lean/OAI/Probability/Perceptron/Cascade/PoissonWeightedTotal.lean

import Mathlib
import OAI.Probability.Perceptron.Cascade.StablePoissonTotalLogMemLpTwo

namespace OAI

noncomputable section
open MeasureTheory ProbabilityTheory Filter Set
open scoped ENNReal NNReal Topology BigOperators BoundedContinuousFunction
namespace SphericalPerceptronFreeEnergy
@[fun_prop] lemma measurable_measure_restrict {S : Type*} [MeasurableSpace S]
    {E : Set S} (hE : MeasurableSet E) : Measurable (fun η : Measure S => η.restrict E) := by
  apply Measure.measurable_of_measurable_coe
  intro t ht
  simp only [Measure.restrict_apply ht]
  exact Measure.measurable_coe (ht.inter hE)

lemma poissonRandomMeasureLaw_mecke_finite {S : Type*} [MeasurableSpace S] [Nonempty S]
    (κ : Measure S) [IsFiniteMeasure κ]
    {H : Measure S × S → ℝ≥0∞} (hH : Measurable H) :
    (∫⁻ η, ∫⁻ x, H (η,x) ∂η ∂poissonRandomMeasureLaw κ) =
      ∫⁻ x, ∫⁻ η, H (Measure.dirac x + η,x) ∂poissonRandomMeasureLaw κ ∂κ := by
  rw [poissonRandomMeasureLaw_of_finite κ,finitePoissonLaw_mecke _ _ hH]
  calc
    _ = ∫⁻ x, ∫⁻ η, H (Measure.dirac x+η,x)
        ∂finitePoissonLaw (κ univ).toNNReal (finiteIntensityMarks κ)
        ∂((κ univ).toNNReal : ℝ≥0∞) • finiteIntensityMarks κ := by
      rw [lintegral_smul_measure]; rfl
    _ = _ := by rw [finiteIntensityMarks_smul κ]

