introvoyz045's picture
Migrated from GitHub
4a56cd6 verified
Raw History Blame Contribute Delete
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