File size: 6,731 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 | import Mathlib
import OAI.Combinatorics.MatchingCount.Machines.TreeList
namespace OAI
namespace MatchingFPRAS.TreeTyped
open TreeData TreeFunction Polynomial
variable {A B C : Type} [Codec A] [Codec B] [Codec C]
def weight (a : A) : ℕ := TreeFunction.size (encode a)
@[simp] lemma weight_prod (a : A) (b : B) : weight (a,b)=1+weight a+weight b := by simp [weight]; omega
@[simp] lemma weight_nil : weight ([] : List A)=1 := rfl
@[simp] lemma weight_cons (a : A) (as : List A) : weight (a::as)=1+weight a+weight as := by simp [weight]; omega
lemma weight_pos (a : A) : 0<weight a := by
change 0<TreeFunction.size (encode a)
cases encode a <;> simp only [size_nil,size_cons] <;> omega
lemma list_length_le_weight (as : List A) : as.length≤weight as := by
rw [weight,size_encode_list]; omega
lemma weight_mem {as : List A} {a : A} (ha : a∈as) : weight a≤weight as := size_encode_mem ha
lemma polynomial_eval_monotone (p : Polynomial ℕ) : Monotone (fun n=>p.eval n) := by
intro a b hab
simp only [Polynomial.eval_eq_sum,Polynomial.sum_def]
exact Finset.sum_le_sum (fun i _=>Nat.mul_le_mul_left _ (Nat.pow_le_pow_left hab i))
def PolynomialBound {f : A → B} (F : Realizer f) (p : Polynomial ℕ) : Prop :=
∀ a,F.cost a+weight (f a)≤p.eval (weight a)
def PolynomialTime {f : A → B} (F : Realizer f) : Prop := ∃ p,PolynomialBound F p
lemma polynomial_identity : PolynomialTime (identity (A:=A)) := by
refine ⟨X+1,?_⟩
intro a
simp [identity,weight,Polynomial.eval_add,Polynomial.eval_X, Nat.add_comm]
lemma polynomial_first : PolynomialTime (first (A:=A) (B:=B)) := by
refine ⟨7*X+11,?_⟩
intro ⟨a,b⟩
simp only [Polynomial.eval_add,Polynomial.eval_mul,Polynomial.eval_ofNat,Polynomial.eval_X,weight_prod]
change 6*weight a+weight b+11+weight a≤7*(1+weight a+weight b)+11
omega
lemma polynomial_second : PolynomialTime (second (A:=A) (B:=B)) := by
refine ⟨4*X+7,?_⟩
intro ⟨a,b⟩
simp only [Polynomial.eval_add,Polynomial.eval_mul,Polynomial.eval_ofNat,Polynomial.eval_X,weight_prod]
change 3*weight a+7+weight b≤4*(1+weight a+weight b)+7
omega
lemma polynomial_composition {f : A → B} {g : B → C} {F : Realizer f} {G : Realizer g}
(hF : PolynomialTime F) (hG : PolynomialTime G) : PolynomialTime (composition F G) := by
obtain ⟨p,hp⟩ := hF
obtain ⟨q,hq⟩ := hG
refine ⟨p+q.comp p,fun a=>?_⟩
have h1 := hp a
have h2 := hq (f a)
have h3 := polynomial_eval_monotone q (show weight (f a)≤p.eval (weight a) by omega)
simp only [Polynomial.eval_add,Polynomial.eval_comp]
change F.cost a+G.cost (f a)+weight (g (f a))≤_
dsimp only at h3
omega
lemma polynomial_pair {f : A → B} {g : A → C} {F : Realizer f} {G : Realizer g}
(hF : PolynomialTime F) (hG : PolynomialTime G) : PolynomialTime (pair F G) := by
obtain ⟨p,hp⟩ := hF
obtain ⟨q,hq⟩ := hG
refine ⟨7*p+q+11*X+32,fun a=>?_⟩
have h1 := hp a
have h2 := hq a
simp only [Polynomial.eval_add,Polynomial.eval_mul,Polynomial.eval_ofNat,Polynomial.eval_X]
rw [weight_prod]
change F.cost a+G.cost a+11*weight a+6*weight (f a)+31+(1+weight (f a)+weight (g a))≤_
omega
lemma polynomial_congr {f g : A → B} {F : Realizer f} (h : ∀ a,f a=g a)
(hF : PolynomialTime F) : PolynomialTime (F.congr h) := by
obtain ⟨p,hp⟩ := hF
exact ⟨p,fun a=>by simpa only [Realizer.congr,←h a] using hp a⟩
lemma polynomial_choose {f : A → Bool} {g h : A → B} {F : Realizer f} {G : Realizer g} {H : Realizer h}
(hF : PolynomialTime F) (hG : PolynomialTime G) (hH : PolynomialTime H) :
PolynomialTime (choose F G H) := by
obtain ⟨p,hp⟩ := hF
obtain ⟨q,hq⟩ := hG
obtain ⟨r,hr⟩ := hH
refine ⟨p+q+r+7*X+18,fun a=>?_⟩
have h1 := hp a
have h2 := hq a
have h3 := hr a
simp only [Polynomial.eval_add,Polynomial.eval_mul,Polynomial.eval_ofNat,Polynomial.eval_X]
change F.cost a+(if f a then G.cost a else H.cost a)+7*weight a+18+
weight (if f a then g a else h a)≤_
cases f a <;> simp only [Bool.false_eq_true,↓reduceIte] <;> omega
lemma polynomial_constantData (b : Data) : PolynomialTime (constantData (A:=A) b) := by
induction b with
| nil => refine ⟨X+3,fun a=>?_⟩; simp [constantData,weight,Codec.encode,size_nil]
| cons b c hb hc =>
obtain ⟨p,hp⟩ := polynomial_pair hb hc
exact ⟨p,hp⟩
lemma polynomial_constant (b : B) : PolynomialTime (constant (A:=A) b) :=
polynomial_constantData (encode b)
omit [Codec B] in
lemma Fold.cost_prefix_bound {f : A×B → B} (t : A×B → ℕ) (as : List A) (b : B) (T S : ℕ)
(hs : weight as≤S)
(hstep : ∀ pre a post,as=pre++a::post → t (a,pre.foldl (fun z c=>f (c,z)) b)≤T) :
Fold.cost f t as b≤as.length*(T+14*S+34)+10 := by
induction as generalizing b with
| nil => simp [Fold.cost]
| cons a as ih =>
have ht := hstep [] a as rfl
simp only [List.foldl_nil] at ht
have hs' : weight as≤S := by rw [weight_cons] at hs; omega
have hi := ih (f (a,b)) hs' (by
intro pre c post he
have hh := hstep (a::pre) c post (by simp only [List.cons_append,he])
exact hh)
simp only [Fold.cost,List.length_cons]
change t (a,b)+6*weight a+8*weight as+34+Fold.cost f t as (f (a,b))≤_
have ha : weight a≤S := by rw [weight_cons] at hs; omega
nlinarith
lemma polynomial_fold {f : A×B → B} {F : Realizer f} (hF : PolynomialTime F)
(p : Polynomial ℕ)
(hsize : ∀ (as : List A) (b : B) pre post,as=pre++post →
weight (pre.foldl (fun z a=>f (a,z)) b)≤p.eval (weight (as,b))) :
PolynomialTime (fold F) := by
obtain ⟨q,hq⟩ := hF
refine ⟨X*(q.comp (1+X+p)+14*X+34)+10+p,fun ⟨as,b⟩=>?_⟩
let S:=weight (as,b)
let T:=q.eval (1+S+p.eval S)
have hs : weight as≤S := by dsimp [S]; rw [weight_prod]; omega
have hc := Fold.cost_prefix_bound (f:=f) F.cost as b T S hs (by
intro pre a post he
have hz := hsize as b pre (a::post) he
change _≤p.eval S at hz
have ha : weight a≤S := (weight_mem (by simp [he])).trans hs
have hq' := hq (a,pre.foldl (fun z c=>f (c,z)) b)
have hm := polynomial_eval_monotone q (show weight (a,pre.foldl (fun z c=>f (c,z)) b)≤1+S+p.eval S by rw [weight_prod]; omega)
dsimp only at hm
dsimp only [T]
omega)
have hout := hsize as b as [] (by simp)
change _≤p.eval S at hout
have hlen : as.length≤S := (list_length_le_weight as).trans hs
simp only [Polynomial.eval_add,Polynomial.eval_mul,Polynomial.eval_ofNat,Polynomial.eval_X,Polynomial.eval_one,Polynomial.eval_comp]
change Fold.cost f F.cost as b+weight (as.foldl (fun z a=>f (a,z)) b)≤_
change _≤S*(T+14*S+34)+10+p.eval S
nlinarith
end MatchingFPRAS.TreeTyped
end OAI
|