lean/OAI/Computability/RandomMean/Loop.lean

import OAI.Computability.RandomMean.InputBounds

namespace OAI

section
namespace MeanPayoff.TreeDevice.Certified.RawControl
open BinaryData Code
local infixl:80 " ≫ₚ " => Code.comp
local infixr:70 " ⋏ₚ " => Code.pair
abbrev Acc := Env×State
noncomputable def advance : Code (Acc×Count) Acc :=
  (fst ≫ₚ fst) ⋏ₚ (((fst ≫ₚ fst) ⋏ₚ snd ⋏ₚ (fst ≫ₚ snd)) ≫ₚ dispatch)
@[simp] theorem advance_eval (e : Env) (s : State) (c : Count) : advance ((e,s),c)=(e,dispatch (e,c,s)) := rfl
 theorem fold_estimates (e : Env) (cs : List Count) {n H E D T : ℕ}
    (hs : e.2.2.1.length ≤ H) (hj : e.2.2.2.1.length ≤ H)
    (he : RawBasic.ArenaBounded e.1 E) (hd : e.2.2.2.2.length*(E+1)+20 ≤ D) (hT : 22 ≤ T)
    (s : State) (M : ℕ) (hc : StateSmall n H M s) (ht : StateTags T s) :
    (Fold.fold advance.eval (e,s) cs).1=e ∧
    StateSmall n H (M+cs.length*D) (Fold.fold advance.eval (e,s) cs).2 ∧
    stateMass (Fold.fold advance.eval (e,s) cs).2  ≤  stateMass s+3*cs.length ∧
    (Fold.fold advance.eval (e,s) cs).2.2.length ≤ s.2.length+2*cs.length ∧
    StateTags T (Fold.fold advance.eval (e,s) cs).2 := by
  induction cs generalizing s M with
  | nil => simpa [Fold.fold] using And.intro (rfl : e=e) (And.intro hc (And.intro (le_refl (stateMass s)) (And.intro (le_refl s.2.length) ht)))
  | cons c cs ih =>
    have hc' : StateSmall n H (M+D) (dispatch (e,c,s)) := dispatch_small hc.1 hc.2 hs hj he hd
    have ht' : StateTags T (dispatch (e,c,s)) := dispatch_tags hT ht
    have hm := dispatch_mass (e,c,s)
    have hh := ih (dispatch (e,c,s)) (M+D) hc' ht'
    rw [show Fold.fold advance.eval (e,s) (c::cs)=Fold.fold advance.eval (e,dispatch (e,c,s)) cs by rfl, List.length_cons]
    refine ⟨hh.1,?_,?_,?_,hh.2.2.2.2⟩
    · convert hh.2.1 using 1 ; ring
    · change stateMass (dispatch (e,c,s)) ≤  stateMass s+3 ∧ _ at hm
      omega
    · change _ ∧ (dispatch (e,c,s)).2.length ≤ s.2.length+2 at hm
      omega
 theorem prefix_size (s : Acc) (cs : List Count) (k : ℕ) (hk : k ≤ cs.length) :
    treeSize (encode (Fold.fold advance.eval s (cs.take k))) ≤
      1099511627776*(treeSize (encode (s,cs))+1)^12 := by
  let N := treeSize (encode (s,cs))+1
  have hs : treeSize (encode s) ≤ N := (Size.fst (s,cs)).trans (Nat.le_succ _)
  have he : treeSize (encode s.1) ≤ N := (Size.fst s).trans hs
  have hz : treeSize (encode s.2) ≤ N := (Size.snd s).trans hs
  have hg : treeSize (encode s.1.1) ≤ N := (Size.fst s.1).trans he
  have he2 := (Size.snd s.1).trans he
  have he22 := (Size.snd s.1.2).trans he2
  have he222 := (Size.snd s.1.2.2).trans he22
  have hsamp : s.1.2.2.1.length ≤ N := (Size.length _).trans ((Size.fst _).trans he22)
  have htrial : s.1.2.2.2.1.length ≤ N := (Size.length _).trans ((Size.fst _).trans he222)
  have hbasic : s.1.2.2.2.2.length ≤ N := (Size.length _).trans ((Size.snd _).trans he222)
  have hn : 1 ≤ N := Nat.le_add_left _ _
  have n2 : N ≤ N^2 := Nat.le_pow (by decide)
  have n3 : N^2 ≤ N^3 := Nat.pow_le_pow_right hn (by omega)
  have n12 : N^3 ≤ N^12 := Nat.pow_le_pow_right hn (by omega)
  have hl : (cs.take k).length ≤ N :=
    (List.length_take_le _ _).trans (hk.trans ((Size.length cs).trans ((Size.snd (s,cs)).trans (Nat.le_succ _))))
  let D := N*(N+1)+20
  have hh := fold_estimates s.1 (cs.take k) hsamp htrial
    (fun v hv e he => (RawBasic.arenaBounded_size _ v hv e he).trans hg)
    (show s.1.2.2.2.2.length*(N+1)+20 ≤ D by dsimp [D]; gcongr)
    (show 22 ≤ N+22 by omega) s.2 N (stateSmall_of_size hz) ((stateTags_of_size hz).mono (by omega))
  simp only [Prod.eta] at hh
  let U := 50*N^3
  have hu : 1 ≤ U := by dsimp [U]; omega
  have hnu : N ≤ U := by dsimp [U]; omega
  have hMu : N+(cs.take k).length*D ≤ U := by
    have hmul := Nat.mul_le_mul_right D hl
    dsimp [D] at hmul ⊢
    dsimp [U]
    nlinarith
  have hmass : stateMass (Fold.fold advance.eval s (cs.take k)).2 ≤ U := by
    have h0 := stateMass_size s.2
    dsimp [U]
    have h1 := hh.2.2.1
    omega
  have hdepth : (Fold.fold advance.eval s (cs.take k)).2.2.length ≤ U := by
    have h0 := (Size.length s.2.2).trans ((Size.snd s.2).trans hz)
    have h1 := hh.2.2.2.1
    dsimp [U]; omega
  have htag : StateTags U (Fold.fold advance.eval s (cs.take k)).2 := hh.2.2.2.2.mono (by dsimp [U]; omega)
  have hout := state_small_size hh.2.1 htag hu hnu hnu hMu hmass hdepth
  rw [←Prod.eta (Fold.fold advance.eval s (cs.take k)),Size.pair]
  rw [hh.1]
  change _ ≤ 1099511627776*N^12
  dsimp [U] at hout
  rw [mul_pow,←pow_mul] at hout
  norm_num at hout
  nlinarith
