import Mathlib
import OAI.Probability.LogConcave.Analysis.PoincareVectorVariance
import OAI.Probability.LogConcave.JetEstimates.ArrayMatrix

namespace OAI

section
noncomputable section
namespace LogConcaveSampling
open MeasureTheory Set
open scoped NNReal ENNReal

namespace TimeJet
variable {X E : Type*} [NormedAddCommGroup X] [NormedSpace ℝ X]
  [NormedAddCommGroup E] [NormedSpace ℝ E]

def jet (f : ℝ × X → E) : ℕ → ℝ × X → E
  | 0 => f
  | n+1 => fun p => fderiv ℝ (jet f n) p (1,0)

lemma smooth {f : ℝ × X → E} (hf : ContDiff ℝ (⊤:ℕ∞) f) (n : ℕ) :
    ContDiff ℝ (⊤:ℕ∞) (jet f n) := by
  induction n with
  | zero => exact hf
  | succ n ih => exact (ih.fderiv_right (by simp)).clm_apply contDiff_const

lemma hasDerivAt (f : ℝ × X → E) (hf : ContDiff ℝ (⊤:ℕ∞) f)
    (n : ℕ) (t : ℝ) (y : X) :
    HasDerivAt (fun s => jet f n (s,y)) (jet f (n+1) (t,y)) t := by
  exact (((smooth hf n).differentiable (by simp)) (t,y)).hasFDerivAt.comp_hasDerivAt t
    ((hasDerivAt_id t).prodMk (hasDerivAt_const t y))

lemma eq_iteratedDeriv (f : ℝ × X → E) (hf : ContDiff ℝ (⊤:ℕ∞) f)
    (n : ℕ) (t : ℝ) (y : X) :
    jet f n (t,y)=iteratedDeriv n (fun s => f (s,y)) t := by
  induction n generalizing t with
  | zero => rfl
  | succ n ih =>
    rw [iteratedDeriv_succ,←funext (fun t => ih t)]
    exact (hasDerivAt f hf n t y).deriv.symm
end TimeJet

namespace RMSIntegral
variable {Ω E : Type*} [MeasurableSpace Ω] [NormedAddCommGroup E] {μ : Measure Ω}

lemma integral_norm_sq_eq_eLpNorm (f : Ω → E) (hf : MemLp f 2 μ) :
    (∫x,‖f x‖^2 ∂μ)=(eLpNorm f 2 μ).toReal^2 := by
  have hh := MemLp.eLpNorm_eq_integral_rpow_norm (f:=f) (by norm_num : (2:ℝ≥0∞)≠0)
    (by norm_num : (2:ℝ≥0∞)≠⊤) hf
  simp only [ENNReal.toReal_ofNat,Real.rpow_two] at hh
  rw [show (2:ℝ)⁻¹=1/2 by norm_num,←Real.sqrt_eq_rpow] at hh
  rw [hh,ENNReal.toReal_ofReal (Real.sqrt_nonneg _),Real.sq_sqrt]
  exact integral_nonneg (fun _ => sq_nonneg _)

lemma integral_norm_sq_le_of_eLpNorm {f : Ω → E}
    (_hm : AEStronglyMeasurable f μ) {B : ℝ≥0∞} (hB : B≠⊤)
    (hb : eLpNorm f 2 μ≤B) :
    Integrable (fun x => ‖f x‖^2) μ ∧ (∫x,‖f x‖^2 ∂μ)≤B.toReal^2 := by
  have hf : MemLp f 2 μ := lt_of_le_of_lt hb (lt_top_iff_ne_top.mpr hB)
  refine ⟨hf.integrable_norm_pow (by norm_num : (2:ℕ)≠0),?_⟩
  rw [integral_norm_sq_eq_eLpNorm f hf]
  exact pow_le_pow_left₀ ENNReal.toReal_nonneg (ENNReal.toReal_mono hB hb) 2
end RMSIntegral

