import Mathlib
import OAI.Probability.LogConcave.Sampling.TerminalBackward
import OAI.Probability.LogConcave.Numerics.ParametricFDeriv
import OAI.Probability.LogConcave.Sampling.JointU
import OAI.Probability.LogConcave.Sampling.ConditionalPositionMoment
import OAI.Probability.LogConcave.Sampling.JointConditionalLawProperties
import OAI.Probability.LogConcave.JetEstimates.JetNormalizedLaplaceMoments

namespace OAI

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

lemma conditionalU_moments_sq {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) (hρ : ρ^2<1)
    {ι : Type*} [DecidableEq ι] (v : ι → Point d) (l : List ι) (hlN : l.Nodup) (u y : Point d) :
    conditionalU F x r ρ y u ((lam:ℝ)*r) v l=
      ((1-ρ^2)^l.length)⁻¹*∑s∈l.toFinset.powerset,
        Appell.inverseMoment (fun t => conditionalPositionMoment F x r v t (ρ,y)) s*
          conditionalMixedMoment F x r u v (l.toFinset\s) (ρ,y) := by
  let := conditionalLaw_probability_sq hF x hr.le hl hρ y
  rw [conditionalU_normalized_jet_sq hF x hr hlam hl hρ]
  rw [Appell.jet_normalizedLaplace_zero_moments
    (conditionalLaw_hasExpMoments_sq hF x hr.le hl hρ y)
    (continuous_const.inner (primitiveField_contDiff hF x r).continuous)
    (primitiveField_inner_growth hF x u hr.le) v l hlN]
  rfl

theorem conditionalU_joint_smooth {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)
    {ι : Type*} [DecidableEq ι] (v : ι → Point d) (l : List ι) (hlN : l.Nodup)
    (u : Point d) (p : ℝ × Point d) (hp : p.1^2<1) :
    ContDiffAt ℝ (⊤:ℕ∞) (fun q : ℝ × Point d => conditionalU F x r q.1 q.2 u ((lam:ℝ)*r) v l) p := by
  have hl' : (lam:ℝ)*r^2<1 := by linarith
  have hM (s : Finset ι) := conditionalPositionMoment_smooth hF x hr.le hl' v s p hp
  have hI (s : Finset ι) := Appell.inverseMoment_contDiffAt hM s
  have hX (s : Finset ι) := conditionalMixedMoment_smooth hF x hr.le hl' u v s p hp
  have hS : ContDiffAt ℝ (⊤:ℕ∞)
      (fun q => ∑s∈l.toFinset.powerset,
        Appell.inverseMoment (fun t => conditionalPositionMoment F x r v t q) s*
          conditionalMixedMoment F x r u v (l.toFinset\s) q) p :=
    ContDiffAt.sum (fun s _ => (hI s).mul (hX _))
  have hA : ContDiffAt ℝ (⊤:ℕ∞) (fun q : ℝ × Point d => ((1-q.1^2)^l.length)⁻¹) p :=
    ((contDiffAt_const.sub (contDiffAt_fst.pow 2)).pow _).inv
      (pow_ne_zero _ (by linarith))
  apply (hA.mul hS).congr_of_eventuallyEq
  filter_upwards [(isOpen_lt (continuous_fst.pow 2) continuous_const).mem_nhds hp] with q hq
  exact conditionalU_moments_sq hF x hr hlam hl hq v l hlN u q.2

lemma jointU_timeSmooth {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)
    {ι : Type*} [DecidableEq ι] (v : ι → Point d) (l : List ι) (hlN : l.Nodup) (i : Fin d) :
    JetCalculus.TimeSmooth (jointU F x r ((lam:ℝ)*r) v l i) := by
  intro p h0 h1
  exact conditionalU_joint_smooth hF x hr hlam hl v l hlN _ p (by nlinarith)

end LogConcaveSampling

end

end

section

noncomputable section
namespace LogConcaveSampling
open Set Function Filter MeasureTheory
open scoped Topology NNReal RealInnerProductSpace

def coordinateRankOne (d : ℕ) (i j : Fin d) : Point d →L[ℝ] Point d :=
  (innerSL ℝ (EuclideanSpace.basisFun (Fin d) ℝ j)).smulRight
    (EuclideanSpace.basisFun (Fin d) ℝ i)

