import Mathlib
import OAI.Probability.LogConcave.Complexity.KernelAnalyticNormalizedBudget
import OAI.Probability.LogConcave.Dynamics.DistanceCoupled

namespace OAI

section
noncomputable section
namespace LogConcaveSampling.EulerGeometry
open MeasureTheory ProbabilityTheory Filter
open scoped Topology Classical NNReal

variable {d : ℕ}

lemma measurable_iterate_map {T : Point d → Point d} (hT : Measurable T)
    (σ : ℝ) (n : ℕ) (x : Point d) :
    Measurable (fun g : PiLp 2 (fun _ : Fin n => Point d) => iterate T σ n x g.ofLp) := by
  have h (n : ℕ) : Measurable (iterate T σ n x) := by
    induction n with
    | zero => exact measurable_const
    | succ n ih =>
      exact (hT.comp (ih.comp (Measurable.of_eval (fun index => measurable_pi_apply index.castSucc)))).add
        ((measurable_pi_apply (Fin.last n)).const_smul σ)
  exact (h n).comp (PiLp.continuous_ofLp (p := 2) (β := fun _ : Fin n => Point d)).measurable

def law (T : Point d → Point d) (σ : ℝ) (n : ℕ) (x : Point d) : Measure (Point d) :=
  (stdGaussian (PiLp 2 (fun _ : Fin n => Point d))).map (fun g => iterate T σ n x g.ofLp)

lemma law_probability {T : Point d → Point d} (hT : Measurable T) (σ : ℝ) (n : ℕ) (x : Point d) :
    IsProbabilityMeasure (law T σ n x) :=
  (Measure.isProbabilityMeasure_map_iff (measurable_iterate_map hT σ n x).aemeasurable).mpr inferInstance

theorem laws_tendsto (μ : Measure (Point d)) [IsProbabilityMeasure μ]
    {q : ℕ → ℝ≥0} {T : ℕ → Point d → Point d} (hT : ∀ k, LipschitzWith (q k) (T k))
    (σ : ℕ → ℝ) (N : ℕ → ℕ)
    (hq : Tendsto (fun k => (q k:ℝ)^(N k)) atTop (𝓝 0))
    {D : ℕ → ℝ} (hD : Tendsto (fun k => (N k:ℝ)*D k) atTop (𝓝 0))
    (hstep : ∀ k (f : Point d → ℝ), Measurable f → ∀ B : ℝ, 0 ≤ B →
      (∀ x, |f x| ≤ B) → |(∫ x, operator (T k) (σ k) f x ∂μ)-∫ x, f x ∂μ| ≤ B*D k)
    (x : Point d) :
    Tendsto (fun k => (⟨law (T k) (σ k) (N k) x,law_probability (hT k).continuous.measurable _ _ _⟩ : ProbabilityMeasure (Point d)))
      atTop (nhds (X := ProbabilityMeasure (Point d)) ⟨μ,inferInstance⟩) := by
  apply tendsto_iff_forall_lipschitz_integral_tendsto.mpr
  intro f hf hl
  obtain ⟨C,hC⟩ := hf
  obtain ⟨L,hL⟩ := hl
  have hb (z : Point d) : |f z|≤C+|f 0| := by
    have h := hC z 0
    rw [Real.dist_eq] at h
    have ha := abs_add_le (f z-f 0) (f 0)
    rw [sub_add_cancel] at ha
    linarith
  have hB : 0≤C+|f 0| := (abs_nonneg (f 0)).trans (hb 0)
  have ht := expectations_tendsto μ hT σ N hq hD hstep hL.uniformContinuous hB hb x
  convert ht using 1
  · funext k
    change (∫z,f z ∂law (T k) (σ k) (N k) x)=_
    rw [law,integral_map (measurable_iterate_map (hT k).continuous.measurable _ _ _).aemeasurable hL.continuous.aestronglyMeasurable]
    exact integral_iterate_gaussian (hT k).continuous.measurable (σ k) hL.continuous.measurable hb (N k) x
  · rfl

lemma comparison_iterate {T U : Point d → Point d} {R : ℝ} (hr : 0≤R)
    (hstep : ∀x y,dist x y≤R → dist (T x) (U y)≤R)
    (σ : ℝ) (n : ℕ) (x : Point d) (g : Fin n → Point d) :
    dist (iterate T σ n x g) (iterate U σ n x g)≤R := by
  induction n with
  | zero => simpa only [iterate,dist_self] using hr
  | succ n ih =>
    simp only [iterate,dist_add_right]
    exact hstep _ _ (ih _)

