| import Mathlib |
| import OAI.Combinatorics.MatchingCount.Sampling.TreeClippedDP |
|
|
| namespace OAI |
|
|
| namespace MatchingFPRAS.ExecutableDP |
| open TreeTyped Polynomial |
|
|
| abbrev CappedState := CountInput×State |
|
|
| def cappedStep (x : ℕ×CappedState) : CappedState := |
| let o:=x.2.1 |
| let st:=x.2.2 |
| let rem:=st.1-1 |
| (o,(rem,(trim st.2.1 x.1,cappedUpdate ((o,((st.2.1,o.1.2),(x.1,st.2.2))),rem)))) |
| def cappedStepRealizer : Realizer cappedStep := by |
| let o : Realizer (fun x : ℕ×CappedState=>x.2.1) := second.fst |
| let st : Realizer (fun x : ℕ×CappedState=>x.2.2) := second.snd |
| let rem := composition st.fst predecessor |
| let bs := composition (pair st.snd.fst first) trimRealizer |
| let inp := pair (pair o (pair (pair st.snd.fst o.fst.snd) (pair first st.snd.snd))) rem |
| exact (pair o (pair rem (pair bs (composition inp cappedUpdateRealizer)))).congr (fun _=>rfl) |
| lemma polynomial_cappedStep : PolynomialTime cappedStepRealizer := by |
| unfold cappedStepRealizer Realizer.fst Realizer.snd |
| dsimp only |
| apply polynomial_congr |
| have := polynomial_predecessor |
| have := polynomial_trim |
| have := polynomial_cappedUpdate |
| tree_poly |
|
|
| def tableWeightBound (o : CountInput) : ℕ := |
| 1+nLabels o*(2+(nVertices o*nPlan o+1)*(4*capBits o+2)) |
| lemma cappedUpdate_weight (x : UpdateInput) : weight (cappedUpdate x)≤tableWeightBound x.1.1 := by |
| unfold cappedUpdate tabulate |
| have hw:=weight_map_bound (as:=List.range (updateRows x)) |
| (f:=fun a=>(List.range (updateColumns x+1)).map fun r=>cappedEntry (x,(a,r))) |
| (N:=1+(nVertices x.1.1*nPlan x.1.1+1)*(4*capBits x.1.1+2)) (by |
| intro a _ |
| have hh:=weight_map_bound (as:=List.range (updateColumns x+1)) |
| (f:=fun r=>cappedEntry (x,(a,r))) (N:=4*capBits x.1.1+1) (by |
| intro r _ |
| have hb:=clip_size (capBits x.1.1) (rawEntry (x.1.2,(a,r))) |
| have hw:=weight_nat_le (cappedEntry (x,(a,r))) |
| change (cappedEntry (x,(a,r))).size≤capBits x.1.1 at hb |
| omega) |
| simp only [List.length_range] at hh |
| simp only [Nat.add_assoc, Nat.reduceAdd] at hh |
| have hdim : updateColumns x≤nVertices x.1.1*nPlan x.1.1 := Nat.mul_le_mul_left _ (min_le_right _ _) |
| have hm:=Nat.mul_le_mul_right (4*capBits x.1.1+2) (Nat.add_le_add_right hdim 1) |
| exact hh.trans (by omega)) |
| simp only [List.length_range,updateRows] at hw |
| unfold tableWeightBound |
| dsimp only |
| exact hw.trans_eq (by ring) |
| lemma tableWeightBound_polynomial (o : CountInput) : |
| tableWeightBound o≤1+weight o*(2+((weight o)^2+1)*(4*((weight o)^2+(weight o)^5+1)+2)) := by |
| obtain ⟨hn,hm,hL⟩:=input_lengths o |
| have hb:=capBits_bound o |
| have hprod : nVertices o*nPlan o≤(weight o)^2 := by simpa only [pow_two] using Nat.mul_le_mul hn hL |
| unfold tableWeightBound |
| exact Nat.add_le_add_left (Nat.mul_le_mul hm (Nat.add_le_add_left (Nat.mul_le_mul |
| (Nat.add_le_add_right hprod 1) (by omega)) 2)) 1 |
|
|
| lemma cappedFold_invariant (ls : List ℕ) (z : CappedState) : |
| let r:=ls.foldl (fun z l=>cappedStep (l,z)) z |
| r.1=z.1 ∧ r.2.1≤z.2.1 ∧ r.2.2.1.Sublist z.2.2.1 ∧ |
| weight r.2.2.2≤weight z.2.2.2+tableWeightBound z.1 := by |
| induction ls generalizing z with |
| | nil => exact ⟨rfl,le_rfl,List.Sublist.refl _,Nat.le_add_right _ _⟩ |
| | cons l ls ih => |
| have h:=ih (cappedStep (l,z)) |
| dsimp only at h ⊢ |
| simp only [List.foldl_cons] |
| refine ⟨h.1,h.2.1.trans (Nat.sub_le _ _),h.2.2.1.trans (List.filter_sublist (p:=fun b=>!(totalFlag (l,b))) (l:=z.2.2.1)),?_⟩ |
|
|
| cases ls with |
| | nil => |
| change weight (cappedUpdate _)≤_ |
| exact (cappedUpdate_weight _).trans (Nat.le_add_left _ _) |
| | cons l' ls => |
| |
| clear ih h |
| have hs : ∀ (as : List ℕ) (v : CappedState) (j : ℕ), |
| weight ((as.foldl (fun z l=>cappedStep (l,z)) (cappedStep (j,v))).2.2.2)≤tableWeightBound v.1 := by |
| intro as |
| induction as with |
| | nil => intro v j; exact cappedUpdate_weight _ |
| | cons a as ih => |
| intro v j |
| simp only [List.foldl_cons] |
| exact ih (cappedStep (j,v)) a |
| exact (hs ls (cappedStep (l,z)) l').trans (Nat.le_add_left _ _) |
|
|
| lemma weight_cappedState (z : CappedState) : weight z=3+weight z.1+weight z.2.1+weight z.2.2.1+weight z.2.2.2 := by |
| rcases z with ⟨o,k,bs,t⟩ |
| simp only [weight_prod] |
| omega |
|
|
| lemma polynomial_cappedFold : PolynomialTime (fold cappedStepRealizer) := by |
| let P : Polynomial ℕ := 1+X*(2+(X^2+1)*(4*(X^2+X^5+1)+2)) |
| apply polynomial_fold polynomial_cappedStep (8*X+10+P) |
| intro ls z pre _ _ |
| let S:=weight (ls,z) |
| let r:=pre.foldl (fun z l=>cappedStep (l,z)) z |
| have hi:=cappedFold_invariant pre z |
| change r.1=z.1 ∧ r.2.1≤z.2.1 ∧ r.2.2.1.Sublist z.2.2.1 ∧ weight r.2.2.2≤weight z.2.2.2+tableWeightBound z.1 at hi |
| have hz : weight z≤S := weight_snd (ls,z) |
| have ho : weight z.1≤S := (weight_fst z).trans hz |
| have hr : weight z.2.1≤S := (weight_fst z.2).trans ((weight_snd z).trans hz) |
| have hb : weight z.2.2.1≤S := (weight_fst z.2.2).trans ((weight_snd z.2).trans ((weight_snd z).trans hz)) |
| have ht : weight z.2.2.2≤S := (weight_snd z.2.2).trans ((weight_snd z.2).trans ((weight_snd z).trans hz)) |
| have h0 : weight r.1≤S := by rw [hi.1]; exact ho |
| have h1 : weight r.2.1≤4*S+1 := by |
| have hh:=weight_nat_le r.2.1 |
| have hh':=(Nat.size_le_size hi.2.1).trans (size_le_weight z.2.1) |
| omega |
| have h2 : weight r.2.2.1≤S := (weight_sublist hi.2.2.1).trans hb |
| have htable:tableWeightBound z.1≤P.eval S := by |
| apply (tableWeightBound_polynomial z.1).trans |
| simpa only [P, Polynomial.eval_add, Polynomial.eval_mul, Polynomial.eval_one, Polynomial.eval_ofNat, Polynomial.eval_pow, Polynomial.eval_X] using polynomial_eval_monotone P ho |
| change weight r≤_ |
| rw [weight_cappedState r] |
| simp only [Polynomial.eval_add,Polynomial.eval_mul,Polynomial.eval_ofNat,Polynomial.eval_X] |
| change _≤8*S+10+P.eval S |
| omega |
| |
| def finishFast : Realizer (fun x : CountInput×Table=>finish (x.2,nLabels x.1)) := |
| composition (composition (pair second (composition (composition first nLabelsRealizer) range)) |
| (mapWith (composition (pair first (pair second (constant 0))) readFast))) listProd |
| lemma polynomial_finishFast : PolynomialTime finishFast := by |
| unfold finishFast |
| apply polynomial_composition _ polynomial_listProd |
| apply polynomial_composition |
| · apply polynomial_pair polynomial_second |
| apply polynomial_boundedRange (polynomial_composition polynomial_first polynomial_nLabels) X |
| intro x |
| simp only [Function.comp_apply,Polynomial.eval_X] |
| exact (input_lengths x.1).2.1.trans (weight_fst x) |
| · apply polynomial_mapWith |
| apply polynomial_composition _ polynomial_readFast |
| tree_poly |
| |
| def cappedCount (o : CountInput) : ℕ := |
| finish ((o.2.foldl (fun z l=>cappedStep (l,z)) (o,(o.2.length,(o.1.1,initial (nLabels o,BInitial o))))).2.2.2,nLabels o) |
| def cappedCountRealizer : Realizer cappedCount := by |
| let init : Realizer (fun o : CountInput=>(o.2,(o,(o.2.length,(o.1.1,initial (nLabels o,BInitial o)))))) := |
| pair second (pair identity (pair nPlanRealizer (pair first.fst initialFast))) |
| exact (composition (pair identity (composition (composition init (fold cappedStepRealizer)) second.snd.snd)) finishFast).congr (fun _=>rfl) |
| lemma polynomial_cappedCount : PolynomialTime cappedCountRealizer := by |
| unfold cappedCountRealizer |
| dsimp only |
| apply polynomial_congr |
| apply polynomial_composition _ polynomial_finishFast |
| apply polynomial_pair polynomial_identity |
| apply polynomial_composition _ (polynomial_snd (polynomial_snd polynomial_second)) |
| apply polynomial_composition _ polynomial_cappedFold |
| apply polynomial_pair polynomial_second |
| apply polynomial_pair polynomial_identity |
| apply polynomial_pair polynomial_nPlan |
| exact polynomial_pair (polynomial_fst polynomial_first) polynomial_initialFast |
| end MatchingFPRAS.ExecutableDP |
| |
| end OAI |
| |
