| import Mathlib |
| import OAI.Combinatorics.MatchingCount.Graphs.Density |
|
|
| namespace OAI |
|
|
| namespace MatchingFPRAS.Replica |
|
|
| section |
|
|
| open Finset |
|
|
| variable {I Ω : Type*} [Fintype I] [DecidableEq I] [Fintype Ω] |
|
|
| variable (p : I → Ω → ℝ) |
|
|
| noncomputable def mean (f : (I → Ω) → ℝ) : ℝ := ∑ s, density p s*f s |
|
|
| noncomputable def variance (f : (I → Ω) → ℝ) : ℝ := |
| dot p (f-(fun _ => mean p f)) (f-(fun _ => mean p f)) |
|
|
| lemma mean_dot (f : (I → Ω) → ℝ) : mean p f = dot p (fun _ => 1) f := by simp [mean,dot] |
|
|
| lemma density_sum (hs : ∀ i, ∑ a, p i a = 1) : ∑ s, density p s = 1 := by |
| unfold density |
| rw [← Fintype.prod_sum] |
| simp_rw [hs] |
| simp |
|
|
| lemma mean_average (hs : ∀ i, ∑ a, p i a = 1) (i : I) (f : (I → Ω) → ℝ) : |
| mean p (average p i f) = mean p f := by |
| rw [mean_dot, ← average_adjoint] |
| have ho : average p i (fun _ => 1) = (fun _ => 1) := by |
| funext s; simpa [average_apply] using hs i |
| rw [ho, ← mean_dot] |
|
|
| lemma mean_avgList (hs : ∀ i, ∑ a, p i a = 1) (l : List I) (f : (I → Ω) → ℝ) : |
| mean p (avgList p l f) = mean p f := by |
| induction l with |
| | nil => rfl |
| | cons i l ih => rw [avgList_cons,mean_average p hs,ih] |
|
|
| omit [Fintype I] in |
| lemma average_update (i : I) (a : Ω) (f : (I → Ω) → ℝ) (s : I → Ω) : |
| average p i f (Function.update s i a) = average p i f s := by |
| simp only [average_apply,Function.update_idem] |
|
|
| lemma invariant_constant (f : (I → Ω) → ℝ) (hf : ∀ i, average p i f = f) |
| (s t : I → Ω) : f s = f t := by |
| classical |
| have hu (i : I) (a : Ω) (s : I → Ω) : f (Function.update s i a) = f s := by |
| rw [← hf i] |
| exact average_update p i a f s |
| have hpatch (S : Finset I) : f (fun i => if i ∈ S then t i else s i) = f s := by |
| induction S using Finset.induction_on with |
| | empty => simp |
| | @insert i S hi ih => |
| have he : (fun j => if j ∈ insert i S then t j else s j) = |
| Function.update (fun j => if j ∈ S then t j else s j) i (t i) := by |
| funext j |
| by_cases hji : j = i |
| · subst j; simp |
| · simp [hji] |
| rw [he,hu,ih] |
| simpa using (hpatch Finset.univ).symm |
|
|
| lemma average_all (hs : ∀ i, ∑ a, p i a = 1) (l : List I) (hl : ∀ i, i ∈ l) |
| (f : (I → Ω) → ℝ) : avgList p l f = (fun _ => mean p f) := by |
| funext s |
| have hc : ∀ t, avgList p l f t = avgList p l f s := fun t => |
| invariant_constant p (avgList p l f) (fun i => average_list_mem p hs l i (hl i) f) t s |
| have hm := mean_avgList p hs l f |
| unfold mean at hm |
| simp_rw [hc] at hm |
| rw [← Finset.sum_mul,density_sum p hs,one_mul] at hm |
| exact hm |
|
|
| omit [Fintype I] in |
| lemma avgList_fixed (l : List I) (f : (I → Ω) → ℝ) |
| (hf : ∀ i ∈ l, average p i f = f) : avgList p l f = f := by |
| induction l with |
| | nil => rfl |
| | cons i l ih => |
| rw [avgList_cons,ih (fun j hj => hf j (List.mem_cons_of_mem i hj)),hf i (List.mem_cons_self)] |
|
|
| omit [Fintype I] in |
| lemma avgList_comm_list (l k : List I) (f : (I → Ω) → ℝ) : |
| avgList p l (avgList p k f) = avgList p k (avgList p l f) := by |
| induction l with |
| | nil => rfl |
| | cons i l ih => rw [avgList_cons,ih,average_comm_list,avgList_cons] |
|
|
| omit [Fintype I] in |
| lemma avgList_congr (hs : ∀ i, ∑ a, p i a = 1) (l k : List I) |
| (hmem : ∀ i, i ∈ l ↔ i ∈ k) (f : (I → Ω) → ℝ) : avgList p l f = avgList p k f := by |
| have h₁ : avgList p l (avgList p k f) = avgList p k f := |
| avgList_fixed p l _ (fun i hi => average_list_mem p hs k i ((hmem i).mp hi) f) |
| have h₂ : avgList p k (avgList p l f) = avgList p l f := |
| avgList_fixed p k _ (fun i hi => average_list_mem p hs l i ((hmem i).mpr hi) f) |
| rw [avgList_comm_list,h₂] at h₁ |
| exact h₁ |
|
|
| lemma projection_pythagoras (P : Projection p) (f : (I → Ω) → ℝ) : |
| dot p (f-P.op f) (f-P.op f) = dot p f f-dot p (P.op f) (P.op f) := by |
| rw [dot_sub_left p f (P.op f) (f-P.op f),dot_sub_right p f f (P.op f), |
| dot_sub_right p (P.op f) f (P.op f),dot_comm p (P.op f) f,P.dot_image] |
| ring |
|
|
| end |
|
|
| section |
|
|
| open Finset |
|
|
| variable {I Ω : Type*} [Fintype I] [DecidableEq I] [LinearOrder I] |
| [Fintype Ω] |
|
|
| variable (p : I → Ω → ℝ) |
|
|
| noncomputable def future (S : Finset I) (x : I) := avgList p ((S.filter (x < ·)).toList) |
|
|
| noncomputable def increment (S : Finset I) (x : I) (f : (I → Ω) → ℝ) : (I → Ω) → ℝ := |
| future p S x f-average p x (future p S x f) |
|
|
| lemma martingale_partial (hs : ∀ i, ∑ a, p i a = 1) (S : Finset I) (f : (I → Ω) → ℝ) : |
| (∑ x ∈ S, dot p (increment p S x f) (increment p S x f)) = |
| dot p f f-dot p (avgList p S.toList f) (avgList p S.toList f) := by |
| classical |
| induction S using Finset.induction_on_min with |
| | empty => simp [future,increment,avgList] |
| | insert a S hmin ih => |
| have ha : a ∉ S := fun h => (lt_irrefl a) (hmin a h) |
| have hfilter : (insert a S).filter (a < ·) = S := by |
| ext i |
| simp only [Finset.mem_filter,Finset.mem_insert] |
| constructor |
| · rintro ⟨hi,hai⟩; rcases hi with rfl | hi |
| · exact (lt_irrefl _ hai).elim |
| · exact hi |
| · intro hi; exact ⟨Or.inr hi,hmin i hi⟩ |
| have hother (x) (hx : x ∈ S) : (insert a S).filter (x < ·) = S.filter (x < ·) := by |
| ext i |
| simp only [Finset.mem_filter,Finset.mem_insert] |
| constructor |
| · rintro ⟨hi,hxi⟩; rcases hi with rfl | hi |
| · exact (not_lt_of_gt (hmin x hx) hxi).elim |
| · exact ⟨hi,hxi⟩ |
| · rintro ⟨hi,hxi⟩; exact ⟨Or.inr hi,hxi⟩ |
| have hc : avgList p (insert a S).toList f = average p a (avgList p S.toList f) := by |
| change avgList p (insert a S).toList f = avgList p (a::S.toList) f |
| apply avgList_congr p hs |
| intro i; simp |
| rw [Finset.sum_insert ha,hc] |
| have hsum : (∑ x ∈ S, dot p (increment p (insert a S) x f) |
| (increment p (insert a S) x f)) = ∑ x ∈ S, dot p (increment p S x f) (increment p S x f) := by |
| apply Finset.sum_congr rfl |
| intro x hx |
| simp only [increment,future,hother x hx] |
| rw [hsum,ih] |
| have hp := projection_pythagoras p (avgProjection p hs a) (avgList p S.toList f) |
| change dot p (increment p (insert a S) a f) (increment p (insert a S) a f) + _ = _ |
| unfold increment future |
| rw [hfilter] |
| change dot p (avgList p S.toList f-average p a (avgList p S.toList f)) |
| (avgList p S.toList f-average p a (avgList p S.toList f)) = |
| dot p (avgList p S.toList f) (avgList p S.toList f)- |
| dot p (average p a (avgList p S.toList f)) (average p a (avgList p S.toList f)) at hp |
| linarith |
|
|
| lemma martingale_variance (hs : ∀ i, ∑ a, p i a = 1) (f : (I → Ω) → ℝ) : |
| variance p f = ∑ x, dot p (increment p Finset.univ x f) (increment p Finset.univ x f) := by |
| rw [martingale_partial p hs] |
| have hp := projection_pythagoras p (listProjection p hs Finset.univ.toList) f |
| change dot p (f-avgList p Finset.univ.toList f) (f-avgList p Finset.univ.toList f) = |
| dot p f f-dot p (avgList p Finset.univ.toList f) (avgList p Finset.univ.toList f) at hp |
| rw [average_all p hs Finset.univ.toList (by simp)] at hp ⊢ |
| exact hp |
|
|
| omit [Fintype I] in |
| lemma increment_center (hs : ∀ i, ∑ a, p i a = 1) (S : Finset I) (x : I) (f : (I → Ω) → ℝ) : |
| average p x (increment p S x f) = 0 := by |
| simp [increment,map_sub,average_idem p hs] |
|
|
| lemma average_pair_future (hs : ∀ i, ∑ a, p i a = 1) (x y : I) (hxy : x < y) |
| (f : (I → Ω) → ℝ) : average p y (pairCondition p x y f) = future p Finset.univ x f := by |
| change avgList p (y::outside x y) f = avgList p ((Finset.univ.filter (x < ·)).toList) f |
| apply avgList_congr p hs |
| intro i |
| simp only [List.mem_cons,Finset.mem_toList,Finset.mem_filter,Finset.mem_univ,true_and,outside] |
| constructor |
| · rintro (rfl | ⟨hi,_⟩) |
| · exact hxy |
| · exact hi |
| · intro hi |
| by_cases hiy : i=y |
| · exact Or.inl hiy |
| · exact Or.inr ⟨hi,hiy⟩ |
|
|
| lemma increment_pair_formula (hs : ∀ i, ∑ a, p i a = 1) (x y : I) (hxy : x < y) |
| (f : (I → Ω) → ℝ) : increment p Finset.univ x f = |
| average p y (pairCondition p x y f)-average p x (average p y (pairCondition p x y f)) := by |
| rw [average_pair_future p hs x y hxy] |
| rfl |
|
|
| end |
|
|
| section |
|
|
| open Finset |
|
|
| variable {Ω A : Type*} [Fintype Ω] [Fintype A] |
|
|
| noncomputable def localEnergy (q : Ω → Ω → ℝ) (f : Ω → ℝ) : ℝ := |
| (∑ a, ∑ b, q a b * (f a-f b)^2)/2 |
|
|
| lemma localEnergy_nonneg (q : Ω → Ω → ℝ) (hq : ∀ a b, 0 ≤ q a b) (f : Ω → ℝ) : |
| 0 ≤ localEnergy q f := by |
| exact div_nonneg (Finset.sum_nonneg (fun a _ => Finset.sum_nonneg |
| (fun b _ => mul_nonneg (hq a b) (sq_nonneg _)))) (by norm_num) |
|
|
| lemma localEnergy_sub (q : Ω → Ω → ℝ) (hq : ∀ a b, 0 ≤ q a b) (f g : Ω → ℝ) : |
| localEnergy q (f-g) ≤ 2*localEnergy q f+2*localEnergy q g := by |
| unfold localEnergy |
| have h : (∑ a, ∑ b, q a b*((f-g) a-(f-g) b)^2) ≤ |
| ∑ a, ∑ b, (2*(q a b*(f a-f b)^2)+2*(q a b*(g a-g b)^2)) := by |
| apply Finset.sum_le_sum; intro a _ |
| apply Finset.sum_le_sum; intro b _ |
| have hsq : ((f a-g a)-(f b-g b))^2 ≤ 2*(f a-f b)^2+2*(g a-g b)^2 := by |
| nlinarith [sq_nonneg ((f a-f b)+(g a-g b))] |
| change q a b*((f a-g a)-(f b-g b))^2 ≤ _ |
| calc |
| _ ≤ q a b*(2*(f a-f b)^2+2*(g a-g b)^2) := mul_le_mul_of_nonneg_left hsq (hq a b) |
| _ = _ := by ring |
| simp only [Finset.sum_add_distrib,← Finset.mul_sum] at h |
| linarith |
|
|
| lemma localEnergy_shift (q : Ω → Ω → ℝ) (f : Ω → ℝ) (c : ℝ) : |
| localEnergy q (fun a => f a-c) = localEnergy q f := by |
| unfold localEnergy |
| congr 1 |
| apply Finset.sum_congr rfl; intro a _ |
| apply Finset.sum_congr rfl; intro b _ |
| congr 2; ring |
|
|
| lemma square_average (w : A → ℝ) (hw : ∀ a, 0 ≤ w a) (hs : ∑ a, w a = 1) (f : A → ℝ) : |
| (∑ a, w a*f a)^2 ≤ ∑ a, w a*(f a)^2 := by |
| have h := Finset.sum_sq_le_sum_mul_sum_of_sq_le_mul Finset.univ |
| (r := fun a => w a*f a) (f := w) (g := fun a => w a*(f a)^2) |
| (fun a _ => hw a) (fun a _ => mul_nonneg (hw a) (sq_nonneg _)) |
| (fun a _ => by nlinarith [sq_nonneg (w a*f a)]) |
| simpa only [hs,one_mul] using h |
|
|
| lemma localEnergy_average (q : Ω → Ω → ℝ) (hq : ∀ a b, 0 ≤ q a b) |
| (w : A → ℝ) (hw : ∀ a, 0 ≤ w a) (hs : ∑ a, w a = 1) (f : A → Ω → ℝ) : |
| localEnergy q (fun a => ∑ i, w i*f i a) ≤ ∑ i, w i*localEnergy q (f i) := by |
| have h : (∑ a, ∑ b, q a b*((∑ i, w i*f i a)-(∑ i, w i*f i b))^2) ≤ |
| ∑ a, ∑ b, q a b*(∑ i, w i*(f i a-f i b)^2) := by |
| apply Finset.sum_le_sum; intro a _ |
| apply Finset.sum_le_sum; intro b _ |
| apply mul_le_mul_of_nonneg_left _ (hq a b) |
| simpa only [mul_sub,Finset.sum_sub_distrib] using square_average w hw hs (fun i => f i a-f i b) |
| have he : (∑ a, ∑ b, q a b*(∑ i, w i*(f i a-f i b)^2)) = |
| ∑ i, w i*(∑ a, ∑ b, q a b*(f i a-f i b)^2) := by |
| simp only [Finset.mul_sum] |
| have hin (a : Ω) : (∑ b, ∑ i, q a b*(w i*(f i a-f i b)^2)) = |
| ∑ i, ∑ b, q a b*(w i*(f i a-f i b)^2) := Finset.sum_comm |
| simp_rw [hin] |
| rw [Finset.sum_comm] |
| apply Finset.sum_congr rfl; intro i _ |
| apply Finset.sum_congr rfl; intro a _ |
| apply Finset.sum_congr rfl; intro b _ |
| ring |
| unfold localEnergy |
| rw [he] at h |
| have := div_le_div_of_nonneg_right h (by norm_num : (0:ℝ) ≤ 2) |
| simpa only [Finset.sum_div,mul_div_assoc] using this |
|
|
| lemma localEnergy_bound (π : Ω → ℝ) (q : Ω → Ω → ℝ) (hq : ∀ a b, 0 ≤ q a b) |
| (hr : ∀ a, ∑ b, q a b = π a) (hc : ∀ b, ∑ a, q a b = π b) (f : Ω → ℝ) : |
| localEnergy q f ≤ 2*∑ a, π a*(f a)^2 := by |
| have hh : (∑ a, ∑ b, q a b*(f a-f b)^2) ≤ |
| ∑ a, ∑ b, (2*(q a b*(f a)^2)+2*(q a b*(f b)^2)) := by |
| apply Finset.sum_le_sum; intro a _ |
| apply Finset.sum_le_sum; intro b _ |
| have hs : (f a-f b)^2 ≤ 2*(f a)^2+2*(f b)^2 := by nlinarith [sq_nonneg (f a+f b)] |
| calc |
| _ ≤ q a b * (2 * (f a)^2 + 2 * (f b)^2) := |
| mul_le_mul_of_nonneg_left hs (hq a b) |
| _ = _ := by ring |
| have hleft : (∑ a, ∑ b, q a b*(f a)^2) = ∑ a, π a*(f a)^2 := by |
| simp only [← Finset.sum_mul,hr] |
| have hright : (∑ a, ∑ b, q a b*(f b)^2) = ∑ b, π b*(f b)^2 := by |
| rw [Finset.sum_comm] |
| simp only [← Finset.sum_mul,hc] |
| simp only [Finset.sum_add_distrib,← Finset.mul_sum,hleft,hright] at hh |
| unfold localEnergy; linarith |
|
|
| end |
|
|
| open Finset |
|
|
| variable {I Ω : Type*} [Fintype I] [DecidableEq I] [Fintype Ω] |
|
|
| variable (p : I → Ω → ℝ) |
|
|
| omit [DecidableEq I] [Fintype Ω] in |
| lemma density_nonneg (hp : ∀ i a, 0 ≤ p i a) (s : I → Ω) : 0 ≤ density p s := |
| Finset.prod_nonneg (fun i _ => hp i (s i)) |
|
|
| lemma mean_mono (hp : ∀ i a, 0 ≤ p i a) {f g : (I → Ω) → ℝ} |
| (h : ∀ s, f s ≤ g s) : mean p f ≤ mean p g := |
| Finset.sum_le_sum (fun s _ => mul_le_mul_of_nonneg_left (h s) (density_nonneg p hp s)) |
|
|
| lemma mean_nonneg (hp : ∀ i a, 0 ≤ p i a) {f : (I → Ω) → ℝ} (h : ∀ s, 0 ≤ f s) : |
| 0 ≤ mean p f := Finset.sum_nonneg (fun s _ => mul_nonneg (density_nonneg p hp s) (h s)) |
|
|
| lemma mean_add (f g : (I → Ω) → ℝ) : mean p (f+g) = mean p f+mean p g := by |
| simp [mean,mul_add,Finset.sum_add_distrib] |
|
|
| lemma mean_mul (c : ℝ) (f : (I → Ω) → ℝ) : mean p (fun s => c*f s) = c*mean p f := by |
| simp only [mean,Finset.mul_sum]; apply Finset.sum_congr rfl; intro s _; ring |
|
|
| lemma mean_square (f : (I → Ω) → ℝ) : mean p (fun s => (f s)^2) = dot p f f := by |
| simp only [mean,dot]; apply Finset.sum_congr rfl; intro s _; ring |
|
|
| structure PairCapacity (x y : I) where |
| q : (Ω × Ω) → (Ω × Ω) → ℝ |
| nonneg : ∀ a b, 0 ≤ q a b |
| row : ∀ a, ∑ b, q a b = p x a.1*p y a.2 |
| col : ∀ b, ∑ a, q a b = p x b.1*p y b.2 |
|
|
| def replacePair (x y : I) (s : I → Ω) (a : Ω × Ω) : I → Ω := |
| Function.update (Function.update s x a.1) y a.2 |
|
|
| def slice (x y : I) (f : (I → Ω) → ℝ) (s : I → Ω) (a : Ω × Ω) : ℝ := |
| f (replacePair x y s a) |
|
|
| noncomputable def pairEnergy (x y : I) (Q : PairCapacity p x y) (f : (I → Ω) → ℝ) : ℝ := |
| mean p (fun s => localEnergy Q.q (slice x y f s)) |
|
|
| omit [Fintype I] [Fintype Ω] in |
| lemma slice_sub (x y : I) (f g : (I → Ω) → ℝ) (s : I → Ω) : |
| slice x y (f-g) s = slice x y f s-slice x y g s := rfl |
|
|
| lemma pairEnergy_nonneg (hp : ∀ i a, 0 ≤ p i a) (x y : I) (Q : PairCapacity p x y) |
| (f : (I → Ω) → ℝ) : 0 ≤ pairEnergy p x y Q f := |
| mean_nonneg p hp (fun _ => localEnergy_nonneg Q.q Q.nonneg _) |
|
|
| lemma pairEnergy_sub (hp : ∀ i a, 0 ≤ p i a) (x y : I) (Q : PairCapacity p x y) |
| (f g : (I → Ω) → ℝ) : pairEnergy p x y Q (f-g) ≤ |
| 2*pairEnergy p x y Q f+2*pairEnergy p x y Q g := by |
| have hh := mean_mono p hp (fun s => localEnergy_sub Q.q Q.nonneg (slice x y f s) (slice x y g s)) |
| change mean p (fun s => localEnergy Q.q (slice x y (f-g) s)) ≤ |
| mean p ((fun s => 2*localEnergy Q.q (slice x y f s))+(fun s => 2*localEnergy Q.q (slice x y g s))) at hh |
| rw [mean_add,mean_mul,mean_mul] at hh |
| exact hh |
|
|
| lemma slice_square_mean (hs : ∀ i, ∑ a, p i a = 1) (x y : I) (f : (I → Ω) → ℝ) : |
| mean p (fun s => ∑ a : Ω × Ω, (p x a.1*p y a.2)*(slice x y f s a)^2) = dot p f f := by |
| have he (s : I → Ω) : (∑ a : Ω × Ω, (p x a.1*p y a.2)*(slice x y f s a)^2) = |
| average p x (average p y (fun s => (f s)^2)) s := by |
| rw [Fintype.sum_prod_type] |
| simp only [average_apply,Finset.mul_sum] |
| apply Finset.sum_congr rfl; intro a _ |
| apply Finset.sum_congr rfl; intro b _ |
| unfold slice replacePair; ring |
| simp_rw [he] |
| rw [mean_average p hs,mean_average p hs,mean_square] |
|
|
| lemma pairEnergy_bound (hp : ∀ i a, 0 ≤ p i a) (hs : ∀ i, ∑ a, p i a = 1) |
| (x y : I) (Q : PairCapacity p x y) (f : (I → Ω) → ℝ) : |
| pairEnergy p x y Q f ≤ 2*dot p f f := by |
| have hh := mean_mono p hp (fun s => localEnergy_bound (fun a => p x a.1*p y a.2) |
| Q.q Q.nonneg Q.row Q.col (slice x y f s)) |
| rw [mean_mul,slice_square_mean p hs] at hh |
| exact hh |
|
|
| omit [Fintype I] [Fintype Ω] in |
| lemma replacePair_update (i x y : I) (hix : i ≠ x) (hiy : i ≠ y) |
| (s : I → Ω) (a : Ω × Ω) (b : Ω) : |
| replacePair x y (Function.update s i b) a = Function.update (replacePair x y s a) i b := by |
| unfold replacePair |
| rw [Function.update_comm hix,Function.update_comm hiy] |
|
|
| omit [Fintype I] in |
| lemma slice_average (i x y : I) (hix : i ≠ x) (hiy : i ≠ y) |
| (f : (I → Ω) → ℝ) (s : I → Ω) : |
| slice x y (average p i f) s = (fun a => ∑ b, p i b*slice x y f (Function.update s i b) a) := by |
| funext a |
| simp only [slice,average_apply,replacePair_update i x y hix hiy] |
|
|
| lemma pairEnergy_average (hp : ∀ i a, 0 ≤ p i a) (hs : ∀ i, ∑ a, p i a = 1) |
| (i x y : I) (hix : i ≠ x) (hiy : i ≠ y) (Q : PairCapacity p x y) (f : (I → Ω) → ℝ) : |
| pairEnergy p x y Q (average p i f) ≤ pairEnergy p x y Q f := by |
| have hh (s : I → Ω) : localEnergy Q.q (slice x y (average p i f) s) ≤ |
| average p i (fun s => localEnergy Q.q (slice x y f s)) s := by |
| rw [slice_average p i x y hix hiy] |
| exact localEnergy_average Q.q Q.nonneg (p i) (hp i) (hs i) (fun b => slice x y f (Function.update s i b)) |
| have hh := mean_mono p hp hh |
| rw [mean_average p hs] at hh |
| exact hh |
|
|
| lemma pairEnergy_avgList (hp : ∀ i a, 0 ≤ p i a) (hs : ∀ i, ∑ a, p i a = 1) |
| (l : List I) (x y : I) (hl : ∀ i ∈ l, i ≠ x ∧ i ≠ y) (Q : PairCapacity p x y) |
| (f : (I → Ω) → ℝ) : pairEnergy p x y Q (avgList p l f) ≤ pairEnergy p x y Q f := by |
| induction l with |
| | nil => exact le_rfl |
| | cons i l ih => |
| rw [avgList_cons] |
| exact (pairEnergy_average p hp hs i x y (hl i (by simp)).1 (hl i (by simp)).2 Q _).trans |
| (ih (fun j hj => hl j (List.mem_cons_of_mem i hj))) |
|
|
| end MatchingFPRAS.Replica |
|
|
| end OAI |
|
|
