import OAI.Combinatorics.EditApproximation.Binary.BinaryDyadicCeiling
import OAI.Combinatorics.EditApproximation.Binary.BinaryOnlineInputs
import OAI.Combinatorics.EditApproximation.Definitions


namespace OAI

/-! Literal Boolean construction of the child envelope of a finite band.
It scans the actual child values, compares with `b/M`, and runs the exact
bounded dyadic scan. Table reads are accounted for by the query program. -/

namespace EditApproximation
namespace BinaryFraction



theorem maxWithWork_value (a b : BinaryFraction) :
    (maxWithWork a b).1.value = max a.value b.value := by
  by_cases h : a.value < b.value
  · simp only [maxWithWork, (ltWithWork_value a b).mpr h, ↓reduceIte, max_eq_right h.le]
  · have hb : (a.ltWithWork b).1 = false := Bool.eq_false_iff.mpr (fun hh => h ((ltWithWork_value a b).mp hh))
    simp only [maxWithWork, hb, Bool.false_eq_true, ↓reduceIte, max_eq_left (le_of_not_gt h)]

theorem maxWithWork_width (a b : BinaryFraction) :
    (maxWithWork a b).1.width ≤ max a.width b.width := by
  unfold maxWithWork
  dsimp only
  split_ifs
  · exact le_max_right _ _
  · exact le_max_left _ _

theorem maxWithWork_cost (a b : BinaryFraction) (B : ℕ) (ha : a.width ≤ B) (hb : b.width ≤ B) :
    (maxWithWork a b).2 ≤ 1000 * (B + 1) ^ 2 + 1 :=
  Nat.add_le_add_right (ltWithWork_cost a b B ha hb) 1



theorem maximumWithWork_value (fallback : BinaryFraction) (values : List BinaryFraction) :
    (maximumWithWork fallback values).1.value = rationalMaximum fallback.value (values.map value) := by
  induction values with
  | nil => rfl
  | cons head rest ih =>
    simp only [maximumWithWork, maxWithWork_value, ih, List.map_cons, rationalMaximum]

theorem maximumWithWork_width (fallback : BinaryFraction) (values : List BinaryFraction)
    (B : ℕ) (hf : fallback.width ≤ B) (hvalues : ∀ a ∈ values, a.width ≤ B) :
    (maximumWithWork fallback values).1.width ≤ B := by
  induction values with
  | nil => exact hf
  | cons head rest ih =>
    exact (maxWithWork_width head (maximumWithWork fallback rest).1).trans
      (max_le (hvalues head List.mem_cons_self) (ih (fun a ha => hvalues a (List.mem_cons_of_mem _ ha))))

theorem maximumWithWork_cost (fallback : BinaryFraction) (values : List BinaryFraction)
    (B : ℕ) (hf : fallback.width ≤ B) (hvalues : ∀ a ∈ values, a.width ≤ B) :
    (maximumWithWork fallback values).2 ≤ 1 + values.length * (1000 * (B + 1) ^ 2 + 2) := by
  induction values with
  | nil => simp [maximumWithWork]
  | cons head rest ih =>
    have htail := ih (fun a ha => hvalues a (List.mem_cons_of_mem _ ha))
    have hw := maximumWithWork_width fallback rest B hf (fun a ha => hvalues a (List.mem_cons_of_mem _ ha))
    have hc := maxWithWork_cost head (maximumWithWork fallback rest).1 B
      (hvalues head List.mem_cons_self) hw
    change (maximumWithWork fallback rest).2 + (maxWithWork head (maximumWithWork fallback rest).1).2 + 1 ≤ _
    simp only [List.length_cons]
    rw [Nat.add_mul, Nat.one_mul]
    omega

