lean/OAI/Probability/GaussianInformation/Kernel/GaussianImages.lean

import Mathlib
import OAI.Probability.GaussianInformation.Kernel.ReplicaMoments

namespace OAI
open MeasureTheory ProbabilityTheory Metric Set
open scoped ENNReal
namespace KernelPotential
open Filter
open scoped Topology NNReal
namespace Projection
open MeasureTheory ProbabilityTheory Set Filter
open scoped ENNReal Topology
open InnerProductSpace Matrix MeasureTheory Set
open scoped RealInnerProductSpace ENNReal
open MeasureTheory ProbabilityTheory Set
open scoped ENNReal NNReal
namespace Support

lemma finiteProduct_le {ι : Type*} [Fintype ι] {E : ι → Type*}
    [∀ i, MeasurableSpace (E i)] {μ ν : ∀ i, Measure (E i)}
    (h : ∀ i, μ i ≤ ν i) : Measure.pi μ ≤ Measure.pi ν := by
  apply Measure.le_iff.mpr
  intro s hs
  rw [Measure.pi, Measure.pi, toMeasure_apply _ _ hs, toMeasure_apply _ _ hs]
  have ho : (OuterMeasure.pi fun i => (μ i).toOuterMeasure) ≤
      OuterMeasure.pi fun i => (ν i).toOuterMeasure := by
    apply OuterMeasure.le_pi.mpr
    intro t _
    exact (OuterMeasure.pi_pi_le _ _).trans
      (Finset.prod_le_prod fun i _ => h i (t i))
  exact ho s

lemma standardGaussianPDF_le_one (x : ℝ) : gaussianPDF 0 1 x ≤ 1 := by
  apply ENNReal.ofReal_le_one.mpr
  change (Real.sqrt (2 * Real.pi * (1 : ℝ)))⁻¹ * Real.exp (-(x - 0)^2 / (2 * 1)) ≤ 1
  simp only [mul_one, sub_zero]
  have hs : 1 ≤ Real.sqrt (2 * Real.pi) := by
    apply (Real.le_sqrt (by norm_num) (by positivity)).mpr
    nlinarith [Real.pi_gt_three]
  have hi : (Real.sqrt (2 * Real.pi))⁻¹ ≤ 1 := inv_le_one_of_one_le₀ hs
  have he : Real.exp (-(x^2) / 2) ≤ 1 := Real.exp_le_one_iff.mpr (by nlinarith [sq_nonneg x])
  exact (mul_le_mul_of_nonneg_left he (by positivity)).trans (by simpa using hi)

lemma standardGaussian_le_volume : gaussianReal 0 1 ≤ (volume : Measure ℝ) := by
  rw [gaussianReal_of_var_ne_zero _ one_ne_zero]
  conv_rhs => rw [← withDensity_one (μ := (volume : Measure ℝ))]
  exact withDensity_mono (ae_of_all _ standardGaussianPDF_le_one)

lemma iidGaussian_le_volume (ι : Type*) [Fintype ι] :
    Measure.pi (fun _ : ι => gaussianReal 0 1) ≤ (volume : Measure (ι → ℝ)) :=
  finiteProduct_le fun _ => standardGaussian_le_volume

