lean/OAI/Probability/LogConcave/JetEstimates/ArrayMatrix.lean

import Mathlib
import OAI.Probability.LogConcave.Sampling.TransportMajorant
import OAI.Probability.LogConcave.JetEstimates.ArrayRelabel
import OAI.Probability.LogConcave.Sampling.TerminalJacobianInverse

namespace OAI

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

namespace TensorEnergy

def arrayMatrix {d : ℕ} (a : (Unit ⊕ Unit → Fin d) → ℝ) : Point d →L[ℝ] Point d :=
  ∑i, ∑j, a (Sum.elim (fun _ => i) (fun _ => j)) • coordinateRankOne d i j

lemma matrixArray_arrayMatrix {d : ℕ} (a : (Unit ⊕ Unit → Fin d) → ℝ) :
    matrixArray d (arrayMatrix a) = a := by
  funext c
  simp only [matrixArray_apply,arrayMatrix,sum_apply,
    smul_apply,coordinateRankOne,ContinuousLinearMap.smulRight_apply,
    real_inner_smul_right,inner_sum,innerSL_apply_apply]
  simp only [orthonormal_iff_ite.mp (EuclideanSpace.basisFun (Fin d) ℝ).orthonormal,
    mul_ite,mul_one,mul_zero]
  simp only [Finset.sum_ite_irrel,Finset.sum_const_zero,Finset.sum_ite_eq',Finset.sum_ite_eq,
    Finset.mem_univ,ite_true]
  congr 1
  funext s
  cases s with
  | inl u => cases u; rfl
  | inr u => cases u; rfl

lemma matrixArray_injective (d : ℕ) : Function.Injective (matrixArray d) := by
  intro A B h
  apply ContinuousLinearMap.coe_injective
  apply (EuclideanSpace.basisFun (Fin d) ℝ).toBasis.ext
  intro j
  apply PiLp.ext
  intro i
  change (A (EuclideanSpace.basisFun (Fin d) ℝ j)).ofLp i =
    (B (EuclideanSpace.basisFun (Fin d) ℝ j)).ofLp i
  have hh := congrFun h (Sum.elim (fun _ => i) (fun _ => j))
  simpa only [matrixArray_apply,Sum.elim_inl,Sum.elim_inr,
    EuclideanSpace.basisFun_apply,EuclideanSpace.inner_single_left,map_one,one_mul] using hh

lemma arrayMatrix_matrixArray {d : ℕ} (A : Point d →L[ℝ] Point d) :
    arrayMatrix (matrixArray d A) = A :=
  matrixArray_injective d (matrixArray_arrayMatrix _)

lemma arrayMatrix_add {d : ℕ} (a b : (Unit ⊕ Unit → Fin d) → ℝ) :
    arrayMatrix (a+b)=arrayMatrix a+arrayMatrix b := by
  apply matrixArray_injective d
  simp only [matrixArray_arrayMatrix,map_add]

lemma arrayMatrix_smul {d : ℕ} (c : ℝ) (a : (Unit ⊕ Unit → Fin d) → ℝ) :
    arrayMatrix (c • a)=c • arrayMatrix a := by
  apply matrixArray_injective d
  simp only [matrixArray_arrayMatrix,map_smul]
end TensorEnergy

namespace TensorSum

def matrixEval {d : ℕ} (A : TensorSum (Unit ⊕ Unit)) (F : Point d → ℝ)
    (x : Point d) (r L : ℝ) (p : ℝ × Point d) : Point d →L[ℝ] Point d :=
  TensorEnergy.arrayMatrix (fun c => A.eval F x r L c p)

lemma matrixEval_add {d : ℕ} (A B : TensorSum (Unit ⊕ Unit)) (F : Point d → ℝ)
    (x : Point d) (r L : ℝ) (p : ℝ × Point d) :
    (A.add B).matrixEval F x r L p=A.matrixEval F x r L p+B.matrixEval F x r L p := by
  simp only [matrixEval,add_eval]
  exact TensorEnergy.arrayMatrix_add _ _

lemma matrixEval_scale {d : ℕ} (A : TensorSum (Unit ⊕ Unit)) (n : ℕ) (P : Polynomial ℝ)
    (F : Point d → ℝ) (x : Point d) (r L : ℝ) (p : ℝ × Point d) :
    (A.scale n P).matrixEval F x r L p=
      ((r*L)^n*P.eval p.1) • A.matrixEval F x r L p := by
  simp only [matrixEval,scale_eval]
  exact TensorEnergy.arrayMatrix_smul _ _