lemma poissonRandomMeasureLaw_mecke_restrict {S : Type*} [MeasurableSpace S] [Nonempty S]
    (κ : Measure S) [SFinite κ] {E : Set S} (hE : MeasurableSet E) (hκ : κ E < ⊤)
    {H : Measure S × S → ℝ≥0∞} (hH : Measurable H) :
    (∫⁻ η, ∫⁻ x in E, H (η,x) ∂η ∂poissonRandomMeasureLaw κ) =
      ∫⁻ x in E, ∫⁻ η, H (Measure.dirac x + η,x) ∂poissonRandomMeasureLaw κ ∂κ := by
  let ν := κ.restrict E
  let ζ := κ.restrict Eᶜ
  let P := poissonRandomMeasureLaw ν
  let Q := poissonRandomMeasureLaw ζ
  have : IsFiniteMeasure ν := ⟨by simpa [ν] using hκ⟩
  have hsum : ν+ζ = κ := Measure.restrict_add_restrict_compl hE
  have hadd : Measurable (fun p : Measure S × Measure S => p.1+p.2) := by fun_prop
  have hPQ : (P.prod Q).map (fun p => p.1+p.2) = poissonRandomMeasureLaw κ := by
    dsimp [P,Q]
    rw [poissonRandomMeasureLaw_superposition]
    simp only [hsum]
  have hm : AEMeasurable (fun η : Measure S => ∫⁻ x in E, H (η,x) ∂η)
      (poissonRandomMeasureLaw κ) :=
    aemeasurable_randomMeasure_lintegral_of_finite (measurable_measure_restrict hE)
      (poissonRandomMeasureLaw_ae_restrict_finite κ hE hκ) hH
  have hPnull : ∀ᵐ η ∂P, η Eᶜ = 0 := by
    apply poissonRandomMeasureLaw_ae_null ν hE.compl
    simp [ν,Measure.restrict_apply,hE.compl]
  have hQnull : ∀ᵐ η ∂Q, η E = 0 := by
    apply poissonRandomMeasureLaw_ae_null ζ hE
    simp [ζ,Measure.restrict_apply,hE]
  have hPQnull : ∀ᵐ p : Measure S × Measure S ∂P.prod Q,
      p.1 Eᶜ = 0 ∧ p.2 E = 0 := by
    apply (Measure.ae_prod_iff_ae_ae
      ((measurableSet_eq_fun ((Measure.measurable_coe hE.compl).comp measurable_fst) measurable_const).inter
        (measurableSet_eq_fun ((Measure.measurable_coe hE).comp measurable_snd) measurable_const))).mpr
    filter_upwards [hPnull] with η hη
    filter_upwards [hQnull] with ξ hξ
    exact ⟨hη,hξ⟩
  have hrestrict (η ξ : Measure S) (hη : η Eᶜ = 0) (hξ : ξ E = 0) :
      (η+ξ).restrict E = η := by
    rw [Measure.restrict_add,Measure.restrict_eq_zero.mpr hξ,add_zero]
    have hh := Measure.restrict_add_restrict_compl (μ := η) hE
    rwa [Measure.restrict_eq_zero.mpr hη,add_zero] at hh
  have haefin : ∀ᵐ p : Measure S × Measure S ∂P.prod Q, p.1 univ < ⊤ := by
    apply (Measure.ae_prod_iff_ae_ae
      (measurableSet_lt ((Measure.measurable_coe MeasurableSet.univ).comp measurable_fst) measurable_const)).mpr
    filter_upwards [poissonRandomMeasureLaw_ae_restrict_finite ν MeasurableSet.univ
      (measure_lt_top ν univ)] with η hη
    exact ae_of_all _ fun _ => by simpa using hη
  have hmeas : AEMeasurable (fun p : Measure S × Measure S =>
      ∫⁻ x, H (p.1+p.2,x) ∂p.1) (P.prod Q) :=
    aemeasurable_randomMeasure_lintegral_of_finite measurable_fst haefin
      (hH.comp (by fun_prop : Measurable (fun p : (Measure S × Measure S) × S => (p.1.1+p.1.2,p.2))))
  calc
    _ = ∫⁻ p : Measure S × Measure S, ∫⁻ x in E, H (p.1+p.2,x) ∂(p.1+p.2) ∂P.prod Q := by
      rw [← hPQ] at hm ⊢
      exact lintegral_map' hm hadd.aemeasurable
    _ = ∫⁻ p : Measure S × Measure S, ∫⁻ x, H (p.1+p.2,x) ∂p.1 ∂P.prod Q := by
      apply lintegral_congr_ae
      filter_upwards [hPQnull] with p hp
      rw [hrestrict p.1 p.2 hp.1 hp.2]
    _ = ∫⁻ ξ, ∫⁻ η, ∫⁻ x, H (η+ξ,x) ∂η ∂P ∂Q := lintegral_prod_symm _ hmeas
    _ = ∫⁻ ξ, ∫⁻ x, ∫⁻ η, H (Measure.dirac x+η+ξ,x) ∂P ∂ν ∂Q := by
      apply lintegral_congr
      intro ξ
      exact poissonRandomMeasureLaw_mecke_finite ν (hH.comp
        (by fun_prop : Measurable (fun p : Measure S × S => (p.1+ξ,p.2))))
    _ = ∫⁻ x, ∫⁻ ξ, ∫⁻ η, H (Measure.dirac x+η+ξ,x) ∂P ∂Q ∂ν := by
      apply lintegral_lintegral_swap
      exact (hH.comp (by fun_prop : Measurable (fun p : (Measure S × S) × Measure S =>
        (Measure.dirac p.1.2+p.2+p.1.1,p.1.2)))).lintegral_prod_right'.aemeasurable
    _ = _ := by
      apply lintegral_congr
      intro x
      rw [← lintegral_prod_symm (μ := P) (ν := Q)
        (fun p : Measure S × Measure S => H (Measure.dirac x+p.1+p.2,x)) (hH.comp (by fun_prop : Measurable
        (fun p : Measure S × Measure S => (Measure.dirac x+p.1+p.2,x)))).aemeasurable]
      rw [← hPQ,lintegral_map (f := fun η : Measure S => H (Measure.dirac x+η,x)) (hH.comp (by fun_prop : Measurable
        (fun η : Measure S => (Measure.dirac x+η,x)))) hadd]
      apply lintegral_congr
      intro p
      rw [add_assoc]