def conditionalFirstJet {d : ℕ} (F : Point d → ℝ) (x : Point d) (r L : ℝ)
    (p : ℝ × Point d) : Point d →L[ℝ] Point d :=
  ∑i,∑j,conditionalU F x r p.1 p.2 (EuclideanSpace.basisFun (Fin d) ℝ i) L
    (fun _ : Unit => EuclideanSpace.basisFun (Fin d) ℝ j) [()] • coordinateRankOne d i j

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 hF hr hlam hl in
lemma conditionalFirstJet_smooth (p : ℝ × Point d) (hp : p.1^2<1) :
    ContDiffAt ℝ (⊤:ℕ∞) (conditionalFirstJet F x r ((lam:ℝ)*r)) p := by
  apply ContDiffAt.sum
  intro i _
  apply ContDiffAt.sum
  intro j _
  exact (conditionalU_joint_smooth hF x hr hlam hl
    (fun _ : Unit => EuclideanSpace.basisFun (Fin d) ℝ j) [()] (by simp)
    (EuclideanSpace.basisFun (Fin d) ℝ i) p hp).smul contDiffAt_const

def terminalJacobian (p : ℝ × Point d) : Point d →L[ℝ] Point d :=
  (fderiv ℝ (terminalForward hF x hr.le hl hT0 hT1)
    (smoothTimeClip hT0 hT1 p.1,terminalBackward hF x hr.le hl hT0 hT1 p)).comp
      (ContinuousLinearMap.inr ℝ ℝ (Point d))

lemma terminalJacobian_smooth : ContDiff ℝ (⊤:ℕ∞) (terminalJacobian hF x hr hl hT0 hT1) := by
  have hclip : ContDiff ℝ (⊤:ℕ∞) (smoothTimeClip hT0 hT1) :=
    contDiff_infty.mpr (smoothTimeClip_contDiff hT0 hT1)
  exact (((terminalForward_smooth hF x hr.le hl hT0 hT1).fderiv_right (by simp)).comp
    ((hclip.comp contDiff_fst).prodMk (terminalBackward_smooth hF x hr.le hl hT0 hT1))).clm_comp contDiff_const

def steinIntegrand (p : ℝ × Point d) : Point d →L[ℝ] Point d :=
  (terminalJacobian hF x hr hl hT0 hT1 p).comp
    (conditionalFirstJet F x r ((lam:ℝ)*r)
      (smoothTimeClip hT0 hT1 p.1,terminalBackward hF x hr.le hl hT0 hT1 p))

include hlam in
lemma steinIntegrand_smooth : ContDiff ℝ (⊤:ℕ∞) (steinIntegrand hF x hr hl hT0 hT1) := by
  have hclip : ContDiff ℝ (⊤:ℕ∞) (smoothTimeClip hT0 hT1) :=
    contDiff_infty.mpr (smoothTimeClip_contDiff hT0 hT1)
  have hU : ContDiff ℝ (⊤:ℕ∞) (fun p => conditionalFirstJet F x r ((lam:ℝ)*r)
      (smoothTimeClip hT0 hT1 p.1,terminalBackward hF x hr.le hl hT0 hT1 p)) := by
    apply contDiff_iff_contDiffAt.mpr
    intro p
    exact (conditionalFirstJet_smooth hF x hr hlam hl _ (smoothTimeClip_sq_lt hT0 hT1 p.1)).comp p
      ((hclip.comp contDiff_fst).prodMk (terminalBackward_smooth hF x hr.le hl hT0 hT1)).contDiffAt
  exact (terminalJacobian_smooth hF x hr hl hT0 hT1).clm_comp hU

def centeringKernel (y : Point d) : Point d →L[ℝ] Point d :=
  (∫ρ in Icc 0 T,steinIntegrand hF x hr hl hT0 hT1 (ρ,y)).adjoint

include hlam in
lemma centeringKernel_smooth : ContDiff ℝ (⊤:ℕ∞) (centeringKernel hF x hr hl hT0 hT1) := by
  let : CompleteSpace (Point d →L[ℝ] Point d) := ContinuousLinearMap.instCompleteSpace
  have hs := CompactIntegral.smooth_parametric
    ((steinIntegrand_smooth hF x hr hlam hl hT0 hT1).comp (contDiff_snd.prodMk contDiff_fst))
    (s:=Icc (0:ℝ) T) isCompact_Icc
  exact ContinuousLinearMap.adjoint.contDiff.comp hs
end LogConcaveSampling

end

end

section

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

