import OAI.Combinatorics.EditApproximation.Coarse.CoarseCellBounds

namespace OAI

namespace EditApproximation
namespace BinaryFraction

/-- A zero marker or one full shift array on the execution's common grid. -/
def CoarseBinaryBox (two : BinaryFraction) (n V D A : ℕ) (array : CoarseBinaryArray) : Prop :=
  ∀ cells, array = some cells → cells.length = n ∧ ∀ a ∈ cells, CoarseGridCell two a V D A

 theorem coarseBinaryBox_none (two : BinaryFraction) (n V D A : ℕ) :
    CoarseBinaryBox two n V D A none := by
  intro cells h; cases h

 theorem coarseBinaryBox_mono (two : BinaryFraction) (n V W D A : ℕ)
    (array : CoarseBinaryArray) (h : CoarseBinaryBox two n V D A array) (hle : V ≤ W) :
    CoarseBinaryBox two n W D A array := by
  intro cells hc
  exact ⟨(h cells hc).1, fun a ha => coarseGridCell_mono two a V W D A ((h cells hc).2 a ha) hle⟩

 theorem coarseGridZipAddWithWork_bounds (two : BinaryFraction) (left right : List BinaryFraction)
    (V W D A : ℕ) (hl : ∀ a ∈ left, CoarseGridCell two a V D A)
    (hr : ∀ a ∈ right, CoarseGridCell two a W D A)
    (hbound : Nat.size (V + W) + 2 * D + 1 ≤ A) :
    ∀ a ∈ (coarseGridZipAddWithWork left right).1, CoarseGridCell two a (V + W) D A := by
  induction left generalizing right with
  | nil => simp only [coarseGridZipAddWithWork, List.not_mem_nil, false_implies, implies_true]
  | cons a left ih =>
    cases right with
    | nil => simp only [coarseGridZipAddWithWork, List.not_mem_nil, false_implies, implies_true]
    | cons b right =>
      intro z hz
      change z ∈ (coarseGridAddWithWork a b).1 :: _ at hz
      rcases List.mem_cons.mp hz with rfl | hz
      · exact coarseGridAddWithWork_bounds two a b V W D A (hl a List.mem_cons_self)
          (hr b List.mem_cons_self) hbound
      · exact ih right (fun a ha => hl a (List.mem_cons_of_mem _ ha))
          (fun b hb => hr b (List.mem_cons_of_mem _ hb)) z hz

 theorem coarseGridZipAddWithWork_length (left right : List BinaryFraction) :
    (coarseGridZipAddWithWork left right).1.length = min left.length right.length := by
  induction left generalizing right with
  | nil => simp only [coarseGridZipAddWithWork, List.length_nil, Nat.zero_min]
  | cons a left ih =>
    cases right with
    | nil => simp only [coarseGridZipAddWithWork, List.length_nil, Nat.min_zero]
    | cons b right =>
      change _ + 1 = min _ _
      rw [ih]
      simp only [List.length_cons]
      omega

 theorem coarseBinaryAddWithWork_box (two : BinaryFraction) (n V W D A : ℕ)
    (left right : CoarseBinaryArray) (hl : CoarseBinaryBox two n V D A left)
    (hr : CoarseBinaryBox two n W D A right)
    (hbound : Nat.size (V + W) + 2 * D + 1 ≤ A) :
    CoarseBinaryBox two n (V + W) D A (coarseBinaryAddWithWork left right).1 := by
  cases left with
  | none => exact coarseBinaryBox_mono two n W (V + W) D A right hr (by omega)
  | some left =>
    cases right with
    | none => exact coarseBinaryBox_mono two n V (V + W) D A (some left) hl (by omega)
    | some right =>
      intro cells hc
      have heq : (coarseGridZipAddWithWork left right).1 = cells := Option.some.inj hc
      rw [← heq]
      refine ⟨?_, coarseGridZipAddWithWork_bounds two left right V W D A
        (hl left rfl).2 (hr right rfl).2 hbound⟩
      rw [coarseGridZipAddWithWork_length, (hl left rfl).1, (hr right rfl).1, min_self]

 theorem coarseBinaryAddWithWork_cost (two : BinaryFraction) (n V W D A : ℕ)
    (left right : CoarseBinaryArray) (hl : CoarseBinaryBox two n V D A left)
    (hr : CoarseBinaryBox two n W D A right) :
    (coarseBinaryAddWithWork left right).2 ≤ n * (100 * (A + 1) + 3) := by
  cases left with
  | none => change 0 ≤ _; omega
  | some left =>
    cases right with
    | none => change 0 ≤ _; omega
    | some right =>
      have h := coarseGridZipAddWithWork_cost left right A
        (fun a ha => ((hl left rfl).2 a ha).2.2.2.2)
        (fun b hb => ((hr right rfl).2 b hb).2.2.2.2)
      simpa only [coarseBinaryAddWithWork, (hl left rfl).1, (hr right rfl).1, min_self] using h

 theorem coarseBinaryPenaltyWithWork_box (two : BinaryFraction) (n V D A : ℕ)
    (array : CoarseBinaryArray) (h : CoarseBinaryBox two n V D A array)
    (htwo : two.value = 2) (htw : two.width ≤ A)
    (hbound : Nat.size (V + 2) + 2 * D + 1 ≤ A) :
    CoarseBinaryBox two n V D A (coarseBinaryPenaltyWithWork two array).1 := by
  cases array with
  | none => exact coarseBinaryBox_none two n V D A
  | some source =>
    intro cells hc
    have heq : (coarseGridPenaltyWithWork two source).1 = cells := Option.some.inj hc
    rw [← heq]
    refine ⟨?_, coarseGridPenaltyWithWork_bounds two source V D A htwo htw hbound (h source rfl).2⟩
    have hv := congrArg List.length (coarseGridPenaltyWithWork_value two source htwo
      (fun a ha => ((h source rfl).2 a ha).1))
    simpa only [List.length_map, coarsePenaltyTransform_length, (h source rfl).1] using hv

 theorem coarseBinaryPenaltyWithWork_cost (two : BinaryFraction) (n V D A : ℕ)
    (array : CoarseBinaryArray) (h : CoarseBinaryBox two n V D A array)
    (htwo : two.value = 2) (htw : two.width ≤ A)
    (hbound : Nat.size (V + 2) + 2 * D + 1 ≤ A) :
    (coarseBinaryPenaltyWithWork two array).2 ≤ n * (3500 * (A + 1) ^ 2 + 20) := by
  cases array with
  | none => change 0 ≤ _; omega
  | some source =>
    have hc := coarseGridPenaltyWithWork_cost two source V D A htwo htw hbound (h source rfl).2
    simpa only [coarseBinaryPenaltyWithWork, (h source rfl).1] using hc

 theorem coarseBinaryMapWithWork_box (two : BinaryFraction) (n V W D A : ℕ)
    (f : BinaryFraction → BinaryFraction × ℕ) (array : CoarseBinaryArray)
    (h : CoarseBinaryBox two n V D A array)
    (hf : ∀ a, CoarseGridCell two a V D A → CoarseGridCell two (f a).1 W D A) :
    CoarseBinaryBox two n W D A (coarseBinaryMapWithWork f array).1 := by
  cases array with
  | none => exact coarseBinaryBox_none two n W D A
  | some source =>
    intro cells hc
    have heq : (arithmeticMapWithWork f source).1 = cells := Option.some.inj hc
    rw [← heq, arithmeticMapWithWork_value]
    refine ⟨?_, ?_⟩
    · simpa only [List.length_map] using (h source rfl).1
    · intro a ha
      obtain ⟨b, hb, rfl⟩ := List.mem_map.mp ha
      exact hf b ((h source rfl).2 b hb)

 theorem coarseBinaryMapWithWork_cost (two : BinaryFraction) (n V D A C : ℕ)
    (f : BinaryFraction → BinaryFraction × ℕ) (array : CoarseBinaryArray)
    (h : CoarseBinaryBox two n V D A array)
    (hf : ∀ a, CoarseGridCell two a V D A → (f a).2 ≤ C) :
    (coarseBinaryMapWithWork f array).2 ≤ n * (C + 3) := by
  cases array with
  | none => change 0 ≤ _; omega
  | some source =>
    have hc := arithmeticMapWithWork_cost f source C (fun a ha => hf a ((h source rfl).2 a ha))
    simpa only [coarseBinaryMapWithWork, (h source rfl).1] using hc

end BinaryFraction
end EditApproximation

end OAI