import OAI.Computability.MeanPayoff.Online

namespace OAI

section

namespace MeanPayoff

@[simp] theorem SolveBox.online_repeated {n Bmax : ℕ} (I : SolveBox n Bmax)
    (t : Counted (BoxVector I)) (J : ℕ) :
    (I.repeatedCounted t J).online = I.repeatedOnline t.online J := by
  simp [SolveBox.repeatedCounted, SolveBox.repeatedOnline]

namespace CountedAlgorithm

def onlineLower {n Bmax : ℕ} {P : Budgets n} (lower : LowerSolver (Bmax := Bmax) P) :
    OnlineAlgorithm.LowerSolver (Bmax := Bmax) P := fun Q h I => (lower Q h I).online

@[simp] theorem online_centerUpdate {n Bmax : ℕ} (P : Budgets n) (hR : 1 ≤ P.parameter)
    (lower : LowerSolver (Bmax := Bmax) P) (I : SolveBox n Bmax)
    (hB : 128 * globalS Bmax < I.width) (q : BoxVector I) :
    (centerUpdate P hR lower I hB q).online =
    OnlineAlgorithm.centerUpdate P hR (onlineLower lower) I hB q := by
  simp [centerUpdate, OnlineAlgorithm.centerUpdate, onlineLower]

@[simp] theorem online_centerSteps {n Bmax : ℕ} (P : Budgets n) (hR : 1 ≤ P.parameter)
    (lower : LowerSolver (Bmax := Bmax) P) (I : SolveBox n Bmax)
    (hB : 128 * globalS Bmax < I.width) (t : ℕ) (q : BoxVector I) :
    (centerSteps P hR lower I hB t q).online =
    OnlineAlgorithm.centerSteps P hR (onlineLower lower) I hB t q := by
  induction t generalizing q with
  | zero => rfl
  | succ t ih => simp only [centerSteps, OnlineAlgorithm.centerSteps, Counted.online_bind,
      online_centerUpdate, Counted.online_map, ih]

@[simp] theorem online_orientationTail (G : Game) {Bmax : ℕ} (P : Budgets G.n)
    (I : SolveBox G.n Bmax) (qs : List (BoxVector I))
    (child : BoxVector I → Counted (Orientation P)) :
    (orientationTail G P I qs child).online =
    OnlineAlgorithm.orientationTail G P I qs (fun q => (child q).online) := by
  unfold orientationTail OnlineAlgorithm.orientationTail
  dsimp only
  split_ifs <;> simp

@[simp] theorem online_orient (G : Game) {Bmax : ℕ} (P : Budgets G.n) (hR : 1 ≤ P.parameter)
    (lower : LowerSolver (Bmax := Bmax) P) (I : SolveBox G.n Bmax) :
    (orient G P hR lower I).online = OnlineAlgorithm.orient G P hR (onlineLower lower) I := by
  rw [orient, OnlineAlgorithm.orient]
  split_ifs with h
  · rfl
  · simp only [Counted.online_bind, online_centerSteps, online_orientationTail]
    apply congrArg (Online.bind _)
    funext qs
    apply congrArg (OnlineAlgorithm.orientationTail G P I qs)
    funext q
    exact online_orient G P hR lower (I.wideCentered (lt_of_not_ge h) q.val)
termination_by I.width
 decreasing_by exact I.E_smaller

@[simp] theorem online_orientPlus {n : ℕ} {P : Budgets n}
    (t : Counted (Orientation P)) (J : ℕ) :
    (orientPlus t J).online = OnlineAlgorithm.orientPlus t.online J := by
  simp [orientPlus, OnlineAlgorithm.orientPlus]

@[simp] theorem online_tighten {n Bmax : ℕ} (P : Budgets n) (hR : 1 ≤ P.parameter)
    (lower : LowerSolver (Bmax := Bmax) P) (I : SolveBox n Bmax)
    (hB : 128 * globalS Bmax < I.width) :
    (tighten P hR lower I hB).online = OnlineAlgorithm.tighten P hR (onlineLower lower) I hB := by
  rw [tighten, OnlineAlgorithm.tighten]
  simp only [Counted.online_bind, SolveBox.online_repeated]
  congr 1
  funext r₁
  split_ifs with h₁
  · simp only [Counted.online_map, online_tighten P hR lower (I.withFloor r₁) hB]
  · simp only [Counted.online_bind, SolveBox.online_repeated]
    congr 1
    funext r₂
    split_ifs with h₂
    · simp only [Counted.online_map, online_tighten P hR lower (I.withCeiling r₂) hB]
    · rfl
