Download data/lean/OAI/Combinatorics/MatchingCount/Graphs/PushedFlow.lean from introvoyz045/math: direct link, hf CLI and curl.
- Browser
- Download file 18.5 kB
-
https://huggingface.co/datasets/introvoyz045/math/resolve/main/data/lean/OAI/Combinatorics/MatchingCount/Graphs/PushedFlow.lean
- Command line
-
hf download hf://datasets/introvoyz045/math/data/lean/OAI/Combinatorics/MatchingCount/Graphs/PushedFlow.lean
-
curl -L -o PushedFlow.lean https://huggingface.co/datasets/introvoyz045/math/resolve/main/data/lean/OAI/Combinatorics/MatchingCount/Graphs/PushedFlow.lean
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 | |