| import Mathlib |
| import OAI.Combinatorics.MatchingCount.Sampling.EndpointPair |
|
|
| namespace OAI |
|
|
| namespace MatchingFPRAS.Transport |
|
|
| variable {V E : Type*} [Fintype V] [DecidableEq V] [Fintype E] [DecidableEq E] |
|
|
| variable {inc : E → V → Prop} |
|
|
| omit [DecidableEq V] [Fintype E] [DecidableEq E] in |
| lemma switch_denominator_bound (hinc : ∀ e, ∃ v, inc e v) (A : PM inc) : |
| 48 * (A.val.card.choose 2 : ℝ) ≤ 60 * (Fintype.card V : ℝ)^2 := by |
| have hm := A.card_le_vertices hinc |
| have hc : A.val.card.choose 2 ≤ (Fintype.card V)^2 := |
| (Nat.choose_le_pow _ _).trans (Nat.pow_le_pow_left hm 2) |
| have hc' : (A.val.card.choose 2 : ℝ) ≤ (Fintype.card V : ℝ)^2 := by exact_mod_cast hc |
| nlinarith [sq_nonneg (Fintype.card V : ℝ)] |
|
|
| omit [DecidableEq V] in |
| lemma safe_switch_elementary (hinc : ∀ e, ∃ v, inc e v) |
| (w : E → ℝ) (hw : ∀ e, 0 < w e) (K : ℝ) (hK : 1 ≤ K) (f : Finset E → ℝ) : |
| (∑ A : PM inc, gibbs w A * ∑ B ∈ safeDestinations w K A, (f A.val-f B.val)^2) ≤ |
| 60 * (Fintype.card V : ℝ)^2 * K^2 * switchDirichlet (inc := inc) w f := by |
| classical |
| simp only [switchDirichlet,Finset.mul_sum] |
| apply Finset.sum_le_sum |
| intro A _ |
| let term (B : PM inc) := 60*(Fintype.card V : ℝ)^2*K^2 * |
| (min (gibbs w A) (gibbs w B)*(f A.val-f B.val)^2 / (48*(A.val.card.choose 2 : ℝ))) |
| change (∑ B ∈ safeDestinations w K A, gibbs w A*(f A.val-f B.val)^2) ≤ |
| ∑ B ∈ switchDestinations A, term B |
| calc |
| _ ≤ ∑ B ∈ safeDestinations w K A, term B := by |
| apply Finset.sum_le_sum |
| intro B hB |
| have h : SafeSwitch w K A B := (Finset.mem_filter.mp hB).2 |
| have hd : 0 < 48 * (A.val.card.choose 2 : ℝ) := by |
| have hc : 0 < A.val.card.choose 2 := Nat.choose_pos h.legal.two_le |
| positivity |
| have hn : 0 ≤ min (gibbs w A) (gibbs w B) * (f A.val-f B.val)^2 := |
| mul_nonneg (le_min (le_of_lt (gibbs_pos w hw A)) (le_of_lt (gibbs_pos w hw B))) (sq_nonneg _) |
| have h₁ := mul_le_mul_of_nonneg_right (h.min_capacity hw hK) (sq_nonneg (f A.val-f B.val)) |
| have h₂ := mul_le_mul_of_nonneg_left (scale_div_lower hn hd (switch_denominator_bound hinc A)) (sq_nonneg K) |
| dsimp only [term] |
| nlinarith only [h₁,h₂] |
| _ ≤ _ := by |
| apply Finset.sum_le_sum_of_subset_of_nonneg |
| · intro B hB |
| have h : SafeSwitch w K A B := (Finset.mem_filter.mp hB).2 |
| exact Finset.mem_filter.mpr ⟨Finset.mem_univ _,h.legal⟩ |
| · intro B _ _ |
| have ha := le_of_lt (gibbs_pos w hw A) |
| have hb := le_of_lt (gibbs_pos w hw B) |
| dsimp only [term] |
| positivity |
|
|
| variable (ends : E → Sym2 V) |
|
|
| omit [DecidableEq V] [Fintype E] in |
| lemma ColorChange.card_pos {A B : PM (fun e v => v ∈ ends e)} (h : ColorChange ends A B) : |
| 0 < A.val.card := by |
| obtain ⟨e,f,R,hef,hA,hB⟩ := h |
| exact Finset.card_pos.mpr ⟨e,by rw [hA]; simp⟩ |
| |
| omit [DecidableEq V] in |
| lemma color_elementary (w : E → ℝ) (hw : ∀ e, 0 < w e) (K : ℝ) (hK : 1 ≤ K) |
| (hcomp : ∀ e f, ends e = ends f → w e ≤ K*w f) (f : Finset E → ℝ) : |
| (∑ A : PM (fun e v => v ∈ ends e), gibbs w A * |
| ∑ B ∈ colorDestinations ends A, (f A.val-f B.val)^2) ≤ |
| 12 * (Fintype.card V : ℝ) * K * colorDirichlet ends w f := by |
| classical |
| have hinc (e : E) : ∃ v, v ∈ ends e := by |
| induction ends e using Sym2.inductionOn with | hf a b => exact ⟨a,by simp⟩ |
| simp only [colorDirichlet,Finset.mul_sum] |
| apply Finset.sum_le_sum |
| intro A _ |
| apply Finset.sum_le_sum |
| intro B hB |
| have h : ColorChange ends A B := (Finset.mem_filter.mp hB).2 |
| have hd : 0 < 12 * (A.val.card : ℝ) := by have := h.card_pos ends; positivity |
| have hb : 12 * (A.val.card : ℝ) ≤ 12 * (Fintype.card V : ℝ) := by |
| exact_mod_cast (Nat.mul_le_mul_left 12 (A.card_le_vertices hinc)) |
| have hn : 0 ≤ min (gibbs w A) (gibbs w B) * (f A.val-f B.val)^2 := |
| mul_nonneg (le_min (le_of_lt (gibbs_pos w hw A)) (le_of_lt (gibbs_pos w hw B))) (sq_nonneg _) |
| have h₁ := mul_le_mul_of_nonneg_right (h.min_capacity ends hw hK hcomp) (sq_nonneg (f A.val-f B.val)) |
| have h₂ := mul_le_mul_of_nonneg_left (scale_div_lower hn hd hb) (by linarith : 0 ≤ K) |
| nlinarith only [h₁,h₂] |
|
|
| omit [Fintype E] in |
| lemma cycleSquare_common (f g : Finset E → ℝ) (A B S : Finset E) (hS : S ⊆ A ∩ B) : |
| cycleSquare f g A B S = 0 := by |
| have hSA : S ⊆ A := fun e he => (Finset.mem_inter.mp (hS he)).1 |
| have hSB : S ⊆ B := fun e he => (Finset.mem_inter.mp (hS he)).2 |
| simp only [cycleSquare,exchange,Finset.inter_eq_right.mpr hSA,Finset.inter_eq_right.mpr hSB, |
| Finset.sdiff_union_of_subset hSA,Finset.sdiff_union_of_subset hSB,sub_self,zero_pow (by decide : 2 ≠ 0)] |
|
|
| omit [DecidableEq V] [Fintype E] in |
| lemma all_cycleSquare_sum (f g : Finset E → ℝ) (A B : PM inc) : |
| (∑ S ∈ components (inc := inc) (A.val ∪ B.val), cycleSquare f g A.val B.val S) = |
| ∑ S ∈ discrepancyComponents A B, cycleSquare f g A.val B.val S := by |
| classical |
| apply (Finset.sum_subset (Finset.filter_subset _ _) ?_).symm |
| intro S hS hnot |
| have hcommon : S ⊆ A.val ∩ B.val := by |
| by_contra h |
| exact hnot (Finset.mem_filter.mpr ⟨hS,h⟩) |
| exact cycleSquare_common f g _ _ _ hcommon |
|
|
| omit [DecidableEq V] in |
| lemma cycle_elementary (hinc : ∀ e, ∃ v, inc e v) |
| (w : E → ℝ) (hw : ∀ e, 0 < w e) (f g : Finset E → ℝ) : |
| (∑ A : PM inc, ∑ B : PM inc, gibbs w A * gibbs w B * |
| ∑ S ∈ components (inc := inc) (A.val ∪ B.val), cycleSquare f g A.val B.val S) ≤ |
| 6 * (Fintype.card V : ℝ) * cycleDirichlet (inc := inc) w f g := by |
| classical |
| simp only [cycleDirichlet,Finset.mul_sum] |
| apply Finset.sum_le_sum |
| intro A _ |
| apply Finset.sum_le_sum |
| intro B _ |
| rw [← Finset.mul_sum,all_cycleSquare_sum,Finset.mul_sum] |
| apply Finset.sum_le_sum |
| intro S hS |
| have hcard : 0 < (discrepancyComponents A B).card := Finset.card_pos.mpr ⟨S,hS⟩ |
| have hd : (discrepancyComponents A B).card ≤ Fintype.card V := |
| (Finset.card_filter_le _ _).trans (components_card_le hinc _) |
| have hb : 6 * ((discrepancyComponents A B).card : ℝ) ≤ 6 * (Fintype.card V : ℝ) := by exact_mod_cast Nat.mul_le_mul_left 6 hd |
| have hscale := scale_div_lower (sq_nonneg ((f A.val+g B.val)-(f (exchange A.val B.val S)+g (exchange B.val A.val S)))) |
| (by positivity : 0 < 6 * ((discrepancyComponents A B).card : ℝ)) hb |
| have h := mul_le_mul_of_nonneg_left hscale |
| (mul_nonneg (le_of_lt (gibbs_pos w hw A)) (le_of_lt (gibbs_pos w hw B))) |
| dsimp only [cycleSquare] at * |
| nlinarith only [h] |
|
|
| end MatchingFPRAS.Transport |
|
|
| namespace MatchingFPRAS.FiniteVariance |
|
|
| variable {Ω : Type*} [Fintype Ω] |
|
|
| noncomputable def variance (π f : Ω → ℝ) : ℝ := |
| ∑ x, π x * (f x - ∑ y, π y * f y)^2 |
|
|
| lemma variance_eq_pair (π f : Ω → ℝ) (hπ : ∑ x, π x = 1) : |
| variance π f = (∑ p : Ω × Ω, π p.1 * π p.2 * (f p.1-f p.2)^2) / 2 := by |
| let m := ∑ y, π y * f y |
| let s := ∑ y, π y * f y ^ 2 |
| have hl : variance π f = s-m^2 := by |
| unfold variance |
| change (∑ x, π x * (f x-m)^2) = s-m^2 |
| calc |
| _ = ∑ x, (π x * f x^2 - 2*m*(π x*f x) + m^2*π x) := by |
| apply Finset.sum_congr rfl |
| intro x _ |
| ring |
| _ = s-m^2 := by |
| rw [Finset.sum_add_distrib,Finset.sum_sub_distrib,← Finset.mul_sum,← Finset.mul_sum,hπ] |
| change s-2*m*m+m^2*1 = s-m^2 |
| ring |
| have hr : (∑ p : Ω × Ω, π p.1 * π p.2 * (f p.1-f p.2)^2) = 2*(s-m^2) := by |
| rw [Fintype.sum_prod_type] |
| have hin (x : Ω) : (∑ y, π x*π y*(f x-f y)^2) = π x*f x^2-2*m*(π x*f x)+s*π x := by |
| calc |
| _ = ∑ y, ((π x*f x^2)*π y - (2*π x*f x)*(π y*f y) + π x*(π y*f y^2)) := by |
| apply Finset.sum_congr rfl |
| intro y _ |
| ring |
| _ = _ := by |
| rw [Finset.sum_add_distrib,Finset.sum_sub_distrib,← Finset.mul_sum,← Finset.mul_sum,← Finset.mul_sum,hπ] |
| change (π x*f x^2)*1-(2*π x*f x)*m+π x*s = _ |
| ring |
| simp_rw [hin] |
| rw [Finset.sum_add_distrib,Finset.sum_sub_distrib,← Finset.mul_sum,← Finset.mul_sum,hπ] |
| change s-2*m*m+s*1 = 2*(s-m^2) |
| ring |
| rw [hl,hr] |
| ring |
|
|
| end MatchingFPRAS.FiniteVariance |
|
|
| namespace MatchingFPRAS |
|
|
| lemma energy_coefficient_bound {N D T : ℝ} (hN1 : 1 ≤ N) (hD : 1 ≤ D) |
| (hT0 : 0 ≤ T) (htag : T ≤ (10*N)^30) : |
| 180*N^5*(1000*D)^6*T+72*N^4*(1000*D)^4*T+12*N^3*(1000*D) ≤ |
| ((10^4 : ℝ)*N*D)^100 := by |
| let K := 1000*D |
| have hK : 1 ≤ K := by dsimp [K]; linarith |
| have hN0 : 0 ≤ N := by linarith |
| have hDN : N ≤ N*D := by nlinarith [mul_nonneg hN0 (sub_nonneg.mpr hD)] |
| have hDD : D ≤ N*D := by nlinarith [mul_nonneg (sub_nonneg.mpr hN1) (le_trans (by norm_num : (0:ℝ) ≤ 1) hD)] |
| let B := (10^4 : ℝ)*N*D |
| have hB : 3 ≤ B := by dsimp [B]; nlinarith |
| have hNB : N ≤ B := by dsimp [B]; nlinarith |
| have hKB : K ≤ B := by dsimp [B,K]; nlinarith |
| have h10NB : 10*N ≤ B := by dsimp [B]; nlinarith |
| have hTB : T ≤ B^30 := htag.trans (by gcongr) |
| have h180 : (180:ℝ) ≤ B := by dsimp [B]; nlinarith |
| have h72 : (72:ℝ) ≤ B := by linarith |
| have h12 : (12:ℝ) ≤ B := by linarith |
| have hb0 : 0 ≤ B := by linarith |
| have hterm1 : 180*N^5*K^6*T ≤ B^42 := by |
| calc |
| _ ≤ B*B^5*B^6*B^30 := by gcongr |
| _ = _ := by ring |
| have hterm2 : 72*N^4*K^4*T ≤ B^39 := by |
| calc |
| _ ≤ B*B^4*B^4*B^30 := by gcongr |
| _ = _ := by ring |
| have hterm3 : 12*N^3*K ≤ B^5 := by |
| calc |
| _ ≤ B*B^3*B := by gcongr |
| _ = _ := by ring |
| have hp39 : B^39 ≤ B^42 := pow_le_pow_right₀ (by linarith : 1 ≤ B) (by omega) |
| have hp5 : B^5 ≤ B^42 := pow_le_pow_right₀ (by linarith : 1 ≤ B) (by omega) |
| have hcoef : 180*N^5*K^6*T+72*N^4*K^4*T+12*N^3*K ≤ B^100 := by |
| calc |
| _ ≤ 3*B^42 := by linarith |
| _ ≤ B*B^42 := mul_le_mul_of_nonneg_right hB (pow_nonneg hb0 _) |
| _ = B^43 := by ring |
| _ ≤ B^100 := pow_le_pow_right₀ (by linarith : 1 ≤ B) (by omega) |
| exact hcoef |
|
|
| end MatchingFPRAS |
|
|
| namespace MatchingFPRAS.Transport.CellDemands |
|
|
| variable {V L : Type*} [Fintype V] [DecidableEq V] [Fintype L] [DecidableEq L] |
|
|
| variable {bags : V → Finset L} {G : SimpleGraph L} |
|
|
| noncomputable local instance : Fintype (BagEdge bags) := Fintype.ofFinite _ |
|
|
| variable {hbags : ∀ v, ∀ a ∈ bags v, ∀ b ∈ bags v, a = b ∨ G.Adj a b} |
|
|
| variable {hG : G.IsAcyclic} |
|
|
| variable (height : L → ℝ) (hheight : ∀ l, 0 < height l) |
|
|
| variable (hstep : ∀ a b, G.Adj a b → height a ≤ 2 * height b) |
|
|
| variable (D : ℝ) (hD : 1 ≤ D) (w : BagEdge bags → ℝ) |
|
|
| variable (hw : ∀ e, height e.color / D ≤ w e ∧ w e ≤ 3 * height e.color) |
|
|
| variable (lo hi : ℝ) (hlo : 0 < lo) (hlohi : lo ≤ hi) |
|
|
| include hheight hstep hD hw hlo hlohi hbags hG |
|
|
| theorem pair_energy_inequality (hN : 2 ≤ Fintype.card V) |
| (M : PM (BagEdge.Incident (bags := bags))) (f g : Finset (BagEdge bags) → ℝ) : |
| let wt := fun e => max lo (min hi (w e)) |
| MatchingFPRAS.FiniteVariance.variance (gibbs (inc := BagEdge.Incident) wt) (fun A => f A.val) ≤ |
| ((10^4 : ℝ) * Fintype.card V * D)^100 * |
| pairDirichlet (fun e : BagEdge bags => e.val.val.1) wt f g := by |
| classical |
| let wt := fun e => max lo (min hi (w e)) |
| have hwt (e : BagEdge bags) : 0 < wt e := lt_of_lt_of_le hlo (le_max_left _ _) |
| let N : ℝ := Fintype.card V |
| let K : ℝ := 1000*D |
| let T : ℝ := Fintype.card (DemandTag (V := V) (E := BagEdge bags)) |
| let E := pairDirichlet (fun e : BagEdge bags => e.val.val.1) wt f g |
| have hK : 1 ≤ K := by dsimp [K]; linarith |
| have hN0 : 0 ≤ N := Nat.cast_nonneg _ |
| have hE : 0 ≤ E := by |
| exact add_nonneg (add_nonneg (switchDirichlet_nonneg wt hwt f) |
| (colorDirichlet_nonneg _ wt hwt f)) (cycleDirichlet_nonneg wt hwt f g) |
| have hsE : switchDirichlet (inc := BagEdge.Incident) wt f ≤ E := |
| (le_add_of_nonneg_right (colorDirichlet_nonneg (fun e : BagEdge bags => e.val.val.1) wt hwt f)).trans |
| (le_add_of_nonneg_right (cycleDirichlet_nonneg wt hwt f g)) |
| have hcE : colorDirichlet (fun e : BagEdge bags => e.val.val.1) wt f ≤ E := |
| (le_add_of_nonneg_left (switchDirichlet_nonneg (inc := BagEdge.Incident) wt hwt f)).trans |
| (le_add_of_nonneg_right (cycleDirichlet_nonneg wt hwt f g)) |
| have hyE : cycleDirichlet (inc := BagEdge.Incident) wt f g ≤ E := |
| le_add_of_nonneg_left (add_nonneg (switchDirichlet_nonneg wt hwt f) |
| (colorDirichlet_nonneg (fun e : BagEdge bags => e.val.val.1) wt hwt f)) |
| have hs := (safe_switch_elementary BagEdge.exists_incident wt hwt K hK f).trans |
| (mul_le_mul_of_nonneg_left hsE (by positivity : 0 ≤ 60*N^2*K^2)) |
| have hc := (color_elementary (fun e : BagEdge bags => e.val.val.1) wt hwt K hK |
| (color_clamp_comparability hbags height hheight hstep D hD w hw lo hi hlo) f).trans |
| (mul_le_mul_of_nonneg_left hcE (by positivity : 0 ≤ 12*N*K)) |
| have hy := (cycle_elementary BagEdge.exists_incident wt hwt f g).trans |
| (mul_le_mul_of_nonneg_left hyE (by positivity : 0 ≤ 6*N)) |
| have hl := total_cell_demand_load (hbags := hbags) (hG := hG) height hheight hstep D hD w hw lo hi hlo hlohi M f g |
| change (∑ d : Demand hbags hG, gibbs wt d.1.1 * gibbs wt d.1.2 * d.cellCost f) ≤ |
| K^4*T*((∑ A : PM BagEdge.Incident, gibbs wt A * |
| ∑ B ∈ safeDestinations wt K A, (f A.val-f B.val)^2) + 4* |
| ∑ A : PM BagEdge.Incident, ∑ B : PM BagEdge.Incident, gibbs wt A*gibbs wt B* |
| ∑ S ∈ components (inc := BagEdge.Incident) (A.val∪B.val), cycleSquare f g A.val B.val S) at hl |
| have hload := hl.trans (mul_le_mul_of_nonneg_left (add_le_add hs (mul_le_mul_of_nonneg_left hy (by norm_num))) |
| (by dsimp [T]; positivity : 0 ≤ K^4*T)) |
| have hv := variance_cell_demand_bound (hbags := hbags) (hG := hG) wt hwt M f |
| have hvar := hv.trans (add_le_add (mul_le_mul_of_nonneg_left hload (by positivity : 0 ≤ 3*N^3)) |
| (mul_le_mul_of_nonneg_left hc (by positivity : 0 ≤ N^2))) |
| have hraw : MatchingFPRAS.FiniteVariance.variance (gibbs (inc := BagEdge.Incident) wt) (fun A => f A.val) ≤ |
| (180*N^5*K^6*T+72*N^4*K^4*T+12*N^3*K)*E := by |
| rw [MatchingFPRAS.FiniteVariance.variance_eq_pair _ _ (gibbs_sum wt hwt M)] |
| calc |
| _ ≤ _ := hvar |
| _ = _ := by ring |
| have htag : T ≤ (10*N)^30 := by |
| have h := tag_card_bound (V := V) (E := BagEdge bags) (Fintype.card V) hN le_rfl (bag_edges_card_le hbags hG) |
| dsimp only [T,N] |
| exact_mod_cast h |
| have hT0 : 0 ≤ T := Nat.cast_nonneg _ |
| have hN1 : 1 ≤ N := by dsimp [N]; exact_mod_cast (show 1 ≤ Fintype.card V by omega) |
| have hcoef := MatchingFPRAS.energy_coefficient_bound hN1 hD hT0 htag |
| exact hraw.trans (mul_le_mul_of_nonneg_right hcoef hE) |
|
|
| end MatchingFPRAS.Transport.CellDemands |
|
|
| namespace MatchingFPRAS.Transport |
|
|
| open Finset |
|
|
| variable {V E : Type*} [Fintype V] [DecidableEq V] [Fintype E] [DecidableEq E] |
|
|
| variable (ends : E → Sym2 V) (hloop : ∀ e, ¬(ends e).IsDiag) |
|
|
| include hloop |
|
|
| omit [Fintype E] [DecidableEq E] in |
| lemma PM.twice_card (A : PM (fun e v => v ∈ ends e)) : 2*A.val.card = Fintype.card V := by |
| classical |
| have hv (v : V) : (∑ e ∈ A.val, if v ∈ ends e then (1:ℕ) else 0) = 1 := by |
| obtain ⟨e,⟨he,hev⟩,hu⟩ := A.property.2 v (Finset.mem_univ v) |
| rw [Finset.sum_eq_single e] |
| · simp [hev] |
| · intro f hf hfe |
| have : v ∉ ends f := fun hfv => hfe (hu f ⟨hf,hfv⟩) |
| simp [this] |
| · exact fun h => (h he).elim |
| have he (e : E) : (∑ v : V, if v ∈ ends e then (1:ℕ) else 0) = 2 := by |
| have hs : Finset.univ.filter (fun v => v ∈ ends e) = (ends e).toFinset := by |
| ext v; simp |
| rw [← Finset.sum_filter,Finset.sum_const,smul_eq_mul,mul_one,hs] |
| exact Sym2.card_toFinset_of_not_isDiag _ (hloop e) |
| calc |
| _ = ∑ e ∈ A.val, ∑ v : V, if v ∈ ends e then (1:ℕ) else 0 := by |
| simp [he,Nat.mul_comm] |
| _ = ∑ v : V, ∑ e ∈ A.val, if v ∈ ends e then (1:ℕ) else 0 := by rw [Finset.sum_comm] |
| _ = _ := by simp [hv] |
|
|
| omit [Fintype E] [DecidableEq E] in |
| lemma PM.card_eq (A B : PM (fun e v => v ∈ ends e)) : A.val.card = B.val.card := by |
| have ha := A.twice_card ends hloop |
| have hb := B.twice_card ends hloop |
| omega |
|
|
| omit hloop |
|
|
| omit [DecidableEq V] [Fintype E] [DecidableEq E] in |
| lemma matchingWeight_compare {w z : E → ℝ} (hw : ∀ e, 0 ≤ w e) |
| (c : ℝ) (_hc : 0 ≤ c) (h : ∀ e, w e ≤ c*z e) |
| (A : PM (fun e v => v ∈ ends e)) : |
| matchingWeight w A ≤ c^A.val.card*matchingWeight z A := by |
| calc |
| _ ≤ ∏ e ∈ A.val, c*z e := Finset.prod_le_prod₀ (fun edge _ => hw edge) (fun edge _ => h edge) |
| _ = _ := by simp only [Finset.prod_mul_distrib,Finset.prod_const]; rfl |
| |
| include hloop |
| |
| omit [DecidableEq E] in |
| lemma partition_compare {w z : E → ℝ} (hw : ∀ e, 0 ≤ w e) |
| (c : ℝ) (hc : 0 ≤ c) (h : ∀ e, w e ≤ c*z e) |
| (A : PM (fun e v => v ∈ ends e)) : |
| partition (inc := fun e v => v ∈ ends e) w ≤ |
| c^A.val.card*partition (inc := fun e v => v ∈ ends e) z := by |
| classical |
| unfold partition |
| rw [Finset.mul_sum] |
| apply Finset.sum_le_sum; intro B _ |
| have hh := matchingWeight_compare ends hw c hc h B |
| rwa [PM.card_eq ends hloop B A] at hh |
|
|
| omit [DecidableEq E] in |
| lemma gibbs_compare {w z : E → ℝ} (hw : ∀ e, 0 < w e) (hz : ∀ e, 0 < z e) |
| (c : ℝ) (hc : 0 ≤ c) (hwz : ∀ e, w e ≤ c*z e) (hzw : ∀ e, z e ≤ c*w e) |
| (A : PM (fun e v => v ∈ ends e)) : |
| gibbs w A ≤ c^(Fintype.card V)*gibbs z A := by |
| have hwa := matchingWeight_compare ends (fun e => (hw e).le) c hc hwz A |
| have hpz := partition_compare ends hloop (fun e => (hz e).le) c hc hzw A |
| have hprod := mul_le_mul hwa hpz (le_of_lt (partition_pos z hz A)) |
| (mul_nonneg (pow_nonneg hc _) (matchingWeight_pos z hz A).le) |
| have he : c^A.val.card*c^A.val.card = c^(Fintype.card V) := by |
| rw [← pow_add,← A.twice_card ends hloop] |
| congr 1; omega |
| have hh : matchingWeight w A*partition (inc := fun e v => v ∈ ends e) z ≤ |
| c^(Fintype.card V)*matchingWeight z A*partition (inc := fun e v => v ∈ ends e) w := by |
| calc |
| _ ≤ (c^A.val.card*matchingWeight z A)*(c^A.val.card*partition (inc := fun e v => v ∈ ends e) w) := hprod |
| _ = _ := by rw [← he]; ring |
| unfold gibbs |
| rw [← mul_div_assoc,div_le_div_iff₀ (partition_pos w hw A) (partition_pos z hz A)] |
| exact hh |
| |
| end MatchingFPRAS.Transport |
| |
| end OAI |
| |
