import Mathlib
import OAI.Computability.MinUncut.Analysis.FaceCorrelation
import OAI.Computability.MinUncut.Estimates.SelectedProject
import OAI.Computability.MinUncut.Graphs.Vertex

namespace OAI

noncomputable section
open scoped BigOperators
open MeasureTheory ProbabilityTheory Filter
open scoped Topology NNReal
open scoped BigOperators
open MeasureTheory ProbabilityTheory Polynomial Filter
open scoped BigOperators Topology
open MeasureTheory ProbabilityTheory WithLp
open scoped BigOperators RealInnerProductSpace
open scoped BigOperators
namespace MinUncut.Inner
open scoped BigOperators
variable {m n : ℕ}

lemma face_update_self (x : Point m n) (i : Fin m) (z : Fin n) :
    face (Function.update x i z) i = face x i := by
  funext j
  exact Function.update_of_ne j.property _ _

theorem faceCorrelation_box_cs (hm : 0 < m) (hn : 0 < n) (v : Point m n → ℝ) :
    faceCorrelation v ^ (2^m) ≤ Box.moment v := by
  have : Nonempty (Fin n) := Fin.pos_iff_nonempty.mp hn
  obtain ⟨z, _, hz⟩ := Finset.exists_mem_eq_sup' Finset.univ_nonempty
    (fun z : Code m n => |𝔼 x : Point m n, v x * BinaryFourier.sign (z.val x)|)
  change faceCorrelation v = _ at hz
  obtain ⟨b, hb⟩ := z.property
  let a : Fin m → Point m n → ℝ := fun i x => BinaryFourier.sign (b ⟨i, face x i⟩)
  have ha : Box.Local a := by
    intro i x t
    simp only [a, face_update_self]
  have hc : |Box.correlation v a| = faceCorrelation v := by
    rw [hz]
    unfold Box.correlation
    congr 1
    apply Finset.expect_congr rfl
    intro x _
    congr 1
    have hbx : z.val x = ∑ i, b ⟨i, face x i⟩ := congrFun hb.symm x
    simp only [hbx, RowNoise.sign_sum, a]
  rw [← hc]
  exact Box.abs_correlation_cs hm v a ha (fun _ _ => (BinaryFourier.sign_abs _).le)
end MinUncut.Inner

namespace MinUncut.GaussianHermite
variable {ι : Type*} [Fintype ι] [DecidableEq ι]

