lean/OAI/Probability/SKGap/Matrix/LogDetIntegral.lean

import Mathlib
import OAI.Probability.SKGap.Localization.Bilinear2
import OAI.Probability.SKGap.Matrix.RegularizedLogDet
import OAI.Probability.SKGap.Brownian.LogDetPath

namespace OAI

section
noncomputable section
namespace SKGap
open Matrix MeasureTheory ProbabilityTheory Real Set
open RealComplex
open scoped BigOperators Matrix.Norms.Frobenius SchwartzMap
variable {ι : Type*} [Fintype ι] [DecidableEq ι]

def logPathGood (R lo hi q : ℝ) (a : ι → ℝ) : Set (Matrix ι ι ℝ) :=
  {M | opNorm M ≤ R ∧ ∀ z ∈ Icc (0:ℝ) 1,
    lo ≤ ComplexSpectral.lowerRayleigh (liftMatrix (1-pathDiagonal a z*(M-pathShift z q)*pathDiagonal a z)) ∧
    -hi ≤ ComplexSpectral.lowerRayleigh (-liftMatrix (1-pathDiagonal a z*(M-pathShift z q)*pathDiagonal a z))}

lemma logPathGood_isClosed (R lo hi q : ℝ) (a : ι → ℝ) :
    IsClosed (logPathGood R lo hi q a) := by
  have hc (z : ℝ) : Continuous (fun M : Matrix ι ι ℝ => liftMatrix (1-pathDiagonal a z*(M-pathShift z q)*pathDiagonal a z)) := by
    dsimp only [liftMatrix]; fun_prop
  have hl (z : ℝ) := isClosed_le (continuous_const (y := lo)) (ComplexSpectral.continuous_lowerRayleigh.comp (hc z))
  have hu (z : ℝ) := isClosed_le (continuous_const (y := -hi)) (ComplexSpectral.continuous_lowerRayleigh.comp (hc z).neg)
  change IsClosed ({M | opNorm M ≤ R} ∩ {M | ∀ z ∈ Icc (0:ℝ) 1, _})
  apply (isClosed_le continuous_realOpNorm continuous_const).inter
  simp only [ofPred_forall]
  exact isClosed_iInter (fun z => isClosed_iInter (fun _ => (hl z).inter (hu z)))

lemma logPathGood_exponential [Nonempty ι] {j A : ℝ} {a : ι → ℝ}
    (hj : 0 < j) (hA : 0 < A) (ha : ∀ i, 0 ≤ a i) (haA : ∀ i, a i ≤ A)
    (hs : sqrt j*A < 1)
    (herr : 2*sqrt A*sqrt (sqrt (2*j^2*A^2/(Fintype.card ι:ℝ))) ≤ (1-sqrt j*A)^2/4) :
    (Measure.pi (fun _ : MatrixCoordinates ι => gaussianReal 0 1)).real
      {g | goeMatrix (j/(Fintype.card ι:ℝ)) g ∉
        logPathGood (2*sqrt j+1+1) ((1-sqrt j*A)^2/4) (2+A*(2*sqrt j+1+j*A))
          ((j/(Fintype.card ι:ℝ))*∑ b,a b) a} ≤ 3*Real.exp (-pathRate j A*(Fintype.card ι:ℝ)) := by
  apply (measureReal_mono (s₂ := {g | ∃ z ∈ Icc (0:ℝ) 1, g ∉ truncationGoodSet (j/(Fintype.card ι:ℝ))
        (2*sqrt j+1+1) ((1-sqrt j*A)^2/4) (2+A*(2*sqrt j+1+j*A))
        (pathDiagonal a z) (pathShift z ((j/(Fintype.card ι:ℝ))*∑ b,a b))}) ?_ (measure_ne_top _ _)).trans
    (path_all_good_exponential hj hA ha haA hs herr)
  intro g hg
  by_contra hcontra
  change ¬(∃ z ∈ Icc (0:ℝ) 1, _) at hcontra
  push Not at hcontra
  apply hg
  constructor
  · exact (hcontra 0 (by constructor <;> norm_num)).1.le
  · intro z hz
    exact ⟨(hcontra z hz).2.1.le,(hcontra z hz).2.2.le⟩

