openAI-math-dataset / lean /OAI /Combinatorics /MatchingCount /Complexity /TreePolynomialCollections.lean
| 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 | |