import OAI.Computability.MeanPayoff.StackSimulation

namespace OAI

section
namespace MeanPayoff
namespace RandomTree

def maximum {α : Type} : RandomTree α → (α → ℕ) → ℕ
  | .leaf a, f => f a
  | .coin l r, f => max (maximum l f) (maximum r f)

theorem maximum_le_iff {α : Type} (t : RandomTree α) (f : α → ℕ) (N : ℕ) :
    t.maximum f ≤ N ↔ t.All (fun a => f a ≤ N) := by
  induction t with
  | leaf a => rfl
  | coin l r hl hr => simp only [maximum, max_le_iff, All, hl, hr]

theorem all_le_maximum {α : Type} (t : RandomTree α) (f : α → ℕ) :
    t.All (fun a => f a ≤ t.maximum f) := (maximum_le_iff t f _).mp le_rfl

theorem maximum_add {α : Type} (t : RandomTree α) (f : α → ℕ) (c : ℕ) :
    t.maximum (fun a => c+f a) = c+t.maximum f := by
  induction t with
  | leaf a => rfl
  | coin l r hl hr => simp only [maximum, hl, hr, ← Nat.add_max_add_left]

theorem not_all_false {α : Type} (t : RandomTree α) : ¬t.All (fun _ => False) := by
  induction t with
  | leaf a => exact id
  | coin l r hl hr => exact fun h => hl h.1

end RandomTree
namespace Counted

def maximum {α : Type} (t : Counted α) : ℕ := t.tree.maximum Prod.snd

theorem maximum_le_iff {α : Type} (t : Counted α) (N : ℕ) :
    t.maximum ≤ N ↔ t.Bounded N := RandomTree.maximum_le_iff _ _ _

theorem maximum_bind {α β : Type} (t : Counted α) (f : α → Counted β) :
    t.tree.All (fun p => p.2+(f p.1).maximum ≤ (t.bind f).maximum) := by
  have h := RandomTree.all_le_maximum (t.bind f).tree Prod.snd
  simp only [bind, RandomTree.all_bind, RandomTree.all_map] at h
  apply RandomTree.all_mono _ h
  intro p hp
  have hm := (RandomTree.maximum_le_iff (f p.1).tree (fun q => p.2+q.2) _).mpr hp
  simpa only [RandomTree.maximum_add, maximum, bind] using hm

end Counted
namespace SourceControl

def State.rank {G : Game} {B : ℕ} {R : Result G B} (s : State G B R) : ℕ :=
  s.credit+controlAllowance G.n B*s.denote.maximum

theorem step_rank {G : Game} {B : ℕ} {R : Result G B} (s : State G B R)
    (h : ¬s.halted) : (step s).tree.All (fun p => p.1.rank < s.rank) := by
  have hc := step_credit s h
  have hm := Counted.maximum_bind (step s) State.denote
  rw [step_denote] at hm
  apply RandomTree.all_mono _ (RandomTree.all_and _ hc hm)
  intro p hp
  have hmul := Nat.mul_le_mul_left (controlAllowance G.n B) hp.2
  rw [Nat.mul_add] at hmul
  simp only [State.rank]
  omega

def run {G : Game} {B : ℕ} {R : Result G B} : ℕ → State G B R → Counted (State G B R)
  | 0, s => Counted.pure s
  | n+1, s => (step s).bind (run n)

theorem run_halted {G : Game} {B : ℕ} {R : Result G B} (n : ℕ) (s : State G B R)
    (h : s.halted) : run n s = Counted.pure s := by
  cases s with
  | call j k => exact h.elim
  | ret k v =>
    cases k with
    | push f k => exact h.elim
    | done =>
      induction n with
      | zero => rfl
      | succ n ih => simpa only [run, step, Counted.pure_bind] using ih

theorem run_halts {G : Game} {B : ℕ} {R : Result G B} (n : ℕ) (s : State G B R)
    (hn : s.rank ≤ n) : (run n s).tree.All (fun p => p.1.halted) := by
  induction n generalizing s with
  | zero =>
    change s.halted
    by_contra h
    have hd := step_rank s h
    exact RandomTree.not_all_false (step s).tree
      (RandomTree.all_mono _ hd (fun p hp => by omega))
  | succ n ih =>
    by_cases h : s.halted
    · rw [run_halted _ _ h]
      exact h
    · simp only [run, Counted.bind, RandomTree.all_bind, RandomTree.all_map]
      apply RandomTree.all_mono _ (step_rank s h)
      intro p hp
      exact ih p.1 (by omega)

