| import Mathlib |
| import OAI.Combinatorics.MatchingCount.Machines.OnlineTraverse |
| import OAI.Combinatorics.MatchingCount.Complexity.OnlineFrameCost |
| import OAI.Combinatorics.MatchingCount.Complexity.OnlineFoldCost |
|
|
| namespace OAI |
|
|
| namespace MatchingFPRAS.OnlineTree |
| open TreeTyped PhysicalStream Polynomial |
|
|
| variable {A B : Type} [Codec A] [Codec B] |
| lemma collectStep_cost {f : A→Experiment B} (F : Realizer f) (a : A) (bs : List B) : |
| (collectStepRealizer F).cost (a,bs)=F.cost a+54*weight a+46*weight bs+ |
| 26*(f a).worst weight+201 := by |
| change (pair (composition (deterministic TreeTyped.first) F) (deterministic TreeTyped.second)).cost (a,bs)+ |
| (((f a).bind (fun b=>Experiment.done (b,bs))).worst (fun _=>1))=_ |
| rw [pair_cost,Experiment.worst_const] |
| simp only [composition,deterministic,TreeTyped.first,TreeTyped.second,Experiment.worst, |
| Experiment.bind,weight_prod] |
| change (6*weight a+weight bs+11+F.cost a)+(3*weight a+7)+45*(1+weight a+weight bs)+ |
| 26*(f a).worst weight+137+1=_ |
| omega |
|
|
| lemma traverse_bound {f : A→Experiment B} (F : Realizer f) : |
| ∃ p : Polynomial ℕ,∀ as M,weight as≤M→(∀ a∈as,F.cost a+(f a).worst weight≤M)→ |
| (traverse F).cost as+(traverseM f as).worst weight≤p.eval M := by |
| obtain ⟨q,hq⟩:=TreeTyped.polynomial_pair (TreeTyped.polynomial_identity (A:=List A)) |
| (TreeTyped.polynomial_constant ([] : List B)) |
| obtain ⟨r,hr⟩:=TreeTyped.polynomial_reverse (A:=B) |
| let H : Polynomial ℕ := X*(X+1)+1 |
| let D : Polynomial ℕ := 27*X+54*X+46*H+201 |
| refine ⟨q+X*(D+14*X+34)+10+r.comp H+H,?_⟩ |
| intro as M hw ht |
| have hl : as.length≤M := (list_length_le_weight as).trans hw |
| have hH : H.eval M=M*(M+1)+1 := by simp [H] |
| have hD : D.eval M=27*M+54*M+46*H.eval M+201 := by simp [D] |
| have hf := fold_cost_bound (collectStep f) (collectStepRealizer F).cost as ([] : List B) |
| (fun k bs=>weight bs+k*(M+1)≤as.length*(M+1)+1) (D.eval M) M |
| (by simp; omega) hw |
| (by |
| intro a ha k _bounded bs hb |
| rw [collectStep,Experiment.all_map] |
| exact (Experiment.all_worst (f a) weight).mono (fun c hc=>by |
| have hc':=ht a ha |
| simp only [weight_cons,Nat.add_mul,Nat.one_mul] at * |
| omega)) |
| (by |
| intro a ha k _bounded bs hb |
| rw [collectStep_cost] |
| have ha':=(weight_mem ha).trans hw |
| have hc':=ht a ha |
| have hmul:=Nat.mul_le_mul_right (M+1) hl |
| rw [hD,hH] |
| omega) |
| have hout : (foldM (collectStep f) as []).All (fun bs=>weight bs≤H.eval M) := |
| hf.2.mono (fun bs hb=>by |
| have hmul:=Nat.mul_le_mul_right (M+1) hl |
| rw [hH];simp only [Nat.zero_mul,Nat.add_zero] at hb;omega) |
| have hrev : (foldM (collectStep f) as []).worst TreeTyped.reverse.cost≤r.eval (H.eval M) := by |
| apply Experiment.worst_le _ _ _ |
| exact hout.mono (fun bs hb=>(Nat.le_add_right _ _).trans |
| ((hr bs).trans (polynomial_eval_monotone r hb))) |
| have hfinal : (traverseM f as).worst weight≤H.eval M := by |
| apply Experiment.worst_le _ _ _ |
| apply Experiment.all_of_mean_eq (p:=(foldM (collectStep f) as []).map List.reverse) |
| (fun h=>by |
| rw [Experiment.mean_map,mean_fold_collect] |
| simp only [List.append_nil,List.reverse_reverse]) _ |
| rw [Experiment.all_map] |
| exact hout.mono (fun bs hb=>by simpa only [weight_reverse] using hb) |
| have hpre:=(hq as).trans (polynomial_eval_monotone q hw) |
| dsimp only at hpre |
| have hmul:=Nat.mul_le_mul_right (D.eval M+14*M+34) hl |
| change (TreeTyped.pair TreeTyped.identity (TreeTyped.constant ([] : List B))).cost as+ |
| Fold.cost (collectStep f) (collectStepRealizer F).cost as []+ |
| (foldM (collectStep f) as []).worst TreeTyped.reverse.cost+(traverseM f as).worst weight≤_ |
| simp only [Polynomial.eval_add,Polynomial.eval_mul,Polynomial.eval_X,Polynomial.eval_ofNat,Polynomial.eval_comp] |
| omega |
|
|
| lemma work_traverse {f : A→Experiment B} {F : Realizer f} {m : A→ℕ} {n : List A→ℕ} |
| (hF : WorkBound F m) (p q : Polynomial ℕ) |
| (hw : ∀ as,weight as≤p.eval (n as)) (hm : ∀ as,∀ a∈as,m a≤q.eval (n as)) : |
| WorkBound (traverse F) n := by |
| obtain ⟨r,hr⟩:=hF |
| obtain ⟨s,hs⟩:=traverse_bound F |
| refine ⟨s.comp (p+r.comp q),fun as=>?_⟩ |
| simp only [Polynomial.eval_comp,Polynomial.eval_add] |
| apply hs |
| · exact (hw as).trans (Nat.le_add_right _ _) |
| · intro a ha |
| exact ((hr a).trans (polynomial_eval_monotone r (hm as a ha))).trans (Nat.le_add_left _ _) |
| lemma polynomial_traverse {f : A→Experiment B} {F : Realizer f} (hF : PolynomialTime F) : |
| PolynomialTime (traverse F) := work_traverse hF X X (by simp) (by intro as a ha;simpa using weight_mem ha) |
| end MatchingFPRAS.OnlineTree |
| |
| end OAI |
| |
