| 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 |
|
|