def bandEnvelopeWithWork {M ny : ℕ} (b : ℕ)
    (band : List (Fin M → TargetInterval ny))
    (initial : Fin M → TargetInterval ny → BinaryFraction) (i : Fin M) : BinaryFraction × ℕ :=
  let floor := divWithWork (nat b) (nat M)
  let maximum := maximumWithWork zero (band.map fun action => initial i (action i))
  let input := maxWithWork floor.1 maximum.1
  let result := dyadicCeilingWithWork input.1
  (result.1, floor.2 + maximum.2 + input.2 + result.2 + band.length + 4)

theorem bandEnvelopeWithWork_value {M ny : ℕ} (b : ℕ)
    (band : List (Fin M → TargetInterval ny))
    (initial : Fin M → TargetInterval ny → BinaryFraction) (i : Fin M)
    (hb : 0 < b) :
    (bandEnvelopeWithWork b band initial i).1.value =
      bandChildEnvelope b band (fun j q => (initial j q).value) i := by
  have hM : 0 < M := Nat.pos_of_ne_zero (fun h => by cases h; exact Fin.elim0 i)
  have hfloor : (divWithWork (nat b) (nat M)).1.value = (b : ℚ) / M := by
    rw [divWithWork_value, ← representation_value (nat b), nat_representation,
      UnreducedRational.value_nat, ← representation_value (nat M), nat_representation,
      UnreducedRational.value_nat]
  have hp : 0 < (maxWithWork (divWithWork (nat b) (nat M)).1
      (maximumWithWork zero (band.map fun action => initial i (action i))).1).1.value := by
    rw [maxWithWork_value, hfloor]
    exact lt_of_lt_of_le (div_pos (by exact_mod_cast hb) (by exact_mod_cast hM)) (le_max_left _ _)
  change (dyadicCeilingWithWork _).1.value = _
  rw [dyadicCeilingWithWork_value _ hp, maxWithWork_value, hfloor, maximumWithWork_value]
  simp only [zero_representation, ← representation_value zero, UnreducedRational.value_zero,
    List.map_map, Function.comp_def, bandChildEnvelope]

def bandEnvelopeWordBudget (b M B : ℕ) : ℕ := B + Nat.size b + Nat.size M + 8

theorem bandEnvelopeWithWork_width {M ny : ℕ} (b : ℕ)
    (band : List (Fin M → TargetInterval ny))
    (initial : Fin M → TargetInterval ny → BinaryFraction) (i : Fin M)
    (B : ℕ) (hbits : ∀ action ∈ band, (initial i (action i)).width ≤ B) :
    (bandEnvelopeWithWork b band initial i).1.width ≤ 3 * bandEnvelopeWordBudget b M B + 1 := by
  let W := bandEnvelopeWordBudget b M B
  have hfloor := divWithWork_self_width (nat b) (nat M)
  rw [divWithWork_representation, nat_representation, nat_representation] at hfloor
  have hf := UnreducedRational.storageBits_div (UnreducedRational.nat b) (UnreducedRational.nat M)
  simp only [UnreducedRational.storageBits_nat] at hf
  have hfW : (divWithWork (nat b) (nat M)).1.width ≤ W := by
    dsimp only [W, bandEnvelopeWordBudget]
    omega
  have hmW := maximumWithWork_width zero (band.map fun action => initial i (action i)) W
    (by change 1 ≤ W; dsimp only [W, bandEnvelopeWordBudget]; omega)
    (by intro a ha; obtain ⟨action, haction, rfl⟩ := List.mem_map.mp ha
        exact (hbits action haction).trans (by dsimp only [W, bandEnvelopeWordBudget]; omega))
  have hin := (maxWithWork_width (divWithWork (nat b) (nat M)).1
    (maximumWithWork zero (band.map fun action => initial i (action i))).1).trans (max_le hfW hmW)
  have h := dyadicCeilingWithWork_width (maxWithWork (divWithWork (nat b) (nat M)).1
    (maximumWithWork zero (band.map fun action => initial i (action i))).1).1
  change (dyadicCeilingWithWork _).1.width ≤ _
  omega