lemma gaussian_square_map_le {ι : Type*} [Fintype ι] [DecidableEq ι]
    (M : Matrix ι ι ℝ) (hM : M.det ≠ 0) :
    (Measure.pi (fun _ : ι => gaussianReal 0 1)).map (Matrix.toLin' M) ≤
      ENNReal.ofReal (|M.det|⁻¹) • (volume : Measure (ι → ℝ)) := by
  have hmap := Measure.map_mono (iidGaussian_le_volume ι)
    (Matrix.toLin' M).continuous_of_finiteDimensional.measurable
  rw [Real.map_matrix_volume_pi_eq_smul_volume_pi hM, abs_inv] at hmap
  exact hmap

open Matrix WithLp
open scoped RealInnerProductSpace MatrixOrder

lemma rectangularGaussian_eq {ι κ : Type*} [Fintype ι] [Fintype κ]
    [DecidableEq ι] [DecidableEq κ] (A : Matrix ι κ ℝ) :
    (stdGaussian (EuclideanSpace ℝ κ)).map
      (LinearMap.toContinuousLinearMap A.toEuclideanLin) =
      multivariateGaussian 0 (A * Aᵀ) := by
  have hA : (A * Aᵀ).PosSemidef := by
    simpa using Matrix.posSemidef_self_mul_conjTranspose A
  apply IsGaussian.ext
  · simp only [id_eq, integral_id_multivariateGaussian]
    rw [ContinuousLinearMap.integral_id_map IsGaussian.integrable_id,
      integral_id_stdGaussian, map_zero]
  · ext x y
    rw [covarianceBilin_map IsGaussian.memLp_two_id, covarianceBilin_stdGaussian,
      covarianceBilin_multivariateGaussian hA, innerSL_apply_apply ℝ,
      ← LinearMap.adjoint_toContinuousLinearMap,
      ← Matrix.toEuclideanLin_conjTranspose_eq_adjoint]
    simp only [LinearMap.coe_toContinuousLinearMap', Matrix.toLpLin_apply,
      Matrix.conjTranspose_eq_transpose_of_trivial, PiLp.inner_apply,
      RCLike.inner_apply, conj_trivial]
    change (Aᵀ *ᵥ y) ⬝ᵥ (Aᵀ *ᵥ x) = x ⬝ᵥ (A * Aᵀ) *ᵥ y
    rw [dotProduct_comm (Aᵀ *ᵥ y)]
    rw [← Matrix.mulVec_mulVec, Matrix.dotProduct_mulVec, ← Matrix.vecMul_transpose]
    simp [Matrix.dotProduct_mulVec]

lemma rectangularGaussian_squareRoot_eq {ι κ : Type*} [Fintype ι] [Fintype κ]
    [DecidableEq ι] [DecidableEq κ] (A : Matrix ι κ ℝ) :
    (Measure.pi (fun _ : κ => gaussianReal 0 1)).map (Matrix.toLin' A) =
    (Measure.pi (fun _ : ι => gaussianReal 0 1)).map
      (Matrix.toLin' (CFC.sqrt (A * Aᵀ))) := by
  have he := congrArg (fun μ : Measure (EuclideanSpace ℝ ι) => μ.map ofLp)
    (rectangularGaussian_eq A)
  unfold multivariateGaussian at he
  simp only [zero_add] at he
  rw [← map_pi_eq_stdGaussian, ← map_pi_eq_stdGaussian] at he
  rw [Measure.map_map (by fun_prop) (by fun_prop),
    Measure.map_map (by fun_prop) (by fun_prop),
    Measure.map_map (by fun_prop) (by fun_prop),
    Measure.map_map (by fun_prop) (by fun_prop)] at he
  exact he

lemma gaussian_rectangular_map_le {ι κ : Type*} [Fintype ι] [Fintype κ]
    [DecidableEq ι] [DecidableEq κ] (A : Matrix ι κ ℝ)
    (hA : (A * Aᵀ).det ≠ 0) :
    (Measure.pi (fun _ : κ => gaussianReal 0 1)).map (Matrix.toLin' A) ≤
      ENNReal.ofReal ((Real.sqrt (A * Aᵀ).det)⁻¹) • (volume : Measure (ι → ℝ)) := by
  have hpos : (A * Aᵀ).PosSemidef := by
    simpa using Matrix.posSemidef_self_mul_conjTranspose A
  have hd : (CFC.sqrt (A * Aᵀ)).det = Real.sqrt (A * Aᵀ).det := by
    rw [hpos.det_sqrt, RCLike.sqrt_of_nonneg hpos.det_nonneg]
    rfl
  have hD : (CFC.sqrt (A * Aᵀ)).det ≠ 0 := by
    rw [hd]
    exact Real.sqrt_ne_zero'.mpr (lt_of_le_of_ne hpos.det_nonneg hA.symm)
  rw [rectangularGaussian_squareRoot_eq]
  convert gaussian_square_map_le (CFC.sqrt (A * Aᵀ)) hD using 1
  rw [hd, abs_of_nonneg (Real.sqrt_nonneg _)]

lemma gaussian_rectangular_box_le {ι κ : Type*} [Fintype ι] [Fintype κ]
    [DecidableEq ι] [DecidableEq κ] (A : Matrix ι κ ℝ)
    (hA : (A * Aᵀ).det ≠ 0) (η : ℝ) (hη : 0 ≤ η) :
    (Measure.pi (fun _ : κ => gaussianReal 0 1))
      {x | ∀ i, |(A *ᵥ x) i| ≤ η} ≤
      ENNReal.ofReal ((Real.sqrt (A * Aᵀ).det)⁻¹ * (2 * η) ^ Fintype.card ι) := by
  have he : {x : κ → ℝ | ∀ i, |(A *ᵥ x) i| ≤ η} =
      (Matrix.toLin' A) ⁻¹' (Set.univ.pi fun _ : ι => Set.Icc (-η) η) := by
    ext x
    simp only [Set.mem_ofPred_eq, Set.mem_preimage, Set.mem_pi, Set.mem_univ,
      forall_true_left, Matrix.toLin'_apply, Set.mem_Icc, abs_le]
  rw [he, ← Measure.map_apply (Matrix.toLin' A).continuous_of_finiteDimensional.measurable
    (MeasurableSet.pi Set.countable_univ fun _ _ => measurableSet_Icc)]
  refine (gaussian_rectangular_map_le A hA _).trans_eq ?_
  rw [Measure.smul_apply, smul_eq_mul, volume_pi, Measure.pi_pi]
  simp only [Real.volume_Icc, sub_neg_eq_add, ← two_mul, Finset.prod_const,
    Finset.card_univ]
  rw [← ENNReal.ofReal_pow (by positivity), ← ENNReal.ofReal_mul (by positivity)]

lemma gaussian_multirow_box_le {ρ ι κ : Type*} [Fintype ρ] [Fintype ι] [Fintype κ]
    [DecidableEq ι] [DecidableEq κ] (A : Matrix ι κ ℝ)
    (hA : (A * Aᵀ).det ≠ 0) (η : ℝ) (hη : 0 ≤ η) :
    (Measure.pi (fun _ : ρ => Measure.pi (fun _ : κ => gaussianReal 0 1)))
      {X | ∀ r i, |(A *ᵥ X r) i| ≤ η} ≤
      ENNReal.ofReal (((Real.sqrt (A * Aᵀ).det)⁻¹ * (2 * η)^Fintype.card ι)^Fintype.card ρ) := by
  have he : {X : ρ → κ → ℝ | ∀ r i, |(A *ᵥ X r) i| ≤ η} =
      Set.univ.pi (fun _ : ρ => {x : κ → ℝ | ∀ i, |(A *ᵥ x) i| ≤ η}) := by
    ext x
    simp
  rw [he, Measure.pi_pi, ENNReal.ofReal_pow (by positivity)]
  simpa using Finset.prod_le_prod (s := (Finset.univ : Finset ρ))
    (fun _ _ => gaussian_rectangular_box_le A hA η hη)

end Support

namespace Support
open Matrix WithLp
open scoped MatrixOrder RealInnerProductSpace

lemma gaussian_multirow_box_le_extended {ρ ι κ : Type*} [Fintype ρ] [Fintype ι] [Fintype κ]
    [DecidableEq ι] [DecidableEq κ] (hρ : 0 < Fintype.card ρ)
    (A : Matrix ι κ ℝ) (η : ℝ) (hη : 0 < η) :
    (Measure.pi (fun _ : ρ => Measure.pi (fun _ : κ => gaussianReal 0 1)))
      {X | ∀ r i, |(A *ᵥ X r) i| ≤ η} ≤
      (ENNReal.ofReal (Real.sqrt (A * Aᵀ).det))⁻¹ ^ Fintype.card ρ *
        ENNReal.ofReal ((2*η)^(Fintype.card ι * Fintype.card ρ)) := by
  by_cases hA : (A * Aᵀ).det ≠ 0
  · refine (gaussian_multirow_box_le A hA η hη.le).trans_eq ?_
    have hpos : (A * Aᵀ).PosSemidef := by
      simpa using Matrix.posSemidef_self_mul_conjTranspose A
    have hd : 0 < Real.sqrt (A * Aᵀ).det := Real.sqrt_pos.mpr
      (lt_of_le_of_ne hpos.det_nonneg hA.symm)
    rw [mul_pow, ← pow_mul, ENNReal.ofReal_mul (by positivity),
      ENNReal.ofReal_pow (by positivity), ENNReal.ofReal_inv_of_pos hd]
  · simp only [not_ne_iff] at hA
    rw [hA, Real.sqrt_zero, ENNReal.ofReal_zero, ENNReal.inv_zero,
      ENNReal.top_pow hρ.ne', ENNReal.top_mul (by positivity)]
    exact le_top

noncomputable def rowMatrix {q d : ℕ} (f : Fin q → EuclideanSpace ℝ (Fin d)) :
    Matrix (Fin q) (Fin d) ℝ := fun i j => f i j

lemma rowMatrix_gram {q d : ℕ} (f : Fin q → EuclideanSpace ℝ (Fin d)) :
    rowMatrix f * (rowMatrix f)ᵀ = Matrix.gram ℝ f := by
  ext i j
  simp only [Matrix.mul_apply, Matrix.transpose_apply, rowMatrix, Matrix.gram_apply,
    PiLp.inner_apply, RCLike.inner_apply, conj_trivial]
  apply Finset.sum_congr rfl
  intro k _
  ring

end Support

end Projection
end KernelPotential

end OAI