lean/OAI/Computability/UniqueGames/Analysis/MatrixEnergy.lean

import Mathlib.Algebra.Order.BigOperators.Expect
import Mathlib.Basic.Real.Basic
import Mathlib.Tactic.FieldSimp
import Mathlib.Tactic.Linarith
import Mathlib.Tactic.Ring
import OAI.Computability.UniqueGames.Analysis.MatrixCharactersLemmas
import OAI.Computability.UniqueGames.Analysis.MatrixRestrictions
import OAI.Computability.UniqueGames.Analysis.MatrixSubspaceCount

namespace OAI

section

namespace UniqueGamesTheorem.Fourier.MatrixEnergy

open scoped BigOperators

variable {Q : Type*} {I : Q → Type*} [Fintype Q] [∀ q, Fintype (I q)]

/-- Squared coefficient energy, averaged using the supplied question weights. -/
noncomputable def energy (weight : Q → ℝ) (a : (q : Q) → I q → ℝ) : ℝ :=
  ∑ q, weight q * ∑ i, a q i ^ 2

/-- Squared energy retained by a coordinate projection. -/
noncomputable def cutoffEnergy (weight : Q → ℝ) (keep : (q : Q) → I q → Prop)
    (a : (q : Q) → I q → ℝ) : ℝ := by
  classical
  exact ∑ q, weight q * ∑ i, if keep q i then a q i ^ 2 else 0

/-- Diagonal spectral quadratic form. -/
noncomputable def spectralEnergy (weight : Q → ℝ) (eigen a : (q : Q) → I q → ℝ) : ℝ :=
  ∑ q, weight q * ∑ i, eigen q i * a q i ^ 2

theorem energy_nonneg (weight : Q → ℝ) (a : (q : Q) → I q → ℝ)
    (hw : ∀ q, 0 ≤ weight q) : 0 ≤ energy weight a := by
  exact Finset.sum_nonneg (fun q _ => mul_nonneg (hw q)
    (Finset.sum_nonneg (fun i _ => sq_nonneg (a q i))))

theorem cutoffEnergy_nonneg (weight : Q → ℝ) (keep : (q : Q) → I q → Prop)
    (a : (q : Q) → I q → ℝ) (hw : ∀ q, 0 ≤ weight q) :
    0 ≤ cutoffEnergy weight keep a := by
  classical
  unfold cutoffEnergy
  apply Finset.sum_nonneg
  intro q _
  apply mul_nonneg (hw q)
  apply Finset.sum_nonneg
  intro i _
  split_ifs
  · exact sq_nonneg _
  · exact le_rfl

/-- The projection onto any set of coefficient indices is a contraction in
the weighted squared norm. -/
theorem cutoffEnergy_le_energy (weight : Q → ℝ) (keep : (q : Q) → I q → Prop)
    (a : (q : Q) → I q → ℝ) (hw : ∀ q, 0 ≤ weight q) :
    cutoffEnergy weight keep a ≤ energy weight a := by
  classical
  apply Finset.sum_le_sum
  intro q _
  apply mul_le_mul_of_nonneg_left _ (hw q)
  apply Finset.sum_le_sum
  intro i _
  split_ifs <;> nlinarith [sq_nonneg (a q i)]

/-- Retained and discarded coefficient coordinates are orthogonal: their
energies add exactly to the original energy. -/
theorem energy_split (weight : Q → ℝ) (keep : (q : Q) → I q → Prop) (a : (q : Q) → I q → ℝ) :
    energy weight a = cutoffEnergy weight keep a +
      cutoffEnergy weight (fun q i => ¬ keep q i) a := by
  classical
  unfold energy cutoffEnergy
  rw [← Finset.sum_add_distrib]
  apply Finset.sum_congr rfl
  intro q _
  rw [← mul_add, ← Finset.sum_add_distrib]
  congr 1
  apply Finset.sum_congr rfl
  intro i _
  by_cases h : keep q i <;> simp [h]

/-- A spectral multiplier bounded by one on retained indices and by `η`
elsewhere contributes at most retained energy plus `η` times total energy. -/
theorem spectralEnergy_le_cutoff_add
    (weight : Q → ℝ) (keep : (q : Q) → I q → Prop) (eigen a : (q : Q) → I q → ℝ) (η : ℝ)
    (hw : ∀ q, 0 ≤ weight q) (hη : 0 ≤ η)
    (hone : ∀ q i, eigen q i ≤ 1)
    (hhigh : ∀ q i, ¬ keep q i → eigen q i ≤ η) :
    spectralEnergy weight eigen a ≤ cutoffEnergy weight keep a + η * energy weight a := by
  classical
  have hpoint (q : Q) (i : I q) :
      eigen q i * a q i ^ 2 ≤ (if keep q i then a q i ^ 2 else 0) + η * a q i ^ 2 := by
    by_cases hk : keep q i
    · have h := mul_le_mul_of_nonneg_right (hone q i) (sq_nonneg (a q i))
      have hn := mul_nonneg hη (sq_nonneg (a q i))
      simp only [hk, ite_true]
      nlinarith
    · simpa only [hk, ite_false, zero_add] using
        mul_le_mul_of_nonneg_right (hhigh q i hk) (sq_nonneg (a q i))
  calc
    spectralEnergy weight eigen a
        ≤ ∑ q, weight q * ∑ i,
          ((if keep q i then a q i ^ 2 else 0) + η * a q i ^ 2) := by
      apply Finset.sum_le_sum
      intro q _
      exact mul_le_mul_of_nonneg_left (Finset.sum_le_sum (fun i _ => hpoint q i)) (hw q)
    _ = cutoffEnergy weight keep a + η * energy weight a := by
      simp only [cutoffEnergy, energy, Finset.sum_add_distrib, ← Finset.mul_sum, mul_add]
      congr 1
      rw [Finset.mul_sum]
      apply Finset.sum_congr rfl
      intro q _
      ring

