| import Mathlib |
| import OAI.Combinatorics.MatchingCount.Complexity.TreePolyTactic |
| import OAI.Combinatorics.MatchingCount.Machines.TreeFastLookup |
| import OAI.Combinatorics.MatchingCount.Complexity.TreePolynomialSums |
| import OAI.Combinatorics.MatchingCount.Machines.TreeFastChoose |
|
|
| namespace OAI |
|
|
| namespace MatchingFPRAS.ExecutableDP |
| open TreeTyped Polynomial |
|
|
| def readFast : Realizer read := |
| composition (pair (composition (pair first second.fst) (getDFast [])) second.snd) (getDFast 0) |
| lemma polynomial_readFast : PolynomialTime readFast := by |
| unfold readFast |
| dsimp only [Realizer.fst, Realizer.snd] |
| apply polynomial_composition _ (polynomial_getDFast 0) |
| apply polynomial_pair _ (polynomial_snd polynomial_second) |
| apply polynomial_composition _ (polynomial_getDFast []) |
| tree_poly |
|
|
| lemma polynomial_totalFlag : PolynomialTime totalFlagRealizer := by |
| unfold totalFlagRealizer |
| apply polynomial_composition _ polynomial_membership |
| tree_poly |
| lemma polynomial_countWith {A B : Type} [Codec A] [Codec B] {p : A×B → Bool} |
| {P : Realizer p} (hP : PolynomialTime P) : PolynomialTime (countWith P) := by |
| unfold countWith countTrue |
| exact polynomial_congr _ (polynomial_composition (polynomial_mapWith hP) |
| (polynomial_composition (polynomial_filter polynomial_identity) polynomial_listLength)) |
|
|
| lemma polynomial_privateFlag : PolynomialTime privateFlagRealizer := by |
| unfold privateFlagRealizer |
| apply polynomial_composition _ polynomial_boolAnd |
| apply polynomial_pair _ polynomial_totalFlag |
| tree_poly |
| lemma polynomial_sharedFlag : PolynomialTime sharedFlagRealizer := by |
| unfold sharedFlagRealizer |
| exact polynomial_composition (polynomial_pair polynomial_totalFlag |
| (polynomial_composition polynomial_privateFlag polynomial_boolNot)) polynomial_boolAnd |
| lemma polynomial_privateNumber : PolynomialTime privateNumberRealizer := by |
| unfold privateNumberRealizer |
| apply polynomial_congr |
| apply polynomial_composition _ (polynomial_countWith polynomial_privateFlag) |
| tree_poly |
| lemma polynomial_sharedNumber : PolynomialTime sharedNumberRealizer := by |
| unfold sharedNumberRealizer |
| apply polynomial_congr |
| apply polynomial_composition _ (polynomial_countWith polynomial_sharedFlag) |
| tree_poly |
| lemma polynomial_totalNumber : PolynomialTime totalNumberRealizer := by |
| unfold totalNumberRealizer |
| apply polynomial_congr |
| apply polynomial_composition _ (polynomial_countWith polynomial_totalFlag) |
| tree_poly |
| lemma polynomial_trim : PolynomialTime trimRealizer := by |
| unfold trimRealizer |
| apply polynomial_composition _ (polynomial_filterWith (polynomial_composition polynomial_totalFlag polynomial_boolNot)) |
| tree_poly |
|
|
| abbrev RawCtx := (Bags×Parents)×(ℕ×Table) |
| def contextFast : Realizer context := by |
| let bl : Realizer (fun x : RawCtx=>(x.1.1,x.2.1)) := pair first.fst second.fst |
| let p := composition bl privateNumberRealizer |
| let q := composition bl sharedNumberRealizer |
| let r := composition bl totalNumberRealizer |
| exact (pair (composition (pair first.snd second.fst) (getDFast (false,0))) |
| (pair second.fst (pair second.snd (pair p (pair q r))))).congr (fun _=>rfl) |
| lemma polynomial_contextFast : PolynomialTime contextFast := by |
| unfold contextFast |
| dsimp only [Realizer.fst, Realizer.snd] |
| apply polynomial_congr |
| apply polynomial_pair |
| · apply polynomial_composition _ (polynomial_getDFast (false,0)) |
| tree_poly |
| · apply polynomial_pair (polynomial_fst polynomial_second) |
| apply polynomial_pair (polynomial_snd polynomial_second) |
| apply polynomial_pair |
| · apply polynomial_composition _ polynomial_privateNumber |
| tree_poly |
| · apply polynomial_pair |
| · apply polynomial_composition _ polynomial_sharedNumber |
| tree_poly |
| · apply polynomial_composition _ polynomial_totalNumber |
| tree_poly |
|
|
| def rawTerm (x : (RawCtx×ℕ)×ℕ) : ℕ := term ((context x.1.1,x.1.2),x.2) |
| def rawTermRealizer : Realizer rawTerm := by |
| let raw : Realizer (fun x : (RawCtx×ℕ)×ℕ=>x.1.1) := first.fst |
| let c := composition raw contextFast |
| let r : Realizer (fun x : (RawCtx×ℕ)×ℕ=>x.1.2) := first.snd |
| let k : Realizer (fun x : (RawCtx×ℕ)×ℕ=>x.2) := second |
| let s := c.snd.snd.snd.snd.fst |
| let u := c.snd.snd.snd.fst |
| let t := c.snd.snd.fst |
| let l := c.snd.fst |
| let p := c.fst.snd |
| let ch := composition (pair s k) fastChoose |
| let L := composition (pair t (pair l (composition (pair u k) add))) readFast |
| let R := composition (pair t (pair p (composition (pair (composition (pair s k) subtract) r) add))) readFast |
| exact (composition (pair (composition (pair ch L) multiply) R) multiply).congr (fun _=>rfl) |
| lemma sharedNumber_le (bs : Bags) (l : ℕ) : sharedNumber bs l≤bs.length := List.length_filter_le _ _ |
| lemma polynomial_rawTerm : PolynomialTime rawTermRealizer := by |
| unfold rawTermRealizer |
| dsimp only [Realizer.fst, Realizer.snd] |
| apply polynomial_congr |
| have hc:=polynomial_contextFast |
| have hr:=polynomial_readFast |
| have hch : PolynomialTime (composition |
| (pair (composition first.fst contextFast).snd.snd.snd.snd.fst (second (A:=RawCtx×ℕ) (B:=ℕ))) fastChoose) := by |
| apply polynomial_boundedFastChoose (by dsimp only [Realizer.fst, Realizer.snd]; tree_poly) X |
| intro x |
| simp only [Polynomial.eval_X] |
| change sharedNumber x.1.1.1.1 x.1.1.2.1≤weight x |
| exact (sharedNumber_le _ _).trans ((list_length_le_weight _).trans (by |
| rcases x with ⟨⟨⟨⟨bs,ps⟩,⟨l,t⟩⟩,r⟩,k⟩ |
| simp only [weight_prod]; omega)) |
| dsimp only [Realizer.fst, Realizer.snd] at hch |
| tree_poly |
|
|
| def rawEntry (x : RawCtx×(ℕ×ℕ)) : ℕ := entry (context x.1,x.2) |
| def rawEntryRealizer : Realizer rawEntry := by |
| let raw : Realizer (fun x : RawCtx×(ℕ×ℕ)=>x.1) := first |
| let c := composition raw contextFast |
| let a : Realizer (fun x : RawCtx×(ℕ×ℕ)=>x.2.1) := second.fst |
| let r : Realizer (fun x : RawCtx×(ℕ×ℕ)=>x.2.2) := second.snd |
| let l := c.snd.fst |
| let rd := composition (pair c.snd.snd.fst (pair a r)) readFast |
| let al := composition (pair a l) natEqual |
| let ap := composition (pair a c.fst.snd) natEqual |
| let ks := composition (composition c.snd.snd.snd.snd.fst successor) range |
| let sm := composition (composition (pair (pair raw r) ks) (mapWith rawTermRealizer)) listSum |
| let rt := composition (pair c.snd.snd.fst (pair l c.snd.snd.snd.snd.snd)) readFast |
| exact (choose c.fst.fst (choose al (constant 1) (choose ap sm rd)) (choose al rt rd)).congr (by |
| intro x; simp only [rawEntry,entry,rawTerm,Function.comp_apply,decide_eq_true_eq]) |
| lemma polynomial_rawEntry : PolynomialTime rawEntryRealizer := by |
| unfold rawEntryRealizer |
| dsimp only [Realizer.fst, Realizer.snd] |
| have hc:=polynomial_contextFast |
| have hr:=polynomial_readFast |
| have ht:=polynomial_rawTerm |
| have hs:=polynomial_listSum |
| have hks : PolynomialTime (composition (composition |
| (composition (first (A:=RawCtx) (B:=ℕ×ℕ)) contextFast).snd.snd.snd.snd.fst successor) range) := by |
| apply polynomial_boundedRange (by |
| have := polynomial_successor |
| dsimp only [Realizer.fst, Realizer.snd] |
| tree_poly) (X+1) |
| intro x |
| simp only [Polynomial.eval_add,Polynomial.eval_X,Polynomial.eval_one] |
| change sharedNumber x.1.1.1 x.1.2.1+1≤weight x+1 |
| have hh:=sharedNumber_le x.1.1.1 x.1.2.1 |
| have hw:=list_length_le_weight x.1.1.1 |
| rcases x with ⟨⟨⟨bs,ps⟩,⟨l,t⟩⟩,ar⟩ |
| simp only [weight_prod] |
| dsimp only at hh hw |
| omega |
| dsimp only [Realizer.fst, Realizer.snd] at hks |
| tree_poly |
| end MatchingFPRAS.ExecutableDP |
|
|
| end OAI |
|
|