lemma gaussian_operator_sq {Ω : Type*} [MeasurableSpace Ω] {μ : Measure Ω}
    [SFinite μ] {d : ℕ} (A : Ω → Point d →L[ℝ] Point d)
    (hA : Measurable A) (hi : Integrable (fun y => ‖A y‖^2) μ) {B : ℝ}
    (hB : (∫y,‖A y‖^2 ∂μ)≤B) :
    Integrable (fun p : Ω × Point d => ‖A p.1 p.2‖^2) (μ.prod (ProbabilityTheory.stdGaussian (Point d))) ∧
      (∫p : Ω × Point d,‖A p.1 p.2‖^2 ∂(μ.prod (ProbabilityTheory.stdGaussian (Point d))))≤B*d := by
  have hg : Integrable (fun z : Point d => ‖z‖^2) (ProbabilityTheory.stdGaussian (Point d)) := by
    simpa only [id_eq] using
      (ProbabilityTheory.IsGaussian.memLp_two_id (μ:=ProbabilityTheory.stdGaussian (Point d))).integrable_norm_pow
        (by norm_num : (2:ℕ)≠0)
  have hiB := hi.mul_prod hg
  have hb (p : Ω × Point d) : ‖A p.1 p.2‖^2≤‖A p.1‖^2*‖p.2‖^2 := by
    rw [←mul_pow]
    exact pow_le_pow_left₀ (norm_nonneg _) (ContinuousLinearMap.le_opNorm _ _) 2
  have hm : Measurable (fun p : Ω × Point d => A p.1 p.2) :=
    (continuous_fst.clm_apply continuous_snd).measurable.comp
      ((hA.comp measurable_fst).prodMk measurable_snd)
  have his : Integrable (fun p : Ω × Point d => ‖A p.1 p.2‖^2)
      (μ.prod (ProbabilityTheory.stdGaussian (Point d))) :=
    hiB.mono' (hm.norm.pow_const 2).aestronglyMeasurable
      (Filter.Eventually.of_forall (fun p => by simpa only [Real.norm_eq_abs,abs_sq] using hb p))
  refine ⟨his,?_⟩
  calc
    _ ≤ ∫p : Ω × Point d,‖A p.1‖^2*‖p.2‖^2 ∂(μ.prod (ProbabilityTheory.stdGaussian (Point d))) :=
      integral_mono his hiB hb
    _ = (∫y,‖A y‖^2 ∂μ)*d := by rw [integral_prod_mul (fun y => ‖A y‖^2) (fun z : Point d => ‖z‖^2),stdGaussian_sq_norm]
    _ ≤ _ := mul_le_mul_of_nonneg_right hB (Nat.cast_nonneg _)
end LogConcaveSampling

end

end

section

noncomputable section
namespace LogConcaveSampling
open Set Filter MeasureTheory ProbabilityTheory
open scoped Classical BigOperators NNReal ENNReal RealInnerProductSpace

variable {d : ℕ} {F : Point d → ℝ} {lam : ℝ≥0}
  (hF : Primitive F lam) (x : Point d) {r T : ℝ} (hr : 0<r) (hlam : 0<lam)
  (hl : (lam:ℝ)*r^2≤1/2) (hT0 : 0<T) (hT1 : T<1)

def terminalActionChain : ℕ → ℝ × (Point d × Point d) → Point d
  | 0 => fun p => (terminalJacobian hF x hr hl hT0.le hT1 (p.1,p.2.1)-
      ContinuousLinearMap.id ℝ (Point d)) p.2.2
  | n+1 => fun p => TimeJet.jet (terminalJacobian hF x hr hl hT0.le hT1) (n+1) (p.1,p.2.1) p.2.2

lemma terminalActionChain_smooth (n : ℕ) :
    ContDiff ℝ (⊤:ℕ∞) (terminalActionChain hF x hr hl hT0 hT1 n) := by
  cases n with
  | zero => exact (((terminalJacobian_smooth hF x hr hl hT0.le hT1).comp
      (contDiff_fst.prodMk contDiff_snd.fst)).sub contDiff_const).clm_apply contDiff_snd.snd
  | succ n => exact ((TimeJet.smooth (terminalJacobian_smooth hF x hr hl hT0.le hT1) (n+1)).comp
      (contDiff_fst.prodMk contDiff_snd.fst)).clm_apply contDiff_snd.snd