/-- Unit total energy and spectral value above `δ` force retained energy above
`δ/2` when all discarded multipliers are at most `δ/2`. -/
theorem cutoffEnergy_gt_half
    (weight : Q → ℝ) (keep : (q : Q) → I q → Prop) (eigen a : (q : Q) → I q → ℝ) (δ : ℝ)
    (hw : ∀ q, 0 ≤ weight q) (hδ : 0 ≤ δ)
    (hone : ∀ q i, eigen q i ≤ 1)
    (hhigh : ∀ q i, ¬ keep q i → eigen q i ≤ δ / 2)
    (htotal : energy weight a = 1) (hvalue : δ < spectralEnergy weight eigen a) :
    δ / 2 < cutoffEnergy weight keep a := by
  have h := spectralEnergy_le_cutoff_add weight keep eigen a (δ / 2)
    hw (by linarith) hone hhigh
  rw [htotal] at h
  linarith

/-- The elementary square bound, summed over the retained coefficients.  The
discarded term on the right uses the full coefficient difference, giving the
contraction needed for equation (5.11) without introducing square roots. -/
theorem cutoffEnergy_le_twice_difference_add
    (weight : Q → ℝ) (keep : (q : Q) → I q → Prop) (H G : (q : Q) → I q → ℝ)
    (hw : ∀ q, 0 ≤ weight q) :
    cutoffEnergy weight keep H ≤
      2 * energy weight (fun q i => H q i - G q i) + 2 * cutoffEnergy weight keep G := by
  classical
  have hpoint (q : Q) (i : I q) :
      (if keep q i then H q i ^ 2 else 0) ≤
        2 * (H q i - G q i) ^ 2 + 2 * (if keep q i then G q i ^ 2 else 0) := by
    by_cases hk : keep q i
    · simp only [hk, ite_true]
      nlinarith [sq_nonneg (H q i - 2 * G q i)]
    · simp only [hk, ite_false, mul_zero, add_zero]
      nlinarith [sq_nonneg (H q i - G q i)]
  calc
    cutoffEnergy weight keep H ≤
        ∑ q, weight q * ∑ i,
          (2 * (H q i - G q i) ^ 2 + 2 * (if keep q i then G q i ^ 2 else 0)) := by
      apply Finset.sum_le_sum
      intro q _
      exact mul_le_mul_of_nonneg_left (Finset.sum_le_sum (fun i _ => hpoint q i)) (hw q)
    _ = 2 * energy weight (fun q i => H q i - G q i) +
        2 * cutoffEnergy weight keep G := by
      simp only [energy, cutoffEnergy, Finset.sum_add_distrib, ← Finset.mul_sum, mul_add]
      congr 1 <;> rw [Finset.mul_sum] <;>
        apply Finset.sum_congr rfl <;> intro q _ <;> ring

theorem deleted_energy_gt_eighth
    (weight : Q → ℝ) (keep : (q : Q) → I q → Prop) (H G : (q : Q) → I q → ℝ) (δ : ℝ)
    (hw : ∀ q, 0 ≤ weight q)
    (hlarge : δ / 2 < cutoffEnergy weight keep H)
    (hsmall : cutoffEnergy weight keep G ≤ δ / 8) :
    δ / 8 < energy weight (fun q i => H q i - G q i) := by
  have h := cutoffEnergy_le_twice_difference_add weight keep H G hw
  linarith

/-- Squared Boolean functions equal their values under a finite weighted sum. -/
theorem boolean_energy_eq_mass (weight : Q → ℝ) (H : (q : Q) → I q → ℝ)
    (hbool : ∀ q i, H q i = 0 ∨ H q i = 1) :
    energy weight H = ∑ q, weight q * ∑ i, H q i := by
  unfold energy
  apply Finset.sum_congr rfl
  intro q _
  congr 1
  apply Finset.sum_congr rfl
  intro i _
  rcases hbool q i with h | h <;> simp [h]