noncomputable def loop : Code (Acc×List Count) Acc := foldPrefix advance 1099511627776 12 prefix_size
end MeanPayoff.TreeDevice.Certified.RawControl

end

section
namespace MeanPayoff.RandomTree
@[simp] theorem all_const_iff {α : Type} (t : RandomTree α) (P : Prop) : t.All (fun _ => P) ↔ P := by
  induction t with
  | leaf a => rfl
  | coin l r hl hr => simp only [All,hl,hr,and_self]
end MeanPayoff.RandomTree
namespace MeanPayoff.SourceControl

theorem sampledResume_all {G : Game} {B : ℕ} {A C R : Result G B} (f : Frame G B A C)
    (v : A.Value) (k : Kont G B C R) (Q : State G B R→Prop) :
    (resume f v k).tree.All (fun p => Q p.1) ↔
      (RandomTree.uniformBelow (sampleExponent B)).All (fun j => Q (sampledResume f v k j)) := by
  cases f
  all_goals simp only [resume,sampledResume]
  all_goals try split_ifs
  all_goals simp [Counted.pure,Counted.map,Counted.lift,RandomTree.all_map,RandomTree.All]

theorem sampledResume_expect {G : Game} {B : ℕ} {A C R : Result G B} (f : Frame G B A C)
    (v : A.Value) (k : Kont G B C R) (Q : State G B R→ℚ) :
    (resume f v k).tree.expect (fun p => Q p.1) =
      (RandomTree.uniformBelow (sampleExponent B)).expect (fun j => Q (sampledResume f v k j)) := by
  cases f
  all_goals simp only [resume,sampledResume]
  all_goals try split_ifs
  all_goals simp [Counted.pure,Counted.map,Counted.lift,RandomTree.expect_map,Function.comp_def]

theorem sampledStep_all {G : Game} {B : ℕ} {R : Result G B} (s : State G B R) (Q : State G B R→Prop) :
    (step s).tree.All (fun p => Q p.1) ↔
      (RandomTree.uniformBelow (sampleExponent B)).All (fun j => Q (sampledStep j s)) := by
  cases s with
  | ret k v =>
    cases k with
    | done => simp [step,sampledStep,Counted.pure,RandomTree.All]
    | push f k => exact sampledResume_all f v k Q
  | call j k =>
    cases j
    all_goals simp only [step,sampledStep]
    all_goals try split_ifs
    all_goals try simp [Counted.charge,Counted.pure,RandomTree.all_map,RandomTree.All]
    all_goals split <;> simp_all [RandomTree.All]

theorem sampledStep_expect {G : Game} {B : ℕ} {R : Result G B} (s : State G B R) (Q : State G B R→ℚ) :
    (step s).tree.expect (fun p => Q p.1) =
      (RandomTree.uniformBelow (sampleExponent B)).expect (fun j => Q (sampledStep j s)) := by
  cases s with
  | ret k v =>
    cases k with
    | done => simp [step,sampledStep,Counted.pure]
    | push f k => exact sampledResume_expect f v k Q
  | call j k =>
    cases j
    all_goals simp only [step,sampledStep]
    all_goals try split_ifs
    all_goals try simp [Counted.charge,Counted.pure,RandomTree.expect_map]
    all_goals split <;> simp_all

