| import Mathlib |
| import OAI.Combinatorics.MatchingCount.Machines.OnlineTree |
| import OAI.Combinatorics.MatchingCount.Machines.OnlineControl |
|
|
| namespace OAI |
|
|
| namespace MatchingFPRAS.OnlineTree |
| open TreeData TreeMachine RegisterProc TreeFunction TreeTyped |
| open Turing MachineCost PhysicalStream OnlineStack |
|
|
| variable {A B C D : Type} [Codec A] [Codec B] [Codec C] [Codec D] |
| namespace Second |
| open OnlineControl |
|
|
| inductive Point where | split | save | body | pop | cons | halt |
| deriving DecidableEq, Inhabited |
| instance : Fintype Point := ⟨{.split,.save,.body,.pop,.cons,.halt},by intro p; cases p <;> simp⟩ |
| def code (P : OnlineProc.Proc (K Reg)) : Point → OnlineControl.Instr Reg Point |
| | .split => .call (OnlineProc.deterministic (TreeFunction.split 1 0 (by decide))) .save |
| | .save => .call (OnlineProc.deterministic (TreeFunction.cons 1 2 (by decide))) .body |
| | .body => .call P .pop |
| | .pop => .call (OnlineProc.deterministic (TreeFunction.split 1 2 (by decide))) .cons |
| | .cons => .call (OnlineProc.deterministic (TreeFunction.cons 1 0 (by decide))) .halt |
| | .halt => .halt |
| lemma runs {f : B → Experiment C} (F : Realizer f) (a : A) (b : B) (s : Data) : |
| ∃ q,At (code F.program) (fun ac : A×C=>env (encode ac) .nil s) (Option.some Point.split) |
| (env (encode (a,b)) .nil s) q ∧ |
| (∀ g : A×C → ℚ,q.mean g=(f b).mean (fun c=>g (a,c))) ∧ |
| q.cost ≤ F.cost b+8*TreeFunction.size (encode a)+22 := by |
| let M:=code F.program |
| let out:=fun ac : A×C=>env (encode ac) .nil s |
| have hend c:=OnlineControl.halt M out Point.halt rfl (a,c) |
| have hcons c:=deterministicCall M out Point.cons Point.halt |
| (TreeFunction.cons 1 0 (by decide)) rfl _ _ _ (cons10 (encode c) (encode a) s) _ (hend c) |
| choose pc hc hmc hcc using hcons |
| have hpop c:=deterministicCall M out Point.pop Point.cons |
| (TreeFunction.split 1 2 (by decide)) rfl _ _ _ (split12 (encode c) .nil (encode a) s) _ (hc c) |
| choose pp hp hmp hcp using hpop |
| obtain ⟨r,hr,hmr,hcr⟩:=F.correct b (.cons (encode a) s) |
| have hbody:=call M out Point.body Point.pop F.program rfl |
| (env (encode b) .nil (.cons (encode a) s)) (fun c=>env (encode c) .nil (.cons (encode a) s)) |
| r hr pp hp |
| obtain ⟨p2,hp2,hm2,hc2⟩:=deterministicCall M out Point.save Point.body |
| (TreeFunction.cons 1 2 (by decide)) rfl _ _ _ (cons12 (encode b) (encode a) s) _ hbody |
| obtain ⟨p1,hp1,hm1,hc1⟩:=deterministicCall M out Point.split Point.save |
| (TreeFunction.split 1 0 (by decide)) rfl _ _ _ (split10 (encode a) (encode b) .nil s) _ hp2 |
| refine ⟨p1,hp1,?_,?_⟩ |
| · intro g |
| rw [hm1,hm2,Experiment.mean,Experiment.mean_bind] |
| simp_rw [hmp,hmc,Experiment.mean] |
| exact hmr _ |
| · have hb : ∀ c,(pp c).cost ≤ 4*TreeFunction.size (encode a)+11 := by |
| intro c |
| have h1:=hcc c |
| have h2:=hcp c |
| simp only [Experiment.cost,size_nil] at h1 h2 |
| omega |
| have hbind:=Experiment.cost_bind_le r pp _ hb |
| simp only [Experiment.cost,size_nil] at hc1 hc2 |
| omega |
| end Second |
| |
| noncomputable def mapSecond {f : B → Experiment C} (F : Realizer f) : |
| Realizer (fun ab : A×B=>(f ab.2).map (Prod.mk ab.1)) where |
| program := OnlineControl.compile (Second.code F.program) |
| cost := fun ab=>F.cost ab.2+8*TreeFunction.size (encode ab.1)+22 |
| correct := by |
| intro ab s |
| obtain ⟨q,hq,hm,hc⟩:=Second.runs F ab.1 ab.2 s |
| exact ⟨q,hq,fun g=>by rw [Experiment.mean_map]; exact hm g,hc⟩ |
|
|
| noncomputable def pair {f : A → Experiment B} {g : A → Experiment C} |
| (F : Realizer f) (G : Realizer g) : |
| Realizer (fun a=>(f a).bind (fun b=>(g a).map (Prod.mk b))) := |
| (composition (deterministic (TreeTyped.pair (TreeTyped.identity (A:=A)) TreeTyped.identity)) |
| (composition (mapSecond F) |
| (composition (deterministic (TreeTyped.pair (TreeTyped.second (A:=A) (B:=B)) TreeTyped.first)) |
| (mapSecond G)))).congr (by |
| intro a h |
| simp only [Experiment.mean_bind,Experiment.mean,Experiment.mean_map,id_eq]) |
| end MatchingFPRAS.OnlineTree |
|
|
| end OAI |
|
|
