Download data/lean/OAI/Combinatorics/MatchingCount/Probability/LocalVariance.lean from introvoyz045/math: direct link, hf CLI and curl.
- Browser
- Download file 19.4 kB
-
https://huggingface.co/datasets/introvoyz045/math/resolve/main/data/lean/OAI/Combinatorics/MatchingCount/Probability/LocalVariance.lean
- Command line
-
hf download hf://datasets/introvoyz045/math/data/lean/OAI/Combinatorics/MatchingCount/Probability/LocalVariance.lean
-
curl -L -o LocalVariance.lean https://huggingface.co/datasets/introvoyz045/math/resolve/main/data/lean/OAI/Combinatorics/MatchingCount/Probability/LocalVariance.lean
19.4 kB
| import Mathlib | |
| import OAI.Combinatorics.MatchingCount.Sampling.RelationDestinations | |
| import OAI.Combinatorics.MatchingCount.Probability.Mean | |
| namespace OAI | |
| namespace MatchingFPRAS.Replica | |
| section | |
| open Finset | |
| variable {I Ξ© : Type*} [Fintype I] [DecidableEq I] [Fintype Ξ©] [DecidableEq Ξ©] | |
| variable (p : I β Ξ© β β) | |
| noncomputable def localVariance (Ο : Ξ© β β) (a : Ξ© β β) : β := | |
| β u, Ο u*(a u-β v, Ο v*a v)^2 | |
| def PairPoincare (x y : I) (Q : PairCapacity p x y) (C : β) : Prop := | |
| β a b : Ξ© β β, localVariance (p x) a β€ C*localEnergy Q.q (fun z => a z.1+b z.2) | |
| omit [Fintype I] [DecidableEq Ξ©] in | |
| lemma invariant_update (i : I) (f : (I β Ξ©) β β) (hi : average p i f = f) | |
| (s : I β Ξ©) (a : Ξ©) : f (Function.update s i a) = f s := by | |
| rw [β hi] | |
| exact average_update p i a f s | |
| omit [DecidableEq Ξ©] in | |
| lemma pairEnergy_shift_invariant (x y : I) (Q : PairCapacity p x y) | |
| (f d : (I β Ξ©) β β) (hx : average p x d = d) (hy : average p y d = d) : | |
| pairEnergy p x y Q (f-d) = pairEnergy p x y Q f := by | |
| have he (s : I β Ξ©) : slice x y (f-d) s = (fun a => slice x y f s a-d s) := by | |
| funext a | |
| change f (replacePair x y s a)-d (Function.update (Function.update s x a.1) y a.2) = _ | |
| rw [invariant_update p y d hy,invariant_update p x d hx] | |
| rfl | |
| unfold pairEnergy | |
| simp_rw [he,localEnergy_shift] | |
| omit [DecidableEq Ξ©] in | |
| lemma pair_poincare_global (hp : β i a, 0 β€ p i a) (hs : β i, β a, p i a = 1) | |
| (x y : I) (hxy : x β y) (Q : PairCapacity p x y) (C : β) (hQ : PairPoincare p x y Q C) | |
| (h k : (I β Ξ©) β β) (hh : average p x h = 0) (hhy : average p y h = h) | |
| (hkx : average p x k = k) : dot p h h β€ C*pairEnergy p x y Q (h+k) := by | |
| have hc (s : I β Ξ©) : (β a, p x a*h (Function.update s x a)) = 0 := by | |
| change average p x h s = 0 | |
| rw [hh]; rfl | |
| have he (s : I β Ξ©) : (fun a : Ξ© Γ Ξ© => | |
| h (Function.update s x a.1)+k (Function.update s y a.2)) = slice x y (h+k) s := by | |
| funext a | |
| change _ = h (Function.update (Function.update s x a.1) y a.2)+ | |
| k (Function.update (Function.update s x a.1) y a.2) | |
| rw [invariant_update p y h hhy,Function.update_comm hxy,invariant_update p x k hkx] | |
| have hi (s : I β Ξ©) : average p x (fun s => (h s)^2) s β€ | |
| C*localEnergy Q.q (slice x y (h+k) s) := by | |
| have hi := hQ (fun a => h (Function.update s x a)) (fun b => k (Function.update s y b)) | |
| unfold localVariance at hi | |
| rw [hc,he] at hi | |
| simpa only [sub_zero,average_apply] using hi | |
| have hi := mean_mono p hp hi | |
| rw [mean_average p hs,mean_square,mean_mul] at hi | |
| exact hi | |
| omit [DecidableEq Ξ©] in | |
| lemma projection_contraction (hp : β i a, 0 β€ p i a) (P : Projection p) (f : (I β Ξ©) β β) : | |
| dot p (P.op f) (P.op f) β€ dot p f f := by | |
| have hh := dot_nonneg p hp (f-P.op f) | |
| rw [projection_pythagoras] at hh | |
| linarith | |
| noncomputable def baseEnergy (i : I) (f : (I β Ξ©) β β) : β := | |
| dot p (f-average p i f) (f-average p i f) | |
| omit [DecidableEq Ξ©] in | |
| lemma baseEnergy_nonneg (hp : β i a, 0 β€ p i a) (i : I) (f : (I β Ξ©) β β) : | |
| 0 β€ baseEnergy p i f := dot_nonneg p hp _ | |
| variable [LinearOrder I] | |
| omit [DecidableEq Ξ©] in | |
| lemma increment_base_bound (hp : β i a, 0 β€ p i a) (hs : β i, β a, p i a = 1) | |
| (i : I) (f : (I β Ξ©) β β) : | |
| dot p (increment p Finset.univ i f) (increment p Finset.univ i f) β€ baseEnergy p i f := by | |
| let P := listProjection p hs ((Finset.univ.filter (i < Β·)).toList) | |
| have he : increment p Finset.univ i f = P.op (f-average p i f) := by | |
| change avgList p _ f-average p i (avgList p _ f) = avgList p _ (f-average p i f) | |
| rw [map_sub,average_comm_list] | |
| rw [he] | |
| exact projection_contraction p hp P (f-average p i f) | |
| omit [DecidableEq Ξ©] in | |
| lemma one_pair (hp : β i a, 0 β€ p i a) (hs : β i, β a, p i a = 1) | |
| (x y : I) (hxy : x < y) (Q : PairCapacity p x y) (L : β) (hL : 0 β€ L) | |
| (hQ : PairPoincare p x y Q (2*L)) (f : (I β Ξ©) β β) : | |
| dot p (increment p Finset.univ x f) (increment p Finset.univ x f) β€ | |
| 4*L*pairEnergy p x y Q f+8*L*dot p (residual p x y f) (residual p x y f) := by | |
| let c := pairCondition p x y f | |
| let h := increment p Finset.univ x f | |
| let k := average p x c-average p x (average p y c) | |
| let d := average p x (average p y c) | |
| have hh : h = average p y c-d := increment_pair_formula p hs x y hxy f | |
| have hhy : average p y h = h := by | |
| rw [hh,map_sub] | |
| change average p y (average p y c)-average p y (average p x (average p y c)) = | |
| average p y c-average p x (average p y c) | |
| rw [average_comm p y x,average_idem p hs] | |
| have hkx : average p x k = k := by | |
| change average p x (average p x c-average p x (average p y c)) = _ | |
| rw [map_sub,average_idem p hs,average_idem p hs] | |
| have hdx : average p x d = d := average_idem p hs x _ | |
| have hdy : average p y d = d := by | |
| change average p y (average p x (average p y c)) = average p x (average p y c) | |
| rw [average_comm,average_idem p hs] | |
| have hhk : h+k = c-residual p x y f-d := by | |
| rw [hh,residual_formula] | |
| change (average p y c-d)+(average p x c-d) = | |
| c-(c-average p x c-average p y c+average p x (average p y c))-d | |
| dsimp [d]; abel | |
| have hpq := pair_poincare_global p hp hs x y (ne_of_lt hxy) Q (2*L) hQ h k | |
| (increment_center p hs Finset.univ x f) hhy hkx | |
| rw [hhk,pairEnergy_shift_invariant p x y Q _ d hdx hdy] at hpq | |
| have hc : pairEnergy p x y Q c β€ pairEnergy p x y Q f := by | |
| apply pairEnergy_avgList p hp hs (outside x y) x y _ Q f | |
| intro i hi | |
| have hi : x < i β§ i β y := by simpa [outside] using hi | |
| exact β¨ne_of_gt hi.1,hi.2β© | |
| have he := pairEnergy_sub p hp x y Q c (residual p x y f) | |
| have hr := pairEnergy_bound p hp hs x y Q (residual p x y f) | |
| nlinarith [mul_nonneg hL (sub_nonneg.mpr hc),mul_nonneg hL (sub_nonneg.mpr hr), | |
| mul_nonneg hL (sub_nonneg.mpr he)] | |
| end | |
| section | |
| open Finset | |
| variable {I Ξ© : Type*} [Fintype I] [DecidableEq I] [LinearOrder I] | |
| [Fintype Ξ©] [DecidableEq Ξ©] | |
| variable (p : I β Ξ© β β) | |
| noncomputable def allowed (guides : I β Finset I) : Finset (I Γ I) := | |
| Finset.univ.filter (fun z => z.2 β guides z.1) | |
| omit [LinearOrder I] in | |
| lemma sum_allowed (guides : I β Finset I) (f : I Γ I β β) : | |
| (β z β allowed guides, f z) = β x, β y β guides x, f (x,y) := by | |
| classical | |
| simp only [allowed,Finset.sum_filter] | |
| rw [Fintype.sum_prod_type] | |
| apply Finset.sum_congr rfl; intro x _ | |
| simpa only [Finset.filter_univ_mem] using | |
| (Finset.sum_filter (s := Finset.univ) (fun y => y β guides x) (fun y => f (x,y))).symm | |
| noncomputable def pairTotal (guides : I β Finset I) (Q : β x y, PairCapacity p x y) | |
| (f : (I β Ξ©) β β) : β := β x, β y β guides x, pairEnergy p x y (Q x y) f | |
| noncomputable def baseTotal (base : Finset I) (f : (I β Ξ©) β β) : β := | |
| β x β base, baseEnergy p x f | |
| noncomputable def scanEnergy (guides : I β Finset I) (base : Finset I) | |
| (Q : β x y, PairCapacity p x y) (f : (I β Ξ©) β β) : β := | |
| (pairTotal p guides Q f+baseTotal p base f)/(2*((β x, (guides x).card)+base.card : β)) | |
| omit [DecidableEq Ξ©] in | |
| theorem replica_gap (hp : β i a, 0 β€ p i a) (hs : β i, β a, p i a = 1) | |
| (guides : I β Finset I) (base : Finset I) (hbase : base.Nonempty) | |
| (q : β) (L : β) (hL : 0 < L) (hq : (q:β) = 32*L) | |
| (hn : β x β base, (guides x).card = q) (hb : β x β base, guides x = β ) | |
| (horder : β x y, y β guides x β x < y) | |
| (Q : β x y, PairCapacity p x y) | |
| (hQ : β x y, y β guides x β PairPoincare p x y (Q x y) (2*L)) | |
| (f : (I β Ξ©) β β) : | |
| variance p f β€ (8*((β x, (guides x).card)+base.card : β)/3:β)* | |
| scanEnergy p guides base Q f := by | |
| classical | |
| let H : I β β := fun x => dot p (increment p Finset.univ x f) (increment p Finset.univ x f) | |
| let B := β x β base, H x | |
| let A := β x β baseαΆ, H x | |
| let E := pairTotal p guides Q f | |
| let F := baseTotal p base f | |
| have hvar : variance p f = A+B := by | |
| have h := Finset.sum_add_sum_compl base H | |
| rw [martingale_variance] | |
| change (β x, H x) = A+B | |
| dsimp [A,B]; linarith | |
| exact hs | |
| have hbaseBound : B β€ F := Finset.sum_le_sum (fun x _ => increment_base_bound p hp hs x f) | |
| have hE : 0 β€ E := Finset.sum_nonneg (fun x _ => Finset.sum_nonneg | |
| (fun y _ => pairEnergy_nonneg p hp x y (Q x y) f)) | |
| have hF : 0 β€ F := Finset.sum_nonneg (fun x _ => baseEnergy_nonneg p hp x f) | |
| have hlhs : (β x, β y β guides x, H x) = (q:β)*A := by | |
| calc | |
| _ = β x, if x β baseαΆ then (q:β)*H x else 0 := by | |
| apply Finset.sum_congr rfl; intro x _ | |
| by_cases hx : x β base | |
| Β· simp [hb x hx,hx] | |
| Β· simp [hx,hn x hx] | |
| _ = β x β baseαΆ, (q:β)*H x := by | |
| simpa only [Finset.filter_univ_mem] using | |
| (Finset.sum_filter (s := Finset.univ) (fun x => x β baseαΆ) (fun x => (q:β)*H x)).symm | |
| _ = _ := by rw [Finset.mul_sum] | |
| have hr : (β x, β y β guides x, dot p (residual p x y f) (residual p x y f)) β€ variance p f := by | |
| have hh := residual_sum p hp hs (allowed guides) | |
| (fun z hz => horder z.1 z.2 (by simpa [allowed] using hz)) f | |
| rw [sum_allowed] at hh | |
| have hv : variance p f = β s, density p s*(f s-β t, density p t*f t)^2 := by | |
| unfold variance dot mean | |
| apply Finset.sum_congr rfl; intro s _ | |
| change density p s*(f s-β t, density p t*f t)*(f s-β t, density p t*f t) = _ | |
| ring | |
| rw [hv] | |
| exact hh | |
| have hpair := Finset.sum_le_sum (fun x (_ : x β (Finset.univ : Finset I)) => | |
| Finset.sum_le_sum (fun y hy => one_pair p hp hs x y (horder x y hy) (Q x y) L | |
| (le_of_lt hL) (hQ x y hy) f)) | |
| change (β x, β y β guides x, H x) β€ _ at hpair | |
| rw [hlhs,hq] at hpair | |
| simp only [Finset.sum_add_distrib,β Finset.mul_sum] at hpair | |
| change 32*L*A β€ 4*L*E+8*L*(β x, β y β guides x, | |
| dot p (residual p x y f) (residual p x y f)) at hpair | |
| have hstrong : variance p f β€ E/6+(4/3:β)*F := by | |
| apply (mul_le_mul_iff_leftβ hL).mp | |
| nlinarith [mul_nonneg (le_of_lt hL) (sub_nonneg.mpr hr), | |
| mul_nonneg (le_of_lt hL) (sub_nonneg.mpr hbaseBound)] | |
| let M : β := ((β x, (guides x).card)+base.card : β) | |
| have hM : 0 < M := by | |
| have hnM : 0 < ((β x, (guides x).card)+base.card : β) := | |
| lt_of_lt_of_le (Finset.card_pos.mpr hbase) (Nat.le_add_left _ _) | |
| dsimp [M] | |
| exact_mod_cast hnM | |
| change variance p f β€ (8*M/3)*((E+F)/(2*M)) | |
| have he : (8*M/3)*((E+F)/(2*M)) = (4/3:β)*(E+F) := by | |
| field_simp [ne_of_gt hM] | |
| ring | |
| rw [he] | |
| linarith | |
| end | |
| open Finset | |
| variable {Ξ© : Type*} [Fintype Ξ©] [DecidableEq Ξ©] | |
| structure SymmetricProposal (Ξ© : Type*) [Fintype Ξ©] where | |
| q : Ξ© β Ξ© β β | |
| nonneg : β a b, 0 β€ q a b | |
| row : β a, β b, q a b = 1 | |
| symmetric : β a b, q a b = q b a | |
| noncomputable def offCapacity (P : SymmetricProposal Ξ©) (Ο : Ξ© β β) (a b : Ξ©) : β := | |
| min (Ο a) (Ο b)*P.q a b | |
| noncomputable def metropolisCapacity (P : SymmetricProposal Ξ©) (Ο : Ξ© β β) (a b : Ξ©) : β := | |
| if a = b then Ο a - β z β Finset.univ.erase a, offCapacity P Ο a z | |
| else offCapacity P Ο a b | |
| omit [DecidableEq Ξ©] in | |
| lemma offCapacity_nonneg (P : SymmetricProposal Ξ©) (Ο : Ξ© β β) | |
| (hΟ : β a, 0 β€ Ο a) (a b : Ξ©) : 0 β€ offCapacity P Ο a b := | |
| mul_nonneg (le_min (hΟ a) (hΟ b)) (P.nonneg a b) | |
| omit [DecidableEq Ξ©] in | |
| lemma offCapacity_le (P : SymmetricProposal Ξ©) (Ο : Ξ© β β) | |
| (a b : Ξ©) : offCapacity P Ο a b β€ Ο a*P.q a b := | |
| mul_le_mul_of_nonneg_right (min_le_left _ _) (P.nonneg a b) | |
| omit [DecidableEq Ξ©] in | |
| lemma offCapacity_symmetric (P : SymmetricProposal Ξ©) (Ο : Ξ© β β) | |
| (a b : Ξ©) : offCapacity P Ο a b = offCapacity P Ο b a := by | |
| simp only [offCapacity,min_comm (Ο a),P.symmetric] | |
| lemma offCapacity_sum_le (P : SymmetricProposal Ξ©) (Ο : Ξ© β β) | |
| (hΟ : β a, 0 β€ Ο a) (a : Ξ©) : | |
| (β z β Finset.univ.erase a, offCapacity P Ο a z) β€ Ο a := by | |
| calc | |
| _ β€ β z, offCapacity P Ο a z := Finset.sum_le_sum_of_subset_of_nonneg | |
| (Finset.erase_subset _ _) (fun z _ _ => offCapacity_nonneg P Ο hΟ a z) | |
| _ β€ β z, Ο a*P.q a z := Finset.sum_le_sum (fun z _ => offCapacity_le P Ο a z) | |
| _ = Ο a := by rw [β Finset.mul_sum,P.row,mul_one] | |
| lemma metropolisCapacity_nonneg (P : SymmetricProposal Ξ©) (Ο : Ξ© β β) | |
| (hΟ : β a, 0 β€ Ο a) (a b : Ξ©) : 0 β€ metropolisCapacity P Ο a b := by | |
| unfold metropolisCapacity | |
| split_ifs | |
| Β· exact sub_nonneg.mpr (offCapacity_sum_le P Ο hΟ a) | |
| Β· exact offCapacity_nonneg P Ο hΟ a b | |
| lemma metropolisCapacity_symmetric (P : SymmetricProposal Ξ©) (Ο : Ξ© β β) | |
| (a b : Ξ©) : metropolisCapacity P Ο a b = metropolisCapacity P Ο b a := by | |
| by_cases h : a = b | |
| Β· subst b; rfl | |
| Β· simp only [metropolisCapacity,ite_eq_right h,ite_eq_right (Ne.symm h)] | |
| exact offCapacity_symmetric P Ο a b | |
| lemma metropolisCapacity_row (P : SymmetricProposal Ξ©) (Ο : Ξ© β β) | |
| (a : Ξ©) : (β b, metropolisCapacity P Ο a b) = Ο a := by | |
| rw [β Finset.sum_erase_add _ _ (Finset.mem_univ a)] | |
| have he : (β b β Finset.univ.erase a, metropolisCapacity P Ο a b) = | |
| β b β Finset.univ.erase a, offCapacity P Ο a b := by | |
| apply Finset.sum_congr rfl; intro b hb | |
| rw [metropolisCapacity,ite_eq_right (Finset.ne_of_mem_erase hb).symm] | |
| rw [he] | |
| simp only [metropolisCapacity,ite_true] | |
| ring | |
| lemma metropolisCapacity_col (P : SymmetricProposal Ξ©) (Ο : Ξ© β β) | |
| (b : Ξ©) : (β a, metropolisCapacity P Ο a b) = Ο b := by | |
| simp_rw [metropolisCapacity_symmetric P Ο] | |
| exact metropolisCapacity_row P Ο b | |
| noncomputable def metropolis (P : SymmetricProposal Ξ©) (Ο : Ξ© β β) (a b : Ξ©) : β := | |
| metropolisCapacity P Ο a b / Ο a | |
| lemma metropolis_row (P : SymmetricProposal Ξ©) (Ο : Ξ© β β) | |
| (hΟ : β a, 0 < Ο a) (a : Ξ©) : (β b, metropolis P Ο a b) = 1 := by | |
| simp only [metropolis,β Finset.sum_div,metropolisCapacity_row] | |
| exact div_self (ne_of_gt (hΟ a)) | |
| lemma metropolis_nonneg (P : SymmetricProposal Ξ©) (Ο : Ξ© β β) | |
| (hΟ : β a, 0 < Ο a) (a b : Ξ©) : 0 β€ metropolis P Ο a b := | |
| div_nonneg (metropolisCapacity_nonneg P Ο (fun a => (hΟ a).le) a b) (hΟ a).le | |
| lemma metropolis_acceptance (P : SymmetricProposal Ξ©) (Ο : Ξ© β β) | |
| (hΟ : β a, 0 < Ο a) (a b : Ξ©) (hab : a β b) : | |
| metropolis P Ο a b = P.q a b*min 1 (Ο b/Ο a) := by | |
| unfold metropolis metropolisCapacity | |
| rw [ite_eq_right hab] | |
| unfold offCapacity | |
| rw [mul_div_right_comm,β min_div_div_right (hΟ a).le,div_self (ne_of_gt (hΟ a)),mul_comm] | |
| lemma metropolis_detailed (P : SymmetricProposal Ξ©) (Ο : Ξ© β β) | |
| (hΟ : β a, 0 < Ο a) (a b : Ξ©) : | |
| Ο a*metropolis P Ο a b = Ο b*metropolis P Ο b a := by | |
| simp only [metropolis,mul_div_cancelβ _ (ne_of_gt (hΟ a)), | |
| mul_div_cancelβ _ (ne_of_gt (hΟ b))] | |
| exact metropolisCapacity_symmetric P Ο a b | |
| lemma metropolis_energy (P : SymmetricProposal Ξ©) (Ο : Ξ© β β) (f : Ξ© β β) : | |
| localEnergy (metropolisCapacity P Ο) f = localEnergy (offCapacity P Ο) f := by | |
| unfold localEnergy | |
| congr 1 | |
| apply Finset.sum_congr rfl; intro a _ | |
| apply Finset.sum_congr rfl; intro b _ | |
| by_cases h : a = b | |
| Β· subst b; simp | |
| Β· simp only [metropolisCapacity,ite_eq_right h] | |
| theorem metropolis_energy_domination (P : SymmetricProposal Ξ©) (Ο ΞΌ : Ξ© β β) | |
| (r : β) (hr : 0 β€ r) (h : β a, r*Ο a β€ ΞΌ a) (f : Ξ© β β) : | |
| r*localEnergy (metropolisCapacity P Ο) f β€ localEnergy (metropolisCapacity P ΞΌ) f := by | |
| rw [metropolis_energy,metropolis_energy] | |
| unfold localEnergy | |
| rw [β mul_div_assoc,Finset.mul_sum] | |
| apply div_le_div_of_nonneg_right _ (by norm_num) | |
| apply Finset.sum_le_sum; intro a _ | |
| rw [Finset.mul_sum] | |
| apply Finset.sum_le_sum; intro b _ | |
| have hh : r*min (Ο a) (Ο b) β€ min (ΞΌ a) (ΞΌ b) := by | |
| apply le_min | |
| Β· exact (mul_le_mul_of_nonneg_left (min_le_left _ _) hr).trans (h a) | |
| Β· exact (mul_le_mul_of_nonneg_left (min_le_right _ _) hr).trans (h b) | |
| calc | |
| _ = (r*min (Ο a) (Ο b))*P.q a b*(f a-f b)^2 := by unfold offCapacity; ring | |
| _ β€ _ := mul_le_mul_of_nonneg_right | |
| (mul_le_mul_of_nonneg_right hh (P.nonneg a b)) (sq_nonneg _) | |
| end MatchingFPRAS.Replica | |
| namespace MatchingFPRAS.Transport | |
| section | |
| open Finset MatchingFPRAS.Replica | |
| variable {V E : Type*} [Fintype V] [DecidableEq V] [Fintype E] [DecidableEq E] | |
| variable (ends : E β Sym2 V) | |
| attribute [local instance] Classical.propDecidable | |
| noncomputable def firstLift {Ξ© : Type*} [Fintype Ξ©] (q : Ξ© β Ξ© β β) | |
| (a b : Ξ© Γ Ξ©) : β := if a.2 = b.2 then q a.1 b.1 else 0 | |
| lemma firstLift_row {Ξ© : Type*} [Fintype Ξ©] (q : Ξ© β Ξ© β β) | |
| (hq : β a, β b, q a b = 1) (a : Ξ© Γ Ξ©) : (β b, firstLift q a b) = 1 := by | |
| classical | |
| simp [Fintype.sum_prod_type,firstLift,hq] | |
| lemma firstLift_symmetric {Ξ© : Type*} [Fintype Ξ©] (q : Ξ© β Ξ© β β) | |
| (hq : β a b, q a b = q b a) (a b : Ξ© Γ Ξ©) : firstLift q a b = firstLift q b a := by | |
| simp [firstLift,eq_comm,hq a.1 b.1] | |
| noncomputable def pairProposalRaw (a b : PM (fun e v => v β ends e) Γ PM (fun e v => v β ends e)) : β := | |
| (firstLift (switchProposal ends) a b + firstLift (colorProposal ends) a b + cycleProposal a b)/3 | |
| noncomputable def pairProposal (hloop : β e, Β¬(ends e).IsDiag) | |
| (hpar : β e, (Finset.univ.filter (fun f => ends f = ends e)).card β€ 2) : | |
| SymmetricProposal (PM (fun e v => v β ends e) Γ PM (fun e v => v β ends e)) where | |
| q := pairProposalRaw ends | |
| nonneg a b := by | |
| unfold pairProposalRaw firstLift | |
| have hs := switchProposal_nonneg ends hloop hpar a.1 b.1 | |
| have hc := colorProposal_nonneg ends hloop hpar a.1 b.1 | |
| have hy := cycleProposal_nonneg a b | |
| split_ifs <;> positivity | |
| row a := by | |
| unfold pairProposalRaw | |
| rw [β Finset.sum_div,Finset.sum_add_distrib,Finset.sum_add_distrib, | |
| firstLift_row _ (switchProposal_row ends),firstLift_row _ (colorProposal_row ends),cycleProposal_row] | |
| norm_num | |
| symmetric a b := by | |
| unfold pairProposalRaw | |
| rw [firstLift_symmetric _ (switchProposal_symmetric ends), | |
| firstLift_symmetric _ (colorProposal_symmetric ends),cycleProposal_symmetric a b] | |
| noncomputable def pairLaw (w z : E β β) (a : PM (fun e v => v β ends e) Γ PM (fun e v => v β ends e)) : β := | |
| gibbs w a.1*gibbs z a.2 | |
| end | |
| open Finset MatchingFPRAS.Replica | |
| variable {Ξ© : Type*} [Fintype Ξ©] [DecidableEq Ξ©] | |
| lemma firstLift_energy (Ο : Ξ© β β) (hΟ : β a, 0 β€ Ο a) (hs : β a, Ο a = 1) | |
| (q : Ξ© β Ξ© β β) (f g : Ξ© β β) : | |
| (β a : Ξ© Γ Ξ©, β b : Ξ© Γ Ξ©, min (Ο a.1*Ο a.2) (Ο b.1*Ο b.2)* | |
| firstLift q a b*((f a.1+g a.2)-(f b.1+g b.2))^2) = | |
| β a, β b, min (Ο a) (Ο b)*q a b*(f a-f b)^2 := by | |
| classical | |
| simp only [Fintype.sum_prod_type,firstLift,mul_ite,ite_mul,zero_mul,mul_zero] | |
| simp only [Finset.sum_ite_eq,Finset.mem_univ,ite_true] | |
| have h (a b c : Ξ©) : | |
| min (Ο a*Ο b) (Ο c*Ο b)*q a c*((f a+g b)-(f c+g b))^2 = | |
| Ο b*(min (Ο a) (Ο c)*q a c*(f a-f c)^2) := by | |
| rw [β min_mul_of_nonneg _ _ (hΟ b)] | |
| ring | |
| simp_rw [h,β Finset.mul_sum] | |
| simp only [β Finset.sum_mul,hs,one_mul] | |
| end MatchingFPRAS.Transport | |
| end OAI | |