lean/OAI/Probability/GaussianPropeller/Dual.lean

import OAI.Probability.GaussianPropeller.Moments

namespace OAI

open MeasureTheory ProbabilityTheory
open scoped ENNReal
namespace GaussianPropeller
open scoped RealInnerProductSpace

namespace Reduction

abbrev Tuple (d k : ℕ) := PiLp 2 (fun _ : Fin k => Space d)

variable {d k : ℕ} [NeZero k]

noncomputable def scoreMax (v : Fin k → Space d) (x : Space d) : ℝ :=
  Finset.univ.sup' Finset.univ_nonempty (fun i => ⟪v i, x⟫)

noncomputable def width (v : Tuple d k) : ℝ := ∫ x, scoreMax v.ofLp x ∂gaussian d

theorem le_scoreMax (v : Fin k → Space d) (i : Fin k) (x : Space d) :
    ⟪v i, x⟫ ≤ scoreMax v x := by
  exact Finset.le_sup' (fun j => ⟪v j, x⟫) (Finset.mem_univ i)

theorem scoreMax_le_iff (v : Fin k → Space d) (x : Space d) (b : ℝ) :
    scoreMax v x ≤ b ↔ ∀ i, ⟪v i, x⟫ ≤ b := by
  simp only [scoreMax, Finset.sup'_le_iff, Finset.mem_univ, forall_const]

theorem exists_scoreMax (v : Fin k → Space d) (x : Space d) :
    ∃ i, ⟪v i, x⟫ = scoreMax v x := by
  obtain ⟨i, _, hi⟩ := Finset.exists_mem_eq_sup' Finset.univ_nonempty (fun i => ⟪v i, x⟫)
  exact ⟨i, hi.symm⟩

theorem continuous_scoreMax (v : Fin k → Space d) : Continuous (scoreMax v) := by
  exact Continuous.finset_sup'_apply Finset.univ_nonempty (fun _ _ => by fun_prop)

theorem norm_scoreMax_le (v : Tuple d k) (x : Space d) :
    ‖scoreMax v.ofLp x‖ ≤ ‖v‖ * ‖x‖ := by
  obtain ⟨i, hi⟩ := exists_scoreMax v.ofLp x
  rw [← hi]
  exact (norm_inner_le_norm _ _).trans
    (mul_le_mul_of_nonneg_right (PiLp.norm_apply_le v i) (norm_nonneg x))

theorem integrable_scoreMax (v : Tuple d k) :
    Integrable (scoreMax v.ofLp) (gaussian d) := by
  apply ((integrable_id_gaussian d).norm.const_mul ‖v‖).mono'
    (continuous_scoreMax v.ofLp).aestronglyMeasurable
  exact Filter.Eventually.of_forall (norm_scoreMax_le v)

theorem scoreMax_sub_le (v w : Tuple d k) (x : Space d) :
    scoreMax v.ofLp x - scoreMax w.ofLp x ≤ ‖v - w‖ * ‖x‖ := by
  rw [sub_le_iff_le_add]
  apply (scoreMax_le_iff _ _ _).mpr
  intro i
  have hinner := real_inner_le_norm (v.ofLp i - w.ofLp i) x
  have hcoord : ‖v.ofLp i - w.ofLp i‖ ≤ ‖v - w‖ := PiLp.norm_apply_le (v - w) i
  have hmul := mul_le_mul_of_nonneg_right hcoord (norm_nonneg x)
  rw [inner_sub_left] at hinner
  linarith [le_scoreMax w.ofLp i x]

theorem norm_scoreMax_sub_le (v w : Tuple d k) (x : Space d) :
    ‖scoreMax v.ofLp x - scoreMax w.ofLp x‖ ≤ ‖v - w‖ * ‖x‖ := by
  rw [Real.norm_eq_abs, abs_le]
  have h := scoreMax_sub_le w v x
  rw [norm_sub_rev] at h
  exact ⟨by linarith, scoreMax_sub_le v w x⟩

theorem width_lipschitz_bound (v w : Tuple d k) :
    ‖width v - width w‖ ≤ (∫ x : Space d, ‖x‖ ∂gaussian d) * ‖v - w‖ := by
  rw [width, width, ← integral_sub (integrable_scoreMax v) (integrable_scoreMax w)]
  calc
    ‖∫ x, scoreMax v.ofLp x - scoreMax w.ofLp x ∂gaussian d‖ ≤
        ∫ x : Space d, ‖v - w‖ * ‖x‖ ∂gaussian d :=
      norm_integral_le_of_norm_le ((integrable_id_gaussian d).norm.const_mul _)
        (Filter.Eventually.of_forall (norm_scoreMax_sub_le v w))
    _ = (∫ x : Space d, ‖x‖ ∂gaussian d) * ‖v - w‖ := by
      rw [integral_const_mul, mul_comm]

theorem continuous_width : Continuous (width : Tuple d k → ℝ) := by
  let K : NNReal := ⟨∫ x : Space d, ‖x‖ ∂gaussian d,
    integral_nonneg (fun x => norm_nonneg x)⟩
  apply (LipschitzWith.of_dist_le_mul (K := K) ?_).continuous
  intro v w
  change ‖width v - width w‖ ≤ (∫ x : Space d, ‖x‖ ∂gaussian d) * ‖v - w‖
  exact width_lipschitz_bound v w

def scoreCell (v : Fin k → Space d) (i : Fin k) : Set (Space d) :=
  {x | (∀ j, ⟪v j, x⟫ ≤ ⟪v i, x⟫) ∧ (∀ j, j < i → ⟪v j, x⟫ < ⟪v i, x⟫)}

omit [NeZero k] in
theorem measurable_scoreCell (v : Fin k → Space d) (i : Fin k) :
    MeasurableSet (scoreCell v i) := by
  change MeasurableSet ({x | ∀ j, ⟪v j, x⟫ ≤ ⟪v i, x⟫} ∩
    {x | ∀ j, j < i → ⟪v j, x⟫ < ⟪v i, x⟫})
  apply MeasurableSet.inter
  · simp only [Set.ofPred_forall]
    exact MeasurableSet.iInter fun j => measurableSet_le (by fun_prop) (by fun_prop)
  · simp only [Set.ofPred_forall]
    apply MeasurableSet.iInter
    intro j
    by_cases h : j < i
    · simpa [h] using
        (measurableSet_lt (show Measurable (fun x : Space d => ⟪v j, x⟫) by fun_prop)
          (show Measurable (fun x : Space d => ⟪v i, x⟫) by fun_prop))
    · simp [h]

theorem exists_unique_scoreCell (v : Fin k → Space d) (x : Space d) :
    ∃! i, x ∈ scoreCell v i := by
  classical
  let s := Finset.univ.filter (fun i => ⟪v i, x⟫ = scoreMax v x)
  have hs : s.Nonempty := by
    obtain ⟨i, hi⟩ := exists_scoreMax v x
    exact ⟨i, Finset.mem_filter.mpr ⟨Finset.mem_univ i, hi⟩⟩
  let i := s.min' hs
  have hmax : ⟪v i, x⟫ = scoreMax v x := (Finset.mem_filter.mp (s.min'_mem hs)).2
  have hi : x ∈ scoreCell v i := by
    constructor
    · intro j
      rw [hmax]
      exact le_scoreMax v j x
    · intro j hji
      have hle : ⟪v j, x⟫ ≤ ⟪v i, x⟫ := hmax ▸ le_scoreMax v j x
      apply lt_of_le_of_ne hle
      intro heq
      have hmem : j ∈ s := Finset.mem_filter.mpr ⟨Finset.mem_univ j, heq.trans hmax⟩
      exact (not_lt_of_ge (s.min'_le j hmem)) hji
  refine ⟨i, hi, ?_⟩
  intro j hj
  apply le_antisymm
  · by_contra h
    have hlt : i < j := lt_of_not_ge h
    exact (not_lt_of_ge (hi.1 j)) (hj.2 i hlt)
  · by_contra h
    have hlt : j < i := lt_of_not_ge h
    exact (not_lt_of_ge (hj.1 i)) (hi.2 j hlt)

theorem scoreCell_partition (v : Fin k → Space d) : IsPartition (scoreCell v) :=
  ⟨measurable_scoreCell v, Filter.Eventually.of_forall (exists_unique_scoreCell v)⟩

theorem scoreCell_score (v : Fin k → Space d) {i : Fin k} {x : Space d}
    (hx : x ∈ scoreCell v i) : ⟪v i, x⟫ = scoreMax v x := by
  exact le_antisymm (le_scoreMax v i x) ((scoreMax_le_iff _ _ _).mpr hx.1)

noncomputable def moments (A : Fin k → Set (Space d)) : Tuple d k :=
  WithLp.toLp 2 (fun i => centroid (A i))

omit [NeZero k] in
theorem norm_moments_sq (A : Fin k → Set (Space d)) : ‖moments A‖ ^ 2 = value A :=
  PiLp.norm_sq_eq_of_L2 _ _

omit [NeZero k] in
theorem pairing_integral {A : Fin k → Set (Space d)} (hA : IsPartition A)
    (v : Tuple d k) :
    ⟪v, moments A⟫ = ∫ x, ∑ i, (A i).indicator (fun x => ⟪v.ofLp i, x⟫) x
      ∂gaussian d := by
  rw [PiLp.inner_apply, integral_finsetSum]
  · apply Finset.sum_congr rfl
    intro i _
    rw [integral_indicator (hA.1 i), integral_inner (integrable_id_restrict d (A i))]
    rfl
  · intro i _
    exact ((integrable_id_gaussian d).const_inner (v.ofLp i)).indicator (hA.1 i)

theorem pairing_le_width {A : Fin k → Set (Space d)} (hA : IsPartition A)
    (v : Tuple d k) : ⟪v, moments A⟫ ≤ width v := by
  classical
  rw [pairing_integral hA]
  have hi : Integrable (fun x => ∑ i, (A i).indicator (fun x => ⟪v.ofLp i, x⟫) x)
      (gaussian d) := integrable_finsetSum _ (fun i _ =>
        ((integrable_id_gaussian d).const_inner (v.ofLp i)).indicator (hA.1 i))
  apply integral_mono_ae hi (integrable_scoreMax v)
  filter_upwards [hA.2] with x hx
  obtain ⟨i, hi, huniq⟩ := hx
  rw [Finset.sum_eq_single i]
  · simpa only [Set.indicator_of_mem hi] using le_scoreMax v.ofLp i x
  · intro j _ hji
    exact Set.indicator_of_notMem (fun hj => hji (huniq j hj)) _
  · simp

theorem pairing_scoreCell (v : Tuple d k) :
    ⟪v, moments (scoreCell v.ofLp)⟫ = width v := by
  classical
  rw [pairing_integral (scoreCell_partition v.ofLp)]
  apply integral_congr_ae
  filter_upwards [] with x
  obtain ⟨i, hi, huniq⟩ := exists_unique_scoreCell v.ofLp x
  rw [Finset.sum_eq_single i]
  · simpa only [Set.indicator_of_mem hi] using scoreCell_score v.ofLp hi
  · intro j _ hji
    exact Set.indicator_of_notMem (fun hj => hji (huniq j hj)) _
  · simp

theorem width_nonneg (v : Tuple d k) : 0 ≤ width v := by
  let i : Fin k := ⟨0, NeZero.pos k⟩
  have h := integral_mono_ae ((integrable_id_gaussian d).const_inner (v.ofLp i))
    (integrable_scoreMax v) (Filter.Eventually.of_forall (le_scoreMax v.ofLp i))
  have hzero : (∫ x : Space d, x ∂gaussian d) = 0 := integral_id_stdGaussian
  rw [integral_inner (integrable_id_gaussian d), hzero, inner_zero_right] at h
  exact h

theorem exists_max_width [NeZero d] :
    ∃ v : Tuple d k, ‖v‖ = 1 ∧ ∀ w : Tuple d k, ‖w‖ = 1 → width w ≤ width v := by
  obtain ⟨v, hv, hmax⟩ := (isCompact_sphere (0 : Tuple d k) 1).exists_isMaxOn
    (NormedSpace.sphere_nonempty.mpr (by norm_num : (0 : ℝ) ≤ 1))
    continuous_width.continuousOn
  refine ⟨v, ?_, ?_⟩
  · simpa only [Metric.mem_sphere, dist_zero_right] using hv
  · intro w hw
    apply hmax
    simpa only [Metric.mem_sphere, dist_zero_right] using hw

theorem norm_moments_le {v : Tuple d k}
    (hmax : ∀ w : Tuple d k, ‖w‖ = 1 → width w ≤ width v)
    {A : Fin k → Set (Space d)} (hA : IsPartition A) : ‖moments A‖ ≤ width v := by
  by_cases hz : moments A = 0
  · simpa only [hz, norm_zero] using width_nonneg v
  have hn : ‖moments A‖ ≠ 0 := norm_ne_zero_iff.mpr hz
  let w : Tuple d k := ‖moments A‖⁻¹ • moments A
  have hw : ‖w‖ = 1 := by
    rw [norm_smul_of_nonneg (inv_nonneg.mpr (norm_nonneg _)), inv_mul_cancel₀ hn]
  have h := (pairing_le_width hA w).trans (hmax w hw)
  have heq : ⟪w, moments A⟫ = ‖moments A‖ := by
    dsimp [w]
    rw [inner_smul_left, real_inner_self_eq_norm_sq]
    simp only [RCLike.conj_to_real]
    field_simp
  rwa [heq] at h

theorem exists_optimal_partition [NeZero d] :
    ∃ A : Fin k → Set (Space d), IsPartition A ∧
      ∀ B : Fin k → Set (Space d), IsPartition B → value B ≤ value A := by
  obtain ⟨v, hv, hmax⟩ := exists_max_width (d := d) (k := k)
  let A := scoreCell v.ofLp
  have hA := scoreCell_partition v.ofLp
  have hnorm : ‖moments A‖ = width v := by
    apply le_antisymm (norm_moments_le hmax hA)
    rw [← pairing_scoreCell]
    simpa only [hv, one_mul] using real_inner_le_norm v (moments A)
  refine ⟨A, hA, ?_⟩
  intro B hB
  have hnormB := norm_moments_le hmax hB
  rw [← hnorm] at hnormB
  rw [← norm_moments_sq, ← norm_moments_sq]
  exact sq_le_sq₀ (norm_nonneg _) (norm_nonneg _) |>.mpr hnormB

def Optimal (A : Fin k → Set (Space d)) : Prop :=
  IsPartition A ∧ ∀ B : Fin k → Set (Space d), IsPartition B → value B ≤ value A

noncomputable def activeLabels (A : Fin k → Set (Space d)) : Finset (Fin k) :=
  Finset.univ.filter (fun i => gaussian d (A i) ≠ 0)

noncomputable def activeCount (A : Fin k → Set (Space d)) : ℕ := (activeLabels A).card

def MinimalOptimal (A : Fin k → Set (Space d)) : Prop :=
  Optimal A ∧ ∀ B : Fin k → Set (Space d), Optimal B → activeCount A ≤ activeCount B

theorem exists_minimal_optimal [NeZero d] :
    ∃ A : Fin k → Set (Space d), MinimalOptimal A := by
  classical
  have hex : ∃ n, ∃ A : Fin k → Set (Space d), Optimal A ∧ activeCount A = n := by
    obtain ⟨A, hA⟩ := exists_optimal_partition (d := d) (k := k)
    exact ⟨activeCount A, A, hA, rfl⟩
  obtain ⟨A, hA, hn⟩ := Nat.find_spec hex
  refine ⟨A, hA, ?_⟩
  intro B hB
  rw [hn]
  exact Nat.find_min' hex ⟨B, hB, rfl⟩

def merge (A : Fin k → Set (Space d)) (i j : Fin k) (l : Fin k) : Set (Space d) :=
  if l = i then A i ∪ A j else if l = j then ∅ else A l

omit [NeZero k] in
theorem merge_partition {A : Fin k → Set (Space d)} (hA : IsPartition A)
    {i j : Fin k} (hij : i ≠ j) : IsPartition (merge A i j) := by
  classical
  constructor
  · intro l
    by_cases hli : l = i
    · simpa [merge, hli] using (hA.1 i).union (hA.1 j)
    · by_cases hlj : l = j
      · simp [merge, hlj, hij.symm]
      · simpa [merge, hli, hlj] using hA.1 l
  · filter_upwards [hA.2] with x hx
    obtain ⟨l, hl, huniq⟩ := hx
    by_cases hlj : l = j
    · subst l
      refine ⟨i, ?_, ?_⟩
      · simp [merge, hl]
      · intro q hq
        by_cases hqi : q = i
        · exact hqi
        · by_cases hqj : q = j
          · simp [merge, hqj, hij.symm] at hq
          · have hqA : x ∈ A q := by simpa [merge, hqi, hqj] using hq
            exact False.elim (hqj (huniq q hqA))
    · refine ⟨l, ?_, ?_⟩
      · by_cases hli : l = i
        · subst l
          simp [merge, hl]
        · simp [merge, hli, hlj, hl]
      · intro q hq
        by_cases hqi : q = i
        · subst q
          have h : x ∈ A i ∨ x ∈ A j := by simpa [merge] using hq
          rcases h with hi | hj
          · exact huniq i hi
          · exact False.elim (hlj (huniq j hj).symm)
        · by_cases hqj : q = j
          · simp [merge, hqj, hij.symm] at hq
          · apply huniq q
            simpa [merge, hqi, hqj] using hq

omit [NeZero k] in
theorem centroid_union {A : Fin k → Set (Space d)} (hA : IsPartition A)
    {i j : Fin k} (hij : i ≠ j) : centroid (A i ∪ A j) = centroid (A i) + centroid (A j) := by
  have hind : (A i ∪ A j).indicator (fun x => x) =ᵐ[gaussian d]
      (fun x => (A i).indicator (fun x => x) x + (A j).indicator (fun x => x) x) := by
    filter_upwards [hA.2] with x hx
    obtain ⟨l, _, huniq⟩ := hx
    by_cases hi : x ∈ A i <;> by_cases hj : x ∈ A j
    · exact False.elim (hij ((huniq i hi).trans (huniq j hj).symm))
    all_goals simp [Set.indicator, hi, hj]
  unfold centroid
  rw [← integral_indicator ((hA.1 i).union (hA.1 j)), integral_congr_ae hind,
    integral_add ((integrable_id_gaussian d).indicator (hA.1 i))
      ((integrable_id_gaussian d).indicator (hA.1 j)),
    integral_indicator (hA.1 i), integral_indicator (hA.1 j)]

omit [NeZero k] in
theorem value_merge {A : Fin k → Set (Space d)} (hA : IsPartition A)
    {i j : Fin k} (hij : i ≠ j) :
    value (merge A i j) = value A + 2 * ⟪centroid (A i), centroid (A j)⟫ := by
  classical
  have hcent : centroid (A i ∪ A j) = centroid (A i) + centroid (A j) := centroid_union hA hij
  have hfun (l : Fin k) : ‖centroid (merge A i j l)‖ ^ 2 =
      ‖centroid (A l)‖ ^ 2 +
      (if l = i then ‖centroid (A i) + centroid (A j)‖ ^ 2 - ‖centroid (A i)‖ ^ 2 else 0) +
      (if l = j then -‖centroid (A j)‖ ^ 2 else 0) := by
    by_cases hli : l = i
    · subst l
      simp [merge, hij, hcent]
    · by_cases hlj : l = j
      · subst l
        simp [merge, hij.symm]
      · simp [merge, hli, hlj]
  unfold value
  simp_rw [hfun, Finset.sum_add_distrib]
  simp only [Finset.sum_ite_eq', Finset.mem_univ, ite_true]
  rw [norm_add_sq_real]
  ring

omit [NeZero k] in
theorem activeCount_merge_lt {A : Fin k → Set (Space d)} {i j : Fin k}
    (hij : i ≠ j) (hi : gaussian d (A i) ≠ 0) (hj : gaussian d (A j) ≠ 0) :
    activeCount (merge A i j) < activeCount A := by
  classical
  apply Finset.card_lt_card
  apply Finset.ssubset_iff_subset_ne.mpr
  constructor
  · intro l hl
    simp only [activeLabels, Finset.mem_filter, Finset.mem_univ, true_and] at hl ⊢
    by_cases hli : l = i
    · simpa only [hli] using hi
    · by_cases hlj : l = j
      · simp [merge, hlj, hij.symm] at hl
      · simpa only [merge, ite_eq_right hli, ite_eq_right hlj] using hl
  · intro heq
    have hs : j ∈ activeLabels (merge A i j) := by
      rw [heq]
      simpa only [activeLabels, Finset.mem_filter, Finset.mem_univ, true_and] using hj
    have hnon : gaussian d (merge A i j j) ≠ 0 := (Finset.mem_filter.mp hs).2
    exact hnon (by simp [merge, hij.symm])

omit [NeZero k] in
theorem negative_inner_of_minimal {A : Fin k → Set (Space d)} (hA : MinimalOptimal A)
    {i j : Fin k} (hij : i ≠ j) (hi : gaussian d (A i) ≠ 0) (hj : gaussian d (A j) ≠ 0) :
    ⟪centroid (A i), centroid (A j)⟫ < 0 := by
  have hpart := merge_partition hA.1.1 hij
  have hvalue := value_merge hA.1.1 hij
  have hbound := hA.1.2 _ hpart
  have hle : ⟪centroid (A i), centroid (A j)⟫ ≤ 0 := by linarith
  apply lt_of_le_of_ne hle
  intro heq
  have heqval : value (merge A i j) = value A := by rw [heq, mul_zero, add_zero] at hvalue; exact hvalue
  have hopt : Optimal (merge A i j) := ⟨hpart, fun B hB => by rw [heqval]; exact hA.1.2 B hB⟩
  exact (not_lt_of_ge (hA.2 _ hopt)) (activeCount_merge_lt hij hi hj)

theorem width_moments_of_optimal {A : Fin k → Set (Space d)} (hA : Optimal A) :
    width (moments A) = value A := by
  have hnorm : ‖moments (scoreCell (moments A).ofLp)‖ ≤ ‖moments A‖ := by
    apply (sq_le_sq₀ (norm_nonneg _) (norm_nonneg _)).mp
    rw [norm_moments_sq, norm_moments_sq]
    exact hA.2 _ (scoreCell_partition _)
  apply le_antisymm
  · rw [← pairing_scoreCell, ← norm_moments_sq]
    calc
      ⟪moments A, moments (scoreCell (moments A).ofLp)⟫ ≤
          ‖moments A‖ * ‖moments (scoreCell (moments A).ofLp)‖ := real_inner_le_norm _ _
      _ ≤ ‖moments A‖ * ‖moments A‖ := mul_le_mul_of_nonneg_left hnorm (norm_nonneg _)
      _ = ‖moments A‖ ^ 2 := (sq _).symm
  · simpa only [real_inner_self_eq_norm_sq, norm_moments_sq] using pairing_le_width hA.1 (moments A)

omit [NeZero k] in
theorem centroid_eq_zero_of_null {A : Set (Space d)} (hA : gaussian d A = 0) : centroid A = 0 := by
  unfold centroid
  rw [Measure.restrict_eq_zero.mpr hA, integral_zero_measure]

theorem assigned_le_scoreMax {A : Fin k → Set (Space d)} (hA : IsPartition A) (v : Tuple d k) :
    (fun x => ∑ i, (A i).indicator (fun x => ⟪v.ofLp i, x⟫) x) ≤ᵐ[gaussian d]
      scoreMax v.ofLp := by
  classical
  filter_upwards [hA.2] with x hx
  obtain ⟨i, hi, huniq⟩ := hx
  rw [Finset.sum_eq_single i]
  · simpa only [Set.indicator_of_mem hi] using le_scoreMax v.ofLp i x
  · intro j _ hji
    exact Set.indicator_of_notMem (fun hj => hji (huniq j hj)) _
  · simp

theorem optimal_winning_ae {A : Fin k → Set (Space d)} (hA : Optimal A) :
    ∀ᵐ x ∂gaussian d, ∀ i, x ∈ A i → ⟪centroid (A i), x⟫ =
      scoreMax (fun j => centroid (A j)) x := by
  classical
  let v := moments A
  let f (x : Space d) := ∑ i, (A i).indicator (fun x => ⟪v.ofLp i, x⟫) x
  have hf : Integrable f (gaussian d) :=
    integrable_finsetSum _ (fun i _ =>
      ((integrable_id_gaussian d).const_inner (v.ofLp i)).indicator (hA.1.1 i))
  have hgap : (fun x => scoreMax v.ofLp x - f x) =ᵐ[gaussian d] 0 := by
    apply (integral_eq_zero_iff_of_nonneg_ae
      (show 0 ≤ᵐ[gaussian d] (fun x => scoreMax v.ofLp x - f x) from
        (assigned_le_scoreMax hA.1 v).mono (fun x hx => sub_nonneg.mpr hx))
      ((integrable_scoreMax v).sub hf)).mp
    rw [integral_sub (integrable_scoreMax v) hf]
    have hi : (∫ x, f x ∂gaussian d) = value A := by
      rw [← pairing_integral hA.1, real_inner_self_eq_norm_sq, norm_moments_sq]
    rw [hi]
    exact sub_eq_zero.mpr (width_moments_of_optimal hA)
  filter_upwards [hgap, hA.1.2] with x hx hxA
  intro i hi
  obtain ⟨j, _, huniq⟩ := hxA
  have hiuniq : ∀ l, x ∈ A l → l = i := fun l hl => (huniq l hl).trans (huniq i hi).symm
  have hfx : f x = ⟪v.ofLp i, x⟫ := by
    dsimp only [f]
    rw [Finset.sum_eq_single i]
    · exact Set.indicator_of_mem hi _
    · intro l _ hli
      exact Set.indicator_of_notMem (fun hl => hli (hiuniq l hl)) _
    · simp
  change scoreMax v.ofLp x - f x = 0 at hx
  rw [hfx] at hx
  exact (sub_eq_zero.mp hx).symm

omit [NeZero k] in

theorem two_nonzero_centroids {A : Fin k → Set (Space d)} (hA : IsPartition A)
    (hpos : 0 < value A) : ∃ i j, i ≠ j ∧ centroid (A i) ≠ 0 ∧ centroid (A j) ≠ 0 := by
  classical
  have hi : ∃ i, centroid (A i) ≠ 0 := by
    by_contra! h
    have hz : value A = 0 := by simp [value, h]
    linarith
  obtain ⟨i, hi⟩ := hi
  have hj : ∃ j, j ≠ i ∧ centroid (A j) ≠ 0 := by
    by_contra! h
    have hz : ∑ j, centroid (A j) = centroid (A i) := by
      apply Finset.sum_eq_single i
      · intro j _ hji
        exact h j hji
      · simp
    exact hi (hz.symm.trans (sum_centroid_eq_zero hA))
  obtain ⟨j, hji, hj⟩ := hj
  exact ⟨i, j, hji.symm, hi, hj⟩

omit [NeZero k] in
theorem active_centroid_ne_zero {A : Fin k → Set (Space d)} (hA : MinimalOptimal A)
    (hpos : 0 < value A) {i : Fin k} (hi : gaussian d (A i) ≠ 0) : centroid (A i) ≠ 0 := by
  obtain ⟨j, l, hjl, hj, hl⟩ := two_nonzero_centroids hA.1.1 hpos
  have hjm : gaussian d (A j) ≠ 0 := fun hz => hj (centroid_eq_zero_of_null hz)
  have hlm : gaussian d (A l) ≠ 0 := fun hz => hl (centroid_eq_zero_of_null hz)
  by_cases hij : i = j
  · simpa only [hij] using hj
  · have hneg := negative_inner_of_minimal hA hij hi hjm
    intro hz
    simp only [hz, inner_zero_left] at hneg
    exact (lt_irrefl 0) hneg

omit [NeZero k] in
theorem active_centroid_ne_other {A : Fin k → Set (Space d)} (hA : MinimalOptimal A)
    (hpos : 0 < value A) {i j : Fin k} (hi : gaussian d (A i) ≠ 0) (hij : i ≠ j) :
    centroid (A i) ≠ centroid (A j) := by
  by_cases hj : gaussian d (A j) = 0
  · rw [centroid_eq_zero_of_null hj]
    exact active_centroid_ne_zero hA hpos hi
  · intro heq
    have hneg := negative_inner_of_minimal hA hij hi hj
    rw [heq, real_inner_self_eq_norm_sq] at hneg
    exact (not_lt_of_ge (sq_nonneg _)) hneg

omit [NeZero k] in

theorem gaussian_hyperplane_null (z : Space d) (hz : z ≠ 0) (c : ℝ) :
    gaussian d {x | ⟪z, x⟫ = c} = 0 := by
  let L : StrongDual ℝ (Space d) := innerSL ℝ z
  have hL : L ≠ 0 := by
    intro heq
    have hx : ⟪z, z⟫ = 0 := by
      have h := DFunLike.congr_fun heq z
      simpa [L] using h
    exact hz (inner_self_eq_zero.mp hx)
  have hv : (variance L (stdGaussian (Space d))).toNNReal ≠ 0 := by
    rw [variance_dual_stdGaussian]
    exact ne_of_gt (Real.toNNReal_pos.mpr (sq_pos_of_pos (norm_pos_iff.mpr hL)))
  have instN : NullSingletonClass
      (gaussianReal (∫ x, L x ∂stdGaussian (Space d))
        (variance L (stdGaussian (Space d))).toNNReal) := nullSingletonClass_gaussianReal hv
  have h := congrArg (fun μ : Measure ℝ => μ {c}) (IsGaussian.map_eq_gaussianReal
    (μ := stdGaussian (Space d)) L)
  rw [Measure.map_apply L.continuous.measurable (measurableSet_singleton c),
    measure_singleton] at h
  exact h

def closedCell (z : Fin k → Space d) (i : Fin k) : Set (Space d) :=
  {x | ∀ j, ⟪z j, x⟫ ≤ ⟪z i, x⟫}

omit [NeZero k] in
theorem measurableSet_closedCell (z : Fin k → Space d) (i : Fin k) :
    MeasurableSet (closedCell z i) := by
  unfold closedCell
  simp only [Set.ofPred_forall]
  exact MeasurableSet.iInter (fun j => measurableSet_le
    (by fun_prop) (by fun_prop))

theorem active_eq_closedCell_ae {A : Fin k → Set (Space d)}
    (hA : MinimalOptimal A) (hpos : 0 < value A) {i : Fin k}
    (hi : gaussian d (A i) ≠ 0) :
    A i =ᵐ[gaussian d] closedCell (fun j => centroid (A j)) i := by
  classical
  have hnotie : ∀ j, i ≠ j → ∀ᵐ x ∂gaussian d,
      ⟪centroid (A i), x⟫ ≠ ⟪centroid (A j), x⟫ := by
    intro j hij
    rw [ae_iff]
    change gaussian d {x | ¬⟪centroid (A i), x⟫ ≠ ⟪centroid (A j), x⟫} = 0
    simpa only [not_not, inner_sub_left, sub_eq_zero] using
      gaussian_hyperplane_null (centroid (A i) - centroid (A j))
        (sub_ne_zero.mpr (active_centroid_ne_other hA hpos hi hij)) 0
  have hnt : ∀ᵐ x ∂gaussian d, ∀ j, i ≠ j →
      ⟪centroid (A i), x⟫ ≠ ⟪centroid (A j), x⟫ := by
    exact ae_all_iff.mpr (fun j => ae_all_iff.mpr (fun hij => hnotie j hij))
  filter_upwards [hA.1.1.2, optimal_winning_ae hA.1, hnt] with x hx hwin hnt
  apply propext
  constructor
  · intro hix j
    rw [hwin i hix]
    exact le_scoreMax (fun j => centroid (A j)) j x
  · intro hclosed
    obtain ⟨j, hj, _⟩ := hx
    by_cases hji : j = i
    · subst j
      exact hj
    · have hle := hclosed j
      rw [hwin j hj] at hle
      have heq := le_antisymm (le_scoreMax (fun l => centroid (A l)) i x) hle
      exact False.elim (hnt j (Ne.symm hji) (heq.trans (hwin j hj).symm))

end Reduction

end GaussianPropeller

end OAI