/-- A finite union bound for fractional removed mass dominated by indicator
events. Both the event choice and the removed value may depend on the outcome. -/
theorem weighted_union_bound {Ω J : Type*} [Fintype Ω] [Fintype J]
    (weight value : Ω → ℝ) (event : J → Ω → Prop)
    [∀ j, DecidablePred (event j)]
    (hw : ∀ ω, 0 ≤ weight ω) (hvalue : ∀ ω, value ω ≤ 1)
    (hcover : ∀ ω, 0 < value ω → ∃ j, event j ω) :
    (∑ ω, weight ω * value ω) ≤
      ∑ j, ∑ ω, weight ω * (if event j ω then (1 : ℝ) else 0) := by
  classical
  rw [Finset.sum_comm]
  apply Finset.sum_le_sum
  intro ω _
  rw [← Finset.mul_sum]
  apply mul_le_mul_of_nonneg_left _ (hw ω)
  by_cases hp : 0 < value ω
  · obtain ⟨j, hj⟩ := hcover ω hp
    have hs : (if event j ω then (1 : ℝ) else 0) ≤
        ∑ k, if event k ω then (1 : ℝ) else 0 := by
      apply Finset.single_le_sum (s := Finset.univ)
        (f := fun k : J => if event k ω then (1 : ℝ) else 0) (a := j)
      · intro k _; split_ifs <;> norm_num
      · exact Finset.mem_univ j
    exact le_trans (hvalue ω) (by simpa [hj] using hs)
  · exact le_trans (le_of_not_gt hp) (Finset.sum_nonneg (by intro j _; split_ifs <;> norm_num))

/-- Finite real pigeonhole principle for the one fixed color/subspace choice. -/
theorem exists_fixed_event {J : Type*} [Fintype J] (mass : J → ℝ)
    (threshold budget : ℝ)
    (hcount : (Fintype.card J : ℝ) * threshold ≤ budget)
    (hmass : budget < ∑ j, mass j) : ∃ j, threshold < mass j := by
  classical
  by_contra h
  push Not at h
  have hs : (∑ j, mass j) ≤ (Fintype.card J : ℝ) * threshold := by
    calc
      (∑ j, mass j) ≤ ∑ _j : J, threshold := Finset.sum_le_sum (fun j _ => h j)
      _ = _ := by simp
  linarith

/-- The explicit denominator in (5.13), for any supplied event-count bound. -/
theorem exists_fixed_event_scaled {J : Type*} [Fintype J]
    (mass : J → ℝ) (N : ℕ) (δ : ℝ)
    (hN : 0 < N) (hδ : 0 ≤ δ) (hcard : Fintype.card J ≤ N)
    (hmass : δ / 8 < ∑ j, mass j) :
    ∃ j, δ / (8 * (N : ℝ)) < mass j := by
  have hNreal : (0 : ℝ) < N := by exact_mod_cast hN
  have hcardreal : (Fintype.card J : ℝ) ≤ N := by exact_mod_cast hcard
  have hthreshold : 0 ≤ δ / (8 * (N : ℝ)) :=
    div_nonneg hδ (mul_nonneg (by norm_num) hNreal.le)
  have hcancel : (N : ℝ) * (δ / (8 * (N : ℝ))) = δ / 8 := by
    field_simp [ne_of_gt hNreal]
  apply exists_fixed_event mass (δ / (8 * (N : ℝ))) (δ / 8) _ hmass
  rw [← hcancel]
  exact mul_le_mul_of_nonneg_right hcardreal hthreshold

section LinearMaps

open MatrixCharacters MatrixFourier

variable {E F : Type*}
variable [AddCommGroup E] [Module F2 E] [AddCommGroup F] [Module F2 F]
variable [FiniteDimensional F2 E] [FiniteDimensional F2 F]
variable [Fintype (E →ₗ[F2] F)] [Fintype (F →ₗ[F2] E)]

/-- The actual rank of a Fourier index restricted to the alphabet subspace. -/
noncomputable def linearRankOn (C : Submodule F2 F) (S : F →ₗ[F2] E) : ℕ :=
  Module.finrank F2 (LinearMap.range (S.comp C.subtype))

omit [FiniteDimensional F2 E] [FiniteDimensional F2 F]
  [Fintype (E →ₗ[F2] F)] [Fintype (F →ₗ[F2] E)] in
theorem linearRankOn_top (S : F →ₗ[F2] E) :
    linearRankOn (⊤ : Submodule F2 F) S =
      Module.finrank F2 (LinearMap.range S) := by
  have hrange : LinearMap.range (S.comp (⊤ : Submodule F2 F).subtype) =
      LinearMap.range S := by
    ext x
    constructor
    · rintro ⟨v, hv⟩
      exact ⟨v.1, hv⟩
    · rintro ⟨v, hv⟩
      exact ⟨⟨v, by simp⟩, hv⟩
  exact congrArg (fun P : Submodule F2 E => Module.finrank F2 P) hrange

omit [FiniteDimensional F2 E] [FiniteDimensional F2 F]
  [Fintype (E →ₗ[F2] F)] [Fintype (F →ₗ[F2] E)] in
/-- Restricting to the image of a symbol embedding has the same image rank
as composition with that embedding, even when it is not injective. -/
theorem linearRankOn_range {V : Type*} [AddCommGroup V] [Module F2 V]
    (S : F →ₗ[F2] E) (ι : V →ₗ[F2] F) :
    linearRankOn (LinearMap.range ι) S =
      Module.finrank F2 (LinearMap.range (S.comp ι)) := by
  have hrange : LinearMap.range (S.comp (LinearMap.range ι).subtype) =
      LinearMap.range (S.comp ι) := by
    ext x
    constructor
    · rintro ⟨v, hv⟩
      obtain ⟨u, hu⟩ := v.property
      refine ⟨u, ?_⟩
      change S (ι u) = x
      rw [hu]
      exact hv
    · rintro ⟨u, hu⟩
      exact ⟨⟨ι u, ⟨u, rfl⟩⟩, hu⟩
  exact congrArg (fun P : Submodule F2 E => Module.finrank F2 P) hrange

