import OAI.Computability.RandomMean.Chunks

namespace OAI

section
namespace MeanPayoff.RegisterBits.Flow
open BinaryData.Take
 theorem quiet_hop_all {K : ℕ} (F : Program K) (p : Fin F.nodes)
    (hq : CoinFree (F.block p)) (s t : Fin K→List Bool) (out out' : List Bool) (N : ℕ)
    (h : ∀ bits, advance (F.block p) bits ⟨some (F.block p).start,s,out⟩ N=⟨none,t,out'⟩)
    (d : Config (compile F)) (he : ∀ b, RegisterBits.step (compile F) (edge F p t out') b=d) :
    ∃ n≤N+1, ∀ bits, advance (compile F) bits (state F p s out) n=d := by
  obtain ⟨n,hn,hh⟩ := quiet_runs F p hq s t out out' N h
  exact ⟨n+1,by omega,fun bits => by rw [advance,hh,he]⟩
 theorem skip_edge (F : Program 5) (p : Fin F.nodes) (hp : F.block p=TreeDevice.skip)
    (s : Fin 5→List Bool) (out : List Bool) (b : Bool) :
    RegisterBits.step (compile F) (state F p s out) b=edge F p s out := by
  have h := step_inner F p ⟨some (F.block p).start,s,out⟩ (by simp) b
  change RegisterBits.step _ (state F p s out) b=_ at h
  rw [h]
  have ht : ∀ q top b, (F.block p).transition q top b=none := by
    rw [hp]; intros; rfl
  simp only [RegisterBits.step,ht]
  rfl
end MeanPayoff.RegisterBits.Flow
namespace MeanPayoff.RandomTable
open RegisterBits BinaryData TreeDevice
open BinaryData.Take (advance_add config_ext)
variable (pre post : RegisterBits.Program 5)
noncomputable def flow : Flow.Program 5 where
  nodes := 12
  start := 0
  block p := if p=0 then pre else if p=9 then moveCode 1 0 else if p=11 then post else skip
  read p := if p=2 ∨ p=5 ∨ p=6 ∨ p=7 ∨ p=8 then 1 else 0
  next p top bit := match p.val with
    | 0 => some ⟨1,.keep,none⟩
    | 1 => some ⟨2,.pop,none⟩
    | 2 => some ⟨3,.push false,none⟩
    | 3 => some ⟨if top=some true then 4 else 9,.pop,none⟩
    | 4 => some ⟨5,.pop,none⟩
    | 5 => some ⟨if bit then 6 else 8,.push false,none⟩
    | 6 => some ⟨7,.push false,none⟩
    | 7 => some ⟨8,.push true,none⟩
    | 8 => some ⟨3,.push true,none⟩
    | 9 => some ⟨10,.keep,none⟩
    | 10 => some ⟨11,.push true,none⟩
    | _ => none
noncomputable def program := Flow.compile (flow pre post)
noncomputable def cfg (p : Fin 12) (xs ys : List Bool) (out : List Bool) : Config (program pre post) :=
  Flow.state (flow pre post) p (core xs ys []) out
noncomputable def edge (p : Fin 12) (xs ys : List Bool) (out : List Bool) : Config (program pre post) :=
  Flow.edge (flow pre post) p (core xs ys []) out
 theorem skip_step (p : Fin 12) (h0 : p≠0) (h9 : p≠9) (h11 : p≠11)
    (xs ys out : List Bool) (b : Bool) :
    RegisterBits.step (program pre post) (cfg pre post p xs ys out) b=edge pre post p xs ys out := by
  exact Flow.skip_edge (flow pre post) p (by simp [flow,h0,h9,h11]) _ _ _
 theorem boundary (p : Fin 12) (xs ys out : List Bool) (b : Bool) :
    RegisterBits.step (program pre post) (edge pre post p xs ys out) b =
    match (flow pre post).next p ((core xs ys []) ((flow pre post).read p)).head? b with
    | none => ⟨none,core xs ys [],out⟩
    | some a => Flow.state (flow pre post) a.next
        (Function.update (core xs ys []) ((flow pre post).read p)
          (BinaryStack.applyOp a.work ((core xs ys []) ((flow pre post).read p)))) (out++a.emit.toList) :=
  by
    convert Flow.step_boundary (flow pre post) p (core xs ys []) out b using 1 <;> try rfl
    cases (flow pre post).next p ((core xs ys []) ((flow pre post).read p)).head? b <;> rfl
 theorem wait_two (p q : Fin 12) (h0 : p≠0) (h9 : p≠9) (h11 : p≠11)
    (xs ys xs' ys' out : List Bool)
    (h : ∀ b, RegisterBits.step (program pre post) (edge pre post p xs ys out) b=cfg pre post q xs' ys' out)
    (bits : ℕ→Bool) : advance (program pre post) bits (cfg pre post p xs ys out) 2=cfg pre post q xs' ys' out := by
  simp only [advance,skip_step pre post p h0 h9 h11,h]
 theorem loop_one (ns xs ys out : List Bool) (bits : ℕ→Bool) :
    advance (program pre post) bits (cfg pre post 3 (true::false::ns++xs) ys out) 5 =
      edge pre post 5 (ns++xs) ys out := by
  have h3 : ∀ b, RegisterBits.step (program pre post) (edge pre post 3 (true::false::ns++xs) ys out) b=
      cfg pre post 4 (false::ns++xs) ys out := by
    intro b; rw [boundary]; apply config_ext <;> (try rfl) <;> (try exact List.append_nil out)
    funext i; fin_cases i <;> rfl
  have h4 : ∀ b, RegisterBits.step (program pre post) (edge pre post 4 (false::ns++xs) ys out) b=
      cfg pre post 5 (ns++xs) ys out := by
    intro b; rw [boundary]; apply config_ext <;> (try rfl) <;> (try exact List.append_nil out)
    funext i; fin_cases i <;> rfl
  change advance _ bits _ (2+(2+1)) = _
  rw [advance_add,wait_two pre post 3 4 (by decide) (by decide) (by decide) _ _ _ _ _ h3,
    advance_add,wait_two pre post 4 5 (by decide) (by decide) (by decide) _ _ _ _ _ h4]
  exact skip_step pre post 5 (by decide) (by decide) (by decide) _ _ _ _
 theorem toss_false (xs ys out : List Bool) :
    RegisterBits.step (program pre post) (edge pre post 5 xs ys out) false=cfg pre post 8 xs (false::ys) out := by
  rw [boundary]; apply config_ext <;> (try rfl) <;> (try exact List.append_nil out)
  funext i; fin_cases i <;> rfl
 theorem toss_true (xs ys out : List Bool) :
    RegisterBits.step (program pre post) (edge pre post 5 xs ys out) true=cfg pre post 6 xs (false::ys) out := by
  rw [boundary]; apply config_ext <;> (try rfl) <;> (try exact List.append_nil out)
  funext i; fin_cases i <;> rfl
 theorem cons_false (xs ys out : List Bool) (bits : ℕ→Bool) :
    advance (program pre post) bits (cfg pre post 8 xs (false::ys) out) 2=cfg pre post 3 xs (consCode false++ys) out := by
  apply wait_two pre post 8 3 (by decide) (by decide) (by decide)
  intro b; rw [boundary]; apply config_ext <;> (try rfl) <;> (try exact List.append_nil out)
  funext i; fin_cases i <;> rfl
 theorem cons_true (xs ys out : List Bool) (bits : ℕ→Bool) :
    advance (program pre post) bits (cfg pre post 6 xs (false::ys) out) 6=cfg pre post 3 xs (consCode true++ys) out := by
  have h6 : ∀ b, RegisterBits.step (program pre post) (edge pre post 6 xs (false::ys) out) b=
      cfg pre post 7 xs (false::false::ys) out := by
    intro b; rw [boundary]; apply config_ext <;> (try rfl) <;> (try exact List.append_nil out)
    funext i; fin_cases i <;> rfl
  have h7 : ∀ b, RegisterBits.step (program pre post) (edge pre post 7 xs (false::false::ys) out) b=
      cfg pre post 8 xs (true::false::false::ys) out := by
    intro b; rw [boundary]; apply config_ext <;> (try rfl) <;> (try exact List.append_nil out)
    funext i; fin_cases i <;> rfl
  change advance _ bits _ (2+(2+2)) = _
  rw [advance_add,wait_two pre post 6 7 (by decide) (by decide) (by decide) _ _ _ _ _ h6,
    advance_add,wait_two pre post 7 8 (by decide) (by decide) (by decide) _ _ _ _ _ h7]
  apply wait_two pre post 8 3 (by decide) (by decide) (by decide)
  intro b; rw [boundary]; apply config_ext <;> (try rfl) <;> (try exact List.append_nil out)
  funext i; fin_cases i <;> rfl
end MeanPayoff.RandomTable

end

section
namespace MeanPayoff.RandomTable
open RegisterBits BinaryData TreeDevice RandomTree
open BinaryData.Take (advance_add config_ext)
variable (pre post : RegisterBits.Program 5)
 theorem loop_zero (xs ys out : List Bool) (bits : ℕ→Bool) :
    advance (program pre post) bits (cfg pre post 3 (false::xs) ys out) 2=cfg pre post 9 xs ys out := by
  apply wait_two pre post 3 9 (by decide) (by decide) (by decide)
  intro b; rw [boundary]; apply config_ext <;> (try rfl) <;> (try exact List.append_nil out)
  funext i; fin_cases i <;> rfl
 theorem pair_up (xs out : List Bool) (bits : ℕ→Bool) :
    advance (program pre post) bits (cfg pre post 10 xs [] out) 2=cfg pre post 11 (true::xs) [] out := by
  apply wait_two pre post 10 11 (by decide) (by decide) (by decide)
  intro b; rw [boundary]; apply config_ext <;> (try rfl) <;> (try exact List.append_nil out)
  funext i; fin_cases i <;> rfl
 theorem moves (x : Data) (xs out : List Bool) :
    ∃ n≤6*treeSize x+4, ∀ bits, advance (program pre post) bits
      (cfg pre post 9 xs (encode x) out) n=cfg pre post 10 (encode x++xs) [] out := by
  apply Flow.quiet_hop_all (flow pre post) (9 : Fin 12) (by intro q top bit; rfl)
    (core xs (encode x) []) (core (encode x++xs) [] []) out out (6*treeSize x+3)
  · intro bits
    change advance (moveCode 1 0) bits ⟨some (moveCode 1 0).start,core xs (encode x) [],out⟩ _ = _
    convert move10 x [] xs [] out bits using 1 ; simp only [List.append_nil] ; rfl
  · intro b
    change RegisterBits.step _ (edge pre post 9 (encode x++xs) [] out) b=_
    rw [boundary]; apply config_ext <;> (try rfl) <;> (try exact List.append_nil out)
    funext i; fin_cases i <;> rfl
 theorem finishes (hq : CoinFree post) (x : Data) (out result : List Bool) (N : ℕ)
    (h : ∀ bits, advance post bits ⟨some post.start,store x [],out⟩ N=⟨none,core [] [] [],result⟩) :
    ∃ n≤N+1, ∀ bits, advance (program pre post) bits (cfg pre post 11 (encode x) [] out) n=
      ⟨none,core [] [] [],result⟩ := by
  have he : ∀ b, RegisterBits.step (Flow.compile (flow pre post))
      (Flow.edge (flow pre post) (11 : Fin 12) (core [] [] []) result) b=
      ⟨none,core [] [] [],result⟩ := by intro b; exact boundary pre post 11 [] [] result b
  obtain ⟨n,hn,hh⟩ := Flow.quiet_hop_all (flow pre post) (11 : Fin 12) hq
    (store x []) (core [] [] []) out result N h _ he
  refine ⟨n,hn,fun bits => ?_⟩
  simpa only [program,cfg,store,List.append_nil,core] using hh bits
 theorem list_size (bs : List Bool) : treeSize (listData bs)≤4*bs.length+1 := by
  induction bs with
  | nil => decide
  | cons b bs ih =>
    change (encode (listData (b::bs))).length≤_
    rw [encode_list_cons,List.length_append,List.length_cons]
    have h := consCode_length_le b
    change (encode (listData bs)).length≤_ at ih
    omega
 theorem sample_trace (hq : CoinFree post) (x : Data) (result : List Bool→List Bool) (U N : ℕ)
    (hp : ∀ bs, bs.length=U → ∀ bits,
      advance post bits ⟨some post.start,store (.pair (listData bs) x) [],[]⟩ N=
        ⟨none,core [] [] [],result bs⟩) (n : ℕ) (bs : List Bool) (hn : n+bs.length=U) :
    ∃ t : RandomTree (Config (program pre post)),
      Traces (program pre post) (cfg pre post 3
        (encode (listTree (fun _ : Unit => Data.nil) (List.replicate n ()))++encode x) (encode (listData bs)) []) t ∧
      t.All (fun c => c.control=none) ∧ t.bitDepth≤12*n+24*U+N+15 ∧
      ∀ f : Config (program pre post)→ℚ, t.expect f=(FairBits.acc n bs).expect
        (fun cs => f ⟨none,core [] [] [],result cs⟩) := by
  induction n generalizing bs with
  | zero =>
    obtain ⟨a,ha,ea⟩ := moves pre post (listData bs) (encode x) []
    obtain ⟨b,hb,eb⟩ := finishes pre post hq (.pair (listData bs) x) [] (result bs) N (hp bs (by omega))
    let d : Config (program pre post) := ⟨none,core [] [] [],result bs⟩
    let t : RandomTree (Config (program pre post)) := wait (2+a+2+b) (.leaf d)
    refine ⟨t,?_,?_,?_,?_⟩
    · apply Traces.wait _ ?_ (Traces.leaf d)
      intro bits
      change advance _ bits (cfg pre post 3 (false::encode x) (encode (listData bs)) []) (2+a+2+b)=d
      rw [advance_add,advance_add,advance_add,loop_zero,ea,pair_up]
      exact eb _
    · simp [t,All,d]
    · simp only [t,depth_wait,bitDepth,Nat.add_zero]
      have hs := list_size bs
      omega
    · intro f; simp only [t,expect_wait,expect,FairBits.acc]; rfl
  | succ n ih =>
    obtain ⟨l,hl,hal,hdl,hel⟩ := ih (false::bs) (by simp only [List.length_cons]; omega)
    obtain ⟨r,hr,har,hdr,her⟩ := ih (true::bs) (by simp only [List.length_cons]; omega)
    let t := wait 5 (RandomTree.coin (wait 2 l) (wait 6 r))
    refine ⟨t,?_,?_,?_,?_⟩
    · refine Traces.wait (d:=edge pre post 5
          (encode (listTree (fun _ : Unit => Data.nil) (List.replicate n ()))++encode x)
          (encode (listData bs)) []) 5 ?_ ?_
      · intro bits
        exact loop_one pre post (encode (listTree (fun _ : Unit => Data.nil) (List.replicate n ()))) (encode x) (encode (listData bs)) [] bits
      · apply Traces.coin
        · rw [toss_false]
          apply Traces.wait 2 (cons_false pre post _ _ [])
          simpa only [encode_list_cons] using hl
        · rw [toss_true]
          apply Traces.wait 6 (cons_true pre post _ _ [])
          simpa only [encode_list_cons] using hr
    · simp only [t,all_wait,All]; exact ⟨hal,har⟩
    · simp only [t,depth_wait,bitDepth]
      omega
    · intro f
      simp only [t,expect_wait,expect,FairBits.acc,hel,her]
 theorem begin_steps (xs ys out : List Bool) (bits : ℕ→Bool) :
    advance (program pre post) bits (cfg pre post 1 (true::xs) ys out) 4=
      cfg pre post 3 xs (false::ys) out := by
  have h1 : ∀ b, RegisterBits.step (program pre post) (edge pre post 1 (true::xs) ys out) b=
      cfg pre post 2 xs ys out := by
    intro b; rw [boundary]; apply config_ext <;> (try rfl) <;> (try exact List.append_nil out)
    funext i; fin_cases i <;> rfl
  have h2 : ∀ b, RegisterBits.step (program pre post) (edge pre post 2 xs ys out) b=
      cfg pre post 3 xs (false::ys) out := by
    intro b; rw [boundary]; apply config_ext <;> (try rfl) <;> (try exact List.append_nil out)
    funext i; fin_cases i <;> rfl
  change advance _ bits _ (2+2)=_
  rw [advance_add,wait_two pre post 1 2 (by decide) (by decide) (by decide) _ _ _ _ _ h1]
  exact wait_two pre post 2 3 (by decide) (by decide) (by decide) _ _ _ _ _ h2 _
 theorem complete_trace (hpre : CoinFree pre) (hpost : CoinFree post)
    (input : List Bool) (x : Data) (result : List Bool→List Bool) (U A B : ℕ)
    (hp : ∀ bits, advance pre bits ⟨some pre.start,core input [] [],[]⟩ A=
      ⟨none,store (.pair (listTree (fun _ : Unit => Data.nil) (List.replicate U ())) x) [],[]⟩)
    (hq : ∀ bs, bs.length=U → ∀ bits,
      advance post bits ⟨some post.start,store (.pair (listData bs) x) [],[]⟩ B=
        ⟨none,core [] [] [],result bs⟩) :
    ∃ t : RandomTree (Config (program pre post)),
      Traces (program pre post) (cfg pre post 0 input [] []) t ∧
      t.All (fun c => c.control=none) ∧ t.bitDepth≤A+36*U+B+20 ∧
      ∀ f : Config (program pre post)→ℚ, t.expect f=(FairBits.acc U []).expect
        (fun cs => f ⟨none,core [] [] [],result cs⟩) := by
  let z := Data.pair (listTree (fun _ : Unit => Data.nil) (List.replicate U ())) x
  have he : ∀ b, RegisterBits.step (Flow.compile (flow pre post))
      (Flow.edge (flow pre post) (0 : Fin 12) (store z []) []) b=
      cfg pre post 1 (encode z) [] [] := by
    intro b
    change RegisterBits.step _ (edge pre post 0 (encode z++[]) [] []) b=_
    rw [List.append_nil,boundary]
    apply config_ext <;> (try rfl)
    funext i; fin_cases i <;> rfl
  obtain ⟨a,ha,ea⟩ := Flow.quiet_hop_all (flow pre post) (0 : Fin 12) hpre
    (core input [] []) (store z []) [] [] A hp _ he
  change ∀ bits, advance (program pre post) bits (cfg pre post 0 input [] []) a=
    cfg pre post 1 (encode z) [] [] at ea
  obtain ⟨t,ht,hal,hd,he⟩ := sample_trace pre post hpost x result U B hq U [] (by simp)
  refine ⟨wait (a+4) t,?_,by simpa only [all_wait] using hal,?_,?_⟩
  · apply Traces.wait _ ?_ ht
    intro bits
    rw [advance_add,ea]
    exact begin_steps pre post _ [] [] _
  · simp only [depth_wait]
    omega
  · intro f; rw [expect_wait,he]
end MeanPayoff.RandomTable

end

section
namespace MeanPayoff.RegisterBits.Sequence5
open BinaryData.Take (advance_add)
variable (P Q : Program 5)
end MeanPayoff.RegisterBits.Sequence5

end

end OAI