import Mathlib
import OAI.Probability.LogConcave.Sampling.ProbabilityNodes
import OAI.Probability.LogConcave.Complexity.TerminalDerivativeBudget

namespace OAI

section
noncomputable section
namespace LogConcaveSampling.Quadrature
open Set MeasureTheory Filter
open scoped BigOperators

variable {I E : Type*} [Fintype I] [DecidableEq I]
  [NormedAddCommGroup E] [NormedSpace ℝ E] [CompleteSpace E]

def ordinaryDerivativeWeight (u : I → ℝ) (a b : ℝ) (i : I) : ℝ :=
  ∫t in a..b,(b-a)⁻¹*t⁻¹*basisDerivative u i ((t-a)/(b-a))

lemma inv_intervalIntegrable {a b : ℝ} (ha : 0<a) (hab : a≤b) :
    IntervalIntegrable (fun t : ℝ => t⁻¹) volume a b := by
  apply ContinuousOn.intervalIntegrable
  rw [uIcc_of_le hab]
  exact continuousOn_id.inv₀ (fun t ht => ne_of_gt (ha.trans_le ht.1))

lemma ordinaryDerivativeWeight_integrand_continuousOn (u : I → ℝ) (a b : ℝ) (i : I)
    (ha : 0<a) (hab : a≤b) :
    ContinuousOn (fun t => (b-a)⁻¹*t⁻¹*basisDerivative u i ((t-a)/(b-a))) (uIcc a b) := by
  rw [uIcc_of_le hab]
  exact (continuousOn_const.mul (continuousOn_id.inv₀
    (fun t ht => ne_of_gt (ha.trans_le ht.1)))).mul
      ((basisDerivative_continuous u i).comp
        ((continuous_id.sub continuous_const).div_const _)).continuousOn

lemma ordinaryDerivativeWeight_integral (u : I → ℝ) (v : I → E) {a b : ℝ}
    (ha : 0<a) (hab : a≤b) :
    (∫t in a..b,t⁻¹ • ((b-a)⁻¹ • derivativeInterpolation u v ((t-a)/(b-a))))=
      ∑i,ordinaryDerivativeWeight u a b i • v i := by
  simp only [derivativeInterpolation,Finset.smul_sum,smul_smul]
  rw [intervalIntegral.integral_finsetSum]
  · apply Finset.sum_congr rfl
    intro i _
    unfold ordinaryDerivativeWeight
    rw [←intervalIntegral.integral_smul_const]
    apply intervalIntegral.integral_congr
    intro t _
    module
  · intro i _
    have hh := ((ordinaryDerivativeWeight_integrand_continuousOn u a b i ha hab).smul
      (continuousOn_const : ContinuousOn (fun _ : ℝ => v i) (uIcc a b))).intervalIntegrable (μ:=volume)
    convert hh using 1
    funext t
    congr 1
    ring

omit [CompleteSpace E] in
lemma derivativeInterpolation_joint_continuous {Ω : Type*} [TopologicalSpace Ω]
    (u : I → ℝ) (v : I → Ω → E) (hv : ∀i,Continuous (v i)) :
    Continuous (fun p : ℝ × Ω => derivativeInterpolation u (fun i => v i p.2) p.1) := by
  exact continuous_finsetSum _ (fun i _ =>
    ((basisDerivative_continuous u i).comp continuous_fst).smul ((hv i).comp continuous_snd))

variable {Ω : Type*} [TopologicalSpace Ω] [MeasurableSpace Ω] [BorelSpace Ω]
  [SecondCountableTopology Ω] {μ : Measure Ω} [SFinite μ]