/-- Projection onto trace characters whose index has bounded rank on `C`. -/
noncomputable def rankProjection (C : Submodule F2 F) (r : ℕ)
    (f : (E →ₗ[F2] F) → ℝ) : (E →ₗ[F2] F) → ℝ := by
  classical
  exact ∑ S : F →ₗ[F2] E,
    (if linearRankOn C S ≤ r then linearCoeff f S else 0) •
      (fun X => (linearTraceCharacter S X).re)

omit [FiniteDimensional F2 E] [FiniteDimensional F2 F] [Fintype (F →ₗ[F2] E)] in
theorem linearCoeff_sub (f g : (E →ₗ[F2] F) → ℝ) (S : F →ₗ[F2] E) :
    linearCoeff (fun X => f X - g X) S = linearCoeff f S - linearCoeff g S := by
  simp only [linearCoeff, sub_mul, Finset.expect_sub_distrib]

/-- The genuine function-space projection acts by the claimed coefficient mask. -/
theorem linearCoeff_rankProjection (C : Submodule F2 F) (r : ℕ)
    (f : (E →ₗ[F2] F) → ℝ) (S : F →ₗ[F2] E) :
    linearCoeff (rankProjection C r f) S =
      if linearRankOn C S ≤ r then linearCoeff f S else 0 := by
  classical
  unfold rankProjection
  rw [linearCoeff_sum]
  simp only [linearCoeff_smul, linearCoeff_character, mul_ite, mul_one, mul_zero]
  simp

/-- Squared norm of the actual projection equals the retained coefficient mass. -/
theorem rankProjection_parseval (C : Submodule F2 F) (r : ℕ)
    (f : (E →ₗ[F2] F) → ℝ) :
    (𝔼 X, rankProjection C r f X ^ 2) =
      ∑ S : F →ₗ[F2] E, if linearRankOn C S ≤ r then linearCoeff f S ^ 2 else 0 := by
  classical
  rw [← linear_parseval]
  apply Finset.sum_congr rfl
  intro S _
  rw [linearCoeff_rankProjection]
  split_ifs <;> simp

/-- Contraction for the actual rank projection with the uniform function norm. -/
theorem rankProjection_contraction (C : Submodule F2 F) (r : ℕ)
    (f : (E →ₗ[F2] F) → ℝ) :
    (𝔼 X, rankProjection C r f X ^ 2) ≤ 𝔼 X, f X ^ 2 := by
  classical
  rw [rankProjection_parseval, ← linear_parseval]
  apply Finset.sum_le_sum
  intro S _
  split_ifs
  · exact le_rfl
  · exact sq_nonneg _

/-- The projected part is orthogonal to the discarded part in the actual
uniform function inner product. -/
theorem rankProjection_orthogonal (C : Submodule F2 F) (r : ℕ)
    (f : (E →ₗ[F2] F) → ℝ) :
    (𝔼 X, rankProjection C r f X * (f X - rankProjection C r f X)) = 0 := by
  classical
  rw [← linear_parseval_inner]
  apply Finset.sum_eq_zero
  intro S _
  rw [linearCoeff_sub, linearCoeff_rankProjection]
  split_ifs <;> simp

theorem linear_energy_parseval (weight : Q → ℝ) (f : Q → (E →ₗ[F2] F) → ℝ) :
    energy weight (fun q S => linearCoeff (f q) S) =
      ∑ q, weight q * (𝔼 X, f q X ^ 2) := by
  simp only [energy, linear_parseval]

theorem linear_difference_energy_parseval (weight : Q → ℝ)
    (H G : Q → (E →ₗ[F2] F) → ℝ) :
    energy weight (fun q S => linearCoeff (H q) S - linearCoeff (G q) S) =
      ∑ q, weight q * (𝔼 X, (H q X - G q X) ^ 2) := by
  simp only [← linearCoeff_sub, linear_energy_parseval]

/-- Equation (5.11) now for actual functions on a binary linear-map space,
using the actual restriction rank and trace Fourier coefficients. -/
theorem linear_deleted_energy_gt_eighth
    (weight : Q → ℝ) (C : Submodule F2 F) (r : ℕ)
    (H G : Q → (E →ₗ[F2] F) → ℝ) (δ : ℝ)
    (hw : ∀ q, 0 ≤ weight q)
    (hlarge : δ / 2 < cutoffEnergy weight (fun _ S => linearRankOn C S ≤ r)
      (fun q S => linearCoeff (H q) S))
    (hsmall : cutoffEnergy weight (fun _ S => linearRankOn C S ≤ r)
      (fun q S => linearCoeff (G q) S) ≤ δ / 8) :
    δ / 8 < ∑ q, weight q * (𝔼 X, (H q X - G q X) ^ 2) := by
  rw [← linear_difference_energy_parseval]
  exact deleted_energy_gt_eighth weight (fun _ S => linearRankOn C S ≤ r)
    (fun q S => linearCoeff (H q) S) (fun q S => linearCoeff (G q) S)
    δ hw hlarge hsmall