termination_by volume I.b I.a
 decreasing_by
  · apply volume_decreases r₁.property.1 r₁.property.2
    obtain ⟨i, hi⟩ := h₁
    have hd := I.delta_positive hB
    intro heq
    have he := congrFun heq i
    omega
  · apply volume_ceiling_decreases r₂.property.1 r₂.property.2
    obtain ⟨i, hi⟩ := h₂
    have hd := I.delta_positive hB
    intro heq
    have he := congrFun heq i
    omega

@[simp] theorem online_finishChoice (G : Game) {Bmax : ℕ} (P : Budgets G.n)
    (hR : 1 ≤ P.parameter) (lower : LowerSolver (Bmax := Bmax) P) (I : SolveBox G.n Bmax)
    (hB : 128 * globalS Bmax < I.width) (O : Orientation P)
    (up : Counted (BoxVector (I.capHigh I.C I.C_positive (I.C_smaller hB).le)))
    (lo : Counted (BoxVector (I.capLow I.C I.C_positive (I.C_smaller hB).le))) :
    (finishChoice G P hR lower I hB O up lo).online =
    OnlineAlgorithm.finishChoice G P hR (onlineLower lower) I hB O up.online lo.online := by
  unfold finishChoice OnlineAlgorithm.finishChoice
  split_ifs <;> simp [onlineLower]

@[simp] theorem online_solveWidth (G : Game) {Bmax : ℕ} (P : Budgets G.n)
    (hR : 1 ≤ P.parameter) (lower : LowerSolver (Bmax := Bmax) P) (I : SolveBox G.n Bmax) :
    (solveWidth G P hR lower I).online = OnlineAlgorithm.solveWidth G P hR (onlineLower lower) I := by
  rw [solveWidth, OnlineAlgorithm.solveWidth, Counted.online_charge]
  apply congrArg (Online.charge 1)
  split_ifs with hB
  · rfl
  · simp only [Counted.online_bind, online_tighten]
    congr 1
    funext T
    simp only [online_orientPlus, online_orient]
    congr 1
    funext O
    simp only [Counted.online_map, online_finishChoice]
    congr 2
    · exact online_solveWidth G P hR lower _
    · exact online_solveWidth G P hR lower _
termination_by I.width
 decreasing_by
  all_goals
    change T.box.C < I.width
    rw [← T.width_eq]
    exact T.box.C_smaller (by rw [T.width_eq]; omega)

@[simp] theorem online_solve (G : Game) {Bmax : ℕ} (P : Budgets G.n) (I : SolveBox G.n Bmax) :
    (solve G P I).online = OnlineAlgorithm.solve G P I := by
  rw [solve, OnlineAlgorithm.solve]
  split_ifs with hR
  · rfl
  · rw [online_solveWidth]
    congr 1
    funext Q h K
    exact online_solve G Q K
termination_by parameterRank P.parameter

end CountedAlgorithm


@[simp] theorem RandomTree.read_map {α β : Type} (t : RandomTree α) (f : α → β)
    (bits : ℕ → Bool) : (t.map f).read bits = f (t.read bits) := by
  induction t generalizing bits with
  | leaf a => rfl
  | coin l r il ir => simp only [RandomTree.map, RandomTree.bind, RandomTree.read]; split <;> simp_all [RandomTree.map]

theorem Counted.online_value {α : Type} (t : Counted α) (bits : ℕ → Bool) (pos : ℕ) :
    (t.online bits pos).1.1 = t.erase.read (fun j => bits (pos + j)) := by
  rw [Counted.erase, RandomTree.read_map, ← RandomTree.consume_read]
  rfl

theorem Counted.online_count {α : Type} (t : Counted α) {N : ℕ} (h : t.Bounded N)
    (bits : ℕ → Bool) (pos : ℕ) : (t.online bits pos).1.2 ≤ N := by
  exact (RandomTree.consume_path t.tree bits pos).2.all h