lemma laws_distanceCoupled {T U : Point d → Point d} (hT : Measurable T) (hU : Measurable U)
    {R : ℝ} (hr : 0≤R) (hstep : ∀x y,dist x y≤R → dist (T x) (U y)≤R)
    (σ : ℝ) (n : ℕ) (x : Point d) : Coupling.DistanceCoupled (law T σ n x) (law U σ n x) R := by
  let J := fun g : PiLp 2 (fun _ : Fin n => Point d) =>
    (iterate T σ n x g.ofLp,iterate U σ n x g.ofLp)
  have hm : Measurable J := (measurable_iterate_map hT _ _ _).prodMk (measurable_iterate_map hU _ _ _)
  refine ⟨(stdGaussian _).map J,inferInstance,?_,?_,?_⟩
  · change ((stdGaussian _).map J).map Prod.fst=_
    rw [Measure.map_map measurable_fst hm]
    rfl
  · change ((stdGaussian _).map J).map Prod.snd=_
    rw [Measure.map_map measurable_snd hm]
    rfl
  · apply ae_map_iff hm.aemeasurable (measurableSet_le (by fun_prop) measurable_const) |>.mpr
    exact Filter.Eventually.of_forall (fun g => comparison_iterate hr hstep σ n x g.ofLp)
end LogConcaveSampling.EulerGeometry

end

end

section

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

variable {d : ℕ}