/-- Color indicator of one actual labeling. -/
noncomputable def colorIndicator {X Y : Type*} (label : X → Y) (y : Y) : X → ℝ := by
  classical
  exact fun x => if label x = y then 1 else 0

theorem colorIndicator_partition {X Y : Type*} [Fintype Y]
    (label : X → Y) (x : X) : ∑ y, colorIndicator label y x ^ 2 = 1 := by
  classical
  simp [colorIndicator, eq_comm]

/-- Parseval for all color indicators sums to exactly one, with the correct
uniform primal normalization and counting measure on Fourier indices. -/
theorem colorIndicator_parseval {Y : Type*} [Fintype Y]
    (label : (E →ₗ[F2] F) → Y) :
    (∑ y, ∑ S : F →ₗ[F2] E, linearCoeff (colorIndicator label y) S ^ 2) = 1 := by
  simp_rw [linear_parseval]
  rw [← Finset.expect_sum_comm]
  simp_rw [colorIndicator_partition]
  exact Fintype.expect_const 1

/-- Fourier coefficient array for a family of labelings, including color as
part of the component index. -/
noncomputable def labelingCoeff {Y : Type*}
    (label : Q → (E →ₗ[F2] F) → Y) (qy : Q × Y) (S : F →ₗ[F2] E) : ℝ :=
  linearCoeff (colorIndicator (label qy.1) qy.2) S

theorem labelingCoeff_energy_one {Y : Type*} [Fintype Y]
    (weight : Q → ℝ) (label : Q → (E →ₗ[F2] F) → Y)
    (hnorm : ∑ q, weight q = 1) :
    energy (fun qy : Q × Y => weight qy.1) (labelingCoeff label) = 1 := by
  classical
  calc
    energy (fun qy : Q × Y => weight qy.1) (labelingCoeff label) =
        ∑ q, weight q * (∑ y, ∑ S : F →ₗ[F2] E,
          linearCoeff (colorIndicator (label q) y) S ^ 2) := by
      simp only [energy, labelingCoeff, Fintype.sum_prod_type, Finset.mul_sum]
    _ = ∑ q, weight q := by simp only [colorIndicator_parseval, mul_one]
    _ = 1 := hnorm

/-- The low-rank Fourier-energy conclusion (5.5), for genuine binary linear
maps and genuine labeling coefficients. The spectral premise can be obtained
from the noise diagonalization; the bound is on actual restriction rank. -/
theorem labeling_lowRank_energy {Y : Type*} [Fintype Y]
    (weight : Q → ℝ) (label : Q → (E →ₗ[F2] F) → Y)
    (C : Submodule F2 F) (r : ℕ) (eigen : Q → (F →ₗ[F2] E) → ℝ) (δ : ℝ)
    (hw : ∀ q, 0 ≤ weight q) (hnorm : ∑ q, weight q = 1) (hδ : 0 ≤ δ)
    (hone : ∀ q S, eigen q S ≤ 1)
    (hhigh : ∀ q S, r < linearRankOn C S → eigen q S ≤ δ / 2)
    (hvalue : δ < spectralEnergy (fun qy : Q × Y => weight qy.1)
      (fun qy S => eigen qy.1 S) (labelingCoeff label)) :
    δ / 2 < cutoffEnergy (fun qy : Q × Y => weight qy.1)
      (fun _ S => linearRankOn C S ≤ r) (labelingCoeff label) := by
  apply cutoffEnergy_gt_half _ _ _ _ δ
  · intro qy; exact hw qy.1
  · exact hδ
  · intro qy S; exact hone qy.1 S
  · intro qy S hS; exact hhigh qy.1 S (Nat.lt_of_not_ge hS)
  · exact labelingCoeff_energy_one weight label hnorm
  · exact hvalue

end LinearMaps

section DependentLinearMaps

open MatrixCharacters MatrixFourier

variable {J : Type*} [Fintype J] {E : J → Type*} {F : Type*}
    [∀ j, AddCommGroup (E j)] [∀ j, Module F2 (E j)]
    [AddCommGroup F] [Module F2 F]
    [∀ j, FiniteDimensional F2 (E j)] [FiniteDimensional F2 F]
    [∀ j, Fintype (E j →ₗ[F2] F)] [∀ j, Fintype (F →ₗ[F2] E j)]

theorem dependent_linear_energy_parseval
    (weight : J → ℝ) (H : (j : J) → (E j →ₗ[F2] F) → ℝ) :
    energy weight (fun j S => linearCoeff (H j) S) =
      ∑ j, weight j * (𝔼 X, H j X ^ 2) := by
  unfold energy
  apply Finset.sum_congr rfl
  intro j _
  rw [linear_parseval]

omit [∀ j, FiniteDimensional F2 (E j)] [FiniteDimensional F2 F] in