theorem run_denote {G : Game} {B : ℕ} {R : Result G B} (n : ℕ) (s : State G B R) :
    (run n s).bind State.denote = s.denote := by
  induction n generalizing s with
  | zero => exact Counted.pure_bind _ _
  | succ n ih => simp only [run, Counted.bind_assoc, ih, step_denote]

theorem run_solve_halts (G : Game) {B : ℕ} (P : Budgets G.n) (I : SolveBox G.n B) :
    (run (controlAllowance G.n B*callBound G.n B (parameterRank P.parameter))
      (.call (.solve P I) .done)).tree.All (fun p => p.1.halted) := by
  apply run_halts
  simp only [State.rank, State.credit, Job.credit, Kont.credit, Nat.zero_add,
    State.denote, Job.denote, Kont.denote, Counted.bind_pure]
  exact Nat.mul_le_mul_left _ ((Counted.maximum_le_iff _ _).mpr
    (CountedAlgorithm.bounded_solve G P I))

end SourceControl
end MeanPayoff
namespace MeanPayoff.SourceControl

theorem affine_power {a X d k c : ℕ} (hX : 1 ≤ X) (ha : a ≤ X^d)
    (hk : k+c ≤ X) : k*a+c ≤ X^(d+1) := by
  have hp : 1 ≤ X^d := Nat.one_le_pow _ _ hX
  have hm := Nat.mul_le_mul_left k ha
  have hh := Nat.mul_le_mul_right (X^d) hk
  rw [pow_succ]
  nlinarith only [hp, hm, hh]