lemma ordinaryDerivativeWeight_error_rms (u : I → ℝ) (f g : ℝ × Ω → E)
    (hf : Continuous f) (hg : Continuous g) {a b B : ℝ}
    (ha : 0<a) (hab : a<b) (hB0 : 0≤B)
    (hi : ∀t∈Icc (0:ℝ) 1,Integrable (fun z =>
      ‖g (a+(b-a)*t,z)-(b-a)⁻¹ • derivativeInterpolation u (fun i => f (a+(b-a)*u i,z)) t‖^2) μ)
    (hB : ∀t∈Icc (0:ℝ) 1,(∫z,
      ‖g (a+(b-a)*t,z)-(b-a)⁻¹ • derivativeInterpolation u (fun i => f (a+(b-a)*u i,z)) t‖^2 ∂μ)≤B) :
    let err := fun z => (∫t in a..b,t⁻¹ • g (t,z))-
      ∑i,ordinaryDerivativeWeight u a b i • f (a+(b-a)*u i,z)
    Integrable (fun z => ‖err z‖^2) μ ∧
      (∫z,‖err z‖^2 ∂μ)≤((b-a)/a)^2*B := by
  dsimp only
  let η := volume.restrict (Ioc a b)
  let R := fun p : ℝ × Ω => g p-(b-a)⁻¹ • derivativeInterpolation u
    (fun i => f (a+(b-a)*u i,p.2)) ((p.1-a)/(b-a))
  have hRc : Continuous R := hg.sub
    (((derivativeInterpolation_joint_continuous u (fun i z => f (a+(b-a)*u i,z))
      (fun i => hf.comp (continuous_const.prodMk continuous_id))).comp
        (((continuous_fst.sub continuous_const).div_const _).prodMk continuous_snd)).const_smul _)
  have hrange {t : ℝ} (ht : t∈Ioc a b) : (t-a)/(b-a)∈Icc (0:ℝ) 1 := by
    constructor
    · exact div_nonneg (sub_nonneg.mpr ht.1.le) (sub_pos.mpr hab).le
    · exact (div_le_one (sub_pos.mpr hab)).mpr (by linarith [ht.2])
  have hcoord (t : ℝ) : a+(b-a)*((t-a)/(b-a))=t := by
    field_simp [ne_of_gt (sub_pos.mpr hab)]; ring
  have hri : ∀ᵐ t ∂η,Integrable (fun z => ‖R (t,z)‖^2) μ := by
    filter_upwards [ae_restrict_mem measurableSet_Ioc] with t ht
    simpa only [R,hcoord] using hi _ (hrange ht)
  have hrB : ∀ᵐ t ∂η,(∫z,‖R (t,z)‖^2 ∂μ)≤B := by
    filter_upwards [ae_restrict_mem measurableSet_Ioc] with t ht
    simpa only [R,hcoord] using hB _ (hrange ht)
  have hw : AEStronglyMeasurable (fun t : ℝ => t⁻¹) η := measurable_id.inv.aestronglyMeasurable
  have hwb : ∀ᵐ t ∂η,|t⁻¹|≤a⁻¹ := by
    filter_upwards [ae_restrict_mem measurableSet_Ioc] with t ht
    rw [abs_of_nonneg (inv_nonneg.mpr (ha.trans ht.1).le)]
    exact inv_anti₀ ha ht.1.le
  have hv := RMSIntegral.weighted_time_seed hRc.aestronglyMeasurable hw hB0 hwb hri hrB
  have hη : η.real univ=b-a := by
    dsimp only [η,Measure.real]
    rw [Measure.restrict_apply_univ]
    exact Real.volume_real_Ioc_of_le hab.le
  have he (z : Ω) : (∫t in a..b,t⁻¹ • g (t,z))-
      ∑i,ordinaryDerivativeWeight u a b i • f (a+(b-a)*u i,z)=
        ∫t,t⁻¹ • R (t,z) ∂η := by
    rw [←ordinaryDerivativeWeight_integral u _ ha hab.le]
    have hg' : IntervalIntegrable (fun t => t⁻¹ • g (t,z)) volume a b := by
      apply ContinuousOn.intervalIntegrable
      rw [uIcc_of_le hab.le]
      exact (continuousOn_id.inv₀ (fun t ht => ne_of_gt (ha.trans_le ht.1))).smul
        (hg.comp (continuous_id.prodMk continuous_const)).continuousOn
    have hp' : IntervalIntegrable (fun t => t⁻¹ • ((b-a)⁻¹ • derivativeInterpolation u
        (fun i => f (a+(b-a)*u i,z)) ((t-a)/(b-a)))) volume a b := by
      apply ContinuousOn.intervalIntegrable
      rw [uIcc_of_le hab.le]
      apply (continuousOn_id.inv₀ (fun t ht => ne_of_gt (ha.trans_le ht.1))).smul
      apply Continuous.continuousOn
      apply Continuous.const_smul
      exact (derivativeInterpolation_joint_continuous u (fun i (_ : Unit) => f (a+(b-a)*u i,z))
        (fun _ => continuous_const)).comp
          (((continuous_id.sub continuous_const).div_const _).prodMk
            (continuous_const : Continuous (fun _ : ℝ => ())))
    rw [←intervalIntegral.integral_sub hg' hp',intervalIntegral.integral_of_le hab.le]
    congr 1
    funext t
    exact (smul_sub _ _ _).symm
  simp_rw [he]
  refine ⟨hv.1,hv.2.trans_eq ?_⟩
  rw [hη]
  ring
