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