File size: 7,407 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 | import Mathlib
import OAI.Combinatorics.MatchingCount.Complexity.TreePolynomialGCD
namespace OAI
namespace MatchingFPRAS.TreeTyped
open Polynomial
variable {A B C : Type} [Codec A] [Codec B] [Codec C]
lemma polynomial_listCase (b : B) {g : A×List A → B} {G : Realizer g}
(hG : PolynomialTime G) : PolynomialTime (listCase b G) := by
obtain ⟨p,hp⟩:=hG
obtain ⟨q,hq⟩:=polynomial_constant (A:=List A) b
refine ⟨p+q+3,fun as=>?_⟩
simp only [Polynomial.eval_add,Polynomial.eval_ofNat]
cases as with
| nil =>
have hh:=hq []
change (constant b (A:=List A)).cost []+weight b≤_ at hh
change 3+(constant b (A:=List A)).cost []+weight b≤_
omega
| cons a as =>
have hh:=hp (a,as)
have he : weight (a,as)=weight (a::as) := rfl
rw [he] at hh
change 3+G.cost (a,as)+weight (g (a,as))≤_
omega
lemma polynomial_head (d : A) : PolynomialTime (head d) := by
unfold head
exact polynomial_congr _ (polynomial_listCase d polynomial_first)
lemma polynomial_tail : PolynomialTime (tail (A:=A)) := polynomial_listCase [] polynomial_second
lemma polynomial_isEmpty : PolynomialTime (isEmpty (A:=A)) := polynomial_listCase true (polynomial_constant false)
lemma weight_sublist {as bs : List A} (h : as.Sublist bs) : weight as≤weight bs := by
induction h with
| slnil => exact le_rfl
| cons a h ih => rw [weight_cons]; omega
| cons_cons a h ih => simp only [weight_cons]; omega
lemma polynomial_append : PolynomialTime (append (A:=A)) := by
unfold append
apply polynomial_congr
apply polynomial_composition (polynomial_pair (polynomial_composition polynomial_first polynomial_reverse) polynomial_second)
apply polynomial_fold polynomial_listCons (2*X+1)
intro as bs pre post he
simp only [List.foldl_flip_cons_eq_append']
have hh:=weight_append pre.reverse bs
rw [weight_reverse] at hh
have hp:=weight_prefix he
simp only [Polynomial.eval_add,Polynomial.eval_mul,Polynomial.eval_ofNat,Polynomial.eval_X,weight_prod]
omega
lemma polynomial_mapStep {f : A×B → C} {F : Realizer f} (hF : PolynomialTime F) :
PolynomialTime (mapStepRealizer F) := by
unfold mapStepRealizer
exact polynomial_pair (polynomial_composition polynomial_second polynomial_first)
(polynomial_composition (polynomial_pair
(polynomial_composition (polynomial_pair (polynomial_composition polynomial_second polynomial_first) polynomial_first) hF)
(polynomial_composition polynomial_second polynomial_second)) polynomial_listCons)
lemma polynomial_mapWith {f : A×B → C} {F : Realizer f} (hF : PolynomialTime F) :
PolynomialTime (mapWith F) := by
unfold mapWith
apply polynomial_congr
apply polynomial_composition _ (polynomial_composition polynomial_second polynomial_reverse)
apply polynomial_composition (polynomial_pair polynomial_second (polynomial_pair polynomial_first (polynomial_constant [])))
obtain ⟨p,hp⟩:=hF
apply polynomial_fold (polynomial_mapStep ⟨p,hp⟩) (2*X+X*(p.comp (1+2*X)+1)+2)
rintro bs ⟨a,cs⟩ pre post he
let S:=weight (bs,(a,cs))
have hb : weight bs≤S := by dsimp [S]; simp only [weight_prod]; omega
have ha : weight a≤S := by dsimp [S]; simp only [weight_prod]; omega
have hc : weight cs≤S := by dsimp [S]; simp only [weight_prod]; omega
have hl : pre.length≤S := (list_length_le_weight pre).trans ((weight_prefix he).trans hb)
have hm:=weight_map_bound (f:=fun b=>f (a,b)) (as:=pre) (N:=p.eval (1+2*S)) (by
intro b hmem
have hbs:=weight_mem hmem
have hpre:=weight_prefix he
have hh:=hp (a,b)
have ht:=polynomial_eval_monotone p (show weight (a,b)≤1+2*S by rw [weight_prod]; omega)
dsimp only at ht
omega)
rw [mapStep_fold,weight_prod]
have happ:=weight_append (pre.map fun b=>f (a,b)).reverse cs
rw [weight_reverse] at happ
simp only [Polynomial.eval_add,Polynomial.eval_mul,Polynomial.eval_ofNat,Polynomial.eval_X,Polynomial.eval_one,Polynomial.eval_comp]
change _≤2*S+S*(p.eval (1+2*S)+1)+2
nlinarith [Nat.mul_le_mul_right (p.eval (1+2*S)+1) hl]
lemma polynomial_map {f : A → B} {F : Realizer f} (hF : PolynomialTime F) :
PolynomialTime (map F) := by
unfold map
apply polynomial_congr
apply polynomial_composition _ polynomial_reverse
apply polynomial_composition (polynomial_pair polynomial_identity (polynomial_constant []))
obtain ⟨p,hp⟩:=hF
apply polynomial_fold (polynomial_composition (polynomial_pair (polynomial_composition polynomial_first ⟨p,hp⟩) polynomial_second) polynomial_listCons)
(X+X*(p+1)+1)
intro as bs pre post he
let S:=weight (as,bs)
have ha : weight as≤S := by dsimp [S]; rw [weight_prod]; omega
have hb : weight bs≤S := by dsimp [S]; rw [weight_prod]; omega
have hl : pre.length≤S := (list_length_le_weight pre).trans ((weight_prefix he).trans ha)
have hm:=weight_map_bound (f:=f) (as:=pre) (N:=p.eval S) (by
intro a hmem
have hh:=hp a
have ht:=polynomial_eval_monotone p ((weight_mem hmem).trans ((weight_prefix he).trans ha))
dsimp only at ht
omega)
have hfold : pre.foldl (fun bs a=>f a::bs) bs=(pre.map f).reverse++bs := by
simp [List.foldl_flip_cons_eq_append]
change weight (pre.foldl (fun bs a=>f a::bs) bs)≤_
rw [hfold]
have happ:=weight_append (pre.map f).reverse bs
rw [weight_reverse] at happ
simp only [Polynomial.eval_add,Polynomial.eval_mul,Polynomial.eval_X,Polynomial.eval_one]
change _≤S+S*(p.eval S+1)+1
nlinarith [Nat.mul_le_mul_right (p.eval S+1) hl]
omit [Codec A] in
lemma filter_fold (f : A → Bool) (as bs : List A) :
as.foldl (fun bs a=>if f a then a::bs else bs) bs=(as.filter f).reverse++bs := by
induction as generalizing bs with
| nil => rfl
| cons a as ih => cases hf:f a <;> simp [List.foldl_cons,hf,ih,List.append_assoc]
lemma polynomial_filter {f : A → Bool} {F : Realizer f} (hF : PolynomialTime F) :
PolynomialTime (filter F) := by
unfold filter
apply polynomial_congr
apply polynomial_composition _ polynomial_reverse
apply polynomial_composition (polynomial_pair polynomial_identity (polynomial_constant []))
apply polynomial_fold (polynomial_choose (polynomial_composition polynomial_first hF) polynomial_listCons polynomial_second) (2*X+1)
intro as bs pre post he
change weight (pre.foldl (fun bs a=>if f a then a::bs else bs) bs)≤_
rw [filter_fold]
have happ:=weight_append (pre.filter f).reverse bs
rw [weight_reverse] at happ
have hf:=weight_sublist (List.filter_sublist (p:=f) (l:=pre))
have hp:=weight_prefix he
simp only [Polynomial.eval_add,Polynomial.eval_mul,Polynomial.eval_ofNat,Polynomial.eval_X,weight_prod]
omega
lemma weight_bool_le (b : Bool) : weight b≤3 := by cases b <;> decide
lemma polynomial_any : PolynomialTime any := by
unfold any
apply polynomial_congr
apply polynomial_composition (polynomial_pair polynomial_identity (polynomial_constant false))
apply polynomial_fold (polynomial_choose polynomial_first (polynomial_constant true) polynomial_second) 3
intro as b pre post he
simpa using weight_bool_le (pre.foldl (fun z b=>if b then true else z) b)
lemma polynomial_membership : PolynomialTime membership := by
unfold membership
exact polynomial_congr _ (polynomial_composition
(polynomial_composition (polynomial_pair polynomial_second polynomial_first) (polynomial_mapWith polynomial_natEqual)) polynomial_any)
end MatchingFPRAS.TreeTyped
end OAI
|