end LogConcaveSampling.Quadrature

end

end

section

noncomputable section
namespace LogConcaveSampling
open Set MeasureTheory Quadrature
open scoped Classical BigOperators

def terminalQuadratureWeight (T h : ℝ) (n : ℕ) (i : ProbabilityNode T h (n+1)) : ℝ :=
  if i.1.val=0 then
    zeroHermiteWeight (probabilityNodes (n+1)) 0 i.2/probabilityCellLength T h i.1
  else ordinaryDerivativeWeight (probabilityNodes (n+1))
    (logMeshNode T h i.1.val) (logMeshNode T h (i.1.val+1)) i.2

lemma probabilityNodes_zero (n : ℕ) : probabilityNodes n 0=0 := by
  simp [probabilityNodes]

lemma logMeshNode_pos {T h : ℝ} (hT0 : 0<T) (hT1 : T<1) (hh : 0<h)
    {j : ℕ} (hj : 0<j) : 0<logMeshNode T h j := by
  simpa only [logMeshNode_zero] using logMeshNode_strictMono hT0 hT1 hh hj

lemma probabilityCellLength_le_h {T h : ℝ} (hT0 : 0<T) (hT1 : T<1) (hh : 0<h)
    (i : Fin (logMeshCount T h)) : probabilityCellLength T h i≤h := by
  have he := logMeshCell_upper hT0 hT1 hh i.val
  have ha := (logMeshNode_mem hT0 hT1 hh i.2.le).1
  dsimp only [probabilityCellLength]
  nlinarith

lemma logMeshFirst_lower {T h : ℝ} (hT0 : 0<T) (hT1 : T<1) (hh : 0<h)
    (hL : h≤logMeshLength T) (hs : h≤Real.log 2) : h/4≤logMeshNode T h 1 := by
  simpa only [logMeshNode_zero,zero_add,sub_zero,mul_one] using
    logMeshCell_lower hT0 hT1 hh hL hs 0

lemma probabilityCellLength_ratio {T h : ℝ} (hT0 : 0<T) (hT1 : T<1) (hh : 0<h)
    (hL : h≤logMeshLength T) (hs : h≤Real.log 2)
    (i : Fin (logMeshCount T h)) (hi : i.val≠0) :
    probabilityCellLength T h i/logMeshNode T h i.val≤4 := by
  have ha := logMeshFirst_lower hT0 hT1 hh hL hs
  have hm : logMeshNode T h 1≤logMeshNode T h i.val :=
    (logMeshNode_strictMono hT0 hT1 hh).monotone (Nat.one_le_iff_ne_zero.mpr hi)
  have hp := logMeshNode_pos hT0 hT1 hh (Nat.pos_of_ne_zero hi)
  rw [div_le_iff₀ hp]
  have hc := probabilityCellLength_le_h hT0 hT1 hh i
  linarith

