math / data /lean /OAI /Combinatorics /MatchingCount /Complexity /TreePolynomial.lean
introvoyz045's picture
Migrated from GitHub
4a56cd6 verified
Raw History Blame Contribute Delete
6.73 kB
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