| import OAI.Computability.RandomMean.RandomTables |
|
|
| namespace OAI |
|
|
| section |
| namespace MeanPayoff.Realizer |
| open RegisterBits BinaryData TreeDevice TreeDevice.Certified |
| noncomputable def preTail : Program 5 := Sequence5.program (moveCode 1 0) Preparation.device.program |
| noncomputable def pre : Program 5 := Sequence5.program Box5.program preTail |
| noncomputable def preCost (d : Digits) : ℕ := |
| (2*d.bits.length+2+feedCost d.bits+1)+(6*treeSize (encode d)+3+Preparation.device.limit d+2)+2 |
| theorem pre_quiet : CoinFree pre := |
| Sequence5.quiet _ _ Box5.quiet (Sequence5.quiet _ _ (by intro q top b; rfl) Preparation.device.quiet) |
| theorem pre_runs (d : Digits) (bits : ℕ→Bool) : |
| advance pre bits ⟨some pre.start,core d.bits [] [],[]⟩ (preCost d)= |
| ⟨none,store (encode (Preparation.value d)) [],[]⟩ := by |
| have hd : (encode d : Data)=listData d.bits := Halve.listTree_boolData _ |
| apply Sequence5.runs Box5.program preTail (core d.bits [] []) (core [] (BinaryData.encode (encode d)) []) |
| (store (encode (Preparation.value d)) []) [] [] _ _ ?_ ?_ bits |
| · intro cs; rw [hd]; exact Box5.runs d.bits [] cs |
| · intro cs |
| apply Sequence5.runs (moveCode 1 0) Preparation.device.program _ (store (encode d) []) _ [] [] _ _ ?_ ?_ cs |
| · intro ds |
| convert move10 (encode d) [] [] [] [] ds using 1 <;> simp only [store,core,List.append_nil] |
| · exact Preparation.device.correct d [] [] |
| noncomputable def post : Program 5 := Sequence5.program PostCode.run.device.program Emit.program |
| noncomputable def postCost (z : PostCode.Input) : ℕ := PostCode.run.device.limit z+Emit.cost (PostCode.run z).bits+2 |
| theorem post_quiet : CoinFree post := Sequence5.quiet _ _ PostCode.run.device.quiet Emit.quiet |
| theorem post_runs (z : PostCode.Input) (bits : ℕ→Bool) : |
| advance post bits ⟨some post.start,store (encode z) [],[]⟩ (postCost z)= |
| ⟨none,core [] [] [],(PostCode.run z).bits⟩ := by |
| apply Sequence5.runs PostCode.run.device.program Emit.program _ (store (encode (PostCode.run z)) []) _ [] _ _ _ |
| (PostCode.run.device.correct z [] []) ?_ bits |
| intro cs |
| have hd : (encode (PostCode.run z) : Data)=listData (PostCode.run z).bits := Halve.listTree_boolData _ |
| convert Emit.runs (PostCode.run z).bits [] [] cs using 1 <;> simp only [List.nil_append,hd] ; rfl |
| theorem digits_length (d : Digits) : d.bits.length≤treeSize (encode d) := by |
| have h := list_length_le_size boolData d.bits |
| change d.bits.length≤treeSize (listTree boolData d.bits) |
| omega |
| theorem post_polynomial : ∃ K e, ∀ z, postCost z≤K*(treeSize (encode z)+1)^e := by |
| have hi := PolyBound.base (fun z : PostCode.Input => treeSize (encode z)) |
| have hc := polynomial_limit PostCode.run.polynomial _ (fun z : PostCode.Input => z) hi |
| have ho := polynomial_output PostCode.run.device _ (fun z : PostCode.Input => z) hi hc |
| have he := ((PolyBound.const _ 4).mul ho).add (PolyBound.const _ 2) |
| have hb : PolyBound (fun z : PostCode.Input => treeSize (encode z)) (fun z => Emit.cost (PostCode.run z).bits) := |
| he.mono (fun z => (Emit.bound _).trans (Nat.add_le_add_right (Nat.mul_le_mul_left 4 (digits_length _)) 2)) |
| exact (hc.add hb).add (PolyBound.const _ 2) |
| end MeanPayoff.Realizer |
|
|
| end |
|
|
| section |
| namespace MeanPayoff.TreeDevice.Certified.RawControl |
| open SourceControl RandomTree |
| theorem halted_value {G : Game} {B : ℕ} {R : Result G B} |
| (s : SourceControl.State G B R) (z : State) (h : StateRep s z) (hh : s.halted) |
| (F : Pack→ℚ) (f : R.Value→ℚ) (hf : ∀ v p, ValueRep R v p → F p=f v) : |
| F z.1.2=s.denote.erase.expect f := by |
| cases s with |
| | call j k => exact hh.elim |
| | ret k v => |
| cases k with |
| | push frame k => exact hh.elim |
| | done => |
| cases h with |
| | ret tag value stack => |
| change F _=f v |
| exact hf v _ value |
| theorem loop_expect {G : Game} {B : ℕ} {R : Result G B} |
| (n : ℕ) (s : SourceControl.State G B R) (z : State) (h : StateRep s z) |
| (e : Env) (he : EnvRep G B e) (hn : s.rank≤n) |
| (F : Pack→ℚ) (f : R.Value→ℚ) (hf : ∀ v p, ValueRep R v p → F p=f v) : |
| (drawSamples (sampleExponent B) n).expect (fun cs => F (loop ((e,z),cs)).2.1.2)= |
| s.denote.erase.expect f := by |
| have hh := (samples_fold_all n s (fun s => s.halted)).mpr |
| ((sampledRun_all n s _).mpr (run_halts n s hn)) |
| calc |
| _ = (drawSamples (sampleExponent B) n).expect |
| (fun cs => (cs.foldl (fun s c => sampledStep c.length s) s).denote.erase.expect f) := by |
| apply expect_congr_all |
| exact all_mono _ hh (fun cs hc => halted_value _ _ (loop_rep s z h e he cs) hc F f hf) |
| _ = (SourceControl.sampledRun n s).expect (fun s => s.denote.erase.expect f) := samples_fold_expect n s (fun s => s.denote.erase.expect f) |
| _ = (SourceControl.run n s).tree.expect (fun p => p.1.denote.erase.expect f) := sampledRun_expect n s _ |
| _ = ((SourceControl.run n s).bind SourceControl.State.denote).erase.expect f := by |
| simp only [Counted.erase,Counted.bind,expect_map,expect_bind,Function.comp_def] |
| _ = s.denote.erase.expect f := by rw [run_denote] |
| end MeanPayoff.TreeDevice.Certified.RawControl |
| namespace MeanPayoff.SourceControl |
| theorem root_rank (G : Game) : |
| (State.call (Job.solve (rootBudgets G) (rootBox G)) .done).rank≤rootControlBound G := by |
| 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 _ _)) |
| end MeanPayoff.SourceControl |
| namespace MeanPayoff.Realizer |
| open TreeDevice TreeDevice.Certified BinaryData RandomTree |
| theorem classify_rep (G : Game) (w : W) (hw : w.val=topWidth G) |
| (v : BoxVector (rootBox G)) (p : RawControl.Pack) (hp : RawControl.ValueRep (.vector (rootBox G)) v p) : |
| PostCode.classify (w,p.q)=List.ofFn (fun i => decide (topWidth G/2<v.val i)) := by |
| obtain ⟨ws,hws,hval⟩ := hp |
| rw [PostCode.classify_eval,hws,List.map_ofFn] |
| congr 1 |
| funext i |
| simp only [Function.comp_def,hw,hval] |
| theorem root_loop_law (G : Game) (N : ℕ) (hN : SourceControl.rootControlBound G≤N) |
| (f : List Bool→ℚ) : |
| (RawControl.drawSamples (sampleExponent (topWidth G).toNat) N).expect |
| (fun cs => f (PostCode.classify (InputCode.width (InputCode.game G), |
| (RawControl.loop ((RootCode.env (InputCode.game G),RootCode.state (InputCode.game G)),cs)).2.1.2.q))) = |
| (gameSolve G).expect (fun out => f (List.ofFn out)) := by |
| have h := RawControl.loop_expect N _ _ (RootCode.state_rep G) _ (RootCode.env_rep G) |
| ((SourceControl.root_rank G).trans hN) |
| (fun p => f (PostCode.classify (InputCode.width (InputCode.game G),p.q))) |
| (fun v => f (List.ofFn (fun i => decide (topWidth G/2<v.val i)))) |
| (fun v p hp => congrArg f (classify_rep G _ (InputCode.width_val G) v p hp)) |
| convert h using 1 |
| simp only [SourceControl.State.denote,SourceControl.Job.denote,SourceControl.Kont.denote, |
| Counted.bind_pure,CountedAlgorithm.erase_solve,gameSolve,expect_map,Function.comp_def] |
| end MeanPayoff.Realizer |
|
|
| end |
|
|
| section |
| namespace MeanPayoff.Realizer |
| open RegisterBits BinaryData TreeDevice TreeDevice.Certified |
| noncomputable def program : Program 5 := RandomTable.program pre post |
| noncomputable def aux (d : Digits) : Preparation.Aux := (Preparation.value d).2 |
| noncomputable def amount (d : Digits) : ℕ := (Preparation.value d).1.length |
| noncomputable def answer (d : Digits) (bs : List Bool) : List Bool := (PostCode.run (⟨bs⟩,aux d)).bits |
| theorem pre_cost_bound : PolyBound Preparation.resource preCost := by |
| have hi := Preparation.input_bound |
| have hl := hi.mono digits_length |
| have hb : PolyBound Preparation.resource |
| (fun d => 2*d.bits.length+2+feedCost d.bits+1) := |
| (((PolyBound.const _ 7).mul hl).add (PolyBound.const _ 3)).mono (fun d => Box.boxes_bound d.bits) |
| exact (((hb.add ((PolyBound.const _ 6).mul hi)).add (PolyBound.const _ 3)).add |
| Preparation.cost_bound).add (PolyBound.const _ 4) |>.mono (by intro d; unfold preCost; omega) |
| theorem amount_bound : PolyBound Preparation.resource amount := |
| Preparation.output_bound.mono (fun d => (Size.length _).trans (Size.fst (Preparation.value d))) |
| theorem aux_bound : PolyBound Preparation.resource (fun d => treeSize (encode (aux d))) := |
| Preparation.output_bound.mono (fun d => Size.snd (Preparation.value d)) |
| noncomputable def postBudget (K e : ℕ) (d : Digits) : ℕ := |
| K*(4*amount d+treeSize (encode (aux d))+3)^e |
| theorem input_size (d : Digits) (bs : List Bool) : |
| treeSize (encode ((⟨bs⟩ : Digits),aux d))≤4*bs.length+treeSize (encode (aux d))+2 := by |
| change treeSize (.pair (listTree boolData bs) (encode (aux d)))≤_ |
| rw [Halve.listTree_boolData,treeSize_pair] |
| have h := RandomTable.list_size bs |
| omega |
| theorem post_budget (K e : ℕ) (h : ∀ z, postCost z≤K*(treeSize (encode z)+1)^e) |
| (d : Digits) (bs : List Bool) (hl : bs.length=amount d) : |
| postCost (⟨bs⟩,aux d)≤postBudget K e d := by |
| apply (h _).trans |
| apply Nat.mul_le_mul_left |
| apply Nat.pow_le_pow_left |
| have hi := input_size d bs |
| rw [hl] at hi |
| omega |
| theorem budget_bound (K e : ℕ) : PolyBound Preparation.resource (postBudget K e) := |
| (PolyBound.const _ K).mul (((((PolyBound.const _ 4).mul amount_bound).add aux_bound).add |
| (PolyBound.const _ 3)).pow e) |
| noncomputable def limit (K e : ℕ) (d : Digits) : ℕ := preCost d+36*amount d+postBudget K e d+20 |
| theorem limit_bound (K e : ℕ) : PolyBound Preparation.resource (limit K e) := |
| ((pre_cost_bound.add ((PolyBound.const _ 36).mul amount_bound)).add (budget_bound K e)).add (PolyBound.const _ 20) |
| theorem trace (K e : ℕ) (h : ∀ z, postCost z≤K*(treeSize (encode z)+1)^e) (d : Digits) : |
| ∃ t : RandomTree (Config program), Traces program (RegisterBits.initial program d.bits) t ∧ |
| t.All (fun c => c.control=none) ∧ t.bitDepth≤limit K e d ∧ |
| ∀ f : Config program→ℚ, t.expect f=(FairBits.acc (amount d) []).expect |
| (fun bs => f ⟨none,core [] [] [],answer d bs⟩) := by |
| have hu : (Preparation.value d).1=List.replicate (amount d) () := |
| List.eq_replicate_of_mem (fun _ _ => Subsingleton.elim _ _) |
| have hp : ∀ bits, advance pre bits ⟨some pre.start,core d.bits [] [],[]⟩ (preCost d)= |
| ⟨none,store (.pair (listTree (fun _ : Unit => Data.nil) (List.replicate (amount d) ())) (encode (aux d))) [],[]⟩ := by |
| intro bits |
| have hv : encode (Preparation.value d)=Data.pair |
| (listTree (fun _ : Unit => Data.nil) (List.replicate (amount d) ())) (encode (aux d)) := by |
| change Data.pair (encode (Preparation.value d).1) (encode (aux d))=_ |
| rw [hu] |
| rfl |
| simpa only [hv] using pre_runs d bits |
| have hq : ∀ bs, bs.length=amount d → ∀ bits, |
| advance post bits ⟨some post.start,store (.pair (listData bs) (encode (aux d))) [],[]⟩ (postBudget K e d)= |
| ⟨none,core [] [] [],answer d bs⟩ := by |
| intro bs hl bits |
| have hr := post_runs (⟨bs⟩,aux d) bits |
| apply advance_pad _ _ _ bits (post_budget K e h d bs hl) ?_ rfl |
| have hv : encode ((⟨bs⟩ : Digits),aux d)=Data.pair (listData bs) (encode (aux d)) := by |
| change Data.pair (listTree boolData bs) _=_ |
| rw [Halve.listTree_boolData] |
| simpa only [hv,answer] using hr |
| obtain ⟨t,ht,hh,hd,he⟩ := RandomTable.complete_trace pre post pre_quiet post_quiet d.bits |
| (encode (aux d)) (answer d) (amount d) (preCost d) (postBudget K e d) hp hq |
| refine ⟨t,?_,hh,hd,he⟩ |
| have hi : RegisterBits.initial program d.bits=RandomTable.cfg pre post 0 d.bits [] [] := by |
| apply BinaryData.Take.config_ext <;> (try rfl) |
| funext i; fin_cases i <;> rfl |
| rw [hi] |
| exact ht |
| end MeanPayoff.Realizer |
|
|
| end |
|
|
| end OAI |
|
|