theorem controlAllowance_scale {n B X : ℕ} (hX : 32 ≤ X) (hn : n+1 ≤ X)
    (hg : globalG B+1 ≤ X) (hs : globalS B ≤ X) :
    controlAllowance n B ≤ X^39 := by
  have hx : 1 ≤ X := by omega
  have hj := globalJ_scale hX hn hs
  have ha : askCredit n B ≤ X^15 := by
    simpa only [askCredit, trialCredit, Nat.add_assoc] using
      (affine_power hx hj (by omega : 3+3 ≤ X))
  have he : exceptionCredit n B ≤ X^16 := by
    simpa only [one_mul, exceptionCredit] using (affine_power hx ha (by omega : 1+3 ≤ X))
  have hu : updateCredit n B ≤ X^16 := by
    exact affine_power hx ha (by omega : 2+3 ≤ X)
  have hu3 : updateCredit n B+3 ≤ X^17 := by
    simpa only [one_mul] using (affine_power hx hu (by omega : 1+3 ≤ X))
  have hcent0 := Nat.mul_le_mul hs hu3
  have hcent0' : globalS B*(updateCredit n B+3) ≤ X^18 := by
    simpa only [← pow_succ'] using hcent0
  have hcent : centersCredit n B (globalS B) ≤ X^19 := by
    simpa only [centersCredit, one_mul] using (affine_power hx hcent0' (by omega : 1+1 ≤ X))
  have he19 : exceptionCredit n B ≤ X^19 := he.trans (Nat.pow_le_pow_right hx (by norm_num))
  have hunit0 : orientUnit n B ≤ 3*X^19+3 := by unfold orientUnit; omega
  have hunit : orientUnit n B ≤ X^20 := hunit0.trans (affine_power hx le_rfl (by omega : 3+3 ≤ X))
  have hoc : orientCredit n B (B+1) ≤ X^21 := by
    have h := Nat.mul_le_mul (by unfold globalG at hg; omega : Nat.clog 2 (B+1)+1 ≤ X) hunit
    simpa only [orientCredit, ← pow_succ'] using h
  have hoc3 : orientCredit n B (B+1)+3 ≤ X^22 := by
    simpa only [one_mul] using (affine_power hx hoc (by omega : 1+3 ≤ X))
  have hp0 : globalJ n B*(orientCredit n B (B+1)+3) ≤ X^36 := by
    simpa only [← pow_add] using Nat.mul_le_mul hj hoc3
  have hp : orientPlusCredit n B (B+1) ≤ X^37 := by
    simpa only [orientPlusCredit, orientTrialsCredit, Nat.add_assoc, one_mul] using
      (affine_power hx hp0 (by omega : 1+3 ≤ X))
  have htu : tightenUnit n B ≤ X^16 := affine_power hx ha (by omega : 2+5 ≤ X)
  have hns := Nat.mul_le_mul (by omega : n ≤ X) hs
  have hfact : 8*n*globalS B+1 ≤ X^3 := by
    have hsq : 8*n*globalS B+1 ≤ 8*X^2+1 := by nlinarith only [hns]
    exact hsq.trans (affine_power hx le_rfl (by omega : 8+1 ≤ X))
  have ht : (8*n*globalS B+1)*tightenUnit n B ≤ X^19 := by
    simpa only [← pow_add] using Nat.mul_le_mul hfact htu
  have ht37 := ht.trans (Nat.pow_le_pow_right hx (by norm_num : 19 ≤ 37))
  have hall : controlAllowance n B ≤ 2*X^37+7 := by unfold controlAllowance; omega
  exact (hall.trans (affine_power hx le_rfl (by omega : 2+7 ≤ X))).trans
    (Nat.pow_le_pow_right hx (by norm_num : 38 ≤ 39))

noncomputable def rootControlBound (G : Game) : ℕ :=
  controlAllowance G.n (topWidth G).toNat * rootInvocationBound G

theorem rootControlBound_nat (G : Game) :
    rootControlBound G ≤ 2^(25000*(Nat.clog 2 ((input G).length+2))^2) := by
  let h := Nat.clog 2 ((input G).length+2)
  have hh : 1 ≤ h := by
    apply (Nat.lt_clog_iff_pow_lt (by norm_num : 1 < 2)).mpr
    simp only [pow_zero]
    omega
  have hk := controlAllowance_scale (inputScale_large G) (inputScale_n G)
    (inputScale_g G) (inputScale_s G)
  have hx : inputScale G ≤ 2^(24+h) := by
    have hp := Nat.le_pow_clog (by norm_num : 1 < 2) ((input G).length+2)
    have hm := Nat.mul_le_mul_left (2^24) hp
    simpa only [inputScale, pow_add] using hm
  have hk' : controlAllowance G.n (topWidth G).toNat ≤ 2^((24+h)*39) :=
    hk.trans (by simpa only [← pow_mul] using Nat.pow_le_pow_left hx 39)
  have hi := rootInvocationBound_nat G
  have ht := Nat.mul_le_mul hk' hi
  rw [← pow_add] at ht
  apply ht.trans
  apply Nat.pow_le_pow_right (by norm_num)
  change (24+h)*39+24000*h^2 ≤ 25000*h^2
  nlinarith only [hh]

theorem root_operational_halts (G : Game) :
    (run (rootControlBound G) (.call (.solve (rootBudgets G) (rootBox G)) .done)).tree.All
      (fun p => p.1.halted) := run_solve_halts G _ _

end MeanPayoff.SourceControl
namespace MeanPayoff
namespace WorkStack.RegisterCompile

inductive Label (s : ℕ) where
  | get0 (q : Fin s)
  | get1 (q : Fin s) (a : Option Bool) (coin : Bool)
  | get2 (q : Fin s) (a b : Option Bool) (coin : Bool)
  | put (q : Fin s) (top : Fin 3 → Option Bool) (coin : Bool) (k : Fin 3)
  deriving DecidableEq, Fintype

noncomputable def equiv (P : Program) : Label P.states ≃ Fin (Fintype.card (Label P.states)) :=
  Fintype.equivFin _
noncomputable def enc (P : Program) (q : Label P.states) := equiv P q
@[simp] theorem decode (P : Program) (q : Label P.states) : (equiv P).symm (enc P q) = q :=
  (equiv P).symm_apply_apply q

noncomputable def program (P : Program) : RegisterBits.Program 3 where
  states := Fintype.card (Label P.states)
  start := enc P (.get0 P.start)
  read q := match (equiv P).symm q with
    | .get0 _ => 0
    | .get1 _ _ _ => 1
    | .get2 _ _ _ _ => 2
    | .put _ _ _ k => k
  transition q top coin := match (equiv P).symm q with
    | .get0 q => some ⟨enc P (.get1 q top coin), .keep, none⟩
    | .get1 q a c => some ⟨enc P (.get2 q a top c), .keep, none⟩
    | .get2 q a b c => some ⟨enc P (.put q ![a,b,top] c 0), .keep, none⟩
    | .put q ts c k => match P.transition q ts c with
      | none => none
      | some a => some ⟨enc P (if h : k.val = 2 then .get0 a.next else
          .put q ts c ⟨k.val+1, by have := k.isLt; omega⟩), a.work k, none⟩

noncomputable def lift (P : Program) (out : List Bool) (c : Config P) :
    RegisterBits.Config (program P) :=
  ⟨c.control.map (fun q => enc P (.get0 q)), c.stack, out⟩

noncomputable def state (P : Program) (q : Label P.states) (xs : Fin 3 → List Bool)
    (out : List Bool) : RegisterBits.Config (program P) := ⟨some (enc P q), xs, out⟩

@[simp] theorem read0 (P : Program) (q : Fin P.states) (xs : Fin 3 → List Bool)
    (out : List Bool) (b : Bool) :
    RegisterBits.step (program P) (state P (.get0 q) xs out) b =
      state P (.get1 q (xs 0).head? b) xs out := by
  simp [RegisterBits.step, program, state, BinaryStack.applyOp]

@[simp] theorem read1 (P : Program) (q : Fin P.states) (a : Option Bool) (c b : Bool)
    (xs : Fin 3 → List Bool) (out : List Bool) :
    RegisterBits.step (program P) (state P (.get1 q a c) xs out) b =
      state P (.get2 q a (xs 1).head? c) xs out := by
  simp [RegisterBits.step, program, state, BinaryStack.applyOp]

@[simp] theorem read2 (P : Program) (q : Fin P.states) (a d : Option Bool) (c b : Bool)
    (xs : Fin 3 → List Bool) (out : List Bool) :
    RegisterBits.step (program P) (state P (.get2 q a d c) xs out) b =
      state P (.put q ![a,d,(xs 2).head?] c 0) xs out := by
  simp [RegisterBits.step, program, state, BinaryStack.applyOp]

@[simp] theorem put_step (P : Program) (q : Fin P.states) (ts : Fin 3 → Option Bool)
    (c b : Bool) (k : Fin 3) (xs : Fin 3 → List Bool) (out : List Bool)
    (a : Act P.states) (ha : P.transition q ts c = some a) :
    RegisterBits.step (program P) (state P (.put q ts c k) xs out) b =
      state P (if h : k.val = 2 then .get0 a.next else
        .put q ts c ⟨k.val+1, by have := k.isLt; omega⟩)
        (Function.update xs k (BinaryStack.applyOp (a.work k) (xs k))) out := by
  simp [RegisterBits.step, program, state, ha]

@[simp] theorem put_stop (P : Program) (q : Fin P.states) (ts : Fin 3 → Option Bool)
    (c b : Bool) (k : Fin 3) (xs : Fin 3 → List Bool) (out : List Bool)
    (ha : P.transition q ts c = none) :
    RegisterBits.step (program P) (state P (.put q ts c k) xs out) b =
      ⟨none, xs, out⟩ := by
  simp [RegisterBits.step, program, state, ha]

theorem six_steps (P : Program) (out : List Bool) (c : Config P) (bits : ℕ → Bool) :
    RegisterBits.advance (program P) bits (lift P out c) 6 =
      lift P out (step P c (bits 0)) := by
  rcases c with ⟨q,xs⟩
  cases q with
  | none => rfl
  | some q =>
    have ht : ![(xs 0).head?, (xs 1).head?, (xs 2).head?] =
        (fun i => (xs i).head?) := by funext i; fin_cases i <;> rfl
    change RegisterBits.advance _ bits (state P (.get0 q) xs out) 6 = _
    simp only [RegisterBits.advance, read0, read1, read2, ht]
    cases ha : P.transition q (fun i => (xs i).head?) (bits 0) with
    | none =>
      rw [put_stop (ha := ha)]
      simp [RegisterBits.step, step, ha, lift]
      rfl
    | some a =>
      simp only [put_step (ha := ha), Fin.val_zero, Nat.reduceAdd, Nat.reduceEqDiff, dite_false, dite_true]
      apply BinaryData.Take.config_ext
      · simp [step, ha, lift, state]; rfl
      · funext i; fin_cases i <;> simp [step, ha, lift, state]
      · rfl

theorem advance_six (P : Program) (out : List Bool) (c : Config P) (bits : ℕ → Bool)
    (n : ℕ) :
    RegisterBits.advance (program P) bits (lift P out c) (6*n) =
      lift P out (advance P (fun i => bits (6*i)) c n) := by
  induction n with
  | zero => rfl
  | succ n ih =>
    rw [show 6*(n+1) = 6*n+6 by omega, BinaryData.Take.advance_add, ih, six_steps]
    rfl

end WorkStack.RegisterCompile
end MeanPayoff
end

end OAI