import Mathlib

namespace OAI

/-! Integrable Pdf Mul. -/

noncomputable section

open scoped BigOperators Matrix Topology
open MeasureTheory ProbabilityTheory Filter
namespace SKGaussian

 

theorem integrable_pdf_mul {f : ℝ → ℝ} (hf : Integrable f (gaussianReal 0 1)) :
    Integrable (fun x => gaussianPDFReal 0 1 x * f x) := by
  rw [gaussianReal_of_var_ne_zero _ one_ne_zero] at hf
  have h := (integrable_withDensity_iff_integrable_smul'
    (measurable_gaussianPDF 0 1) (ae_of_all _ fun x => (gaussianPDF_lt_top (x := x)))).1 hf
  simpa only [toReal_gaussianPDF, smul_eq_mul] using h

 
theorem hasDerivAt_standardDensity (x : ℝ) :
    HasDerivAt (gaussianPDFReal 0 1) (-x * gaussianPDFReal 0 1 x) x := by
  have hp : HasDerivAt (fun y : ℝ => -(y ^ 2) / 2) (-x) x := by
    convert (((hasDerivAt_id x).fun_pow 2).fun_neg.div_const 2) using 1 <;> try rfl
    norm_num
    ring
  simp only [gaussianPDFReal_def, NNReal.coe_one, sub_zero, mul_one]
  convert hp.exp.const_mul (Real.sqrt (2 * Real.pi))⁻¹ using 1
  ring

 