end LogConcaveSampling

end

end

section

noncomputable section
namespace LogConcaveSampling.Quadrature
open Set MeasureTheory

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

lemma regularized_intervalIntegrable_nonneg {f : ℝ → E} (hf : Continuous f)
    (hd : DifferentiableAt ℝ f 0) (h0 : f 0=0)
    {a b : ℝ} (ha : 0≤a) (hab : a≤b) :
    IntervalIntegrable (fun t => t⁻¹ • f t) volume a b := by
  have hc : Continuous (dslope f 0) := continuousOn_univ.mp
    ((continuousOn_dslope (s:=univ) (by simp)).mpr ⟨hf.continuousOn,hd⟩)
  apply (hc.intervalIntegrable a b).congr_uIoo
  intro t ht
  rw [uIoo_of_le hab] at ht
  simp only [dslope_of_ne f (ne_of_gt (ha.trans_lt ht.1)),slope_def_module,h0,sub_zero]

lemma regularized_integral_scale (f : ℝ → E) {b : ℝ} (hb : b≠0) :
    (∫t in (0:ℝ)..b,t⁻¹ • f t)=(∫t in (0:ℝ)..1,t⁻¹ • f (b*t)) := by
  have he := intervalIntegral.smul_integral_comp_mul_left (a:=0) (b:=1)
    (fun t => t⁻¹ • f t) b
  simp only [mul_zero,mul_one] at he
  rw [←he,←intervalIntegral.integral_smul]
  apply intervalIntegral.integral_congr
  intro t ht
  simp only [smul_smul,mul_inv_rev]
  congr 1
  field_simp

end LogConcaveSampling.Quadrature

namespace LogConcaveSampling
open Set MeasureTheory ProbabilityTheory Quadrature
open scoped Classical BigOperators NNReal

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

include hlam in

