import OAI.Computability.MeanPayoff.Realizer

namespace OAI

namespace MeanPayoff
namespace RandomTree
 theorem all_read {α : Type} {Q : α→Prop} (t : RandomTree α) (h : t.All Q) (bits : ℕ→Bool) : Q (t.read bits) := by
  induction t generalizing bits with
  | leaf a => exact h
  | coin l r il ir =>
    simp only [read]
    split
    · exact ir h.2 _
    · exact il h.1 _
end RandomTree
namespace RegisterBits
 theorem tree_coinFree {K : ℕ} (P : Program K) (hq : CoinFree P) (n : ℕ) (c : Config P) :
    (tree P n c).All (fun z => z=advance P (fun _ => false) c n) := by
  induction n generalizing c with
  | zero => rfl
  | succ n ih =>
    rw [advance_front]
    simp only [tree,RandomTree.All,step_coinFree P hq c true]
    exact ⟨ih _,ih _⟩
namespace Compile
 theorem deterministic_packet {K : ℕ} (P : Program K) (hq : CoinFree P) (input : List Bool) (n : ℕ)
    (out : List Bool) (hc : (advance P (fun _ => false) (initial P input) n).control=none)
    (ho : (advance P (fun _ => false) (initial P input) n).output=out) :
    (MeanPayoff.run (machine P) input (fun _ => false) (2*bound P input n)).control=none ∧
    (MeanPayoff.run (machine P) input (fun _ => false) (2*bound P input n)).tape 2=BinaryStack.cells out 0 := by
  have ht : (tree P n (initial P input)).All (fun c => c.control=none ∧ c.output=out) :=
    RandomTree.all_mono _ (tree_coinFree P hq n (initial P input)) (fun c he => by rw [he]; exact ⟨hc,ho⟩)
  have hh : (tree P n (initial P input)).All (fun c => c.control=none) :=
    RandomTree.all_mono _ ht (fun _ h => h.1)
  have hi := (initialized_all P input n _).mpr ht
  have hr := RandomTree.all_read (initializedTree P input n) hi
    (padBits (TwoPhase.even (fun _ : Fin (2*bound P input n) => false)))
  have hp := machine_packet P input n hh (fun _ => false)
  change _ ∧ _=BinaryStack.cells ((initializedTree P input n).read
    (padBits (TwoPhase.even (fun _ : Fin (2*bound P input n) => false)))).output 0 at hp
  rw [hr.2] at hp
  have hf : padBits (fun _ : Fin (2*bound P input n) => false)=(fun _ => false) := by
    funext j
    simp [padBits]
  rw [hf] at hp
  exact hp
end Compile
end RegisterBits

def freeze (M : Machine) : Machine where
  states := M.states
  start := M.start
  transition s cells _ := M.transition s cells false

def freezeConfig (M : Machine) (c : Configuration M) : Configuration (freeze M) :=
  ⟨c.control,c.head,c.tape⟩
 theorem freeze_deterministic (M : Machine) : Deterministic (freeze M) := by
  intro s cells
  rfl
 theorem freeze_step (M : Machine) (c : Configuration M) (b : Bool) :
    step (freeze M) (freezeConfig M c) b=freezeConfig M (step M c false) := by
  cases c with
  | mk control head tape =>
    cases control with
    | none => rfl
    | some s =>
      simp only [step,freezeConfig,freeze]
      cases M.transition s (fun k => tape k (head k)) false <;> rfl
 theorem freeze_run (M : Machine) (input : List Bool) (n : ℕ) :
    run (freeze M) input (fun _ => false) n=freezeConfig M (run M input (fun _ => false) n) := by
  induction n with
  | zero => rfl
  | succ n ih =>
    simp only [run,ih,freeze_step]
 theorem freeze_correct (G : Game) (M : Machine) (c : Configuration M) (hc : CorrectOutput G c) :
    CorrectOutput G (freezeConfig M c) := hc

namespace DetRealizer
open RegisterBits BinaryData TreeDevice TreeDevice.Certified
noncomputable def machine : Machine := freeze (Compile.machine program)
 theorem machine_deterministic : Deterministic machine := freeze_deterministic _
 theorem correct (G : Game) : CorrectOutput G (run machine (input G) (fun _ => false) (total ⟨input G⟩)) := by
  have he := runs ⟨input G⟩ (fun _ => false)
  have hp := Compile.deterministic_packet program program_quiet (input G) (limit ⟨input G⟩)
    (DetPreparation.value ⟨input G⟩) (by rw [he]) (by rw [he])
  have ho : BinaryInput.CorrectList G (DetPreparation.value ⟨input G⟩) := by
    rw [DetPreparation.value_game,BinaryInput.correctList_ofFn]
    exact Label.mainLabels_correct G
  have hc := correctList_packet G (Compile.machine program) _ _ ho hp.1 hp.2
  rw [machine,freeze_run]
  exact freeze_correct G _ _ hc
end DetRealizer

 theorem deterministic_main : DeterministicMainClaim := by
  obtain ⟨C,hC,hbound⟩ := DetRealizer.total_quasi
  exact ⟨DetRealizer.machine,DetRealizer.machine_deterministic,C,hC,fun G =>
    ⟨DetRealizer.total ⟨input G⟩,hbound ⟨input G⟩,DetRealizer.correct G⟩⟩
end MeanPayoff

theorem deterministic_quasipolynomial_mean_payoff : MeanPayoff.DeterministicMainClaim := MeanPayoff.deterministic_main

end OAI