lemma poissonRandomMeasureLaw_mecke {S : Type*} [MeasurableSpace S] [Nonempty S]
    (κ : Measure S) [SigmaFinite κ] {H : Measure S × S → ℝ≥0∞} (hH : Measurable H) :
    (∫⁻ η, ∫⁻ x, H (η,x) ∂η ∂poissonRandomMeasureLaw κ) =
      ∫⁻ x, ∫⁻ η, H (Measure.dirac x + η,x) ∂poissonRandomMeasureLaw κ ∂κ := by
  have hset (η : Measure S) : (∫⁻ x, H (η,x) ∂η) =
      ⨆ n : ℕ, ∫⁻ x in spanningSets κ n, H (η,x) ∂η := by
    rw [← setLIntegral_iUnion_of_directed _ (monotone_spanningSets κ).directed_le,
      iUnion_spanningSets,Measure.restrict_univ]
  simp_rw [hset]
  rw [lintegral_iSup']
  · simp_rw [poissonRandomMeasureLaw_mecke_restrict κ (measurableSet_spanningSets κ _)
      (measure_spanningSets_lt_top κ _) hH]
    rw [← setLIntegral_iUnion_of_directed _ (monotone_spanningSets κ).directed_le,
      iUnion_spanningSets,Measure.restrict_univ]
  · intro n
    exact aemeasurable_randomMeasure_lintegral_of_finite (measurable_measure_restrict (measurableSet_spanningSets κ n))
      (poissonRandomMeasureLaw_ae_restrict_finite κ (measurableSet_spanningSets κ n)
        (measure_spanningSets_lt_top κ n)) hH
  · exact ae_of_all _ fun η n m hnm => lintegral_mono_set (monotone_spanningSets κ hnm)

def poissonWeightedTotal {S : Type*} [MeasurableSpace S] (F : S → ℝ)
    (η : Measure (ℝ × S)) : ℝ :=
  (∫⁻ p, ENNReal.ofReal (Real.exp (p.1+F p.2)) ∂η).toReal

lemma poissonWeightedTotal_measurable {S : Type*} [MeasurableSpace S]
    {F : S → ℝ} (hF : Measurable F) : Measurable (poissonWeightedTotal F) :=
  (Measure.measurable_lintegral ((measurable_fst.add (hF.comp measurable_snd)).exp.ennreal_ofReal)).ennreal_toReal

lemma poissonWeightedTotal_eq {S : Type*} [MeasurableSpace S]
    {F : S → ℝ} (hF : Measurable F) (η : Measure (ℝ × S)) :
    poissonWeightedTotal F η = stablePoissonTotal (η.map (fun p => p.1+F p.2)) := by
  unfold poissonWeightedTotal stablePoissonTotal
  rw [lintegral_map (by fun_prop) (by fun_prop)]

lemma poissonWeightedTotal_add_const {S : Type*} [MeasurableSpace S]
    {F : S → ℝ} (_hF : Measurable F) (c : ℝ) (η : Measure (ℝ × S)) :
    poissonWeightedTotal (fun x => F x+c) η = Real.exp c * poissonWeightedTotal F η := by
  unfold poissonWeightedTotal
  simp_rw [show ∀ p : ℝ × S, p.1+(F p.2+c) = c+(p.1+F p.2) by intro p; ring,
    Real.exp_add,ENNReal.ofReal_mul (Real.exp_pos c).le]
  rw [lintegral_const_mul' _ _ ENNReal.ofReal_ne_top,ENNReal.toReal_mul,
    ENNReal.toReal_ofReal (Real.exp_pos c).le]

lemma normalized_mark_density_probability {S : Type*} [MeasurableSpace S]
    (ν : Measure S) {b : ℝ} {F : S → ℝ}
    (hI : Integrable (fun x => Real.exp (b*F x)) ν)
    (hM : (∫ x, Real.exp (b*F x) ∂ν) = 1) :
    IsProbabilityMeasure (ν.withDensity (fun x => ENNReal.ofReal (Real.exp (b*F x)))) := by
  constructor
  rw [withDensity_apply _ MeasurableSet.univ,Measure.restrict_univ,
    ← ofReal_integral_eq_lintegral_ofReal hI (ae_of_all _ fun x => (Real.exp_pos _).le),hM]
  simp

lemma stablePoisson_normalized_mark_projection {S : Type*} [MeasurableSpace S] [Nonempty S]
    (ν : Measure S) [IsProbabilityMeasure ν] {b : ℝ} (hb : 0 ≤ b)
    {F : S → ℝ} (hF : Measurable F)
    (hI : Integrable (fun x => Real.exp (b*F x)) ν)
    (hM : (∫ x, Real.exp (b*F x) ∂ν) = 1) :
    (poissonRandomMeasureLaw ((stableLogIntensity b).prod ν)).map
      (Measure.map (fun p : ℝ × S => p.1+F p.2)) =
        poissonRandomMeasureLaw (stableLogIntensity b) := by
  have : IsProbabilityMeasure (ν.withDensity (fun x => ENNReal.ofReal (Real.exp (b*F x)))) :=
    normalized_mark_density_probability ν hI hM
  have hm : Measurable (fun p : ℝ × S => p.1+F p.2) := measurable_fst.add (hF.comp measurable_snd)
  have he : (((stableLogIntensity b).prod ν).map (fun p : ℝ × S => p.1+F p.2)) =
      stableLogIntensity b := by
    change Measure.map (Prod.fst ∘ logMarkShift F) ((stableLogIntensity b).prod ν) = _
    rw [← Measure.map_map measurable_fst (logMarkShift_measurable hF),stableLogIntensity_mark_shift ν hb hF,
      Measure.map_fst_prod,measure_univ,one_smul]
  rw [poissonRandomMeasureLaw_map _ hm]
  simp only [he]

lemma poissonWeightedTotal_normalized_log_memLp {S : Type*} [MeasurableSpace S] [Nonempty S]
    (ν : Measure S) [IsProbabilityMeasure ν] {b : ℝ} (hb0 : 0 < b) (hb1 : b < 1)
    {F : S → ℝ} (hF : Measurable F)
    (hI : Integrable (fun x => Real.exp (b*F x)) ν)
    (hM : (∫ x, Real.exp (b*F x) ∂ν) = 1) :
    MemLp (fun η => Real.log (poissonWeightedTotal F η)) 2
      (poissonRandomMeasureLaw ((stableLogIntensity b).prod ν)) := by
  have hpres : MeasurePreserving (Measure.map (fun p : ℝ × S => p.1+F p.2))
      (poissonRandomMeasureLaw ((stableLogIntensity b).prod ν))
      (poissonRandomMeasureLaw (stableLogIntensity b)) :=
    ⟨Measure.measurable_map _ (measurable_fst.add (hF.comp measurable_snd)),
      stablePoisson_normalized_mark_projection ν hb0.le hF hI hM⟩
  simpa only [Function.comp_def,poissonWeightedTotal_eq hF] using
    (stablePoissonTotal_log_memLp_two hb0 hb1).comp_measurePreserving hpres

lemma poissonWeightedTotal_normalized_pos {S : Type*} [MeasurableSpace S] [Nonempty S]
    (ν : Measure S) [IsProbabilityMeasure ν] {b : ℝ} (hb0 : 0 < b) (hb1 : b < 1)
    {F : S → ℝ} (hF : Measurable F)
    (hI : Integrable (fun x => Real.exp (b*F x)) ν)
    (hM : (∫ x, Real.exp (b*F x) ∂ν) = 1) :
    ∀ᵐ η ∂poissonRandomMeasureLaw ((stableLogIntensity b).prod ν), 0 < poissonWeightedTotal F η := by
  have he := stablePoisson_normalized_mark_projection ν hb0.le hF hI hM
  have hh := stablePoissonTotal_pos hb0 hb1
  rw [← he] at hh
  have hh' := (ae_map_iff (Measure.measurable_map _
    (measurable_fst.add (hF.comp measurable_snd))).aemeasurable
      (measurableSet_lt measurable_const stablePoissonTotal_measurable)).mp hh
  simpa only [poissonWeightedTotal_eq hF, Pi.add_def, Function.comp_def] using hh'

