import Mathlib
import OAI.Computability.MinUncut.Analysis.FreshCorrelation

namespace OAI

noncomputable section
open scoped BigOperators
variable {m n : ℕ}
namespace MinUncut.Average

lemma weighted_sqrt_mul_sqrt {T : Type*} [Fintype T] (w a b : T → ℝ)
    (hw : ∀ t, 0 ≤ w t) (ha : ∀ t, 0 ≤ a t) (hb : ∀ t, 0 ≤ b t) :
    (∑ t, w t * (Real.sqrt (a t) * Real.sqrt (b t))) ≤
      Real.sqrt (∑ t, w t*a t) * Real.sqrt (∑ t, w t*b t) := by
  have he t : w t * (Real.sqrt (a t) * Real.sqrt (b t)) =
      Real.sqrt (w t*a t) * Real.sqrt (w t*b t) := by
    rw [Real.sqrt_mul (hw t), Real.sqrt_mul (hw t)]
    calc
      _ = (Real.sqrt (w t))^2 * (Real.sqrt (a t) * Real.sqrt (b t)) := by rw [Real.sq_sqrt (hw t)]
      _ = _ := by ring
  simp_rw [he]
  exact Real.sum_sqrt_mul_sqrt_le _ (fun t => mul_nonneg (hw t) (ha t))
    (fun t => mul_nonneg (hw t) (hb t))

lemma weighted_sqrt {T : Type*} [Fintype T] (w a : T → ℝ)
    (hw : ∀ t, 0 ≤ w t) (hw1 : ∑ t, w t=1) (ha : ∀ t, 0 ≤ a t) :
    (∑ t, w t * Real.sqrt (a t)) ≤ Real.sqrt (∑ t, w t*a t) := by
  simpa only [Real.sqrt_one, mul_one, hw1] using
    weighted_sqrt_mul_sqrt w a (fun _ => 1) hw ha (fun _ => by norm_num)

lemma expect_sqrt_mul_sqrt {T : Type*} [Fintype T] (a b : T → ℝ)
    (ha : ∀ t, 0 ≤ a t) (hb : ∀ t, 0 ≤ b t) :
    (𝔼 t, Real.sqrt (a t)*Real.sqrt (b t)) ≤
      Real.sqrt (𝔼 t, a t)*Real.sqrt (𝔼 t, b t) := by
  have h := weighted_sqrt_mul_sqrt (fun _ : T => (Fintype.card T:ℝ)⁻¹) a b
    (fun _ => by positivity) ha hb
  simpa only [← Finset.mul_sum, Fintype.expect_eq_sum_div_card, div_eq_mul_inv,
    mul_comm (Fintype.card T:ℝ)⁻¹, ← Finset.sum_mul] using h
end MinUncut.Average

namespace MinUncut.Inner
open MeasureTheory ProbabilityTheory BinaryFourier RowNoise GaussianHermite Subbox
attribute [local instance] Classical.propDecidable

lemma faceCorrelation_sum_le {T : Type*} (S : Finset T) (v : T → Point m n → ℝ) :
    faceCorrelation (fun x => ∑ t ∈ S, v t x) ≤ ∑ t ∈ S, faceCorrelation (v t) := by
  apply faceCorrelation_le
  intro z
  simp_rw [Finset.sum_mul, Finset.expect_sum_comm]
  exact (Finset.abs_sum_le_sum_abs _ _).trans
    (Finset.sum_le_sum (fun t _ => code_correlation_le (v t) z))

lemma faceCorrelation_integrable {Ω : Type*} [MeasurableSpace Ω] {μ : Measure Ω}
    (u : Ω → Point m n → ℝ) (hm : ∀ x, Measurable (fun t => u t x))
    (hi : ∀ x, Integrable (fun t => u t x) μ) :
    Integrable (fun t => faceCorrelation (u t)) μ := by
  have hh : Integrable (fun t => 𝔼 x, |u t x|) μ := by
    simp only [Fintype.expect_eq_sum_div_card]
    exact (integrable_finsetSum _ (fun x _ => (hi x).abs)).div_const _
  exact hh.mono' (faceCorrelation_measurable_field u hm).aestronglyMeasurable
    (ae_of_all _ (fun t => by
      rw [Real.norm_eq_abs, abs_of_nonneg (faceCorrelation_nonneg _)]
      exact faceCorrelation_le_l1 _))

variable {V A : Type*} [AddCommGroup V] [Module F₂ V] [AddTorsor V A] [Fintype A]

def classField (f : FoldedProof A) (σ η : ℝ)
    (J : Finset (Finset (Row m n) × (Point m n → ℕ))) (a : Option (PairClass m))
    (B : FaceArray A m n) (c : Point m n → ℝ) (x : Point m n) : ℝ :=
  selectedProject (classSelection x a J) (fun B c => gradient f B σ η c x) B c

lemma classField_memLp (f : FoldedProof A) (σ η : ℝ)
    (J : Finset (Finset (Row m n) × (Point m n → ℕ))) (a : Option (PairClass m))
    (B : FaceArray A m n) (x : Point m n) :
    MemLp (fun c => classField f σ η J a B c x) 2 (γpi (Point m n)) :=
  memLp_selectedProject _ _ _

lemma classField_measurable (f : FoldedProof A) (σ η : ℝ)
    (J : Finset (Finset (Row m n) × (Point m n → ℕ))) (a : Option (PairClass m))
    (B : FaceArray A m n) (x : Point m n) :
    Measurable (fun c => classField f σ η J a B c x) :=
  (selectedProject_continuous _ _ _).measurable

lemma classField_correlation_integrable (f : FoldedProof A) (σ η : ℝ)
    (J : Finset (Finset (Row m n) × (Point m n → ℕ))) (a : Option (PairClass m))
    (B : FaceArray A m n) :
    Integrable (fun c => faceCorrelation (classField f σ η J a B c)) (γpi (Point m n)) :=
  faceCorrelation_integrable _ (classField_measurable f σ η J a B)
    (fun x => (classField_memLp f σ η J a B x).integrable (by norm_num))

lemma lowGradient_class_partition (D s : ℕ) (f : FoldedProof A) (σ η : ℝ)
    (B : FaceArray A m n) (c : Point m n → ℝ) (x : Point m n) :
    lowGradient D s f σ η B c x =
      ∑ a : Option (PairClass m), classField f σ η (rectangle D s) a B c x :=
  classSelection_partition x _ _

lemma lowGradient_classes_correlation (D s : ℕ) (f : FoldedProof A) (σ η : ℝ) :
    averagedCorrelation (lowGradient (m := m) (n := n) D s f σ η) ≤
      ∑ a : Option (PairClass m), averagedCorrelation (classField (n := n) f σ η (rectangle D s) a) := by
  have hp (B : FaceArray A m n) (c : Point m n → ℝ) :
      faceCorrelation (lowGradient D s f σ η B c) ≤
        ∑ a : Option (PairClass m), faceCorrelation (classField f σ η (rectangle D s) a B c) := by
    conv_lhs => arg 1; ext x; rw [lowGradient_class_partition]
    exact faceCorrelation_sum_le _ _
  unfold averagedCorrelation
  rw [← Finset.expect_sum_comm]
  apply Finset.expect_le_expect
  intro B _
  calc
    _ ≤ ∫ c, (∑ a : Option (PairClass m), faceCorrelation (classField f σ η (rectangle D s) a B c)) ∂γpi (Point m n) :=
      integral_mono (lowGradient_correlation_integrable D s f σ η B)
        (integrable_finsetSum _ (fun a _ => classField_correlation_integrable f σ η (rectangle D s) a B)) (hp B)
    _ = _ := integral_finsetSum _ (fun a _ => classField_correlation_integrable f σ η (rectangle D s) a B)
