| import Mathlib |
| import OAI.Combinatorics.MatchingCount.Algorithm.OnlineInitialLaw |
| import OAI.Combinatorics.MatchingCount.Tapes.Input |
| import OAI.Combinatorics.MatchingCount.Sampling.Endpoints2 |
| import OAI.Combinatorics.MatchingCount.Machines.OnlineCase |
| import OAI.Combinatorics.MatchingCount.Graphs.OnlineGraphInvariant |
|
|
| namespace OAI |
|
|
| namespace MatchingFPRAS.LiteralAlgorithm |
| open TreeTyped TreeFraction PhysicalStream LiteralInput Polynomial |
|
|
| def empty (x : Parsed) : Bool := decide (x.1=0) |
| def emptyRealizer : Realizer empty := composition (pair first (constant 0)) natEqual |
| lemma polynomial_empty : PolynomialTime emptyRealizer := by |
| exact polynomial_composition (polynomial_pair polynomial_first (polynomial_constant 0)) polynomial_natEqual |
|
|
| def invalid (x : Parsed) : Bool := !(decide (x.1%2=0)) || ExecutableInput.tooSparse (x.1,x.2.1) |
| def invalidRealizer : Realizer invalid := |
| (choose (composition first ExecutableSource.evenTest) |
| (composition (pair first second.fst) ExecutableInput.tooSparseRealizer) (constant true)).congr (by |
| intro x |
| unfold invalid |
| cases h : decide (x.1%2=0) <;> simp only [Function.comp_apply,h,Bool.not_true,Bool.not_false,Bool.false_or,Bool.true_or,Bool.false_eq_true,ite_false,ite_true]) |
| lemma polynomial_invalid : PolynomialTime invalidRealizer := by |
| unfold invalidRealizer Realizer.fst |
| apply polynomial_congr |
| have := ExecutableSource.polynomial_evenTest |
| have := ExecutableInput.polynomial_tooSparse |
| tree_cost |
|
|
| def materialize (x : Parsed) : OnlineInitial.Seed := ((List.range x.1,x.2.1),x.2.2) |
| def materializeRealizer : Realizer materialize := |
| pair (pair (composition first range) second.fst) second.snd |
| lemma work_materialize : WorkBound materializeRealizer (fun x=>x.1+weight x) := by |
| have lift {A : Type} [Codec A] {f : Parsed→A} {F : Realizer f} (hF : PolynomialTime F) : |
| WorkBound F (fun x=>x.1+weight x) := work_of_polynomial hF X (by intro x;simp) |
| unfold materializeRealizer Realizer.fst Realizer.snd |
| apply work_pair _ (lift (by tree_cost)) X (by intro x;simp) |
| apply work_pair _ (lift (by tree_cost)) X (by intro x;simp) |
| apply work_composition (lift polynomial_first) range_numeric_work X |
| intro x;simp |
|
|
| def compute (x : Parsed) : Experiment Fraction := |
| OnlineAmplification.run (OnlineInitial.initializeInput (materialize x)) |
| noncomputable def computeRealizer : OnlineTree.Realizer compute := |
| (OnlineTree.composition (OnlineTree.deterministic |
| (composition materializeRealizer OnlineInitial.initializeInputRealizer)) OnlineAmplification.runRealizer).congr (fun _ _=>rfl) |
|
|
| def count (x : Parsed) : Experiment Fraction := |
| if empty x then .done (1,1) else if invalid x then .done (0,1) else compute x |
| noncomputable def countRealizer : OnlineTree.Realizer count := |
| (OnlineTree.conditional emptyRealizer (OnlineTree.deterministic (constant (1,1))) |
| (OnlineTree.conditional invalidRealizer (OnlineTree.deterministic (constant (0,1))) computeRealizer)).congr (fun _ _=>rfl) |
|
|
| def algorithm (as : List Symbol) : Experiment (List Symbol) := |
| (count (parseInput as)).map LiteralCodec.ratWord |
| noncomputable def algorithmRealizer : OnlineTree.Realizer algorithm := |
| (OnlineTree.composition (OnlineTree.composition (OnlineTree.deterministic parseInputRealizer) countRealizer) |
| (OnlineTree.deterministic LiteralCodec.ratWordRealizer)).congr (by |
| intro as h;simp only [algorithm,Experiment.mean_bind,Experiment.mean,Experiment.mean_map]) |
|
|
| lemma edgeNumbers_length (G : GraphInput) : (edgeNumbers G).length=G.edges.card := by |
| simp only [edgeNumbers,List.length_map,Finset.length_sort,Finset.card_map] |
| lemma edgeNumbers_mem (G : GraphInput) (e : ℕ×ℕ) : |
| e∈edgeNumbers G ↔ e∈(ExecutableAdaptive.graphRep G).2 := by |
| classical |
| simp only [edgeNumbers,ExecutableAdaptive.graphRep,List.mem_map,Finset.mem_sort, |
| Finset.mem_map,Finset.mem_toList] |
| constructor |
| · rintro ⟨a,⟨b,hb,rfl⟩,he⟩ |
| exact ⟨b,hb,he⟩ |
| · rintro ⟨b,hb,he⟩ |
| exact ⟨toLex b,⟨b,hb,rfl⟩,he⟩ |
| noncomputable def reorder (G : GraphInput) (es : OnlineGraph.Edges) : OnlineGraph.Edges := |
| if es=(ExecutableAdaptive.graphRep G).2 then edgeNumbers G else es |
| lemma reorder_mem (G : GraphInput) (es : OnlineGraph.Edges) (e : ℕ×ℕ) : |
| e∈reorder G es ↔ e∈es := by |
| classical |
| unfold reorder |
| split |
| · rename_i he;rw [he];exact edgeNumbers_mem G e |
| · rfl |
| lemma materialize_source (G : GraphInput) (ε δ : ℚ) : |
| materialize (parseInput (encodeInput G ε δ))= |
| OnlineGraph.seed (reorder G) (OnlineInitial.sourceSeed (G:=G) ε δ) := by |
| rw [parseInput_source] |
| unfold materialize OnlineGraph.seed OnlineGraph.graph OnlineInitial.sourceSeed reorder |
| simp only [ite_true] |
| rfl |
| lemma compute_mean {G : GraphInput} [Nontrivial (Fin G.n)] |
| (hn : 2≤G.n) (hev : Even G.n) (ε δ : ℚ) (he : 0<ε) (he1 : ε<1) (hd : 0≤δ) |
| (h : Fraction→ℚ) : |
| (compute (parseInput (encodeInput G ε δ))).mean h= |
| PhysicalStream.qaverage (fun b=>h (TreeFraction.repr |
| (FiniteTrial.guardedAmplifiedBitOutput (FiniteTrial.parameters G hn hev ε he he1) δ b))) := by |
| unfold compute |
| rw [materialize_source,OnlineGraph.initialize_mean (reorder G) (reorder_mem G), |
| OnlineInitial.initializeInput_source hn hev ε δ he he1 hd] |
| exact OnlineAmplification.run_mean _ δ h |
| end MatchingFPRAS.LiteralAlgorithm |
|
|
| end OAI |
|
|