theorem terminalQuadrature_cell_rms (hd : 1≤d) (n : ℕ) (D : ℝ) (hD : 1≤D)
    (hDu : ∀t∈Icc (0:ℝ) 1,∑i,|basisDerivative (probabilityNodes (n+1)) i t|≤D)
    (hh : 0<h) (hs : h≤Real.log 2) (hL : h≤logMeshLength T)
    (c : Fin (logMeshCount T h)) :
    let J := terminalActionChain hF x hr hl hT0 hT1
    let μ := (interpolationLaw F x r T).prod (stdGaussian (Point d))
    let H := ∑i,|zeroHermiteWeight (probabilityNodes (n+1)) 0 i|
    let err := fun z => (∫t in logMeshNode T h c.val..logMeshNode T h (c.val+1),t⁻¹ • J 1 (t,z))-
      ∑i,terminalQuadratureWeight T h n (c,i) • J 0 (probabilityNodeTime T h (n+1) (c,i),z)
    Integrable (fun z => ‖err z‖^2) μ ∧
      (∫z,‖err z‖^2 ∂μ)≤32*(1+D^2+H^2)*
        (terminalDerivativeBudget (n+1) d lam r*(2*h)^(n+1))^2*d := by
  dsimp only
  let := interpolationLaw_probability hF x hr.le (by linarith) T
  let J := terminalActionChain hF x hr hl hT0 hT1
  let μ := (interpolationLaw F x r T).prod (stdGaussian (Point d))
  let A := (terminalDerivativeBudget (n+1) d lam r*(2*h)^(n+1))^2*d
  let H := ∑i,|zeroHermiteWeight (probabilityNodes (n+1)) 0 i|
  have hA : 0≤A := by dsimp only [A]; positivity
  have ha := logMeshNode_mem hT0 hT1 hh c.2.le
  have hb := logMeshNode_mem hT0 hT1 hh (Nat.succ_le_of_lt c.2)
  have hab := logMeshNode_strictMono hT0 hT1 hh (Nat.lt_succ_self c.val)
  have hc := logMeshCell_upper_right hT0 hT1 hh hs c.val
  by_cases hc0 : c.val=0
  · have hb0 := logMeshNode_pos hT0 hT1 hh (by omega : 0<c.val+1)
    have hv := terminal_hermite_cell_rms hF x hr hlam hl hT0 hT1
      (probabilityNodes (n+1)) (probabilityNodes_injective (by omega)) 0
      (probabilityNodes_zero _) (probabilityNodes_mem (by omega)) n (by simp) hd
      hb0 hb.2 (by positivity : 0≤2*h) (by simpa only [hc0,logMeshNode_zero,sub_zero] using hc)
    dsimp only at hv
    have hEq (z : Point d × Point d) :
        (∫t in logMeshNode T h c.val..logMeshNode T h (c.val+1),t⁻¹ • J 1 (t,z))-
          ∑i,terminalQuadratureWeight T h n (c,i) • J 0 (probabilityNodeTime T h (n+1) (c,i),z)=
        (∫t in (0:ℝ)..1,t⁻¹ • J 1 (logMeshNode T h (c.val+1)*t,z))-
          ∑i,(zeroHermiteWeight (probabilityNodes (n+1)) 0 i/logMeshNode T h (c.val+1)) •
            J 0 (logMeshNode T h (c.val+1)*probabilityNodes (n+1) i,z) := by
      simp only [terminalQuadratureWeight,probabilityNodeTime,probabilityCellLength,
        hc0,ite_true,logMeshNode_zero,sub_zero,zero_add]
      rw [regularized_integral_scale _ (ne_of_gt (logMeshNode_pos hT0 hT1 hh (by omega : 0<1)))]
    dsimp only [J] at hEq
    simp_rw [hEq]
    refine ⟨hv.1,hv.2.trans ?_⟩
    have he : 2*(1+H^2)≤32*(1+D^2+H^2) := by nlinarith [sq_nonneg D,sq_nonneg H]
    convert mul_le_mul_of_nonneg_right he hA using 1 <;> ring
  · have ha0 := logMeshNode_pos hT0 hT1 hh (by omega : 0<c.val)
    have hv (t : ℝ) (ht : t∈Icc (0:ℝ) 1) :=
      terminal_derivative_cell_rms hF x hr hlam hl hT0 hT1
        (probabilityNodes (n+1)) (probabilityNodes_injective (by omega))
        (probabilityNodes_mem (by omega)) n (by simp) hd ha.1 hab hb.2
        (by positivity : 0≤2*h) hc ht
    have hi (t : ℝ) (ht : t∈Icc (0:ℝ) 1) := (hv t ht).1
    have hB (t : ℝ) (ht : t∈Icc (0:ℝ) 1) :
        (∫z,‖J 1 (logMeshNode T h c.val+probabilityCellLength T h c*t,z)-
          (probabilityCellLength T h c)⁻¹ • derivativeInterpolation (probabilityNodes (n+1))
            (fun i => J 0 (logMeshNode T h c.val+probabilityCellLength T h c*probabilityNodes (n+1) i,z)) t‖^2 ∂μ)
          ≤2*(1+D^2)*A := by
      apply (hv t ht).2.trans
      have hps := pow_le_pow_left₀ (Finset.sum_nonneg (fun i _ => abs_nonneg
        (basisDerivative (probabilityNodes (n+1)) i t))) (hDu t ht) 2
      have he : 2*(1+(∑i,|basisDerivative (probabilityNodes (n+1)) i t|)^2)≤2*(1+D^2) := by linarith
      convert mul_le_mul_of_nonneg_right he hA using 1; ring
    have he := ordinaryDerivativeWeight_error_rms (μ:=μ) (probabilityNodes (n+1)) (J 0) (J 1)
      (terminalActionChain_smooth hF x hr hl hT0 hT1 0).continuous
      (terminalActionChain_smooth hF x hr hl hT0 hT1 1).continuous
      ha0 hab (by positivity : 0≤2*(1+D^2)*A) hi hB
    dsimp only at he
    simp only [terminalQuadratureWeight,hc0,ite_false,probabilityNodeTime]
    refine ⟨he.1,he.2.trans ?_⟩
    have hr0 : 0≤probabilityCellLength T h c/logMeshNode T h c.val :=
      div_nonneg (probabilityCellLength_pos hT0 hT1 hh c).le ha0.le
    have hr4 := probabilityCellLength_ratio hT0 hT1 hh hL hs c hc0
    have hr16 : (probabilityCellLength T h c/logMeshNode T h c.val)^2≤16 := by
      nlinarith [sq_nonneg (4-probabilityCellLength T h c/logMeshNode T h c.val)]
    calc
      _ ≤ 16*(2*(1+D^2)*A) := mul_le_mul_of_nonneg_right hr16 (by positivity)
      _ ≤ _ := by nlinarith [mul_nonneg (sq_nonneg H) hA]