end MinUncut.Inner

namespace MinUncut.RowNoise
open MeasureTheory ProbabilityTheory GaussianHermite
variable {R W ι : Type*} [Fintype R] [DecidableEq R] [Fintype W] [Nonempty W] [Fintype ι]

def jointL1 (u : (R → W) → (ι → ℝ) → ℝ) : ℝ :=
  𝔼 B, ∫ c, |u B c| ∂γpi ι

lemma jointL1_le_sqrt (u : (R → W) → (ι → ℝ) → ℝ)
    (hu : ∀ B, MemLp (u B) 2 (γpi ι)) : jointL1 u ≤ Real.sqrt (jointEnergy u) := by
  have hi (B : R → W) : (∫ c, |u B c| ∂γpi ι) ≤ Real.sqrt (∫ c, (u B c)^2 ∂γpi ι) := by
    simpa using integral_norm_mul_le_sqrt (hu B) (memLp_const (1:ℝ) (p := 2) (μ := γpi ι))
  exact (Finset.expect_le_expect (fun B _ => hi B)).trans
    (expect_sqrt_le _ (fun B => integral_nonneg (fun c => sq_nonneg _)))
end MinUncut.RowNoise

namespace MinUncut.Inner
open MeasureTheory ProbabilityTheory BinaryFourier RowNoise GaussianHermite Subbox
attribute [local instance] Classical.propDecidable
variable {V A : Type*} [AddCommGroup V] [Module F₂ V] [AddTorsor V A] [Fintype A]

lemma averagedEnergy_eq_expect_joint
    (u : FaceArray A m n → (Point m n → ℝ) → Point m n → ℝ)
    (hu : ∀ B x, MemLp (fun c => u B c x) 2 (γpi (Point m n))) :
    averagedEnergy u = 𝔼 x, jointEnergy (fun B c => u B c x) := by
  rw [averagedEnergy_eq_jointEnergy u hu]
  simp only [Fintype.expect_eq_sum_div_card, Fintype.card_fun, Point, Fintype.card_fin]
  ring

lemma retainedClass_localized (x : Point m n) {k : ℕ} (Y : PointedBox x k)
    (a : Option (PairClass m)) (J : Finset (Finset (Row m n) × (Point m n → ℕ))) :
    retainedClass x Y a J=localizedSelection x Y (classSelection x a J) := rfl

lemma class_localization_energy (f : FoldedProof A) {σ : ℝ} (hσ : σ≠0) (η : ℝ)
    (hn : 2 ≤ n) {k s D : ℕ} (hk : k ≤ n-1)
    (J : Finset (Finset (Row m n) × (Point m n → ℕ)))
    (hJ : ∀ j ∈ J, (∑ u, j.2 u) ≤ s ∧ j.1.card ≤ D) (a : Option (PairClass m)) :
    (𝔼 x : Point m n, 𝔼 Y : PointedBox x k, jointEnergy (fun B c =>
      classField f σ η J a B c x-
      selectedProject (retainedClass x Y a J) (fun B c => gradient f B σ η c x) B c)) ≤
      ((s+D:ℕ):ℝ)*((k:ℝ)/((n:ℝ)-1))*σ⁻¹^2 := by
  have : NeZero n := ⟨by omega⟩
  have hnR : 0 ≤ (n:ℝ)-1 := by
    have : (2:ℝ) ≤ n := by exact_mod_cast hn
    linarith
  let δ : ℝ := ((s+D:ℕ):ℝ)*((k:ℝ)/((n:ℝ)-1))
  have hd : 0 ≤ δ := by dsimp [δ]; positivity
  have hx (x : Point m n) :
      (𝔼 Y : PointedBox x k, jointEnergy (fun B c => classField f σ η J a B c x-
        selectedProject (retainedClass x Y a J) (fun B c => gradient f B σ η c x) B c)) ≤
      δ*jointEnergy (fun B c => gradient f B σ η c x) := by
    have hh := localization_energy_loss (W := Forms A) x (by simpa using hk)
      (classSelection x a J) (fun j hj => hJ j (Finset.mem_filter.mp hj).1)
      (fun B c => gradient f B σ η c x)
    change (𝔼 Y : PointedBox x k, jointEnergy (fun B c => classField f σ η J a B c x-
        selectedProject (retainedClass x Y a J) (fun B c => gradient f B σ η c x) B c)) ≤
      ((s+D:ℕ):ℝ)*((k:ℝ)/(Fintype.card (Fin n)-1))*
        jointEnergy (selectedProject (classSelection x a J) (fun B c => gradient f B σ η c x)) at hh
    simp only [Fintype.card_fin] at hh
    exact hh.trans
      (mul_le_mul_of_nonneg_left
        (selectedProject_energy_le (classSelection x a J) _ (fun B => gradient_memLp f B hσ η x)) hd)
  calc
    _ ≤ 𝔼 x : Point m n, δ*jointEnergy (fun B c => gradient f B σ η c x) :=
      Finset.expect_le_expect (fun x _ => hx x)
    _ = δ*averagedEnergy (fun B c => gradient f B σ η c) := by
      rw [← Finset.mul_expect, averagedEnergy_eq_expect_joint _ (fun B x => gradient_memLp f B hσ η x)]
    _ ≤ _ := mul_le_mul_of_nonneg_left (averagedEnergy_gradient_le f (by omega) hσ η) hd