def matrixComp (A B : TensorSum (Unit ⊕ Unit)) : TensorSum (Unit ⊕ Unit) :=
  A.contract (B.relabel (Equiv.sumComm Unit Unit))

lemma matrixComp_weight {A B : TensorSum (Unit ⊕ Unit)} {u v : ℕ}
    (hA : A.weightLE u) (hB : B.weightLE v) : (A.matrixComp B).weightLE (u+v) :=
  weightLE_contract hA (weightLE_relabel hB _)

lemma matrixEval_comp {d : ℕ} (A B : TensorSum (Unit ⊕ Unit)) (F : Point d → ℝ)
    (x : Point d) (r L : ℝ) (p : ℝ × Point d) :
    (A.matrixComp B).matrixEval F x r L p=
      (A.matrixEval F x r L p).comp (B.matrixEval F x r L p) := by
  apply TensorEnergy.matrixArray_injective d
  funext c
  rw [matrixEval,TensorEnergy.matrixArray_arrayMatrix]
  rw [TensorEnergy.matrixArray_comp]
  simp only [matrixComp,contract_eval,relabel_eval,matrixEval,
    TensorEnergy.matrixArray_arrayMatrix]
  rfl

lemma matrixEval_smoothAt {d : ℕ} {F : Point d → ℝ} {lam : ℝ≥0}
    (hF : Primitive F lam) (x : Point d) {r ρ : ℝ} (hr : 0<r)
    (hlam : 0<lam) (hl : (lam:ℝ)*r^2≤1/2) (h0 : -1<ρ) (h1 : ρ<1)
    (A : TensorSum (Unit ⊕ Unit)) (y : Point d) :
    ContDiffAt ℝ (⊤:ℕ∞) (A.matrixEval F x r ((lam:ℝ)*r)) (ρ,y) := by
  unfold matrixEval TensorEnergy.arrayMatrix
  apply ContDiffAt.sum
  intro i _
  apply ContDiffAt.sum
  intro j _
  exact (A.timeSmooth hF x hr hlam hl _ (ρ,y) h0 h1).smul contDiffAt_const

lemma HasMaterial.matrixEval_path {A D : TensorSum (Unit ⊕ Unit)} (hA : A.HasMaterial D)
    {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) (h0 : 0<ρ) (hT : ρ<T) (y : Point d) :
    HasDerivAt (fun t => A.matrixEval F x r ((lam:ℝ)*r)
      (t,terminalBackward hF x hr.le hl hT0 hT1 (t,y)))
      (D.matrixEval F x r ((lam:ℝ)*r)
        (ρ,terminalBackward hF x hr.le hl hT0 hT1 (ρ,y))) ρ := by
  unfold matrixEval TensorEnergy.arrayMatrix
  apply HasDerivAt.fun_sum
  intro i _
  apply HasDerivAt.fun_sum
  intro j _
  have hS := (A.timeSmooth hF x hr hlam hl
    (Sum.elim (fun _ => i) (fun _ => j))
    (ρ,terminalBackward hF x hr.le hl hT0 hT1 (ρ,y)) (by dsimp; linarith)
    (hT.trans hT1)).differentiableAt (by simp)
  have hd := hS.hasFDerivAt.comp_hasDerivAt ρ ((hasDerivAt_id ρ).prodMk
    (terminalBackward_deriv hF x hr hl hT0 hT1 h0 hT y))
  rw [joint_material_direction F x r hS,hA hF x hr hlam hl h0.le (hT.trans hT1)] at hd
  exact hd.smul_const (coordinateRankOne d i j)

def firstMatrix : TensorSum (Unit ⊕ Unit) :=
  (pure (TensorAtom.jetList [()] (by simp) (by intro u; cases u; simp) (by simp))).relabel
    (Equiv.sumComm Unit Unit)

lemma firstMatrix_weight : firstMatrix.weightLE 0 := by
  apply weightLE_relabel
  apply weightLE_pure
  simp only [TensorAtom.jetList_weight,List.length_singleton,Nat.sub_self,le_refl]