end LogConcaveSampling

end

end

section

noncomputable section
namespace LogConcaveSampling.Quadrature
open Set MeasureTheory
open scoped BigOperators

variable {Ω E : Type*} [MeasurableSpace Ω]
  [NormedAddCommGroup E] [NormedSpace ℝ E]

lemma stronglyMeasurable_parametric_intervalIntegral (f : ℝ × Ω → E)
    (hf : StronglyMeasurable f) (a b : ℝ) :
    StronglyMeasurable (fun z => ∫t in a..b,f (t,z)) := by
  have he : StronglyMeasurable (fun z : Ω × ℝ => f (z.2,z.1)) :=
    hf.comp_measurable measurable_swap
  unfold intervalIntegral
  exact (he.integral_prod_right').sub (he.integral_prod_right')

lemma quadrature_error_sum {N : ℕ} {I : Type*} [Fintype I]
    (a : ℕ → ℝ) (f : ℝ → E) (v : Fin N → I → E) (w : Fin N → I → ℝ)
    (hi : ∀j,j<N → IntervalIntegrable f volume (a j) (a (j+1))) :
    (∫t in a 0..a N,f t)-(∑p : Fin N × I,w p.1 p.2 • v p.1 p.2)=
      ∑j : Fin N,((∫t in a j.val..a (j.val+1),f t)-∑i,w j i • v j i) := by
  rw [Finset.sum_sub_distrib,Fintype.sum_prod_type]
  congr 1
  rw [Fin.sum_univ_eq_sum_range (fun j => ∫t in a j..a (j+1),f t)]
  exact (intervalIntegral.sum_integral_adjacent_intervals hi).symm
end LogConcaveSampling.Quadrature

namespace LogConcaveSampling
open Set MeasureTheory ProbabilityTheory Quadrature RMSIntegral
open scoped Classical BigOperators NNReal

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

include hlam in