lemma class_localization_l1 (f : FoldedProof A) {σ : ℝ} (hσ : 0<σ) (η : ℝ)
    (hn : 2 ≤ n) {k s D : ℕ} (hk : k ≤ n-1)
    (J : Finset (Finset (Row m n) × (Point m n → ℕ)))
    (hJ : ∀ j ∈ J, (∑ u, j.2 u) ≤ s ∧ j.1.card ≤ D) (a : Option (PairClass m)) :
    (𝔼 x : Point m n, 𝔼 Y : PointedBox x k, jointL1 (fun B c =>
      classField f σ η J a B c x-
      selectedProject (retainedClass x Y a J) (fun B c => gradient f B σ η c x) B c)) ≤
      σ⁻¹*Real.sqrt (((s+D:ℕ):ℝ)*((k:ℝ)/((n:ℝ)-1))) := by
  have : NeZero n := ⟨by omega⟩
  have hnR : 0 ≤ (n:ℝ)-1 := by
    have : (2:ℝ) ≤ n := by exact_mod_cast hn
    linarith
  have (x : Point m n) (i : Fin m) : Nonempty (OuterSmoothness.FixedSets (Away (x i)) k) :=
    OuterSmoothness.fixedSets_nonempty (by simpa [card_away] using hk)
  let u := fun (x : Point m n) (Y : PointedBox x k) B c =>
    classField f σ η J a B c x-
      selectedProject (retainedClass x Y a J) (fun B c => gradient f B σ η c x) B c
  have hu x Y B : MemLp (u x Y B) 2 (γpi (Point m n)) :=
    (classField_memLp f σ η J a B x).sub (memLp_selectedProject _ _ _)
  calc
    _ ≤ 𝔼 x : Point m n, 𝔼 Y : PointedBox x k, Real.sqrt (jointEnergy (u x Y)) :=
      Finset.expect_le_expect (fun x _ => Finset.expect_le_expect (fun Y _ => jointL1_le_sqrt _ (hu x Y)))
    _ ≤ Real.sqrt (𝔼 x : Point m n, 𝔼 Y : PointedBox x k, jointEnergy (u x Y)) := by
      apply le_trans (Finset.expect_le_expect (fun x _ => expect_sqrt_le _ (fun Y => jointEnergy_nonneg (u x Y))))
      exact expect_sqrt_le _ (fun x => Finset.expect_nonneg (fun Y _ => jointEnergy_nonneg (u x Y)))
    _ ≤ Real.sqrt (((s+D:ℕ):ℝ)*((k:ℝ)/((n:ℝ)-1))*σ⁻¹^2) :=
      Real.sqrt_le_sqrt (class_localization_energy f hσ.ne' η hn hk J hJ a)
    _ = _ := by
      rw [Real.sqrt_mul (by positivity), Real.sqrt_sq (inv_nonneg.mpr hσ.le), mul_comm]
end MinUncut.Inner

namespace MinUncut.Slice
open MeasureTheory GaussianHermite BinaryFourier
open scoped BigOperators
variable {Ω T W : Type*} [MeasurableSpace Ω] [Fintype T]
  [Fintype W] [AddCommGroup W] [Module F₂ W] {μ : Measure Ω} [IsProbabilityMeasure μ]

lemma processed_average_integral_loss (one : W) (v : T → Ω → W → ℝ)
    (hm : ∀ t w, Measurable (fun c => v t c w))
    (hv : ∀ t w, MemLp (fun c => v t c w) 2 μ)
    {H γ A : ℝ} (hH : 0<H) (hγ : 0<γ) (hA : 0<A) :
    (𝔼 t, ∫ c, (𝔼 w, |v t c w-processed H γ A one (v t c) w|) ∂μ) ≤
      (𝔼 t, ∫ c, energy (v t) c ∂μ)/H +
      Real.sqrt (𝔼 t, ∫ c, energy (v t) c ∂μ)*
        Real.sqrt ((𝔼 t, ∫ c, oddMax one (v t c) ∂μ)/γ) +
      (𝔼 t, ∫ c, energy (v t) c ∂μ)/A := by
  classical
  have he t : 0≤∫ c, energy (v t) c ∂μ := integral_nonneg (energy_nonneg (v t))
  have hq t : 0≤(∫ c, oddMax one (v t c) ∂μ)/γ :=
    div_nonneg (integral_nonneg (fun c => oddMax_nonneg one (v t c))) hγ.le
  calc
    _ ≤ 𝔼 t, ((∫ c, energy (v t) c ∂μ)/H +
        Real.sqrt (∫ c, energy (v t) c ∂μ)*Real.sqrt ((∫ c, oddMax one (v t c) ∂μ)/γ) +
        (∫ c, energy (v t) c ∂μ)/A) :=
      Finset.expect_le_expect (fun t _ => processed_integral_loss one (v t) (hm t) (hv t) hH hγ hA)
    _ = (𝔼 t, ∫ c, energy (v t) c ∂μ)/H +
        (𝔼 t, Real.sqrt (∫ c, energy (v t) c ∂μ)*Real.sqrt ((∫ c, oddMax one (v t c) ∂μ)/γ)) +
        (𝔼 t, ∫ c, energy (v t) c ∂μ)/A := by
      simp only [Finset.expect_add_distrib, Finset.expect_div]
    _ ≤ _ := by
      have hcs := Average.expect_sqrt_mul_sqrt
        (fun t => ∫ c, energy (v t) c ∂μ) (fun t => (∫ c, oddMax one (v t c) ∂μ)/γ) he hq
      rw [← Finset.expect_div] at hcs
      linarith only [hcs]
end MinUncut.Slice

namespace MinUncut.Inner
open MeasureTheory ProbabilityTheory BinaryFourier RowNoise GaussianHermite Subbox
attribute [local instance] Classical.propDecidable
variable {V A : Type*} [AddCommGroup V] [Module F₂ V] [AddTorsor V A] [Fintype A]

def pairProcessed (f : FoldedProof A) (σ η : ℝ) (x : Point m n)
    {k : ℕ} (Y : PointedBox x k) (p : PairClass m)
    (J : Finset (Finset (Row m n) × (Point m n → ℕ))) (H γ A₀ : ℝ)
    (B : FaceArray A m n) (c : Point m n → ℝ) : ℝ :=
  Slice.processed H γ A₀ (AffineMap.const F₂ A 1) (pairSlice f σ η x Y p J B c)
    (B ⟨p.val.1,face x p.val.1⟩+B ⟨p.val.2,face x p.val.2⟩)

lemma pairSlice_resample (f : FoldedProof A) (σ η : ℝ) (x : Point m n)
    {k : ℕ} (Y : PointedBox x k) (p : PairClass m)
    (J : Finset (Finset (Row m n) × (Point m n → ℕ))) (B : FaceArray A m n) (b : Forms A) :
    pairSlice f σ η x Y p J (joinRow ⟨p.val.1,face x p.val.1⟩ b (fun t => B t.val)) =
      pairSlice f σ η x Y p J B := by
  apply pairSlice_background
  intro t ht
  have htr : t≠⟨p.val.1,face x p.val.1⟩ := by
    rintro rfl
    exact ht (local_free_left x Y p)
  exact joinRow_other _ _ _ ⟨t,htr⟩

attribute [local irreducible] gradient selectedProject retainedClass pairSlice pairProcessed Slice.processed

lemma pair_processing_loss_law (f : FoldedProof A) {σ : ℝ} (hσ : σ≠0) (η : ℝ)
    (x : Point m n) {k : ℕ} (Y : PointedBox x k) (p : PairClass m)
    (J : Finset (Finset (Row m n) × (Point m n → ℕ))) (H γ A₀ : ℝ) (c : Point m n → ℝ) :
    (𝔼 B : FaceArray A m n, |selectedProject (retainedClass x Y (some p) J)
      (fun B c => gradient f B σ η c x) B c - pairProcessed f σ η x Y p J H γ A₀ B c|) =
    𝔼 B : FaceArray A m n, 𝔼 b : Forms A, |pairSlice f σ η x Y p J B c b -
      Slice.processed H γ A₀ (AffineMap.const F₂ A 1) (pairSlice f σ η x Y p J B c) b| := by
  let r : Row m n := ⟨p.val.1,face x p.val.1⟩
  let s : Row m n := ⟨p.val.2,face x p.val.2⟩
  have hsr : s≠r := by
    intro h
    exact (ne_of_lt p.property) (congrArg Sigma.fst h).symm
  let L := fun B : FaceArray A m n => |selectedProject (retainedClass x Y (some p) J)
      (fun B c => gradient f B σ η c x) B c - pairProcessed f σ η x Y p J H γ A₀ B c|
  have hB (B : FaceArray A m n) :
      (𝔼 b : Forms A, L (joinRow r b (fun t => B t.val))) =
      𝔼 b : Forms A, |pairSlice f σ η x Y p J B c b -
        Slice.processed H γ A₀ (AffineMap.const F₂ A 1) (pairSlice f σ η x Y p J B c) b| := by
    calc
      _ = 𝔼 b : Forms A, |pairSlice f σ η x Y p J B c (B s+b) -
          Slice.processed H γ A₀ (AffineMap.const F₂ A 1) (pairSlice f σ η x Y p J B c) (B s+b)| := by
        apply Finset.expect_congr rfl
        intro b _
        dsimp only [L]
        rw [pairSlice_row f hσ]
        unfold pairProcessed
        rw [pairSlice_resample, joinRow_at, joinRow_other _ _ _ ⟨s,hsr⟩]
        rw [add_comm b]
      _ = _ := expect_translate (fun b => |pairSlice f σ η x Y p J B c b -
          Slice.processed H γ A₀ (AffineMap.const F₂ A 1) (pairSlice f σ η x Y p J B c) b|) (B s)
  exact (expect_resample_row r L).symm.trans (Finset.expect_congr rfl (fun B _ => hB B))

open MeasureTheory ProbabilityTheory BinaryFourier RowNoise GaussianHermite Subbox
attribute [local instance] Classical.propDecidable
variable {V A : Type*} [AddCommGroup V] [Module F₂ V] [AddTorsor V A] [Fintype A]

lemma pairProcessed_measurable (f : FoldedProof A) (σ η : ℝ) (x : Point m n)
    {k : ℕ} (Y : PointedBox x k) (p : PairClass m)
    (J : Finset (Finset (Row m n) × (Point m n → ℕ))) (H γ A₀ : ℝ) (B : FaceArray A m n) :
    Measurable (pairProcessed f σ η x Y p J H γ A₀ B) := by
  unfold pairProcessed
  exact Slice.processed_measurable _ _ (pairSlice_measurable f σ η x Y p J B) _ _ _ _

lemma pairProcessed_memLp (f : FoldedProof A) (σ η : ℝ) (x : Point m n)
    {k : ℕ} (Y : PointedBox x k) (p : PairClass m)
    (J : Finset (Finset (Row m n) × (Point m n → ℕ))) (H γ : ℝ) {A₀ : ℝ} (hA : 0≤A₀)
    (B : FaceArray A m n) : MemLp (pairProcessed f σ η x Y p J H γ A₀ B) 2 (γpi (Point m n)) := by
  unfold pairProcessed
  exact Slice.processed_memLp _ _ (pairSlice_measurable f σ η x Y p J B) hA _

lemma pairSlice_jointEnergy (f : FoldedProof A) {σ : ℝ} (hσ : σ≠0) (η : ℝ)
    (x : Point m n) {k : ℕ} (Y : PointedBox x k) (p : PairClass m)
    (J : Finset (Finset (Row m n) × (Point m n → ℕ))) :
    (𝔼 B : FaceArray A m n, ∫ c, Slice.energy (pairSlice f σ η x Y p J B) c ∂γpi (Point m n)) =
      jointEnergy (selectedProject (retainedClass x Y (some p) J) (fun B c => gradient f B σ η c x)) := by
  rw [← integral_expect _ (fun B => Slice.energy_integrable _ (pairSlice_memLp f σ η x Y p J B))]
  change (∫ c, (𝔼 B : FaceArray A m n, 𝔼 b : Forms A,
    (pairSlice f σ η x Y p J B c b)^2) ∂γpi (Point m n)) = _
  simp_rw [pairSlice_energy_law f hσ]
  exact integral_expect _ (fun B => (memLp_selectedProject _ _ B).integrable_sq)

lemma pair_processing_loss_integral (f : FoldedProof A) {σ : ℝ} (hσ : σ≠0) (η : ℝ)
    (x : Point m n) {k : ℕ} (Y : PointedBox x k) (p : PairClass m)
    (J : Finset (Finset (Row m n) × (Point m n → ℕ))) {H γ A₀ : ℝ}
    (hH : 0<H) (hγ : 0<γ) (hA : 0<A₀) :
    jointL1 (fun B c => selectedProject (retainedClass x Y (some p) J)
      (fun B c => gradient f B σ η c x) B c - pairProcessed f σ η x Y p J H γ A₀ B c) ≤
      jointEnergy (selectedProject (retainedClass x Y (some p) J) (fun B c => gradient f B σ η c x))/H +
      Real.sqrt (jointEnergy (selectedProject (retainedClass x Y (some p) J) (fun B c => gradient f B σ η c x))) *
        Real.sqrt ((𝔼 B : FaceArray A m n, ∫ c, Slice.oddMax (AffineMap.const F₂ A 1)
          (pairSlice f σ η x Y p J B c) ∂γpi (Point m n))/γ) +
      jointEnergy (selectedProject (retainedClass x Y (some p) J) (fun B c => gradient f B σ η c x))/A₀ := by
  have hi B : Integrable (fun c => |selectedProject (retainedClass x Y (some p) J)
      (fun B c => gradient f B σ η c x) B c - pairProcessed f σ η x Y p J H γ A₀ B c|) (γpi (Point m n)) :=
    ((memLp_selectedProject _ _ _).sub (pairProcessed_memLp f σ η x Y p J H γ hA.le B)).integrable (by norm_num) |>.abs
  have hj B : Integrable (fun c => 𝔼 b : Forms A, |pairSlice f σ η x Y p J B c b -
      Slice.processed H γ A₀ (AffineMap.const F₂ A 1) (pairSlice f σ η x Y p J B c) b|) (γpi (Point m n)) := by
    simp only [Fintype.expect_eq_sum_div_card]
    apply Integrable.div_const
    apply integrable_finsetSum
    intro b _
    exact ((pairSlice_memLp f σ η x Y p J B b).sub
      (Slice.processed_memLp _ _ (pairSlice_measurable f σ η x Y p J B) hA.le b)).integrable (by norm_num) |>.abs
  have hh := Slice.processed_average_integral_loss (μ := γpi (Point m n)) (AffineMap.const F₂ A 1)
    (pairSlice f σ η x Y p J) (pairSlice_measurable f σ η x Y p J) (pairSlice_memLp f σ η x Y p J) hH hγ hA
  rw [pairSlice_jointEnergy f hσ] at hh
  apply le_trans ?_ hh
  unfold jointL1
  rw [← integral_expect _ hi, ← integral_expect _ hj]
  exact le_of_eq (integral_congr_ae (ae_of_all _ (pair_processing_loss_law f hσ η x Y p J H γ A₀)))

open MeasureTheory ProbabilityTheory BinaryFourier RowNoise GaussianHermite Subbox
attribute [local instance] Classical.propDecidable
variable {V A : Type*} [AddCommGroup V] [Module F₂ V] [AddTorsor V A] [Fintype A]

lemma pairSlice_atom_integral_law (f : FoldedProof A) {σ : ℝ} (hσ : σ≠0) (η : ℝ)
    (x : Point m n) {k : ℕ} (Y : PointedBox x k) (p : PairClass m)
    (J : Finset (Finset (Row m n) × (Point m n → ℕ))) :
    (𝔼 B : FaceArray A m n, ∫ c, Slice.oddMax (AffineMap.const F₂ A 1)
        (pairSlice f σ η x Y p J B c) ∂γpi (Point m n)) =
      𝔼 D, ∫ c, oddAtom ⟨p.val.1,face x p.val.1⟩ (AffineMap.const F₂ A 1)
        (fun B => selectedProject (retainedClass x Y (some p) J) (fun B c => gradient f B σ η c x) B c) D ∂γpi (Point m n) := by
  rw [← integral_expect _ (fun B => (Slice.oddMax_memLp _ _
    (pairSlice_memLp f σ η x Y p J B)).integrable (by norm_num))]
  simp_rw [pairSlice_atom_mean f hσ]
  exact integral_expect _ (fun D => (memLp_oddAtom _ _ _ (memLp_selectedProject _ _) D).integrable (by norm_num))

lemma pairSlice_atom_integral_le (f : FoldedProof A) {σ : ℝ} (hσ : σ≠0) (η : ℝ)
    (x : Point m n) {k : ℕ} (Y : PointedBox x k) (p : PairClass m)
    (J : Finset (Finset (Row m n) × (Point m n → ℕ))) :
    (𝔼 B : FaceArray A m n, ∫ c, Slice.oddMax (AffineMap.const F₂ A 1)
        (pairSlice f σ η x Y p J B c) ∂γpi (Point m n)) ≤
      (J.card:ℝ)*(2:ℝ)^Fintype.card (Row m n) * Real.sqrt
        (𝔼 D, ∫ c, (oddAtom ⟨p.val.1,face x p.val.1⟩ (AffineMap.const F₂ A 1)
          (fun B => gradient f B σ η c x) D)^2 ∂γpi (Point m n)) := by
  rw [pairSlice_atom_integral_law f hσ]
  have hh := selectedProject_atom_mean (retainedClass x Y (some p) J)
    ⟨p.val.1,face x p.val.1⟩ (AffineMap.const F₂ A 1)
    (fun B c => gradient f B σ η c x) (fun B => gradient_memLp f B hσ η x)
  apply hh.trans
  gcongr
  intro j hj
  unfold retainedClass classSelection at hj
  exact (Finset.mem_filter.mp (Finset.mem_filter.mp hj).1).1

lemma retained_energy_le (f : FoldedProof A) {σ : ℝ} (hσ : σ≠0) (η : ℝ)
    (x : Point m n) {k : ℕ} (Y : PointedBox x k) (a : Option (PairClass m))
    (J : Finset (Finset (Row m n) × (Point m n → ℕ))) :
    jointEnergy (selectedProject (retainedClass x Y a J) (fun B c => gradient f B σ η c x)) ≤
      jointEnergy (fun B c => gradient f B σ η c x) :=
  selectedProject_energy_le _ _ (fun B => gradient_memLp f B hσ η x)
end MinUncut.Inner

open scoped BigOperators
variable {m n : ℕ}
namespace MinUncut.RowNoise
open MeasureTheory ProbabilityTheory GaussianHermite
variable {R W ι : Type*} [Fintype R] [DecidableEq R] [Fintype W] [Nonempty W] [Fintype ι]

omit [Nonempty W] in
lemma jointL1_sub_triangle (u v w : (R → W) → (ι → ℝ) → ℝ)
    (hu : ∀ B, MemLp (u B) 2 (γpi ι)) (hv : ∀ B, MemLp (v B) 2 (γpi ι))
    (hw : ∀ B, MemLp (w B) 2 (γpi ι)) :
    jointL1 (fun B c => u B c-w B c) ≤
      jointL1 (fun B c => u B c-v B c)+jointL1 (fun B c => v B c-w B c) := by
  unfold jointL1
  rw [← Finset.expect_add_distrib]
  apply Finset.expect_le_expect
  intro B _
  change (∫ c, |u B c-w B c| ∂γpi ι) ≤
    (∫ c, |(u B-v B) c| ∂γpi ι) + (∫ c, |(v B-w B) c| ∂γpi ι)
  rw [← integral_add ((hu B).sub (hv B) |>.integrable (by norm_num) |>.abs)
    ((hv B).sub (hw B) |>.integrable (by norm_num) |>.abs)]
  apply integral_mono ((hu B).sub (hw B) |>.integrable (by norm_num) |>.abs)
    (((hu B).sub (hv B) |>.integrable (by norm_num) |>.abs).add
      ((hv B).sub (hw B) |>.integrable (by norm_num) |>.abs))
  intro c
  simpa only [sub_add_sub_cancel, Pi.add_apply, Pi.sub_apply] using abs_add_le (u B c-v B c) (v B c-w B c)
end MinUncut.RowNoise

namespace MinUncut.Inner
open MeasureTheory ProbabilityTheory BinaryFourier RowNoise GaussianHermite Subbox
attribute [local instance] Classical.propDecidable
attribute [local irreducible] faceCorrelation pointEmbed pointBox
variable {V A : Type*} [AddCommGroup V] [Module F₂ V] [AddTorsor V A] [Fintype A]

lemma pointedJointL1_bayes {k : ℕ}
    (u : (x : Point m n) → PointedBox x k → FaceArray A m n → (Point m n → ℝ) → ℝ)
    (hu : ∀ x Y B, Integrable (u x Y B) (γpi (Point m n))) :
    (𝔼 x : Point m n, 𝔼 Y : PointedBox x k, jointL1 (u x Y)) =
      𝔼 Y : UnpointedBox (Fin m) (Fin n) k, 𝔼 B : FaceArray A m n,
        ∫ c, (𝔼 t : Point m (k+1), |u (pointEmbed Y t) (pointBox Y t) B c|) ∂γpi (Point m n) := by
  rw [pointed_bayes]
  apply Finset.expect_congr rfl
  intro Y _
  unfold jointL1
  rw [Finset.expect_comm]
  apply Finset.expect_congr rfl
  intro B _
  exact (integral_expect _ (fun t => (hu (pointEmbed Y t) (pointBox Y t) B).abs)).symm

lemma faceCorrelation_pointed_compare {k : ℕ} (hk : k≤n-1)
    (u : Point m n → ℝ) (v : (x : Point m n) → PointedBox x k → ℝ) :
    faceCorrelation u ≤
      (𝔼 Y : UnpointedBox (Fin m) (Fin n) k,
        faceCorrelation (fun t : Point m (k+1) => v (pointEmbed Y t) (pointBox Y t))) +
      (𝔼 Y : UnpointedBox (Fin m) (Fin n) k,
        𝔼 t : Point m (k+1), |u (pointEmbed Y t)-v (pointEmbed Y t) (pointBox Y t)|) := by
  have ht := faceCorrelation_restriction hk u
  rw [← Finset.expect_add_distrib]
  apply ht.trans
  apply Finset.expect_le_expect
  intro Y _
  have hl := faceCorrelation_lipschitz (fun t : Point m (k+1) => u (pointEmbed Y t))
    (fun t : Point m (k+1) => v (pointEmbed Y t) (pointBox Y t))
  linarith only [le_trans (le_abs_self _) hl]

lemma averagedCorrelation_pointed_compare {k : ℕ} (hk : k≤n-1)
    (u : FaceArray A m n → (Point m n → ℝ) → Point m n → ℝ)
    (v : (x : Point m n) → PointedBox x k → FaceArray A m n → (Point m n → ℝ) → ℝ)
    (hum : ∀ B x, Measurable (fun c => u B c x))
    (hui : ∀ B x, Integrable (fun c => u B c x) (γpi (Point m n)))
    (hvm : ∀ x Y B, Measurable (v x Y B))
    (hvi : ∀ x Y B, Integrable (v x Y B) (γpi (Point m n))) :
    averagedCorrelation u ≤
      (𝔼 Y : UnpointedBox (Fin m) (Fin n) k, 𝔼 B : FaceArray A m n,
        ∫ c, faceCorrelation (fun t : Point m (k+1) => v (pointEmbed Y t) (pointBox Y t) B c) ∂γpi (Point m n)) +
      (𝔼 x : Point m n, 𝔼 Y : PointedBox x k,
        jointL1 (fun B c => u B c x-v x Y B c)) := by
  let C := fun (Y : UnpointedBox (Fin m) (Fin n) k) (B : FaceArray A m n) c =>
    faceCorrelation (fun t : Point m (k+1) => v (pointEmbed Y t) (pointBox Y t) B c)
  let D := fun (Y : UnpointedBox (Fin m) (Fin n) k) (B : FaceArray A m n) c =>
    𝔼 t : Point m (k+1), |u B c (pointEmbed Y t)-v (pointEmbed Y t) (pointBox Y t) B c|
  have hC Y B : Integrable (C Y B) (γpi (Point m n)) :=
    faceCorrelation_integrable _ (fun t => hvm _ _ B) (fun t => hvi _ _ B)
  have hD Y B : Integrable (D Y B) (γpi (Point m n)) := by
    simp only [D,Fintype.expect_eq_sum_div_card]
    exact (integrable_finsetSum _ (fun t _ => ((hui B _).sub (hvi _ _ B)).abs)).div_const _
  have hu' B : Integrable (fun c => faceCorrelation (u B c)) (γpi (Point m n)) :=
    faceCorrelation_integrable _ (hum B) (hui B)
  have hCi B : Integrable (fun c => 𝔼 Y, C Y B c) (γpi (Point m n)) := by
    simp only [Fintype.expect_eq_sum_div_card]
    exact (integrable_finsetSum _ (fun Y _ => hC Y B)).div_const _
  have hDi B : Integrable (fun c => 𝔼 Y, D Y B c) (γpi (Point m n)) := by
    simp only [Fintype.expect_eq_sum_div_card]
    exact (integrable_finsetSum _ (fun Y _ => hD Y B)).div_const _
  have hB B : (∫ c, faceCorrelation (u B c) ∂γpi (Point m n)) ≤
      (𝔼 Y, ∫ c, C Y B c ∂γpi (Point m n)) + (𝔼 Y, ∫ c, D Y B c ∂γpi (Point m n)) := by
    rw [← integral_expect _ (fun Y => hC Y B), ← integral_expect _ (fun Y => hD Y B),
      ← integral_add (hCi B) (hDi B)]
    exact integral_mono (hu' B) ((hCi B).add (hDi B))
      (fun c => faceCorrelation_pointed_compare hk (u B c) (fun x Y => v x Y B c))
  have hh := Finset.expect_le_expect (fun B (_ : B∈(Finset.univ : Finset (FaceArray A m n))) => hB B)
  rw [Finset.expect_add_distrib] at hh
  rw [Finset.expect_comm (f := fun B Y => ∫ c, C Y B c ∂γpi (Point m n)),
    Finset.expect_comm (f := fun B Y => ∫ c, D Y B c ∂γpi (Point m n))] at hh
  have hl := pointedJointL1_bayes
    (fun x Y B c => u B c x-v x Y B c) (fun x Y B => (hui B x).sub (hvi x Y B))
  rw [hl]
  exact hh
end MinUncut.Inner

open scoped BigOperators
variable {m n : ℕ}
namespace MinUncut.Slice

def lossBound (H γ A E q : ℝ) : ℝ := E/H+Real.sqrt E*Real.sqrt (q/γ)+E/A

lemma lossBound_mono {H γ A E E' q q' : ℝ} (hH : 0≤H) (hγ : 0≤γ) (hA : 0≤A)
    (hE : E≤E') (hq : q≤q') : lossBound H γ A E q ≤ lossBound H γ A E' q' := by
  unfold lossBound
  gcongr

lemma lossBound_expect {T : Type*} [Fintype T] (H γ A : ℝ) (E q : T → ℝ)
    (hγ : 0≤γ) (hE : ∀ t, 0≤E t) (hq : ∀ t, 0≤q t) :
    (𝔼 t, lossBound H γ A (E t) (q t)) ≤ lossBound H γ A (𝔼 t, E t) (𝔼 t, q t) := by
  unfold lossBound
  simp only [Finset.expect_add_distrib, ← Finset.expect_div]
  have hh := Average.expect_sqrt_mul_sqrt E (fun t => q t/γ) hE (fun t => div_nonneg (hq t) hγ)
  rw [← Finset.expect_div] at hh
  linarith only [hh]

lemma lossBound_weighted {T : Type*} [Fintype T] (H γ A : ℝ) (w E q : T → ℝ)
    (hw : ∀ t, 0≤w t) (hγ : 0≤γ) (hE : ∀ t, 0≤E t) (hq : ∀ t, 0≤q t) :
    (∑ t, w t*lossBound H γ A (E t) (q t)) ≤
      lossBound H γ A (∑ t, w t*E t) (∑ t, w t*q t) := by
  unfold lossBound
  simp only [mul_add, Finset.sum_add_distrib, ← mul_div_assoc, ← Finset.sum_div]
  have hh := Average.weighted_sqrt_mul_sqrt w E (fun t => q t/γ) hw hE
    (fun t => div_nonneg (hq t) hγ)
  simp only [← mul_div_assoc, ← Finset.sum_div] at hh
  linarith only [hh]
end MinUncut.Slice

namespace MinUncut.Inner
open MeasureTheory ProbabilityTheory BinaryFourier RowNoise GaussianHermite Subbox
attribute [local instance] Classical.propDecidable
attribute [local irreducible] gradient selectedProject retainedClass pairSlice pairProcessed Slice.processed
variable {V A : Type*} [AddCommGroup V] [Module F₂ V] [AddTorsor V A] [Fintype A]

def pairAtomMean (f : FoldedProof A) (σ η : ℝ) (x : Point m n)
    {k : ℕ} (Y : PointedBox x k) (p : PairClass m)
    (J : Finset (Finset (Row m n) × (Point m n → ℕ))) : ℝ :=
  𝔼 B : FaceArray A m n, ∫ c, Slice.oddMax (AffineMap.const F₂ A 1)
      (pairSlice f σ η x Y p J B c) ∂γpi (Point m n)

lemma pairAtomMean_nonneg (f : FoldedProof A) (σ η : ℝ) (x : Point m n)
    {k : ℕ} (Y : PointedBox x k) (p : PairClass m)
    (J : Finset (Finset (Row m n) × (Point m n → ℕ))) : 0≤pairAtomMean f σ η x Y p J :=
  Finset.expect_nonneg (fun _ _ => integral_nonneg (fun _ => Slice.oddMax_nonneg _ _))

lemma pairAtomMean_uniform_le (f : FoldedProof A) {σ : ℝ} (hσ : σ≠0) (η : ℝ)
    (x : Point m n) {k s : ℕ} (Y : PointedBox x k) (p : PairClass m)
    (J : Finset (Finset (Row m n) × (Point m n → ℕ)))
    (hJ : ∀ j ∈ J, GaussianHermite.degree j.2 ≤ s) :
    pairAtomMean f σ η x Y p J ≤
      (4:ℝ)^Fintype.card (Row m n) * ((Fintype.card (Point m n)+s).choose s:ℝ) * Real.sqrt
        (𝔼 D, ∫ c, (oddAtom ⟨p.val.1,face x p.val.1⟩ (AffineMap.const F₂ A 1)
          (fun B => gradient f B σ η c x) D)^2 ∂γpi (Point m n)) := by
  unfold pairAtomMean
  rw [pairSlice_atom_integral_law f hσ]
  apply selectedProject_atom_mean_uniform s _ _ _ _ _ (fun B => gradient_memLp f B hσ η x)
  intro j hj
  apply hJ j
  unfold retainedClass classSelection at hj
  exact (Finset.mem_filter.mp (Finset.mem_filter.mp hj).1).1

lemma pair_processing_loss_average (f : FoldedProof A) {σ : ℝ} (hσ : 0<σ) (η : ℝ)
    (hn : 0<n) {k : ℕ} (hk : k≤n-1) (p : PairClass m)
    (J : Finset (Finset (Row m n) × (Point m n → ℕ)))
    {H γ A₀ : ℝ} (hH : 0<H) (hγ : 0<γ) (hA : 0<A₀) :
    (𝔼 x : Point m n, 𝔼 Y : PointedBox x k, jointL1 (fun B c =>
      selectedProject (retainedClass x Y (some p) J) (fun B c => gradient f B σ η c x) B c -
        pairProcessed f σ η x Y p J H γ A₀ B c)) ≤
      Slice.lossBound H γ A₀ (σ⁻¹^2) (𝔼 x : Point m n, 𝔼 Y : PointedBox x k, pairAtomMean f σ η x Y p J) := by
  have : NeZero n := ⟨by omega⟩
  have (x : Point m n) (i : Fin m) : Nonempty (OuterSmoothness.FixedSets (Away (x i)) k) :=
    OuterSmoothness.fixedSets_nonempty (by simpa [card_away] using hk)
  let E := fun (x : Point m n) (Y : PointedBox x k) =>
    jointEnergy (selectedProject (retainedClass x Y (some p) J) (fun B c => gradient f B σ η c x))
  let q := pairAtomMean f σ η (k := k) (p := p) (J := J)
  have hE x Y : 0≤E x Y := jointEnergy_nonneg _
  have hq x Y : 0≤q x Y := pairAtomMean_nonneg _ _ _ _ _ _ _
  have hcap : (𝔼 x, 𝔼 Y, E x Y) ≤ σ⁻¹^2 := by
    calc
      _ ≤ 𝔼 x : Point m n, 𝔼 _Y : PointedBox x k, jointEnergy (fun B c => gradient f B σ η c x) :=
        Finset.expect_le_expect (fun x _ => Finset.expect_le_expect (fun Y _ => retained_energy_le f hσ.ne' η x Y (some p) J))
      _ = averagedEnergy (fun B c => gradient (m := m) (n := n) f B σ η c) := by
        simp only [Fintype.expect_const]
        exact (averagedEnergy_eq_expect_joint _ (fun B x => gradient_memLp f B hσ.ne' η x)).symm
      _ ≤ _ := averagedEnergy_gradient_le f hn hσ.ne' η
  calc
    _ ≤ 𝔼 x, 𝔼 Y, Slice.lossBound H γ A₀ (E x Y) (q x Y) :=
      Finset.expect_le_expect (fun x _ => Finset.expect_le_expect (fun Y _ =>
        pair_processing_loss_integral f hσ.ne' η x Y p J hH hγ hA))
    _ ≤ 𝔼 x, Slice.lossBound H γ A₀ (𝔼 Y, E x Y) (𝔼 Y, q x Y) :=
      Finset.expect_le_expect (fun x _ => Slice.lossBound_expect H γ A₀ _ _ hγ.le (hE x) (hq x))
    _ ≤ Slice.lossBound H γ A₀ (𝔼 x, 𝔼 Y, E x Y) (𝔼 x, 𝔼 Y, q x Y) :=
      Slice.lossBound_expect H γ A₀ _ _ hγ.le
        (fun x => Finset.expect_nonneg (fun Y _ => hE x Y)) (fun x => Finset.expect_nonneg (fun Y _ => hq x Y))
    _ ≤ _ := Slice.lossBound_mono hH.le hγ.le hA.le hcap le_rfl
end MinUncut.Inner

open scoped BigOperators
namespace MinUncut.RowNoise
open MeasureTheory ProbabilityTheory BinaryFourier GaussianHermite
attribute [local instance] Classical.propDecidable
local instance innerAssemblyDualFintype {U : Type*} [AddCommGroup U] [Module F₂ U] [Fintype U] :
    Fintype (Module.Dual F₂ U) := BinaryFourier.dualFintype
variable {R W Ω : Type*} [Fintype R] [DecidableEq R] [Fintype W] [DecidableEq W]
  [AddCommGroup W] [Module F₂ W] [MeasurableSpace Ω]

omit [Fintype R] [DecidableEq W] in
lemma oddAtom_le_bound (r : R) (one : W) (f : (R → W) → ℝ) (D : Rest (W := W) r)
    {a : ℝ} (ha : 0 ≤ a) (hf : ∀ B, |f B| ≤ a) : oddAtom r one f D ≤ a := by
  apply oddAtom_le r one f D ha
  intro α _
  calc
    |rowCoefficient r f α D| ≤ 𝔼 b, |f (joinRow r b D) * character α b| :=
      Finset.abs_expect_le _ _
    _ = 𝔼 b, |f (joinRow r b D)| := by simp only [abs_mul, character_abs, mul_one]
    _ ≤ 𝔼 _b : W, a := Finset.expect_le_expect (fun b _ => hf _)
    _ = a := Fintype.expect_const a

omit [Fintype R] [DecidableEq W] in
lemma measurable_oddAtom (r : R) (one : W) (u : (R → W) → Ω → ℝ)
    (hu : ∀ B, Measurable (u B)) (D : Rest (W := W) r) :
    Measurable (fun c => oddAtom r one (fun B => u B c) D) := by
  let fs : Module.Dual F₂ W → Ω → ℝ := fun α c =>
    if α one=1 then |rowCoefficient r (fun B => u B c) α D| else 0
  have hfs (α : Module.Dual F₂ W) : Measurable (fs α) := by
    by_cases h : α one=1
    · simp only [fs, ite_eq_left h, rowCoefficient, Finset.expect_eq_sum_div_card]
      exact ((Finset.measurable_sum _ (fun b _ => (hu _).mul_const _)).div_const _).abs
    · simpa only [fs, ite_eq_right h] using (measurable_const : Measurable (fun _ : Ω => (0:ℝ)))
  have hh : Measurable (Finset.univ.sup' Finset.univ_nonempty fs) :=
    Finset.sup'_induction (p := fun f => Measurable f) Finset.univ_nonempty fs
      (fun _ hf _ hg => hf.max hg) (fun α _ => hfs α)
  convert hh using 1
  funext c
  simp only [Finset.sup'_apply, fs, oddAtom]
end MinUncut.RowNoise

namespace MinUncut.Inner
open MeasureTheory ProbabilityTheory BinaryFourier RowNoise GaussianHermite
attribute [local instance] Classical.propDecidable
attribute [local irreducible] gradient oddAtom
variable {V A : Type*} [AddCommGroup V] [Module F₂ V] [AddTorsor V A] [Fintype A] {m n : ℕ}

def rowAtom (f : FoldedProof A) (σ η : ℝ) (x : Point m n) (i : Fin m)
    (D : Rest (W := AffineMap F₂ A F₂) (⟨i,face x i⟩ : Row m n)) (c : Point m n → ℝ) : ℝ :=
  oddAtom ⟨i,face x i⟩ (AffineMap.const F₂ A 1) (fun B => gradient f B σ η c x) D

lemma rowAtom_nonneg (f : FoldedProof A) (σ η : ℝ) (x : Point m n) (i : Fin m)
    (D : Rest (W := AffineMap F₂ A F₂) (⟨i,face x i⟩ : Row m n)) (c : Point m n → ℝ) :
    0 ≤ rowAtom f σ η x i D c := oddAtom_nonneg _ _ _ _

lemma rowAtom_le_gradientBound (f : FoldedProof A) {σ : ℝ} (hσ : 0 < σ) (η : ℝ)
    (x : Point m n) (i : Fin m) (D : Rest (W := AffineMap F₂ A F₂) (⟨i,face x i⟩ : Row m n))
    (c : Point m n → ℝ) : rowAtom f σ η x i D c ≤ Real.sqrt (n^m : ℕ)/σ :=
  oddAtom_le_bound _ _ _ _ (by positivity) (fun B => gradient_abs_le f B hσ η c x)

lemma gradient_measurable (f : FoldedProof A) (B : FaceArray A m n)
    {σ : ℝ} (hσ : σ ≠ 0) (η : ℝ) (x : Point m n) :
    Measurable (fun c => gradient f B σ η c x) := by
  have hh := (measurable_score 1 σ (measurable_tableSmooth f B η) x).const_mul
    (Real.sqrt (n^m : ℕ)/σ)
  convert hh using 1
  funext c
  rw [gradient_score f B hσ]
  simp only [score,one_smul]
  rfl

lemma rowAtom_measurable (f : FoldedProof A) {σ : ℝ} (hσ : σ ≠ 0) (η : ℝ) (x : Point m n) (i : Fin m)
    (D : Rest (W := AffineMap F₂ A F₂) (⟨i,face x i⟩ : Row m n)) :
    Measurable (rowAtom f σ η x i D) :=
  measurable_oddAtom _ _ _ (fun B => gradient_measurable f B hσ η x) _

lemma rowAtom_memLp (f : FoldedProof A) {σ : ℝ} (hσ : σ ≠ 0) (η : ℝ) (x : Point m n) (i : Fin m)
    (D : Rest (W := AffineMap F₂ A F₂) (⟨i,face x i⟩ : Row m n)) :
    MemLp (rowAtom f σ η x i D) 2 (γpi (Point m n)) :=
  memLp_oddAtom _ _ _ (fun B => gradient_memLp f B hσ η x) _

def rowAtomIndicator (f : FoldedProof A) (σ η θ : ℝ) (x : Point m n) (i : Fin m)
    (D : Rest (W := AffineMap F₂ A F₂) (⟨i,face x i⟩ : Row m n)) (c : Point m n → ℝ) : ℝ :=
  if θ ≤ rowAtom f σ η x i D c then 1 else 0

lemma rowAtomIndicator_integrable (f : FoldedProof A) {σ : ℝ} (hσ : σ ≠ 0) (η θ : ℝ) (x : Point m n) (i : Fin m)
    (D : Rest (W := AffineMap F₂ A F₂) (⟨i,face x i⟩ : Row m n)) :
    Integrable (rowAtomIndicator f σ η θ x i D) (γpi (Point m n)) := by
  have hm : Measurable (rowAtomIndicator f σ η θ x i D) :=
    Measurable.ite (measurableSet_le measurable_const (rowAtom_measurable f hσ η x i D))
      measurable_const measurable_const
  apply (MemLp.of_bound hm.aestronglyMeasurable 1 (ae_of_all _ (fun c => ?_)) :
    MemLp (rowAtomIndicator f σ η θ x i D) 2 (γpi (Point m n))).integrable (by norm_num)
  unfold rowAtomIndicator
  split_ifs <;> norm_num

def rowEventProbability (f : FoldedProof A) (σ η θ : ℝ) (x : Point m n) (i : Fin m) : ℝ :=
  𝔼 D, ∫ c, rowAtomIndicator f σ η θ x i D c ∂γpi (Point m n)

def atomProbability (f : FoldedProof A) (σ η θ : ℝ) : ℝ :=
  𝔼 x : Point m n, 𝔼 i : Fin m, rowEventProbability f σ η θ x i

lemma rowEventProbability_nonneg (f : FoldedProof A) (σ η θ : ℝ) (x : Point m n) (i : Fin m) :
    0 ≤ rowEventProbability f σ η θ x i := by
  apply Finset.expect_nonneg
  intro D _
  exact integral_nonneg (fun c => by unfold rowAtomIndicator; split_ifs <;> norm_num)

lemma rowAtom_sq_le (f : FoldedProof A) {σ θ : ℝ} (hσ : 0 < σ) (hθ : 0 ≤ θ) (η : ℝ)
    (x : Point m n) (i : Fin m) (D : Rest (W := AffineMap F₂ A F₂) (⟨i,face x i⟩ : Row m n))
    (c : Point m n → ℝ) :
    (rowAtom f σ η x i D c)^2 ≤ θ^2 + (n^m : ℕ)/σ^2*rowAtomIndicator f σ η θ x i D c := by
  have hn : 0 ≤ (n^m : ℕ) := Nat.zero_le _
  have hu := rowAtom_le_gradientBound f hσ η x i D c
  have hl := rowAtom_nonneg f σ η x i D c
  have hs : (Real.sqrt (n^m : ℕ)/σ)^2 = (n^m : ℕ)/σ^2 := by
    rw [div_pow,Real.sq_sqrt (by positivity)]
  unfold rowAtomIndicator
  split_ifs with h
  · have hh := sq_le_sq₀ hl (by positivity) |>.mpr hu
    nlinarith [sq_nonneg θ]
  · simp only [mul_zero,add_zero]
    exact sq_le_sq₀ hl hθ |>.mpr (le_of_lt (lt_of_not_ge h))

lemma rowAtom_secondMoment (f : FoldedProof A) {σ θ : ℝ} (hσ : 0 < σ) (hθ : 0 ≤ θ) (η : ℝ)
    (x : Point m n) (i : Fin m) :
    (𝔼 D, ∫ c, (rowAtom f σ η x i D c)^2 ∂γpi (Point m n)) ≤
      θ^2 + (n^m : ℕ)/σ^2*rowEventProbability f σ η θ x i := by
  calc
    _ ≤ 𝔼 D, ∫ c, θ^2 + (n^m : ℕ)/σ^2*rowAtomIndicator f σ η θ x i D c ∂γpi (Point m n) := by
      apply Finset.expect_le_expect
      intro D _
      exact integral_mono (rowAtom_memLp f hσ.ne' η x i D).integrable_sq
        ((integrable_const _).add ((rowAtomIndicator_integrable f hσ.ne' η θ x i D).const_mul _))
        (rowAtom_sq_le f hσ hθ η x i D)
    _ = _ := by
      simp_rw [integral_add (integrable_const _) ((rowAtomIndicator_integrable f hσ.ne' η θ x i _).const_mul _),
        integral_const_mul, integral_const, probReal_univ, smul_eq_mul, one_mul]
      rw [Finset.expect_add_distrib,Fintype.expect_const, ← Finset.mul_expect]
      rfl

lemma fixed_row_probability_le (f : FoldedProof A) (σ η θ : ℝ) (i : Fin m) :
    (𝔼 x : Point m n, rowEventProbability f σ η θ x i) ≤ (m:ℝ)*atomProbability (m := m) (n := n) f σ η θ := by
  have hm : m ≠ 0 := by have := i.isLt; omega
  have hx (x : Point m n) : rowEventProbability f σ η θ x i ≤
      (m:ℝ)*(𝔼 j : Fin m, rowEventProbability f σ η θ x j) := by
    rw [Fintype.expect_eq_sum_div_card,Fintype.card_fin,mul_div_cancel₀ _ (by exact_mod_cast hm)]
    exact Finset.single_le_sum (fun j _ => rowEventProbability_nonneg f σ η θ x j) (Finset.mem_univ i)
  have h := Finset.expect_le_expect (fun x (_ : x ∈ (Finset.univ : Finset (Point m n))) => hx x)
  simpa only [← Finset.mul_expect, atomProbability] using h
end MinUncut.Inner

end

end OAI