| import Mathlib |
| import OAI.Combinatorics.MatchingCount.Machines.TreeFinite |
|
|
| namespace OAI |
|
|
| namespace MatchingFPRAS.TreeTyped |
| open Polynomial |
|
|
| variable {A B C : Type} [Codec A] [Codec B] [Codec C] |
|
|
| def WorkBound {f : A → B} (F : Realizer f) (measure : A → ℕ) : Prop := |
| ∃ p : Polynomial ℕ, ∀ a,F.cost a+weight (f a)≤p.eval (measure a) |
|
|
| lemma work_of_polynomial {f : A → B} {F : Realizer f} (hF : PolynomialTime F) |
| {measure : A → ℕ} (p : Polynomial ℕ) (hp : ∀ a,weight a≤p.eval (measure a)) : WorkBound F measure := by |
| obtain ⟨q,hq⟩:=hF |
| exact ⟨q.comp p,fun a=>(hq a).trans (by simpa using polynomial_eval_monotone q (hp a))⟩ |
| lemma work_congr {f g : A → B} {F : Realizer f} {measure : A → ℕ} |
| (h : ∀ a,f a=g a) (hF : WorkBound F measure) : WorkBound (F.congr h) measure := by |
| obtain ⟨p,hp⟩:=hF |
| exact ⟨p,fun a=>by simpa only [Realizer.congr,←h a] using hp a⟩ |
| lemma work_composition {f : A → B} {g : B → C} {F : Realizer f} {G : Realizer g} |
| {measure : A → ℕ} {other : B → ℕ} |
| (hF : WorkBound F measure) (hG : WorkBound G other) (p : Polynomial ℕ) |
| (hm : ∀ a,other (f a)≤p.eval (measure a)) : WorkBound (composition F G) measure := by |
| obtain ⟨q,hq⟩:=hF |
| obtain ⟨r,hr⟩:=hG |
| refine ⟨q+r.comp p,fun a=>?_⟩ |
| have h1:=hq a |
| have h2:=hr (f a) |
| have h3:=polynomial_eval_monotone r (hm a) |
| 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 work_then_polynomial {f : A → B} {g : B → C} {F : Realizer f} {G : Realizer g} |
| {measure : A → ℕ} (hF : WorkBound F measure) (hG : PolynomialTime G) : |
| WorkBound (composition F G) measure := by |
| obtain ⟨p,hp⟩:=hF |
| exact work_composition ⟨p,hp⟩ hG p (fun a=>Nat.le_trans (Nat.le_add_left _ _) (hp a)) |
| lemma work_remeasure {f : A → B} {F : Realizer f} {measure other : A → ℕ} |
| (hF : WorkBound F measure) (p : Polynomial ℕ) (hm : ∀ a,measure a≤p.eval (other a)) : |
| WorkBound F other := by |
| obtain ⟨q,hq⟩:=hF |
| exact ⟨q.comp p,fun a=>(hq a).trans (by simpa using polynomial_eval_monotone q (hm a))⟩ |
|
|
| lemma work_boundedRepeat {init : A → ℕ×B} {f : ℕ×B → B} |
| {Init : Realizer init} {F : Realizer f} {measure : A → ℕ} |
| (hInit : WorkBound Init measure) (hF : PolynomialTime F) |
| (p q : Polynomial ℕ) (I : A → ℕ → B → Prop) |
| (hn : ∀ a,(init a).1≤p.eval (measure a)) |
| (hi : ∀ a,I a (init a).1 (init a).2) |
| (hs : ∀ a k,(k<(init a).1) → ∀ z,I a (k+1) z → I a k (f (k+1,z))) |
| (hw : ∀ a k z,I a k z → weight z≤q.eval (measure a)) : |
| WorkBound (composition Init (iterateDown F)) measure := by |
| obtain ⟨r,hr⟩:=hInit |
| obtain ⟨t,ht⟩:=polynomial_repeatNext hF |
| refine ⟨r+p*(t.comp (2+4*p+q)+4*(4*p+1)+12)+10+q,fun a=>?_⟩ |
| let S:=measure a |
| let N:=(init a).1 |
| let T:=t.eval (2+4*p.eval S+q.eval S) |
| have hN : N≤p.eval S:=hn a |
| have hsz : ∀ k<N,weight (k+1)≤4*p.eval S+1 := by |
| intro k hk |
| have hh:=weight_nat_le (k+1) |
| have hbit : (k+1).size≤k+1 := Nat.size_le.mpr Nat.lt_two_pow_self |
| omega |
| have hc:=Repeat.cost_bound (f:=f) (Repeat.nextRealizer F).cost (I a) N (init a).2 |
| T (4*p.eval S+1) (hi a) (by |
| intro k hk z hz |
| refine ⟨hs a k hk z hz,?_⟩ |
| have h1:=ht (k+1,z) |
| have h2:=hsz k hk |
| have h3:=hw a (k+1) z hz |
| change weight z≤q.eval S at h3 |
| have h4:=polynomial_eval_monotone t (show weight (k+1,z)≤2+4*p.eval S+q.eval S by rw [weight_prod]; omega) |
| dsimp only at h4 |
| dsimp only [T] |
| omega) hsz |
| have hout:=hw a 0 (countDown f N (init a).2) |
| (countDown_invariant (I a) (hi a) (hs a)) |
| have hinit:=hr a |
| change _≤r.eval S at hinit |
| simp only [Polynomial.eval_add,Polynomial.eval_mul,Polynomial.eval_ofNat,Polynomial.eval_one, |
| Polynomial.eval_comp] |
| change Init.cost a+Repeat.cost f (Repeat.nextRealizer F).cost N (init a).2+ |
| weight (countDown f N (init a).2)≤r.eval S+p.eval S*(T+4*(4*p.eval S+1)+12)+10+q.eval S |
| change _≤q.eval S at hout |
| have hm:=Nat.mul_le_mul_right (T+4*(4*p.eval S+1)+12) hN |
| omega |
|
|
| lemma weight_nat_numeric (n : ℕ) : weight n≤4*n+1 := by |
| have h:=weight_nat_le n |
| have hn : n.size≤n := Nat.size_le.mpr Nat.lt_two_pow_self |
| omega |
| lemma polynomial_successor : PolynomialTime successor := |
| polynomial_congr _ (polynomial_composition (polynomial_pair polynomial_identity (polynomial_constant 1)) polynomial_add) |
| lemma polynomial_rangeStep : PolynomialTime rangeStepRealizer := |
| polynomial_composition (polynomial_pair (polynomial_composition polynomial_first polynomial_predecessor) polynomial_second) polynomial_listCons |
|
|
| lemma range_numeric_work : WorkBound range id := by |
| unfold range |
| apply work_congr |
| apply work_boundedRepeat (work_of_polynomial (polynomial_pair polynomial_identity (polynomial_constant [])) |
| (4*X+1) (fun n=>by simpa using weight_nat_numeric n)) polynomial_rangeStep X (4*X^2+2*X+1) |
| (fun n k zs=>zs.length+k=n ∧ ∀ z∈zs,z<n) |
| · intro n; simp |
| · intro n; simp |
| · intro n k hk zs hz |
| change k<n at hk |
| change ((k+1-1)::zs).length+k=n ∧ ∀ z∈((k+1-1)::zs),z<n |
| simp only [Nat.add_sub_cancel,List.length_cons,List.mem_cons] |
| constructor |
| · omega |
| · intro z h |
| rcases h with rfl | h |
| · exact hk |
| · exact hz.2 z h |
| · intro n k zs hz |
| have hh:=weight_map_bound (as:=zs) (f:=id) (N:=4*n+1) (by |
| intro z h |
| exact (weight_nat_numeric z).trans (by have :=hz.2 z h; omega)) |
| simp only [List.map_id] at hh |
| have hlen:zs.length≤n:=by omega |
| have hm:=Nat.mul_le_mul_right (4*n+2) hlen |
| simp only [Polynomial.eval_add,Polynomial.eval_mul,Polynomial.eval_ofNat,Polynomial.eval_X,Polynomial.eval_pow,Polynomial.eval_one,id_eq] |
| nlinarith |
|
|
| lemma polynomial_boundedRange {f : A → ℕ} {F : Realizer f} (hF : PolynomialTime F) |
| (p : Polynomial ℕ) (hn : ∀ a,f a≤p.eval (weight a)) : PolynomialTime (composition F range) := |
| work_composition hF range_numeric_work p hn |
|
|
| end MatchingFPRAS.TreeTyped |
|
|
| end OAI |
|
|
