| import OAI.Combinatorics.ContingencyTables.Sampling.ExactCoreCost |
| import OAI.Combinatorics.ContingencyTables.Sampling.PhysicalPartialSequence |
|
|
| namespace OAI |
|
|
| /-! # A cheap prefix ending before rare-branch tabulation -/ |
|
|
| namespace ContingencyTables.ExactGatePrefix |
| open MatchingFPRAS MatchingFPRAS.TreeData MatchingFPRAS.TreeFunction |
| open MatchingFPRAS.TreeMachine (Env K encodeEnv) |
| open MatchingFPRAS.PhysicalStream MatchingFPRAS.OnlineStack |
| open ProfilePrograms DensePrograms ExactCoreProgram |
|
|
| noncomputable def output (z : CompletionMargins) (s : Data) : |
| Option MatrixCode → OnlinePartialCall.Config instructions |
| | none => OnlineControl.cfg instructions (some .prepareRare) (env (TreeTyped.encode z) .nil s) |
| | some X => OnlineControl.cfg instructions none (env (TreeTyped.encode X) .nil s) |
|
|
| def experiment (z : CompletionMargins) : Experiment (Option MatrixCode) := |
| (rareBranch z).bind (fun b => if b then .done none else (exactOrdinary z).map some) |
|
|
| noncomputable def budget (z : CompletionMargins) : ℕ := |
| rareBranchRealizer.cost z+exactOrdinaryRealizer.cost z+10*TreeFunction.size (TreeTyped.encode z)+50 |
|
|
| / |
| not started at the failure endpoint of this bounded prefix. -/ |
| theorem prefix_correct_cost (z : CompletionMargins) (s : Data) : |
| ∃ p,Executes program.code program.coin (output z s) |
| (OnlineTree.initial program (TreeTyped.encode z) s) p ∧ |
| (∀ g : Option MatrixCode → ℚ,p.mean g=(experiment z).mean g) ∧ p.cost≤budget z := by |
| let out := output z s |
| have halted (X : MatrixCode) : |
| OnlinePartialCall.At instructions out (some .halt) (env (TreeTyped.encode X) .nil s) |
| (.delay 1 (.done (some X))) := |
| OnlinePartialCall.halt instructions out .halt rfl (some X) _ rfl |
| have ordinary : ∃ p,OnlinePartialCall.At instructions out (some .ordinary) |
| (env (TreeTyped.encode z) .nil s) p ∧ |
| (∀ g : Option MatrixCode → ℚ,p.mean g=((exactOrdinary z).map some).mean g) ∧ |
| p.cost≤exactOrdinaryRealizer.cost z+2 := by |
| obtain ⟨u,hu,hum,huc⟩ := exactOrdinaryRealizer.correct z s |
| refine ⟨.delay 1 (u.bind (fun X => .delay 1 (.done (some X)))),?_,?_,?_⟩ |
| · exact OnlinePartialCall.call instructions out .ordinary .halt exactOrdinaryRealizer.program |
| rfl _ (fun X => env (TreeTyped.encode X) .nil s) u hu _ halted |
| · intro g |
| simp only [Experiment.mean,Experiment.mean_bind,Experiment.mean_map] |
| exact hum _ |
| · have hc := Experiment.cost_bind_le u (fun X => .delay 1 (.done (some X))) 1 |
| (by intro X; rfl) |
| simp only [Experiment.cost] at hc ⊢ |
| omega |
| have branch (b : Bool) : ∃ p,OnlinePartialCall.At instructions out (some .choose) |
| (env (TreeTyped.encode b) .nil (.cons (TreeTyped.encode z) s)) p ∧ |
| (∀ g : Option MatrixCode → ℚ,p.mean g= |
| (if b then (.done none : Experiment (Option MatrixCode)) else (exactOrdinary z).map some).mean g) ∧ |
| p.cost≤exactOrdinaryRealizer.cost z+2*TreeFunction.size (TreeTyped.encode z)+20 := by |
| cases b with |
| | false => |
| obtain ⟨p,hp,hpm,hpc⟩ := ordinary |
| obtain ⟨v,hv,hvm,hvc⟩ := OnlinePartialCall.deterministicCall instructions out |
| .ordinaryInput .ordinary (split 0 2 (by decide)) rfl _ _ _ |
| (split02 (TreeTyped.encode false) .nil (TreeTyped.encode z) s) p hp |
| refine ⟨.delay 1 v,?_,(fun g => (hvm g).trans (hpm g)),?_⟩ |
| · exact OnlinePartialCall.nilBranch instructions out .choose .ordinaryInput .rareInput 0 rfl _ rfl v hv |
| · have hb : TreeFunction.size (TreeTyped.encode false)≤3 := by decide |
| simp only [Experiment.cost] |
| omega |
| | true => |
| have hp : OnlinePartialCall.At instructions out (some .prepareRare) |
| (env (TreeTyped.encode z) .nil s) (.done none) := .done none |
| obtain ⟨v,hv,hvm,hvc⟩ := OnlinePartialCall.deterministicCall instructions out |
| .rareInput .prepareRare (split 0 2 (by decide)) rfl _ _ _ |
| (split02 (TreeTyped.encode true) .nil (TreeTyped.encode z) s) (.done none) hp |
| refine ⟨.delay 1 v,?_,hvm,?_⟩ |
| · exact OnlinePartialCall.consBranch instructions out .choose .ordinaryInput .rareInput 0 rfl _ |
| .nil .nil rfl v hv |
| · have hb : TreeFunction.size (TreeTyped.encode true)≤3 := by decide |
| simp only [Experiment.cost] at hvc ⊢ |
| omega |
| choose v hv hvm hvc using branch |
| obtain ⟨u,hu,hum,huc⟩ := rareBranchRealizer.correct z (.cons (TreeTyped.encode z) s) |
| have hgate := OnlinePartialCall.call instructions out .gate .choose rareBranchRealizer.program |
| rfl _ (fun b => env (TreeTyped.encode b) .nil (.cons (TreeTyped.encode z) s)) u hu v hv |
| obtain ⟨p,hp,hpm,hpc⟩ := OnlinePartialCall.deterministicCall instructions out .prepare .gate |
| OnlineIntegerRetry.prepareProc rfl _ _ _ (OnlineIntegerRetry.prepare_exec (TreeTyped.encode z) s) |
| (.delay 1 (u.bind v)) hgate |
| refine ⟨p,hp,?_,?_⟩ |
| · intro g |
| rw [hpm] |
| simp only [Experiment.mean,Experiment.mean_bind] |
| simp_rw [hvm] |
| rw [hum,experiment,Experiment.mean_bind] |
| · have hc := Experiment.cost_bind_le u v |
| (exactOrdinaryRealizer.cost z+2*TreeFunction.size (TreeTyped.encode z)+20) hvc |
| simp only [Experiment.cost] at hpc |
| unfold budget |
| omega |
|
|
| lemma failure (z : CompletionMargins) : |
| (experiment z).mean (fun o => if o=none then 1 else 0)=1/(2:ℚ)^(exactPrecision z) := by |
| rw [experiment,Experiment.mean_bind] |
| have he : (fun b : Bool => (if b then (.done none : Experiment (Option MatrixCode)) |
| else (exactOrdinary z).map some).mean (fun o => if o=none then 1 else 0))= |
| (fun b => if b then 1 else 0) := by |
| funext b |
| cases b with |
| | true => rfl |
| | false => |
| simp only [Bool.false_eq_true,ite_false,Experiment.mean_map,Option.some_ne_none] |
| exact PhysicalPartialSequence.mean_const _ _ |
| rw [he,rareBranch_probability] |
|
|
| end ContingencyTables.ExactGatePrefix |
|
|
| end OAI |
|
|