theorem integral_mul_eq_integral_deriv {f f' : ℝ → ℝ}
    (hd : ∀ x, HasDerivAt f (f' x) x)
    (hf : Integrable f (gaussianReal 0 1))
    (hf' : Integrable f' (gaussianReal 0 1))
    (hxf : Integrable (fun x => x * f x) (gaussianReal 0 1)) :
    (∫ x, x * f x ∂gaussianReal 0 1) = ∫ x, f' x ∂gaussianReal 0 1 := by
  have h := integral_mul_deriv_eq_deriv_mul_of_integrable
    (u := f) (u' := f') (v := gaussianPDFReal 0 1)
    (v' := fun x => -x * gaussianPDFReal 0 1 x)
    (fun x _ => hd x) (fun x _ => hasDerivAt_standardDensity x)
    (by convert (integrable_pdf_mul hxf).neg using 1; funext x; simp only [Pi.mul_apply, Pi.neg_apply]; ring)
    (by convert integrable_pdf_mul hf' using 1; funext x; simp only [Pi.mul_apply]; ring)
    (by convert integrable_pdf_mul hf using 1; funext x; simp only [Pi.mul_apply]; ring)
  simp only [neg_mul, mul_neg, integral_neg] at h
  rw [integral_gaussianReal_eq_integral_smul one_ne_zero,
    integral_gaussianReal_eq_integral_smul one_ne_zero]
  simp only [smul_eq_mul]
  have heq := neg_injective h
  convert heq using 1 <;> congr 1 <;> funext x <;> ring

 
def standardLaw (n : ℕ) : Measure (Fin n → ℝ) :=
  Measure.pi fun _ => gaussianReal 0 1

instance (n : ℕ) : IsProbabilityMeasure (standardLaw n) := by
  unfold standardLaw
  infer_instance

 

theorem integral_coord_mul_eq {n : ℕ} (k : Fin (n + 1))
    {f g : (Fin (n + 1) → ℝ) → ℝ}
    (hd : ∀ (y : Fin n → ℝ) z,
      HasDerivAt (fun s => f (k.insertNth s y)) (g (k.insertNth z y)) z)
    (hf : Integrable f (standardLaw (n + 1)))
    (hg : Integrable g (standardLaw (n + 1)))
    (hxf : Integrable (fun x => x k * f x) (standardLaw (n + 1))) :
    (∫ x, x k * f x ∂standardLaw (n + 1)) = ∫ x, g x ∂standardLaw (n + 1) := by
  let e : (ℝ × (Fin n → ℝ)) ≃ᵐ (Fin (n + 1) → ℝ) :=
    (MeasurableEquiv.piFinSuccAbove (fun _ => ℝ) k).symm
  have hm : MeasurePreserving e ((gaussianReal 0 1).prod (standardLaw n))
      (standardLaw (n + 1)) :=
    (measurePreserving_piFinSuccAbove (fun _ => gaussianReal 0 1) k).symm
  have hfp := (hm.integrable_comp hf.aestronglyMeasurable).mpr hf
  have hgp := (hm.integrable_comp hg.aestronglyMeasurable).mpr hg
  have hx := (hm.integrable_comp hxf.aestronglyMeasurable).mpr hxf
  rw [← hm.integral_comp' (fun x => x k * f x), ← hm.integral_comp' g]
  change (∫ x, ((fun x => x k * f x) ∘ e) x ∂(gaussianReal 0 1).prod (standardLaw n)) =
    ∫ x, (g ∘ e) x ∂(gaussianReal 0 1).prod (standardLaw n)
  rw [integral_prod_symm _ hx, integral_prod_symm _ hgp]
  apply integral_congr_ae
  filter_upwards [hfp.prod_left_ae, hgp.prod_left_ae, hx.prod_left_ae] with y hfy hgy hxy
  have he (z : ℝ) : e (z, y) = k.insertNth z y := rfl
  simp only [Function.comp_apply, he, Fin.insertNth_apply_same] at hfy hgy hxy ⊢
  exact integral_mul_eq_integral_deriv (hd y) hfy hgy hxy

variable {ι : Type*} [Fintype ι] [Nonempty ι]

 
def partition (x : ι → ℝ) : ℝ := ∑ i, Real.exp (x i)

def weight (x : ι → ℝ) (i : ι) : ℝ := Real.exp (x i) / partition x

def logPartition (x : ι → ℝ) : ℝ := Real.log (partition x)

def finiteMax (x : ι → ℝ) : ℝ := Finset.univ.sup' Finset.univ_nonempty x

theorem partition_pos (x : ι → ℝ) : 0 < partition x :=
  Finset.sum_pos (fun _ _ => Real.exp_pos _) Finset.univ_nonempty

theorem weight_pos (x : ι → ℝ) (i : ι) : 0 < weight x i :=
  div_pos (Real.exp_pos _) (partition_pos x)

theorem sum_weight (x : ι → ℝ) : ∑ i, weight x i = 1 := by
  simpa only [weight, ← Finset.sum_div, partition] using div_self (partition_pos x).ne'

theorem weight_le_one (x : ι → ℝ) (i : ι) : weight x i ≤ 1 := by
  rw [weight, div_le_one (partition_pos x)]
  exact Finset.single_le_sum (fun j _ => (Real.exp_pos _).le) (Finset.mem_univ i)

omit [Nonempty ι] in
theorem continuous_partition : Continuous (@partition ι _) := by
  unfold partition
  fun_prop

theorem continuous_weight (i : ι) : Continuous (fun x : ι → ℝ => weight x i) := by
  unfold weight
  exact (Real.continuous_exp.comp (continuous_apply i)).div continuous_partition
    (fun x => (partition_pos x).ne')

theorem continuous_logPartition : Continuous (@logPartition ι _) :=
  continuous_partition.log (fun x => (partition_pos x).ne')

theorem le_finiteMax (x : ι → ℝ) (i : ι) : x i ≤ finiteMax x :=
  Finset.le_sup' x (Finset.mem_univ i)

theorem le_logPartition (x : ι → ℝ) (i : ι) : x i ≤ logPartition x := by
  rw [logPartition, Real.le_log_iff_exp_le (partition_pos x)]
  exact Finset.single_le_sum (fun j _ => (Real.exp_pos _).le) (Finset.mem_univ i)

theorem finiteMax_le_logPartition (x : ι → ℝ) : finiteMax x ≤ logPartition x := by
  exact Finset.sup'_le Finset.univ_nonempty _ (fun i _ => le_logPartition x i)

theorem logPartition_le (x : ι → ℝ) :
    logPartition x ≤ finiteMax x + Real.log (Fintype.card ι) := by
  have hc : 0 < (Fintype.card ι : ℝ) := Nat.cast_pos.mpr Fintype.card_pos
  calc
    logPartition x ≤ Real.log ((Fintype.card ι : ℝ) * Real.exp (finiteMax x)) := by
      apply Real.log_le_log (partition_pos x)
      calc
        partition x ≤ ∑ _ : ι, Real.exp (finiteMax x) :=
          Finset.sum_le_sum fun i _ => Real.exp_le_exp.mpr (le_finiteMax x i)
        _ = _ := by simp
    _ = _ := by rw [Real.log_mul hc.ne' (Real.exp_pos _).ne', Real.log_exp]; ring

theorem abs_weight_sum_le (x v : ι → ℝ) {M : ℝ} (hM : ∀ i, |v i| ≤ M) :
    |∑ i, weight x i * v i| ≤ M := by
  calc
    |∑ i, weight x i * v i| ≤ ∑ i, |weight x i * v i| := Finset.abs_sum_le_sum_abs _ _
    _ = ∑ i, weight x i * |v i| := by
      simp only [abs_mul, abs_of_pos (weight_pos _ _)]
    _ ≤ ∑ i, weight x i * M := Finset.sum_le_sum fun i _ =>
      mul_le_mul_of_nonneg_left (hM i) (weight_pos x i).le
    _ = M := by rw [← Finset.sum_mul, sum_weight, one_mul]

theorem hasDerivAt_logPartition {f : ℝ → ι → ℝ} {v : ι → ℝ} {t : ℝ}
    (hf : ∀ i, HasDerivAt (fun s => f s i) (v i) t) :
    HasDerivAt (fun s => logPartition (f s))
      (∑ i, weight (f t) i * v i) t := by
  have h := (HasDerivAt.fun_sum (fun i _ => (hf i).exp)).log (partition_pos (f t)).ne'
  convert h using 1 <;> try rfl
  simp only [weight, div_mul_eq_mul_div, ← Finset.sum_div, partition]

theorem hasDerivAt_weight {f : ℝ → ι → ℝ} {v : ι → ℝ} {t : ℝ}
    (hf : ∀ i, HasDerivAt (fun s => f s i) (v i) t) (i : ι) :
    HasDerivAt (fun s => weight (f s) i)
      (weight (f t) i * (v i - ∑ j, weight (f t) j * v j)) t := by
  have h := (hf i).exp.div (HasDerivAt.fun_sum (fun j _ => (hf j).exp))
    (partition_pos (f t)).ne'
  convert h using 1 <;> try rfl
  simp only [weight, div_mul_eq_mul_div, ← Finset.sum_div, partition]
  field_simp

theorem logPartition_abs_le (x : ι → ℝ) :
    |logPartition x| ≤ (∑ i, |x i|) + Real.log (Fintype.card ι) := by
  have hxi (i : ι) : |x i| ≤ ∑ j, |x j| :=
    Finset.single_le_sum (fun j _ => abs_nonneg (x j)) (Finset.mem_univ i)
  have hm : finiteMax x ≤ ∑ i, |x i| :=
    Finset.sup'_le Finset.univ_nonempty _ (fun i _ => (le_abs_self _).trans (hxi i))
  have hlog := Real.log_natCast_nonneg (Fintype.card ι)
  have hlo : -(∑ i, |x i|) ≤ logPartition x := by
    let i : ι := Classical.choice inferInstance
    exact (neg_le_of_abs_le (hxi i)).trans (le_logPartition x i)
  exact abs_le.mpr ⟨by linarith, (logPartition_le x).trans (add_le_add hm le_rfl)⟩

theorem integrable_logPartition {Ω : Type*} [MeasurableSpace Ω] {μ : Measure Ω}
    [IsFiniteMeasure μ] {f : Ω → ι → ℝ}
    (hf : ∀ i, Integrable (fun x => f x i) μ) :
    Integrable (fun x => logPartition (f x)) μ := by
  apply ((integrable_finsetSum _ fun i _ => (hf i).abs).add
    (integrable_const (Real.log (Fintype.card ι)))).mono'
  · exact continuous_logPartition.comp_aestronglyMeasurable
      (integrable_pi_iff.mpr hf).aestronglyMeasurable
  · exact ae_of_all _ fun x => by simpa only [Real.norm_eq_abs, Pi.add_apply] using logPartition_abs_le (f x)

 
def linearField {n : ℕ} (A : ι → Fin n → ℝ) (x : Fin n → ℝ) (i : ι) : ℝ :=
  ∑ k, A i k * x k

omit [Fintype ι] [Nonempty ι] in
theorem continuous_linearField {n : ℕ} (A : ι → Fin n → ℝ) :
    Continuous (linearField A) := by
  unfold linearField
  fun_prop

theorem integrable_coordinate {n : ℕ} (k : Fin n) :
    Integrable (fun x : Fin n → ℝ => x k) (standardLaw n) := by
  apply (measurePreserving_eval (fun _ : Fin n => gaussianReal 0 1) k).integrable_comp
    (measurable_id.aestronglyMeasurable) |>.mpr
  exact MemLp.integrable (by norm_num) (memLp_id_gaussianReal (μ := 0) (v := 1) 1)

omit [Fintype ι] [Nonempty ι] in
theorem integrable_linearField {n : ℕ} (A : ι → Fin n → ℝ) (i : ι) :
    Integrable (fun x => linearField A x i) (standardLaw n) :=
  integrable_finsetSum _ fun k _ => (integrable_coordinate k).const_mul (A i k)

theorem integrable_weight {n : ℕ} (A : ι → Fin n → ℝ) (i : ι) :
    Integrable (fun x => weight (linearField A x) i) (standardLaw n) := by
  apply (integrable_const (1 : ℝ)).mono'
    ((continuous_weight i).comp (continuous_linearField A)).aestronglyMeasurable
  exact ae_of_all _ fun x => by
    simpa only [Function.comp_apply, Real.norm_eq_abs, abs_of_pos (weight_pos _ _)] using
      weight_le_one (linearField A x) i

omit [Fintype ι] [Nonempty ι] in
theorem hasDerivAt_linearField_insert {n : ℕ} (A : ι → Fin (n + 1) → ℝ)
    (k : Fin (n + 1)) (y : Fin n → ℝ) (z : ℝ) (i : ι) :
    HasDerivAt (fun s => linearField A (k.insertNth s y) i) (A i k) z := by
  have he (s : ℝ) : linearField A (k.insertNth s y) i =
      A i k * s + ∑ j : Fin n, A i (k.succAbove j) * y j := by
    rw [linearField, Fin.sum_univ_succAbove _ k]
    simp
  simp_rw [he]
  simpa using ((hasDerivAt_id z).const_mul (A i k)).add_const
    (∑ j : Fin n, A i (k.succAbove j) * y j)

 
theorem integrable_weight_derivative {n : ℕ} (A : ι → Fin n → ℝ)
    (i : ι) (k : Fin n) :
    Integrable (fun x => weight (linearField A x) i *
      (A i k - ∑ j, weight (linearField A x) j * A j k)) (standardLaw n) := by
  apply ((integrable_const (A i k)).sub
    (integrable_finsetSum _ fun j _ => (integrable_weight A j).mul_const (A j k))).bdd_mul
    ((continuous_weight i).comp (continuous_linearField A)).aestronglyMeasurable
  exact ae_of_all _ fun x => by
    simpa only [Function.comp_apply, Real.norm_eq_abs, abs_of_pos (weight_pos _ _)] using
      weight_le_one (linearField A x) i

theorem integrable_coord_weight {n : ℕ} (A : ι → Fin n → ℝ)
    (i : ι) (k : Fin n) :
    Integrable (fun x => x k * weight (linearField A x) i) (standardLaw n) := by
  apply (integrable_coordinate k).mul_bdd
    ((continuous_weight i).comp (continuous_linearField A)).aestronglyMeasurable
  exact ae_of_all _ fun x => by
    simpa only [Function.comp_apply, Real.norm_eq_abs, abs_of_pos (weight_pos _ _)] using
      weight_le_one (linearField A x) i

 
theorem integral_coord_weight {n : ℕ} (A : ι → Fin n → ℝ) (i : ι) (k : Fin n) :
    (∫ x, x k * weight (linearField A x) i ∂standardLaw n) =
      ∫ x, weight (linearField A x) i *
        (A i k - ∑ j, weight (linearField A x) j * A j k) ∂standardLaw n := by
  cases n with
  | zero => exact Fin.elim0 k
  | succ n =>
    apply integral_coord_mul_eq k
      (fun y z => hasDerivAt_weight (fun j => hasDerivAt_linearField_insert A k y z j) i)
      (integrable_weight A i) (integrable_weight_derivative A i k)
      (integrable_coord_weight A i k)

omit [Nonempty ι] in
 
theorem weighted_covariance (w a b : ι → ℝ) (hw : ∑ i, w i = 1) :
    (∑ i, ∑ j, w i * w j * (a i - a j) * (b i - b j)) =
      2 * ((∑ i, w i * a i * b i) - (∑ i, w i * a i) * (∑ j, w j * b j)) := by
  have he (i j : ι) : w i * w j * (a i - a j) * (b i - b j) =
      (w i * a i * b i) * w j - (w i * a i) * (w j * b j) -
        (w i * b i) * (w j * a j) + w i * (w j * a j * b j) := by ring
  simp_rw [he, Finset.sum_add_distrib, Finset.sum_sub_distrib]
  simp only [← Finset.mul_sum, ← Finset.sum_mul, hw, one_mul, mul_one]
  ring

omit [Fintype ι] [Nonempty ι] in
theorem linearField_combo {n : ℕ} (A B : ι → Fin n → ℝ) (a b : ℝ)
    (x : Fin n → ℝ) (i : ι) :
    linearField (fun i k => a * A i k + b * B i k) x i =
      a * linearField A x i + b * linearField B x i := by
  simp only [linearField, add_mul, Finset.sum_add_distrib, ← mul_assoc, Finset.mul_sum]

def rotateCoeff {n : ℕ} (A B : ι → Fin n → ℝ) (t : ℝ) (i : ι) (k : Fin n) : ℝ :=
  Real.cos t * A i k + Real.sin t * B i k

def velocityCoeff {n : ℕ} (A B : ι → Fin n → ℝ) (t : ℝ) (i : ι) (k : Fin n) : ℝ :=
  -Real.sin t * A i k + Real.cos t * B i k

omit [Fintype ι] [Nonempty ι] in
theorem hasDerivAt_rotatedField {n : ℕ} (A B : ι → Fin n → ℝ)
    (x : Fin n → ℝ) (i : ι) (t : ℝ) :
    HasDerivAt (fun s => linearField (rotateCoeff A B s) x i)
      (linearField (velocityCoeff A B t) x i) t := by
  change HasDerivAt (fun s => linearField (fun i k => Real.cos s * A i k + Real.sin s * B i k) x i)
    (linearField (fun i k => -Real.sin t * A i k + Real.cos t * B i k) x i) t
  simp_rw [linearField_combo]
  exact ((Real.hasDerivAt_cos t).mul_const (linearField A x i)).add
    ((Real.hasDerivAt_sin t).mul_const (linearField B x i))

theorem continuous_weightedMean {n : ℕ} (A D : ι → Fin n → ℝ) :
    Continuous (fun x => ∑ i, weight (linearField A x) i * linearField D x i) := by
  apply continuous_finsetSum
  intro i _
  exact ((continuous_weight i).comp (continuous_linearField A)).mul
    ((continuous_apply i).comp (continuous_linearField D))

theorem integrable_weightedMean {n : ℕ} (A D : ι → Fin n → ℝ) :
    Integrable (fun x => ∑ i, weight (linearField A x) i * linearField D x i)
      (standardLaw n) := by
  apply integrable_finsetSum
  intro i _
  apply (integrable_linearField D i).bdd_mul
    ((continuous_weight i).comp (continuous_linearField A)).aestronglyMeasurable
  exact ae_of_all _ fun x => by
    simpa only [Function.comp_apply, Real.norm_eq_abs, abs_of_pos (weight_pos _ _)] using
      weight_le_one (linearField A x) i

theorem rotated_derivative_bound {n : ℕ} (A B : ι → Fin n → ℝ)
    (x : Fin n → ℝ) (t : ℝ) :
    |∑ i, weight (linearField (rotateCoeff A B t) x) i *
      linearField (velocityCoeff A B t) x i| ≤
        ∑ i, (|linearField A x i| + |linearField B x i|) := by
  apply abs_weight_sum_le
  intro i
  calc
    |linearField (velocityCoeff A B t) x i| =
      |-Real.sin t * linearField A x i + Real.cos t * linearField B x i| := by
        exact congrArg abs (linearField_combo A B (-Real.sin t) (Real.cos t) x i)
    _ ≤ |Real.sin t| * |linearField A x i| + |Real.cos t| * |linearField B x i| := by
      simpa only [abs_mul, abs_neg] using abs_add_le
        (-Real.sin t * linearField A x i) (Real.cos t * linearField B x i)
    _ ≤ |linearField A x i| + |linearField B x i| := by
      exact add_le_add (mul_le_of_le_one_left (abs_nonneg _) (Real.abs_sin_le_one t))
        (mul_le_of_le_one_left (abs_nonneg _) (Real.abs_cos_le_one t))
    _ ≤ ∑ j, (|linearField A x j| + |linearField B x j|) :=
      Finset.single_le_sum (fun j _ => add_nonneg (abs_nonneg (linearField A x j))
        (abs_nonneg (linearField B x j))) (Finset.mem_univ i)

 

theorem hasDerivAt_expected_rotated {n : ℕ} (A B : ι → Fin n → ℝ) (t : ℝ) :
    HasDerivAt (fun s => ∫ x, logPartition (linearField (rotateCoeff A B s) x) ∂standardLaw n)
      (∫ x, ∑ i, weight (linearField (rotateCoeff A B t) x) i *
        linearField (velocityCoeff A B t) x i ∂standardLaw n) t := by
  apply (hasDerivAt_integral_of_dominated_loc_of_deriv_le (s := Set.univ)
    (bound := fun x => ∑ i, (|linearField A x i| + |linearField B x i|))
    (F' := fun s x => ∑ i, weight (linearField (rotateCoeff A B s) x) i *
      linearField (velocityCoeff A B s) x i)
    (Filter.univ_mem) ?_ ?_ ?_ ?_ ?_ ?_).2
  · exact Filter.Eventually.of_forall fun s =>
      (continuous_logPartition.comp (continuous_linearField (rotateCoeff A B s))).aestronglyMeasurable
  · exact integrable_logPartition (integrable_linearField (rotateCoeff A B t))
  · exact (continuous_weightedMean (rotateCoeff A B t) (velocityCoeff A B t)).aestronglyMeasurable
  · exact ae_of_all _ fun x s _ => by
      simpa only [Real.norm_eq_abs] using rotated_derivative_bound A B x s
  · exact integrable_finsetSum _ fun i _ =>
      (integrable_linearField A i).abs.add (integrable_linearField B i).abs
  · exact ae_of_all _ fun x s _ =>
      hasDerivAt_logPartition (fun i => hasDerivAt_rotatedField A B x i s)

 
theorem integral_weightedMean_eq {n : ℕ} (A D : ι → Fin n → ℝ) :
    (∫ x, ∑ i, weight (linearField A x) i * linearField D x i ∂standardLaw n) =
      ∫ x, ∑ i, ∑ k, D i k * (weight (linearField A x) i *
        (A i k - ∑ j, weight (linearField A x) j * A j k)) ∂standardLaw n := by
  have hleft (i : ι) (k : Fin n) :
      Integrable (fun x => D i k * (x k * weight (linearField A x) i)) (standardLaw n) :=
    (integrable_coord_weight A i k).const_mul (D i k)
  have hright (i : ι) (k : Fin n) :
      Integrable (fun x => D i k * (weight (linearField A x) i *
        (A i k - ∑ j, weight (linearField A x) j * A j k))) (standardLaw n) :=
    (integrable_weight_derivative A i k).const_mul (D i k)
  calc
    _ = ∫ x, ∑ i, ∑ k, D i k * (x k * weight (linearField A x) i) ∂standardLaw n := by
      apply integral_congr_ae
      exact ae_of_all _ fun x => by
        apply Finset.sum_congr rfl
        intro i _
        rw [linearField, Finset.mul_sum]
        apply Finset.sum_congr rfl
        intro k _
        ring
    _ = ∑ i, ∑ k, D i k * (∫ x, x k * weight (linearField A x) i ∂standardLaw n) := by
      rw [integral_finsetSum _ (fun i _ => integrable_finsetSum _ (fun k _ => hleft i k))]
      apply Finset.sum_congr rfl
      intro i _
      rw [integral_finsetSum _ (fun k _ => hleft i k)]
      simp only [integral_const_mul]
    _ = ∑ i, ∑ k, D i k * (∫ x, weight (linearField A x) i *
        (A i k - ∑ j, weight (linearField A x) j * A j k) ∂standardLaw n) := by
      simp_rw [integral_coord_weight]
    _ = _ := by
      rw [integral_finsetSum _ (fun i _ => integrable_finsetSum _ (fun k _ => hright i k))]
      apply Finset.sum_congr rfl
      intro i _
      rw [integral_finsetSum _ (fun k _ => hright i k)]
      simp only [integral_const_mul]

omit [Nonempty ι] in
theorem pairwise_covariance {n : ℕ} (A D : ι → Fin n → ℝ) (w : ι → ℝ)
    (hw : ∑ i, w i = 1) :
    (∑ i, ∑ k, D i k * (w i * (A i k - ∑ j, w j * A j k))) =
      (1 / 2 : ℝ) * ∑ i, ∑ j, w i * w j *
        ∑ k, (D i k - D j k) * (A i k - A j k) := by
  have hk (k : Fin n) :
      (∑ i, D i k * (w i * (A i k - ∑ j, w j * A j k))) =
      (1 / 2 : ℝ) * ∑ i, ∑ j, w i * w j * (D i k - D j k) * (A i k - A j k) := by
    have h := weighted_covariance w (fun i => D i k) (fun i => A i k) hw
    have he : (∑ i, D i k * (w i * (A i k - ∑ j, w j * A j k))) =
        (∑ i, w i * D i k * A i k) - (∑ i, w i * D i k) * (∑ j, w j * A j k) := by
      calc
        _ = ∑ i, (w i * D i k * A i k - (w i * D i k) * (∑ j, w j * A j k)) := by
          apply Finset.sum_congr rfl
          intro i _
          ring
        _ = _ := by rw [Finset.sum_sub_distrib, ← Finset.sum_mul]
    rw [he, h]
    ring
  rw [Finset.sum_comm]
  simp_rw [hk, ← Finset.mul_sum]
  congr 1
  rw [Finset.sum_comm]
  apply Finset.sum_congr rfl
  intro i _
  rw [Finset.sum_comm]
  apply Finset.sum_congr rfl
  intro j _
  rw [Finset.mul_sum]
  apply Finset.sum_congr rfl
  intro k _
  ring

 

theorem integral_weightedMean_eq_pairwise {n : ℕ} (A D : ι → Fin n → ℝ) :
    (∫ x, ∑ i, weight (linearField A x) i * linearField D x i ∂standardLaw n) =
      ∫ x, (1 / 2 : ℝ) * ∑ i, ∑ j,
        weight (linearField A x) i * weight (linearField A x) j *
          ∑ k, (D i k - D j k) * (A i k - A j k) ∂standardLaw n := by
  rw [integral_weightedMean_eq]
  apply integral_congr_ae
  exact ae_of_all _ fun x => pairwise_covariance A D (weight (linearField A x)) (sum_weight _)

omit [Fintype ι] [Nonempty ι] in
theorem rotated_increment_covariance {n : ℕ} (A B : ι → Fin n → ℝ)
    (hAB : ∀ i j, ∑ k, A i k * B j k = 0) (i j : ι) (t : ℝ) :
    (∑ k, (velocityCoeff A B t i k - velocityCoeff A B t j k) *
      (rotateCoeff A B t i k - rotateCoeff A B t j k)) =
      Real.sin t * Real.cos t *
        ((∑ k, (B i k - B j k) ^ 2) - ∑ k, (A i k - A j k) ^ 2) := by
  have hcross : (∑ k, (A i k - A j k) * (B i k - B j k)) = 0 := by
    simp_rw [sub_mul, mul_sub, Finset.sum_sub_distrib, hAB]
    ring
  have he (k : Fin n) :
      (velocityCoeff A B t i k - velocityCoeff A B t j k) *
        (rotateCoeff A B t i k - rotateCoeff A B t j k) =
      Real.sin t * Real.cos t * ((B i k - B j k) ^ 2 - (A i k - A j k) ^ 2) +
        (Real.cos t ^ 2 - Real.sin t ^ 2) * ((A i k - A j k) * (B i k - B j k)) := by
    unfold velocityCoeff rotateCoeff
    ring
  simp_rw [he, Finset.sum_add_distrib, ← Finset.mul_sum, Finset.sum_sub_distrib, hcross]
  ring

 

theorem expected_rotated_derivative_nonneg {n : ℕ} (A B : ι → Fin n → ℝ)
    (hAB : ∀ i j, ∑ k, A i k * B j k = 0)
    (hinc : ∀ i j, (∑ k, (A i k - A j k) ^ 2) ≤ ∑ k, (B i k - B j k) ^ 2)
    {t : ℝ} (ht : t ∈ Set.Icc 0 (Real.pi / 2)) :
    0 ≤ ∫ x, ∑ i, weight (linearField (rotateCoeff A B t) x) i *
      linearField (velocityCoeff A B t) x i ∂standardLaw n := by
  rw [integral_weightedMean_eq_pairwise]
  apply integral_nonneg
  intro x
  apply mul_nonneg (by norm_num)
  apply Finset.sum_nonneg
  intro i _
  apply Finset.sum_nonneg
  intro j _
  apply mul_nonneg (mul_nonneg (weight_pos _ _).le (weight_pos _ _).le)
  rw [rotated_increment_covariance A B hAB]
  have hs : 0 ≤ Real.sin t := Real.sin_nonneg_of_nonneg_of_le_pi ht.1
    (ht.2.trans (by linarith [Real.pi_pos]))
  have hc : 0 ≤ Real.cos t := Real.cos_nonneg_of_mem_Icc ⟨by linarith [ht.1, Real.pi_pos], ht.2⟩
  exact mul_nonneg (mul_nonneg hs hc) (sub_nonneg.mpr (hinc i j))

 

theorem expected_logPartition_le {n : ℕ} (A B : ι → Fin n → ℝ)
    (hAB : ∀ i j, ∑ k, A i k * B j k = 0)
    (hinc : ∀ i j, (∑ k, (A i k - A j k) ^ 2) ≤ ∑ k, (B i k - B j k) ^ 2) :
    (∫ x, logPartition (linearField A x) ∂standardLaw n) ≤
      ∫ x, logPartition (linearField B x) ∂standardLaw n := by
  have hc : Continuous (fun t => ∫ x, logPartition (linearField (rotateCoeff A B t) x) ∂standardLaw n) :=
    continuous_iff_continuousAt.mpr fun t => (hasDerivAt_expected_rotated A B t).continuousAt
  have hm := monotoneOn_of_hasDerivWithinAt_nonneg (convex_Icc (0 : ℝ) (Real.pi / 2))
    hc.continuousOn (fun t _ => (hasDerivAt_expected_rotated A B t).hasDerivWithinAt)
    (fun t ht => expected_rotated_derivative_nonneg A B hAB hinc (interior_subset ht))
  have hpi : 0 ≤ Real.pi / 2 := by positivity
  have h := hm (show (0 : ℝ) ∈ Set.Icc 0 (Real.pi / 2) from ⟨le_rfl, hpi⟩)
    (show Real.pi / 2 ∈ Set.Icc 0 (Real.pi / 2) from ⟨hpi, le_rfl⟩) hpi
  have h0 : rotateCoeff A B 0 = A := by funext i k; simp [rotateCoeff]
  have h1 : rotateCoeff A B (Real.pi / 2) = B := by funext i k; simp [rotateCoeff]
  simpa only [h0, h1] using h

theorem finiteMax_abs_le (x : ι → ℝ) : |finiteMax x| ≤ ∑ i, |x i| := by
  obtain ⟨i, _, hi⟩ := Finset.exists_mem_eq_sup' (Finset.univ_nonempty : (Finset.univ : Finset ι).Nonempty) x
  rw [finiteMax, hi]
  exact Finset.single_le_sum (fun j _ => abs_nonneg (x j)) (Finset.mem_univ i)

theorem continuous_finiteMax : Continuous (@finiteMax ι _ _) := by
  exact Continuous.finset_sup'_apply Finset.univ_nonempty fun i _ => continuous_apply i

theorem integrable_finiteMax {Ω : Type*} [MeasurableSpace Ω] {μ : Measure Ω}
    {f : Ω → ι → ℝ} (hf : ∀ i, Integrable (fun x => f x i) μ) :
    Integrable (fun x => finiteMax (f x)) μ := by
  apply (integrable_finsetSum _ fun i _ => (hf i).abs).mono'
  · exact continuous_finiteMax.comp_aestronglyMeasurable
      (integrable_pi_iff.mpr hf).aestronglyMeasurable
  · exact ae_of_all _ fun x => by simpa only [Real.norm_eq_abs] using finiteMax_abs_le (f x)

theorem finiteMax_const_mul (x : ι → ℝ) {c : ℝ} (hc : 0 ≤ c) :
    finiteMax (fun i => c * x i) = c * finiteMax x := by
  apply le_antisymm
  · exact Finset.sup'_le Finset.univ_nonempty _ fun i _ =>
      mul_le_mul_of_nonneg_left (le_finiteMax x i) hc
  · obtain ⟨i, _, hi⟩ := Finset.exists_mem_eq_sup'
      (Finset.univ_nonempty : (Finset.univ : Finset ι).Nonempty) x
    change c * Finset.univ.sup' Finset.univ_nonempty x ≤ _
    rw [hi]
    exact le_finiteMax (fun i => c * x i) i

omit [Fintype ι] [Nonempty ι] in
theorem linearField_const_mul {n : ℕ} (A : ι → Fin n → ℝ) (c : ℝ)
    (x : Fin n → ℝ) (i : ι) :
    linearField (fun i k => c * A i k) x i = c * linearField A x i := by
  simp only [linearField, mul_assoc, Finset.mul_sum]

 

theorem expected_finiteMax_le {n : ℕ} (A B : ι → Fin n → ℝ)
    (hAB : ∀ i j, ∑ k, A i k * B j k = 0)
    (hinc : ∀ i j, (∑ k, (A i k - A j k) ^ 2) ≤ ∑ k, (B i k - B j k) ^ 2) :
    (∫ x, finiteMax (linearField A x) ∂standardLaw n) ≤
      ∫ x, finiteMax (linearField B x) ∂standardLaw n := by
  apply le_of_forall_pos_le_add
  intro ε hε
  let c : ℝ := (Real.log (Fintype.card ι) + 1) / ε
  have hc : 0 < c := div_pos (by linarith [Real.log_natCast_nonneg (Fintype.card ι)]) hε
  let A' : ι → Fin n → ℝ := fun i k => c * A i k
  let B' : ι → Fin n → ℝ := fun i k => c * B i k
  have hor : ∀ i j, ∑ k, A' i k * B' j k = 0 := by
    intro i j
    calc
      _ = c ^ 2 * ∑ k, A i k * B j k := by
        rw [Finset.mul_sum]
        apply Finset.sum_congr rfl
        intro k _
        dsimp [A', B']
        ring
      _ = 0 := by rw [hAB, mul_zero]
  have hdist : ∀ i j, (∑ k, (A' i k - A' j k) ^ 2) ≤ ∑ k, (B' i k - B' j k) ^ 2 := by
    intro i j
    have he (C : ι → Fin n → ℝ) :
        (∑ k, (c * C i k - c * C j k) ^ 2) = c ^ 2 * ∑ k, (C i k - C j k) ^ 2 := by
      simp only [← mul_sub, mul_pow, Finset.mul_sum]
    change (∑ k, (c * A i k - c * A j k) ^ 2) ≤ ∑ k, (c * B i k - c * B j k) ^ 2
    rw [he A, he B]
    exact mul_le_mul_of_nonneg_left (hinc i j) (sq_nonneg c)
  have hscaled : c * (∫ x, finiteMax (linearField A x) ∂standardLaw n) ≤
      c * (∫ x, finiteMax (linearField B x) ∂standardLaw n) + Real.log (Fintype.card ι) := by
    calc
      _ = ∫ x, finiteMax (linearField A' x) ∂standardLaw n := by
        simp_rw [show ∀ x, linearField A' x = fun i => c * linearField A x i from
          fun x => funext fun i => linearField_const_mul A c x i,
          finiteMax_const_mul _ hc.le, integral_const_mul]
      _ ≤ ∫ x, logPartition (linearField A' x) ∂standardLaw n :=
        integral_mono (integrable_finiteMax (integrable_linearField A'))
          (integrable_logPartition (integrable_linearField A'))
          (fun x => finiteMax_le_logPartition (linearField A' x))
      _ ≤ ∫ x, logPartition (linearField B' x) ∂standardLaw n :=
        expected_logPartition_le A' B' hor hdist
      _ ≤ ∫ x, finiteMax (linearField B' x) + Real.log (Fintype.card ι) ∂standardLaw n :=
        integral_mono (integrable_logPartition (integrable_linearField B'))
          ((integrable_finiteMax (integrable_linearField B')).add (integrable_const _))
          (fun x => logPartition_le (linearField B' x))
      _ = _ := by
        rw [integral_add (integrable_finiteMax (integrable_linearField B')) (integrable_const _)]
        simp_rw [show ∀ x, linearField B' x = fun i => c * linearField B x i from
          fun x => funext fun i => linearField_const_mul B c x i,
          finiteMax_const_mul _ hc.le, integral_const_mul]
        simp
  have heps : c * ε = Real.log (Fintype.card ι) + 1 := by
    dsimp [c]
    exact div_mul_cancel₀ _ hε.ne'
  nlinarith

 
def gaussianLaw (κ : Type*) [Fintype κ] : Measure (κ → ℝ) :=
  Measure.pi fun _ => gaussianReal 0 1

instance (κ : Type*) [Fintype κ] : IsProbabilityMeasure (gaussianLaw κ) := by
  unfold gaussianLaw
  infer_instance

 
def field {κ : Type*} [Fintype κ] (A : ι → κ → ℝ) (x : κ → ℝ) (i : ι) : ℝ :=
  ∑ k, A i k * x k

omit [Fintype ι] [Nonempty ι] in
theorem integrable_field {κ : Type*} [Fintype κ] (A : ι → κ → ℝ) (i : ι) :
    Integrable (fun x => field A x i) (gaussianLaw κ) := by
  apply integrable_finsetSum
  intro k _
  apply Integrable.const_mul
  change Integrable (fun x : κ → ℝ => id (x k)) (Measure.pi fun _ : κ => gaussianReal 0 1)
  apply integrable_comp_eval
  exact MemLp.integrable (by norm_num) (memLp_id_gaussianReal (μ := 0) (v := 1) 1)

omit [Fintype ι] [Nonempty ι] in
theorem integral_reindex_field {κ : Type*} [Fintype κ] (A : ι → κ → ℝ)
    (f : (ι → ℝ) → ℝ) :
    (∫ x, f (linearField (fun i k => A i ((Fintype.equivFin κ).symm k)) x)
      ∂standardLaw (Fintype.card κ)) = ∫ x, f (field A x) ∂gaussianLaw κ := by
  let e : Fin (Fintype.card κ) ≃ κ := (Fintype.equivFin κ).symm
  let T : (Fin (Fintype.card κ) → ℝ) ≃ᵐ (κ → ℝ) :=
    MeasurableEquiv.piCongrLeft (fun _ => ℝ) e
  have hm : MeasurePreserving T (standardLaw (Fintype.card κ)) (gaussianLaw κ) :=
    measurePreserving_piCongrLeft (fun _ => gaussianReal 0 1) e
  have he (x : Fin (Fintype.card κ) → ℝ) :
      field A (T x) = linearField (fun i k => A i (e k)) x := by
    funext i
    show (∑ k, A i k * T x k) = ∑ k, A i (e k) * x k
    rw [← e.sum_comp (fun k => A i k * T x k)]
    apply Finset.sum_congr rfl
    intro k _
    simp only [T, MeasurableEquiv.piCongrLeft_apply_apply]
  have h := hm.integral_comp' (fun x => f (field A x))
  simp_rw [he] at h
  exact h

 
theorem expected_field_max_le_of_orthogonal {κ : Type*} [Fintype κ]
    (A B : ι → κ → ℝ)
    (hAB : ∀ i j, ∑ k, A i k * B j k = 0)
    (hinc : ∀ i j, (∑ k, (A i k - A j k) ^ 2) ≤ ∑ k, (B i k - B j k) ^ 2) :
    (∫ x, finiteMax (field A x) ∂gaussianLaw κ) ≤
      ∫ x, finiteMax (field B x) ∂gaussianLaw κ := by
  rw [← integral_reindex_field A finiteMax, ← integral_reindex_field B finiteMax]
  apply expected_finiteMax_le
  · intro i j
    exact ((Fintype.equivFin κ).symm.sum_comp (fun k => A i k * B j k)).trans (hAB i j)
  · intro i j
    exact ((Fintype.equivFin κ).symm.sum_comp (fun k => (A i k - A j k) ^ 2)).le.trans
      ((hinc i j).trans ((Fintype.equivFin κ).symm.sum_comp (fun k => (B i k - B j k) ^ 2)).symm.le)

omit [Fintype ι] [Nonempty ι] in
 
theorem integral_field_inl {κ κ₂ : Type*} [Fintype κ] [Fintype κ₂] (A : ι → κ → ℝ)
    (f : (ι → ℝ) → ℝ) :
    (∫ x, f (field (fun i => Sum.elim (A i) (fun _ : κ₂ => 0)) x) ∂gaussianLaw (κ ⊕ κ₂)) =
      ∫ x, f (field A x) ∂gaussianLaw κ := by
  let T : ((κ → ℝ) × (κ₂ → ℝ)) ≃ᵐ ((κ ⊕ κ₂) → ℝ) :=
    (MeasurableEquiv.sumPiEquivProdPi (fun _ : κ ⊕ κ₂ => ℝ)).symm
  have hm : MeasurePreserving T ((gaussianLaw κ).prod (gaussianLaw κ₂)) (gaussianLaw (κ ⊕ κ₂)) :=
    measurePreserving_sumPiEquivProdPi_symm (fun _ => gaussianReal 0 1)
  rw [← hm.integral_comp' (fun x => f (field (fun i => Sum.elim (A i) (fun _ : κ₂ => 0)) x))]
  have he (x : (κ → ℝ) × (κ₂ → ℝ)) :
      field (fun i => Sum.elim (A i) (fun _ : κ₂ => 0)) (T x) = field A x.1 := by
    funext i
    simp only [field, Fintype.sum_sum_type, Sum.elim_inl, Sum.elim_inr, zero_mul,
      Finset.sum_const_zero, add_zero]
    rfl
  simp_rw [he]
  simpa using integral_fun_fst (μ := gaussianLaw κ) (ν := gaussianLaw κ₂)
    (fun x => f (field A x))

omit [Fintype ι] [Nonempty ι] in
theorem integral_field_inr {κ κ₂ : Type*} [Fintype κ] [Fintype κ₂] (B : ι → κ₂ → ℝ)
    (f : (ι → ℝ) → ℝ) :
    (∫ x, f (field (fun i => Sum.elim (fun _ : κ => 0) (B i)) x) ∂gaussianLaw (κ ⊕ κ₂)) =
      ∫ x, f (field B x) ∂gaussianLaw κ₂ := by
  let T : ((κ → ℝ) × (κ₂ → ℝ)) ≃ᵐ ((κ ⊕ κ₂) → ℝ) :=
    (MeasurableEquiv.sumPiEquivProdPi (fun _ : κ ⊕ κ₂ => ℝ)).symm
  have hm : MeasurePreserving T ((gaussianLaw κ).prod (gaussianLaw κ₂)) (gaussianLaw (κ ⊕ κ₂)) :=
    measurePreserving_sumPiEquivProdPi_symm (fun _ => gaussianReal 0 1)
  rw [← hm.integral_comp' (fun x => f (field (fun i => Sum.elim (fun _ : κ => 0) (B i)) x))]
  have he (x : (κ → ℝ) × (κ₂ → ℝ)) :
      field (fun i => Sum.elim (fun _ : κ => 0) (B i)) (T x) = field B x.2 := by
    funext i
    simp only [field, Fintype.sum_sum_type, Sum.elim_inl, Sum.elim_inr, zero_mul,
      Finset.sum_const_zero, zero_add]
    rfl
  simp_rw [he]
  simpa using integral_fun_snd (μ := gaussianLaw κ) (ν := gaussianLaw κ₂)
    (fun x => f (field B x))

 

theorem expected_field_max_le {κ κ₂ : Type*} [Fintype κ] [Fintype κ₂]
    (A : ι → κ → ℝ) (B : ι → κ₂ → ℝ)
    (hinc : ∀ i j, (∑ k, (A i k - A j k) ^ 2) ≤ ∑ k, (B i k - B j k) ^ 2) :
    (∫ x, finiteMax (field A x) ∂gaussianLaw κ) ≤
      ∫ x, finiteMax (field B x) ∂gaussianLaw κ₂ := by
  rw [← integral_field_inl (κ₂ := κ₂) A finiteMax,
    ← integral_field_inr (κ := κ) B finiteMax]
  apply expected_field_max_le_of_orthogonal
  · intro i j
    simp [Fintype.sum_sum_type]
  · intro i j
    simpa only [Fintype.sum_sum_type, Sum.elim_inl, Sum.elim_inr, sub_self,
      sq, mul_zero, Finset.sum_const_zero, add_zero, zero_add] using hinc i j

end SKGaussian

end

end OAI