theorem Counted.online_coins {α : Type} (t : Counted α) {K E : ℕ} (h : t.Resource K E)
    (bits : ℕ → Bool) (pos : ℕ) :
    pos ≤ (t.online bits pos).2 ∧
    (t.online bits pos).2 ≤ pos + K * (t.online bits pos).1.2 + E := by
  obtain ⟨hp, hh⟩ := RandomTree.consume_path t.tree bits pos
  have hb := h _ _ hh
  exact ⟨hp, by unfold Counted.online; omega⟩

def onlineGame (G : Game) : Online (Fin G.n → Bool) :=
  (OnlineAlgorithm.solve G (rootBudgets G) (rootBox G)).map
    (fun p v => decide (topWidth G / 2 < p.val v))

theorem onlineGame_counted (G : Game) : onlineGame G =
    ((CountedAlgorithm.solve G (rootBudgets G) (rootBox G)).map
      (fun p v => decide (topWidth G / 2 < p.val v))).online := by
  simp only [onlineGame, Counted.online_map, CountedAlgorithm.online_solve]

theorem onlineGame_value (G : Game) (bits : ℕ → Bool) (pos : ℕ) :
    (onlineGame G bits pos).1.1 = (gameSolve G).read (fun j => bits (pos + j)) := by
  rw [onlineGame_counted, Counted.online_value]
  simp only [Counted.erase_map, CountedAlgorithm.erase_solve, gameSolve]

theorem onlineGame_count (G : Game) (bits : ℕ → Bool) (pos : ℕ) :
    (onlineGame G bits pos).1.2 ≤ rootInvocationBound G := by
  rw [onlineGame_counted]
  exact Counted.online_count _
    (Counted.bounded_map _ (CountedAlgorithm.bounded_solve G (rootBudgets G) (rootBox G))) bits pos

theorem onlineGame_coins (G : Game) (bits : ℕ → Bool) (pos : ℕ) :
    pos ≤ (onlineGame G bits pos).2 ∧
    (onlineGame G bits pos).2 ≤ pos + rootRandomBound G := by
  have h := Counted.online_coins
    ((CountedAlgorithm.solve G (rootBudgets G) (rootBox G)).map
      (fun p v => decide (topWidth G / 2 < p.val v)))
    (Counted.resource_map _ (CountedAlgorithm.resource_solve G (rootBudgets G) (rootBox G))) bits pos
  rw [← onlineGame_counted G] at h
  have hc := Nat.mul_le_mul_left (nodeRandomBound G.n (topWidth G).toNat) (onlineGame_count G bits pos)
  exact ⟨h.1, by unfold rootRandomBound; omega⟩

namespace BinaryInput

def onlineProgram (code : List Bool) : Online (List Bool) :=
  match decodeGame code with
  | none => Online.pure []
  | some G => (onlineGame G).map List.ofFn

@[simp] theorem onlineProgram_input (G : Game) :
    onlineProgram (input G) = (onlineGame G).map List.ofFn := by
  simp only [onlineProgram, decodeGame_input]

theorem onlineProgram_value (G : Game) (bits : ℕ → Bool) (pos : ℕ) :
    (onlineProgram (input G) bits pos).1.1 =
      List.ofFn ((gameSolve G).read (fun j => bits (pos + j))) := by
  simp only [onlineProgram_input, Online.map, onlineGame_value]

def CorrectList (G : Game) (out : List Bool) : Prop :=
  out.length = G.n ∧ ∀ v : Fin G.n, out[v.val]? = some true ↔ Winning G v

@[simp] theorem correctList_ofFn (G : Game) (out : Fin G.n → Bool) :
    CorrectList G (List.ofFn out) ↔ CorrectSet G out := by
  simp only [CorrectList, List.length_ofFn, List.getElem?_ofFn, Fin.isLt, ↓reduceDIte,
    Option.some.injEq, true_and, CorrectSet]

theorem onlineProgram_coins (G : Game) (bits : ℕ → Bool) :
    (onlineProgram (input G) bits 0).2 ≤ rootRandomBound G := by
  simpa only [onlineProgram_input, Online.map, Nat.zero_add] using (onlineGame_coins G bits 0).2

open scoped Classical