theorem gibbs_distanceCoupled_of_euler
    {H U : Point d → ℝ} (hH : ContDiff ℝ 2 H) (hU : ContDiff ℝ 2 U)
    {MH MU : ℝ≥0} (hMH : LipschitzWith MH (gradient H)) (hMU : LipschitzWith MU (gradient U))
    (hH0 : partition H ≠ 0) (hHt : partition H ≠ ⊤)
    (hU0 : partition U ≠ 0) (hUt : partition U ≠ ⊤)
    (hHi : Integrable (fun x => ‖gradient H x‖^2) (gibbs H))
    (hUi : Integrable (fun x => ‖gradient U x‖^2) (gibbs U))
    {m a B : ℝ} (hm : 0 < m) (ha : 0 < a) (hma : m*a≤1) (hB : 0 ≤ B)
    (hTH : ∀h,0 ≤ h → h ≤ a → ∀x y,dist (eulerDrift H h x) (eulerDrift H h y)≤(1-m*h)*dist x y)
    (hTU : ∀h,0 ≤ h → h ≤ a → ∀x y,dist (eulerDrift U h x) (eulerDrift U h y)≤(1-m*h)*dist x y)
    (hpert : ∀x,‖gradient H x-gradient U x‖≤B) :
    Coupling.DistanceCoupled (gibbs H) (gibbs U) (B/m) := by
  let := probability_gibbs_of_partition hH0 hHt
  let := probability_gibbs_of_partition hU0 hUt
  have hrate : Tendsto (fun s => EulerDefect.rate H s+EulerDefect.rate U s) (𝓝 0) (𝓝 0) := by
    simpa only [zero_add] using (EulerDefect.rate_tendsto hH hMH hHi).add (EulerDefect.rate_tendsto hU hMU hUi)
  obtain ⟨N,s,hs,hD⟩ := exists_consistent_schedule hrate
    (fun s => add_nonneg (EulerDefect.rate_nonneg H s) (EulerDefect.rate_nonneg U s)) ha
  have hq0 (k) : 0 ≤ 1-m*(s k)^2 := by
    have h := mul_le_mul_of_nonneg_left (hs k).2.2.1 hm.le
    linarith
  let q : ℕ → ℝ≥0 := fun k => ⟨1-m*(s k)^2,hq0 k⟩
  have hTL (k) : LipschitzWith (q k) (eulerDrift H ((s k)^2)) :=
    LipschitzWith.of_dist_le_mul (hTH _ (sq_nonneg _) (hs k).2.2.1)
  have hUL (k) : LipschitzWith (q k) (eulerDrift U ((s k)^2)) :=
    LipschitzWith.of_dist_le_mul (hTU _ (sq_nonneg _) (hs k).2.2.1)
  have hq : Tendsto (fun k => (q k:ℝ)^(N k)) atTop (𝓝 0) :=
    schedule_contraction_tendsto hm N s hq0 (fun k => (hs k).2.2.2)
  have hDH : Tendsto (fun k => (N k:ℝ)*(2*(s k)^2*EulerDefect.rate H (s k))) atTop (𝓝 0) := by
    apply squeeze_zero (fun k => by positivity [EulerDefect.rate_nonneg H (s k)]) _ hD
    intro k
    gcongr
    exact le_add_of_nonneg_right (EulerDefect.rate_nonneg U _)
  have hDU : Tendsto (fun k => (N k:ℝ)*(2*(s k)^2*EulerDefect.rate U (s k))) atTop (𝓝 0) := by
    apply squeeze_zero (fun k => by positivity [EulerDefect.rate_nonneg U (s k)]) _ hD
    intro k
    gcongr
    exact le_add_of_nonneg_left (EulerDefect.rate_nonneg H _)
  have hcH := laws_tendsto (gibbs H) hTL (fun k => Real.sqrt 2*s k) N hq hDH
    (fun k f hf B hB hb => euler_operator_gibbs_defect hH hMH hH0 hHt hHi
      (hs k).1.ne' (by rw [abs_of_pos (hs k).1]; exact (hs k).2.1) hf hB hb) 0
  have hcU := laws_tendsto (gibbs U) hUL (fun k => Real.sqrt 2*s k) N hq hDU
    (fun k f hf B hB hb => euler_operator_gibbs_defect hU hMU hU0 hUt hUi
      (hs k).1.ne' (by rw [abs_of_pos (hs k).1]; exact (hs k).2.1) hf hB hb) 0
  apply Coupling.distanceCoupled_of_tendsto hcH hcU
  intro k
  apply laws_distanceCoupled (hTL k).continuous.measurable (hUL k).continuous.measurable
    (div_nonneg hB hm.le)
  intro x y hxy
  have he : dist (eulerDrift H ((s k)^2) y) (eulerDrift U ((s k)^2) y)≤(s k)^2*B := by
    rw [eulerDrift,eulerDrift,dist_eq_norm,show y-(s k)^2 • gradient H y-(y-(s k)^2 • gradient U y) =
      -(s k)^2 • (gradient H y-gradient U y) by module,norm_smul,Real.norm_eq_abs,abs_neg,abs_sq]
    exact mul_le_mul_of_nonneg_left (hpert y) (sq_nonneg _)
  have ht := dist_triangle (eulerDrift H ((s k)^2) x) (eulerDrift H ((s k)^2) y)
    (eulerDrift U ((s k)^2) y)
  have hb := (hTL k).dist_le_mul x y
  have hmul := mul_le_mul_of_nonneg_left hxy (hq0 k)
  have hid : (1-m*(s k)^2)*(B/m)+(s k)^2*B=B/m := by field_simp; ring
  change _≤B/m
  change dist _ _≤(1-m*(s k)^2)*dist x y at hb
  linarith
end LogConcaveSampling

end

end

section

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

variable {d : ℕ}

lemma gradient_contDiff_one {H : Point d → ℝ} (hH : ContDiff ℝ 2 H) :
    ContDiff ℝ 1 (gradient H) :=
  (InnerProductSpace.toDual ℝ (Point d)).symm.contDiff.comp (hH.fderiv_right (by norm_num))

lemma hessian_euler_contraction {H : Point d → ℝ} (hH : ContDiff ℝ 2 H)
    {m M s : ℝ} (_ : 0 < m) (hs : 0 ≤ s) (hsM : s*M ≤ 1)
    (hess : ∀x v : Point d,m*‖v‖^2 ≤ inner ℝ v (fderiv ℝ (gradient H) x v) ∧
      inner ℝ v (fderiv ℝ (gradient H) x v) ≤ M*‖v‖^2)
    (hsm : s*m ≤ 1) :
    LipschitzWith ⟨1-s*m,sub_nonneg.mpr hsm⟩ (eulerDrift H s) := by
  have hg := (gradient_contDiff_one hH).differentiable (by norm_num)
  have hd (x : Point d) : fderiv ℝ (eulerDrift H s) x=
      ContinuousLinearMap.id ℝ (Point d)-s • fderiv ℝ (gradient H) x :=
    ((hasFDerivAt_id x).sub ((hg x).hasFDerivAt.const_smul s)).fderiv
  apply lipschitzWith_of_nnnorm_fderiv_le (differentiable_id.sub (hg.const_smul s))
  intro x
  change ‖fderiv ℝ (eulerDrift H s) x‖ ≤ 1-s*m
  rw [hd]
  change ‖ContinuousLinearMap.id ℝ (Point d)-s • fderiv ℝ (gradient H) x‖ ≤ 1-s*m
  have hsym : (ContinuousLinearMap.id ℝ (Point d)-s • fderiv ℝ (gradient H) x).IsSymmetric := by
    intro v w
    change inner ℝ (v-s • fderiv ℝ (gradient H) x v) w=inner ℝ v (w-s • fderiv ℝ (gradient H) x w)
    simp only [inner_sub_left,inner_sub_right,real_inner_smul_left,real_inner_smul_right]
    have he : inner ℝ (fderiv ℝ (gradient H) x v) w=inner ℝ v (fderiv ℝ (gradient H) x w) :=
      (ContDiff.isSymmetric_gradient_derivative hH x) v w
    rw [he]
  rw [ContinuousLinearMap.norm_eq_iSup_rayleighQuotient _ hsym]
  apply ciSup_le
  intro v
  by_cases hv : v=0
  · simp [hv,sub_nonneg.mpr hsm]
  have hp : 0 < ‖v‖^2 := sq_pos_of_pos (norm_pos_iff.mpr hv)
  rw [ContinuousLinearMap.rayleighQuotient,ContinuousLinearMap.reApplyInnerSelf_apply,real_inner_comm]
  simp only [RCLike.re_to_real,sub_apply,ContinuousLinearMap.id_apply,
    smul_apply,inner_sub_right,real_inner_smul_right,real_inner_self_eq_norm_sq]
  have hn : 0 ≤ ‖v‖^2-s*inner ℝ v (fderiv ℝ (gradient H) x v) := by
    have hh := mul_le_mul_of_nonneg_left (hess x v).2 hs
    have hb := mul_le_mul_of_nonneg_right hsM hp.le
    nlinarith
  rw [abs_of_nonneg (div_nonneg hn hp.le),div_le_iff₀ hp]
  have hh := mul_le_mul_of_nonneg_left (hess x v).1 hs
  nlinarith

def posteriorPotential (V : Point d → ℝ) (h : ℝ) (y z : Point d) : ℝ :=
  V z+‖z-y‖^2/(2*h)

lemma posterior_smooth {V : Point d → ℝ} (hV : Admissible V) (h : ℝ) (y : Point d) :
    ContDiff ℝ 2 (posteriorPotential V h y) :=
  hV.smooth.add (((contDiff_norm_sq ℝ).comp (contDiff_id.sub contDiff_const)).div_const _)

lemma posterior_gradient {V : Point d → ℝ} (hV : Admissible V) (h : ℝ) (y z : Point d) :
    gradient (posteriorPotential V h y) z=gradient V z+h⁻¹ • (z-y) := by
  apply HasGradientAt.gradient
  apply hasGradientAt_iff_hasFDerivAt.mpr
  have ha := (hasStrictFDerivAt_norm_sq (z-y)).hasFDerivAt.comp z
    ((hasFDerivAt_id z).sub (hasFDerivAt_const y z))
  have hd := (hV.smooth.differentiable (by norm_num) z).hasFDerivAt.add (ha.const_smul (2*h)⁻¹)
  convert! hd using 1
  · funext w
    simp only [posteriorPotential,Pi.add_apply,Pi.smul_apply,Function.comp_apply,Pi.sub_apply,id_eq,smul_eq_mul]
    ring
  ext v
  simp only [add_apply,smul_apply,
    ContinuousLinearMap.comp_apply,sub_apply,ContinuousLinearMap.id_apply,
    map_sub,sub_zero,smul_eq_mul,innerSL_apply_apply,
    InnerProductSpace.toDual_apply_apply,inner_add_left,real_inner_smul_left,inner_sub_left,←toDual_gradient]
  ring

lemma posterior_hessian {V : Point d → ℝ} (hV : Admissible V) (h : ℝ) (y z v : Point d) :
    fderiv ℝ (gradient (posteriorPotential V h y)) z v=fderiv ℝ (gradient V) z v+h⁻¹ • v := by
  have he : gradient (posteriorPotential V h y)=(fun z => gradient V z+h⁻¹ • (z-y)) :=
    funext (posterior_gradient hV h y)
  rw [he]
  have hd := (hV.contDiff_gradient.differentiable (by norm_num) z).hasFDerivAt.add
    (((hasFDerivAt_id z).sub (hasFDerivAt_const y z)).const_smul h⁻¹)
  change (fderiv ℝ (gradient V+h⁻¹ • (id-fun _ => y)) z) v=_
  rw [hd.fderiv]
  simp

lemma posterior_tail {V : Point d → ℝ} (hV : Admissible V) {h : ℝ} (hh : 0 < h) (y : Point d) :
    HasGaussianLowerTail (posteriorPotential V h y) := by
  refine ⟨1/2,by norm_num,0,fun z => ?_⟩
  dsimp [posteriorPotential]
  have hq := (hV.quadratic_bounds z).1
  have hn : 0 ≤ ‖z-y‖^2/(2*h) := by positivity
  linarith

lemma posterior_gradient_lipschitz {V : Point d → ℝ} (hV : Admissible V)
    {h : ℝ} (hh : 0 < h) (y : Point d) :
    LipschitzWith ⟨2+h⁻¹,by positivity⟩ (gradient (posteriorPotential V h y)) := by
  apply LipschitzWith.of_dist_le_mul
  intro x z
  simp only [posterior_gradient hV h y]
  have hb := dist_add_add_le (gradient V x) (h⁻¹ • (x-y)) (gradient V z) (h⁻¹ • (z-y))
  simp only [dist_smul₀,Real.norm_eq_abs,abs_of_pos (inv_pos.mpr hh),dist_sub_right] at hb
  have hg := hV.gradient_lipschitz.dist_le_mul x z
  change _ ≤ (2+h⁻¹)*dist x z
  norm_num at hg
  nlinarith

lemma norm_sq_growth_of_lipschitz {g : Point d → Point d} {L : ℝ≥0} (hg : LipschitzWith L g) :
    HasPolynomialGrowth (fun x => ‖g x‖^2) := by
  obtain ⟨C,hC,n,hb⟩ := growth_of_lipschitz hg
  refine ⟨2*C^2,by positivity,2*n,fun x => ?_⟩
  rw [Real.norm_eq_abs,abs_sq]
  have hs := pow_le_pow_left₀ (norm_nonneg _) (hb x) 2
  have hr := sq_nonneg (1-‖x‖^n)
  rw [mul_comm 2 n,pow_mul]
  nlinarith [mul_nonneg (sq_nonneg C) hr]

lemma posterior_gradient_integrable {V : Point d → ℝ} (hV : Admissible V)
    {h : ℝ} (hh : 0 < h) (y : Point d) :
    Integrable (fun z => ‖gradient (posteriorPotential V h y) z‖^2) (gibbs (posteriorPotential V h y)) :=
  integrable_polynomial_gibbs (posterior_smooth hV h y).continuous (posterior_tail hV hh y)
    ((posterior_gradient_lipschitz hV hh y).continuous.norm.pow 2)
    (norm_sq_growth_of_lipschitz (posterior_gradient_lipschitz hV hh y))
end LogConcaveSampling

end

end

section

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

variable {d : ℕ}

lemma posterior_euler_lipschitz {V : Point d → ℝ} (hV : Admissible V) {h : ℝ}
    (hh : 0 < h) (y : Point d) {s : ℝ} (hs : 0 ≤ s) (hsM : s*(2+h⁻¹) ≤ 1) :
    ∀ x z, dist (eulerDrift (posteriorPotential V h y) s x)
      (eulerDrift (posteriorPotential V h y) s z) ≤ (1-(1+h⁻¹)*s)*dist x z := by
  have hsm : s*(1+h⁻¹) ≤ 1 := by nlinarith
  have he := hessian_euler_contraction (posterior_smooth hV h y)
    (by positivity : 0 < 1+h⁻¹) hs hsM (fun x v => ?_) hsm
  · intro x z
    have hb := he.dist_le_mul x z
    change dist _ _ ≤ (1-s*(1+h⁻¹))*dist x z at hb
    convert! hb using 1
    ring
  · rw [posterior_hessian hV h y,inner_add_right,real_inner_smul_right,real_inner_self_eq_norm_sq]
    obtain ⟨hl,hu⟩ := hV.hessian_bounds x v
    constructor <;> nlinarith

theorem posterior_distanceCoupled {V : Point d → ℝ} (hV : Admissible V) {h : ℝ}
    (hh : 0 < h) (y z : Point d) :
    Coupling.DistanceCoupled (gibbs (posteriorPotential V h y))
      (gibbs (posteriorPotential V h z)) (dist y z/(1+h)) := by
  have hM : 0 < 2+h⁻¹ := by positivity
  have hm : 0 < 1+h⁻¹ := by positivity
  have hma : (1+h⁻¹)*(2+h⁻¹)⁻¹ ≤ 1 := by
    rw [←div_eq_mul_inv,div_le_one hM]
    linarith
  have hstep (u : Point d) (s : ℝ) (hs : 0 ≤ s) (hsa : s ≤ (2+h⁻¹)⁻¹) :=
    posterior_euler_lipschitz hV hh u hs (by
      have hsc := mul_le_mul_of_nonneg_right hsa hM.le
      rw [inv_mul_cancel₀ hM.ne'] at hsc
      exact hsc)
  have hpert (x : Point d) :
      ‖gradient (posteriorPotential V h y) x-gradient (posteriorPotential V h z) x‖ ≤ h⁻¹*dist y z := by
    rw [posterior_gradient hV h y,posterior_gradient hV h z,
      show gradient V x+h⁻¹ • (x-y)-(gradient V x+h⁻¹ • (x-z))=h⁻¹ • (z-y) by module,
      norm_smul,Real.norm_eq_abs,abs_of_pos (inv_pos.mpr hh),←dist_eq_norm,dist_comm z y]
  have he := gibbs_distanceCoupled_of_euler (posterior_smooth hV h y) (posterior_smooth hV h z)
    (posterior_gradient_lipschitz hV hh y) (posterior_gradient_lipschitz hV hh z)
    (partition_pos_of_continuous (posterior_smooth hV h y).continuous).ne'
    (partition_ne_top_of_integrable ((posterior_tail hV hh y).integrable_exp (posterior_smooth hV h y).continuous))
    (partition_pos_of_continuous (posterior_smooth hV h z).continuous).ne'
    (partition_ne_top_of_integrable ((posterior_tail hV hh z).integrable_exp (posterior_smooth hV h z).continuous))
    (posterior_gradient_integrable hV hh y) (posterior_gradient_integrable hV hh z)
    hm (inv_pos.mpr hM) hma (mul_nonneg (inv_pos.mpr hh).le dist_nonneg)
    (hstep y) (hstep z) hpert
  have hid : h⁻¹*dist y z/(1+h⁻¹)=dist y z/(1+h) := by
    field_simp
    ring
  rwa [hid] at he

lemma posterior_squaredCoupled {V : Point d → ℝ} (hV : Admissible V) {h : ℝ}
    (hh : 0 < h) (y z : Point d) :
    Coupling.SquaredAt (gibbs (posteriorPotential V h y))
      (gibbs (posteriorPotential V h z)) id id ((dist y z/(1+h))^2) :=
  (posterior_distanceCoupled hV hh y z).squared (div_nonneg dist_nonneg (by positivity))
end LogConcaveSampling

end

end

section

noncomputable section
namespace LogConcaveSampling
open MeasureTheory ProbabilityTheory Function
open scoped Classical ENNReal

variable {d : ℕ} {A : Type*} [MeasurableSpace A]

lemma measurable_gibbs_family {H : A → Point d → ℝ}
    (hH : Measurable (uncurry H)) : Measurable (fun a => gibbs (H a)) := by
  have hw : Measurable (fun p : A × Point d => gibbsDensity (H p.1) p.2) := by
    unfold gibbsDensity
    exact (Real.measurable_exp.comp hH.neg).ennreal_ofReal
  have hp : Measurable (fun a => partition (H a)) := hw.lintegral_prod_right
  apply Measure.measurable_of_measurable_coe
  intro s hs
  simp only [gibbs,Measure.smul_apply,smul_eq_mul,withDensity_apply _ hs]
  change Measurable (fun a => (partition (H a))⁻¹ * ∫⁻z in s,gibbsDensity (H a) z)
  exact hp.inv.mul (hw.lintegral_prod_right (ν:=volume.restrict s))

def gibbsKernel (H : A → Point d → ℝ) (hH : Measurable (uncurry H)) : Kernel A (Point d) where
  toFun a := gibbs (H a)
  measurable' := measurable_gibbs_family hH

lemma bounded_integrable {E : Type*} [MeasurableSpace E] {μ : Measure E}
    [IsFiniteMeasure μ] {f : E → ℝ} (hf : Measurable f) {C : ℝ} (hb : ∀x,|f x|≤C) :
    Integrable f μ := by
  exact (integrable_const C).mono' hf.aestronglyMeasurable
    (Filter.Eventually.of_forall (fun x => by simpa only [Real.norm_eq_abs] using hb x))

lemma bounded_integral {E : Type*} [MeasurableSpace E] {μ : Measure E}
    [IsProbabilityMeasure μ] {f : E → ℝ} {C : ℝ} (_ : 0≤C) (hb : ∀x,|f x|≤C) :
    |∫x,f x ∂μ|≤C := by
  rw [←Real.norm_eq_abs]
  exact (norm_integral_le_of_norm_le_const (Filter.Eventually.of_forall
    (fun x => by simpa only [Real.norm_eq_abs] using hb x))).trans (by simp)

lemma gibbs_family_integral_measurable {H : A → Point d → ℝ}
    (hH : Measurable (uncurry H)) {f : Point d → ℝ} (hf : Measurable f) :
    Measurable (fun a => ∫z,f z ∂gibbs (H a)) :=
  (hf.stronglyMeasurable.integral_kernel (κ:=gibbsKernel H hH)).measurable

def posteriorKernel (V : Point d → ℝ) (hV : Admissible V) (h : ℝ) : Kernel (Point d) (Point d) :=
  gibbsKernel (posteriorPotential V h) (by
    have hm := hV.smooth.continuous.measurable
    unfold uncurry posteriorPotential
    fun_prop)

lemma posteriorKernel_probability {V : Point d → ℝ} (hV : Admissible V) {h : ℝ}
    (hh : 0<h) : IsMarkovKernel (posteriorKernel V hV h) := by
  constructor
  intro y
  exact probability_gibbs_of_partition (partition_pos_of_continuous (posterior_smooth hV h y).continuous).ne'
    (partition_ne_top_of_integrable ((posterior_tail hV hh y).integrable_exp (posterior_smooth hV h y).continuous))

def jointPosteriorLaw (V : Point d → ℝ) (h : ℝ) : Measure (Point d × Point d) :=
  ((gibbs V).prod (stdGaussian (Point d))).map (fun p => (p.1,p.1+Real.sqrt h • p.2))

def noisedLaw (V : Point d → ℝ) (h : ℝ) : Measure (Point d) :=
  ((gibbs V).prod (stdGaussian (Point d))).map (fun p => p.1+Real.sqrt h • p.2)

lemma noisedLaw_probability {V : Point d → ℝ} (hV : Admissible V) (h : ℝ) :
    IsProbabilityMeasure (noisedLaw V h) := by
  let := hV.isProbabilityMeasure_gibbs
  unfold noisedLaw
  infer_instance

lemma jointPosteriorLaw_probability {V : Point d → ℝ} (hV : Admissible V) (h : ℝ) :
    IsProbabilityMeasure (jointPosteriorLaw V h) := by
  let := hV.isProbabilityMeasure_gibbs
  unfold jointPosteriorLaw
  infer_instance

lemma jointPosterior_fst {V : Point d → ℝ} (h : ℝ) :
    (jointPosteriorLaw V h).map Prod.fst=gibbs V := by
  rw [jointPosteriorLaw,Measure.map_map measurable_fst (by fun_prop)]
  simpa only [Function.comp_def,measure_univ,one_smul] using
    (Measure.map_fst_prod (μ:=gibbs V) (ν:=stdGaussian (Point d)))

lemma jointPosterior_snd {V : Point d → ℝ} (h : ℝ) :
    (jointPosteriorLaw V h).map Prod.snd=noisedLaw V h := by
  rw [jointPosteriorLaw,Measure.map_map measurable_snd (by fun_prop)]
  rfl

end LogConcaveSampling

end

end

end OAI