def bandEnvelopeBitBudget (b M size B : ℕ) : ℕ :=
  let W := bandEnvelopeWordBudget b M B
  2100 * (Nat.size b + Nat.size M + 6) ^ 2 +
    (1 + size * (1000 * (W + 1) ^ 2 + 2)) + (1000 * (W + 1) ^ 2 + 1) +
    (1 + 2 * W * (1000 * (3 * W + 2) ^ 2 + 2) + 3 * W + 5) + size + 4

theorem bandEnvelopeWithWork_cost {M ny : ℕ} (b : ℕ)
    (band : List (Fin M → TargetInterval ny))
    (initial : Fin M → TargetInterval ny → BinaryFraction) (i : Fin M)
    (B : ℕ) (hbits : ∀ action ∈ band, (initial i (action i)).width ≤ B) :
    (bandEnvelopeWithWork b band initial i).2 ≤ bandEnvelopeBitBudget b M band.length B := by
  let W := bandEnvelopeWordBudget b M B
  let floor := (divWithWork (nat b) (nat M)).1
  let maximum := (maximumWithWork zero (band.map fun action => initial i (action i))).1
  let input := (maxWithWork floor maximum).1
  have hfloor := divWithWork_self_width (nat b) (nat M)
  rw [divWithWork_representation, nat_representation, nat_representation] at hfloor
  have hf := UnreducedRational.storageBits_div (UnreducedRational.nat b) (UnreducedRational.nat M)
  simp only [UnreducedRational.storageBits_nat] at hf
  have hfW : floor.width ≤ W := by
    dsimp only [W, bandEnvelopeWordBudget]
    change floor.width ≤ _ at hfloor
    omega
  have hmW : maximum.width ≤ W := maximumWithWork_width zero
    (band.map fun action => initial i (action i)) W
    (by change 1 ≤ W; dsimp only [W, bandEnvelopeWordBudget]; omega)
    (by intro a ha; obtain ⟨action, haction, rfl⟩ := List.mem_map.mp ha
        exact (hbits action haction).trans (by dsimp only [W, bandEnvelopeWordBudget]; omega))
  have hiW : input.width ≤ W := (maxWithWork_width floor maximum).trans (max_le hfW hmW)
  have hfc := divWithWork_cost (nat b) (nat M) (Nat.size b + Nat.size M + 4)
    ((nat_width_le b).trans (by omega)) ((nat_width_le M).trans (by omega))
  rw [show Nat.size b + Nat.size M + 4 + 2 = Nat.size b + Nat.size M + 6 by omega] at hfc
  have hmc := maximumWithWork_cost zero (band.map fun action => initial i (action i)) W
    (by change 1 ≤ W; dsimp only [W, bandEnvelopeWordBudget]; omega)
    (by intro a ha; obtain ⟨action, haction, rfl⟩ := List.mem_map.mp ha
        exact (hbits action haction).trans (by dsimp only [W, bandEnvelopeWordBudget]; omega))
  simp only [List.length_map] at hmc
  have hic := maxWithWork_cost floor maximum W hfW hmW
  have hdc := dyadicCeilingWithWork_cost_le input W hiW
  change (divWithWork (nat b) (nat M)).2 +
    (maximumWithWork zero (band.map fun action => initial i (action i))).2 +
    (maxWithWork floor maximum).2 + (dyadicCeilingWithWork input).2 + band.length + 4 ≤ _
  change _ ≤ 2100 * (Nat.size b + Nat.size M + 6) ^ 2 +
    (1 + band.length * (1000 * (W + 1) ^ 2 + 2)) + (1000 * (W + 1) ^ 2 + 1) +
    (1 + 2 * W * (1000 * (3 * W + 2) ^ 2 + 2) + 3 * W + 5) + band.length + 4
  omega

end BinaryFraction
end EditApproximation

end OAI