theorem dependent_remainder_cutoff_le_eighth
    (weight : J → ℝ) (C : Submodule F2 F) (r : ℕ)
    (G : (j : J) → (E j →ₗ[F2] F) → ℝ) (κ δ : ℝ)
    (hw : ∀ j, 0 ≤ weight j) (hκ : 0 ≤ κ) (hκδ : κ ≤ δ / 8)
    (hlevel : ∀ j, (∑ S : F →ₗ[F2] E j,
      if linearRankOn C S ≤ r then linearCoeff (G j) S ^ 2 else 0) ≤
        κ * (𝔼 X, G j X ^ 2))
    (hmass : (∑ j, weight j * (𝔼 X, G j X ^ 2)) ≤ 1) :
    cutoffEnergy weight (fun _ S => linearRankOn C S ≤ r)
      (fun j S => linearCoeff (G j) S) ≤ δ / 8 := by
  classical
  have hs : cutoffEnergy weight (fun _ S => linearRankOn C S ≤ r)
      (fun j S => linearCoeff (G j) S) ≤
      κ * (∑ j, weight j * (𝔼 X, G j X ^ 2)) := by
    calc
      _ ≤ ∑ j, weight j * (κ * (𝔼 X, G j X ^ 2)) := by
        apply Finset.sum_le_sum
        intro j _
        apply mul_le_mul_of_nonneg_left _ (hw j)
        simpa using hlevel j
      _ = _ := by
        rw [Finset.mul_sum]
        apply Finset.sum_congr rfl
        intro j _
        ring
  have hm := mul_le_mul_of_nonneg_left hmass hκ
  linarith

/-- The actual removed probability energy in Section 5.3, allowing the map
domain to depend on the complete question and color index. -/
theorem dependent_deleted_energy_from_level
    (weight : J → ℝ) (C : Submodule F2 F) (r : ℕ)
    (H G : (j : J) → (E j →ₗ[F2] F) → ℝ) (κ δ : ℝ)
    (hw : ∀ j, 0 ≤ weight j) (hκ : 0 ≤ κ) (hκδ : κ ≤ δ / 8)
    (hlarge : δ / 2 < cutoffEnergy weight (fun _ S => linearRankOn C S ≤ r)
      (fun j S => linearCoeff (H j) S))
    (hlevel : ∀ j, (∑ S : F →ₗ[F2] E j,
      if linearRankOn C S ≤ r then linearCoeff (G j) S ^ 2 else 0) ≤
        κ * (𝔼 X, G j X ^ 2))
    (hmass : (∑ j, weight j * (𝔼 X, G j X ^ 2)) ≤ 1) :
    δ / 8 < ∑ j, weight j * (𝔼 X, (H j X - G j X) ^ 2) := by
  have hsmall := dependent_remainder_cutoff_le_eighth weight C r G κ δ
    hw hκ hκδ hlevel hmass
  have h := deleted_energy_gt_eighth weight (fun _ S => linearRankOn C S ≤ r)
    (fun j S => linearCoeff (H j) S) (fun j S => linearCoeff (G j) S)
    δ hw hlarge hsmall
  simpa only [← linearCoeff_sub, energy, linear_parseval, Pi.sub_apply] using h

end DependentLinearMaps

/-- Real value of a Boolean indicator. -/
def boolReal (b : Bool) : ℝ := if b then 1 else 0

@[simp] theorem boolReal_sq (b : Bool) : boolReal b ^ 2 = boolReal b := by
  cases b <;> norm_num [boolReal]

theorem boolReal_le_one (b : Bool) : boolReal b ≤ 1 := by
  cases b <;> norm_num [boolReal]

/-- Boolean indicator of one color of a labeling. -/
noncomputable def labelBool {X Y : Type*} (label : X → Y) (y : Y) : X → Bool := by
  classical
  exact fun x => decide (label x = y)

theorem labelBool_real {X Y : Type*} (label : X → Y) (y : Y) (x : X) :
    boolReal (labelBool label y x) = colorIndicator label y x := by
  classical
  simp [boolReal, labelBool, colorIndicator]

/-- Deletion's actual Boolean removed function is exactly the difference of
the original and remainder indicators. -/
theorem removed_boolReal {X Row Witness : Type*}
    (S : Deletion.RestrictionSystem X Row Witness) (H : X → Bool) (p d : ℕ) (x : X) :
    boolReal (Deletion.removed S H p d x) =
      boolReal (H x) - boolReal (Deletion.remainder S H p d x) := by
  classical
  by_cases hd : Deletion.DeletedSet S H p d x
  · simp [Deletion.removed, Deletion.remainder, hd, boolReal]
  · simp [Deletion.removed, Deletion.remainder, hd, boolReal]

theorem removed_difference_sq {X Row Witness : Type*}
    (S : Deletion.RestrictionSystem X Row Witness) (H : X → Bool) (p d : ℕ) (x : X) :
    (boolReal (H x) - boolReal (Deletion.remainder S H p d x)) ^ 2 =
      boolReal (Deletion.removed S H p d x) := by
  rw [← removed_boolReal, boolReal_sq]

section QuestionProbabilities

variable {Ω : Q → Type*} [∀ q, Fintype (Ω q)]
variable {Y A : Type*} [Fintype Y] [Fintype A]

/-- An event probability: first sample the question with the supplied weights,
then sample uniformly in its own finite space. -/
noncomputable def questionEventMass
    (weight : Q → ℝ) (B : (q : Q) → Ω q → Prop) : ℝ := by
  classical
  exact ∑ q, weight q * (𝔼 X, if B q X then (1 : ℝ) else 0)

