Sync missing files (lean, preprints, history.md); remove stale build artifacts (part 7)

lean/OAI/Probability/SLE/Mass/LevelRandomRadon.lean

@@ -0,0 +1,107 @@
+import OAI.Probability.SLE.Mass.LevelRadonExtraction
+import OAI.Probability.SLE.Mass.RandomRadonLimit
+import OAI.Probability.SLE.Mass.RadonTestLimitProperties
+
+namespace OAI
+
+/-! Measurable versions and simultaneous time ordering of the actual
+common Radon limits. -/
+
+noncomputable section
+open Set Filter MeasureTheory ProbabilityTheory Classical
+open scoped NNReal ENNReal Topology CompactlySupported
+
+namespace SLEExactGauge.Multipoint
+
+local instance : LocallyCompactSpace upperHalfPlane := isOpen_upperHalfPlane.locallyCompactSpace
+
+lemma halfPlaneLevelMeasure_mono
+    {Ω : Type*} (κ : ℝ) (B : ℝ≥0 → Ω → ℝ)
+    (γ : Ω → ℝ≥0 → ℂ) (G : Ω → ℝ≥0 → ℂ → ℂ) (u : ℝ) (ω : Ω) :
+    Monotone (fun t => halfPlaneLevelMeasure κ B γ G u t ω) := by
+  intro s t hst
+  apply Measure.le_iff.mpr
+  intro A hA
+  simp only [halfPlaneLevelMeasure,comap_subtype_coe_apply isOpen_upperHalfPlane.measurableSet]
+  exact levelApproximation_mono κ B γ G u ω hst _
+
+lemma convexLevelMeasure_mono
+    {Ω : Type*} (κ : ℝ) (B : ℝ≥0 → Ω → ℝ)
+    (γ : Ω → ℝ≥0 → ℂ) (G : Ω → ℝ≥0 → ℂ → ℂ) (u : ℕ → ℝ)
+    (s : ℕ → Finset ℕ) (w : ℕ → ℕ → ℝ) (n : ℕ) (ω : Ω) :
+    Monotone (fun t => convexLevelMeasure κ B γ G u s w n t ω) := by
+  intro t₁ t₂ ht
+  apply Measure.le_iff.mpr
+  intro A hA
+  simp only [convexLevelMeasure,Measure.finsetSum_apply,Measure.smul_apply,smul_eq_mul]
+  exact Finset.sum_le_sum (fun i _ => mul_le_mul' le_rfl
+    (halfPlaneLevelMeasure_mono κ B γ G (u (n+i)) ω ht A))
+
+lemma convexLevelMeasure_test_measurable
+    {Ω : Type*} [MeasurableSpace Ω] {B : ℝ≥0 → Ω → ℝ}
+    (hm : ∀ t, Measurable (B t)) (hBc : ∀ ω, Continuous (fun t => B t ω))
+    {κ : ℝ} (hκ : 0 < κ) (hκ8 : κ < 8)
+    (γ : Ω → ℝ≥0 → ℂ) (G F : Ω → ℝ≥0 → ℂ → ℂ)
+    (hw : ∀ ω, IsCapacityTwoWitness (fun t => Real.sqrt κ * B t ω) (γ ω) (G ω) (F ω))
+    (u : ℕ → ℝ) (hu : ∀ n, 0 ≤ u n) (s : ℕ → Finset ℕ) (w : ℕ → ℕ → ℝ)
+    (hw₀ : ∀ n i, i ∈ s n → 0 ≤ w n i) (n : ℕ) (t : ℝ≥0∞)
+    (f : C_c(upperHalfPlane,ℝ)) :
+    Measurable (fun ω => ∫ z, f z ∂convexLevelMeasure κ B γ G u s w n t ω) := by
+  have he (ω : Ω) := integral_convexLevelMeasure hκ hκ8 γ G F ω (hBc ω) (hw ω)
+    u s w n t (hw₀ n) f
+  simp_rw [he]
+  apply Finset.measurable_sum
+  intro i hi
+  exact measurable_const.mul (levelApproximationRealTest_measurable hm hBc κ (u (n+i))
+    (hu (n+i)) γ G F hw t (extendHalfPlaneTest f)
+    (extendHalfPlaneTest_measurable f f.continuous.measurable))
+
+theorem exists_measurable_level_radon_limits
+    {Ω : Type*} [MeasurableSpace Ω]
+    {P : Measure Ω} {B : ℝ≥0 → Ω → ℝ} (hB : IsBrownianReal B P)
+    (hm : ∀ t, Measurable (B t)) (hBm : Measurable (Function.uncurry B))
+    (hBc : ∀ ω, Continuous (fun t => B t ω)) (hB0 : ∀ ω, B 0 ω = 0)
+    {κ : ℝ} (hκ : 0 < κ) (hκ8 : κ < 8)
+    (γ : Ω → ℝ≥0 → ℂ) (G F : Ω → ℝ≥0 → ℂ → ℂ)
+    (hw : ∀ ω, IsCapacityTwoWitness (fun t => Real.sqrt κ * B t ω) (γ ω) (G ω) (F ω))
+    (hgrowth : PublishedDiskUnivalentGrowth)
+    (u : ℕ → ℝ) (hu : ∀ n, 0 ≤ u n) (t : ℕ → ℝ≥0∞) :
+    ∃ s : ℕ → Finset ℕ, ∃ w : ℕ → ℕ → ℝ, ∃ ν : ℕ → Ω → Measure upperHalfPlane,
+      (∀ n i, i ∈ s n → 0 ≤ w n i) ∧ (∀ n, ∑ i ∈ s n, w n i = 1) ∧
+      (∀ j, Measurable (ν j)) ∧
+      (∀ j ω, (ν j ω).Regular ∧ IsFiniteMeasureOnCompacts (ν j ω)) ∧
+      (∀ᵐ ω ∂P,
+        (∀ j (f : C_c(upperHalfPlane,ℝ)),
+          Tendsto (fun n => ∫ z, f z ∂convexLevelMeasure κ B γ G u s w n (t j) ω)
+            atTop (𝓝 (∫ z, f z ∂ν j ω))) ∧
+        ∀ i j, t i ≤ t j → ν i ω ≤ ν j ω) := by
+  obtain ⟨s,w,hw₀,hw₁,hex⟩ := exists_common_level_radon_limits hB hm hBm hBc hB0 hκ hκ8
+    γ G F hw hgrowth u hu t
+  have hex' : ∀ᵐ ω ∂P, ∃ ν : ℕ → Measure upperHalfPlane, (∀ j, (ν j).Regular) ∧
+      ∀ j (f : C_c(upperHalfPlane,ℝ)),
+        Tendsto (fun n => ∫ z, f z ∂convexLevelMeasure κ B γ G u s w n (t j) ω)
+          atTop (𝓝 (∫ z, f z ∂ν j)) := by
+    filter_upwards [hex] with ω hω
+    obtain ⟨ν,hν,hlim⟩ := hω
+    exact ⟨ν,fun j => (hν j).1,hlim⟩
+  obtain ⟨ν,hνm,hνr,hlim⟩ := exists_measurable_countable_radon_limits P
+    (fun n j ω => convexLevelMeasure κ B γ G u s w n (t j) ω)
+    (fun n j f => convexLevelMeasure_test_measurable hm hBc hκ hκ8 γ G F hw u hu s w hw₀ n (t j) f) hex'
+  refine ⟨s,w,ν,hw₀,hw₁,hνm,hνr,?_⟩
+  filter_upwards [hlim] with ω hω
+  refine ⟨hω,?_⟩
+  intro i j hij
+  let (k : ℕ) : IsFiniteMeasureOnCompacts (convexLevelMeasure κ B γ G u s w k (t i) ω) :=
+    convexLevelMeasure_finite_on_compacts hκ hκ8 γ G F ω (hBc ω) (hw ω) u s w k (t i)
+  let (k : ℕ) : IsFiniteMeasureOnCompacts (convexLevelMeasure κ B γ G u s w k (t j) ω) :=
+    convexLevelMeasure_finite_on_compacts hκ hκ8 γ G F ω (hBc ω) (hw ω) u s w k (t j)
+  let : (ν i ω).Regular := (hνr i ω).1
+  let : (ν j ω).Regular := (hνr j ω).1
+  exact radon_limits_mono _ _ (ν i ω) (ν j ω) (hω i) (hω j)
+    (fun k => convexLevelMeasure_mono κ B γ G u s w k ω hij)
+
+end SLEExactGauge.Multipoint
+
+end
+
+end OAI

lean/OAI/Probability/SLE/Mass/LevelRemainderMeasure.lean

@@ -0,0 +1,113 @@
+import OAI.Probability.SLE.Mass.LevelApproximationKernel
+import OAI.Probability.SLE.Mass.LevelMeanMeasure
+
+namespace OAI
+
+/-! The unreached part of a finite-level approximation, as a positive
+measure. The conditional Green identity holds as a measure identity. -/
+
+noncomputable section
+open Set Filter MeasureTheory ProbabilityTheory Classical
+open scoped NNReal ENNReal
+
+namespace SLEExactGauge.Multipoint
+
+def halfPlaneRemainderMeasure {Ω : Type*} (κ : ℝ) (B : ℝ≥0 → Ω → ℝ)
+    (γ : Ω → ℝ≥0 → ℂ) (G : Ω → ℝ≥0 → ℂ → ℂ)
+    (u : ℝ) (t : ℝ≥0) (ω : Ω) : Measure upperHalfPlane :=
+  (volume.withDensity (fun z => ENNReal.ofReal (levelRemainderGreen κ B γ G u t z ω))).comap Subtype.val
+
+def halfPlaneCurrentMeasure {Ω : Type*} (κ : ℝ) (B : ℝ≥0 → Ω → ℝ)
+    (γ : Ω → ℝ≥0 → ℂ) (G : Ω → ℝ≥0 → ℂ → ℂ)
+    (u : ℝ) (t : ℝ≥0) (ω : Ω) : Measure upperHalfPlane :=
+  (volume.withDensity (fun z => ENNReal.ofReal (levelCurrentGreen κ B γ G u t z ω))).comap Subtype.val
+
+lemma levelDensity_split {Ω : Type*} (κ : ℝ) (B : ℝ≥0 → Ω → ℝ)
+    (γ : Ω → ℝ≥0 → ℂ) (G : Ω → ℝ≥0 → ℂ → ℂ)
+    (u : ℝ) (t : ℝ≥0) (ω : Ω) (z : ℂ) :
+    levelApproximationDensity κ B γ G u ∞ ω z =
+      levelApproximationDensity κ B γ G u t ω z +
+        ENNReal.ofReal (levelRemainderGreen κ B γ G u t z ω) := by
+  unfold levelApproximationDensity levelRemainderGreen
+  by_cases h : radiusLevelTime (γ ω) (G ω) z u ≤ t
+  · simp only [le_top,ite_true,ite_eq_left h,ite_eq_right (not_lt.mpr h),
+      ENNReal.ofReal_zero,add_zero]
+  · simp only [le_top,ite_true,ite_eq_right h,ite_eq_left (lt_of_not_ge h),zero_add]
+
+lemma halfPlaneRemainderMeasure_measurable
+    {Ω : Type*} [MeasurableSpace Ω] {B : ℝ≥0 → Ω → ℝ}
+    (hm : ∀ t, Measurable (B t)) (hBc : ∀ ω, Continuous (fun t => B t ω))
+    (κ u : ℝ) (hu : 0 ≤ u)
+    (γ : Ω → ℝ≥0 → ℂ) (G F : Ω → ℝ≥0 → ℂ → ℂ)
+    (hw : ∀ ω, IsCapacityTwoWitness (fun t => Real.sqrt κ * B t ω) (γ ω) (G ω) (F ω))
+    (t : ℝ≥0) : Measurable (halfPlaneRemainderMeasure κ B γ G u t) := by
+  apply Measure.measurable_of_measurable_coe
+  intro A hA
+  have hAI := (MeasurableEmbedding.subtype_coe isOpen_upperHalfPlane.measurableSet).measurableSet_image.mpr hA
+  simp only [halfPlaneRemainderMeasure,comap_subtype_coe_apply isOpen_upperHalfPlane.measurableSet,
+    withDensity_apply _ hAI]
+  exact (levelRemainderGreen_joint_measurable hm hBc κ u hu γ G F hw t).ennreal_ofReal.lintegral_prod_right'
+
+lemma halfPlaneCurrentMeasure_measurable
+    {Ω : Type*} [MeasurableSpace Ω] {B : ℝ≥0 → Ω → ℝ}
+    (hBm : Measurable (Function.uncurry B)) (hBc : ∀ ω, Continuous (fun t => B t ω))
+    (κ u : ℝ) (hu : 0 ≤ u)
+    (γ : Ω → ℝ≥0 → ℂ) (G F : Ω → ℝ≥0 → ℂ → ℂ)
+    (hw : ∀ ω, IsCapacityTwoWitness (fun t => Real.sqrt κ * B t ω) (γ ω) (G ω) (F ω))
+    (t : ℝ≥0) : Measurable (halfPlaneCurrentMeasure κ B γ G u t) := by
+  apply Measure.measurable_of_measurable_coe
+  intro A hA
+  have hAI := (MeasurableEmbedding.subtype_coe isOpen_upperHalfPlane.measurableSet).measurableSet_image.mpr hA
+  simp only [halfPlaneCurrentMeasure,comap_subtype_coe_apply isOpen_upperHalfPlane.measurableSet,
+    withDensity_apply _ hAI]
+  exact (levelCurrentGreen_joint_measurable hBm hBc κ u hu γ G F hw t).ennreal_ofReal.lintegral_prod_right'
+
+lemma halfPlaneLevelMeasure_split
+    {Ω : Type*} [MeasurableSpace Ω] {B : ℝ≥0 → Ω → ℝ}
+    (hm : ∀ t, Measurable (B t)) (hBc : ∀ ω, Continuous (fun t => B t ω))
+    (κ u : ℝ) (hu : 0 ≤ u)
+    (γ : Ω → ℝ≥0 → ℂ) (G F : Ω → ℝ≥0 → ℂ → ℂ)
+    (hw : ∀ ω, IsCapacityTwoWitness (fun t => Real.sqrt κ * B t ω) (γ ω) (G ω) (F ω))
+    (t : ℝ≥0) (ω : Ω) :
+    halfPlaneLevelMeasure κ B γ G u ∞ ω =
+      halfPlaneLevelMeasure κ B γ G u t ω + halfPlaneRemainderMeasure κ B γ G u t ω := by
+  apply Measure.ext
+  intro A hA
+  have hAI := (MeasurableEmbedding.subtype_coe isOpen_upperHalfPlane.measurableSet).measurableSet_image.mpr hA
+  simp only [Measure.add_apply,halfPlaneLevelMeasure,halfPlaneRemainderMeasure,levelApproximation,
+    comap_subtype_coe_apply isOpen_upperHalfPlane.measurableSet,withDensity_apply _ hAI]
+  simp_rw [levelDensity_split κ B γ G u t ω]
+  exact lintegral_add_left
+    (levelApproximationDensity_joint_measurable hm hBc κ u hu γ G F hw t).of_uncurry_left _
+
+theorem halfPlaneRemainderMeasure_conditional_mean
+    {Ω : Type*} [MeasurableSpace Ω]
+    {P : Measure Ω} {B : ℝ≥0 → Ω → ℝ} (hB : IsBrownianReal B P)
+    (hBm : Measurable (Function.uncurry B))
+    (hBc : ∀ ω, Continuous (fun t => B t ω)) (hB0 : ∀ ω, B 0 ω = 0)
+    {κ : ℝ} (hκ : 0 < κ) (hκ8 : κ < 8)
+    (γ : Ω → ℝ≥0 → ��) (G F : Ω → ℝ≥0 → ℂ → ℂ)
+    (hw : ∀ ω, IsCapacityTwoWitness (fun t => Real.sqrt κ * B t ω) (γ ω) (G ω) (F ω))
+    (u : ℝ) (hu : 0 ≤ u) (t : ℝ≥0) (E : Set Ω)
+    (hE : MeasurableSet[Filtration.natural B (fun s =>
+      (hBm.comp (measurable_const.prodMk measurable_id) : Measurable (B s)).stronglyMeasurable) t] E) :
+    (P.restrict E).bind (halfPlaneRemainderMeasure κ B γ G u t) =
+      (P.restrict E).bind (halfPlaneCurrentMeasure κ B γ G u t) := by
+  let hm (s : ℝ≥0) : Measurable (B s) := hBm.comp (measurable_const.prodMk measurable_id)
+  apply Measure.ext
+  intro A hA
+  have hAI := (MeasurableEmbedding.subtype_coe isOpen_upperHalfPlane.measurableSet).measurableSet_image.mpr hA
+  have hAH : (Subtype.val : upperHalfPlane → ℂ) '' A ⊆ upperHalfPlane := by
+    rintro _ ⟨x,_,rfl⟩; exact x.property
+  rw [Measure.bind_apply hA (halfPlaneRemainderMeasure_measurable hm hBc κ u hu γ G F hw t).aemeasurable,
+    Measure.bind_apply hA (halfPlaneCurrentMeasure_measurable hBm hBc κ u hu γ G F hw t).aemeasurable]
+  simp only [halfPlaneRemainderMeasure,halfPlaneCurrentMeasure,
+    comap_subtype_coe_apply isOpen_upperHalfPlane.measurableSet,withDensity_apply _ hAI]
+  simpa only [one_mul] using levelRemainderGreen_spatial_kernel hB hBm hBc hB0 hκ hκ8 γ G F hw
+    u hu t _ hAI hAH (fun _ => 1) measurable_const E hE
+
+end SLEExactGauge.Multipoint
+
+end
+
+end OAI

lean/OAI/Probability/SLE/Mass/LevelRemainderSupport.lean

@@ -0,0 +1,87 @@
+import OAI.Probability.SLE.Geometry.RandomKernelSupport
+import OAI.Probability.SLE.Mass.GreenMeasureSupport
+import OAI.Probability.SLE.Geometry.CountableRemainderKernels
+
+namespace OAI
+
+/-! The positive remaining mass in the actual countable Radon construction
+is carried by the surviving Loewner domain. -/
+
+noncomputable section
+open Set Filter MeasureTheory ProbabilityTheory Classical
+open scoped NNReal ENNReal Topology CompactlySupported
+
+namespace SLEExactGauge.Multipoint
+
+local instance : LocallyCompactSpace upperHalfPlane := isOpen_upperHalfPlane.locallyCompactSpace
+
+lemma surviving_complement_past_measurable
+    {Ω : Type*} [mΩ : MeasurableSpace Ω] {B : ℝ≥0 → Ω → ℝ}
+    (hm : ∀ t, Measurable (B t)) (hBc : ∀ ω, Continuous (fun t => B t ω))
+    (κ : ℝ) (γ : Ω → ℝ≥0 → ℂ) (G F : Ω → ℝ≥0 → ℂ → ℂ)
+    (hw : ∀ ω, IsCapacityTwoWitness (fun t => Real.sqrt κ * B t ω) (γ ω) (G ω) (F ω))
+    (t : ℝ≥0) :
+    @MeasurableSet (Ω × upperHalfPlane)
+      ((Filtration.natural B (fun r => (hm r).stronglyMeasurable) t).prod inferInstance)
+      {p | (p.2 : ℂ) ∉ survivingDomain (γ p.1) t} := by
+  have hlive := (actual_spatial_past_kernels hm hBc κ γ G F hw t).2.2
+  let : MeasurableSpace Ω := Filtration.natural B (fun r => (hm r).stronglyMeasurable) t
+  let t0 : Iic t := ⟨t,by simp only [mem_Iic]; exact le_rfl⟩
+  have hmap : Measurable (fun p : Ω × upperHalfPlane =>
+      (t0,((p.2 : ℂ),p.1))) := by
+    apply Measurable.prodMk
+    · exact measurable_const
+    · exact ((measurable_subtype_coe : Measurable (fun z : upperHalfPlane => (z : ℂ))).comp
+        measurable_snd).prodMk measurable_fst
+  exact (hlive.preimage hmap).compl
+
+theorem ae_remainder_carried_by_surviving
+    {Ω : Type*} [mΩ : MeasurableSpace Ω] {P : Measure Ω}
+    {B : ℝ≥0 → Ω → ℝ} (hB : IsBrownianReal B P)
+    (hBm : Measurable (Function.uncurry B)) (hBc : ∀ ω, Continuous (fun t => B t ω))
+    (hB0 : ∀ ω, B 0 ω = 0) {κ : ℝ} (hκ : 0 < κ) (hκ8 : κ < 8)
+    (γ : Ω → ℝ≥0 → ℂ) (G F : Ω → ℝ≥0 → ℂ → ℂ)
+    (hw : ∀ ω, IsCapacityTwoWitness (fun t => Real.sqrt κ * B t ω) (γ ω) (G ω) (F ω))
+    (t : ℝ≥0) (η : Ω → Measure upperHalfPlane) (hη : Measurable η)
+    (hηfin : ∀ ω, IsFiniteMeasureOnCompacts (η ω))
+    (hevent : ∀ E : Set Ω,
+      MeasurableSet[Filtration.natural B (fun r =>
+        (hBm.comp (measurable_const.prodMk measurable_id) : Measurable (B r)).stronglyMeasurable) t] E →
+      (P.restrict E).bind η = (P.restrict E).bind (halfPlaneGreenMeasure κ B γ G t)) :
+    ∀ᵐ ω ∂P, η ω {z : upperHalfPlane | (z : ℂ) ∉ survivingDomain (γ ω) t} = 0 := by
+  let D := localTestFamily upperHalfPlane
+  let ℱ := Filtration.natural B (fun r =>
+    (hBm.comp (measurable_const.prodMk measurable_id) : Measurable (B r)).stronglyMeasurable)
+  have hmean : P.bind η = P.bind (halfPlaneGreenMeasure κ B γ G t) := by
+    simpa only [Measure.restrict_univ] using hevent univ MeasurableSet.univ
+  let : IsFiniteMeasureOnCompacts (initialGreenMeasure κ) := initialGreenMeasure_finite_on_compacts κ
+  refine ae_avoids_random_set_of_conditional_kernel (ℱ t) (ℱ.le t) P η
+    (halfPlaneGreenMeasure κ B γ G t) hη
+    (halfPlaneGreenMeasure_measurable hBm hBc κ γ G F hw t)
+    D.compactSet (fun n => (D.isCompact n).measurableSet) ?_ ?_ ?_ ?_ hevent
+    {p | (p.2 : ℂ) ∉ survivingDomain (γ p.1) t} ?_ ?_
+  · intro z
+    obtain ⟨n,hn⟩ := D.exhaustive {z} isCompact_singleton
+    exact ⟨n,hn (mem_singleton z)⟩
+  · intro n ω
+    let := hηfin ω
+    exact (D.isCompact n).measure_lt_top
+  · intro n
+    exact ae_halfPlaneGreenMeasure_compact_finite hB hBm hBc hB0 hκ hκ8 γ G F hw t
+      _ (D.isCompact n)
+  · intro n
+    rw [hmean]
+    have hb := halfPlaneGreenMeasure_mean_le hB hBm hBc hB0 hκ hκ8 γ G F hw t univ
+      (D.compactSet n)
+    rw [Measure.restrict_univ] at hb
+    exact lt_of_le_of_lt hb (D.isCompact n).measure_lt_top
+  · exact surviving_complement_past_measurable
+      (fun r => hBm.comp (measurable_const.prodMk measurable_id)) hBc κ γ G F hw t
+  · intro ω
+    exact halfPlaneGreenMeasure_off_surviving ω (hw ω) t
+
+end SLEExactGauge.Multipoint
+
+end
+
+end OAI

lean/OAI/Probability/SLE/Mass/LevelStoppingConvex.lean

@@ -0,0 +1,128 @@
+import OAI.Probability.SLE.Mass.LevelStoppingTests
+
+namespace OAI
+
+/-! The actual common convex tails preserve the conditional decomposition
+at every Brownian stopping time, including infinite stops. -/
+
+noncomputable section
+open Set Filter MeasureTheory ProbabilityTheory Classical
+open scoped NNReal ENNReal Topology CompactlySupported
+
+namespace SLEExactGauge.Multipoint
+
+local instance : LocallyCompactSpace upperHalfPlane := isOpen_upperHalfPlane.locallyCompactSpace
+
+def convexStoppingCurrentMean {Ω : Type*} [MeasurableSpace Ω] (P : Measure Ω)
+    (κ : ℝ) (B : ℝ≥0 → Ω → ℝ) (γ : Ω → ℝ≥0 → ℂ) (G : Ω → ℝ≥0 → ℂ → ℂ)
+    (u : ℕ → ℝ) (s : ℕ → Finset ℕ) (w : ℕ → ℕ → ℝ) (n : ℕ) (S : Ω → ℝ≥0∞) :
+    Measure upperHalfPlane :=
+  ∑ i ∈ s n, ENNReal.ofReal (w n i) • P.bind (halfPlaneStoppingCurrentMeasure κ B γ G (u (n+i)) S)
+
+lemma convexLevelMeasure_random_time_measurable
+    {Ω : Type*} [MeasurableSpace Ω] {B : ℝ≥0 → Ω → ℝ}
+    (hm : ∀ t, Measurable (B t)) (hc : ∀ ω, Continuous (fun t => B t ω))
+    (κ : ℝ) (γ : Ω → ℝ≥0 → ℂ) (G F : Ω → ℝ≥0 → ℂ → ℂ)
+    (hw : ∀ ω, IsCapacityTwoWitness (fun t => Real.sqrt κ * B t ω) (γ ω) (G ω) (F ω))
+    (u : ℕ → ℝ) (hu : ∀ n, 0 ≤ u n) (s : ℕ → Finset ℕ) (w : ℕ → ℕ → ℝ)
+    (n : ℕ) (S : Ω → ℝ≥0∞) (hS : Measurable S) :
+    Measurable (fun ω => convexLevelMeasure κ B γ G u s w n (S ω) ω) := by
+  apply Measure.measurable_of_measurable_coe
+  intro A hA
+  simp only [convexLevelMeasure,Measure.finsetSum_apply,Measure.smul_apply,smul_eq_mul]
+  apply Finset.measurable_sum
+  intro i _
+  exact measurable_const.mul ((Measure.measurable_coe hA).comp
+    (halfPlaneLevelMeasure_random_time_measurable hm hc κ (u (n+i)) (hu _) γ G F hw S hS))
+
+lemma convexLevelMeasure_stopping_conditional_split
+    {Ω : Type*} [MeasurableSpace Ω] {P : Measure Ω}
+    {B : ℝ≥0 → Ω → ℝ} (hB : IsBrownianReal B P)
+    (hBm : Measurable (Function.uncurry B)) (hc : ∀ ω, Continuous (fun t => B t ω))
+    (hB0 : ∀ ω, B 0 ω = 0) {κ : ℝ} (hκ : 0 < κ) (hκ8 : κ < 8)
+    (γ : Ω → ℝ≥0 → ℂ) (G F : Ω → ℝ≥0 → ℂ → ℂ)
+    (hw : ∀ ω, IsCapacityTwoWitness (fun t => Real.sqrt κ * B t ω) (γ ω) (G ω) (F ω))
+    (u : ℕ → ℝ) (hu : ∀ n, 0 ≤ u n) (s : ℕ → Finset ℕ) (w : ℕ → ℕ → ℝ)
+    (n : ℕ) (S : Ω → WithTop ℝ≥0)
+    (hS : IsStoppingTime (Filtration.natural B (fun r =>
+      (hBm.comp (measurable_const.prodMk measurable_id) : Measurable (B r)).stronglyMeasurable)) S)
+    (E : Set Ω) (hE : MeasurableSet[hS.measurableSpace] E) :
+    (P.restrict E).bind (convexLevelMeasure κ B γ G u s w n ∞) =
+      (P.restrict E).bind (fun ω => convexLevelMeasure κ B γ G u s w n (S ω) ω) +
+        convexStoppingCurrentMean (P.restrict E) κ B γ G u s w n S := by
+  let hm (r : ℝ≥0) : Measurable (B r) := hBm.comp (measurable_const.prodMk measurable_id)
+  unfold convexLevelMeasure convexStoppingCurrentMean
+  rw [bind_finset_smul _ _ _ (fun _ => ENNReal.ofReal_ne_top) _
+      (fun i => halfPlaneLevelMeasure_measurable hm hc κ (u (n+i)) (hu _) γ G F hw ∞),
+    bind_finset_smul _ _ _ (fun _ => ENNReal.ofReal_ne_top) _
+      (fun i => halfPlaneLevelMeasure_random_time_measurable hm hc κ (u (n+i)) (hu _)
+        γ G F hw S hS.measurable')]
+  simp_rw [halfPlaneLevelMeasure_stopping_conditional_split hB hBm hc hB0 hκ hκ8 γ G F hw
+    _ (hu _) S hS E hE,smul_add,Finset.sum_add_distrib]
+
+lemma convexStoppingCurrentMean_le
+    {Ω : Type*} [MeasurableSpace Ω] {P : Measure Ω}
+    {B : ℝ≥0 → Ω → ℝ} (hB : IsBrownianReal B P)
+    (hBm : Measurable (Function.uncurry B)) (hc : ∀ ω, Continuous (fun t => B t ω))
+    (hB0 : ∀ ω, B 0 ω = 0) {κ : ℝ} (hκ : 0 < κ) (hκ8 : κ < 8)
+    (γ : Ω → ℝ≥0 → ℂ) (G F : Ω → ℝ≥0 → ℂ → ℂ)
+    (hw : ∀ ω, IsCapacityTwoWitness (fun t => Real.sqrt κ * B t ω) (γ ω) (G ω) (F ω))
+    (u : ℕ → ℝ) (hu : ∀ n, 0 ≤ u n) (s : ℕ → Finset ℕ) (w : ℕ → ℕ → ℝ)
+    (hw₀ : ∀ n i, i ∈ s n → 0 ≤ w n i) (hw₁ : ∀ n, ∑ i ∈ s n, w n i = 1)
+    (n : ℕ) (S : Ω → WithTop ℝ≥0)
+    (hS : IsStoppingTime (Filtration.natural B (fun r =>
+      (hBm.comp (measurable_const.prodMk measurable_id) : Measurable (B r)).stronglyMeasurable)) S)
+    (E : Set Ω) :
+    convexStoppingCurrentMean (P.restrict E) κ B γ G u s w n S ≤ initialGreenMeasure κ := by
+  apply Measure.le_iff.mpr
+  intro A _
+  simp only [convexStoppingCurrentMean,Measure.finsetSum_apply,Measure.smul_apply,smul_eq_mul]
+  calc
+    _ ≤ ∑ i ∈ s n, ENNReal.ofReal (w n i) * initialGreenMeasure κ A :=
+      Finset.sum_le_sum (fun i _ => mul_le_mul' le_rfl
+        (halfPlaneStoppingCurrentMeasure_mean_le hB hBm hc hB0 hκ hκ8 γ G F hw
+          (u (n+i)) (hu _) S hS E A))
+    _ = _ := by
+      rw [← Finset.sum_mul,← ENNReal.ofReal_sum_of_nonneg (hw₀ n),hw₁ n,ENNReal.ofReal_one,one_mul]
+
+theorem convexStoppingCurrentMean_test_tendsto
+    {Ω : Type*} [MeasurableSpace Ω] {P : Measure Ω}
+    {B : ℝ≥0 → Ω → ℝ} (hB : IsBrownianReal B P)
+    (hBm : Measurable (Function.uncurry B)) (hc : ∀ ω, Continuous (fun t => B t ω))
+    (hB0 : ∀ ω, B 0 ω = 0) {κ : ℝ} (hκ : 0 < κ) (hκ8 : κ < 8)
+    (γ : Ω → ℝ≥0 → ℂ) (G F : Ω → ℝ≥0 → ℂ → ℂ)
+    (hw : ∀ ω, IsCapacityTwoWitness (fun t => Real.sqrt κ * B t ω) (γ ω) (G ω) (F ω))
+    (u : ℕ → ℝ) (hu : ∀ n, 0 ≤ u n) (hmono : Monotone u) (hlim : Tendsto u atTop atTop)
+    (s : ℕ → Finset ℕ) (w : ℕ → ℕ → ℝ)
+    (hw₀ : ∀ n i, i ∈ s n → 0 ≤ w n i) (hw₁ : ∀ n, ∑ i ∈ s n, w n i = 1)
+    (S : Ω → WithTop ℝ≥0)
+    (hS : IsStoppingTime (Filtration.natural B (fun r =>
+      (hBm.comp (measurable_const.prodMk measurable_id) : Measurable (B r)).stronglyMeasurable)) S)
+    (E : Set Ω) (f : C_c(upperHalfPlane,ℝ)) :
+    Tendsto (fun n => ∫ z, f z ∂convexStoppingCurrentMean (P.restrict E) κ B γ G u s w n S)
+      atTop (𝓝 (∫ z, f z ∂(P.restrict E).bind (halfPlaneStoppingGreenMeasure κ B γ G S))) := by
+  let ρ := initialGreenMeasure κ
+  let : IsFiniteMeasureOnCompacts ρ := initialGreenMeasure_finite_on_compacts κ
+  let μ (j : ℕ) := (P.restrict E).bind (halfPlaneStoppingCurrentMeasure κ B γ G (u j) S)
+  have hμ (j : ℕ) : μ j ≤ ρ :=
+    halfPlaneStoppingCurrentMeasure_mean_le hB hBm hc hB0 hκ hκ8 γ G F hw (u j) (hu j) S hS E
+  have hfi (j : ℕ) : Integrable f (μ j) := f.integrable.mono_measure (hμ j)
+  have he (n : ℕ) : (∫ z, f z ∂convexStoppingCurrentMean (P.restrict E) κ B γ G u s w n S) =
+      ∑ i ∈ s n, w n i * (∫ z, f z ∂μ (n+i)) := by
+    have hi (i : ℕ) : Integrable f (ENNReal.ofReal (w n i) • μ (n+i)) :=
+      (hfi (n+i)).smul_measure ENNReal.ofReal_ne_top
+    change (∫ z, f z ∂∑ i ∈ s n, ENNReal.ofReal (w n i) • μ (n+i)) = _
+    rw [integral_finsetSum_measure (fun i _ => hi i)]
+    apply Finset.sum_congr rfl
+    intro i his
+    rw [integral_smul_measure,ENNReal.toReal_ofReal (hw₀ n i his),smul_eq_mul]
+  simp only [he]
+  exact real_convex_tail_tendsto (fun j => ∫ z, f z ∂μ j)
+    (halfPlaneStoppingCurrentMeasure_mean_test_tendsto hB hBm hc hB0 hκ hκ8 γ G F hw
+      u hu hmono hlim S hS E f) s w hw₀ hw₁
+
+end SLEExactGauge.Multipoint
+
+end
+
+end OAI

lean/OAI/Probability/SLE/Mass/LevelStoppingGreenLimit.lean

@@ -0,0 +1,131 @@
+import OAI.Probability.SLE.Mass.LevelStoppingSpatialKernel
+import OAI.Probability.SLE.Mass.LevelGreenLimit
+
+namespace OAI
+
+/-! Increasing finite radius levels recover the Green kernel killed at an
+arbitrary stopping time. Its expectation is bounded by the initial Green
+function, also when the stopping time may be infinite. -/
+
+noncomputable section
+open Set Filter MeasureTheory ProbabilityTheory Classical
+open scoped Topology NNReal ENNReal
+
+namespace SLEExactGauge.Multipoint
+
+def stoppingGreen {Ω : Type*} (κ : ℝ) (B : ℝ≥0 → Ω → ℝ)
+    (γ : Ω → ℝ≥0 → ℂ) (G : Ω → ℝ≥0 → ℂ → ℂ)
+    (S : Ω → ℝ≥0∞) (z : ℂ) (ω : Ω) : ℝ :=
+  if S ω < ∞ then greenDensity κ (fun s => Real.sqrt κ * B s ω)
+    (γ ω) (G ω) (S ω).toNNReal z else 0
+
+lemma levelStoppingCurrentGreen_mono
+    {Ω : Type*} {B : ℝ≥0 → Ω → ℝ} {κ : ℝ}
+    {γ : Ω → ℝ≥0 → ℂ} {G F : Ω → ℝ≥0 → ℂ → ℂ}
+    (ω : Ω) (hc : Continuous (fun s => B s ω))
+    (hw : IsCapacityTwoWitness (fun s => Real.sqrt κ * B s ω) (γ ω) (G ω) (F ω))
+    (z : ℂ) (S : Ω → ℝ≥0∞) {u v : ℝ} (hu : 0 ≤ u) (huv : u ≤ v) :
+    levelStoppingCurrentGreen κ B γ G u S z ω ≤ levelStoppingCurrentGreen κ B γ G v S z ω := by
+  have hτ := radiusLevelTime_mono (hc.const_mul _) hw z hu huv
+  unfold levelStoppingCurrentGreen
+  split_ifs with h₁ h₂
+  · exact le_rfl
+  · exact False.elim (h₂ (h₁.trans_le hτ))
+  · exact greenDensity_nonneg hw κ _ z
+  · exact le_rfl
+
+lemma levelStoppingCurrentGreen_eventually_eq
+    {Ω : Type*} {B : ℝ≥0 → Ω → ℝ} {κ : ℝ}
+    {γ : Ω → ℝ≥0 → ℂ} {G F : Ω → ℝ≥0 → ℂ → ℂ}
+    (ω : Ω) (hc : Continuous (fun s => B s ω))
+    (hw : IsCapacityTwoWitness (fun s => Real.sqrt κ * B s ω) (γ ω) (G ω) (F ω))
+    (z : ℂ) (S : Ω → ℝ≥0∞) (u : ℕ → ℝ) (hu : ∀ n, 0 ≤ u n)
+    (hlim : Tendsto u atTop atTop) :
+    ∀ᶠ n in atTop, levelStoppingCurrentGreen κ B γ G (u n) S z ω = stoppingGreen κ B γ G S z ω := by
+  by_cases hfin : S ω < ∞
+  · have hcoe : ((S ω).toNNReal : ℝ≥0∞) = S ω := ENNReal.coe_toNNReal hfin.ne
+    filter_upwards [levelCurrentGreen_eventually_eq ω hc hw z (S ω).toNNReal u hu hlim] with n hn
+    simpa only [levelCurrentGreen,levelStoppingCurrentGreen,stoppingGreen,hcoe,ite_eq_left hfin] using hn
+  · have htop : S ω = ∞ := top_le_iff.mp (le_of_not_gt hfin)
+    filter_upwards [] with n
+    simp [levelStoppingCurrentGreen,stoppingGreen,htop]
+
+theorem levelStoppingCurrentGreen_mean_le
+    {Ω : Type*} [mΩ : MeasurableSpace Ω] {P : Measure Ω}
+    {B : ℝ≥0 → Ω → ℝ} (hB : IsBrownianReal B P)
+    (hBm : Measurable (Function.uncurry B))
+    (hc : ∀ ω, Continuous (fun t => B t ω)) (hB0 : ∀ ω, B 0 ω = 0)
+    {κ : ℝ} (hκ : 0 < κ) (hκ8 : κ < 8)
+    (γ : Ω → ℝ≥0 → ℂ) (G F : Ω → ℝ≥0 → ℂ → ℂ)
+    (hw : ∀ ω, IsCapacityTwoWitness (fun s => Real.sqrt κ * B s ω) (γ ω) (G ω) (F ω))
+    (z : ℂ) (hz : z ∈ upperHalfPlane) (u : ℝ) (hu : 0 ≤ u)
+    (S : Ω → WithTop ℝ≥0)
+    (hS : IsStoppingTime (Filtration.natural B (fun s =>
+      (hBm.comp (measurable_const.prodMk measurable_id) : Measurable (B s)).stronglyMeasurable)) S) :
+    (∫⁻ ω, ENNReal.ofReal (levelStoppingCurrentGreen κ B γ G u S z ω) ∂P) ≤
+      ENNReal.ofReal (initialGreen κ z) := by
+  let : IsProbabilityMeasure P := hB.isGaussianProcess.isProbabilityMeasure
+  have he := levelStoppingRemainderGreen_setLIntegral hB hBm hc hB0 hκ hκ8
+    γ G F hw z hz u hu S hS univ MeasurableSet.univ
+  simp only [Measure.restrict_univ] at he
+  rw [← he]
+  calc
+    _ ≤ ∫⁻ ω, ENNReal.ofReal (stoppedGreen κ (fun s => Real.sqrt κ * B s ω)
+        (γ ω) (G ω) z u) ∂P := by
+      apply lintegral_mono
+      intro ω
+      unfold levelStoppingRemainderGreen
+      dsimp only
+      split_ifs
+      · exact le_rfl
+      · simp only [ENNReal.ofReal_zero]
+        exact bot_le
+    _ = _ := by
+      obtain ⟨hi,he⟩ := finite_stopped_green_regular hB hBm hc hB0 κ hκ hκ8 γ G F
+        (ae_of_all _ hw) z hz u hu
+      rw [← ofReal_integral_eq_lintegral_ofReal hi
+        (ae_of_all _ (fun ω => stoppedGreen_nonneg (hw ω) κ z u)),he]
+
+theorem stoppingGreen_mean_le
+    {Ω : Type*} [mΩ : MeasurableSpace Ω] {P : Measure Ω}
+    {B : ℝ≥0 → Ω → ℝ} (hB : IsBrownianReal B P)
+    (hBm : Measurable (Function.uncurry B))
+    (hc : ∀ ω, Continuous (fun t => B t ω)) (hB0 : ∀ ω, B 0 ω = 0)
+    {κ : ℝ} (hκ : 0 < κ) (hκ8 : κ < 8)
+    (γ : Ω → ℝ≥0 → ℂ) (G F : Ω → ℝ≥0 → ℂ → ℂ)
+    (hw : ∀ ω, IsCapacityTwoWitness (fun s => Real.sqrt κ * B s ω) (γ ω) (G ω) (F ω))
+    (z : ℂ) (hz : z ∈ upperHalfPlane) (S : Ω → WithTop ℝ≥0)
+    (hS : IsStoppingTime (Filtration.natural B (fun s =>
+      (hBm.comp (measurable_const.prodMk measurable_id) : Measurable (B s)).stronglyMeasurable)) S) :
+    (∫⁻ ω, ENNReal.ofReal (stoppingGreen κ B γ G S z ω) ∂P) ≤
+      ENNReal.ofReal (initialGreen κ z) := by
+  have hm (n : ℕ) : Measurable (fun ω => ENNReal.ofReal
+      (levelStoppingCurrentGreen κ B γ G n S z ω)) := by
+    have hj := (levelStoppingCurrentGreen_joint_measurable hBm hc κ n (Nat.cast_nonneg n)
+      γ G F hw S hS.measurable').ennreal_ofReal
+    have hh := hj.comp (measurable_id.prodMk (measurable_const (a := z)))
+    simpa only [Function.comp_def,id_eq] using hh
+  have hmono : ∀ᵐ ω ∂P, Monotone (fun n : ℕ => ENNReal.ofReal
+      (levelStoppingCurrentGreen κ B γ G n S z ω)) := by
+    filter_upwards [] with ω
+    intro n k hnk
+    exact ENNReal.ofReal_le_ofReal (levelStoppingCurrentGreen_mono ω (hc ω) (hw ω)
+      z S (Nat.cast_nonneg n) (Nat.cast_le.mpr hnk))
+  have hlim : ∀ᵐ ω ∂P, Tendsto (fun n : ℕ => ENNReal.ofReal
+      (levelStoppingCurrentGreen κ B γ G n S z ω)) atTop
+      (𝓝 (ENNReal.ofReal (stoppingGreen κ B γ G S z ω))) := by
+    filter_upwards [] with ω
+    apply tendsto_const_nhds.congr'
+    exact (levelStoppingCurrentGreen_eventually_eq ω (hc ω) (hw ω) z S
+      (fun n : ℕ => (n:ℝ)) (fun n => Nat.cast_nonneg n) tendsto_natCast_atTop_atTop).mono
+      (fun _ he => congrArg ENNReal.ofReal he.symm)
+  exact le_of_tendsto (lintegral_tendsto_of_tendsto_of_monotone
+    (fun n => (hm n).aemeasurable) hmono hlim)
+    (Eventually.of_forall (fun n => levelStoppingCurrentGreen_mean_le hB hBm hc hB0 hκ hκ8
+      γ G F hw z hz n (Nat.cast_nonneg n) S hS))
+
+end SLEExactGauge.Multipoint
+
+end
+
+end OAI

lean/OAI/Probability/SLE/Mass/LevelStoppingKernel.lean

@@ -0,0 +1,230 @@
+import OAI.Probability.SLE.Mass.LevelApproximationKernel
+import OAI.Probability.SLE.Loewner.ActualRadiusStopsRegular
+import OAI.Probability.SLE.Gauge.ExtendedExperimentStop
+
+namespace OAI
+
+/-! The finite-level remaining Green kernel at any Brownian stopping
+time. Both sides vanish at an infinite stopping time. Finite cutoffs use
+the existing optional identity for the stopped Green martingale. -/
+
+noncomputable section
+open Set Filter MeasureTheory ProbabilityTheory Classical
+open scoped Topology NNReal ENNReal
+
+namespace SLEExactGauge.Multipoint
+
+def levelStoppingRemainderGreen {Ω : Type*} (κ : ℝ) (B : ℝ≥0 → Ω → ℝ)
+    (γ : Ω → ℝ≥0 → ℂ) (G : Ω → ℝ≥0 → ℂ → ℂ)
+    (u : ℝ) (S : Ω → ℝ≥0∞) (z : ℂ) (ω : Ω) : ℝ :=
+  if S ω < radiusLevelTime (γ ω) (G ω) z u then
+    stoppedGreen κ (fun s => Real.sqrt κ * B s ω) (γ ω) (G ω) z u else 0
+
+def levelStoppingCurrentGreen {Ω : Type*} (κ : ℝ) (B : ℝ≥0 → Ω → ℝ)
+    (γ : Ω → ℝ≥0 → ℂ) (G : Ω → ℝ≥0 → ℂ → ℂ)
+    (u : ℝ) (S : Ω → ℝ≥0∞) (z : ℂ) (ω : Ω) : ℝ :=
+  if S ω < radiusLevelTime (γ ω) (G ω) z u then
+    greenDensity κ (fun s => Real.sqrt κ * B s ω) (γ ω) (G ω) (S ω).toNNReal z else 0
+
+lemma levelStoppingRemainderGreen_nonneg
+    {Ω : Type*} (κ : ℝ) (B : ℝ≥0 → Ω → ℝ)
+    (γ : Ω → ℝ≥0 → ℂ) (G F : Ω → ℝ≥0 → ℂ → ℂ)
+    (hw : ∀ ω, IsCapacityTwoWitness (fun s => Real.sqrt κ * B s ω) (γ ω) (G ω) (F ω))
+    (u : ℝ) (S : Ω → ℝ≥0∞) (z : ℂ) (ω : Ω) :
+    0 ≤ levelStoppingRemainderGreen κ B γ G u S z ω := by
+  unfold levelStoppingRemainderGreen
+  split_ifs
+  · exact stoppedGreen_nonneg (hw ω) κ z u
+  · exact le_rfl
+
+lemma levelStoppingCurrentGreen_nonneg
+    {Ω : Type*} (κ : ℝ) (B : ℝ≥0 → Ω → ℝ)
+    (γ : Ω → ℝ≥0 → ℂ) (G F : Ω → ℝ≥0 → ℂ → ℂ)
+    (hw : ∀ ω, IsCapacityTwoWitness (fun s => Real.sqrt κ * B s ω) (γ ω) (G ω) (F ω))
+    (u : ℝ) (S : Ω → ℝ≥0∞) (z : ℂ) (ω : Ω) :
+    0 ≤ levelStoppingCurrentGreen κ B γ G u S z ω := by
+  unfold levelStoppingCurrentGreen
+  split_ifs
+  · exact greenDensity_nonneg (hw ω) κ _ z
+  · exact le_rfl
+
+theorem levelStoppingRemainderGreen_finite_condExp
+    {Ω : Type*} [mΩ : MeasurableSpace Ω] {P : Measure Ω}
+    {B : ℝ≥0 → Ω → ℝ} (hB : IsBrownianReal B P)
+    (hBm : Measurable (Function.uncurry B))
+    (hc : ∀ ω, Continuous (fun t => B t ω)) (hB0 : ∀ ω, B 0 ω = 0)
+    {κ : ℝ} (hκ : 0 < κ) (hκ8 : κ < 8)
+    (γ : Ω → ℝ≥0 → ℂ) (G F : Ω → ℝ≥0 → ℂ → ℂ)
+    (hw : ∀ ω, IsCapacityTwoWitness (fun s => Real.sqrt κ * B s ω) (γ ω) (G ω) (F ω))
+    (z : ℂ) (hz : z ∈ upperHalfPlane) (u : ℝ) (hu : 0 ≤ u)
+    (σ : Ω → ℝ≥0)
+    (hσ : IsStoppingTime (Filtration.natural B (fun s =>
+      (hBm.comp (measurable_const.prodMk measurable_id) : Measurable (B s)).stronglyMeasurable))
+      (fun ω => (σ ω : WithTop ℝ≥0))) :
+    Integrable (levelStoppingRemainderGreen κ B γ G u (fun ω => σ ω) z) P ∧
+      Integrable (levelStoppingCurrentGreen κ B γ G u (fun ω => σ ω) z) P ∧
+      P[levelStoppingRemainderGreen κ B γ G u (fun ω => σ ω) z | hσ.measurableSpace] =ᵐ[P]
+        levelStoppingCurrentGreen κ B γ G u (fun ω => σ ω) z := by
+  let : IsProbabilityMeasure P := hB.isGaussianProcess.isProbabilityMeasure
+  let hm (s : ℝ≥0) : Measurable (B s) := hBm.comp (measurable_const.prodMk measurable_id)
+  obtain ⟨M,Z,_,hZi,_,_,_,hStop,heq,_⟩ := exists_physical_green_stopping_regular
+    hB hBm hc hB0 κ hκ hκ8 γ G F (ae_of_all _ hw) z hz u hu
+  have hτ := actual_radiusLevelTime_stopping hB hm hBm hc hB0 κ hκ hκ8 γ G F hw z hz u hu
+  let A : Set Ω := {ω | (σ ω : ℝ≥0∞) < radiusLevelTime (γ ω) (G ω) z u}
+  have hA : MeasurableSet[hσ.measurableSpace] A := by
+    have he : A = {ω | radiusLevelTime (γ ω) (G ω) z u ≤ (σ ω : WithTop ℝ≥0)}ᶜ := by
+      ext ω
+      change (σ ω : ℝ≥0∞) < radiusLevelTime (γ ω) (G ω) z u ↔
+        ¬ radiusLevelTime (γ ω) (G ω) z u ≤ (σ ω : ℝ≥0∞)
+      exact lt_iff_not_ge
+    rw [he]
+    exact (hτ.measurableSet_stopping_time_le hσ).compl
+  have hAg : MeasurableSet A := hσ.measurableSpace_le _ hA
+  have hR : levelStoppingRemainderGreen κ B γ G u (fun ω => σ ω) z =ᵐ[P] A.indicator Z := by
+    filter_upwards [heq] with ω he
+    by_cases ha : ω ∈ A
+    · have ht : (σ ω : ℝ≥0∞) < radiusLevelTime (γ ω) (G ω) z u := ha
+      rw [levelStoppingRemainderGreen,ite_eq_left ht,indicator_of_mem ha,he.2]
+    · have ht : ¬ (σ ω : ℝ≥0∞) < radiusLevelTime (γ ω) (G ω) z u := ha
+      rw [levelStoppingRemainderGreen,ite_eq_right ht,indicator_of_notMem ha]
+  have hC : levelStoppingCurrentGreen κ B γ G u (fun ω => σ ω) z =ᵐ[P]
+      A.indicator (fun ω => M (σ ω) ω) := by
+    filter_upwards [heq] with ω he
+    by_cases ha : ω ∈ A
+    · have ht : (σ ω : ℝ≥0∞) < radiusLevelTime (γ ω) (G ω) z u := ha
+      rw [levelStoppingCurrentGreen,ite_eq_left ht,indicator_of_mem ha,ENNReal.toNNReal_coe,
+        he.1 (σ ω),physicalStoppedGreen,ite_eq_right (not_le.mpr ht)]
+    · have ht : ¬ (σ ω : ℝ≥0∞) < radiusLevelTime (γ ω) (G ω) z u := ha
+      rw [levelStoppingCurrentGreen,ite_eq_right ht,indicator_of_notMem ha]
+  have hMi : Integrable (fun ω => M (σ ω) ω) P :=
+    integrable_condExp.congr (hStop σ hσ).symm
+  refine ⟨(hZi.indicator hAg).congr hR.symm,(hMi.indicator hAg).congr hC.symm,?_⟩
+  apply (condExp_congr_ae hR).trans
+  apply (condExp_indicator hZi hA).trans
+  apply EventuallyEq.trans _ hC.symm
+  filter_upwards [hStop σ hσ] with ω he
+  by_cases ha : ω ∈ A
+  · simpa only [indicator_of_mem ha] using he.symm
+  · simp only [indicator_of_notMem ha]
+
+theorem levelStoppingRemainderGreen_finite_setLIntegral
+    {Ω : Type*} [mΩ : MeasurableSpace Ω] {P : Measure Ω}
+    {B : ℝ≥0 → Ω → ℝ} (hB : IsBrownianReal B P)
+    (hBm : Measurable (Function.uncurry B))
+    (hc : ∀ ω, Continuous (fun t => B t ω)) (hB0 : ∀ ω, B 0 ω = 0)
+    {κ : ℝ} (hκ : 0 < κ) (hκ8 : κ < 8)
+    (γ : Ω → ℝ≥0 → ℂ) (G F : Ω → ℝ≥0 → ℂ → ℂ)
+    (hw : ∀ ω, IsCapacityTwoWitness (fun s => Real.sqrt κ * B s ω) (γ ω) (G ω) (F ω))
+    (z : ℂ) (hz : z ∈ upperHalfPlane) (u : ℝ) (hu : 0 ≤ u)
+    (σ : Ω → ℝ≥0)
+    (hσ : IsStoppingTime (Filtration.natural B (fun s =>
+      (hBm.comp (measurable_const.prodMk measurable_id) : Measurable (B s)).stronglyMeasurable))
+      (fun ω => (σ ω : WithTop ℝ≥0)))
+    (A : Set Ω) (hA : MeasurableSet[hσ.measurableSpace] A) :
+    (∫⁻ ω in A, ENNReal.ofReal (levelStoppingRemainderGreen κ B γ G u (fun ω => σ ω) z ω) ∂P) =
+      ∫⁻ ω in A, ENNReal.ofReal (levelStoppingCurrentGreen κ B γ G u (fun ω => σ ω) z ω) ∂P := by
+  let : IsProbabilityMeasure P := hB.isGaussianProcess.isProbabilityMeasure
+  obtain ⟨hR,hC,he⟩ := levelStoppingRemainderGreen_finite_condExp hB hBm hc hB0 hκ hκ8
+    γ G F hw z hz u hu σ hσ
+  have hRn : ∀ᵐ ω ∂P.restrict A, 0 ≤ levelStoppingRemainderGreen κ B γ G u (fun ω => σ ω) z ω :=
+    ae_of_all _ (levelStoppingRemainderGreen_nonneg κ B γ G F hw u _ z)
+  have hCn : ∀ᵐ ω ∂P.restrict A, 0 ≤ levelStoppingCurrentGreen κ B γ G u (fun ω => σ ω) z ω :=
+    ae_of_all _ (levelStoppingCurrentGreen_nonneg κ B γ G F hw u _ z)
+  rw [← ofReal_integral_eq_lintegral_ofReal hR.integrableOn hRn,
+    ← ofReal_integral_eq_lintegral_ofReal hC.integrableOn hCn]
+  congr 1
+  have : IsFiniteMeasure (P.trim hσ.measurableSpace_le) := isFiniteMeasure_trim hσ.measurableSpace_le
+  exact (setIntegral_condExp hσ.measurableSpace_le hR hA).symm.trans
+    (integral_congr_ae (ae_restrict_of_ae he))
+
+private lemma stopped_setLIntegral_cutoffs
+    {Ω : Type*} [MeasurableSpace Ω] (P : Measure Ω)
+    (S : Ω → ℝ≥0∞) (hS : Measurable S) (E : Set Ω) (f : Ω → ℝ≥0∞)
+    (hz : ∀ ω, S ω = ∞ → f ω = 0) :
+    (∫⁻ ω in E, f ω ∂P) =
+      ⨆ n : ℕ, ∫⁻ ω in E ∩ {ω | S ω ≤ (n:ℝ≥0)}, f ω ∂P := by
+  let A (n : ℕ) := E ∩ {ω | S ω ≤ (n:ℝ≥0)}
+  have hmono : Monotone A := by
+    intro n k hnk ω hω
+    refine ⟨hω.1,?_⟩
+    change S ω ≤ ((k:ℝ≥0):ℝ≥0∞)
+    exact hω.2.trans (ENNReal.coe_le_coe.mpr (by exact_mod_cast hnk))
+  have hcover : (⋃ n, A n) = E ∩ {ω | S ω < ∞} := by
+    ext ω
+    simp only [mem_iUnion,A,mem_inter_iff,mem_ofPred_eq]
+    constructor
+    · rintro ⟨n,hnE,hn⟩
+      exact ⟨hnE,hn.trans_lt ENNReal.coe_lt_top⟩
+    · rintro ⟨hE,hfin⟩
+      obtain ⟨n,hn⟩ := exists_nat_ge ((S ω).toReal)
+      refine ⟨n,hE,?_⟩
+      exact (ENNReal.toReal_le_toReal hfin.ne ENNReal.coe_ne_top).mp (by simpa using hn)
+  have hsupp : f.support ⊆ {ω | S ω < ∞} := by
+    intro ω hω
+    by_contra hn
+    exact hω (hz ω (top_le_iff.mp (le_of_not_gt hn)))
+  calc
+    (∫⁻ ω in E, f ω ∂P) = ∫⁻ ω in {ω | S ω < ∞}, f ω ∂P.restrict E :=
+      (setLIntegral_eq_of_support_subset hsupp).symm
+    _ = ∫⁻ ω in E ∩ {ω | S ω < ∞}, f ω ∂P := by
+      rw [Measure.restrict_restrict (measurableSet_lt hS measurable_const),inter_comm]
+    _ = ∫⁻ ω in ⋃ n, A n, f ω ∂P := by rw [hcover]
+    _ = _ := setLIntegral_iUnion_of_directed f hmono.directed_le
+
+theorem levelStoppingRemainderGreen_setLIntegral
+    {Ω : Type*} [mΩ : MeasurableSpace Ω] {P : Measure Ω}
+    {B : ℝ≥0 → Ω → ℝ} (hB : IsBrownianReal B P)
+    (hBm : Measurable (Function.uncurry B))
+    (hc : ∀ ω, Continuous (fun t => B t ω)) (hB0 : ∀ ω, B 0 ω = 0)
+    {κ : ℝ} (hκ : 0 < κ) (hκ8 : κ < 8)
+    (γ : Ω → ℝ≥0 → ℂ) (G F : Ω → ℝ≥0 → ℂ → ℂ)
+    (hw : ∀ ω, IsCapacityTwoWitness (fun s => Real.sqrt κ * B s ω) (γ ω) (G ω) (F ω))
+    (z : ℂ) (hz : z ∈ upperHalfPlane) (u : ℝ) (hu : 0 ≤ u)
+    (S : Ω → WithTop ℝ≥0)
+    (hS : IsStoppingTime (Filtration.natural B (fun s =>
+      (hBm.comp (measurable_const.prodMk measurable_id) : Measurable (B s)).stronglyMeasurable)) S)
+    (E : Set Ω) (hE : MeasurableSet[hS.measurableSpace] E) :
+    (∫⁻ ω in E, ENNReal.ofReal (levelStoppingRemainderGreen κ B γ G u S z ω) ∂P) =
+      ∫⁻ ω in E, ENNReal.ofReal (levelStoppingCurrentGreen κ B γ G u S z ω) ∂P := by
+  classical
+  let ℱ := Filtration.natural B (fun s =>
+    (hBm.comp (measurable_const.prodMk measurable_id) : Measurable (B s)).stronglyMeasurable)
+  have hRzero (ω : Ω) (hω : S ω = ∞) :
+      ENNReal.ofReal (levelStoppingRemainderGreen κ B γ G u S z ω) = 0 := by
+    simp [levelStoppingRemainderGreen,hω]
+  have hCzero (ω : Ω) (hω : S ω = ∞) :
+      ENNReal.ofReal (levelStoppingCurrentGreen κ B γ G u S z ω) = 0 := by
+    simp [levelStoppingCurrentGreen,hω]
+  rw [stopped_setLIntegral_cutoffs P S hS.measurable' E _ hRzero,
+    stopped_setLIntegral_cutoffs P S hS.measurable' E _ hCzero]
+  apply iSup_congr
+  intro n
+  let σ := cutoffStop S (n:ℝ≥0)
+  have hσ := cutoffStop_stopping ℱ S hS (n:ℝ≥0)
+  have hlocal := levelStoppingRemainderGreen_finite_setLIntegral hB hBm hc hB0 hκ hκ8
+    γ G F hw z hz u hu σ hσ (E ∩ {ω | S ω ≤ (n:ℝ≥0)})
+    (cutoffStop_success_measurable ℱ S hS (n:ℝ≥0) E hE)
+  have he (ω : Ω) (hω : ω ∈ E ∩ {ω | S ω ≤ (n:ℝ≥0)}) : (σ ω : ℝ≥0∞) = S ω := by
+    change (cutoffStop S (n:ℝ≥0) ω : WithTop ℝ≥0) = S ω
+    rw [cutoffStop_coe,min_eq_left hω.2]
+  calc
+    _ = ∫⁻ ω in E ∩ {ω | S ω ≤ (n:ℝ≥0)},
+        ENNReal.ofReal (levelStoppingRemainderGreen κ B γ G u (fun ω => σ ω) z ω) ∂P := by
+      apply setLIntegral_congr_fun (hS.measurableSpace_le _
+        (hE.inter (hS.measurableSet_le' (n:ℝ≥0))))
+      intro ω hω
+      simp only [levelStoppingRemainderGreen,he ω hω]
+      split_ifs <;> rfl
+    _ = _ := hlocal
+    _ = _ := by
+      apply setLIntegral_congr_fun (hS.measurableSpace_le _
+        (hE.inter (hS.measurableSet_le' (n:ℝ≥0))))
+      intro ω hω
+      simp only [levelStoppingCurrentGreen,he ω hω]
+      split_ifs <;> rfl
+
+end SLEExactGauge.Multipoint
+
+end
+
+end OAI

lean/OAI/Probability/SLE/Mass/LevelStoppingMeasures.lean

@@ -0,0 +1,280 @@
+import OAI.Probability.SLE.Mass.LevelStoppingGreenLimit
+import OAI.Probability.SLE.Mass.LevelMeanMeasure
+
+namespace OAI
+
+/-! The unreached part of a finite-level approximation at an arbitrary
+stopping time, as a positive measure. -/
+
+noncomputable section
+open Set Filter MeasureTheory ProbabilityTheory Classical
+open scoped NNReal ENNReal Topology
+
+namespace SLEExactGauge.Multipoint
+
+lemma levelApproximationDensity_random_time_joint_measurable
+    {Ω : Type*} [MeasurableSpace Ω] {B : ℝ≥0 → Ω → ℝ}
+    (hm : ∀ t, Measurable (B t)) (hc : ∀ ω, Continuous (fun t => B t ω))
+    (κ u : ℝ) (hu : 0 ≤ u)
+    (γ : Ω → ℝ≥0 → ℂ) (G F : Ω → ℝ≥0 → ℂ → ℂ)
+    (hw : ∀ ω, IsCapacityTwoWitness (fun t => Real.sqrt κ * B t ω) (γ ω) (G ω) (F ω))
+    (S : Ω → ℝ≥0∞) (hS : Measurable S) :
+    Measurable (fun p : Ω × ℂ => levelApproximationDensity κ B γ G u (S p.1) p.1 p.2) :=
+  Measurable.ite (measurableSet_le
+    (actual_radiusLevel_joint_measurable hm hc κ u hu γ G F hw) (hS.comp measurable_fst))
+    (actual_stoppedGreen_joint_measurable hm hc κ u hu γ G F hw).ennreal_ofReal measurable_const
+
+lemma halfPlaneLevelMeasure_random_time_measurable
+    {Ω : Type*} [MeasurableSpace Ω] {B : ℝ≥0 → Ω → ℝ}
+    (hm : ∀ t, Measurable (B t)) (hc : ∀ ω, Continuous (fun t => B t ω))
+    (κ u : ℝ) (hu : 0 ≤ u)
+    (γ : Ω → ℝ≥0 → ℂ) (G F : Ω → ℝ≥0 → ℂ → ℂ)
+    (hw : ∀ ω, IsCapacityTwoWitness (fun t => Real.sqrt κ * B t ω) (γ ω) (G ω) (F ω))
+    (S : Ω → ℝ≥0∞) (hS : Measurable S) :
+    Measurable (fun ω => halfPlaneLevelMeasure κ B γ G u (S ω) ω) := by
+  apply Measure.measurable_of_measurable_coe
+  intro A hA
+  have hAI := (MeasurableEmbedding.subtype_coe isOpen_upperHalfPlane.measurableSet).measurableSet_image.mpr hA
+  simp only [halfPlaneLevelMeasure,levelApproximation,
+    comap_subtype_coe_apply isOpen_upperHalfPlane.measurableSet,withDensity_apply _ hAI]
+  exact (levelApproximationDensity_random_time_joint_measurable hm hc κ u hu γ G F hw S hS).lintegral_prod_right'
+
+def halfPlaneStoppingRemainderMeasure {Ω : Type*} (κ : ℝ) (B : ℝ≥0 → Ω → ℝ)
+    (γ : Ω → ℝ≥0 → ℂ) (G : Ω → ℝ≥0 → ℂ → ℂ)
+    (u : ℝ) (S : Ω → ℝ≥0∞) (ω : Ω) : Measure upperHalfPlane :=
+  (volume.withDensity (fun z => ENNReal.ofReal (levelStoppingRemainderGreen κ B γ G u S z ω))).comap Subtype.val
+
+def halfPlaneStoppingCurrentMeasure {Ω : Type*} (κ : ℝ) (B : ℝ≥0 → Ω → ℝ)
+    (γ : Ω → ℝ≥0 → ℂ) (G : Ω → ℝ≥0 → ℂ → ℂ)
+    (u : ℝ) (S : Ω → ℝ≥0∞) (ω : Ω) : Measure upperHalfPlane :=
+  (volume.withDensity (fun z => ENNReal.ofReal (levelStoppingCurrentGreen κ B γ G u S z ω))).comap Subtype.val
+
+def halfPlaneStoppingGreenMeasure {Ω : Type*} (κ : ℝ) (B : ℝ≥0 → Ω → ℝ)
+    (γ : Ω → ℝ≥0 → ℂ) (G : Ω → ℝ≥0 → ℂ → ℂ)
+    (S : Ω → ℝ≥0∞) (ω : Ω) : Measure upperHalfPlane :=
+  (volume.withDensity (fun z => ENNReal.ofReal (stoppingGreen κ B γ G S z ω))).comap Subtype.val
+
+lemma stoppingGreen_joint_measurable
+    {Ω : Type*} [MeasurableSpace Ω] {B : ℝ≥0 → Ω → ℝ}
+    (hBm : Measurable (Function.uncurry B)) (hc : ∀ ω, Continuous (fun t => B t ω))
+    (κ : ℝ) (γ : Ω → ℝ≥0 → ℂ) (G F : Ω → ℝ≥0 → ℂ → ℂ)
+    (hw : ∀ ω, IsCapacityTwoWitness (fun t => Real.sqrt κ * B t ω) (γ ω) (G ω) (F ω))
+    (S : Ω → ℝ≥0∞) (hS : Measurable S) :
+    Measurable (fun p : Ω × ℂ => stoppingGreen κ B γ G S p.2 p.1) :=
+  Measurable.ite (measurableSet_lt (hS.comp measurable_fst) measurable_const)
+    (actual_greenDensity_random_time_joint_measurable hBm hc κ γ G F hw
+      (fun ω => (S ω).toNNReal) (ENNReal.measurable_toNNReal.comp hS)) measurable_const
+
+lemma halfPlaneStoppingGreenMeasure_measurable
+    {Ω : Type*} [MeasurableSpace Ω] {B : ℝ≥0 → Ω → ℝ}
+    (hBm : Measurable (Function.uncurry B)) (hc : ∀ ω, Continuous (fun t => B t ω))
+    (κ : ℝ) (γ : Ω → ℝ≥0 → ℂ) (G F : Ω → ℝ≥0 → ℂ → ℂ)
+    (hw : ∀ ω, IsCapacityTwoWitness (fun t => Real.sqrt κ * B t ω) (γ ω) (G ω) (F ω))
+    (S : Ω → ℝ≥0∞) (hS : Measurable S) :
+    Measurable (halfPlaneStoppingGreenMeasure κ B γ G S) := by
+  apply Measure.measurable_of_measurable_coe
+  intro A hA
+  have hAI := (MeasurableEmbedding.subtype_coe isOpen_upperHalfPlane.measurableSet).measurableSet_image.mpr hA
+  simp only [halfPlaneStoppingGreenMeasure,comap_subtype_coe_apply isOpen_upperHalfPlane.measurableSet,
+    withDensity_apply _ hAI]
+  exact (stoppingGreen_joint_measurable hBm hc κ γ G F hw S hS).ennreal_ofReal.lintegral_prod_right'
+
+lemma halfPlaneStoppingRemainderMeasure_measurable
+    {Ω : Type*} [MeasurableSpace Ω] {B : ℝ≥0 → Ω → ℝ}
+    (hm : ∀ t, Measurable (B t)) (hBc : ∀ ω, Continuous (fun t => B t ω))
+    (κ u : ℝ) (hu : 0 ≤ u)
+    (γ : Ω → ℝ≥0 → ℂ) (G F : Ω → ℝ≥0 → ℂ → ℂ)
+    (hw : ∀ ω, IsCapacityTwoWitness (fun t => Real.sqrt κ * B t ω) (γ ω) (G ω) (F ω))
+    (S : Ω → ℝ≥0∞) (hS : Measurable S) : Measurable (halfPlaneStoppingRemainderMeasure κ B γ G u S) := by
+  apply Measure.measurable_of_measurable_coe
+  intro A hA
+  have hAI := (MeasurableEmbedding.subtype_coe isOpen_upperHalfPlane.measurableSet).measurableSet_image.mpr hA
+  simp only [halfPlaneStoppingRemainderMeasure,comap_subtype_coe_apply isOpen_upperHalfPlane.measurableSet,
+    withDensity_apply _ hAI]
+  exact (levelStoppingRemainderGreen_joint_measurable hm hBc κ u hu γ G F hw S hS).ennreal_ofReal.lintegral_prod_right'
+
+lemma halfPlaneStoppingCurrentMeasure_measurable
+    {Ω : Type*} [MeasurableSpace Ω] {B : ℝ≥0 → Ω → ℝ}
+    (hBm : Measurable (Function.uncurry B)) (hBc : ∀ ω, Continuous (fun t => B t ω))
+    (κ u : ℝ) (hu : 0 ≤ u)
+    (γ : Ω → ℝ≥0 → ℂ) (G F : Ω → ℝ≥0 → ℂ → ℂ)
+    (hw : ∀ ω, IsCapacityTwoWitness (fun t => Real.sqrt κ * B t ω) (γ ω) (G ω) (F ω))
+    (S : Ω → ℝ≥0∞) (hS : Measurable S) : Measurable (halfPlaneStoppingCurrentMeasure κ B γ G u S) := by
+  apply Measure.measurable_of_measurable_coe
+  intro A hA
+  have hAI := (MeasurableEmbedding.subtype_coe isOpen_upperHalfPlane.measurableSet).measurableSet_image.mpr hA
+  simp only [halfPlaneStoppingCurrentMeasure,comap_subtype_coe_apply isOpen_upperHalfPlane.measurableSet,
+    withDensity_apply _ hAI]
+  exact (levelStoppingCurrentGreen_joint_measurable hBm hBc κ u hu γ G F hw S hS).ennreal_ofReal.lintegral_prod_right'
+
+lemma halfPlaneLevelMeasure_stopping_split
+    {Ω : Type*} [MeasurableSpace Ω] {B : ℝ≥0 → Ω → ℝ}
+    (hm : ∀ t, Measurable (B t)) (hBc : ∀ ω, Continuous (fun t => B t ω))
+    (κ u : ℝ) (hu : 0 ≤ u)
+    (γ : Ω → ℝ≥0 → ℂ) (G F : Ω → ℝ≥0 → ℂ → ℂ)
+    (hw : ∀ ω, IsCapacityTwoWitness (fun t => Real.sqrt κ * B t ω) (γ ω) (G ω) (F ω))
+    (S : Ω → ℝ≥0∞) (hS : Measurable S) (ω : Ω) :
+    halfPlaneLevelMeasure κ B γ G u ∞ ω =
+      halfPlaneLevelMeasure κ B γ G u (S ω) ω + halfPlaneStoppingRemainderMeasure κ B γ G u S ω := by
+  apply Measure.ext
+  intro A hA
+  have hAI := (MeasurableEmbedding.subtype_coe isOpen_upperHalfPlane.measurableSet).measurableSet_image.mpr hA
+  simp only [Measure.add_apply,halfPlaneLevelMeasure,halfPlaneStoppingRemainderMeasure,levelApproximation,
+    comap_subtype_coe_apply isOpen_upperHalfPlane.measurableSet,withDensity_apply _ hAI]
+  simp_rw [stopping_level_density_split κ B γ G u S ω]
+  have hd : Measurable (fun z => levelApproximationDensity κ B γ G u (S ω) ω z) := by
+    have hp : Measurable (fun z : ℂ => (ω,z)) := measurable_const.prodMk measurable_id
+    have hh := (levelApproximationDensity_random_time_joint_measurable hm hBc κ u hu
+      γ G F hw S hS).comp hp
+    simpa only [Function.comp_def] using hh
+  exact lintegral_add_left hd _
+
+theorem halfPlaneStoppingRemainderMeasure_conditional_mean
+    {Ω : Type*} [MeasurableSpace Ω]
+    {P : Measure Ω} {B : ℝ≥0 → Ω → ℝ} (hB : IsBrownianReal B P)
+    (hBm : Measurable (Function.uncurry B))
+    (hBc : ∀ ω, Continuous (fun t => B t ω)) (hB0 : ∀ ω, B 0 ω = 0)
+    {κ : ℝ} (hκ : 0 < κ) (hκ8 : κ < 8)
+    (γ : Ω → ℝ≥0 → ℂ) (G F : Ω → ℝ≥0 → ℂ → ℂ)
+    (hw : ∀ ω, IsCapacityTwoWitness (fun t => Real.sqrt κ * B t ω) (γ ω) (G ω) (F ω))
+    (u : ℝ) (hu : 0 ≤ u) (S : Ω → WithTop ℝ≥0)
+    (hS : IsStoppingTime (Filtration.natural B (fun s =>
+      (hBm.comp (measurable_const.prodMk measurable_id) : Measurable (B s)).stronglyMeasurable)) S)
+    (E : Set Ω)
+    (hE : MeasurableSet[hS.measurableSpace] E) :
+    (P.restrict E).bind (halfPlaneStoppingRemainderMeasure κ B γ G u S) =
+      (P.restrict E).bind (halfPlaneStoppingCurrentMeasure κ B γ G u S) := by
+  let hm (s : ℝ≥0) : Measurable (B s) := hBm.comp (measurable_const.prodMk measurable_id)
+  apply Measure.ext
+  intro A hA
+  have hAI := (MeasurableEmbedding.subtype_coe isOpen_upperHalfPlane.measurableSet).measurableSet_image.mpr hA
+  have hAH : (Subtype.val : upperHalfPlane → ℂ) '' A ⊆ upperHalfPlane := by
+    rintro _ ⟨x,_,rfl⟩; exact x.property
+  rw [Measure.bind_apply hA (halfPlaneStoppingRemainderMeasure_measurable hm hBc κ u hu γ G F hw S hS.measurable').aemeasurable,
+    Measure.bind_apply hA (halfPlaneStoppingCurrentMeasure_measurable hBm hBc κ u hu γ G F hw S hS.measurable').aemeasurable]
+  simp only [halfPlaneStoppingRemainderMeasure,halfPlaneStoppingCurrentMeasure,
+    comap_subtype_coe_apply isOpen_upperHalfPlane.measurableSet,withDensity_apply _ hAI]
+  simpa only [one_mul] using levelStoppingRemainderGreen_spatial_kernel hB hBm hBc hB0 hκ hκ8 γ G F hw
+    u hu S hS _ hAI hAH (fun _ => 1) measurable_const E hE
+
+theorem halfPlaneLevelMeasure_stopping_conditional_split
+    {Ω : Type*} [MeasurableSpace Ω] {P : Measure Ω}
+    {B : ℝ≥0 → Ω → ℝ} (hB : IsBrownianReal B P)
+    (hBm : Measurable (Function.uncurry B)) (hc : ∀ ω, Continuous (fun t => B t ω))
+    (hB0 : ∀ ω, B 0 ω = 0) {κ : ℝ} (hκ : 0 < κ) (hκ8 : κ < 8)
+    (γ : Ω → ℝ≥0 → ℂ) (G F : Ω → ℝ≥0 → ℂ → ℂ)
+    (hw : ∀ ω, IsCapacityTwoWitness (fun t => Real.sqrt κ * B t ω) (γ ω) (G ω) (F ω))
+    (u : ℝ) (hu : 0 ≤ u) (S : Ω → WithTop ℝ≥0)
+    (hS : IsStoppingTime (Filtration.natural B (fun s =>
+      (hBm.comp (measurable_const.prodMk measurable_id) : Measurable (B s)).stronglyMeasurable)) S)
+    (E : Set Ω) (hE : MeasurableSet[hS.measurableSpace] E) :
+    (P.restrict E).bind (halfPlaneLevelMeasure κ B γ G u ∞) =
+      (P.restrict E).bind (fun ω => halfPlaneLevelMeasure κ B γ G u (S ω) ω) +
+      (P.restrict E).bind (halfPlaneStoppingCurrentMeasure κ B γ G u S) := by
+  let hm (s : ℝ≥0) : Measurable (B s) := hBm.comp (measurable_const.prodMk measurable_id)
+  rw [← halfPlaneStoppingRemainderMeasure_conditional_mean hB hBm hc hB0 hκ hκ8
+    γ G F hw u hu S hS E hE]
+  apply Measure.ext
+  intro A hA
+  rw [Measure.add_apply,
+    Measure.bind_apply hA (halfPlaneLevelMeasure_measurable hm hc κ u hu γ G F hw ∞).aemeasurable,
+    Measure.bind_apply hA (halfPlaneLevelMeasure_random_time_measurable hm hc κ u hu
+      γ G F hw S hS.measurable').aemeasurable,
+    Measure.bind_apply hA (halfPlaneStoppingRemainderMeasure_measurable hm hc κ u hu
+      γ G F hw S hS.measurable').aemeasurable]
+  simp_rw [halfPlaneLevelMeasure_stopping_split hm hc κ u hu γ G F hw S hS.measurable',Measure.add_apply]
+  exact lintegral_add_left (((Measure.measurable_coe hA).comp
+    (halfPlaneLevelMeasure_random_time_measurable hm hc κ u hu γ G F hw S hS.measurable'))) _
+
+theorem halfPlaneStoppingGreenMeasure_mean_le
+    {Ω : Type*} [MeasurableSpace Ω] {P : Measure Ω}
+    {B : ℝ≥0 → Ω → ℝ} (hB : IsBrownianReal B P)
+    (hBm : Measurable (Function.uncurry B)) (hc : ∀ ω, Continuous (fun t => B t ω))
+    (hB0 : ∀ ω, B 0 ω = 0) {κ : ℝ} (hκ : 0 < κ) (hκ8 : κ < 8)
+    (γ : Ω → ℝ≥0 → ℂ) (G F : Ω → ℝ≥0 → ℂ → ℂ)
+    (hw : ∀ ω, IsCapacityTwoWitness (fun t => Real.sqrt κ * B t ω) (γ ω) (G ω) (F ω))
+    (S : Ω → WithTop ℝ≥0)
+    (hS : IsStoppingTime (Filtration.natural B (fun s =>
+      (hBm.comp (measurable_const.prodMk measurable_id) : Measurable (B s)).stronglyMeasurable)) S)
+    (E : Set Ω) :
+    (P.restrict E).bind (halfPlaneStoppingGreenMeasure κ B γ G S) ≤ initialGreenMeasure κ := by
+  let : IsProbabilityMeasure P := hB.isGaussianProcess.isProbabilityMeasure
+  apply Measure.le_iff.mpr
+  intro A hA
+  have hAI := (MeasurableEmbedding.subtype_coe isOpen_upperHalfPlane.measurableSet).measurableSet_image.mpr hA
+  have hAH : (Subtype.val : upperHalfPlane → ℂ) '' A ⊆ upperHalfPlane := by
+    rintro _ ⟨x,_,rfl⟩
+    exact x.property
+  rw [Measure.bind_apply hA
+    (halfPlaneStoppingGreenMeasure_measurable hBm hc κ γ G F hw S hS.measurable').aemeasurable]
+  simp only [halfPlaneStoppingGreenMeasure,initialGreenMeasure,
+    comap_subtype_coe_apply isOpen_upperHalfPlane.measurableSet,withDensity_apply _ hAI]
+  apply (lintegral_mono' Measure.restrict_le_self (le_refl _)).trans
+  rw [lintegral_lintegral_swap
+    (stoppingGreen_joint_measurable hBm hc κ γ G F hw S hS.measurable').ennreal_ofReal.aemeasurable]
+  exact setLIntegral_mono' hAI (fun z hz =>
+    stoppingGreen_mean_le hB hBm hc hB0 hκ hκ8 γ G F hw z (hAH hz) S hS)
+
+theorem stoppingCurrentGreen_spatial_mean_tendsto
+    {Ω : Type*} [MeasurableSpace Ω] (P : Measure Ω)
+    {B : ℝ≥0 → Ω → ℝ} (hBm : Measurable (Function.uncurry B))
+    (hBc : ∀ ω, Continuous (fun t => B t ω)) (κ : ℝ)
+    (γ : Ω → ℝ≥0 → ℂ) (G F : Ω → ℝ≥0 → ℂ → ℂ)
+    (hw : ∀ ω, IsCapacityTwoWitness (fun t => Real.sqrt κ * B t ω) (γ ω) (G ω) (F ω))
+    (u : ℕ → ℝ) (hu : ∀ n, 0 ≤ u n) (hmono : Monotone u)
+    (hlim : Tendsto u atTop atTop) (S : Ω → ℝ≥0∞) (hS : Measurable S) (K : Set ℂ)
+    (f : ℂ → ℝ≥0∞) (hf : Measurable f) (E : Set Ω) :
+    Tendsto (fun n => ∫⁻ ω in E, (∫⁻ z in K,
+      f z * ENNReal.ofReal (levelStoppingCurrentGreen κ B γ G (u n) S z ω) ∂volume) ∂P)
+      atTop (𝓝 (∫⁻ ω in E, (∫⁻ z in K, f z * ENNReal.ofReal
+        (stoppingGreen κ B γ G S z ω) ∂volume) ∂P)) := by
+  let a (n : ℕ) (q : Ω × ℂ) :=
+    f q.2 * ENNReal.ofReal (levelStoppingCurrentGreen κ B γ G (u n) S q.2 q.1)
+  have ha (n : ℕ) : Measurable (a n) :=
+    (hf.comp measurable_snd).mul
+      (levelStoppingCurrentGreen_joint_measurable hBm hBc κ (u n) (hu n) γ G F hw S hS).ennreal_ofReal
+  have ham (ω : Ω) : Monotone (fun n => fun z => a n (ω,z)) := by
+    intro n m hnm z
+    exact mul_le_mul' le_rfl (ENNReal.ofReal_le_ofReal
+      (levelStoppingCurrentGreen_mono ω (hBc ω) (hw ω) z S (hu n) (hmono hnm)))
+  have hal (ω : Ω) : Tendsto (fun n => ∫⁻ z in K, a n (ω,z)) atTop
+      (𝓝 (∫⁻ z in K, f z * ENNReal.ofReal
+        (stoppingGreen κ B γ G S z ω))) := by
+    apply lintegral_tendsto_of_tendsto_of_monotone (μ := volume.restrict K)
+      (f := fun n z => a n (ω,z))
+      (fun n => ((ha n).comp (measurable_const.prodMk measurable_id)).aemeasurable)
+      (Eventually.of_forall (fun z n m hnm => ham ω hnm z))
+    filter_upwards [] with z
+    apply tendsto_const_nhds.congr'
+    exact (levelStoppingCurrentGreen_eventually_eq ω (hBc ω) (hw ω) z S u hu hlim).mono
+      (fun n hn => congrArg (fun x : ℝ => f z * ENNReal.ofReal x) hn.symm)
+  exact lintegral_tendsto_of_tendsto_of_monotone
+    (fun n => (ha n).lintegral_prod_right'.aemeasurable)
+    (Eventually.of_forall (fun ω n m hnm => lintegral_mono (ham ω hnm)))
+    (Eventually.of_forall hal)
+
+theorem halfPlaneStoppingCurrentMeasure_mean_tendsto
+    {Ω : Type*} [MeasurableSpace Ω] (P : Measure Ω)
+    {B : ℝ≥0 → Ω → ℝ} (hBm : Measurable (Function.uncurry B))
+    (hBc : ∀ ω, Continuous (fun t => B t ω)) (κ : ℝ)
+    (γ : Ω → ℝ≥0 → ℂ) (G F : Ω → ℝ≥0 → ℂ → ℂ)
+    (hw : ∀ ω, IsCapacityTwoWitness (fun t => Real.sqrt κ * B t ω) (γ ω) (G ω) (F ω))
+    (u : ℕ → ℝ) (hu : ∀ n, 0 ≤ u n) (hmono : Monotone u)
+    (hlim : Tendsto u atTop atTop) (S : Ω → ℝ≥0∞) (hS : Measurable S) (E : Set Ω)
+    (A : Set upperHalfPlane) (hA : MeasurableSet A) :
+    Tendsto (fun n => (P.restrict E).bind (halfPlaneStoppingCurrentMeasure κ B γ G (u n) S) A)
+      atTop (𝓝 ((P.restrict E).bind (halfPlaneStoppingGreenMeasure κ B γ G S) A)) := by
+  have hAI := (MeasurableEmbedding.subtype_coe isOpen_upperHalfPlane.measurableSet).measurableSet_image.mpr hA
+  simp only [Measure.bind_apply hA
+    (halfPlaneStoppingCurrentMeasure_measurable hBm hBc κ (u _) (hu _) γ G F hw S hS).aemeasurable,
+    Measure.bind_apply hA (halfPlaneStoppingGreenMeasure_measurable hBm hBc κ γ G F hw S hS).aemeasurable,
+    halfPlaneStoppingCurrentMeasure,halfPlaneStoppingGreenMeasure,
+    comap_subtype_coe_apply isOpen_upperHalfPlane.measurableSet,withDensity_apply _ hAI]
+  simpa only [one_mul] using stoppingCurrentGreen_spatial_mean_tendsto P hBm hBc κ γ G F hw
+    u hu hmono hlim S hS _ (fun _ => 1) measurable_const E
+
+end SLEExactGauge.Multipoint
+
+end
+
+end OAI

lean/OAI/Probability/SLE/Mass/LevelStoppingSpatialKernel.lean

@@ -0,0 +1,114 @@
+import OAI.Probability.SLE.Mass.LevelStoppingKernel
+
+namespace OAI
+
+/-! Joint spatial measurability and the spatial form of the finite-level
+conditional kernel at an arbitrary, possibly infinite, stopping time. -/
+
+noncomputable section
+open Set Filter MeasureTheory ProbabilityTheory Classical
+open scoped Topology NNReal ENNReal
+
+namespace SLEExactGauge.Multipoint
+
+lemma actual_greenDensity_random_time_joint_measurable
+    {Ω : Type*} [MeasurableSpace Ω] {B : ℝ≥0 → Ω → ℝ}
+    (hBm : Measurable (Function.uncurry B)) (hc : ∀ ω, Continuous (fun t => B t ω))
+    (κ : ℝ) (γ : Ω → ℝ≥0 → ℂ) (G F : Ω → ℝ≥0 → ℂ → ℂ)
+    (hw : ∀ ω, IsCapacityTwoWitness (fun t => Real.sqrt κ * B t ω) (γ ω) (G ω) (F ω))
+    (t : Ω → ℝ≥0) (ht : Measurable t) :
+    Measurable (fun p : Ω × ℂ => greenDensity κ
+      (fun s => Real.sqrt κ * B s p.1) (γ p.1) (G p.1) (t p.1) p.2) := by
+  let U (s : ℝ≥0) (ω : Ω) := Real.sqrt κ * B s ω
+  let c := spatialClippedFamily U (hBm.const_mul _) (fun ω => (hc ω).const_mul _)
+  have hmap : Measurable (fun p : Ω × ℂ => (t p.1,p.2,p.1)) :=
+    (ht.comp measurable_fst).prodMk (measurable_snd.prodMk measurable_fst)
+  have hj := (c.jointGreen_measurable κ B hBm).comp hmap
+  have he (p : Ω × ℂ) : c.jointGreen κ B (t p.1,p.2,p.1) =
+      greenDensity κ (fun s => Real.sqrt κ * B s p.1) (γ p.1) (G p.1) (t p.1) p.2 :=
+    c.jointGreen_eq κ B p.1 ((hc p.1).const_mul _) (fun _ => rfl) (hw p.1) _ _
+  simpa only [Function.comp_def,he] using hj
+
+lemma levelStoppingRemainderGreen_joint_measurable
+    {Ω : Type*} [MeasurableSpace Ω] {B : ℝ≥0 → Ω → ℝ}
+    (hm : ∀ t, Measurable (B t)) (hc : ∀ ω, Continuous (fun t => B t ω))
+    (κ u : ℝ) (hu : 0 ≤ u)
+    (γ : Ω → ℝ≥0 → ℂ) (G F : Ω → ℝ≥0 → ℂ → ℂ)
+    (hw : ∀ ω, IsCapacityTwoWitness (fun t => Real.sqrt κ * B t ω) (γ ω) (G ω) (F ω))
+    (S : Ω → ℝ≥0∞) (hS : Measurable S) :
+    Measurable (fun p : Ω × ℂ => levelStoppingRemainderGreen κ B γ G u S p.2 p.1) :=
+  Measurable.ite
+    (measurableSet_lt (hS.comp measurable_fst)
+      (actual_radiusLevel_joint_measurable hm hc κ u hu γ G F hw))
+    (actual_stoppedGreen_joint_measurable hm hc κ u hu γ G F hw) measurable_const
+
+lemma levelStoppingCurrentGreen_joint_measurable
+    {Ω : Type*} [MeasurableSpace Ω] {B : ℝ≥0 → Ω → ℝ}
+    (hBm : Measurable (Function.uncurry B)) (hc : ∀ ω, Continuous (fun t => B t ω))
+    (κ u : ℝ) (hu : 0 ≤ u)
+    (γ : Ω → ℝ≥0 → ℂ) (G F : Ω → ℝ≥0 → ℂ → ℂ)
+    (hw : ∀ ω, IsCapacityTwoWitness (fun t => Real.sqrt κ * B t ω) (γ ω) (G ω) (F ω))
+    (S : Ω → ℝ≥0∞) (hS : Measurable S) :
+    Measurable (fun p : Ω × ℂ => levelStoppingCurrentGreen κ B γ G u S p.2 p.1) := by
+  let hm (t : ℝ≥0) : Measurable (B t) := hBm.comp (measurable_const.prodMk measurable_id)
+  exact Measurable.ite
+    (measurableSet_lt (hS.comp measurable_fst)
+      (actual_radiusLevel_joint_measurable hm hc κ u hu γ G F hw))
+    (actual_greenDensity_random_time_joint_measurable hBm hc κ γ G F hw
+      (fun ω => (S ω).toNNReal) (ENNReal.measurable_toNNReal.comp hS)) measurable_const
+
+theorem levelStoppingRemainderGreen_spatial_kernel
+    {Ω : Type*} [mΩ : MeasurableSpace Ω] {P : Measure Ω}
+    {B : ℝ≥0 → Ω → ℝ} (hB : IsBrownianReal B P)
+    (hBm : Measurable (Function.uncurry B))
+    (hc : ∀ ω, Continuous (fun t => B t ω)) (hB0 : ∀ ω, B 0 ω = 0)
+    {κ : ℝ} (hκ : 0 < κ) (hκ8 : κ < 8)
+    (γ : Ω → ℝ≥0 → ℂ) (G F : Ω → ℝ≥0 → ℂ → ℂ)
+    (hw : ∀ ω, IsCapacityTwoWitness (fun s => Real.sqrt κ * B s ω) (γ ω) (G ω) (F ω))
+    (u : ℝ) (hu : 0 ≤ u) (S : Ω → WithTop ℝ≥0)
+    (hS : IsStoppingTime (Filtration.natural B (fun s =>
+      (hBm.comp (measurable_const.prodMk measurable_id) : Measurable (B s)).stronglyMeasurable)) S)
+    (K : Set ℂ) (hK : MeasurableSet K) (hKH : K ⊆ upperHalfPlane)
+    (f : ℂ → ℝ≥0∞) (hf : Measurable f) (E : Set Ω)
+    (hE : MeasurableSet[hS.measurableSpace] E) :
+    (∫⁻ ω in E, (∫⁻ z in K, f z * ENNReal.ofReal
+      (levelStoppingRemainderGreen κ B γ G u S z ω) ∂volume) ∂P) =
+      ∫⁻ ω in E, (∫⁻ z in K, f z * ENNReal.ofReal
+        (levelStoppingCurrentGreen κ B γ G u S z ω) ∂volume) ∂P := by
+  let : IsProbabilityMeasure P := hB.isGaussianProcess.isProbabilityMeasure
+  let hm (t : ℝ≥0) : Measurable (B t) := hBm.comp (measurable_const.prodMk measurable_id)
+  have hmR := levelStoppingRemainderGreen_joint_measurable hm hc κ u hu γ G F hw S hS.measurable'
+  have hmC := levelStoppingCurrentGreen_joint_measurable hBm hc κ u hu γ G F hw S hS.measurable'
+  have hR := (hf.comp measurable_snd).mul hmR.ennreal_ofReal
+  have hC := (hf.comp measurable_snd).mul hmC.ennreal_ofReal
+  conv_lhs => rw [lintegral_lintegral_swap hR.aemeasurable]
+  conv_rhs => rw [lintegral_lintegral_swap hC.aemeasurable]
+  apply setLIntegral_congr_fun hK
+  intro z hz
+  dsimp only
+  have hp : Measurable (fun ω : Ω => (ω,z)) := measurable_id.prodMk measurable_const
+  have hRz := hmR.ennreal_ofReal.comp hp
+  have hCz := hmC.ennreal_ofReal.comp hp
+  simp only [Function.comp_def] at hRz hCz
+  rw [lintegral_const_mul _ hRz,lintegral_const_mul _ hCz]
+  rw [levelStoppingRemainderGreen_setLIntegral hB hBm hc hB0 hκ hκ8
+    γ G F hw z (hKH hz) u hu S hS E hE]
+
+lemma stopping_level_density_split
+    {Ω : Type*} (κ : ℝ) (B : ℝ≥0 → Ω → ℝ)
+    (γ : Ω → ℝ≥0 → ℂ) (G : Ω → ℝ≥0 → ℂ → ℂ)
+    (u : ℝ) (S : Ω → ℝ≥0∞) (ω : Ω) (z : ℂ) :
+    levelApproximationDensity κ B γ G u ∞ ω z =
+      levelApproximationDensity κ B γ G u (S ω) ω z +
+        ENNReal.ofReal (levelStoppingRemainderGreen κ B γ G u S z ω) := by
+  by_cases h : radiusLevelTime (γ ω) (G ω) z u ≤ S ω
+  · simp only [levelApproximationDensity,le_top,ite_true,ite_eq_left h,
+      levelStoppingRemainderGreen,ite_eq_right (not_lt.mpr h),ENNReal.ofReal_zero,add_zero]
+  · simp only [levelApproximationDensity,le_top,ite_true,ite_eq_right h,
+      levelStoppingRemainderGreen,ite_eq_left (lt_of_not_ge h),zero_add]
+
+end SLEExactGauge.Multipoint
+
+end
+
+end OAI

lean/OAI/Probability/SLE/Mass/LevelStoppingTests.lean

@@ -0,0 +1,146 @@
+import OAI.Probability.SLE.Mass.LevelStoppingMeasures
+import OAI.Probability.SLE.Mass.LevelCurrentTests
+import OAI.Probability.SLE.Mass.LevelConditionalMean
+
+namespace OAI
+
+/-! Signed compact-test convergence for the Green remainder at arbitrary
+stopping times, and its preservation by the chosen convex tails. -/
+
+noncomputable section
+open Set Filter MeasureTheory ProbabilityTheory Classical
+open scoped NNReal ENNReal Topology CompactlySupported
+
+namespace SLEExactGauge.Multipoint
+
+local instance : LocallyCompactSpace upperHalfPlane := isOpen_upperHalfPlane.locallyCompactSpace
+
+lemma levelStoppingCurrentGreen_le_green
+    {Ω : Type*} {B : ℝ≥0 → Ω → ℝ} {κ : ℝ}
+    {γ : Ω → ℝ≥0 → ℂ} {G F : Ω → ℝ≥0 → ℂ → ℂ}
+    (ω : Ω) (hw : IsCapacityTwoWitness
+      (fun s => Real.sqrt κ * B s ω) (γ ω) (G ω) (F ω))
+    (u : ℝ) (S : Ω → ℝ≥0∞) (z : ℂ) :
+    levelStoppingCurrentGreen κ B γ G u S z ω ≤ stoppingGreen κ B γ G S z ω := by
+  by_cases hfin : S ω < ∞
+  · unfold levelStoppingCurrentGreen stoppingGreen
+    rw [ite_eq_left hfin]
+    split_ifs
+    · exact le_rfl
+    · exact greenDensity_nonneg hw κ _ z
+  · have hnot : ¬ S ω < radiusLevelTime (γ ω) (G ω) z u :=
+      fun h => hfin (h.trans_le le_top)
+    simp only [levelStoppingCurrentGreen,stoppingGreen,ite_eq_right hfin,ite_eq_right hnot]
+    exact le_rfl
+
+lemma halfPlaneStoppingCurrentMeasure_le_green
+    {Ω : Type*} {B : ℝ≥0 → Ω → ℝ} {κ : ℝ}
+    {γ : Ω → ℝ≥0 → ℂ} {G F : Ω → ℝ≥0 → ℂ → ℂ}
+    (ω : Ω) (hw : IsCapacityTwoWitness
+      (fun s => Real.sqrt κ * B s ω) (γ ω) (G ω) (F ω))
+    (u : ℝ) (S : Ω → ℝ≥0∞) :
+    halfPlaneStoppingCurrentMeasure κ B γ G u S ω ≤ halfPlaneStoppingGreenMeasure κ B γ G S ω := by
+  apply Measure.le_iff.mpr
+  intro A hA
+  have hAI := (MeasurableEmbedding.subtype_coe isOpen_upperHalfPlane.measurableSet).measurableSet_image.mpr hA
+  simp only [halfPlaneStoppingCurrentMeasure,halfPlaneStoppingGreenMeasure,
+    comap_subtype_coe_apply isOpen_upperHalfPlane.measurableSet,withDensity_apply _ hAI]
+  exact lintegral_mono (fun z => ENNReal.ofReal_le_ofReal (levelStoppingCurrentGreen_le_green ω hw u S z))
+
+lemma halfPlaneStoppingCurrentMeasure_mean_lintegral_test
+    {Ω : Type*} [MeasurableSpace Ω] (P : Measure Ω)
+    {B : ℝ≥0 → Ω → ℝ} (hBm : Measurable (Function.uncurry B))
+    (hBc : ∀ ω, Continuous (fun t => B t ω)) (κ u : ℝ) (hu : 0 ≤ u)
+    (γ : Ω → ℝ≥0 → ℂ) (G F : Ω → ℝ≥0 → ℂ → ℂ)
+    (hw : ∀ ω, IsCapacityTwoWitness (fun t => Real.sqrt κ * B t ω) (γ ω) (G ω) (F ω))
+    (S : Ω → ℝ≥0∞) (hS : Measurable S) (f : upperHalfPlane → ℝ) (hf : Measurable f) :
+    (∫⁻ z, ENNReal.ofReal (f z) ∂P.bind (halfPlaneStoppingCurrentMeasure κ B γ G u S)) =
+      ∫⁻ ω, (∫⁻ z, ENNReal.ofReal (extendHalfPlaneTest f z) *
+        ENNReal.ofReal (levelStoppingCurrentGreen κ B γ G u S z ω) ∂volume) ∂P :=
+  lintegral_density_kernel_test P _
+    (halfPlaneStoppingCurrentMeasure_measurable hBm hBc κ u hu γ G F hw S hS) _
+    (levelStoppingCurrentGreen_joint_measurable hBm hBc κ u hu γ G F hw S hS).ennreal_ofReal
+    (fun _ => rfl) f hf
+
+lemma halfPlaneStoppingGreenMeasure_mean_lintegral_test
+    {Ω : Type*} [MeasurableSpace Ω] (P : Measure Ω)
+    {B : ℝ≥0 → Ω → ℝ} (hBm : Measurable (Function.uncurry B))
+    (hBc : ∀ ω, Continuous (fun t => B t ω)) (κ : ℝ)
+    (γ : Ω → ℝ≥0 → ℂ) (G F : Ω → ℝ≥0 → ℂ → ℂ)
+    (hw : ∀ ω, IsCapacityTwoWitness (fun t => Real.sqrt κ * B t ω) (γ ω) (G ω) (F ω))
+    (S : Ω → ℝ≥0∞) (hS : Measurable S) (f : upperHalfPlane → ℝ) (hf : Measurable f) :
+    (∫⁻ z, ENNReal.ofReal (f z) ∂P.bind (halfPlaneStoppingGreenMeasure κ B γ G S)) =
+      ∫⁻ ω, (∫⁻ z, ENNReal.ofReal (extendHalfPlaneTest f z) * ENNReal.ofReal
+        (stoppingGreen κ B γ G S z ω) ∂volume) ∂P :=
+  lintegral_density_kernel_test P _ (halfPlaneStoppingGreenMeasure_measurable hBm hBc κ γ G F hw S hS) _
+    (stoppingGreen_joint_measurable hBm hBc κ γ G F hw S hS).ennreal_ofReal
+    (fun _ => rfl) f hf
+
+lemma halfPlaneStoppingCurrentMeasure_mean_lintegral_test_tendsto
+    {Ω : Type*} [MeasurableSpace Ω] (P : Measure Ω)
+    {B : ℝ≥0 → Ω → ℝ} (hBm : Measurable (Function.uncurry B))
+    (hBc : ∀ ω, Continuous (fun t => B t ω)) (κ : ℝ)
+    (γ : Ω → ℝ≥0 → ℂ) (G F : Ω → ℝ≥0 → ℂ → ℂ)
+    (hw : ∀ ω, IsCapacityTwoWitness (fun t => Real.sqrt κ * B t ω) (γ ω) (G ω) (F ω))
+    (u : ℕ → ℝ) (hu : ∀ n, 0 ≤ u n) (hmono : Monotone u)
+    (hlim : Tendsto u atTop atTop) (S : Ω → ℝ≥0∞) (hS : Measurable S) (E : Set Ω)
+    (f : upperHalfPlane → ℝ) (hf : Measurable f) :
+    Tendsto (fun n => ∫⁻ z, ENNReal.ofReal (f z)
+      ∂(P.restrict E).bind (halfPlaneStoppingCurrentMeasure κ B γ G (u n) S)) atTop
+      (𝓝 (∫⁻ z, ENNReal.ofReal (f z) ∂(P.restrict E).bind (halfPlaneStoppingGreenMeasure κ B γ G S))) := by
+  simp_rw [halfPlaneStoppingCurrentMeasure_mean_lintegral_test _ hBm hBc κ _ (hu _) γ G F hw S hS f hf,
+    halfPlaneStoppingGreenMeasure_mean_lintegral_test _ hBm hBc κ γ G F hw S hS f hf]
+  simpa only [Measure.restrict_univ] using stoppingCurrentGreen_spatial_mean_tendsto P hBm hBc κ γ G F hw
+    u hu hmono hlim S hS univ (fun z => ENNReal.ofReal (extendHalfPlaneTest f z))
+    (extendHalfPlaneTest_measurable f hf).ennreal_ofReal E
+
+lemma halfPlaneStoppingCurrentMeasure_mean_le
+    {Ω : Type*} [MeasurableSpace Ω] {P : Measure Ω}
+    {B : ℝ≥0 → Ω → ℝ} (hB : IsBrownianReal B P)
+    (hBm : Measurable (Function.uncurry B)) (hBc : ∀ ω, Continuous (fun t => B t ω))
+    (hB0 : ∀ ω, B 0 ω = 0) {κ : ℝ} (hκ : 0 < κ) (hκ8 : κ < 8)
+    (γ : Ω → ℝ≥0 → ℂ) (G F : Ω → ℝ≥0 → ℂ → ℂ)
+    (hw : ∀ ω, IsCapacityTwoWitness (fun t => Real.sqrt κ * B t ω) (γ ω) (G ω) (F ω))
+    (u : ℝ) (hu : 0 ≤ u) (S : Ω → WithTop ℝ≥0)
+    (hS : IsStoppingTime (Filtration.natural B (fun s =>
+      (hBm.comp (measurable_const.prodMk measurable_id) : Measurable (B s)).stronglyMeasurable)) S)
+    (E : Set Ω) :
+    (P.restrict E).bind (halfPlaneStoppingCurrentMeasure κ B γ G u S) ≤ initialGreenMeasure κ := by
+  apply le_trans ?_ (halfPlaneStoppingGreenMeasure_mean_le hB hBm hBc hB0 hκ hκ8 γ G F hw S hS E)
+  apply Measure.le_iff.mpr
+  intro A hA
+  rw [Measure.bind_apply hA (halfPlaneStoppingCurrentMeasure_measurable hBm hBc κ u hu γ G F hw S hS.measurable').aemeasurable,
+    Measure.bind_apply hA (halfPlaneStoppingGreenMeasure_measurable hBm hBc κ γ G F hw S hS.measurable').aemeasurable]
+  exact lintegral_mono (fun ω => halfPlaneStoppingCurrentMeasure_le_green ω (hw ω) u S A)
+
+theorem halfPlaneStoppingCurrentMeasure_mean_test_tendsto
+    {Ω : Type*} [MeasurableSpace Ω] {P : Measure Ω}
+    {B : ℝ≥0 → Ω → ℝ} (hB : IsBrownianReal B P)
+    (hBm : Measurable (Function.uncurry B)) (hBc : ∀ ω, Continuous (fun t => B t ω))
+    (hB0 : ∀ ω, B 0 ω = 0) {κ : ℝ} (hκ : 0 < κ) (hκ8 : κ < 8)
+    (γ : Ω → ℝ≥0 → ℂ) (G F : Ω → ℝ≥0 → ℂ → ℂ)
+    (hw : ∀ ω, IsCapacityTwoWitness (fun t => Real.sqrt κ * B t ω) (γ ω) (G ω) (F ω))
+    (u : ℕ → ℝ) (hu : ∀ n, 0 ≤ u n) (hmono : Monotone u)
+    (hlim : Tendsto u atTop atTop) (S : Ω → WithTop ℝ≥0)
+    (hS : IsStoppingTime (Filtration.natural B (fun s =>
+      (hBm.comp (measurable_const.prodMk measurable_id) : Measurable (B s)).stronglyMeasurable)) S)
+    (E : Set Ω)
+    (f : C_c(upperHalfPlane,ℝ)) :
+    Tendsto (fun n => ∫ z, f z ∂(P.restrict E).bind (halfPlaneStoppingCurrentMeasure κ B γ G (u n) S))
+      atTop (𝓝 (∫ z, f z ∂(P.restrict E).bind (halfPlaneStoppingGreenMeasure κ B γ G S))) := by
+  let : IsFiniteMeasureOnCompacts (initialGreenMeasure κ) := initialGreenMeasure_finite_on_compacts κ
+  have hfi : Integrable f (initialGreenMeasure κ) := f.integrable
+  apply integral_tendsto_of_lintegral_pos_neg
+  · exact fun n => hfi.mono_measure (halfPlaneStoppingCurrentMeasure_mean_le hB hBm hBc hB0 hκ hκ8
+      γ G F hw (u n) (hu n) S hS E)
+  · exact hfi.mono_measure (halfPlaneStoppingGreenMeasure_mean_le hB hBm hBc hB0 hκ hκ8 γ G F hw S hS E)
+  · exact halfPlaneStoppingCurrentMeasure_mean_lintegral_test_tendsto P hBm hBc κ γ G F hw
+      u hu hmono hlim S hS.measurable' E f f.continuous.measurable
+  · exact halfPlaneStoppingCurrentMeasure_mean_lintegral_test_tendsto P hBm hBc κ γ G F hw
+      u hu hmono hlim S hS.measurable' E (fun z => -f z) f.continuous.measurable.neg
+
+end SLEExactGauge.Multipoint
+
+end
+
+end OAI

lean/OAI/Probability/SLE/Mass/LocalGridMass.lean

@@ -0,0 +1,118 @@
+import OAI.Probability.SLE.Gauge.CoverGrid
+
+namespace OAI
+
+/-! A translated finite grid count for arbitrary sets of bounded diameter.
+No regularity of the set being covered is required. -/
+
+noncomputable section
+open Set Filter MeasureTheory Metric
+open scoped Topology NNReal ENNReal
+
+namespace SLEExactGauge
+
+lemma localGrid_coordinate {r s x y : ℝ} (hr : 0 < r) (_hs : 0 ≤ s)
+    (hxy : |y-x| ≤ s) :
+    ⌊x/r⌋-(⌈s/r⌉+2)  ≤  ⌊y/r⌋ ∧ ⌊y/r⌋  ≤  ⌊x/r⌋+(⌈s/r⌉+2) := by
+  have hx0 := Int.floor_le (x/r)
+  have hx1 := Int.lt_floor_add_one (x/r)
+  have hy0 := Int.floor_le (y/r)
+  have hy1 := Int.lt_floor_add_one (y/r)
+  have hc := Int.le_ceil (s/r)
+  have hlo : -s/r ≤ (y-x)/r := div_le_div_of_nonneg_right (abs_le.mp hxy).1 hr.le
+  have hhi : (y-x)/r ≤ s/r := div_le_div_of_nonneg_right (abs_le.mp hxy).2 hr.le
+  rw [sub_div] at hlo hhi
+  rw [neg_div] at hlo
+  constructor
+  · have hh : ((⌊x/r⌋-(⌈s/r⌉+2):ℤ):ℝ) ≤ (⌊y/r⌋:ℝ) := by
+      push_cast
+      linarith
+    exact_mod_cast hh
+  · have hh : (⌊y/r⌋:ℝ) ≤ ((⌊x/r⌋+(⌈s/r⌉+2):ℤ):ℝ) := by
+      push_cast
+      linarith
+    exact_mod_cast hh
+
+def localGridIndex (r s : ℝ) (z : ℂ) : Finset (ℤ×ℤ) :=
+  let N : ℤ := ⌈s/r⌉+2
+  (Finset.Icc (⌊z.re/r⌋-N) (⌊z.re/r⌋+N)) ×ˢ
+    (Finset.Icc (⌊z.im/r⌋-N) (⌊z.im/r⌋+N))
+
+lemma localGrid_covers {r s : ℝ} (hr : 0 < r) (hs : 0 ≤ s) (z : ℂ) :
+    closedBall z s ⊆ ⋃ i∈localGridIndex r s z, closedBall (coverGridCenter r i) (2*r) := by
+  intro w hw
+  have hn : ‖w-z‖ ≤ s := by simpa only [mem_closedBall,dist_eq_norm] using hw
+  have hx := localGrid_coordinate hr hs ((Complex.abs_re_le_norm (w-z)).trans hn)
+  have hy := localGrid_coordinate hr hs ((Complex.abs_im_le_norm (w-z)).trans hn)
+  refine mem_iUnion₂.mpr ⟨(⌊w.re/r⌋,⌊w.im/r⌋),?_,coverGrid_floor_distance hr w⟩
+  simpa only [localGridIndex,Finset.mem_product,Finset.mem_Icc,Complex.sub_re,Complex.sub_im]
+    using And.intro hx hy
+
+lemma localGrid_card_bound {r s : ℝ} (hr : 0 < r) (hs : 0 ≤ s) (z : ℂ) :
+    ((localGridIndex r s z).card:ℝ)  ≤  81*max 1 ((s/r)^2) := by
+  let N : ℤ := ⌈s/r⌉+2
+  have hN : 0 ≤ N := by
+    have h := Int.ceil_nonneg (div_nonneg hs hr.le)
+    dsimp [N]
+    omega
+  have hside : 2*(N:ℝ)+1  ≤  2*(s/r)+7 := by
+    have hc := Int.ceil_lt_add_one (s/r)
+    dsimp [N]
+    push_cast
+    linarith
+  have hside0 : 0 ≤ 2*(N:ℝ)+1 := by exact_mod_cast (show (0:ℤ) ≤ 2*N+1 by omega)
+  have hcard : ((localGridIndex r s z).card:ℝ)=(2*(N:ℝ)+1)^2 := by
+    have hx := Int.card_Icc_of_le (a:=⌊z.re/r⌋-N) (b:=⌊z.re/r⌋+N) (by omega)
+    have hy := Int.card_Icc_of_le (a:=⌊z.im/r⌋-N) (b:=⌊z.im/r⌋+N) (by omega)
+    have hx' : ((Finset.Icc (⌊z.re/r⌋-N) (⌊z.re/r⌋+N)).card:ℝ)=2*(N:ℝ)+1 := by
+      have h : ((Finset.Icc (⌊z.re/r⌋-N) (⌊z.re/r⌋+N)).card:ℝ)=
+          ((⌊z.re/r⌋:ℝ)+(N:ℝ))+1-((⌊z.re/r⌋:ℝ)-(N:ℝ)) := by exact_mod_cast hx
+      linarith
+    have hy' : ((Finset.Icc (⌊z.im/r⌋-N) (⌊z.im/r⌋+N)).card:ℝ)=2*(N:ℝ)+1 := by
+      have h : ((Finset.Icc (⌊z.im/r⌋-N) (⌊z.im/r⌋+N)).card:ℝ)=
+          ((⌊z.im/r⌋:ℝ)+(N:ℝ))+1-((⌊z.im/r⌋:ℝ)-(N:ℝ)) := by exact_mod_cast hy
+      linarith
+    change (((Finset.Icc _ _) ×ˢ (Finset.Icc _ _)).card:ℝ)=_
+    rw [Finset.card_product,Nat.cast_mul,hx',hy',pow_two]
+  rw [hcard]
+  have hratio : 0 ≤ s/r := div_nonneg hs hr.le
+  by_cases hsmall : s/r ≤ 1
+  · have h : 2*(N:ℝ)+1 ≤ 9 := by linarith
+    have hp := pow_le_pow_left₀ hside0 h 2
+    norm_num at hp
+    exact hp.trans (by nlinarith [le_max_left (1:ℝ) ((s/r)^2)])
+  · have hlarge : 1 ≤ s/r := (lt_of_not_ge hsmall).le
+    have h : 2*(N:ℝ)+1 ≤ 9*(s/r) := by linarith
+    have hp := pow_le_pow_left₀ hside0 h 2
+    calc
+      _  ≤  (9*(s/r))^2 := hp
+      _ = 81*(s/r)^2 := by ring
+      _  ≤  _ := mul_le_mul_of_nonneg_left (le_max_right _ _) (by norm_num)
+
+lemma localGrid_mass_bound
+    (μ : Measure ℂ) {r s H : ℝ} (hr : 0 < r) (hs : 0 ≤ s) (hH : 0 ≤ H)
+    (hcell : ∀ i : ℤ×ℤ, μ (closedBall (coverGridCenter r i) (2*r))  ≤  ENNReal.ofReal H)
+    (A : Set ℂ) (hA : ∀ x∈A, ∀ y∈A, dist x y ≤ s) :
+    μ A  ≤  ENNReal.ofReal (81*H*max 1 ((s/r)^2)) := by
+  classical
+  rcases A.eq_empty_or_nonempty with rfl | ⟨z,hz⟩
+  · simp
+  have hcover : A ⊆ closedBall z s := by
+    intro w hw
+    exact hA w hw z hz
+  calc
+    μ A  ≤  μ (⋃ i∈localGridIndex r s z, closedBall (coverGridCenter r i) (2*r)) :=
+      measure_mono (hcover.trans (localGrid_covers hr hs z))
+    _  ≤  ∑ i∈localGridIndex r s z, μ (closedBall (coverGridCenter r i) (2*r)) := measure_biUnion_finset_le _ _
+    _  ≤  ∑ _i∈localGridIndex r s z, ENNReal.ofReal H := Finset.sum_le_sum (fun i _ => hcell i)
+    _ = ENNReal.ofReal (((localGridIndex r s z).card:ℝ)*H) := by
+      simp only [Finset.sum_const,nsmul_eq_mul,ENNReal.ofReal_mul (Nat.cast_nonneg _),ENNReal.ofReal_natCast]
+    _  ≤  _ := ENNReal.ofReal_le_ofReal (by
+      have h := mul_le_mul_of_nonneg_right (localGrid_card_bound hr hs z) hH
+      nlinarith)
+
+end SLEExactGauge
+
+end
+
+end OAI

lean/OAI/Probability/SLE/Mass/LocallyFiniteMeasureSubtract.lean

@@ -0,0 +1,49 @@
+import Mathlib.MeasureTheory.Measure.Sub
+import Mathlib.MeasureTheory.Measure.Typeclasses.SFinite
+
+namespace OAI
+
+/-! Subtraction for locally finite canonical mass. Cancellation is checked
+on finite restrictions, so no finite total-mass assumption is needed. -/
+
+noncomputable section
+open Set MeasureTheory
+open scoped ENNReal
+
+namespace SLEExactGauge
+
+theorem sigmaFinite_sub_add_cancel_of_le
+    {X : Type*} [MeasurableSpace X] {μ ν : Measure X} [SigmaFinite ν]
+    (hle : ν ≤ μ) : μ - ν + ν = μ := by
+  apply Measure.ext_of_iUnion_eq_univ (iUnion_spanningSets ν)
+  intro n
+  rw [Measure.restrict_add,Measure.restrict_sub_eq_restrict_sub_restrict
+    (measurableSet_spanningSets ν n)]
+  have : Fact (ν (spanningSets ν n) < ⊤) := ⟨measure_spanningSets_lt_top ν n⟩
+  exact Measure.sub_add_cancel_of_le (Measure.restrict_mono le_rfl hle)
+
+theorem sub_apply_of_finite_restriction
+    {X : Type*} [MeasurableSpace X] {μ ν : Measure X} (hle : ν ≤ μ)
+    {A : Set X} (hA : MeasurableSet A) (hνA : ν A ≠ ⊤) :
+    (μ - ν) A = μ A - ν A := by
+  have : Fact (ν A < ⊤) := ⟨hνA.lt_top⟩
+  calc
+    (μ - ν) A = ((μ - ν).restrict A) univ := by simp
+    _ = (μ.restrict A - ν.restrict A) univ := by
+      rw [Measure.restrict_sub_eq_restrict_sub_restrict hA]
+    _ = μ.restrict A univ - ν.restrict A univ :=
+      Measure.sub_apply MeasurableSet.univ (Measure.restrict_mono le_rfl hle)
+    _ = μ A - ν A := by simp
+
+theorem sub_le_sub_right_of_le
+    {X : Type*} [MeasurableSpace X] {μ ν ξ : Measure X} [SigmaFinite ξ]
+    (hξ : ξ ≤ ν) (hμν : μ ≤ ν) : μ - ξ ≤ ν - ξ := by
+  apply Measure.sub_le_of_le_add
+  rw [sigmaFinite_sub_add_cancel_of_le hξ]
+  exact hμν
+
+end SLEExactGauge
+
+end
+
+end OAI

lean/OAI/Probability/SLE/Mass/MarkedTubeHarmonicMeasure.lean

@@ -0,0 +1,103 @@
+import OAI.Probability.SLE.Geometry.MarkedWindowRoutes
+import OAI.Probability.SLE.Geometry.FiniteExitArcAt
+
+namespace OAI
+
+/-! Convert the two explicit marked-point Brownian tubes into lower
+bounds for both conformal exit arcs. Every geometric condition concerns
+actual paths in the surviving domain; the only probabilistic input here
+is the generic published conformal Brownian exit law. -/
+
+noncomputable section
+open Set Filter MeasureTheory Metric
+open scoped Topology NNReal ENNReal
+
+namespace SLEExactGauge.Serpentine
+open RibbonCoordinates CrosscutSides Target
+
+lemma marked_window_tubes_opposite_sides
+    (hopen : PublishedPlanarDiskOpenness) (w : ℂ) {a : ℝ} (ha : 0 < a)
+    (f : ℂ → ℂ) (j : ℂ → ℝ)
+    (hf : ContinuousOn f (ball (0 : ℂ) (a / 12)))
+    (hfi : InjOn f (ball (0 : ℂ) (a / 12)))
+    (hzero : ∀ z ∈ ball (0 : ℂ) (a / 12), (f z).re = 0 ↔ z.im = 0)
+    (hrel : ∀ z ∈ ball (0 : ℂ) (a / 12), j (markedCornerChart w z) = (f z).re) :
+    ∃ right : Bool,
+      (∀ y : ℂ, dist y (markedWindowRoute right w a (1 / 64)) < a / 10000 → 0 < j y) ∧
+      (∀ y : ℂ, dist y (markedWindowRoute (!right) w a (1 / 64)) < a / 10000 → j y < 0) := by
+  rcases marked_physical_tubes_opposite_sides hopen w ha f j hf hfi hzero hrel with h | h
+  · refine ⟨false, ?_⟩
+    simpa only [markedWindowRoute_small, Bool.false_eq_true, ↓reduceIte, Bool.not_false] using h
+  · refine ⟨true, ?_⟩
+    simpa only [markedWindowRoute_small, ↓reduceIte, Bool.not_true, Bool.false_eq_true] using And.symm h
+
+theorem marked_tubes_harmonic_bounds
+    (hopen : PublishedPlanarDiskOpenness) (hexitLaw : PublishedHalfPlaneConformalExitLaw)
+    (W : WienerLaw) (hW : IsWiener W)
+    (D : Set ℂ) (hD : IsOpen D) (hDH : D ⊆ upperHalfPlane)
+    (g F : ℂ → ℂ) (hg : DifferentiableOn ℂ g D)
+    (hF : DifferentiableOn ℂ F upperHalfPlane)
+    (hgH : MapsTo g D upperHalfPlane) (hFD : MapsTo F upperHalfPlane D)
+    (hFg : ∀ z ∈ D, F (g z) = z) (hgF : ∀ z ∈ upperHalfPlane, g (F z) = z)
+    (w : ℂ) (hwD : w ∈ D) {a : ℝ} (ha : 0 < a)
+    (h : ℂ ≃ₜ ℂ) (hreal : ∀ x : ℝ, h (x : ℂ) = (x : ℂ))
+    (hloc : ContinuousOn (fun z => h (g (markedCornerChart w z))) (ball (0 : ℂ) (a / 12)))
+    (hloci : InjOn (fun z => h (g (markedCornerChart w z))) (ball (0 : ℂ) (a / 12)))
+    (hlocz : ∀ z ∈ ball (0 : ℂ) (a / 12),
+      (h (g (markedCornerChart w z))).re = 0 ↔ z.im = 0)
+    (q : ℝ≥0∞)
+    (hprob : ∀ right : Bool, q ≤ (W.prod W) {b | ∀ t ∈ Icc (0 : ℝ) 3,
+      dist (physicalUnitBrownianPath w b t) (markedWindowRoute right w a t) < a / 10000})
+    (hgeom : ∀ (right : Bool) (b : Driver × Driver),
+      (∀ t ∈ Icc (0 : ℝ) 3,
+        dist (physicalUnitBrownianPath w b t) (markedWindowRoute right w a t) < a / 10000) →
+      ∃ τ : ℝ, UnitWindowFirstExit D (physicalUnitBrownianPath w b) τ ∧ (1 / 64 : ℝ) < τ ∧
+        ∀ t ∈ Ico (1 / 64 : ℝ) τ, (h (g (physicalUnitBrownianPath w b t))).re ≠ 0) :
+    q ≤ ENNReal.ofReal ((g w).arg / Real.pi) ∧
+      q ≤ ENNReal.ofReal (1 - (g w).arg / Real.pi) := by
+  let E := fun right : Bool => {b | ∀ t ∈ Icc (0 : ℝ) 3,
+    dist (physicalUnitBrownianPath w b t) (markedWindowRoute right w a t) < a / 10000}
+  obtain ⟨hae, hnegBound, hposBound⟩ := hexitLaw W hW D g F hD hDH
+    hg hF hgH hFD hFg hgF w hwD
+  obtain ⟨right, hpos, hneg⟩ := marked_window_tubes_opposite_sides hopen w ha
+    (fun z => h (g (markedCornerChart w z))) (fun z => (h (g z)).re)
+    hloc hloci hlocz (fun _ _ => rfl)
+  have hposProb : q ≤ (W.prod W) (unitWindowExitArc D g w 1) := by
+    refine (hprob right).trans (finite_exit_event_measure_le_arc_at (W.prod W) D g w h hreal
+      hg.continuousOn (E right) (Or.inr rfl) (by norm_num : (0 : ℝ) ≤ 1 / 64) hae
+      (hgeom right) ?_)
+    intro b hb
+    simpa only [one_mul] using hpos _ (hb _ (by norm_num))
+  have hnegProb : q ≤ (W.prod W) (unitWindowExitArc D g w (-1)) := by
+    refine (hprob (!right)).trans (finite_exit_event_measure_le_arc_at (W.prod W) D g w h hreal
+      hg.continuousOn (E (!right)) (Or.inl rfl) (by norm_num : (0 : ℝ) ≤ 1 / 64) hae
+      (hgeom (!right)) ?_)
+    intro b hb
+    have hh := hneg _ (hb _ (by norm_num))
+    nlinarith
+  exact ⟨hnegProb.trans hnegBound, hposProb.trans hposBound⟩
+
+/-- Early survival, a final exit and avoidance of the actual complete
+guide imply the geometric hypotheses in the harmonic-measure theorem. -/
+theorem marked_tube_first_exit_geometry
+    (D : Set ℂ) (hD : IsOpen D) (g : ℂ → ℂ) (h : ℂ ≃ₜ ℂ)
+    (α : ℝ≥0 → ℂ)
+    (hzero : ∀ z ∈ D, (h (g z)).re = 0 → ∃ u : ℝ≥0, 0 < u ∧ α u = z)
+    (ζ : ℝ → ℂ) (hc : Continuous ζ)
+    (hearly : MapsTo ζ (Icc (0 : ℝ) (1 / 64)) D)
+    (hlast : ζ 3 ∉ D)
+    (havoid : ∀ t ∈ Icc (1 / 64 : ℝ) 3, ∀ u : ℝ≥0, 0 < u → ζ t ≠ α u) :
+    ∃ τ : ℝ, UnitWindowFirstExit D ζ τ ∧ (1 / 64 : ℝ) < τ ∧
+      ∀ t ∈ Ico (1 / 64 : ℝ) τ, (h (g (ζ t))).re ≠ 0 := by
+  obtain ⟨τ, hτ, hout, hin⟩ := exists_first_domain_exit (L := 3) D hD ζ hc.continuousOn hearly
+    ⟨3, by norm_num, hlast⟩
+  refine ⟨τ, ⟨⟨by linarith [hτ.1], hτ.2⟩, hout, hin⟩, hτ.1, ?_⟩
+  intro t ht he
+  obtain ⟨u, hu, hue⟩ := hzero (ζ t) (hin ⟨by linarith [ht.1], ht.2⟩) he
+  exact havoid t ⟨ht.1, ht.2.le.trans hτ.2⟩ u hu hue.symm
+
+end SLEExactGauge.Serpentine
+
+end
+
+end OAI

lean/OAI/Probability/SLE/Mass/MassCompensatorEndpoint.lean

@@ -0,0 +1,117 @@
+import OAI.Probability.SLE.Mass.MassCompensatorMesh
+
+namespace OAI
+
+/-! The last full dyadic cell before a finite or infinite time. -/
+
+noncomputable section
+open Set Filter MeasureTheory
+open scoped Topology NNReal ENNReal
+
+namespace SLEExactGauge
+
+lemma compensatorMeshTime_eq_div (n i : ℕ) :
+    compensatorMeshTime n i = (i:ℝ≥0)/(2:ℝ≥0)^n := by
+  simp only [compensatorMeshTime,zpow_neg,zpow_natCast,div_eq_mul_inv]
+
+@[simp] lemma compensatorMeshTime_end (n : ℕ) :
+    compensatorMeshTime n (n*2^n) = n := by
+  rw [compensatorMeshTime_eq_div]
+  push_cast
+  exact mul_div_cancel_right₀ _ (by positivity)
+
+def compensatorFiniteIndex (n : ℕ) (t : ℝ≥0) : ℕ :=
+  min (n*2^n) ⌊t*(2:ℝ≥0)^n⌋₊
+
+lemma compensatorFiniteIndex_le (n : ℕ) (t : ℝ≥0) :
+    compensatorFiniteIndex n t ≤ n*2^n := min_le_left _ _
+
+lemma compensator_cell_before_iff (n i : ℕ) (t : ℝ≥0) :
+    compensatorMeshTime n (i+1) ≤ t ↔ i < ⌊t*(2:ℝ≥0)^n⌋₊ := by
+  rw [compensatorMeshTime_eq_div,div_le_iff₀ (by positivity),
+    ← Nat.le_floor_iff (show 0 ≤ t*(2:ℝ≥0)^n from zero_le)]
+  exact Nat.succ_le_iff
+
+lemma compensator_before_sum (n : ℕ) (t : ℝ≥0) (q : ℕ → ℝ) :
+    (∑ i ∈ Finset.range (n*2^n),
+      if compensatorMeshTime n (i+1) ≤ t then q i else 0) =
+    ∑ i ∈ Finset.range (compensatorFiniteIndex n t), q i := by
+  simp only [compensator_cell_before_iff]
+  rw [← Finset.sum_filter]
+  congr 1
+  ext i
+  simp only [Finset.mem_filter,Finset.mem_range,compensatorFiniteIndex,lt_min_iff]
+
+lemma compensatorFiniteIndex_eq_floor {n : ℕ} {t : ℝ≥0} (ht : t ≤ n) :
+    compensatorFiniteIndex n t = ⌊t*(2:ℝ≥0)^n⌋₊ := by
+  apply min_eq_right
+  apply Nat.floor_le_of_le
+  push_cast
+  exact mul_le_mul_of_nonneg_right ht (by positivity)
+
+lemma compensatorEndpoint_le (n : ℕ) (t : ℝ≥0) :
+    compensatorMeshTime n (compensatorFiniteIndex n t) ≤ t := by
+  rw [compensatorMeshTime_eq_div,div_le_iff₀ (by positivity)]
+  exact (Nat.cast_le.mpr (min_le_right _ _)).trans (Nat.floor_le (show 0 ≤ t*(2:ℝ≥0)^n from zero_le))
+
+lemma compensatorEndpoint_lower {n : ℕ} {t : ℝ≥0} (ht : t ≤ n) :
+    t < compensatorMeshTime n (compensatorFiniteIndex n t)+(2:ℝ≥0)^(-(n:ℤ)) := by
+  rw [compensatorFiniteIndex_eq_floor ht,compensatorMeshTime_eq_div,
+    zpow_neg,zpow_natCast,← one_div,← add_div,lt_div_iff₀ (by positivity)]
+  exact Nat.lt_floor_add_one _
+
+/-- A finite endpoint is approached from below even though the grid
+horizon grows. -/
+theorem compensatorEndpoint_tendsto (t : ℝ≥0) :
+    Tendsto (fun n => compensatorMeshTime n (compensatorFiniteIndex n t)) atTop (𝓝 t) := by
+  apply NNReal.tendsto_coe.mp
+  apply tendsto_of_tendsto_of_tendsto_of_le_of_le'
+    (show Tendsto (fun n : ℕ => (t:ℝ)-(2:ℝ)^(-(n:ℤ))) atTop (𝓝 (t:ℝ)) from
+      by simpa only [sub_zero,zpow_neg,zpow_natCast,inv_pow] using
+        tendsto_const_nhds.sub (tendsto_pow_atTop_nhds_zero_of_lt_one
+          (show 0 ≤ (2:ℝ)⁻¹ by positivity) (show (2:ℝ)⁻¹<1 by norm_num)))
+    tendsto_const_nhds
+  · have hn : ∀ᶠ n : ℕ in atTop, t ≤ (n:ℝ≥0) :=
+      (tendsto_natCast_atTop_atTop (R := ℝ≥0)).eventually (eventually_ge_atTop t)
+    filter_upwards [hn] with n hn
+    have h := compensatorEndpoint_lower hn
+    have hc : (t:ℝ) < (compensatorMeshTime n (compensatorFiniteIndex n t):ℝ)+
+        (2:ℝ)^(-(n:ℤ)) := by exact_mod_cast h
+    linarith
+  · exact Eventually.of_forall (fun n => by exact_mod_cast compensatorEndpoint_le n t)
+
+def compensatorStopIndex (n : ℕ) (T : ℝ≥0∞) : ℕ :=
+  if T=∞ then n*2^n else compensatorFiniteIndex n T.toNNReal
+
+lemma compensatorStopIndex_measurable {Ω : Type*} [MeasurableSpace Ω]
+    (T : Ω → ℝ≥0∞) (hT : Measurable T) (n : ℕ) :
+    Measurable (fun ω => compensatorStopIndex n (T ω)) := by
+  apply Measurable.ite (measurableSet_eq_fun hT measurable_const) measurable_const
+  exact measurable_const.min ((hT.ennreal_toNNReal.mul_const ((2:ℝ≥0)^n)).nat_floor)
+
+lemma compensatorStopIndex_le (n : ℕ) (T : ℝ≥0∞) :
+    compensatorStopIndex n T ≤ n*2^n := by
+  unfold compensatorStopIndex
+  split_ifs
+  · exact le_rfl
+  · exact compensatorFiniteIndex_le _ _
+
+def massAtExtendedTime (A : ℝ≥0 → ℝ) (L : ℝ) (T : ℝ≥0∞) : ℝ :=
+  if T=∞ then L else A T.toNNReal
+
+theorem massAt_compensatorEndpoint_tendsto
+    (A : ℝ≥0 → ℝ) (L : ℝ) (hA : Continuous A)
+    (hL : Tendsto A atTop (𝓝 L)) (T : ℝ≥0∞) :
+    Tendsto (fun n => A (compensatorMeshTime n (compensatorStopIndex n T)))
+      atTop (𝓝 (massAtExtendedTime A L T)) := by
+  by_cases hT : T=∞
+  · simpa only [compensatorStopIndex,massAtExtendedTime,hT,ite_true,
+      compensatorMeshTime_end,Function.comp_def] using hL.comp (tendsto_natCast_atTop_atTop (R := ℝ≥0))
+  · simpa only [compensatorStopIndex,massAtExtendedTime,hT,ite_false,Function.comp_def] using
+      hA.continuousAt.tendsto.comp (compensatorEndpoint_tendsto T.toNNReal)
+
+end SLEExactGauge
+
+end
+
+end OAI

lean/OAI/Probability/SLE/Mass/MassCompensatorMesh.lean

@@ -0,0 +1,146 @@
+import OAI.Probability.SLE.Mass.MassUniquenessMesh
+import OAI.Probability.SLE.MomentGauge
+import Mathlib.Topology.Order.Compact
+
+namespace OAI
+
+/-! The deterministic quadratic-error estimate for the prescribed dyadic
+potential compensator. A finite terminal limit controls the growing horizon. -/
+
+noncomputable section
+open Set Filter MeasureTheory
+open scoped Topology NNReal
+
+namespace SLEExactGauge
+
+/-- A continuous mass path with a finite terminal limit is uniformly
+continuous even though the compensator mesh horizon grows to infinity. -/
+lemma mass_path_uniformContinuous (A : ℝ≥0 → ℝ) (L : ℝ)
+    (hc : Continuous A) (hl : Tendsto A atTop (𝓝 L)) : UniformContinuous A := by
+  apply hc.uniformContinuous_of_tendsto_cocompact
+  simpa only [cocompact_eq_atTop] using hl
+
+def compensatorMeshTime (n i : ℕ) : ℝ≥0 :=
+  (i : ℝ≥0) * (2 : ℝ≥0)^(-(n:ℤ))
+
+@[simp] lemma compensatorMeshTime_zero (n : ℕ) : compensatorMeshTime n 0=0 := by
+  simp [compensatorMeshTime]
+
+lemma compensatorMeshTime_mono (n : ℕ) : Monotone (compensatorMeshTime n) := by
+  intro i j hij
+  exact mul_le_mul_of_nonneg_right (by exact_mod_cast hij) (by positivity)
+
+lemma compensatorMeshTime_dist (n i : ℕ) :
+    dist (compensatorMeshTime n (i+1)) (compensatorMeshTime n i) = (2:ℝ)^(-(n:ℤ)) := by
+  rw [NNReal.dist_eq]
+  simp only [compensatorMeshTime,NNReal.coe_mul,NNReal.coe_zpow,NNReal.coe_ofNat,
+    NNReal.coe_natCast,NNReal.coe_add,NNReal.coe_one,Nat.cast_add,Nat.cast_one]
+  rw [show ((i:ℝ)+1)*(2:ℝ)^(-(n:ℤ))-(i:ℝ)*(2:ℝ)^(-(n:ℤ)) =
+    (2:ℝ)^(-(n:ℤ)) by ring, abs_of_pos (by positivity)]
+
+lemma compensatorMeshTime_small_increments (A : ℝ≥0 → ℝ) (L : ℝ)
+    (hc : Continuous A) (hl : Tendsto A atTop (𝓝 L)) :
+    ∀ ε : ℝ, 0 < ε → ∀ᶠ n : ℕ in atTop, ∀ i : ℕ,
+      |A (compensatorMeshTime n (i+1))-A (compensatorMeshTime n i)| ≤ ε := by
+  intro ε hε
+  obtain ⟨δ,hδ,hAδ⟩ := Metric.uniformContinuous_iff.mp
+    (mass_path_uniformContinuous A L hc hl) ε hε
+  have hmesh : Tendsto (fun n : ℕ => (2:ℝ)^(-(n:ℤ))) atTop (𝓝 0) := by
+    simpa only [zpow_neg, zpow_natCast, inv_pow] using
+      (tendsto_pow_atTop_nhds_zero_of_lt_one (show 0 ≤ (2:ℝ)⁻¹ by positivity)
+        (show (2:ℝ)⁻¹ < 1 by norm_num))
+  filter_upwards [hmesh.eventually (gt_mem_nhds hδ)] with n hn i
+  have h := hAδ (a := compensatorMeshTime n (i+1)) (b := compensatorMeshTime n i)
+    (by simpa only [compensatorMeshTime_dist] using hn)
+  exact (by simpa only [Real.dist_eq] using h.le)
+
+def compensatorQuadraticError (A : ℝ≥0 → ℝ) (n : ℕ) : ℝ :=
+  ∑ i ∈ Finset.range (n*2^n),
+    (A (compensatorMeshTime n (i+1))-A (compensatorMeshTime n i))^2
+
+lemma compensatorQuadraticError_nonneg (A : ℝ≥0 → ℝ) (n : ℕ) :
+    0 ≤ compensatorQuadraticError A n :=
+  Finset.sum_nonneg (fun _ _ => sq_nonneg _)
+
+lemma compensatorQuadraticError_le (A : ℝ≥0 → ℝ) (L : ℝ)
+    (hm : Monotone A) (h0 : A 0=0) (hb : ∀ t, A t ≤ L)
+    (n : ℕ) {ε : ℝ} (hε : 0 ≤ ε)
+    (hsmall : ∀ i : ℕ, A (compensatorMeshTime n (i+1))-A (compensatorMeshTime n i) ≤ ε) :
+    compensatorQuadraticError A n ≤ ε*L := by
+  have hsum : (∑ i ∈ Finset.range (n*2^n),
+      (A (compensatorMeshTime n (i+1))-A (compensatorMeshTime n i))) ≤ L := by
+    rw [Finset.sum_range_sub (fun i => A (compensatorMeshTime n i)) (n*2^n),
+      compensatorMeshTime_zero,h0,sub_zero]
+    exact hb _
+  calc
+    compensatorQuadraticError A n ≤ ∑ i ∈ Finset.range (n*2^n),
+        ε*(A (compensatorMeshTime n (i+1))-A (compensatorMeshTime n i)) := by
+      apply Finset.sum_le_sum
+      intro i _
+      have hnonneg := sub_nonneg.mpr (hm (compensatorMeshTime_mono n (Nat.le_succ i)))
+      nlinarith [hsmall i]
+    _ = ε*∑ i ∈ Finset.range (n*2^n),
+        (A (compensatorMeshTime n (i+1))-A (compensatorMeshTime n i)) :=
+      (Finset.mul_sum _ _ _).symm
+    _ ≤ ε*L := mul_le_mul_of_nonneg_left hsum hε
+
+lemma compensatorQuadraticError_le_terminal_sq (A : ℝ≥0 → ℝ) (L : ℝ)
+    (hm : Monotone A) (h0 : A 0=0) (hb : ∀ t, A t ≤ L) (n : ℕ) :
+    compensatorQuadraticError A n ≤ L^2 := by
+  have hL : 0 ≤ L := by simpa only [h0] using hb 0
+  simpa only [pow_two] using compensatorQuadraticError_le A L hm h0 hb n hL (fun i => by
+    have hAi : 0 ≤ A (compensatorMeshTime n i) := by
+      rw [← h0]
+      exact hm (show 0 ≤ _ from zero_le)
+    linarith [hb (compensatorMeshTime n (i+1))])
+
+/-- The accumulated squared mass increments vanish for the exact growing
+horizon and dyadic mesh used by the paper's potential formula. -/
+theorem compensatorQuadraticError_tendsto_zero (A : ℝ≥0 → ℝ) (L : ℝ)
+    (hm : Monotone A) (h0 : A 0=0) (hc : Continuous A)
+    (hl : Tendsto A atTop (𝓝 L)) (hb : ∀ t, A t ≤ L) :
+    Tendsto (compensatorQuadraticError A) atTop (𝓝 0) := by
+  have hL : 0 ≤ L := by simpa only [h0] using hb 0
+  apply tendsto_order.mpr
+  constructor
+  · intro a ha
+    exact Eventually.of_forall (fun n => ha.trans_le (compensatorQuadraticError_nonneg A n))
+  · intro b hb0
+    have hd : 0 < b/(L+1) := div_pos hb0 (by linarith)
+    filter_upwards [compensatorMeshTime_small_increments A L hc hl _ hd] with n hn
+    have hbound := compensatorQuadraticError_le A L hm h0 hb n hd.le
+      (fun i => (le_abs_self _).trans (hn i))
+    have he : b/(L+1)*(L+1)=b := div_mul_cancel₀ b (by linarith)
+    nlinarith
+
+/-- Dominated convergence for the exact quadratic mesh error; the bound
+requires only the second terminal moment, not a uniform time horizon. -/
+theorem compensatorQuadraticError_mean_tendsto_zero
+    {Ω : Type*} [MeasurableSpace Ω] (P : Measure Ω)
+    (A : ℝ≥0 → Ω → ℝ) (L : Ω → ℝ)
+    (hA : ∀ t, Measurable (A t)) (hL : Integrable (fun ω => L ω^2) P)
+    (hp : ∀ᵐ ω ∂P, Monotone (fun t => A t ω) ∧ A 0 ω=0 ∧
+      Continuous (fun t => A t ω) ∧ Tendsto (fun t => A t ω) atTop (𝓝 (L ω)) ∧
+      ∀ t, A t ω ≤ L ω) :
+    Tendsto (fun n => ∫ ω, compensatorQuadraticError (fun t => A t ω) n ∂P)
+      atTop (𝓝 0) := by
+  have hm (n : ℕ) : Measurable (fun ω => compensatorQuadraticError (fun t => A t ω) n) := by
+    apply Finset.measurable_sum
+    intro i _
+    exact ((hA _).sub (hA _)).pow_const 2
+  have hb (n : ℕ) : ∀ᵐ ω ∂P, ‖compensatorQuadraticError (fun t => A t ω) n‖ ≤ L ω^2 := by
+    filter_upwards [hp] with ω hω
+    rw [Real.norm_of_nonneg (compensatorQuadraticError_nonneg _ _)]
+    exact compensatorQuadraticError_le_terminal_sq _ _ hω.1 hω.2.1 hω.2.2.2.2 n
+  have hl : ∀ᵐ ω ∂P, Tendsto (fun n => compensatorQuadraticError (fun t => A t ω) n)
+      atTop (𝓝 0) := by
+    filter_upwards [hp] with ω hω
+    exact compensatorQuadraticError_tendsto_zero _ _ hω.1 hω.2.1 hω.2.2.1 hω.2.2.2.1 hω.2.2.2.2
+  simpa only [integral_zero] using tendsto_integral_of_dominated_convergence
+    (fun ω => L ω^2) (fun n => (hm n).aestronglyMeasurable) hL hb hl
+
+end SLEExactGauge
+
+end
+
+end OAI

lean/OAI/Probability/SLE/Mass/MassCompensatorRecovery.lean

@@ -0,0 +1,144 @@
+import OAI.Probability.SLE.Mass.MassCompensatorEndpoint
+import OAI.Probability.SLE.Mass.MassCompensatorSelection
+
+namespace OAI
+
+/-! Recovery of a continuous finite mass path from its discrete
+predictable increments, with the paper's growing dyadic horizon. -/
+
+noncomputable section
+open Set Filter MeasureTheory ProbabilityTheory
+open scoped Topology NNReal ENNReal
+
+namespace SLEExactGauge
+
+variable {Ω : Type*} [mΩ : MeasurableSpace Ω] (P : Measure Ω) [IsProbabilityMeasure P]
+
+def meshMassIncrement (A : ℝ≥0 → Ω → ℝ) (n i : ℕ) (ω : Ω) : ℝ :=
+  A (compensatorMeshTime n (i+1)) ω-A (compensatorMeshTime n i) ω
+
+def meshMassCompensator (ℱ : ℕ → Filtration ℕ mΩ) (A : ℝ≥0 → Ω → ℝ)
+    (n j : ℕ) (ω : Ω) : ℝ :=
+  ∑ i ∈ Finset.range j, condExp (ℱ n i) P (meshMassIncrement A n i) ω
+
+omit [IsProbabilityMeasure P] in
+lemma meshMassIncrement_memLp
+    (A : ℝ≥0 → Ω → ℝ) (L : Ω → ℝ) (hL : MemLp L 2 P)
+    (hA : ∀ t, Measurable (A t))
+    (hp : ∀ᵐ ω ∂P, Monotone (fun t => A t ω) ∧ A 0 ω=0 ∧ ∀ t, A t ω ≤ L ω)
+    (n i : ℕ) : MemLp (meshMassIncrement A n i) 2 P := by
+  apply hL.mono' (((hA _).sub (hA _)).aestronglyMeasurable)
+  filter_upwards [hp] with ω hω
+  have hn : 0 ≤ meshMassIncrement A n i ω :=
+    sub_nonneg.mpr (hω.1 (compensatorMeshTime_mono n (Nat.le_succ i)))
+  have hz : 0 ≤ A (compensatorMeshTime n i) ω := by
+    rw [← hω.2.1]
+    exact hω.1 (show 0 ≤ _ from zero_le)
+  simp only [Pi.sub_apply]
+  change 0 ≤ A (compensatorMeshTime n (i+1)) ω-A (compensatorMeshTime n i) ω at hn
+  rw [Real.norm_of_nonneg hn]
+  linarith [hω.2.2 (compensatorMeshTime n (i+1))]
+
+omit [IsProbabilityMeasure P] in
+lemma meshMassCompensator_decomposition
+    (ℱ : ℕ → Filtration ℕ mΩ) (A : ℝ≥0 → Ω → ℝ) (n j : ℕ) (ω : Ω) :
+    meshMassCompensator P ℱ A n j ω =
+      A (compensatorMeshTime n j) ω-A 0 ω-
+        centeredMassPartialSum P (ℱ n) (meshMassIncrement A n) j ω := by
+  unfold centeredMassPartialSum meshMassCompensator
+  rw [Finset.sum_sub_distrib]
+  have he : (∑ i ∈ Finset.range j, meshMassIncrement A n i ω) =
+      A (compensatorMeshTime n j) ω-A 0 ω := by
+    simp only [meshMassIncrement]
+    rw [Finset.sum_range_sub (fun i => A (compensatorMeshTime n i) ω) j,compensatorMeshTime_zero]
+  rw [he]
+  ring
+
+theorem meshMassCentered_selected_tendstoInMeasure
+    (ℱ : ℕ → Filtration ℕ mΩ) (A : ℝ≥0 → Ω → ℝ) (L : Ω → ℝ)
+    (hA : ∀ t, Measurable (A t))
+    (hgrid : ∀ n i, StronglyMeasurable[ℱ n i] (A (compensatorMeshTime n i)))
+    (hL : MemLp L 2 P)
+    (hp : ∀ᵐ ω ∂P, Monotone (fun t => A t ω) ∧ A 0 ω=0 ∧
+      Continuous (fun t => A t ω) ∧ Tendsto (fun t => A t ω) atTop (𝓝 (L ω)) ∧
+      ∀ t, A t ω ≤ L ω)
+    (J : ℕ → Ω → ℕ) (hJ : ∀ n ω, J n ω ≤ n*2^n) :
+    TendstoInMeasure P
+      (fun n ω => centeredMassPartialSum P (ℱ n) (meshMassIncrement A n) (J n ω) ω)
+      atTop 0 := by
+  apply centeredMassPartialSum_selected_tendstoInMeasure P ℱ (meshMassIncrement A)
+    (fun n i => meshMassIncrement_memLp P A L hL hA
+      (hp.mono (fun ω hω => ⟨hω.1,hω.2.1,hω.2.2.2.2⟩)) n i)
+    (fun n i => (hgrid n (i+1)).sub ((hgrid n i).mono (ℱ n |>.mono (Nat.le_succ i))))
+    (fun n => n*2^n) J hJ
+  exact compensatorQuadraticError_mean_tendsto_zero P A L hA hL.integrable_sq hp
+
+omit [IsProbabilityMeasure P] in
+lemma meshMassCompensator_selected_measurable
+    (ℱ : ℕ → Filtration ℕ mΩ) (A : ℝ≥0 → Ω → ℝ)
+    (n : ℕ) (J : Ω → ℕ) (hJ : Measurable J) :
+    Measurable (fun ω => meshMassCompensator P ℱ A n (J ω) ω) := by
+  have hjoint : Measurable (fun z : ℕ × Ω => meshMassCompensator P ℱ A n z.1 z.2) := by
+    apply measurable_from_prod_countable_right
+    intro j
+    change Measurable (fun ω => ∑ i ∈ Finset.range j, condExp (ℱ n i) P (meshMassIncrement A n i) ω)
+    apply Finset.measurable_sum
+    intro i _
+    exact stronglyMeasurable_condExp.measurable.le (ℱ n |>.le i)
+  exact hjoint.comp (hJ.prodMk measurable_id)
+
+/-- Any measurable choice of endpoints where the sampled mass has its
+pathwise limit recovers that same mass from the predictable increments. -/
+theorem meshMassCompensator_selected_tendstoInMeasure
+    (ℱ : ℕ → Filtration ℕ mΩ) (A : ℝ≥0 → Ω → ℝ) (L V : Ω → ℝ)
+    (hA : ∀ t, Measurable (A t))
+    (hgrid : ∀ n i, StronglyMeasurable[ℱ n i] (A (compensatorMeshTime n i)))
+    (hL : MemLp L 2 P)
+    (hp : ∀ᵐ ω ∂P, Monotone (fun t => A t ω) ∧ A 0 ω=0 ∧
+      Continuous (fun t => A t ω) ∧ Tendsto (fun t => A t ω) atTop (𝓝 (L ω)) ∧
+      ∀ t, A t ω ≤ L ω)
+    (J : ℕ → Ω → ℕ) (hJm : ∀ n, Measurable (J n))
+    (hJ : ∀ n ω, J n ω ≤ n*2^n)
+    (hJV : ∀ᵐ ω ∂P, Tendsto (fun n => A (compensatorMeshTime n (J n ω)) ω)
+      atTop (𝓝 (V ω))) :
+    TendstoInMeasure P (fun n ω => meshMassCompensator P ℱ A n (J n ω) ω) atTop V := by
+  have hZ := meshMassCentered_selected_tendstoInMeasure P ℱ A L hA hgrid hL hp J hJ
+  apply (exists_seq_tendstoInMeasure_atTop_iff
+    (fun n => (meshMassCompensator_selected_measurable P ℱ A n (J n) (hJm n)).aestronglyMeasurable)).mpr
+  intro ns hns
+  obtain ⟨ms,hms,hlim⟩ := (hZ.comp hns.tendsto_atTop).exists_seq_tendsto_ae
+  refine ⟨ms,hms,?_⟩
+  filter_upwards [hp,hJV,hlim] with ω hω hV hZω
+  have ht := (hV.comp (hns.tendsto_atTop.comp hms.tendsto_atTop)).sub hZω
+  simp only [Pi.zero_apply,sub_zero,Function.comp_def] at ht
+  convert ht using 1
+  funext n
+  rw [meshMassCompensator_decomposition,hω.2.1,sub_zero]
+
+/-- The exact last-full-cell convention, including an infinite endpoint,
+recovers the stopped mass in probability. -/
+theorem meshMassCompensator_stopped_tendstoInMeasure
+    (ℱ : ℕ → Filtration ℕ mΩ) (A : ℝ≥0 → Ω → ℝ) (L : Ω → ℝ)
+    (hA : ∀ t, Measurable (A t))
+    (hgrid : ∀ n i, StronglyMeasurable[ℱ n i] (A (compensatorMeshTime n i)))
+    (hL : MemLp L 2 P)
+    (hp : ∀ᵐ ω ∂P, Monotone (fun t => A t ω) ∧ A 0 ω=0 ∧
+      Continuous (fun t => A t ω) ∧ Tendsto (fun t => A t ω) atTop (𝓝 (L ω)) ∧
+      ∀ t, A t ω ≤ L ω)
+    (T : Ω → ℝ≥0∞) (hT : Measurable T) :
+    TendstoInMeasure P
+      (fun n ω => meshMassCompensator P ℱ A n (compensatorStopIndex n (T ω)) ω)
+      atTop (fun ω => massAtExtendedTime (fun t => A t ω) (L ω) (T ω)) := by
+  apply meshMassCompensator_selected_tendstoInMeasure P ℱ A L _ hA hgrid hL hp
+    (fun n ω => compensatorStopIndex n (T ω))
+    (fun n => compensatorStopIndex_measurable T hT n)
+    (fun n ω => compensatorStopIndex_le n (T ω))
+  filter_upwards [hp] with ω hω
+  exact massAt_compensatorEndpoint_tendsto (fun t => A t ω) (L ω)
+    hω.2.2.1 hω.2.2.2.1 (T ω)
+
+end SLEExactGauge
+
+end
+
+end OAI

lean/OAI/Probability/SLE/Mass/MassCompensatorSelection.lean

@@ -0,0 +1,81 @@
+import OAI.Probability.SLE.Mass.MassCompensatorVariance
+import Mathlib.MeasureTheory.Function.ConvergenceInMeasure
+
+namespace OAI
+
+/-! The compensator error at a selected grid endpoint. The endpoint may
+depend on the whole path; the maximal bound does not require it to be a
+discrete stopping time. -/
+
+noncomputable section
+open Set Filter MeasureTheory ProbabilityTheory
+open scoped Topology NNReal ENNReal
+
+namespace SLEExactGauge
+
+variable {Ω : Type*} [mΩ : MeasurableSpace Ω] (P : Measure Ω) [IsProbabilityMeasure P]
+
+lemma centeredMassPartialSum_selected_bound
+    (ℱ : Filtration ℕ mΩ) (D : ℕ → Ω → ℝ)
+    (hD : ∀ i, MemLp (D i) 2 P)
+    (hDm : ∀ i, StronglyMeasurable[ℱ (i+1)] (D i))
+    (N : ℕ) (J : Ω → ℕ) (hJ : ∀ ω, J ω ≤ N) (ε : ℝ) (hε : 0 < ε) :
+    ENNReal.ofReal (ε^2) * P {ω | ε ≤ |centeredMassPartialSum P ℱ D (J ω) ω|} ≤
+      ENNReal.ofReal (∫ ω, ∑ i ∈ Finset.range N, D i ω^2 ∂P) := by
+  have hs : {ω | ε ≤ |centeredMassPartialSum P ℱ D (J ω) ω|} ⊆
+      {ω | ε^2 ≤ (Finset.range (N+1)).sup' Finset.nonempty_range_add_one
+        (fun j => centeredMassPartialSum P ℱ D j ω^2)} := by
+    intro ω hω
+    change ε^2 ≤ _
+    apply Finset.le_sup'_of_le (fun j => centeredMassPartialSum P ℱ D j ω^2)
+      (Finset.mem_range.mpr (Nat.lt_succ_of_le (hJ ω)))
+    have hh := mul_self_le_mul_self hε.le hω
+    simpa only [sq_abs,← pow_two] using hh
+  have hb := centeredMassPartialSum_maximal_error P ℱ D hD hDm
+    (NNReal.mk (ε^2) (sq_nonneg ε)) N
+  have hb' : ENNReal.ofReal (ε^2) * P {ω | ε^2 ≤
+      (Finset.range (N+1)).sup' Finset.nonempty_range_add_one
+        (fun j => centeredMassPartialSum P ℱ D j ω^2)} ≤
+      ENNReal.ofReal (∫ ω, ∑ i ∈ Finset.range N, D i ω^2 ∂P) := by
+    simpa only [ENNReal.ofReal_eq_coe_nnreal (sq_nonneg ε),NNReal.coe_mk] using hb
+  exact (mul_le_mul_of_nonneg_left (measure_mono hs)
+    (show 0 ≤ ENNReal.ofReal (ε^2) from zero_le)).trans hb'
+
+/-- Vanishing expected quadratic increments imply that the centered
+compensator vanishes in probability at every bounded selected index. -/
+theorem centeredMassPartialSum_selected_tendstoInMeasure
+    (ℱ : ℕ → Filtration ℕ mΩ) (D : ℕ → ℕ → Ω → ℝ)
+    (hD : ∀ n i, MemLp (D n i) 2 P)
+    (hDm : ∀ n i, StronglyMeasurable[ℱ n (i+1)] (D n i))
+    (N : ℕ → ℕ) (J : ℕ → Ω → ℕ) (hJ : ∀ n ω, J n ω ≤ N n)
+    (hE : Tendsto (fun n => ∫ ω, ∑ i ∈ Finset.range (N n), D n i ω^2 ∂P)
+      atTop (𝓝 0)) :
+    TendstoInMeasure P (fun n ω => centeredMassPartialSum P (ℱ n) (D n) (J n ω) ω)
+      atTop 0 := by
+  rw [tendstoInMeasure_iff_norm]
+  intro ε hε
+  let c : ℝ≥0∞ := ENNReal.ofReal (ε^2)
+  have hc0 : c ≠ 0 := (ENNReal.ofReal_pos.mpr (sq_pos_of_pos hε)).ne'
+  have hcT : c ≠ ∞ := ENNReal.ofReal_ne_top
+  have hb (n : ℕ) : P {ω | ε ≤ |centeredMassPartialSum P (ℱ n) (D n) (J n ω) ω|} ≤
+      c⁻¹*ENNReal.ofReal (∫ ω, ∑ i ∈ Finset.range (N n), D n i ω^2 ∂P) := by
+    calc
+      _ = c⁻¹*(c*P {ω | ε ≤ |centeredMassPartialSum P (ℱ n) (D n) (J n ω) ω|}) := by
+        rw [← mul_assoc,ENNReal.inv_mul_cancel hc0 hcT,one_mul]
+      _ ≤ _ := mul_le_mul_of_nonneg_left
+        (centeredMassPartialSum_selected_bound P (ℱ n) (D n) (hD n) (hDm n)
+          (N n) (J n) (hJ n) ε hε) (show 0 ≤ c⁻¹ from zero_le)
+  have ht : Tendsto (fun n => c⁻¹*ENNReal.ofReal
+      (∫ ω, ∑ i ∈ Finset.range (N n), D n i ω^2 ∂P)) atTop (𝓝 0) := by
+    simpa only [ENNReal.ofReal_zero,mul_zero] using
+      ENNReal.Tendsto.const_mul (ENNReal.tendsto_ofReal hE)
+        (Or.inr (ENNReal.inv_ne_top.mpr hc0))
+  simpa only [Pi.zero_apply,sub_zero,Real.norm_eq_abs] using
+    tendsto_of_tendsto_of_tendsto_of_le_of_le tendsto_const_nhds ht
+      (fun _ => bot_le) hb
+
+end SLEExactGauge
+
+end
+
+end OAI

lean/OAI/Probability/SLE/Mass/MassCompensatorVariance.lean

@@ -0,0 +1,192 @@
+import OAI.Probability.SLE.Mass.MassCompensatorMesh
+import Mathlib.Probability.Martingale.Centering
+import Mathlib.Probability.Martingale.OptionalStopping
+import Mathlib.Probability.CondVar
+
+namespace OAI
+
+/-! Orthogonality and variance bounds for the discrete potential
+compensator used in the prescribed moment coefficients. -/
+
+noncomputable section
+open Set Filter MeasureTheory ProbabilityTheory
+open scoped Topology NNReal ENNReal
+
+namespace SLEExactGauge
+
+variable {Ω : Type*} [mΩ : MeasurableSpace Ω] (P : Measure Ω) [IsProbabilityMeasure P]
+
+section Centered
+variable (m : MeasurableSpace Ω) (hm : m ≤ mΩ)
+
+include hm in
+lemma centered_mass_increment_condExp (X : Ω → ℝ) (hX : MemLp X 2 P) :
+    P[X-P[X|m]|m] =ᵐ[P] 0 := by
+  have hi := hX.integrable one_le_two
+  have h := condExp_sub hi (integrable_condExp (μ := P) (m := m) (f := X)) m
+  rw [condExp_of_stronglyMeasurable hm stronglyMeasurable_condExp integrable_condExp] at h
+  simpa only [sub_self] using h
+
+include hm in
+lemma integral_mul_centered_mass_increment
+    (X Y : Ω → ℝ) (hX : MemLp X 2 P) (hY : MemLp Y 2 P)
+    (hYm : StronglyMeasurable[m] Y) :
+    (∫ ω, Y ω*(X ω-P[X|m] ω) ∂P)=0 := by
+  have hZ : MemLp (X-P[X|m]) 2 P := hX.sub (hX.condExp one_le_two)
+  have hprod : Integrable (Y*(X-P[X|m])) P := memLp_one_iff_integrable.mp (hY.mul hZ)
+  have he := condExp_mul_of_stronglyMeasurable_left hYm hprod (hZ.integrable one_le_two)
+  have hz := centered_mass_increment_condExp (mΩ := mΩ) P m hm X hX
+  have he0 : P[Y*(X-P[X|m])|m] =ᵐ[P] 0 := by
+    filter_upwards [he,hz] with ω hp hz
+    simp only [Pi.mul_apply,Pi.zero_apply,hz,mul_zero] at hp ⊢
+    exact hp
+  calc
+    _ = ∫ ω, P[Y*(X-P[X|m])|m] ω ∂P := (integral_condExp hm).symm
+    _ = 0 := by simpa only [Pi.zero_apply,integral_zero] using integral_congr_ae he0
+
+include hm in
+lemma centered_mass_increment_variance_le (X : Ω → ℝ) (hX : MemLp X 2 P) :
+    (∫ ω, (X ω-P[X|m] ω)^2 ∂P) ≤ ∫ ω, X ω^2 ∂P := by
+  have hZ : Integrable (fun ω => (X ω-P[X|m] ω)^2) P :=
+    (hX.sub (hX.condExp one_le_two)).integrable_sq
+  have he := setIntegral_condVar (hm := hm) hZ (MeasurableSet.univ : MeasurableSet[m] univ)
+  simp only [Measure.restrict_univ] at he
+  rw [← he]
+  calc
+    _ ≤ ∫ ω, P[X^2|m] ω ∂P :=
+      integral_mono_ae integrable_condVar integrable_condExp (condVar_ae_le_condExp_sq hm hX)
+    _ = _ := integral_condExp hm
+
+end Centered
+
+lemma martingale_square_submartingale
+    {ι : Type*} [Preorder ι] (ℱ : Filtration ι mΩ)
+    (M : ι → Ω → ℝ) (hM : Martingale M ℱ P) (h2 : ∀ i, MemLp (M i) 2 P) :
+    Submartingale (fun i ω => M i ω^2) ℱ P := by
+  refine ⟨fun i => (hM.stronglyMeasurable i).pow 2,?_,fun i => (h2 i).integrable_sq⟩
+  intro i j hij
+  have hv := condVar_ae_eq_condExp_sq_sub_sq_condExp (ℱ.le i) (h2 j)
+  have hn : 0 ≤ᵐ[P] condVar (ℱ i) (M j) P :=
+    condExp_nonneg (ae_of_all _ (fun ω => sq_nonneg (M j ω-P[M j|ℱ i] ω)))
+  filter_upwards [hv,hn,hM.condExp_ae_eq hij] with ω hv hn he
+  simp only [Pi.sub_apply,Pi.pow_apply] at hv
+  rw [he] at hv
+  change 0 ≤ condVar (ℱ i) (M j) P ω at hn
+  change condVar (ℱ i) (M j) P ω = P[fun ω => M j ω^2|ℱ i] ω - M i ω^2 at hv
+  linarith
+
+lemma martingale_square_maximal_ineq
+    (ℱ : Filtration ℕ mΩ) (M : ℕ → Ω → ℝ)
+    (hM : Martingale M ℱ P) (h2 : ∀ i, MemLp (M i) 2 P)
+    (ε : ℝ≥0) (N : ℕ) :
+    (ε:ℝ≥0∞) * P {ω | (ε:ℝ) ≤ (Finset.range (N+1)).sup'
+      Finset.nonempty_range_add_one (fun j => M j ω^2)} ≤
+      ENNReal.ofReal (∫ ω, M N ω^2 ∂P) := by
+  have hsub := martingale_square_submartingale P ℱ M hM h2
+  have h := maximal_ineq hsub (fun i ω => sq_nonneg (M i ω)) (ε := ε) N
+  refine h.trans (ENNReal.ofReal_le_ofReal ?_)
+  exact setIntegral_le_integral (h2 N).integrable_sq (ae_of_all _ (fun ω => sq_nonneg (M N ω)))
+
+noncomputable def centeredMassPartialSum (ℱ : Filtration ℕ mΩ) (D : ℕ → Ω → ℝ)
+    (n : ℕ) (ω : Ω) : ℝ := ∑ i ∈ Finset.range n, (D i ω - condExp (ℱ i) P (D i) ω)
+
+omit [IsProbabilityMeasure P] in
+lemma centeredMassPartialSum_memLp (ℱ : Filtration ℕ mΩ) (D : ℕ → Ω → ℝ)
+    (hD : ∀ i, MemLp (D i) 2 P) (n : ℕ) :
+    MemLp (centeredMassPartialSum P ℱ D n) 2 P :=
+  memLp_finsetSum _ (fun i _ => (hD i).sub ((hD i).condExp one_le_two))
+
+omit [IsProbabilityMeasure P] in
+lemma centeredMassPartialSum_stronglyMeasurable
+    (ℱ : Filtration ℕ mΩ) (D : ℕ → Ω → ℝ)
+    (hD : ∀ i, StronglyMeasurable[ℱ (i+1)] (D i)) (n : ℕ) :
+    StronglyMeasurable[ℱ n] (centeredMassPartialSum P ℱ D n) := by
+  apply Finset.stronglyMeasurable_fun_sum
+  intro i hi
+  have hle : i+1 ≤ n := Nat.succ_le_of_lt (Finset.mem_range.mp hi)
+  exact ((hD i).mono (ℱ.mono hle)).sub
+    (stronglyMeasurable_condExp.mono (ℱ.mono (Nat.le_of_lt (Finset.mem_range.mp hi))))
+
+lemma centeredMassPartialSum_variance
+    (ℱ : Filtration ℕ mΩ) (D : ℕ → Ω → ℝ)
+    (hD : ∀ i, MemLp (D i) 2 P)
+    (hDm : ∀ i, StronglyMeasurable[ℱ (i+1)] (D i)) (n : ℕ) :
+    (∫ ω, centeredMassPartialSum P ℱ D n ω^2 ∂P) =
+      ∑ i ∈ Finset.range n, ∫ ω, (D i ω-P[D i|ℱ i] ω)^2 ∂P := by
+  induction n with
+  | zero => simp [centeredMassPartialSum]
+  | succ n ih =>
+    have hS := centeredMassPartialSum_memLp P ℱ D hD n
+    have hX : MemLp (D n-P[D n|ℱ n]) 2 P := (hD n).sub ((hD n).condExp one_le_two)
+    have hSX : Integrable (fun ω => centeredMassPartialSum P ℱ D n ω*
+        (D n ω-P[D n|ℱ n] ω)) P := memLp_one_iff_integrable.mp (hS.mul hX)
+    have hcross := integral_mul_centered_mass_increment P (ℱ n) (ℱ.le n)
+      (D n) (centeredMassPartialSum P ℱ D n) (hD n) hS
+      (centeredMassPartialSum_stronglyMeasurable P ℱ D hDm n)
+    have he : (fun ω => centeredMassPartialSum P ℱ D (n+1) ω^2) =
+        (fun ω => centeredMassPartialSum P ℱ D n ω^2+
+          2*(centeredMassPartialSum P ℱ D n ω*(D n ω-P[D n|ℱ n] ω))+
+          (D n ω-P[D n|ℱ n] ω)^2) := by
+      funext ω
+      simp only [centeredMassPartialSum,Finset.sum_range_succ]
+      ring
+    have hi₁ := integral_add (hS.integrable_sq.add (hSX.const_mul 2)) hX.integrable_sq
+    have hi₂ := integral_add hS.integrable_sq (hSX.const_mul 2)
+    simp only [Pi.add_apply,Pi.sub_apply] at hi₁ hi₂
+    rw [he,hi₁,hi₂,integral_const_mul,hcross,mul_zero,add_zero,ih,Finset.sum_range_succ]
+
+lemma centeredMassPartialSum_variance_le
+    (ℱ : Filtration ℕ mΩ) (D : ℕ → Ω → ℝ)
+    (hD : ∀ i, MemLp (D i) 2 P)
+    (hDm : ∀ i, StronglyMeasurable[ℱ (i+1)] (D i)) (n : ℕ) :
+    (∫ ω, centeredMassPartialSum P ℱ D n ω^2 ∂P) ≤
+      ∫ ω, ∑ i ∈ Finset.range n, D i ω^2 ∂P := by
+  rw [centeredMassPartialSum_variance P ℱ D hD hDm n,
+    integral_finsetSum _ (fun i _ => (hD i).integrable_sq)]
+  exact Finset.sum_le_sum (fun i _ => centered_mass_increment_variance_le P (ℱ i) (ℱ.le i) (D i) (hD i))
+
+lemma centeredMassPartialSum_martingale
+    (ℱ : Filtration ℕ mΩ) (D : ℕ → Ω → ℝ)
+    (hD : ∀ i, MemLp (D i) 2 P)
+    (hDm : ∀ i, StronglyMeasurable[ℱ (i+1)] (D i)) :
+    Martingale (centeredMassPartialSum P ℱ D) ℱ P := by
+  let A : ℕ → Ω → ℝ := fun n ω => ∑ i ∈ Finset.range n, D i ω
+  have hAm : StronglyAdapted ℱ A := by
+    intro n
+    apply Finset.stronglyMeasurable_fun_sum
+    intro i hi
+    exact (hDm i).mono (ℱ.mono (Nat.succ_le_of_lt (Finset.mem_range.mp hi)))
+  have hAI (n : ℕ) : Integrable (A n) P :=
+    (memLp_finsetSum _ (fun i _ => hD i)).integrable one_le_two
+  have hd (i : ℕ) : A (i+1)-A i=D i := by
+    funext ω
+    simp only [A,Finset.sum_range_succ,Pi.sub_apply,add_sub_cancel_left]
+  have he : martingalePart A ℱ P = centeredMassPartialSum P ℱ D := by
+    rw [martingalePart_eq_sum]
+    funext n ω
+    simp only [Pi.add_apply,Finset.sum_apply,Pi.sub_apply]
+    change A 0 ω+(∑ i ∈ Finset.range n,
+      ((A (i+1)-A i) ω-condExp (ℱ i) P (A (i+1)-A i) ω)) = _
+    simp only [hd]
+    simp only [A,Finset.range_zero,Finset.sum_empty,zero_add,centeredMassPartialSum]
+  simpa only [he] using martingale_martingalePart hAm hAI
+
+/-- A maximal estimate valid at every selected grid index, without
+requiring that the selected index itself be a stopping time. -/
+theorem centeredMassPartialSum_maximal_error
+    (ℱ : Filtration ℕ mΩ) (D : ℕ → Ω → ℝ)
+    (hD : ∀ i, MemLp (D i) 2 P)
+    (hDm : ∀ i, StronglyMeasurable[ℱ (i+1)] (D i)) (ε : ℝ≥0) (N : ℕ) :
+    (ε:ℝ≥0∞)*P {ω | (ε:ℝ) ≤ (Finset.range (N+1)).sup'
+      Finset.nonempty_range_add_one (fun j => centeredMassPartialSum P ℱ D j ω^2)} ≤
+        ENNReal.ofReal (∫ ω, ∑ i ∈ Finset.range N, D i ω^2 ∂P) := by
+  exact (martingale_square_maximal_ineq P ℱ (centeredMassPartialSum P ℱ D)
+    (centeredMassPartialSum_martingale P ℱ D hD hDm)
+    (centeredMassPartialSum_memLp P ℱ D hD) ε N).trans
+      (ENNReal.ofReal_le_ofReal (centeredMassPartialSum_variance_le P ℱ D hD hDm N))
+
+end SLEExactGauge
+
+end
+
+end OAI

lean/OAI/Probability/SLE/Mass/MassGridCutoffs.lean

@@ -0,0 +1,105 @@
+import OAI.Probability.SLE.Mass.MassGridOverlap
+import OAI.Probability.SLE.Mass.LevelRadonMoments
+
+namespace OAI
+
+/-! Compact spatial test functions adapted to the mass grid. A fixed
+compact cutoff keeps every enlarged grid cell inside the open half-plane. -/
+
+noncomputable section
+open Set Metric Filter MeasureTheory Classical
+open scoped ENNReal Topology CompactlySupported
+
+namespace SLEExactGauge.Multipoint
+
+lemma exists_unit_compact_test_cutoff (K : Set upperHalfPlane) (hK : IsCompact K) :
+    ∃ f : C_c(upperHalfPlane,ℝ), (∀ z, 0 ≤ f z ∧ f z ≤ 1) ∧ ∀ z ∈ K, f z = 1 := by
+  let : LocallyCompactSpace upperHalfPlane := isOpen_upperHalfPlane.locallyCompactSpace
+  obtain ⟨f,hf,hfc,_,h01⟩ := exists_continuousMap_one_of_isCompact_subset_isOpen
+    hK isOpen_univ (subset_univ K)
+  exact ⟨⟨f,hfc⟩,h01,fun z hz => hf hz⟩
+
+def massGridBump (r : ℝ) (i : ℤ×ℤ) : C(upperHalfPlane,ℝ) :=
+  ⟨fun z => max 0 (min 1 ((3*r-dist (z:ℂ) (coverGridCenter r i))/r)), by fun_prop⟩
+
+def massGridCutoff (χ : C_c(upperHalfPlane,ℝ)) (r : ℝ) (i : ℤ×ℤ) :
+    C_c(upperHalfPlane,ℝ) := massGridBump r i • χ
+
+lemma massGridBump_bounds (r : ℝ) (i : ℤ×ℤ) (z : upperHalfPlane) :
+    0 ≤ massGridBump r i z ∧ massGridBump r i z ≤ 1 := by
+  exact ⟨le_max_left _ _, max_le (by norm_num) (min_le_left _ _)⟩
+
+lemma massGridBump_eq_one {r : ℝ} (hr : 0 < r) (i : ℤ×ℤ) (z : upperHalfPlane)
+    (hz : dist (z:ℂ) (coverGridCenter r i) ≤ 2*r) : massGridBump r i z = 1 := by
+  have hh : 1 ≤ (3*r-dist (z:ℂ) (coverGridCenter r i))/r := (le_div_iff₀ hr).mpr (by linarith)
+  simp only [massGridBump,ContinuousMap.coe_mk,min_eq_left hh,max_eq_right (by norm_num : (0:ℝ)≤1)]
+
+lemma massGridBump_eq_zero {r : ℝ} (hr : 0 < r) (i : ℤ×ℤ) (z : upperHalfPlane)
+    (hz : 3*r < dist (z:ℂ) (coverGridCenter r i)) : massGridBump r i z = 0 := by
+  have hh : (3*r-dist (z:ℂ) (coverGridCenter r i))/r ≤ 0 :=
+    div_nonpos_of_nonpos_of_nonneg (by linarith) hr.le
+  apply max_eq_left
+  exact (min_le_right _ _).trans hh
+
+lemma massGridCutoff_bounds (χ : C_c(upperHalfPlane,ℝ))
+    (hχ : ∀ z, 0 ≤ χ z ∧ χ z ≤ 1) (r : ℝ) (i : ℤ×ℤ) (z : upperHalfPlane) :
+    0 ≤ massGridCutoff χ r i z ∧ massGridCutoff χ r i z ≤ 1 := by
+  have hb := massGridBump_bounds r i z
+  change 0 ≤ massGridBump r i z * χ z ∧ massGridBump r i z * χ z ≤ 1
+  exact ⟨mul_nonneg hb.1 (hχ z).1,(mul_le_mul_of_nonneg_right hb.2 (hχ z).1).trans (by simpa only [one_mul] using (hχ z).2)⟩
+
+lemma massGridCutoff_eq_one (χ : C_c(upperHalfPlane,ℝ)) {r : ℝ} (hr : 0 < r)
+    (i : ℤ×ℤ) (z : upperHalfPlane) (hχ : χ z = 1)
+    (hz : dist (z:ℂ) (coverGridCenter r i) ≤ 2*r) : massGridCutoff χ r i z = 1 := by
+  change massGridBump r i z * χ z = 1
+  rw [massGridBump_eq_one hr i z hz,hχ,one_mul]
+
+lemma massGridCutoff_support (χ : C_c(upperHalfPlane,ℝ)) {r : ℝ} (hr : 0 < r)
+    (i : ℤ×ℤ) (z : ℂ) (hz : extendHalfPlaneTest (massGridCutoff χ r i) z ≠ 0) :
+    dist z (coverGridCenter r i) ≤ 3*r := by
+  by_cases hH : z ∈ upperHalfPlane
+  · by_contra h
+    have he := massGridBump_eq_zero hr i ⟨z,hH⟩ (lt_of_not_ge h)
+    apply hz
+    rw [show z = (⟨z,hH⟩ : upperHalfPlane).val from rfl,extendHalfPlaneTest_apply]
+    change massGridBump r i ⟨z,hH⟩ * χ ⟨z,hH⟩ = 0
+    rw [he,zero_mul]
+  · exact False.elim (hz (extendHalfPlaneTest_of_not_mem _ z hH))
+
+lemma massGridCutoff_common_support (χ : C_c(upperHalfPlane,ℝ)) (r : ℝ) (i : ℤ×ℤ)
+    (z : ℂ) (hz : z ∉ (Subtype.val : upperHalfPlane → ℂ) '' tsupport χ) :
+    extendHalfPlaneTest (massGridCutoff χ r i) z = 0 := by
+  by_cases hH : z ∈ upperHalfPlane
+  · let x : upperHalfPlane := ⟨z,hH⟩
+    have hχ : χ x = 0 := image_eq_zero_of_notMem_tsupport (fun h => hz ⟨x,h,rfl⟩)
+    change extendHalfPlaneTest (massGridCutoff χ r i) x = 0
+    rw [extendHalfPlaneTest_apply]
+    change massGridBump r i x * χ x = 0
+    rw [hχ,mul_zero]
+  · exact extendHalfPlaneTest_of_not_mem _ z hH
+
+lemma massGridCutoff_sum_bound (χ : C_c(upperHalfPlane,ℝ))
+    (hχ : ∀ z, 0 ≤ χ z ∧ χ z ≤ 1) {r : ℝ} (hr : 0 < r) (I : Finset (ℤ×ℤ))
+    (x y : ℂ) :
+    (∑ i ∈ I, ENNReal.ofReal (extendHalfPlaneTest (massGridCutoff χ r i) x) *
+      ENNReal.ofReal (extendHalfPlaneTest (massGridCutoff χ r i) y)) ≤
+        if dist x y ≤ 6*r then 81 else 0 := by
+  refine massGrid_cutoff_product_sum_le hr I
+    (fun i z => ENNReal.ofReal (extendHalfPlaneTest (massGridCutoff χ r i) z)) ?_ ?_ x y
+  · intro i z
+    apply ENNReal.ofReal_le_one.mpr
+    by_cases hH : z ∈ upperHalfPlane
+    · rw [show z = (⟨z,hH⟩ : upperHalfPlane).val from rfl,extendHalfPlaneTest_apply]
+      exact (massGridCutoff_bounds χ hχ r i ⟨z,hH⟩).2
+    · rw [extendHalfPlaneTest_of_not_mem _ z hH]
+      norm_num
+  · intro i z hz
+    apply massGridCutoff_support χ hr i z
+    intro he
+    exact hz (by rw [he,ENNReal.ofReal_zero])
+
+end SLEExactGauge.Multipoint
+
+end
+
+end OAI

lean/OAI/Probability/SLE/Mass/MassGridOverlap.lean

@@ -0,0 +1,91 @@
+import OAI.Probability.SLE.Gauge.CoverGrid
+
+namespace OAI
+
+/-! A fixed overlap bound for planar mass cutoffs on the physical grid. -/
+
+noncomputable section
+open Set Metric Filter MeasureTheory Classical
+open scoped ENNReal
+
+namespace SLEExactGauge
+
+lemma massGrid_coordinate_bounds {r x : ℝ} (hr : 0 < r) (i : ℤ)
+    (hi : |x-r*(i:ℝ)| ≤ 3*r) :
+    ⌊x/r⌋-4 ≤ i ∧ i ≤ ⌊x/r⌋+4 := by
+  have hf : r*(⌊x/r⌋:ℝ) ≤ x := by
+    have hh := mul_le_mul_of_nonneg_left (Int.floor_le (x/r)) hr.le
+    rwa [mul_div_cancel₀ _ hr.ne'] at hh
+  have hg : x < r*((⌊x/r⌋:ℝ)+1) := by
+    have hh := mul_lt_mul_of_pos_left (Int.lt_floor_add_one (x/r)) hr
+    rwa [mul_div_cancel₀ _ hr.ne'] at hh
+  have hlo : ((⌊x/r⌋-4:ℤ):ℝ) ≤ (i:ℝ) := by
+    push_cast
+    nlinarith [abs_le.mp hi]
+  have hhi : (i:ℝ) ≤ ((⌊x/r⌋+4:ℤ):ℝ) := by
+    push_cast
+    nlinarith [abs_le.mp hi]
+  exact ⟨by exact_mod_cast hlo,by exact_mod_cast hhi⟩
+
+lemma massGrid_nearby_card_le {r : ℝ} (hr : 0 < r) (I : Finset (ℤ×ℤ)) (z : ℂ) :
+    (I.filter (fun ij => dist z (coverGridCenter r ij) ≤ 3*r)).card ≤ 81 := by
+  let J := (Finset.Icc (⌊z.re/r⌋-4) (⌊z.re/r⌋+4)) ×ˢ
+    (Finset.Icc (⌊z.im/r⌋-4) (⌊z.im/r⌋+4))
+  have hsub : I.filter (fun ij => dist z (coverGridCenter r ij) ≤ 3*r) ⊆ J := by
+    intro ij hij
+    have hd := (Finset.mem_filter.mp hij).2
+    have hre : |z.re-r*(ij.1:ℝ)| ≤ 3*r := by
+      have h := (Complex.abs_re_le_norm (z-coverGridCenter r ij)).trans
+        (by simpa only [dist_eq_norm] using hd)
+      simpa [coverGridCenter] using h
+    have him : |z.im-r*(ij.2:ℝ)| ≤ 3*r := by
+      have h := (Complex.abs_im_le_norm (z-coverGridCenter r ij)).trans
+        (by simpa only [dist_eq_norm] using hd)
+      simpa [coverGridCenter] using h
+    simpa only [J,Finset.mem_product,Finset.mem_Icc] using
+      And.intro (massGrid_coordinate_bounds hr ij.1 hre) (massGrid_coordinate_bounds hr ij.2 him)
+  have hcard : J.card = 81 := by
+    simp only [J,Finset.card_product,Int.card_Icc]
+    rw [show ⌊z.re/r⌋+4+1-(⌊z.re/r⌋-4) = (9:ℤ) by omega,
+      show ⌊z.im/r⌋+4+1-(⌊z.im/r⌋-4) = (9:ℤ) by omega]
+    rfl
+  exact (Finset.card_le_card hsub).trans_eq hcard
+
+lemma massGrid_cutoff_product_sum_le {r : ℝ} (hr : 0 < r) (I : Finset (ℤ×ℤ))
+    (f : (ℤ×ℤ) → ℂ → ℝ≥0∞) (hf : ∀ i z, f i z ≤ 1)
+    (hs : ∀ i z, f i z ≠ 0 → dist z (coverGridCenter r i) ≤ 3*r)
+    (x y : ℂ) :
+    (∑ i ∈ I, f i x * f i y) ≤ if dist x y ≤ 6*r then 81 else 0 := by
+  by_cases hxy : dist x y ≤ 6*r
+  · rw [ite_eq_left hxy]
+    let J := I.filter (fun i => dist x (coverGridCenter r i) ≤ 3*r)
+    have he : (∑ i ∈ I, f i x * f i y) = ∑ i ∈ J, f i x * f i y := by
+      symm
+      apply Finset.sum_subset (Finset.filter_subset _ _)
+      intro i hi hij
+      have hx : f i x = 0 := by
+        by_contra h
+        exact hij (Finset.mem_filter.mpr ⟨hi,hs i x h⟩)
+      simp only [hx,zero_mul]
+    rw [he]
+    calc
+      _ ≤ ∑ _i ∈ J, (1 : ℝ≥0∞) :=
+        Finset.sum_le_sum (fun i _ => (mul_le_mul' (hf i x) (hf i y)).trans_eq (one_mul 1))
+      _ = J.card := by simp
+      _ ≤ 81 := by exact_mod_cast massGrid_nearby_card_le hr I x
+  · rw [ite_eq_right hxy]
+    apply le_of_eq
+    apply Finset.sum_eq_zero
+    intro i hi
+    by_cases hx : f i x = 0
+    · simp only [hx,zero_mul]
+    by_cases hy : f i y = 0
+    · simp only [hy,mul_zero]
+    exact False.elim (hxy ((dist_triangle_right x y (coverGridCenter r i)).trans
+      (by linarith [hs i x hx,hs i y hy])))
+
+end SLEExactGauge
+
+end
+
+end OAI

lean/OAI/Probability/SLE/Mass/MassKernelUniqueness.lean

@@ -0,0 +1,51 @@
+import OAI.Probability.SLE.Mass.MassMartingaleUniqueness
+
+namespace OAI
+
+/-! Equal terminal remainder kernels yield a martingale difference; continuity
+and increasing integrable masses then imply uniqueness. -/
+
+noncomputable section
+open MeasureTheory Filter
+open scoped Topology NNReal
+
+namespace SLEExactGauge
+
+variable {Ω : Type*} [MeasurableSpace Ω] {P : Measure Ω} [IsFiniteMeasure P]
+  {ℱ : Filtration ℝ≥0 ‹MeasurableSpace Ω›}
+
+lemma mass_difference_martingale_of_terminal_mean
+    (A B : ℝ≥0 → Ω → ℝ) (Z : Ω → ℝ) (hZ : Integrable Z P)
+    (hAm : StronglyAdapted ℱ A) (hBm : StronglyAdapted ℱ B)
+    (hAI : ∀ t, Integrable (A t) P) (hBI : ∀ t, Integrable (B t) P)
+    (hmean : ∀ t E, MeasurableSet[ℱ t] E →
+      (∫ ω in E, A t ω-B t ω ∂P) = ∫ ω in E, Z ω ∂P) :
+    Martingale (fun t ω => A t ω-B t ω) ℱ P := by
+  have he (t : ℝ≥0) : (fun ω => A t ω-B t ω) =ᵐ[P] P[Z | ℱ t] := by
+    apply ae_eq_condExp_of_forall_setIntegral_eq (ℱ.le t) hZ
+      (fun E _ _ => ((hAI t).sub (hBI t)).integrableOn)
+      (fun E hE _ => hmean t E hE)
+    exact ((hAm t).sub (hBm t)).aestronglyMeasurable
+  exact (martingale_condExp Z ℱ P).congr (hAm.sub hBm)
+    (fun t => (he t).symm)
+
+theorem increasing_mass_unique_of_terminal_mean
+    (A B : ℝ≥0 → Ω → ℝ) (Z : Ω → ℝ) (hZ : Integrable Z P)
+    (hAm : StronglyAdapted ℱ A) (hBm : StronglyAdapted ℱ B)
+    (hAI : ∀ t, Integrable (A t) P) (hBI : ∀ t, Integrable (B t) P)
+    (hmean : ∀ t E, MeasurableSet[ℱ t] E →
+      (∫ ω in E, A t ω-B t ω ∂P) = ∫ ω in E, Z ω ∂P)
+    (hA : ∀ᵐ ω ∂P, Monotone (fun t => A t ω))
+    (hB : ∀ᵐ ω ∂P, Monotone (fun t => B t ω))
+    (hA0 : A 0 =ᵐ[P] 0) (hB0 : B 0 =ᵐ[P] 0)
+    (hcont : ∀ᵐ ω ∂P, Continuous (fun t => A t ω-B t ω)) :
+    ∀ᵐ ω ∂P, ∀ t, A t ω = B t ω :=
+  increasing_mass_martingale_indistinguishable A B
+    (mass_difference_martingale_of_terminal_mean A B Z hZ hAm hBm hAI hBI hmean)
+    hA hB hA0 hB0 hAI hBI hcont
+
+end SLEExactGauge
+
+end
+
+end OAI

lean/OAI/Probability/SLE/Mass/MassMartingaleTesting.lean

@@ -0,0 +1,75 @@
+import OAI.Probability.SLE.Mass.MassUniquenessSeparation
+import Mathlib.Probability.Martingale.Basic
+import Mathlib.MeasureTheory.Function.ConditionalExpectation.PullOut
+
+namespace OAI
+
+/-! Bounded predictable testing of the increments in the mass uniqueness proof. -/
+
+noncomputable section
+open MeasureTheory Filter
+open scoped Topology NNReal
+
+namespace SLEExactGauge
+
+lemma massSeparationTest_continuous : Continuous massSeparationTest :=
+  continuous_iff_continuousAt.mpr (fun x => (massSeparationTest_hasDerivAt x).continuousAt)
+
+lemma massSeparationSlope_continuous : Continuous massSeparationSlope :=
+  continuous_iff_continuousAt.mpr (fun x => (massSeparationSlope_hasDerivAt x).continuousAt)
+
+variable {Ω : Type*} [MeasurableSpace Ω] {P : Measure Ω} [IsFiniteMeasure P]
+  {ℱ : Filtration ℝ≥0 ‹MeasurableSpace Ω›} {M : ℝ≥0 → Ω → ℝ}
+
+omit [IsFiniteMeasure P] in
+lemma martingale_mass_test_integrable (hM : Martingale M ℱ P) (t : ℝ≥0) :
+    Integrable (fun ω => massSeparationTest (M t ω)) P := by
+  apply ((hM.integrable t).norm.const_mul 2).mono'
+    (massSeparationTest_continuous.comp_stronglyMeasurable
+      ((hM.stronglyMeasurable t).mono (ℱ.le t))).aestronglyMeasurable
+  filter_upwards [] with ω
+  simpa only [Real.norm_eq_abs,massSeparationTest_zero,sub_zero] using
+    massSeparationTest_lipschitz 0 (M t ω)
+
+omit [IsFiniteMeasure P] in
+lemma martingale_mass_weighted_increment_integrable (hM : Martingale M ℱ P)
+    (s t : ℝ≥0) :
+    Integrable (fun ω => massSeparationSlope (M s ω)*(M t ω-M s ω)) P := by
+  exact ((hM.integrable t).sub (hM.integrable s)).bdd_mul
+    (massSeparationSlope_continuous.comp_stronglyMeasurable
+      ((hM.stronglyMeasurable s).mono (ℱ.le s))).aestronglyMeasurable
+    (ae_of_all _ (fun ω => by simpa only [Real.norm_eq_abs] using
+      massSeparationSlope_abs_le (M s ω)))
+
+lemma martingale_mass_weighted_increment_mean (hM : Martingale M ℱ P)
+    {s t : ℝ≥0} (hst : s ≤ t) :
+    (∫ ω, massSeparationSlope (M s ω)*(M t ω-M s ω) ∂P) = 0 := by
+  have hg := (hM.integrable t).sub (hM.integrable s)
+  have hfg := martingale_mass_weighted_increment_integrable hM s t
+  have hCE : P[(fun ω => M t ω-M s ω) | ℱ s] =ᵐ[P] 0 := by
+    have hsub := condExp_sub (hM.integrable t) (hM.integrable s) (ℱ s)
+    have hs : P[M s | ℱ s] = M s :=
+      condExp_of_stronglyMeasurable (ℱ.le s) (hM.stronglyMeasurable s) (hM.integrable s)
+    filter_upwards [hsub,hM.condExp_ae_eq hst] with ω hω htω
+    simp only [Pi.sub_apply,hs,htω,sub_self,Pi.zero_apply] at hω ⊢
+    exact hω
+  have hpull := condExp_mul_of_stronglyMeasurable_left
+    (massSeparationSlope_continuous.comp_stronglyMeasurable (hM.stronglyMeasurable s)) hfg hg
+  calc
+    _ = ∫ ω, P[(fun ω => massSeparationSlope (M s ω)*(M t ω-M s ω)) | ℱ s] ω ∂P :=
+      (integral_condExp (ℱ.le s)).symm
+    _ = 0 := by
+      have he : P[(fun ω => massSeparationSlope (M s ω)*(M t ω-M s ω)) | ℱ s] =ᵐ[P] 0 := by
+        filter_upwards [hpull,hCE] with ω hp hc
+        change P[(fun ω => massSeparationSlope (M s ω)*(M t ω-M s ω)) | ℱ s] ω =
+          massSeparationSlope (M s ω)*P[(fun ω => M t ω-M s ω) | ℱ s] ω at hp
+        change P[(fun ω => M t ω-M s ω) | ℱ s] ω = 0 at hc
+        simpa only [hc,mul_zero,Pi.zero_apply] using hp
+      rw [integral_congr_ae he]
+      simp
+
+end SLEExactGauge
+
+end
+
+end OAI

lean/OAI/Probability/SLE/Mass/MassMartingaleUniqueness.lean

@@ -0,0 +1,123 @@
+import OAI.Probability.SLE.Mass.MassUniquenessMesh
+import OAI.Probability.SLE.Mass.MassMartingaleTesting
+import Mathlib.MeasureTheory.Integral.DominatedConvergence
+import Mathlib.Topology.DenseEmbedding
+
+namespace OAI
+
+/-! Uniqueness of a continuous mass process from its integrable increasing
+variation and martingale difference. No second moment is imposed on a competing
+mass construction. -/
+
+noncomputable section
+open Set Filter MeasureTheory
+open scoped Topology NNReal
+
+namespace SLEExactGauge
+
+variable {Ω : Type*} [MeasurableSpace Ω] {P : Measure Ω} [IsFiniteMeasure P]
+  {ℱ : Filtration ℝ≥0 ‹MeasurableSpace Ω›} (A B : ℝ≥0 → Ω → ℝ)
+
+/-- A continuous martingale which is the difference of two increasing processes
+starting at zero vanishes, using only integrability of the two endpoint masses. -/
+theorem increasing_mass_martingale_eq_at
+    (hM : Martingale (fun t ω => A t ω-B t ω) ℱ P)
+    (hA : ∀ᵐ ω ∂P, Monotone (fun t => A t ω))
+    (hB : ∀ᵐ ω ∂P, Monotone (fun t => B t ω))
+    (hA0 : A 0 =ᵐ[P] 0) (hB0 : B 0 =ᵐ[P] 0)
+    (T : ℝ≥0) (hAI : Integrable (A T) P) (hBI : Integrable (B T) P)
+    (hcont : ∀ᵐ ω ∂P, ContinuousOn (fun t => A t ω-B t ω) (Icc 0 T)) :
+    A T =ᵐ[P] B T := by
+  let M : ℝ≥0 → Ω → ℝ := fun t ω => A t ω-B t ω
+  let X : ℕ → Ω → ℝ := fun n ω =>
+    massPartitionRemainder (fun i => M (massTimeMesh T n i) ω) (n+1)
+  have hXint (n : ℕ) : Integrable (X n) P := by
+    have hsum : Integrable (fun ω => ∑ i ∈ Finset.range (n+1),
+        massSeparationSlope (M (massTimeMesh T n i) ω)*
+          (M (massTimeMesh T n (i+1)) ω-M (massTimeMesh T n i) ω)) P :=
+      integrable_finsetSum _ (fun i _ =>
+        martingale_mass_weighted_increment_integrable hM _ _)
+    exact ((martingale_mass_test_integrable hM _).sub
+      (martingale_mass_test_integrable hM _)).sub hsum
+  have hXmean (n : ℕ) : (∫ ω, X n ω ∂P) = ∫ ω, massSeparationTest (M T ω) ∂P := by
+    have hsum (i : ℕ) := martingale_mass_weighted_increment_integrable hM
+      (massTimeMesh T n i) (massTimeMesh T n (i+1))
+    change (∫ ω, massSeparationTest (M (massTimeMesh T n (n+1)) ω)-
+      massSeparationTest (M (massTimeMesh T n 0) ω)-
+        ∑ i ∈ Finset.range (n+1), massSeparationSlope (M (massTimeMesh T n i) ω)*
+          (M (massTimeMesh T n (i+1)) ω-M (massTimeMesh T n i) ω) ∂P) = _
+    rw [massTimeMesh_end,massTimeMesh_zero,
+      integral_sub (f := fun ω => massSeparationTest (M T ω)-massSeparationTest (M 0 ω))
+        (g := fun ω => ∑ i ∈ Finset.range (n+1), massSeparationSlope (M (massTimeMesh T n i) ω)*
+          (M (massTimeMesh T n (i+1)) ω-M (massTimeMesh T n i) ω))
+        ((martingale_mass_test_integrable hM T).sub
+        (martingale_mass_test_integrable hM 0)) (integrable_finsetSum _ (fun i _ => hsum i)),
+      integral_sub (f := fun ω => massSeparationTest (M T ω))
+        (g := fun ω => massSeparationTest (M 0 ω))
+        (martingale_mass_test_integrable hM T) (martingale_mass_test_integrable hM 0),
+      integral_finsetSum _ (fun i _ => hsum i)]
+    have hzero : (fun ω => massSeparationTest (M 0 ω)) =ᵐ[P] 0 := by
+      filter_upwards [hA0,hB0] with ω ha hb
+      simp only [M,ha,hb,Pi.zero_apply,sub_self,massSeparationTest_zero]
+    have hmeans : (∑ i ∈ Finset.range (n+1), ∫ ω,
+        massSeparationSlope (M (massTimeMesh T n i) ω)*
+          (M (massTimeMesh T n (i+1)) ω-M (massTimeMesh T n i) ω) ∂P) = 0 := by
+      apply Finset.sum_eq_zero
+      intro i _
+      exact martingale_mass_weighted_increment_mean hM (massTimeMesh_mono T n (Nat.le_succ i))
+    simp only [M] at hmeans
+    rw [integral_congr_ae hzero,hmeans]
+    simp
+  have hbound (n : ℕ) : ∀ᵐ ω ∂P, ‖X n ω‖ ≤ 4*(A T ω+B T ω) := by
+    filter_upwards [hA,hB,hA0,hB0] with ω ha hb ha0 hb0
+    calc
+      _ ≤ 4*∑ i ∈ Finset.range (n+1),
+          |M (massTimeMesh T n (i+1)) ω-M (massTimeMesh T n i) ω| := by
+        simpa only [X,Real.norm_eq_abs] using massPartitionRemainder_linear
+          (fun i => M (massTimeMesh T n i) ω) (n+1)
+      _ ≤ 4*((A T ω-A 0 ω)+(B T ω-B 0 ω)) :=
+        mul_le_mul_of_nonneg_left (massDifference_mesh_variation
+          (fun t => A t ω) (fun t => B t ω) ha hb T n) (by norm_num)
+      _ = _ := by simp only [ha0,hb0,Pi.zero_apply,sub_zero]
+  have hlim : ∀ᵐ ω ∂P, Tendsto (fun n => X n ω) atTop (𝓝 0) := by
+    filter_upwards [hA,hB,hcont] with ω ha hb hc
+    exact massDifference_mesh_remainder_tendsto (fun t => A t ω) (fun t => B t ω) ha hb T hc
+  have hI := tendsto_integral_of_dominated_convergence (fun ω => 4*(A T ω+B T ω))
+    (fun n => (hXint n).aestronglyMeasurable) ((hAI.add hBI).const_mul 4) hbound hlim
+  simp only [integral_zero,hXmean] at hI
+  have htest0 : (∫ ω, massSeparationTest (M T ω) ∂P) = 0 :=
+    tendsto_nhds_unique tendsto_const_nhds hI
+  have hae := (integral_eq_zero_iff_of_nonneg
+    (fun ω => massSeparationTest_nonneg (M T ω))
+    (martingale_mass_test_integrable hM T)).mp htest0
+  filter_upwards [hae] with ω hω
+  exact sub_eq_zero.mp ((massSeparationTest_eq_zero (M T ω)).mp hω)
+
+/-- The fixed-time result holds simultaneously at every time by continuity and
+a countable dense family of deterministic times. -/
+theorem increasing_mass_martingale_indistinguishable
+    (hM : Martingale (fun t ω => A t ω-B t ω) ℱ P)
+    (hA : ∀ᵐ ω ∂P, Monotone (fun t => A t ω))
+    (hB : ∀ᵐ ω ∂P, Monotone (fun t => B t ω))
+    (hA0 : A 0 =ᵐ[P] 0) (hB0 : B 0 =ᵐ[P] 0)
+    (hAI : ∀ T, Integrable (A T) P) (hBI : ∀ T, Integrable (B T) P)
+    (hcont : ∀ᵐ ω ∂P, Continuous (fun t => A t ω-B t ω)) :
+    ∀ᵐ ω ∂P, ∀ t, A t ω = B t ω := by
+  have heq (t : ℝ≥0) : A t =ᵐ[P] B t :=
+    increasing_mass_martingale_eq_at A B hM hA hB hA0 hB0 t (hAI t) (hBI t)
+      (hcont.mono (fun _ h => h.continuousOn))
+  have hcount : ∀ᵐ ω ∂P, ∀ n : ℕ,
+      A (TopologicalSpace.denseSeq ℝ≥0 n) ω = B (TopologicalSpace.denseSeq ℝ≥0 n) ω :=
+    ae_all_iff.mpr (fun n => heq _)
+  filter_upwards [hcount,hcont] with ω he hc
+  have hfun : (fun t => A t ω-B t ω) = fun _ => 0 :=
+    (TopologicalSpace.denseRange_denseSeq ℝ≥0).equalizer hc continuous_const
+      (funext (fun n => sub_eq_zero.mpr (he n)))
+  intro t
+  exact sub_eq_zero.mp (congr_fun hfun t)
+
+end SLEExactGauge
+
+end
+
+end OAI

lean/OAI/Probability/SLE/Mass/MassPotentialCompensator.lean

@@ -0,0 +1,57 @@
+import OAI.Probability.SLE.Mass.MassCompensatorVariance
+
+namespace OAI
+
+/-! A remaining-mass potential determines the predictable mass increments. -/
+
+noncomputable section
+open Set Filter MeasureTheory ProbabilityTheory
+open scoped Topology NNReal ENNReal
+
+namespace SLEExactGauge
+
+variable {Ω : Type*} [mΩ : MeasurableSpace Ω] (P : Measure Ω) [IsProbabilityMeasure P]
+
+/-- The difference of the current potential and the one-step averaged
+future potential is the conditional expectation of the mass increment. -/
+theorem remainingPotential_increment
+    (ℱ : Filtration ℕ mΩ) (A V : ℕ → Ω → ℝ) (L : Ω → ℝ)
+    (hA : StronglyAdapted ℱ A) (hAI : ∀ i, Integrable (A i) P) (hLI : Integrable L P)
+    (hV : ∀ i, V i =ᵐ[P] P[L-A i|ℱ i]) (i : ℕ) :
+    V i-P[V (i+1)|ℱ i] =ᵐ[P] P[A (i+1)-A i|ℱ i] := by
+  have hnext := (condExp_congr_ae (m := ℱ i) (hV (i+1))).trans
+    (condExp_condExp_of_le (ℱ.mono (Nat.le_succ i)) (ℱ.le (i+1)))
+  have hcur := (hV i).trans (condExp_sub hLI (hAI i) (ℱ i))
+  have hnext' := hnext.trans (condExp_sub hLI (hAI (i+1)) (ℱ i))
+  have hinc := condExp_sub (hAI (i+1)) (hAI i) (ℱ i)
+  have hz := condExp_of_stronglyMeasurable (ℱ.le i) (hA i) (hAI i)
+  filter_upwards [hcur,hnext',hinc] with ω hc hn hi
+  simp only [Pi.sub_apply,hz] at hc hn hi ⊢
+  linarith
+
+omit [IsProbabilityMeasure P] in
+/-- Pathwise telescoping after identifying each predictable increment. -/
+lemma predictable_mass_sum_eq
+    (ℱ : Filtration ℕ mΩ) (A : ℕ → Ω → ℝ)
+    (q : ℕ → Ω → ℝ)
+    (hq : ∀ i, q i =ᵐ[P] P[A (i+1)-A i|ℱ i]) (N : ℕ) :
+    (fun ω => ∑ i ∈ Finset.range N, q i ω) =ᵐ[P]
+      fun ω => A N ω-A 0 ω-centeredMassPartialSum P ℱ
+        (fun i => A (i+1)-A i) N ω := by
+  filter_upwards [ae_all_iff.mpr hq] with ω hω
+  simp only [centeredMassPartialSum,Pi.sub_apply]
+  have hs := Finset.sum_sub_distrib (s := Finset.range N)
+    (f := fun i => A (i+1) ω-A i ω)
+    (g := fun i => condExp (ℱ i) P (A (i+1)-A i) ω)
+  rw [Finset.sum_range_sub (fun i => A i ω) N] at hs
+  have hq' : (∑ i ∈ Finset.range N, q i ω) =
+      ∑ i ∈ Finset.range N, condExp (ℱ i) P (A (i+1)-A i) ω :=
+    Finset.sum_congr rfl (fun i _ => hω i)
+  rw [hq']
+  linarith
+
+end SLEExactGauge
+
+end
+
+end OAI

lean/OAI/Probability/SLE/Mass/MassUniquenessMesh.lean

@@ -0,0 +1,81 @@
+import OAI.Probability.SLE.Mass.MassUniquenessPartitions
+import Mathlib.Topology.Instances.NNReal.Lemmas
+import Mathlib.Topology.UniformSpace.HeineCantor
+
+namespace OAI
+
+/-! Uniform finite time partitions used in the continuous-mass uniqueness proof. -/
+
+noncomputable section
+open Set Filter
+open scoped Topology NNReal
+
+namespace SLEExactGauge
+
+def massTimeMesh (T : ℝ≥0) (n i : ℕ) : ℝ≥0 := T*(i:ℝ≥0)/(n+1:ℝ≥0)
+
+@[simp] lemma massTimeMesh_zero (T : ℝ≥0) (n : ℕ) : massTimeMesh T n 0 = 0 := by
+  simp [massTimeMesh]
+
+@[simp] lemma massTimeMesh_end (T : ℝ≥0) (n : ℕ) : massTimeMesh T n (n+1) = T := by
+  simp [massTimeMesh]
+
+lemma massTimeMesh_mono (T : ℝ≥0) (n : ℕ) : Monotone (massTimeMesh T n) := by
+  intro i j hij
+  exact div_le_div_of_nonneg_right
+    (mul_le_mul_of_nonneg_left (by exact_mod_cast hij) (show 0 ≤ T from zero_le))
+    (by positivity)
+
+lemma massTimeMesh_mem (T : ℝ≥0) (n i : ℕ) (hi : i ≤ n+1) :
+    massTimeMesh T n i ∈ Icc 0 T := by
+  exact ⟨zero_le,(massTimeMesh_mono T n hi).trans_eq (massTimeMesh_end T n)⟩
+
+lemma massTimeMesh_dist (T : ℝ≥0) (n i : ℕ) :
+    dist (massTimeMesh T n (i+1)) (massTimeMesh T n i) = (T:ℝ)/(n+1:ℝ) := by
+  rw [NNReal.dist_eq]
+  simp only [massTimeMesh,NNReal.coe_div,NNReal.coe_mul,NNReal.coe_natCast,NNReal.coe_add,
+    NNReal.coe_one,Nat.cast_add,Nat.cast_one]
+  rw [show (T:ℝ)*(i+1:ℝ)/(n+1)-(T:ℝ)*(i:ℝ)/(n+1) = T/(n+1) by ring,
+    abs_of_nonneg (by positivity)]
+
+lemma massTimeMesh_small_increments (T : ℝ≥0) (f : ℝ≥0 → ℝ)
+    (hf : ContinuousOn f (Icc 0 T)) :
+    ∀ ε : ℝ, 0 < ε → ∀ᶠ n in atTop,
+      ∀ i < n+1, |f (massTimeMesh T n (i+1))-f (massTimeMesh T n i)| ≤ ε := by
+  intro ε hε
+  obtain ⟨δ,hδ,hfδ⟩ := Metric.uniformContinuousOn_iff.mp
+    (isCompact_Icc.uniformContinuousOn_of_continuous hf) ε hε
+  have hlim : Tendsto (fun n : ℕ => (T:ℝ)/(n+1:ℝ)) atTop (𝓝 0) := by
+    simpa only [mul_one_div,mul_zero] using
+      (tendsto_one_div_add_atTop_nhds_zero_nat (𝕜 := ℝ)).const_mul (T:ℝ)
+  filter_upwards [hlim.eventually (gt_mem_nhds hδ)] with n hn i hi
+  have h := hfδ (massTimeMesh T n (i+1)) (massTimeMesh_mem T n (i+1) (by omega))
+    (massTimeMesh T n i) (massTimeMesh_mem T n i (by omega))
+    (by simpa only [massTimeMesh_dist] using hn)
+  exact le_of_lt (by simpa only [Real.dist_eq] using h)
+
+lemma massDifference_mesh_variation (A B : ℝ≥0 → ℝ)
+    (hA : Monotone A) (hB : Monotone B) (T : ℝ≥0) (n : ℕ) :
+    (∑ i ∈ Finset.range (n+1),
+      |(A (massTimeMesh T n (i+1))-B (massTimeMesh T n (i+1)))-
+        (A (massTimeMesh T n i)-B (massTimeMesh T n i))|) ≤
+      (A T-A 0)+(B T-B 0) := by
+  simpa only [Function.comp_def,massTimeMesh_zero,massTimeMesh_end] using
+    massDifference_partition_variation (A ∘ massTimeMesh T n) (B ∘ massTimeMesh T n)
+      (hA.comp (massTimeMesh_mono T n)) (hB.comp (massTimeMesh_mono T n)) (n+1)
+
+lemma massDifference_mesh_remainder_tendsto (A B : ℝ≥0 → ℝ)
+    (hA : Monotone A) (hB : Monotone B) (T : ℝ≥0)
+    (hcont : ContinuousOn (fun t => A t-B t) (Icc 0 T)) :
+    Tendsto (fun n => massPartitionRemainder
+      (fun i => A (massTimeMesh T n i)-B (massTimeMesh T n i)) (n+1)) atTop (𝓝 0) := by
+  exact massPartitionRemainder_tendsto_zero _ _ ((A T-A 0)+(B T-B 0))
+    (add_nonneg (sub_nonneg.mpr (hA zero_le)) (sub_nonneg.mpr (hB zero_le)))
+    (massDifference_mesh_variation A B hA hB T)
+    (massTimeMesh_small_increments T _ hcont)
+
+end SLEExactGauge
+
+end
+
+end OAI

lean/OAI/Probability/SLE/Mass/MassUniquenessPartitions.lean

@@ -0,0 +1,87 @@
+import OAI.Probability.SLE.Mass.MassUniquenessSeparation
+import Mathlib.Analysis.SpecificLimits.Basic
+
+namespace OAI
+
+/-! Finite-variation estimates for the smooth separator on time partitions. -/
+
+noncomputable section
+open Set Filter
+open scoped Topology NNReal
+
+namespace SLEExactGauge
+
+def massPartitionRemainder (x : ℕ → ℝ) (N : ℕ) : ℝ :=
+  massSeparationTest (x N)-massSeparationTest (x 0) -
+    ∑ i ∈ Finset.range N, massSeparationSlope (x i)*(x (i+1)-x i)
+
+lemma massPartitionRemainder_eq_sum (x : ℕ → ℝ) (N : ℕ) :
+    massPartitionRemainder x N = ∑ i ∈ Finset.range N,
+      (massSeparationTest (x (i+1))-massSeparationTest (x i)-
+        massSeparationSlope (x i)*(x (i+1)-x i)) := by
+  rw [Finset.sum_sub_distrib,
+    Finset.sum_range_sub (fun i => massSeparationTest (x i)) N]
+  rfl
+
+lemma massPartitionRemainder_linear (x : ℕ → ℝ) (N : ℕ) :
+    |massPartitionRemainder x N| ≤ 4*∑ i ∈ Finset.range N, |x (i+1)-x i| := by
+  rw [massPartitionRemainder_eq_sum,Finset.mul_sum]
+  exact (Finset.abs_sum_le_sum_abs _ _).trans
+    (Finset.sum_le_sum (fun i _ => massSeparationTest_remainder_linear (x i) (x (i+1))))
+
+lemma massPartitionRemainder_small (x : ℕ → ℝ) (N : ℕ) {ε : ℝ}
+    (hx : ∀ i < N, |x (i+1)-x i| ≤ ε) :
+    |massPartitionRemainder x N| ≤ (8*ε)*∑ i ∈ Finset.range N, |x (i+1)-x i| := by
+  rw [massPartitionRemainder_eq_sum,Finset.mul_sum]
+  apply (Finset.abs_sum_le_sum_abs _ _).trans
+  apply Finset.sum_le_sum
+  intro i hi
+  exact (massSeparationTest_remainder_le (x i) (x (i+1))).trans (by
+    rw [pow_two,mul_assoc]
+    exact mul_le_mul_of_nonneg_left
+      (mul_le_mul_of_nonneg_right (hx i (Finset.mem_range.mp hi)) (abs_nonneg _)) (by norm_num))
+
+lemma massDifference_partition_variation (A B : ℕ → ℝ)
+    (hA : Monotone A) (hB : Monotone B) (N : ℕ) :
+    (∑ i ∈ Finset.range N, |(A (i+1)-B (i+1))-(A i-B i)|) ≤
+      (A N-A 0)+(B N-B 0) := by
+  calc
+    _ ≤ ∑ i ∈ Finset.range N, ((A (i+1)-A i)+(B (i+1)-B i)) := by
+      apply Finset.sum_le_sum
+      intro i _
+      have hAi : 0 ≤ A (i+1)-A i := sub_nonneg.mpr (hA (Nat.le_succ i))
+      have hBi : 0 ≤ B (i+1)-B i := sub_nonneg.mpr (hB (Nat.le_succ i))
+      calc
+        _ = |(A (i+1)-A i)-(B (i+1)-B i)| := by congr 1; ring
+        _ ≤ |A (i+1)-A i|+|B (i+1)-B i| := abs_sub _ _
+        _ = _ := by rw [abs_of_nonneg hAi,abs_of_nonneg hBi]
+    _ = _ := by rw [Finset.sum_add_distrib,Finset.sum_range_sub,Finset.sum_range_sub]
+
+lemma massPartitionRemainder_tendsto_zero
+    (x : ℕ → ℕ → ℝ) (N : ℕ → ℕ) (D : ℝ) (hD : 0 ≤ D)
+    (hvar : ∀ n, (∑ i ∈ Finset.range (N n), |x n (i+1)-x n i|) ≤ D)
+    (hsmall : ∀ ε : ℝ, 0 < ε → ∀ᶠ n in atTop, ∀ i < N n, |x n (i+1)-x n i| ≤ ε) :
+    Tendsto (fun n => massPartitionRemainder (x n) (N n)) atTop (𝓝 0) := by
+  apply Metric.tendsto_atTop.mpr
+  intro ε hε
+  let η := ε/(16*(D+1))
+  have hη : 0 < η := div_pos hε (by positivity)
+  obtain ⟨n₀,hn₀⟩ := eventually_atTop.mp (hsmall η hη)
+  refine ⟨n₀,fun n hn => ?_⟩
+  rw [Real.dist_eq,sub_zero]
+  calc
+    _ ≤ (8*η)*∑ i ∈ Finset.range (N n), |x n (i+1)-x n i| :=
+      massPartitionRemainder_small (x n) (N n) (hn₀ n hn)
+    _ ≤ (8*η)*D := mul_le_mul_of_nonneg_left (hvar n) (by positivity)
+    _ < ε := by
+      dsimp only [η]
+      have hpos : 0 < D+1 := by linarith
+      rw [show 8*(ε/(16*(D+1)))*D = (8*ε*D)/(16*(D+1)) by ring]
+      apply (div_lt_iff₀ (by positivity : 0 < 16*(D+1))).mpr
+      nlinarith
+
+end SLEExactGauge
+
+end
+
+end OAI

lean/OAI/Probability/SLE/Mass/MassUniquenessSeparation.lean

@@ -0,0 +1,124 @@
+import Mathlib.Analysis.Calculus.MeanValue
+import Mathlib.Analysis.Calculus.Deriv.Pow
+import Mathlib.Analysis.Calculus.Deriv.Inv
+import Mathlib.Analysis.SpecialFunctions.Pow.Real
+
+namespace OAI
+
+/-! A bounded smooth test detecting a nonzero continuous finite-variation
+martingale. Its bounded derivatives permit an integrable-variation argument. -/
+
+noncomputable section
+open Set
+open scoped Topology
+
+namespace SLEExactGauge
+
+def massSeparationTest (x : ℝ) : ℝ := x^2 / (1+x^2)
+def massSeparationSlope (x : ℝ) : ℝ := 2*x / (1+x^2)^2
+
+theorem massSeparationTest_nonneg (x : ℝ) : 0 ≤ massSeparationTest x := by
+  unfold massSeparationTest
+  positivity
+
+@[simp] theorem massSeparationTest_zero : massSeparationTest 0 = 0 := by
+  norm_num [massSeparationTest]
+
+@[simp] theorem massSeparationTest_eq_zero (x : ℝ) : massSeparationTest x = 0 ↔ x = 0 := by
+  have hp : 0 < 1+x^2 := by positivity
+  simp only [massSeparationTest,div_eq_zero_iff,hp.ne',or_false,pow_eq_zero_iff (by decide : (2:ℕ) ≠ 0)]
+
+theorem massSeparationTest_hasDerivAt (x : ℝ) :
+    HasDerivAt massSeparationTest (massSeparationSlope x) x := by
+  have hd := ((hasDerivAt_id x).pow 2).div
+    ((hasDerivAt_const x 1).add ((hasDerivAt_id x).pow 2)) (by positivity : 1+x^2 ≠ 0)
+  convert hd using 1
+  · rfl
+  · dsimp only [massSeparationSlope,id_eq,Pi.pow_apply,Pi.add_apply,Pi.div_apply]
+    field_simp
+    ring
+
+theorem massSeparationSlope_hasDerivAt (x : ℝ) :
+    HasDerivAt massSeparationSlope ((2-6*x^2)/(1+x^2)^3) x := by
+  have hd := ((hasDerivAt_id x).const_mul 2).div
+    (((hasDerivAt_const x 1).add ((hasDerivAt_id x).pow 2)).pow 2)
+    (by positivity : (1+x^2)^2 ≠ 0)
+  convert hd using 1
+  · rfl
+  · dsimp only [id_eq,Pi.pow_apply,Pi.add_apply,Pi.div_apply]
+    field_simp
+    ring
+
+theorem massSeparationSlope_abs_le (x : ℝ) : |massSeparationSlope x| ≤ 2 := by
+  have hy : 0 ≤ x^2 := sq_nonneg x
+  have hx : |x| ≤ 1+x^2 := by
+    nlinarith [sq_nonneg (|x|-1),sq_abs x]
+  have hp : 0 < 1+x^2 := by positivity
+  rw [massSeparationSlope,abs_div,abs_mul,abs_of_pos (sq_pos_of_pos hp)]
+  norm_num only [abs_of_pos (by norm_num : (0:ℝ)<2)]
+  apply (div_le_iff₀ (sq_pos_of_pos hp)).mpr
+  nlinarith [sq_nonneg (x^2)]
+
+theorem massSeparationSlope_deriv_abs_le (x : ℝ) :
+    |(2-6*x^2)/(1+x^2)^3| ≤ 8 := by
+  have hp : 0 < 1+x^2 := by positivity
+  rw [abs_div,abs_of_pos (pow_pos hp 3)]
+  apply (div_le_iff₀ (pow_pos hp 3)).mpr
+  have hn : |2-6*x^2| ≤ 2+6*x^2 := by
+    have hh := abs_sub (2:ℝ) (6*x^2)
+    norm_num [abs_mul,abs_of_nonneg (sq_nonneg x)] at hh ⊢
+    exact hh
+  have hb : 2+6*x^2 ≤ 8*(1+x^2)^3 := by
+    nlinarith [sq_nonneg (x^2),pow_nonneg (sq_nonneg x) 3]
+  exact hn.trans hb
+
+theorem massSeparationTest_lipschitz (x y : ℝ) :
+    |massSeparationTest y-massSeparationTest x| ≤ 2*|y-x| := by
+  have h := Convex.norm_image_sub_le_of_norm_deriv_le
+    (s := (univ:Set ℝ)) (f := massSeparationTest) (C := 2) (x := x) (y := y)
+    (fun z _ => (massSeparationTest_hasDerivAt z).differentiableAt)
+    (fun z _ => by simpa only [(massSeparationTest_hasDerivAt z).deriv,Real.norm_eq_abs]
+      using massSeparationSlope_abs_le z) convex_univ (mem_univ x) (mem_univ y)
+  simpa only [Real.norm_eq_abs] using h
+
+theorem massSeparationSlope_lipschitz (x y : ℝ) :
+    |massSeparationSlope y-massSeparationSlope x| ≤ 8*|y-x| := by
+  have h := Convex.norm_image_sub_le_of_norm_deriv_le
+    (s := (univ:Set ℝ)) (f := massSeparationSlope) (C := 8) (x := x) (y := y)
+    (fun z _ => (massSeparationSlope_hasDerivAt z).differentiableAt)
+    (fun z _ => by simpa only [(massSeparationSlope_hasDerivAt z).deriv,Real.norm_eq_abs]
+      using massSeparationSlope_deriv_abs_le z) convex_univ (mem_univ x) (mem_univ y)
+  simpa only [Real.norm_eq_abs] using h
+
+theorem massSeparationTest_remainder_le (x y : ℝ) :
+    |massSeparationTest y-massSeparationTest x-massSeparationSlope x*(y-x)| ≤ 8*|y-x|^2 := by
+  let f (z : ℝ) := massSeparationTest z-massSeparationTest x-massSeparationSlope x*(z-x)
+  have hd (z : ℝ) : HasDerivAt f (massSeparationSlope z-massSeparationSlope x) z := by
+    convert ((massSeparationTest_hasDerivAt z).sub_const
+      (massSeparationTest x)).sub (((hasDerivAt_id z).sub_const x).const_mul (massSeparationSlope x)) using 1
+    · rfl
+    · ring
+  have h := Convex.norm_image_sub_le_of_norm_deriv_le
+    (s := Metric.closedBall x |y-x|) (f := f) (C := 8*|y-x|) (x := x) (y := y)
+    (fun z _ => (hd z).differentiableAt)
+    (fun z hz => by
+      rw [(hd z).deriv,Real.norm_eq_abs]
+      exact (massSeparationSlope_lipschitz x z).trans
+        (mul_le_mul_of_nonneg_left (by simpa only [Metric.mem_closedBall,Real.dist_eq] using hz) (by norm_num)))
+    (convex_closedBall x _) (Metric.mem_closedBall_self (abs_nonneg _))
+    (by simp only [Metric.mem_closedBall,Real.dist_eq,le_refl])
+  simpa only [f,sub_self,mul_zero,sub_zero,Real.norm_eq_abs,pow_two,mul_assoc] using h
+
+theorem massSeparationTest_remainder_linear (x y : ℝ) :
+    |massSeparationTest y-massSeparationTest x-massSeparationSlope x*(y-x)| ≤ 4*|y-x| := by
+  calc
+    _ ≤ |massSeparationTest y-massSeparationTest x|+|massSeparationSlope x*(y-x)| := abs_sub _ _
+    _ ≤ 2*|y-x|+2*|y-x| := add_le_add (massSeparationTest_lipschitz x y)
+      (by rw [abs_mul]; exact mul_le_mul_of_nonneg_right (massSeparationSlope_abs_le x) (abs_nonneg _))
+    _ = _ := by ring
+
+end SLEExactGauge
+
+end
+
+end OAI

lean/OAI/Probability/SLE/Mass/MomentLevels.lean

@@ -0,0 +1,77 @@
+import OAI.Probability.SLE.MomentGauge
+
+namespace OAI
+
+/-!
+The prescribed retained level in the first paper's moment-batch construction.
+Its definition counts bad positive integer levels. Monotonicity makes those
+levels an initial segment, so one plus their cardinal is a good level.
+The moment convergence hypotheses here are explicit internal proof inputs.
+-/
+
+noncomputable section
+open Set Filter
+open scoped Topology
+
+namespace SLEExactGauge.Target
+
+theorem batchLevel_ge_one (κ : ℝ) (W : WienerLaw) (n : ℕ) :
+    1 ≤ batchLevel κ W n := by
+  unfold batchLevel
+  omega
+
+theorem finite_bad_moment_levels (κ : ℝ) (W : WienerLaw) (n : ℕ)
+    (hm : 0 < moment κ W n)
+    (hlim : Tendsto (fun j : ℕ => finiteMoment κ W n j) atTop (𝓝 (moment κ W n))) :
+    {j : ℕ | 1 ≤ j ∧ finiteMoment κ W n j ≤ 3 * moment κ W n / 4}.Finite := by
+  have hlt : 3 * moment κ W n / 4 < moment κ W n := by linarith
+  have hevent : ∀ᶠ j : ℕ in atTop, 3 * moment κ W n / 4 < finiteMoment κ W n j :=
+    (tendsto_order.mp hlim).1 _ hlt
+  obtain ⟨N, hN⟩ := eventually_atTop.mp hevent
+  apply (finite_Iio N).subset
+  intro j hj
+  show j < N
+  by_contra hjN
+  exact (not_le_of_gt (hN j (le_of_not_gt hjN))) hj.2
+
+/-- The actual `Target.batchLevel`, not a separately chosen large level,
+retains more than three quarters of the limiting moment. -/
+theorem finiteMoment_batchLevel_gt (κ : ℝ) (W : WienerLaw) (n : ℕ)
+    (hmono : Monotone (fun j : ℕ => finiteMoment κ W n j))
+    (hm : 0 < moment κ W n)
+    (hlim : Tendsto (fun j : ℕ => finiteMoment κ W n j) atTop (𝓝 (moment κ W n))) :
+    3 * moment κ W n / 4 < finiteMoment κ W n (batchLevel κ W n) := by
+  classical
+  let B := {j : ℕ // 1 ≤ j ∧ finiteMoment κ W n j ≤ 3 * moment κ W n / 4}
+  let : Finite B := (finite_bad_moment_levels κ W n hm hlim).to_subtype
+  by_contra hbad
+  have hbad' : finiteMoment κ W n (batchLevel κ W n) ≤ 3 * moment κ W n / 4 :=
+    le_of_not_gt hbad
+  let f : Fin (batchLevel κ W n) → B := fun j =>
+    ⟨(j : ℕ) + 1, by
+      refine ⟨by omega, ?_⟩
+      exact (hmono (Nat.succ_le_of_lt j.isLt)).trans hbad'⟩
+  have hinj : Function.Injective f := by
+    intro i j hij
+    apply Fin.ext
+    have hval := congrArg Subtype.val hij
+    dsimp only [f] at hval
+    omega
+  have hcard := Nat.card_le_card_of_injective f hinj
+  rw [Nat.card_fin] at hcard
+  change 1 + Nat.card B ≤ Nat.card B at hcard
+  omega
+
+theorem batchLevel_retains_moment (κ : ℝ) (W : WienerLaw) (n : ℕ)
+    (hmono : Monotone (fun j : ℕ => finiteMoment κ W n j))
+    (hm : 0 < moment κ W n)
+    (hlim : Tendsto (fun j : ℕ => finiteMoment κ W n j) atTop (𝓝 (moment κ W n))) :
+    1 ≤ batchLevel κ W n ∧
+      3 * moment κ W n / 4 < finiteMoment κ W n (batchLevel κ W n) :=
+  ⟨batchLevel_ge_one κ W n, finiteMoment_batchLevel_gt κ W n hmono hm hlim⟩
+
+end SLEExactGauge.Target
+
+end
+
+end OAI

lean/OAI/Probability/SLE/Mass/MonotoneMassExhaustion.lean

@@ -0,0 +1,33 @@
+import Mathlib.MeasureTheory.Integral.Lebesgue.DominatedConvergence
+import Mathlib.Topology.Order.MonotoneConvergence
+
+namespace OAI
+
+/-! Nonnegative decreasing remaining masses vanish almost surely when
+their expectations tend to zero. -/
+
+noncomputable section
+open Set Filter MeasureTheory
+open scoped ENNReal Topology
+
+namespace SLEExactGauge
+
+theorem ae_tendsto_zero_of_antitone_lintegral
+    {Ω : Type*} [MeasurableSpace Ω] (P : Measure Ω) (f : ℕ → Ω → ℝ≥0∞)
+    (hf : ∀ n, Measurable (f n)) (hanti : ∀ᵐ ω ∂P, Antitone (fun n => f n ω))
+    (hmean : Tendsto (fun n => ∫⁻ ω, f n ω ∂P) atTop (𝓝 0)) :
+    ∀ᵐ ω ∂P, Tendsto (fun n => f n ω) atTop (𝓝 0) := by
+  have hi : (∫⁻ ω, liminf (fun n => f n ω) atTop ∂P) = 0 := by
+    apply le_zero_iff.mp
+    exact (lintegral_liminf_le hf).trans_eq hmean.liminf_eq
+  have hz := (lintegral_eq_zero_iff (Measurable.liminf hf)).mp hi
+  filter_upwards [hanti,hz] with ω ha hz
+  have ht := tendsto_atTop_iInf ha
+  have he : (⨅ n, f n ω) = 0 := ht.liminf_eq.symm.trans hz
+  rwa [he] at ht
+
+end SLEExactGauge
+
+end
+
+end OAI

lean/OAI/Probability/SLE/Mass/NonnegativeL2Passage.lean

@@ -0,0 +1,56 @@
+import OAI.Probability.SLE.ExponentialMartingales
+
+namespace OAI
+
+/-! Uniform second moments of terminal tests also control every smaller
+nonnegative test, including tests evaluated at random times. -/
+
+noncomputable section
+open Set Filter MeasureTheory
+open scoped ENNReal Topology
+
+namespace SLEExactGauge
+
+lemma memLp_two_of_nonnegative_square_bound
+    {Ω : Type*} [MeasurableSpace Ω] (P : Measure Ω) (X : Ω → ℝ)
+    (hm : Measurable X) (hX : ∀ ω, 0 ≤ X ω)
+    (M : ℝ≥0∞) (hM : M < ∞)
+    (hb : (∫⁻ ω, ENNReal.ofReal (X ω)^2 ∂P) ≤ M) :
+    MemLp X 2 P ∧ (∫ ω, X ω^2 ∂P) ≤ M.toReal := by
+  have hi : Integrable (fun ω => X ω^2) P := by
+    refine ⟨(hm.pow_const 2).aestronglyMeasurable,?_⟩
+    apply (hasFiniteIntegral_iff_ofReal (ae_of_all _ (fun ω => sq_nonneg (X ω)))).mpr
+    simpa only [ENNReal.ofReal_pow (hX _)] using hb.trans_lt hM
+  have hmem := (memLp_two_iff_integrable_sq hm.aestronglyMeasurable).mpr hi
+  refine ⟨hmem,?_⟩
+  have he : ENNReal.ofReal (∫ ω, X ω^2 ∂P) ≤ M := by
+    rw [ofReal_integral_eq_lintegral_ofReal hi (ae_of_all _ (fun ω => sq_nonneg (X ω)))]
+    simpa only [ENNReal.ofReal_pow (hX _)] using hb
+  have ht := ENNReal.toReal_mono hM.ne he
+  rwa [ENNReal.toReal_ofReal (integral_nonneg (fun ω => sq_nonneg (X ω)))] at ht
+
+theorem integral_tendsto_of_nonnegative_L2_domination
+    {Ω : Type*} [MeasurableSpace Ω] (P : Measure Ω) [IsFiniteMeasure P]
+    (X Z : ℕ → Ω → ℝ) (Y : Ω → ℝ)
+    (hXm : ∀ n, Measurable (X n)) (hX0 : ∀ n ω, 0 ≤ X n ω)
+    (hXZ : ∀ n ω, X n ω ≤ Z n ω) (hZ : ∀ n, MemLp (Z n) 2 P)
+    (A : ℝ) (hA : ∀ n, (∫ ω, Z n ω^2 ∂P) ≤ A)
+    (hlim : ∀ᵐ ω ∂P, Tendsto (fun n => X n ω) atTop (𝓝 (Y ω))) :
+    Integrable Y P ∧
+      Tendsto (fun n => ∫ ω, X n ω ∂P) atTop (𝓝 (∫ ω, Y ω ∂P)) := by
+  have hX (n : ℕ) : MemLp (X n) 2 P :=
+    (hZ n).mono' (hXm n).aestronglyMeasurable
+      (ae_of_all _ (fun ω => by simpa only [Real.norm_of_nonneg (hX0 n ω)] using hXZ n ω))
+  have hsq (n : ℕ) : (∫ ω, X n ω^2 ∂P) ≤ A := by
+    apply (integral_mono (hX n).integrable_sq (hZ n).integrable_sq ?_).trans (hA n)
+    intro ω
+    exact pow_le_pow_left₀ (hX0 n ω) (hXZ n ω) 2
+  obtain ⟨hY,hL1⟩ := finite_L1_tendsto_of_square_bound hX A hsq hlim
+  exact ⟨hY,tendsto_integral_of_L1' Y
+    (Eventually.of_forall (fun n => (hX n).integrable (by norm_num))) hL1⟩
+
+end SLEExactGauge
+
+end
+
+end OAI

lean/OAI/Probability/SLE/Mass/NormalizedDiskCompensator.lean

@@ -0,0 +1,92 @@
+import OAI.Probability.SLE.Geometry.CanonicalNormalizedPotential
+import OAI.Probability.SLE.Mass.CanonicalMassCompensator
+
+namespace OAI
+
+/-! Recovery of the actual canonical disk mass on the exact target
+Brownian-time dyadic grid. -/
+
+noncomputable section
+open Set Filter _root_.MeasureTheory _root_.OAI.MeasureTheory ProbabilityTheory
+open scoped Topology NNReal ENNReal
+
+namespace SLEExactGauge.Multipoint.CanonicalMass
+
+variable {Ω : Type*} [mΩ : MeasurableSpace Ω] {P : Measure Ω}
+  {κ : ℝ}
+  {B : ℝ≥0 → Ω → ℝ} {hBm : Measurable (Function.uncurry B)}
+  {γ : Ω → ℝ≥0 → ℂ} {G : Ω → ℝ≥0 → ℂ → ℂ}
+  (C : CanonicalMass P κ B hBm γ G)
+
+def normalizedDiskScalar (θ : ℝ) (hθ : θ ∈ Ioo (0:ℝ) Real.pi)
+    (t : ℝ≥0) (ω : Ω) : ℝ := C.diskScalar θ hθ (t/κ.toNNReal) ω
+
+lemma normalizedDiskScalar_measurable (θ : ℝ) (hθ : θ ∈ Ioo (0:ℝ) Real.pi)
+    (t : ℝ≥0) : Measurable (C.normalizedDiskScalar θ hθ t) :=
+  (compactWeightedMass_measurable _ _
+    (Target.diskSourceHalfPlane_compact hθ).measurableSet).comp
+      C.progressive.adapted.measurable
+
+lemma normalizedDiskScalar_integrable (θ : ℝ) (hθ : θ ∈ Ioo (0:ℝ) Real.pi)
+    (t : ℝ≥0) : Integrable (C.normalizedDiskScalar θ hθ t) P := by
+  exact (compactWeightedMass_kernel_integrable P κ (C.process (t/κ.toNNReal))
+    C.progressive.adapted.measurable
+    (by simpa only [Measure.restrict_univ] using
+      C.uniqueness_process_mean_le (t/κ.toNNReal) univ)
+    _ _ (Target.diskSourceHalfPlane_compact hθ)).1
+
+lemma normalizedDiskScalar_stronglyAdapted (hκ : 0<κ)
+    (hc : ∀ ω, Continuous (fun t => B t ω)) (h0 : ∀ ω, B 0 ω=0)
+    (θ : ℝ) (hθ : θ ∈ Ioo (0:ℝ) Real.pi) :
+    StronglyAdapted (Target.normalizedFiltration κ B
+      (fun r => (hBm.comp (measurable_const.prodMk measurable_id) : Measurable (B r))) hc h0)
+      (C.normalizedDiskScalar θ hθ) := by
+  intro t
+  erw [Target.normalizedFiltration_at κ hκ]
+  exact ((compactWeightedMass_measurable _ _
+    (Target.diskSourceHalfPlane_compact hθ).measurableSet).comp
+      (C.progressive.adapted (t/κ.toNNReal))).stronglyMeasurable
+
+theorem normalizedDiskScalar_paths (hκ : 0<κ)
+    (θ : ℝ) (hθ : θ ∈ Ioo (0:ℝ) Real.pi) :
+    ∀ᵐ ω ∂P, Monotone (fun t => C.normalizedDiskScalar θ hθ t ω) ∧
+      C.normalizedDiskScalar θ hθ 0 ω=0 ∧
+      Continuous (fun t => C.normalizedDiskScalar θ hθ t ω) ∧
+      Tendsto (fun t => C.normalizedDiskScalar θ hθ t ω) atTop
+        (𝓝 (C.diskTerminalScalar θ hθ ω)) ∧
+      ∀ t, C.normalizedDiskScalar θ hθ t ω ≤ C.diskTerminalScalar θ hθ ω := by
+  filter_upwards [C.compactWeightedMass_paths (Target.diskMassWeight κ θ hθ)
+    (Target.diskSourceHalfPlane θ) (Target.diskSourceHalfPlane_compact hθ)] with ω hω
+  refine ⟨?_,?_,hω.2.2.1.comp (continuous_id.div_const _),?_,fun t => hω.2.2.2.2 _⟩
+  · intro s t hst
+    exact hω.1 (div_le_div_of_nonneg_right hst zero_le)
+  · simpa only [normalizedDiskScalar,diskScalar,zero_div] using hω.2.1
+  · exact hω.2.2.2.1.comp
+      ((tendsto_div_const_atTop_of_pos (Real.toNNReal_pos.mpr hκ)).mpr tendsto_id)
+
+theorem normalized_disk_compensator_recovery [IsProbabilityMeasure P]
+    (hκ : 0<κ) (hc : ∀ ω, Continuous (fun t => B t ω)) (h0 : ∀ ω, B 0 ω=0)
+    (θ : ℝ) (hθ : θ ∈ Ioo (0:ℝ) Real.pi) (T : Ω → ℝ≥0∞) (hT : Measurable T) :
+    TendstoInMeasure P
+      (fun n ω => meshMassCompensator P
+        (compensatorMeshFiltration (Target.normalizedFiltration κ B
+          (fun r => (hBm.comp (measurable_const.prodMk measurable_id) : Measurable (B r))) hc h0))
+        (C.normalizedDiskScalar θ hθ) n (compensatorStopIndex n (T ω)) ω) atTop
+      (fun ω => massAtExtendedTime (fun t => C.normalizedDiskScalar θ hθ t ω)
+        (C.diskTerminalScalar θ hθ ω) (T ω)) := by
+  apply meshMassCompensator_stopped_tendstoInMeasure P _ _ _ _ _
+    (C.compactWeightedMass_terminal_memLp _ _ (Target.diskSourceHalfPlane_compact hθ))
+    (C.normalizedDiskScalar_paths hκ θ hθ) T hT
+  · intro t
+    exact C.normalizedDiskScalar_measurable θ hθ t
+  · intro n i
+    change StronglyMeasurable[Target.normalizedFiltration κ B
+      (fun r => (hBm.comp (measurable_const.prodMk measurable_id) : Measurable (B r)))
+      hc h0 (compensatorMeshTime n i)] _
+    exact C.normalizedDiskScalar_stronglyAdapted hκ hc h0 θ hθ _
+
+end SLEExactGauge.Multipoint.CanonicalMass
+
+end
+
+end OAI

lean/OAI/Probability/SLE/Mass/OriginalShiftedMass.lean

@@ -0,0 +1,58 @@
+import OAI.Probability.SLE.Mass.CanonicalMassRemaining
+import OAI.Probability.SLE.Stochastic.ProgressiveStoppedTime
+
+namespace OAI
+
+/-! The original canonical mass evaluated after a finite stopping time.
+Its remaining Green kernel is stated in the full shifted filtration. -/
+
+noncomputable section
+open Set Filter _root_.MeasureTheory _root_.OAI.MeasureTheory Classical
+open scoped NNReal ENNReal Topology
+
+namespace SLEExactGauge.Multipoint
+
+lemma extendedCanonicalMass_finite_time
+    {Ω : Type*} (N : ℝ≥0 → Ω → Measure upperHalfPlane)
+    (ν : Ω → Measure upperHalfPlane) (τ : Ω → ℝ≥0) (ω : Ω) :
+    extendedCanonicalMass N ν (τ ω:ℝ≥0∞) ω=N (τ ω) ω := by
+  simp only [extendedCanonicalMass,ENNReal.coe_lt_top,ite_true,ENNReal.toNNReal_coe]
+
+variable {Ω : Type*} [MeasurableSpace Ω] {P : Measure Ω} {κ : ℝ}
+  {B : ℝ≥0 → Ω → ℝ} {hBm : Measurable (Function.uncurry B)}
+  {γ : Ω → ℝ≥0 → ℂ} {G : Ω → ℝ≥0 → ℂ → ℂ}
+  (C : CanonicalMass P κ B hBm γ G) (τ : Ω → ℝ≥0)
+  (hτ : IsStoppingTime (Filtration.natural B (fun s =>
+    (hBm.comp (measurable_const.prodMk measurable_id) : Measurable (B s)).stronglyMeasurable))
+    (fun ω => (τ ω:WithTop ℝ≥0)))
+
+include C τ hτ in
+lemma CanonicalMass.original_shifted_adapted :
+    Adapted (shiftedStoppingFiltration hτ) (fun t ω => C.process (τ ω+t) ω) :=
+  _root_.OAI.MeasureTheory.IsProgressive.shifted_adapted C.progressive τ hτ
+
+include C τ hτ in
+lemma CanonicalMass.original_shifted_green_kernel
+    (t : ℝ≥0) (E : Set Ω) (hE : MeasurableSet[shiftedStoppingFiltration hτ t] E) :
+    (P.restrict E).bind C.rational.terminal =
+      (P.restrict E).bind (fun ω => C.process (τ ω+t) ω)+
+      (P.restrict E).bind (fun ω => halfPlaneGreenMeasure κ B γ G (τ ω+t) ω) := by
+  have h := C.kernel (fun ω => ((τ ω+t:ℝ≥0):WithTop ℝ≥0))
+    (stopping_time_add_nnreal hτ t) E hE
+  change (P.restrict E).bind C.rational.terminal =
+    (P.restrict E).bind (fun ω => C.process (τ ω+t) ω)+
+      (P.restrict E).bind (fun ω => halfPlaneGreenMeasure κ B γ G (τ ω+t) ω) at h
+  exact h
+
+include C τ hτ in
+lemma CanonicalMass.original_shifted_mean_le (t : ℝ≥0) (E : Set Ω) :
+    (P.restrict E).bind (fun ω => C.process (τ ω+t) ω) ≤ initialGreenMeasure κ := by
+  have h := C.atTime_mean_le (fun ω => ((τ ω+t:ℝ≥0):ℝ≥0∞))
+    (stopping_time_add_nnreal hτ t).measurable' E
+  exact h
+
+end SLEExactGauge.Multipoint
+
+end
+
+end OAI

lean/OAI/Probability/SLE/Mass/PastThresholdMass.lean

@@ -0,0 +1,63 @@
+import OAI.Probability.SLE.Gauge.StrictPastCountable
+import OAI.Probability.SLE.Geometry.WeightedCompactTerminal
+
+namespace OAI
+
+/-! Continuous mass crosses an intermediate level at a dense test time.
+Consequently a cell with twice the threshold has at least half its mass
+strictly after a successful past test. -/
+
+noncomputable section
+open Set Filter _root_.MeasureTheory _root_.OAI.MeasureTheory ProbabilityTheory
+open scoped Topology NNReal ENNReal
+attribute [local instance] Classical.propDecidable
+
+namespace SLEExactGauge.Multipoint
+
+lemma dense_time_between_mass_levels (q : ℕ → ℝ≥0) (hq : DenseRange q)
+    (f : ℝ≥0 → ℝ) (hf : Continuous f) (h0 : f 0=0)
+    (M H L : ℝ) (hH : 0<H) (hHL : H<L) (hLM : L<M)
+    (hlim : Tendsto f atTop (𝓝 M)) : ∃ n, H<f (q n) ∧ f (q n)<L := by
+  obtain ⟨T,hT⟩ := (hlim.eventually (lt_mem_nhds hLM)).exists
+  obtain ⟨t,_,ht⟩ := intermediate_value_Icc (show (0:ℝ≥0)≤T from bot_le)
+    hf.continuousOn (show (H+L)/2∈Icc (f 0) (f T) by rw [h0]; constructor <;> linarith)
+  have hopen : IsOpen (f ⁻¹' Ioo H L) := isOpen_Ioo.preimage hf
+  have hne : (f ⁻¹' Ioo H L).Nonempty := ⟨t,by change H<f t ∧ f t<L; rw [ht]; constructor <;> linarith⟩
+  exact hq.exists_mem_open hopen hne
+
+lemma past_threshold_detects_half
+    {X : Type*} [MeasurableSpace X] (μ : Measure X) (K : Set X)
+    (hfin : μ K≠∞)
+    (A : ℝ≥0 → Set X) (hA : ∀ t, MeasurableSet (A t))
+    (q : ℕ → ℝ≥0) (hq : DenseRange q) (f : ℝ≥0 → ℝ)
+    (hf : Continuous f) (h0 : f 0=0)
+    (hlim : Tendsto f atTop (𝓝 (μ K).toReal))
+    (hpast : ∀ n, μ (K ∩ A (q n))=ENNReal.ofReal (f (q n)))
+    (H : ℝ) (hH : 0<H) (hlarge : ENNReal.ofReal (2*H)<μ K) :
+    μ K≤2*μ (K ∩ ⋃ n, if H<f (q n) then (A (q n))ᶜ else ∅) := by
+  have hreal : 2*H<(μ K).toReal := by
+    have he := (ENNReal.toReal_lt_toReal ENNReal.ofReal_ne_top hfin).2 hlarge
+    simpa only [ENNReal.toReal_ofReal (by positivity : 0≤2*H)] using he
+  obtain ⟨n,hnH,hnM⟩ := dense_time_between_mass_levels q hq f hf h0 (μ K).toReal H
+    ((μ K).toReal/2) hH (by linarith) (by linarith) hlim
+  have hsub : K \ A (q n) ⊆ K ∩ ⋃ n, if H<f (q n) then (A (q n))ᶜ else ∅ := by
+    intro x hx
+    exact ⟨hx.1,mem_iUnion.mpr ⟨n,by rw [ite_eq_left hnH]; exact hx.2⟩⟩
+  have hfuture : μ K≤2*μ (K \ A (q n)) := by
+    have he := measure_inter_add_sdiff (μ:=μ) K (hA (q n))
+    rw [hpast n] at he
+    have hd : μ (K \ A (q n))≠∞ := ne_top_of_le_ne_top hfin (measure_mono sdiff_subset)
+    have hsum := congrArg ENNReal.toReal he
+    rw [ENNReal.toReal_add ENNReal.ofReal_ne_top hd,
+      ENNReal.toReal_ofReal (hH.trans hnH).le] at hsum
+    apply (ENNReal.toReal_le_toReal hfin (ENNReal.mul_ne_top (by norm_num) hd)).mp
+    rw [ENNReal.toReal_mul]
+    norm_num only [ENNReal.toReal_ofNat]
+    linarith
+  exact hfuture.trans (mul_le_mul' (show (2:ℝ≥0∞)≤2 from le_rfl) (measure_mono hsub))
+
+end SLEExactGauge.Multipoint
+
+end
+
+end OAI

lean/OAI/Probability/SLE/Mass/PhysicalDiskMass.lean

@@ -0,0 +1,94 @@
+import OAI.Probability.SLE.Mass.DiskChartMass
+import OAI.Probability.SLE.Geometry.PhysicalCellDisk
+
+namespace OAI
+
+/-! The disk scalar controls the actual centered and rescaled inverse
+Loewner pushforward. The marked angle is retained exactly. -/
+
+noncomputable section
+open Set Filter _root_.MeasureTheory _root_.OAI.MeasureTheory Metric
+open scoped Topology NNReal ENNReal
+
+namespace SLEExactGauge
+open Multipoint
+
+lemma diskChartMass_eq_of_coordinates
+    (κ θ : ℝ) (f H : ℂ → ℂ)
+    (he : ∀ z ∈ upperHalfPlane, f (Target.diskMap θ z)=H z)
+    (μ : Measure upperHalfPlane) :
+    diskChartMass κ θ f μ = weightedImageMass (fun z : upperHalfPlane => H z)
+      (fun z : upperHalfPlane => ENNReal.ofReal (‖deriv H z‖^dimension κ)) μ := by
+  have hmap : (fun z : upperHalfPlane => f (Target.diskMap θ z))=
+      (fun z : upperHalfPlane => H z) := funext (fun z => he z z.property)
+  have hder (z : upperHalfPlane) : deriv (f ∘ Target.diskMap θ) z=deriv H z := by
+    apply Filter.EventuallyEq.deriv_eq
+    filter_upwards [isOpen_upperHalfPlane.mem_nhds z.property] with w hw
+    exact he w hw
+  unfold diskChartMass
+  rw [hmap]
+  congr 1
+  funext z
+  rw [hder]
+
+lemma diskToHalfPlane_real_affine (c a : ℝ) (z ξ : ℂ)
+    (hξ : ξ ∈ ball (0:ℂ) 1) :
+    diskToHalfPlane ((c:ℂ)+(a:ℂ)*z) ξ =
+      (c:ℂ)+(a:ℂ)*diskToHalfPlane z ξ := by
+  simp only [diskToHalfPlane,star_add,star_mul,Complex.star_def,Complex.conj_ofReal]
+  field_simp [disk_denominator_ne hξ]
+  ring
+
+lemma physicalDiskChart_normalized
+    (F G : ℝ≥0 → ℂ → ℂ) (t : ℝ≥0) (z : ℂ) (c a θ : ℝ)
+    (he : G t z=(c:ℂ)+(a:ℂ)*Complex.exp (θ*Complex.I))
+    {ξ : ℂ} (hξ : ξ ∈ ball (0:ℂ) 1) :
+    physicalDiskChart id F G t z ξ =
+      F t ((c:ℂ)+(a:ℂ)*Target.diskMapInv θ ξ) := by
+  change F t (diskToHalfPlane (G t z) ξ)=_
+  rw [he,diskToHalfPlane_real_affine c a _ ξ hξ,← Target.diskMapInv_eq_diskToHalfPlane]
+
+lemma physicalDiskChart_mass_eq
+    (κ θ : ℝ) (hθ : θ ∈ Ioo (0:ℝ) Real.pi)
+    (F G : ℝ≥0 → ℂ → ℂ) (t : ℝ≥0) (z : ℂ) (c a : ℝ)
+    (he : G t z=(c:ℂ)+(a:ℂ)*Complex.exp (θ*Complex.I))
+    (μ : Measure upperHalfPlane) :
+    diskChartMass κ θ (physicalDiskChart id F G t z) μ =
+      weightedImageMass (fun w : upperHalfPlane => F t ((c:ℂ)+(a:ℂ)*w))
+        (fun w : upperHalfPlane => ENNReal.ofReal
+          (‖deriv (fun v : ℂ => F t ((c:ℂ)+(a:ℂ)*v)) w‖^dimension κ)) μ := by
+  apply diskChartMass_eq_of_coordinates κ θ (physicalDiskChart id F G t z)
+    (fun v : ℂ => F t ((c:ℂ)+(a:ℂ)*v))
+  intro w hw
+  rw [physicalDiskChart_normalized F G t z c a θ he (Target.diskMap_maps hθ hw),
+    Target.diskMapInv_diskMap hθ hw]
+
+lemma IsCapacityTwoWitness.physical_quarter_mass_bounds
+    {U : ℝ≥0 → ℝ} {γ : ℝ≥0 → ℂ} {G F : ℝ≥0 → ℂ → ℂ}
+    (hw : IsCapacityTwoWitness U γ G F) (hgrowth : PublishedDiskUnivalentGrowth)
+    (κ : ℝ) (hκ : 0 < κ) (θ : ℝ) (hθ : θ ∈ Ioo (0:ℝ) Real.pi)
+    (t : ℝ≥0) (z : ℂ) (hz : z ∈ survivingDomain γ t) (a : ℝ)
+    (he : G t z=(U t:ℂ)+(a:ℂ)*Complex.exp (θ*Complex.I))
+    (μ : Measure upperHalfPlane) [IsFiniteMeasureOnCompacts μ] :
+    let f := physicalDiskChart id F G t z
+    let ν := weightedImageMass (fun w : upperHalfPlane => F t ((U t:ℂ)+(a:ℂ)*w))
+      (fun w : upperHalfPlane => ENNReal.ofReal
+        (‖deriv (fun v : ℂ => F t ((U t:ℂ)+(a:ℂ)*v)) w‖^dimension κ)) μ
+    let L := ENNReal.ofReal (compactWeightedMass (Target.diskMassWeight κ θ hθ)
+      (Target.diskSourceHalfPlane θ) μ)
+    ENNReal.ofReal ((fullRadius G t z/16)^dimension κ)*L ≤ ν (f '' Target.diskK) ∧
+      ν (f '' Target.diskK) ≤ ENNReal.ofReal ((16*fullRadius G t z)^dimension κ)*L := by
+  obtain ⟨hd,hi,_,hder,_⟩ := hw.physical_disk_chart id differentiableOn_id
+    (fun _ _ _ _ h => h) t z hz
+  have hder' : ‖deriv (physicalDiskChart id F G t z) 0‖=fullRadius G t z := by
+    simpa [physicalConformalRadius] using hder
+  have hb := diskChartMass_quarter_bounds hgrowth κ hκ θ hθ
+    (physicalDiskChart id F G t z) hd hi μ
+  rw [hder',physicalDiskChart_mass_eq κ θ hθ F G t z (U t) a he μ] at hb
+  exact hb
+
+end SLEExactGauge
+
+end
+
+end OAI

lean/OAI/Probability/SLE/Mass/PositiveMassContinuity.lean

@@ -0,0 +1,37 @@
+import OAI.Probability.SLE.Loewner.StoppedInversePaths
+
+namespace OAI
+
+/-! Positive compact tests determine continuity of every real compact test. -/
+noncomputable section
+open Set Filter _root_.MeasureTheory _root_.OAI.MeasureTheory
+open scoped Topology NNReal ENNReal CompactlySupported
+
+namespace SLEExactGauge
+
+lemma PositiveMassPaths.continuous_real_tests
+    {N : ℝ≥0 → Measure upperHalfPlane} {ν : Measure upperHalfPlane}
+    (h : PositiveMassPaths N ν) (f : C_c(upperHalfPlane,ℝ)) :
+    Continuous (fun t => ∫ z, f z ∂N t) := by
+  let fp : C_c(upperHalfPlane,ℝ) := f ⊔ 0
+  let fm : C_c(upperHalfPlane,ℝ) := -f ⊔ 0
+  have hp : ∀ z, 0 ≤ fp z := fun z => le_max_right _ _
+  have hm : ∀ z, 0 ≤ fm z := fun z => le_max_right _ _
+  have he (t : ℝ≥0) : (∫ z, f z ∂N t) = (∫ z, fp z ∂N t)-(∫ z, fm z ∂N t) := by
+    let := (h.radon t).2
+    rw [← integral_sub fp.integrable fm.integrable]
+    apply integral_congr_ae
+    exact ae_of_all _ (fun z => by
+      change f z = max (f z) 0-max (-f z) 0
+      rcases le_total 0 (f z) with hz | hz
+      · rw [max_eq_left hz,max_eq_right (neg_nonpos.mpr hz)]; ring
+      · rw [max_eq_right hz,max_eq_left (neg_nonneg.mpr hz)]; ring)
+  have hcont : Continuous (fun t => (∫ z, fp z ∂N t)-(∫ z, fm z ∂N t)) :=
+    (h.continuous_tests fp hp).sub (h.continuous_tests fm hm)
+  exact hcont.congr (fun t => (he t).symm)
+
+end SLEExactGauge
+
+end
+
+end OAI

lean/OAI/Probability/SLE/Mass/PositiveMassGerm.lean

@@ -0,0 +1,98 @@
+import OAI.Probability.SLE.Stochastic.BrownianGerm
+import OAI.Probability.SLE.Mass.CanonicalMassConstruction
+
+namespace OAI
+
+/-! A uniform positive chance of early mass, together with the Brownian
+germ law, gives mass before every positive time. The scaling estimate
+needed to apply this lemma is kept explicit. -/
+
+noncomputable section
+open Set Filter _root_.MeasureTheory _root_.OAI.MeasureTheory ProbabilityTheory
+open scoped NNReal ENNReal Topology
+
+namespace SLEExactGauge
+
+lemma earlyMassGerm_tail {Ω : Type*} (E : ℕ → Set Ω) (k : ℕ) :
+    (⋂ N : ℕ, ⋃ j ≥ N, E j) = (⋂ N : ℕ, ⋃ j ≥ max N k, E j) := by
+  ext ω
+  simp only [mem_iInter,mem_iUnion]
+  constructor
+  · intro h N
+    exact h (max N k)
+  · intro h N
+    obtain ⟨j,hj,hE⟩ := h N
+    exact ⟨j,(le_max_left N k).trans hj,hE⟩
+
+/-- This is the zero-one step of the canonical mass positivity argument.
+The lower bound will come from scaling a single nonzero compact mean. -/
+theorem positive_mass_all_times_of_uniform_probability
+    {Ω : Type*} [mΩ : MeasurableSpace Ω] {P : Measure Ω} [IsProbabilityMeasure P]
+    {B : ℝ≥0 → Ω → ℝ} (hB : IsBrownianReal B P) (hm : ∀ t, Measurable (B t))
+    (hc : ∀ ω, Continuous (fun t => B t ω)) (h0 : ∀ ω, B 0 ω=0)
+    (Z : ℝ≥0 → Ω → ℝ≥0∞)
+    (hZ : Adapted (Filtration.natural B (fun t => (hm t).stronglyMeasurable)) Z)
+    (hmono : ∀ᵐ ω ∂P, Monotone (fun t => Z t ω))
+    (ε : ℕ → ℝ≥0) (hεanti : Antitone ε) (hε : Tendsto ε atTop (𝓝 0))
+    (p : ℝ≥0∞) (hp : 0<p) (hprob : ∀ n, p ≤ P {ω | 0<Z (ε n) ω}) :
+    ∀ᵐ ω ∂P, ∀ t : ℝ≥0, 0<t → 0<Z t ω := by
+  let E : ℕ → Set Ω := fun n => {ω | 0<Z (ε n) ω}
+  let A : ℕ → Set Ω := fun N => ⋃ j ≥ N, E j
+  let G : Set Ω := ⋂ N, A N
+  have hEp (j k : ℕ) (hkj : k≤j) :
+      MeasurableSet[Filtration.natural B (fun t => (hm t).stronglyMeasurable) (ε k)] (E j) := by
+    have hz : Measurable[Filtration.natural B (fun t => (hm t).stronglyMeasurable) (ε k)]
+        (Z (ε j)) := (hZ (ε j)).mono
+      ((Filtration.natural B (fun t => (hm t).stronglyMeasurable)).mono (hεanti hkj)) le_rfl
+    exact measurableSet_lt measurable_const hz
+  have hGp (k : ℕ) : MeasurableSet[Filtration.natural B (fun t => (hm t).stronglyMeasurable) (ε k)] G := by
+    change MeasurableSet[Filtration.natural B (fun t => (hm t).stronglyMeasurable) (ε k)]
+      (⋂ N : ℕ, ⋃ j ≥ N, E j)
+    rw [earlyMassGerm_tail E k]
+    apply MeasurableSet.iInter
+    intro N
+    apply MeasurableSet.iUnion
+    intro j
+    apply MeasurableSet.iUnion
+    intro hj
+    exact hEp j k ((le_max_right N k).trans hj)
+  have hEm (j : ℕ) : MeasurableSet (E j) :=
+    (Filtration.natural B (fun t => (hm t).stronglyMeasurable)).le _ _ (hEp j j le_rfl)
+  have hAm (N : ℕ) : MeasurableSet (A N) :=
+    MeasurableSet.iUnion (fun j => MeasurableSet.iUnion (fun _ => hEm j))
+  have hGm : MeasurableSet G := MeasurableSet.iInter hAm
+  have hAa : Antitone A := by
+    intro N M hNM ω hω
+    obtain ⟨j,hj⟩ := mem_iUnion.mp hω
+    obtain ⟨hjM,hωE⟩ := mem_iUnion.mp hj
+    exact mem_iUnion.mpr ⟨j,mem_iUnion.mpr ⟨hNM.trans hjM,hωE⟩⟩
+  have hpG : p≤P G := by
+    change p≤P (⋂ N, A N)
+    rw [hAa.measure_iInter (fun N => (hAm N).nullMeasurableSet) ⟨0,measure_ne_top P _⟩]
+    apply le_iInf
+    intro N
+    apply (hprob N).trans (measure_mono ?_)
+    intro ω hω
+    exact mem_iUnion.mpr ⟨N,mem_iUnion.mpr ⟨le_rfl,hω⟩⟩
+  have hGone : P G=1 := by
+    rcases brownian_germ_zero_one hB hm hc h0 ε hε G hGp with hG | hG
+    · exact ((ne_of_gt hp) (le_zero_iff.mp (hpG.trans hG.le))).elim
+    · exact hG
+  have hGa : ∀ᵐ ω ∂P, ω∈G := (mem_ae_iff_prob_eq_one hGm).mpr hGone
+  filter_upwards [hGa,hmono] with ω hω hωmono
+  intro t ht
+  obtain ⟨N,hN⟩ := (hε.eventually (eventually_lt_nhds ht)).exists
+  have hg : ∀ N : ℕ, ∃ j, N≤j ∧ ω∈E j := by
+    intro N
+    change ω∈⋂ N, ⋃ j ≥ N, E j at hω
+    obtain ⟨j,hj⟩ := mem_iUnion.mp (mem_iInter.mp hω N)
+    obtain ⟨hNj,hmem⟩ := mem_iUnion.mp hj
+    exact ⟨j,hNj,hmem⟩
+  obtain ⟨j,hj,hωj⟩ := hg N
+  exact lt_of_lt_of_le hωj (hωmono ((hεanti hj).trans hN.le))
+
+end SLEExactGauge
+
+end
+
+end OAI

lean/OAI/Probability/SLE/Mass/PositiveRestartMass.lean

@@ -0,0 +1,167 @@
+import OAI.Probability.SLE.Mass.CanonicalMassRestart
+import OAI.Probability.SLE.Geometry.RestartGreenKernel
+
+namespace OAI
+
+/-! Positive mass survives the actual inverse-Loewner transport and
+passes from initial intervals to every finite Brownian restart. -/
+
+noncomputable section
+open Set Filter _root_.MeasureTheory _root_.OAI.MeasureTheory ProbabilityTheory
+open scoped NNReal ENNReal Topology
+
+namespace SLEExactGauge
+
+lemma weightedImageMass_ne_zero {X : Type*} [MeasurableSpace X]
+    (J : upperHalfPlane → X) (hJ : Measurable J)
+    (w : upperHalfPlane → ℝ≥0∞) (hw : Measurable w) (hp : ∀ z, 0<w z)
+    (μ : Measure upperHalfPlane) (hμ : μ≠0) : weightedImageMass J w μ≠0 := by
+  apply Measure.measure_univ_pos.mp
+  rw [weightedImageMass_apply J hJ w μ univ MeasurableSet.univ]
+  simp only [preimage_univ,indicator_univ]
+  rw [lintegral_pos_iff_support hw]
+  have he : Function.support w=univ := by
+    ext z
+    simp only [Function.mem_support,mem_univ,iff_true]
+    exact (hp z).ne'
+  rw [he]
+  exact Measure.measure_univ_pos.mpr hμ
+
+namespace Multipoint.CanonicalMass
+
+local instance : LocallyCompactSpace upperHalfPlane := isOpen_upperHalfPlane.locallyCompactSpace
+
+local instance positiveRestartDriverMeasurable : MeasurableSpace C(ℝ≥0,ℝ) := borel _
+local instance positiveRestartDriverBorel : BorelSpace C(ℝ≥0,ℝ) := ⟨rfl⟩
+
+variable {Ω : Type*} [mΩ : MeasurableSpace Ω] {P : Measure Ω} [IsProbabilityMeasure P] {κ : ℝ}
+  {B : ℝ≥0 → Ω → ℝ} {hBm : Measurable (Function.uncurry B)}
+  {γ : Ω → ℝ≥0 → ℂ} {G : Ω → ℝ≥0 → ℂ → ℂ}
+  (C : CanonicalMass P κ B hBm γ G)
+
+lemma raw_restart_positive_time
+    (hB : IsBrownianReal B P) (hc : ∀ ω, Continuous (fun t => B t ω))
+    (R : RawCanonicalMass)
+    (he : ∀ᵐ ω ∂P, ∀ t, R.process t (sourceDriverPath B hc ω)=C.process t ω)
+    (hpos : ∀ᵐ ω ∂P, ∀ t : ℝ≥0, 0<t → C.process t ω≠0)
+    (τ : Ω → ℝ≥0)
+    (hτ : IsStoppingTime (Filtration.natural B (fun s =>
+      (hBm.comp (measurable_const.prodMk measurable_id) : Measurable (B s)).stronglyMeasurable))
+      (fun ω => (τ ω:WithTop ℝ≥0)))
+    (t : ℝ≥0) (ht : 0<t) :
+    ∀ᵐ ω ∂P, R.process t (sourceRestartDriverPath B hc τ ω)≠0 := by
+  let E : Set C(ℝ≥0,ℝ) := {p | 0<R.process t p univ}
+  have hEm : MeasurableSet E := measurableSet_lt measurable_const
+    ((Measure.measurable_coe MeasurableSet.univ).comp (R.progressive.adapted.measurable (i:=t)))
+  have hm (s : ℝ≥0) : Measurable (B s) := hBm.comp (measurable_const.prodMk measurable_id)
+  have hp := source_path_measurable (sourceDriverPath B hc) hm
+  have hEfull : ∀ᵐ p ∂P.map (sourceDriverPath B hc), p∈E := by
+    apply (ae_map_iff hp.aemeasurable hEm).mpr
+    filter_upwards [he,hpos] with ω hω hωp
+    rw [hω t]
+    exact Measure.measure_univ_pos.mpr (hωp t ht)
+  filter_upwards [sourceRestart_mem_full_driver_set hB hm hc τ hτ E hEm hEfull] with ω hω
+  exact Measure.measure_univ_pos.mp hω
+
+lemma positive_increment_after_stop
+    (hB : IsBrownianReal B P) (hc : ∀ ω, Continuous (fun t => B t ω)) (hκ : 0<κ)
+    (F : Ω → ℝ≥0 → ℂ → ℂ)
+    (hw : ∀ ω, IsCapacityTwoWitness (fun t => Real.sqrt κ*B t ω) (γ ω) (G ω) (F ω))
+    (hpublished : PublishedTraceGeneration (P.map (sourceDriverPath B hc)) κ (fun t p => p t))
+    (hpos : ∀ᵐ ω ∂P, ∀ t : ℝ≥0, 0<t → C.process t ω≠0)
+    (τ : Ω → ℝ≥0)
+    (hτ : IsStoppingTime (Filtration.natural B (fun s =>
+      (hBm.comp (measurable_const.prodMk measurable_id) : Measurable (B s)).stronglyMeasurable))
+      (fun ω => (τ ω:WithTop ℝ≥0)))
+    (t : ℝ≥0) (ht : 0<t) :
+    ∀ᵐ ω ∂P, C.process (τ ω+t) ω-C.process (τ ω) ω≠0 := by
+  obtain ⟨R,he,hr⟩ := C.exists_raw_pathwise_restart hB hc hκ F hw hpublished
+  have hm (s : ℝ≥0) : Measurable (B s) := hBm.comp (measurable_const.prodMk measurable_id)
+  have hJ := stoppedMassPoint_measurable B κ γ G F hw τ hm hc hτ
+  have hW := stoppedMassWeight_measurable B κ γ G F hw τ hm hc hτ hκ
+  have hpair (ω : Ω) : @Measurable upperHalfPlane (Ω × upperHalfPlane) inferInstance
+      (hτ.measurableSpace.prod inferInstance) (fun z => (ω,z)) :=
+    @measurable_prodMk_left Ω upperHalfPlane hτ.measurableSpace inferInstance ω
+  have hJsec (ω : Ω) : Measurable (stoppedMassPoint B κ γ G F hw τ ω) :=
+    @Measurable.comp upperHalfPlane (Ω × upperHalfPlane) upperHalfPlane
+      inferInstance (hτ.measurableSpace.prod inferInstance) inferInstance
+      (fun p => stoppedMassPoint B κ γ G F hw τ p.1 p.2) (fun z => (ω,z)) hJ (hpair ω)
+  have hWsec (ω : Ω) : Measurable (stoppedMassWeight B κ F τ ω) :=
+    @Measurable.comp upperHalfPlane (Ω × upperHalfPlane) ℝ≥0∞
+      inferInstance (hτ.measurableSpace.prod inferInstance) inferInstance
+      (fun p => stoppedMassWeight B κ F τ p.1 p.2) (fun z => (ω,z)) hW (hpair ω)
+  filter_upwards [hr τ hτ,C.raw_restart_positive_time hB hc R (he.mono fun _ h => h.1)
+    hpos τ hτ t ht,fresh_capacity_witness_exists hB hm hc hpublished τ hτ] with ω hω hp hf
+  rw [hω.1 t]
+  obtain ⟨β,G',F',hf⟩ := hf
+  apply weightedImageMass_ne_zero (stoppedMassPoint B κ γ G F hw τ ω)
+    (hJsec ω)
+    (stoppedMassWeight B κ F τ ω)
+    (hWsec ω)
+    (fun z => ?_) _ hp
+  exact ENNReal.ofReal_pos.mpr (Real.rpow_pos_of_pos
+    ((hw ω).restart_inverse_derivative_norm_pos ((hc ω).const_mul _) (τ ω) hf z z.property) _)
+
+lemma positive_increment_fixed_times
+    (hB : IsBrownianReal B P) (hc : ∀ ω, Continuous (fun t => B t ω)) (hκ : 0 < κ)
+    (F : Ω → ℝ≥0 → ℂ → ℂ)
+    (hw : ∀ ω, IsCapacityTwoWitness (fun t => Real.sqrt κ*B t ω) (γ ω) (G ω) (F ω))
+    (hpublished : PublishedTraceGeneration (P.map (sourceDriverPath B hc)) κ (fun t p => p t))
+    (hpos : ∀ᵐ ω ∂P, ∀ t : ℝ≥0, 0 < t → C.process t ω ≠ 0)
+    (s t : ℝ≥0) (hst : s < t) :
+    ∀ᵐ ω ∂P, C.process t ω-C.process s ω ≠ 0 := by
+  have hτ := isStoppingTime_const (Filtration.natural B (fun r =>
+    (hBm.comp (measurable_const.prodMk measurable_id) : Measurable (B r)).stronglyMeasurable)) s
+  have h := C.positive_increment_after_stop hB hc hκ F hw hpublished hpos
+    (fun _ => s) hτ (t-s) (tsub_pos_iff_lt.mpr hst)
+  simpa only [add_tsub_cancel_of_le hst.le] using h
+
+lemma positive_increment_all_times
+    (hB : IsBrownianReal B P) (hc : ∀ ω, Continuous (fun t => B t ω)) (hκ : 0 < κ)
+    (F : Ω → ℝ≥0 → ℂ → ℂ)
+    (hw : ∀ ω, IsCapacityTwoWitness (fun t => Real.sqrt κ*B t ω) (γ ω) (G ω) (F ω))
+    (hpublished : PublishedTraceGeneration (P.map (sourceDriverPath B hc)) κ (fun t p => p t))
+    (hpos : ∀ᵐ ω ∂P, ∀ t : ℝ≥0, 0 < t → C.process t ω ≠ 0) :
+    ∀ᵐ ω ∂P, ∀ s t : ℝ≥0, s < t → C.process t ω-C.process s ω ≠ 0 := by
+  have hq (p q : ℚ) : ∀ᵐ ω ∂P,
+      (p:ℝ).toNNReal < (q:ℝ).toNNReal →
+        C.process (q:ℝ).toNNReal ω-C.process (p:ℝ).toNNReal ω ≠ 0 := by
+    by_cases hpq : (p:ℝ).toNNReal < (q:ℝ).toNNReal
+    · exact (C.positive_increment_fixed_times hB hc hκ F hw hpublished hpos _ _ hpq).mono
+        (fun _ h _ => h)
+    · exact ae_of_all _ (fun _ h => (hpq h).elim)
+  filter_upwards [C.paths,ae_all_iff.mpr (fun p => ae_all_iff.mpr (hq p))] with ω hp hqω
+  intro s t hst hz
+  obtain ⟨p,hsp,hpt⟩ := exists_rat_btwn (show (s:ℝ) < (t:ℝ) from hst)
+  obtain ⟨q,hpq,hqt⟩ := exists_rat_btwn hpt
+  have hp0 : (0:ℝ) ≤ p := s.coe_nonneg.trans hsp.le
+  have hq0 : (0:ℝ) ≤ q := hp0.trans hpq.le
+  have hsp' : s ≤ (p:ℝ).toNNReal := by
+    exact_mod_cast (show (s:ℝ) ≤ ((p:ℝ).toNNReal:ℝ) by rw [Real.coe_toNNReal _ hp0]; exact hsp.le)
+  have hpq' : (p:ℝ).toNNReal < (q:ℝ).toNNReal := by
+    exact_mod_cast (show ((p:ℝ).toNNReal:ℝ) < ((q:ℝ).toNNReal:ℝ) by
+      rw [Real.coe_toNNReal _ hp0,Real.coe_toNNReal _ hq0]; exact hpq)
+  have hqt' : (q:ℝ).toNNReal ≤ t := by
+    exact_mod_cast (show ((q:ℝ).toNNReal:ℝ) ≤ (t:ℝ) by rw [Real.coe_toNNReal _ hq0]; exact hqt.le)
+  let : IsFiniteMeasureOnCompacts (C.process s ω) := (C.radon s ω).2
+  have hts : C.process t ω=C.process s ω := by
+    have h := sigmaFinite_sub_add_cancel_of_le (hp.monotone hst.le)
+    rw [hz,zero_add] at h
+    exact h.symm
+  have hps : C.process (p:ℝ).toNNReal ω=C.process s ω := by
+    apply le_antisymm
+    · exact (hp.monotone (hpq'.le.trans hqt')).trans_eq hts
+    · exact hp.monotone hsp'
+  have hqs : C.process (q:ℝ).toNNReal ω=C.process s ω := by
+    apply le_antisymm
+    · exact (hp.monotone hqt').trans_eq hts
+    · exact hp.monotone (hsp'.trans hpq'.le)
+  apply hqω p q hpq'
+  rw [hps,hqs,Measure.sub_self]
+
+end Multipoint.CanonicalMass
+end SLEExactGauge
+
+end
+
+end OAI

lean/OAI/Probability/SLE/Mass/PositiveTraceMass.lean

@@ -0,0 +1,72 @@
+import OAI.Probability.SLE.Mass.PositiveRestartMass
+import OAI.Probability.SLE.Mass.CanonicalMassScaling
+
+namespace OAI
+
+/-! Positive increments and trace support force positive canonical mass
+in each open set visited at a positive time. -/
+
+noncomputable section
+open Set Filter _root_.MeasureTheory _root_.OAI.MeasureTheory ProbabilityTheory
+open scoped Topology NNReal ENNReal
+
+namespace SLEExactGauge.Multipoint
+
+lemma positive_trace_mass_of_positive_increments
+    (γ : ℝ≥0 → ℂ) (hγ : Continuous γ) (N : ℝ≥0 → Measure upperHalfPlane)
+    (hmono : Monotone N)
+    (hinc : ∀ s t, s ≤ t → (N t-N s)
+      {z : upperHalfPlane | (z:ℂ) ∉ (fun r : ℝ => γ r.toNNReal) '' Icc (s:ℝ) t}=0)
+    (hpos : ∀ s t, s < t → N t-N s ≠ 0)
+    (V : Set ℂ) (hV : IsOpen V) (u T : ℝ≥0) (hu : 0 < u) (huT : u ≤ T)
+    (hvisit : γ u ∈ V) : 0 < N T (Subtype.val ⁻¹' V) := by
+  have hpre : γ ⁻¹' V ∈ 𝓝 u := hγ.continuousAt.preimage_mem_nhds (hV.mem_nhds hvisit)
+  obtain ⟨a,ha,haV⟩ := exists_Ioc_subset_of_mem_nhds' hpre hu
+  obtain ⟨b,hab,hbu⟩ := exists_between ha.2
+  have hseg : (fun r : ℝ => γ r.toNNReal) '' Icc (b:ℝ) u ⊆ V := by
+    rintro _ ⟨r,hr,rfl⟩
+    apply haV
+    have hbr : b ≤ r.toNNReal := by
+      simpa only [Real.toNNReal_coe] using Real.toNNReal_mono hr.1
+    have hru : r.toNNReal ≤ u := by
+      simpa only [Real.toNNReal_coe] using Real.toNNReal_mono hr.2
+    exact ⟨hab.trans_le hbr,hru⟩
+  have hnull : (N u-N b) (Subtype.val ⁻¹' V)ᶜ=0 := by
+    apply le_antisymm ?_ bot_le
+    apply (measure_mono (show (Subtype.val ⁻¹' V)ᶜ ⊆
+      {z : upperHalfPlane | (z:ℂ) ∉ (fun r : ℝ => γ r.toNNReal) '' Icc (b:ℝ) u} from ?_)).trans_eq
+      (hinc b u hbu.le)
+    intro z hz hs
+    exact hz (hseg hs)
+  have hVmeas : MeasurableSet ((Subtype.val : upperHalfPlane → ℂ) ⁻¹' V) :=
+    (hV.preimage (continuous_subtype_val : Continuous (Subtype.val : upperHalfPlane → ℂ))).measurableSet
+  have he := measure_add_measure_compl (μ:=N u-N b) hVmeas
+  rw [hnull,add_zero] at he
+  have hp : 0 < (N u-N b) (Subtype.val ⁻¹' V) := by
+    rw [he]
+    exact Measure.measure_univ_pos.mpr (hpos b u hbu)
+  exact hp.trans_le (((Measure.sub_le : N u-N b ≤ N u).trans (hmono huT)) _)
+
+variable {Ω : Type*} [MeasurableSpace Ω] {P : Measure Ω} [IsProbabilityMeasure P]
+  {κ : ℝ} {B : ℝ≥0 → Ω → ℝ} {hBm : Measurable (Function.uncurry B)}
+  {γ : Ω → ℝ≥0 → ℂ} {G : Ω → ℝ≥0 → ℂ → ℂ}
+
+lemma CanonicalMass.positive_open_visited
+    (C : CanonicalMass P κ B hBm γ G) (hB : IsBrownianReal B P)
+    (hc : ∀ ω, Continuous (fun t => B t ω)) (h0 : ∀ ω, B 0 ω=0) (hκ : 0 < κ)
+    (F : Ω → ℝ≥0 → ℂ → ℂ)
+    (hw : ∀ ω, IsCapacityTwoWitness (fun t => Real.sqrt κ*B t ω) (γ ω) (G ω) (F ω))
+    (hpublished : PublishedTraceGeneration (P.map (sourceDriverPath B hc)) κ (fun t p => p t)) :
+    ∀ᵐ ω ∂P, ∀ V : Set ℂ, IsOpen V → ∀ u T : ℝ≥0,
+      0 < u → u ≤ T → γ ω u ∈ V → 0 < C.process T ω (Subtype.val ⁻¹' V) := by
+  have hp := C.positive_all_times hB hc h0 F hw
+  have hi := C.positive_increment_all_times hB hc hκ F hw hpublished hp
+  filter_upwards [C.paths,hi] with ω hω hωi
+  exact positive_trace_mass_of_positive_increments (γ ω) (hw ω).1 (fun t => C.process t ω)
+    hω.monotone hω.increment_support hωi
+
+end SLEExactGauge.Multipoint
+
+end
+
+end OAI

lean/OAI/Probability/SLE/Mass/RadonApproximationList.lean

@@ -0,0 +1,56 @@
+import OAI.Probability.SLE.Mass.RadonTestLimit
+import Mathlib.Topology.Bases
+import Mathlib.Topology.Instances.Real.Lemmas
+
+namespace OAI
+
+/-! A countable list of positive Radon measures approximates every finite
+list of compact-test integrals. This uses separability of the image in
+real sequence space, without a topology on the space of measures. -/
+
+noncomputable section
+open Set Filter MeasureTheory Classical
+open scoped Topology CompactlySupported
+
+namespace SLEExactGauge
+
+variable {X : Type*} [TopologicalSpace X] [T2Space X] [LocallyCompactSpace X]
+  [MeasurableSpace X] [BorelSpace X]
+
+omit [T2Space X] [LocallyCompactSpace X] [BorelSpace X] in
+lemma LocalTestFamily.exists_countable_measure_approximants (D : LocalTestFamily X) :
+    ∃ μ : ℕ → Measure X, (∀ k, (μ k).Regular) ∧
+      ∀ (ν : Measure X), ν.Regular → ∀ n : ℕ, ∀ ε : ℝ, 0 < ε →
+        ∃ k, ∀ j < n+1, |(∫ x, D.test j x ∂μ k)-(∫ x, D.test j x ∂ν)| < ε := by
+  let R := {ν : Measure X // ν.Regular}
+  let V : R → ℕ → ℝ := fun ν j => ∫ x, D.test j x ∂ν.val
+  let S := range V
+  let : Nonempty S := ⟨⟨V ⟨0,inferInstance⟩,⟨⟨0,inferInstance⟩,rfl⟩⟩⟩
+  let q : ℕ → S := TopologicalSpace.denseSeq S
+  have hq : DenseRange q := TopologicalSpace.denseRange_denseSeq S
+  choose μ hμ using fun k => (q k).property
+  refine ⟨fun k => (μ k).val,fun k => (μ k).property,?_⟩
+  intro ν hν n ε hε
+  let v : S := ⟨V ⟨ν,hν⟩,⟨⟨ν,hν⟩,rfl⟩⟩
+  let U : Set S := {w | ∀ j : Fin (n+1), |w.val j.val-v.val j.val| < ε}
+  have hU : IsOpen U := by
+    simp only [U,Set.ofPred_forall]
+    apply isOpen_iInter_of_finite
+    intro j
+    exact isOpen_lt (((continuous_apply j.val).comp continuous_subtype_val).sub continuous_const).abs
+      continuous_const
+  have hv : v ∈ U := by
+    intro j
+    simpa only [sub_self,abs_zero] using hε
+  obtain ⟨k,hk⟩ := hq.exists_mem_open hU ⟨v,hv⟩
+  refine ⟨k,fun j hj => ?_⟩
+  have hh := hk (⟨j,hj⟩ : Fin (n+1))
+  change |(V (μ k)) j-(V ⟨ν,hν⟩) j| < ε
+  rw [hμ k]
+  exact hh
+
+end SLEExactGauge
+
+end
+
+end OAI

lean/OAI/Probability/SLE/Mass/RadonFactorization.lean

@@ -0,0 +1,97 @@
+import OAI.Probability.SLE.Mass.RadonApproximationList
+import OAI.Probability.SLE.Mass.RawRadonLimit
+import OAI.Probability.SLE.Mass.RadonTestDetermines
+import Mathlib.MeasureTheory.Function.FactorsThrough
+
+namespace OAI
+
+/-! Doob--Dynkin factorization of a locally finite Radon kernel through
+countably many real compact tests. The factor is regular on every input and
+is reconstructed in the target data space, without ambient null-set changes. -/
+
+noncomputable section
+open Set Filter MeasureTheory Classical
+open scoped Topology CompactlySupported
+
+namespace SLEExactGauge
+
+lemma exists_measurable_nat_choice
+    {Y : Type*} [MeasurableSpace Y] (p : Y → ℕ → Prop)
+    (hm : ∀ k, MeasurableSet {y | p y k}) :
+    ∃ i : Y → ℕ, Measurable i ∧ ∀ y, (∃ k, p y k) → p y (i y) := by
+  let q (y : Y) (k : ℕ) := (∃ j, p y j) → p y k
+  have hq (y : Y) : ∃ k, q y k := by
+    by_cases h : ∃ j, p y j
+    · obtain ⟨k,hk⟩ := h
+      exact ⟨k,fun _ => hk⟩
+    · exact ⟨0,fun h' => (h h').elim⟩
+  have hqm (k : ℕ) : MeasurableSet {y | q y k} := by
+    have he : {y | q y k} = (⋃ j, {y | p y j})ᶜ ∪ {y | p y k} := by
+      ext y
+      simp only [q,mem_ofPred_eq,mem_union,mem_compl_iff,mem_iUnion]
+      tauto
+    rw [he]
+    exact (MeasurableSet.iUnion hm).compl.union (hm k)
+  exact ⟨fun y => Nat.find (hq y),measurable_find hq hqm,
+    fun y hy => Nat.find_spec (hq y) hy⟩
+
+variable {X : Type*} [TopologicalSpace X] [T2Space X] [LocallyCompactSpace X]
+  [SecondCountableTopology X] [MeasurableSpace X] [BorelSpace X]
+
+/-- Countable compact tests suffice for a raw measurable Radon factor.
+The factorization equality holds at every original input. -/
+theorem LocalTestFamily.measurable_radon_factor
+    (D : LocalTestFamily X) {Ω Y : Type*} [MeasurableSpace Y]
+    (F : Ω → Y) (μ : Ω → Measure X) (hμ : ∀ ω, (μ ω).Regular)
+    (htest : ∀ j, Measurable[MeasurableSpace.comap F inferInstance]
+      (fun ω => ∫ x, D.test j x ∂μ ω)) :
+    ∃ ν : Y → Measure X, Measurable ν ∧ (∀ y, (ν y).Regular) ∧ ∀ ω, ν (F ω)=μ ω := by
+  choose g hgm hg using fun j => (htest j).exists_eq_measurable_comp
+  obtain ⟨a,ha,happrox⟩ := D.exists_countable_measure_approximants
+  let p (n : ℕ) (y : Y) (k : ℕ) : Prop :=
+    ∀ j < n+1, |(∫ x, D.test j x ∂a k)-g j y| < 1/(n+1:ℝ)
+  have hpm (n k : ℕ) : MeasurableSet {y | p n y k} := by
+    simp only [p,Set.ofPred_forall]
+    apply MeasurableSet.iInter
+    intro j
+    apply MeasurableSet.iInter
+    intro _
+    simpa only [Real.norm_eq_abs,Pi.sub_apply] using
+      measurableSet_lt (measurable_const.sub (hgm j)).norm measurable_const
+  choose i him hi using fun n => exists_measurable_nat_choice (p n) (hpm n)
+  let μn (n : ℕ) (y : Y) := a (i n y)
+  have hμnm (n : ℕ) (f : C_c(X,ℝ)) : Measurable (fun y => ∫ x, f x ∂μn n y) :=
+    (measurable_of_countable (fun k => ∫ x, f x ∂a k)).comp (him n)
+  have hvalid (n : ℕ) (ω : Ω) : p n (F ω) (i n (F ω)) := by
+    apply hi n
+    obtain ⟨k,hk⟩ := happrox (μ ω) (hμ ω) n (1/(n+1:ℝ)) (by positivity)
+    refine ⟨k,fun j hj => ?_⟩
+    have he : g j (F ω) = ∫ x, D.test j x ∂μ ω := congr_fun (hg j) ω |>.symm
+    rw [he]
+    exact hk j hj
+  have hlim (ω : Ω) (j : ℕ) : Tendsto (fun n => ∫ x, D.test j x ∂μn n (F ω)) atTop
+      (𝓝 (∫ x, D.test j x ∂μ ω)) := by
+    apply Metric.tendsto_atTop.mpr
+    intro ε hε
+    obtain ⟨N,hN⟩ := eventually_atTop.mp
+      ((tendsto_one_div_add_atTop_nhds_zero_nat (𝕜 := ℝ)).eventually (gt_mem_nhds hε))
+    refine ⟨max j N,fun n hn => ?_⟩
+    rw [Real.dist_eq]
+    have hjn : j < n+1 := by omega
+    have hv := hvalid n ω j hjn
+    have he : g j (F ω) = ∫ x, D.test j x ∂μ ω := congr_fun (hg j) ω |>.symm
+    rw [he] at hv
+    exact hv.trans (hN n (le_trans (le_max_right _ _) hn))
+  obtain ⟨ν,hνm,hν,hνlim⟩ := D.exists_raw_radon_limit μn (fun n y => ha (i n y)) hμnm
+  refine ⟨ν,hνm,hν,fun ω => ?_⟩
+  let := hν (F ω)
+  let := hμ ω
+  apply D.measure_eq_of_test_integrals
+  intro j
+  exact tendsto_nhds_unique (hνlim (F ω) (fun j => (hlim ω j).cauchySeq) (D.test j)) (hlim ω j)
+
+end SLEExactGauge
+
+end
+
+end OAI

lean/OAI/Probability/SLE/Mass/RadonKernelIntegral.lean

@@ -0,0 +1,67 @@
+import Mathlib.MeasureTheory.Measure.GiryMonad
+import Mathlib.MeasureTheory.Integral.Bochner.Basic
+
+namespace OAI
+
+/-! Signed integrals of a random Radon measure can be computed from its
+mean measure. The positive and negative parts use Tonelli separately. -/
+
+noncomputable section
+open Set Filter MeasureTheory
+open scoped ENNReal
+
+namespace SLEExactGauge
+
+lemma lintegral_ofReal_lt_top_of_integrable
+    {X : Type*} [MeasurableSpace X] {μ : Measure X} {f : X → ℝ}
+    (hf : Integrable f μ) : (∫⁻ x, ENNReal.ofReal (f x) ∂μ) < ⊤ := by
+  apply (lintegral_mono (fun x => ENNReal.ofReal_le_ofReal (le_abs_self (f x)))).trans_lt
+  exact (hasFiniteIntegral_iff_ofReal (Eventually.of_forall (fun x => norm_nonneg (f x)))).mp
+    hf.norm.hasFiniteIntegral
+
+theorem integrable_integral_bind_of_sections
+    {Ω X : Type*} [MeasurableSpace Ω] [MeasurableSpace X]
+    (P : Measure Ω) (μ : Ω → Measure X) (hμ : Measurable μ)
+    (f : X → ℝ) (hf : Measurable f)
+    (hfi : ∀ ω, Integrable f (μ ω)) (hfP : Integrable f (P.bind μ)) :
+    Integrable (fun ω => ∫ x, f x ∂μ ω) P ∧
+      (∫ ω, (∫ x, f x ∂μ ω) ∂P) = ∫ x, f x ∂P.bind μ := by
+  let A (ω : Ω) := ∫⁻ x, ENNReal.ofReal (f x) ∂μ ω
+  let B (ω : Ω) := ∫⁻ x, ENNReal.ofReal (-f x) ∂μ ω
+  have hAm : Measurable A := (Measure.measurable_lintegral hf.ennreal_ofReal).comp hμ
+  have hBm : Measurable B := (Measure.measurable_lintegral hf.neg.ennreal_ofReal).comp hμ
+  have hA : (∫⁻ ω, A ω ∂P) = ∫⁻ x, ENNReal.ofReal (f x) ∂P.bind μ :=
+    (Measure.lintegral_bind hμ.aemeasurable hf.ennreal_ofReal.aemeasurable).symm
+  have hB : (∫⁻ ω, B ω ∂P) = ∫⁻ x, ENNReal.ofReal (-f x) ∂P.bind μ :=
+    (Measure.lintegral_bind hμ.aemeasurable hf.neg.ennreal_ofReal.aemeasurable).symm
+  have hAf : (∫⁻ ω, A ω ∂P) < ⊤ := hA.trans_lt (lintegral_ofReal_lt_top_of_integrable hfP)
+  have hBf : (∫⁻ ω, B ω ∂P) < ⊤ := hB.trans_lt (lintegral_ofReal_lt_top_of_integrable hfP.neg)
+  have he (ω : Ω) : (∫ x, f x ∂μ ω) = (A ω).toReal - (B ω).toReal :=
+    integral_eq_lintegral_pos_part_sub_lintegral_neg_part (hfi ω)
+  refine ⟨?_,?_⟩
+  · convert (integrable_toReal_of_lintegral_ne_top hAm.aemeasurable hAf.ne).sub
+      (integrable_toReal_of_lintegral_ne_top hBm.aemeasurable hBf.ne) using 1
+    funext ω
+    exact he ω
+  simp_rw [he]
+  rw [integral_sub (integrable_toReal_of_lintegral_ne_top hAm.aemeasurable hAf.ne)
+    (integrable_toReal_of_lintegral_ne_top hBm.aemeasurable hBf.ne),
+    integral_toReal hAm.aemeasurable (Eventually.of_forall (fun ω =>
+      lintegral_ofReal_lt_top_of_integrable (hfi ω))),
+    integral_toReal hBm.aemeasurable (Eventually.of_forall (fun ω =>
+      lintegral_ofReal_lt_top_of_integrable (hfi ω).neg)),hA,hB]
+  exact (integral_eq_lintegral_pos_part_sub_lintegral_neg_part hfP).symm
+
+theorem integral_bind_of_integrable_sections
+    {Ω X : Type*} [MeasurableSpace Ω] [MeasurableSpace X]
+    (P : Measure Ω) (μ : Ω → Measure X) (hμ : Measurable μ)
+    (f : X → ℝ) (hf : Measurable f)
+    (hfi : ∀ ω, Integrable f (μ ω)) (hfP : Integrable f (P.bind μ)) :
+    (∫ ω, (∫ x, f x ∂μ ω) ∂P) = ∫ x, f x ∂P.bind μ :=
+  (integrable_integral_bind_of_sections P μ hμ f hf hfi hfP).2
+
+end SLEExactGauge
+
+end
+
+end OAI

lean/OAI/Probability/SLE/Mass/RadonPathCertificates.lean

@@ -0,0 +1,77 @@
+import OAI.Probability.SLE.Mass.RadonTestDetermines
+import OAI.Probability.SLE.Mass.RadonTestLimitProperties
+import OAI.Probability.SLE.Mass.RationalTraceMassProgressiveVersion
+
+namespace OAI
+
+/-! Countable compact-test certificates for order and continuous Radon paths.
+The cutoff coordinates in the determining family supply local mass bounds. -/
+
+noncomputable section
+open Set Filter MeasureTheory
+open scoped Topology CompactlySupported NNReal
+
+namespace SLEExactGauge
+
+variable {X : Type*} [TopologicalSpace X] [T2Space X] [LocallyCompactSpace X]
+  [MeasurableSpace X] [BorelSpace X]
+
+private lemma positive_part_error {a b e : ℝ} (ha : 0 ≤ a) (h : |a-b| ≤ e) :
+    |a-max b 0| ≤ e := by
+  rcases le_total 0 b with hb | hb
+  · simpa only [max_eq_left hb] using h
+  · rw [max_eq_right hb,sub_zero,abs_of_nonneg ha]
+    rw [abs_of_nonneg (sub_nonneg.mpr (hb.trans ha))] at h
+    linarith
+
+theorem LocalTestFamily.measure_le_of_positive_tests (D : LocalTestFamily X)
+    (μ ν : Measure X) [μ.Regular] [ν.Regular]
+    (h : ∀ j, (∫ x, (D.test j ⊔ 0) x ∂μ) ≤ ∫ x, (D.test j ⊔ 0) x ∂ν) : μ ≤ ν := by
+  apply radon_measure_le_of_nonneg_tests
+  intro f hf
+  obtain ⟨k,_,happrox⟩ := D.weighted_approximation f
+  let A := ∫ x, f x ∂μ
+  let B := ∫ x, f x ∂ν
+  let M := (∫ x, D.test k x ∂μ)+(∫ x, D.test k x ∂ν)
+  have hb (n : ℕ) : A ≤ B+(1/(n+1:ℝ))*M := by
+    obtain ⟨j,hj⟩ := happrox (1/(n+1:ℝ)) (by positivity)
+    have hp (x : X) : |f x-(D.test j ⊔ 0) x| ≤ (1/(n+1:ℝ))*D.test k x :=
+      positive_part_error (hf x) (hj x)
+    have hμ := integral_sub_le_cutoff μ f (D.test j ⊔ 0) (D.test k) _ hp
+    have hν := integral_sub_le_cutoff ν f (D.test j ⊔ 0) (D.test k) _ hp
+    have hh := h j
+    dsimp only [A,B,M]
+    have hμ' := le_abs_self ((∫ x, f x ∂μ)-(∫ x, (D.test j ⊔ 0) x ∂μ))
+    have hν' := neg_le_abs ((∫ x, f x ∂ν)-(∫ x, (D.test j ⊔ 0) x ∂ν))
+    nlinarith
+  have hl : Tendsto (fun n : ℕ => B+(1/(n+1:ℝ))*M) atTop (𝓝 B) := by
+    simpa only [zero_mul,add_zero] using tendsto_const_nhds.add
+      ((tendsto_one_div_add_atTop_nhds_zero_nat (𝕜 := ℝ)).mul_const M)
+  exact le_of_tendsto_of_tendsto' tendsto_const_nhds hl hb
+
+theorem LocalTestFamily.continuous_integrals_of_tests (D : LocalTestFamily X)
+    {T : Type*} [TopologicalSpace T] [SequentialSpace T]
+    (N : T → Measure X) (hr : ∀ t, (N t).Regular)
+    (hc : ∀ j, Continuous (fun t => ∫ x, D.test j x ∂N t)) :
+    ∀ f : C_c(X,ℝ), Continuous (fun t => ∫ x, f x ∂N t) := by
+  intro f
+  apply SeqContinuous.continuous
+  intro t a hta
+  let (n : ℕ) : IsFiniteMeasureOnCompacts (N (t n)) := by
+    let := hr (t n)
+    infer_instance
+  obtain ⟨ν,hν,_,hl⟩ := D.exists_radon_limit (fun n => N (t n))
+    (fun j => ⟨∫ x, D.test j x ∂N a,(hc j).continuousAt.tendsto.comp hta⟩)
+  have he : ν=N a := by
+    let := hν
+    let := hr a
+    apply D.measure_eq_of_test_integrals
+    intro j
+    exact tendsto_nhds_unique (hl (D.test j)) ((hc j).continuousAt.tendsto.comp hta)
+  simpa only [he,Function.comp_def] using hl f
+
+end SLEExactGauge
+
+end
+
+end OAI

lean/OAI/Probability/SLE/Mass/RadonProcessAEUniqueness.lean

@@ -0,0 +1,39 @@
+import OAI.Probability.SLE.Mass.RadonProcessUniqueness
+
+namespace OAI
+
+/-! A single almost-sure Radon certificate suffices when upgrading
+simultaneous positive-test identities to identities of measure paths. -/
+
+noncomputable section
+open Set Filter MeasureTheory
+open scoped Topology CompactlySupported NNReal
+
+namespace SLEExactGauge
+
+ theorem random_radon_process_eq_of_positive_tests_ae
+    {X : Type*} [TopologicalSpace X] [T2Space X] [LocallyCompactSpace X]
+    [MeasurableSpace X] [BorelSpace X]
+    {Ω : Type*} [MeasurableSpace Ω] (P : Measure Ω)
+    (D : LocalTestFamily X) (N M : ℝ≥0 → Ω → Measure X)
+    (hNr : ∀ᵐ ω ∂P, ∀ t, (N t ω).Regular)
+    (hMr : ∀ᵐ ω ∂P, ∀ t, (M t ω).Regular)
+    (htest : ∀ f : C_c(X,ℝ), (∀ x, 0 ≤ f x) →
+      ∀ᵐ ω ∂P, ∀ t, (∫ x, f x ∂N t ω)=∫ x, f x ∂M t ω) :
+    ∀ᵐ ω ∂P, ∀ t, N t ω=M t ω := by
+  have hp (j : ℕ) := htest (D.test j ⊔ 0) (fun x => le_max_right _ _)
+  have hn (j : ℕ) := htest ((-D.test j) ⊔ 0) (fun x => le_max_right _ _)
+  filter_upwards [hNr,hMr,ae_all_iff.mpr hp,ae_all_iff.mpr hn] with ω hN hM hωp hωn
+  intro t
+  let := hN t
+  let := hM t
+  apply D.measure_eq_of_test_integrals
+  intro j
+  rw [compact_test_integral_pos_sub_neg (N t ω) (D.test j),
+    compact_test_integral_pos_sub_neg (M t ω) (D.test j),hωp j t,hωn j t]
+
+end SLEExactGauge
+
+end
+
+end OAI

lean/OAI/Probability/SLE/Mass/RadonProcessUniqueness.lean

@@ -0,0 +1,51 @@
+import OAI.Probability.SLE.Mass.MassKernelUniqueness
+import OAI.Probability.SLE.Mass.RadonTestDetermines
+
+namespace OAI
+
+/-! Countably many positive compact tests give one common full-measure event
+on which all times of two random Radon processes agree. -/
+
+noncomputable section
+open Set Filter MeasureTheory
+open scoped Topology CompactlySupported NNReal
+
+namespace SLEExactGauge
+
+variable {X : Type*} [TopologicalSpace X] [T2Space X] [LocallyCompactSpace X]
+  [MeasurableSpace X] [BorelSpace X]
+
+omit [T2Space X] [LocallyCompactSpace X] in
+lemma compact_test_integral_pos_sub_neg (μ : Measure X) [μ.Regular] (f : C_c(X,ℝ)) :
+    (∫ x, f x ∂μ) = (∫ x, (f ⊔ 0) x ∂μ)-(∫ x, ((-f) ⊔ 0) x ∂μ) := by
+  rw [← integral_sub (f ⊔ 0).integrable ((-f) ⊔ 0).integrable]
+  apply integral_congr_ae
+  filter_upwards [] with x
+  change f x = max (f x) 0-max (-f x) 0
+  rcases le_total 0 (f x) with h | h
+  · rw [max_eq_left h,max_eq_right (neg_nonpos.mpr h),sub_zero]
+  · rw [max_eq_right h,max_eq_left (neg_nonneg.mpr h),zero_sub,neg_neg]
+
+theorem random_radon_process_eq_of_positive_tests
+    {Ω : Type*} [MeasurableSpace Ω] (P : Measure Ω)
+    (D : LocalTestFamily X) (N M : ℝ≥0 → Ω → Measure X)
+    (hNr : ∀ t ω, (N t ω).Regular) (hMr : ∀ t ω, (M t ω).Regular)
+    (htest : ∀ f : C_c(X,ℝ), (∀ x, 0 ≤ f x) →
+      ∀ᵐ ω ∂P, ∀ t, (∫ x, f x ∂N t ω) = ∫ x, f x ∂M t ω) :
+    ∀ᵐ ω ∂P, ∀ t, N t ω = M t ω := by
+  have hp (j : ℕ) := htest (D.test j ⊔ 0) (fun x => le_max_right _ _)
+  have hn (j : ℕ) := htest ((-D.test j) ⊔ 0) (fun x => le_max_right _ _)
+  filter_upwards [ae_all_iff.mpr hp,ae_all_iff.mpr hn] with ω hωp hωn
+  intro t
+  let := hNr t ω
+  let := hMr t ω
+  apply D.measure_eq_of_test_integrals
+  intro j
+  rw [compact_test_integral_pos_sub_neg (N t ω) (D.test j),
+    compact_test_integral_pos_sub_neg (M t ω) (D.test j),hωp j t,hωn j t]
+
+end SLEExactGauge
+
+end
+
+end OAI

lean/OAI/Probability/SLE/Mass/RadonRandomTesting.lean

@@ -0,0 +1,64 @@
+import OAI.Probability.SLE.Geometry.RandomSpatialTesting
+import OAI.Probability.SLE.LoewnerCharts
+
+namespace OAI
+
+/-! Nonnegative random tests of locally finite half-plane measures.
+Compact restrictions remove any need for a finite total mass. -/
+
+noncomputable section
+open Set Filter MeasureTheory ProbabilityTheory Classical
+open scoped ENNReal
+
+namespace SLEExactGauge
+
+local instance : LocallyCompactSpace upperHalfPlane := isOpen_upperHalfPlane.locallyCompactSpace
+
+private lemma finite_halfPlane_random_test_measurable
+    {Ω : Type*} [MeasurableSpace Ω]
+    (μ : Ω → Measure upperHalfPlane) (hμ : Measurable μ)
+    (hfin : ∀ ω, IsFiniteMeasure (μ ω))
+    (f : Ω × upperHalfPlane → ℝ≥0∞) (hf : Measurable f) :
+    Measurable (fun ω => ∫⁻ z, f (ω,z) ∂μ ω) := by
+  let K : Kernel Ω upperHalfPlane := ⟨μ,hμ⟩
+  have hp : Measurable (fun ω => (μ ω).map (Prod.mk ω)) := by
+    apply Measure.measurable_of_measurable_coe
+    intro A hA
+    have h := Kernel.measurable_kernel_prodMk_left_of_finite (κ := K) hA hfin
+    change Measurable (fun a => μ a (Prod.mk a ⁻¹' A)) at h
+    simpa only [Measure.map_apply measurable_prodMk_left hA] using h
+  have h := (Measure.measurable_lintegral hf).comp hp
+  convert h using 1
+  funext ω
+  exact (lintegral_map hf measurable_prodMk_left).symm
+
+theorem halfPlane_random_test_measurable
+    {Ω : Type*} [MeasurableSpace Ω]
+    (μ : Ω → Measure upperHalfPlane) (hμ : Measurable μ)
+    (hfin : ∀ ω, IsFiniteMeasureOnCompacts (μ ω))
+    (f : Ω × upperHalfPlane → ℝ≥0∞) (hf : Measurable f) :
+    Measurable (fun ω => ∫⁻ z, f (ω,z) ∂μ ω) := by
+  have he (ω : Ω) : (∫⁻ z, f (ω,z) ∂μ ω) =
+      ⨆ n, ∫⁻ z in compactCovering upperHalfPlane n, f (ω,z) ∂μ ω := by
+    rw [← setLIntegral_iUnion_of_directed _ (Monotone.directed_le (compactCovering_subset upperHalfPlane)),
+      iUnion_compactCovering,Measure.restrict_univ]
+  simp_rw [he]
+  apply Measurable.iSup
+  intro n
+  have hK := (isCompact_compactCovering upperHalfPlane n).measurableSet
+  have hm : Measurable (fun ω => (μ ω).restrict (compactCovering upperHalfPlane n)) := by
+    apply Measure.measurable_of_measurable_coe
+    intro A hA
+    simp only [Measure.restrict_apply hA]
+    exact (Measure.measurable_coe (hA.inter hK)).comp hμ
+  apply finite_halfPlane_random_test_measurable _ hm _ f hf
+  intro ω
+  let := hfin ω
+  exact ⟨by simpa only [Measure.restrict_apply_univ] using
+    (isCompact_compactCovering upperHalfPlane n).measure_lt_top (μ := μ ω)⟩
+
+end SLEExactGauge
+
+end
+
+end OAI

lean/OAI/Probability/SLE/Mass/RadonTerminalUniqueness.lean

@@ -0,0 +1,49 @@
+import OAI.Probability.SLE.Mass.RadonProcessUniqueness
+import OAI.Probability.SLE.Mass.RationalTraceMassLocalVariation
+import OAI.Probability.SLE.Mass.LocallyFiniteMeasureSubtract
+
+namespace OAI
+
+/-! Local exhaustion determines the terminal measure once the finite-time
+increasing Radon family is fixed. -/
+
+noncomputable section
+open Set Filter MeasureTheory
+open scoped ENNReal NNReal Topology
+
+namespace SLEExactGauge
+
+lemma radon_terminal_eq_of_common_exhaustion
+    {X : Type*} [TopologicalSpace X] [T2Space X] [LocallyCompactSpace X]
+    [MeasurableSpace X] [BorelSpace X]
+    (μ ν : Measure X) [μ.Regular] [ν.Regular]
+    (N : ℝ≥0 → Measure X)
+    (hμ : ∀ t, N t ≤ μ) (hν : ∀ t, N t ≤ ν)
+    (hlμ : ∀ K : Set X, IsCompact K → Tendsto (fun t : ℝ≥0 => (μ-N t) K) atTop (𝓝 0))
+    (hlν : ∀ K : Set X, IsCompact K → Tendsto (fun t : ℝ≥0 => (ν-N t) K) atTop (𝓝 0)) :
+    μ = ν := by
+  have hle (ρ σ : Measure X) [ρ.Regular] (hρ : ∀ t, N t ≤ ρ) (hσ : ∀ t, N t ≤ σ)
+      (hl : ∀ K : Set X, IsCompact K → Tendsto (fun t : ℝ≥0 => (ρ-N t) K) atTop (𝓝 0))
+      (K : Set X) (hK : IsCompact K) : ρ K ≤ σ K := by
+    have hb (t : ℝ≥0) : ρ K ≤ σ K+(ρ-N t) K := by
+      let : IsFiniteMeasureOnCompacts (N t) :=
+        ⟨fun L hL => lt_of_le_of_lt (hρ t L) hL.measure_lt_top⟩
+      rw [sub_apply_of_finite_restriction (hρ t) hK.measurableSet hK.measure_lt_top.ne]
+      calc
+        ρ K = (ρ K-N t K)+N t K := (tsub_add_cancel_of_le (hρ t K)).symm
+        _ ≤ (ρ K-N t K)+σ K := add_le_add le_rfl (hσ t K)
+        _ = _ := add_comm _ _
+    have hlim := (tendsto_const_nhds (x := σ K)).add (hl K hK)
+    simp only [add_zero] at hlim
+    exact le_of_tendsto_of_tendsto' tendsto_const_nhds hlim hb
+  apply Measure.OuterRegular.ext_isOpen
+  apply Measure.InnerRegularWRT.eq_of_innerRegularWRT_of_forall_eq
+    Measure.Regular.innerRegular Measure.Regular.innerRegular
+  intro K hK
+  exact (hle μ ν hμ hν hlμ K hK).antisymm (hle ν μ hν hμ hlν K hK)
+
+end SLEExactGauge
+
+end
+
+end OAI

lean/OAI/Probability/SLE/Mass/RadonTestDetermines.lean

@@ -0,0 +1,49 @@
+import OAI.Probability.SLE.Mass.RadonTestLimit
+
+namespace OAI
+
+/-! The constructed countable local family determines a regular measure. -/
+
+noncomputable section
+open Set Filter MeasureTheory
+open scoped Topology CompactlySupported
+
+namespace SLEExactGauge
+
+variable {X : Type*} [TopologicalSpace X] [T2Space X] [LocallyCompactSpace X]
+  [MeasurableSpace X] [BorelSpace X]
+
+theorem LocalTestFamily.measure_eq_of_test_integrals (D : LocalTestFamily X)
+    (μ ν : Measure X) [μ.Regular] [ν.Regular]
+    (h : ∀ j, (∫ x, D.test j x ∂μ) = ∫ x, D.test j x ∂ν) : μ = ν := by
+  apply Measure.ext_of_integral_eq_on_compactlySupported
+  intro f
+  let M (n : ℕ) := if n % 2 = 0 then μ else ν
+  let (n : ℕ) : IsFiniteMeasureOnCompacts (M n) := by
+    dsimp only [M]
+    split_ifs <;> infer_instance
+  have hc : CauchySeq (fun n => ∫ x, f x ∂M n) := D.integrals_cauchy M (fun j => by
+    refine ⟨∫ x, D.test j x ∂ν,?_⟩
+    have he : (fun n => ∫ x, D.test j x ∂M n) = fun _ => ∫ x, D.test j x ∂ν := by
+      funext n
+      dsimp only [M]
+      split_ifs
+      · exact h j
+      · rfl
+    rw [he]
+    exact tendsto_const_nhds) f
+  apply eq_of_dist_eq_zero
+  apply le_antisymm _ dist_nonneg
+  apply le_of_forall_pos_le_add
+  intro ε hε
+  obtain ⟨N,hN⟩ := Metric.cauchySeq_iff.mp hc ε hε
+  have hh := hN (2*N) (by omega) (2*N+1) (by omega)
+  have hm0 : (2*N)%2=0 := by omega
+  have hm1 : (2*N+1)%2≠0 := by omega
+  simpa only [M,hm0,hm1,ite_true,ite_false,zero_add] using hh.le
+
+end SLEExactGauge
+
+end
+
+end OAI

lean/OAI/Probability/SLE/Mass/RadonTestFamily.lean

@@ -0,0 +1,118 @@
+import OAI.Probability.SLE.Mass.RadonTestLimit
+import Mathlib.Topology.ContinuousMap.SecondCountableSpace
+import Mathlib.Topology.UrysohnsLemma
+
+namespace OAI
+
+/-! A countable determining family on a second-countable locally compact
+space, constructed from compact exhaustion and separability on compacts. -/
+
+noncomputable section
+open Set Filter MeasureTheory
+open scoped Topology CompactlySupported
+
+namespace SLEExactGauge
+
+variable {X : Type*} [TopologicalSpace X] [T2Space X] [LocallyCompactSpace X]
+  [SecondCountableTopology X]
+
+omit [LocallyCompactSpace X] in
+/-- Compact support in a fixed compact set admits a countable uniformly
+dense family, with the same support constraint. -/
+theorem exists_compact_test_sequence (K : Set X) (hK : IsCompact K) :
+    ∃ f : ℕ → C_c(X, ℝ), (∀ j, tsupport (f j) ⊆ K) ∧
+      ∀ g : C_c(X, ℝ), tsupport g ⊆ K → ∀ ε : ℝ, 0 < ε →
+        ∃ j, ∀ x, |g x-f j x| ≤ ε := by
+  classical
+  let : CompactSpace K := isCompact_iff_compactSpace.mp hK
+  let S : Set C(K, ℝ) := {g | ∃ f : C_c(X, ℝ), tsupport f ⊆ K ∧ ∀ x : K, g x=f x}
+  have hzero : (0 : C(K, ℝ)) ∈ S := by
+    refine ⟨0, ?_, fun _ => rfl⟩
+    simp
+  let : Nonempty S := ⟨⟨0,hzero⟩⟩
+  obtain ⟨d,hd⟩ := TopologicalSpace.exists_dense_seq S
+  have hrep (j : ℕ) : ∃ f : C_c(X, ℝ), tsupport f ⊆ K ∧ ∀ x : K, (d j).1 x=f x :=
+    (d j).2
+  choose f hf hrep using hrep
+  refine ⟨f,hf,fun g hg ε hε => ?_⟩
+  let r : C(K, ℝ) := ⟨fun x => g x, g.continuous.comp continuous_subtype_val⟩
+  have hr : r ∈ S := ⟨g,hg,fun _ => rfl⟩
+  obtain ⟨j,hj⟩ := Metric.denseRange_iff.mp hd ⟨r,hr⟩ ε hε
+  refine ⟨j,fun x => ?_⟩
+  by_cases hx : x ∈ K
+  · have hb := ContinuousMap.norm_coe_le_norm (r-(d j).1) ⟨x,hx⟩
+    have hb' : |g x-f j x| ≤ dist (⟨r,hr⟩ : S) (d j) := by
+      change |g x-f j x| ≤ dist r (d j).1
+      rw [dist_eq_norm]
+      simpa only [ContinuousMap.sub_apply, Real.norm_eq_abs, hrep j ⟨x,hx⟩, r,
+        ContinuousMap.coe_mk] using hb
+    exact hb'.trans hj.le
+  · have hgx : g x=0 := image_eq_zero_of_notMem_tsupport (fun h => hx (hg h))
+    have hfx : f j x=0 := image_eq_zero_of_notMem_tsupport (fun h => hx (hf j h))
+    simpa only [hgx,hfx,sub_self,abs_zero] using hε.le
+
+omit [SecondCountableTopology X] in
+/-- One nonnegative compactly supported cutoff dominates one on a given
+compact set. -/
+theorem exists_compact_test_cutoff (K : Set X) (hK : IsCompact K) :
+    ∃ f : C_c(X, ℝ), (∀ x, 0 ≤ f x) ∧ ∀ x ∈ K, 1 ≤ f x := by
+  obtain ⟨f,hf,hfc,_,h01⟩ := exists_continuousMap_one_of_isCompact_subset_isOpen
+    hK isOpen_univ (subset_univ K)
+  refine ⟨⟨f,hfc⟩,fun x => (h01 x).1,fun x hx => ?_⟩
+  change 1 ≤ f x
+  rw [hf hx]
+  rfl
+
+/-- The determining family required by Radon reconstruction exists
+without an additional density or cutoff hypothesis. -/
+theorem exists_localTestFamily : Nonempty (LocalTestFamily X) := by
+  classical
+  let K := CompactExhaustion.choice X
+  have hdense (n : ℕ) := exists_compact_test_sequence (K n) (K.isCompact n)
+  choose f hf hfdense using hdense
+  have hcut (n : ℕ) := exists_compact_test_cutoff (K n) (K.isCompact n)
+  choose ψ hψ0 hψ1 using hcut
+  let test (j : ℕ) : C_c(X, ℝ) :=
+    match Encodable.decode (α := ℕ ⊕ (ℕ × ℕ)) j with
+    | some (.inl n) => ψ n
+    | some (.inr (n,k)) => f n k
+    | none => 0
+  have htest_cut (n : ℕ) : test (Encodable.encode (Sum.inl n : ℕ ⊕ (ℕ × ℕ)))=ψ n := by
+    simp only [test, Encodable.encodek]
+  have htest_dense (n j : ℕ) :
+      test (Encodable.encode (Sum.inr (n,j) : ℕ ⊕ (ℕ × ℕ)))=f n j := by
+    simp only [test, Encodable.encodek]
+  refine ⟨{
+    compactSet := K
+    isCompact := K.isCompact
+    exhaustive := fun _ h => K.exists_superset_of_isCompact h
+    test := test
+    cutoffIndex := fun n => Encodable.encode (Sum.inl n : ℕ ⊕ (ℕ × ℕ))
+    cutoff_nonneg := ?_
+    cutoff_one_le := ?_
+    dense := ?_ }⟩
+  · intro n x
+    rw [htest_cut]
+    exact hψ0 n x
+  · intro n x hx
+    rw [htest_cut]
+    exact hψ1 n x hx
+  · intro n g hg ε hε
+    obtain ⟨j,hj⟩ := hfdense n g hg ε hε
+    refine ⟨Encodable.encode (Sum.inr (n,j) : ℕ ⊕ (ℕ × ℕ)), ?_, ?_⟩
+    · rw [htest_dense]
+      exact hf n j
+    · rw [htest_dense]
+      exact hj
+
+/-- A chosen countable family can be used for all times and all random
+outcomes of a measure-valued construction. -/
+def localTestFamily (X : Type*) [TopologicalSpace X] [T2Space X] [LocallyCompactSpace X]
+    [SecondCountableTopology X] : LocalTestFamily X :=
+  Classical.choice exists_localTestFamily
+
+end SLEExactGauge
+
+end
+
+end OAI

lean/OAI/Probability/SLE/Mass/RadonTestLimit.lean

@@ -0,0 +1,138 @@
+import Mathlib.MeasureTheory.Integral.RieszMarkovKakutani.Real
+import Mathlib.Topology.MetricSpace.Sequences
+
+namespace OAI
+
+/-! Deterministic reconstruction in `mass:construction`. A countable
+family locally dense in compactly supported continuous functions,
+including nonnegative exhaustion cutoffs, determines one Radon limit. -/
+
+noncomputable section
+open Set Filter MeasureTheory
+open scoped Topology CompactlySupported
+
+namespace SLEExactGauge
+
+variable {X : Type*} [TopologicalSpace X] [T2Space X] [LocallyCompactSpace X]
+  [MeasurableSpace X] [BorelSpace X]
+
+/-- A countable determining family with explicit support control.
+Density is in the uniform norm within each compact exhaustion set. -/
+structure LocalTestFamily (X : Type*) [TopologicalSpace X] where
+  compactSet : ℕ → Set X
+  isCompact : ∀ n, IsCompact (compactSet n)
+  exhaustive : ∀ K : Set X, IsCompact K → ∃ n, K ⊆ compactSet n
+  test : ℕ → C_c(X, ℝ)
+  cutoffIndex : ℕ → ℕ
+  cutoff_nonneg : ∀ n x, 0 ≤ test (cutoffIndex n) x
+  cutoff_one_le : ∀ n x, x ∈ compactSet n → 1 ≤ test (cutoffIndex n) x
+  dense : ∀ n (f : C_c(X, ℝ)), tsupport f ⊆ compactSet n →
+    ∀ ε : ℝ, 0 < ε → ∃ j, tsupport (test j) ⊆ compactSet n ∧
+      ∀ x, |f x-test j x| ≤ ε
+
+omit [T2Space X] [LocallyCompactSpace X] [MeasurableSpace X] [BorelSpace X] in
+lemma LocalTestFamily.weighted_approximation (D : LocalTestFamily X) (f : C_c(X, ℝ)) :
+    ∃ k, (∀ x, 0 ≤ D.test k x) ∧ ∀ ε : ℝ, 0 < ε →
+      ∃ j, ∀ x, |f x-D.test j x| ≤ ε * D.test k x := by
+  obtain ⟨n,hn⟩ := D.exhaustive (tsupport f) f.hasCompactSupport
+  refine ⟨D.cutoffIndex n,D.cutoff_nonneg n,fun ε hε => ?_⟩
+  obtain ⟨j,hj,happrox⟩ := D.dense n f hn ε hε
+  refine ⟨j,fun x => ?_⟩
+  by_cases hx : x ∈ D.compactSet n
+  · exact (happrox x).trans (le_mul_of_one_le_right hε.le (D.cutoff_one_le n x hx))
+  · have hfx : f x=0 := image_eq_zero_of_notMem_tsupport (fun h => hx (hn h))
+    have hjx : D.test j x=0 := image_eq_zero_of_notMem_tsupport (fun h => hx (hj h))
+    rw [hfx,hjx,sub_self,abs_zero]
+    exact mul_nonneg hε.le (D.cutoff_nonneg n x)
+
+omit [T2Space X] [LocallyCompactSpace X] in
+lemma integral_sub_le_cutoff (μ : Measure X) [IsFiniteMeasureOnCompacts μ]
+    (f g ψ : C_c(X, ℝ)) (ε : ℝ)
+    (h : ∀ x, |f x-g x| ≤ ε*ψ x) :
+    |(∫ x, f x ∂μ)-(∫ x, g x ∂μ)| ≤ ε*(∫ x, ψ x ∂μ) := by
+  rw [← integral_sub f.integrable g.integrable]
+  have hh := norm_integral_le_of_norm_le (f := fun x => f x-g x) (ψ.integrable.const_mul ε)
+    (ae_of_all μ (fun x => by simpa only [Real.norm_eq_abs] using h x))
+  simpa only [Real.norm_eq_abs,integral_const_mul] using hh
+
+omit [T2Space X] [LocallyCompactSpace X] in
+/-- Compactly supported integrals are Cauchy once the countable tests
+converge. Cutoff convergence supplies the uniform local mass bounds. -/
+theorem LocalTestFamily.integrals_cauchy (D : LocalTestFamily X)
+    (μ : ℕ → Measure X) [∀ n, IsFiniteMeasureOnCompacts (μ n)]
+    (htest : ∀ j, ∃ a : ℝ, Tendsto (fun n => ∫ x, D.test j x ∂μ n) atTop (𝓝 a))
+    (f : C_c(X, ℝ)) : CauchySeq (fun n => ∫ x, f x ∂μ n) := by
+  obtain ⟨k,_,hk⟩ := D.weighted_approximation f
+  obtain ⟨a,ha⟩ := htest k
+  obtain ⟨B,hB⟩ := (Metric.isBounded_range_of_tendsto _ ha).exists_norm_le
+  have hB0 : 0 ≤ B := (norm_nonneg _).trans (hB _ (mem_range_self 0))
+  have hB' (n : ℕ) : (∫ x, D.test k x ∂μ n) ≤ B :=
+    (le_abs_self _).trans (by simpa only [Real.norm_eq_abs] using hB _ (mem_range_self n))
+  apply Metric.cauchySeq_iff.mpr
+  intro ε hε
+  let δ : ℝ := ε/(4*(B+1))
+  have hδ : 0 < δ := by dsimp [δ]; positivity
+  have hδB : δ*B < ε/4 := by
+    dsimp [δ]
+    rw [div_mul_eq_mul_div,div_lt_div_iff₀ (by positivity) (by norm_num : (0:ℝ)<4)]
+    nlinarith
+  obtain ⟨j,hj⟩ := hk δ hδ
+  obtain ⟨a,ha⟩ := htest j
+  obtain ⟨N,hN⟩ := Metric.cauchySeq_iff.mp ha.cauchySeq (ε/2) (by positivity)
+  have herror (n : ℕ) : dist (∫ x, f x ∂μ n) (∫ x, D.test j x ∂μ n) ≤ δ*B := by
+    rw [Real.dist_eq]
+    exact (integral_sub_le_cutoff (μ n) f (D.test j) (D.test k) δ hj).trans
+      (mul_le_mul_of_nonneg_left (hB' n) hδ.le)
+  refine ⟨N,fun n hn m hm => ?_⟩
+  have hmid := hN n hn m hm
+  have htri := dist_triangle (∫ x, f x ∂μ n) (∫ x, D.test j x ∂μ n) (∫ x, f x ∂μ m)
+  have htri' := dist_triangle (∫ x, D.test j x ∂μ n) (∫ x, D.test j x ∂μ m) (∫ x, f x ∂μ m)
+  have hright : dist (∫ x, D.test j x ∂μ m) (∫ x, f x ∂μ m) ≤ δ*B := by
+    rw [dist_comm]
+    exact herror m
+  have hleft := herror n
+  linarith
+
+/-- Positive limits of compact continuous tests are represented by one
+locally finite regular measure. -/
+theorem radon_limit_of_all_test_limits (μ : ℕ → Measure X)
+    [∀ n, IsFiniteMeasureOnCompacts (μ n)]
+    (hlimit : ∀ f : C_c(X, ℝ), ∃ a : ℝ,
+      Tendsto (fun n => ∫ x, f x ∂μ n) atTop (𝓝 a)) :
+    ∃ ν : Measure X, ν.Regular ∧ IsFiniteMeasureOnCompacts ν ∧
+      ∀ f : C_c(X, ℝ), Tendsto (fun n => ∫ x, f x ∂μ n) atTop (𝓝 (∫ x, f x ∂ν)) := by
+  choose L hL using hlimit
+  let I (n : ℕ) : C_c(X, ℝ) →ₚ[ℝ] ℝ :=
+    CompactlySupportedContinuousMap.integralPositiveLinearMap (μ n)
+  have hI (f : C_c(X, ℝ)) : Tendsto (fun n => I n f) atTop (𝓝 (L f)) := hL f
+  have hadd (f g : C_c(X, ℝ)) : L (f+g) = L f+L g := by
+    apply tendsto_nhds_unique (hI (f+g))
+    simpa only [map_add] using (hI f).add (hI g)
+  have hsmul (c : ℝ) (f : C_c(X, ℝ)) : L (c • f) = c • L f := by
+    apply tendsto_nhds_unique (hI (c • f))
+    simpa only [map_smul] using tendsto_const_nhds.smul (hI f)
+  let Λ : C_c(X, ℝ) →ₚ[ℝ] ℝ :=
+    { toFun := L
+      map_add' := hadd
+      map_smul' := hsmul
+      monotone' := fun f g hfg => le_of_tendsto_of_tendsto' (hI f) (hI g)
+        (fun n => (I n).monotone hfg) }
+  refine ⟨RealRMK.rieszMeasure Λ,inferInstance,inferInstance,fun f => ?_⟩
+  rw [RealRMK.integral_rieszMeasure]
+  exact hL f
+
+/-- Reconstruction from a single countable locally determining family. -/
+theorem LocalTestFamily.exists_radon_limit (D : LocalTestFamily X)
+    (μ : ℕ → Measure X) [∀ n, IsFiniteMeasureOnCompacts (μ n)]
+    (htest : ∀ j, ∃ a : ℝ, Tendsto (fun n => ∫ x, D.test j x ∂μ n) atTop (𝓝 a)) :
+    ∃ ν : Measure X, ν.Regular ∧ IsFiniteMeasureOnCompacts ν ∧
+      ∀ f : C_c(X, ℝ), Tendsto (fun n => ∫ x, f x ∂μ n) atTop (𝓝 (∫ x, f x ∂ν)) := by
+  apply radon_limit_of_all_test_limits μ
+  intro f
+  exact cauchySeq_tendsto_of_complete (D.integrals_cauchy μ htest f)
+
+end SLEExactGauge
+
+end
+
+end OAI

lean/OAI/Probability/SLE/Mass/RadonTestLimitProperties.lean

@@ -0,0 +1,101 @@
+import OAI.Probability.SLE.Mass.RadonTestFamily
+
+namespace OAI
+
+/-! Order and closed-support properties of the reconstructed Radon limits. -/
+
+noncomputable section
+open Set Filter MeasureTheory
+open scoped Topology CompactlySupported ENNReal
+
+namespace SLEExactGauge
+
+variable {X : Type*} [TopologicalSpace X] [T2Space X] [LocallyCompactSpace X]
+  [MeasurableSpace X] [BorelSpace X]
+
+lemma compact_measure_le_test_integral (μ : Measure X) [μ.Regular]
+    (f : C_c(X, ℝ)) (hf : ∀ x, 0 ≤ f x) {K : Set X} (hK : IsCompact K)
+    (hfone : ∀ x ∈ K, f x=1) : μ K ≤ ENNReal.ofReal (∫ x, f x ∂μ) := by
+  simpa only [RealRMK.rieszMeasure_integralPositiveLinearMap,
+    CompactlySupportedContinuousMap.integralPositiveLinearMap_apply] using
+    RealRMK.rieszMeasure_le_of_eq_one
+      (CompactlySupportedContinuousMap.integralPositiveLinearMap μ) hf hK hfone
+
+lemma test_integral_le_measure (μ : Measure X) [μ.Regular]
+    (f : C_c(X, ℝ)) (hf : ∀ x, 0 ≤ f x ∧ f x ≤ 1) {U : Set X}
+    (hs : tsupport f ⊆ U) : ENNReal.ofReal (∫ x, f x ∂μ) ≤ μ U := by
+  simpa only [RealRMK.rieszMeasure_integralPositiveLinearMap,
+    CompactlySupportedContinuousMap.integralPositiveLinearMap_apply] using
+    RealRMK.le_rieszMeasure_tsupport_subset
+      (CompactlySupportedContinuousMap.integralPositiveLinearMap μ) hf hs
+
+/-- The positive compact-test order determines the order of Radon measures. -/
+theorem radon_measure_le_of_nonneg_tests (μ ν : Measure X) [μ.Regular] [ν.Regular]
+    (h : ∀ f : C_c(X, ℝ), (∀ x, 0 ≤ f x) → (∫ x, f x ∂μ) ≤ ∫ x, f x ∂ν) : μ ≤ ν := by
+  have hc (K : Set X) (hK : IsCompact K) : μ K ≤ ν K := by
+    apply ENNReal.le_of_forall_pos_le_add
+    intro ε hε _
+    obtain ⟨U,hKU,hU,hνU⟩ := K.exists_isOpen_le_add ν
+      (ne_of_gt (ENNReal.coe_lt_coe.mpr hε))
+    obtain ⟨f,hf1,hfc,hfs,hf01⟩ := exists_continuousMap_one_of_isCompact_subset_isOpen
+      hK hU hKU
+    let g : C_c(X, ℝ) := ⟨f,hfc⟩
+    have hg0 : ∀ x, 0 ≤ g x := fun x => (hf01 x).1
+    calc
+      μ K ≤ ENNReal.ofReal (∫ x, g x ∂μ) := compact_measure_le_test_integral μ g hg0 hK hf1
+      _ ≤ ENNReal.ofReal (∫ x, g x ∂ν) := ENNReal.ofReal_le_ofReal (h g hg0)
+      _ ≤ ν U := test_integral_le_measure ν g hf01 hfs
+      _ ≤ ν K+ε := hνU
+  have ho (U : Set X) (hU : IsOpen U) : μ U ≤ ν U := by
+    rw [Measure.Regular.innerRegular.measure_eq_iSup hU]
+    exact iSup_le fun K => iSup_le fun hKU => iSup_le fun hK => (hc K hK).trans (measure_mono hKU)
+  apply Measure.le_iff'.mpr
+  intro A
+  rw [A.measure_eq_iInf_isOpen ν]
+  exact le_iInf fun U => le_iInf fun hAU => le_iInf fun hU => (measure_mono hAU).trans (ho U hU)
+
+/-- Order of positive approximants passes to every compact-test limit. -/
+theorem radon_limits_mono (μ ν : ℕ → Measure X)
+    [∀ n, IsFiniteMeasureOnCompacts (μ n)] [∀ n, IsFiniteMeasureOnCompacts (ν n)]
+    (μ₀ ν₀ : Measure X) [μ₀.Regular] [ν₀.Regular]
+    (hμ : ∀ f : C_c(X, ℝ), Tendsto (fun n => ∫ x, f x ∂μ n) atTop (𝓝 (∫ x, f x ∂μ₀)))
+    (hν : ∀ f : C_c(X, ℝ), Tendsto (fun n => ∫ x, f x ∂ν n) atTop (𝓝 (∫ x, f x ∂ν₀)))
+    (hle : ∀ n, μ n ≤ ν n) : μ₀ ≤ ν₀ := by
+  apply radon_measure_le_of_nonneg_tests
+  intro f hf
+  exact le_of_tendsto_of_tendsto' (hμ f) (hν f) (fun n =>
+    integral_mono_measure (hle n) (ae_of_all _ hf) f.integrable)
+
+/-- Vanishing compact tests inside an open set force the Radon mass of
+that open set to vanish. -/
+theorem radon_open_eq_zero_of_tests (μ : Measure X) [μ.Regular] (U : Set X) (hU : IsOpen U)
+    (hzero : ∀ f : C_c(X, ℝ), tsupport f ⊆ U → (∫ x, f x ∂μ)=0) : μ U=0 := by
+  apply le_antisymm ?_ bot_le
+  rw [Measure.Regular.innerRegular.measure_eq_iSup hU]
+  refine iSup_le fun K => iSup_le fun hKU => iSup_le fun hK => ?_
+  obtain ⟨f,hf1,hfc,hfs,hf01⟩ := exists_continuousMap_one_of_isCompact_subset_isOpen
+    hK hU hKU
+  let g : C_c(X, ℝ) := ⟨f,hfc⟩
+  have hg0 : ∀ x, 0 ≤ g x := fun x => (hf01 x).1
+  have hb := compact_measure_le_test_integral μ g hg0 hK hf1
+  change μ K ≤ 0
+  simpa only [hzero g hfs,ENNReal.ofReal_zero] using hb
+
+/-- The compact-test limit is carried by a closed set if each compact
+test separated from it eventually vanishes. -/
+theorem radon_limit_carried_by_closed (μ : ℕ → Measure X) (ν : Measure X) [ν.Regular]
+    (hlim : ∀ f : C_c(X, ℝ), Tendsto (fun n => ∫ x, f x ∂μ n) atTop (𝓝 (∫ x, f x ∂ν)))
+    (S : Set X) (hS : IsClosed S)
+    (hvanish : ∀ f : C_c(X, ℝ), tsupport f ⊆ Sᶜ →
+      ∀ᶠ n in atTop, (∫ x, f x ∂μ n)=0) : ν Sᶜ=0 := by
+  apply radon_open_eq_zero_of_tests ν Sᶜ hS.isOpen_compl
+  intro f hf
+  have heq : (fun _ : ℕ => (0:ℝ)) =ᶠ[atTop] (fun n => ∫ x, f x ∂μ n) :=
+    (hvanish f hf).mono (fun _ h => h.symm)
+  exact tendsto_nhds_unique (hlim f) (tendsto_const_nhds.congr' heq)
+
+end SLEExactGauge
+
+end
+
+end OAI

lean/OAI/Probability/SLE/Mass/RadonTestMeasurability.lean

@@ -0,0 +1,138 @@
+import OAI.Probability.SLE.Mass.RadonTestLimitProperties
+import Mathlib.MeasureTheory.Measure.GiryMonad
+import Mathlib.MeasureTheory.Constructions.Polish.Basic
+
+namespace OAI
+
+/-! A Radon measure determined by measurable compact continuous tests is
+a measurable measure-valued function. Local finite restrictions are used,
+so no finite total-mass hypothesis is imposed. -/
+
+noncomputable section
+open Set Filter MeasureTheory
+open scoped Topology CompactlySupported ENNReal
+
+namespace SLEExactGauge
+
+variable {X : Type*} [TopologicalSpace X] [T2Space X] [LocallyCompactSpace X]
+  [SecondCountableTopology X] [MeasurableSpace X] [BorelSpace X]
+
+/-- A fixed countable list of compact cutoffs recovers the mass of a fixed
+open set simultaneously for all Radon measures. -/
+theorem exists_open_cutoff_sequence (U : Set X) (hU : IsOpen U) :
+    ∃ f : ℕ → C_c(X, ℝ), (∀ n x, 0 ≤ f n x ∧ f n x ≤ 1) ∧
+      (∀ n, tsupport (f n) ⊆ U) ∧ ∀ (μ : Measure X), μ.Regular →
+        μ U = ⨆ n, ENNReal.ofReal (∫ x, f n x ∂μ) := by
+  let : LocallyCompactSpace U := hU.locallyCompactSpace
+  let K := CompactExhaustion.choice U
+  let A (n : ℕ) : Set X := Subtype.val '' K n
+  have hAc (n : ℕ) : IsCompact (A n) := (K.isCompact n).image continuous_subtype_val
+  have hAU (n : ℕ) : A n ⊆ U := by rintro _ ⟨x,_,rfl⟩; exact x.2
+  have hcut (n : ℕ) := exists_continuousMap_one_of_isCompact_subset_isOpen (hAc n) hU (hAU n)
+  choose f hf1 hfc hfs hf01 using hcut
+  let g (n : ℕ) : C_c(X, ℝ) := ⟨f n,hfc n⟩
+  have hAm : Monotone A := fun _ _ h => image_mono (K.subset h)
+  have hUnion : (⋃ n, A n)=U := by
+    ext x
+    constructor
+    · intro hx
+      obtain ⟨n,hn⟩ := mem_iUnion.mp hx
+      exact hAU n hn
+    · intro hx
+      obtain ⟨n,hn⟩ := K.exists_mem (⟨x,hx⟩ : U)
+      exact mem_iUnion.mpr ⟨n,⟨⟨x,hx⟩,hn,rfl⟩⟩
+  refine ⟨g,hf01,hfs,fun μ hμ => ?_⟩
+  let : μ.Regular := hμ
+  apply le_antisymm
+  · rw [← hUnion,hAm.measure_iUnion]
+    exact iSup_mono fun n => compact_measure_le_test_integral μ (g n)
+      (fun x => (hf01 n x).1) (hAc n) (hf1 n)
+  · exact iSup_le fun n => test_integral_le_measure μ (g n) (hf01 n) (hfs n)
+
+/-- Measurability of all compact continuous test integrals implies
+measurability of every open-set evaluation. -/
+theorem measurable_open_evaluation_of_tests
+    {Ω : Type*} [MeasurableSpace Ω] (ν : Ω → Measure X)
+    (hν : ∀ ω, (ν ω).Regular)
+    (htest : ∀ f : C_c(X, ℝ), Measurable (fun ω => ∫ x, f x ∂ν ω))
+    (U : Set X) (hU : IsOpen U) : Measurable (fun ω => ν ω U) := by
+  obtain ⟨f,_,_,hf⟩ := exists_open_cutoff_sequence U hU
+  have he : (fun ω => ν ω U)=(fun ω => ⨆ n, ENNReal.ofReal (∫ x, f n x ∂ν ω)) :=
+    funext fun ω => hf (ν ω) (hν ω)
+  rw [he]
+  exact Measurable.iSup fun n => (htest (f n)).ennreal_ofReal
+
+omit [T2Space X] in
+/-- Locally finite Radon kernels are measurable once all their open-set
+evaluations are measurable. -/
+theorem measurable_radon_of_open_evaluations
+    {Ω : Type*} [MeasurableSpace Ω] (ν : Ω → Measure X)
+    (hν : ∀ ω, (ν ω).Regular)
+    (hopen : ∀ U : Set X, IsOpen U → Measurable (fun ω => ν ω U)) : Measurable ν := by
+  let K := CompactExhaustion.choice X
+  let U (n : ℕ) := interior (K n)
+  have hU (n : ℕ) : IsOpen (U n) := isOpen_interior
+  have hfinite (n : ℕ) (ω : Ω) : ν ω (U n) < ⊤ := by
+    let : (ν ω).Regular := hν ω
+    exact (measure_mono interior_subset).trans_lt (K.isCompact n).measure_lt_top
+  have hlocal (n : ℕ) : ∀ A : Set X, MeasurableSet A →
+      Measurable (fun ω => ν ω (A ∩ U n)) := by
+    apply MeasurableSet.induction_on_open
+    · intro A hA
+      exact hopen _ (hA.inter (hU n))
+    · intro A hA hm
+      have he (ω : Ω) : ν ω (Aᶜ ∩ U n)=ν ω (U n)-ν ω (A ∩ U n) := by
+        have hset : Aᶜ ∩ U n=U n \ (A ∩ U n) := by ext x; simp only [Set.mem_inter_iff,Set.mem_compl_iff,Set.mem_sdiff]; tauto
+        rw [hset]
+        exact measure_sdiff inter_subset_right (hA.inter (hU n).measurableSet).nullMeasurableSet
+          ((measure_mono inter_subset_right).trans_lt (hfinite n ω)).ne
+      simp_rw [he]
+      exact (hopen _ (hU n)).sub hm
+    · intro A hd hA hm
+      have hd' : Pairwise (fun i j => Disjoint (A i ∩ U n) (A j ∩ U n)) :=
+        fun i j hij => (hd hij).mono inter_subset_left inter_subset_left
+      have he (ω : Ω) : ν ω ((⋃ i, A i) ∩ U n)=∑' i, ν ω (A i ∩ U n) := by
+        rw [iUnion_inter]
+        exact measure_iUnion hd' (fun i => (hA i).inter (hU n).measurableSet)
+      simp_rw [he]
+      exact Measurable.tsum hm
+  have hUnion : (⋃ n, U n)=univ := by
+    apply eq_univ_of_forall
+    intro x
+    obtain ⟨n,hn⟩ := K.exists_mem x
+    exact mem_iUnion.mpr ⟨n+1,K.subset_interior_succ n hn⟩
+  have hUm : Monotone U := fun _ _ h => interior_mono (K.subset h)
+  apply Measure.measurable_of_measurable_coe
+  intro A hA
+  have he (ω : Ω) : ν ω A=⨆ n, ν ω (A ∩ U n) := by
+    have hmono : Monotone (fun n => A ∩ U n) := monotone_const.inter hUm
+    rw [← hmono.measure_iUnion,← inter_iUnion,hUnion,inter_univ]
+  simp_rw [he]
+  exact Measurable.iSup fun n => hlocal n A hA
+
+/-- A reconstruction with measurable compact-test integrals is a genuine
+measurable measure-valued map, not only a collection of scalar tests. -/
+theorem measurable_radon_of_tests
+    {Ω : Type*} [MeasurableSpace Ω] (ν : Ω → Measure X)
+    (hν : ∀ ω, (ν ω).Regular)
+    (htest : ∀ f : C_c(X, ℝ), Measurable (fun ω => ∫ x, f x ∂ν ω)) : Measurable ν :=
+  measurable_radon_of_open_evaluations ν hν (measurable_open_evaluation_of_tests ν hν htest)
+
+/-- Pointwise convergence of measurable compact-test integrals provides
+measurability of the reconstructed Radon kernel. -/
+theorem measurable_radon_of_test_limits
+    {Ω : Type*} [MeasurableSpace Ω] (μ : ℕ → Ω → Measure X) (ν : Ω → Measure X)
+    (hν : ∀ ω, (ν ω).Regular)
+    (hmeas : ∀ n (f : C_c(X, ℝ)), Measurable (fun ω => ∫ x, f x ∂μ n ω))
+    (hlim : ∀ ω (f : C_c(X, ℝ)), Tendsto (fun n => ∫ x, f x ∂μ n ω)
+      atTop (𝓝 (∫ x, f x ∂ν ω))) : Measurable ν := by
+  apply measurable_radon_of_tests ν hν
+  intro f
+  exact measurable_of_tendsto_metrizable (fun n => hmeas n f)
+    (tendsto_pi_nhds.mpr (fun ω => hlim ω f))
+
+end SLEExactGauge
+
+end
+
+end OAI