theorem onlineProgram_success (G : Game) :
    (∀ bits : ℕ → Bool, (onlineProgram (input G) bits 0).2 ≤ rootRandomBound G) ∧
    7 * 2 ^ rootRandomBound G ≤ 8 * (Finset.univ.filter
      (fun bits : Fin (rootRandomBound G) → Bool =>
        CorrectList G (onlineProgram (input G) (padBits bits) 0).1.1)).card := by
  refine ⟨onlineProgram_coins G, ?_⟩
  have h := RandomTree.game_prefix_success G (rootRandomBound G) (game_bitDepth G)
  simp only [onlineProgram_value, Nat.zero_add, correctList_ofFn, RandomTree.readPrefix] at ⊢ h
  convert h using 1
  congr 1

end BinaryInput
end MeanPayoff

namespace MeanPayoff
namespace TwoPhase

def even {t : ℕ} (bits : Fin (2 * t) → Bool) (j : Fin t) : Bool :=
  bits ⟨2 * j.val, by omega⟩

def odd {t : ℕ} (bits : Fin (2 * t) → Bool) (j : Fin t) : Bool :=
  bits ⟨2 * j.val + 1, by omega⟩

def interleave {t : ℕ} (bits : (Fin t → Bool) × (Fin t → Bool))
    (j : Fin (2 * t)) : Bool :=
  if j.val % 2 = 0 then bits.1 ⟨j.val / 2, by omega⟩
  else bits.2 ⟨j.val / 2, by omega⟩

@[simp] theorem even_interleave {t : ℕ} (bits : (Fin t → Bool) × (Fin t → Bool)) :
    even (interleave bits) = bits.1 := by
  funext j
  simp [even, interleave]

@[simp] theorem odd_interleave {t : ℕ} (bits : (Fin t → Bool) × (Fin t → Bool)) :
    odd (interleave bits) = bits.2 := by
  funext j
  simp [odd, interleave, Nat.add_div]

def equiv (t : ℕ) : ((Fin t → Bool) × (Fin t → Bool)) ≃ (Fin (2 * t) → Bool) where
  toFun := interleave
  invFun := fun bits => (even bits, odd bits)
  left_inv bits := by simp only [even_interleave, odd_interleave]
  right_inv bits := by
    funext j
    simp only [interleave, even, odd]
    split <;> rename_i hj
    · congr 1
      apply Fin.ext
      dsimp only
      have hm := Nat.mod_add_div j.val 2
      omega
    · congr 1
      apply Fin.ext
      dsimp only
      have hm := Nat.mod_add_div j.val 2
      have hb := Nat.mod_lt j.val (by omega : 0 < 2)
      omega

theorem pad_even {t : ℕ} (bits : Fin (2 * t) → Bool) :
    (fun j => padBits bits (2 * j)) = padBits (even bits) := by
  funext j
  by_cases hj : j < t
  · simp only [padBits, show 2 * j < 2 * t by omega, hj, ↓reduceDIte, even]
  · simp only [padBits, show ¬2 * j < 2 * t by omega, hj, ↓reduceDIte]

open scoped Classical

theorem successful_count (t : ℕ) (Q : (Fin t → Bool) → Prop) :
    (Finset.univ.filter (fun bits : Fin (2 * t) → Bool => Q (even bits))).card =
      2 ^ t * (Finset.univ.filter Q).card := by
  have h := Equiv.sum_comp (equiv t) (fun bits => if Q (even bits) then (1 : ℕ) else 0)
  rw [Fintype.sum_prod_type] at h
  simp only [equiv, Equiv.coe_fn_mk, even_interleave] at h
  calc
    _ = ∑ x : Fin t → Bool, if Q x then 2 ^ t else 0 := by
      simpa [Finset.sum_boole, Fintype.card_fun] using h.symm
    _ = _ := by simp [Finset.sum_ite, Nat.mul_comm]

theorem success_transfer (t : ℕ) (Q : (Fin t → Bool) → Prop)
    (h : 7 * 2 ^ t ≤ 8 * (Finset.univ.filter Q).card) :
    7 * 2 ^ (2 * t) ≤ 8 * (Finset.univ.filter
      (fun bits : Fin (2 * t) → Bool => Q (even bits))).card := by
  rw [successful_count]
  have hh := Nat.mul_le_mul_left (2 ^ t) h
  rw [show 2 * t = t + t by omega, pow_add]
  nlinarith only [hh]

end TwoPhase
end MeanPayoff
end

end OAI