lemma firstMatrix_eval {d : ℕ} (F : Point d → ℝ) (x : Point d) (r L : ℝ)
    (p : ℝ × Point d) :
    firstMatrix.matrixEval F x r L p=L⁻¹ • conditionalFirstJet F x r L p := by
  apply TensorEnergy.matrixArray_injective d
  funext c
  rw [matrixEval,TensorEnergy.matrixArray_arrayMatrix,map_smul]
  simp only [firstMatrix,relabel_eval,pure_eval,TensorAtom.jetList_eval,
    Equiv.sumComm_apply,Function.comp_apply,Sum.swap_inl,Sum.swap_inr,Pi.smul_apply,
    smul_eq_mul]
  rw [matrixArray_firstJet]
  rfl
end TensorSum

namespace TensorSum

def material {S : Type} (A : TensorSum S) {w : ℕ} (hw : A.weightLE w) : TensorSum S :=
  Classical.choose (A.hasMaterial hw)
lemma material_weight {S : Type} (A : TensorSum S) {w : ℕ} (hw : A.weightLE w) :
    (A.material hw).weightLE (w+2) := (Classical.choose_spec (A.hasMaterial hw)).1
lemma material_spec {S : Type} (A : TensorSum S) {w : ℕ} (hw : A.weightLE w) :
    A.HasMaterial (A.material hw) := (Classical.choose_spec (A.hasMaterial hw)).2

def terminalQ : (n : ℕ) → {A : TensorSum (Unit ⊕ Unit) // A.weightLE (2*n)}
  | 0 => ⟨firstMatrix.scale 0 Polynomial.X,weightLE_scale firstMatrix_weight _ _⟩
  | n+1 =>
    let Q := terminalQ n
    ⟨((firstMatrix.matrixComp Q.val).scale 1 Polynomial.X).add (Q.val.material Q.property),
      weightLE_add
        (weightLE_mono (weightLE_scale (matrixComp_weight firstMatrix_weight Q.property) _ _)
          (by omega))
        (weightLE_mono (Q.val.material_weight Q.property) (by omega))⟩

lemma terminalQ_zero_eval {d : ℕ} (F : Point d → ℝ) (x : Point d) (r L : ℝ)
    (p : ℝ × Point d) :
    (terminalQ 0).val.matrixEval F x r L p = (p.1*L⁻¹) • conditionalFirstJet F x r L p := by
  rw [terminalQ,matrixEval_scale,firstMatrix_eval]
  simp only [pow_zero,one_mul,Polynomial.eval_X,smul_smul]

lemma terminalQ_succ_eval {d : ℕ} (n : ℕ) (F : Point d → ℝ) (x : Point d) (r L : ℝ)
    (p : ℝ × Point d) :
    (terminalQ (n+1)).val.matrixEval F x r L p =
      ((r*L)*p.1) • ((firstMatrix.matrixEval F x r L p).comp
        ((terminalQ n).val.matrixEval F x r L p)) +
      ((terminalQ n).val.material (terminalQ n).property).matrixEval F x r L p := by
  conv_lhs => unfold terminalQ
  rw [matrixEval_add,matrixEval_scale,matrixEval_comp]
  simp only [pow_one,Polynomial.eval_X]
end TensorSum

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)

include hlam