theorem terminalQuadrature_analytic_rms (hd : 1≤d) (n : ℕ) (D : ℝ) (hD : 1≤D)
    (hDu : ∀t∈Icc (0:ℝ) 1,∑i,|basisDerivative (probabilityNodes (n+1)) i t|≤D)
    (hh : 0<h) (hs : h≤Real.log 2) (hL : h≤logMeshLength T) :
    let J := terminalActionChain hF x hr hl hT0 hT1
    let μ := (interpolationLaw F x r T).prod (stdGaussian (Point d))
    let H := ∑i,|zeroHermiteWeight (probabilityNodes (n+1)) 0 i|
    let err := fun z => (∫t in (0:ℝ)..T,t⁻¹ • J 1 (t,z))-
      ∑s,terminalQuadratureWeight T h n s • J 0 (probabilityNodeTime T h (n+1) s,z)
    Integrable (fun z => ‖err z‖^2) μ ∧
      (∫z,‖err z‖^2 ∂μ)≤(logMeshCount T h:ℝ)^2*(32*(1+D^2+H^2)*
        (terminalDerivativeBudget (n+1) d lam r*(2*h)^(n+1))^2*d) := by
  dsimp only
  let J := terminalActionChain hF x hr hl hT0 hT1
  let μ := (interpolationLaw F x r T).prod (stdGaussian (Point d))
  let e := fun c : Fin (logMeshCount T h) => fun z =>
    (∫t in logMeshNode T h c.val..logMeshNode T h (c.val+1),t⁻¹ • J 1 (t,z))-
      ∑i,terminalQuadratureWeight T h n (c,i) • J 0 (probabilityNodeTime T h (n+1) (c,i),z)
  have hc := terminalActionChain_smooth hF x hr hl hT0 hT1
  have hm (c : Fin (logMeshCount T h)) : StronglyMeasurable (e c) := by
    apply StronglyMeasurable.sub
    · refine stronglyMeasurable_parametric_intervalIntegral (fun p => p.1⁻¹ • J 1 p) ?_ _ _
      exact (measurable_fst.inv.smul (hc 1).continuous.measurable).stronglyMeasurable
    · have hcj (i : Fin (n+2)) : Continuous (fun z : Point d × Point d =>
          terminalQuadratureWeight T h n (c,i) • J 0 (probabilityNodeTime T h (n+1) (c,i),z)) := by
        have hscalar : Continuous (fun v : Point d => terminalQuadratureWeight T h n (c,i) • v) := continuous_const_smul _
        convert! hscalar.comp ((hc 0).continuous.comp
          ((continuous_const : Continuous (fun _ : Point d × Point d => probabilityNodeTime T h (n+1) (c,i))).prodMk continuous_id)) using 1
      exact (continuous_finsetSum _ (fun i _ => hcj i)).stronglyMeasurable
  have he := weighted_sum_sq (ν:=μ) (fun _ : Fin (logMeshCount T h) => (1:ℝ)) e
    (fun c => (hm c).aestronglyMeasurable)
    (fun c => (terminalQuadrature_cell_rms hF x hr hlam hl hT0 hT1 hd n D hD hDu hh hs hL c).1)
    (fun c => (terminalQuadrature_cell_rms hF x hr hlam hl hT0 hT1 hd n D hD hDu hh hs hL c).2)
  have heq (z : Point d × Point d) :
      (∫t in (0:ℝ)..T,t⁻¹ • J 1 (t,z))-
        ∑s,terminalQuadratureWeight T h n s • J 0 (probabilityNodeTime T h (n+1) s,z)=
      ∑c : Fin (logMeshCount T h),e c z := by
    have ht := quadrature_error_sum (logMeshNode T h) (fun t => t⁻¹ • J 1 (t,z))
      (fun c i => J 0 (probabilityNodeTime T h (n+1) (c,i),z))
      (fun c i => terminalQuadratureWeight T h n (c,i)) (fun j hj =>
        regularized_intervalIntegrable_nonneg
          ((hc 1).continuous.comp (continuous_id.prodMk continuous_const))
          (terminalActionChain_hasDerivAt hF x hr hl hT0 hT1 1 0 z).differentiableAt
          (terminalActionChain_first_zero hF x hr hlam hl hT0 hT1 z)
          (logMeshNode_mem hT0 hT1 hh hj.le).1
          (logMeshNode_strictMono hT0 hT1 hh (Nat.lt_succ_self j)).le)
    simpa only [logMeshNode_zero,logMeshNode_last hT0 hT1 hh] using ht
  dsimp only [J] at heq
  simp_rw [heq]
  simpa only [one_smul,abs_one,Finset.sum_const,Finset.card_univ,Fintype.card_fin,nsmul_eq_mul,mul_one] using he
end LogConcaveSampling

end

end

end OAI