lemma poissonWeightedTotal_normalized_log_mean {S : Type*} [MeasurableSpace S] [Nonempty S]
    (ν : Measure S) [IsProbabilityMeasure ν] {b : ℝ} (hb : 0 ≤ b)
    {F : S → ℝ} (hF : Measurable F)
    (hI : Integrable (fun x => Real.exp (b*F x)) ν)
    (hM : (∫ x, Real.exp (b*F x) ∂ν) = 1) :
    (∫ η, Real.log (poissonWeightedTotal F η)
      ∂poissonRandomMeasureLaw ((stableLogIntensity b).prod ν)) =
    ∫ η, Real.log (stablePoissonTotal η) ∂poissonRandomMeasureLaw (stableLogIntensity b) := by
  rw [← stablePoisson_normalized_mark_projection ν hb hF hI hM]
  have h := integral_map (μ := poissonRandomMeasureLaw ((stableLogIntensity b).prod ν))
    (Measure.measurable_map _ (measurable_fst.add (hF.comp measurable_snd))).aemeasurable
    stablePoissonTotal_measurable.log.aestronglyMeasurable
  simp only [Pi.add_def, Function.comp_def] at h
  rw [h]
  simp only [poissonWeightedTotal_eq hF]

lemma stablePoisson_log_recursion {S : Type*} [MeasurableSpace S] [Nonempty S]
    (ν : Measure S) [IsProbabilityMeasure ν] {b : ℝ} (hb0 : 0 < b) (hb1 : b < 1)
    {X : S → ℝ} (hX : Measurable X)
    (hI : Integrable (fun x => Real.exp (b*X x)) ν) :
    (∫ η, Real.log (poissonWeightedTotal X η / poissonWeightedTotal (fun _ => 0) η)
      ∂poissonRandomMeasureLaw ((stableLogIntensity b).prod ν)) =
    Real.log (∫ x, Real.exp (b*X x) ∂ν)/b := by
  let c := Real.log (∫ x, Real.exp (b*X x) ∂ν)/b
  let F := fun x => X x-c
  have hF : Measurable F := hX.sub_const c
  have hMpos := integral_exp_pos hI
  have hfac (x : S) : Real.exp (b*F x) = Real.exp (-b*c)*Real.exp (b*X x) := by
    dsimp [F]
    rw [← Real.exp_add]
    congr 1
    ring
  have hFI : Integrable (fun x => Real.exp (b*F x)) ν := by
    simp_rw [hfac]
    exact hI.const_mul _
  have hFM : (∫ x, Real.exp (b*F x) ∂ν) = 1 := by
    simp_rw [hfac]
    rw [integral_const_mul,show -b*c = -Real.log (∫ x, Real.exp (b*X x) ∂ν) by dsimp [c]; field_simp,
      Real.exp_neg,Real.exp_log hMpos,inv_mul_cancel₀ hMpos.ne']
  have h0I : Integrable (fun _ : S => Real.exp (b*0)) ν := by simp
  have h0M : (∫ _ : S, Real.exp (b*0) ∂ν) = 1 := by simp
  have hlogF := poissonWeightedTotal_normalized_log_memLp ν hb0 hb1 hF hFI hFM
  have hlog0 := poissonWeightedTotal_normalized_log_memLp ν hb0 hb1 measurable_const h0I h0M
  have hEq : (fun η => Real.log (poissonWeightedTotal X η / poissonWeightedTotal (fun _ => 0) η)) =ᵐ[
      poissonRandomMeasureLaw ((stableLogIntensity b).prod ν)]
      (fun η => c+Real.log (poissonWeightedTotal F η)-Real.log (poissonWeightedTotal (fun _ => 0) η)) := by
    filter_upwards [poissonWeightedTotal_normalized_pos ν hb0 hb1 hF hFI hFM,
      poissonWeightedTotal_normalized_pos ν hb0 hb1 measurable_const h0I h0M] with η hηF hη0
    have hs : poissonWeightedTotal X η = Real.exp c*poissonWeightedTotal F η := by
      convert poissonWeightedTotal_add_const hF c η using 1
      congr 1
      funext x
      dsimp [F]
      ring
    rw [Real.log_div (by rw [hs]; positivity) hη0.ne',hs,
      Real.log_mul (Real.exp_pos _).ne' hηF.ne',Real.log_exp]
  have he := integral_sub ((integrable_const c).add (hlogF.integrable (by norm_num)))
    (hlog0.integrable (by norm_num))
  have he' := integral_add (integrable_const c) (hlogF.integrable (by norm_num))
  simp only [Pi.add_apply] at he he'
  rw [integral_congr_ae hEq,he,he',
    poissonWeightedTotal_normalized_log_mean ν hb0.le hF hFI hFM,
    poissonWeightedTotal_normalized_log_mean ν hb0.le measurable_const h0I h0M]
  simp [c]

end SphericalPerceptronFreeEnergy

end

end OAI