lemma terminalJacobian_first_Q {ρ : ℝ} (h0 : 0<ρ) (hT : ρ<T) (y : Point d) :
    HasDerivAt (fun t => terminalJacobian hF x hr hl hT0 hT1 (t,y))
      ((r*((lam:ℝ)*r)) • (terminalJacobian hF x hr hl hT0 hT1 (ρ,y)).comp
        ((TensorSum.terminalQ 0).val.matrixEval F x r ((lam:ℝ)*r)
          (ρ,terminalBackward hF x hr.le hl hT0 hT1 (ρ,y)))) ρ := by
  have hL : (lam:ℝ)*r≠0 := mul_ne_zero (ne_of_gt hlam) hr.ne'
  convert terminalJacobian_deriv hF x hr hlam hl hT0 hT1 h0 hT y using 1
  rw [TensorSum.terminalQ_zero_eval,ContinuousLinearMap.comp_smul,smul_smul]
  congr 1
  field_simp [ne_of_gt (show (0:ℝ)<lam from hlam),hr.ne']

lemma terminalJacobian_Q_deriv (n : ℕ) {ρ : ℝ} (h0 : 0<ρ) (hT : ρ<T) (y : Point d) :
    HasDerivAt (fun t => (r*((lam:ℝ)*r)) •
      (terminalJacobian hF x hr hl hT0 hT1 (t,y)).comp
        ((TensorSum.terminalQ n).val.matrixEval F x r ((lam:ℝ)*r)
          (t,terminalBackward hF x hr.le hl hT0 hT1 (t,y))))
      ((r*((lam:ℝ)*r)) • (terminalJacobian hF x hr hl hT0 hT1 (ρ,y)).comp
        ((TensorSum.terminalQ (n+1)).val.matrixEval F x r ((lam:ℝ)*r)
          (ρ,terminalBackward hF x hr.le hl hT0 hT1 (ρ,y)))) ρ := by
  let Q := (TensorSum.terminalQ n).val
  have hD := TensorSum.HasMaterial.matrixEval_path (Q.material_spec (TensorSum.terminalQ n).property)
    hF x hr hlam hl hT0 hT1 h0 hT y
  have hB := terminalJacobian_deriv hF x hr hlam hl hT0 hT1 h0 hT y
  have hh := (hB.clm_comp hD).const_smul (r*((lam:ℝ)*r))
  convert hh using 1; try rfl
  rw [TensorSum.terminalQ_succ_eval,TensorSum.firstMatrix_eval,
    ContinuousLinearMap.comp_add,ContinuousLinearMap.comp_smul,
    ContinuousLinearMap.smul_comp,ContinuousLinearMap.comp_smul,
    ContinuousLinearMap.smul_comp,ContinuousLinearMap.comp_assoc,smul_smul]
  congr 2
  have hL : (lam:ℝ)*r≠0 := mul_ne_zero (ne_of_gt hlam) hr.ne'
  congr 1
  field_simp [ne_of_gt (show (0:ℝ)<lam from hlam),hr.ne']

theorem terminalJacobian_iteratedDeriv_Q (n : ℕ) {ρ : ℝ} (h0 : 0<ρ) (hT : ρ<T)
    (y : Point d) :
    iteratedDeriv (n+1) (fun t => terminalJacobian hF x hr hl hT0 hT1 (t,y)) ρ =
      (r*((lam:ℝ)*r)) • (terminalJacobian hF x hr hl hT0 hT1 (ρ,y)).comp
        ((TensorSum.terminalQ n).val.matrixEval F x r ((lam:ℝ)*r)
          (ρ,terminalBackward hF x hr.le hl hT0 hT1 (ρ,y))) := by
  induction n generalizing ρ with
  | zero =>
    rw [zero_add,iteratedDeriv_one]
    exact (terminalJacobian_first_Q hF x hr hlam hl hT0 hT1 h0 hT y).deriv
  | succ n ih =>
    rw [iteratedDeriv_succ]
    have he : iteratedDeriv (n+1) (fun t => terminalJacobian hF x hr hl hT0 hT1 (t,y)) =ᶠ[nhds ρ]
        (fun t => (r*((lam:ℝ)*r)) • (terminalJacobian hF x hr hl hT0 hT1 (t,y)).comp
          ((TensorSum.terminalQ n).val.matrixEval F x r ((lam:ℝ)*r)
            (t,terminalBackward hF x hr.le hl hT0 hT1 (t,y)))) := by
      filter_upwards [Ioo_mem_nhds h0 hT] with t ht
      exact ih ht.1 ht.2
    rw [he.deriv_eq]
    exact (terminalJacobian_Q_deriv hF x hr hlam hl hT0 hT1 n h0 hT y).deriv

theorem terminalJacobian_iteratedDeriv_Q_closed (hTpos : 0<T) (n : ℕ)
    (ρ : Icc (0:ℝ) T) (y : Point d) :
    iteratedDeriv (n+1) (fun t => terminalJacobian hF x hr hl hT0 hT1 (t,y)) ρ =
      (r*((lam:ℝ)*r)) • (terminalJacobian hF x hr hl hT0 hT1 (ρ,y)).comp
        ((TensorSum.terminalQ n).val.matrixEval F x r ((lam:ℝ)*r)
          (ρ,terminalBackward hF x hr.le hl hT0 hT1 (ρ,y))) := by
  let B := fun t => terminalJacobian hF x hr hl hT0 hT1 (t,y)
  let X := fun t => terminalBackward hF x hr.le hl hT0 hT1 (t,y)
  let H := fun t => (r*((lam:ℝ)*r)) • (B t).comp
    ((TensorSum.terminalQ n).val.matrixEval F x r ((lam:ℝ)*r) (t,X t))
  have hB : ContDiff ℝ (⊤:ℕ∞) B :=
    (terminalJacobian_smooth hF x hr hl hT0 hT1).comp (contDiff_id.prodMk contDiff_const)
  have hX : Continuous X :=
    (terminalBackward_smooth hF x hr.le hl hT0 hT1).continuous.comp
      (continuous_id.prodMk continuous_const)
  have hH : ContinuousOn H (Icc 0 T) := by
    intro t ht
    have hq := TensorSum.matrixEval_smoothAt hF x hr hlam hl
      (by linarith [ht.1] : -1<t) (ht.2.trans_lt hT1) (TensorSum.terminalQ n).val (X t)
    have hs : ContinuousAt (fun _ : ℝ => r*((lam:ℝ)*r)) t := continuousAt_const
    exact (hs.smul (hB.continuous.continuousAt.clm_comp
      (hq.continuousAt.comp (x:=t) (f:=fun u : ℝ => (u,X u))
        (continuousAt_id.prodMk hX.continuousAt)))).continuousWithinAt
  have hD : Continuous (iteratedDeriv (n+1) B) :=
    hB.continuous_iteratedDeriv (n+1) (by exact_mod_cast (le_top : ((n+1):ℕ∞)≤⊤))
  have hc : IsClosed {t | t∈Icc (0:ℝ) T ∧ iteratedDeriv (n+1) B t=H t} :=
    isClosed_Icc.isClosed_eq hD.continuousOn hH
  have hs : Ioo (0:ℝ) T ⊆ {t | t∈Icc (0:ℝ) T ∧ iteratedDeriv (n+1) B t=H t} := by
    intro t ht
    exact ⟨⟨ht.1.le,ht.2.le⟩,terminalJacobian_iteratedDeriv_Q hF x hr hlam hl hT0 hT1 n ht.1 ht.2 y⟩
  have hh := closure_minimal hs hc
  rw [closure_Ioo hTpos.ne] at hh
  exact (hh ρ.2).2
end LogConcaveSampling

end

end

section

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

namespace TensorEnergy
lemma matrixArray_mulVec {d : ℕ} (A : Point d →L[ℝ] Point d) (v : Point d) :
    (fun i => ∑j,matrixArray d A (Sum.elim (fun _ => i) (fun _ => j))*v.ofLp j) =
      (A v).ofLp := by
  funext i
  have hv : ∑j,v.ofLp j • EuclideanSpace.basisFun (Fin d) ℝ j=v := by
    simpa only [OrthonormalBasis.repr_apply_apply,EuclideanSpace.basisFun_apply,
      EuclideanSpace.inner_single_left,map_one,one_mul] using
      (EuclideanSpace.basisFun (Fin d) ℝ).sum_repr v
  have hh := congrArg (fun z => inner ℝ (EuclideanSpace.basisFun (Fin d) ℝ i) (A z)) hv
  simpa only [map_sum,map_smul,inner_sum,real_inner_smul_right,
    matrixArray_apply,Sum.elim_inl,Sum.elim_inr,EuclideanSpace.basisFun_apply,
    EuclideanSpace.inner_single_left,map_one,one_mul,mul_comm,WithLp.ofLp_smul,Pi.smul_apply,smul_eq_mul] using hh

lemma AllSplitBound.matrixArray_norm_le {d : ℕ} {A : Point d →L[ℝ] Point d}
    {M : ℝ} (h : AllSplitBound (matrixArray d A) M) (hM : 0≤M) : ‖A‖≤M := by
  have hb := (h Unit Unit (Equiv.sumComm Unit Unit)).reindex
    (Equiv.funUnique Unit (Fin d)).symm (Equiv.funUnique Unit (Fin d)).symm
  change Bound (fun i j => matrixArray d A (Sum.elim (fun _ => i) (fun _ => j))) (M^2) at hb
  apply ContinuousLinearMap.opNorm_le_bound _ hM
  intro v
  apply (sq_le_sq₀ (norm_nonneg _) (mul_nonneg hM (norm_nonneg v))).mp
  have hv := hb v.ofLp
  have he (i : Fin d) := congrFun (matrixArray_mulVec A v) i
  dsimp only at he
  simp_rw [he] at hv
  simpa only [←EuclideanSpace.real_norm_sq_eq,mul_pow] using hv

lemma AllSplitBound.of_spatialTensor_zero {d : ℕ} {S : Type} [Fintype S]
    (f : (S → Fin d) → Point d → ℝ) (y : Point d) {M : ℝ}
    (h : AllSplitBound (spatialTensor f (List.finRange 0) y) M) :
    AllSplitBound (fun c => f c y) M := by
  let e : Fin 0 ⊕ S ≃ S :=
    ⟨Sum.elim Fin.elim0 id,Sum.inr,by rintro (a|a); exact Fin.elim0 a; rfl,by intro a; rfl⟩
  have hh := h.reindex e
  change AllSplitBound (fun c => f (fun s => c s) y) M at hh
  exact hh

end TensorEnergy
end LogConcaveSampling

end

end

section

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

namespace TensorSum
lemma matrixEval_norm_le {d : ℕ} {F : Point d → ℝ} {lam : ℝ≥0}
    (hF : Primitive F lam) (x : Point d) {r ρ : ℝ} (hr : 0<r)
    (hlam : 0<lam) (hl : (lam:ℝ)*r^2≤1/2) (h0 : 0≤ρ) (h1 : ρ<1)
    (A : TensorSum (Unit ⊕ Unit)) (y : Point d) :
    ‖A.matrixEval F x r ((lam:ℝ)*r) (ρ,y)‖≤A.spatialBound F x r ρ ((lam:ℝ)*r) 0 y := by
  have hh := (A.spatialBound_allSplit hF x hr hlam hl h0 h1 0 y).of_spatialTensor_zero
    (A.slice F x r ρ ((lam:ℝ)*r)) y
  apply TensorEnergy.AllSplitBound.matrixArray_norm_le _ (A.spatialBound_nonneg _ _ _ _ _ _ _)
  simpa only [matrixEval,TensorEnergy.matrixArray_arrayMatrix,slice] using hh
end TensorSum

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)

lemma terminalBackward_measurePreserving (t : Icc (0:ℝ) T) :
    MeasurePreserving (fun y => terminalBackward hF x hr.le hl hT0.le hT1 (t,y))
      (interpolationLaw F x r T) (interpolationLaw F x r t) := by
  have he : (fun y => terminalBackward hF x hr.le hl hT0.le hT1 (t,y))=
      probabilityTransport hF x hr.le hl hT0.le hT1 ⟨T,hT0.le,le_rfl⟩ t :=
    funext (terminalBackward_eq hF x hr.le hl hT0.le hT1 t)
  rw [he]
  exact ⟨(probabilityTransport_continuous hF x hr.le hl hT0.le hT1 _ _).measurable,
    probabilityTransport_pushforward hF x hr.le hl hT0.le hT1 _ _⟩

include hlam in
lemma terminalJacobian_iteratedDeriv_norm_le (n : ℕ) (t : Icc (0:ℝ) T) (y : Point d) :
    ‖iteratedDeriv (n+1) (fun s => terminalJacobian hF x hr hl hT0.le hT1 (s,y)) t‖≤
      (r*((lam:ℝ)*r)*Real.exp (Real.pi^2/4))*
        (TensorSum.terminalQ n).val.spatialBound F x r t ((lam:ℝ)*r) 0
          (terminalBackward hF x hr.le hl hT0.le hT1 (t,y)) := by
  rw [terminalJacobian_iteratedDeriv_Q_closed hF x hr hlam hl hT0.le hT1 hT0,
    norm_smul,Real.norm_eq_abs,abs_of_nonneg (by positivity : 0≤r*((lam:ℝ)*r))]
  apply (mul_le_mul_of_nonneg_left (ContinuousLinearMap.opNorm_comp_le _ _) (by positivity)).trans
  have hb := mul_le_mul (terminalJacobian_norm_le hF x hr hl hT0.le hT1 t y)
    (TensorSum.matrixEval_norm_le hF x hr hlam hl t.2.1 (t.2.2.trans_lt hT1)
      (TensorSum.terminalQ n).val (terminalBackward hF x hr.le hl hT0.le hT1 (t,y)))
    (norm_nonneg _) (Real.exp_pos _).le
  simpa only [mul_assoc] using mul_le_mul_of_nonneg_left hb
    (show 0≤r*((lam:ℝ)*r) by positivity)

include hlam in

theorem terminalJacobian_iteratedDeriv_eLpNorm (hd : 1≤d) (n : ℕ)
    (t : Icc (0:ℝ) T) {p : ℝ≥0∞} (hp : 1≤p) (hpf : p≠⊤) :
    eLpNorm (fun y => iteratedDeriv (n+1)
      (fun s => terminalJacobian hF x hr hl hT0.le hT1 (s,y)) t) p
      (interpolationLaw F x r T)≤
      ENNReal.ofReal (r*((lam:ℝ)*r)*Real.exp (Real.pi^2/4))*
        ((TensorSum.terminalQ n).val.momentBudget d 0 p)*
        ENNReal.ofReal ((Real.sqrt (1-(t:ℝ)^2))⁻¹)^(2*n) := by
  let A := (TensorSum.terminalQ n).val
  let g := fun y => terminalBackward hF x hr.le hl hT0.le hT1 (t,y)
  let V := A.spatialBound F x r t ((lam:ℝ)*r) 0
  let c := r*((lam:ℝ)*r)*Real.exp (Real.pi^2/4)
  have hV : AEStronglyMeasurable V (interpolationLaw F x r t) := (A.spatialBound_measurable hF x hr hlam hl t.2.1 (t.2.2.trans_lt hT1) 0).aestronglyMeasurable
  have hDerivative : Continuous (fun y => iteratedDeriv (n+1)
      (fun s => terminalJacobian hF x hr hl hT0.le hT1 (s,y)) t) := by
    simp_rw [terminalJacobian_iteratedDeriv_Q_closed hF x hr hlam hl hT0.le hT1 hT0]
    have hJacobian : Continuous (fun point : Point d =>
        terminalJacobian hF x hr hl hT0.le hT1 ((t:ℝ),point)) :=
      (terminalJacobian_smooth hF x hr hl hT0.le hT1).continuous.comp
        (continuous_const.prodMk continuous_id)
    have hBackward : Continuous g :=
      (terminalBackward_smooth hF x hr.le hl hT0.le hT1).continuous.comp
        (continuous_const.prodMk continuous_id)
    apply continuous_iff_continuousAt.mpr
    intro point
    have hMatrix := TensorSum.matrixEval_smoothAt hF x hr hlam hl
      (by linarith [t.2.1] : -1<(t:ℝ)) (t.2.2.trans_lt hT1)
      (TensorSum.terminalQ n).val (g point)
    have hScalar : ContinuousAt (fun _ : Point d => r*((lam:ℝ)*r)) point :=
      continuousAt_const
    exact hScalar.smul (hJacobian.continuousAt.clm_comp
      (hMatrix.continuousAt.comp (x:=point) (f:=fun value : Point d => ((t:ℝ),g value))
        (continuousAt_const.prodMk hBackward.continuousAt)))
  have hb := eLpNorm_mono_real (μ:=interpolationLaw F x r T) (p:=p)
    hDerivative.aestronglyMeasurable
    (terminalJacobian_iteratedDeriv_norm_le hF x hr hlam hl hT0 hT1 n t)
  have he : (fun y => c*V (g y))=c • (V ∘ g) := rfl
  change _ ≤ eLpNorm (fun y => c*V (g y)) p _ at hb
  rw [he,eLpNorm_const_smul,
    eLpNorm_comp_measurePreserving hV (terminalBackward_measurePreserving hF x hr hl hT0 hT1 t),
    Real.enorm_eq_ofReal_abs,abs_of_nonneg (by positivity : 0≤c)] at hb
  apply hb.trans
  rw [mul_assoc]
  apply mul_le_mul' le_rfl
  simpa only [Nat.add_zero] using A.spatialBound_Lp hF x hr hlam hl t.2.1
    (t.2.2.trans_lt hT1) hd (TensorSum.terminalQ n).property 0 hp hpf
end LogConcaveSampling

end

end

end OAI