theorem dependent_removed_union_bound
    (weight : Q → ℝ) (d : (q : Q) → Y → Ω q → ℝ)
    (B : (q : Q) → Y → A → Ω q → Prop)
    (hw : ∀ q, 0 ≤ weight q)
    (hd : ∀ q y X, d q y X ≤ 1)
    (hc : ∀ q y X, 0 < d q y X → ∃ a, B q y a X) :
    (∑ q, weight q * ∑ y, 𝔼 X, d q y X) ≤
      ∑ ya : Y × A, questionEventMass weight (fun q X => B q ya.1 ya.2 X) := by
  classical
  have hp (q : Q) (y : Y) (X : Ω q) :
      d q y X ≤ ∑ a, if B q y a X then (1 : ℝ) else 0 := by
    by_cases hpos : 0 < d q y X
    · obtain ⟨a, ha⟩ := hc q y X hpos
      have hi := Finset.single_le_sum (s := Finset.univ)
        (f := fun b : A => if B q y b X then (1 : ℝ) else 0)
        (fun b _ => by split_ifs <;> norm_num) (Finset.mem_univ a)
      exact le_trans (hd q y X) (by simpa [ha] using hi)
    · exact le_trans (le_of_not_gt hpos)
        (Finset.sum_nonneg (by intro a _; split_ifs <;> norm_num))
  calc
    _ ≤ ∑ q, weight q * ∑ y, 𝔼 X,
        ∑ a, if B q y a X then (1 : ℝ) else 0 := by
      apply Finset.sum_le_sum
      intro q _
      apply mul_le_mul_of_nonneg_left _ (hw q)
      apply Finset.sum_le_sum
      intro y _
      exact Finset.expect_le_expect (fun X _ => hp q y X)
    _ = _ := by
      simp only [questionEventMass, Finset.expect_sum_comm,
        Finset.mul_sum, Fintype.sum_prod_type]
      rw [Finset.sum_comm]
      apply Finset.sum_congr rfl
      intro y _
      exact Finset.sum_comm

/-- One target is fixed before sampling the question and its map. -/
theorem fixed_target_of_removed_mass
    (weight : Q → ℝ) (d : (q : Q) → Y → Ω q → ℝ)
    (B : (q : Q) → Y → A → Ω q → Prop)
    (hw : ∀ q, 0 ≤ weight q) (hd : ∀ q y X, d q y X ≤ 1)
    (hc : ∀ q y X, 0 < d q y X → ∃ a, B q y a X)
    (δ : ℝ) (N : ℕ) (hδ : 0 ≤ δ) (hN : 0 < N)
    (hcount : Fintype.card (Y × A) ≤ N)
    (hremoved : δ / 8 < ∑ q, weight q * ∑ y, 𝔼 X, d q y X) :
    ∃ y a, δ / (8 * (N : ℝ)) <
      questionEventMass weight (fun q X => B q y a X) := by
  have hu := dependent_removed_union_bound weight d B hw hd hc
  obtain ⟨⟨y, a⟩, hya⟩ := exists_fixed_event_scaled
    (fun ya : Y × A => questionEventMass weight (fun q X => B q ya.1 ya.2 X))
    N δ hN hδ hcount (lt_of_lt_of_le hremoved hu)
  exact ⟨y, a, hya⟩

/-- A Boolean subpartition has total squared mass at most one. Colors are
summed with counting measure, not averaged. -/
theorem boolean_subpartition_energy_le_one [∀ q, Nonempty (Ω q)]
    (weight : Q → ℝ) (label : (q : Q) → Ω q → Y)
    (G : (q : Q) → Y → Ω q → Bool)
    (hw : ∀ q, 0 ≤ weight q) (hnorm : ∑ q, weight q = 1)
    (hG : ∀ q y X, G q y X = true → label q X = y) :
    (∑ q, weight q * ∑ y, 𝔼 X, boolReal (G q y X) ^ 2) ≤ 1 := by
  classical
  have hp (q : Q) (X : Ω q) :
      (∑ y, boolReal (G q y X) ^ 2) ≤ 1 := by
    calc
      _ ≤ ∑ y, colorIndicator (label q) y X ^ 2 := by
        apply Finset.sum_le_sum
        intro y _
        by_cases hg : G q y X = true
        · have hl := hG q y X hg
          simp [hg, boolReal, colorIndicator, hl]
        · simpa [boolReal, hg] using sq_nonneg (colorIndicator (label q) y X)
      _ = 1 := colorIndicator_partition (label q) X
  have hq (q : Q) : (∑ y, 𝔼 X, boolReal (G q y X) ^ 2) ≤ 1 := by
    rw [← Finset.expect_sum_comm]
    calc
      _ ≤ 𝔼 _X : Ω q, (1 : ℝ) := Finset.expect_le_expect (fun X _ => hp q X)
      _ = 1 := Fintype.expect_const 1
  calc
    _ ≤ ∑ q, weight q * 1 :=
      Finset.sum_le_sum (fun q _ => mul_le_mul_of_nonneg_left (hq q) (hw q))
    _ = 1 := by simpa using hnorm

