| import Mathlib |
| import OAI.Combinatorics.MatchingCount.Machines.TreeSlotWeight |
|
|
| namespace OAI |
|
|
| namespace MatchingFPRAS.TreeFraction |
| lemma fold_sum_repr (xs : List ℚ) (hx : ∀ x∈xs,0≤x) (a : ℚ) (ha : 0≤a) : |
| ((xs.map repr).foldl (fun a b=>add (b,a)) (repr a))=repr (xs.sum+a) := by |
| induction xs generalizing a with |
| | nil => simp |
| | cons x xs ih => |
| have h : 0≤x:=hx x (by simp) |
| simp only [List.map_cons,List.foldl_cons,add_repr h ha] |
| rw [ih (fun y hy=>hx y (by simp [hy])) (x+a) (add_nonneg h ha)] |
| congr 1 |
| simp only [List.sum_cons] |
| ring |
| lemma sum_repr (xs : List ℚ) (hx : ∀ x∈xs,0≤x) : sum (xs.map repr)=repr xs.sum := by |
| unfold sum |
| have h:=fold_sum_repr xs hx 0 (by decide) |
| simpa only [add_zero,show repr (0:ℚ)=(0,1) from rfl] using h |
| end MatchingFPRAS.TreeFraction |
|
|
| namespace MatchingFPRAS.ExecutableEstimator |
| open TreeTyped TreeFraction |
|
|
| def mean (xs : List Fraction) : Fraction := div (sum xs,(xs.length,1)) |
| def meanRealizer : Realizer mean := composition |
| (pair sumRealizer (pair listLength (constant 1))) divRealizer |
| lemma polynomial_mean : PolynomialTime meanRealizer := by |
| unfold meanRealizer |
| apply polynomial_composition _ polynomial_div |
| exact polynomial_pair polynomial_sum (polynomial_pair polynomial_listLength (polynomial_constant _)) |
| lemma mean_rep (xs : List ℚ) (hx : ∀ x∈xs,0≤x) : |
| mean (xs.map TreeFraction.repr)=TreeFraction.repr (xs.sum/xs.length) := by |
| unfold mean |
| rw [sum_repr xs hx,List.length_map,←repr_nat xs.length,div_repr (List.sum_nonneg hx) (by positivity)] |
|
|
| def ratio (x : Fraction×Fraction) : Fraction := |
| if less ((0,1),x.1) then div (x.2,x.1) else (1,1) |
| def ratioRealizer : Realizer ratio := |
| (choose (composition (pair (constant (0,1)) first) lessRealizer) |
| (composition (pair second first) divRealizer) (constant (1,1))).congr (fun _=>rfl) |
| lemma polynomial_ratio : PolynomialTime ratioRealizer := by |
| unfold ratioRealizer |
| apply polynomial_congr |
| have := TreeFraction.polynomial_less |
| have := polynomial_div |
| tree_cost |
| lemma ratio_rep (a d : ℚ) (ha : 0≤a) (hd : 0≤d) : |
| ratio (TreeFraction.repr a,TreeFraction.repr d)=TreeFraction.repr (Counting.ratioEstimate a d) := by |
| unfold ratio Counting.ratioEstimate |
| rw [show ((0,1) : Fraction)=TreeFraction.repr (0:ℚ) from rfl, |
| less_val _ _ (by decide) a.pos,val_repr (by decide),val_repr ha] |
| simp only [decide_eq_true_eq] |
| split_ifs |
| · exact div_repr hd ha |
| · rfl |
|
|
| def upper (x : ℕ×(Fraction×Fraction)) : Fraction := |
| if less ((0,1),x.2.1) then |
| maximum ((1,100000),minimum ((3,1),add (div (mul ((x.1,1),x.2.2),x.2.1),(1,100000)))) |
| else (1,1) |
| def upperRealizer : Realizer upper := by |
| let q : Realizer (fun x : ℕ×(Fraction×Fraction)=> |
| div (mul ((x.1,1),x.2.2),x.2.1)) := |
| (composition (pair (composition (pair (pair first (constant 1)) second.snd) mulRealizer) second.fst) divRealizer).congr (fun _=>rfl) |
| exact (choose (composition (pair (constant (0,1)) second.fst) lessRealizer) |
| (composition (pair (constant (1,100000)) (composition (pair (constant (3,1)) |
| (composition (pair q (constant (1,100000))) addRealizer)) minimumRealizer)) maximumRealizer) |
| (constant (1,1))).congr (fun _=>rfl) |
| lemma polynomial_upper : PolynomialTime upperRealizer := by |
| unfold upperRealizer Realizer.fst Realizer.snd |
| dsimp only |
| apply polynomial_congr |
| have := TreeFraction.polynomial_less |
| have := polynomial_div |
| have := polynomial_mul |
| have := TreeFraction.polynomial_add |
| have := TreeFraction.polynomial_minimum |
| have := polynomial_maximum |
| tree_cost |
| lemma upper_rep (D : ℕ) (d z : ℚ) (hd : 0≤d) (hz : 0≤z) : |
| upper (D,(TreeFraction.repr d,TreeFraction.repr z))=TreeFraction.repr (Counting.upperEstimate D d z) := by |
| have ha : ((1,100000) : Fraction)=TreeFraction.repr Counting.alpha := by norm_num [TreeFraction.repr,Counting.alpha] |
| have ha0 : (0:ℚ)≤Counting.alpha := by norm_num [Counting.alpha] |
| have h0 : ((0,1) : Fraction)=TreeFraction.repr (0:ℚ) := rfl |
| have h3 : ((3,1) : Fraction)=TreeFraction.repr (3:ℚ) := rfl |
| unfold upper Counting.upperEstimate |
| rw [h0,less_val _ _ (by decide) d.pos,val_repr (by decide),val_repr hd] |
| simp only [decide_eq_true_eq] |
| split_ifs |
| · rw [ha,h3,←repr_nat D,mul_repr (by positivity) hz,div_repr (by positivity) hd, |
| add_repr (by positivity) ha0,minimum_repr (by decide) (by positivity),maximum_repr ha0 (by positivity)] |
| · rfl |
| end MatchingFPRAS.ExecutableEstimator |
|
|
| end OAI |
|
|