lemma logdetPath_integral [Nonempty ι] (f : 𝓢(ℝ,ℂ)) {lo hi : ℝ} (hlo : 0 < lo)
    (hf : ∀ x ∈ Icc lo hi, f x=(x:ℂ)⁻¹) {R : ℝ} (hR : 0 ≤ R)
    (j : ℝ) {a : ι → ℝ} (ha : ∀ i, 0 ≤ a i) (M : Matrix ι ι ℝ) (hM : Mᵀ=M)
    (hg : M ∈ logPathGood R lo hi ((j/(Fintype.card ι:ℝ))*∑ b,a b) a) :
    (∫ z in (0:ℝ)..1, logPathCutoffDerivative f R hR j a M z)=
      log (logPath ((j/(Fintype.card ι:ℝ))*∑ b,a b) a M 1).det/(Fintype.card ι:ℝ) := by
  have hc : Continuous (fun z => logPathCutoffDerivative f R hR j a M z) :=
    (continuous_logPathCutoffDerivative f hR j a).comp (continuous_id.prodMk continuous_const)
  have hh := intervalIntegral.integral_eq_sub_of_hasDerivAt
    (f := fun z => log (logPath ((j/(Fintype.card ι:ℝ))*∑ b,a b) a M z).det/(Fintype.card ι:ℝ))
    (f' := fun z => logPathCutoffDerivative f R hR j a M z)
    (fun z hz => ?_) (hc.intervalIntegrable 0 1)
  · simpa only [logPath,zero_pow (by norm_num : 2 ≠ 0),zero_mul,zero_smul,add_zero,
      sub_zero,Matrix.det_one,log_one,zero_div] using hh
  · have hz' : z ∈ Icc (0:ℝ) 1 := by simpa only [uIcc_of_le (by norm_num : (0:ℝ)≤1)] using hz
    obtain ⟨hunit,hagree⟩ := pathK_agrees_at f hlo hf hR j ha hz'.1 M hM hg.1 (hg.2 z hz').1 (hg.2 z hz').2
    have hd := (LogDet.hasDerivAt_logdet (hasDerivAt_logPath ((j/(Fintype.card ι:ℝ))*∑ b,a b) a M z) hunit).div_const (Fintype.card ι:ℝ)
    rw [logPath_trace_derivative,← hagree] at hd
    simpa only [logPathCutoffDerivative,realProject_eq_self hR M hM hg.1] using hd

lemma trace_abs_le_card_opNorm (M : Matrix ι ι ℝ) : |M.trace| ≤ (Fintype.card ι:ℝ)*opNorm M := by
  unfold Matrix.trace Matrix.diag
  exact (Finset.abs_sum_le_sum_abs _ _).trans (by simpa only [Finset.sum_const,Finset.card_univ,nsmul_eq_mul] using Finset.sum_le_sum (s := Finset.univ) (fun i _ => matrix_entry_le_opNorm M i i))

lemma logPathCutoffDerivative_bound [Nonempty ι] (f : 𝓢(ℝ,ℂ)) {R j : ℝ} (hR : 0 ≤ R) (hj : 0 ≤ j)
    {a : ι → ℝ} (ha : ∀ i, 0 ≤ a i) (haA : ∀ i, a i ≤ 1) {z : ℝ} (hz : z ∈ Icc (0:ℝ) 1)
    (M : Matrix ι ι ℝ) :
    |logPathCutoffDerivative f R hR j a M z| ≤ (2*j+R)*pathBound f R j 1 := by
  have hn : (0:ℝ) < Fintype.card ι := Nat.cast_pos.mpr Fintype.card_pos
  have hB := (path_constants_nonneg f hR hj (by norm_num : (0:ℝ)≤1)).1
  have hq := diagonal_mean_bounds hj ha haA
  simp only [mul_one] at hq
  have hK := (pathK_bounds f hR hj (by norm_num : (0:ℝ)≤1) ha haA hz).1 M
  have hD : opNorm (diagonal a) ≤ 1 := opNorm_diagonal_le (by norm_num) (fun i => by rw [abs_of_nonneg (ha i)]; exact haA i)
  have hKD : opNorm (pathK f R hR j a z M*diagonal a) ≤ pathBound f R j 1 :=
    (opNorm_mul _ _).trans (by simpa only [mul_one] using mul_le_mul hK hD (norm_nonneg _) hB)
  have hWKD : opNorm (realProject R hR M*pathK f R hR j a z M*diagonal a) ≤ R*pathBound f R j 1 := by
    rw [mul_assoc]
    exact (opNorm_mul _ _).trans (mul_le_mul (realProject_opNorm hR M) hKD (norm_nonneg _) hR)
  have ht₁ := (trace_abs_le_card_opNorm _).trans (mul_le_mul_of_nonneg_left hKD hn.le)
  have ht₂ := (trace_abs_le_card_opNorm _).trans (mul_le_mul_of_nonneg_left hWKD hn.le)
  have hzq : |2*z*((j/(Fintype.card ι:ℝ))*∑ b,a b)| ≤ 2*j := by
    rw [abs_of_nonneg (mul_nonneg (mul_nonneg (by norm_num) hz.1) hq.1)]
    nlinarith [mul_le_mul hz.2 hq.2 hq.1 (by norm_num : (0:ℝ)≤1)]
  unfold logPathCutoffDerivative
  rw [abs_div,abs_of_pos hn]
  apply (div_le_iff₀ hn).mpr
  have hterm : |(2*z*((j/(Fintype.card ι:ℝ))*∑ b,a b))*(pathK f R hR j a z M*diagonal a).trace| ≤
      2*j*((Fintype.card ι:ℝ)*pathBound f R j 1) := by
    rw [abs_mul]
    exact mul_le_mul hzq ht₁ (abs_nonneg _) (by positivity)
  have hh := (abs_sub (2*z*((j/(Fintype.card ι:ℝ))*∑ b,a b)*(pathK f R hR j a z M*diagonal a).trace)
    (realProject R hR M*pathK f R hR j a z M*diagonal a).trace).trans (add_le_add hterm ht₂)
  exact hh.trans_eq (by ring)
end SKGap
end
end

section
noncomputable section
namespace SKGap
open Matrix MeasureTheory ProbabilityTheory Real Set
open RealComplex
open scoped BigOperators Matrix.Norms.Frobenius SchwartzMap
variable {ι : Type*} [Fintype ι] [DecidableEq ι]

lemma frobenius_le_sum_abs (M : Matrix ι ι ℝ) : ‖M‖ ≤ ∑ i,∑ k,|M i k| := by
  apply (sq_le_sq₀ (norm_nonneg M) (by positivity : 0 ≤ ∑ i,∑ k,|M i k|)).mp
  rw [frobenius_sq]
  calc
    _ ≤ ∑ i,(∑ k,|M i k|)^2 := Finset.sum_le_sum (fun i _ => by
      simpa only [sq_abs] using Finset.sum_sq_le_sq_sum_of_nonneg (s := Finset.univ) (fun k _ => abs_nonneg (M i k)))
    _ ≤ (∑ i,∑ k,|M i k|)^2 := Finset.sum_sq_le_sq_sum_of_nonneg (fun i _ => by positivity)

lemma frobenius_one : ‖(1:Matrix ι ι ℝ)‖=sqrt (Fintype.card ι:ℝ) := by
  have hs := LogDet.frobenius_sq_trace (1:Matrix ι ι ℝ)
  simp only [transpose_one,one_mul,Matrix.trace_one] at hs
  nlinarith [norm_nonneg (1:Matrix ι ι ℝ),sqrt_nonneg (Fintype.card ι:ℝ),sq_sqrt (Nat.cast_nonneg (Fintype.card ι))]

lemma logPath_one_frobenius [Nonempty ι] {j : ℝ} (hj : 0 ≤ j)
    {a : ι → ℝ} (ha : ∀ i, 0 ≤ a i) (ha1 : ∀ i, a i ≤ 1) (M : Matrix ι ι ℝ) :
    ‖logPath ((j/(Fintype.card ι:ℝ))*∑ i,a i) a M 1‖ ≤ sqrt (Fintype.card ι:ℝ)*(1+j)+‖M‖ := by
  have hq := diagonal_mean_bounds hj ha ha1
  simp only [mul_one] at hq
  have hD : opNorm (diagonal a) ≤ 1 := opNorm_diagonal_le (by norm_num) (fun i => by rw [abs_of_nonneg (ha i)]; exact ha1 i)
  have hDn := (LogDet.frobenius_le_sqrt_card_opNorm (diagonal a)).trans
    (mul_le_mul_of_nonneg_left hD (sqrt_nonneg _))
  simp only [mul_one] at hDn
  have hDM := (frobenius_mul_le_opNorm (diagonal a) M).trans (mul_le_mul_of_nonneg_right hD (norm_nonneg M))
  simp only [one_mul] at hDM
  simp only [logPath,one_pow,one_mul,one_smul]
  apply (norm_sub_le _ _).trans
  apply (add_le_add (norm_add_le _ _) hDM).trans
  rw [norm_smul,Real.norm_eq_abs,abs_of_nonneg hq.1,frobenius_one]
  have hh := mul_le_mul hq.2 hDn (norm_nonneg _) hj
  nlinarith

lemma logPath_one_lipschitz {j : ℝ} {a : ι → ℝ}
    (ha : ∀ i, 0 ≤ a i) (ha1 : ∀ i, a i ≤ 1) :
    LipschitzWith 1 (fun M : Matrix ι ι ℝ => logPath ((j/(Fintype.card ι:ℝ))*∑ i,a i) a M 1) := by
  apply LipschitzWith.of_dist_le_mul
  intro M N
  simp only [dist_eq_norm,NNReal.coe_one,one_mul]
  have he : logPath ((j/(Fintype.card ι:ℝ))*∑ i,a i) a M 1-
      logPath ((j/(Fintype.card ι:ℝ))*∑ i,a i) a N 1= -(diagonal a*(M-N)) := by
    simp only [logPath,one_pow,one_mul,one_smul,Matrix.mul_sub]; abel
  rw [he,norm_neg]
  have hD : opNorm (diagonal a) ≤ 1 := opNorm_diagonal_le (by norm_num) (fun i => by rw [abs_of_nonneg (ha i)]; exact ha1 i)
  exact (frobenius_mul_le_opNorm _ _).trans (by simpa only [one_mul] using mul_le_mul_of_nonneg_right hD (norm_nonneg (M-N)))

lemma logPath_regularized_integrable [Nonempty ι] {j γ : ℝ} (hγ : 0 < γ)
    {a : ι → ℝ} (ha : ∀ i, 0 ≤ a i) (ha1 : ∀ i, a i ≤ 1) :
    Integrable (fun g => LogDet.regularizedLogDet γ (logPath ((j/(Fintype.card ι:ℝ))*∑ i,a i) a
      (goeMatrix (j/(Fintype.card ι:ℝ)) g) 1))
      (Measure.pi (fun _ : MatrixCoordinates ι => gaussianReal 0 1)) := by
  have hF : LipschitzWith ⟨1/sqrt ((Fintype.card ι:ℝ)*γ),by positivity⟩ (LogDet.regularizedLogDet γ : Matrix ι ι ℝ → ℝ) := by
    apply LipschitzWith.of_dist_le_mul
    intro M N
    change |LogDet.regularizedLogDet γ M-LogDet.regularizedLogDet γ N| ≤ (1/sqrt ((Fintype.card ι:ℝ)*γ))*‖M-N‖
    exact LogDet.regularizedLogDet_lipschitz hγ M N
  exact gaussianProduct_integrable_lipschitz (hF.comp ((logPath_one_lipschitz ha ha1).comp (goeMatrix_L2_lipschitz _)))

lemma logPath_regularized_rare [Nonempty ι] {j γ : ℝ} (hj : 0 ≤ j) (hγ : 0 < γ)
    {a : ι → ℝ} (ha : ∀ i, 0 ≤ a i) (ha1 : ∀ i, a i ≤ 1)
    {s : Set (MatrixCoordinates ι → ℝ)} (hs : MeasurableSet s) :
    (∫ g in s, |LogDet.regularizedLogDet γ (logPath ((j/(Fintype.card ι:ℝ))*∑ i,a i) a
      (goeMatrix (j/(Fintype.card ι:ℝ)) g) 1)|
      ∂Measure.pi (fun _ : MatrixCoordinates ι => gaussianReal 0 1)) ≤
      (|log γ|+sqrt (Fintype.card ι:ℝ)*(1+j)/sqrt ((Fintype.card ι:ℝ)*γ))*
        (Measure.pi (fun _ : MatrixCoordinates ι => gaussianReal 0 1)).real s+
      (Fintype.card ι:ℝ)^2*sqrt (2*j/(Fintype.card ι:ℝ))/sqrt ((Fintype.card ι:ℝ)*γ)*
        sqrt ((Measure.pi (fun _ : MatrixCoordinates ι => gaussianReal 0 1)).real s) := by
  let μ := Measure.pi (fun _ : MatrixCoordinates ι => gaussianReal 0 1)
  let r := j/(Fintype.card ι:ℝ)
  have hentry (i k : ι) : Integrable (fun g => |goeMatrix r g i k|) μ :=
    ((goeEntry_memLp r i k).integrable (by norm_num)).abs
  have hsum : Integrable (fun g => ∑ i,∑ k,|goeMatrix r g i k|) μ :=
    integrable_finsetSum _ (fun i _ => integrable_finsetSum _ (fun k _ => hentry i k))
  have hpoint (g) : |LogDet.regularizedLogDet γ (logPath ((j/(Fintype.card ι:ℝ))*∑ i,a i) a (goeMatrix r g) 1)| ≤
      (|log γ|+sqrt (Fintype.card ι:ℝ)*(1+j)/sqrt ((Fintype.card ι:ℝ)*γ))+
        (∑ i,∑ k,|goeMatrix r g i k|)/sqrt ((Fintype.card ι:ℝ)*γ) := by
    apply (LogDet.regularizedLogDet_abs hγ _).trans
    have hh := (logPath_one_frobenius hj ha ha1 (goeMatrix r g)).trans (add_le_add_right (frobenius_le_sum_abs _) _)
    have ht := add_le_add_right (div_le_div_of_nonneg_right hh (sqrt_nonneg ((Fintype.card ι:ℝ)*γ))) |log γ|
    exact ht.trans_eq (by ring)
  have hm := integral_mono (μ := μ.restrict s) (logPath_regularized_integrable hγ ha ha1).abs.integrableOn
    ((integrable_const _).add (hsum.div_const _)).integrableOn hpoint
  simp only [Pi.add_apply] at hm
  rw [integral_add (integrable_const (|log γ|+sqrt (Fintype.card ι:ℝ)*(1+j)/sqrt ((Fintype.card ι:ℝ)*γ)))
      (hsum.div_const (sqrt ((Fintype.card ι:ℝ)*γ))).integrableOn,integral_const,smul_eq_mul,
    measureReal_restrict_apply_univ,integral_div] at hm
  have hsumle : (∫ g in s, (∑ i,∑ k,|goeMatrix r g i k|) ∂μ) ≤
      (Fintype.card ι:ℝ)^2*sqrt (2*j/(Fintype.card ι:ℝ))*sqrt (μ.real s) := by
    rw [integral_finsetSum _ (fun i _ => (integrable_finsetSum _ (fun k _ => hentry i k)).integrableOn)]
    simp_rw [integral_finsetSum _ (fun k _ => (hentry _ k).integrableOn)]
    have ht := Finset.sum_le_sum (s := Finset.univ) (fun i _ => Finset.sum_le_sum (s := Finset.univ) (fun k _ =>
      (integral_abs_on_set_le (goeEntry_memLp r i k) hs).trans (mul_le_mul_of_nonneg_right
        (sqrt_le_sqrt (goeEntry_integral_sq_le (by dsimp [r]; positivity) i k)) (sqrt_nonneg _))))
    simp only [Finset.sum_const,Finset.card_univ,nsmul_eq_mul] at ht
    exact ht.trans_eq (by
      dsimp only [r,μ]
      rw [show 2*(j/(Fintype.card ι:ℝ))=2*j/(Fintype.card ι:ℝ) by ring]
      ring)
  apply hm.trans
  have hh := div_le_div_of_nonneg_right hsumle (sqrt_nonneg ((Fintype.card ι:ℝ)*γ))
  exact (add_le_add_right hh (μ.real s*(|log γ|+sqrt (Fintype.card ι:ℝ)*(1+j)/sqrt ((Fintype.card ι:ℝ)*γ)))).trans_eq (by ring)
end SKGap

namespace SKGap
open MeasureTheory Real Set
lemma expectation_upper_good {Ω : Type*} [MeasurableSpace Ω] {μ : Measure Ω} [IsProbabilityMeasure μ]
    {F I : Ω → ℝ} {s : Set Ω} (hs : MeasurableSet s) (hF : Integrable F μ) (hI : Integrable I μ)
    {D c : ℝ} (hc : 0 ≤ c) (hD : ∀ x, |I x| ≤ D)
    (hgood : ∀ x ∉ s, F x ≤ 2*I x+c) :
    (∫ x, F x ∂μ) ≤ 2*(∫ x, I x ∂μ)+c+(∫ x in s, |F x| ∂μ)+2*D*μ.real s := by
  have hi : Integrable (fun x => 2*I x+c+s.indicator (fun x => |F x|+2*D) x) μ :=
    ((hI.const_mul 2).add (integrable_const c)).add ((hF.abs.add (integrable_const (2*D))).indicator hs)
  have hp (x) : F x ≤ 2*I x+c+s.indicator (fun x => |F x|+2*D) x := by
    by_cases hx : x ∈ s
    · simp only [Set.indicator_of_mem hx]
      have hh := (abs_le.mp (hD x)).1
      nlinarith [le_abs_self (F x)]
    · simpa only [Set.indicator_of_notMem hx,add_zero] using hgood x hx
  have hh := integral_mono hF hi hp
  have hi₁ : Integrable (fun x => 2*I x+c) μ := (hI.const_mul 2).add (integrable_const c)
  have hi₂ : Integrable (s.indicator (fun x => |F x|+2*D)) μ := (hF.abs.add (integrable_const (2*D))).indicator hs
  rw [integral_add hi₁ hi₂,integral_add (hI.const_mul 2) (integrable_const c),
    integral_const_mul,integral_indicator hs,integral_add hF.abs.integrableOn (integrable_const (2*D)),
    integral_const,integral_const] at hh
  simpa only [probReal_univ,mul_one,smul_eq_mul,measureReal_restrict_apply_univ,one_mul,mul_comm,add_assoc] using hh
end SKGap
end
end

end OAI