/-- The actual whole-row remainder of labeling indicators satisfies the mass
bound needed in the deleted-energy argument, with no remaining mass hypothesis. -/
theorem remainder_subpartition_energy_le_one [∀ q, Nonempty (Ω q)]
    {Row Witness : Q → Type*}
    (S : (q : Q) → Deletion.RestrictionSystem (Ω q) (Row q) (Witness q))
    (weight : Q → ℝ) (label : (q : Q) → Ω q → Y) (p d : ℕ)
    (hw : ∀ q, 0 ≤ weight q) (hnorm : ∑ q, weight q = 1) :
    (∑ q, weight q * ∑ y, 𝔼 X,
      boolReal (Deletion.remainder (S q) (labelBool (label q) y) p d X) ^ 2) ≤ 1 := by
  apply boolean_subpartition_energy_le_one weight label _ hw hnorm
  intro q y X hG
  have h := Deletion.remainder_le_original (S q) (labelBool (label q) y) p d X hG
  simpa [labelBool] using h

end QuestionProbabilities

section ActualBadRows

open MatrixCharacters

variable {C : Type*} [AddCommGroup C] [Module F2 C]
    [FiniteDimensional F2 C] [Fintype C]
    {E : Q → Type*} [∀ q, AddCommGroup (E q)] [∀ q, Module F2 (E q)]
    [∀ q, Finite (E q)] [∀ q, Fintype (E q →ₗ[F2] C)]

/-- Equation (5.13) for the actual whole-row deletion system. Only the color
and target subspace are selected. Neither the question, row value, nor witness
vanishing subspace is part of the counted target. -/
theorem fixed_badRow_target_of_removed_mass
    (weight : Q → ℝ) (H : (q : Q) → C → (E q →ₗ[F2] C) → Bool)
    (r p d : ℕ) (δ : ℝ)
    (hw : ∀ q, 0 ≤ weight q) (hδ : 0 ≤ δ)
    (hremoved : δ / 8 < ∑ q, weight q * ∑ y, 𝔼 X,
      boolReal (Deletion.removed (MatrixRestrictions.system r) (H q y) p d X)) :
    ∃ (y : C) (C' : Submodule F2 C), Module.finrank F2 (C ⧸ C') ≤ r ∧
      δ / (8 * (Nat.card C : ℝ) * (2 : ℝ) ^
        (Module.finrank F2 C * Module.finrank F2 C)) <
      questionEventMass weight (fun q (X : E q →ₗ[F2] C) =>
        Deletion.BadRow (MatrixRestrictions.system r) (H q y) p d
          ⟨C', C'.mkQ.comp X⟩) := by
  classical
  let : Finite (C →ₗ[F2] C) := Finite.of_injective
    (fun f : C →ₗ[F2] C => (f : C → C)) DFunLike.coe_injective
  let : Finite (Submodule F2 C) := Finite.of_surjective
    (fun f : C →ₗ[F2] C => LinearMap.range f)
    MatrixSubspaceCount.endomorphism_range_surjective
  let A := {C' : Submodule F2 C // Module.finrank F2 (C ⧸ C') ≤ r}
  let : Fintype A := Fintype.ofFinite A
  let N := Nat.card C * 2 ^ (Module.finrank F2 C * Module.finrank F2 C)
  let value (q : Q) (y : C) (X : E q →ₗ[F2] C) : ℝ :=
    boolReal (Deletion.removed (MatrixRestrictions.system r) (H q y) p d X)
  let event (q : Q) (y : C) (a : A) (X : E q →ₗ[F2] C) : Prop :=
    Deletion.BadRow (MatrixRestrictions.system r) (H q y) p d
      ⟨a.val, a.val.mkQ.comp X⟩
  have hcover (q : Q) (y : C) (X : E q →ₗ[F2] C) (hpos : 0 < value q y X) :
      ∃ a : A, event q y a X := by
    have ht : Deletion.removed (MatrixRestrictions.system r) (H q y) p d X = true := by
      by_contra hn
      simp [value, boolReal, hn] at hpos
    have hdel : Deletion.DeletedSet (MatrixRestrictions.system r) (H q y) p d X := by
      by_contra hn
      simp [Deletion.removed, hn] at ht
    obtain ⟨C', hcodim, hbad⟩ :=
      (MatrixRestrictions.deletedSet_iff_exists_admissible_target (H q y) r p d X).mp hdel
    exact ⟨⟨C', hcodim⟩, hbad⟩
  have hcount : Fintype.card (C × A) ≤ N := by
    simpa only [A, N, Nat.card_eq_fintype_card] using
      (MatrixSubspaceCount.card_color_admissible_subspaces_le
        (fun C' : Submodule F2 C => Module.finrank F2 (C ⧸ C') ≤ r))
  have hN : 0 < N := by
    simpa only [N, Nat.card_eq_fintype_card] using
      (Nat.mul_pos (Fintype.card_pos : 0 < Fintype.card C)
        (pow_pos (by norm_num : 0 < (2 : ℕ)) (Module.finrank F2 C * Module.finrank F2 C)))
  obtain ⟨y, a, ha⟩ := fixed_target_of_removed_mass weight value event hw
    (fun _ _ _ => boolReal_le_one _) hcover δ N hδ hN hcount hremoved
  refine ⟨y, a.val, a.property, ?_⟩
  simpa only [N, event, Nat.cast_mul, Nat.cast_pow, Nat.cast_ofNat, mul_assoc] using ha

end ActualBadRows

end UniqueGamesTheorem.Fourier.MatrixEnergy

end

end OAI