lean/OAI/Combinatorics/MatchingCount/Probability/LocalVariance.lean

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