end MeanPayoff.SourceControl

end

section
namespace MeanPayoff.SourceControl

def sampledRun {G : Game} {B : ℕ} {R : Result G B} : ℕ → State G B R → RandomTree (State G B R)
  | 0,s => .leaf s
  | n+1,s => (RandomTree.uniformBelow (sampleExponent B)).bind fun j => sampledRun n (sampledStep j s)

theorem sampledRun_all {G : Game} {B : ℕ} {R : Result G B} (n : ℕ) (s : State G B R) (Q : State G B R→Prop) :
    (sampledRun n s).All Q ↔ (run n s).tree.All (fun p => Q p.1) := by
  induction n generalizing s with
  | zero => rfl
  | succ n ih =>
    simp only [sampledRun,RandomTree.all_bind,run,Counted.bind,RandomTree.all_bind,RandomTree.all_map]
    simp_rw [ih]
    exact (sampledStep_all s (fun t => (run n t).tree.All (fun p => Q p.1))).symm

theorem sampledRun_expect {G : Game} {B : ℕ} {R : Result G B} (n : ℕ) (s : State G B R) (Q : State G B R→ℚ) :
    (sampledRun n s).expect Q = (run n s).tree.expect (fun p => Q p.1) := by
  induction n generalizing s with
  | zero => rfl
  | succ n ih =>
    simp only [sampledRun,RandomTree.expect_bind,run,Counted.bind,RandomTree.expect_bind,RandomTree.expect_map]
    simp_rw [ih]
    exact (sampledStep_expect s (fun t => (run n t).tree.expect (fun p => Q p.1))).symm
end MeanPayoff.SourceControl
namespace MeanPayoff.TreeDevice.Certified.RawControl
open BinaryData Code

def drawSamples (e n : ℕ) : RandomTree (List Count) :=
  match n with
  | 0 => .leaf []
  | n+1 => (RandomTree.uniformBelow e).bind fun j => (drawSamples e n).map (List.replicate j () :: ·)

theorem samples_length (e n : ℕ) : (drawSamples e n).All (fun cs => cs.length=n) := by
  induction n with
  | zero => rfl
  | succ n ih =>
    simp only [drawSamples,RandomTree.all_bind,RandomTree.all_map]
    apply RandomTree.all_of_forall
    intro j
    exact RandomTree.all_mono _ ih (by intro cs h; simpa using h)

theorem loop_rep {G : Game} {B : ℕ} {R : SourceControl.Result G B}
    (s : SourceControl.State G B R) (z : State) (h : StateRep s z)
    (e : Env) (he : EnvRep G B e) (cs : List Count) :
    StateRep (cs.foldl (fun s c => SourceControl.sampledStep c.length s) s) (loop ((e,z),cs)).2 := by
  change StateRep _ (Fold.fold advance.eval (e,z) cs).2
  induction cs generalizing s z with
  | nil => exact h
  | cons c cs ih =>
    exact ih _ _ (sampled_dispatch_rep h e he c)

theorem samples_fold_expect {G : Game} {B : ℕ} {R : SourceControl.Result G B}
    (n : ℕ) (s : SourceControl.State G B R) (Q : SourceControl.State G B R→ℚ) :
    (drawSamples (sampleExponent B) n).expect (fun cs => Q (cs.foldl (fun s c => SourceControl.sampledStep c.length s) s)) =
      (SourceControl.sampledRun n s).expect Q := by
  induction n generalizing s with
  | zero => rfl
  | succ n ih =>
    simp only [drawSamples,RandomTree.expect_bind,RandomTree.expect_map,Function.comp_def,List.foldl_cons,List.length_replicate,
      SourceControl.sampledRun]
    simp_rw [ih]

theorem samples_fold_all {G : Game} {B : ℕ} {R : SourceControl.Result G B}
    (n : ℕ) (s : SourceControl.State G B R) (Q : SourceControl.State G B R→Prop) :
    (drawSamples (sampleExponent B) n).All (fun cs => Q (cs.foldl (fun s c => SourceControl.sampledStep c.length s) s)) ↔
      (SourceControl.sampledRun n s).All Q := by
  induction n generalizing s with
  | zero => rfl
  | succ n ih =>
    simp only [drawSamples,RandomTree.all_bind,RandomTree.all_map,List.foldl_cons,List.length_replicate,
      SourceControl.sampledRun]
    simp_rw [ih]
end MeanPayoff.TreeDevice.Certified.RawControl

end

end OAI