File size: 7,876 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 111 112 113 114 115 116 117 118 119 120 121 122 123 124 125 126 127 128 129 130 131 132 133 134 135 136 137 138 139 140 141 142 143 144 145 146 147 148 149 150 151 152 153 154 155 156 157 158 159 160 161 162 163 164 165 | 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
|