File size: 8,059 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 | import Mathlib
import OAI.Combinatorics.MatchingCount.Sampling.TreeUnitSampler
import OAI.Combinatorics.MatchingCount.Sampling.TreeFastUnit
namespace OAI
namespace MatchingFPRAS.ExecutableUnit
open TreeTyped ExecutableDP Polynomial
def fastSelected (x : Context×Bits) : ℕ×ℕ := fastDraw (x.1,x.2.getD (x.1.1.1.length-1) [])
def fastSelectedRealizer : Realizer fastSelected := by
let n : Realizer (fun x : Context×Bits=>x.1.1.1.length-1) := composition (composition first.fst.fst listLength) predecessor
exact (composition (pair first (composition (pair second n) (getDFast []))) fastDrawRealizer).congr (fun _=>rfl)
lemma polynomial_fastSelected : PolynomialTime fastSelectedRealizer := by
unfold fastSelectedRealizer
dsimp only
apply polynomial_congr
apply polynomial_composition _ polynomial_fastDraw
have := polynomial_getDFast ([] : List Bool)
have := polynomial_predecessor
dsimp only [Realizer.fst,Realizer.snd]
tree_poly
def nextContextFast : Realizer nextContext :=
(pair (pair (composition (pair first.fst.fst second.fst) residualFast) first.fst.snd) first.snd).congr (fun _=>rfl)
lemma polynomial_nextContextFast : PolynomialTime nextContextFast := by
unfold nextContextFast
apply polynomial_congr
have := polynomial_residualFast
dsimp only [Realizer.fst,Realizer.snd]
tree_poly
def fastStep (x : State) : State :=
if 2≤x.1.1.1.length then
let c:=fastSelected (x.1,x.2.1)
(nextContext (x.1,c),(x.2.1,(x.1.1.1.length-2,c)::x.2.2))
else x
def fastStepRealizer : Realizer fastStep := by
let n : Realizer (fun x : State=>x.1.1.1.length) := composition first.fst.fst listLength
let c : Realizer (fun x : State=>fastSelected (x.1,x.2.1)) := (composition (f:=fun x : State=>(x.1,x.2.1)) (pair first second.fst) fastSelectedRealizer).congr (fun _=>rfl)
let ctx := composition (pair first c) nextContextFast
let k := composition (pair n (constant 2)) subtract
let fs := composition (pair (pair k c) second.snd) listCons
let r := pair ctx (pair second.fst fs)
exact (choose (composition (composition (pair n (constant 2)) less) boolNot) r identity).congr (by
intro x; simp [fastStep,Nat.succ_le_iff])
lemma polynomial_fastStep : PolynomialTime fastStepRealizer := by
unfold fastStepRealizer
dsimp only
apply polynomial_congr
have := polynomial_fastSelected
have := polynomial_nextContextFast
dsimp only [Realizer.fst,Realizer.snd]
tree_poly
lemma chooseBits_le_length (x : List TreeFraction.Fraction×List Bool) : ExecutableChoice.chooseBits x≤x.1.length := by
exact TreeTyped.listMin_le_default _ _
lemma fastDraw_bounds (x : Context×List Bool) :
(fastDraw x).1≤x.1.1.1.length*x.1.1.2.length ∧ (fastDraw x).2≤x.1.1.1.length*x.1.1.2.length := by
have h:=chooseBits_le_length (fastProbabilities x.1,x.2)
simp only [fastProbabilities,List.length_map,List.length_range] at h
exact ⟨(Nat.div_le_self _ _).trans h,(Nat.mod_le _ _).trans h⟩
lemma fastSelected_bounds (x : Context×Bits) :
(fastSelected x).1≤x.1.1.1.length*x.1.1.2.length ∧ (fastSelected x).2≤x.1.1.1.length*x.1.1.2.length :=
fastDraw_bounds _
lemma residual_length (bs : Bags) (b : ℕ) : (residual (bs,b)).length=bs.length-2 := by
simp [residual]
lemma residual_mem {bs : Bags} {b : ℕ} {a : Bag} (ha : a∈residual (bs,b)) : a∈bs := by
simp only [residual,List.mem_map,List.mem_range] at ha
obtain ⟨i,hi,rfl⟩:=ha
have hj : skip (i,b)<bs.length := by simp only [skip]; split_ifs <;> omega
rw [List.getD_eq_getElem _ _ hj]
exact List.getElem_mem _
def DescentInvariant (a : Context×Bits) (k : ℕ) (z : State) : Prop :=
z.1.1.1.length≤a.1.1.1.length ∧
(∀ b∈z.1.1.1,b∈a.1.1.1) ∧ z.1.1.2=a.1.1.2 ∧ z.1.2=a.1.2 ∧ z.2.1=a.2 ∧
z.2.2.length+k≤a.1.1.1.length ∧
∀ f∈z.2.2,f.1≤a.1.1.1.length ∧ f.2.1≤a.1.1.1.length*a.1.1.2.length ∧ f.2.2≤a.1.1.1.length*a.1.1.2.length
lemma descent_init (a : Context×Bits) : DescentInvariant a a.1.1.1.length (a.1,(a.2,[])) := by
simp only [DescentInvariant,List.length_nil,Nat.zero_add,List.not_mem_nil,IsEmpty.forall_iff,le_refl,implies_true,true_and,and_true]
exact fun b h=>h
lemma descent_step (a : Context×Bits) (k : ℕ) (z : State) (hz : DescentInvariant a (k+1) z) :
DescentInvariant a k (fastStep z) := by
obtain ⟨hl,hb,hp,ho,ht,hf,hm⟩:=hz
by_cases hn : 2≤z.1.1.1.length
· rw [fastStep,ite_eq_left hn]
have hc:=fastSelected_bounds (z.1,z.2.1)
rw [hp] at hc
have hmul:=Nat.mul_le_mul_right a.1.1.2.length hl
refine ⟨?_,?_,hp,ho,ht,?_,?_⟩
· change (residual (z.1.1.1,(fastSelected (z.1,z.2.1)).1)).length≤_
rw [residual_length]; omega
· intro b hb'
exact hb b (residual_mem hb')
· change ( _ :: z.2.2).length+k≤_
simp only [List.length_cons]; omega
· intro f hh
rcases List.mem_cons.mp hh with rfl | hh
· exact ⟨(Nat.sub_le _ _).trans hl,hc.1.trans hmul,hc.2.trans hmul⟩
· exact hm f hh
· rw [fastStep,ite_eq_right hn]
exact ⟨hl,hb,hp,ho,ht,by omega,hm⟩
lemma descent_weight (a : Context×Bits) (k : ℕ) (z : State) (hz : DescentInvariant a k z) :
weight z≤ 20*(weight a+1)^3 := by
obtain ⟨hl,hb,hp,ho,ht,hf,hm⟩:=hz
let S:=weight a
have hn : a.1.1.1.length≤S := (list_length_le_weight _).trans ((weight_fst a.1.1).trans ((weight_fst a.1).trans (weight_fst a)))
have hn' : a.1.1.2.length≤S := (list_length_le_weight _).trans ((weight_snd a.1.1).trans ((weight_fst a.1).trans (weight_fst a)))
have hbn:weight z.1.1.1≤S*(S+1)+1 := by
have hh:=weight_map_bound (as:=z.1.1.1) (f:=id) (N:=S) (fun b hh=>(weight_mem (hb b hh)).trans ((weight_fst a.1.1).trans ((weight_fst a.1).trans (weight_fst a))))
simpa only [List.map_id] using hh.trans (Nat.add_le_add_right (Nat.mul_le_mul_right (S+1) (hl.trans hn)) 1)
have hmfn:weight z.2.2≤S*(8*S*S+4*S+6)+1 := by
have hh:=weight_map_bound (as:=z.2.2) (f:=id) (N:=8*S*S+4*S+5) (by
intro f hh
obtain ⟨h1,h2,h3⟩:=hm f hh
have hm:=Nat.mul_le_mul hn hn'
have hf1:=weight_nat_numeric f.1
have hf2:=weight_nat_numeric f.2.1
have hf3:=weight_nat_numeric f.2.2
change weight f≤_
rw [←Prod.eta f,weight_prod,←Prod.eta f.2,weight_prod]
nlinarith)
simp only [List.map_id] at hh
have hlen :z.2.2.length≤S:=by omega
have he : 8*S*S+4*S+5+1=8*S*S+4*S+6 := by omega
rw [he] at hh
exact hh.trans (Nat.add_le_add_right (Nat.mul_le_mul_right _ hlen) 1)
have hpar :weight a.1.1.2≤S := (weight_snd a.1.1).trans ((weight_fst a.1).trans (weight_fst a))
have hplan :weight a.1.2≤S := (weight_snd a.1).trans (weight_fst a)
have hbits :weight a.2≤S := weight_snd a
rw [←Prod.eta z,weight_prod,←Prod.eta z.1,weight_prod,←Prod.eta z.1.1,weight_prod,←Prod.eta z.2,weight_prod,hp,ho,ht]
change _≤20*(S+1)^3
nlinarith
def fastDescend (a : Context×Bits) : State :=
countDown (fun y : ℕ×State=>fastStep y.2) a.1.1.1.length (a.1,(a.2,[]))
def fastDescendRealizer : Realizer fastDescend :=
(composition (pair (composition first.fst.fst listLength) (pair first (pair second (constant ([] : List Frame)))))
(iterateDown (composition second fastStepRealizer))).congr (fun _=>rfl)
lemma polynomial_fastDescend : PolynomialTime fastDescendRealizer := by
unfold fastDescendRealizer
apply polynomial_congr
apply polynomial_boundedRepeat (by dsimp only [Realizer.fst,Realizer.snd]; tree_poly)
(polynomial_composition polynomial_second polynomial_fastStep)
X (20*(X+1)^3) DescentInvariant
· intro a
simpa only [Function.comp_apply,Polynomial.eval_X] using (list_length_le_weight a.1.1.1).trans ((weight_fst a.1.1).trans ((weight_fst a.1).trans (weight_fst a)))
· exact descent_init
· intro a k _hk z hz
exact descent_step a k z hz
· intro a k z hz
simpa only [Polynomial.eval_mul,Polynomial.eval_ofNat,Polynomial.eval_pow,Polynomial.eval_add,Polynomial.eval_X,Polynomial.eval_one] using descent_weight a k z hz
end MatchingFPRAS.ExecutableUnit
end OAI
|