def indexSym (s : ℕ) (I : {I : ι → ℕ // I ∈ low s}) : Sym (Option ι) s :=
  ⟨(∑ i, Multiset.replicate (I.val i) (some i)) +
    Multiset.replicate (s-degree I.val) none, by
      rw [Multiset.card_add, Multiset.card_sum, Multiset.card_replicate]
      simp only [Multiset.card_replicate]
      exact Nat.add_sub_of_le ((mem_low _ _).mp I.property)⟩

lemma count_indexSym (s : ℕ) (I : {I : ι → ℕ // I ∈ low s}) (i : ι) :
    Multiset.count (some i) (indexSym s I).val = I.val i := by
  simp [indexSym, Multiset.count_sum', Multiset.count_replicate]

lemma indexSym_injective (s : ℕ) : Function.Injective (indexSym (ι := ι) s) := by
  intro I J h
  apply Subtype.ext
  funext i
  simpa only [count_indexSym] using congrArg (fun z : Sym (Option ι) s => Multiset.count (some i) z.val) h

lemma card_low_le (s : ℕ) : (low (ι := ι) s).card ≤ (Fintype.card ι+s).choose s := by
  have h := Fintype.card_le_of_injective _ (indexSym_injective (ι := ι) s)
  simpa only [Fintype.card_coe, Sym.card_sym_eq_choose, Fintype.card_option,
    Nat.add_right_comm (Fintype.card ι) 1 s, Nat.add_sub_cancel] using h
end MinUncut.GaussianHermite
namespace MinUncut.RowNoise
open MeasureTheory ProbabilityTheory BinaryFourier GaussianHermite
open scoped BigOperators
local instance faceUpdateSelfRowDualFintype {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] [Fintype ι] [DecidableEq ι]

lemma selectedProject_atom_mean_uniform (s : ℕ) (J : Finset (Finset R × (ι → ℕ)))
    (hJ : ∀ j ∈ J, GaussianHermite.degree j.2 ≤ s) (r : R) (one : W)
    (u : (R → W) → (ι → ℝ) → ℝ) (hu : ∀ B, MemLp (u B) 2 (γpi ι)) :
    (𝔼 D, ∫ c, oddAtom r one (fun B => selectedProject J u B c) D ∂γpi ι) ≤
      (4:ℝ)^Fintype.card R * ((Fintype.card ι+s).choose s : ℝ) * Real.sqrt
        (𝔼 D, ∫ c, (oddAtom r one (fun B => u B c) D)^2 ∂γpi ι) := by
  have hj : J ⊆ (Finset.univ : Finset (Finset R)) ×ˢ low s := by
    intro j hj
    exact Finset.mem_product.mpr ⟨Finset.mem_univ _, (mem_low _ _).mpr (hJ j hj)⟩
  have hc : J.card ≤ 2^Fintype.card R * (Fintype.card ι+s).choose s := by
    calc
      J.card ≤ ((Finset.univ : Finset (Finset R)) ×ˢ low s).card := Finset.card_le_card hj
      _ = 2^Fintype.card R * (low (ι := ι) s).card := by simp
      _ ≤ _ := Nat.mul_le_mul_left _ (card_low_le s)
  have hc' : (J.card : ℝ) ≤ (2:ℝ)^Fintype.card R * ((Fintype.card ι+s).choose s : ℝ) := by exact_mod_cast hc
  refine (selectedProject_atom_mean J r one u hu).trans ?_
  have hp : (2:ℝ)^Fintype.card R * (2:ℝ)^Fintype.card R = (4:ℝ)^Fintype.card R := by
    rw [← mul_pow]; norm_num
  calc
    _ ≤ ((2:ℝ)^Fintype.card R * ((Fintype.card ι+s).choose s : ℝ)) *
        (2:ℝ)^Fintype.card R * Real.sqrt
        (𝔼 D, ∫ c, (oddAtom r one (fun B => u B c) D)^2 ∂γpi ι) := by
      gcongr
    _ = _ := by rw [mul_right_comm ((2:ℝ)^Fintype.card R), hp]
end MinUncut.RowNoise
namespace MinUncut.Slice
open BinaryFourier
variable {W : Type*} [Fintype W] [DecidableEq W] [AddCommGroup W] [Module F₂ W]

def clip (A z : ℝ) : ℝ := max (-A) (min z A)

lemma clip_abs_le {A : ℝ} (hA : 0 ≤ A) (z : ℝ) : |clip A z| ≤ A := by
  rw [abs_le]
  constructor
  · exact le_max_left _ _
  · exact max_le (by linarith) (min_le_right _ _)

lemma clip_abs_le_self {A : ℝ} (hA : 0 ≤ A) (z : ℝ) : |clip A z| ≤ |z| := by
  unfold clip
  rcases le_total z A with hz | hz
  · rw [min_eq_left hz]
    rcases le_total (-A) z with ha | ha
    · rw [max_eq_right ha]
    · rw [max_eq_left ha, abs_neg, abs_of_nonneg hA, abs_of_nonpos (by linarith)]
      linarith
  · rw [min_eq_right hz, max_eq_right (by linarith), abs_of_nonneg hA,
      abs_of_nonneg (by linarith)]
    exact hz

lemma clip_loss {A : ℝ} (hA : 0 < A) (z : ℝ) : |z-clip A z| ≤ z^2/A := by
  rw [le_div_iff₀ hA]
  unfold clip
  rcases le_total z A with hz | hz
  · rw [min_eq_left hz]
    rcases le_total (-A) z with ha | ha
    · rw [max_eq_right ha]; simpa using sq_nonneg z
    · rw [max_eq_left ha, abs_of_nonpos (by linarith)]
      nlinarith [sq_nonneg (z+A), mul_nonneg (le_of_lt hA) (show 0 ≤ -z-A by linarith)]
  · rw [min_eq_right hz, max_eq_right (by linarith), abs_of_nonneg (by linarith)]
    nlinarith [sq_nonneg (z-A), mul_nonneg (le_of_lt hA) (show 0 ≤ z-A by linarith)]

lemma clip_sq_le {A : ℝ} (hA : 0 ≤ A) (z : ℝ) : clip A z ^2 ≤ z^2 := by
  have h := clip_abs_le_self hA z
  nlinarith [abs_nonneg (clip A z), abs_nonneg z, sq_abs (clip A z), sq_abs z]

omit [DecidableEq W] in
lemma coefficient_lipschitz (f g : W → ℝ) (α : Module.Dual F₂ W) :
    |coefficient f α - coefficient g α| ≤ 𝔼 w, |f w-g w| := by
  simp only [coefficient, ← Finset.expect_sub_distrib, ← sub_mul]
  calc
    _ ≤ 𝔼 w, |(f w-g w)*character α w| := by
      simp only [Finset.expect_eq_sum_div_card, abs_div, Nat.abs_cast]
      exact div_le_div_of_nonneg_right (Finset.abs_sum_le_sum_abs _ _) (by positivity)
    _ = _ := by simp only [abs_mul, character_abs, mul_one]

omit [DecidableEq W] [AddCommGroup W] [Module F₂ W] in
lemma clip_mean_loss {A : ℝ} (hA : 0 < A) (f : W → ℝ) :
    (𝔼 w, |f w-clip A (f w)|) ≤ (𝔼 w, (f w)^2)/A := by
  calc
    _ ≤ 𝔼 w, (f w)^2/A := Finset.expect_le_expect (fun w _ => clip_loss hA (f w))
    _ = _ := by simp [Finset.expect_div]

local instance faceUpdateSelfSliceDualFintype : Fintype (Module.Dual F₂ W) :=
  BinaryFourier.dualFintype

def oddMax (one : W) (f : W → ℝ) : ℝ :=
  Finset.univ.sup' Finset.univ_nonempty (fun α : Module.Dual F₂ W =>
    if α one = 1 then |coefficient f α| else 0)

omit [DecidableEq W] in
lemma oddMax_nonneg (one : W) (f : W → ℝ) : 0 ≤ oddMax one f := by
  have h := Finset.le_sup' (fun α : Module.Dual F₂ W =>
    if α one = 1 then |coefficient f α| else 0) (Finset.mem_univ 0)
  change 0 ≤ Finset.univ.sup' Finset.univ_nonempty _
  simpa only [LinearMap.zero_apply, zero_ne_one, ↓reduceIte] using h

omit [DecidableEq W] in
lemma coefficient_le_oddMax (one : W) (f : W → ℝ)
    (hodd : ∀ α : Module.Dual F₂ W, α one ≠ 1 → coefficient f α = 0)
    (α : Module.Dual F₂ W) : |coefficient f α| ≤ oddMax one f := by
  by_cases h : α one = 1
  · have h' := Finset.le_sup' (fun α : Module.Dual F₂ W =>
      if α one = 1 then |coefficient f α| else 0) (Finset.mem_univ α)
    simpa only [h, ↓reduceIte, oddMax] using h'
  · rw [hodd α h, abs_zero]
    exact oddMax_nonneg one f

def processed (H γ A : ℝ) (one : W) (f : W → ℝ) (w : W) : ℝ :=
  if H < Real.sqrt (𝔼 b, (f b)^2) ∨ γ < oddMax one f then 0 else clip A (f w)

omit [DecidableEq W] in
lemma processed_abs_le {H γ A : ℝ} (hA : 0 ≤ A) (one : W) (f : W → ℝ) (w : W) :
    |processed H γ A one f w| ≤ A := by
  unfold processed; split_ifs
  · simpa using hA
  · exact clip_abs_le hA _

omit [DecidableEq W] in
lemma processed_sq_le {H γ A : ℝ} (hA : 0 ≤ A) (one : W) (f : W → ℝ) (w : W) :
    (processed H γ A one f w)^2 ≤ (f w)^2 := by
  unfold processed; split_ifs
  · simpa using sq_nonneg (f w)
  · exact clip_sq_le hA _

omit [DecidableEq W] in
lemma processed_energy_le {H γ A : ℝ} (hA : 0 ≤ A) (one : W) (f : W → ℝ) :
    (𝔼 w, (processed H γ A one f w)^2) ≤ H^2 := by
  by_cases h : H < Real.sqrt (𝔼 b, (f b)^2) ∨ γ < oddMax one f
  · simp only [processed, h, ↓reduceIte, zero_pow (by omega : 2 ≠ 0), Fintype.expect_const]
    exact sq_nonneg H
  · have hs : Real.sqrt (𝔼 b, (f b)^2) ≤ H := le_of_not_gt (fun ht => h (Or.inl ht))
    have he : 0 ≤ 𝔼 b, (f b)^2 := Finset.expect_nonneg (fun _ _ => sq_nonneg _)
    calc
      _ ≤ 𝔼 w, (f w)^2 := Finset.expect_le_expect (fun w _ => processed_sq_le hA one f w)
      _ ≤ H^2 := by nlinarith [Real.sq_sqrt he, Real.sqrt_nonneg (𝔼 b, (f b)^2)]

omit [DecidableEq W] in
lemma processed_coefficient_le {H γ A : ℝ} (hA : 0 < A) (hγ : 0 ≤ γ)
    (one : W) (f : W → ℝ)
    (hodd : ∀ α : Module.Dual F₂ W, α one ≠ 1 → coefficient f α = 0)
    (α : Module.Dual F₂ W) :
    |coefficient (processed H γ A one f) α| ≤ γ + H^2/A := by
  by_cases h : H < Real.sqrt (𝔼 b, (f b)^2) ∨ γ < oddMax one f
  · simp only [processed, h, ↓reduceIte, coefficient, zero_mul, Fintype.expect_const, abs_zero]
    positivity
  · have hs : Real.sqrt (𝔼 b, (f b)^2) ≤ H := le_of_not_gt (fun ht => h (Or.inl ht))
    have hq : oddMax one f ≤ γ := le_of_not_gt (fun ht => h (Or.inr ht))
    have he : 0 ≤ 𝔼 b, (f b)^2 := Finset.expect_nonneg (fun _ _ => sq_nonneg _)
    have hE : (𝔼 b, (f b)^2) ≤ H^2 := by
      nlinarith [Real.sq_sqrt he, Real.sqrt_nonneg (𝔼 b, (f b)^2)]
    have hp : processed H γ A one f = fun w => clip A (f w) := by funext w; simp only [processed, h, ↓reduceIte]
    rw [hp]
    calc
      _ ≤ |coefficient (fun w => clip A (f w)) α - coefficient f α| + |coefficient f α| := by
        have hh := abs_add_le (coefficient (fun w => clip A (f w)) α - coefficient f α) (coefficient f α)
        simpa only [sub_add_cancel] using hh
      _ ≤ (𝔼 w, |clip A (f w)-f w|) + oddMax one f := add_le_add
        (coefficient_lipschitz _ _ _) (coefficient_le_oddMax one f hodd α)
      _ = (𝔼 w, |f w-clip A (f w)|) + oddMax one f := by simp_rw [abs_sub_comm]
      _ ≤ (𝔼 w, (f w)^2)/A + γ := add_le_add (clip_mean_loss hA f) hq
      _ ≤ γ + H^2/A := by linarith [div_le_div_of_nonneg_right hE (le_of_lt hA)]

open BinaryFourier
variable {W : Type*} [Fintype W] [DecidableEq W] [AddCommGroup W] [Module F₂ W]

omit [DecidableEq W] [Module F₂ W] in
lemma mean_abs_le_sqrt (f : W → ℝ) :
    (𝔼 w, |f w|) ≤ Real.sqrt (𝔼 w, (f w)^2) := by
  have h := Box.expect_sq_le (fun w => |f w|)
  simp only [sq_abs] at h
  have he : 0 ≤ 𝔼 w, (f w)^2 := Finset.expect_nonneg (fun _ _ => sq_nonneg _)
  exact (Real.le_sqrt (Finset.expect_nonneg (fun _ _ => abs_nonneg _)) he).mpr h

omit [DecidableEq W] in
lemma processed_mean_loss {H γ A : ℝ} (hH : 0 < H) (hA : 0 < A)
    (one : W) (f : W → ℝ) :
    (𝔼 w, |f w-processed H γ A one f w|) ≤
      (𝔼 w, (f w)^2)/H +
      (if γ < oddMax one f then Real.sqrt (𝔼 w, (f w)^2) else 0) +
      (𝔼 w, (f w)^2)/A := by
  have hE : 0 ≤ 𝔼 w, (f w)^2 := Finset.expect_nonneg (fun _ _ => sq_nonneg _)
  have hu : 0 ≤ (𝔼 w, (f w)^2)/H := div_nonneg hE hH.le
  have hv : 0 ≤ (𝔼 w, (f w)^2)/A := div_nonneg hE hA.le
  by_cases hn : H < Real.sqrt (𝔼 w, (f w)^2)
  · simp only [processed, hn, true_or, ↓reduceIte, sub_zero]
    have ht : Real.sqrt (𝔼 w, (f w)^2) ≤ (𝔼 w, (f w)^2)/H := by
      rw [le_div_iff₀ hH]
      have hh := mul_le_mul_of_nonneg_left hn.le (Real.sqrt_nonneg (𝔼 w, (f w)^2))
      nlinarith [Real.sq_sqrt hE]
    have hi : 0 ≤ if γ < oddMax one f then Real.sqrt (𝔼 w, (f w)^2) else 0 := by split_ifs <;> positivity
    linarith [mean_abs_le_sqrt f]
  · by_cases hq : γ < oddMax one f
    · simp only [processed, hq, or_true, ↓reduceIte, sub_zero]
      linarith [mean_abs_le_sqrt f]
    · simp only [processed, hn, hq, or_self, ↓reduceIte, add_zero]
      linarith [clip_mean_loss hA f]
end MinUncut.Slice
namespace MinUncut.IndependentSquares
open BinaryFourier
variable {C W : Type*} [Fintype C] [DecidableEq C] [Fintype W]
  [DecidableEq W] [AddCommGroup W] [Module F₂ W]

lemma expect_prod {ι : Type*} [Fintype ι] [DecidableEq ι]
    {A : ι → Type*} [∀ i, Fintype (A i)] (f : ∀ i, A i → ℝ) :
    (𝔼 x : ∀ i, A i, ∏ i, f i (x i)) = ∏ i, 𝔼 a, f i a := by
  simp only [Fintype.expect_eq_sum_div_card, Fintype.card_pi]
  rw [← Fintype.prod_sum, Nat.cast_prod, Finset.prod_div_distrib]

omit [DecidableEq W] [Module F₂ W] in
lemma factor_squares (V : C → Bool → Bool → W → ℝ) :
    (𝔼 r₀ : C → W, 𝔼 r₁ : C → W, 𝔼 s₀ : C → W, 𝔼 s₁ : C → W,
      ∏ c, V c false false (r₀ c+s₀ c) * V c false true (r₀ c+s₁ c) *
        V c true false (r₁ c+s₀ c) * V c true true (r₁ c+s₁ c)) =
      ∏ c, 𝔼 r₀, 𝔼 r₁, 𝔼 s₀, 𝔼 s₁,
        V c false false (r₀+s₀) * V c false true (r₀+s₁) *
        V c true false (r₁+s₀) * V c true true (r₁+s₁) := by
  calc
    _ = 𝔼 r₀ : C → W, 𝔼 r₁ : C → W, 𝔼 s₀ : C → W, ∏ c, 𝔼 s₁,
        V c false false (r₀ c+s₀ c) * V c false true (r₀ c+s₁) *
        V c true false (r₁ c+s₀ c) * V c true true (r₁ c+s₁) := by
      apply Finset.expect_congr rfl; intro r₀ _
      apply Finset.expect_congr rfl; intro r₁ _
      apply Finset.expect_congr rfl; intro s₀ _
      exact expect_prod (fun c s₁ => V c false false (r₀ c+s₀ c) * V c false true (r₀ c+s₁) * V c true false (r₁ c+s₀ c) * V c true true (r₁ c+s₁))
    _ = 𝔼 r₀ : C → W, 𝔼 r₁ : C → W, ∏ c, 𝔼 s₀, 𝔼 s₁,
        V c false false (r₀ c+s₀) * V c false true (r₀ c+s₁) *
        V c true false (r₁ c+s₀) * V c true true (r₁ c+s₁) := by
      apply Finset.expect_congr rfl; intro r₀ _
      apply Finset.expect_congr rfl; intro r₁ _
      exact expect_prod (fun c s₀ => 𝔼 s₁, V c false false (r₀ c+s₀) * V c false true (r₀ c+s₁) * V c true false (r₁ c+s₀) * V c true true (r₁ c+s₁))
    _ = 𝔼 r₀ : C → W, ∏ c, 𝔼 r₁, 𝔼 s₀, 𝔼 s₁,
        V c false false (r₀ c+s₀) * V c false true (r₀ c+s₁) *
        V c true false (r₁+s₀) * V c true true (r₁+s₁) := by
      apply Finset.expect_congr rfl; intro r₀ _
      exact expect_prod (fun c r₁ => 𝔼 s₀, 𝔼 s₁, V c false false (r₀ c+s₀) * V c false true (r₀ c+s₁) * V c true false (r₁+s₀) * V c true true (r₁+s₁))
    _ = _ := expect_prod (fun c r₀ => 𝔼 r₁, 𝔼 s₀, 𝔼 s₁, V c false false (r₀+s₀) * V c false true (r₀+s₁) * V c true false (r₁+s₀) * V c true true (r₁+s₁))

omit [DecidableEq W] in
lemma independent_square_bound (V : C → Bool → Bool → W → ℝ) (ε H : ℝ)
    (hε : 0 ≤ ε)
    (hcoef : ∀ c a b α, |coefficient (V c a b) α| ≤ ε)
    (henergy : ∀ c a b, (𝔼 w, (V c a b w)^2) ≤ H^2) :
    |𝔼 r₀ : C → W, 𝔼 r₁ : C → W, 𝔼 s₀ : C → W, 𝔼 s₁ : C → W,
      ∏ c, V c false false (r₀ c+s₀ c) * V c false true (r₀ c+s₁ c) *
        V c true false (r₁ c+s₀ c) * V c true true (r₁ c+s₁ c)| ≤
      (ε^2*H^2)^Fintype.card C := by
  rw [factor_squares, Finset.abs_prod]
  calc
    _ ≤ ∏ _c : C, ε^2*H^2 := by
      apply Finset.prod_le_prod₀ (fun _ _ => abs_nonneg _)
      intro c _
      exact square_bound _ _ _ _ ε H hε (hcoef c false false) (hcoef c false true)
        (henergy c true false) (henergy c true true)
    _ = _ := by simp

def restrictLinear {R D : Type*} (j : D → R) : (R → W) →ₗ[F₂] (D → W) where
  toFun B := B ∘ j
  map_add' _ _ := rfl
  map_smul' _ _ := rfl

omit [Fintype W] [DecidableEq W] in
lemma restrict_surjective {R D : Type*} (j : D → R) (hj : Function.Injective j) :
    Function.Surjective (restrictLinear (W := W) j) := by
  classical
  intro b
  refine ⟨Function.extend j b (fun _ => 0), ?_⟩
  funext d
  exact hj.extend_apply b (fun _ => 0) d

lemma expect_surjective_linear {G H : Type*} [Fintype G] [AddCommGroup G] [Module F₂ G]
    [Fintype H] [AddCommGroup H] [Module F₂ H]
    (φ : G →ₗ[F₂] H) (hφ : Function.Surjective φ) (f : H → ℝ) :
    (𝔼 g, f (φ g)) = 𝔼 h, f h := by
  have h (h : H) : (𝔼 g, f (h+φ g)) = 𝔼 g, f (φ g) := by
    obtain ⟨g, rfl⟩ := hφ h
    simpa only [map_add] using expect_translate (fun a => f (φ a)) g
  calc
    _ = 𝔼 h', 𝔼 g, f (h'+φ g) := by simp_rw [h]; simp
    _ = 𝔼 g, 𝔼 h', f (h'+φ g) := Finset.expect_comm _ _ _
    _ = 𝔼 g : G, 𝔼 h', f h' := by
      apply Finset.expect_congr rfl
      intro g _
      simpa only [add_comm] using expect_translate f (φ g)
    _ = _ := by simp

omit [DecidableEq W] in
lemma expect_restrict {R D : Type*} [Fintype R] [Fintype D] [DecidableEq R] [DecidableEq D]
    (j : D → R) (hj : Function.Injective j) (f : (D → W) → ℝ) :
    (𝔼 B : R → W, f (B ∘ j)) = 𝔼 b, f b :=
  expect_surjective_linear (restrictLinear j) (restrict_surjective j hj) f
end MinUncut.IndependentSquares

namespace MinUncut.Slice
open MeasureTheory Filter
variable {Ω : Type*} [MeasurableSpace Ω] {μ : Measure Ω} [IsProbabilityMeasure μ]

lemma clip_memLp {f : Ω → ℝ} {A : ℝ} (hA : 0 ≤ A) (hf : MemLp f 2 μ) :
    MemLp (fun x => clip A (f x)) 2 μ := by
  apply MemLp.of_bound
    ((aemeasurable_const.max (hf.aestronglyMeasurable.aemeasurable.min aemeasurable_const)).aestronglyMeasurable) A
  exact Eventually.of_forall (fun x => by simpa only [Real.norm_eq_abs, clip] using clip_abs_le hA (f x))

lemma clip_integral_loss {f : Ω → ℝ} {A : ℝ} (hA : 0 < A) (hf : MemLp f 2 μ) :
    (∫ x, |f x-clip A (f x)| ∂μ) ≤ (∫ x, (f x)^2 ∂μ)/A := by
  have hh : Integrable (fun x => |f x-clip A (f x)|) μ :=
    ((hf.sub (clip_memLp hA.le hf)).integrable (by norm_num)).abs
  calc
    _ ≤ ∫ x, (f x)^2/A ∂μ := integral_mono hh (hf.integrable_sq.div_const _) (fun x => clip_loss hA (f x))
    _ = _ := integral_div _ _

def centeredClip (μ : Measure Ω) (A : ℝ) (f : Ω → ℝ) (x : Ω) : ℝ :=
  clip A (f x) - ∫ y, clip A (f y) ∂μ

lemma centeredClip_mean_zero {f : Ω → ℝ} {A : ℝ} (hA : 0 ≤ A) (hf : MemLp f 2 μ) :
    (∫ x, centeredClip μ A f x ∂μ) = 0 := by
  unfold centeredClip
  rw [integral_sub ((clip_memLp hA hf).integrable (by norm_num)) (integrable_const _)]
  simp

lemma centeredClip_abs_le {f : Ω → ℝ} {A : ℝ} (hA : 0 ≤ A) (hf : MemLp f 2 μ) (x : Ω) :
    |centeredClip μ A f x| ≤ 2*A := by
  have hc : |∫ y, clip A (f y) ∂μ| ≤ A := by
    calc
      _ ≤ ∫ y, |clip A (f y)| ∂μ := abs_integral_le_integral_abs
      _ ≤ ∫ _y : Ω, A ∂μ := integral_mono ((clip_memLp hA hf).integrable (by norm_num)).abs
        (integrable_const _) (fun y => clip_abs_le hA (f y))
      _ = _ := by simp
  exact (abs_sub _ _).trans (by linarith [clip_abs_le hA (f x)])

lemma centeredClip_loss {f : Ω → ℝ} {A : ℝ} (hA : 0 < A) (hf : MemLp f 2 μ)
    (hm : (∫ x, f x ∂μ) = 0) :
    (∫ x, |f x-centeredClip μ A f x| ∂μ) ≤ 2*(∫ x, (f x)^2 ∂μ)/A := by
  have hc := (clip_memLp hA.le hf).integrable (by norm_num)
  have hf' := hf.integrable (by norm_num)
  have he : |∫ x, clip A (f x) ∂μ| ≤ ∫ x, |f x-clip A (f x)| ∂μ := by
    have h := abs_integral_le_integral_abs (μ := μ) (f := fun x => f x-clip A (f x))
    rw [integral_sub hf' hc, hm, zero_sub, abs_neg] at h
    exact h
  have hl := clip_integral_loss hA hf
  have hi : Integrable (fun x => |f x-centeredClip μ A f x|) μ :=
    (hf'.sub (hc.sub (integrable_const _))).abs
  calc
    _ ≤ ∫ x, |f x-clip A (f x)| + |∫ y, clip A (f y) ∂μ| ∂μ := by
      refine integral_mono hi ((hf'.sub hc).abs.add (integrable_const _)) ?_
      intro x
      have hrewrite : f x - centeredClip μ A f x =
          (f x - clip A (f x)) + ∫ y, clip A (f y) ∂μ := by
        unfold centeredClip
        ring
      simpa only [hrewrite] using
        abs_add_le (f x - clip A (f x)) (∫ y, clip A (f y) ∂μ)
    _ = (∫ x, |f x-clip A (f x)| ∂μ) + |∫ y, clip A (f y) ∂μ| := by
      have hh : Integrable (fun x => |f x-clip A (f x)|) μ := (hf'.sub hc).abs
      rw [integral_add hh (integrable_const _)]; simp
    _ ≤ 2*(∫ x, (f x)^2 ∂μ)/A := by rw [mul_div_assoc]; linarith

lemma tail_probability {q : Ω → ℝ} (hq : Integrable q μ) (hqpos : ∀ x, 0 ≤ q x)
    {γ : ℝ} (hγ : 0 < γ) : μ.real {x | γ < q x} ≤ (∫ x, q x ∂μ)/γ := by
  have h := mul_meas_ge_le_integral_of_nonneg (Eventually.of_forall hqpos) hq γ
  have hm : μ.real {x | γ < q x} ≤ μ.real {x | γ ≤ q x} :=
    measureReal_mono (fun x hx => (show γ < q x from hx).le)
  rw [le_div_iff₀ hγ]
  nlinarith

lemma integral_tail_loss {ν q : Ω → ℝ} (hν : MemLp ν 2 μ)
    (hq : Measurable q) (hqi : Integrable q μ) (hqpos : ∀ x, 0 ≤ q x)
    {γ : ℝ} (hγ : 0 < γ) :
    (∫ x in {x | γ < q x}, |ν x| ∂μ) ≤
      Real.sqrt (∫ x, (ν x)^2 ∂μ) * Real.sqrt ((∫ x, q x ∂μ)/γ) := by
  let S := {x | γ < q x}
  have hS : MeasurableSet S := measurableSet_lt measurable_const hq
  have hg : MemLp (S.indicator (fun _ => (1:ℝ))) 2 μ :=
    (memLp_const (1:ℝ)).indicator hS
  have h := GaussianHermite.integral_norm_mul_le_sqrt hν hg
  have hl : (∫ x, |ν x| * |S.indicator (fun _ => (1:ℝ)) x| ∂μ) = ∫ x in S, |ν x| ∂μ := by
    rw [← integral_indicator hS]
    apply integral_congr_ae
    exact Eventually.of_forall (fun x => by by_cases hx : x ∈ S <;> simp [hx])
  have hr : (∫ x, (S.indicator (fun _ => (1:ℝ)) x)^2 ∂μ) = μ.real S := by
    have he : (fun x => (S.indicator (fun _ => (1:ℝ)) x)^2) = S.indicator (fun _ => (1:ℝ)) := by
      funext x; by_cases hx : x ∈ S <;> simp [hx]
    rw [he, integral_indicator hS]; simp
  rw [hl, hr] at h
  exact h.trans (mul_le_mul_of_nonneg_left (Real.sqrt_le_sqrt (tail_probability hqi hqpos hγ)) (Real.sqrt_nonneg _))
end MinUncut.Slice

namespace MinUncut.CubeRows
open BinaryFourier IndependentSquares
variable {ι A W : Type*} [Fintype ι] [DecidableEq ι]
  [Fintype W] [DecidableEq W] [AddCommGroup W] [Module F₂ W]

abbrev Other (i j : ι) := {k : ι // k ≠ i ∧ k ≠ j}

def join (i j : ι) (c : Other i j → Bool) (a b : Bool) (k : ι) : Bool :=
  if hi : k = i then a else if hj : k = j then b else c ⟨k,hi,hj⟩

omit [Fintype ι] in
@[simp] lemma join_i (i j : ι) (c : Other i j → Bool) (a b : Bool) : join i j c a b i = a := by simp [join]
omit [Fintype ι] in
@[simp] lemma join_j (i j : ι) (hij : i ≠ j) (c : Other i j → Bool) (a b : Bool) :
    join i j c a b j = b := by simp [join, hij.symm]
omit [Fintype ι] in
@[simp] lemma join_other (i j : ι) (c : Other i j → Bool) (a b : Bool) (k : Other i j) :
    join i j c a b k = c k := by simp [join, k.property.1, k.property.2]

def splitEquiv (i j : ι) (hij : i ≠ j) : (ι → Bool) ≃ ((Other i j → Bool) × Bool × Bool) where
  toFun ν := (fun k => ν k, ν i, ν j)
  invFun v := join i j v.1 v.2.1 v.2.2
  left_inv ν := by funext k; by_cases hi : k=i <;> by_cases hj : k=j <;> simp [join, hi, hj, hij.symm]
  right_inv v := by ext k <;> simp [hij]

def vertex (ν : ι → Bool) (x y : ι → A) (k : ι) : A := if ν k then x k else y k

def face (i : ι) (x : ι → A) : {k : ι // k ≠ i} → A := fun k => x k

def rowJ (i j : ι) (x y : ι → A) (v : (Other i j → Bool) × Bool) : {k : ι // k ≠ j} → A :=
  face j (vertex (join i j v.1 v.2 false) x y)

def rowI (i j : ι) (x y : ι → A) (v : (Other i j → Bool) × Bool) : {k : ι // k ≠ i} → A :=
  face i (vertex (join i j v.1 false v.2) x y)

lemma bool_choice_injective {x y : A} (hxy : x ≠ y) : Function.Injective (fun b : Bool => if b then x else y) := by
  intro a b h; cases a <;> cases b <;> simp_all

omit [Fintype ι] in
lemma rowJ_injective (i j : ι) (hij : i ≠ j) (x y : ι → A) (hxy : ∀ k, x k ≠ y k) :
    Function.Injective (rowJ i j x y) := by
  intro v w h
  apply Prod.ext
  · funext k
    apply bool_choice_injective (hxy k)
    have hh := congrFun h ⟨k,k.property.2⟩
    simpa only [rowJ, face, vertex, join_other] using hh
  · apply bool_choice_injective (hxy i)
    have hh := congrFun h ⟨i,hij⟩
    simpa only [rowJ, face, vertex, join_i] using hh

omit [Fintype ι] in
lemma rowI_injective (i j : ι) (hij : i ≠ j) (x y : ι → A) (hxy : ∀ k, x k ≠ y k) :
    Function.Injective (rowI i j x y) := by
  intro v w h
  apply Prod.ext
  · funext k
    apply bool_choice_injective (hxy k)
    have hh := congrFun h ⟨k,k.property.1⟩
    simpa only [rowI, face, vertex, join_other] using hh
  · apply bool_choice_injective (hxy j)
    have hh := congrFun h ⟨j,hij.symm⟩
    simpa only [rowI, face, vertex, join_j i j hij] using hh

omit [Fintype ι] in
lemma face_join_J (i j : ι) (_hij : i ≠ j) (x y : ι → A)
    (c : Other i j → Bool) (a b : Bool) :
    face j (vertex (join i j c a b) x y) = rowJ i j x y (c,a) := by
  funext k
  dsimp [face, vertex, rowJ]
  congr 1
  unfold join
  split_ifs <;> simp_all [k.property]

omit [Fintype ι] in
lemma face_join_I (i j : ι) (_hij : i ≠ j) (x y : ι → A)
    (c : Other i j → Bool) (a b : Bool) :
    face i (vertex (join i j c a b) x y) = rowI i j x y (c,b) := by
  funext k
  dsimp [face, vertex, rowI]
  congr 1
  unfold join
  split_ifs <;> simp_all [k.property]

lemma prod_split (i j : ι) (hij : i ≠ j) (F : (ι → Bool) → ℝ) :
    (∏ ν, F ν) = ∏ c : Other i j → Bool,
      F (join i j c false false) * F (join i j c false true) *
      F (join i j c true false) * F (join i j c true true) := by
  have h := Fintype.prod_equiv (splitEquiv i j hij)
    F (fun v => F (join i j v.1 v.2.1 v.2.2))
    (fun ν => congrArg F ((splitEquiv i j hij).left_inv ν).symm)
  rw [h, Fintype.prod_prod_type]
  apply Finset.prod_congr rfl
  intro c _
  simp only [Fintype.prod_prod_type, Fintype.prod_bool]
  ring

variable {C : Type*} [Fintype C] [DecidableEq C]
def boolSplitEquiv : ((C × Bool) → W) ≃ ((C → W) × (C → W)) where
  toFun t := (fun c => t (c,false), fun c => t (c,true))
  invFun v := fun cb => if cb.2 then v.2 cb.1 else v.1 cb.1
  left_inv t := by funext cb; rcases cb with ⟨c,b⟩; cases b <;> rfl
  right_inv v := by ext c <;> rfl

omit [DecidableEq W] [AddCommGroup W] [Module F₂ W] in
lemma expect_boolSplit (f : (C → W) → (C → W) → ℝ) :
    (𝔼 t : (C × Bool) → W, f (fun c => t (c,false)) (fun c => t (c,true))) =
      𝔼 t₀ : C → W, 𝔼 t₁ : C → W, f t₀ t₁ := by
  rw [← Finset.expect_product', Finset.univ_product_univ]
  exact Fintype.expect_equiv boolSplitEquiv _ _ (fun _ => rfl)

def cubeExpectation (i j : ι) (x y : ι → A) [Fintype A] [DecidableEq A]
    (V : (ι → Bool) → W → ℝ) : ℝ :=
  𝔼 Bj : ({k : ι // k ≠ j} → A) → W,
  𝔼 Bi : ({k : ι // k ≠ i} → A) → W,
    ∏ ν : ι → Bool, V ν (Bj (face j (vertex ν x y)) + Bi (face i (vertex ν x y)))

def squareProduct (i j : ι) (V : (ι → Bool) → W → ℝ)
    (r s : ((Other i j → Bool) × Bool) → W) : ℝ :=
  ∏ c : Other i j → Bool,
    V (join i j c false false) (r (c,false)+s (c,false)) *
    V (join i j c false true) (r (c,false)+s (c,true)) *
    V (join i j c true false) (r (c,true)+s (c,false)) *
    V (join i j c true true) (r (c,true)+s (c,true))

omit [Fintype W] [DecidableEq W] [Module F₂ W] in
lemma cubeProduct_eq (i j : ι) (hij : i ≠ j) (x y : ι → A)
    (V : (ι → Bool) → W → ℝ)
    (Bj : ({k : ι // k ≠ j} → A) → W) (Bi : ({k : ι // k ≠ i} → A) → W) :
    (∏ ν : ι → Bool, V ν (Bj (face j (vertex ν x y)) + Bi (face i (vertex ν x y)))) =
      squareProduct i j V (Bj ∘ rowJ i j x y) (Bi ∘ rowI i j x y) := by
  rw [prod_split i j hij]
  simp only [face_join_J i j hij, face_join_I i j hij, squareProduct, Function.comp_apply]

omit [DecidableEq W] in
lemma cubeExpectation_restrict [Fintype A] [DecidableEq A]
    (i j : ι) (hij : i ≠ j) (x y : ι → A) (hxy : ∀ k, x k ≠ y k)
    (V : (ι → Bool) → W → ℝ) :
    cubeExpectation i j x y V = 𝔼 r, 𝔼 s, squareProduct i j V r s := by
  unfold cubeExpectation
  simp_rw [cubeProduct_eq i j hij]
  have hBi (r) := expect_restrict (rowI i j x y) (rowI_injective i j hij x y hxy)
    (squareProduct i j V r)
  calc
    _ = 𝔼 Bj, 𝔼 s, squareProduct i j V (Bj ∘ rowJ i j x y) s := by
      apply Finset.expect_congr rfl
      intro Bj _
      exact hBi (Bj ∘ rowJ i j x y)
    _ = _ := expect_restrict (rowJ i j x y) (rowJ_injective i j hij x y hxy)
      (fun r => 𝔼 s, squareProduct i j V r s)

omit [DecidableEq W] in
lemma cubeExpectation_eq_squares [Fintype A] [DecidableEq A]
    (i j : ι) (hij : i ≠ j) (x y : ι → A) (hxy : ∀ k, x k ≠ y k)
    (V : (ι → Bool) → W → ℝ) :
    cubeExpectation i j x y V =
    𝔼 r₀ : (Other i j → Bool) → W, 𝔼 r₁ : (Other i j → Bool) → W,
    𝔼 s₀ : (Other i j → Bool) → W, 𝔼 s₁ : (Other i j → Bool) → W,
      ∏ c : Other i j → Bool,
        V (join i j c false false) (r₀ c+s₀ c) * V (join i j c false true) (r₀ c+s₁ c) *
        V (join i j c true false) (r₁ c+s₀ c) * V (join i j c true true) (r₁ c+s₁ c) := by
  rw [cubeExpectation_restrict i j hij x y hxy V]
  let F := squareProduct i j V
  change (𝔼 r, 𝔼 s, F r s) = _
  have hs (r : ((Other i j → Bool) × Bool) → W) : (𝔼 s, F r s) =
      𝔼 s₀ : (Other i j → Bool) → W, 𝔼 s₁ : (Other i j → Bool) → W,
      ∏ c : Other i j → Bool,
        V (join i j c false false) (r (c,false)+s₀ c) * V (join i j c false true) (r (c,false)+s₁ c) *
        V (join i j c true false) (r (c,true)+s₀ c) * V (join i j c true true) (r (c,true)+s₁ c) := expect_boolSplit (fun s₀ s₁ =>
      ∏ c : Other i j → Bool,
        V (join i j c false false) (r (c,false)+s₀ c) * V (join i j c false true) (r (c,false)+s₁ c) *
        V (join i j c true false) (r (c,true)+s₀ c) * V (join i j c true true) (r (c,true)+s₁ c))
  trans 𝔼 r : ((Other i j → Bool) × Bool) → W,
      𝔼 s₀ : (Other i j → Bool) → W, 𝔼 s₁ : (Other i j → Bool) → W,
        ∏ c : Other i j → Bool,
          V (join i j c false false) (r (c,false)+s₀ c) * V (join i j c false true) (r (c,false)+s₁ c) *
          V (join i j c true false) (r (c,true)+s₀ c) * V (join i j c true true) (r (c,true)+s₁ c)
  · exact Finset.expect_congr rfl (fun r _ => hs r)
  · exact expect_boolSplit (fun r₀ r₁ : (Other i j → Bool) → W =>
      𝔼 s₀ : (Other i j → Bool) → W, 𝔼 s₁ : (Other i j → Bool) → W,
        ∏ c : Other i j → Bool,
          V (join i j c false false) (r₀ c+s₀ c) * V (join i j c false true) (r₀ c+s₁ c) *
          V (join i j c true false) (r₁ c+s₀ c) * V (join i j c true true) (r₁ c+s₁ c))

omit [DecidableEq W] in
lemma cubeExpectation_bound [Fintype A] [DecidableEq A]
    (i j : ι) (hij : i ≠ j) (x y : ι → A) (hxy : ∀ k, x k ≠ y k)
    (V : (ι → Bool) → W → ℝ) (ε H : ℝ) (hε : 0 ≤ ε)
    (hcoef : ∀ ν α, |coefficient (V ν) α| ≤ ε)
    (henergy : ∀ ν, (𝔼 w, (V ν w)^2) ≤ H^2) :
    |cubeExpectation i j x y V| ≤ (ε^2*H^2)^(2^Fintype.card (Other i j)) := by
  rw [cubeExpectation_eq_squares i j hij x y hxy V]
  have h := independent_square_bound (fun c a b => V (join i j c a b)) ε H hε
    (fun c a b => hcoef _) (fun c a b => henergy _)
  simpa only [Fintype.card_fun, Fintype.card_bool] using h
end MinUncut.CubeRows

end

end OAI