lemma covariance_field_synthesis {d : ℕ} {μ : Measure (Point d)} [IsProbabilityMeasure μ]
    {f : Point d → ℝ} {g : Point d → Point d} (hf : MemLp f 2 μ)
    (hg : ∀u,MemLp (fun z => inner ℝ u (g z)) 2 μ) (v : Point d) :
    (∑i : Fin d,inner ℝ v ((EuclideanSpace.basisFun (Fin d) ℝ) i)*
      cov[f,(fun z => inner ℝ ((EuclideanSpace.basisFun (Fin d) ℝ) i) (g z));μ])=
      cov[f,(fun z => inner ℝ v (g z));μ] := by
  let b := EuclideanSpace.basisFun (Fin d) ℝ
  have hh := covariance_fun_sum_right
    (fun i : Fin d => (hg (b i)).const_mul (inner ℝ v (b i))) hf
  simp only [covariance_const_mul_right] at hh
  simpa only [b.sum_inner_mul_inner v] using hh.symm

variable {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) (hρ0 : 0≤ρ) (hρ1 : ρ<1)

include hF hr hlam hl hρ0 hρ1 in
lemma conditionalFirstJet_inner (u v y : Point d) :
    inner ℝ u (conditionalFirstJet F x r ((lam:ℝ)*r) (ρ,y) v)=
      (1/(1-ρ^2))*cov[(fun z => inner ℝ v z),
        (fun z => inner ℝ u (primitiveField F x r z));gibbs (conditionalPotential F x r ρ y)] := by
  let b := EuclideanSpace.basisFun (Fin d) ℝ
  let μ := gibbs (conditionalPotential F x r ρ y)
  let := conditionalLaw_probability hF x hr.le hl hρ0 hρ1 y
  have hm := conditionalLaw_hasExpMoments hF x hr.le hl hρ0 hρ1 y
  have hi (v : Point d) : MemLp (fun z => inner ℝ v z) 2 μ :=
    (Appell.HasGrowth.linear (innerSL ℝ v)).memLp (by fun_prop) hm.hasMoments
  have hg (u : Point d) : MemLp (fun z => inner ℝ u (primitiveField F x r z)) 2 μ :=
    (primitiveField_inner_growth hF x u hr.le).memLp
      (continuous_const.inner (primitiveField_contDiff hF x r).continuous).aestronglyMeasurable hm.hasMoments
  simp only [conditionalFirstJet,sum_apply,smul_apply,
    inner_sum,inner_smul_right,coordinateRankOne,ContinuousLinearMap.smulRight_apply,
    innerSL_apply_apply,conditionalU_one_cov hF x hr hlam hl hρ0 hρ1]
  change (∑i,∑j,(1/(1-ρ^2))*cov[(fun z => inner ℝ (b j) z),
    (fun z => inner ℝ (b i) (primitiveField F x r z));μ]*(inner ℝ (b j) v*inner ℝ u (b i)))=_
  calc
    _=(1/(1-ρ^2))*(∑i,inner ℝ u (b i)*(∑j,inner ℝ v (b j)*
        cov[(fun z => inner ℝ (b j) z),(fun z => inner ℝ (b i) (primitiveField F x r z));μ])) := by
      simp only [Finset.mul_sum]
      apply Finset.sum_congr rfl
      intro i _
      apply Finset.sum_congr rfl
      intro j _
      rw [real_inner_comm (b j) v]
      ring
    _=_ := by
      have hs (i : Fin d) := covariance_inner_synthesis hm (hg (b i)) v
      dsimp [μ,b] at hs ⊢
      simp only [hs]
      rw [covariance_field_synthesis (hi v) hg u]