lemma terminalActionChain_hasDerivAt (n : ℕ) (t : ℝ) (p : Point d × Point d) :
    HasDerivAt (fun s => terminalActionChain hF x hr hl hT0 hT1 n (s,p))
      (terminalActionChain hF x hr hl hT0 hT1 (n+1) (t,p)) t := by
  have hd (n : ℕ) := (TimeJet.hasDerivAt _
    (terminalJacobian_smooth hF x hr hl hT0.le hT1) n t p.1).clm_apply (hasDerivAt_const t p.2)
  cases n with
  | zero =>
    have hh := (hd 0).sub_const p.2
    simpa only [terminalActionChain,TimeJet.jet,Function.comp_apply,
      sub_apply,ContinuousLinearMap.id_apply,map_zero,
      add_zero] using hh
  | succ n =>
    simpa only [terminalActionChain,map_zero,add_zero] using hd (n+1)

include hlam in
lemma terminalActionChain_first_zero (p : Point d × Point d) :
    terminalActionChain hF x hr hl hT0 hT1 1 (0,p)=0 := by
  exact (terminalActionChain_hasDerivAt hF x hr hl hT0 hT1 0 0 p).unique
    (terminalJacobian_action_initial_deriv hF x hr hlam hl hT0 hT1 p.1 p.2)

include hlam in

theorem terminalActionChain_sq (hd : 1≤d) (n : ℕ) (t : Icc (0:ℝ) T) :
    let μ := (interpolationLaw F x r T).prod (stdGaussian (Point d))
    let b := (r*((lam:ℝ)*r)*Real.exp (Real.pi^2/4))*
      ((TensorSum.terminalQ n).val.momentBudget d 0 2).toReal*
      ((Real.sqrt (1-(t:ℝ)^2))⁻¹)^(2*n)
    Integrable (fun p => ‖terminalActionChain hF x hr hl hT0 hT1 (n+1) (t,p)‖^2) μ ∧
      (∫p,‖terminalActionChain hF x hr hl hT0 hT1 (n+1) (t,p)‖^2 ∂μ)≤b^2*d := by
  dsimp only
  let := interpolationLaw_probability hF x hr.le (by linarith) T
  let A := fun y => TimeJet.jet (terminalJacobian hF x hr hl hT0.le hT1) (n+1) (t,y)
  have hAc : Continuous A := (TimeJet.smooth
    (terminalJacobian_smooth hF x hr hl hT0.le hT1) (n+1)).continuous.comp
      (continuous_const.prodMk continuous_id)
  have he : A=fun y => iteratedDeriv (n+1)
      (fun s => terminalJacobian hF x hr hl hT0.le hT1 (s,y)) t :=
    funext (fun y => TimeJet.eq_iteratedDeriv _
      (terminalJacobian_smooth hF x hr hl hT0.le hT1) (n+1) t y)
  let B : ℝ≥0∞ := ENNReal.ofReal (r*((lam:ℝ)*r)*Real.exp (Real.pi^2/4))*
    (TensorSum.terminalQ n).val.momentBudget d 0 2*
      ENNReal.ofReal ((Real.sqrt (1-(t:ℝ)^2))⁻¹)^(2*n)
  have hB : B≠⊤ := ENNReal.mul_ne_top
    (ENNReal.mul_ne_top ENNReal.ofReal_ne_top (TensorSum.momentBudget_ne_top _ _ _ _))
      (ENNReal.pow_ne_top ENNReal.ofReal_ne_top)
  have hb : eLpNorm A 2 (interpolationLaw F x r T)≤B := by
    rw [he]
    exact terminalJacobian_iteratedDeriv_eLpNorm hF x hr hlam hl hT0 hT1 hd n t
      (by norm_num) (by norm_num)
  have hi := RMSIntegral.integral_norm_sq_le_of_eLpNorm hAc.aestronglyMeasurable hB hb
  have hh := gaussian_operator_sq A hAc.measurable hi.1 hi.2
  simpa only [B,ENNReal.toReal_mul,ENNReal.toReal_pow,
    ENNReal.toReal_ofReal (by positivity : 0≤r*((lam:ℝ)*r)*Real.exp (Real.pi^2/4)),
    ENNReal.toReal_ofReal (by positivity : 0≤(Real.sqrt (1-(t:ℝ)^2))⁻¹),
    terminalActionChain,A] using hh

end LogConcaveSampling

end

end

end OAI