lean/OAI/Probability/Perceptron/Sphere/SphereIsometryMap.lean

import Mathlib
import OAI.Probability.Perceptron.Variational.StableLogIntensity

namespace OAI

noncomputable section

open MeasureTheory ProbabilityTheory Filter Set
open scoped ENNReal NNReal Topology BigOperators BoundedContinuousFunction
open MeasureTheory ProbabilityTheory Set Filter
open scoped ENNReal NNReal BigOperators Topology RealInnerProductSpace
open scoped Pointwise
namespace SphericalPerceptronFreeEnergy
section SphereInvariance
variable {E : Type*} [NormedAddCommGroup E] [InnerProductSpace ℝ E]
  [FiniteDimensional ℝ E] [MeasurableSpace E] [BorelSpace E]

def sphereIsometryMap (e : E ≃ₗᵢ[ℝ] E) (x : Metric.sphere (0 : E) 1) :
    Metric.sphere (0 : E) 1 := ⟨e x, by simp⟩

omit [FiniteDimensional ℝ E] in
lemma sphereIsometryMap_measurable (e : E ≃ₗᵢ[ℝ] E) : Measurable (sphereIsometryMap e) :=
  (e.continuous.comp continuous_subtype_val).subtype_mk _ |>.measurable

omit [FiniteDimensional ℝ E] [MeasurableSpace E] [BorelSpace E] in
lemma sphereIsometryMap_preimage_cone (e : E ≃ₗᵢ[ℝ] E) (s : Set (Metric.sphere (0 : E) 1)) :
    Ioo (0:ℝ) 1 • (Subtype.val '' (sphereIsometryMap e ⁻¹' s)) =
      e ⁻¹' (Ioo (0:ℝ) 1 • (Subtype.val '' s)) := by
  ext x
  constructor
  · rintro ⟨r,hr,v,⟨u,hu,rfl⟩,rfl⟩
    exact ⟨r,hr,e u,⟨sphereIsometryMap e u,hu,rfl⟩,by simp⟩
  · rintro ⟨r,hr,v,⟨u,hu,rfl⟩,he⟩
    refine ⟨r,hr,e.symm u,⟨sphereIsometryMap e.symm u,?_,rfl⟩,?_⟩
    · simpa [sphereIsometryMap] using hu
    · apply e.injective
      simpa only [map_smul,LinearIsometryEquiv.apply_symm_apply] using he

lemma sphereIsometryMap_preserving (e : E ≃ₗᵢ[ℝ] E) :
    MeasurePreserving (sphereIsometryMap e) (volume : Measure E).toSphere (volume : Measure E).toSphere := by
  refine ⟨sphereIsometryMap_measurable e,?_⟩
  apply Measure.ext
  intro s hs
  rw [Measure.map_apply (sphereIsometryMap_measurable e) hs,
    Measure.toSphere_apply' _ ((sphereIsometryMap_measurable e) hs),Measure.toSphere_apply' _ hs,
    sphereIsometryMap_preimage_cone]
  congr 1
  exact e.measurePreserving.measure_preimage_emb e.toHomeomorph.measurableEmbedding _

end SphereInvariance

lemma unitSphereLaw_isometry_preserving {N : ℕ} (e : Spin N ≃ₗᵢ[ℝ] Spin N) :
    MeasurePreserving (sphereIsometryMap e) (unitSphereLaw N) (unitSphereLaw N) := by
  refine ⟨sphereIsometryMap_measurable e,?_⟩
  unfold unitSphereLaw
  rw [Measure.map_smul _ (sphereIsometryMap_measurable e).aemeasurable,
    (sphereIsometryMap_preserving e).map_eq]

lemma sphereLaw_isometry_preserving {N : ℕ} (e : Spin N ≃ₗᵢ[ℝ] Spin N) :
    MeasurePreserving e (sphereLaw N) (sphereLaw N) := by
  refine ⟨e.continuous.measurable,?_⟩
  have hm : Measurable (fun x : Metric.sphere (0 : Spin N) 1 => Real.sqrt (N:ℝ) • x.val) :=
    (continuous_subtype_val.const_smul (Real.sqrt (N:ℝ))).measurable
  rw [sphereLaw,Measure.map_map e.continuous.measurable hm]
  have hc : (e ∘ fun x : Metric.sphere (0 : Spin N) 1 => Real.sqrt (N:ℝ) • x.val) =
      (fun x : Metric.sphere (0 : Spin N) 1 => Real.sqrt (N:ℝ) • x.val) ∘ sphereIsometryMap e := by
    funext x
    exact e.map_smul _ _
  rw [hc]
  rw [← Measure.map_map hm (sphereIsometryMap_measurable e),
    (unitSphereLaw_isometry_preserving e).map_eq]

section RotationCalculus
variable {E : Type*} [NormedAddCommGroup E] [InnerProductSpace ℝ E]
  [FiniteDimensional ℝ E]

noncomputable def skewFlow (A : E →L[ℝ] E) (hA : A ∈ skewAdjoint (E →L[ℝ] E)) (t : ℝ) : E ≃ₗᵢ[ℝ] E := by
  letI : NormedAlgebra ℚ (E →L[ℝ] E) := NormedAlgebra.restrictScalars ℚ ℝ (E →L[ℝ] E)
  exact Unitary.linearIsometryEquiv ⟨NormedSpace.exp (t • A),
    NormedSpace.exp_mem_unitary_of_mem_skewAdjoint (by
      rw [skewAdjoint.mem_iff] at hA ⊢
      simp [hA])⟩

lemma skewFlow_apply (A : E →L[ℝ] E) (hA : A ∈ skewAdjoint (E →L[ℝ] E)) (t : ℝ) (x : E) :
    skewFlow A hA t x = NormedSpace.exp (t • A) x := rfl

lemma skewFlow_zero (A : E →L[ℝ] E) (hA : A ∈ skewAdjoint (E →L[ℝ] E)) (x : E) :
    skewFlow A hA 0 x = x := by simp [skewFlow_apply]

lemma skewFlow_deriv (A : E →L[ℝ] E) (hA : A ∈ skewAdjoint (E →L[ℝ] E)) (t : ℝ) (x : E) :
    HasDerivAt (fun u => skewFlow A hA u x) (A (skewFlow A hA t x)) t := by
  simpa only [skewFlow_apply,mul_apply_eq_comp,map_zero,
    add_zero] using (hasDerivAt_exp_smul_const' A t).clm_apply (hasDerivAt_const t x)

variable [MeasurableSpace E] [BorelSpace E]

lemma integrable_of_continuous_sphere_support (μ : Measure E) [IsFiniteMeasure μ] {R : ℝ}
    (hR : ∀ᵐ x ∂μ, ‖x‖ ≤ R) {f : E → ℝ} (hf : Continuous f) : Integrable f μ := by
  obtain ⟨C,hC⟩ := (isCompact_closedBall (0:E) R).exists_bound_of_continuousOn hf.continuousOn
  exact Integrable.of_bound hf.aestronglyMeasurable C (hR.mono fun x hx =>
    hC x (by simpa only [Metric.mem_closedBall,dist_zero_right] using hx))

lemma invariant_skew_integral_zero (μ : Measure E) [IsFiniteMeasure μ] {R : ℝ}
    (hR : ∀ᵐ x ∂μ, ‖x‖ ≤ R) (A : E →L[ℝ] E) (hA : A ∈ skewAdjoint (E →L[ℝ] E))
    (hμ : ∀ t, MeasurePreserving (skewFlow A hA t) μ μ) {f : E → ℝ} (hf : ContDiff ℝ 1 f) :
    ∫ x, fderiv ℝ f x (A x) ∂μ = 0 := by
  obtain ⟨C,hC⟩ := (isCompact_closedBall (0:E) R).exists_bound_of_continuousOn
    (hf.continuous_fderiv (by norm_num)).continuousOn
  have hDf (t : ℝ) : Continuous (fun x => fderiv ℝ f (skewFlow A hA t x) (A (skewFlow A hA t x))) :=
    ((hf.continuous_fderiv (by norm_num)).comp (skewFlow A hA t).continuous).clm_apply
      (A.continuous.comp (skewFlow A hA t).continuous)
  have hder := (hasDerivAt_integral_of_dominated_loc_of_deriv_le
    (μ := μ) (s := Set.univ) (x₀ := (0:ℝ))
    (F := fun t x => f (skewFlow A hA t x))
    (F' := fun t x => fderiv ℝ f (skewFlow A hA t x) (A (skewFlow A hA t x)))
    (bound := fun _ => max C 0 * (‖A‖ * R)) (Filter.univ_mem)
    (Filter.Eventually.of_forall fun t => (hf.continuous.comp (skewFlow A hA t).continuous).aestronglyMeasurable)
    (integrable_of_continuous_sphere_support μ hR (hf.continuous.comp (skewFlow A hA 0).continuous))
    ((hDf 0).aestronglyMeasurable) (hR.mono fun x hx t _ => ?_) (integrable_const _)
    (Filter.Eventually.of_forall fun x t _ =>
      (hf.differentiable (by norm_num) _).hasFDerivAt.comp_hasDerivAt t (skewFlow_deriv A hA t x))).2
  · have hconst (t : ℝ) : (∫ x, f (skewFlow A hA t x) ∂μ) = ∫ x, f x ∂μ :=
      (hμ t).integral_comp (skewFlow A hA t).toHomeomorph.measurableEmbedding f
    have hc : HasDerivAt (fun t : ℝ => ∫ x, f (skewFlow A hA t x) ∂μ) 0 0 := by
      simp_rw [hconst]
      exact hasDerivAt_const _ _
    simpa only [skewFlow_zero] using hder.unique hc
  · have hb : ‖fderiv ℝ f (skewFlow A hA t x)‖ ≤ max C 0 :=
      (hC _ (by simpa only [Metric.mem_closedBall,dist_zero_right,LinearIsometryEquiv.norm_map] using hx)).trans (le_max_left _ _)
    calc
      ‖fderiv ℝ f (skewFlow A hA t x) (A (skewFlow A hA t x))‖ ≤
          ‖fderiv ℝ f (skewFlow A hA t x)‖ * ‖A (skewFlow A hA t x)‖ := ContinuousLinearMap.le_opNorm _ _
      _ ≤ max C 0 * (‖A‖ * R) := mul_le_mul hb
        ((A.le_opNorm _).trans (by rw [LinearIsometryEquiv.norm_map]; gcongr)) (norm_nonneg _) (le_max_right _ _)

noncomputable def planeSkew (a y : E) : E →L[ℝ] E :=
  InnerProductSpace.rankOne ℝ a y - InnerProductSpace.rankOne ℝ y a

omit [MeasurableSpace E] [BorelSpace E] in
lemma planeSkew_mem (a y : E) : planeSkew a y ∈ skewAdjoint (E →L[ℝ] E) := by
  rw [skewAdjoint.mem_iff,planeSkew,star_sub,ContinuousLinearMap.star_eq_adjoint,
    ContinuousLinearMap.star_eq_adjoint,InnerProductSpace.adjoint_rankOne,InnerProductSpace.adjoint_rankOne]
  abel

omit [FiniteDimensional ℝ E] [MeasurableSpace E] [BorelSpace E] in
lemma planeSkew_apply (a y x : E) : planeSkew a y x = inner ℝ y x • a - inner ℝ a x • y := by
  simp [planeSkew,InnerProductSpace.rankOne_apply]

omit [FiniteDimensional ℝ E] [MeasurableSpace E] [BorelSpace E] in
lemma rotation_product_deriv {f : E → ℝ} (hf : ContDiff ℝ 1 f) (a y x : E) :
    fderiv ℝ (fun z => inner ℝ a z * f z) x (planeSkew a y x) =
      inner ℝ a (planeSkew a y x) * f x + inner ℝ a x * fderiv ℝ f x (planeSkew a y x) := by
  have hh := ((innerSL ℝ a).hasFDerivAt.mul (hf.differentiable (by norm_num) x).hasFDerivAt).fderiv
  have hh' : fderiv ℝ (fun z => inner ℝ a z * f z) x =
      (inner ℝ a x) • fderiv ℝ f x + f x • (innerSL ℝ a) := by
    simpa only [Pi.mul_def,coe_innerSL_apply,innerSL_apply_apply] using hh
  rw [hh']
  simp [mul_comm,add_comm]

omit [FiniteDimensional ℝ E] [MeasurableSpace E] [BorelSpace E] in
lemma sum_planeSkew (ι : Type*) [Fintype ι] (b : OrthonormalBasis ι ℝ E) (x y : E) :
    ∑ i, inner ℝ (b i) x • planeSkew (b i) y x =
      inner ℝ y x • x - (‖x‖^2) • y := by
  have hn : ∑ i, (inner ℝ (b i) x)^2 = ‖x‖^2 := by
    simpa only [real_inner_comm x,pow_two,real_inner_self_eq_norm_sq] using b.sum_inner_mul_inner x x
  simp_rw [planeSkew_apply,smul_sub,smul_smul]
  rw [Finset.sum_sub_distrib]
  congr 1
  · calc
      _ = ∑ i, inner ℝ y x • (inner ℝ (b i) x • b i) := by
        apply Finset.sum_congr rfl
        intro i _
        rw [smul_smul,mul_comm]
      _ = _ := by rw [← Finset.smul_sum,b.sum_repr' x]
  · rw [← Finset.sum_smul,← hn]
    simp only [pow_two]

omit [FiniteDimensional ℝ E] [MeasurableSpace E] [BorelSpace E] in
lemma sum_planeSkew_divergence (ι : Type*) [Fintype ι] (b : OrthonormalBasis ι ℝ E) (x y : E) :
    ∑ i, inner ℝ (b i) (planeSkew (b i) y x) = (Fintype.card ι - 1 : ℝ) * inner ℝ y x := by
  simp_rw [planeSkew_apply,inner_sub_right,inner_smul_right,b.inner_eq_one,mul_one]
  rw [Finset.sum_sub_distrib,Finset.sum_const,Finset.card_univ,nsmul_eq_mul]
  have hb : (∑ i, inner ℝ (b i) x * inner ℝ (b i) y) = inner ℝ y x := by
    calc
      _ = ∑ i, inner ℝ y (b i) * inner ℝ (b i) x := by
        apply Finset.sum_congr rfl
        intro i _
        rw [real_inner_comm y (b i),mul_comm]
      _ = _ := b.sum_inner_mul_inner y x
  rw [hb]
  ring

lemma invariant_tangent_integral (μ : Measure E) [IsFiniteMeasure μ] {R : ℝ}
    (hR : ∀ᵐ x ∂μ, ‖x‖ ≤ R) (hμ : ∀ e : E ≃ₗᵢ[ℝ] E, MeasurePreserving e μ μ)
    (ι : Type*) [Fintype ι] (b : OrthonormalBasis ι ℝ E) (y : E) {f : E → ℝ} (hf : ContDiff ℝ 1 f) :
    ∫ x, fderiv ℝ f x ((‖x‖^2) • y - inner ℝ y x • x) ∂μ =
      ∫ x, (Fintype.card ι - 1 : ℝ) * inner ℝ y x * f x ∂μ := by
  let F : ι → E → ℝ := fun i x => inner ℝ (b i) x * f x
  have hF (i) : ContDiff ℝ 1 (F i) := (innerSL ℝ (b i)).contDiff.mul hf
  have hI (i) : Integrable (fun x => fderiv ℝ (F i) x (planeSkew (b i) y x)) μ :=
    integrable_of_continuous_sphere_support μ hR
      (((hF i).continuous_fderiv (by norm_num)).clm_apply (planeSkew (b i) y).continuous)
  have hzero (i) := invariant_skew_integral_zero μ hR (planeSkew (b i) y) (planeSkew_mem _ _)
    (fun t => hμ (skewFlow _ (planeSkew_mem _ _) t)) (hF i)
  have halg (x) : (∑ i, fderiv ℝ (F i) x (planeSkew (b i) y x)) =
      (Fintype.card ι - 1 : ℝ) * inner ℝ y x * f x -
        fderiv ℝ f x ((‖x‖^2) • y - inner ℝ y x • x) := by
    simp_rw [F,rotation_product_deriv hf,Finset.sum_add_distrib]
    rw [← Finset.sum_mul,sum_planeSkew_divergence]
    have hh : (∑ i, inner ℝ (b i) x * fderiv ℝ f x (planeSkew (b i) y x)) =
        fderiv ℝ f x (inner ℝ y x • x - (‖x‖^2) • y) := by
      rw [← sum_planeSkew ι b x y,map_sum]
      simp only [map_smul,smul_eq_mul]
    rw [hh,map_sub,map_sub]
    ring
  have hi₁ := integrable_of_continuous_sphere_support μ hR
    (show Continuous (fun x => (Fintype.card ι - 1 : ℝ)*inner ℝ y x*f x) by fun_prop)
  have hi₂ := integrable_of_continuous_sphere_support μ hR
    (show Continuous (fun x => fderiv ℝ f x ((‖x‖^2) • y - inner ℝ y x • x)) from
      (hf.continuous_fderiv (by norm_num)).clm_apply (by fun_prop))
  have he : (∫ x, (Fintype.card ι - 1 : ℝ)*inner ℝ y x*f x ∂μ) -
      (∫ x, fderiv ℝ f x ((‖x‖^2) • y - inner ℝ y x • x) ∂μ) = 0 := by
    rw [← integral_sub hi₁ hi₂]
    simp_rw [← halg]
    rw [integral_finsetSum _ (fun i _ => hI i)]
    simp only [hzero,Finset.sum_const_zero]
  linarith

end RotationCalculus
lemma sphereLaw_ae_norm (N : ℕ) : ∀ᵐ x ∂sphereLaw N, ‖x‖ = Real.sqrt (N:ℝ) := by
  have hm : Measurable (fun x : Metric.sphere (0 : Spin N) 1 => Real.sqrt (N:ℝ) • x.val) :=
    (continuous_subtype_val.const_smul (Real.sqrt (N:ℝ))).measurable
  rw [sphereLaw,ae_map_iff hm.aemeasurable (measurableSet_eq_fun continuous_norm.measurable measurable_const)]
  exact Filter.Eventually.of_forall fun x => by
    have hx : ‖x.val‖ = 1 := by simpa only [Metric.mem_sphere,dist_zero_right] using x.property
    simp only [norm_smul,Real.norm_eq_abs,abs_of_nonneg (Real.sqrt_nonneg _),hx,mul_one]

local instance (N : ℕ) : IsFiniteMeasure (sphereLaw N) := by
  unfold sphereLaw unitSphereLaw
  infer_instance

lemma sphere_integrable_of_continuous (N : ℕ) {f : Spin (N+1) → ℝ} (hf : Continuous f) :
    Integrable f (sphereLaw (N+1)) :=
  integrable_of_continuous_sphere_support _ ((sphereLaw_ae_norm (N+1)).mono fun _ hx => hx.le) hf

lemma sphere_tangent_integral (N : ℕ) (y : Spin (N+1)) {f : Spin (N+1) → ℝ} (hf : ContDiff ℝ 1 f) :
    ∫ x, fderiv ℝ f x (((N+1:ℕ):ℝ) • y - inner ℝ y x • x) ∂sphereLaw (N+1) =
      (N:ℝ) * ∫ x, inner ℝ y x * f x ∂sphereLaw (N+1) := by
  have hh := invariant_tangent_integral (sphereLaw (N+1))
    ((sphereLaw_ae_norm (N+1)).mono fun _ hx => hx.le) (fun e => sphereLaw_isometry_preserving e)
    (Fin (N+1)) (EuclideanSpace.basisFun (Fin (N+1)) ℝ) y hf
  calc
    _ = ∫ x, fderiv ℝ f x ((‖x‖^2) • y - inner ℝ y x • x) ∂sphereLaw (N+1) := by
      apply integral_congr_ae
      filter_upwards [sphereLaw_ae_norm (N+1)] with x hx
      rw [hx,Real.sq_sqrt (by positivity)]
    _ = _ := by simpa only [Fintype.card_fin,Nat.cast_add,Nat.cast_one,add_sub_cancel_right,
      mul_assoc,integral_const_mul] using hh

def sphereOverlap {N : ℕ} (x y : Spin N) : ℝ := inner ℝ y x / (N:ℝ)

lemma sphere_tangent_integral_normalized (N : ℕ) (y : Spin (N+1)) {f : Spin (N+1) → ℝ}
    (hf : ContDiff ℝ 1 f) :
    ∫ x, fderiv ℝ f x (y - sphereOverlap x y • x) ∂sphereLaw (N+1) =
      (N:ℝ) * ∫ x, sphereOverlap x y * f x ∂sphereLaw (N+1) := by
  have hd : ((N+1:ℕ):ℝ) ≠ 0 := by positivity
  apply mul_left_cancel₀ hd
  rw [← integral_const_mul]
  have he (x : Spin (N+1)) : ((N+1:ℕ):ℝ) * fderiv ℝ f x (y - sphereOverlap x y • x) =
      fderiv ℝ f x (((N+1:ℕ):ℝ) • y - inner ℝ y x • x) := by
    rw [← smul_eq_mul,← map_smul,smul_sub,smul_smul]
    simp only [sphereOverlap,mul_div_cancel₀ _ hd]
  simp_rw [he]
  rw [sphere_tangent_integral N y hf]
  have hr : (∫ x, inner ℝ y x*f x ∂sphereLaw (N+1)) =
      ((N+1:ℕ):ℝ) * ∫ x, sphereOverlap x y * f x ∂sphereLaw (N+1) := by
    rw [← integral_const_mul]
    congr 1
    funext x
    dsimp [sphereOverlap]
    field_simp
  rw [hr]
  ring

lemma sphereOverlap_hasFDerivAt (N : ℕ) (y x : Spin (N+1)) :
    HasFDerivAt (fun z => sphereOverlap z y) (((N+1:ℕ):ℝ)⁻¹ • innerSL ℝ y) x := by
  simpa only [sphereOverlap,Pi.smul_def,smul_eq_mul,div_eq_mul_inv,mul_comm,coe_innerSL_apply] using
    (innerSL ℝ y).hasFDerivAt.const_smul (((N+1:ℕ):ℝ)⁻¹)

lemma sphereOverlap_tangent_deriv (N : ℕ) (y : Spin (N+1)) (hy : ‖y‖^2 = ((N+1:ℕ):ℝ))
    (x : Spin (N+1)) :
    ((((N+1:ℕ):ℝ)⁻¹ • innerSL ℝ y) (y - sphereOverlap x y • x)) = 1 - sphereOverlap x y ^ 2 := by
  have hd : ((N+1:ℕ):ℝ) ≠ 0 := by positivity
  simp only [smul_apply,innerSL_apply_apply,inner_sub_right,inner_smul_right,
    real_inner_self_eq_norm_sq,hy,smul_eq_mul,sphereOverlap]
  field_simp

lemma sphere_gibbs_tangent_identity (N : ℕ) (y : Spin (N+1)) (hy : ‖y‖^2 = ((N+1:ℕ):ℝ))
    {H : Spin (N+1) → ℝ} (hH : ContDiff ℝ 1 H) {G : ℝ → ℝ} (hG : ContDiff ℝ 1 G) :
    (N:ℝ) * (∫ x, sphereOverlap x y * (G (sphereOverlap x y) * Real.exp (H x)) ∂sphereLaw (N+1)) =
      ∫ x, (deriv G (sphereOverlap x y) * (1-sphereOverlap x y^2) +
        G (sphereOverlap x y)*fderiv ℝ H x (y-sphereOverlap x y • x))*Real.exp (H x) ∂sphereLaw (N+1) := by
  let F : Spin (N+1) → ℝ := fun x => G (sphereOverlap x y) * Real.exp (H x)
  have hR : ContDiff ℝ 1 (fun x : Spin (N+1) => sphereOverlap x y) := by
    unfold sphereOverlap
    exact (innerSL ℝ y).contDiff.div_const _
  have hF : ContDiff ℝ 1 F := (hG.comp hR).mul hH.exp
  rw [← sphere_tangent_integral_normalized N y hF]
  apply integral_congr_ae
  exact Filter.Eventually.of_forall fun x => by
    have hh := (((hG.differentiable (by norm_num) (sphereOverlap x y)).hasDerivAt.comp_hasFDerivAt x
      (sphereOverlap_hasFDerivAt N y x)).mul (hH.differentiable (by norm_num) x).hasFDerivAt.exp).fderiv
    have he : fderiv ℝ F x = G (sphereOverlap x y) • (Real.exp (H x) • fderiv ℝ H x) +
        Real.exp (H x) • (deriv G (sphereOverlap x y) • (((N+1:ℕ):ℝ)⁻¹ • innerSL ℝ y)) := by
      simpa only [F,Pi.mul_def,Function.comp_def] using hh
    dsimp only
    rw [he]
    simp only [add_apply,smul_apply,smul_eq_mul,
      sphereOverlap_tangent_deriv N y hy]
    ring

def poissonMarkMeasure {S : Type*} [MeasurableSpace S] (η : Measure (ℝ × S)) : Measure S :=
  (η.withDensity (fun p => ENNReal.ofReal (Real.exp p.1))).map Prod.snd

def normalizedMeasure {S : Type*} [MeasurableSpace S] (μ : Measure S) : Measure S :=
  (μ univ)⁻¹ • μ

lemma measurable_measure_withDensity_fixed {S : Type*} [MeasurableSpace S]
    {f : S → ℝ≥0∞} (hf : Measurable f) : Measurable (fun μ : Measure S => μ.withDensity f) := by
  refine Measure.measurable_of_measurable_coe _ fun s hs => ?_
  simp only [withDensity_apply _ hs,← lintegral_indicator hs]
  exact Measure.measurable_lintegral (hf.indicator hs)

lemma poissonMarkMeasure_measurable {S : Type*} [MeasurableSpace S] :
    Measurable (poissonMarkMeasure (S := S)) :=
  (Measure.measurable_map _ measurable_snd).comp
    (measurable_measure_withDensity_fixed (by fun_prop))

lemma normalizedMeasure_measurable {S : Type*} [MeasurableSpace S] :
    Measurable (normalizedMeasure (S := S)) := by
  refine Measure.measurable_of_measurable_coe _ fun s hs => ?_
  change Measurable (fun μ : Measure S => (μ univ)⁻¹ * μ s)
  exact (Measure.measurable_coe MeasurableSet.univ).inv.mul (Measure.measurable_coe hs)

lemma normalizedMeasure_probability {S : Type*} [MeasurableSpace S] (μ : Measure S)
    (h0 : μ univ ≠ 0) (hf : μ univ ≠ ⊤) : IsProbabilityMeasure (normalizedMeasure μ) := by
  constructor
  change (μ univ)⁻¹ * μ univ = 1
  exact ENNReal.inv_mul_cancel h0 hf

lemma normalizedMeasure_smul {S : Type*} [MeasurableSpace S] (μ : Measure S)
    {c : ℝ≥0∞} (hc0 : c ≠ 0) (hcf : c ≠ ⊤) :
    normalizedMeasure (c • μ) = normalizedMeasure μ := by
  unfold normalizedMeasure
  rw [Measure.smul_apply,smul_eq_mul,ENNReal.mul_inv (Or.inl hc0) (Or.inl hcf),smul_smul]
  congr 1
  calc
    c⁻¹ * (μ univ)⁻¹ * c = c⁻¹*c*(μ univ)⁻¹ := by ac_rfl
    _ = _ := by rw [ENNReal.inv_mul_cancel hc0 hcf,one_mul]

lemma map_withDensity_comp {S T : Type*} [MeasurableSpace S] [MeasurableSpace T]
    (μ : Measure S) {f : S → T} (hf : Measurable f) {g : T → ℝ≥0∞} (hg : Measurable g) :
    (μ.map f).withDensity g = (μ.withDensity (g ∘ f)).map f := by
  apply Measure.ext_of_lintegral
  intro h hh
  rw [lintegral_withDensity_eq_lintegral_mul _ hg hh,
    lintegral_map (hg.mul hh) hf,lintegral_map hh hf]
  rw [lintegral_withDensity_eq_lintegral_mul _ (hg.comp hf) (show Measurable (fun x => h (f x)) from hh.comp hf)]
  rfl

lemma poissonMarkMeasure_shift {S : Type*} [MeasurableSpace S]
    (η : Measure (ℝ × S)) {F : S → ℝ} (hF : Measurable F) :
    poissonMarkMeasure (η.map (logMarkShift F)) =
      (poissonMarkMeasure η).withDensity (fun s => ENNReal.ofReal (Real.exp (F s))) := by
  unfold poissonMarkMeasure
  rw [map_withDensity_comp _ (logMarkShift_measurable hF) (by fun_prop),
    Measure.map_map measurable_snd (logMarkShift_measurable hF),
    map_withDensity_comp _ measurable_snd (by fun_prop),← withDensity_mul _ (by fun_prop) (by fun_prop)]
  congr 1
  congr 1
  funext p
  simp only [Function.comp_def,logMarkShift,Real.exp_add,ENNReal.ofReal_mul (Real.exp_pos _).le,Pi.mul_apply]

lemma poissonMarkMeasure_mass {S : Type*} [MeasurableSpace S] (η : Measure (ℝ × S)) :
    poissonMarkMeasure η univ = ∫⁻ p, ENNReal.ofReal (Real.exp p.1) ∂η := by
  unfold poissonMarkMeasure
  rw [Measure.map_apply measurable_snd MeasurableSet.univ]
  simp only [preimage_univ,withDensity_apply _ MeasurableSet.univ,Measure.restrict_univ]

lemma poissonMarkMeasure_probability {S : Type*} [MeasurableSpace S] [Nonempty S]
    (ν : Measure S) [IsProbabilityMeasure ν] {b : ℝ} (hb0 : 0 < b) (hb1 : b < 1) :
    ∀ᵐ η ∂poissonRandomMeasureLaw ((stableLogIntensity b).prod ν),
      IsProbabilityMeasure (normalizedMeasure (poissonMarkMeasure η)) := by
  have he : (poissonRandomMeasureLaw ((stableLogIntensity b).prod ν)).map (Measure.map Prod.fst) =
      poissonRandomMeasureLaw (stableLogIntensity b) := by
    rw [poissonRandomMeasureLaw_map _ measurable_fst]
    simp only [Measure.map_fst_prod,measure_univ,one_smul]
  have hh : ∀ᵐ η ∂poissonRandomMeasureLaw (stableLogIntensity b),
      (∫⁻ x, ENNReal.ofReal (Real.exp x) ∂η) ≠ 0 ∧
      (∫⁻ x, ENNReal.ofReal (Real.exp x) ∂η) ≠ ⊤ := by
    filter_upwards [stablePoisson_total_positive hb0,stablePoisson_total_finite hb0 hb1] with η h1 h2
    exact ⟨h1.ne',h2⟩
  rw [← he] at hh
  have hmeas : Measurable (fun η : Measure ℝ => ∫⁻ x, ENNReal.ofReal (Real.exp x) ∂η) :=
    Measure.measurable_lintegral (by fun_prop)
  have hh' := (ae_map_iff (Measure.measurable_map _ measurable_fst).aemeasurable
    (((measurableSet_eq_fun hmeas measurable_const).compl).inter
      ((measurableSet_eq_fun hmeas measurable_const).compl))).mp hh
  filter_upwards [hh'] with η hη
  change (∫⁻ x, ENNReal.ofReal (Real.exp x) ∂η.map Prod.fst) ≠ 0 ∧
    (∫⁻ x, ENNReal.ofReal (Real.exp x) ∂η.map Prod.fst) ≠ ⊤ at hη
  rw [lintegral_map (by fun_prop) measurable_fst] at hη
  exact normalizedMeasure_probability _ (by simpa only [poissonMarkMeasure_mass] using hη.1) (by simpa only [poissonMarkMeasure_mass] using hη.2)

lemma stablePoisson_gibbs_measure_law {S : Type*} [MeasurableSpace S] [Nonempty S]
    (ν : Measure S) [IsProbabilityMeasure ν] {b : ℝ} (hb : 0 ≤ b)
    {F : S → ℝ} (hF : Measurable F) :
    (poissonRandomMeasureLaw ((stableLogIntensity b).prod ν)).map
      (fun η => normalizedMeasure ((poissonMarkMeasure η).withDensity
        (fun s => ENNReal.ofReal (Real.exp (F s))))) =
    (poissonRandomMeasureLaw ((stableLogIntensity b).prod
      (ν.withDensity (fun s => ENNReal.ofReal (Real.exp (b*F s)))))).map
        (fun η => normalizedMeasure (poissonMarkMeasure η)) := by
  rw [← stablePoisson_mark_shift ν hb hF,
    Measure.map_map (show Measurable (fun η => normalizedMeasure (poissonMarkMeasure η)) from
      normalizedMeasure_measurable.comp poissonMarkMeasure_measurable)
      (show Measurable (Measure.map (logMarkShift F)) from
        Measure.measurable_map _ (logMarkShift_measurable hF))]
  congr 1
  funext η
  simp only [Function.comp_def,poissonMarkMeasure_shift η hF]

open Matrix
open scoped RealInnerProductSpace MatrixOrder

end SphericalPerceptronFreeEnergy

end

end OAI