File size: 4,936 Bytes
e5a97c6 | 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 105 106 107 108 109 110 | import Mathlib
import OAI.Combinatorics.MatchingCount.Machines.TreeSum
import OAI.Combinatorics.MatchingCount.Graphs.ExperimentSupport
import OAI.Combinatorics.MatchingCount.Tapes.OnlineComposition
namespace OAI
namespace MatchingFPRAS.OnlineTree
open Turing MachineCost PhysicalStream OnlineStack TreeData TreeMachine TreeFunction TreeTyped
abbrev StoreCfg (P : OnlineProc.Proc (K Reg)) := TM2.Cfg (fun _ : K Reg=>Bool) P.Label RegisterProc.Store
def initial (P : OnlineProc.Proc (K Reg)) (x s : Data) : StoreCfg P :=
⟨some default,none,encodeEnv (env x .nil s)⟩
def final (P : OnlineProc.Proc (K Reg)) (x s : Data) : StoreCfg P :=
⟨none,none,encodeEnv (env x .nil s)⟩
structure Realizer {A B : Type} [Codec A] [Codec B] (f : A → Experiment B) where
program : OnlineProc.Proc (K Reg)
cost : A → ℕ
correct : ∀ a s,∃ q : Experiment B,
Executes program.code program.coin (fun b=>final program (encode b) s)
(initial program (encode a) s) q ∧
(∀ g : B → ℚ,q.mean g=(f a).mean g) ∧ q.cost≤cost a
variable {A B C : Type} [Codec A] [Codec B] [Codec C]
def deterministic {f : A → B} (F : TreeTyped.Realizer f) : Realizer (fun a=>.done (f a)) where
program := OnlineProc.deterministic F.program
cost := F.cost
correct := by
intro a s
obtain ⟨n,hn,he⟩:=F.correct a s
obtain ⟨p,hp,hm,hc⟩:=Executes.of_run F.program.code n _ _ _ he
refine ⟨p.map (fun _=>f a),?_,?_,?_⟩
· exact hp.bind (fun _=>.done (f a)) _ (fun _=>.done (f a))
· intro g
rw [Experiment.mean_map,hm]; rfl
· rw [Experiment.cost_map]
exact hc.trans hn
noncomputable def composition {f : A → Experiment B} {g : B → Experiment C}
(F : Realizer f) (G : Realizer g) : Realizer (fun a=>(f a).bind g) where
program := OnlineProc.seq F.program G.program
cost := fun a=>F.cost a+(f a).worst G.cost
correct := by
intro a s
obtain ⟨p,hp,hm,hc⟩:=F.correct a s
choose q hq hqm hqc using fun b=>G.correct b s
have hp':=hp.relabel (OnlineProc.seq F.program G.program).code (OnlineProc.seq F.program G.program).coin
Sum.inl (some (Sum.inr default)) (fun _=>rfl) (fun _=>rfl)
have hq' b := (hq b).relabel (OnlineProc.seq F.program G.program).code (OnlineProc.seq F.program G.program).coin
Sum.inr none (fun _=>rfl) (fun _=>rfl)
refine ⟨p.bind q,hp'.bind q _ hq',?_,?_⟩
· intro h
simp_rw [Experiment.mean_bind,hqm]
exact hm _
· apply (Experiment.cost_bind_le_of_all p q ((f a).worst G.cost) ?_).trans (Nat.add_le_add_right hc _)
exact (Experiment.all_of_mean_eq hm _ (Experiment.all_worst (f a) G.cost)).mono
(fun b hb=>(hqc b).trans hb)
def Realizer.congr {f g : A → Experiment B} (F : Realizer f)
(h : ∀ a w,(f a).mean w=(g a).mean w) : Realizer g where
program := F.program
cost := F.cost
correct := by
intro a s
obtain ⟨q,hq,hm,hc⟩:=F.correct a s
exact ⟨q,hq,fun w=>(hm w).trans (h a w),hc⟩
def chooseProgram (P Q : OnlineProc.Proc (K Reg)) : OnlineProc.Proc (K Reg) where
toProc := {
Label := Unit ⊕ (P.Label ⊕ Q.Label)
entry := ⟨.inl ()⟩
code := fun l=>match l with
| .inl _ => .halt
| .inr (.inl l) => StackComposition.relabel (fun u=>Sum.inr (Sum.inl u)) none (P.code l)
| .inr (.inr l) => StackComposition.relabel (fun u=>Sum.inr (Sum.inr u)) none (Q.code l) }
coin := fun l=>match l with
| .inl _ => some (fun b=>if b then .inr (.inr default) else .inr (.inl default))
| .inr (.inl l) => (P.coin l).map (fun f b=>.inr (.inl (f b)))
| .inr (.inr l) => (Q.coin l).map (fun f b=>.inr (.inr (f b)))
noncomputable def choose {f g : A → Experiment B} (F : Realizer f) (G : Realizer g) :
Realizer (fun a=>.read (fun b=>if b then g a else f a)) where
program := chooseProgram F.program G.program
cost := fun a=>1+max (F.cost a) (G.cost a)
correct := by
intro a s
obtain ⟨p,hp,hm,hc⟩:=F.correct a s
obtain ⟨q,hq,hqm,hqc⟩:=G.correct a s
have hp':=hp.relabel (chooseProgram F.program G.program).code (chooseProgram F.program G.program).coin
(fun u=>Sum.inr (Sum.inl u)) none (fun _=>rfl) (fun _=>rfl)
have hq':=hq.relabel (chooseProgram F.program G.program).code (chooseProgram F.program G.program).coin
(fun u=>Sum.inr (Sum.inr u)) none (fun _=>rfl) (fun _=>rfl)
refine ⟨.read (fun b=>if b then q else p),?_,?_,?_⟩
· apply Executes.read _ _ _ _ _ rfl
intro b
cases b
· exact hp'
· exact hq'
· intro h
simp only [Experiment.mean,Bool.false_eq_true,↓reduceIte,hm,hqm]
· simp only [Experiment.cost,Bool.false_eq_true,↓reduceIte]
omega
noncomputable def randomBit : Realizer (fun _ : A=>.read (fun b=>.done b)) :=
(choose (deterministic (TreeTyped.constant false)) (deterministic (TreeTyped.constant true))).congr
(by intro a f; rfl)
end MatchingFPRAS.OnlineTree
end OAI
|