lean/OAI/Dynamics/SmoothObstruction/StandardProbability.lean

import Mathlib

namespace OAI

section

open MeasureTheory ProbabilityTheory Set ENNReal unitInterval Filter Topology Function

namespace SmoothObstruction

/- The quantile construction gives a measurable map from the unit interval
with the prescribed probability law. Injectivity yields a measurable
isomorphism on conull subsets for nonatomic laws. -/

noncomputable def unitQuantile (μ : Measure I) (t : I) : I :=
  sSup {x | μ.real (Icc 0 x) < t}

lemma monotone_unitQuantile (μ : Measure I) : Monotone (unitQuantile μ) := by
  intro u v huv
  apply sSup_le_sSup
  intro x hx
  exact lt_of_lt_of_le hx (show (u : ℝ) ≤ v from huv)

lemma measurable_unitQuantile (μ : Measure I) : Measurable (unitQuantile μ) :=
  (monotone_unitQuantile μ).measurable

lemma map_unitQuantile (μ : Measure I) [IsProbabilityMeasure μ] :
    volume.map (unitQuantile μ) = μ := by
  apply (volume.map (unitQuantile μ)).ext_of_Iic μ
  intro x
  have Iic_to_Icc : Iic x = Icc 0 x := by ext; simp
  have μ_in_I : μ.real (Icc 0 x) ∈ I := ⟨measureReal_nonneg, measureReal_le_one⟩
  simp_rw [Measure.map_apply (measurable_unitQuantile μ) measurableSet_Iic, preimage,
    mem_Iic, Iic_to_Icc, ← ofReal_measureReal (measure_ne_top μ _),
    ← unitInterval.volume_Iic ⟨_, μ_in_I⟩]
  congr with ξ
  constructor
  · intro (hξ : unitQuantile μ ξ ≤ x)
    change ξ ≤ μ.real (Icc 0 x)
    by_cases hx : x = 1
    · simp [hx, ← univ_eq_Icc, ξ.2.2]
    let g := fun y ↦ μ.real (Icc 0 y)
    let nebot : NeBot (𝓝[>] x) := by
      refine nhdsGT_neBot_of_exists_gt ?_
      exact ⟨1, lt_of_le_of_ne x.2.2 hx⟩
    refine le_of_tendsto_of_tendsto (b := 𝓝[>] x) (g := g) continuousWithinAt_const ?_ ?_
    · let h := cdf (μ.map Subtype.val)
      have h_continuousWithinAt := continuousWithinAt_Ioi_iff_Ici.mpr (h.right_continuous x)
      simp_rw [g, ← unitInterval.cdf_eq_real μ]
      exact h_continuousWithinAt.comp (Continuous.continuousWithinAt (by fun_prop)) (fun y hy ↦ hy)
    · refine eventually_nhdsWithin_of_forall fun y hy ↦ ?_
      by_contra! h
      simp only [sSup_le_iff, unitQuantile] at hξ
      specialize hξ y h
      grind
  · intro (hξ : ξ ≤ μ.real (Icc 0 x))
    simp only [sSup_le_iff, unitQuantile]
    intro c hc
    by_contra! h
    have h_lt : ¬ μ.real (Icc 0 x) ≤ μ.real (Icc 0 c) := not_le.mpr (lt_of_le_of_lt' hξ hc)
    refine h_lt ?_
    gcongr
    simp

lemma strictMono_unitQuantile (μ : Measure I) [IsProbabilityMeasure μ]
    [NullSingletonClass μ] : StrictMono (unitQuantile μ) := by
  intro u v huv
  refine lt_of_le_of_ne (monotone_unitQuantile μ huv.le) ?_
  intro heq
  have hnull : (volume : Measure I) ((unitQuantile μ) ⁻¹' {unitQuantile μ u}) = 0 := by
    rw [← Measure.map_apply (measurable_unitQuantile μ) (measurableSet_singleton _),
      map_unitQuantile, measure_singleton]
  have hsub : Icc u v ⊆ (unitQuantile μ) ⁻¹' {unitQuantile μ u} := by
    intro t ht
    exact le_antisymm ((monotone_unitQuantile μ ht.2).trans_eq heq.symm)
      (monotone_unitQuantile μ ht.1)
  have hzero := measure_mono_null hsub hnull
  rw [unitInterval.volume_Icc, ENNReal.ofReal_eq_zero] at hzero
  exact not_le_of_gt (sub_pos.mpr (show (u : ℝ) < v from huv)) hzero

lemma embedding_unitQuantile (μ : Measure I) [IsProbabilityMeasure μ]
    [NullSingletonClass μ] : MeasurableEmbedding (unitQuantile μ) :=
  (measurable_unitQuantile μ).measurableEmbedding (strictMono_unitQuantile μ).injective


/-- Measure-space isomorphism after removing measurable null sets. -/
def ConullIsomorphic {X Y : Type*} [MeasurableSpace X] [MeasurableSpace Y]
    (μ : Measure X) (ν : Measure Y) : Prop :=
  ∃ (A : Set X) (B : Set Y), MeasurableSet A ∧ MeasurableSet B ∧
    μ Aᶜ = 0 ∧ ν Bᶜ = 0 ∧
    ∃ e : A ≃ᵐ B,
      MeasurePreserving e (μ.comap (Subtype.val : A → X))
        (ν.comap (Subtype.val : B → Y))

/-- Standard nonatomic in the source's explicit modulo-null-set sense. -/
def StandardNonatomic {X : Type*} [MeasurableSpace X] (μ : Measure X) : Prop :=
  ConullIsomorphic μ
    (volume.comap (Subtype.val : Set.Icc (0 : ℝ) 1 → ℝ))

lemma equivImage_preserving {X Z : Type*} [MeasurableSpace X] [MeasurableSpace Z]
    {f : X → Z} (hf : MeasurableEmbedding f) (μ : Measure X)
    {A : Set X} (hA : MeasurableSet A) :
    MeasurePreserving (hf.equivImage A) (μ.comap (Subtype.val : A → X))
      ((μ.map f).comap (Subtype.val : f '' A → Z)) := by
  refine ⟨(hf.equivImage A).measurable, ?_⟩
  apply (MeasurableEmbedding.subtype_coe (hf.measurableSet_image' hA)).map_injective
  rw [Measure.map_map measurable_subtype_coe (hf.equivImage A).measurable,
    map_comap_subtype_coe (hf.measurableSet_image' hA)]
  change (μ.comap (Subtype.val : A → X)).map (f ∘ Subtype.val) = _
  rw [← Measure.map_map hf.measurable measurable_subtype_coe,
    map_comap_subtype_coe hA, hf.restrict_map, hf.injective.preimage_image]

private def setEqEquiv {Z : Type*} [MeasurableSpace Z] {A B : Set Z} (h : A = B) :
    A ≃ᵐ B := by
  subst B
  exact MeasurableEquiv.refl A

private lemma setEqEquiv_preserving {Z : Type*} [MeasurableSpace Z] {A B : Set Z}
    (h : A = B) (μ : Measure Z) :
    MeasurePreserving (setEqEquiv h) (μ.comap (Subtype.val : A → Z))
      (μ.comap (Subtype.val : B → Z)) := by
  subst B
  exact MeasurePreserving.id _

/-- Two measurable embeddings having the same image law give an actual
measurable isomorphism on conull sets, not merely two factors. -/
lemma conullIsomorphic_of_common_embedding {X Y Z : Type*}
    [MeasurableSpace X] [MeasurableSpace Y] [MeasurableSpace Z]
    {f : X → Z} {g : Y → Z} (hf : MeasurableEmbedding f) (hg : MeasurableEmbedding g)
    (μ : Measure X) (ν : Measure Y) (heq : μ.map f = ν.map g) :
    ConullIsomorphic μ ν := by
  let A := f ⁻¹' range g
  let B := g ⁻¹' range f
  have hA : MeasurableSet A := hf.measurable hg.measurableSet_range
  have hB : MeasurableSet B := hg.measurable hf.measurableSet_range
  have hAnull : μ Aᶜ = 0 := by
    change μ (f ⁻¹' (range g)ᶜ) = 0
    rw [← hf.map_apply, heq, hg.map_apply]
    simp
  have hBnull : ν Bᶜ = 0 := by
    change ν (g ⁻¹' (range f)ᶜ) = 0
    rw [← hg.map_apply, ← heq, hf.map_apply]
    simp
  have hAB : f '' A = g '' B := by
    simp only [A, B, image_preimage_eq_inter_range, inter_comm]
  let eA := hf.equivImage A
  let eB := hg.equivImage B
  let eC := setEqEquiv hAB
  have hC : MeasurePreserving eC ((μ.map f).comap (Subtype.val : f '' A → Z))
      ((ν.map g).comap (Subtype.val : g '' B → Z)) := by
    rw [heq]
    exact setEqEquiv_preserving hAB _
  refine ⟨A, B, hA, hB, hAnull, hBnull, eA.trans (eC.trans eB.symm), ?_⟩
  exact (MeasurePreserving.symm eB (equivImage_preserving hg ν hB)).comp
    (hC.comp (equivImage_preserving hf μ hA))

lemma nullSingleton_map_embedding {X Y : Type*} [MeasurableSpace X]
    [MeasurableSpace Y] {f : X → Y} (hf : MeasurableEmbedding f)
    (μ : Measure X) [NullSingletonClass μ] : NullSingletonClass (μ.map f) := by
  constructor
  intro y
  rw [hf.map_apply]
  exact (Set.subsingleton_singleton.preimage hf.injective).measure_zero μ

/-- The nonatomic standard-Borel classification needed by prop:system,
with the same closed-unit-interval reference as the frozen main target. -/
theorem standardNonatomic_of_standardBorel {X : Type*} [MeasurableSpace X]
    [StandardBorelSpace X] (μ : Measure X) [IsProbabilityMeasure μ]
    [NullSingletonClass μ] : StandardNonatomic μ := by
  let f := sigmoid ∘ embeddingReal X
  have hf : MeasurableEmbedding f := measurableEmbedding_sigmoid_comp_embeddingReal X
  let ρ := μ.map f
  have : IsProbabilityMeasure ρ := inferInstance
  have : NullSingletonClass ρ := nullSingleton_map_embedding hf μ
  have hq := embedding_unitQuantile ρ
  have h := conullIsomorphic_of_common_embedding hf hq μ volume (map_unitQuantile ρ).symm
  exact h

end SmoothObstruction

end

end OAI