introvoyz045's picture
Migrated from GitHub
4a56cd6 verified
Raw History Blame Contribute Delete
18.5 kB
import Mathlib
import OAI.Combinatorics.MatchingCount.Probability.LocalVariance
namespace OAI
namespace MatchingFPRAS.Replica
section
open Finset
variable {R A S : Type*} [Fintype R] [Fintype A] [Fintype S] [DecidableEq S]
noncomputable def pushedFlow (ρ : R β†’ ℝ) (F : R β†’ A β†’ S) (q : A β†’ A β†’ ℝ) (s t : S) : ℝ :=
βˆ‘ z : R Γ— (A Γ— A), if (F z.1 z.2.1,F z.1 z.2.2) = (s,t) then ρ z.1*q z.2.1 z.2.2 else 0
omit [Fintype S] in
lemma pushedFlow_nonneg (ρ : R β†’ ℝ) (F : R β†’ A β†’ S) (q : A β†’ A β†’ ℝ)
(hρ : βˆ€ r, 0 ≀ ρ r) (hq : βˆ€ a b, 0 ≀ q a b) (s t : S) :
0 ≀ pushedFlow ρ F q s t := by
apply Finset.sum_nonneg; intro z _
split_ifs <;> [exact mul_nonneg (hρ _) (hq _ _); exact le_refl _]
lemma pushedFlow_test (ρ : R β†’ ℝ) (F : R β†’ A β†’ S) (q : A β†’ A β†’ ℝ)
(g : S β†’ S β†’ ℝ) :
(βˆ‘ s, βˆ‘ t, pushedFlow ρ F q s t*g s t) =
βˆ‘ r, ρ r*βˆ‘ a, βˆ‘ b, q a b*g (F r a) (F r b) := by
classical
calc
_ = βˆ‘ st : S Γ— S, (βˆ‘ z : R Γ— (A Γ— A),
if (F z.1 z.2.1,F z.1 z.2.2) = st then ρ z.1*q z.2.1 z.2.2 else 0)*g st.1 st.2 := by
rw [Fintype.sum_prod_type]; rfl
_ = βˆ‘ z : R Γ— (A Γ— A), ρ z.1*q z.2.1 z.2.2*g (F z.1 z.2.1) (F z.1 z.2.2) := by
simp_rw [Finset.sum_mul]
rw [Finset.sum_comm]
apply Finset.sum_congr rfl; intro z _
simp only [ite_mul,zero_mul]
simp
_ = _ := by
simp only [Fintype.sum_prod_type,Finset.mul_sum]
apply Finset.sum_congr rfl; intro r _
apply Finset.sum_congr rfl; intro a _
apply Finset.sum_congr rfl; intro b _
ring
lemma pushedFlow_row_test (ρ : R β†’ ℝ) (F : R β†’ A β†’ S) (q : A β†’ A β†’ ℝ)
(ΞΌ : A β†’ ℝ) (hrow : βˆ€ a, βˆ‘ b, q a b = ΞΌ a) (g : S β†’ ℝ) :
(βˆ‘ s, βˆ‘ t, pushedFlow ρ F q s t*g s) = βˆ‘ r, ρ r*βˆ‘ a, ΞΌ a*g (F r a) := by
rw [pushedFlow_test]
apply Finset.sum_congr rfl; intro r _
congr 1
apply Finset.sum_congr rfl; intro a _
rw [← Finset.sum_mul,hrow]
lemma pushedFlow_col_test (ρ : R β†’ ℝ) (F : R β†’ A β†’ S) (q : A β†’ A β†’ ℝ)
(ΞΌ : A β†’ ℝ) (hcol : βˆ€ b, βˆ‘ a, q a b = ΞΌ b) (g : S β†’ ℝ) :
(βˆ‘ s, βˆ‘ t, pushedFlow ρ F q s t*g t) = βˆ‘ r, ρ r*βˆ‘ b, ΞΌ b*g (F r b) := by
rw [pushedFlow_test]
apply Finset.sum_congr rfl; intro r _
congr 1
rw [Finset.sum_comm]
apply Finset.sum_congr rfl; intro b _
rw [← Finset.sum_mul,hcol]
lemma pushedFlow_energy (ρ : R β†’ ℝ) (F : R β†’ A β†’ S) (q : A β†’ A β†’ ℝ)
(f : S β†’ ℝ) : localEnergy (pushedFlow ρ F q) f =
βˆ‘ r, ρ r*localEnergy q (fun a => f (F r a)) := by
unfold localEnergy
rw [pushedFlow_test]
simp only [mul_div_assoc,Finset.sum_div]
end
section
open Finset
variable {I Ξ© : Type*} [Fintype I] [DecidableEq I] [Fintype Ξ©] [DecidableEq Ξ©]
variable (p : I β†’ Ξ© β†’ ℝ)
noncomputable def pairFlow (x y : I) (Q : PairCapacity p x y) : (I β†’ Ξ©) β†’ (I β†’ Ξ©) β†’ ℝ :=
pushedFlow (density p) (replacePair x y) Q.q
omit [DecidableEq Ξ©] in
lemma slice_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*f (replacePair x y s a)) = mean p f := by
have he (s : I β†’ Ξ©) : (βˆ‘ a : Ξ© Γ— Ξ©, p x a.1*p y a.2*f (replacePair x y s a)) =
average p x (average p y f) 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 replacePair; ring
simp_rw [he]
rw [mean_average p hs,mean_average p hs]
lemma pairFlow_row (hs : βˆ€ i, βˆ‘ a, p i a = 1) (x y : I) (Q : PairCapacity p x y) (s : I β†’ Ξ©) :
(βˆ‘ t, pairFlow p x y Q s t) = density p s := by
have h := pushedFlow_row_test (density p) (replacePair x y) Q.q
(fun a => p x a.1*p y a.2) Q.row (fun t => if t=s then 1 else 0)
change (βˆ‘ r, βˆ‘ t, pairFlow p x y Q r t*(if r=s then 1 else 0)) =
mean p (fun r => βˆ‘ a : Ξ© Γ— Ξ©, p x a.1*p y a.2*(if replacePair x y r a=s then 1 else 0)) at h
rw [slice_mean p hs x y (fun t => if t=s then 1 else 0)] at h
simpa [mean,mul_ite,Finset.sum_ite_irrel] using h
lemma pairFlow_col (hs : βˆ€ i, βˆ‘ a, p i a = 1) (x y : I) (Q : PairCapacity p x y) (t : I β†’ Ξ©) :
(βˆ‘ s, pairFlow p x y Q s t) = density p t := by
have h := pushedFlow_col_test (density p) (replacePair x y) Q.q
(fun a => p x a.1*p y a.2) Q.col (fun s => if s=t then 1 else 0)
change (βˆ‘ r, βˆ‘ s, pairFlow p x y Q r s*(if s=t then 1 else 0)) =
mean p (fun r => βˆ‘ a : Ξ© Γ— Ξ©, p x a.1*p y a.2*(if replacePair x y r a=t then 1 else 0)) at h
rw [slice_mean p hs x y (fun s => if s=t then 1 else 0)] at h
simpa [mean,mul_ite] using h
lemma pairFlow_nonneg (hp : βˆ€ i a, 0 ≀ p i a) (x y : I) (Q : PairCapacity p x y) (s t : I β†’ Ξ©) :
0 ≀ pairFlow p x y Q s t := pushedFlow_nonneg _ _ _ (density_nonneg p hp) Q.nonneg s t
lemma pairFlow_energy (x y : I) (Q : PairCapacity p x y) (f : (I β†’ Ξ©) β†’ ℝ) :
localEnergy (pairFlow p x y Q) f = pairEnergy p x y Q f :=
pushedFlow_energy _ _ _ f
noncomputable def baseFlow (i : I) : (I β†’ Ξ©) β†’ (I β†’ Ξ©) β†’ ℝ :=
pushedFlow (density p) (fun s a => Function.update s i a) (fun a b => p i a*p i b)
lemma baseFlow_nonneg (hp : βˆ€ i a, 0 ≀ p i a) (i : I) (s t : I β†’ Ξ©) :
0 ≀ baseFlow p i s t := pushedFlow_nonneg _ _ _ (density_nonneg p hp)
(fun a b => mul_nonneg (hp i a) (hp i b)) s t
lemma baseFlow_row (hs : βˆ€ i, βˆ‘ a, p i a = 1) (i : I) (s : I β†’ Ξ©) :
(βˆ‘ t, baseFlow p i s t) = density p s := by
have h := pushedFlow_row_test (density p) (fun r a => Function.update r i a)
(fun a b => p i a*p i b) (p i) (fun a => by rw [← Finset.mul_sum,hs, mul_one])
(fun t => if t=s then 1 else 0)
change (βˆ‘ r, βˆ‘ t, baseFlow p i r t*(if r=s then 1 else 0)) =
mean p (average p i (fun t => if t=s then 1 else 0)) at h
rw [mean_average p hs] at h
simpa [mean,mul_ite,Finset.sum_ite_irrel] using h
lemma baseFlow_col (hs : βˆ€ i, βˆ‘ a, p i a = 1) (i : I) (t : I β†’ Ξ©) :
(βˆ‘ s, baseFlow p i s t) = density p t := by
have h := pushedFlow_col_test (density p) (fun r a => Function.update r i a)
(fun a b => p i a*p i b) (p i) (fun b => by rw [← Finset.sum_mul,hs, one_mul])
(fun s => if s=t then 1 else 0)
change (βˆ‘ r, βˆ‘ s, baseFlow p i r s*(if s=t then 1 else 0)) =
mean p (average p i (fun s => if s=t then 1 else 0)) at h
rw [mean_average p hs] at h
simpa [mean,mul_ite] using h
lemma baseFlow_energy (hs : βˆ€ i, βˆ‘ a, p i a = 1) (i : I) (f : (I β†’ Ξ©) β†’ ℝ) :
localEnergy (baseFlow p i) f = baseEnergy p i f := by
rw [baseFlow,pushedFlow_energy]
have he (s : I β†’ Ξ©) : localEnergy (fun a b => p i a*p i b) (fun a => f (Function.update s i a)) =
average p i (fun r => (f r-average p i f r)^2) s := by
have h := FiniteVariance.variance_eq_pair (p i) (fun a => f (Function.update s i a)) (hs i)
rw [Fintype.sum_prod_type] at h
unfold localEnergy
rw [← h]
simp only [FiniteVariance.variance,average_apply,Function.update_idem]
simp_rw [he]
change mean p (average p i (fun r => (f r-average p i f r)^2)) = _
rw [mean_average p hs]
exact mean_square p (f-average p i f)
noncomputable def updateCount (guides : I β†’ Finset I) (base : Finset I) : β„• :=
(βˆ‘ x, (guides x).card)+base.card
noncomputable def scanFlow (guides : I β†’ Finset I) (base : Finset I)
(Q : βˆ€ x y, PairCapacity p x y) (s t : I β†’ Ξ©) : ℝ :=
(if s=t then density p s else 0)/2+
((βˆ‘ x, βˆ‘ y ∈ guides x, pairFlow p x y (Q x y) s t)+
βˆ‘ i ∈ base, baseFlow p i s t)/(2*(updateCount guides base:ℝ))
end
section
open Finset
variable {Ξ© J : Type*} [Fintype Ξ©]
lemma localEnergy_add (q r : Ξ© β†’ Ξ© β†’ ℝ) (f : Ξ© β†’ ℝ) :
localEnergy (fun a b => q a b+r a b) f = localEnergy q f+localEnergy r f := by
simp only [localEnergy,add_mul,Finset.sum_add_distrib,add_div]
lemma localEnergy_div (q : Ξ© β†’ Ξ© β†’ ℝ) (c : ℝ) (f : Ξ© β†’ ℝ) :
localEnergy (fun a b => q a b/c) f = localEnergy q f/c := by
simp only [localEnergy,div_mul_eq_mul_div,← Finset.sum_div]
ring
lemma localEnergy_sum (s : Finset J) (q : J β†’ Ξ© β†’ Ξ© β†’ ℝ) (f : Ξ© β†’ ℝ) :
localEnergy (fun a b => βˆ‘ i ∈ s, q i a b) f = βˆ‘ i ∈ s, localEnergy (q i) f := by
classical
induction s using Finset.induction_on with
| empty => simp [localEnergy]
| @insert i s hi ih =>
simp only [Finset.sum_insert hi]
rw [localEnergy_add,ih]
lemma localEnergy_diag [DecidableEq Ξ©] (Ο€ : Ξ© β†’ ℝ) (f : Ξ© β†’ ℝ) :
localEnergy (fun a b => if a=b then Ο€ a else 0) f = 0 := by
unfold localEnergy
have h (a b : Ξ©) : (if a=b then Ο€ a else 0)*(f a-f b)^2 = 0 := by
by_cases hh : a=b <;> simp [hh]
simp_rw [h]; simp
end
open Finset
variable {I Ξ© : Type*} [Fintype I] [DecidableEq I] [Fintype Ξ©] [DecidableEq Ξ©]
variable (p : I β†’ Ξ© β†’ ℝ)
omit [DecidableEq I] in
lemma updateCount_pos (guides : I β†’ Finset I) (base : Finset I) (hb : base.Nonempty) :
0 < updateCount guides base := Nat.add_pos_right _ (Finset.card_pos.mpr hb)
lemma scanFlow_nonneg (hp : βˆ€ i a, 0 ≀ p i a) (guides : I β†’ Finset I) (base : Finset I)
(Q : βˆ€ x y, PairCapacity p x y) (s t : I β†’ Ξ©) : 0 ≀ scanFlow p guides base Q s t := by
unfold scanFlow
apply add_nonneg
Β· apply div_nonneg _ (by norm_num)
split_ifs <;> [exact density_nonneg p hp s; exact le_refl _]
Β· apply div_nonneg _ (by positivity)
exact add_nonneg (Finset.sum_nonneg (fun x _ => Finset.sum_nonneg
(fun y _ => pairFlow_nonneg p hp x y (Q x y) s t)))
(Finset.sum_nonneg (fun i _ => baseFlow_nonneg p hp i s t))
lemma scanFlow_lazy (hp : βˆ€ i a, 0 ≀ p i a) (guides : I β†’ Finset I) (base : Finset I)
(Q : βˆ€ x y, PairCapacity p x y) (s : I β†’ Ξ©) : density p s/2 ≀ scanFlow p guides base Q s s := by
unfold scanFlow
simp only [ite_true,le_add_iff_nonneg_right]
apply div_nonneg _ (by positivity)
exact add_nonneg (Finset.sum_nonneg (fun x _ => Finset.sum_nonneg
(fun y _ => pairFlow_nonneg p hp x y (Q x y) s s)))
(Finset.sum_nonneg (fun i _ => baseFlow_nonneg p hp i s s))
lemma scanFlow_row (hs : βˆ€ i, βˆ‘ a, p i a = 1) (guides : I β†’ Finset I) (base : Finset I)
(hb : base.Nonempty) (Q : βˆ€ x y, PairCapacity p x y) (s : I β†’ Ξ©) :
(βˆ‘ t, scanFlow p guides base Q s t) = density p s := by
have hm : (updateCount guides base:ℝ) β‰  0 := by exact_mod_cast (ne_of_gt (updateCount_pos guides base hb))
unfold scanFlow
rw [Finset.sum_add_distrib,← Finset.sum_div,← Finset.sum_div]
simp only [Finset.sum_ite_eq,Finset.mem_univ,ite_true]
rw [Finset.sum_add_distrib,Finset.sum_comm]
simp_rw [Finset.sum_comm (s := Finset.univ) (t := guides _)]
simp_rw [pairFlow_row p hs]
rw [Finset.sum_comm]
simp only [baseFlow_row p hs,Finset.sum_const,nsmul_eq_mul]
simp only [← Finset.sum_mul]
have hc : (βˆ‘ x, ((guides x).card:ℝ))+(base.card:ℝ) = (updateCount guides base:ℝ) := by
simp [updateCount,Nat.cast_sum]
rw [← add_mul,hc]
field_simp
ring
lemma scanFlow_col (hs : βˆ€ i, βˆ‘ a, p i a = 1) (guides : I β†’ Finset I) (base : Finset I)
(hb : base.Nonempty) (Q : βˆ€ x y, PairCapacity p x y) (t : I β†’ Ξ©) :
(βˆ‘ s, scanFlow p guides base Q s t) = density p t := by
have hm : (updateCount guides base:ℝ) β‰  0 := by exact_mod_cast (ne_of_gt (updateCount_pos guides base hb))
unfold scanFlow
rw [Finset.sum_add_distrib,← Finset.sum_div,← Finset.sum_div]
simp only [Finset.sum_ite_eq',Finset.mem_univ,ite_true]
rw [Finset.sum_add_distrib,Finset.sum_comm]
simp_rw [Finset.sum_comm (s := Finset.univ) (t := guides _)]
simp_rw [pairFlow_col p hs]
rw [Finset.sum_comm]
simp only [baseFlow_col p hs,Finset.sum_const,nsmul_eq_mul]
simp only [← Finset.sum_mul]
have hc : (βˆ‘ x, ((guides x).card:ℝ))+(base.card:ℝ) = (updateCount guides base:ℝ) := by
simp [updateCount,Nat.cast_sum]
rw [← add_mul,hc]
field_simp
ring
lemma scanFlow_energy (hs : βˆ€ i, βˆ‘ a, p i a = 1) (guides : I β†’ Finset I) (base : Finset I)
(Q : βˆ€ x y, PairCapacity p x y) (f : (I β†’ Ξ©) β†’ ℝ) :
localEnergy (scanFlow p guides base Q) f = scanEnergy p guides base Q f := by
unfold scanFlow
rw [localEnergy_add,localEnergy_div,localEnergy_diag,zero_div,zero_add,
localEnergy_div,localEnergy_add]
simp_rw [localEnergy_sum,pairFlow_energy,baseFlow_energy p hs]
rfl
end MatchingFPRAS.Replica
namespace MatchingFPRAS.FiniteChain
open Finset MatchingFPRAS.Replica
variable {Ξ© : Type*} [Fintype Ξ©] [DecidableEq Ξ©]
noncomputable def sqNorm (Ο€ f : Ξ© β†’ ℝ) : ℝ := βˆ‘ a, Ο€ a*(f a)^2
noncomputable def massMean (Ο€ f : Ξ© β†’ ℝ) : ℝ := βˆ‘ a, Ο€ a*f a
noncomputable def stepDensity (Ο€ : Ξ© β†’ ℝ) (C : Ξ© β†’ Ξ© β†’ ℝ) (f : Ξ© β†’ ℝ) (b : Ξ©) : ℝ :=
(βˆ‘ a, C a b*f a)/Ο€ b
omit [DecidableEq Ξ©] in
lemma stepDensity_mean (Ο€ : Ξ© β†’ ℝ) (hp : βˆ€ a, 0 < Ο€ a) (C : Ξ© β†’ Ξ© β†’ ℝ)
(hrow : βˆ€ a, βˆ‘ b, C a b = Ο€ a) (f : Ξ© β†’ ℝ) :
massMean Ο€ (stepDensity Ο€ C f) = massMean Ο€ f := by
unfold massMean stepDensity
simp only [mul_div_cancelβ‚€ _ (ne_of_gt (hp _))]
rw [Finset.sum_comm]
simp_rw [← Finset.sum_mul,hrow]
omit [DecidableEq Ξ©] in
lemma stepDensity_one (Ο€ : Ξ© β†’ ℝ) (hp : βˆ€ a, 0 < Ο€ a) (C : Ξ© β†’ Ξ© β†’ ℝ)
(hcol : βˆ€ b, βˆ‘ a, C a b = Ο€ b) : stepDensity Ο€ C (fun _ => 1) = (fun _ => 1) := by
funext b; simp only [stepDensity,mul_one,hcol,div_self (ne_of_gt (hp b))]
omit [DecidableEq Ξ©] in
lemma stepDensity_linear (Ο€ : Ξ© β†’ ℝ) (C : Ξ© β†’ Ξ© β†’ ℝ) (f g : Ξ© β†’ ℝ) (c d : ℝ) :
stepDensity Ο€ C (fun a => c*f a+d*g a) =
fun b => c*stepDensity Ο€ C f b+d*stepDensity Ο€ C g b := by
funext b
have hc (a : Ξ©) : C a b*(c*f a) = c*(C a b*f a) := by ring
have hd (a : Ξ©) : C a b*(d*g a) = d*(C a b*g a) := by ring
simp only [stepDensity,mul_add,Finset.sum_add_distrib,hc,hd,← Finset.mul_sum,
add_div,mul_div_assoc]
omit [DecidableEq Ξ©] in
lemma stepDensity_jensen (Ο€ : Ξ© β†’ ℝ) (hp : βˆ€ a, 0 < Ο€ a) (C : Ξ© β†’ Ξ© β†’ ℝ)
(hC : βˆ€ a b, 0 ≀ C a b) (hrow : βˆ€ a, βˆ‘ b, C a b = Ο€ a)
(hcol : βˆ€ b, βˆ‘ a, C a b = Ο€ b) (f : Ξ© β†’ ℝ) :
sqNorm Ο€ (stepDensity Ο€ C f) ≀ sqNorm Ο€ f := by
have h (b : Ξ©) : Ο€ b*(stepDensity Ο€ C f b)^2 ≀ βˆ‘ a, C a b*(f a)^2 := by
have hh := square_average (fun a => C a b/Ο€ b) (fun a => div_nonneg (hC a b) (hp b).le)
(by rw [← Finset.sum_div,hcol,div_self (ne_of_gt (hp b))]) f
have he : (βˆ‘ a, (C a b/Ο€ b)*f a) = stepDensity Ο€ C f b := by
simp only [stepDensity,div_mul_eq_mul_div,Finset.sum_div]
rw [he] at hh
have hh := mul_le_mul_of_nonneg_left hh (hp b).le
simp only [div_mul_eq_mul_div,← Finset.sum_div,mul_div_cancelβ‚€ _ (ne_of_gt (hp b))] at hh
exact hh
have hh := Finset.sum_le_sum (fun b (_ : b ∈ Finset.univ) => h b)
rw [Finset.sum_comm] at hh
simp_rw [← Finset.sum_mul,hrow] at hh
exact hh
omit [DecidableEq Ξ©] in
lemma energy_norm_cross (Ο€ : Ξ© β†’ ℝ) (C : Ξ© β†’ Ξ© β†’ ℝ)
(hrow : βˆ€ a, βˆ‘ b, C a b = Ο€ a) (hcol : βˆ€ b, βˆ‘ a, C a b = Ο€ b)
(f : Ξ© β†’ ℝ) : localEnergy C f = sqNorm Ο€ f-(βˆ‘ a, βˆ‘ b, C a b*f a*f b) := by
have he (a b : Ξ©) : C a b*(f a-f b)^2 = C a b*(f a)^2+C a b*(f b)^2-2*(C a b*f a*f b) := by ring
unfold localEnergy
simp_rw [he,Finset.sum_sub_distrib,Finset.sum_add_distrib]
have hl : (βˆ‘ a, βˆ‘ b, C a b*(f a)^2) = sqNorm Ο€ f := by
simp_rw [← Finset.sum_mul,hrow]; rfl
have hr : (βˆ‘ a, βˆ‘ b, C a b*(f b)^2) = sqNorm Ο€ f := by
rw [Finset.sum_comm]; simp_rw [← Finset.sum_mul,hcol]; rfl
simp_rw [← Finset.mul_sum]
rw [hl,hr]; ring
noncomputable def unlazyFlow (Ο€ : Ξ© β†’ ℝ) (C : Ξ© β†’ Ξ© β†’ ℝ) (a b : Ξ©) : ℝ :=
2*C a b-(if a=b then Ο€ a else 0)
omit [Fintype Ξ©] in
lemma unlazyFlow_nonneg (Ο€ : Ξ© β†’ ℝ) (C : Ξ© β†’ Ξ© β†’ ℝ)
(hC : βˆ€ a b, 0 ≀ C a b) (hlazy : βˆ€ a, Ο€ a/2 ≀ C a a) :
βˆ€ a b, 0 ≀ unlazyFlow Ο€ C a b := by
intro a b; unfold unlazyFlow
by_cases h : a=b
Β· subst b; simp only [ite_true]; linarith [hlazy a]
Β· simp only [ite_eq_right h,sub_zero]; exact mul_nonneg (by norm_num) (hC a b)
lemma unlazyFlow_row (Ο€ : Ξ© β†’ ℝ) (C : Ξ© β†’ Ξ© β†’ ℝ) (hrow : βˆ€ a, βˆ‘ b, C a b = Ο€ a) (a : Ξ©) :
(βˆ‘ b, unlazyFlow Ο€ C a b) = Ο€ a := by
simp only [unlazyFlow,Finset.sum_sub_distrib,← Finset.mul_sum,hrow,
Finset.sum_ite_eq,Finset.mem_univ,ite_true]
ring
lemma unlazyFlow_col (Ο€ : Ξ© β†’ ℝ) (C : Ξ© β†’ Ξ© β†’ ℝ) (hcol : βˆ€ b, βˆ‘ a, C a b = Ο€ b) (b : Ξ©) :
(βˆ‘ a, unlazyFlow Ο€ C a b) = Ο€ b := by
simp only [unlazyFlow,Finset.sum_sub_distrib,← Finset.mul_sum,hcol,
Finset.sum_ite_eq',Finset.mem_univ,ite_true]
ring
lemma unlazyFlow_step (Ο€ : Ξ© β†’ ℝ) (hp : βˆ€ a, 0 < Ο€ a) (C : Ξ© β†’ Ξ© β†’ ℝ) (f : Ξ© β†’ ℝ) :
stepDensity Ο€ (unlazyFlow Ο€ C) f = fun b => 2*stepDensity Ο€ C f b-f b := by
funext b
simp only [stepDensity,unlazyFlow,sub_mul,Finset.sum_sub_distrib,ite_mul,zero_mul,
Finset.sum_ite_eq',Finset.mem_univ,ite_true,sub_div,
mul_div_cancel_leftβ‚€ (f b) (ne_of_gt (hp b))]
simp_rw [mul_assoc,← Finset.mul_sum]
ring
lemma lazy_l2 (Ο€ : Ξ© β†’ ℝ) (hp : βˆ€ a, 0 < Ο€ a) (C : Ξ© β†’ Ξ© β†’ ℝ)
(hC : βˆ€ a b, 0 ≀ C a b) (hrow : βˆ€ a, βˆ‘ b, C a b = Ο€ a)
(hcol : βˆ€ b, βˆ‘ a, C a b = Ο€ b) (hlazy : βˆ€ a, Ο€ a/2 ≀ C a a)
(f : Ξ© β†’ ℝ) : sqNorm Ο€ (stepDensity Ο€ C f) ≀ sqNorm Ο€ f-localEnergy C f := by
have hj := stepDensity_jensen Ο€ hp (unlazyFlow Ο€ C) (unlazyFlow_nonneg Ο€ C hC hlazy)
(unlazyFlow_row Ο€ C hrow) (unlazyFlow_col Ο€ C hcol) f
rw [unlazyFlow_step Ο€ hp] at hj
have he : sqNorm Ο€ (fun b => 2*stepDensity Ο€ C f b-f b) =
4*sqNorm Ο€ (stepDensity Ο€ C f)-4*(βˆ‘ a, βˆ‘ b, C a b*f a*f b)+sqNorm Ο€ f := by
have ht (b : Ξ©) : Ο€ b*(2*stepDensity Ο€ C f b-f b)^2 =
4*(Ο€ b*(stepDensity Ο€ C f b)^2)-4*(Ο€ b*stepDensity Ο€ C f b*f b)+Ο€ b*(f b)^2 := by ring
unfold sqNorm
simp_rw [ht,Finset.sum_add_distrib,Finset.sum_sub_distrib,← Finset.mul_sum]
congr 2
simp only [stepDensity,mul_div_cancelβ‚€ _ (ne_of_gt (hp _)),Finset.sum_mul]
rw [Finset.sum_comm]
rw [he] at hj
rw [energy_norm_cross Ο€ C hrow hcol]
linarith
end MatchingFPRAS.FiniteChain
end OAI