include hF hr hlam hl hρ0 hρ1 in
lemma conditionalFirstJet_norm_le (y : Point d) :
    ‖conditionalFirstJet F x r ((lam:ℝ)*r) (ρ,y)‖≤(Real.pi^2/2)*((lam:ℝ)*r) := by
  have ha := (probability_time hρ0 hρ1).1
  apply ContinuousLinearMap.opNorm_le_bound _ (by positivity)
  intro v
  let w := conditionalFirstJet F x r ((lam:ℝ)*r) (ρ,y) v
  have he := conditionalFirstJet_inner hF x hr hlam hl hρ0 hρ1 w v y
  have hb := mul_le_mul_of_nonneg_left
    (conditional_covariance_le hF x hr.le hl hρ0 hρ1 w v y) (by positivity : 0≤1/(1-ρ^2))
  have hh : ‖w‖^2≤((Real.pi^2/2)*((lam:ℝ)*r))*‖w‖*‖v‖ := by
    rw [←real_inner_self_eq_norm_sq w,he]
    calc
      _≤(1/(1-ρ^2))*|cov[(fun z => inner ℝ v z),
          (fun z => inner ℝ w (primitiveField F x r z));gibbs (conditionalPotential F x r ρ y)]| :=
        mul_le_mul_of_nonneg_left (le_abs_self _) (by positivity)
      _≤_ := by convert! hb using 1; field_simp [ha.ne']
  change ‖w‖≤_
  by_cases hw : ‖w‖=0
  · rw [hw]; positivity
  · apply (mul_le_mul_iff_left₀ (lt_of_le_of_ne (norm_nonneg w) (Ne.symm hw))).mp
    convert! hh using 1 <;> ring

include hF hr hlam hl hρ0 hρ1 in
lemma conditionalFirstJet_deriv (y : Point d) :
    fderiv ℝ (conditionalFieldMean F x r ρ) y=
      ρ • conditionalFirstJet F x r ((lam:ℝ)*r) (ρ,y) := by
  apply ContinuousLinearMap.ext
  intro v
  apply ext_inner_left ℝ
  intro u
  simp only [smul_apply,inner_smul_right,
    conditionalFieldMean_inner_deriv hF x hr.le hl hρ0 hρ1,
    conditionalFirstJet_inner hF x hr hlam hl hρ0 hρ1]
  ring
end LogConcaveSampling

end

end

section

noncomputable section
namespace LogConcaveSampling
open MeasureTheory Set Function
open scoped NNReal Topology

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 terminalJacobian_eq (t : Icc (0:ℝ) T) (y : Point d) :
    terminalJacobian hF x hr hl hT0 hT1 (t,y)=
      fderiv ℝ (probabilityTransport hF x hr.le hl hT0 hT1 t ⟨T,hT0,le_rfl⟩)
        (terminalBackward hF x hr.le hl hT0 hT1 (t,y)) := by
  have hh := ((terminalForward_smooth hF x hr.le hl hT0 hT1).differentiable (by simp)
    ((t:ℝ),terminalBackward hF x hr.le hl hT0 hT1 (t,y))).hasFDerivAt.comp
    (terminalBackward hF x hr.le hl hT0 hT1 (t,y))
    ((hasFDerivAt_const (t:ℝ) _).prodMk (hasFDerivAt_id _))
  have he : (fun z => terminalForward hF x hr.le hl hT0 hT1 (t,z))=
      probabilityTransport hF x hr.le hl hT0 hT1 t ⟨T,hT0,le_rfl⟩ :=
    funext (terminalForward_eq hF x hr.le hl hT0 hT1 t)
  change HasFDerivAt (fun z => terminalForward hF x hr.le hl hT0 hT1 (t,z)) _ _ at hh
  rw [he] at hh
  change HasFDerivAt _ ((fderiv ℝ (terminalForward hF x hr.le hl hT0 hT1)
    ((t:ℝ),terminalBackward hF x hr.le hl hT0 hT1 (t,y))).comp
      (ContinuousLinearMap.inr ℝ ℝ (Point d))) _ at hh
  simpa only [terminalJacobian,smoothTimeClip_eq hT0 hT1 t.2] using hh.fderiv.symm

lemma terminalJacobian_norm_le (t : Icc (0:ℝ) T) (y : Point d) :
    ‖terminalJacobian hF x hr hl hT0 hT1 (t,y)‖≤Real.exp (Real.pi^2/4) := by
  rw [terminalJacobian_eq]
  have hb := norm_fderiv_le_of_lipschitz ℝ (x₀:=terminalBackward hF x hr.le hl hT0 hT1 (t,y))
    (GlobalODE.flow_lipschitz
      (fun u (_ : u∈Icc 0 T) => clampedProbabilityVelocity_lipschitz hF x hr.le hl hT0 hT1 u)
      (clampedProbabilityVelocity_continuous hF x hr.le hl hT0 hT1) t ⟨T,hT0,le_rfl⟩)
  apply hb.trans
  apply Real.exp_le_exp.mpr
  have ht : 0≤T-(t:ℝ) := sub_nonneg.mpr t.2.2
  rw [abs_of_nonneg ht]
  have htt : T-(t:ℝ)≤1 := by linarith [t.2.1]
  have hbase : (Real.pi^2/2)*(lam:ℝ)*r^2≤Real.pi^2/4 := by nlinarith [sq_nonneg Real.pi]
  exact (mul_le_of_le_one_right (by positivity : 0≤(Real.pi^2/2)*(lam:ℝ)*r^2) htt).trans hbase

include hlam in
lemma steinIntegrand_norm_le (t : Icc (0:ℝ) T) (y : Point d) :
    ‖steinIntegrand hF x hr hl hT0 hT1 (t,y)‖≤
      (Real.exp (Real.pi^2/4)*(Real.pi^2/2))*((lam:ℝ)*r) := by
  unfold steinIntegrand
  calc
    _≤‖terminalJacobian hF x hr hl hT0 hT1 (t,y)‖*
      ‖conditionalFirstJet F x r ((lam:ℝ)*r)
        (smoothTimeClip hT0 hT1 t,terminalBackward hF x hr.le hl hT0 hT1 (t,y))‖ :=
      ContinuousLinearMap.opNorm_comp_le _ _
    _≤Real.exp (Real.pi^2/4)*((Real.pi^2/2)*((lam:ℝ)*r)) := by
      rw [smoothTimeClip_eq hT0 hT1 t.2]
      exact mul_le_mul (terminalJacobian_norm_le hF x hr hl hT0 hT1 t y)
        (conditionalFirstJet_norm_le hF x hr hlam hl t.2.1 (t.2.2.trans_lt hT1) _)
        (norm_nonneg _) (Real.exp_pos _).le
    _=_ := by ring

include hlam in
theorem centeringKernel_norm_le (y : Point d) :
    ‖centeringKernel hF x hr hl hT0 hT1 y‖≤
      (Real.exp (Real.pi^2/4)*(Real.pi^2/2))*((lam:ℝ)*r) := by
  unfold centeringKernel
  rw [ContinuousLinearMap.adjoint.norm_map]
  have hb := norm_setIntegral_le_of_norm_le_const (μ:=volume)
    (s:=Icc (0:ℝ) T) (f:=fun t => steinIntegrand hF x hr hl hT0 hT1 (t,y))
    isCompact_Icc.measure_lt_top
    (fun t ht => steinIntegrand_norm_le hF x hr hlam hl hT0 hT1 ⟨t,ht⟩ y)
  apply hb.trans
  simp only [Measure.real,Real.volume_Icc,sub_zero,ENNReal.toReal_ofReal hT0]
  exact mul_le_of_le_one_right (by positivity) hT1.le
end LogConcaveSampling

end

end

section

noncomputable section
namespace LogConcaveSampling
open Filter
open scoped Topology Classical BigOperators

lemma eq_zero_of_continuous_pos {f g : ℝ → ℝ}
    (hf : ContinuousAt f 0) (hg : ContinuousAt g 0)
    (he : ∀t,0<t → t<1 → f t=g t) : f 0=g 0 := by
  have hfg : f=ᶠ[nhdsWithin 0 (Set.Ioi 0)]g := by
    filter_upwards [self_mem_nhdsWithin,nhdsWithin_le_nhds (Iio_mem_nhds (by norm_num : (0:ℝ)<1))] with t h0 h1
    exact he t h0 h1
  exact tendsto_nhds_unique (hf.mono_left nhdsWithin_le_nhds)
    ((hg.mono_left nhdsWithin_le_nhds).congr' hfg.symm)

namespace JetCalculus
variable {E : Type*} [NormedAddCommGroup E] [NormedSpace ℝ E]
variable {ι : Type*} [Fintype ι]
lemma smooth_gadj_at (b : ι → E) {s V : ι → E → ℝ} {p : E}
    (hs : ∀i,ContDiffAt ℝ (⊤:ℕ∞) (s i) p) (hV : ∀i,ContDiffAt ℝ (⊤:ℕ∞) (V i) p) :
    ContDiffAt ℝ (⊤:ℕ∞) (gadj b s V) p :=
  ContDiffAt.sum (fun i _ => smooth_cadj_at (b i) (hs i) (hV i))
end JetCalculus

lemma extra_list_nodup {ι : Type*} {l : List ι} (hl : l.Nodup) :
    (Sum.inr ()::l.map (Sum.inl (β:=Unit))).Nodup := by
  simp only [List.nodup_cons]
  refine ⟨?_,hl.map Sum.inl_injective⟩
  simp

end LogConcaveSampling

end

end

section

noncomputable section
namespace LogConcaveSampling
open Filter
open scoped Topology Classical BigOperators NNReal RealInnerProductSpace

theorem material_jointU {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) (hρ0 : 0≤ρ) (hρ1 : ρ<1)
    {κ : Type*} [DecidableEq κ] (v : κ → Point d) (l : List κ) (hlN : l.Nodup)
    (i : Fin d) (y : Point d) :
    JetCalculus.mdir (1,0) jointSpace r (jointMean F x r)
      (jointU F x r ((lam:ℝ)*r) v l i) (ρ,y)=
      JetCalculus.gadj jointSpace (jointScore F x r)
        (fun k => jointU F x r ((lam:ℝ)*r)
          (Sum.elim v (fun _ : Unit => JetCalculus.spaceBasis d k))
            (Sum.inr ()::l.map Sum.inl) i) (ρ,y)+
      2*r*ρ*∑s∈l.toFinset.powerset.erase ∅,∑k,
        jointU F x r ((lam:ℝ)*r) v (l.filter (fun j => j∈s)) k (ρ,y)*
          jointU F x r ((lam:ℝ)*r) (Sum.elim v (fun _ : Unit => JetCalculus.spaceBasis d k))
            (Sum.inr ()::(l.filter (fun j => j∉s)).map Sum.inl) i (ρ,y) := by
  let U := jointU F x r ((lam:ℝ)*r) v l i
  let V := fun k => jointU F x r ((lam:ℝ)*r)
    (Sum.elim v (fun _ : Unit => JetCalculus.spaceBasis d k)) (Sum.inr ()::l.map Sum.inl) i
  let A := JetCalculus.mdir (1,0) jointSpace r (jointMean F x r) U
  let B := fun p : ℝ × Point d => JetCalculus.gadj jointSpace (jointScore F x r) V p+
    2*r*p.1*∑s∈l.toFinset.powerset.erase ∅,∑k,
      jointU F x r ((lam:ℝ)*r) v (l.filter (fun j => j∈s)) k p*
        jointU F x r ((lam:ℝ)*r) (Sum.elim v (fun _ : Unit => JetCalculus.spaceBasis d k))
          (Sum.inr ()::(l.filter (fun j => j∉s)).map Sum.inl) i p
  change A (ρ,y)=B (ρ,y)
  have hU := jointU_timeSmooth hF x hr hlam hl v l hlN i
  have hV (k : Fin d) := jointU_timeSmooth hF x hr hlam hl
    (Sum.elim v (fun _ : Unit => JetCalculus.spaceBasis d k)) (Sum.inr ()::l.map Sum.inl)
      (extra_list_nodup hlN) i
  have hpos (t : ℝ) (h0 : 0<t) (h1 : t<1) : A (t,y)=B (t,y) := by
    have he := material_conditionalU_pos hF x hr hlam hl h0 h1 v l hlN i y
    have hs := JetCalculus.gadj_right_slice_at (JetCalculus.spaceBasis d) (jointScore F x r)
      (V:=V) (fun k => (hV k (t,y) (by dsimp; linarith) h1).differentiableAt (by simp))
    change JetCalculus.gadj jointSpace (jointScore F x r) V (t,y)=_ at hs
    change JetCalculus.mdir (1,0) jointSpace r (jointMean F x r)
      (jointU F x r ((lam:ℝ)*r) v l i) (t,y)=_
    rw [he]
    exact congrArg (fun a => a+2*r*t*∑s∈l.toFinset.powerset.erase ∅,∑k,
      jointU F x r ((lam:ℝ)*r) v (l.filter (fun j => j∈s)) k (t,y)*
        jointU F x r ((lam:ℝ)*r) (Sum.elim v (fun _ : Unit => JetCalculus.spaceBasis d k))
          (Sum.inr ()::(l.filter (fun j => j∉s)).map Sum.inl) i (t,y)) hs.symm
  rcases hρ0.eq_or_lt with hzero|hposρ
  · subst ρ
    have hz : (0:ℝ)^2<1 := by norm_num
    have hA : ContDiffAt ℝ (⊤:ℕ∞) A (0,y) :=
      JetCalculus.smooth_mdir_at (1,0) jointSpace r (jointMean_smooth_at hF x hr.le hl hz)
        (hU (0,y) (by norm_num) (by norm_num))
    have hB : ContDiffAt ℝ (⊤:ℕ∞) B (0,y) := by
      apply ContDiffAt.add
      · exact JetCalculus.smooth_gadj_at jointSpace (jointScore_smooth_at hF x hr.le hl hz)
          (fun k => hV k (0,y) (by norm_num) (by norm_num))
      · apply ContDiffAt.mul (contDiffAt_const.mul contDiffAt_fst)
        apply ContDiffAt.sum
        intro s _
        apply ContDiffAt.sum
        intro k _
        exact (jointU_timeSmooth hF x hr hlam hl v _ (hlN.filter _) k (0,y)
          (by norm_num) (by norm_num)).mul
          (jointU_timeSmooth hF x hr hlam hl _ _ (extra_list_nodup (hlN.filter _)) i (0,y)
            (by norm_num) (by norm_num))
    have hc : ContinuousAt (fun t : ℝ => (t,y)) 0 :=
      continuousAt_id.prodMk continuousAt_const
    exact eq_zero_of_continuous_pos (hA.continuousAt.comp (f:=fun t : ℝ => (t,y)) hc)
      (hB.continuousAt.comp (f:=fun t : ℝ => (t,y)) hc) hpos
  · exact hpos ρ hposρ hρ1

end LogConcaveSampling

end

end

section

noncomputable section
namespace LogConcaveSampling
open scoped Classical BigOperators NNReal RealInnerProductSpace

lemma joint_score_transport_nonneg {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) (hρ0 : 0≤ρ) (hρ1 : ρ<1)
    (y : Point d) (i : Fin d) :
    JetCalculus.mdir (1,0) jointSpace r (jointMean F x r) (jointScore F x r i) (ρ,y)=
      r*JetCalculus.gadj jointSpace (jointScore F x r)
        (fun k => JetCalculus.dir (jointSpace i) (jointMean F x r k)) (ρ,y) := by
  rcases hρ0.eq_or_lt with hz|hpos
  · subst ρ
    have hM := jointMean_smooth_at hF x hr.le hl (p:=(0,y)) (by norm_num)
    have hS := jointScore_smooth_at hF x hr.le hl (p:=(0,y)) (by norm_num)
    have ha := JetCalculus.smooth_mdir_at (1,0) jointSpace r hM (hS i)
    have hb := (contDiffAt_const (c:=r)).mul (JetCalculus.smooth_gadj_at jointSpace hS
      (fun k => JetCalculus.smooth_dir_at (hM k) (jointSpace i)))
    have hc : ContinuousAt (fun t : ℝ => (t,y)) 0 := continuousAt_id.prodMk continuousAt_const
    exact eq_zero_of_continuous_pos (ha.continuousAt.comp (f:=fun t : ℝ => (t,y)) hc)
      (hb.continuousAt.comp (f:=fun t : ℝ => (t,y)) hc)
      (fun t h0 h1 => joint_score_transport hF x hr hlam hl h0 h1 y i)
  · exact joint_score_transport hF x hr hlam hl hpos hρ1 y i

theorem physical_material_adjoint_nonneg {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) (hρ0 : 0≤ρ) (hρ1 : ρ<1)
    {V : Fin d → ℝ × Point d → ℝ} {y : Point d}
    (hV : ∀i,ContDiffAt ℝ (⊤:ℕ∞) (V i) (ρ,y)) :
    JetCalculus.mdir (1,0) jointSpace r (jointMean F x r)
      (JetCalculus.gadj jointSpace (jointScore F x r) V) (ρ,y)=
      JetCalculus.gadj jointSpace (jointScore F x r)
        (fun i => JetCalculus.mdir (1,0) jointSpace r (jointMean F x r) (V i)) (ρ,y)+
      r*JetCalculus.gadj jointSpace (jointScore F x r)
        (fun k p => ∑i,JetCalculus.dir (jointSpace i) (jointMean F x r k) p*V i p) (ρ,y) := by
  have hp : ρ^2<1 := by have := (probability_time hρ0 hρ1).1; linarith
  exact JetCalculus.mdir_gadj_at _ _ _ (jointMean_smooth_at hF x hr.le hl hp)
    (jointScore_smooth_at hF x hr.le hl hp) hV (joint_score_transport_nonneg hF x hr hlam hl hρ0 hρ1 y)

end LogConcaveSampling

end

end

end

end OAI