Sync from openai/math@faee2cf485a8 (part 19)

lean/OAI/Probability/SLE/Mass/RandomRadonLimit.lean

@@ -1,116 +1,116 @@
-import OAI.Probability.SLE.Mass.RadonTestMeasurability
-
-namespace OAI
-
-/-! Measurable selection of the pathwise Radon limit. Only a measurable
-full-measure set is retained; the limit is set to zero on its complement. -/
-
-noncomputable section
-open Set Filter MeasureTheory Classical
-open scoped Topology CompactlySupported
-
-namespace SLEExactGauge
-
-variable {X : Type*} [TopologicalSpace X] [T2Space X] [LocallyCompactSpace X]
-  [SecondCountableTopology X] [MeasurableSpace X] [BorelSpace X]
-
-/-- An almost-sure regular vague limit of random positive measures has a
-measurable regular version. The approximants need only have measurable
-compact-test integrals. -/
-theorem exists_measurable_random_radon_limit
-    {Ω : Type*} [MeasurableSpace Ω] (P : Measure Ω) (μ : ℕ → Ω → Measure X)
-    (hmeas : ∀ n (f : C_c(X,ℝ)), Measurable (fun ω => ∫ x, f x ∂μ n ω))
-    (hex : ∀ᵐ ω ∂P, ∃ ν : Measure X, ν.Regular ∧
-      ∀ f : C_c(X,ℝ), Tendsto (fun n => ∫ x, f x ∂μ n ω) atTop (𝓝 (∫ x, f x ∂ν))) :
-    ∃ ν : Ω → Measure X, Measurable ν ∧
-      (∀ ω, (ν ω).Regular ∧ IsFiniteMeasureOnCompacts (ν ω)) ∧
-      ∀ᵐ ω ∂P, ∀ f : C_c(X,ℝ),
-        Tendsto (fun n => ∫ x, f x ∂μ n ω) atTop (𝓝 (∫ x, f x ∂ν ω)) := by
-  let good (ω : Ω) : Prop := ∃ ν : Measure X, ν.Regular ∧
-    ∀ f : C_c(X,ℝ), Tendsto (fun n => ∫ x, f x ∂μ n ω) atTop (𝓝 (∫ x, f x ∂ν))
-  have hnull : P {ω | ¬good ω}=0 := ae_iff.mp hex
-  obtain ⟨N,hN,hNm,hN0⟩ := exists_measurable_superset_of_null hnull
-  have hgood (ω : Ω) (hω : ω ∉ N) : good ω := by
-    by_contra h
-    exact hω (hN h)
-  have hall (ω : Ω) : ∃ ν : Measure X, ν.Regular ∧
-      ∀ f : C_c(X,ℝ), Tendsto (fun n => if ω ∈ N then (0:ℝ) else ∫ x, f x ∂μ n ω)
-        atTop (𝓝 (∫ x, f x ∂ν)) := by
-    by_cases hω : ω ∈ N
-    · refine ⟨0,inferInstance,fun f => ?_⟩
-      simpa only [ite_eq_left hω,integral_zero_measure] using
-        (tendsto_const_nhds : Tendsto (fun _ : ℕ => (0:ℝ)) atTop (𝓝 0))
-    · obtain ⟨ν,hν,hlim⟩ := hgood ω hω
-      exact ⟨ν,hν,fun f => by simpa only [ite_eq_right hω] using hlim f⟩
-  choose ν hν hlim using hall
-  have hνm : Measurable ν := by
-    apply measurable_radon_of_tests ν hν
-    intro f
-    apply measurable_of_tendsto_metrizable
-      (f := fun n ω => if ω ∈ N then (0:ℝ) else ∫ x, f x ∂μ n ω)
-    · intro n
-      exact measurable_const.ite hNm (hmeas n f)
-    · exact tendsto_pi_nhds.mpr (fun ω => hlim ω f)
-  refine ⟨ν,hνm,fun ω => ?_,?_⟩
-  · let : (ν ω).Regular := hν ω
-    exact ⟨hν ω,inferInstance⟩
-  · filter_upwards [compl_mem_ae_iff.mpr hN0] with ω hω
-    intro f
-    simpa only [ite_eq_right hω] using hlim ω f
-
-/-- Countably many times retain one common event of convergence, and each
-selected time slice is a measurable locally finite regular random measure. -/
-theorem exists_measurable_countable_radon_limits
-    {Ω : Type*} [MeasurableSpace Ω] (P : Measure Ω) (μ : ℕ → ℕ → Ω → Measure X)
-    (hmeas : ∀ n j (f : C_c(X,ℝ)), Measurable (fun ω => ∫ x, f x ∂μ n j ω))
-    (hex : ∀ᵐ ω ∂P, ∃ ν : ℕ → Measure X, (∀ j, (ν j).Regular) ∧
-      ∀ j (f : C_c(X,ℝ)), Tendsto (fun n => ∫ x, f x ∂μ n j ω) atTop (𝓝 (∫ x, f x ∂ν j))) :
-    ∃ ν : ℕ → Ω → Measure X, (∀ j, Measurable (ν j)) ∧
-      (∀ j ω, (ν j ω).Regular ∧ IsFiniteMeasureOnCompacts (ν j ω)) ∧
-      ∀ᵐ ω ∂P, ∀ j (f : C_c(X,ℝ)),
-        Tendsto (fun n => ∫ x, f x ∂μ n j ω) atTop (𝓝 (∫ x, f x ∂ν j ω)) := by
-  have hj (j : ℕ) : ∀ᵐ ω ∂P, ∃ ν : Measure X, ν.Regular ∧
-      ∀ f : C_c(X,ℝ), Tendsto (fun n => ∫ x, f x ∂μ n j ω) atTop (𝓝 (∫ x, f x ∂ν)) := by
-    filter_upwards [hex] with ω hω
-    obtain ⟨ν,hν,hlim⟩ := hω
-    exact ⟨ν j,hν j,hlim j⟩
-  choose ν hνm hνr hlim using fun j =>
-    exists_measurable_random_radon_limit P (fun n => μ n j) (fun n => hmeas n j) (hj j)
-  exact ⟨ν,hνm,hνr,ae_all_iff.mpr hlim⟩
-
-omit [SecondCountableTopology X] in
-/-- Regular vague limits of the same sequence are unique. -/
-theorem radon_test_limit_unique (μ : ℕ → Measure X) (ν η : 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 ∂η))) :
-    ν=η :=
-  Measure.ext_of_integral_eq_on_compactlySupported fun f => tendsto_nhds_unique (hν f) (hη f)
-
-/-- Any pathwise version of the same limit is almost everywhere
-measurable, useful when the approximants are measurable in a smaller
-stopped or deterministic-time sigma algebra. -/
-theorem aemeasurable_radon_of_test_limits_ae
-    {Ω : Type*} [MeasurableSpace Ω] (P : Measure Ω) (μ : ℕ → Ω → Measure X)
-    (ν : Ω → Measure X)
-    (hmeas : ∀ n (f : C_c(X,ℝ)), Measurable (fun ω => ∫ x, f x ∂μ n ω))
-    (hν : ∀ᵐ ω ∂P, (ν ω).Regular)
-    (hlim : ∀ᵐ ω ∂P, ∀ f : C_c(X,ℝ),
-      Tendsto (fun n => ∫ x, f x ∂μ n ω) atTop (𝓝 (∫ x, f x ∂ν ω))) :
-    AEMeasurable ν P := by
-  have hex : ∀ᵐ ω ∂P, ∃ η : Measure X, η.Regular ∧
-      ∀ f : C_c(X,ℝ), Tendsto (fun n => ∫ x, f x ∂μ n ω) atTop (𝓝 (∫ x, f x ∂η)) := by
-    filter_upwards [hν,hlim] with ω hr hl
-    exact ⟨ν ω,hr,hl⟩
-  obtain ⟨η,hηm,hηr,hηlim⟩ := exists_measurable_random_radon_limit P μ hmeas hex
-  apply hηm.aemeasurable.congr
-  filter_upwards [hν,hlim,hηlim] with ω hr hl hηl
-  let : (ν ω).Regular := hr
-  let : (η ω).Regular := (hηr ω).1
-  exact (radon_test_limit_unique (fun n => μ n ω) (ν ω) (η ω) hl hηl).symm
-
-end SLEExactGauge
-
-end
-
-end OAI
+import OAI.Probability.SLE.Mass.RadonTestMeasurability
+
+namespace OAI
+
+/-! Measurable selection of the pathwise Radon limit. Only a measurable
+full-measure set is retained; the limit is set to zero on its complement. -/
+
+noncomputable section
+open Set Filter MeasureTheory Classical
+open scoped Topology CompactlySupported
+
+namespace SLEExactGauge
+
+variable {X : Type*} [TopologicalSpace X] [T2Space X] [LocallyCompactSpace X]
+  [SecondCountableTopology X] [MeasurableSpace X] [BorelSpace X]
+
+/-- An almost-sure regular vague limit of random positive measures has a
+measurable regular version. The approximants need only have measurable
+compact-test integrals. -/
+theorem exists_measurable_random_radon_limit
+    {Ω : Type*} [MeasurableSpace Ω] (P : Measure Ω) (μ : ℕ → Ω → Measure X)
+    (hmeas : ∀ n (f : C_c(X,ℝ)), Measurable (fun ω => ∫ x, f x ∂μ n ω))
+    (hex : ∀ᵐ ω ∂P, ∃ ν : Measure X, ν.Regular ∧
+      ∀ f : C_c(X,ℝ), Tendsto (fun n => ∫ x, f x ∂μ n ω) atTop (𝓝 (∫ x, f x ∂ν))) :
+    ∃ ν : Ω → Measure X, Measurable ν ∧
+      (∀ ω, (ν ω).Regular ∧ IsFiniteMeasureOnCompacts (ν ω)) ∧
+      ∀ᵐ ω ∂P, ∀ f : C_c(X,ℝ),
+        Tendsto (fun n => ∫ x, f x ∂μ n ω) atTop (𝓝 (∫ x, f x ∂ν ω)) := by
+  let good (ω : Ω) : Prop := ∃ ν : Measure X, ν.Regular ∧
+    ∀ f : C_c(X,ℝ), Tendsto (fun n => ∫ x, f x ∂μ n ω) atTop (𝓝 (∫ x, f x ∂ν))
+  have hnull : P {ω | ¬good ω}=0 := ae_iff.mp hex
+  obtain ⟨N,hN,hNm,hN0⟩ := exists_measurable_superset_of_null hnull
+  have hgood (ω : Ω) (hω : ω ∉ N) : good ω := by
+    by_contra h
+    exact hω (hN h)
+  have hall (ω : Ω) : ∃ ν : Measure X, ν.Regular ∧
+      ∀ f : C_c(X,ℝ), Tendsto (fun n => if ω ∈ N then (0:ℝ) else ∫ x, f x ∂μ n ω)
+        atTop (𝓝 (∫ x, f x ∂ν)) := by
+    by_cases hω : ω ∈ N
+    · refine ⟨0,inferInstance,fun f => ?_⟩
+      simpa only [ite_eq_left hω,integral_zero_measure] using
+        (tendsto_const_nhds : Tendsto (fun _ : ℕ => (0:ℝ)) atTop (𝓝 0))
+    · obtain ⟨ν,hν,hlim⟩ := hgood ω hω
+      exact ⟨ν,hν,fun f => by simpa only [ite_eq_right hω] using hlim f⟩
+  choose ν hν hlim using hall
+  have hνm : Measurable ν := by
+    apply measurable_radon_of_tests ν hν
+    intro f
+    apply measurable_of_tendsto_metrizable
+      (f := fun n ω => if ω ∈ N then (0:ℝ) else ∫ x, f x ∂μ n ω)
+    · intro n
+      exact measurable_const.ite hNm (hmeas n f)
+    · exact tendsto_pi_nhds.mpr (fun ω => hlim ω f)
+  refine ⟨ν,hνm,fun ω => ?_,?_⟩
+  · let : (ν ω).Regular := hν ω
+    exact ⟨hν ω,inferInstance⟩
+  · filter_upwards [compl_mem_ae_iff.mpr hN0] with ω hω
+    intro f
+    simpa only [ite_eq_right hω] using hlim ω f
+
+/-- Countably many times retain one common event of convergence, and each
+selected time slice is a measurable locally finite regular random measure. -/
+theorem exists_measurable_countable_radon_limits
+    {Ω : Type*} [MeasurableSpace Ω] (P : Measure Ω) (μ : ℕ → ℕ → Ω → Measure X)
+    (hmeas : ∀ n j (f : C_c(X,ℝ)), Measurable (fun ω => ∫ x, f x ∂μ n j ω))
+    (hex : ∀ᵐ ω ∂P, ∃ ν : ℕ → Measure X, (∀ j, (ν j).Regular) ∧
+      ∀ j (f : C_c(X,ℝ)), Tendsto (fun n => ∫ x, f x ∂μ n j ω) atTop (𝓝 (∫ x, f x ∂ν j))) :
+    ∃ ν : ℕ → Ω → Measure X, (∀ j, Measurable (ν j)) ∧
+      (∀ j ω, (ν j ω).Regular ∧ IsFiniteMeasureOnCompacts (ν j ω)) ∧
+      ∀ᵐ ω ∂P, ∀ j (f : C_c(X,ℝ)),
+        Tendsto (fun n => ∫ x, f x ∂μ n j ω) atTop (𝓝 (∫ x, f x ∂ν j ω)) := by
+  have hj (j : ℕ) : ∀ᵐ ω ∂P, ∃ ν : Measure X, ν.Regular ∧
+      ∀ f : C_c(X,ℝ), Tendsto (fun n => ∫ x, f x ∂μ n j ω) atTop (𝓝 (∫ x, f x ∂ν)) := by
+    filter_upwards [hex] with ω hω
+    obtain ⟨ν,hν,hlim⟩ := hω
+    exact ⟨ν j,hν j,hlim j⟩
+  choose ν hνm hνr hlim using fun j =>
+    exists_measurable_random_radon_limit P (fun n => μ n j) (fun n => hmeas n j) (hj j)
+  exact ⟨ν,hνm,hνr,ae_all_iff.mpr hlim⟩
+
+omit [SecondCountableTopology X] in
+/-- Regular vague limits of the same sequence are unique. -/
+theorem radon_test_limit_unique (μ : ℕ → Measure X) (ν η : 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 ∂η))) :
+    ν=η :=
+  Measure.ext_of_integral_eq_on_compactlySupported fun f => tendsto_nhds_unique (hν f) (hη f)
+
+/-- Any pathwise version of the same limit is almost everywhere
+measurable, useful when the approximants are measurable in a smaller
+stopped or deterministic-time sigma algebra. -/
+theorem aemeasurable_radon_of_test_limits_ae
+    {Ω : Type*} [MeasurableSpace Ω] (P : Measure Ω) (μ : ℕ → Ω → Measure X)
+    (ν : Ω → Measure X)
+    (hmeas : ∀ n (f : C_c(X,ℝ)), Measurable (fun ω => ∫ x, f x ∂μ n ω))
+    (hν : ∀ᵐ ω ∂P, (ν ω).Regular)
+    (hlim : ∀ᵐ ω ∂P, ∀ f : C_c(X,ℝ),
+      Tendsto (fun n => ∫ x, f x ∂μ n ω) atTop (𝓝 (∫ x, f x ∂ν ω))) :
+    AEMeasurable ν P := by
+  have hex : ∀ᵐ ω ∂P, ∃ η : Measure X, η.Regular ∧
+      ∀ f : C_c(X,ℝ), Tendsto (fun n => ∫ x, f x ∂μ n ω) atTop (𝓝 (∫ x, f x ∂η)) := by
+    filter_upwards [hν,hlim] with ω hr hl
+    exact ⟨ν ω,hr,hl⟩
+  obtain ⟨η,hηm,hηr,hηlim⟩ := exists_measurable_random_radon_limit P μ hmeas hex
+  apply hηm.aemeasurable.congr
+  filter_upwards [hν,hlim,hηlim] with ω hr hl hηl
+  let : (ν ω).Regular := hr
+  let : (η ω).Regular := (hηr ω).1
+  exact (radon_test_limit_unique (fun n => μ n ω) (ν ω) (η ω) hl hηl).symm
+
+end SLEExactGauge
+
+end
+
+end OAI

lean/OAI/Probability/SLE/Mass/RationalCanonicalMass.lean

@@ -1,190 +1,190 @@
-import OAI.Probability.SLE.Mass.LevelRemainderSupport
-import OAI.Probability.SLE.Mass.RationalMassFromSupports
-import OAI.Probability.SLE.Mass.CountableLevelAdapted
-import OAI.Probability.SLE.Mass.LevelRadonNonatomic
-
-namespace OAI
-
-/-! The actual common convex-tail construction at rational times, with
-adapted versions, positive trace increments and its conditional Green kernel. -/
-
-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 rationalMassTime (n : ℕ) : ℝ≥0 :=
-  (((Encodable.decode (α := ℚ) n).getD 0 : ℚ) : ℝ).toNNReal
-
-@[simp] lemma rationalMassTime_encode (q : ℚ) :
-    rationalMassTime (Encodable.encode q) = (q : ℝ).toNNReal := by
-  simp only [rationalMassTime,Encodable.encodek,Option.getD_some]
-
-structure RationalCanonicalMass
-    {Ω : Type*} [MeasurableSpace Ω] (P : Measure Ω) (κ : ℝ)
-    (B : ℝ≥0 → Ω → ℝ) (hBm : Measurable (Function.uncurry B))
-    (γ : Ω → ℝ≥0 → ℂ) (G : Ω → ℝ≥0 → ℂ → ℂ) where
-  terminal : Ω → Measure upperHalfPlane
-  mass : ℚ → Ω → Measure upperHalfPlane
-  terminal_measurable : Measurable terminal
-  mass_measurable : ∀ q : ℚ, Measurable[Filtration.natural B (fun r =>
-    (hBm.comp (measurable_const.prodMk measurable_id) : Measurable (B r)).stronglyMeasurable)
-      (q : ℝ).toNNReal] (mass q)
-  terminal_radon : ∀ ω, (terminal ω).Regular ∧ IsFiniteMeasureOnCompacts (terminal ω)
-  mass_radon : ∀ q ω, (mass q ω).Regular ∧ IsFiniteMeasureOnCompacts (mass q ω)
-  supports : ℕ → Finset ℕ
-  weights : ℕ → ℕ → ℝ
-  weights_nonneg : ∀ n i, i ∈ supports n → 0 ≤ weights n i
-  weights_sum : ∀ n, ∑ i ∈ supports n, weights n i = 1
-  terminal_limit : ∀ᵐ ω ∂P, ∀ f : C_c(upperHalfPlane,ℝ),
-    Tendsto (fun n => ∫ z, f z ∂convexLevelMeasure κ B γ G (fun n => (n:ℝ))
-      supports weights n ∞ ω) atTop (𝓝 (∫ z, f z ∂terminal ω))
-  mass_limit : ∀ᵐ ω ∂P, ∀ (q : ℚ) (f : C_c(upperHalfPlane,ℝ)),
-    Tendsto (fun n => ∫ z, f z ∂convexLevelMeasure κ B γ G (fun n => (n:ℝ))
-      supports weights n (q : ℝ).toNNReal ω) atTop (𝓝 (∫ z, f z ∂mass q ω))
-  zero : ∀ᵐ ω ∂P, mass 0 ω = 0
-  increments : ∀ᵐ ω ∂P,
-    HalfPlaneTraceIncrements (fun q => mass q ω) (terminal ω) (fun r => γ ω r.toNNReal)
-  nonatomic : ∀ᵐ ω ∂P, NullSingletonClass (terminal ω)
-  moments : ∀ K : Set upperHalfPlane, IsCompact K → ∀ m : ℕ,
-    (∫⁻ ω, terminal ω K ^ m ∂P) < ∞
-  mean : P.bind terminal = initialGreenMeasure κ
-  conditional : ∀ q : ℚ, ∀ E : Set Ω,
-    MeasurableSet[Filtration.natural B (fun r =>
-      (hBm.comp (measurable_const.prodMk measurable_id) : Measurable (B r)).stronglyMeasurable)
-        (q : ℝ).toNNReal] E →
-    (P.restrict E).bind terminal = (P.restrict E).bind (mass q) +
-      (P.restrict E).bind (halfPlaneGreenMeasure κ B γ G (q : ℝ).toNNReal)
-
-theorem exists_rationalCanonicalMass
-    {Ω : 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) :
-    Nonempty (RationalCanonicalMass P κ B hBm γ G) := by
-  obtain ⟨s,w,ν,η,hw₀,hw₁,hνm,hν,hlim,hηm,hη,hηsum,hmean,hkernel⟩ :=
-    exists_countable_radon_remainder_kernels hB hm hBm hBc hB0 hκ hκ8 γ G F hw hgrowth
-      rationalMassTime
-  have hfiniteLimit : ∀ᵐ ω ∂P, ∀ j (f : C_c(upperHalfPlane,ℝ)),
-      Tendsto (fun n => ∫ z, f z ∂convexLevelMeasure κ B γ G (fun n => (n:ℝ))
-        s w n (rationalMassTime j) ω) atTop (𝓝 (∫ z, f z ∂ν (j+1) ω)) := by
-    filter_upwards [hlim] with ω hω
-    intro j f
-    simpa only [levelMassTimes_succ] using hω (j+1) f
-  obtain ⟨M,hMm,hMr,hMeq⟩ := countable_level_limits_have_past_versions P
-    (fun r => hBm.comp (measurable_const.prodMk measurable_id)) hBc hκ hκ8 γ G F hw
-    (fun n => (n:ℝ)) (fun n => Nat.cast_nonneg n) s w hw₀ rationalMassTime
-    (fun j => ν (j+1)) (Eventually.of_forall (fun ω j => (hν (j+1) ω).1)) hfiniteLimit
-  let μ (q : ℚ) := M (Encodable.encode q)
-  have hμeq : ∀ᵐ ω ∂P, ∀ q, μ q ω = ν (Encodable.encode q+1) ω := by
-    filter_upwards [hMeq] with ω hω
-    exact fun q => hω _
-  have hμlim : ∀ᵐ ω ∂P, ∀ (q : ℚ) (f : C_c(upperHalfPlane,ℝ)),
-      Tendsto (fun n => ∫ z, f z ∂convexLevelMeasure κ B γ G (fun n => (n:ℝ))
-        s w n (q:ℝ).toNNReal ω) atTop (𝓝 (∫ z, f z ∂μ q ω)) := by
-    filter_upwards [hfiniteLimit,hμeq] with ω hl he
-    intro q f
-    rw [he q]
-    simpa only [rationalMassTime_encode] using hl (Encodable.encode q) f
-  have htermLimit : ∀ᵐ ω ∂P, ∀ f : C_c(upperHalfPlane,ℝ),
-      Tendsto (fun n => ∫ z, f z ∂convexLevelMeasure κ B γ G (fun n => (n:ℝ))
-        s w n ∞ ω) atTop (𝓝 (∫ z, f z ∂ν 0 ω)) := by
-    filter_upwards [hlim] with ω hω
-    exact hω 0
-  have hfuture (j : ℕ) := ae_remainder_carried_by_surviving hB hBm hBc hB0 hκ hκ8 γ G F hw
-    (rationalMassTime j) (η j) (hηm j) (fun ω => (hη j ω).2) (hkernel j)
-  have hinc : ∀ᵐ ω ∂P,
-      HalfPlaneTraceIncrements (fun q => μ q ω) (ν 0 ω) (fun r => γ ω r.toNNReal) := by
-    filter_upwards [hμlim,htermLimit,hμeq,hηsum,ae_all_iff.mpr hfuture] with ω hl ht he hs hf
-    let : (ν 0 ω).Regular := (hν 0 ω).1
-    let (q : ℚ) : (μ q ω).Regular := (hMr (Encodable.encode q) ω).1
-    let (q : ℚ) : IsFiniteMeasureOnCompacts (μ q ω) := (hMr (Encodable.encode q) ω).2
-    let (n : ℕ) (v : ℝ≥0∞) : IsFiniteMeasureOnCompacts
-        (convexLevelMeasure κ B γ G (fun n => (n:ℝ)) s w n v ω) :=
-      convexLevelMeasure_finite_on_compacts hκ hκ8 γ G F ω (hBc ω) (hw ω) _ s w n v
-    have hdom (q : ℚ) : μ q ω ≤ ν 0 ω := by
-      apply radon_limits_mono _ _ _ _ (hl q) ht
-      intro n
-      exact convexLevelMeasure_mono κ B γ G (fun n => (n:ℝ)) s w n ω le_top
-    have hmono : Monotone (fun q => μ q ω) := by
-      intro p q hpq
-      let (n : ℕ) : IsFiniteMeasureOnCompacts
-          (convexLevelMeasure κ B γ G (fun n => (n:ℝ)) s w n (p:ℝ).toNNReal ω) :=
-        convexLevelMeasure_finite_on_compacts hκ hκ8 γ G F ω (hBc ω) (hw ω) _ s w n _
-      apply radon_limits_mono _ _ _ _ (hl p) (hl q)
-      intro n
-      exact convexLevelMeasure_mono κ B γ G (fun n => (n:ℝ)) s w n ω
-        (ENNReal.coe_le_coe.mpr (Real.toNNReal_mono (Rat.cast_le.mpr hpq)))
-    have hzero (q : ℚ) (hq : q ≤ 0) : μ q ω = 0 := by
-      apply convex_level_radon_limit_zero_at_zero ω (hBc ω) (hw ω) (fun n => (n:ℝ))
-        tendsto_natCast_atTop_atTop s w (μ q ω)
-      simpa only [Real.toNNReal_eq_zero.mpr (Rat.cast_nonpos.mpr hq),ENNReal.coe_zero] using hl q
-    apply halfPlaneTraceIncrements_of_past_and_future (fun q => μ q ω) (ν 0 ω) (γ ω)
-      (fun q => (hMr (Encodable.encode q) ω).1) hdom hmono hzero
-    · intro q _
-      exact convex_level_radon_limit_carried_by_past ω (hBc ω) (hw ω) _ (fun n => (n:ℝ))
-        tendsto_natCast_atTop_atTop s w (μ q ω) (hl q)
-    · intro q _
-      have heη : η (Encodable.encode q) ω = ν 0 ω-μ q ω := by
-        apply (Measure.add_left_inj (μ q ω) _ _).mp
-        rw [sigmaFinite_sub_add_cancel_of_le (hdom q),he q]
-        exact hs _
-      rw [← heη]
-      simpa only [rationalMassTime_encode] using hf (Encodable.encode q)
-  refine ⟨{
-    terminal := ν 0
-    mass := μ
-    terminal_measurable := hνm 0
-    mass_measurable := ?_
-    terminal_radon := hν 0
-    mass_radon := fun q => hMr (Encodable.encode q)
-    supports := s
-    weights := w
-    weights_nonneg := hw₀
-    weights_sum := hw₁
-    terminal_limit := htermLimit
-    mass_limit := hμlim
-    zero := ?_
-    increments := hinc
-    nonatomic := ?_
-    moments := ?_
-    mean := hmean
-    conditional := ?_ }⟩
-  · intro q
-    simpa +instances only [rationalMassTime_encode,Function.comp_def,Function.uncurry] using hMm (Encodable.encode q)
-  · filter_upwards [hμlim] with ω hω
-    let : (μ 0 ω).Regular := (hMr (Encodable.encode (0:ℚ)) ω).1
-    apply convex_level_radon_limit_zero_at_zero ω (hBc ω) (hw ω) (fun n => (n:ℝ))
-      tendsto_natCast_atTop_atTop s w (μ 0 ω)
-    simpa only [Rat.cast_zero,Real.toNNReal_zero,ENNReal.coe_zero] using hω 0
-  · exact level_radon_limit_nonatomic hB hm hBm hBc hB0 hκ hκ8 γ G F hw hgrowth
-      (fun n => (n:ℝ)) (fun n => Nat.cast_nonneg n) s w hw₀ hw₁ ∞ (ν 0) (hνm 0)
-      (fun ω => (hν 0 ω).2) htermLimit
-  · intro K hK m
-    exact level_radon_limit_compact_moments hB hm hBm hBc hB0 hκ hκ8 γ G F hw hgrowth
-      (fun n => (n:ℝ)) (fun n => Nat.cast_nonneg n) s w hw₀ hw₁ ∞ (ν 0)
-      (fun ω => (hν 0 ω).2) htermLimit K hK m
-  · intro q E hE
-    have hμm : Measurable (μ q) := (hMm (Encodable.encode q)).mono (Filtration.le _ _) le_rfl
-    have hs : ∀ᵐ ω ∂P, η (Encodable.encode q) ω + μ q ω = ν 0 ω := by
-      filter_upwards [hμeq,hηsum] with ω he hs
-      rw [he q]
-      exact hs _
-    have hc := bind_add_of_ae (P.restrict E) (μ q) (ν 0) (η (Encodable.encode q))
-      hμm (hνm 0) (hηm _) (ae_restrict_of_ae hs)
-    rw [← hc,add_comm]
-    congr 1
-    simpa only [rationalMassTime_encode] using hkernel (Encodable.encode q) E (by simpa +instances only [rationalMassTime_encode] using hE)
-
-end SLEExactGauge.Multipoint
-
-end
-
-end OAI
+import OAI.Probability.SLE.Mass.LevelRemainderSupport
+import OAI.Probability.SLE.Mass.RationalMassFromSupports
+import OAI.Probability.SLE.Mass.CountableLevelAdapted
+import OAI.Probability.SLE.Mass.LevelRadonNonatomic
+
+namespace OAI
+
+/-! The actual common convex-tail construction at rational times, with
+adapted versions, positive trace increments and its conditional Green kernel. -/
+
+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 rationalMassTime (n : ℕ) : ℝ≥0 :=
+  (((Encodable.decode (α := ℚ) n).getD 0 : ℚ) : ℝ).toNNReal
+
+@[simp] lemma rationalMassTime_encode (q : ℚ) :
+    rationalMassTime (Encodable.encode q) = (q : ℝ).toNNReal := by
+  simp only [rationalMassTime,Encodable.encodek,Option.getD_some]
+
+structure RationalCanonicalMass
+    {Ω : Type*} [MeasurableSpace Ω] (P : Measure Ω) (κ : ℝ)
+    (B : ℝ≥0 → Ω → ℝ) (hBm : Measurable (Function.uncurry B))
+    (γ : Ω → ℝ≥0 → ℂ) (G : Ω → ℝ≥0 → ℂ → ℂ) where
+  terminal : Ω → Measure upperHalfPlane
+  mass : ℚ → Ω → Measure upperHalfPlane
+  terminal_measurable : Measurable terminal
+  mass_measurable : ∀ q : ℚ, Measurable[Filtration.natural B (fun r =>
+    (hBm.comp (measurable_const.prodMk measurable_id) : Measurable (B r)).stronglyMeasurable)
+      (q : ℝ).toNNReal] (mass q)
+  terminal_radon : ∀ ω, (terminal ω).Regular ∧ IsFiniteMeasureOnCompacts (terminal ω)
+  mass_radon : ∀ q ω, (mass q ω).Regular ∧ IsFiniteMeasureOnCompacts (mass q ω)
+  supports : ℕ → Finset ℕ
+  weights : ℕ → ℕ → ℝ
+  weights_nonneg : ∀ n i, i ∈ supports n → 0 ≤ weights n i
+  weights_sum : ∀ n, ∑ i ∈ supports n, weights n i = 1
+  terminal_limit : ∀ᵐ ω ∂P, ∀ f : C_c(upperHalfPlane,ℝ),
+    Tendsto (fun n => ∫ z, f z ∂convexLevelMeasure κ B γ G (fun n => (n:ℝ))
+      supports weights n ∞ ω) atTop (𝓝 (∫ z, f z ∂terminal ω))
+  mass_limit : ∀ᵐ ω ∂P, ∀ (q : ℚ) (f : C_c(upperHalfPlane,ℝ)),
+    Tendsto (fun n => ∫ z, f z ∂convexLevelMeasure κ B γ G (fun n => (n:ℝ))
+      supports weights n (q : ℝ).toNNReal ω) atTop (𝓝 (∫ z, f z ∂mass q ω))
+  zero : ∀ᵐ ω ∂P, mass 0 ω = 0
+  increments : ∀ᵐ ω ∂P,
+    HalfPlaneTraceIncrements (fun q => mass q ω) (terminal ω) (fun r => γ ω r.toNNReal)
+  nonatomic : ∀ᵐ ω ∂P, NullSingletonClass (terminal ω)
+  moments : ∀ K : Set upperHalfPlane, IsCompact K → ∀ m : ℕ,
+    (∫⁻ ω, terminal ω K ^ m ∂P) < ∞
+  mean : P.bind terminal = initialGreenMeasure κ
+  conditional : ∀ q : ℚ, ∀ E : Set Ω,
+    MeasurableSet[Filtration.natural B (fun r =>
+      (hBm.comp (measurable_const.prodMk measurable_id) : Measurable (B r)).stronglyMeasurable)
+        (q : ℝ).toNNReal] E →
+    (P.restrict E).bind terminal = (P.restrict E).bind (mass q) +
+      (P.restrict E).bind (halfPlaneGreenMeasure κ B γ G (q : ℝ).toNNReal)
+
+theorem exists_rationalCanonicalMass
+    {Ω : 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) :
+    Nonempty (RationalCanonicalMass P κ B hBm γ G) := by
+  obtain ⟨s,w,ν,η,hw₀,hw₁,hνm,hν,hlim,hηm,hη,hηsum,hmean,hkernel⟩ :=
+    exists_countable_radon_remainder_kernels hB hm hBm hBc hB0 hκ hκ8 γ G F hw hgrowth
+      rationalMassTime
+  have hfiniteLimit : ∀ᵐ ω ∂P, ∀ j (f : C_c(upperHalfPlane,ℝ)),
+      Tendsto (fun n => ∫ z, f z ∂convexLevelMeasure κ B γ G (fun n => (n:ℝ))
+        s w n (rationalMassTime j) ω) atTop (𝓝 (∫ z, f z ∂ν (j+1) ω)) := by
+    filter_upwards [hlim] with ω hω
+    intro j f
+    simpa only [levelMassTimes_succ] using hω (j+1) f
+  obtain ⟨M,hMm,hMr,hMeq⟩ := countable_level_limits_have_past_versions P
+    (fun r => hBm.comp (measurable_const.prodMk measurable_id)) hBc hκ hκ8 γ G F hw
+    (fun n => (n:ℝ)) (fun n => Nat.cast_nonneg n) s w hw₀ rationalMassTime
+    (fun j => ν (j+1)) (Eventually.of_forall (fun ω j => (hν (j+1) ω).1)) hfiniteLimit
+  let μ (q : ℚ) := M (Encodable.encode q)
+  have hμeq : ∀ᵐ ω ∂P, ∀ q, μ q ω = ν (Encodable.encode q+1) ω := by
+    filter_upwards [hMeq] with ω hω
+    exact fun q => hω _
+  have hμlim : ∀ᵐ ω ∂P, ∀ (q : ℚ) (f : C_c(upperHalfPlane,ℝ)),
+      Tendsto (fun n => ∫ z, f z ∂convexLevelMeasure κ B γ G (fun n => (n:ℝ))
+        s w n (q:ℝ).toNNReal ω) atTop (𝓝 (∫ z, f z ∂μ q ω)) := by
+    filter_upwards [hfiniteLimit,hμeq] with ω hl he
+    intro q f
+    rw [he q]
+    simpa only [rationalMassTime_encode] using hl (Encodable.encode q) f
+  have htermLimit : ∀ᵐ ω ∂P, ∀ f : C_c(upperHalfPlane,ℝ),
+      Tendsto (fun n => ∫ z, f z ∂convexLevelMeasure κ B γ G (fun n => (n:ℝ))
+        s w n ∞ ω) atTop (𝓝 (∫ z, f z ∂ν 0 ω)) := by
+    filter_upwards [hlim] with ω hω
+    exact hω 0
+  have hfuture (j : ℕ) := ae_remainder_carried_by_surviving hB hBm hBc hB0 hκ hκ8 γ G F hw
+    (rationalMassTime j) (η j) (hηm j) (fun ω => (hη j ω).2) (hkernel j)
+  have hinc : ∀ᵐ ω ∂P,
+      HalfPlaneTraceIncrements (fun q => μ q ω) (ν 0 ω) (fun r => γ ω r.toNNReal) := by
+    filter_upwards [hμlim,htermLimit,hμeq,hηsum,ae_all_iff.mpr hfuture] with ω hl ht he hs hf
+    let : (ν 0 ω).Regular := (hν 0 ω).1
+    let (q : ℚ) : (μ q ω).Regular := (hMr (Encodable.encode q) ω).1
+    let (q : ℚ) : IsFiniteMeasureOnCompacts (μ q ω) := (hMr (Encodable.encode q) ω).2
+    let (n : ℕ) (v : ℝ≥0∞) : IsFiniteMeasureOnCompacts
+        (convexLevelMeasure κ B γ G (fun n => (n:ℝ)) s w n v ω) :=
+      convexLevelMeasure_finite_on_compacts hκ hκ8 γ G F ω (hBc ω) (hw ω) _ s w n v
+    have hdom (q : ℚ) : μ q ω ≤ ν 0 ω := by
+      apply radon_limits_mono _ _ _ _ (hl q) ht
+      intro n
+      exact convexLevelMeasure_mono κ B γ G (fun n => (n:ℝ)) s w n ω le_top
+    have hmono : Monotone (fun q => μ q ω) := by
+      intro p q hpq
+      let (n : ℕ) : IsFiniteMeasureOnCompacts
+          (convexLevelMeasure κ B γ G (fun n => (n:ℝ)) s w n (p:ℝ).toNNReal ω) :=
+        convexLevelMeasure_finite_on_compacts hκ hκ8 γ G F ω (hBc ω) (hw ω) _ s w n _
+      apply radon_limits_mono _ _ _ _ (hl p) (hl q)
+      intro n
+      exact convexLevelMeasure_mono κ B γ G (fun n => (n:ℝ)) s w n ω
+        (ENNReal.coe_le_coe.mpr (Real.toNNReal_mono (Rat.cast_le.mpr hpq)))
+    have hzero (q : ℚ) (hq : q ≤ 0) : μ q ω = 0 := by
+      apply convex_level_radon_limit_zero_at_zero ω (hBc ω) (hw ω) (fun n => (n:ℝ))
+        tendsto_natCast_atTop_atTop s w (μ q ω)
+      simpa only [Real.toNNReal_eq_zero.mpr (Rat.cast_nonpos.mpr hq),ENNReal.coe_zero] using hl q
+    apply halfPlaneTraceIncrements_of_past_and_future (fun q => μ q ω) (ν 0 ω) (γ ω)
+      (fun q => (hMr (Encodable.encode q) ω).1) hdom hmono hzero
+    · intro q _
+      exact convex_level_radon_limit_carried_by_past ω (hBc ω) (hw ω) _ (fun n => (n:ℝ))
+        tendsto_natCast_atTop_atTop s w (μ q ω) (hl q)
+    · intro q _
+      have heη : η (Encodable.encode q) ω = ν 0 ω-μ q ω := by
+        apply (Measure.add_left_inj (μ q ω) _ _).mp
+        rw [sigmaFinite_sub_add_cancel_of_le (hdom q),he q]
+        exact hs _
+      rw [← heη]
+      simpa only [rationalMassTime_encode] using hf (Encodable.encode q)
+  refine ⟨{
+    terminal := ν 0
+    mass := μ
+    terminal_measurable := hνm 0
+    mass_measurable := ?_
+    terminal_radon := hν 0
+    mass_radon := fun q => hMr (Encodable.encode q)
+    supports := s
+    weights := w
+    weights_nonneg := hw₀
+    weights_sum := hw₁
+    terminal_limit := htermLimit
+    mass_limit := hμlim
+    zero := ?_
+    increments := hinc
+    nonatomic := ?_
+    moments := ?_
+    mean := hmean
+    conditional := ?_ }⟩
+  · intro q
+    simpa +instances only [rationalMassTime_encode,Function.comp_def,Function.uncurry] using hMm (Encodable.encode q)
+  · filter_upwards [hμlim] with ω hω
+    let : (μ 0 ω).Regular := (hMr (Encodable.encode (0:ℚ)) ω).1
+    apply convex_level_radon_limit_zero_at_zero ω (hBc ω) (hw ω) (fun n => (n:ℝ))
+      tendsto_natCast_atTop_atTop s w (μ 0 ω)
+    simpa only [Rat.cast_zero,Real.toNNReal_zero,ENNReal.coe_zero] using hω 0
+  · exact level_radon_limit_nonatomic hB hm hBm hBc hB0 hκ hκ8 γ G F hw hgrowth
+      (fun n => (n:ℝ)) (fun n => Nat.cast_nonneg n) s w hw₀ hw₁ ∞ (ν 0) (hνm 0)
+      (fun ω => (hν 0 ω).2) htermLimit
+  · intro K hK m
+    exact level_radon_limit_compact_moments hB hm hBm hBc hB0 hκ hκ8 γ G F hw hgrowth
+      (fun n => (n:ℝ)) (fun n => Nat.cast_nonneg n) s w hw₀ hw₁ ∞ (ν 0)
+      (fun ω => (hν 0 ω).2) htermLimit K hK m
+  · intro q E hE
+    have hμm : Measurable (μ q) := (hMm (Encodable.encode q)).mono (Filtration.le _ _) le_rfl
+    have hs : ∀ᵐ ω ∂P, η (Encodable.encode q) ω + μ q ω = ν 0 ω := by
+      filter_upwards [hμeq,hηsum] with ω he hs
+      rw [he q]
+      exact hs _
+    have hc := bind_add_of_ae (P.restrict E) (μ q) (ν 0) (η (Encodable.encode q))
+      hμm (hνm 0) (hηm _) (ae_restrict_of_ae hs)
+    rw [← hc,add_comm]
+    congr 1
+    simpa only [rationalMassTime_encode] using hkernel (Encodable.encode q) E (by simpa +instances only [rationalMassTime_encode] using hE)
+
+end SLEExactGauge.Multipoint
+
+end
+
+end OAI

lean/OAI/Probability/SLE/Mass/RationalMassFromSupports.lean

@@ -1,85 +1,85 @@
-import OAI.Probability.SLE.Mass.RationalTraceMassLocal
-import OAI.Probability.SLE.Mass.LevelRadonSupport
-import OAI.Probability.SLE.Mass.LocallyFiniteMeasureSubtract
-
-namespace OAI
-
-/-! Past support and the remaining-mass support give exactly the rational
-increment hypothesis used by the locally finite continuous extension. -/
-
-noncomputable section
-open Set MeasureTheory Classical
-open scoped NNReal ENNReal
-
-namespace SLEExactGauge
-
-local instance : LocallyCompactSpace upperHalfPlane := isOpen_upperHalfPlane.locallyCompactSpace
-
-lemma trace_segment_toNNReal_image (γ : ℝ≥0 → ℂ) {p q : ℚ} (hp : 0 ≤ p) (hpq : p ≤ q) :
-    γ '' Icc (p : ℝ).toNNReal (q : ℝ).toNNReal ⊆
-      (fun r : ℝ => γ r.toNNReal) '' Icc (p:ℝ) q := by
-  rintro _ ⟨r,hr,rfl⟩
-  refine ⟨(r:ℝ),⟨?_,?_⟩,?_⟩
-  · have hr' : ((p:ℝ).toNNReal:ℝ) ≤ (r:ℝ) := by exact_mod_cast hr.1
-    simpa only [Real.coe_toNNReal _ (Rat.cast_nonneg.mpr hp)] using hr'
-  · have hq : (0:ℝ) ≤ q := Rat.cast_nonneg.mpr (hp.trans hpq)
-    have hr' : (r:ℝ) ≤ ((q:ℝ).toNNReal:ℝ) := by exact_mod_cast hr.2
-    simpa only [Real.coe_toNNReal _ hq] using hr'
-  · change γ (r:ℝ).toNNReal = γ r
-    rw [Real.toNNReal_coe]
-
-theorem halfPlaneTraceIncrements_of_past_and_future
-    (μ : ℚ → Measure upperHalfPlane) (ν : Measure upperHalfPlane) [ν.Regular]
-    (γ : ℝ≥0 → ℂ) (hμr : ∀ q, (μ q).Regular)
-    (hdom : ∀ q, μ q ≤ ν) (hmono : Monotone μ)
-    (hzero : ∀ q, q ≤ 0 → μ q = 0)
-    (hpast : ∀ q, 0 ≤ q → μ q {z : upperHalfPlane | (z : ℂ) ∉ γ '' Icc 0 (q : ℝ).toNNReal} = 0)
-    (hfuture : ∀ q, 0 ≤ q → (ν-μ q)
-      {z : upperHalfPlane | (z : ℂ) ∉ survivingDomain γ (q : ℝ).toNNReal} = 0) :
-    HalfPlaneTraceIncrements μ ν (fun r : ℝ => γ r.toNNReal) := by
-  let (q : ℚ) : (μ q).Regular := hμr q
-  refine ⟨hμr,hdom,?_⟩
-  intro p q hpq
-  let η := μ q-μ p
-  have hηsum : μ q = μ p+η := by
-    rw [add_comm]
-    exact (sigmaFinite_sub_add_cancel_of_le (hmono hpq)).symm
-  refine ⟨η,hηsum,?_⟩
-  by_cases hq : q ≤ 0
-  · have hp : p ≤ 0 := hpq.trans hq
-    simp only [η,hzero p hp,hzero q hq,Measure.sub_self]
-    exact bot_le
-  by_cases hp : p < 0
-  · have heη : η = μ q := by simp only [η,hzero p hp.le,Measure.sub_zero]
-    rw [heη]
-    let A := {z : upperHalfPlane | (z : ℂ) ∈ (fun r : ℝ => γ r.toNNReal) '' Icc (p:ℝ) q}
-    have hqpos : 0 < (q:ℝ) := Rat.cast_pos.mpr (lt_of_not_ge hq)
-    have hsubset : γ '' Icc 0 (q:ℝ).toNNReal ⊆
-        (fun r : ℝ => γ r.toNNReal) '' Icc (p:ℝ) q := by
-      rintro _ ⟨r,hr,rfl⟩
-      refine ⟨(r:ℝ),⟨(Rat.cast_nonpos.mpr hp.le).trans r.coe_nonneg,?_⟩,?_⟩
-      · have hr' : (r:ℝ) ≤ ((q:ℝ).toNNReal:ℝ) := by exact_mod_cast hr.2
-        simpa only [Real.coe_toNNReal _ hqpos.le] using hr'
-      · change γ (r:ℝ).toNNReal = γ r
-        rw [Real.toNNReal_coe]
-    have ha : ∀ᵐ z : upperHalfPlane ∂μ q, z ∈ A := by
-      have hh := measure_eq_zero_iff_ae_notMem.mp (hpast q (lt_of_not_ge hq).le)
-      filter_upwards [hh] with z hz
-      exact hsubset (not_not.mp hz)
-    calc
-      μ q = (μ q).restrict A := (Measure.restrict_eq_self_of_ae_mem ha).symm
-      _ ≤ ν.restrict A := Measure.restrict_mono le_rfl (hdom q)
-  · have hp' : 0 ≤ p := le_of_not_gt hp
-    have hq' : 0 ≤ q := hp'.trans hpq
-    have hh := Multipoint.increment_le_restrict_trace_segment γ
-      (p:ℝ).toNNReal (q:ℝ).toNNReal η (μ q) (ν-μ p) ν
-      Measure.sub_le (sub_le_sub_right_of_le (hdom p) (hdom q))
-      (Measure.sub_le.trans (hdom q)) (hpast q hq') (hfuture p hp')
-    exact hh.trans (Measure.restrict_mono
-      (fun (z : upperHalfPlane) hz => trace_segment_toNNReal_image γ hp' hpq hz) le_rfl)
-
-end SLEExactGauge
-
-end
-
-end OAI
+import OAI.Probability.SLE.Mass.RationalTraceMassLocal
+import OAI.Probability.SLE.Mass.LevelRadonSupport
+import OAI.Probability.SLE.Mass.LocallyFiniteMeasureSubtract
+
+namespace OAI
+
+/-! Past support and the remaining-mass support give exactly the rational
+increment hypothesis used by the locally finite continuous extension. -/
+
+noncomputable section
+open Set MeasureTheory Classical
+open scoped NNReal ENNReal
+
+namespace SLEExactGauge
+
+local instance : LocallyCompactSpace upperHalfPlane := isOpen_upperHalfPlane.locallyCompactSpace
+
+lemma trace_segment_toNNReal_image (γ : ℝ≥0 → ℂ) {p q : ℚ} (hp : 0 ≤ p) (hpq : p ≤ q) :
+    γ '' Icc (p : ℝ).toNNReal (q : ℝ).toNNReal ⊆
+      (fun r : ℝ => γ r.toNNReal) '' Icc (p:ℝ) q := by
+  rintro _ ⟨r,hr,rfl⟩
+  refine ⟨(r:ℝ),⟨?_,?_⟩,?_⟩
+  · have hr' : ((p:ℝ).toNNReal:ℝ) ≤ (r:ℝ) := by exact_mod_cast hr.1
+    simpa only [Real.coe_toNNReal _ (Rat.cast_nonneg.mpr hp)] using hr'
+  · have hq : (0:ℝ) ≤ q := Rat.cast_nonneg.mpr (hp.trans hpq)
+    have hr' : (r:ℝ) ≤ ((q:ℝ).toNNReal:ℝ) := by exact_mod_cast hr.2
+    simpa only [Real.coe_toNNReal _ hq] using hr'
+  · change γ (r:ℝ).toNNReal = γ r
+    rw [Real.toNNReal_coe]
+
+theorem halfPlaneTraceIncrements_of_past_and_future
+    (μ : ℚ → Measure upperHalfPlane) (ν : Measure upperHalfPlane) [ν.Regular]
+    (γ : ℝ≥0 → ℂ) (hμr : ∀ q, (μ q).Regular)
+    (hdom : ∀ q, μ q ≤ ν) (hmono : Monotone μ)
+    (hzero : ∀ q, q ≤ 0 → μ q = 0)
+    (hpast : ∀ q, 0 ≤ q → μ q {z : upperHalfPlane | (z : ℂ) ∉ γ '' Icc 0 (q : ℝ).toNNReal} = 0)
+    (hfuture : ∀ q, 0 ≤ q → (ν-μ q)
+      {z : upperHalfPlane | (z : ℂ) ∉ survivingDomain γ (q : ℝ).toNNReal} = 0) :
+    HalfPlaneTraceIncrements μ ν (fun r : ℝ => γ r.toNNReal) := by
+  let (q : ℚ) : (μ q).Regular := hμr q
+  refine ⟨hμr,hdom,?_⟩
+  intro p q hpq
+  let η := μ q-μ p
+  have hηsum : μ q = μ p+η := by
+    rw [add_comm]
+    exact (sigmaFinite_sub_add_cancel_of_le (hmono hpq)).symm
+  refine ⟨η,hηsum,?_⟩
+  by_cases hq : q ≤ 0
+  · have hp : p ≤ 0 := hpq.trans hq
+    simp only [η,hzero p hp,hzero q hq,Measure.sub_self]
+    exact bot_le
+  by_cases hp : p < 0
+  · have heη : η = μ q := by simp only [η,hzero p hp.le,Measure.sub_zero]
+    rw [heη]
+    let A := {z : upperHalfPlane | (z : ℂ) ∈ (fun r : ℝ => γ r.toNNReal) '' Icc (p:ℝ) q}
+    have hqpos : 0 < (q:ℝ) := Rat.cast_pos.mpr (lt_of_not_ge hq)
+    have hsubset : γ '' Icc 0 (q:ℝ).toNNReal ⊆
+        (fun r : ℝ => γ r.toNNReal) '' Icc (p:ℝ) q := by
+      rintro _ ⟨r,hr,rfl⟩
+      refine ⟨(r:ℝ),⟨(Rat.cast_nonpos.mpr hp.le).trans r.coe_nonneg,?_⟩,?_⟩
+      · have hr' : (r:ℝ) ≤ ((q:ℝ).toNNReal:ℝ) := by exact_mod_cast hr.2
+        simpa only [Real.coe_toNNReal _ hqpos.le] using hr'
+      · change γ (r:ℝ).toNNReal = γ r
+        rw [Real.toNNReal_coe]
+    have ha : ∀ᵐ z : upperHalfPlane ∂μ q, z ∈ A := by
+      have hh := measure_eq_zero_iff_ae_notMem.mp (hpast q (lt_of_not_ge hq).le)
+      filter_upwards [hh] with z hz
+      exact hsubset (not_not.mp hz)
+    calc
+      μ q = (μ q).restrict A := (Measure.restrict_eq_self_of_ae_mem ha).symm
+      _ ≤ ν.restrict A := Measure.restrict_mono le_rfl (hdom q)
+  · have hp' : 0 ≤ p := le_of_not_gt hp
+    have hq' : 0 ≤ q := hp'.trans hpq
+    have hh := Multipoint.increment_le_restrict_trace_segment γ
+      (p:ℝ).toNNReal (q:ℝ).toNNReal η (μ q) (ν-μ p) ν
+      Measure.sub_le (sub_le_sub_right_of_le (hdom p) (hdom q))
+      (Measure.sub_le.trans (hdom q)) (hpast q hq') (hfuture p hp')
+    exact hh.trans (Measure.restrict_mono
+      (fun (z : upperHalfPlane) hz => trace_segment_toNNReal_image γ hp' hpq hz) le_rfl)
+
+end SLEExactGauge
+
+end
+
+end OAI

lean/OAI/Probability/SLE/Mass/RationalTraceMass.lean

@@ -1,137 +1,137 @@
-import OAI.Probability.SLE.Mass.RationalTraceMassControl
-import Mathlib.Topology.Sequences
-
-namespace OAI
-
-/-! Continuous extension of a rational measure family whose positive
-increments are supported on the corresponding trace intervals. -/
-
-noncomputable section
-open Set Filter MeasureTheory Classical
-open scoped Topology CompactlySupported ENNReal
-
-namespace SLEExactGauge
-
-variable {X : Type*} [TopologicalSpace X] [T2Space X] [LocallyCompactSpace X]
-  [SecondCountableTopology X] [MeasurableSpace X] [BorelSpace X]
-
-/-- This is the positive-increment and interval-support assertion used in
-the pathwise extension. Local applications restrict all measures to one
-compact set, making the terminal measure finite. -/
-structure RationalTraceIncrements (μ : ℚ → Measure X) (ν : Measure X) (γ : ℝ → X) : Prop where
-  regular : ∀ q, (μ q).Regular
-  dominated : ∀ q, μ q ≤ ν
-  increment : ∀ p q, p ≤ q → ∃ η : Measure X,
-    μ q=μ p+η ∧ η ≤ ν.restrict (γ '' Icc (p:ℝ) q)
-
-omit [T2Space X] [LocallyCompactSpace X] [SecondCountableTopology X] [BorelSpace X] in
-lemma RationalTraceIncrements.monotone {μ : ℚ → Measure X} {ν : Measure X} {γ : ℝ → X}
-    (H : RationalTraceIncrements μ ν γ) : Monotone μ := by
-  intro p q hpq
-  obtain ⟨η,hη,_⟩ := H.increment p q hpq
-  rw [hη]
-  exact Measure.le_add_right le_rfl
-
-omit [T2Space X] [LocallyCompactSpace X] [SecondCountableTopology X] in
-lemma RationalTraceIncrements.integral_dist_le {μ : ℚ → Measure X} {ν : Measure X}
-    [IsFiniteMeasure ν] {γ : ℝ → X} (H : RationalTraceIncrements μ ν γ)
-    (f : C_c(X,ℝ)) (p q : ℚ) :
-    dist (∫ x, f x ∂μ p) (∫ x, f x ∂μ q) ≤ ‖f.toBoundedContinuousFunction‖ *
-      (ν (γ '' Icc (min (p:ℝ) q) (max (p:ℝ) q))).toReal := by
-  have ordered (a b : ℚ) (hab : a ≤ b) :
-      dist (∫ x, f x ∂μ a) (∫ x, f x ∂μ b) ≤ ‖f.toBoundedContinuousFunction‖ *
-        (ν (γ '' Icc (a:ℝ) b)).toReal := by
-    obtain ⟨η,hη,hην⟩ := H.increment a b hab
-    have hηle : η ≤ ν := hην.trans Measure.restrict_le_self
-    let : IsFiniteMeasure η := isFiniteMeasure_of_le ν hηle
-    let : (μ a).Regular := H.regular a
-    rw [hη,integral_add_measure f.integrable f.integrable,dist_eq_norm]
-    have hsub : (∫ x, f x ∂μ a)-((∫ x, f x ∂μ a)+(∫ x, f x ∂η))= -(∫ x, f x ∂η) := by ring
-    rw [hsub,norm_neg]
-    have hb := norm_integral_le_of_norm_le_const (μ := η)
-      (ae_of_all η (fun x => f.toBoundedContinuousFunction.norm_coe_le_norm x))
-    apply hb.trans
-    apply mul_le_mul_of_nonneg_left _ (norm_nonneg _)
-    apply ENNReal.toReal_mono (measure_ne_top ν _)
-    exact (hην univ).trans_eq (by simp)
-  rcases le_total p q with h | h
-  · simpa only [min_eq_left (Rat.cast_le.mpr h),max_eq_right (Rat.cast_le.mpr h)] using ordered p q h
-  · rw [dist_comm]
-    simpa only [min_eq_right (Rat.cast_le.mpr h),max_eq_left (Rat.cast_le.mpr h)] using ordered q p h
-
-lemma exists_rational_sequence_tendsto (t : ℝ) :
-    ∃ q : ℕ → ℚ, Tendsto (fun n => (q n : ℝ)) atTop (𝓝 t) := by
-  obtain ⟨x,hx,ht⟩ := mem_closure_iff_seq_limit.mp (Rat.denseRange_cast t)
-  choose q hq using hx
-  exact ⟨q,by simpa only [hq] using ht⟩
-
-omit [SecondCountableTopology X] in
-/-- The rational family has an all-real-time regular extension, continuous
-against every compact continuous test. It is dominated by the same finite
-terminal measure, and agrees exactly at every rational time. -/
-theorem RationalTraceIncrements.exists_continuous_extension
-    {μ : ℚ → Measure X} {ν : Measure X} [ν.Regular] [IsFiniteMeasure ν]
-    [NullSingletonClass ν] {γ : ℝ → X} (H : RationalTraceIncrements μ ν γ)
-    (hγ : Continuous γ) :
-    ∃ M : ℝ → Measure X, (∀ t, (M t).Regular) ∧ (∀ t, M t ≤ ν) ∧
-      (∀ q : ℚ, M q=μ q) ∧
-      (∀ f : C_c(X,ℝ), Continuous (fun t => ∫ x, f x ∂M t)) ∧ Monotone M := by
-  have hf (f : C_c(X,ℝ)) := continuous_rational_extension_of_trace_control
-    ν γ hγ (fun q => ∫ x, f x ∂μ q) ‖f.toBoundedContinuousFunction‖ (norm_nonneg _)
-    (H.integral_dist_le f)
-  choose F hFc hFq _ using hf
-  have hex (t : ℝ) : ∃ η : Measure X, η.Regular ∧ IsFiniteMeasureOnCompacts η ∧
-      ∀ f : C_c(X,ℝ), (∫ x, f x ∂η)=F f t := by
-    obtain ⟨q,hq⟩ := exists_rational_sequence_tendsto t
-    let (n : ℕ) : (μ (q n)).Regular := H.regular (q n)
-    have hlim (f : C_c(X,ℝ)) : Tendsto (fun n => ∫ x, f x ∂μ (q n)) atTop (𝓝 (F f t)) := by
-      simpa only [Function.comp_def,hFq] using (hFc f).continuousAt.tendsto.comp hq
-    obtain ⟨η,hηr,hηf,hηlim⟩ := radon_limit_of_all_test_limits (fun n => μ (q n))
-      (fun f => ⟨F f t,hlim f⟩)
-    exact ⟨η,hηr,hηf,fun f => tendsto_nhds_unique (hηlim f) (hlim f)⟩
-  choose M hMr hMf hMI using hex
-  have hcont (f : C_c(X,ℝ)) : Continuous (fun t => ∫ x, f x ∂M t) := by
-    simpa only [hMI] using hFc f
-  have hrat (q : ℚ) : M q=μ q := by
-    let : (M q).Regular := hMr q
-    let : (μ q).Regular := H.regular q
-    apply Measure.ext_of_integral_eq_on_compactlySupported
-    intro f
-    rw [hMI,hFq]
-  have hdom (t : ℝ) : M t ≤ ν := by
-    let : (M t).Regular := hMr t
-    obtain ⟨q,hq⟩ := exists_rational_sequence_tendsto t
-    apply radon_measure_le_of_nonneg_tests
-    intro f hfn
-    have hlim : Tendsto (fun n => ∫ x, f x ∂μ (q n)) atTop (𝓝 (∫ x, f x ∂M t)) := by
-      simpa only [Function.comp_def,hrat] using (hcont f).continuousAt.tendsto.comp hq
-    apply le_of_tendsto_of_tendsto' hlim tendsto_const_nhds
-    intro n
-    exact integral_mono_measure (H.dominated (q n)) (ae_of_all ν hfn) f.integrable
-  refine ⟨M,hMr,hdom,hrat,hcont,?_⟩
-  intro s t hst
-  rcases eq_or_lt_of_le hst with rfl | hst
-  · exact le_rfl
-  let : (M s).Regular := hMr s
-  let : (M t).Regular := hMr t
-  obtain ⟨p,hp⟩ := exists_rational_sequence_tendsto s
-  obtain ⟨q,hq⟩ := exists_rational_sequence_tendsto t
-  have hp' : ∀ᶠ n in atTop, (p n : ℝ)<(s+t)/2 := hp.eventually (gt_mem_nhds (by linarith))
-  have hq' : ∀ᶠ n in atTop, (s+t)/2<(q n : ℝ) := hq.eventually (lt_mem_nhds (by linarith))
-  apply radon_measure_le_of_nonneg_tests
-  intro f hfn
-  have hplim : Tendsto (fun n => ∫ x, f x ∂μ (p n)) atTop (𝓝 (∫ x, f x ∂M s)) := by
-    simpa only [Function.comp_def,hrat] using (hcont f).continuousAt.tendsto.comp hp
-  have hqlim : Tendsto (fun n => ∫ x, f x ∂μ (q n)) atTop (𝓝 (∫ x, f x ∂M t)) := by
-    simpa only [Function.comp_def,hrat] using (hcont f).continuousAt.tendsto.comp hq
-  apply le_of_tendsto_of_tendsto hplim hqlim
-  filter_upwards [hp',hq'] with n hpn hqn
-  let : (μ (q n)).Regular := H.regular (q n)
-  exact integral_mono_measure (H.monotone (Rat.cast_le.mp (le_of_lt (hpn.trans hqn))))
-    (ae_of_all _ hfn) f.integrable
-
-end SLEExactGauge
-
-end
-
-end OAI
+import OAI.Probability.SLE.Mass.RationalTraceMassControl
+import Mathlib.Topology.Sequences
+
+namespace OAI
+
+/-! Continuous extension of a rational measure family whose positive
+increments are supported on the corresponding trace intervals. -/
+
+noncomputable section
+open Set Filter MeasureTheory Classical
+open scoped Topology CompactlySupported ENNReal
+
+namespace SLEExactGauge
+
+variable {X : Type*} [TopologicalSpace X] [T2Space X] [LocallyCompactSpace X]
+  [SecondCountableTopology X] [MeasurableSpace X] [BorelSpace X]
+
+/-- This is the positive-increment and interval-support assertion used in
+the pathwise extension. Local applications restrict all measures to one
+compact set, making the terminal measure finite. -/
+structure RationalTraceIncrements (μ : ℚ → Measure X) (ν : Measure X) (γ : ℝ → X) : Prop where
+  regular : ∀ q, (μ q).Regular
+  dominated : ∀ q, μ q ≤ ν
+  increment : ∀ p q, p ≤ q → ∃ η : Measure X,
+    μ q=μ p+η ∧ η ≤ ν.restrict (γ '' Icc (p:ℝ) q)
+
+omit [T2Space X] [LocallyCompactSpace X] [SecondCountableTopology X] [BorelSpace X] in
+lemma RationalTraceIncrements.monotone {μ : ℚ → Measure X} {ν : Measure X} {γ : ℝ → X}
+    (H : RationalTraceIncrements μ ν γ) : Monotone μ := by
+  intro p q hpq
+  obtain ⟨η,hη,_⟩ := H.increment p q hpq
+  rw [hη]
+  exact Measure.le_add_right le_rfl
+
+omit [T2Space X] [LocallyCompactSpace X] [SecondCountableTopology X] in
+lemma RationalTraceIncrements.integral_dist_le {μ : ℚ → Measure X} {ν : Measure X}
+    [IsFiniteMeasure ν] {γ : ℝ → X} (H : RationalTraceIncrements μ ν γ)
+    (f : C_c(X,ℝ)) (p q : ℚ) :
+    dist (∫ x, f x ∂μ p) (∫ x, f x ∂μ q) ≤ ‖f.toBoundedContinuousFunction‖ *
+      (ν (γ '' Icc (min (p:ℝ) q) (max (p:ℝ) q))).toReal := by
+  have ordered (a b : ℚ) (hab : a ≤ b) :
+      dist (∫ x, f x ∂μ a) (∫ x, f x ∂μ b) ≤ ‖f.toBoundedContinuousFunction‖ *
+        (ν (γ '' Icc (a:ℝ) b)).toReal := by
+    obtain ⟨η,hη,hην⟩ := H.increment a b hab
+    have hηle : η ≤ ν := hην.trans Measure.restrict_le_self
+    let : IsFiniteMeasure η := isFiniteMeasure_of_le ν hηle
+    let : (μ a).Regular := H.regular a
+    rw [hη,integral_add_measure f.integrable f.integrable,dist_eq_norm]
+    have hsub : (∫ x, f x ∂μ a)-((∫ x, f x ∂μ a)+(∫ x, f x ∂η))= -(∫ x, f x ∂η) := by ring
+    rw [hsub,norm_neg]
+    have hb := norm_integral_le_of_norm_le_const (μ := η)
+      (ae_of_all η (fun x => f.toBoundedContinuousFunction.norm_coe_le_norm x))
+    apply hb.trans
+    apply mul_le_mul_of_nonneg_left _ (norm_nonneg _)
+    apply ENNReal.toReal_mono (measure_ne_top ν _)
+    exact (hην univ).trans_eq (by simp)
+  rcases le_total p q with h | h
+  · simpa only [min_eq_left (Rat.cast_le.mpr h),max_eq_right (Rat.cast_le.mpr h)] using ordered p q h
+  · rw [dist_comm]
+    simpa only [min_eq_right (Rat.cast_le.mpr h),max_eq_left (Rat.cast_le.mpr h)] using ordered q p h
+
+lemma exists_rational_sequence_tendsto (t : ℝ) :
+    ∃ q : ℕ → ℚ, Tendsto (fun n => (q n : ℝ)) atTop (𝓝 t) := by
+  obtain ⟨x,hx,ht⟩ := mem_closure_iff_seq_limit.mp (Rat.denseRange_cast t)
+  choose q hq using hx
+  exact ⟨q,by simpa only [hq] using ht⟩
+
+omit [SecondCountableTopology X] in
+/-- The rational family has an all-real-time regular extension, continuous
+against every compact continuous test. It is dominated by the same finite
+terminal measure, and agrees exactly at every rational time. -/
+theorem RationalTraceIncrements.exists_continuous_extension
+    {μ : ℚ → Measure X} {ν : Measure X} [ν.Regular] [IsFiniteMeasure ν]
+    [NullSingletonClass ν] {γ : ℝ → X} (H : RationalTraceIncrements μ ν γ)
+    (hγ : Continuous γ) :
+    ∃ M : ℝ → Measure X, (∀ t, (M t).Regular) ∧ (∀ t, M t ≤ ν) ∧
+      (∀ q : ℚ, M q=μ q) ∧
+      (∀ f : C_c(X,ℝ), Continuous (fun t => ∫ x, f x ∂M t)) ∧ Monotone M := by
+  have hf (f : C_c(X,ℝ)) := continuous_rational_extension_of_trace_control
+    ν γ hγ (fun q => ∫ x, f x ∂μ q) ‖f.toBoundedContinuousFunction‖ (norm_nonneg _)
+    (H.integral_dist_le f)
+  choose F hFc hFq _ using hf
+  have hex (t : ℝ) : ∃ η : Measure X, η.Regular ∧ IsFiniteMeasureOnCompacts η ∧
+      ∀ f : C_c(X,ℝ), (∫ x, f x ∂η)=F f t := by
+    obtain ⟨q,hq⟩ := exists_rational_sequence_tendsto t
+    let (n : ℕ) : (μ (q n)).Regular := H.regular (q n)
+    have hlim (f : C_c(X,ℝ)) : Tendsto (fun n => ∫ x, f x ∂μ (q n)) atTop (𝓝 (F f t)) := by
+      simpa only [Function.comp_def,hFq] using (hFc f).continuousAt.tendsto.comp hq
+    obtain ⟨η,hηr,hηf,hηlim⟩ := radon_limit_of_all_test_limits (fun n => μ (q n))
+      (fun f => ⟨F f t,hlim f⟩)
+    exact ⟨η,hηr,hηf,fun f => tendsto_nhds_unique (hηlim f) (hlim f)⟩
+  choose M hMr hMf hMI using hex
+  have hcont (f : C_c(X,ℝ)) : Continuous (fun t => ∫ x, f x ∂M t) := by
+    simpa only [hMI] using hFc f
+  have hrat (q : ℚ) : M q=μ q := by
+    let : (M q).Regular := hMr q
+    let : (μ q).Regular := H.regular q
+    apply Measure.ext_of_integral_eq_on_compactlySupported
+    intro f
+    rw [hMI,hFq]
+  have hdom (t : ℝ) : M t ≤ ν := by
+    let : (M t).Regular := hMr t
+    obtain ⟨q,hq⟩ := exists_rational_sequence_tendsto t
+    apply radon_measure_le_of_nonneg_tests
+    intro f hfn
+    have hlim : Tendsto (fun n => ∫ x, f x ∂μ (q n)) atTop (𝓝 (∫ x, f x ∂M t)) := by
+      simpa only [Function.comp_def,hrat] using (hcont f).continuousAt.tendsto.comp hq
+    apply le_of_tendsto_of_tendsto' hlim tendsto_const_nhds
+    intro n
+    exact integral_mono_measure (H.dominated (q n)) (ae_of_all ν hfn) f.integrable
+  refine ⟨M,hMr,hdom,hrat,hcont,?_⟩
+  intro s t hst
+  rcases eq_or_lt_of_le hst with rfl | hst
+  · exact le_rfl
+  let : (M s).Regular := hMr s
+  let : (M t).Regular := hMr t
+  obtain ⟨p,hp⟩ := exists_rational_sequence_tendsto s
+  obtain ⟨q,hq⟩ := exists_rational_sequence_tendsto t
+  have hp' : ∀ᶠ n in atTop, (p n : ℝ)<(s+t)/2 := hp.eventually (gt_mem_nhds (by linarith))
+  have hq' : ∀ᶠ n in atTop, (s+t)/2<(q n : ℝ) := hq.eventually (lt_mem_nhds (by linarith))
+  apply radon_measure_le_of_nonneg_tests
+  intro f hfn
+  have hplim : Tendsto (fun n => ∫ x, f x ∂μ (p n)) atTop (𝓝 (∫ x, f x ∂M s)) := by
+    simpa only [Function.comp_def,hrat] using (hcont f).continuousAt.tendsto.comp hp
+  have hqlim : Tendsto (fun n => ∫ x, f x ∂μ (q n)) atTop (𝓝 (∫ x, f x ∂M t)) := by
+    simpa only [Function.comp_def,hrat] using (hcont f).continuousAt.tendsto.comp hq
+  apply le_of_tendsto_of_tendsto hplim hqlim
+  filter_upwards [hp',hq'] with n hpn hqn
+  let : (μ (q n)).Regular := H.regular (q n)
+  exact integral_mono_measure (H.monotone (Rat.cast_le.mp (le_of_lt (hpn.trans hqn))))
+    (ae_of_all _ hfn) f.integrable
+
+end SLEExactGauge
+
+end
+
+end OAI

lean/OAI/Probability/SLE/Mass/RationalTraceMassAdapted.lean

@@ -1,111 +1,111 @@
-import OAI.Probability.SLE.Mass.RationalTraceMassLocalVariation
-import OAI.Probability.SLE.Mass.RadonTestMeasurability
-
-namespace OAI
-
-/-! Adapted and jointly measurable all-time Radon mass, obtained from
-rational left limits in the original filtration. -/
-
-noncomputable section
-open Set Filter MeasureTheory Classical
-open scoped Topology ENNReal NNReal CompactlySupported
-
-namespace SLEExactGauge
-
-local instance : LocallyCompactSpace upperHalfPlane := isOpen_upperHalfPlane.locallyCompactSpace
-
-lemma measurable_halfPlane_compact_test_integral
-    {Ω : Type*} [MeasurableSpace Ω] (μ : Ω → Measure upperHalfPlane)
-    (hm : Measurable μ) (hr : ∀ ω, (μ ω).Regular) (f : C_c(upperHalfPlane,ℝ)) :
-    Measurable (fun ω => ∫ z, f z ∂μ ω) := by
-  have hp := (Measure.measurable_lintegral f.continuous.measurable.ennreal_ofReal).comp hm
-  have hn := (Measure.measurable_lintegral f.continuous.measurable.neg.ennreal_ofReal).comp hm
-  have he (ω : Ω) : (∫ z, f z ∂μ ω) =
-      (∫⁻ z, ENNReal.ofReal (f z) ∂μ ω).toReal -
-        (∫⁻ z, ENNReal.ofReal (-f z) ∂μ ω).toReal := by
-    let := hr ω
-    exact integral_eq_lintegral_pos_part_sub_lintegral_neg_part f.integrable
-  simp_rw [he]
-  exact hp.ennreal_toReal.sub hn.ennreal_toReal
-
-theorem halfPlane_extension_adapted
-    {Ω : Type*} [mΩ : MeasurableSpace Ω] (ℱ : Filtration ℝ≥0 mΩ)
-    (μ : ℚ → Ω → Measure upperHalfPlane) (M : ℝ → Ω → Measure upperHalfPlane)
-    (hMr : ∀ t ω, (M t ω).Regular)
-    (hcont : ∀ ω (f : C_c(upperHalfPlane,ℝ)), Continuous (fun t => ∫ z, f z ∂M t ω))
-    (hrat : ∀ (q : ℚ) ω, M q ω = μ q ω)
-    (hμm : ∀ q : ℚ, 0 ≤ q → Measurable[ℱ (q : ℝ).toNNReal] (μ q)) :
-    Adapted ℱ (fun t : ℝ≥0 => M t) := by
-  intro t
-  by_cases ht : t = 0
-  · subst t
-    have he : M (0:ℝ) = μ (0:ℚ) := by
-      funext ω
-      simpa only [Rat.cast_zero] using hrat 0 ω
-    change Measurable[ℱ 0] (M (0:ℝ))
-    rw [he]
-    convert hμm (0:ℚ) le_rfl using 1
-    norm_num
-  · have htpos : 0 < (t:ℝ) := NNReal.coe_pos.mpr (pos_iff_ne_zero.mpr ht)
-    obtain ⟨q,_,hq,hqt⟩ := Rat.denseRange_cast.exists_seq_strictMono_tendsto_of_lt
-      (fun a b hab => Rat.cast_le.mpr hab) htpos
-    let : MeasurableSpace Ω := ℱ t
-    apply measurable_radon_of_tests (M t) (hMr t)
-    intro f
-    have hqm (n : ℕ) : Measurable[ℱ t] (μ (q n)) := by
-      have hqn : 0 ≤ q n := Rat.cast_nonneg.mp (hq n).1.le
-      have htime : (q n : ℝ).toNNReal ≤ t := by
-        simpa only [Real.toNNReal_coe] using Real.toNNReal_le_toNNReal (hq n).2.le
-      exact (hμm (q n) hqn).mono (ℱ.mono htime) le_rfl
-    apply measurable_of_tendsto_metrizable
-      (fun n => measurable_halfPlane_compact_test_integral (μ (q n)) (hqm n)
-        (fun ω => hrat (q n) ω ▸ hMr (q n) ω) f)
-    apply tendsto_pi_nhds.mpr
-    intro ω
-    simpa only [Function.comp_def,hrat] using
-      (hcont ω f).continuousAt.tendsto.comp hqt
-
-/-- Joint measurability follows through real compact-test integrals;
-no topology on the space of Radon measures is required. -/
-theorem halfPlane_extension_joint_measurable
-    {Ω : Type*} [mΩ : MeasurableSpace Ω] (ℱ : Filtration ℝ≥0 mΩ)
-    (μ : ℚ → Ω → Measure upperHalfPlane) (M : ℝ → Ω → Measure upperHalfPlane)
-    (hMr : ∀ t ω, (M t ω).Regular)
-    (hcont : ∀ ω (f : C_c(upperHalfPlane,ℝ)), Continuous (fun t => ∫ z, f z ∂M t ω))
-    (hrat : ∀ (q : ℚ) ω, M q ω = μ q ω)
-    (hμm : ∀ q : ℚ, 0 ≤ q → Measurable[ℱ (q : ℝ).toNNReal] (μ q)) :
-    Measurable (fun q : ℝ≥0 × Ω => M q.1 q.2) := by
-  have had := halfPlane_extension_adapted ℱ μ M hMr hcont hrat hμm
-  apply measurable_radon_of_tests (fun q : ℝ≥0 × Ω => M q.1 q.2)
-    (fun q => hMr q.1 q.2)
-  intro f
-  apply measurable_uncurry_of_continuous_of_measurable
-    (fun ω => (hcont ω f).comp NNReal.continuous_coe)
-  intro t
-  exact measurable_halfPlane_compact_test_integral (M t) (had.measurable (i := t)) (hMr t) f
-
-theorem halfPlane_extension_progressive
-    {Ω : Type*} [mΩ : MeasurableSpace Ω] (ℱ : Filtration ℝ≥0 mΩ)
-    (μ : ℚ → Ω → Measure upperHalfPlane) (M : ℝ → Ω → Measure upperHalfPlane)
-    (hMr : ∀ t ω, (M t ω).Regular)
-    (hcont : ∀ ω (f : C_c(upperHalfPlane,ℝ)), Continuous (fun t => ∫ z, f z ∂M t ω))
-    (hrat : ∀ (q : ℚ) ω, M q ω = μ q ω)
-    (hμm : ∀ q : ℚ, 0 ≤ q → Measurable[ℱ (q : ℝ).toNNReal] (μ q)) :
-    IsProgressive ℱ (fun t : ℝ≥0 => M t) := by
-  have had := halfPlane_extension_adapted ℱ μ M hMr hcont hrat hμm
-  intro T
-  let : MeasurableSpace Ω := ℱ T
-  apply measurable_radon_of_tests (fun q : Iic T × Ω => M q.1.1 q.2)
-    (fun q => hMr q.1.1 q.2)
-  intro f
-  apply measurable_uncurry_of_continuous_of_measurable
-    (fun ω => (hcont ω f).comp (NNReal.continuous_coe.comp continuous_subtype_val))
-  intro t
-  have ht : Measurable[ℱ T] (M (t.1 : ℝ)) := had.measurable_le t.2
-  exact measurable_halfPlane_compact_test_integral (M (t.1 : ℝ)) ht (hMr t.1) f
-
-end SLEExactGauge
-
-end
-
-end OAI
+import OAI.Probability.SLE.Mass.RationalTraceMassLocalVariation
+import OAI.Probability.SLE.Mass.RadonTestMeasurability
+
+namespace OAI
+
+/-! Adapted and jointly measurable all-time Radon mass, obtained from
+rational left limits in the original filtration. -/
+
+noncomputable section
+open Set Filter MeasureTheory Classical
+open scoped Topology ENNReal NNReal CompactlySupported
+
+namespace SLEExactGauge
+
+local instance : LocallyCompactSpace upperHalfPlane := isOpen_upperHalfPlane.locallyCompactSpace
+
+lemma measurable_halfPlane_compact_test_integral
+    {Ω : Type*} [MeasurableSpace Ω] (μ : Ω → Measure upperHalfPlane)
+    (hm : Measurable μ) (hr : ∀ ω, (μ ω).Regular) (f : C_c(upperHalfPlane,ℝ)) :
+    Measurable (fun ω => ∫ z, f z ∂μ ω) := by
+  have hp := (Measure.measurable_lintegral f.continuous.measurable.ennreal_ofReal).comp hm
+  have hn := (Measure.measurable_lintegral f.continuous.measurable.neg.ennreal_ofReal).comp hm
+  have he (ω : Ω) : (∫ z, f z ∂μ ω) =
+      (∫⁻ z, ENNReal.ofReal (f z) ∂μ ω).toReal -
+        (∫⁻ z, ENNReal.ofReal (-f z) ∂μ ω).toReal := by
+    let := hr ω
+    exact integral_eq_lintegral_pos_part_sub_lintegral_neg_part f.integrable
+  simp_rw [he]
+  exact hp.ennreal_toReal.sub hn.ennreal_toReal
+
+theorem halfPlane_extension_adapted
+    {Ω : Type*} [mΩ : MeasurableSpace Ω] (ℱ : Filtration ℝ≥0 mΩ)
+    (μ : ℚ → Ω → Measure upperHalfPlane) (M : ℝ → Ω → Measure upperHalfPlane)
+    (hMr : ∀ t ω, (M t ω).Regular)
+    (hcont : ∀ ω (f : C_c(upperHalfPlane,ℝ)), Continuous (fun t => ∫ z, f z ∂M t ω))
+    (hrat : ∀ (q : ℚ) ω, M q ω = μ q ω)
+    (hμm : ∀ q : ℚ, 0 ≤ q → Measurable[ℱ (q : ℝ).toNNReal] (μ q)) :
+    Adapted ℱ (fun t : ℝ≥0 => M t) := by
+  intro t
+  by_cases ht : t = 0
+  · subst t
+    have he : M (0:ℝ) = μ (0:ℚ) := by
+      funext ω
+      simpa only [Rat.cast_zero] using hrat 0 ω
+    change Measurable[ℱ 0] (M (0:ℝ))
+    rw [he]
+    convert hμm (0:ℚ) le_rfl using 1
+    norm_num
+  · have htpos : 0 < (t:ℝ) := NNReal.coe_pos.mpr (pos_iff_ne_zero.mpr ht)
+    obtain ⟨q,_,hq,hqt⟩ := Rat.denseRange_cast.exists_seq_strictMono_tendsto_of_lt
+      (fun a b hab => Rat.cast_le.mpr hab) htpos
+    let : MeasurableSpace Ω := ℱ t
+    apply measurable_radon_of_tests (M t) (hMr t)
+    intro f
+    have hqm (n : ℕ) : Measurable[ℱ t] (μ (q n)) := by
+      have hqn : 0 ≤ q n := Rat.cast_nonneg.mp (hq n).1.le
+      have htime : (q n : ℝ).toNNReal ≤ t := by
+        simpa only [Real.toNNReal_coe] using Real.toNNReal_le_toNNReal (hq n).2.le
+      exact (hμm (q n) hqn).mono (ℱ.mono htime) le_rfl
+    apply measurable_of_tendsto_metrizable
+      (fun n => measurable_halfPlane_compact_test_integral (μ (q n)) (hqm n)
+        (fun ω => hrat (q n) ω ▸ hMr (q n) ω) f)
+    apply tendsto_pi_nhds.mpr
+    intro ω
+    simpa only [Function.comp_def,hrat] using
+      (hcont ω f).continuousAt.tendsto.comp hqt
+
+/-- Joint measurability follows through real compact-test integrals;
+no topology on the space of Radon measures is required. -/
+theorem halfPlane_extension_joint_measurable
+    {Ω : Type*} [mΩ : MeasurableSpace Ω] (ℱ : Filtration ℝ≥0 mΩ)
+    (μ : ℚ → Ω → Measure upperHalfPlane) (M : ℝ → Ω → Measure upperHalfPlane)
+    (hMr : ∀ t ω, (M t ω).Regular)
+    (hcont : ∀ ω (f : C_c(upperHalfPlane,ℝ)), Continuous (fun t => ∫ z, f z ∂M t ω))
+    (hrat : ∀ (q : ℚ) ω, M q ω = μ q ω)
+    (hμm : ∀ q : ℚ, 0 ≤ q → Measurable[ℱ (q : ℝ).toNNReal] (μ q)) :
+    Measurable (fun q : ℝ≥0 × Ω => M q.1 q.2) := by
+  have had := halfPlane_extension_adapted ℱ μ M hMr hcont hrat hμm
+  apply measurable_radon_of_tests (fun q : ℝ≥0 × Ω => M q.1 q.2)
+    (fun q => hMr q.1 q.2)
+  intro f
+  apply measurable_uncurry_of_continuous_of_measurable
+    (fun ω => (hcont ω f).comp NNReal.continuous_coe)
+  intro t
+  exact measurable_halfPlane_compact_test_integral (M t) (had.measurable (i := t)) (hMr t) f
+
+theorem halfPlane_extension_progressive
+    {Ω : Type*} [mΩ : MeasurableSpace Ω] (ℱ : Filtration ℝ≥0 mΩ)
+    (μ : ℚ → Ω → Measure upperHalfPlane) (M : ℝ → Ω → Measure upperHalfPlane)
+    (hMr : ∀ t ω, (M t ω).Regular)
+    (hcont : ∀ ω (f : C_c(upperHalfPlane,ℝ)), Continuous (fun t => ∫ z, f z ∂M t ω))
+    (hrat : ∀ (q : ℚ) ω, M q ω = μ q ω)
+    (hμm : ∀ q : ℚ, 0 ≤ q → Measurable[ℱ (q : ℝ).toNNReal] (μ q)) :
+    IsProgressive ℱ (fun t : ℝ≥0 => M t) := by
+  have had := halfPlane_extension_adapted ℱ μ M hMr hcont hrat hμm
+  intro T
+  let : MeasurableSpace Ω := ℱ T
+  apply measurable_radon_of_tests (fun q : Iic T × Ω => M q.1.1 q.2)
+    (fun q => hMr q.1.1 q.2)
+  intro f
+  apply measurable_uncurry_of_continuous_of_measurable
+    (fun ω => (hcont ω f).comp (NNReal.continuous_coe.comp continuous_subtype_val))
+  intro t
+  have ht : Measurable[ℱ T] (M (t.1 : ℝ)) := had.measurable_le t.2
+  exact measurable_halfPlane_compact_test_integral (M (t.1 : ℝ)) ht (hMr t.1) f
+
+end SLEExactGauge
+
+end
+
+end OAI

lean/OAI/Probability/SLE/Mass/RationalTraceMassAdaptedVersion.lean

@@ -1,76 +1,76 @@
-import OAI.Probability.SLE.Mass.RationalTraceMassAdapted
-import OAI.Probability.SLE.Mass.SubSigmaRadonLimit
-
-namespace OAI
-
-/-! Rational adapted versions determine one adapted all-time version on the
-same probability-one set on which the limiting compact tests are continuous. -/
-
-noncomputable section
-open Set Filter MeasureTheory Classical
-open scoped Topology NNReal ENNReal CompactlySupported
-
-namespace SLEExactGauge
-
-local instance : LocallyCompactSpace upperHalfPlane := isOpen_upperHalfPlane.locallyCompactSpace
-
-theorem halfPlane_extension_adapted_common_version
-    {Ω : Type*} [mΩ : MeasurableSpace Ω] (P : Measure Ω) (ℱ : Filtration ℝ≥0 mΩ)
-    (μ : ℚ → Ω → Measure upperHalfPlane) (M : ℝ → Ω → Measure upperHalfPlane)
-    (hμr : ∀ q ω, (μ q ω).Regular) (hMr : ∀ t ω, (M t ω).Regular)
-    (hcont : ∀ᵐ ω ∂P, ∀ f : C_c(upperHalfPlane,ℝ),
-      Continuous (fun t => ∫ z, f z ∂M t ω))
-    (hrat : ∀ᵐ ω ∂P, ∀ q : ℚ, M q ω = μ q ω)
-    (hμm : ∀ q : ℚ, 0 ≤ q → Measurable[ℱ (q : ℝ).toNNReal] (μ q)) :
-    ∃ N : ℝ≥0 → Ω → Measure upperHalfPlane, Adapted ℱ N ∧
-      (∀ t ω, (N t ω).Regular ∧ IsFiniteMeasureOnCompacts (N t ω)) ∧
-      ∀ᵐ ω ∂P, ∀ t : ℝ≥0, N t ω = M t ω := by
-  let Good (ω : Ω) : Prop :=
-    (∀ f : C_c(upperHalfPlane,ℝ), Continuous (fun t => ∫ z, f z ∂M t ω)) ∧
-      ∀ q : ℚ, M q ω = μ q ω
-  have hex (t : ℝ≥0) : ∃ N : Ω → Measure upperHalfPlane,
-      Measurable[ℱ t] N ∧ (∀ ω, (N ω).Regular ∧ IsFiniteMeasureOnCompacts (N ω)) ∧
-      ∀ ω, Good ω → N ω = M t ω := by
-    by_cases ht : t = 0
-    · subst t
-      refine ⟨μ 0,?_,?_,?_⟩
-      · convert hμm (0:ℚ) le_rfl using 1
-        norm_num
-      · intro ω
-        let := hμr 0 ω
-        exact ⟨hμr 0 ω,inferInstance⟩
-      · intro ω hω
-        simpa only [Rat.cast_zero,NNReal.coe_zero] using (hω.2 0).symm
-    · have htpos : 0 < (t:ℝ) := NNReal.coe_pos.mpr (pos_iff_ne_zero.mpr ht)
-      obtain ⟨q,_,hq,hqt⟩ := Rat.denseRange_cast.exists_seq_strictMono_tendsto_of_lt
-        (fun a b hab => Rat.cast_le.mpr hab) htpos
-      have hqm (n : ℕ) : Measurable[ℱ t] (μ (q n)) := by
-        have hqn : 0 ≤ q n := Rat.cast_nonneg.mp (hq n).1.le
-        have htime : (q n : ℝ).toNNReal ≤ t := by
-          simpa only [Real.toNNReal_coe] using Real.toNNReal_le_toNNReal (hq n).2.le
-        exact (hμm (q n) hqn).mono (ℱ.mono htime) le_rfl
-      have hfinite (n : ℕ) (ω : Ω) : IsFiniteMeasureOnCompacts (μ (q n) ω) := by
-        let := hμr (q n) ω
-        infer_instance
-      let : MeasurableSpace Ω := ℱ t
-      have hm (n : ℕ) (f : C_c(upperHalfPlane,ℝ)) :
-          Measurable[ℱ t] (fun ω => ∫ z, f z ∂μ (q n) ω) :=
-        measurable_halfPlane_compact_test_integral (μ (q n)) (hqm n) (hμr (q n)) f
-      obtain ⟨N,hNm,hNr,hNe⟩ := exists_subsigma_radon_version_identified
-        (ℱ t) (fun n => μ (q n)) hfinite hm
-      refine ⟨N,hNm,hNr,?_⟩
-      intro ω hω
-      apply hNe ω (M t ω) (hMr t ω)
-      intro f
-      simpa only [Function.comp_def,hω.2] using
-        (hω.1 f).continuousAt.tendsto.comp hqt
-  choose N hNm hNr hNe using hex
-  refine ⟨N,hNm,hNr,?_⟩
-  filter_upwards [hcont,hrat] with ω hc hr
-  exact fun t => hNe t ω ⟨hc,hr⟩
-
-end SLEExactGauge
-
-end
-
-end OAI
+import OAI.Probability.SLE.Mass.RationalTraceMassAdapted
+import OAI.Probability.SLE.Mass.SubSigmaRadonLimit
+
+namespace OAI
+
+/-! Rational adapted versions determine one adapted all-time version on the
+same probability-one set on which the limiting compact tests are continuous. -/
+
+noncomputable section
+open Set Filter MeasureTheory Classical
+open scoped Topology NNReal ENNReal CompactlySupported
+
+namespace SLEExactGauge
+
+local instance : LocallyCompactSpace upperHalfPlane := isOpen_upperHalfPlane.locallyCompactSpace
+
+theorem halfPlane_extension_adapted_common_version
+    {Ω : Type*} [mΩ : MeasurableSpace Ω] (P : Measure Ω) (ℱ : Filtration ℝ≥0 mΩ)
+    (μ : ℚ → Ω → Measure upperHalfPlane) (M : ℝ → Ω → Measure upperHalfPlane)
+    (hμr : ∀ q ω, (μ q ω).Regular) (hMr : ∀ t ω, (M t ω).Regular)
+    (hcont : ∀ᵐ ω ∂P, ∀ f : C_c(upperHalfPlane,ℝ),
+      Continuous (fun t => ∫ z, f z ∂M t ω))
+    (hrat : ∀ᵐ ω ∂P, ∀ q : ℚ, M q ω = μ q ω)
+    (hμm : ∀ q : ℚ, 0 ≤ q → Measurable[ℱ (q : ℝ).toNNReal] (μ q)) :
+    ∃ N : ℝ≥0 → Ω → Measure upperHalfPlane, Adapted ℱ N ∧
+      (∀ t ω, (N t ω).Regular ∧ IsFiniteMeasureOnCompacts (N t ω)) ∧
+      ∀ᵐ ω ∂P, ∀ t : ℝ≥0, N t ω = M t ω := by
+  let Good (ω : Ω) : Prop :=
+    (∀ f : C_c(upperHalfPlane,ℝ), Continuous (fun t => ∫ z, f z ∂M t ω)) ∧
+      ∀ q : ℚ, M q ω = μ q ω
+  have hex (t : ℝ≥0) : ∃ N : Ω → Measure upperHalfPlane,
+      Measurable[ℱ t] N ∧ (∀ ω, (N ω).Regular ∧ IsFiniteMeasureOnCompacts (N ω)) ∧
+      ∀ ω, Good ω → N ω = M t ω := by
+    by_cases ht : t = 0
+    · subst t
+      refine ⟨μ 0,?_,?_,?_⟩
+      · convert hμm (0:ℚ) le_rfl using 1
+        norm_num
+      · intro ω
+        let := hμr 0 ω
+        exact ⟨hμr 0 ω,inferInstance⟩
+      · intro ω hω
+        simpa only [Rat.cast_zero,NNReal.coe_zero] using (hω.2 0).symm
+    · have htpos : 0 < (t:ℝ) := NNReal.coe_pos.mpr (pos_iff_ne_zero.mpr ht)
+      obtain ⟨q,_,hq,hqt⟩ := Rat.denseRange_cast.exists_seq_strictMono_tendsto_of_lt
+        (fun a b hab => Rat.cast_le.mpr hab) htpos
+      have hqm (n : ℕ) : Measurable[ℱ t] (μ (q n)) := by
+        have hqn : 0 ≤ q n := Rat.cast_nonneg.mp (hq n).1.le
+        have htime : (q n : ℝ).toNNReal ≤ t := by
+          simpa only [Real.toNNReal_coe] using Real.toNNReal_le_toNNReal (hq n).2.le
+        exact (hμm (q n) hqn).mono (ℱ.mono htime) le_rfl
+      have hfinite (n : ℕ) (ω : Ω) : IsFiniteMeasureOnCompacts (μ (q n) ω) := by
+        let := hμr (q n) ω
+        infer_instance
+      let : MeasurableSpace Ω := ℱ t
+      have hm (n : ℕ) (f : C_c(upperHalfPlane,ℝ)) :
+          Measurable[ℱ t] (fun ω => ∫ z, f z ∂μ (q n) ω) :=
+        measurable_halfPlane_compact_test_integral (μ (q n)) (hqm n) (hμr (q n)) f
+      obtain ⟨N,hNm,hNr,hNe⟩ := exists_subsigma_radon_version_identified
+        (ℱ t) (fun n => μ (q n)) hfinite hm
+      refine ⟨N,hNm,hNr,?_⟩
+      intro ω hω
+      apply hNe ω (M t ω) (hMr t ω)
+      intro f
+      simpa only [Function.comp_def,hω.2] using
+        (hω.1 f).continuousAt.tendsto.comp hqt
+  choose N hNm hNr hNe using hex
+  refine ⟨N,hNm,hNr,?_⟩
+  filter_upwards [hcont,hrat] with ω hc hr
+  exact fun t => hNe t ω ⟨hc,hr⟩
+
+end SLEExactGauge
+
+end
+
+end OAI

lean/OAI/Probability/SLE/Mass/RationalTraceMassControl.lean

@@ -1,101 +1,101 @@
-import OAI.Probability.SLE.Mass.RadonTestLimitProperties
-import Mathlib.Topology.Instances.Rat
-import Mathlib.Topology.DenseEmbedding
-
-namespace OAI
-
-/-! Shrinking trace intervals have vanishing nonatomic mass. This gives
-local oscillation control and continuous extension from rational times. -/
-
-noncomputable section
-open Set Filter MeasureTheory
-open scoped Topology ENNReal
-
-namespace SLEExactGauge
-
-variable {X : Type*} [TopologicalSpace X] [MeasurableSpace X] [BorelSpace X]
-
-omit [BorelSpace X] in
-/-- Continuity and null singleton mass control every sufficiently short
-trace interval around any fixed time. It applies to a finite compact
-restriction of the terminal measure. -/
-theorem trace_interval_mass_small (ν : Measure X) [ν.OuterRegular]
-    [NullSingletonClass ν] (γ : ℝ → X) (hγ : Continuous γ)
-    (t : ℝ) (ε : ℝ≥0∞) (hε : 0 < ε) :
-    ∃ δ : ℝ, 0 < δ ∧ ∀ a b : ℝ, dist a t < δ → dist b t < δ →
-      ν (γ '' Icc a b) < ε := by
-  obtain ⟨U,hUsub,hU,hνU⟩ := ({γ t} : Set X).exists_isOpen_lt_of_lt (μ := ν) ε (by simpa using hε)
-  have htU : γ t ∈ U := hUsub (mem_singleton _)
-  have hpre : γ ⁻¹' U ∈ 𝓝 t := hγ.continuousAt.preimage_mem_nhds (hU.mem_nhds htU)
-  obtain ⟨δ,hδ,hδsub⟩ := Metric.mem_nhds_iff.mp hpre
-  refine ⟨δ,hδ,fun a b ha hb => (measure_mono ?_).trans_lt hνU⟩
-  rintro _ ⟨x,hx,rfl⟩
-  apply hδsub
-  rw [Metric.mem_ball,Real.dist_eq]
-  rw [Real.dist_eq,abs_lt] at ha hb
-  exact abs_lt.mpr ⟨lt_of_lt_of_le ha.1 (sub_le_sub_right hx.1 t),
-    lt_of_le_of_lt (sub_le_sub_right hx.2 t) hb.2⟩
-
-/-- A rational-time real observable with arbitrarily small local
-oscillation has a unique continuous extension to all real times. -/
-theorem exists_continuous_rational_extension
-    (f : ℚ → ℝ)
-    (hosc : ∀ t : ℝ, ∀ ε : ℝ, 0 < ε → ∃ δ : ℝ, 0 < δ ∧
-      ∀ p q : ℚ, dist (p:ℝ) t < δ → dist (q:ℝ) t < δ → dist (f p) (f q) < ε) :
-    ∃ F : ℝ → ℝ, Continuous F ∧ (∀ q : ℚ, F q=f q) ∧
-      ∀ G : ℝ → ℝ, Continuous G → (∀ q : ℚ, G q=f q) → G=F := by
-  let D := Rat.isDenseEmbedding_coe_real.isDenseInducing
-  have hlim (t : ℝ) : ∃ c : ℝ, Tendsto f (comap ((↑) : ℚ → ℝ) (𝓝 t)) (𝓝 c) := by
-    let : NeBot (comap ((↑) : ℚ → ℝ) (𝓝 t))  := D.comap_nhds_neBot t
-    apply cauchy_map_iff_exists_tendsto.mp
-    apply Metric.cauchy_iff.mpr
-    refine ⟨inferInstance,fun ε hε => ?_⟩
-    obtain ⟨δ,hδ,hcontrol⟩ := hosc t ε hε
-    let A : Set ℚ := ((↑) : ℚ → ℝ) ⁻¹' Metric.ball t δ
-    have hA : A ∈ comap ((↑) : ℚ → ℝ) (𝓝 t) :=
-      preimage_mem_comap (Metric.ball_mem_nhds t hδ)
-    refine ⟨f '' A,image_mem_map hA,?_⟩
-    rintro _ ⟨p,hp,rfl⟩ _ ⟨q,hq,rfl⟩
-    exact hcontrol p q hp hq
-  refine ⟨D.extend f,D.continuous_extend hlim,D.extend_eq' hlim,?_⟩
-  intro G hG heq
-  exact (D.extend_unique heq hG).symm
-
-omit [BorelSpace X] in
-/-- The trace-support estimate for increments supplies the local
-oscillation hypothesis of the rational extension theorem. -/
-theorem continuous_rational_extension_of_trace_control
-    (ν : Measure X) [ν.OuterRegular] [IsFiniteMeasure ν] [NullSingletonClass ν]
-    (γ : ℝ → X) (hγ : Continuous γ) (f : ℚ → ℝ) (C : ℝ) (hC : 0 ≤ C)
-    (hcontrol : ∀ p q : ℚ, dist (f p) (f q) ≤
-      C*(ν (γ '' Icc (min (p:ℝ) q) (max (p:ℝ) q))).toReal) :
-    ∃ F : ℝ → ℝ, Continuous F ∧ (∀ q : ℚ, F q=f q) ∧
-      ∀ G : ℝ → ℝ, Continuous G → (∀ q : ℚ, G q=f q) → G=F := by
-  apply exists_continuous_rational_extension f
-  intro t ε hε
-  have he : 0 < ε/(C+1) := div_pos hε (by linarith)
-  obtain ⟨δ,hδ,hsmall⟩ := trace_interval_mass_small ν γ hγ t
-    (ENNReal.ofReal (ε/(C+1))) (ENNReal.ofReal_pos.mpr he)
-  refine ⟨δ,hδ,fun p q hp hq => ?_⟩
-  have hm : dist (min (p:ℝ) q) t < δ := by
-    rcases le_total (p:ℝ) q with h | h
-    · simpa only [min_eq_left h] using hp
-    · simpa only [min_eq_right h] using hq
-  have hM : dist (max (p:ℝ) q) t < δ := by
-    rcases le_total (p:ℝ) q with h | h
-    · simpa only [max_eq_right h] using hq
-    · simpa only [max_eq_left h] using hp
-  have hv : (ν (γ '' Icc (min (p:ℝ) q) (max (p:ℝ) q))).toReal < ε/(C+1) := by
-    have hh := (ENNReal.toReal_lt_toReal (measure_ne_top ν _) ENNReal.ofReal_ne_top).mpr (hsmall _ _ hm hM)
-    simpa only [ENNReal.toReal_ofReal he.le] using hh
-  have hbound := hcontrol p q
-  have hratio : C*(ε/(C+1)) < ε := by
-    rw [← mul_div_assoc,div_lt_iff₀ (by linarith : 0<C+1)]
-    nlinarith
-  exact hbound.trans_lt ((mul_le_mul_of_nonneg_left hv.le hC).trans_lt hratio)
-
-end SLEExactGauge
-
-end
-
-end OAI
+import OAI.Probability.SLE.Mass.RadonTestLimitProperties
+import Mathlib.Topology.Instances.Rat
+import Mathlib.Topology.DenseEmbedding
+
+namespace OAI
+
+/-! Shrinking trace intervals have vanishing nonatomic mass. This gives
+local oscillation control and continuous extension from rational times. -/
+
+noncomputable section
+open Set Filter MeasureTheory
+open scoped Topology ENNReal
+
+namespace SLEExactGauge
+
+variable {X : Type*} [TopologicalSpace X] [MeasurableSpace X] [BorelSpace X]
+
+omit [BorelSpace X] in
+/-- Continuity and null singleton mass control every sufficiently short
+trace interval around any fixed time. It applies to a finite compact
+restriction of the terminal measure. -/
+theorem trace_interval_mass_small (ν : Measure X) [ν.OuterRegular]
+    [NullSingletonClass ν] (γ : ℝ → X) (hγ : Continuous γ)
+    (t : ℝ) (ε : ℝ≥0∞) (hε : 0 < ε) :
+    ∃ δ : ℝ, 0 < δ ∧ ∀ a b : ℝ, dist a t < δ → dist b t < δ →
+      ν (γ '' Icc a b) < ε := by
+  obtain ⟨U,hUsub,hU,hνU⟩ := ({γ t} : Set X).exists_isOpen_lt_of_lt (μ := ν) ε (by simpa using hε)
+  have htU : γ t ∈ U := hUsub (mem_singleton _)
+  have hpre : γ ⁻¹' U ∈ 𝓝 t := hγ.continuousAt.preimage_mem_nhds (hU.mem_nhds htU)
+  obtain ⟨δ,hδ,hδsub⟩ := Metric.mem_nhds_iff.mp hpre
+  refine ⟨δ,hδ,fun a b ha hb => (measure_mono ?_).trans_lt hνU⟩
+  rintro _ ⟨x,hx,rfl⟩
+  apply hδsub
+  rw [Metric.mem_ball,Real.dist_eq]
+  rw [Real.dist_eq,abs_lt] at ha hb
+  exact abs_lt.mpr ⟨lt_of_lt_of_le ha.1 (sub_le_sub_right hx.1 t),
+    lt_of_le_of_lt (sub_le_sub_right hx.2 t) hb.2⟩
+
+/-- A rational-time real observable with arbitrarily small local
+oscillation has a unique continuous extension to all real times. -/
+theorem exists_continuous_rational_extension
+    (f : ℚ → ℝ)
+    (hosc : ∀ t : ℝ, ∀ ε : ℝ, 0 < ε → ∃ δ : ℝ, 0 < δ ∧
+      ∀ p q : ℚ, dist (p:ℝ) t < δ → dist (q:ℝ) t < δ → dist (f p) (f q) < ε) :
+    ∃ F : ℝ → ℝ, Continuous F ∧ (∀ q : ℚ, F q=f q) ∧
+      ∀ G : ℝ → ℝ, Continuous G → (∀ q : ℚ, G q=f q) → G=F := by
+  let D := Rat.isDenseEmbedding_coe_real.isDenseInducing
+  have hlim (t : ℝ) : ∃ c : ℝ, Tendsto f (comap ((↑) : ℚ → ℝ) (𝓝 t)) (𝓝 c) := by
+    let : NeBot (comap ((↑) : ℚ → ℝ) (𝓝 t))  := D.comap_nhds_neBot t
+    apply cauchy_map_iff_exists_tendsto.mp
+    apply Metric.cauchy_iff.mpr
+    refine ⟨inferInstance,fun ε hε => ?_⟩
+    obtain ⟨δ,hδ,hcontrol⟩ := hosc t ε hε
+    let A : Set ℚ := ((↑) : ℚ → ℝ) ⁻¹' Metric.ball t δ
+    have hA : A ∈ comap ((↑) : ℚ → ℝ) (𝓝 t) :=
+      preimage_mem_comap (Metric.ball_mem_nhds t hδ)
+    refine ⟨f '' A,image_mem_map hA,?_⟩
+    rintro _ ⟨p,hp,rfl⟩ _ ⟨q,hq,rfl⟩
+    exact hcontrol p q hp hq
+  refine ⟨D.extend f,D.continuous_extend hlim,D.extend_eq' hlim,?_⟩
+  intro G hG heq
+  exact (D.extend_unique heq hG).symm
+
+omit [BorelSpace X] in
+/-- The trace-support estimate for increments supplies the local
+oscillation hypothesis of the rational extension theorem. -/
+theorem continuous_rational_extension_of_trace_control
+    (ν : Measure X) [ν.OuterRegular] [IsFiniteMeasure ν] [NullSingletonClass ν]
+    (γ : ℝ → X) (hγ : Continuous γ) (f : ℚ → ℝ) (C : ℝ) (hC : 0 ≤ C)
+    (hcontrol : ∀ p q : ℚ, dist (f p) (f q) ≤
+      C*(ν (γ '' Icc (min (p:ℝ) q) (max (p:ℝ) q))).toReal) :
+    ∃ F : ℝ → ℝ, Continuous F ∧ (∀ q : ℚ, F q=f q) ∧
+      ∀ G : ℝ → ℝ, Continuous G → (∀ q : ℚ, G q=f q) → G=F := by
+  apply exists_continuous_rational_extension f
+  intro t ε hε
+  have he : 0 < ε/(C+1) := div_pos hε (by linarith)
+  obtain ⟨δ,hδ,hsmall⟩ := trace_interval_mass_small ν γ hγ t
+    (ENNReal.ofReal (ε/(C+1))) (ENNReal.ofReal_pos.mpr he)
+  refine ⟨δ,hδ,fun p q hp hq => ?_⟩
+  have hm : dist (min (p:ℝ) q) t < δ := by
+    rcases le_total (p:ℝ) q with h | h
+    · simpa only [min_eq_left h] using hp
+    · simpa only [min_eq_right h] using hq
+  have hM : dist (max (p:ℝ) q) t < δ := by
+    rcases le_total (p:ℝ) q with h | h
+    · simpa only [max_eq_right h] using hq
+    · simpa only [max_eq_left h] using hp
+  have hv : (ν (γ '' Icc (min (p:ℝ) q) (max (p:ℝ) q))).toReal < ε/(C+1) := by
+    have hh := (ENNReal.toReal_lt_toReal (measure_ne_top ν _) ENNReal.ofReal_ne_top).mpr (hsmall _ _ hm hM)
+    simpa only [ENNReal.toReal_ofReal he.le] using hh
+  have hbound := hcontrol p q
+  have hratio : C*(ε/(C+1)) < ε := by
+    rw [← mul_div_assoc,div_lt_iff₀ (by linarith : 0<C+1)]
+    nlinarith
+  exact hbound.trans_lt ((mul_le_mul_of_nonneg_left hv.le hC).trans_lt hratio)
+
+end SLEExactGauge
+
+end
+
+end OAI

lean/OAI/Probability/SLE/Mass/RationalTraceMassLocal.lean

@@ -1,197 +1,197 @@
-import OAI.Probability.SLE.Mass.RationalTraceMassVariation
-import OAI.Probability.SLE.LoewnerCharts
-
-namespace OAI
-
-/-! Rational-time reconstruction on the open half-plane. The terminal
-measure is only locally finite; the trace is allowed to touch the real
-line. Compact test supports supply the finite ambient control measures. -/
-
-noncomputable section
-open Set Filter MeasureTheory Classical
-open scoped Topology ENNReal CompactlySupported
-
-namespace SLEExactGauge
-
-local instance : LocallyCompactSpace upperHalfPlane := isOpen_upperHalfPlane.locallyCompactSpace
-
-structure HalfPlaneTraceIncrements (μ : ℚ → Measure upperHalfPlane)
-    (ν : Measure upperHalfPlane) (γ : ℝ → ℂ) : Prop where
-  regular : ∀ q, (μ q).Regular
-  dominated : ∀ q, μ q ≤ ν
-  increment : ∀ p q, p ≤ q → ∃ η : Measure upperHalfPlane,
-    μ q = μ p + η ∧ η ≤ ν.restrict {z : upperHalfPlane | (z : ℂ) ∈ γ '' Icc (p:ℝ) q}
-
-lemma HalfPlaneTraceIncrements.monotone
-    {μ : ℚ → Measure upperHalfPlane} {ν : Measure upperHalfPlane} {γ : ℝ → ℂ}
-    (H : HalfPlaneTraceIncrements μ ν γ) : Monotone μ := by
-  intro p q hpq
-  obtain ⟨η,hη,_⟩ := H.increment p q hpq
-  rw [hη]
-  exact Measure.le_add_right le_rfl
-
-def ambientCompactRestriction (ν : Measure upperHalfPlane) (K : Set upperHalfPlane) : Measure ℂ :=
-  Measure.map (Subtype.val : upperHalfPlane → ℂ) (ν.restrict K)
-
-lemma ambientCompactRestriction_finite (ν : Measure upperHalfPlane)
-    [IsFiniteMeasureOnCompacts ν] (K : Set upperHalfPlane) (hK : IsCompact K) :
-    IsFiniteMeasure (ambientCompactRestriction ν K) := by
-  have : Fact (ν K < ⊤) := ⟨hK.measure_lt_top⟩
-  exact inferInstanceAs (IsFiniteMeasure ((ν.restrict K).map (Subtype.val : upperHalfPlane → ℂ)))
-
-lemma ambientCompactRestriction_nullSingletons (ν : Measure upperHalfPlane)
-    [NullSingletonClass ν] (K : Set upperHalfPlane) :
-    NullSingletonClass (ambientCompactRestriction ν K) := by
-  constructor
-  intro z
-  rw [ambientCompactRestriction,Measure.map_apply measurable_subtype_coe (measurableSet_singleton z)]
-  apply Set.Subsingleton.measure_zero
-  intro a ha b hb
-  apply Subtype.ext
-  exact (mem_singleton_iff.mp ha).trans (mem_singleton_iff.mp hb).symm
-
-lemma HalfPlaneTraceIncrements.integral_dist_le
-    {μ : ℚ → Measure upperHalfPlane} {ν : Measure upperHalfPlane} [ν.Regular]
-    {γ : ℝ → ℂ} (H : HalfPlaneTraceIncrements μ ν γ) (hγ : Continuous γ)
-    (f : C_c(upperHalfPlane,ℝ)) (p q : ℚ) :
-    dist (∫ z, f z ∂μ p) (∫ z, f z ∂μ q) ≤ ‖f.toBoundedContinuousFunction‖ *
-      (ambientCompactRestriction ν (tsupport f)
-        (γ '' Icc (min (p:ℝ) q) (max (p:ℝ) q))).toReal := by
-  have ordered (a b : ℚ) (hab : a ≤ b) :
-      dist (∫ z, f z ∂μ a) (∫ z, f z ∂μ b) ≤ ‖f.toBoundedContinuousFunction‖ *
-        (ambientCompactRestriction ν (tsupport f) (γ '' Icc (a:ℝ) b)).toReal := by
-    let K := tsupport f
-    let A : Set upperHalfPlane := {z | (z : ℂ) ∈ γ '' Icc (a:ℝ) b}
-    have hAm : MeasurableSet A :=
-      (isCompact_Icc.image hγ).measurableSet.preimage measurable_subtype_coe
-    obtain ⟨η,hη,hην⟩ := H.increment a b hab
-    have hηle : η ≤ ν := hην.trans Measure.restrict_le_self
-    let : IsFiniteMeasureOnCompacts η := ⟨fun L hL => (hηle L).trans_lt hL.measure_lt_top⟩
-    let : (μ a).Regular := H.regular a
-    have hηK : η K < ⊤ := f.hasCompactSupport.measure_lt_top
-    have : Fact (η K < ⊤) := ⟨hηK⟩
-    let : IsFiniteMeasure (η.restrict K) := inferInstance
-    let : IsFiniteMeasure (ambientCompactRestriction ν K) :=
-      ambientCompactRestriction_finite ν K f.hasCompactSupport
-    have hbound : η K ≤ ambientCompactRestriction ν K (γ '' Icc (a:ℝ) b) := by
-      calc
-        η K ≤ ν.restrict A K := hην K
-        _ = ν (K ∩ A) := Measure.restrict_apply f.hasCompactSupport.measurableSet
-        _ = ambientCompactRestriction ν K (γ '' Icc (a:ℝ) b) := by
-          rw [ambientCompactRestriction,Measure.map_apply measurable_subtype_coe
-            (isCompact_Icc.image hγ).measurableSet]
-          change ν (K ∩ A) = ν.restrict K A
-          rw [Measure.restrict_apply hAm,inter_comm]
-    rw [hη,integral_add_measure f.integrable f.integrable,dist_eq_norm]
-    have hsub : (∫ z, f z ∂μ a)-((∫ z, f z ∂μ a)+(∫ z, f z ∂η)) = -(∫ z, f z ∂η) := by ring
-    rw [hsub,norm_neg,← setIntegral_eq_integral_of_forall_compl_eq_zero
-      (fun z hz => image_eq_zero_of_notMem_tsupport hz)]
-    have hb := norm_integral_le_of_norm_le_const (μ := η.restrict K)
-      (ae_of_all _ (fun z => f.toBoundedContinuousFunction.norm_coe_le_norm z))
-    apply hb.trans
-    apply mul_le_mul_of_nonneg_left _ (norm_nonneg _)
-    apply ENNReal.toReal_mono (measure_ne_top (ambientCompactRestriction ν K) _)
-    simpa only [Measure.restrict_apply_univ] using hbound
-  rcases le_total p q with h | h
-  · simpa only [min_eq_left (Rat.cast_le.mpr h),max_eq_right (Rat.cast_le.mpr h)] using ordered p q h
-  · rw [dist_comm]
-    simpa only [min_eq_right (Rat.cast_le.mpr h),max_eq_left (Rat.cast_le.mpr h)] using ordered q p h
-
-lemma HalfPlaneTraceIncrements.continuous_test_extension
-    {μ : ℚ → Measure upperHalfPlane} {ν : Measure upperHalfPlane} [ν.Regular]
-    [NullSingletonClass ν] {γ : ℝ → ℂ}
-    (H : HalfPlaneTraceIncrements μ ν γ) (hγ : Continuous γ) (f : C_c(upperHalfPlane,ℝ)) :
-    ∃ F : ℝ → ℝ, Continuous F ∧ (∀ q : ℚ, F q = ∫ z, f z ∂μ q) ∧
-      ∀ G : ℝ → ℝ, Continuous G → (∀ q : ℚ, G q = ∫ z, f z ∂μ q) → G = F := by
-  let ρ := ambientCompactRestriction ν (tsupport f)
-  let : IsFiniteMeasure ρ := ambientCompactRestriction_finite ν _ f.hasCompactSupport
-  let : NullSingletonClass ρ := ambientCompactRestriction_nullSingletons ν _
-  exact continuous_rational_extension_of_trace_control ρ γ hγ
-    (fun q => ∫ z, f z ∂μ q) ‖f.toBoundedContinuousFunction‖ (norm_nonneg _)
-    (H.integral_dist_le hγ f)
-
-/-- One locally finite Radon family extends all rational times. Every
-compact test is continuous, even when the physical trace meets the real line. -/
-theorem HalfPlaneTraceIncrements.exists_continuous_extension
-    {μ : ℚ → Measure upperHalfPlane} {ν : Measure upperHalfPlane} [ν.Regular]
-    [NullSingletonClass ν] {γ : ℝ → ℂ}
-    (H : HalfPlaneTraceIncrements μ ν γ) (hγ : Continuous γ) :
-    ∃ M : ℝ → Measure upperHalfPlane, (∀ t, (M t).Regular) ∧ (∀ t, M t ≤ ν) ∧
-      (∀ q : ℚ, M q = μ q) ∧
-      (∀ f : C_c(upperHalfPlane,ℝ), Continuous (fun t => ∫ z, f z ∂M t)) ∧ Monotone M := by
-  choose F hFc hFq _ using H.continuous_test_extension hγ
-  have hex (t : ℝ) : ∃ η : Measure upperHalfPlane, η.Regular ∧ IsFiniteMeasureOnCompacts η ∧
-      ∀ f : C_c(upperHalfPlane,ℝ), (∫ z, f z ∂η) = F f t := by
-    obtain ⟨q,hq⟩ := exists_rational_sequence_tendsto t
-    let (n : ℕ) : (μ (q n)).Regular := H.regular (q n)
-    have hlim (f : C_c(upperHalfPlane,ℝ)) :
-        Tendsto (fun n => ∫ z, f z ∂μ (q n)) atTop (𝓝 (F f t)) := by
-      simpa only [Function.comp_def,hFq] using (hFc f).continuousAt.tendsto.comp hq
-    obtain ⟨η,hηr,hηf,hηlim⟩ := radon_limit_of_all_test_limits (fun n => μ (q n))
-      (fun f => ⟨F f t,hlim f⟩)
-    exact ⟨η,hηr,hηf,fun f => tendsto_nhds_unique (hηlim f) (hlim f)⟩
-  choose M hMr hMf hMI using hex
-  have hcont (f : C_c(upperHalfPlane,ℝ)) : Continuous (fun t => ∫ z, f z ∂M t) := by
-    simpa only [hMI] using hFc f
-  have hrat (q : ℚ) : M q = μ q := by
-    let : (M q).Regular := hMr q
-    let : (μ q).Regular := H.regular q
-    apply Measure.ext_of_integral_eq_on_compactlySupported
-    intro f
-    rw [hMI,hFq]
-  have hdom (t : ℝ) : M t ≤ ν := by
-    let : (M t).Regular := hMr t
-    obtain ⟨q,hq⟩ := exists_rational_sequence_tendsto t
-    apply radon_measure_le_of_nonneg_tests
-    intro f hfn
-    have hlim : Tendsto (fun n => ∫ z, f z ∂μ (q n)) atTop (𝓝 (∫ z, f z ∂M t)) := by
-      simpa only [Function.comp_def,hrat] using (hcont f).continuousAt.tendsto.comp hq
-    apply le_of_tendsto_of_tendsto' hlim tendsto_const_nhds
-    intro n
-    exact integral_mono_measure (H.dominated (q n)) (ae_of_all ν hfn) f.integrable
-  refine ⟨M,hMr,hdom,hrat,hcont,?_⟩
-  intro s t hst
-  rcases eq_or_lt_of_le hst with rfl | hst
-  · exact le_rfl
-  let : (M s).Regular := hMr s
-  let : (M t).Regular := hMr t
-  obtain ⟨p,hp⟩ := exists_rational_sequence_tendsto s
-  obtain ⟨q,hq⟩ := exists_rational_sequence_tendsto t
-  have hp' : ∀ᶠ n in atTop, (p n : ℝ) < (s+t)/2 := hp.eventually (gt_mem_nhds (by linarith))
-  have hq' : ∀ᶠ n in atTop, (s+t)/2 < (q n : ℝ) := hq.eventually (lt_mem_nhds (by linarith))
-  apply radon_measure_le_of_nonneg_tests
-  intro f hfn
-  have hplim : Tendsto (fun n => ∫ z, f z ∂μ (p n)) atTop (𝓝 (∫ z, f z ∂M s)) := by
-    simpa only [Function.comp_def,hrat] using (hcont f).continuousAt.tendsto.comp hp
-  have hqlim : Tendsto (fun n => ∫ z, f z ∂μ (q n)) atTop (𝓝 (∫ z, f z ∂M t)) := by
-    simpa only [Function.comp_def,hrat] using (hcont f).continuousAt.tendsto.comp hq
-  apply le_of_tendsto_of_tendsto hplim hqlim
-  filter_upwards [hp',hq'] with n hpn hqn
-  let : (μ (q n)).Regular := H.regular (q n)
-  exact integral_mono_measure (H.monotone (Rat.cast_le.mp (le_of_lt (hpn.trans hqn))))
-    (ae_of_all _ hfn) f.integrable
-
-/-- Agreement at rational times identifies continuous Radon families.
-Thus the reconstruction is independent of compact exhaustions. -/
-theorem halfPlane_continuous_measure_extension_unique
-    (M N : ℝ → Measure upperHalfPlane)
-    (hMr : ∀ t, (M t).Regular) (hNr : ∀ t, (N t).Regular)
-    (hMc : ∀ f : C_c(upperHalfPlane,ℝ), Continuous (fun t => ∫ z, f z ∂M t))
-    (hNc : ∀ f : C_c(upperHalfPlane,ℝ), Continuous (fun t => ∫ z, f z ∂N t))
-    (heq : ∀ q : ℚ, M q = N q) : M = N := by
-  funext t
-  let : (M t).Regular := hMr t
-  let : (N t).Regular := hNr t
-  apply Measure.ext_of_integral_eq_on_compactlySupported
-  intro f
-  obtain ⟨q,hq⟩ := exists_rational_sequence_tendsto t
-  have hm := (hMc f).continuousAt.tendsto.comp hq
-  have hn := (hNc f).continuousAt.tendsto.comp hq
-  simp only [Function.comp_def,heq] at hm hn
-  exact tendsto_nhds_unique hm hn
-
-end SLEExactGauge
-
-end
-
-end OAI
+import OAI.Probability.SLE.Mass.RationalTraceMassVariation
+import OAI.Probability.SLE.LoewnerCharts
+
+namespace OAI
+
+/-! Rational-time reconstruction on the open half-plane. The terminal
+measure is only locally finite; the trace is allowed to touch the real
+line. Compact test supports supply the finite ambient control measures. -/
+
+noncomputable section
+open Set Filter MeasureTheory Classical
+open scoped Topology ENNReal CompactlySupported
+
+namespace SLEExactGauge
+
+local instance : LocallyCompactSpace upperHalfPlane := isOpen_upperHalfPlane.locallyCompactSpace
+
+structure HalfPlaneTraceIncrements (μ : ℚ → Measure upperHalfPlane)
+    (ν : Measure upperHalfPlane) (γ : ℝ → ℂ) : Prop where
+  regular : ∀ q, (μ q).Regular
+  dominated : ∀ q, μ q ≤ ν
+  increment : ∀ p q, p ≤ q → ∃ η : Measure upperHalfPlane,
+    μ q = μ p + η ∧ η ≤ ν.restrict {z : upperHalfPlane | (z : ℂ) ∈ γ '' Icc (p:ℝ) q}
+
+lemma HalfPlaneTraceIncrements.monotone
+    {μ : ℚ → Measure upperHalfPlane} {ν : Measure upperHalfPlane} {γ : ℝ → ℂ}
+    (H : HalfPlaneTraceIncrements μ ν γ) : Monotone μ := by
+  intro p q hpq
+  obtain ⟨η,hη,_⟩ := H.increment p q hpq
+  rw [hη]
+  exact Measure.le_add_right le_rfl
+
+def ambientCompactRestriction (ν : Measure upperHalfPlane) (K : Set upperHalfPlane) : Measure ℂ :=
+  Measure.map (Subtype.val : upperHalfPlane → ℂ) (ν.restrict K)
+
+lemma ambientCompactRestriction_finite (ν : Measure upperHalfPlane)
+    [IsFiniteMeasureOnCompacts ν] (K : Set upperHalfPlane) (hK : IsCompact K) :
+    IsFiniteMeasure (ambientCompactRestriction ν K) := by
+  have : Fact (ν K < ⊤) := ⟨hK.measure_lt_top⟩
+  exact inferInstanceAs (IsFiniteMeasure ((ν.restrict K).map (Subtype.val : upperHalfPlane → ℂ)))
+
+lemma ambientCompactRestriction_nullSingletons (ν : Measure upperHalfPlane)
+    [NullSingletonClass ν] (K : Set upperHalfPlane) :
+    NullSingletonClass (ambientCompactRestriction ν K) := by
+  constructor
+  intro z
+  rw [ambientCompactRestriction,Measure.map_apply measurable_subtype_coe (measurableSet_singleton z)]
+  apply Set.Subsingleton.measure_zero
+  intro a ha b hb
+  apply Subtype.ext
+  exact (mem_singleton_iff.mp ha).trans (mem_singleton_iff.mp hb).symm
+
+lemma HalfPlaneTraceIncrements.integral_dist_le
+    {μ : ℚ → Measure upperHalfPlane} {ν : Measure upperHalfPlane} [ν.Regular]
+    {γ : ℝ → ℂ} (H : HalfPlaneTraceIncrements μ ν γ) (hγ : Continuous γ)
+    (f : C_c(upperHalfPlane,ℝ)) (p q : ℚ) :
+    dist (∫ z, f z ∂μ p) (∫ z, f z ∂μ q) ≤ ‖f.toBoundedContinuousFunction‖ *
+      (ambientCompactRestriction ν (tsupport f)
+        (γ '' Icc (min (p:ℝ) q) (max (p:ℝ) q))).toReal := by
+  have ordered (a b : ℚ) (hab : a ≤ b) :
+      dist (∫ z, f z ∂μ a) (∫ z, f z ∂μ b) ≤ ‖f.toBoundedContinuousFunction‖ *
+        (ambientCompactRestriction ν (tsupport f) (γ '' Icc (a:ℝ) b)).toReal := by
+    let K := tsupport f
+    let A : Set upperHalfPlane := {z | (z : ℂ) ∈ γ '' Icc (a:ℝ) b}
+    have hAm : MeasurableSet A :=
+      (isCompact_Icc.image hγ).measurableSet.preimage measurable_subtype_coe
+    obtain ⟨η,hη,hην⟩ := H.increment a b hab
+    have hηle : η ≤ ν := hην.trans Measure.restrict_le_self
+    let : IsFiniteMeasureOnCompacts η := ⟨fun L hL => (hηle L).trans_lt hL.measure_lt_top⟩
+    let : (μ a).Regular := H.regular a
+    have hηK : η K < ⊤ := f.hasCompactSupport.measure_lt_top
+    have : Fact (η K < ⊤) := ⟨hηK⟩
+    let : IsFiniteMeasure (η.restrict K) := inferInstance
+    let : IsFiniteMeasure (ambientCompactRestriction ν K) :=
+      ambientCompactRestriction_finite ν K f.hasCompactSupport
+    have hbound : η K ≤ ambientCompactRestriction ν K (γ '' Icc (a:ℝ) b) := by
+      calc
+        η K ≤ ν.restrict A K := hην K
+        _ = ν (K ∩ A) := Measure.restrict_apply f.hasCompactSupport.measurableSet
+        _ = ambientCompactRestriction ν K (γ '' Icc (a:ℝ) b) := by
+          rw [ambientCompactRestriction,Measure.map_apply measurable_subtype_coe
+            (isCompact_Icc.image hγ).measurableSet]
+          change ν (K ∩ A) = ν.restrict K A
+          rw [Measure.restrict_apply hAm,inter_comm]
+    rw [hη,integral_add_measure f.integrable f.integrable,dist_eq_norm]
+    have hsub : (∫ z, f z ∂μ a)-((∫ z, f z ∂μ a)+(∫ z, f z ∂η)) = -(∫ z, f z ∂η) := by ring
+    rw [hsub,norm_neg,← setIntegral_eq_integral_of_forall_compl_eq_zero
+      (fun z hz => image_eq_zero_of_notMem_tsupport hz)]
+    have hb := norm_integral_le_of_norm_le_const (μ := η.restrict K)
+      (ae_of_all _ (fun z => f.toBoundedContinuousFunction.norm_coe_le_norm z))
+    apply hb.trans
+    apply mul_le_mul_of_nonneg_left _ (norm_nonneg _)
+    apply ENNReal.toReal_mono (measure_ne_top (ambientCompactRestriction ν K) _)
+    simpa only [Measure.restrict_apply_univ] using hbound
+  rcases le_total p q with h | h
+  · simpa only [min_eq_left (Rat.cast_le.mpr h),max_eq_right (Rat.cast_le.mpr h)] using ordered p q h
+  · rw [dist_comm]
+    simpa only [min_eq_right (Rat.cast_le.mpr h),max_eq_left (Rat.cast_le.mpr h)] using ordered q p h
+
+lemma HalfPlaneTraceIncrements.continuous_test_extension
+    {μ : ℚ → Measure upperHalfPlane} {ν : Measure upperHalfPlane} [ν.Regular]
+    [NullSingletonClass ν] {γ : ℝ → ℂ}
+    (H : HalfPlaneTraceIncrements μ ν γ) (hγ : Continuous γ) (f : C_c(upperHalfPlane,ℝ)) :
+    ∃ F : ℝ → ℝ, Continuous F ∧ (∀ q : ℚ, F q = ∫ z, f z ∂μ q) ∧
+      ∀ G : ℝ → ℝ, Continuous G → (∀ q : ℚ, G q = ∫ z, f z ∂μ q) → G = F := by
+  let ρ := ambientCompactRestriction ν (tsupport f)
+  let : IsFiniteMeasure ρ := ambientCompactRestriction_finite ν _ f.hasCompactSupport
+  let : NullSingletonClass ρ := ambientCompactRestriction_nullSingletons ν _
+  exact continuous_rational_extension_of_trace_control ρ γ hγ
+    (fun q => ∫ z, f z ∂μ q) ‖f.toBoundedContinuousFunction‖ (norm_nonneg _)
+    (H.integral_dist_le hγ f)
+
+/-- One locally finite Radon family extends all rational times. Every
+compact test is continuous, even when the physical trace meets the real line. -/
+theorem HalfPlaneTraceIncrements.exists_continuous_extension
+    {μ : ℚ → Measure upperHalfPlane} {ν : Measure upperHalfPlane} [ν.Regular]
+    [NullSingletonClass ν] {γ : ℝ → ℂ}
+    (H : HalfPlaneTraceIncrements μ ν γ) (hγ : Continuous γ) :
+    ∃ M : ℝ → Measure upperHalfPlane, (∀ t, (M t).Regular) ∧ (∀ t, M t ≤ ν) ∧
+      (∀ q : ℚ, M q = μ q) ∧
+      (∀ f : C_c(upperHalfPlane,ℝ), Continuous (fun t => ∫ z, f z ∂M t)) ∧ Monotone M := by
+  choose F hFc hFq _ using H.continuous_test_extension hγ
+  have hex (t : ℝ) : ∃ η : Measure upperHalfPlane, η.Regular ∧ IsFiniteMeasureOnCompacts η ∧
+      ∀ f : C_c(upperHalfPlane,ℝ), (∫ z, f z ∂η) = F f t := by
+    obtain ⟨q,hq⟩ := exists_rational_sequence_tendsto t
+    let (n : ℕ) : (μ (q n)).Regular := H.regular (q n)
+    have hlim (f : C_c(upperHalfPlane,ℝ)) :
+        Tendsto (fun n => ∫ z, f z ∂μ (q n)) atTop (𝓝 (F f t)) := by
+      simpa only [Function.comp_def,hFq] using (hFc f).continuousAt.tendsto.comp hq
+    obtain ⟨η,hηr,hηf,hηlim⟩ := radon_limit_of_all_test_limits (fun n => μ (q n))
+      (fun f => ⟨F f t,hlim f⟩)
+    exact ⟨η,hηr,hηf,fun f => tendsto_nhds_unique (hηlim f) (hlim f)⟩
+  choose M hMr hMf hMI using hex
+  have hcont (f : C_c(upperHalfPlane,ℝ)) : Continuous (fun t => ∫ z, f z ∂M t) := by
+    simpa only [hMI] using hFc f
+  have hrat (q : ℚ) : M q = μ q := by
+    let : (M q).Regular := hMr q
+    let : (μ q).Regular := H.regular q
+    apply Measure.ext_of_integral_eq_on_compactlySupported
+    intro f
+    rw [hMI,hFq]
+  have hdom (t : ℝ) : M t ≤ ν := by
+    let : (M t).Regular := hMr t
+    obtain ⟨q,hq⟩ := exists_rational_sequence_tendsto t
+    apply radon_measure_le_of_nonneg_tests
+    intro f hfn
+    have hlim : Tendsto (fun n => ∫ z, f z ∂μ (q n)) atTop (𝓝 (∫ z, f z ∂M t)) := by
+      simpa only [Function.comp_def,hrat] using (hcont f).continuousAt.tendsto.comp hq
+    apply le_of_tendsto_of_tendsto' hlim tendsto_const_nhds
+    intro n
+    exact integral_mono_measure (H.dominated (q n)) (ae_of_all ν hfn) f.integrable
+  refine ⟨M,hMr,hdom,hrat,hcont,?_⟩
+  intro s t hst
+  rcases eq_or_lt_of_le hst with rfl | hst
+  · exact le_rfl
+  let : (M s).Regular := hMr s
+  let : (M t).Regular := hMr t
+  obtain ⟨p,hp⟩ := exists_rational_sequence_tendsto s
+  obtain ⟨q,hq⟩ := exists_rational_sequence_tendsto t
+  have hp' : ∀ᶠ n in atTop, (p n : ℝ) < (s+t)/2 := hp.eventually (gt_mem_nhds (by linarith))
+  have hq' : ∀ᶠ n in atTop, (s+t)/2 < (q n : ℝ) := hq.eventually (lt_mem_nhds (by linarith))
+  apply radon_measure_le_of_nonneg_tests
+  intro f hfn
+  have hplim : Tendsto (fun n => ∫ z, f z ∂μ (p n)) atTop (𝓝 (∫ z, f z ∂M s)) := by
+    simpa only [Function.comp_def,hrat] using (hcont f).continuousAt.tendsto.comp hp
+  have hqlim : Tendsto (fun n => ∫ z, f z ∂μ (q n)) atTop (𝓝 (∫ z, f z ∂M t)) := by
+    simpa only [Function.comp_def,hrat] using (hcont f).continuousAt.tendsto.comp hq
+  apply le_of_tendsto_of_tendsto hplim hqlim
+  filter_upwards [hp',hq'] with n hpn hqn
+  let : (μ (q n)).Regular := H.regular (q n)
+  exact integral_mono_measure (H.monotone (Rat.cast_le.mp (le_of_lt (hpn.trans hqn))))
+    (ae_of_all _ hfn) f.integrable
+
+/-- Agreement at rational times identifies continuous Radon families.
+Thus the reconstruction is independent of compact exhaustions. -/
+theorem halfPlane_continuous_measure_extension_unique
+    (M N : ℝ → Measure upperHalfPlane)
+    (hMr : ∀ t, (M t).Regular) (hNr : ∀ t, (N t).Regular)
+    (hMc : ∀ f : C_c(upperHalfPlane,ℝ), Continuous (fun t => ∫ z, f z ∂M t))
+    (hNc : ∀ f : C_c(upperHalfPlane,ℝ), Continuous (fun t => ∫ z, f z ∂N t))
+    (heq : ∀ q : ℚ, M q = N q) : M = N := by
+  funext t
+  let : (M t).Regular := hMr t
+  let : (N t).Regular := hNr t
+  apply Measure.ext_of_integral_eq_on_compactlySupported
+  intro f
+  obtain ⟨q,hq⟩ := exists_rational_sequence_tendsto t
+  have hm := (hMc f).continuousAt.tendsto.comp hq
+  have hn := (hNc f).continuousAt.tendsto.comp hq
+  simp only [Function.comp_def,heq] at hm hn
+  exact tendsto_nhds_unique hm hn
+
+end SLEExactGauge
+
+end
+
+end OAI

lean/OAI/Probability/SLE/Mass/RationalTraceMassLocalVariation.lean

@@ -1,139 +1,139 @@
-import OAI.Probability.SLE.Mass.RationalTraceMassLocal
-
-namespace OAI
-
-/-! Local total-variation continuity of the half-plane reconstruction.
-Only the mass of a fixed compact is used; the terminal mass may be infinite. -/
-
-noncomputable section
-open Set Filter MeasureTheory Classical
-open scoped Topology ENNReal CompactlySupported
-
-namespace SLEExactGauge
-
-local instance : LocallyCompactSpace upperHalfPlane := isOpen_upperHalfPlane.locallyCompactSpace
-
-private lemma halfPlane_regular_add (μ ν : Measure upperHalfPlane) [μ.Regular] [ν.Regular] :
-    (μ + ν).Regular := by
-  let : IsFiniteMeasureOnCompacts (μ + ν) := ⟨fun K hK => by
-    rw [Measure.add_apply]
-    exact ENNReal.add_lt_top.mpr ⟨hK.measure_lt_top,hK.measure_lt_top⟩⟩
-  infer_instance
-
-theorem HalfPlaneTraceIncrements.local_variation_continuity
-    {μ : ℚ → Measure upperHalfPlane} {ν : Measure upperHalfPlane} [ν.Regular]
-    [NullSingletonClass ν] {γ : ℝ → ℂ}
-    (H : HalfPlaneTraceIncrements μ ν γ) (hγ : Continuous γ)
-    (M : ℝ → Measure upperHalfPlane) (hMr : ∀ t, (M t).Regular)
-    (hdom : ∀ t, M t ≤ ν) (hrat : ∀ q : ℚ, M q = μ q)
-    (hcont : ∀ f : C_c(upperHalfPlane,ℝ), Continuous (fun t => ∫ z, f z ∂M t))
-    (K : Set upperHalfPlane) (hK : IsCompact K) :
-    ∀ t₀ : ℝ, ∀ ε : ℝ, 0 < ε → ∃ δ : ℝ, 0 < δ ∧
-      ∀ s t : ℝ, dist s t₀ < δ → dist t t₀ < δ →
-        ∀ A : Set upperHalfPlane, MeasurableSet A → A ⊆ K →
-          |(M s A).toReal-(M t A).toReal| < ε := by
-  intro t₀ ε hε
-  let ρ := ambientCompactRestriction ν K
-  let : IsFiniteMeasure ρ := ambientCompactRestriction_finite ν K hK
-  let : NullSingletonClass ρ := ambientCompactRestriction_nullSingletons ν K
-  obtain ⟨U,hUsub,hU,hρU⟩ := ({γ t₀} : Set ℂ).exists_isOpen_lt_of_lt (μ := ρ)
-    (ENNReal.ofReal ε) (by simpa using ENNReal.ofReal_pos.mpr hε)
-  let V : Set upperHalfPlane := (Subtype.val : upperHalfPlane → ℂ) ⁻¹' U
-  have hV : IsOpen V := hU.preimage continuous_subtype_val
-  have htU : γ t₀ ∈ U := hUsub (mem_singleton _)
-  obtain ⟨δ,hδ,hδsub⟩ := Metric.mem_nhds_iff.mp
-    (hγ.continuousAt.preimage_mem_nhds (hU.mem_nhds htU))
-  have hI (a b : ℝ) (ha : dist a t₀ < δ) (hb : dist b t₀ < δ) : γ '' Icc a b ⊆ U := by
-    rintro _ ⟨x,hx,rfl⟩
-    apply hδsub
-    rw [Metric.mem_ball,Real.dist_eq]
-    rw [Real.dist_eq,abs_lt] at ha hb
-    exact abs_lt.mpr ⟨lt_of_lt_of_le ha.1 (sub_le_sub_right hx.1 t₀),
-      lt_of_le_of_lt (sub_le_sub_right hx.2 t₀) hb.2⟩
-  have hq (p q : ℚ) (hp : dist (p:ℝ) t₀ < δ) (hq : dist (q:ℝ) t₀ < δ) :
-      μ p ≤ μ q+ν.restrict V := by
-    rcases le_total p q with hpq | hqp
-    · exact (H.monotone hpq).trans (Measure.le_add_right le_rfl)
-    · obtain ⟨η,hη,hην⟩ := H.increment q p hqp
-      rw [hη]
-      apply add_le_add le_rfl
-      exact hην.trans (Measure.restrict_mono
-        (show {z : upperHalfPlane | (z : ℂ) ∈ γ '' Icc (q:ℝ) p} ⊆ V
-          from fun z hz => hI q p hq hp hz) le_rfl)
-  have hreal (s t : ℝ) (hs : dist s t₀ < δ) (ht : dist t t₀ < δ) :
-      M s ≤ M t+ν.restrict V := by
-    let : (M s).Regular := hMr s
-    let : (M t).Regular := hMr t
-    let : (ν.restrict V).Regular := inferInstance
-    let : (M t+ν.restrict V).Regular := halfPlane_regular_add _ _
-    obtain ⟨p,hp⟩ := exists_rational_sequence_tendsto s
-    obtain ⟨q,hqt⟩ := exists_rational_sequence_tendsto t
-    have hpU : ∀ᶠ n in atTop, dist (p n:ℝ) t₀ < δ :=
-      hp.eventually (isOpen_lt (continuous_id.dist continuous_const) continuous_const |>.mem_nhds hs)
-    have hqU : ∀ᶠ n in atTop, dist (q n:ℝ) t₀ < δ :=
-      hqt.eventually (isOpen_lt (continuous_id.dist continuous_const) continuous_const |>.mem_nhds ht)
-    apply radon_measure_le_of_nonneg_tests
-    intro f hfn
-    have hplim : Tendsto (fun n => ∫ z, f z ∂μ (p n)) atTop (𝓝 (∫ z, f z ∂M s)) := by
-      simpa only [Function.comp_def,hrat] using (hcont f).continuousAt.tendsto.comp hp
-    have hqlim : Tendsto (fun n => ∫ z, f z ∂(μ (q n)+ν.restrict V)) atTop
-        (𝓝 (∫ z, f z ∂(M t+ν.restrict V))) := by
-      have hi := ((hcont f).continuousAt.tendsto.comp hqt).add
-        (tendsto_const_nhds (x := ∫ z, f z ∂ν.restrict V))
-      simp only [Function.comp_def,hrat] at hi
-      have hqadd (n : ℕ) : (∫ z, f z ∂(μ (q n)+ν.restrict V)) =
-          (∫ z, f z ∂μ (q n))+(∫ z, f z ∂ν.restrict V) := by
-        let : (μ (q n)).Regular := H.regular (q n)
-        exact integral_add_measure f.integrable f.integrable
-      simpa only [hqadd,integral_add_measure f.integrable f.integrable] using hi
-    apply le_of_tendsto_of_tendsto hplim hqlim
-    filter_upwards [hpU,hqU] with n hpn hqn
-    let : (μ (q n)).Regular := H.regular (q n)
-    let : (μ (q n)+ν.restrict V).Regular := halfPlane_regular_add _ _
-    exact integral_mono_measure (hq (p n) (q n) hpn hqn) (ae_of_all _ hfn) f.integrable
-  refine ⟨δ,hδ,fun s t hs ht A hA hAK => ?_⟩
-  have hst := hreal s t hs ht A
-  have hts := hreal t s ht hs A
-  have hsn : M s A ≠ ⊤ := ((hdom s A).trans ((measure_mono hAK))).trans_lt hK.measure_lt_top |>.ne
-  have htn : M t A ≠ ⊤ := ((hdom t A).trans ((measure_mono hAK))).trans_lt hK.measure_lt_top |>.ne
-  have hUn : ρ U ≠ ⊤ := measure_ne_top ρ U
-  rw [Measure.add_apply,Measure.restrict_apply hA,inter_comm] at hst hts
-  have hUA : ν (V ∩ A) ≤ ρ U := by
-    change ν (V ∩ A) ≤ ambientCompactRestriction ν K U
-    rw [ambientCompactRestriction,Measure.map_apply measurable_subtype_coe hU.measurableSet]
-    change ν (V ∩ A) ≤ ν.restrict K V
-    rw [Measure.restrict_apply hV.measurableSet]
-    exact measure_mono (fun z hz => ⟨hz.1,hAK hz.2⟩)
-  have hcan : ν (V ∩ A) ≠ ⊤ := (hUA.trans_lt hUn.lt_top).ne
-  have hst' := ENNReal.toReal_mono (ENNReal.add_ne_top.mpr ⟨htn,hcan⟩) hst
-  have hts' := ENNReal.toReal_mono (ENNReal.add_ne_top.mpr ⟨hsn,hcan⟩) hts
-  rw [ENNReal.toReal_add htn hcan] at hst'
-  rw [ENNReal.toReal_add hsn hcan] at hts'
-  have hless : (ν (V ∩ A)).toReal < ε := by
-    have hUl : (ρ U).toReal < ε := by
-      simpa only [ENNReal.toReal_ofReal hε.le] using
-        (ENNReal.toReal_lt_toReal hUn ENNReal.ofReal_ne_top).mpr hρU
-    exact (ENNReal.toReal_mono hUn hUA).trans_lt hUl
-  exact abs_lt.mpr ⟨by linarith,by linarith⟩
-
-theorem HalfPlaneTraceIncrements.exists_locally_tv_continuous_extension
-    {μ : ℚ → Measure upperHalfPlane} {ν : Measure upperHalfPlane} [ν.Regular]
-    [NullSingletonClass ν] {γ : ℝ → ℂ}
-    (H : HalfPlaneTraceIncrements μ ν γ) (hγ : Continuous γ) :
-    ∃ M : ℝ → Measure upperHalfPlane, (∀ t, (M t).Regular) ∧ (∀ t, M t ≤ ν) ∧
-      (∀ q : ℚ, M q = μ q) ∧ Monotone M ∧
-      (∀ f : C_c(upperHalfPlane,ℝ), Continuous (fun t => ∫ z, f z ∂M t)) ∧
-      ∀ K : Set upperHalfPlane, IsCompact K →
-        ∀ t₀ : ℝ, ∀ ε : ℝ, 0 < ε → ∃ δ : ℝ, 0 < δ ∧
-          ∀ s t : ℝ, dist s t₀ < δ → dist t t₀ < δ →
-            ∀ A : Set upperHalfPlane, MeasurableSet A → A ⊆ K →
-              |(M s A).toReal-(M t A).toReal| < ε := by
-  obtain ⟨M,hMr,hdom,hrat,hcont,hmono⟩ := H.exists_continuous_extension hγ
-  exact ⟨M,hMr,hdom,hrat,hmono,hcont,
-    fun K hK => H.local_variation_continuity hγ M hMr hdom hrat hcont K hK⟩
-
-end SLEExactGauge
-
-end
-
-end OAI
+import OAI.Probability.SLE.Mass.RationalTraceMassLocal
+
+namespace OAI
+
+/-! Local total-variation continuity of the half-plane reconstruction.
+Only the mass of a fixed compact is used; the terminal mass may be infinite. -/
+
+noncomputable section
+open Set Filter MeasureTheory Classical
+open scoped Topology ENNReal CompactlySupported
+
+namespace SLEExactGauge
+
+local instance : LocallyCompactSpace upperHalfPlane := isOpen_upperHalfPlane.locallyCompactSpace
+
+private lemma halfPlane_regular_add (μ ν : Measure upperHalfPlane) [μ.Regular] [ν.Regular] :
+    (μ + ν).Regular := by
+  let : IsFiniteMeasureOnCompacts (μ + ν) := ⟨fun K hK => by
+    rw [Measure.add_apply]
+    exact ENNReal.add_lt_top.mpr ⟨hK.measure_lt_top,hK.measure_lt_top⟩⟩
+  infer_instance
+
+theorem HalfPlaneTraceIncrements.local_variation_continuity
+    {μ : ℚ → Measure upperHalfPlane} {ν : Measure upperHalfPlane} [ν.Regular]
+    [NullSingletonClass ν] {γ : ℝ → ℂ}
+    (H : HalfPlaneTraceIncrements μ ν γ) (hγ : Continuous γ)
+    (M : ℝ → Measure upperHalfPlane) (hMr : ∀ t, (M t).Regular)
+    (hdom : ∀ t, M t ≤ ν) (hrat : ∀ q : ℚ, M q = μ q)
+    (hcont : ∀ f : C_c(upperHalfPlane,ℝ), Continuous (fun t => ∫ z, f z ∂M t))
+    (K : Set upperHalfPlane) (hK : IsCompact K) :
+    ∀ t₀ : ℝ, ∀ ε : ℝ, 0 < ε → ∃ δ : ℝ, 0 < δ ∧
+      ∀ s t : ℝ, dist s t₀ < δ → dist t t₀ < δ →
+        ∀ A : Set upperHalfPlane, MeasurableSet A → A ⊆ K →
+          |(M s A).toReal-(M t A).toReal| < ε := by
+  intro t₀ ε hε
+  let ρ := ambientCompactRestriction ν K
+  let : IsFiniteMeasure ρ := ambientCompactRestriction_finite ν K hK
+  let : NullSingletonClass ρ := ambientCompactRestriction_nullSingletons ν K
+  obtain ⟨U,hUsub,hU,hρU⟩ := ({γ t₀} : Set ℂ).exists_isOpen_lt_of_lt (μ := ρ)
+    (ENNReal.ofReal ε) (by simpa using ENNReal.ofReal_pos.mpr hε)
+  let V : Set upperHalfPlane := (Subtype.val : upperHalfPlane → ℂ) ⁻¹' U
+  have hV : IsOpen V := hU.preimage continuous_subtype_val
+  have htU : γ t₀ ∈ U := hUsub (mem_singleton _)
+  obtain ⟨δ,hδ,hδsub⟩ := Metric.mem_nhds_iff.mp
+    (hγ.continuousAt.preimage_mem_nhds (hU.mem_nhds htU))
+  have hI (a b : ℝ) (ha : dist a t₀ < δ) (hb : dist b t₀ < δ) : γ '' Icc a b ⊆ U := by
+    rintro _ ⟨x,hx,rfl⟩
+    apply hδsub
+    rw [Metric.mem_ball,Real.dist_eq]
+    rw [Real.dist_eq,abs_lt] at ha hb
+    exact abs_lt.mpr ⟨lt_of_lt_of_le ha.1 (sub_le_sub_right hx.1 t₀),
+      lt_of_le_of_lt (sub_le_sub_right hx.2 t₀) hb.2⟩
+  have hq (p q : ℚ) (hp : dist (p:ℝ) t₀ < δ) (hq : dist (q:ℝ) t₀ < δ) :
+      μ p ≤ μ q+ν.restrict V := by
+    rcases le_total p q with hpq | hqp
+    · exact (H.monotone hpq).trans (Measure.le_add_right le_rfl)
+    · obtain ⟨η,hη,hην⟩ := H.increment q p hqp
+      rw [hη]
+      apply add_le_add le_rfl
+      exact hην.trans (Measure.restrict_mono
+        (show {z : upperHalfPlane | (z : ℂ) ∈ γ '' Icc (q:ℝ) p} ⊆ V
+          from fun z hz => hI q p hq hp hz) le_rfl)
+  have hreal (s t : ℝ) (hs : dist s t₀ < δ) (ht : dist t t₀ < δ) :
+      M s ≤ M t+ν.restrict V := by
+    let : (M s).Regular := hMr s
+    let : (M t).Regular := hMr t
+    let : (ν.restrict V).Regular := inferInstance
+    let : (M t+ν.restrict V).Regular := halfPlane_regular_add _ _
+    obtain ⟨p,hp⟩ := exists_rational_sequence_tendsto s
+    obtain ⟨q,hqt⟩ := exists_rational_sequence_tendsto t
+    have hpU : ∀ᶠ n in atTop, dist (p n:ℝ) t₀ < δ :=
+      hp.eventually (isOpen_lt (continuous_id.dist continuous_const) continuous_const |>.mem_nhds hs)
+    have hqU : ∀ᶠ n in atTop, dist (q n:ℝ) t₀ < δ :=
+      hqt.eventually (isOpen_lt (continuous_id.dist continuous_const) continuous_const |>.mem_nhds ht)
+    apply radon_measure_le_of_nonneg_tests
+    intro f hfn
+    have hplim : Tendsto (fun n => ∫ z, f z ∂μ (p n)) atTop (𝓝 (∫ z, f z ∂M s)) := by
+      simpa only [Function.comp_def,hrat] using (hcont f).continuousAt.tendsto.comp hp
+    have hqlim : Tendsto (fun n => ∫ z, f z ∂(μ (q n)+ν.restrict V)) atTop
+        (𝓝 (∫ z, f z ∂(M t+ν.restrict V))) := by
+      have hi := ((hcont f).continuousAt.tendsto.comp hqt).add
+        (tendsto_const_nhds (x := ∫ z, f z ∂ν.restrict V))
+      simp only [Function.comp_def,hrat] at hi
+      have hqadd (n : ℕ) : (∫ z, f z ∂(μ (q n)+ν.restrict V)) =
+          (∫ z, f z ∂μ (q n))+(∫ z, f z ∂ν.restrict V) := by
+        let : (μ (q n)).Regular := H.regular (q n)
+        exact integral_add_measure f.integrable f.integrable
+      simpa only [hqadd,integral_add_measure f.integrable f.integrable] using hi
+    apply le_of_tendsto_of_tendsto hplim hqlim
+    filter_upwards [hpU,hqU] with n hpn hqn
+    let : (μ (q n)).Regular := H.regular (q n)
+    let : (μ (q n)+ν.restrict V).Regular := halfPlane_regular_add _ _
+    exact integral_mono_measure (hq (p n) (q n) hpn hqn) (ae_of_all _ hfn) f.integrable
+  refine ⟨δ,hδ,fun s t hs ht A hA hAK => ?_⟩
+  have hst := hreal s t hs ht A
+  have hts := hreal t s ht hs A
+  have hsn : M s A ≠ ⊤ := ((hdom s A).trans ((measure_mono hAK))).trans_lt hK.measure_lt_top |>.ne
+  have htn : M t A ≠ ⊤ := ((hdom t A).trans ((measure_mono hAK))).trans_lt hK.measure_lt_top |>.ne
+  have hUn : ρ U ≠ ⊤ := measure_ne_top ρ U
+  rw [Measure.add_apply,Measure.restrict_apply hA,inter_comm] at hst hts
+  have hUA : ν (V ∩ A) ≤ ρ U := by
+    change ν (V ∩ A) ≤ ambientCompactRestriction ν K U
+    rw [ambientCompactRestriction,Measure.map_apply measurable_subtype_coe hU.measurableSet]
+    change ν (V ∩ A) ≤ ν.restrict K V
+    rw [Measure.restrict_apply hV.measurableSet]
+    exact measure_mono (fun z hz => ⟨hz.1,hAK hz.2⟩)
+  have hcan : ν (V ∩ A) ≠ ⊤ := (hUA.trans_lt hUn.lt_top).ne
+  have hst' := ENNReal.toReal_mono (ENNReal.add_ne_top.mpr ⟨htn,hcan⟩) hst
+  have hts' := ENNReal.toReal_mono (ENNReal.add_ne_top.mpr ⟨hsn,hcan⟩) hts
+  rw [ENNReal.toReal_add htn hcan] at hst'
+  rw [ENNReal.toReal_add hsn hcan] at hts'
+  have hless : (ν (V ∩ A)).toReal < ε := by
+    have hUl : (ρ U).toReal < ε := by
+      simpa only [ENNReal.toReal_ofReal hε.le] using
+        (ENNReal.toReal_lt_toReal hUn ENNReal.ofReal_ne_top).mpr hρU
+    exact (ENNReal.toReal_mono hUn hUA).trans_lt hUl
+  exact abs_lt.mpr ⟨by linarith,by linarith⟩
+
+theorem HalfPlaneTraceIncrements.exists_locally_tv_continuous_extension
+    {μ : ℚ → Measure upperHalfPlane} {ν : Measure upperHalfPlane} [ν.Regular]
+    [NullSingletonClass ν] {γ : ℝ → ℂ}
+    (H : HalfPlaneTraceIncrements μ ν γ) (hγ : Continuous γ) :
+    ∃ M : ℝ → Measure upperHalfPlane, (∀ t, (M t).Regular) ∧ (∀ t, M t ≤ ν) ∧
+      (∀ q : ℚ, M q = μ q) ∧ Monotone M ∧
+      (∀ f : C_c(upperHalfPlane,ℝ), Continuous (fun t => ∫ z, f z ∂M t)) ∧
+      ∀ K : Set upperHalfPlane, IsCompact K →
+        ∀ t₀ : ℝ, ∀ ε : ℝ, 0 < ε → ∃ δ : ℝ, 0 < δ ∧
+          ∀ s t : ℝ, dist s t₀ < δ → dist t t₀ < δ →
+            ∀ A : Set upperHalfPlane, MeasurableSet A → A ⊆ K →
+              |(M s A).toReal-(M t A).toReal| < ε := by
+  obtain ⟨M,hMr,hdom,hrat,hcont,hmono⟩ := H.exists_continuous_extension hγ
+  exact ⟨M,hMr,hdom,hrat,hmono,hcont,
+    fun K hK => H.local_variation_continuity hγ M hMr hdom hrat hcont K hK⟩
+
+end SLEExactGauge
+
+end
+
+end OAI

lean/OAI/Probability/SLE/Mass/RationalTraceMassProgressiveVersion.lean

@@ -1,111 +1,111 @@
-import OAI.Probability.SLE.Mass.RationalTraceMassAdaptedVersion
-import OAI.Probability.SLE.Mass.CanonicalRadonLimit
-import Mathlib.MeasureTheory.Function.Floor
-import Mathlib.Analysis.SpecificLimits.Basic
-
-namespace OAI
-
-/-! A single reconstruction from rational left samples is progressive in
-the uncompleted filtration and agrees at every time on the common good set. -/
-
-noncomputable section
-open Set Filter MeasureTheory Classical
-open scoped Topology NNReal ENNReal CompactlySupported
-
-namespace SLEExactGauge
-
-local instance : LocallyCompactSpace upperHalfPlane := isOpen_upperHalfPlane.locallyCompactSpace
-
-def leftRationalSample (n : ℕ) (t : ℝ≥0) : ℚ :=
-  (⌊(t:ℝ)*((n:ℝ)+1)⌋₊ : ℚ)/((n:ℚ)+1)
-
-lemma leftRationalSample_nonneg (n : ℕ) (t : ℝ≥0) : 0 ≤ leftRationalSample n t := by
-  unfold leftRationalSample
-  positivity
-
-lemma leftRationalSample_le (n : ℕ) (t : ℝ≥0) : (leftRationalSample n t : ℝ) ≤ t := by
-  unfold leftRationalSample
-  push_cast
-  apply (div_le_iff₀ (by positivity : 0 < (n:ℝ)+1)).mpr
-  exact Nat.floor_le (mul_nonneg t.coe_nonneg (by positivity))
-
-lemma leftRationalSample_tendsto (t : ℝ≥0) :
-    Tendsto (fun n => (leftRationalSample n t : ℝ)) atTop (𝓝 (t:ℝ)) := by
-  have h := (tendsto_nat_floor_mul_div_atTop t.coe_nonneg).comp
-    (tendsto_atTop_add_const_right atTop (1:ℝ) (tendsto_natCast_atTop_atTop (R := ℝ)))
-  simpa only [leftRationalSample,Rat.cast_div,Rat.cast_natCast,Rat.cast_add,Rat.cast_one,
-    Function.comp_def] using h
-
-lemma leftRationalSample_measurable (n : ℕ) : Measurable (leftRationalSample n) := by
-  exact (measurable_of_countable (fun k : ℕ => (k:ℚ)/((n:ℚ)+1))).comp
-    ((NNReal.continuous_coe.measurable.mul_const ((n:ℝ)+1)).nat_floor)
-
-def rationalRadonExtension {Ω : Type*} (μ : ℚ → Ω → Measure upperHalfPlane)
-    (t : ℝ≥0) (ω : Ω) : Measure upperHalfPlane :=
-  canonicalRadonLimit (fun n => μ (leftRationalSample n t) ω)
-
-theorem rationalRadonExtension_regular {Ω : Type*}
-    (μ : ℚ → Ω → Measure upperHalfPlane) (t : ℝ≥0) (ω : Ω) :
-    (rationalRadonExtension μ t ω).Regular ∧
-      IsFiniteMeasureOnCompacts (rationalRadonExtension μ t ω) := by
-  have h : (rationalRadonExtension μ t ω).Regular :=
-    canonicalRadonLimit_regular (fun n => μ (leftRationalSample n t) ω)
-  let := h
-  exact ⟨h,inferInstance⟩
-
-theorem rationalRadonExtension_progressive
-    {Ω : Type*} [mΩ : MeasurableSpace Ω] (ℱ : Filtration ℝ≥0 mΩ)
-    (μ : ℚ → Ω → Measure upperHalfPlane)
-    (hμr : ∀ q ω, (μ q ω).Regular)
-    (hμm : ∀ q : ℚ, 0 ≤ q → Measurable[ℱ (q : ℝ).toNNReal] (μ q)) :
-    IsProgressive ℱ (rationalRadonExtension μ) := by
-  classical
-  intro T
-  let : MeasurableSpace Ω := ℱ T
-  have hm (n : ℕ) : Measurable (fun p : Iic T × Ω => μ (leftRationalSample n p.1) p.2) := by
-    let ν (q : ℚ) (ω : Ω) := if 0 ≤ q ∧ (q:ℝ) ≤ T then μ q ω else 0
-    have hνm (q : ℚ) : Measurable (ν q) := by
-      by_cases hq : 0 ≤ q ∧ (q:ℝ) ≤ T
-      · have hqt : (q:ℝ).toNNReal ≤ T := by
-          simpa only [Real.toNNReal_coe] using Real.toNNReal_le_toNNReal hq.2
-        simpa only [ν,ite_eq_left hq] using (hμm q hq.1).mono (ℱ.mono hqt) le_rfl
-      · simpa only [ν,ite_eq_right hq] using (measurable_const : Measurable (fun _ : Ω => (0 : Measure upperHalfPlane)))
-    have hv : Measurable (fun p : ℚ × Ω => ν p.1 p.2) :=
-      measurable_from_prod_countable_right hνm
-    have hq : Measurable (fun p : Iic T × Ω => (leftRationalSample n p.1,p.2)) :=
-      ((leftRationalSample_measurable n).comp
-        (measurable_subtype_coe.comp measurable_fst)).prodMk measurable_snd
-    have h := hv.comp hq
-    convert h using 1
-    funext p
-    dsimp only [Function.comp_def,ν]
-    rw [ite_eq_left ⟨leftRationalSample_nonneg n p.1,
-      (leftRationalSample_le n p.1).trans (NNReal.coe_le_coe.mpr p.1.property)⟩]
-  apply canonicalRadonLimit_measurable (fun (n : ℕ) (p : Iic T × Ω) => μ (leftRationalSample n p.1) p.2)
-  · intro n p
-    let := hμr (leftRationalSample n p.1) p.2
-    infer_instance
-  · intro n f
-    exact measurable_halfPlane_compact_test_integral _ (hm n)
-      (fun p => hμr (leftRationalSample n p.1) p.2) f
-
-theorem rationalRadonExtension_common_version
-    {Ω : Type*} [MeasurableSpace Ω] (P : Measure Ω)
-    (μ : ℚ → Ω → Measure upperHalfPlane) (M : ℝ → Ω → Measure upperHalfPlane)
-    (hMr : ∀ t ω, (M t ω).Regular)
-    (hcont : ∀ᵐ ω ∂P, ∀ f : C_c(upperHalfPlane,ℝ), Continuous (fun t => ∫ z, f z ∂M t ω))
-    (hrat : ∀ᵐ ω ∂P, ∀ q : ℚ, M q ω = μ q ω) :
-    ∀ᵐ ω ∂P, ∀ t : ℝ≥0, rationalRadonExtension μ t ω = M t ω := by
-  filter_upwards [hcont,hrat] with ω hc hr
-  intro t
-  apply canonicalRadonLimit_identified _ (M t ω)
-  refine ⟨hMr t ω,?_⟩
-  intro f
-  simpa only [Function.comp_def,hr] using
-    (hc f).continuousAt.tendsto.comp (leftRationalSample_tendsto t)
-
-end SLEExactGauge
-
-end
-
-end OAI
+import OAI.Probability.SLE.Mass.RationalTraceMassAdaptedVersion
+import OAI.Probability.SLE.Mass.CanonicalRadonLimit
+import Mathlib.MeasureTheory.Function.Floor
+import Mathlib.Analysis.SpecificLimits.Basic
+
+namespace OAI
+
+/-! A single reconstruction from rational left samples is progressive in
+the uncompleted filtration and agrees at every time on the common good set. -/
+
+noncomputable section
+open Set Filter MeasureTheory Classical
+open scoped Topology NNReal ENNReal CompactlySupported
+
+namespace SLEExactGauge
+
+local instance : LocallyCompactSpace upperHalfPlane := isOpen_upperHalfPlane.locallyCompactSpace
+
+def leftRationalSample (n : ℕ) (t : ℝ≥0) : ℚ :=
+  (⌊(t:ℝ)*((n:ℝ)+1)⌋₊ : ℚ)/((n:ℚ)+1)
+
+lemma leftRationalSample_nonneg (n : ℕ) (t : ℝ≥0) : 0 ≤ leftRationalSample n t := by
+  unfold leftRationalSample
+  positivity
+
+lemma leftRationalSample_le (n : ℕ) (t : ℝ≥0) : (leftRationalSample n t : ℝ) ≤ t := by
+  unfold leftRationalSample
+  push_cast
+  apply (div_le_iff₀ (by positivity : 0 < (n:ℝ)+1)).mpr
+  exact Nat.floor_le (mul_nonneg t.coe_nonneg (by positivity))
+
+lemma leftRationalSample_tendsto (t : ℝ≥0) :
+    Tendsto (fun n => (leftRationalSample n t : ℝ)) atTop (𝓝 (t:ℝ)) := by
+  have h := (tendsto_nat_floor_mul_div_atTop t.coe_nonneg).comp
+    (tendsto_atTop_add_const_right atTop (1:ℝ) (tendsto_natCast_atTop_atTop (R := ℝ)))
+  simpa only [leftRationalSample,Rat.cast_div,Rat.cast_natCast,Rat.cast_add,Rat.cast_one,
+    Function.comp_def] using h
+
+lemma leftRationalSample_measurable (n : ℕ) : Measurable (leftRationalSample n) := by
+  exact (measurable_of_countable (fun k : ℕ => (k:ℚ)/((n:ℚ)+1))).comp
+    ((NNReal.continuous_coe.measurable.mul_const ((n:ℝ)+1)).nat_floor)
+
+def rationalRadonExtension {Ω : Type*} (μ : ℚ → Ω → Measure upperHalfPlane)
+    (t : ℝ≥0) (ω : Ω) : Measure upperHalfPlane :=
+  canonicalRadonLimit (fun n => μ (leftRationalSample n t) ω)
+
+theorem rationalRadonExtension_regular {Ω : Type*}
+    (μ : ℚ → Ω → Measure upperHalfPlane) (t : ℝ≥0) (ω : Ω) :
+    (rationalRadonExtension μ t ω).Regular ∧
+      IsFiniteMeasureOnCompacts (rationalRadonExtension μ t ω) := by
+  have h : (rationalRadonExtension μ t ω).Regular :=
+    canonicalRadonLimit_regular (fun n => μ (leftRationalSample n t) ω)
+  let := h
+  exact ⟨h,inferInstance⟩
+
+theorem rationalRadonExtension_progressive
+    {Ω : Type*} [mΩ : MeasurableSpace Ω] (ℱ : Filtration ℝ≥0 mΩ)
+    (μ : ℚ → Ω → Measure upperHalfPlane)
+    (hμr : ∀ q ω, (μ q ω).Regular)
+    (hμm : ∀ q : ℚ, 0 ≤ q → Measurable[ℱ (q : ℝ).toNNReal] (μ q)) :
+    IsProgressive ℱ (rationalRadonExtension μ) := by
+  classical
+  intro T
+  let : MeasurableSpace Ω := ℱ T
+  have hm (n : ℕ) : Measurable (fun p : Iic T × Ω => μ (leftRationalSample n p.1) p.2) := by
+    let ν (q : ℚ) (ω : Ω) := if 0 ≤ q ∧ (q:ℝ) ≤ T then μ q ω else 0
+    have hνm (q : ℚ) : Measurable (ν q) := by
+      by_cases hq : 0 ≤ q ∧ (q:ℝ) ≤ T
+      · have hqt : (q:ℝ).toNNReal ≤ T := by
+          simpa only [Real.toNNReal_coe] using Real.toNNReal_le_toNNReal hq.2
+        simpa only [ν,ite_eq_left hq] using (hμm q hq.1).mono (ℱ.mono hqt) le_rfl
+      · simpa only [ν,ite_eq_right hq] using (measurable_const : Measurable (fun _ : Ω => (0 : Measure upperHalfPlane)))
+    have hv : Measurable (fun p : ℚ × Ω => ν p.1 p.2) :=
+      measurable_from_prod_countable_right hνm
+    have hq : Measurable (fun p : Iic T × Ω => (leftRationalSample n p.1,p.2)) :=
+      ((leftRationalSample_measurable n).comp
+        (measurable_subtype_coe.comp measurable_fst)).prodMk measurable_snd
+    have h := hv.comp hq
+    convert h using 1
+    funext p
+    dsimp only [Function.comp_def,ν]
+    rw [ite_eq_left ⟨leftRationalSample_nonneg n p.1,
+      (leftRationalSample_le n p.1).trans (NNReal.coe_le_coe.mpr p.1.property)⟩]
+  apply canonicalRadonLimit_measurable (fun (n : ℕ) (p : Iic T × Ω) => μ (leftRationalSample n p.1) p.2)
+  · intro n p
+    let := hμr (leftRationalSample n p.1) p.2
+    infer_instance
+  · intro n f
+    exact measurable_halfPlane_compact_test_integral _ (hm n)
+      (fun p => hμr (leftRationalSample n p.1) p.2) f
+
+theorem rationalRadonExtension_common_version
+    {Ω : Type*} [MeasurableSpace Ω] (P : Measure Ω)
+    (μ : ℚ → Ω → Measure upperHalfPlane) (M : ℝ → Ω → Measure upperHalfPlane)
+    (hMr : ∀ t ω, (M t ω).Regular)
+    (hcont : ∀ᵐ ω ∂P, ∀ f : C_c(upperHalfPlane,ℝ), Continuous (fun t => ∫ z, f z ∂M t ω))
+    (hrat : ∀ᵐ ω ∂P, ∀ q : ℚ, M q ω = μ q ω) :
+    ∀ᵐ ω ∂P, ∀ t : ℝ≥0, rationalRadonExtension μ t ω = M t ω := by
+  filter_upwards [hcont,hrat] with ω hc hr
+  intro t
+  apply canonicalRadonLimit_identified _ (M t ω)
+  refine ⟨hMr t ω,?_⟩
+  intro f
+  simpa only [Function.comp_def,hr] using
+    (hc f).continuousAt.tendsto.comp (leftRationalSample_tendsto t)
+
+end SLEExactGauge
+
+end
+
+end OAI

lean/OAI/Probability/SLE/Mass/RationalTraceMassSupport.lean

@@ -1,101 +1,101 @@
-import OAI.Probability.SLE.Mass.RationalTraceMassLocal
-import OAI.Probability.SLE.Mass.RadonTestLimitProperties
-import OAI.Probability.SLE.Mass.LocallyFiniteMeasureSubtract
-
-namespace OAI
-
-/-! The trace support of rational increments passes simultaneously to every
-real interval, using only monotonicity and continuity of the trace. -/
-
-noncomputable section
-open Set Filter MeasureTheory Classical
-open scoped Topology ENNReal CompactlySupported
-
-namespace SLEExactGauge
-
-local instance : LocallyCompactSpace upperHalfPlane := isOpen_upperHalfPlane.locallyCompactSpace
-
-lemma exists_rational_trace_enclosure_avoiding
-    (γ : ℝ → ℂ) (hγ : Continuous γ) {s t : ℝ} (hst : s ≤ t)
-    (K : Set ℂ) (hK : IsClosed K) (hdis : Disjoint K (γ '' Icc s t)) :
-    ∃ p q : ℚ, (p:ℝ) < s ∧ t < (q:ℝ) ∧ Disjoint K (γ '' Icc (p:ℝ) q) := by
-  let U := γ ⁻¹' Kᶜ
-  have hU : IsOpen U := hK.isOpen_compl.preimage hγ
-  have hs : s ∈ U := by
-    intro hs
-    exact Set.disjoint_left.mp hdis hs ⟨s,⟨le_rfl,hst⟩,rfl⟩
-  have ht : t ∈ U := by
-    intro ht
-    exact Set.disjoint_left.mp hdis ht ⟨t,⟨hst,le_rfl⟩,rfl⟩
-  obtain ⟨ε,hε,hballε⟩ := Metric.isOpen_iff.mp hU s hs
-  obtain ⟨δ,hδ,hballδ⟩ := Metric.isOpen_iff.mp hU t ht
-  obtain ⟨p,hp,hps⟩ := exists_rat_btwn (show s-ε < s by linarith)
-  obtain ⟨q,htq,hq⟩ := exists_rat_btwn (show t < t+δ by linarith)
-  refine ⟨p,q,hps,htq,Set.disjoint_left.mpr ?_⟩
-  rintro z hz ⟨r,hr,rfl⟩
-  by_cases hrs : r < s
-  · have hb : r ∈ Metric.ball s ε := by
-      rw [Metric.mem_ball,Real.dist_eq,abs_of_neg (sub_neg.mpr hrs)]
-      linarith [hr.1]
-    exact hballε hb hz
-  by_cases htr : t < r
-  · have hb : r ∈ Metric.ball t δ := by
-      rw [Metric.mem_ball,Real.dist_eq,abs_of_pos (sub_pos.mpr htr)]
-      linarith [hr.2]
-    exact hballδ hb hz
-  exact Set.disjoint_left.mp hdis hz ⟨r,⟨le_of_not_gt hrs,le_of_not_gt htr⟩,rfl⟩
-
-theorem HalfPlaneTraceIncrements.extension_increment_carried
-    {μ : ℚ → Measure upperHalfPlane} {ν : Measure upperHalfPlane} [ν.Regular]
-    {γ : ℝ → ℂ} (H : HalfPlaneTraceIncrements μ ν γ) (hγ : Continuous γ)
-    (M : ℝ → Measure upperHalfPlane) (hMr : ∀ t, (M t).Regular)
-    (hrat : ∀ q : ℚ, M q = μ q) (hmono : Monotone M)
-    {s t : ℝ} (hst : s ≤ t) :
-    (M t-M s) {z : upperHalfPlane | (z:ℂ) ∉ γ '' Icc s t} = 0 := by
-  let η := M t-M s
-  let : (M t).Regular := hMr t
-  let : (M s).Regular := hMr s
-  let : IsFiniteMeasureOnCompacts η :=
-    ⟨fun K hK => lt_of_le_of_lt (Measure.sub_le K) hK.measure_lt_top⟩
-  let : η.Regular := inferInstance
-  let S : Set upperHalfPlane := {z | (z:ℂ) ∈ γ '' Icc s t}
-  apply radon_limit_carried_by_closed (fun _ => η) η (fun _ => tendsto_const_nhds) S
-    (((isCompact_Icc.image hγ).isClosed).preimage continuous_subtype_val)
-  intro f hf
-  let K := (Subtype.val : upperHalfPlane → ℂ) '' tsupport f
-  have hK : IsCompact K := f.hasCompactSupport.image continuous_subtype_val
-  have hdis : Disjoint K (γ '' Icc s t) := by
-    apply Set.disjoint_left.mpr
-    rintro _ ⟨z,hz,rfl⟩ hs
-    exact hf hz hs
-  obtain ⟨p,q,hps,htq,havoid⟩ := exists_rational_trace_enclosure_avoiding γ hγ hst K hK.isClosed hdis
-  have hpq : p ≤ q := Rat.cast_le.mp (hps.le.trans (hst.trans htq.le))
-  obtain ⟨ξ,hξ,hξle⟩ := H.increment p q hpq
-  have hηξ : η ≤ ξ := by
-    apply Measure.sub_le_of_le_add
-    calc
-      M t ≤ M q := hmono htq.le
-      _ = μ q := hrat q
-      _ = μ p+ξ := hξ
-      _ = ξ+M p := by rw [hrat p,add_comm]
-      _ ≤ ξ+M s := add_le_add le_rfl (hmono hps.le)
-  have hzero : η (tsupport f) = 0 := by
-    apply le_zero_iff.mp
-    apply ((hηξ _).trans (hξle _)).trans_eq
-    rw [Measure.restrict_apply f.hasCompactSupport.measurableSet]
-    have hempty : tsupport f ∩ {z : upperHalfPlane | (z:ℂ) ∈ γ '' Icc (p:ℝ) q} = ∅ := by
-      apply Set.eq_empty_iff_forall_notMem.mpr
-      intro z hz
-      exact Set.disjoint_left.mp havoid ⟨z,hz.1,rfl⟩ hz.2
-    rw [hempty,measure_empty]
-  apply Eventually.of_forall
-  intro _
-  apply integral_eq_zero_of_ae
-  filter_upwards [measure_eq_zero_iff_ae_notMem.mp hzero] with z hz
-  exact image_eq_zero_of_notMem_tsupport hz
-
-end SLEExactGauge
-
-end
-
-end OAI
+import OAI.Probability.SLE.Mass.RationalTraceMassLocal
+import OAI.Probability.SLE.Mass.RadonTestLimitProperties
+import OAI.Probability.SLE.Mass.LocallyFiniteMeasureSubtract
+
+namespace OAI
+
+/-! The trace support of rational increments passes simultaneously to every
+real interval, using only monotonicity and continuity of the trace. -/
+
+noncomputable section
+open Set Filter MeasureTheory Classical
+open scoped Topology ENNReal CompactlySupported
+
+namespace SLEExactGauge
+
+local instance : LocallyCompactSpace upperHalfPlane := isOpen_upperHalfPlane.locallyCompactSpace
+
+lemma exists_rational_trace_enclosure_avoiding
+    (γ : ℝ → ℂ) (hγ : Continuous γ) {s t : ℝ} (hst : s ≤ t)
+    (K : Set ℂ) (hK : IsClosed K) (hdis : Disjoint K (γ '' Icc s t)) :
+    ∃ p q : ℚ, (p:ℝ) < s ∧ t < (q:ℝ) ∧ Disjoint K (γ '' Icc (p:ℝ) q) := by
+  let U := γ ⁻¹' Kᶜ
+  have hU : IsOpen U := hK.isOpen_compl.preimage hγ
+  have hs : s ∈ U := by
+    intro hs
+    exact Set.disjoint_left.mp hdis hs ⟨s,⟨le_rfl,hst⟩,rfl⟩
+  have ht : t ∈ U := by
+    intro ht
+    exact Set.disjoint_left.mp hdis ht ⟨t,⟨hst,le_rfl⟩,rfl⟩
+  obtain ⟨ε,hε,hballε⟩ := Metric.isOpen_iff.mp hU s hs
+  obtain ⟨δ,hδ,hballδ⟩ := Metric.isOpen_iff.mp hU t ht
+  obtain ⟨p,hp,hps⟩ := exists_rat_btwn (show s-ε < s by linarith)
+  obtain ⟨q,htq,hq⟩ := exists_rat_btwn (show t < t+δ by linarith)
+  refine ⟨p,q,hps,htq,Set.disjoint_left.mpr ?_⟩
+  rintro z hz ⟨r,hr,rfl⟩
+  by_cases hrs : r < s
+  · have hb : r ∈ Metric.ball s ε := by
+      rw [Metric.mem_ball,Real.dist_eq,abs_of_neg (sub_neg.mpr hrs)]
+      linarith [hr.1]
+    exact hballε hb hz
+  by_cases htr : t < r
+  · have hb : r ∈ Metric.ball t δ := by
+      rw [Metric.mem_ball,Real.dist_eq,abs_of_pos (sub_pos.mpr htr)]
+      linarith [hr.2]
+    exact hballδ hb hz
+  exact Set.disjoint_left.mp hdis hz ⟨r,⟨le_of_not_gt hrs,le_of_not_gt htr⟩,rfl⟩
+
+theorem HalfPlaneTraceIncrements.extension_increment_carried
+    {μ : ℚ → Measure upperHalfPlane} {ν : Measure upperHalfPlane} [ν.Regular]
+    {γ : ℝ → ℂ} (H : HalfPlaneTraceIncrements μ ν γ) (hγ : Continuous γ)
+    (M : ℝ → Measure upperHalfPlane) (hMr : ∀ t, (M t).Regular)
+    (hrat : ∀ q : ℚ, M q = μ q) (hmono : Monotone M)
+    {s t : ℝ} (hst : s ≤ t) :
+    (M t-M s) {z : upperHalfPlane | (z:ℂ) ∉ γ '' Icc s t} = 0 := by
+  let η := M t-M s
+  let : (M t).Regular := hMr t
+  let : (M s).Regular := hMr s
+  let : IsFiniteMeasureOnCompacts η :=
+    ⟨fun K hK => lt_of_le_of_lt (Measure.sub_le K) hK.measure_lt_top⟩
+  let : η.Regular := inferInstance
+  let S : Set upperHalfPlane := {z | (z:ℂ) ∈ γ '' Icc s t}
+  apply radon_limit_carried_by_closed (fun _ => η) η (fun _ => tendsto_const_nhds) S
+    (((isCompact_Icc.image hγ).isClosed).preimage continuous_subtype_val)
+  intro f hf
+  let K := (Subtype.val : upperHalfPlane → ℂ) '' tsupport f
+  have hK : IsCompact K := f.hasCompactSupport.image continuous_subtype_val
+  have hdis : Disjoint K (γ '' Icc s t) := by
+    apply Set.disjoint_left.mpr
+    rintro _ ⟨z,hz,rfl⟩ hs
+    exact hf hz hs
+  obtain ⟨p,q,hps,htq,havoid⟩ := exists_rational_trace_enclosure_avoiding γ hγ hst K hK.isClosed hdis
+  have hpq : p ≤ q := Rat.cast_le.mp (hps.le.trans (hst.trans htq.le))
+  obtain ⟨ξ,hξ,hξle⟩ := H.increment p q hpq
+  have hηξ : η ≤ ξ := by
+    apply Measure.sub_le_of_le_add
+    calc
+      M t ≤ M q := hmono htq.le
+      _ = μ q := hrat q
+      _ = μ p+ξ := hξ
+      _ = ξ+M p := by rw [hrat p,add_comm]
+      _ ≤ ξ+M s := add_le_add le_rfl (hmono hps.le)
+  have hzero : η (tsupport f) = 0 := by
+    apply le_zero_iff.mp
+    apply ((hηξ _).trans (hξle _)).trans_eq
+    rw [Measure.restrict_apply f.hasCompactSupport.measurableSet]
+    have hempty : tsupport f ∩ {z : upperHalfPlane | (z:ℂ) ∈ γ '' Icc (p:ℝ) q} = ∅ := by
+      apply Set.eq_empty_iff_forall_notMem.mpr
+      intro z hz
+      exact Set.disjoint_left.mp havoid ⟨z,hz.1,rfl⟩ hz.2
+    rw [hempty,measure_empty]
+  apply Eventually.of_forall
+  intro _
+  apply integral_eq_zero_of_ae
+  filter_upwards [measure_eq_zero_iff_ae_notMem.mp hzero] with z hz
+  exact image_eq_zero_of_notMem_tsupport hz
+
+end SLEExactGauge
+
+end
+
+end OAI

lean/OAI/Probability/SLE/Mass/RationalTraceMassVariation.lean

@@ -1,118 +1,118 @@
-import OAI.Probability.SLE.Mass.RationalTraceMass
-
-namespace OAI
-
-/-! Uniform local total-variation control for the all-time extension. -/
-
-noncomputable section
-open Set Filter MeasureTheory
-open scoped Topology ENNReal CompactlySupported
-
-namespace SLEExactGauge
-
-variable {X : Type*} [TopologicalSpace X] [T2Space X] [LocallyCompactSpace X]
-  [SecondCountableTopology X] [MeasurableSpace X] [BorelSpace X]
-
-/-- Local total variation is expressed uniformly on measurable sets. The
-finite-terminal form applies to each compact restriction in the source. -/
-theorem RationalTraceIncrements.local_variation_continuity
-    {μ : ℚ → Measure X} {ν : Measure X} [ν.Regular] [IsFiniteMeasure ν]
-    [NullSingletonClass ν] {γ : ℝ → X} (H : RationalTraceIncrements μ ν γ)
-    (hγ : Continuous γ) (M : ℝ → Measure X)
-    (hMr : ∀ t, (M t).Regular) (hdom : ∀ t, M t ≤ ν)
-    (hrat : ∀ q : ℚ, M q=μ q)
-    (hcont : ∀ f : C_c(X,ℝ), Continuous (fun t => ∫ x, f x ∂M t)) :
-    ∀ t₀ : ℝ, ∀ ε : ℝ, 0 < ε → ∃ δ : ℝ, 0 < δ ∧
-      ∀ s t : ℝ, dist s t₀ < δ → dist t t₀ < δ →
-        ∀ A : Set X, MeasurableSet A → |(M s A).toReal-(M t A).toReal| < ε := by
-  intro t₀ ε hε
-  obtain ⟨U,hUsub,hU,hνU⟩ := ({γ t₀} : Set X).exists_isOpen_lt_of_lt (μ := ν)
-    (ENNReal.ofReal ε) (by simpa using ENNReal.ofReal_pos.mpr hε)
-  have htU : γ t₀ ∈ U := hUsub (mem_singleton _)
-  obtain ⟨δ,hδ,hδsub⟩ := Metric.mem_nhds_iff.mp
-    (hγ.continuousAt.preimage_mem_nhds (hU.mem_nhds htU))
-  have hI (a b : ℝ) (ha : dist a t₀ < δ) (hb : dist b t₀ < δ) : γ '' Icc a b ⊆ U := by
-    rintro _ ⟨x,hx,rfl⟩
-    apply hδsub
-    rw [Metric.mem_ball,Real.dist_eq]
-    rw [Real.dist_eq,abs_lt] at ha hb
-    exact abs_lt.mpr ⟨lt_of_lt_of_le ha.1 (sub_le_sub_right hx.1 t₀),
-      lt_of_le_of_lt (sub_le_sub_right hx.2 t₀) hb.2⟩
-  have hq (p q : ℚ) (hp : dist (p:ℝ) t₀ < δ) (hq : dist (q:ℝ) t₀ < δ) :
-      μ p ≤ μ q+ν.restrict U := by
-    rcases le_total p q with hpq | hqp
-    · exact (H.monotone hpq).trans (Measure.le_add_right le_rfl)
-    · obtain ⟨η,hη,hην⟩ := H.increment q p hqp
-      rw [hη]
-      exact add_le_add le_rfl (hην.trans (Measure.restrict_mono (hI q p hq hp) le_rfl))
-  have hreal (s t : ℝ) (hs : dist s t₀ < δ) (ht : dist t t₀ < δ) :
-      M s ≤ M t+ν.restrict U := by
-    let : (M s).Regular := hMr s
-    let : (M t).Regular := hMr t
-    let : IsFiniteMeasure (M t) := isFiniteMeasure_of_le ν (hdom t)
-    let : (ν.restrict U).Regular := Measure.Regular.restrict_of_measure_ne_top (measure_ne_top ν U)
-    obtain ⟨p,hp⟩ := exists_rational_sequence_tendsto s
-    obtain ⟨q,hqt⟩ := exists_rational_sequence_tendsto t
-    have hpU : ∀ᶠ n in atTop, dist (p n:ℝ) t₀ < δ :=
-      hp.eventually (isOpen_lt (continuous_id.dist continuous_const) continuous_const |>.mem_nhds hs)
-    have hqU : ∀ᶠ n in atTop, dist (q n:ℝ) t₀ < δ :=
-      hqt.eventually (isOpen_lt (continuous_id.dist continuous_const) continuous_const |>.mem_nhds ht)
-    apply radon_measure_le_of_nonneg_tests
-    intro f hfn
-    have hplim : Tendsto (fun n => ∫ x, f x ∂μ (p n)) atTop (𝓝 (∫ x, f x ∂M s)) := by
-      simpa only [Function.comp_def,hrat] using (hcont f).continuousAt.tendsto.comp hp
-    have hqlim : Tendsto (fun n => ∫ x, f x ∂(μ (q n)+ν.restrict U)) atTop
-        (𝓝 (∫ x, f x ∂(M t+ν.restrict U))) := by
-      have hi := ((hcont f).continuousAt.tendsto.comp hqt).add
-        (tendsto_const_nhds (x := ∫ x, f x ∂ν.restrict U))
-      simp only [Function.comp_def,hrat] at hi
-      have hqadd (n : ℕ) : (∫ x, f x ∂(μ (q n)+ν.restrict U))=
-          (∫ x, f x ∂μ (q n))+(∫ x, f x ∂ν.restrict U) := by
-        let : (μ (q n)).Regular := H.regular (q n)
-        exact integral_add_measure f.integrable f.integrable
-      simpa only [hqadd,integral_add_measure f.integrable f.integrable] using hi
-    apply le_of_tendsto_of_tendsto hplim hqlim
-    filter_upwards [hpU,hqU] with n hpn hqn
-    let : (μ (q n)).Regular := H.regular (q n)
-    let : IsFiniteMeasure (μ (q n)) := isFiniteMeasure_of_le ν (H.dominated (q n))
-    exact integral_mono_measure (hq (p n) (q n) hpn hqn) (ae_of_all _ hfn) f.integrable
-  refine ⟨δ,hδ,fun s t hs ht A hA => ?_⟩
-  have hst := hreal s t hs ht A
-  have hts := hreal t s ht hs A
-  have hsn : M s A ≠ ⊤ := ((hdom s A).trans_lt (measure_lt_top ν A)).ne
-  have htn : M t A ≠ ⊤ := ((hdom t A).trans_lt (measure_lt_top ν A)).ne
-  have hUn : ν U ≠ ⊤ := measure_ne_top ν U
-  rw [Measure.add_apply,Measure.restrict_apply hA,inter_comm] at hst hts
-  have hUA : ν (U ∩ A) ≤ ν U := measure_mono inter_subset_left
-  have hcan : ν (U ∩ A) ≠ ⊤ := (hUA.trans_lt hUn.lt_top).ne
-  have hst' := ENNReal.toReal_mono (ENNReal.add_ne_top.mpr ⟨htn,hcan⟩) hst
-  have hts' := ENNReal.toReal_mono (ENNReal.add_ne_top.mpr ⟨hsn,hcan⟩) hts
-  rw [ENNReal.toReal_add htn hcan] at hst'
-  rw [ENNReal.toReal_add hsn hcan] at hts'
-  have hless : (ν (U ∩ A)).toReal < ε := by
-    have hUl : (ν U).toReal < ε := by
-      simpa only [ENNReal.toReal_ofReal hε.le] using
-        (ENNReal.toReal_lt_toReal hUn ENNReal.ofReal_ne_top).mpr hνU
-    exact (ENNReal.toReal_mono hUn hUA).trans_lt hUl
-  exact abs_lt.mpr ⟨by linarith,by linarith⟩
-
-/-- The pathwise rational squeeze gives one increasing extension with
-local total-variation continuity. -/
-theorem RationalTraceIncrements.exists_locally_tv_continuous_extension
-    {μ : ℚ → Measure X} {ν : Measure X} [ν.Regular] [IsFiniteMeasure ν]
-    [NullSingletonClass ν] {γ : ℝ → X} (H : RationalTraceIncrements μ ν γ)
-    (hγ : Continuous γ) :
-    ∃ M : ℝ → Measure X, (∀ t, (M t).Regular) ∧ (∀ t, M t ≤ ν) ∧
-      (∀ q : ℚ, M q=μ q) ∧ Monotone M ∧
-      (∀ f : C_c(X,ℝ), Continuous (fun t => ∫ x, f x ∂M t)) ∧
-      ∀ t₀ : ℝ, ∀ ε : ℝ, 0 < ε → ∃ δ : ℝ, 0 < δ ∧
-        ∀ s t : ℝ, dist s t₀ < δ → dist t t₀ < δ →
-          ∀ A : Set X, MeasurableSet A → |(M s A).toReal-(M t A).toReal| < ε := by
-  obtain ⟨M,hMr,hdom,hrat,hcont,hmono⟩ := H.exists_continuous_extension hγ
-  exact ⟨M,hMr,hdom,hrat,hmono,hcont,H.local_variation_continuity hγ M hMr hdom hrat hcont⟩
-
-end SLEExactGauge
-
-end
-
-end OAI
+import OAI.Probability.SLE.Mass.RationalTraceMass
+
+namespace OAI
+
+/-! Uniform local total-variation control for the all-time extension. -/
+
+noncomputable section
+open Set Filter MeasureTheory
+open scoped Topology ENNReal CompactlySupported
+
+namespace SLEExactGauge
+
+variable {X : Type*} [TopologicalSpace X] [T2Space X] [LocallyCompactSpace X]
+  [SecondCountableTopology X] [MeasurableSpace X] [BorelSpace X]
+
+/-- Local total variation is expressed uniformly on measurable sets. The
+finite-terminal form applies to each compact restriction in the source. -/
+theorem RationalTraceIncrements.local_variation_continuity
+    {μ : ℚ → Measure X} {ν : Measure X} [ν.Regular] [IsFiniteMeasure ν]
+    [NullSingletonClass ν] {γ : ℝ → X} (H : RationalTraceIncrements μ ν γ)
+    (hγ : Continuous γ) (M : ℝ → Measure X)
+    (hMr : ∀ t, (M t).Regular) (hdom : ∀ t, M t ≤ ν)
+    (hrat : ∀ q : ℚ, M q=μ q)
+    (hcont : ∀ f : C_c(X,ℝ), Continuous (fun t => ∫ x, f x ∂M t)) :
+    ∀ t₀ : ℝ, ∀ ε : ℝ, 0 < ε → ∃ δ : ℝ, 0 < δ ∧
+      ∀ s t : ℝ, dist s t₀ < δ → dist t t₀ < δ →
+        ∀ A : Set X, MeasurableSet A → |(M s A).toReal-(M t A).toReal| < ε := by
+  intro t₀ ε hε
+  obtain ⟨U,hUsub,hU,hνU⟩ := ({γ t₀} : Set X).exists_isOpen_lt_of_lt (μ := ν)
+    (ENNReal.ofReal ε) (by simpa using ENNReal.ofReal_pos.mpr hε)
+  have htU : γ t₀ ∈ U := hUsub (mem_singleton _)
+  obtain ⟨δ,hδ,hδsub⟩ := Metric.mem_nhds_iff.mp
+    (hγ.continuousAt.preimage_mem_nhds (hU.mem_nhds htU))
+  have hI (a b : ℝ) (ha : dist a t₀ < δ) (hb : dist b t₀ < δ) : γ '' Icc a b ⊆ U := by
+    rintro _ ⟨x,hx,rfl⟩
+    apply hδsub
+    rw [Metric.mem_ball,Real.dist_eq]
+    rw [Real.dist_eq,abs_lt] at ha hb
+    exact abs_lt.mpr ⟨lt_of_lt_of_le ha.1 (sub_le_sub_right hx.1 t₀),
+      lt_of_le_of_lt (sub_le_sub_right hx.2 t₀) hb.2⟩
+  have hq (p q : ℚ) (hp : dist (p:ℝ) t₀ < δ) (hq : dist (q:ℝ) t₀ < δ) :
+      μ p ≤ μ q+ν.restrict U := by
+    rcases le_total p q with hpq | hqp
+    · exact (H.monotone hpq).trans (Measure.le_add_right le_rfl)
+    · obtain ⟨η,hη,hην⟩ := H.increment q p hqp
+      rw [hη]
+      exact add_le_add le_rfl (hην.trans (Measure.restrict_mono (hI q p hq hp) le_rfl))
+  have hreal (s t : ℝ) (hs : dist s t₀ < δ) (ht : dist t t₀ < δ) :
+      M s ≤ M t+ν.restrict U := by
+    let : (M s).Regular := hMr s
+    let : (M t).Regular := hMr t
+    let : IsFiniteMeasure (M t) := isFiniteMeasure_of_le ν (hdom t)
+    let : (ν.restrict U).Regular := Measure.Regular.restrict_of_measure_ne_top (measure_ne_top ν U)
+    obtain ⟨p,hp⟩ := exists_rational_sequence_tendsto s
+    obtain ⟨q,hqt⟩ := exists_rational_sequence_tendsto t
+    have hpU : ∀ᶠ n in atTop, dist (p n:ℝ) t₀ < δ :=
+      hp.eventually (isOpen_lt (continuous_id.dist continuous_const) continuous_const |>.mem_nhds hs)
+    have hqU : ∀ᶠ n in atTop, dist (q n:ℝ) t₀ < δ :=
+      hqt.eventually (isOpen_lt (continuous_id.dist continuous_const) continuous_const |>.mem_nhds ht)
+    apply radon_measure_le_of_nonneg_tests
+    intro f hfn
+    have hplim : Tendsto (fun n => ∫ x, f x ∂μ (p n)) atTop (𝓝 (∫ x, f x ∂M s)) := by
+      simpa only [Function.comp_def,hrat] using (hcont f).continuousAt.tendsto.comp hp
+    have hqlim : Tendsto (fun n => ∫ x, f x ∂(μ (q n)+ν.restrict U)) atTop
+        (𝓝 (∫ x, f x ∂(M t+ν.restrict U))) := by
+      have hi := ((hcont f).continuousAt.tendsto.comp hqt).add
+        (tendsto_const_nhds (x := ∫ x, f x ∂ν.restrict U))
+      simp only [Function.comp_def,hrat] at hi
+      have hqadd (n : ℕ) : (∫ x, f x ∂(μ (q n)+ν.restrict U))=
+          (∫ x, f x ∂μ (q n))+(∫ x, f x ∂ν.restrict U) := by
+        let : (μ (q n)).Regular := H.regular (q n)
+        exact integral_add_measure f.integrable f.integrable
+      simpa only [hqadd,integral_add_measure f.integrable f.integrable] using hi
+    apply le_of_tendsto_of_tendsto hplim hqlim
+    filter_upwards [hpU,hqU] with n hpn hqn
+    let : (μ (q n)).Regular := H.regular (q n)
+    let : IsFiniteMeasure (μ (q n)) := isFiniteMeasure_of_le ν (H.dominated (q n))
+    exact integral_mono_measure (hq (p n) (q n) hpn hqn) (ae_of_all _ hfn) f.integrable
+  refine ⟨δ,hδ,fun s t hs ht A hA => ?_⟩
+  have hst := hreal s t hs ht A
+  have hts := hreal t s ht hs A
+  have hsn : M s A ≠ ⊤ := ((hdom s A).trans_lt (measure_lt_top ν A)).ne
+  have htn : M t A ≠ ⊤ := ((hdom t A).trans_lt (measure_lt_top ν A)).ne
+  have hUn : ν U ≠ ⊤ := measure_ne_top ν U
+  rw [Measure.add_apply,Measure.restrict_apply hA,inter_comm] at hst hts
+  have hUA : ν (U ∩ A) ≤ ν U := measure_mono inter_subset_left
+  have hcan : ν (U ∩ A) ≠ ⊤ := (hUA.trans_lt hUn.lt_top).ne
+  have hst' := ENNReal.toReal_mono (ENNReal.add_ne_top.mpr ⟨htn,hcan⟩) hst
+  have hts' := ENNReal.toReal_mono (ENNReal.add_ne_top.mpr ⟨hsn,hcan⟩) hts
+  rw [ENNReal.toReal_add htn hcan] at hst'
+  rw [ENNReal.toReal_add hsn hcan] at hts'
+  have hless : (ν (U ∩ A)).toReal < ε := by
+    have hUl : (ν U).toReal < ε := by
+      simpa only [ENNReal.toReal_ofReal hε.le] using
+        (ENNReal.toReal_lt_toReal hUn ENNReal.ofReal_ne_top).mpr hνU
+    exact (ENNReal.toReal_mono hUn hUA).trans_lt hUl
+  exact abs_lt.mpr ⟨by linarith,by linarith⟩
+
+/-- The pathwise rational squeeze gives one increasing extension with
+local total-variation continuity. -/
+theorem RationalTraceIncrements.exists_locally_tv_continuous_extension
+    {μ : ℚ → Measure X} {ν : Measure X} [ν.Regular] [IsFiniteMeasure ν]
+    [NullSingletonClass ν] {γ : ℝ → X} (H : RationalTraceIncrements μ ν γ)
+    (hγ : Continuous γ) :
+    ∃ M : ℝ → Measure X, (∀ t, (M t).Regular) ∧ (∀ t, M t ≤ ν) ∧
+      (∀ q : ℚ, M q=μ q) ∧ Monotone M ∧
+      (∀ f : C_c(X,ℝ), Continuous (fun t => ∫ x, f x ∂M t)) ∧
+      ∀ t₀ : ℝ, ∀ ε : ℝ, 0 < ε → ∃ δ : ℝ, 0 < δ ∧
+        ∀ s t : ℝ, dist s t₀ < δ → dist t t₀ < δ →
+          ∀ A : Set X, MeasurableSet A → |(M s A).toReal-(M t A).toReal| < ε := by
+  obtain ⟨M,hMr,hdom,hrat,hcont,hmono⟩ := H.exists_continuous_extension hγ
+  exact ⟨M,hMr,hdom,hrat,hmono,hcont,H.local_variation_continuity hγ M hMr hdom hrat hcont⟩
+
+end SLEExactGauge
+
+end
+
+end OAI

lean/OAI/Probability/SLE/Mass/RawMassFunctional.lean

@@ -1,74 +1,74 @@
-import OAI.Probability.SLE.Stochastic.DriverPastFactorization
-import OAI.Probability.SLE.Mass.RationalTraceMassProgressiveVersion
-
-namespace OAI
-
-/-! A fixed raw, nonanticipating mass functional on continuous driver paths.
-Each rational slice is first factored through the stopped driver, and the
-single rational reconstruction is progressive on the full path space. -/
-
-noncomputable section
-open Set Filter MeasureTheory
-open scoped Topology NNReal CompactlySupported
-
-namespace SLEExactGauge
-
-local instance rawMassDriverMeasurable : MeasurableSpace C(ℝ≥0,ℝ) := borel _
-local instance rawMassDriverBorel : BorelSpace C(ℝ≥0,ℝ) := ⟨rfl⟩
-local instance : LocallyCompactSpace upperHalfPlane := isOpen_upperHalfPlane.locallyCompactSpace
-
-lemma raw_rational_reconstruction_depends_on_past
-    (F : ℚ → C(ℝ≥0,ℝ) → Measure upperHalfPlane)
-    (t : ℝ≥0) (p q : C(ℝ≥0,ℝ)) (hpq : ∀ s ≤ t, p s=q s) :
-    rationalRadonExtension (fun r p => F r (driverPathStopped (r:ℝ).toNNReal p)) t p =
-      rationalRadonExtension (fun r p => F r (driverPathStopped (r:ℝ).toNNReal p)) t q := by
-  unfold rationalRadonExtension
-  apply congrArg canonicalRadonLimit
-  funext n
-  apply congrArg (F (leftRationalSample n t))
-  exact driverPathStopped_eq_of_agree t _ (by
-    simpa only [Real.toNNReal_coe] using
-      Real.toNNReal_le_toNNReal (leftRationalSample_le n t)) p q hpq
-
-theorem exists_raw_progressive_radon_factor
-    {Ω : Type*} [MeasurableSpace Ω] (P : Measure Ω)
-    (B : ℝ≥0 → Ω → ℝ) (hm : ∀ t, Measurable (B t))
-    (hc : ∀ ω, Continuous (fun t => B t ω))
-    (N : ℝ≥0 → Ω → Measure upperHalfPlane)
-    (hNm : Adapted (Filtration.natural B (fun t => (hm t).stronglyMeasurable)) N)
-    (hNr : ∀ t ω, (N t ω).Regular)
-    (hNc : ∀ᵐ ω ∂P, ∀ f : C_c(upperHalfPlane,ℝ), Continuous (fun t => ∫ z, f z ∂N t ω)) :
-    ∃ R : ℝ≥0 → C(ℝ≥0,ℝ) → Measure upperHalfPlane,
-      IsProgressive driverPathFiltration R ∧
-      (∀ t p, (R t p).Regular ∧ IsFiniteMeasureOnCompacts (R t p)) ∧
-      (∀ t p q, (∀ s ≤ t, p s=q s) → R t p=R t q) ∧
-      ∀ᵐ ω ∂P, ∀ t, R t (sourceDriverPath B hc ω) = N t ω := by
-  choose F hFm hFr hFe using fun q : ℚ => exists_stopped_driver_radon_factor B hm hc
-    (q:ℝ).toNNReal (N (q:ℝ).toNNReal) (hNr _) (hNm _)
-  let μ (q : ℚ) (p : C(ℝ≥0,ℝ)) := F q (driverPathStopped (q:ℝ).toNNReal p)
-  have hμr (q : ℚ) (p : C(ℝ≥0,ℝ)) : (μ q p).Regular := hFr q _
-  have hμm (q : ℚ) (_hq : 0 ≤ q) :
-      Measurable[driverPathFiltration (q:ℝ).toNNReal] (μ q) :=
-    (hFm q).comp (driverPathStopped_measurable_past (q:ℝ).toNNReal)
-  refine ⟨rationalRadonExtension μ,rationalRadonExtension_progressive
-    driverPathFiltration μ hμr hμm,rationalRadonExtension_regular μ,
-      raw_rational_reconstruction_depends_on_past F,?_⟩
-  let μ' (q : ℚ) (ω : Ω) := μ q (sourceDriverPath B hc ω)
-  have hcont : ∀ᵐ ω ∂P, ∀ f : C_c(upperHalfPlane,ℝ),
-      Continuous (fun t : ℝ => ∫ z, f z ∂N t.toNNReal ω) := by
-    filter_upwards [hNc] with ω hω
-    intro f
-    exact (hω f).comp continuous_real_toNNReal
-  have heq : ∀ᵐ ω ∂P, ∀ q : ℚ, N (q:ℝ).toNNReal ω = μ' q ω :=
-    ae_of_all _ (fun ω q => (hFe q ω).symm)
-  have he := rationalRadonExtension_common_version P μ' (fun t ω => N t.toNNReal ω)
-    (fun t ω => hNr t.toNNReal ω) hcont heq
-  filter_upwards [he] with ω hω
-  intro t
-  simpa only [rationalRadonExtension,μ',Real.toNNReal_coe] using hω t
-
-end SLEExactGauge
-
-end
-
-end OAI
+import OAI.Probability.SLE.Stochastic.DriverPastFactorization
+import OAI.Probability.SLE.Mass.RationalTraceMassProgressiveVersion
+
+namespace OAI
+
+/-! A fixed raw, nonanticipating mass functional on continuous driver paths.
+Each rational slice is first factored through the stopped driver, and the
+single rational reconstruction is progressive on the full path space. -/
+
+noncomputable section
+open Set Filter MeasureTheory
+open scoped Topology NNReal CompactlySupported
+
+namespace SLEExactGauge
+
+local instance rawMassDriverMeasurable : MeasurableSpace C(ℝ≥0,ℝ) := borel _
+local instance rawMassDriverBorel : BorelSpace C(ℝ≥0,ℝ) := ⟨rfl⟩
+local instance : LocallyCompactSpace upperHalfPlane := isOpen_upperHalfPlane.locallyCompactSpace
+
+lemma raw_rational_reconstruction_depends_on_past
+    (F : ℚ → C(ℝ≥0,ℝ) → Measure upperHalfPlane)
+    (t : ℝ≥0) (p q : C(ℝ≥0,ℝ)) (hpq : ∀ s ≤ t, p s=q s) :
+    rationalRadonExtension (fun r p => F r (driverPathStopped (r:ℝ).toNNReal p)) t p =
+      rationalRadonExtension (fun r p => F r (driverPathStopped (r:ℝ).toNNReal p)) t q := by
+  unfold rationalRadonExtension
+  apply congrArg canonicalRadonLimit
+  funext n
+  apply congrArg (F (leftRationalSample n t))
+  exact driverPathStopped_eq_of_agree t _ (by
+    simpa only [Real.toNNReal_coe] using
+      Real.toNNReal_le_toNNReal (leftRationalSample_le n t)) p q hpq
+
+theorem exists_raw_progressive_radon_factor
+    {Ω : Type*} [MeasurableSpace Ω] (P : Measure Ω)
+    (B : ℝ≥0 → Ω → ℝ) (hm : ∀ t, Measurable (B t))
+    (hc : ∀ ω, Continuous (fun t => B t ω))
+    (N : ℝ≥0 → Ω → Measure upperHalfPlane)
+    (hNm : Adapted (Filtration.natural B (fun t => (hm t).stronglyMeasurable)) N)
+    (hNr : ∀ t ω, (N t ω).Regular)
+    (hNc : ∀ᵐ ω ∂P, ∀ f : C_c(upperHalfPlane,ℝ), Continuous (fun t => ∫ z, f z ∂N t ω)) :
+    ∃ R : ℝ≥0 → C(ℝ≥0,ℝ) → Measure upperHalfPlane,
+      IsProgressive driverPathFiltration R ∧
+      (∀ t p, (R t p).Regular ∧ IsFiniteMeasureOnCompacts (R t p)) ∧
+      (∀ t p q, (∀ s ≤ t, p s=q s) → R t p=R t q) ∧
+      ∀ᵐ ω ∂P, ∀ t, R t (sourceDriverPath B hc ω) = N t ω := by
+  choose F hFm hFr hFe using fun q : ℚ => exists_stopped_driver_radon_factor B hm hc
+    (q:ℝ).toNNReal (N (q:ℝ).toNNReal) (hNr _) (hNm _)
+  let μ (q : ℚ) (p : C(ℝ≥0,ℝ)) := F q (driverPathStopped (q:ℝ).toNNReal p)
+  have hμr (q : ℚ) (p : C(ℝ≥0,ℝ)) : (μ q p).Regular := hFr q _
+  have hμm (q : ℚ) (_hq : 0 ≤ q) :
+      Measurable[driverPathFiltration (q:ℝ).toNNReal] (μ q) :=
+    (hFm q).comp (driverPathStopped_measurable_past (q:ℝ).toNNReal)
+  refine ⟨rationalRadonExtension μ,rationalRadonExtension_progressive
+    driverPathFiltration μ hμr hμm,rationalRadonExtension_regular μ,
+      raw_rational_reconstruction_depends_on_past F,?_⟩
+  let μ' (q : ℚ) (ω : Ω) := μ q (sourceDriverPath B hc ω)
+  have hcont : ∀ᵐ ω ∂P, ∀ f : C_c(upperHalfPlane,ℝ),
+      Continuous (fun t : ℝ => ∫ z, f z ∂N t.toNNReal ω) := by
+    filter_upwards [hNc] with ω hω
+    intro f
+    exact (hω f).comp continuous_real_toNNReal
+  have heq : ∀ᵐ ω ∂P, ∀ q : ℚ, N (q:ℝ).toNNReal ω = μ' q ω :=
+    ae_of_all _ (fun ω q => (hFe q ω).symm)
+  have he := rationalRadonExtension_common_version P μ' (fun t ω => N t.toNNReal ω)
+    (fun t ω => hNr t.toNNReal ω) hcont heq
+  filter_upwards [he] with ω hω
+  intro t
+  simpa only [rationalRadonExtension,μ',Real.toNNReal_coe] using hω t
+
+end SLEExactGauge
+
+end
+
+end OAI

lean/OAI/Probability/SLE/Mass/RawMassPathLaw.lean

@@ -1,133 +1,133 @@
-import OAI.Probability.SLE.Mass.CanonicalRawMass
-import OAI.Probability.SLE.Mass.RawRadonGoodPaths
-
-namespace OAI
-
-/-! The raw mass has one measurable full-law event carrying all path
-properties simultaneously. Equal driver laws therefore preserve these
-properties without assuming measurability of an uncountable predicate. -/
-
-noncomputable section
-open Set Filter _root_.MeasureTheory _root_.OAI.MeasureTheory
-open scoped Topology CompactlySupported NNReal
-
-namespace SLEExactGauge
-
-local instance rawPathLawDriverMeasurable : MeasurableSpace C(ℝ≥0,ℝ) := borel _
-local instance rawPathLawDriverBorel : BorelSpace C(ℝ≥0,ℝ) := ⟨rfl⟩
-local instance : LocallyCompactSpace upperHalfPlane := isOpen_upperHalfPlane.locallyCompactSpace
-
-theorem exists_raw_rational_radon_factor
-    {Ω : Type*} [MeasurableSpace Ω]
-    (B : ℝ≥0 → Ω → ℝ) (hm : ∀ t, Measurable (B t))
-    (hc : ∀ ω, Continuous (fun t => B t ω))
-    (N : ℝ≥0 → Ω → Measure upperHalfPlane)
-    (hNm : Adapted (Filtration.natural B (fun t => (hm t).stronglyMeasurable)) N)
-    (hNr : ∀ t ω, (N t ω).Regular) :
-    ∃ μ : ℚ → C(ℝ≥0,ℝ) → Measure upperHalfPlane,
-      (∀ q p, (μ q p).Regular) ∧
-      (∀ q : ℚ, Measurable[driverPathFiltration (q:ℝ).toNNReal] (μ q)) ∧
-      (∀ (q : ℚ) p r, (∀ s ≤ (q:ℝ).toNNReal, p s=r s) → μ q p=μ q r) ∧
-      ∀ ω q, μ q (sourceDriverPath B hc ω)=N (q:ℝ).toNNReal ω := by
-  choose F hFm hFr hFe using fun q : ℚ => exists_stopped_driver_radon_factor B hm hc
-    (q:ℝ).toNNReal (N (q:ℝ).toNNReal) (hNr _) (hNm _)
-  refine ⟨fun q p => F q (driverPathStopped (q:ℝ).toNNReal p),?_,?_,?_,?_⟩
-  · exact fun q p => hFr q _
-  · exact fun q => (hFm q).comp (driverPathStopped_measurable_past (q:ℝ).toNNReal)
-  · intro q p r hpr
-    exact congrArg (F q) (driverPathStopped_eq_of_agree _ _ le_rfl p r hpr)
-  · exact fun ω q => hFe q ω
-
-lemma rational_reconstruction_nonanticipating
-    (μ : ℚ → C(ℝ≥0,ℝ) → Measure upperHalfPlane)
-    (hμ : ∀ (q : ℚ) p r, (∀ s ≤ (q:ℝ).toNNReal, p s=r s) → μ q p=μ q r)
-    (t : ℝ≥0) (p r : C(ℝ≥0,ℝ)) (hpr : ∀ s ≤ t, p s=r s) :
-    rationalRadonExtension μ t p=rationalRadonExtension μ t r := by
-  unfold rationalRadonExtension
-  apply congrArg canonicalRadonLimit
-  funext n
-  apply hμ
-  intro s hs
-  apply hpr s
-  apply hs.trans
-  simpa only [Real.toNNReal_coe] using Real.toNNReal_le_toNNReal (leftRationalSample_le n t)
-
-theorem raw_radon_path_properties_of_same_law
-    {Ω Ξ Y : Type*} [MeasurableSpace Ω] [MeasurableSpace Ξ] [MeasurableSpace Y]
-    (P : Measure Ω) (Q : Measure Ξ) (A : Ω → Y) (B : Ξ → Y)
-    (hA : Measurable A) (hB : Measurable B) (hlaw : Q.map B=P.map A)
-    (D : LocalTestFamily upperHalfPlane) (μ : ℚ → Y → Measure upperHalfPlane)
-    (hm : ∀ q, Measurable (μ q)) (hr : ∀ q y, (μ q y).Regular)
-    (hg : ∀ᵐ ω ∂P, RawRadonGood D (fun q => μ q (A ω))) :
-    ∀ᵐ ξ ∂Q,
-      rationalRadonExtension μ 0 (B ξ)=0 ∧
-      Monotone (fun t => rationalRadonExtension μ t (B ξ)) ∧
-      ∀ f : C_c(upperHalfPlane,ℝ),
-        Continuous (fun t => ∫ z, f z ∂rationalRadonExtension μ t (B ξ)) := by
-  have hE := measurableSet_rawRadonGood D μ hm hr
-  have hpush : ∀ᵐ y ∂P.map A, RawRadonGood D (fun q => μ q y) :=
-    (ae_map_iff hA.aemeasurable hE).mpr hg
-  rw [← hlaw] at hpush
-  have hgood := (ae_map_iff hB.aemeasurable hE).mp hpush
-  filter_upwards [hgood] with ξ hξ
-  exact RawRadonGood.reconstructed_paths D (fun q => μ q (B ξ)) (fun q => hr q _) hξ
-
-namespace Multipoint
-
-theorem CanonicalMass.exists_raw_nonanticipating_with_good_set
-    {Ω : Type*} [MeasurableSpace Ω] {P : Measure Ω} {κ : ℝ}
-    {B : ℝ≥0 → Ω → ℝ} {hBm : Measurable (Function.uncurry B)}
-    {γ : Ω → ℝ≥0 → ℂ} {G : Ω → ℝ≥0 → ℂ → ℂ}
-    (C : CanonicalMass P κ B hBm γ G)
-    (hBc : ∀ ω, Continuous (fun t => B t ω)) :
-    ∃ R : ℝ≥0 → C(ℝ≥0,ℝ) → Measure upperHalfPlane,
-      ∃ E : Set C(ℝ≥0,ℝ),
-      IsProgressive driverPathFiltration R ∧
-      (∀ t p, (R t p).Regular ∧ IsFiniteMeasureOnCompacts (R t p)) ∧
-      (∀ t p r, (∀ s ≤ t, p s=r s) → R t p=R t r) ∧
-      MeasurableSet E ∧ (∀ᵐ p ∂P.map (sourceDriverPath B hBc), p ∈ E) ∧
-      (∀ p ∈ E, R 0 p=0 ∧ Monotone (fun t => R t p) ∧
-        ∀ f : C_c(upperHalfPlane,ℝ), Continuous (fun t => ∫ z, f z ∂(R t p))) ∧
-      ∀ᵐ ω ∂P, ∀ t, R t (sourceDriverPath B hBc ω)=C.process t ω := by
-  have hm (t : ℝ≥0) : Measurable (B t) :=
-    hBm.comp (measurable_const.prodMk measurable_id)
-  obtain ⟨μ,hμr,hμm,hμn,hμe⟩ := exists_raw_rational_radon_factor B hm hBc C.process
-    C.progressive.adapted (fun t ω => (C.radon t ω).1)
-  let R := rationalRadonExtension μ
-  let D := localTestFamily upperHalfPlane
-  let E : Set C(ℝ≥0,ℝ) := {p | RawRadonGood D (fun q => μ q p)}
-  have hμma (q : ℚ) : Measurable (μ q) :=
-    (hμm q).mono (driverPathFiltration.le _) le_rfl
-  have hEm : MeasurableSet E := measurableSet_rawRadonGood D μ hμma hμr
-  have hgood : ∀ᵐ ω ∂P, sourceDriverPath B hBc ω ∈ E := by
-    filter_upwards [C.paths] with ω hω
-    dsimp only [E,mem_ofPred_eq]
-    simp_rw [hμe]
-    exact rawRadonGood_of_continuous_path D (fun t => C.process t ω)
-      (fun t => (C.radon t ω).1) hω.zero hω.monotone hω.continuous_tests
-  have hbp : Measurable (sourceDriverPath B hBc) := source_path_measurable _ hm
-  refine ⟨R,E,rationalRadonExtension_progressive driverPathFiltration μ hμr (fun q _ => hμm q),
-    rationalRadonExtension_regular μ,rational_reconstruction_nonanticipating μ hμn,
-    hEm,(ae_map_iff hbp.aemeasurable hEm).mpr hgood,?_,?_⟩
-  · intro p hp
-    exact RawRadonGood.reconstructed_paths D (fun q => μ q p) (fun q => hμr q p) hp
-  · let μ' (q : ℚ) (ω : Ω) := μ q (sourceDriverPath B hBc ω)
-    have hc : ∀ᵐ ω ∂P, ∀ f : C_c(upperHalfPlane,ℝ),
-        Continuous (fun t : ℝ => ∫ z, f z ∂C.process t.toNNReal ω) := by
-      filter_upwards [C.paths] with ω hω
-      intro f
-      exact (hω.continuous_tests f).comp continuous_real_toNNReal
-    have he : ∀ᵐ ω ∂P, ∀ q : ℚ, C.process (q:ℝ).toNNReal ω=μ' q ω :=
-      ae_of_all _ (fun ω q => (hμe ω q).symm)
-    have h := rationalRadonExtension_common_version P μ' (fun t ω => C.process t.toNNReal ω)
-      (fun t ω => (C.radon t.toNNReal ω).1) hc he
-    filter_upwards [h] with ω hω
-    intro t
-    simpa only [R,rationalRadonExtension,μ',Real.toNNReal_coe] using hω t
-
-end Multipoint
-end SLEExactGauge
-
-end
-
-end OAI
+import OAI.Probability.SLE.Mass.CanonicalRawMass
+import OAI.Probability.SLE.Mass.RawRadonGoodPaths
+
+namespace OAI
+
+/-! The raw mass has one measurable full-law event carrying all path
+properties simultaneously. Equal driver laws therefore preserve these
+properties without assuming measurability of an uncountable predicate. -/
+
+noncomputable section
+open Set Filter _root_.MeasureTheory _root_.OAI.MeasureTheory
+open scoped Topology CompactlySupported NNReal
+
+namespace SLEExactGauge
+
+local instance rawPathLawDriverMeasurable : MeasurableSpace C(ℝ≥0,ℝ) := borel _
+local instance rawPathLawDriverBorel : BorelSpace C(ℝ≥0,ℝ) := ⟨rfl⟩
+local instance : LocallyCompactSpace upperHalfPlane := isOpen_upperHalfPlane.locallyCompactSpace
+
+theorem exists_raw_rational_radon_factor
+    {Ω : Type*} [MeasurableSpace Ω]
+    (B : ℝ≥0 → Ω → ℝ) (hm : ∀ t, Measurable (B t))
+    (hc : ∀ ω, Continuous (fun t => B t ω))
+    (N : ℝ≥0 → Ω → Measure upperHalfPlane)
+    (hNm : Adapted (Filtration.natural B (fun t => (hm t).stronglyMeasurable)) N)
+    (hNr : ∀ t ω, (N t ω).Regular) :
+    ∃ μ : ℚ → C(ℝ≥0,ℝ) → Measure upperHalfPlane,
+      (∀ q p, (μ q p).Regular) ∧
+      (∀ q : ℚ, Measurable[driverPathFiltration (q:ℝ).toNNReal] (μ q)) ∧
+      (∀ (q : ℚ) p r, (∀ s ≤ (q:ℝ).toNNReal, p s=r s) → μ q p=μ q r) ∧
+      ∀ ω q, μ q (sourceDriverPath B hc ω)=N (q:ℝ).toNNReal ω := by
+  choose F hFm hFr hFe using fun q : ℚ => exists_stopped_driver_radon_factor B hm hc
+    (q:ℝ).toNNReal (N (q:ℝ).toNNReal) (hNr _) (hNm _)
+  refine ⟨fun q p => F q (driverPathStopped (q:ℝ).toNNReal p),?_,?_,?_,?_⟩
+  · exact fun q p => hFr q _
+  · exact fun q => (hFm q).comp (driverPathStopped_measurable_past (q:ℝ).toNNReal)
+  · intro q p r hpr
+    exact congrArg (F q) (driverPathStopped_eq_of_agree _ _ le_rfl p r hpr)
+  · exact fun ω q => hFe q ω
+
+lemma rational_reconstruction_nonanticipating
+    (μ : ℚ → C(ℝ≥0,ℝ) → Measure upperHalfPlane)
+    (hμ : ∀ (q : ℚ) p r, (∀ s ≤ (q:ℝ).toNNReal, p s=r s) → μ q p=μ q r)
+    (t : ℝ≥0) (p r : C(ℝ≥0,ℝ)) (hpr : ∀ s ≤ t, p s=r s) :
+    rationalRadonExtension μ t p=rationalRadonExtension μ t r := by
+  unfold rationalRadonExtension
+  apply congrArg canonicalRadonLimit
+  funext n
+  apply hμ
+  intro s hs
+  apply hpr s
+  apply hs.trans
+  simpa only [Real.toNNReal_coe] using Real.toNNReal_le_toNNReal (leftRationalSample_le n t)
+
+theorem raw_radon_path_properties_of_same_law
+    {Ω Ξ Y : Type*} [MeasurableSpace Ω] [MeasurableSpace Ξ] [MeasurableSpace Y]
+    (P : Measure Ω) (Q : Measure Ξ) (A : Ω → Y) (B : Ξ → Y)
+    (hA : Measurable A) (hB : Measurable B) (hlaw : Q.map B=P.map A)
+    (D : LocalTestFamily upperHalfPlane) (μ : ℚ → Y → Measure upperHalfPlane)
+    (hm : ∀ q, Measurable (μ q)) (hr : ∀ q y, (μ q y).Regular)
+    (hg : ∀ᵐ ω ∂P, RawRadonGood D (fun q => μ q (A ω))) :
+    ∀ᵐ ξ ∂Q,
+      rationalRadonExtension μ 0 (B ξ)=0 ∧
+      Monotone (fun t => rationalRadonExtension μ t (B ξ)) ∧
+      ∀ f : C_c(upperHalfPlane,ℝ),
+        Continuous (fun t => ∫ z, f z ∂rationalRadonExtension μ t (B ξ)) := by
+  have hE := measurableSet_rawRadonGood D μ hm hr
+  have hpush : ∀ᵐ y ∂P.map A, RawRadonGood D (fun q => μ q y) :=
+    (ae_map_iff hA.aemeasurable hE).mpr hg
+  rw [← hlaw] at hpush
+  have hgood := (ae_map_iff hB.aemeasurable hE).mp hpush
+  filter_upwards [hgood] with ξ hξ
+  exact RawRadonGood.reconstructed_paths D (fun q => μ q (B ξ)) (fun q => hr q _) hξ
+
+namespace Multipoint
+
+theorem CanonicalMass.exists_raw_nonanticipating_with_good_set
+    {Ω : Type*} [MeasurableSpace Ω] {P : Measure Ω} {κ : ℝ}
+    {B : ℝ≥0 → Ω → ℝ} {hBm : Measurable (Function.uncurry B)}
+    {γ : Ω → ℝ≥0 → ℂ} {G : Ω → ℝ≥0 → ℂ → ℂ}
+    (C : CanonicalMass P κ B hBm γ G)
+    (hBc : ∀ ω, Continuous (fun t => B t ω)) :
+    ∃ R : ℝ≥0 → C(ℝ≥0,ℝ) → Measure upperHalfPlane,
+      ∃ E : Set C(ℝ≥0,ℝ),
+      IsProgressive driverPathFiltration R ∧
+      (∀ t p, (R t p).Regular ∧ IsFiniteMeasureOnCompacts (R t p)) ∧
+      (∀ t p r, (∀ s ≤ t, p s=r s) → R t p=R t r) ∧
+      MeasurableSet E ∧ (∀ᵐ p ∂P.map (sourceDriverPath B hBc), p ∈ E) ∧
+      (∀ p ∈ E, R 0 p=0 ∧ Monotone (fun t => R t p) ∧
+        ∀ f : C_c(upperHalfPlane,ℝ), Continuous (fun t => ∫ z, f z ∂(R t p))) ∧
+      ∀ᵐ ω ∂P, ∀ t, R t (sourceDriverPath B hBc ω)=C.process t ω := by
+  have hm (t : ℝ≥0) : Measurable (B t) :=
+    hBm.comp (measurable_const.prodMk measurable_id)
+  obtain ⟨μ,hμr,hμm,hμn,hμe⟩ := exists_raw_rational_radon_factor B hm hBc C.process
+    C.progressive.adapted (fun t ω => (C.radon t ω).1)
+  let R := rationalRadonExtension μ
+  let D := localTestFamily upperHalfPlane
+  let E : Set C(ℝ≥0,ℝ) := {p | RawRadonGood D (fun q => μ q p)}
+  have hμma (q : ℚ) : Measurable (μ q) :=
+    (hμm q).mono (driverPathFiltration.le _) le_rfl
+  have hEm : MeasurableSet E := measurableSet_rawRadonGood D μ hμma hμr
+  have hgood : ∀ᵐ ω ∂P, sourceDriverPath B hBc ω ∈ E := by
+    filter_upwards [C.paths] with ω hω
+    dsimp only [E,mem_ofPred_eq]
+    simp_rw [hμe]
+    exact rawRadonGood_of_continuous_path D (fun t => C.process t ω)
+      (fun t => (C.radon t ω).1) hω.zero hω.monotone hω.continuous_tests
+  have hbp : Measurable (sourceDriverPath B hBc) := source_path_measurable _ hm
+  refine ⟨R,E,rationalRadonExtension_progressive driverPathFiltration μ hμr (fun q _ => hμm q),
+    rationalRadonExtension_regular μ,rational_reconstruction_nonanticipating μ hμn,
+    hEm,(ae_map_iff hbp.aemeasurable hEm).mpr hgood,?_,?_⟩
+  · intro p hp
+    exact RawRadonGood.reconstructed_paths D (fun q => μ q p) (fun q => hμr q p) hp
+  · let μ' (q : ℚ) (ω : Ω) := μ q (sourceDriverPath B hBc ω)
+    have hc : ∀ᵐ ω ∂P, ∀ f : C_c(upperHalfPlane,ℝ),
+        Continuous (fun t : ℝ => ∫ z, f z ∂C.process t.toNNReal ω) := by
+      filter_upwards [C.paths] with ω hω
+      intro f
+      exact (hω.continuous_tests f).comp continuous_real_toNNReal
+    have he : ∀ᵐ ω ∂P, ∀ q : ℚ, C.process (q:ℝ).toNNReal ω=μ' q ω :=
+      ae_of_all _ (fun ω q => (hμe ω q).symm)
+    have h := rationalRadonExtension_common_version P μ' (fun t ω => C.process t.toNNReal ω)
+      (fun t ω => (C.radon t.toNNReal ω).1) hc he
+    filter_upwards [h] with ω hω
+    intro t
+    simpa only [R,rationalRadonExtension,μ',Real.toNNReal_coe] using hω t
+
+end Multipoint
+end SLEExactGauge
+
+end
+
+end OAI

lean/OAI/Probability/SLE/Mass/RawRadonGoodPaths.lean

@@ -1,109 +1,109 @@
-import OAI.Probability.SLE.Geometry.RationalTestPath
-
-namespace OAI
-
-/-! A countably measurable event guaranteeing zero initial mass, monotone
-growth, and continuous compact-test paths for the raw rational reconstruction. -/
-
-noncomputable section
-open Set Filter MeasureTheory
-open scoped Topology CompactlySupported NNReal
-
-namespace SLEExactGauge
-
-local instance : LocallyCompactSpace upperHalfPlane := isOpen_upperHalfPlane.locallyCompactSpace
-
-def RawRadonGood (D : LocalTestFamily upperHalfPlane) (μ : ℚ → Measure upperHalfPlane) : Prop :=
-  HasContinuousRationalTests D μ ∧
-  (∀ p q : ℚ, 0 ≤ p → p ≤ q → ∀ j,
-    (∫ z, (D.test j ⊔ 0) z ∂μ p) ≤ ∫ z, (D.test j ⊔ 0) z ∂μ q) ∧
-  ∀ j, (∫ z, D.test j z ∂μ 0)=0
-
-lemma measurableSet_rawRadonGood {Y : Type*} [MeasurableSpace Y]
-    (D : LocalTestFamily upperHalfPlane) (μ : ℚ → Y → Measure upperHalfPlane)
-    (hm : ∀ q, Measurable (μ q)) (hr : ∀ q y, (μ q y).Regular) :
-    MeasurableSet {y | RawRadonGood D (fun q => μ q y)} := by
-  have htest (q : ℚ) (f : C_c(upperHalfPlane,ℝ)) :=
-    measurable_halfPlane_compact_test_integral (μ q) (hm q) (hr q) f
-  have hc := measurableSet_hasContinuousRationalTests D μ (fun q j => htest q (D.test j))
-  have ho : MeasurableSet {y | ∀ p q : ℚ, 0 ≤ p → p ≤ q → ∀ j,
-      (∫ z, (D.test j ⊔ 0) z ∂μ p y) ≤ ∫ z, (D.test j ⊔ 0) z ∂μ q y} := by
-    simp only [Set.ofPred_forall]
-    exact MeasurableSet.iInter fun p => MeasurableSet.iInter fun q =>
-      MeasurableSet.iInter fun _ => MeasurableSet.iInter fun _ =>
-        MeasurableSet.iInter fun j => measurableSet_le (htest p _) (htest q _)
-  have hz : MeasurableSet {y | ∀ j, (∫ z, D.test j z ∂μ 0 y)=0} := by
-    simp only [Set.ofPred_forall]
-    exact MeasurableSet.iInter fun j => measurableSet_eq_fun (htest 0 (D.test j)) measurable_const
-  simpa only [RawRadonGood,Set.ofPred_and] using hc.inter (ho.inter hz)
-
-theorem RawRadonGood.reconstructed_paths
-    (D : LocalTestFamily upperHalfPlane) (μ : ℚ → Measure upperHalfPlane)
-    (hr : ∀ q, (μ q).Regular) (hg : RawRadonGood D μ) :
-    let N := fun t => rationalRadonExtension (fun q (_ : Unit) => μ q) t ()
-    N 0=0 ∧ Monotone N ∧ ∀ f : C_c(upperHalfPlane,ℝ),
-      Continuous (fun t => ∫ z, f z ∂N t) := by
-  dsimp only
-  let N := fun t => rationalRadonExtension (fun q (_ : Unit) => μ q) t ()
-  obtain ⟨hq,hc⟩ := HasContinuousRationalTests.continuous_extension D μ hr hg.1
-  have hzero : μ 0=0 := by
-    let := hr 0
-    apply D.measure_eq_of_test_integrals
-    intro j
-    simpa only [integral_zero_measure] using hg.2.2 j
-  have hz : N 0=0 := by
-    have h := hq 0 le_rfl
-    simpa only [Rat.cast_zero,Real.toNNReal_zero,hzero] using h
-  refine ⟨hz,?_,hc⟩
-  intro s t hst
-  rcases eq_or_lt_of_le hst with rfl | hst
-  · exact le_rfl
-  let := (rationalRadonExtension_regular (fun q (_ : Unit) => μ q) s ()).1
-  let := (rationalRadonExtension_regular (fun q (_ : Unit) => μ q) t ()).1
-  apply radon_measure_le_of_nonneg_tests
-  intro f hf
-  have hlim (r : ℝ≥0) : Tendsto (fun n => ∫ z, f z ∂μ (leftRationalSample n r)) atTop
-      (𝓝 (∫ z, f z ∂N r)) := by
-    have he (n : ℕ) := hq (leftRationalSample n r) (leftRationalSample_nonneg n r)
-    have ht := (continuous_real_toNNReal.tendsto (r:ℝ)).comp (leftRationalSample_tendsto r)
-    simpa only [Real.toNNReal_coe,Function.comp_def,he] using
-      (hc f).continuousAt.tendsto.comp ht
-  have hlt : ∀ᶠ n in atTop, leftRationalSample n s ≤ leftRationalSample n t := by
-    have hs := (leftRationalSample_tendsto s).eventually
-      (gt_mem_nhds (show (s:ℝ)<((s:ℝ)+t)/2 by exact (by have := NNReal.coe_lt_coe.mpr hst; linarith)))
-    have ht := (leftRationalSample_tendsto t).eventually
-      (lt_mem_nhds (show ((s:ℝ)+t)/2<(t:ℝ) by exact (by have := NNReal.coe_lt_coe.mpr hst; linarith)))
-    filter_upwards [hs,ht] with n hn hm
-    exact Rat.cast_le.mp (hn.trans hm).le
-  apply le_of_tendsto_of_tendsto (hlim s) (hlim t)
-  filter_upwards [hlt] with n hn
-  have hle : μ (leftRationalSample n s) ≤ μ (leftRationalSample n t) := by
-    let := hr (leftRationalSample n s)
-    let := hr (leftRationalSample n t)
-    exact D.measure_le_of_positive_tests _ _
-      (hg.2.1 _ _ (leftRationalSample_nonneg n s) hn)
-  let := hr (leftRationalSample n t)
-  exact integral_mono_measure hle (ae_of_all _ hf) f.integrable
-
-theorem rawRadonGood_of_continuous_path
-    (D : LocalTestFamily upperHalfPlane) (N : ℝ≥0 → Measure upperHalfPlane)
-    (hr : ∀ t, (N t).Regular) (hz : N 0=0) (hm : Monotone N)
-    (hc : ∀ f : C_c(upperHalfPlane,ℝ), Continuous (fun t => ∫ z, f z ∂N t)) :
-    RawRadonGood D (fun q : ℚ => N (q:ℝ).toNNReal) := by
-  refine ⟨?_,?_,?_⟩
-  · intro j
-    refine ⟨⟨fun t => ∫ z, D.test j z ∂N t.toNNReal,
-      (hc (D.test j)).comp continuous_real_toNNReal⟩,?_⟩
-    rfl
-  · intro p q _hp hpq j
-    let := hr (q:ℝ).toNNReal
-    exact integral_mono_measure (hm (Real.toNNReal_le_toNNReal (Rat.cast_le.mpr hpq)))
-      (ae_of_all _ (fun _ => le_max_right _ _)) (D.test j ⊔ 0).integrable
-  · intro j
-    simp only [Rat.cast_zero,Real.toNNReal_zero,hz,integral_zero_measure]
-
-end SLEExactGauge
-
-end
-
-end OAI
+import OAI.Probability.SLE.Geometry.RationalTestPath
+
+namespace OAI
+
+/-! A countably measurable event guaranteeing zero initial mass, monotone
+growth, and continuous compact-test paths for the raw rational reconstruction. -/
+
+noncomputable section
+open Set Filter MeasureTheory
+open scoped Topology CompactlySupported NNReal
+
+namespace SLEExactGauge
+
+local instance : LocallyCompactSpace upperHalfPlane := isOpen_upperHalfPlane.locallyCompactSpace
+
+def RawRadonGood (D : LocalTestFamily upperHalfPlane) (μ : ℚ → Measure upperHalfPlane) : Prop :=
+  HasContinuousRationalTests D μ ∧
+  (∀ p q : ℚ, 0 ≤ p → p ≤ q → ∀ j,
+    (∫ z, (D.test j ⊔ 0) z ∂μ p) ≤ ∫ z, (D.test j ⊔ 0) z ∂μ q) ∧
+  ∀ j, (∫ z, D.test j z ∂μ 0)=0
+
+lemma measurableSet_rawRadonGood {Y : Type*} [MeasurableSpace Y]
+    (D : LocalTestFamily upperHalfPlane) (μ : ℚ → Y → Measure upperHalfPlane)
+    (hm : ∀ q, Measurable (μ q)) (hr : ∀ q y, (μ q y).Regular) :
+    MeasurableSet {y | RawRadonGood D (fun q => μ q y)} := by
+  have htest (q : ℚ) (f : C_c(upperHalfPlane,ℝ)) :=
+    measurable_halfPlane_compact_test_integral (μ q) (hm q) (hr q) f
+  have hc := measurableSet_hasContinuousRationalTests D μ (fun q j => htest q (D.test j))
+  have ho : MeasurableSet {y | ∀ p q : ℚ, 0 ≤ p → p ≤ q → ∀ j,
+      (∫ z, (D.test j ⊔ 0) z ∂μ p y) ≤ ∫ z, (D.test j ⊔ 0) z ∂μ q y} := by
+    simp only [Set.ofPred_forall]
+    exact MeasurableSet.iInter fun p => MeasurableSet.iInter fun q =>
+      MeasurableSet.iInter fun _ => MeasurableSet.iInter fun _ =>
+        MeasurableSet.iInter fun j => measurableSet_le (htest p _) (htest q _)
+  have hz : MeasurableSet {y | ∀ j, (∫ z, D.test j z ∂μ 0 y)=0} := by
+    simp only [Set.ofPred_forall]
+    exact MeasurableSet.iInter fun j => measurableSet_eq_fun (htest 0 (D.test j)) measurable_const
+  simpa only [RawRadonGood,Set.ofPred_and] using hc.inter (ho.inter hz)
+
+theorem RawRadonGood.reconstructed_paths
+    (D : LocalTestFamily upperHalfPlane) (μ : ℚ → Measure upperHalfPlane)
+    (hr : ∀ q, (μ q).Regular) (hg : RawRadonGood D μ) :
+    let N := fun t => rationalRadonExtension (fun q (_ : Unit) => μ q) t ()
+    N 0=0 ∧ Monotone N ∧ ∀ f : C_c(upperHalfPlane,ℝ),
+      Continuous (fun t => ∫ z, f z ∂N t) := by
+  dsimp only
+  let N := fun t => rationalRadonExtension (fun q (_ : Unit) => μ q) t ()
+  obtain ⟨hq,hc⟩ := HasContinuousRationalTests.continuous_extension D μ hr hg.1
+  have hzero : μ 0=0 := by
+    let := hr 0
+    apply D.measure_eq_of_test_integrals
+    intro j
+    simpa only [integral_zero_measure] using hg.2.2 j
+  have hz : N 0=0 := by
+    have h := hq 0 le_rfl
+    simpa only [Rat.cast_zero,Real.toNNReal_zero,hzero] using h
+  refine ⟨hz,?_,hc⟩
+  intro s t hst
+  rcases eq_or_lt_of_le hst with rfl | hst
+  · exact le_rfl
+  let := (rationalRadonExtension_regular (fun q (_ : Unit) => μ q) s ()).1
+  let := (rationalRadonExtension_regular (fun q (_ : Unit) => μ q) t ()).1
+  apply radon_measure_le_of_nonneg_tests
+  intro f hf
+  have hlim (r : ℝ≥0) : Tendsto (fun n => ∫ z, f z ∂μ (leftRationalSample n r)) atTop
+      (𝓝 (∫ z, f z ∂N r)) := by
+    have he (n : ℕ) := hq (leftRationalSample n r) (leftRationalSample_nonneg n r)
+    have ht := (continuous_real_toNNReal.tendsto (r:ℝ)).comp (leftRationalSample_tendsto r)
+    simpa only [Real.toNNReal_coe,Function.comp_def,he] using
+      (hc f).continuousAt.tendsto.comp ht
+  have hlt : ∀ᶠ n in atTop, leftRationalSample n s ≤ leftRationalSample n t := by
+    have hs := (leftRationalSample_tendsto s).eventually
+      (gt_mem_nhds (show (s:ℝ)<((s:ℝ)+t)/2 by exact (by have := NNReal.coe_lt_coe.mpr hst; linarith)))
+    have ht := (leftRationalSample_tendsto t).eventually
+      (lt_mem_nhds (show ((s:ℝ)+t)/2<(t:ℝ) by exact (by have := NNReal.coe_lt_coe.mpr hst; linarith)))
+    filter_upwards [hs,ht] with n hn hm
+    exact Rat.cast_le.mp (hn.trans hm).le
+  apply le_of_tendsto_of_tendsto (hlim s) (hlim t)
+  filter_upwards [hlt] with n hn
+  have hle : μ (leftRationalSample n s) ≤ μ (leftRationalSample n t) := by
+    let := hr (leftRationalSample n s)
+    let := hr (leftRationalSample n t)
+    exact D.measure_le_of_positive_tests _ _
+      (hg.2.1 _ _ (leftRationalSample_nonneg n s) hn)
+  let := hr (leftRationalSample n t)
+  exact integral_mono_measure hle (ae_of_all _ hf) f.integrable
+
+theorem rawRadonGood_of_continuous_path
+    (D : LocalTestFamily upperHalfPlane) (N : ℝ≥0 → Measure upperHalfPlane)
+    (hr : ∀ t, (N t).Regular) (hz : N 0=0) (hm : Monotone N)
+    (hc : ∀ f : C_c(upperHalfPlane,ℝ), Continuous (fun t => ∫ z, f z ∂N t)) :
+    RawRadonGood D (fun q : ℚ => N (q:ℝ).toNNReal) := by
+  refine ⟨?_,?_,?_⟩
+  · intro j
+    refine ⟨⟨fun t => ∫ z, D.test j z ∂N t.toNNReal,
+      (hc (D.test j)).comp continuous_real_toNNReal⟩,?_⟩
+    rfl
+  · intro p q _hp hpq j
+    let := hr (q:ℝ).toNNReal
+    exact integral_mono_measure (hm (Real.toNNReal_le_toNNReal (Rat.cast_le.mpr hpq)))
+      (ae_of_all _ (fun _ => le_max_right _ _)) (D.test j ⊔ 0).integrable
+  · intro j
+    simp only [Rat.cast_zero,Real.toNNReal_zero,hz,integral_zero_measure]
+
+end SLEExactGauge
+
+end
+
+end OAI

lean/OAI/Probability/SLE/Mass/RawRadonLimit.lean

@@ -1,44 +1,44 @@
-import OAI.Probability.SLE.Mass.CanonicalRadonLimit
-
-namespace OAI
-
-/-! Raw Radon reconstruction from countable test-Cauchy data. The existing
-canonical reconstruction tests Cauchy convergence in the data space itself;
-its cutoff coordinates supply the local mass bounds. -/
-
-noncomputable section
-open Set Filter MeasureTheory Classical
-open scoped Topology CompactlySupported
-
-namespace SLEExactGauge
-
-variable {X : Type*} [TopologicalSpace X] [T2Space X] [LocallyCompactSpace X]
-  [SecondCountableTopology X] [MeasurableSpace X] [BorelSpace X]
-
-lemma LocalTestFamily.exists_raw_radon_limit
-    (D : LocalTestFamily X) {Y : Type*} [MeasurableSpace Y]
-    (μ : ℕ → Y → Measure X) (hμ : ∀ n y, (μ n y).Regular)
-    (hm : ∀ n (f : C_c(X,ℝ)), Measurable (fun y => ∫ x, f x ∂μ n y)) :
-    ∃ ν : Y → Measure X, Measurable ν ∧ (∀ y, (ν y).Regular) ∧
-      ∀ y, (∀ j, CauchySeq (fun n => ∫ x, D.test j x ∂μ n y)) →
-        ∀ f : C_c(X,ℝ), Tendsto (fun n => ∫ x, f x ∂μ n y) atTop (𝓝 (∫ x, f x ∂ν y)) := by
-  let ν (y : Y) := canonicalRadonLimit (fun n => μ n y)
-  refine ⟨ν,canonicalRadonLimit_measurable μ ?_ hm,
-    fun y => canonicalRadonLimit_regular _,?_⟩
-  · intro n y
-    let := hμ n y
-    infer_instance
-  · intro y hy
-    let (n : ℕ) : IsFiniteMeasureOnCompacts (μ n y) := by
-      let := hμ n y
-      infer_instance
-    obtain ⟨η,hη,_,hl⟩ := D.exists_radon_limit (fun n => μ n y)
-      (fun j => cauchySeq_tendsto_of_complete (hy j))
-    have he : ν y=η := canonicalRadonLimit_identified _ η ⟨hη,hl⟩
-    simpa only [he] using hl
-
-end SLEExactGauge
-
-end
-
-end OAI
+import OAI.Probability.SLE.Mass.CanonicalRadonLimit
+
+namespace OAI
+
+/-! Raw Radon reconstruction from countable test-Cauchy data. The existing
+canonical reconstruction tests Cauchy convergence in the data space itself;
+its cutoff coordinates supply the local mass bounds. -/
+
+noncomputable section
+open Set Filter MeasureTheory Classical
+open scoped Topology CompactlySupported
+
+namespace SLEExactGauge
+
+variable {X : Type*} [TopologicalSpace X] [T2Space X] [LocallyCompactSpace X]
+  [SecondCountableTopology X] [MeasurableSpace X] [BorelSpace X]
+
+lemma LocalTestFamily.exists_raw_radon_limit
+    (D : LocalTestFamily X) {Y : Type*} [MeasurableSpace Y]
+    (μ : ℕ → Y → Measure X) (hμ : ∀ n y, (μ n y).Regular)
+    (hm : ∀ n (f : C_c(X,ℝ)), Measurable (fun y => ∫ x, f x ∂μ n y)) :
+    ∃ ν : Y → Measure X, Measurable ν ∧ (∀ y, (ν y).Regular) ∧
+      ∀ y, (∀ j, CauchySeq (fun n => ∫ x, D.test j x ∂μ n y)) →
+        ∀ f : C_c(X,ℝ), Tendsto (fun n => ∫ x, f x ∂μ n y) atTop (𝓝 (∫ x, f x ∂ν y)) := by
+  let ν (y : Y) := canonicalRadonLimit (fun n => μ n y)
+  refine ⟨ν,canonicalRadonLimit_measurable μ ?_ hm,
+    fun y => canonicalRadonLimit_regular _,?_⟩
+  · intro n y
+    let := hμ n y
+    infer_instance
+  · intro y hy
+    let (n : ℕ) : IsFiniteMeasureOnCompacts (μ n y) := by
+      let := hμ n y
+      infer_instance
+    obtain ⟨η,hη,_,hl⟩ := D.exists_radon_limit (fun n => μ n y)
+      (fun j => cauchySeq_tendsto_of_complete (hy j))
+    have he : ν y=η := canonicalRadonLimit_identified _ η ⟨hη,hl⟩
+    simpa only [he] using hl
+
+end SLEExactGauge
+
+end
+
+end OAI

lean/OAI/Probability/SLE/Mass/RawScaledMassMeans.lean

@@ -1,135 +1,135 @@
-import OAI.Probability.SLE.Mass.RawScaledMassPaths
-import OAI.Probability.SLE.Mass.ScaledGreenMeasure
-import OAI.Probability.SLE.Mass.GreenMassProcessUniqueness
-
-namespace OAI
-
-/-! Mean bounds and equal Green remainders for the physical dilation
-and the canonical functional of the scaled Brownian driver. -/
-
-noncomputable section
-open Set Filter _root_.MeasureTheory _root_.OAI.MeasureTheory ProbabilityTheory
-open scoped Topology NNReal ENNReal
-
-namespace SLEExactGauge.Multipoint
-
-local instance rawScaledMeansMeasurable : MeasurableSpace C(ℝ≥0,ℝ) := borel _
-local instance rawScaledMeansBorel : BorelSpace C(ℝ≥0,ℝ) := ⟨rfl⟩
-
-lemma bind_comp_eq_of_path_law {Ω : Type*} [MeasurableSpace Ω] (P : Measure Ω)
-    (X Y : Ω → C(ℝ≥0,ℝ)) (hX : Measurable X) (hY : Measurable Y)
-    (hXY : P.map X=P.map Y) (N : C(ℝ≥0,ℝ) → Measure upperHalfPlane) (hN : Measurable N) :
-    P.bind (fun ω => N (X ω))=P.bind (fun ω => N (Y ω)) := by
-  calc
-    _ = (P.map X).bind N := by
-      unfold Measure.bind
-      rw [Measure.map_map hN hX]
-      rfl
-    _ = (P.map Y).bind N := by rw [hXY]
-    _ = _ := by
-      unfold Measure.bind
-      rw [Measure.map_map hN hY]
-      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) (hB : IsBrownianReal B P)
-  (hc : ∀ ω, Continuous (fun t => B t ω))
-  (R : RawCanonicalMass)
-  (he : ∀ᵐ ω ∂P, (∀ t, R.process t (sourceDriverPath B hc ω)=C.process t ω) ∧
-    R.terminal (sourceDriverPath B hc ω)=C.rational.terminal ω)
-  (c : ℝ≥0) (hcp : 0 < c)
-
-include C hB hc R he c hcp in
-omit [IsProbabilityMeasure P] in
-lemma CanonicalMass.scaledRawMass_mean_le (t : ℝ≥0) :
-    P.bind (scaledRawMass R c B hc t) ≤ initialGreenMeasure κ := by
-  have hm (s : ℝ≥0) : Measurable (B s) := hBm.comp (measurable_const.prodMk measurable_id)
-  have hp := source_path_measurable (sourceDriverPath B hc) hm
-  have hy := source_path_measurable
-    (sourceDriverPath (scaledBrownianDriver c B) (scaledBrownianDriver_continuous c B hc))
-    (scaledBrownianDriver_measurable c B hm)
-  have h := bind_comp_eq_of_path_law P _ _ hy hp
-    (scaledBrownianDriver_path_law c hcp B hB hm hc) (R.process (c^2*t))
-    (R.progressive.adapted.measurable (i:=c^2*t))
-  change P.bind (scaledRawMass R c B hc t)=_ at h
-  rw [h,Measure.bind_congr_right (he.mono (fun _ h => h.1 (c^2*t)))]
-  simpa only [Measure.restrict_univ] using C.uniqueness_process_mean_le (c^2*t) univ
-
-include C hB hc R he c hcp in
-omit [IsProbabilityMeasure P] in
-lemma CanonicalMass.scaledRawTerminal_mean :
-    P.bind (scaledRawTerminal R c B hc)=initialGreenMeasure κ := by
-  have hm (s : ℝ≥0) : Measurable (B s) := hBm.comp (measurable_const.prodMk measurable_id)
-  have hp := source_path_measurable (sourceDriverPath B hc) hm
-  have hy := source_path_measurable
-    (sourceDriverPath (scaledBrownianDriver c B) (scaledBrownianDriver_continuous c B hc))
-    (scaledBrownianDriver_measurable c B hm)
-  have h := bind_comp_eq_of_path_law P _ _ hy hp
-    (scaledBrownianDriver_path_law c hcp B hB hm hc) R.terminal R.terminal_measurable
-  change P.bind (scaledRawTerminal R c B hc)=_ at h
-  rw [h,Measure.bind_congr_right (he.mono (fun _ h => h.2)),C.rational.mean]
-
-include C in
-omit [IsProbabilityMeasure P] in
-lemma CanonicalMass.deterministic_green_kernel (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 C.rational.terminal=(P.restrict E).bind (C.process t)+
-      (P.restrict E).bind (halfPlaneGreenMeasure κ B γ G t) := by
-  let ℱ := Filtration.natural B (fun s =>
-    (hBm.comp (measurable_const.prodMk measurable_id) : Measurable (B s)).stronglyMeasurable)
-  have hs := isStoppingTime_const ℱ t
-  have hEs : MeasurableSet[hs.measurableSpace] E := by
-    change MeasurableSet[(isStoppingTime_const ℱ t).measurableSpace] E
-    rw [IsStoppingTime.measurableSpace_const]
-    exact hE
-  have h := C.kernel (fun _ => (t:WithTop ℝ≥0)) hs E hEs
-  change (P.restrict E).bind C.rational.terminal=(P.restrict E).bind (C.process t)+
-    (P.restrict E).bind (halfPlaneGreenMeasure κ B γ G t) at h
-  exact h
-
-include C hB hc R he c hcp in
-lemma CanonicalMass.scaledRawMass_cross_kernel
-    (F : Ω → ℝ≥0 → ℂ → ℂ)
-    (hw : ∀ ω, IsCapacityTwoWitness (fun t => Real.sqrt κ*B t ω) (γ ω) (G ω) (F ω))
-    (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 (fun ω => dilationMass �� c hcp (C.rational.terminal ω))+
-      (P.restrict E).bind (scaledRawMass R c B hc t)=
-    (P.restrict E).bind (scaledRawTerminal R c B hc)+
-      (P.restrict E).bind (fun ω => dilationMass κ c hcp (C.process t ω)) := by
-  have hm (s : ℝ≥0) : Measurable (B s) := hBm.comp (measurable_const.prodMk measurable_id)
-  have hCm := C.progressive.adapted.measurable (i:=t)
-  have hGm := halfPlaneGreenMeasure_measurable hBm hc κ γ G F hw t
-  have hdm : Measurable (dilationMass κ c hcp) := conformalMass_measurable _ _
-  have hNm := (scaledRawMass_adapted R c hcp B hm hc).measurable (i:=t)
-  have hd := congrArg (dilationMass κ c hcp) (C.deterministic_green_kernel t E hE)
-  change dilationMass κ c hcp ((P.restrict E).bind C.rational.terminal)=
-    conformalMass (halfPlaneDilation c hcp) _
-      ((P.restrict E).bind (C.process t)+(P.restrict E).bind (halfPlaneGreenMeasure κ B γ G t)) at hd
-  rw [conformalMass_add] at hd
-  change dilationMass κ c hcp ((P.restrict E).bind C.rational.terminal)=
-    dilationMass κ c hcp ((P.restrict E).bind (C.process t))+
-      dilationMass κ c hcp ((P.restrict E).bind (halfPlaneGreenMeasure κ B γ G t)) at hd
-  rw [← dilationMass_bind _ _ _ _ _ C.rational.terminal_measurable,
-    ← dilationMass_bind _ _ _ _ _ hCm,← dilationMass_bind _ _ _ _ _ hGm] at hd
-  have hr := C.raw_scaled_green_kernel hB hc F hw R he c hcp t E hE
-  dsimp only at hr
-  simp_rw [canonicalGreenMass_scaled κ B hc γ G F hw c hcp t] at hr
-  change (P.restrict E).bind (scaledRawTerminal R c B hc)=
-    (P.restrict E).bind (fun ω => scaledRawMass R c B hc t ω+
-      dilationMass κ c hcp (halfPlaneGreenMeasure κ B γ G t ω)) at hr
-  have hD : Measurable (fun ω => dilationMass κ c hcp (halfPlaneGreenMeasure κ B γ G t ω)) :=
-    hdm.comp hGm
-  rw [bind_kernel_add _ _ _ hNm hD] at hr
-  rw [hd,hr]
-  ac_rfl
-
-end SLEExactGauge.Multipoint
-
-end
-
-end OAI
+import OAI.Probability.SLE.Mass.RawScaledMassPaths
+import OAI.Probability.SLE.Mass.ScaledGreenMeasure
+import OAI.Probability.SLE.Mass.GreenMassProcessUniqueness
+
+namespace OAI
+
+/-! Mean bounds and equal Green remainders for the physical dilation
+and the canonical functional of the scaled Brownian driver. -/
+
+noncomputable section
+open Set Filter _root_.MeasureTheory _root_.OAI.MeasureTheory ProbabilityTheory
+open scoped Topology NNReal ENNReal
+
+namespace SLEExactGauge.Multipoint
+
+local instance rawScaledMeansMeasurable : MeasurableSpace C(ℝ≥0,ℝ) := borel _
+local instance rawScaledMeansBorel : BorelSpace C(ℝ≥0,ℝ) := ⟨rfl⟩
+
+lemma bind_comp_eq_of_path_law {Ω : Type*} [MeasurableSpace Ω] (P : Measure Ω)
+    (X Y : Ω → C(ℝ≥0,ℝ)) (hX : Measurable X) (hY : Measurable Y)
+    (hXY : P.map X=P.map Y) (N : C(ℝ≥0,ℝ) → Measure upperHalfPlane) (hN : Measurable N) :
+    P.bind (fun ω => N (X ω))=P.bind (fun ω => N (Y ω)) := by
+  calc
+    _ = (P.map X).bind N := by
+      unfold Measure.bind
+      rw [Measure.map_map hN hX]
+      rfl
+    _ = (P.map Y).bind N := by rw [hXY]
+    _ = _ := by
+      unfold Measure.bind
+      rw [Measure.map_map hN hY]
+      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) (hB : IsBrownianReal B P)
+  (hc : ∀ ω, Continuous (fun t => B t ω))
+  (R : RawCanonicalMass)
+  (he : ∀ᵐ ω ∂P, (∀ t, R.process t (sourceDriverPath B hc ω)=C.process t ω) ∧
+    R.terminal (sourceDriverPath B hc ω)=C.rational.terminal ω)
+  (c : ℝ≥0) (hcp : 0 < c)
+
+include C hB hc R he c hcp in
+omit [IsProbabilityMeasure P] in
+lemma CanonicalMass.scaledRawMass_mean_le (t : ℝ≥0) :
+    P.bind (scaledRawMass R c B hc t) ≤ initialGreenMeasure κ := by
+  have hm (s : ℝ≥0) : Measurable (B s) := hBm.comp (measurable_const.prodMk measurable_id)
+  have hp := source_path_measurable (sourceDriverPath B hc) hm
+  have hy := source_path_measurable
+    (sourceDriverPath (scaledBrownianDriver c B) (scaledBrownianDriver_continuous c B hc))
+    (scaledBrownianDriver_measurable c B hm)
+  have h := bind_comp_eq_of_path_law P _ _ hy hp
+    (scaledBrownianDriver_path_law c hcp B hB hm hc) (R.process (c^2*t))
+    (R.progressive.adapted.measurable (i:=c^2*t))
+  change P.bind (scaledRawMass R c B hc t)=_ at h
+  rw [h,Measure.bind_congr_right (he.mono (fun _ h => h.1 (c^2*t)))]
+  simpa only [Measure.restrict_univ] using C.uniqueness_process_mean_le (c^2*t) univ
+
+include C hB hc R he c hcp in
+omit [IsProbabilityMeasure P] in
+lemma CanonicalMass.scaledRawTerminal_mean :
+    P.bind (scaledRawTerminal R c B hc)=initialGreenMeasure κ := by
+  have hm (s : ℝ≥0) : Measurable (B s) := hBm.comp (measurable_const.prodMk measurable_id)
+  have hp := source_path_measurable (sourceDriverPath B hc) hm
+  have hy := source_path_measurable
+    (sourceDriverPath (scaledBrownianDriver c B) (scaledBrownianDriver_continuous c B hc))
+    (scaledBrownianDriver_measurable c B hm)
+  have h := bind_comp_eq_of_path_law P _ _ hy hp
+    (scaledBrownianDriver_path_law c hcp B hB hm hc) R.terminal R.terminal_measurable
+  change P.bind (scaledRawTerminal R c B hc)=_ at h
+  rw [h,Measure.bind_congr_right (he.mono (fun _ h => h.2)),C.rational.mean]
+
+include C in
+omit [IsProbabilityMeasure P] in
+lemma CanonicalMass.deterministic_green_kernel (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 C.rational.terminal=(P.restrict E).bind (C.process t)+
+      (P.restrict E).bind (halfPlaneGreenMeasure κ B γ G t) := by
+  let ℱ := Filtration.natural B (fun s =>
+    (hBm.comp (measurable_const.prodMk measurable_id) : Measurable (B s)).stronglyMeasurable)
+  have hs := isStoppingTime_const ℱ t
+  have hEs : MeasurableSet[hs.measurableSpace] E := by
+    change MeasurableSet[(isStoppingTime_const ℱ t).measurableSpace] E
+    rw [IsStoppingTime.measurableSpace_const]
+    exact hE
+  have h := C.kernel (fun _ => (t:WithTop ℝ≥0)) hs E hEs
+  change (P.restrict E).bind C.rational.terminal=(P.restrict E).bind (C.process t)+
+    (P.restrict E).bind (halfPlaneGreenMeasure κ B γ G t) at h
+  exact h
+
+include C hB hc R he c hcp in
+lemma CanonicalMass.scaledRawMass_cross_kernel
+    (F : Ω → ℝ≥0 → ℂ → ℂ)
+    (hw : ∀ ω, IsCapacityTwoWitness (fun t => Real.sqrt κ*B t ω) (γ ω) (G ω) (F ω))
+    (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 (fun ω => dilationMass κ c hcp (C.rational.terminal ω))+
+      (P.restrict E).bind (scaledRawMass R c B hc t)=
+    (P.restrict E).bind (scaledRawTerminal R c B hc)+
+      (P.restrict E).bind (fun ω => dilationMass κ c hcp (C.process t ω)) := by
+  have hm (s : ℝ≥0) : Measurable (B s) := hBm.comp (measurable_const.prodMk measurable_id)
+  have hCm := C.progressive.adapted.measurable (i:=t)
+  have hGm := halfPlaneGreenMeasure_measurable hBm hc κ γ G F hw t
+  have hdm : Measurable (dilationMass κ c hcp) := conformalMass_measurable _ _
+  have hNm := (scaledRawMass_adapted R c hcp B hm hc).measurable (i:=t)
+  have hd := congrArg (dilationMass κ c hcp) (C.deterministic_green_kernel t E hE)
+  change dilationMass κ c hcp ((P.restrict E).bind C.rational.terminal)=
+    conformalMass (halfPlaneDilation c hcp) _
+      ((P.restrict E).bind (C.process t)+(P.restrict E).bind (halfPlaneGreenMeasure κ B γ G t)) at hd
+  rw [conformalMass_add] at hd
+  change dilationMass κ c hcp ((P.restrict E).bind C.rational.terminal)=
+    dilationMass κ c hcp ((P.restrict E).bind (C.process t))+
+      dilationMass κ c hcp ((P.restrict E).bind (halfPlaneGreenMeasure κ B γ G t)) at hd
+  rw [← dilationMass_bind _ _ _ _ _ C.rational.terminal_measurable,
+    ← dilationMass_bind _ _ _ _ _ hCm,← dilationMass_bind _ _ _ _ _ hGm] at hd
+  have hr := C.raw_scaled_green_kernel hB hc F hw R he c hcp t E hE
+  dsimp only at hr
+  simp_rw [canonicalGreenMass_scaled κ B hc γ G F hw c hcp t] at hr
+  change (P.restrict E).bind (scaledRawTerminal R c B hc)=
+    (P.restrict E).bind (fun ω => scaledRawMass R c B hc t ω+
+      dilationMass κ c hcp (halfPlaneGreenMeasure κ B γ G t ω)) at hr
+  have hD : Measurable (fun ω => dilationMass κ c hcp (halfPlaneGreenMeasure κ B γ G t ω)) :=
+    hdm.comp hGm
+  rw [bind_kernel_add _ _ _ hNm hD] at hr
+  rw [hd,hr]
+  ac_rfl
+
+end SLEExactGauge.Multipoint
+
+end
+
+end OAI

lean/OAI/Probability/SLE/Mass/RawScaledMassPaths.lean

@@ -1,109 +1,109 @@
-import OAI.Probability.SLE.Loewner.RawScaledGreenKernel
-import OAI.Probability.SLE.Loewner.RawTerminalExhaustion
-import OAI.Probability.SLE.Loewner.StoppedInversePaths
-
-namespace OAI
-
-/-! One raw canonical functional has a measurable full-law certificate
-for continuous positive mass paths. Brownian scaling preserves it. -/
-
-noncomputable section
-open Set Filter _root_.MeasureTheory _root_.OAI.MeasureTheory ProbabilityTheory
-open scoped Topology NNReal ENNReal CompactlySupported
-
-namespace SLEExactGauge.Multipoint
-
-local instance rawScaledMassMeasurable : MeasurableSpace C(ℝ≥0,ℝ) := borel _
-local instance rawScaledMassBorel : BorelSpace C(ℝ≥0,ℝ) := ⟨rfl⟩
-local instance rawScaledMassLocallyCompact : LocallyCompactSpace upperHalfPlane :=
-  isOpen_upperHalfPlane.locallyCompactSpace
-
-variable {Ω : Type*} [mΩ : MeasurableSpace Ω] {P : Measure Ω} [IsProbabilityMeasure P]
-  {κ : ℝ} {B : ℝ≥0 → Ω → ℝ} {hBm : Measurable (Function.uncurry B)}
-  {γ : Ω → ℝ≥0 → ℂ} {G : Ω → ℝ≥0 → ℂ → ℂ}
-
-omit [IsProbabilityMeasure P] in
-lemma CanonicalMass.exists_raw_positive_paths (C : CanonicalMass P κ B hBm γ G)
-    (hc : ∀ ω, Continuous (fun t => B t ω)) :
-    ∃ R : RawCanonicalMass,
-      (∀ᵐ ω ∂P, (∀ t, R.process t (sourceDriverPath B hc ω)=C.process t ω) ∧
-        R.terminal (sourceDriverPath B hc ω)=C.rational.terminal ω) ∧
-      ∃ E : Set C(ℝ≥0,ℝ), MeasurableSet E ∧
-        (∀ᵐ p ∂P.map (sourceDriverPath B hc), p ∈ E) ∧
-        ∀ p ∈ E, PositiveMassPaths (fun t => R.process t p) (R.terminal p) := by
-  obtain ⟨N,E,hNp,hNr,hNn,hEm,hEf,hEp,he⟩ := C.exists_raw_nonanticipating_with_good_set hc
-  let R : RawCanonicalMass := ⟨N,rawTerminalMass N,hNp,hNr,
-    rawTerminalMass_measurable N hNp hNr,rawTerminalMass_radon N,hNn⟩
-  obtain ⟨hTm,hTf,hTp⟩ := C.raw_terminal_good_set hc N hNp hNr he
-  refine ⟨R,?_,E ∩ {p | RawTerminalGood (localTestFamily upperHalfPlane)
-    (fun t => N t p) (rawTerminalMass N p)},hEm.inter hTm,?_,?_⟩
-  · filter_upwards [he,C.rawTerminal_realizes hc N he] with ω hω ht
-    exact ⟨hω,ht⟩
-  · exact hEf.and hTf
-  · intro p hp
-    obtain ⟨hz,hm,hcont⟩ := hEp p hp.1
-    exact ⟨hz,hm,(hTp p hp.2 hm).1,(fun t => hNr t p),fun f _ => hcont f⟩
-
-def scaledRawMass (R : RawCanonicalMass) (c : ℝ≥0)
-    (B : ℝ≥0 → Ω → ℝ) (hc : ∀ ω, Continuous (fun t => B t ω))
-    (t : ℝ≥0) (ω : Ω) : Measure upperHalfPlane :=
-  R.process (c^2*t) (sourceDriverPath (scaledBrownianDriver c B)
-    (scaledBrownianDriver_continuous c B hc) ω)
-
-def scaledRawTerminal (R : RawCanonicalMass) (c : ℝ≥0)
-    (B : ℝ≥0 → Ω → ℝ) (hc : ∀ ω, Continuous (fun t => B t ω))
-    (ω : Ω) : Measure upperHalfPlane :=
-  R.terminal (sourceDriverPath (scaledBrownianDriver c B)
-    (scaledBrownianDriver_continuous c B hc) ω)
-
-lemma scaledRawMass_adapted (R : RawCanonicalMass) (c : ℝ≥0) (hcp : 0 < c)
-    (B : ℝ≥0 → Ω → ℝ) (hm : ∀ t, Measurable (B t))
-    (hc : ∀ ω, Continuous (fun t => B t ω)) :
-    Adapted (Filtration.natural B (fun s => (hm s).stronglyMeasurable)) (scaledRawMass R c B hc) := by
-  let ℱc := Filtration.natural (scaledBrownianDriver c B)
-    (fun s => (scaledBrownianDriver_measurable c B hm s).stronglyMeasurable)
-  let Y := sourceDriverPath (scaledBrownianDriver c B) (scaledBrownianDriver_continuous c B hc)
-  have hY : Adapted ℱc (fun t ω => Y ω t) := fun t =>
-    (Filtration.stronglyAdapted_natural
-      (fun s => (scaledBrownianDriver_measurable c B hm s).stronglyMeasurable) t).measurable
-  have hp := (raw_process_comp_progressive ℱc Y hY R.process R.progressive).adapted
-  intro t
-  have h := hp (c^2*t)
-  change Measurable[ℱc (c^2*t)] (scaledRawMass R c B hc t) at h
-  rwa [show ℱc (c^2*t)=(Filtration.natural B (fun s => (hm s).stronglyMeasurable)) t from
-    scaledBrownianDriver_filtration c hcp B hm t] at h
-
-omit [IsProbabilityMeasure P] in
-lemma scaledRawMass_positive_paths
-    (R : RawCanonicalMass) (E : Set C(ℝ≥0,ℝ)) (hE : MeasurableSet E)
-    (B : ℝ≥0 → Ω → ℝ) (hB : IsBrownianReal B P)
-    (hm : ∀ t, Measurable (B t)) (hc : ∀ ω, Continuous (fun t => B t ω))
-    (hEf : ∀ᵐ p ∂P.map (sourceDriverPath B hc), p ∈ E)
-    (hEp : ∀ p ∈ E, PositiveMassPaths (fun t => R.process t p) (R.terminal p))
-    (c : ℝ≥0) (hcp : 0 < c) :
-    ∀ᵐ ω ∂P, PositiveMassPaths (fun t => scaledRawMass R c B hc t ω)
-      (scaledRawTerminal R c B hc ω) := by
-  have hY := source_path_measurable
-    (sourceDriverPath (scaledBrownianDriver c B) (scaledBrownianDriver_continuous c B hc))
-    (scaledBrownianDriver_measurable c B hm)
-  have hf : ∀ᵐ p ∂P.map (sourceDriverPath (scaledBrownianDriver c B)
-      (scaledBrownianDriver_continuous c B hc)), p ∈ E := by
-    rwa [scaledBrownianDriver_path_law c hcp B hB hm hc]
-  filter_upwards [(ae_map_iff hY.aemeasurable hE).mp hf] with ω hω
-  have hp := hEp _ hω
-  refine ⟨?_,?_,?_,?_,?_⟩
-  · simpa only [scaledRawMass,mul_zero] using hp.zero
-  · intro s t hst
-    exact hp.monotone (mul_le_mul_of_nonneg_left hst zero_le)
-  · intro t
-    exact hp.dominated (c^2*t)
-  · intro t
-    exact hp.radon (c^2*t)
-  · intro f hfp
-    exact (hp.continuous_tests f hfp).comp (continuous_const.mul continuous_id)
-
-end SLEExactGauge.Multipoint
-
-end
-
-end OAI
+import OAI.Probability.SLE.Loewner.RawScaledGreenKernel
+import OAI.Probability.SLE.Loewner.RawTerminalExhaustion
+import OAI.Probability.SLE.Loewner.StoppedInversePaths
+
+namespace OAI
+
+/-! One raw canonical functional has a measurable full-law certificate
+for continuous positive mass paths. Brownian scaling preserves it. -/
+
+noncomputable section
+open Set Filter _root_.MeasureTheory _root_.OAI.MeasureTheory ProbabilityTheory
+open scoped Topology NNReal ENNReal CompactlySupported
+
+namespace SLEExactGauge.Multipoint
+
+local instance rawScaledMassMeasurable : MeasurableSpace C(ℝ≥0,ℝ) := borel _
+local instance rawScaledMassBorel : BorelSpace C(ℝ≥0,ℝ) := ⟨rfl⟩
+local instance rawScaledMassLocallyCompact : LocallyCompactSpace upperHalfPlane :=
+  isOpen_upperHalfPlane.locallyCompactSpace
+
+variable {Ω : Type*} [mΩ : MeasurableSpace Ω] {P : Measure Ω} [IsProbabilityMeasure P]
+  {κ : ℝ} {B : ℝ≥0 → Ω → ℝ} {hBm : Measurable (Function.uncurry B)}
+  {γ : Ω → ℝ≥0 → ℂ} {G : Ω → ℝ≥0 → ℂ → ℂ}
+
+omit [IsProbabilityMeasure P] in
+lemma CanonicalMass.exists_raw_positive_paths (C : CanonicalMass P κ B hBm γ G)
+    (hc : ∀ ω, Continuous (fun t => B t ω)) :
+    ∃ R : RawCanonicalMass,
+      (∀ᵐ ω ∂P, (∀ t, R.process t (sourceDriverPath B hc ω)=C.process t ω) ∧
+        R.terminal (sourceDriverPath B hc ω)=C.rational.terminal ω) ∧
+      ∃ E : Set C(ℝ≥0,ℝ), MeasurableSet E ∧
+        (∀ᵐ p ∂P.map (sourceDriverPath B hc), p ∈ E) ∧
+        ∀ p ∈ E, PositiveMassPaths (fun t => R.process t p) (R.terminal p) := by
+  obtain ⟨N,E,hNp,hNr,hNn,hEm,hEf,hEp,he⟩ := C.exists_raw_nonanticipating_with_good_set hc
+  let R : RawCanonicalMass := ⟨N,rawTerminalMass N,hNp,hNr,
+    rawTerminalMass_measurable N hNp hNr,rawTerminalMass_radon N,hNn⟩
+  obtain ⟨hTm,hTf,hTp⟩ := C.raw_terminal_good_set hc N hNp hNr he
+  refine ⟨R,?_,E ∩ {p | RawTerminalGood (localTestFamily upperHalfPlane)
+    (fun t => N t p) (rawTerminalMass N p)},hEm.inter hTm,?_,?_⟩
+  · filter_upwards [he,C.rawTerminal_realizes hc N he] with ω hω ht
+    exact ⟨hω,ht⟩
+  · exact hEf.and hTf
+  · intro p hp
+    obtain ⟨hz,hm,hcont⟩ := hEp p hp.1
+    exact ⟨hz,hm,(hTp p hp.2 hm).1,(fun t => hNr t p),fun f _ => hcont f⟩
+
+def scaledRawMass (R : RawCanonicalMass) (c : ℝ≥0)
+    (B : ℝ≥0 → Ω → ℝ) (hc : ∀ ω, Continuous (fun t => B t ω))
+    (t : ℝ≥0) (ω : Ω) : Measure upperHalfPlane :=
+  R.process (c^2*t) (sourceDriverPath (scaledBrownianDriver c B)
+    (scaledBrownianDriver_continuous c B hc) ω)
+
+def scaledRawTerminal (R : RawCanonicalMass) (c : ℝ≥0)
+    (B : ℝ≥0 → Ω → ℝ) (hc : ∀ ω, Continuous (fun t => B t ω))
+    (ω : Ω) : Measure upperHalfPlane :=
+  R.terminal (sourceDriverPath (scaledBrownianDriver c B)
+    (scaledBrownianDriver_continuous c B hc) ω)
+
+lemma scaledRawMass_adapted (R : RawCanonicalMass) (c : ℝ≥0) (hcp : 0 < c)
+    (B : ℝ≥0 → Ω → ℝ) (hm : ∀ t, Measurable (B t))
+    (hc : ∀ ω, Continuous (fun t => B t ω)) :
+    Adapted (Filtration.natural B (fun s => (hm s).stronglyMeasurable)) (scaledRawMass R c B hc) := by
+  let ℱc := Filtration.natural (scaledBrownianDriver c B)
+    (fun s => (scaledBrownianDriver_measurable c B hm s).stronglyMeasurable)
+  let Y := sourceDriverPath (scaledBrownianDriver c B) (scaledBrownianDriver_continuous c B hc)
+  have hY : Adapted ℱc (fun t ω => Y ω t) := fun t =>
+    (Filtration.stronglyAdapted_natural
+      (fun s => (scaledBrownianDriver_measurable c B hm s).stronglyMeasurable) t).measurable
+  have hp := (raw_process_comp_progressive ℱc Y hY R.process R.progressive).adapted
+  intro t
+  have h := hp (c^2*t)
+  change Measurable[ℱc (c^2*t)] (scaledRawMass R c B hc t) at h
+  rwa [show ℱc (c^2*t)=(Filtration.natural B (fun s => (hm s).stronglyMeasurable)) t from
+    scaledBrownianDriver_filtration c hcp B hm t] at h
+
+omit [IsProbabilityMeasure P] in
+lemma scaledRawMass_positive_paths
+    (R : RawCanonicalMass) (E : Set C(ℝ≥0,ℝ)) (hE : MeasurableSet E)
+    (B : ℝ≥0 → Ω → ℝ) (hB : IsBrownianReal B P)
+    (hm : ∀ t, Measurable (B t)) (hc : ∀ ω, Continuous (fun t => B t ω))
+    (hEf : ∀ᵐ p ∂P.map (sourceDriverPath B hc), p ∈ E)
+    (hEp : ∀ p ∈ E, PositiveMassPaths (fun t => R.process t p) (R.terminal p))
+    (c : ℝ≥0) (hcp : 0 < c) :
+    ∀ᵐ ω ∂P, PositiveMassPaths (fun t => scaledRawMass R c B hc t ω)
+      (scaledRawTerminal R c B hc ω) := by
+  have hY := source_path_measurable
+    (sourceDriverPath (scaledBrownianDriver c B) (scaledBrownianDriver_continuous c B hc))
+    (scaledBrownianDriver_measurable c B hm)
+  have hf : ∀ᵐ p ∂P.map (sourceDriverPath (scaledBrownianDriver c B)
+      (scaledBrownianDriver_continuous c B hc)), p ∈ E := by
+    rwa [scaledBrownianDriver_path_law c hcp B hB hm hc]
+  filter_upwards [(ae_map_iff hY.aemeasurable hE).mp hf] with ω hω
+  have hp := hEp _ hω
+  refine ⟨?_,?_,?_,?_,?_⟩
+  · simpa only [scaledRawMass,mul_zero] using hp.zero
+  · intro s t hst
+    exact hp.monotone (mul_le_mul_of_nonneg_left hst zero_le)
+  · intro t
+    exact hp.dominated (c^2*t)
+  · intro t
+    exact hp.radon (c^2*t)
+  · intro f hfp
+    exact (hp.continuous_tests f hfp).comp (continuous_const.mul continuous_id)
+
+end SLEExactGauge.Multipoint
+
+end
+
+end OAI

lean/OAI/Probability/SLE/Mass/RestartMassCoordinates.lean

@@ -1,87 +1,87 @@
-import OAI.Probability.SLE.Mass.ConformalMassTransport
-import OAI.Probability.SLE.Geometry.RestartConformalRadius
-
-namespace OAI
-
-/-! The actual centered inverse Loewner map and its mass weight.
-These are defined only on interior points; no boundary extension is used. -/
-
-noncomputable section
-open Set Filter _root_.MeasureTheory _root_.OAI.MeasureTheory Classical
-open scoped NNReal ENNReal Topology CompactlySupported
-
-namespace SLEExactGauge
-
-def IsCapacityTwoWitness.restartHomeomorph
-    {U : ℝ≥0 → ℝ} {γ : ℝ≥0 → ℂ} {G F : ℝ≥0 → ℂ → ℂ}
-    (hw : IsCapacityTwoWitness U γ G F) (T : ℝ≥0) :
-    upperHalfPlane ≃ₜ survivingDomain γ T := by
-  rcases hw with ⟨hc,_,_,hG,hF,hGM,hFM,hFG,hGF,_,_,_,_⟩
-  have hshift (z : upperHalfPlane) : (z:ℂ)+(U T:ℂ) ∈ upperHalfPlane := by
-    simpa only [upperHalfPlane,mem_ofPred_eq,Complex.add_im,Complex.ofReal_im,add_zero]
-      using z.property
-  have hback (z : survivingDomain γ T) : G T z-(U T:ℂ) ∈ upperHalfPlane := by
-    simpa only [upperHalfPlane,mem_ofPred_eq,Complex.sub_im,Complex.ofReal_im,sub_zero]
-      using hGM T z.property
-  refine {
-    toFun := fun z => ⟨F T ((z:ℂ)+(U T:ℂ)),hFM T (hshift z)⟩
-    invFun := fun z => ⟨G T z-(U T:ℂ),hback z⟩
-    left_inv := ?_
-    right_inv := ?_
-    continuous_toFun := ?_
-    continuous_invFun := ?_ }
-  · intro z
-    apply Subtype.ext
-    exact (congrArg (fun v : ℂ => v-(U T:ℂ)) (hGF T _ (hshift z))).trans
-      (add_sub_cancel_right _ _)
-  · intro z
-    apply Subtype.ext
-    change F T ((G T z-(U T:ℂ))+(U T:ℂ)) = z
-    rw [sub_add_cancel,hFG T _ z.property]
-  · exact ((hF T).continuousOn.comp_continuous
-      (continuous_subtype_val.add continuous_const) hshift).subtype_mk _
-  · exact (((hG T).continuousOn.comp_continuous continuous_subtype_val
-      (fun z => z.property)).sub continuous_const).subtype_mk _
-
-@[simp] lemma IsCapacityTwoWitness.restartHomeomorph_apply
-    {U : ℝ≥0 → ℝ} {γ : ℝ≥0 → ℂ} {G F : ℝ≥0 → ℂ → ℂ}
-    (hw : IsCapacityTwoWitness U γ G F) (T : ℝ≥0) (z : upperHalfPlane) :
-    ((hw.restartHomeomorph T z : survivingDomain γ T):ℂ) = F T ((z:ℂ)+(U T:ℂ)) := by
-  rcases hw with ⟨hc,h0,hi,hG,hF,hGM,hFM,hFG,hGF,hG0,hode,hn,ht⟩
-  rfl
-
-def IsCapacityTwoWitness.restartMassWeight
-    {U : ℝ≥0 → ℝ} {γ : ℝ≥0 → ℂ} {G F : ℝ≥0 → ℂ → ℂ}
-    (hw : IsCapacityTwoWitness U γ G F) (T : ℝ≥0) (κ : ℝ) (hκ : 0 < κ) :
-    C(upperHalfPlane, ℝ≥0) where
-  toFun z := ⟨‖deriv (F T) ((z:ℂ)+(U T:ℂ))‖ ^ (1+κ/8),Real.rpow_nonneg (norm_nonneg _) _⟩
-  continuous_toFun := by
-    have hshift (z : upperHalfPlane) : (z:ℂ)+(U T:ℂ) ∈ upperHalfPlane := by
-      simpa only [upperHalfPlane,mem_ofPred_eq,Complex.add_im,Complex.ofReal_im,add_zero]
-        using z.property
-    have hd := (hw.2.2.2.2.1 T).deriv isOpen_upperHalfPlane
-    have hc := hd.continuousOn.comp_continuous
-      (continuous_subtype_val.add continuous_const) hshift
-    exact ((Real.continuous_rpow_const (by linarith : 0 ≤ 1+κ/8)).comp hc.norm).subtype_mk _
-
-def IsCapacityTwoWitness.restartMass
-    {U : ℝ≥0 → ℝ} {γ : ℝ≥0 → ℂ} {G F : ℝ≥0 → ℂ → ℂ}
-    (hw : IsCapacityTwoWitness U γ G F) (T : ℝ≥0) (κ : ℝ) (hκ : 0 < κ)
-    (μ : Measure upperHalfPlane) : Measure (survivingDomain γ T) :=
-  Multipoint.conformalMass (hw.restartHomeomorph T) (hw.restartMassWeight T κ hκ) μ
-
-lemma IsCapacityTwoWitness.restartMass_integral
-    {U : ℝ≥0 → ℝ} {γ : ℝ≥0 → ℂ} {G F : ℝ≥0 → ℂ → ℂ}
-    (hw : IsCapacityTwoWitness U γ G F) (T : ℝ≥0) (κ : ℝ) (hκ : 0 < κ)
-    (μ : Measure upperHalfPlane) (f : C_c(survivingDomain γ T, ℝ)) :
-    (∫ z, f z ∂hw.restartMass T κ hκ μ) =
-      ∫ z : upperHalfPlane, ‖deriv (F T) ((z:ℂ)+(U T:ℂ))‖ ^ (1+κ/8) *
-        f (hw.restartHomeomorph T z) ∂μ :=
-  Multipoint.conformalMass_integral (hw.restartHomeomorph T)
-    (hw.restartMassWeight T κ hκ) μ f
-
-end SLEExactGauge
-
-end
-
-end OAI
+import OAI.Probability.SLE.Mass.ConformalMassTransport
+import OAI.Probability.SLE.Geometry.RestartConformalRadius
+
+namespace OAI
+
+/-! The actual centered inverse Loewner map and its mass weight.
+These are defined only on interior points; no boundary extension is used. -/
+
+noncomputable section
+open Set Filter _root_.MeasureTheory _root_.OAI.MeasureTheory Classical
+open scoped NNReal ENNReal Topology CompactlySupported
+
+namespace SLEExactGauge
+
+def IsCapacityTwoWitness.restartHomeomorph
+    {U : ℝ≥0 → ℝ} {γ : ℝ≥0 → ℂ} {G F : ℝ≥0 → ℂ → ℂ}
+    (hw : IsCapacityTwoWitness U γ G F) (T : ℝ≥0) :
+    upperHalfPlane ≃ₜ survivingDomain γ T := by
+  rcases hw with ⟨hc,_,_,hG,hF,hGM,hFM,hFG,hGF,_,_,_,_⟩
+  have hshift (z : upperHalfPlane) : (z:ℂ)+(U T:ℂ) ∈ upperHalfPlane := by
+    simpa only [upperHalfPlane,mem_ofPred_eq,Complex.add_im,Complex.ofReal_im,add_zero]
+      using z.property
+  have hback (z : survivingDomain γ T) : G T z-(U T:ℂ) ∈ upperHalfPlane := by
+    simpa only [upperHalfPlane,mem_ofPred_eq,Complex.sub_im,Complex.ofReal_im,sub_zero]
+      using hGM T z.property
+  refine {
+    toFun := fun z => ⟨F T ((z:ℂ)+(U T:ℂ)),hFM T (hshift z)⟩
+    invFun := fun z => ⟨G T z-(U T:ℂ),hback z⟩
+    left_inv := ?_
+    right_inv := ?_
+    continuous_toFun := ?_
+    continuous_invFun := ?_ }
+  · intro z
+    apply Subtype.ext
+    exact (congrArg (fun v : ℂ => v-(U T:ℂ)) (hGF T _ (hshift z))).trans
+      (add_sub_cancel_right _ _)
+  · intro z
+    apply Subtype.ext
+    change F T ((G T z-(U T:ℂ))+(U T:ℂ)) = z
+    rw [sub_add_cancel,hFG T _ z.property]
+  · exact ((hF T).continuousOn.comp_continuous
+      (continuous_subtype_val.add continuous_const) hshift).subtype_mk _
+  · exact (((hG T).continuousOn.comp_continuous continuous_subtype_val
+      (fun z => z.property)).sub continuous_const).subtype_mk _
+
+@[simp] lemma IsCapacityTwoWitness.restartHomeomorph_apply
+    {U : ℝ≥0 → ℝ} {γ : ℝ≥0 → ℂ} {G F : ℝ≥0 → ℂ → ℂ}
+    (hw : IsCapacityTwoWitness U γ G F) (T : ℝ≥0) (z : upperHalfPlane) :
+    ((hw.restartHomeomorph T z : survivingDomain γ T):ℂ) = F T ((z:ℂ)+(U T:ℂ)) := by
+  rcases hw with ⟨hc,h0,hi,hG,hF,hGM,hFM,hFG,hGF,hG0,hode,hn,ht⟩
+  rfl
+
+def IsCapacityTwoWitness.restartMassWeight
+    {U : ℝ≥0 → ℝ} {γ : ℝ≥0 → ℂ} {G F : ℝ≥0 → ℂ → ℂ}
+    (hw : IsCapacityTwoWitness U γ G F) (T : ℝ≥0) (κ : ℝ) (hκ : 0 < κ) :
+    C(upperHalfPlane, ℝ≥0) where
+  toFun z := ⟨‖deriv (F T) ((z:ℂ)+(U T:ℂ))‖ ^ (1+κ/8),Real.rpow_nonneg (norm_nonneg _) _⟩
+  continuous_toFun := by
+    have hshift (z : upperHalfPlane) : (z:ℂ)+(U T:ℂ) ∈ upperHalfPlane := by
+      simpa only [upperHalfPlane,mem_ofPred_eq,Complex.add_im,Complex.ofReal_im,add_zero]
+        using z.property
+    have hd := (hw.2.2.2.2.1 T).deriv isOpen_upperHalfPlane
+    have hc := hd.continuousOn.comp_continuous
+      (continuous_subtype_val.add continuous_const) hshift
+    exact ((Real.continuous_rpow_const (by linarith : 0 ≤ 1+κ/8)).comp hc.norm).subtype_mk _
+
+def IsCapacityTwoWitness.restartMass
+    {U : ℝ≥0 → ℝ} {γ : ℝ≥0 → ℂ} {G F : ℝ≥0 → ℂ → ℂ}
+    (hw : IsCapacityTwoWitness U γ G F) (T : ℝ≥0) (κ : ℝ) (hκ : 0 < κ)
+    (μ : Measure upperHalfPlane) : Measure (survivingDomain γ T) :=
+  Multipoint.conformalMass (hw.restartHomeomorph T) (hw.restartMassWeight T κ hκ) μ
+
+lemma IsCapacityTwoWitness.restartMass_integral
+    {U : ℝ≥0 → ℝ} {γ : ℝ≥0 → ℂ} {G F : ℝ≥0 → ℂ → ℂ}
+    (hw : IsCapacityTwoWitness U γ G F) (T : ℝ≥0) (κ : ℝ) (hκ : 0 < κ)
+    (μ : Measure upperHalfPlane) (f : C_c(survivingDomain γ T, ℝ)) :
+    (∫ z, f z ∂hw.restartMass T κ hκ μ) =
+      ∫ z : upperHalfPlane, ‖deriv (F T) ((z:ℂ)+(U T:ℂ))‖ ^ (1+κ/8) *
+        f (hw.restartHomeomorph T z) ∂μ :=
+  Multipoint.conformalMass_integral (hw.restartHomeomorph T)
+    (hw.restartMassWeight T κ hκ) μ f
+
+end SLEExactGauge
+
+end
+
+end OAI

lean/OAI/Probability/SLE/Mass/RestartRandomMassTesting.lean

@@ -1,55 +1,55 @@
-import OAI.Probability.SLE.Mass.RadonRandomTesting
-import OAI.Probability.SLE.Geometry.RandomRestartEvents
-
-namespace OAI
-
-/-! The fresh-driver law may be tested against a random spatial weight
-measurable in the stopped past. This is the conditional-Tonelli step for
-the restart candidate, before invoking uniqueness. -/
-
-noncomputable section
-open Set Filter MeasureTheory ProbabilityTheory Classical
-open scoped ENNReal
-
-namespace SLEExactGauge
-
-lemma fresh_mass_test_joint_measurable
-    {Ω X : Type*} [MeasurableSpace Ω] [MeasurableSpace X]
-    (M : X → Measure upperHalfPlane) (hM : Measurable M)
-    (hMf : ∀ x, IsFiniteMeasureOnCompacts (M x))
-    (f : Ω × upperHalfPlane → ℝ≥0∞) (hf : Measurable f) :
-    Measurable (fun p : Ω × X => ∫⁻ z, f (p.1,z) ∂M p.2) := by
-  exact halfPlane_random_test_measurable (fun p : Ω × X => M p.2)
-    (hM.comp measurable_snd) (fun p => hMf p.2)
-    (fun p : (Ω × X) × upperHalfPlane => f (p.1.1,p.2))
-    (hf.comp (measurable_fst.fst.prodMk measurable_snd))
-
-theorem restart_random_mass_test
-    {Ω X : Type*} [mΩ : MeasurableSpace Ω] [mX : MeasurableSpace X]
-    (P : Measure Ω) [IsFiniteMeasure P] (ν : Measure X) [IsFiniteMeasure ν]
-    (m : MeasurableSpace Ω) (hm : m ≤ mΩ)
-    (Y : Ω → X) (hY : Measurable[mΩ] Y)
-    (hlaw : ∀ A : Set Ω, MeasurableSet[m] A →
-      @Measure.map Ω X mΩ mX Y (P.restrict A) = P A • ν)
-    (M : X → Measure upperHalfPlane) (hM : Measurable M)
-    (hMf : ∀ x, IsFiniteMeasureOnCompacts (M x))
-    (f : Ω × upperHalfPlane → ℝ≥0∞)
-    (hf : Measurable[m.prod inferInstance] f) :
-    (∫⁻ ω, ∫⁻ z, f (ω,z) ∂M (Y ω) ∂P) =
-      ∫⁻ ω, ∫⁻ z, f (ω,z) ∂ν.bind M ∂P := by
-  let : MeasurableSpace Ω := mΩ
-  have hg : Measurable[m.prod mX]
-      (fun p : Ω × X => ∫⁻ z, f (p.1,z) ∂M p.2) :=
-    @fresh_mass_test_joint_measurable Ω X m mX M hM hMf f hf
-  rw [@restart_lintegral_random_test Ω X mΩ mX P inferInstance ν inferInstance
-    m hm Y hY hlaw _ hg]
-  apply lintegral_congr
-  intro ω
-  exact (Measure.lintegral_bind hM.aemeasurable
-    (hf.comp (measurable_const.prodMk measurable_id)).aemeasurable).symm
-
-end SLEExactGauge
-
-end
-
-end OAI
+import OAI.Probability.SLE.Mass.RadonRandomTesting
+import OAI.Probability.SLE.Geometry.RandomRestartEvents
+
+namespace OAI
+
+/-! The fresh-driver law may be tested against a random spatial weight
+measurable in the stopped past. This is the conditional-Tonelli step for
+the restart candidate, before invoking uniqueness. -/
+
+noncomputable section
+open Set Filter MeasureTheory ProbabilityTheory Classical
+open scoped ENNReal
+
+namespace SLEExactGauge
+
+lemma fresh_mass_test_joint_measurable
+    {Ω X : Type*} [MeasurableSpace Ω] [MeasurableSpace X]
+    (M : X → Measure upperHalfPlane) (hM : Measurable M)
+    (hMf : ∀ x, IsFiniteMeasureOnCompacts (M x))
+    (f : Ω × upperHalfPlane → ℝ≥0∞) (hf : Measurable f) :
+    Measurable (fun p : Ω × X => ∫⁻ z, f (p.1,z) ∂M p.2) := by
+  exact halfPlane_random_test_measurable (fun p : Ω × X => M p.2)
+    (hM.comp measurable_snd) (fun p => hMf p.2)
+    (fun p : (Ω × X) × upperHalfPlane => f (p.1.1,p.2))
+    (hf.comp (measurable_fst.fst.prodMk measurable_snd))
+
+theorem restart_random_mass_test
+    {Ω X : Type*} [mΩ : MeasurableSpace Ω] [mX : MeasurableSpace X]
+    (P : Measure Ω) [IsFiniteMeasure P] (ν : Measure X) [IsFiniteMeasure ν]
+    (m : MeasurableSpace Ω) (hm : m ≤ mΩ)
+    (Y : Ω → X) (hY : Measurable[mΩ] Y)
+    (hlaw : ∀ A : Set Ω, MeasurableSet[m] A →
+      @Measure.map Ω X mΩ mX Y (P.restrict A) = P A • ν)
+    (M : X → Measure upperHalfPlane) (hM : Measurable M)
+    (hMf : ∀ x, IsFiniteMeasureOnCompacts (M x))
+    (f : Ω × upperHalfPlane → ℝ≥0∞)
+    (hf : Measurable[m.prod inferInstance] f) :
+    (∫⁻ ω, ∫⁻ z, f (ω,z) ∂M (Y ω) ∂P) =
+      ∫⁻ ω, ∫⁻ z, f (ω,z) ∂ν.bind M ∂P := by
+  let : MeasurableSpace Ω := mΩ
+  have hg : Measurable[m.prod mX]
+      (fun p : Ω × X => ∫⁻ z, f (p.1,z) ∂M p.2) :=
+    @fresh_mass_test_joint_measurable Ω X m mX M hM hMf f hf
+  rw [@restart_lintegral_random_test Ω X mΩ mX P inferInstance ν inferInstance
+    m hm Y hY hlaw _ hg]
+  apply lintegral_congr
+  intro ω
+  exact (Measure.lintegral_bind hM.aemeasurable
+    (hf.comp (measurable_const.prodMk measurable_id)).aemeasurable).symm
+
+end SLEExactGauge
+
+end
+
+end OAI

lean/OAI/Probability/SLE/Mass/RestartStoppedMass.lean

@@ -1,93 +1,93 @@
-import OAI.Probability.SLE.Geometry.NormalizedRestartKernel
-import OAI.Probability.SLE.Gauge.ConformalDenseExperiment
-
-namespace OAI
-
-/-! A dense mass generated by the normalized fresh trace is present in the
-original stopped trace at the corresponding physical radius level. -/
-
-noncomputable section
-open Set Filter Metric MeasureTheory
-open scoped Topology NNReal ENNReal
-
-namespace SLEExactGauge
-open FrontSuccessMeasurability
-
-lemma segmentSausageCharge_clock_le
-    (κ : ℝ) (γ η : C(ℝ≥0, ℂ)) (T c σ : ℝ≥0)
-    (hpath : ∀ t, η t = γ (T + c * t)) (v : ℝ) (D : Set ℂ) :
-    segmentSausageCharge κ η 0 σ v D ≤ segmentSausageCharge κ γ 0 (T + c * σ) v D := by
-  apply mul_le_mul' le_rfl
-  apply measure_mono
-  rintro z ⟨hz, t, ht, hdist⟩
-  refine ⟨hz, T + c * t, ⟨bot_le,
-    add_le_add le_rfl (mul_le_mul_of_nonneg_left ht.2 (show 0 ≤ c from bot_le))⟩, ?_⟩
-  simpa only [hpath t] using hdist
-
-lemma stoppedWholeSausageCharge_clock_le
-    (κ : ℝ) (γ η : C(ℝ≥0, ℂ)) (T c σ : ℝ≥0) (ρ : WithTop ℝ≥0)
-    (hpath : ∀ t, η t = γ (T + c * t))
-    (hstop : ((T + c * σ : ℝ≥0) : WithTop ℝ≥0) ≤ ρ) (v : ℝ) (D : Set ℂ) :
-    stoppedWholeSausageCharge κ η (σ : WithTop ℝ≥0) v D ≤
-      stoppedWholeSausageCharge κ γ ρ v D := by
-  rw [stoppedWholeSausageCharge_finite]
-  exact (segmentSausageCharge_clock_le κ γ η T c σ hpath v D).trans
-    (segmentSausageCharge_le_stoppedWhole κ γ _ ρ hstop v D)
-
-lemma IsCapacityTwoWitness.normalized_restart_level_of_live_source
-    {U : ℝ≥0 → ℝ} {γ β : ℝ≥0 → ℂ} {G F G' F' : ℝ≥0 → ℂ → ℂ}
-    (hw : IsCapacityTwoWitness U γ G F) (hU : Continuous U) (T a : ℝ≥0) (ha : 0 < a)
-    (hb : IsCapacityTwoWitness (normalizedRestartDriver U T a) β G' F')
-    (w : ℂ) (u v : ℝ)
-    (hbase : fullRadius G T (F T ((a : ℂ) * w + (U T : ℂ))) =
-      (2 * (F T ((a : ℂ) * w + (U T : ℂ))).im) * Real.exp (-u))
-    (t : ℝ≥0) (ht : w ∈ survivingDomain β t)
-    (hR : fullRadius G' t w = (2 * w.im) * Real.exp (-v)) :
-    fullRadius G (T + a ^ 2 * t) (F T ((a : ℂ) * w + (U T : ℂ))) =
-        (2 * (F T ((a : ℂ) * w + (U T : ℂ))).im) * Real.exp (-(u + v)) ∧
-      radiusLevelTime γ G (F T ((a : ℂ) * w + (U T : ℂ))) (u + v) =
-        (T + a ^ 2 * t : ℝ≥0) := by
-  have hbup := normalized_restart_witness T a ha hb
-  have haC : (a : ℂ) ≠ 0 := by exact_mod_cast ha.ne'
-  have htu : (a : ℂ) * w ∈ survivingDomain (sourceScaleTrace a β) (a ^ 2 * t) := by
-    rw [source_scale_domain_iff a _ ha β, source_scale_time_mul_sq a t ha,
-      mul_div_cancel_left₀ w haC]
-    exact ht
-  have hRu : fullRadius (sourceScaleChart a G') (a ^ 2 * t) ((a : ℂ) * w) =
-      (2 * ((a : ℂ) * w).im) * Real.exp (-v) := by
-    rw [hb.scaled_radius a ha t w ht, hR]
-    simp only [Complex.mul_im, Complex.ofReal_re, Complex.ofReal_im, zero_mul, add_zero]
-    ring
-  exact hw.restart_level_of_live_source hU T hbup ((a : ℂ) * w) u v hbase (a ^ 2 * t) htu hRu
-
-/-- At every finite source radius level, the stopped fresh physical mass
-is contained in the stopped original mass at the corresponding actual level. -/
-theorem IsCapacityTwoWitness.normalized_restart_stopped_mass_le
-    {U : ℝ≥0 → ℝ} {γ β : ℝ≥0 → ℂ} {G F G' F' : ℝ≥0 → ℂ → ℂ}
-    (hw : IsCapacityTwoWitness U γ G F) (hU : Continuous U) (T a : ℝ≥0) (ha : 0 < a)
-    (hb : IsCapacityTwoWitness (normalizedRestartDriver U T a) β G' F')
-    (w : ℂ) (u q : ℝ)
-    (hbase : fullRadius G T (F T ((a : ℂ) * w + (U T : ℂ))) =
-      (2 * (F T ((a : ℂ) * w + (U T : ℂ))).im) * Real.exp (-u))
-    (η : C(ℝ≥0, ℂ)) (hpath : ∀ t, η t = γ (T + a ^ 2 * t))
-    (hfinite : radiusLevelTime β G' w q < ∞) (κ v : ℝ) (D : Set ℂ) :
-    stoppedWholeSausageCharge κ η (radiusLevelTime β G' w q) v D ≤
-      stoppedWholeSausageCharge κ ⟨γ, hw.1⟩
-        (radiusLevelTime γ G (F T ((a : ℂ) * w + (U T : ℂ))) (u + q)) v D := by
-  have hV : Continuous (normalizedRestartDriver U T a) := by
-    unfold normalizedRestartDriver
-    fun_prop
-  obtain ⟨t, ht, hR⟩ := exists_live_level_of_radiusLevelTime_lt_top β G' w q hfinite
-  have hs := radiusLevelTime_eq_of_live_level hV hb w q t ht hR
-  have hp := (hw.normalized_restart_level_of_live_source hU T a ha hb w u q hbase t ht hR).2
-  have hs' : (radiusLevelTime β G' w q : WithTop ℝ≥0) = (t : WithTop ℝ≥0) := by exact_mod_cast hs
-  have hp' : (radiusLevelTime γ G (F T ((a : ℂ) * w + (U T : ℂ))) (u + q) : WithTop ℝ≥0) =
-      ((T + a ^ 2 * t : ℝ≥0) : WithTop ℝ≥0) := by exact_mod_cast hp
-  rw [hs', hp']
-  exact stoppedWholeSausageCharge_clock_le κ ⟨γ, hw.1⟩ η T (a ^ 2) t _ hpath le_rfl v D
-
-end SLEExactGauge
-
-end
-
-end OAI
+import OAI.Probability.SLE.Geometry.NormalizedRestartKernel
+import OAI.Probability.SLE.Gauge.ConformalDenseExperiment
+
+namespace OAI
+
+/-! A dense mass generated by the normalized fresh trace is present in the
+original stopped trace at the corresponding physical radius level. -/
+
+noncomputable section
+open Set Filter Metric MeasureTheory
+open scoped Topology NNReal ENNReal
+
+namespace SLEExactGauge
+open FrontSuccessMeasurability
+
+lemma segmentSausageCharge_clock_le
+    (κ : ℝ) (γ η : C(ℝ≥0, ℂ)) (T c σ : ℝ≥0)
+    (hpath : ∀ t, η t = γ (T + c * t)) (v : ℝ) (D : Set ℂ) :
+    segmentSausageCharge κ η 0 σ v D ≤ segmentSausageCharge κ γ 0 (T + c * σ) v D := by
+  apply mul_le_mul' le_rfl
+  apply measure_mono
+  rintro z ⟨hz, t, ht, hdist⟩
+  refine ⟨hz, T + c * t, ⟨bot_le,
+    add_le_add le_rfl (mul_le_mul_of_nonneg_left ht.2 (show 0 ≤ c from bot_le))⟩, ?_⟩
+  simpa only [hpath t] using hdist
+
+lemma stoppedWholeSausageCharge_clock_le
+    (κ : ℝ) (γ η : C(ℝ≥0, ℂ)) (T c σ : ℝ≥0) (ρ : WithTop ℝ≥0)
+    (hpath : ∀ t, η t = γ (T + c * t))
+    (hstop : ((T + c * σ : ℝ≥0) : WithTop ℝ≥0) ≤ ρ) (v : ℝ) (D : Set ℂ) :
+    stoppedWholeSausageCharge κ η (σ : WithTop ℝ≥0) v D ≤
+      stoppedWholeSausageCharge κ γ ρ v D := by
+  rw [stoppedWholeSausageCharge_finite]
+  exact (segmentSausageCharge_clock_le κ γ η T c σ hpath v D).trans
+    (segmentSausageCharge_le_stoppedWhole κ γ _ ρ hstop v D)
+
+lemma IsCapacityTwoWitness.normalized_restart_level_of_live_source
+    {U : ℝ≥0 → ℝ} {γ β : ℝ≥0 → ℂ} {G F G' F' : ℝ≥0 → ℂ → ℂ}
+    (hw : IsCapacityTwoWitness U γ G F) (hU : Continuous U) (T a : ℝ≥0) (ha : 0 < a)
+    (hb : IsCapacityTwoWitness (normalizedRestartDriver U T a) β G' F')
+    (w : ℂ) (u v : ℝ)
+    (hbase : fullRadius G T (F T ((a : ℂ) * w + (U T : ℂ))) =
+      (2 * (F T ((a : ℂ) * w + (U T : ℂ))).im) * Real.exp (-u))
+    (t : ℝ≥0) (ht : w ∈ survivingDomain β t)
+    (hR : fullRadius G' t w = (2 * w.im) * Real.exp (-v)) :
+    fullRadius G (T + a ^ 2 * t) (F T ((a : ℂ) * w + (U T : ℂ))) =
+        (2 * (F T ((a : ℂ) * w + (U T : ℂ))).im) * Real.exp (-(u + v)) ∧
+      radiusLevelTime γ G (F T ((a : ℂ) * w + (U T : ℂ))) (u + v) =
+        (T + a ^ 2 * t : ℝ≥0) := by
+  have hbup := normalized_restart_witness T a ha hb
+  have haC : (a : ℂ) ≠ 0 := by exact_mod_cast ha.ne'
+  have htu : (a : ℂ) * w ∈ survivingDomain (sourceScaleTrace a β) (a ^ 2 * t) := by
+    rw [source_scale_domain_iff a _ ha β, source_scale_time_mul_sq a t ha,
+      mul_div_cancel_left₀ w haC]
+    exact ht
+  have hRu : fullRadius (sourceScaleChart a G') (a ^ 2 * t) ((a : ℂ) * w) =
+      (2 * ((a : ℂ) * w).im) * Real.exp (-v) := by
+    rw [hb.scaled_radius a ha t w ht, hR]
+    simp only [Complex.mul_im, Complex.ofReal_re, Complex.ofReal_im, zero_mul, add_zero]
+    ring
+  exact hw.restart_level_of_live_source hU T hbup ((a : ℂ) * w) u v hbase (a ^ 2 * t) htu hRu
+
+/-- At every finite source radius level, the stopped fresh physical mass
+is contained in the stopped original mass at the corresponding actual level. -/
+theorem IsCapacityTwoWitness.normalized_restart_stopped_mass_le
+    {U : ℝ≥0 → ℝ} {γ β : ℝ≥0 → ℂ} {G F G' F' : ℝ≥0 → ℂ → ℂ}
+    (hw : IsCapacityTwoWitness U γ G F) (hU : Continuous U) (T a : ℝ≥0) (ha : 0 < a)
+    (hb : IsCapacityTwoWitness (normalizedRestartDriver U T a) β G' F')
+    (w : ℂ) (u q : ℝ)
+    (hbase : fullRadius G T (F T ((a : ℂ) * w + (U T : ℂ))) =
+      (2 * (F T ((a : ℂ) * w + (U T : ℂ))).im) * Real.exp (-u))
+    (η : C(ℝ≥0, ℂ)) (hpath : ∀ t, η t = γ (T + a ^ 2 * t))
+    (hfinite : radiusLevelTime β G' w q < ∞) (κ v : ℝ) (D : Set ℂ) :
+    stoppedWholeSausageCharge κ η (radiusLevelTime β G' w q) v D ≤
+      stoppedWholeSausageCharge κ ⟨γ, hw.1⟩
+        (radiusLevelTime γ G (F T ((a : ℂ) * w + (U T : ℂ))) (u + q)) v D := by
+  have hV : Continuous (normalizedRestartDriver U T a) := by
+    unfold normalizedRestartDriver
+    fun_prop
+  obtain ⟨t, ht, hR⟩ := exists_live_level_of_radiusLevelTime_lt_top β G' w q hfinite
+  have hs := radiusLevelTime_eq_of_live_level hV hb w q t ht hR
+  have hp := (hw.normalized_restart_level_of_live_source hU T a ha hb w u q hbase t ht hR).2
+  have hs' : (radiusLevelTime β G' w q : WithTop ℝ≥0) = (t : WithTop ℝ≥0) := by exact_mod_cast hs
+  have hp' : (radiusLevelTime γ G (F T ((a : ℂ) * w + (U T : ℂ))) (u + q) : WithTop ℝ≥0) =
+      ((T + a ^ 2 * t : ℝ≥0) : WithTop ℝ≥0) := by exact_mod_cast hp
+  rw [hs', hp']
+  exact stoppedWholeSausageCharge_clock_le κ ⟨γ, hw.1⟩ η T (a ^ 2) t _ hpath le_rfl v D
+
+end SLEExactGauge
+
+end
+
+end OAI

lean/OAI/Probability/SLE/Mass/ScaledGreenMeasure.lean

@@ -1,61 +1,61 @@
-import OAI.Probability.SLE.Mass.DilationMass
-import OAI.Probability.SLE.Loewner.RawScaledGreenKernel
-import OAI.Probability.SLE.Geometry.ScaledMarkedKernel
-
-namespace OAI
-
-/-! Killed Green measures scale by the same dimension-weighted spatial
-pushforward as the canonical mass, including points no longer surviving. -/
-
-noncomputable section
-open Set Filter _root_.MeasureTheory _root_.OAI.MeasureTheory ProbabilityTheory
-open scoped Topology NNReal ENNReal
-
-namespace SLEExactGauge.Multipoint
-
-local instance scaledGreenMeasurable : MeasurableSpace C(ℝ≥0,ℝ) := borel _
-local instance scaledGreenBorel : BorelSpace C(ℝ≥0,ℝ) := ⟨rfl⟩
-
-lemma halfPlaneGreenMeasure_scaled {Ω : Type*} (κ : ℝ)
-    (B : ℝ≥0 → Ω → ℝ) (γ : Ω → ℝ≥0 → ℂ) (G F : Ω → ℝ≥0 → ℂ → ℂ)
-    (hw : ∀ ω, IsCapacityTwoWitness (fun t => Real.sqrt κ*B t ω) (γ ω) (G ω) (F ω))
-    (c : ℝ≥0) (hc : 0 < c) (t : ℝ≥0) (ω : Ω) :
-    halfPlaneGreenMeasure κ (scaledBrownianDriver c B)
-      (fun ω => sourceScaleTrace c (γ ω)) (fun ω => sourceScaleChart c (G ω)) (c^2*t) ω=
-      dilationMass κ c hc (halfPlaneGreenMeasure κ B γ G t ω) := by
-  unfold halfPlaneGreenMeasure
-  apply dilationMass_realDensity
-  intro z _hz
-  have h := source_scale_greenDensity κ c hc (fun t => Real.sqrt κ*B t ω)
-    (γ ω) (G ω) (F ω) (hw ω) (c^2*t) z
-  rw [source_scale_time_mul_sq c t hc] at h
-  simpa only [scaledBrownianDriver,mul_left_comm (Real.sqrt κ) (c:ℝ)] using h
-
-lemma canonicalGreenMass_scaled {Ω : Type*} (κ : ℝ)
-    (B : ℝ≥0 → Ω → ℝ) (hc : ∀ ω, Continuous (fun t => B t ω))
-    (γ : Ω → ℝ≥0 → ℂ) (G F : Ω → ℝ≥0 → ℂ → ℂ)
-    (hw : ∀ ω, IsCapacityTwoWitness (fun t => Real.sqrt κ*B t ω) (γ ω) (G ω) (F ω))
-    (c : ℝ≥0) (hcp : 0 < c) (t : ℝ≥0) (ω : Ω) :
-    canonicalGreenMass κ (c^2*t)
-      (sourceDriverPath (scaledBrownianDriver c B) (scaledBrownianDriver_continuous c B hc) ω)=
-      dilationMass κ c hcp (halfPlaneGreenMeasure κ B γ G t ω) := by
-  have hwc : IsCapacityTwoWitness (fun t => Real.sqrt κ*scaledBrownianDriver c B t ω)
-      (sourceScaleTrace c (γ ω)) (sourceScaleChart c (G ω)) (sourceScaleChart c (F ω)) := by
-    have h := source_scale_witness c hcp (fun t => Real.sqrt κ*B t ω)
-      (γ ω) (G ω) (F ω) (hw ω)
-    simpa only [scaledBrownianDriver,mul_left_comm (Real.sqrt κ) (c:ℝ)] using h
-  have he := canonicalGreenMass_eq κ
-    (sourceDriverPath (scaledBrownianDriver c B) (scaledBrownianDriver_continuous c B hc) ω)
-    hwc (c^2*t)
-  change canonicalGreenMass κ (c^2*t)
-    (sourceDriverPath (scaledBrownianDriver c B) (scaledBrownianDriver_continuous c B hc) ω)=
-      halfPlaneGreenMeasure κ (scaledBrownianDriver c B)
-        (fun ω => sourceScaleTrace c (γ ω)) (fun ω => sourceScaleChart c (G ω)) (c^2*t) ω at he
-  rw [he]
-  exact halfPlaneGreenMeasure_scaled κ B γ G F hw c hcp t ω
-
-end SLEExactGauge.Multipoint
-
-end
-
-end OAI
+import OAI.Probability.SLE.Mass.DilationMass
+import OAI.Probability.SLE.Loewner.RawScaledGreenKernel
+import OAI.Probability.SLE.Geometry.ScaledMarkedKernel
+
+namespace OAI
+
+/-! Killed Green measures scale by the same dimension-weighted spatial
+pushforward as the canonical mass, including points no longer surviving. -/
+
+noncomputable section
+open Set Filter _root_.MeasureTheory _root_.OAI.MeasureTheory ProbabilityTheory
+open scoped Topology NNReal ENNReal
+
+namespace SLEExactGauge.Multipoint
+
+local instance scaledGreenMeasurable : MeasurableSpace C(ℝ≥0,ℝ) := borel _
+local instance scaledGreenBorel : BorelSpace C(ℝ≥0,ℝ) := ⟨rfl⟩
+
+lemma halfPlaneGreenMeasure_scaled {Ω : Type*} (κ : ℝ)
+    (B : ℝ≥0 → Ω → ℝ) (γ : Ω → ℝ≥0 → ℂ) (G F : Ω → ℝ≥0 → ℂ → ℂ)
+    (hw : ∀ ω, IsCapacityTwoWitness (fun t => Real.sqrt κ*B t ω) (γ ω) (G ω) (F ω))
+    (c : ℝ≥0) (hc : 0 < c) (t : ℝ≥0) (ω : Ω) :
+    halfPlaneGreenMeasure κ (scaledBrownianDriver c B)
+      (fun ω => sourceScaleTrace c (γ ω)) (fun ω => sourceScaleChart c (G ω)) (c^2*t) ω=
+      dilationMass κ c hc (halfPlaneGreenMeasure κ B γ G t ω) := by
+  unfold halfPlaneGreenMeasure
+  apply dilationMass_realDensity
+  intro z _hz
+  have h := source_scale_greenDensity κ c hc (fun t => Real.sqrt κ*B t ω)
+    (γ ω) (G ω) (F ω) (hw ω) (c^2*t) z
+  rw [source_scale_time_mul_sq c t hc] at h
+  simpa only [scaledBrownianDriver,mul_left_comm (Real.sqrt κ) (c:ℝ)] using h
+
+lemma canonicalGreenMass_scaled {Ω : Type*} (κ : ℝ)
+    (B : ℝ≥0 → Ω → ℝ) (hc : ∀ ω, Continuous (fun t => B t ω))
+    (γ : Ω → ℝ≥0 → ℂ) (G F : Ω → ℝ≥0 → ℂ → ℂ)
+    (hw : ∀ ω, IsCapacityTwoWitness (fun t => Real.sqrt κ*B t ω) (γ ω) (G ω) (F ω))
+    (c : ℝ≥0) (hcp : 0 < c) (t : ℝ≥0) (ω : Ω) :
+    canonicalGreenMass κ (c^2*t)
+      (sourceDriverPath (scaledBrownianDriver c B) (scaledBrownianDriver_continuous c B hc) ω)=
+      dilationMass κ c hcp (halfPlaneGreenMeasure κ B γ G t ω) := by
+  have hwc : IsCapacityTwoWitness (fun t => Real.sqrt κ*scaledBrownianDriver c B t ω)
+      (sourceScaleTrace c (γ ω)) (sourceScaleChart c (G ω)) (sourceScaleChart c (F ω)) := by
+    have h := source_scale_witness c hcp (fun t => Real.sqrt κ*B t ω)
+      (γ ω) (G ω) (F ω) (hw ω)
+    simpa only [scaledBrownianDriver,mul_left_comm (Real.sqrt κ) (c:ℝ)] using h
+  have he := canonicalGreenMass_eq κ
+    (sourceDriverPath (scaledBrownianDriver c B) (scaledBrownianDriver_continuous c B hc) ω)
+    hwc (c^2*t)
+  change canonicalGreenMass κ (c^2*t)
+    (sourceDriverPath (scaledBrownianDriver c B) (scaledBrownianDriver_continuous c B hc) ω)=
+      halfPlaneGreenMeasure κ (scaledBrownianDriver c B)
+        (fun ω => sourceScaleTrace c (γ ω)) (fun ω => sourceScaleChart c (G ω)) (c^2*t) ω at he
+  rw [he]
+  exact halfPlaneGreenMeasure_scaled κ B γ G F hw c hcp t ω
+
+end SLEExactGauge.Multipoint
+
+end
+
+end OAI

lean/OAI/Probability/SLE/Mass/SignedLevelTests.lean

@@ -1,142 +1,142 @@
-import OAI.Probability.SLE.Mass.LevelApproximationL2
-
-namespace OAI
-
-/-! Real compact tests of the actual level measures. Both signs are
-controlled by the same compact moment estimate. -/
-
-noncomputable section
-open Set Filter MeasureTheory ProbabilityTheory Classical
-open scoped NNReal ENNReal Topology
-
-namespace SLEExactGauge.Multipoint
-
-def levelApproximationRealTest {Ω : Type*} (κ : ℝ) (B : ℝ≥0 → Ω → ℝ)
-    (γ : Ω → ℝ≥0 → ℂ) (G : Ω → ℝ≥0 → ℂ → ℂ)
-    (u : ℝ) (t : ℝ≥0∞) (f : ℂ → ℝ) (ω : Ω) : ℝ :=
-  ∫ z, f z ∂levelApproximation κ B γ G u t ω
-
-lemma integrable_of_bounded_support (μ : Measure ℂ) (K : Set ℂ)
-    (hK : MeasurableSet K) (hμK : μ K < ⊤) (f : ℂ → ℝ)
-    (hfm : Measurable f) (C : ℝ) (hf : ∀ z ∈ K, ‖f z‖ ≤ C)
-    (hz : ∀ z ∉ K, f z = 0) : Integrable f μ := by
-  have hi : Integrable (K.indicator (fun _ : ℂ => C)) μ :=
-    (integrableOn_const hμK.ne).integrable_indicator hK
-  apply hi.mono' hfm.aestronglyMeasurable
-  filter_upwards [] with z
-  by_cases h : z ∈ K
-  · simpa only [indicator_of_mem h] using hf z h
-  · simp only [hz z h,norm_zero,indicator_of_notMem h,le_refl]
-
-lemma levelApproximationRealTest_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 s => Real.sqrt κ * B s ω) (γ ω) (G ω) (F ω))
-    (t : ℝ≥0∞) (f : ℂ → ℝ) (hfm : Measurable f) :
-    Measurable (levelApproximationRealTest κ B γ G u t f) := by
-  have hd := levelApproximationDensity_joint_measurable hm hBc κ u hu γ G F hw t
-  have he (ω : Ω) : levelApproximationRealTest κ B γ G u t f ω =
-      ∫ z, (levelApproximationDensity κ B γ G u t ω z).toReal * f z := by
-    apply integral_withDensity_eq_integral_toReal_smul hd.of_uncurry_left
-    filter_upwards [] with z
-    unfold levelApproximationDensity
-    split_ifs <;> simp
-  simp_rw [show levelApproximationRealTest κ B γ G u t f =
-    (fun ω => ∫ z, (levelApproximationDensity κ B γ G u t ω z).toReal * f z)
-    from funext he]
-  exact (hd.ennreal_toReal.mul (hfm.comp measurable_snd)).stronglyMeasurable.integral_prod_right'.measurable
-
-lemma levelApproximationRealTest_eq_parts
-    {Ω : Type*} (κ : ℝ) (B : ℝ≥0 → Ω → ℝ)
-    (γ : Ω → ℝ≥0 → ℂ) (G : Ω → ℝ≥0 → ℂ → ℂ)
-    (u : ℝ) (t : ℝ≥0∞) (f : ℂ → ℝ) (ω : Ω)
-    (K : Set ℂ) (hK : MeasurableSet K) (hM : levelMass κ B γ G u K ω < ⊤)
-    (hfm : Measurable f) (C : ℝ) (hf : ∀ z ∈ K, ‖f z‖ ≤ C)
-    (hz : ∀ z ∉ K, f z = 0) :
-    levelApproximationRealTest κ B γ G u t f ω =
-      (levelApproximationTest κ B γ G u t (fun z => ENNReal.ofReal (f z)) ω).toReal -
-      (levelApproximationTest κ B γ G u t (fun z => ENNReal.ofReal (-f z)) ω).toReal := by
-  exact integral_eq_lintegral_pos_part_sub_lintegral_neg_part
-    (integrable_of_bounded_support _ K hK
-      ((levelApproximation_apply_le κ B γ G u t ω hK).trans_lt hM) f hfm C hf hz)
-
-theorem levelMass_ae_finite
-    {Ω : 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 s => Real.sqrt κ * B s ω) (γ ω) (G ω) (F ω))
-    (hgrowth : PublishedDiskUnivalentGrowth)
-    (K : Set ℂ) (hK : IsCompact K) (hKH : K ⊆ upperHalfPlane)
-    (u : ℝ) (hu : 0 ≤ u) : ∀ᵐ ω ∂P, levelMass κ B γ G u K ω < ⊤ := by
-  obtain ⟨M,hM,hbound⟩ := uniform_levelMass_compact_moments hB hm hBm hBc hB0 hκ hκ8
-    γ G F hw hgrowth K hK hKH 1
-  apply ae_lt_top (levelMass_measurable hm hBc κ u hu γ G F hw K)
-  exact (lt_of_le_of_lt (by simpa only [pow_one] using hbound u hu) hM).ne
-
-theorem uniform_signed_levelTest_L2
-    {Ω : 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 s => Real.sqrt κ * B s ω) (γ ω) (G ω) (F ω))
-    (hgrowth : PublishedDiskUnivalentGrowth)
-    (K : Set ℂ) (hK : IsCompact K) (hKH : K ⊆ upperHalfPlane)
-    (f : ℂ → ℝ) (hfm : Measurable f) (C : ℝ) (hf : ∀ z ∈ K, ‖f z‖ ≤ C)
-    (hz : ∀ z ∉ K, f z = 0) :
-    (∀ u : ℝ, 0 ≤ u → ∀ t : ℝ≥0∞, MemLp (levelApproximationRealTest κ B γ G u t f) 2 P) ∧
-      ∃ D : ℝ, ∀ u : ℝ, ∀ _hu : 0 ≤ u, ∀ t : ℝ≥0∞,
-        ∀ hp : MemLp (levelApproximationRealTest κ B γ G u t f) 2 P,
-          ‖hp.toLp (levelApproximationRealTest κ B γ G u t f)‖ ≤ D := by
-  let fp : ℂ → ℝ≥0∞ := fun z => ENNReal.ofReal (f z)
-  let fn : ℂ → ℝ≥0∞ := fun z => ENNReal.ofReal (-f z)
-  have hfp (z : ℂ) (hzK : z ∈ K) : fp z ≤ ENNReal.ofReal C :=
-    ENNReal.ofReal_le_ofReal ((le_abs_self _).trans (hf z hzK))
-  have hfn (z : ℂ) (hzK : z ∈ K) : fn z ≤ ENNReal.ofReal C :=
-    ENNReal.ofReal_le_ofReal ((neg_le_abs _).trans (hf z hzK))
-  obtain ⟨Mp,hMp,hpb⟩ := uniform_levelApproximationTest_moments hB hm hBm hBc hB0 hκ hκ8
-    γ G F hw hgrowth K hK hKH fp (ENNReal.ofReal C) ENNReal.ofReal_lt_top hfp
-    (fun z hzK => by simp only [fp,hz z hzK,ENNReal.ofReal_zero]) 2
-  obtain ⟨Mn,hMn,hnb⟩ := uniform_levelApproximationTest_moments hB hm hBm hBc hB0 hκ hκ8
-    γ G F hw hgrowth K hK hKH fn (ENNReal.ofReal C) ENNReal.ofReal_lt_top hfn
-    (fun z hzK => by simp only [fn,hz z hzK,neg_zero,ENNReal.ofReal_zero]) 2
-  have hpm (u : ℝ) (hu : 0 ≤ u) (t : ℝ≥0∞) :=
-    levelApproximationTest_measurable hm hBc κ u hu γ G F hw t fp hfm.ennreal_ofReal
-  have hnm (u : ℝ) (hu : 0 ≤ u) (t : ℝ≥0∞) :=
-    levelApproximationTest_measurable hm hBc κ u hu γ G F hw t fn hfm.neg.ennreal_ofReal
-  have hpLp (u : ℝ) (hu : 0 ≤ u) (t : ℝ≥0∞) :=
-    memLp_toReal_two P _ (hpm u hu t) Mp hMp (hpb u hu t)
-  have hnLp (u : ℝ) (hu : 0 ≤ u) (t : ℝ≥0∞) :=
-    memLp_toReal_two P _ (hnm u hu t) Mn hMn (hnb u hu t)
-  have he (u : ℝ) (hu : 0 ≤ u) (t : ℝ≥0∞) : levelApproximationRealTest κ B γ G u t f =ᵐ[P]
-      fun ω => (levelApproximationTest κ B γ G u t fp ω).toReal -
-        (levelApproximationTest κ B γ G u t fn ω).toReal := by
-    filter_upwards [levelMass_ae_finite hB hm hBm hBc hB0 hκ hκ8 γ G F hw hgrowth K hK hKH u hu]
-      with ω hω
-    exact levelApproximationRealTest_eq_parts κ B γ G u t f ω K hK.measurableSet hω hfm C hf hz
-  refine ⟨fun u hu t => MemLp.ae_eq (he u hu t).symm ((hpLp u hu t).sub (hnLp u hu t)),
-    ⟨(Mp ^ (1/2 : ℝ)).toReal + (Mn ^ (1/2 : ℝ)).toReal, ?_⟩⟩
-  intro u hu t hp
-  have hclass : hp.toLp (levelApproximationRealTest κ B γ G u t f) =
-      (hpLp u hu t).toLp _ - (hnLp u hu t).toLp _ := by
-    apply Lp.ext
-    filter_upwards [hp.coeFn_toLp, (hpLp u hu t).coeFn_toLp,
-      (hnLp u hu t).coeFn_toLp,Lp.coeFn_sub ((hpLp u hu t).toLp _) ((hnLp u hu t).toLp _),
-      he u hu t] with ω h₁ h₂ h₃ h₄ h₅
-    rw [h₁,h₄,Pi.sub_apply,h₂,h₃,h₅]
-  rw [hclass]
-  exact (norm_sub_le _ _).trans (add_le_add
-    (norm_toLp_toReal_two_le P _ (hpm u hu t) Mp hMp (hpb u hu t) (hpLp u hu t))
-    (norm_toLp_toReal_two_le P _ (hnm u hu t) Mn hMn (hnb u hu t) (hnLp u hu t)))
-
-end SLEExactGauge.Multipoint
-
-end
-
-end OAI
+import OAI.Probability.SLE.Mass.LevelApproximationL2
+
+namespace OAI
+
+/-! Real compact tests of the actual level measures. Both signs are
+controlled by the same compact moment estimate. -/
+
+noncomputable section
+open Set Filter MeasureTheory ProbabilityTheory Classical
+open scoped NNReal ENNReal Topology
+
+namespace SLEExactGauge.Multipoint
+
+def levelApproximationRealTest {Ω : Type*} (κ : ℝ) (B : ℝ≥0 → Ω → ℝ)
+    (γ : Ω → ℝ≥0 → ℂ) (G : Ω → ℝ≥0 → ℂ → ℂ)
+    (u : ℝ) (t : ℝ≥0∞) (f : ℂ → ℝ) (ω : Ω) : ℝ :=
+  ∫ z, f z ∂levelApproximation κ B γ G u t ω
+
+lemma integrable_of_bounded_support (μ : Measure ℂ) (K : Set ℂ)
+    (hK : MeasurableSet K) (hμK : μ K < ⊤) (f : ℂ → ℝ)
+    (hfm : Measurable f) (C : ℝ) (hf : ∀ z ∈ K, ‖f z‖ ≤ C)
+    (hz : ∀ z ∉ K, f z = 0) : Integrable f μ := by
+  have hi : Integrable (K.indicator (fun _ : ℂ => C)) μ :=
+    (integrableOn_const hμK.ne).integrable_indicator hK
+  apply hi.mono' hfm.aestronglyMeasurable
+  filter_upwards [] with z
+  by_cases h : z ∈ K
+  · simpa only [indicator_of_mem h] using hf z h
+  · simp only [hz z h,norm_zero,indicator_of_notMem h,le_refl]
+
+lemma levelApproximationRealTest_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 s => Real.sqrt κ * B s ω) (γ ω) (G ω) (F ω))
+    (t : ℝ≥0∞) (f : ℂ → ℝ) (hfm : Measurable f) :
+    Measurable (levelApproximationRealTest κ B γ G u t f) := by
+  have hd := levelApproximationDensity_joint_measurable hm hBc κ u hu γ G F hw t
+  have he (ω : Ω) : levelApproximationRealTest κ B γ G u t f ω =
+      ∫ z, (levelApproximationDensity κ B γ G u t ω z).toReal * f z := by
+    apply integral_withDensity_eq_integral_toReal_smul hd.of_uncurry_left
+    filter_upwards [] with z
+    unfold levelApproximationDensity
+    split_ifs <;> simp
+  simp_rw [show levelApproximationRealTest κ B γ G u t f =
+    (fun ω => ∫ z, (levelApproximationDensity κ B γ G u t ω z).toReal * f z)
+    from funext he]
+  exact (hd.ennreal_toReal.mul (hfm.comp measurable_snd)).stronglyMeasurable.integral_prod_right'.measurable
+
+lemma levelApproximationRealTest_eq_parts
+    {Ω : Type*} (κ : ℝ) (B : ℝ≥0 → Ω → ℝ)
+    (γ : Ω → ℝ≥0 → ℂ) (G : Ω → ℝ≥0 → ℂ → ℂ)
+    (u : ℝ) (t : ℝ≥0∞) (f : ℂ → ℝ) (ω : Ω)
+    (K : Set ℂ) (hK : MeasurableSet K) (hM : levelMass κ B γ G u K ω < ⊤)
+    (hfm : Measurable f) (C : ℝ) (hf : ∀ z ∈ K, ‖f z‖ ≤ C)
+    (hz : ∀ z ∉ K, f z = 0) :
+    levelApproximationRealTest κ B γ G u t f ω =
+      (levelApproximationTest κ B γ G u t (fun z => ENNReal.ofReal (f z)) ω).toReal -
+      (levelApproximationTest κ B γ G u t (fun z => ENNReal.ofReal (-f z)) ω).toReal := by
+  exact integral_eq_lintegral_pos_part_sub_lintegral_neg_part
+    (integrable_of_bounded_support _ K hK
+      ((levelApproximation_apply_le κ B γ G u t ω hK).trans_lt hM) f hfm C hf hz)
+
+theorem levelMass_ae_finite
+    {Ω : 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 s => Real.sqrt κ * B s ω) (γ ω) (G ω) (F ω))
+    (hgrowth : PublishedDiskUnivalentGrowth)
+    (K : Set ℂ) (hK : IsCompact K) (hKH : K ⊆ upperHalfPlane)
+    (u : ℝ) (hu : 0 ≤ u) : ∀ᵐ ω ∂P, levelMass κ B γ G u K ω < ⊤ := by
+  obtain ⟨M,hM,hbound⟩ := uniform_levelMass_compact_moments hB hm hBm hBc hB0 hκ hκ8
+    γ G F hw hgrowth K hK hKH 1
+  apply ae_lt_top (levelMass_measurable hm hBc κ u hu γ G F hw K)
+  exact (lt_of_le_of_lt (by simpa only [pow_one] using hbound u hu) hM).ne
+
+theorem uniform_signed_levelTest_L2
+    {Ω : 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 s => Real.sqrt κ * B s ω) (γ ω) (G ω) (F ω))
+    (hgrowth : PublishedDiskUnivalentGrowth)
+    (K : Set ℂ) (hK : IsCompact K) (hKH : K ⊆ upperHalfPlane)
+    (f : ℂ → ℝ) (hfm : Measurable f) (C : ℝ) (hf : ∀ z ∈ K, ‖f z‖ ≤ C)
+    (hz : ∀ z ∉ K, f z = 0) :
+    (∀ u : ℝ, 0 ≤ u → ∀ t : ℝ≥0∞, MemLp (levelApproximationRealTest κ B γ G u t f) 2 P) ∧
+      ∃ D : ℝ, ∀ u : ℝ, ∀ _hu : 0 ≤ u, ∀ t : ℝ≥0∞,
+        ∀ hp : MemLp (levelApproximationRealTest κ B γ G u t f) 2 P,
+          ‖hp.toLp (levelApproximationRealTest κ B γ G u t f)‖ ≤ D := by
+  let fp : ℂ → ℝ≥0∞ := fun z => ENNReal.ofReal (f z)
+  let fn : ℂ → ℝ≥0∞ := fun z => ENNReal.ofReal (-f z)
+  have hfp (z : ℂ) (hzK : z ∈ K) : fp z ≤ ENNReal.ofReal C :=
+    ENNReal.ofReal_le_ofReal ((le_abs_self _).trans (hf z hzK))
+  have hfn (z : ℂ) (hzK : z ∈ K) : fn z ≤ ENNReal.ofReal C :=
+    ENNReal.ofReal_le_ofReal ((neg_le_abs _).trans (hf z hzK))
+  obtain ⟨Mp,hMp,hpb⟩ := uniform_levelApproximationTest_moments hB hm hBm hBc hB0 hκ hκ8
+    γ G F hw hgrowth K hK hKH fp (ENNReal.ofReal C) ENNReal.ofReal_lt_top hfp
+    (fun z hzK => by simp only [fp,hz z hzK,ENNReal.ofReal_zero]) 2
+  obtain ⟨Mn,hMn,hnb⟩ := uniform_levelApproximationTest_moments hB hm hBm hBc hB0 hκ hκ8
+    γ G F hw hgrowth K hK hKH fn (ENNReal.ofReal C) ENNReal.ofReal_lt_top hfn
+    (fun z hzK => by simp only [fn,hz z hzK,neg_zero,ENNReal.ofReal_zero]) 2
+  have hpm (u : ℝ) (hu : 0 ≤ u) (t : ℝ≥0∞) :=
+    levelApproximationTest_measurable hm hBc κ u hu γ G F hw t fp hfm.ennreal_ofReal
+  have hnm (u : ℝ) (hu : 0 ≤ u) (t : ℝ≥0∞) :=
+    levelApproximationTest_measurable hm hBc κ u hu γ G F hw t fn hfm.neg.ennreal_ofReal
+  have hpLp (u : ℝ) (hu : 0 ≤ u) (t : ℝ≥0∞) :=
+    memLp_toReal_two P _ (hpm u hu t) Mp hMp (hpb u hu t)
+  have hnLp (u : ℝ) (hu : 0 ≤ u) (t : ℝ≥0∞) :=
+    memLp_toReal_two P _ (hnm u hu t) Mn hMn (hnb u hu t)
+  have he (u : ℝ) (hu : 0 ≤ u) (t : ℝ≥0∞) : levelApproximationRealTest κ B γ G u t f =ᵐ[P]
+      fun ω => (levelApproximationTest κ B γ G u t fp ω).toReal -
+        (levelApproximationTest κ B γ G u t fn ω).toReal := by
+    filter_upwards [levelMass_ae_finite hB hm hBm hBc hB0 hκ hκ8 γ G F hw hgrowth K hK hKH u hu]
+      with ω hω
+    exact levelApproximationRealTest_eq_parts κ B γ G u t f ω K hK.measurableSet hω hfm C hf hz
+  refine ⟨fun u hu t => MemLp.ae_eq (he u hu t).symm ((hpLp u hu t).sub (hnLp u hu t)),
+    ⟨(Mp ^ (1/2 : ℝ)).toReal + (Mn ^ (1/2 : ℝ)).toReal, ?_⟩⟩
+  intro u hu t hp
+  have hclass : hp.toLp (levelApproximationRealTest κ B γ G u t f) =
+      (hpLp u hu t).toLp _ - (hnLp u hu t).toLp _ := by
+    apply Lp.ext
+    filter_upwards [hp.coeFn_toLp, (hpLp u hu t).coeFn_toLp,
+      (hnLp u hu t).coeFn_toLp,Lp.coeFn_sub ((hpLp u hu t).toLp _) ((hnLp u hu t).toLp _),
+      he u hu t] with ω h₁ h₂ h₃ h₄ h₅
+    rw [h₁,h₄,Pi.sub_apply,h₂,h₃,h₅]
+  rw [hclass]
+  exact (norm_sub_le _ _).trans (add_le_add
+    (norm_toLp_toReal_two_le P _ (hpm u hu t) Mp hMp (hpb u hu t) (hpLp u hu t))
+    (norm_toLp_toReal_two_le P _ (hnm u hu t) Mn hMn (hnb u hu t) (hnLp u hu t)))
+
+end SLEExactGauge.Multipoint
+
+end
+
+end OAI

lean/OAI/Probability/SLE/Mass/SignedMeasureConvergence.lean

@@ -1,102 +1,102 @@
-import OAI.Probability.SLE.Mass.RadonKernelIntegral
-import Mathlib.MeasureTheory.Integral.Bochner.Set
-import Mathlib.MeasureTheory.Function.LpSpace.Indicator
-import Mathlib.Analysis.Normed.Group.FunctionSeries
-
-namespace OAI
-
-/-! Small analytic passages used for the conditional mass kernel. -/
-
-noncomputable section
-open Set Filter MeasureTheory
-open scoped ENNReal Topology
-
-namespace SLEExactGauge
-
-theorem integral_tendsto_of_lintegral_pos_neg
-    {X : Type*} [MeasurableSpace X] (μ : ℕ → Measure X) (ν : Measure X)
-    (f : X → ℝ) (hμ : ∀ n, Integrable f (μ n)) (hν : Integrable f ν)
-    (hpos : Tendsto (fun n => ∫⁻ x, ENNReal.ofReal (f x) ∂μ n) atTop
-      (𝓝 (∫⁻ x, ENNReal.ofReal (f x) ∂ν)))
-    (hneg : Tendsto (fun n => ∫⁻ x, ENNReal.ofReal (-f x) ∂μ n) atTop
-      (𝓝 (∫⁻ x, ENNReal.ofReal (-f x) ∂ν))) :
-    Tendsto (fun n => ∫ x, f x ∂μ n) atTop (𝓝 (∫ x, f x ∂ν)) := by
-  have hp := (ENNReal.tendsto_toReal (lintegral_ofReal_lt_top_of_integrable hν).ne).comp hpos
-  have hn := (ENNReal.tendsto_toReal (lintegral_ofReal_lt_top_of_integrable hν.neg).ne).comp hneg
-  have hh := hp.sub hn
-  dsimp only [Function.comp_def,Pi.neg_apply] at hh
-  rw [← integral_eq_lintegral_pos_part_sub_lintegral_neg_part hν] at hh
-  exact hh.congr' (Eventually.of_forall (fun n =>
-    (integral_eq_lintegral_pos_part_sub_lintegral_neg_part (hμ n)).symm))
-
-theorem real_convex_tail_tendsto (f : ℕ → ℝ) {a : ℝ}
-    (hf : Tendsto f atTop (𝓝 a)) (s : ℕ → Finset ℕ) (w : ℕ → ℕ → ℝ)
-    (hw₀ : ∀ n i, i ∈ s n → 0 ≤ w n i) (hw₁ : ∀ n, ∑ i ∈ s n, w n i = 1) :
-    Tendsto (fun n => ∑ i ∈ s n, w n i * f (n+i)) atTop (𝓝 a) := by
-  apply Metric.tendsto_atTop.mpr
-  intro ε hε
-  obtain ⟨N,hN⟩ := Metric.tendsto_atTop.mp hf (ε/2) (by positivity)
-  refine ⟨N,fun n hn => ?_⟩
-  have he : (∑ i ∈ s n, w n i * f (n+i)) - a =
-      ∑ i ∈ s n, w n i * (f (n+i)-a) := by
-    simp only [mul_sub,Finset.sum_sub_distrib,← Finset.sum_mul,hw₁ n,one_mul]
-  calc
-    dist (∑ i ∈ s n, w n i * f (n+i)) a =
-        ‖∑ i ∈ s n, w n i * (f (n+i)-a)‖ := by rw [dist_eq_norm,he]
-    _ ≤ ∑ i ∈ s n, ‖w n i * (f (n+i)-a)‖ := norm_sum_le _ _
-    _ ≤ ∑ i ∈ s n, w n i * (ε/2) := by
-      apply Finset.sum_le_sum
-      intro i hi
-      rw [norm_mul,Real.norm_of_nonneg (hw₀ n i hi)]
-      exact mul_le_mul_of_nonneg_left (le_of_lt (hN (n+i) (by omega))) (hw₀ n i hi)
-    _ = ε/2 := by rw [← Finset.sum_mul,hw₁ n,one_mul]
-    _ < ε := by linarith
-
-
-lemma integral_indicator_one_mul
-    {Ω : Type*} [MeasurableSpace Ω] (P : Measure Ω) (E : Set Ω)
-    (hE : MeasurableSet E) (f : Ω → ℝ) :
-    (∫ ω, E.indicator (fun _ => (1 : ℝ)) ω * f ω ∂P) = ∫ ω in E, f ω ∂P := by
-  rw [← integral_indicator hE]
-  congr 1
-  funext ω
-  by_cases hω : ω ∈ E
-  · simp only [indicator_of_mem hω,one_mul]
-  · simp only [indicator_of_notMem hω,zero_mul]
-
-theorem setIntegral_tendsto_of_L2_pairings
-    {Ω : Type*} [MeasurableSpace Ω] (P : Measure Ω) [IsFiniteMeasure P]
-    (F : ℕ → Ω → ℝ) (f : Ω → ℝ)
-    (hp : ∀ a : Ω → ℝ, MemLp a 2 P →
-      Tendsto (fun n => ∫ ω, a ω * F n ω ∂P) atTop (𝓝 (∫ ω, a ω * f ω ∂P)))
-    (E : Set Ω) (hE : MeasurableSet E) :
-    Tendsto (fun n => ∫ ω in E, F n ω ∂P) atTop (𝓝 (∫ ω in E, f ω ∂P)) := by
-  have ha : MemLp (E.indicator (fun _ => (1 : ℝ))) 2 P := (memLp_const 1).indicator hE
-  have hh := hp (E.indicator (fun _ => 1)) ha
-  simpa only [integral_indicator_one_mul P E hE] using hh
-
-
-theorem mean_test_tendsto_of_L2_pairings
-    {Ω X : Type*} [MeasurableSpace Ω] [MeasurableSpace X]
-    (P : Measure Ω) [IsFiniteMeasure P] (μ : ℕ → Ω → Measure X) (ν : Ω → Measure X)
-    (hμ : ∀ n, Measurable (μ n)) (hν : Measurable ν) (f : X → ℝ) (hf : Measurable f)
-    (hμi : ∀ n ω, Integrable f (μ n ω)) (hνi : ∀ ω, Integrable f (ν ω))
-    (E : Set Ω) (hE : MeasurableSet E)
-    (hμP : ∀ n, Integrable f ((P.restrict E).bind (μ n)))
-    (hνP : Integrable f ((P.restrict E).bind ν))
-    (hp : ∀ a : Ω → ℝ, MemLp a 2 P →
-      Tendsto (fun n => ∫ ω, a ω * (∫ x, f x ∂μ n ω) ∂P) atTop
-        (𝓝 (∫ ω, a ω * (∫ x, f x ∂ν ω) ∂P))) :
-    Tendsto (fun n => ∫ x, f x ∂(P.restrict E).bind (μ n)) atTop
-      (𝓝 (∫ x, f x ∂(P.restrict E).bind ν)) := by
-  have he (n : ℕ) := integral_bind_of_integrable_sections (P.restrict E) (μ n) (hμ n) f hf
-    (hμi n) (hμP n)
-  have hev := integral_bind_of_integrable_sections (P.restrict E) ν hν f hf hνi hνP
-  simpa only [he,hev] using setIntegral_tendsto_of_L2_pairings P
-    (fun n ω => ∫ x, f x ∂μ n ω) (fun ω => ∫ x, f x ∂ν ω) hp E hE
-
-end SLEExactGauge
-
-end
-
-end OAI
+import OAI.Probability.SLE.Mass.RadonKernelIntegral
+import Mathlib.MeasureTheory.Integral.Bochner.Set
+import Mathlib.MeasureTheory.Function.LpSpace.Indicator
+import Mathlib.Analysis.Normed.Group.FunctionSeries
+
+namespace OAI
+
+/-! Small analytic passages used for the conditional mass kernel. -/
+
+noncomputable section
+open Set Filter MeasureTheory
+open scoped ENNReal Topology
+
+namespace SLEExactGauge
+
+theorem integral_tendsto_of_lintegral_pos_neg
+    {X : Type*} [MeasurableSpace X] (μ : ℕ → Measure X) (ν : Measure X)
+    (f : X → ℝ) (hμ : ∀ n, Integrable f (μ n)) (hν : Integrable f ν)
+    (hpos : Tendsto (fun n => ∫⁻ x, ENNReal.ofReal (f x) ∂μ n) atTop
+      (𝓝 (∫⁻ x, ENNReal.ofReal (f x) ∂ν)))
+    (hneg : Tendsto (fun n => ∫⁻ x, ENNReal.ofReal (-f x) ∂μ n) atTop
+      (𝓝 (∫⁻ x, ENNReal.ofReal (-f x) ∂ν))) :
+    Tendsto (fun n => ∫ x, f x ∂μ n) atTop (𝓝 (∫ x, f x ∂ν)) := by
+  have hp := (ENNReal.tendsto_toReal (lintegral_ofReal_lt_top_of_integrable hν).ne).comp hpos
+  have hn := (ENNReal.tendsto_toReal (lintegral_ofReal_lt_top_of_integrable hν.neg).ne).comp hneg
+  have hh := hp.sub hn
+  dsimp only [Function.comp_def,Pi.neg_apply] at hh
+  rw [← integral_eq_lintegral_pos_part_sub_lintegral_neg_part hν] at hh
+  exact hh.congr' (Eventually.of_forall (fun n =>
+    (integral_eq_lintegral_pos_part_sub_lintegral_neg_part (hμ n)).symm))
+
+theorem real_convex_tail_tendsto (f : ℕ → ℝ) {a : ℝ}
+    (hf : Tendsto f atTop (𝓝 a)) (s : ℕ → Finset ℕ) (w : ℕ → ℕ → ℝ)
+    (hw₀ : ∀ n i, i ∈ s n → 0 ≤ w n i) (hw₁ : ∀ n, ∑ i ∈ s n, w n i = 1) :
+    Tendsto (fun n => ∑ i ∈ s n, w n i * f (n+i)) atTop (𝓝 a) := by
+  apply Metric.tendsto_atTop.mpr
+  intro ε hε
+  obtain ⟨N,hN⟩ := Metric.tendsto_atTop.mp hf (ε/2) (by positivity)
+  refine ⟨N,fun n hn => ?_⟩
+  have he : (∑ i ∈ s n, w n i * f (n+i)) - a =
+      ∑ i ∈ s n, w n i * (f (n+i)-a) := by
+    simp only [mul_sub,Finset.sum_sub_distrib,← Finset.sum_mul,hw₁ n,one_mul]
+  calc
+    dist (∑ i ∈ s n, w n i * f (n+i)) a =
+        ‖∑ i ∈ s n, w n i * (f (n+i)-a)‖ := by rw [dist_eq_norm,he]
+    _ ≤ ∑ i ∈ s n, ‖w n i * (f (n+i)-a)‖ := norm_sum_le _ _
+    _ ≤ ∑ i ∈ s n, w n i * (ε/2) := by
+      apply Finset.sum_le_sum
+      intro i hi
+      rw [norm_mul,Real.norm_of_nonneg (hw₀ n i hi)]
+      exact mul_le_mul_of_nonneg_left (le_of_lt (hN (n+i) (by omega))) (hw₀ n i hi)
+    _ = ε/2 := by rw [← Finset.sum_mul,hw₁ n,one_mul]
+    _ < ε := by linarith
+
+
+lemma integral_indicator_one_mul
+    {Ω : Type*} [MeasurableSpace Ω] (P : Measure Ω) (E : Set Ω)
+    (hE : MeasurableSet E) (f : Ω → ℝ) :
+    (∫ ω, E.indicator (fun _ => (1 : ℝ)) ω * f ω ∂P) = ∫ ω in E, f ω ∂P := by
+  rw [← integral_indicator hE]
+  congr 1
+  funext ω
+  by_cases hω : ω ∈ E
+  · simp only [indicator_of_mem hω,one_mul]
+  · simp only [indicator_of_notMem hω,zero_mul]
+
+theorem setIntegral_tendsto_of_L2_pairings
+    {Ω : Type*} [MeasurableSpace Ω] (P : Measure Ω) [IsFiniteMeasure P]
+    (F : ℕ → Ω → ℝ) (f : Ω → ℝ)
+    (hp : ∀ a : Ω → ℝ, MemLp a 2 P →
+      Tendsto (fun n => ∫ ω, a ω * F n ω ∂P) atTop (𝓝 (∫ ω, a ω * f ω ∂P)))
+    (E : Set Ω) (hE : MeasurableSet E) :
+    Tendsto (fun n => ∫ ω in E, F n ω ∂P) atTop (𝓝 (∫ ω in E, f ω ∂P)) := by
+  have ha : MemLp (E.indicator (fun _ => (1 : ℝ))) 2 P := (memLp_const 1).indicator hE
+  have hh := hp (E.indicator (fun _ => 1)) ha
+  simpa only [integral_indicator_one_mul P E hE] using hh
+
+
+theorem mean_test_tendsto_of_L2_pairings
+    {Ω X : Type*} [MeasurableSpace Ω] [MeasurableSpace X]
+    (P : Measure Ω) [IsFiniteMeasure P] (μ : ℕ → Ω → Measure X) (ν : Ω → Measure X)
+    (hμ : ∀ n, Measurable (μ n)) (hν : Measurable ν) (f : X → ℝ) (hf : Measurable f)
+    (hμi : ∀ n ω, Integrable f (μ n ω)) (hνi : ∀ ω, Integrable f (ν ω))
+    (E : Set Ω) (hE : MeasurableSet E)
+    (hμP : ∀ n, Integrable f ((P.restrict E).bind (μ n)))
+    (hνP : Integrable f ((P.restrict E).bind ν))
+    (hp : ∀ a : Ω → ℝ, MemLp a 2 P →
+      Tendsto (fun n => ∫ ω, a ω * (∫ x, f x ∂μ n ω) ∂P) atTop
+        (𝓝 (∫ ω, a ω * (∫ x, f x ∂ν ω) ∂P))) :
+    Tendsto (fun n => ∫ x, f x ∂(P.restrict E).bind (μ n)) atTop
+      (𝓝 (∫ x, f x ∂(P.restrict E).bind ν)) := by
+  have he (n : ℕ) := integral_bind_of_integrable_sections (P.restrict E) (μ n) (hμ n) f hf
+    (hμi n) (hμP n)
+  have hev := integral_bind_of_integrable_sections (P.restrict E) ν hν f hf hνi hνP
+  simpa only [he,hev] using setIntegral_tendsto_of_L2_pairings P
+    (fun n ω => ∫ x, f x ∂μ n ω) (fun ω => ∫ x, f x ∂ν ω) hp E hE
+
+end SLEExactGauge
+
+end
+
+end OAI

lean/OAI/Probability/SLE/Mass/SimultaneousConvexTails.lean

@@ -1,82 +1,82 @@
-import OAI.Probability.SLE.Mass.HilbertConvexTails
-import Mathlib.Analysis.InnerProductSpace.l2Space
-
-namespace OAI
-
-/-! The countable deterministic extraction in `mass:construction`.
-A weighted Hilbert sum ensures the same finite convex coefficients work
-for every member of the countable family of bounded test sequences. -/
-
-noncomputable section
-open Set Filter
-open scoped Topology ENNReal
-
-namespace SLEExactGauge
-
-variable {E : Type*} [NormedAddCommGroup E] [InnerProductSpace ℝ E] [CompleteSpace E]
-
-lemma geometric_half_mem_l2 : Memℓp (fun j : ℕ => (1/2 : ℝ)^j) 2 := by
-  apply memℓp_gen
-  have h := summable_geometric_of_abs_lt_one (show |(1/4 : ℝ)| < 1 by norm_num)
-  convert h using 1
-  funext j
-  simp only [ENNReal.toReal_ofNat,Real.rpow_two,Real.norm_eq_abs,
-    abs_of_nonneg (pow_nonneg (by norm_num : (0:ℝ) ≤ 1/2) j)]
-  rw [pow_two,← mul_pow]
-  norm_num
-
-theorem exists_simultaneous_convex_tail_combinations (u : ℕ → ℕ → E)
-    (hbound : ∀ j, ∃ B : ℝ, ∀ n, ‖u n j‖ ≤ B) :
-    ∃ x : ℕ → E, ∃ s : ℕ → Finset ℕ, ∃ w : ℕ → ℕ → ℝ,
-      (∀ n i, i ∈ s n → 0 ≤ w n i) ∧
-      (∀ n, ∑ i ∈ s n, w n i = 1) ∧
-      (∀ j, Summable (fun n => ‖(∑ i ∈ s n, w n i • u (n+i) j) - x j‖)) ∧
-      (∀ j, Tendsto (fun n => ∑ i ∈ s n, w n i • u (n+i) j) atTop (𝓝 (x j))) := by
-  choose B hB using hbound
-  let c : ℕ → ℝ := fun j => (1/2:ℝ)^j / max 1 (B j)
-  have hc (j : ℕ) : 0 < c j := by
-    apply div_pos (pow_pos (by norm_num) _)
-    exact lt_of_lt_of_le zero_lt_one (le_max_left _ _)
-  have hsmall (n j : ℕ) : ‖c j • u n j‖ ≤ (1/2:ℝ)^j := by
-    rw [norm_smul,Real.norm_eq_abs,abs_of_pos (hc j)]
-    dsimp only [c]
-    have hd : 0 < max 1 (B j) := lt_of_lt_of_le zero_lt_one (le_max_left _ _)
-    have hh : ‖u n j‖ ≤ max 1 (B j) := (hB j n).trans (le_max_right _ _)
-    calc
-      (1/2:ℝ)^j / max 1 (B j) * ‖u n j‖ =
-          (1/2:ℝ)^j * ‖u n j‖ / max 1 (B j) := by ring
-      _ ≤ (1/2:ℝ)^j := (div_le_iff₀ hd).mpr (by gcongr)
-  let g : lp (fun _ : ℕ => ℝ) 2 := ⟨_,geometric_half_mem_l2⟩
-  let v : ℕ → lp (fun _ : ℕ => E) 2 := fun n =>
-    ⟨fun j => c j • u n j,geometric_half_mem_l2.mono (hsmall n)⟩
-  have hv (n : ℕ) : ‖v n‖ ≤ ‖g‖ := by
-    apply lp.norm_mono (by norm_num : (2 : ℝ≥0∞) ≠ 0)
-    intro j
-    simpa only [g,Real.norm_eq_abs,
-      abs_of_nonneg (pow_nonneg (by norm_num : (0:ℝ) ≤ 1/2) j)] using hsmall n j
-  obtain ⟨x,s,w,hw,hs,herror,hconv⟩ := exists_convex_tail_combinations v ‖g‖ hv
-  let L (j : ℕ) : lp (fun _ : ℕ => E) 2 →L[ℝ] E :=
-    (c j)⁻¹ • lp.evalCLM ℝ (fun _ : ℕ => E) 2 j
-  have hL (j n : ℕ) : L j (v n) = u n j := by
-    change (c j)⁻¹ • (c j • u n j) = _
-    rw [smul_smul,inv_mul_cancel₀ (hc j).ne',one_smul]
-  refine ⟨fun j => L j x,s,w,hw,hs,?_,?_⟩
-  · intro j
-    have hgeo : Summable (fun n : ℕ => ‖L j‖ * (1/2:ℝ)^n) :=
-      (summable_geometric_of_abs_lt_one (show |(1/2:ℝ)| < 1 by norm_num)).mul_left _
-    apply Summable.of_nonneg_of_le (fun _ => norm_nonneg _) _ hgeo
-    intro n
-    have hnorm := (L j).le_opNorm ((∑ i ∈ s n, w n i • v (n+i))-x)
-    simp only [map_sub,map_sum,map_smul,hL] at hnorm
-    have hh : ‖(∑ i ∈ s n, w n i • v (n+i))-x‖ ≤ (1/2:ℝ)^n := by
-      simpa only [dist_eq_norm] using (herror n).le
-    exact hnorm.trans (mul_le_mul_of_nonneg_left hh (norm_nonneg _))
-  · intro j
-    have hh := ((L j).continuous.tendsto x).comp hconv
-    simpa only [Function.comp_def,map_sum,map_smul,hL] using hh
-
-end SLEExactGauge
-
-end
-
-end OAI
+import OAI.Probability.SLE.Mass.HilbertConvexTails
+import Mathlib.Analysis.InnerProductSpace.l2Space
+
+namespace OAI
+
+/-! The countable deterministic extraction in `mass:construction`.
+A weighted Hilbert sum ensures the same finite convex coefficients work
+for every member of the countable family of bounded test sequences. -/
+
+noncomputable section
+open Set Filter
+open scoped Topology ENNReal
+
+namespace SLEExactGauge
+
+variable {E : Type*} [NormedAddCommGroup E] [InnerProductSpace ℝ E] [CompleteSpace E]
+
+lemma geometric_half_mem_l2 : Memℓp (fun j : ℕ => (1/2 : ℝ)^j) 2 := by
+  apply memℓp_gen
+  have h := summable_geometric_of_abs_lt_one (show |(1/4 : ℝ)| < 1 by norm_num)
+  convert h using 1
+  funext j
+  simp only [ENNReal.toReal_ofNat,Real.rpow_two,Real.norm_eq_abs,
+    abs_of_nonneg (pow_nonneg (by norm_num : (0:ℝ) ≤ 1/2) j)]
+  rw [pow_two,← mul_pow]
+  norm_num
+
+theorem exists_simultaneous_convex_tail_combinations (u : ℕ → ℕ → E)
+    (hbound : ∀ j, ∃ B : ℝ, ∀ n, ‖u n j‖ ≤ B) :
+    ∃ x : ℕ → E, ∃ s : ℕ → Finset ℕ, ∃ w : ℕ → ℕ → ℝ,
+      (∀ n i, i ∈ s n → 0 ≤ w n i) ∧
+      (∀ n, ∑ i ∈ s n, w n i = 1) ∧
+      (∀ j, Summable (fun n => ‖(∑ i ∈ s n, w n i • u (n+i) j) - x j‖)) ∧
+      (∀ j, Tendsto (fun n => ∑ i ∈ s n, w n i • u (n+i) j) atTop (𝓝 (x j))) := by
+  choose B hB using hbound
+  let c : ℕ → ℝ := fun j => (1/2:ℝ)^j / max 1 (B j)
+  have hc (j : ℕ) : 0 < c j := by
+    apply div_pos (pow_pos (by norm_num) _)
+    exact lt_of_lt_of_le zero_lt_one (le_max_left _ _)
+  have hsmall (n j : ℕ) : ‖c j • u n j‖ ≤ (1/2:ℝ)^j := by
+    rw [norm_smul,Real.norm_eq_abs,abs_of_pos (hc j)]
+    dsimp only [c]
+    have hd : 0 < max 1 (B j) := lt_of_lt_of_le zero_lt_one (le_max_left _ _)
+    have hh : ‖u n j‖ ≤ max 1 (B j) := (hB j n).trans (le_max_right _ _)
+    calc
+      (1/2:ℝ)^j / max 1 (B j) * ‖u n j‖ =
+          (1/2:ℝ)^j * ‖u n j‖ / max 1 (B j) := by ring
+      _ ≤ (1/2:ℝ)^j := (div_le_iff₀ hd).mpr (by gcongr)
+  let g : lp (fun _ : ℕ => ℝ) 2 := ⟨_,geometric_half_mem_l2⟩
+  let v : ℕ → lp (fun _ : ℕ => E) 2 := fun n =>
+    ⟨fun j => c j • u n j,geometric_half_mem_l2.mono (hsmall n)⟩
+  have hv (n : ℕ) : ‖v n‖ ≤ ‖g‖ := by
+    apply lp.norm_mono (by norm_num : (2 : ℝ≥0∞) ≠ 0)
+    intro j
+    simpa only [g,Real.norm_eq_abs,
+      abs_of_nonneg (pow_nonneg (by norm_num : (0:ℝ) ≤ 1/2) j)] using hsmall n j
+  obtain ⟨x,s,w,hw,hs,herror,hconv⟩ := exists_convex_tail_combinations v ‖g‖ hv
+  let L (j : ℕ) : lp (fun _ : ℕ => E) 2 →L[ℝ] E :=
+    (c j)⁻¹ • lp.evalCLM ℝ (fun _ : ℕ => E) 2 j
+  have hL (j n : ℕ) : L j (v n) = u n j := by
+    change (c j)⁻¹ • (c j • u n j) = _
+    rw [smul_smul,inv_mul_cancel₀ (hc j).ne',one_smul]
+  refine ⟨fun j => L j x,s,w,hw,hs,?_,?_⟩
+  · intro j
+    have hgeo : Summable (fun n : ℕ => ‖L j‖ * (1/2:ℝ)^n) :=
+      (summable_geometric_of_abs_lt_one (show |(1/2:ℝ)| < 1 by norm_num)).mul_left _
+    apply Summable.of_nonneg_of_le (fun _ => norm_nonneg _) _ hgeo
+    intro n
+    have hnorm := (L j).le_opNorm ((∑ i ∈ s n, w n i • v (n+i))-x)
+    simp only [map_sub,map_sum,map_smul,hL] at hnorm
+    have hh : ‖(∑ i ∈ s n, w n i • v (n+i))-x‖ ≤ (1/2:ℝ)^n := by
+      simpa only [dist_eq_norm] using (herror n).le
+    exact hnorm.trans (mul_le_mul_of_nonneg_left hh (norm_nonneg _))
+  · intro j
+    have hh := ((L j).continuous.tendsto x).comp hconv
+    simpa only [Function.comp_def,map_sum,map_smul,hL] using hh
+
+end SLEExactGauge
+
+end
+
+end OAI

lean/OAI/Probability/SLE/Mass/StoppedConformalPassageMass.lean

@@ -1,218 +1,218 @@
-import OAI.Probability.SLE.Mass.CompactConformalPassageMass
-
-namespace OAI
-
-/-! Retained sausage mass before the actual passage stop. The physical
-curve may include boundary visits; only its retained interior interval is
-identified with the conformal image. All mass is charged to the prescribed
-stopped segment, rather than to later portions of the whole trace. -/
-
-noncomputable section
-open Set Filter MeasureTheory
-open scoped Topology ENNReal NNReal
-
-namespace SLEExactGauge
-
-def segmentSausageCharge (κ : ℝ) (η : ℝ≥0 → ℂ) (s t : ℝ≥0)
-    (v : ℝ) (R : Set ℂ) : ℝ≥0∞ :=
-  ENNReal.ofReal (v ^ (-codimension κ)) * volume (R ∩ sourceSausageSet η s t v)
-
-theorem sourceSausageSet_mono_interval
-    (η : ℝ≥0 → ℂ) {s t a b : ℝ≥0} (hsa : s ≤ a) (hbt : b ≤ t) (v : ℝ) :
-    sourceSausageSet η a b v ⊆ sourceSausageSet η s t v := by
-  rintro z ⟨u, hu, hd⟩
-  exact ⟨u, ⟨hsa.trans hu.1, hu.2.trans hbt⟩, hd⟩
-
-theorem sourceSausageSet_congr_interval
-    {η ξ : ℝ≥0 → ℂ} {s t : ℝ≥0} (heq : EqOn η ξ (Icc s t)) (v : ℝ) :
-    sourceSausageSet η s t v = sourceSausageSet ξ s t v := by
-  ext z
-  constructor <;> rintro ⟨u, hu, hd⟩
-  · exact ⟨u, hu, by simpa only [heq hu] using hd⟩
-  · exact ⟨u, hu, by simpa only [heq hu] using hd⟩
-
-theorem segmentSausageCharge_mono
-    (κ : ℝ) (η : ℝ≥0 → ℂ) {s t a b : ℝ≥0}
-    (hsa : s ≤ a) (hbt : b ≤ t) (v : ℝ) {R S : Set ℂ} (hRS : R ⊆ S) :
-    segmentSausageCharge κ η a b v R ≤ segmentSausageCharge κ η s t v S :=
-  mul_le_mul' le_rfl (measure_mono (inter_subset_inter hRS
-    (sourceSausageSet_mono_interval η hsa hbt v)))
-
-/-- The finite-list conformal transfer charges only the actual stopped
-physical passage. Its values at parameter-boundary times can be supplied by
-the boundary-safe restart theorem. -/
-theorem compact_conformal_stopped_passage_mass
-    {Ω : Type*} [MeasurableSpace Ω] (P : Measure Ω) [IsProbabilityMeasure P]
-    (κ : ℝ) (hκ : 0 < κ) (hκ8 : κ < 8)
-    (γ : Ω → ℝ≥0 → ℂ) (hSLE : IsOrdinaryChordalSLE κ γ P)
-    (Fₙ : ℕ → ℂ → ℂ) (F : ℂ → ℂ)
-    (hFn : ∀ n, DifferentiableOn ℂ (Fₙ n) upperHalfPlane)
-    (hinj : ∀ n, InjOn (Fₙ n) upperHalfPlane)
-    (hF : DifferentiableOn ℂ F upperHalfPlane)
-    (hne : ∀ z ∈ upperHalfPlane, deriv F z ≠ 0)
-    (hconv : TendstoLocallyUniformlyOn Fₙ F atTop upperHalfPlane)
-    (K : Set ℂ) (hK : IsCompact K) (hKn : K.Nonempty) (hKH : K ⊆ upperHalfPlane)
-    (R : Set ℂ) (hR : IsOpen R) (himage : F '' K ⊆ R)
-    (I : Finset (ℝ≥0 × ℝ≥0)) (hI : ∀ J ∈ I, J.1 < J.2)
-    (v : ℕ → ℝ) (hv : ∀ n, 0 < v n) (hlim : Tendsto v atTop (𝓝 0))
-    (η : ℕ → Ω → ℝ≥0 → ℂ) (s t : ℕ → Ω → ℝ≥0) (Rₙ : ℕ → Set ℂ)
-    (G : ℕ → Set Ω) (q : ℝ) (hq : 0 < q)
-    (hG : ∀ᶠ n in atTop, ENNReal.ofReal q ≤ P (G n))
-    (hregion : ∀ᶠ n in atTop, R ⊆ Rₙ n)
-    (hretain : ∀ᶠ n in atTop, ∀ ω, ω ∈ G n →
-      ∃ J ∈ I, γ ω '' Icc J.1 J.2 ⊆ K ∧ s n ω ≤ J.1 ∧ J.2 ≤ t n ω ∧
-        EqOn (η n ω) (fun u => Fₙ n (γ ω u)) (Icc J.1 J.2)) :
-    ∃ a : ℝ, 0 < a ∧ ∀ᶠ n in atTop,
-      ENNReal.ofReal (q / 2) ≤ P {ω | ω ∈ G n ∧ ENNReal.ofReal a ≤
-        segmentSausageCharge κ (η n ω) (s n ω) (t n ω) (v n) (Rₙ n)} := by
-  obtain ⟨c, ell, v₀, hc, hell, hv₀, htransfer⟩ := eventually_compact_sausage_transfer
-    κ Fₙ F hFn hinj hF hne hconv K hK hKn hKH R hR himage
-  have hcoeff : 0 < c ^ 2 * ell ^ codimension κ :=
-    mul_pos (sq_pos_of_pos hc) (Real.rpow_pos_of_pos hell _)
-  have hsmall : ∀ᶠ n in atTop, v n < v₀ := hlim.eventually (gt_mem_nhds hv₀)
-  have hlim' : Tendsto (fun n => ell * v n) atTop (𝓝 0) := by
-    simpa only [mul_zero] using tendsto_const_nhds.mul hlim
-  have htrans : ∀ᶠ n in atTop, ∀ ω, ω ∈ G n → True ∧
-      ∃ J ∈ I, ENNReal.ofReal (c ^ 2 * ell ^ codimension κ) *
-        sourceSausageMass κ (γ ω) J.1 J.2 (ell * v n) ≤
-        segmentSausageCharge κ (η n ω) (s n ω) (t n ω) (v n) (Rₙ n) := by
-    filter_upwards [htransfer, hretain, hsmall, hregion] with n hn hr hs hRsub
-    intro ω hω
-    obtain ⟨J, hJI, hJK, hJs, hJt, heq⟩ := hr ω hω
-    refine ⟨trivial, J, hJI, (hn (γ ω) J.1 J.2 hJK (v n) (hv n) hs).trans ?_⟩
-    change segmentSausageCharge κ (fun u => Fₙ n (γ ω u)) J.1 J.2 (v n) R ≤ _
-    have hsausage := sourceSausageSet_congr_interval heq (v n)
-    unfold segmentSausageCharge
-    rw [← hsausage]
-    exact segmentSausageCharge_mono κ (η n ω) hJs hJt (v n) hRsub
-  obtain ⟨a, ha, hmass⟩ := ribbon_passage_mass_of_eventually_finite_intervals
-    P κ hκ hκ8 γ hSLE I hI (fun n => ell * v n)
-    (fun n => mul_pos hell (hv n)) hlim' G q hq hG
-    (fun n ω => segmentSausageCharge κ (η n ω) (s n ω) (t n ω) (v n) (Rₙ n))
-    (fun _ _ => True) (c ^ 2 * ell ^ codimension κ) hcoeff htrans
-  exact ⟨a, ha, by simpa only [true_and] using hmass⟩
-
-/-- Almost-sure chart identities suffice; exceptional restart paths are
-removed without changing the probabilities of the retained events. -/
-theorem compact_conformal_stopped_passage_mass_ae
-    {Ω : Type*} [MeasurableSpace Ω] (P : Measure Ω) [IsProbabilityMeasure P]
-    (κ : ℝ) (hκ : 0 < κ) (hκ8 : κ < 8)
-    (γ : Ω → ℝ≥0 → ℂ) (hSLE : IsOrdinaryChordalSLE κ γ P)
-    (Fₙ : ℕ → ℂ → ℂ) (F : ℂ → ℂ)
-    (hFn : ∀ n, DifferentiableOn ℂ (Fₙ n) upperHalfPlane)
-    (hinj : ∀ n, InjOn (Fₙ n) upperHalfPlane)
-    (hF : DifferentiableOn ℂ F upperHalfPlane)
-    (hne : ∀ z ∈ upperHalfPlane, deriv F z ≠ 0)
-    (hconv : TendstoLocallyUniformlyOn Fₙ F atTop upperHalfPlane)
-    (K : Set ℂ) (hK : IsCompact K) (hKn : K.Nonempty) (hKH : K ⊆ upperHalfPlane)
-    (R : Set ℂ) (hR : IsOpen R) (himage : F '' K ⊆ R)
-    (I : Finset (ℝ≥0 × ℝ≥0)) (hI : ∀ J ∈ I, J.1 < J.2)
-    (v : ℕ → ℝ) (hv : ∀ n, 0 < v n) (hlim : Tendsto v atTop (𝓝 0))
-    (η : ℕ → Ω → ℝ≥0 → ℂ) (s t : ℕ → Ω → ℝ≥0) (Rₙ : ℕ → Set ℂ)
-    (G : ℕ → Set Ω) (q : ℝ) (hq : 0 < q)
-    (hG : ∀ᶠ n in atTop, ENNReal.ofReal q ≤ P (G n))
-    (hregion : ∀ᶠ n in atTop, R ⊆ Rₙ n)
-    (hretain : ∀ᶠ n in atTop, ∀ᵐ ω ∂P, ω ∈ G n →
-      ∃ J ∈ I, γ ω '' Icc J.1 J.2 ⊆ K ∧ s n ω ≤ J.1 ∧ J.2 ≤ t n ω ∧
-        EqOn (η n ω) (fun u => Fₙ n (γ ω u)) (Icc J.1 J.2)) :
-    ∃ a : ℝ, 0 < a ∧ ∀ᶠ n in atTop,
-      ENNReal.ofReal (q / 2) ≤ P {ω | ω ∈ G n ∧ ENNReal.ofReal a ≤
-        segmentSausageCharge κ (η n ω) (s n ω) (t n ω) (v n) (Rₙ n)} := by
-  let H (n : ℕ) : Set Ω := {ω | ω ∈ G n ∧
-      ∃ J ∈ I, γ ω '' Icc J.1 J.2 ⊆ K ∧ s n ω ≤ J.1 ∧ J.2 ≤ t n ω ∧
-        EqOn (η n ω) (fun u => Fₙ n (γ ω u)) (Icc J.1 J.2)}
-  have hH : ∀ᶠ n in atTop, ENNReal.ofReal q ≤ P (H n) := by
-    filter_upwards [hG, hretain] with n hn hr
-    have he : H n =ᵐ[P] G n := by
-      filter_upwards [hr] with ω hω
-      exact propext ⟨fun h => h.1, fun h => ⟨h, hω h⟩⟩
-    simpa only [measure_congr he] using hn
-  have hr : ∀ᶠ n in atTop, ∀ ω, ω ∈ H n →
-      ∃ J ∈ I, γ ω '' Icc J.1 J.2 ⊆ K ∧ s n ω ≤ J.1 ∧ J.2 ≤ t n ω ∧
-        EqOn (η n ω) (fun u => Fₙ n (γ ω u)) (Icc J.1 J.2) :=
-    Eventually.of_forall fun _ _ hω => hω.2
-  obtain ⟨a, ha, hm⟩ := compact_conformal_stopped_passage_mass P κ hκ hκ8 γ hSLE
-    Fₙ F hFn hinj hF hne hconv K hK hKn hKH R hR himage I hI v hv hlim
-    η s t Rₙ H q hq hH hregion hr
-  refine ⟨a, ha, ?_⟩
-  filter_upwards [hm] with n hn
-  exact hn.trans (measure_mono fun _ hω => ⟨hω.1.1, hω.2⟩)
-
-/-- Countable compact/time certificates are extracted before choosing the
-common mesh. The selected intervals lie before the actual passage stop. -/
-theorem countable_compact_conformal_stopped_passage_mass
-    {Ω : Type*} [MeasurableSpace Ω] (P : Measure Ω) [IsProbabilityMeasure P]
-    (κ : ℝ) (hκ : 0 < κ) (hκ8 : κ < 8)
-    (γ : Ω → ℝ≥0 → ℂ) (hSLE : IsOrdinaryChordalSLE κ γ P)
-    (Fₙ : ℕ → ℂ → ℂ) (F : ℂ → ℂ)
-    (hFn : ∀ n, DifferentiableOn ℂ (Fₙ n) upperHalfPlane)
-    (hinj : ∀ n, InjOn (Fₙ n) upperHalfPlane)
-    (hF : DifferentiableOn ℂ F upperHalfPlane)
-    (hne : ∀ z ∈ upperHalfPlane, deriv F z ≠ 0)
-    (hconv : TendstoLocallyUniformlyOn Fₙ F atTop upperHalfPlane)
-    (K : ℕ → Set ℂ) (hK : ∀ i, IsCompact (K i)) (hKH : ∀ i, K i ⊆ upperHalfPlane)
-    (R : Set ℂ) (hR : IsOpen R) (himage : ∀ i, F '' K i ⊆ R)
-    (J : ℕ → ℝ≥0 × ℝ≥0) (hJ : ∀ i, (J i).1 < (J i).2)
-    (E : Set Ω) (D : ℕ → Set Ω) (hE : MeasurableSet E) (hD : ∀ i, MeasurableSet (D i))
-    (hcover : P (E \ ⋃ i, D i) = 0)
-    (hretain : ∀ i ω, ω ∈ D i → γ ω '' Icc (J i).1 (J i).2 ⊆ K i)
-    (v : ℕ → ℝ) (hv : ∀ n, 0 < v n) (hlim : Tendsto v atTop (𝓝 0))
-    (η : ℕ → Ω → ℝ≥0 → ℂ) (s t : ℕ → Ω → ℝ≥0) (Rₙ : ℕ → Set ℂ)
-    (hregion : ∀ᶠ n in atTop, R ⊆ Rₙ n)
-    (G : ℕ → Set Ω) (q : ℝ) (hq : 0 < q)
-    (hG : ∀ n, ENNReal.ofReal q ≤ P (G n ∩ E))
-    (hwindow : ∀ i, ∀ᶠ n in atTop, ∀ ω, ω ∈ G n ∩ E ∩ D i →
-      s n ω ≤ (J i).1 ∧ (J i).2 ≤ t n ω ∧
-        EqOn (η n ω) (fun u => Fₙ n (γ ω u)) (Icc (J i).1 (J i).2)) :
-    ∃ a : ℝ, 0 < a ∧ ∀ᶠ n in atTop,
-      ENNReal.ofReal (q / 4) ≤ P {ω | ω ∈ G n ∩ E ∧ ENNReal.ofReal a ≤
-        segmentSausageCharge κ (η n ω) (s n ω) (t n ω) (v n) (Rₙ n)} := by
-  classical
-  obtain ⟨N, hN⟩ := varying_events_after_finite_retention P E D G hE hD hcover q hq hG
-  let A := ⋃ i ∈ Finset.range N, D i
-  let Q := ⋃ i ∈ Finset.range N, K i
-  let H : ℕ → Set Ω := fun n => G n ∩ E ∩ A
-  have hQ : IsCompact Q := (Finset.range N).isCompact_biUnion (fun i _ => hK i)
-  have hQH : Q ⊆ upperHalfPlane := iUnion₂_subset (fun i _ => hKH i)
-  have hQR : F '' Q ⊆ R := by
-    rintro w ⟨z, hz, rfl⟩
-    obtain ⟨i, _, hi⟩ := mem_iUnion₂.mp hz
-    exact himage i (mem_image_of_mem F hi)
-  have hQn : Q.Nonempty := by
-    have hHpos : 0 < P (H 0) := (ENNReal.ofReal_pos.mpr (by positivity : 0 < q / 2)).trans_le (hN 0)
-    obtain ⟨ω, hω⟩ := nonempty_of_measure_ne_zero hHpos.ne'
-    obtain ⟨i, hi, hDi⟩ := mem_iUnion₂.mp hω.2
-    exact ⟨γ ω (J i).1, mem_iUnion₂.mpr ⟨i, hi,
-      hretain i ω hDi (mem_image_of_mem (γ ω) ⟨le_rfl, (hJ i).le⟩)⟩⟩
-  let I := (Finset.range N).image J
-  have hI : ∀ L ∈ I, L.1 < L.2 := by
-    intro L hL
-    obtain ⟨i, _, rfl⟩ := Finset.mem_image.mp hL
-    exact hJ i
-  have hwin : ∀ᶠ n in atTop, ∀ i ∈ Finset.range N, ∀ ω, ω ∈ G n ∩ E ∩ D i →
-      s n ω ≤ (J i).1 ∧ (J i).2 ≤ t n ω ∧
-        EqOn (η n ω) (fun u => Fₙ n (γ ω u)) (Icc (J i).1 (J i).2) :=
-    (Finset.eventually_all _).mpr (fun i _ => hwindow i)
-  have hr : ∀ᶠ n in atTop, ∀ ω, ω ∈ H n →
-      ∃ L ∈ I, γ ω '' Icc L.1 L.2 ⊆ Q ∧ s n ω ≤ L.1 ∧ L.2 ≤ t n ω ∧
-        EqOn (η n ω) (fun u => Fₙ n (γ ω u)) (Icc L.1 L.2) := by
-    filter_upwards [hwin] with n hn
-    intro ω hω
-    obtain ⟨i, hi, hDi⟩ := mem_iUnion₂.mp hω.2
-    exact ⟨J i, Finset.mem_image.mpr ⟨i, hi, rfl⟩,
-      (hretain i ω hDi).trans (subset_iUnion₂_of_subset i hi Subset.rfl),
-      hn i hi ω ⟨hω.1, hDi⟩⟩
-  obtain ⟨a, ha, hmass⟩ := compact_conformal_stopped_passage_mass P κ hκ hκ8 γ hSLE
-    Fₙ F hFn hinj hF hne hconv Q hQ hQn hQH R hR hQR I hI v hv hlim
-    η s t Rₙ H (q / 2) (by positivity) (Eventually.of_forall hN) hregion hr
-  refine ⟨a, ha, ?_⟩
-  filter_upwards [hmass] with n hn
-  have hqq : q / 2 / 2 = q / 4 := by ring
-  rw [hqq] at hn
-  exact hn.trans (measure_mono (fun _ hω => ⟨hω.1.1, hω.2⟩))
-
-end SLEExactGauge
-
-end
-
-end OAI
+import OAI.Probability.SLE.Mass.CompactConformalPassageMass
+
+namespace OAI
+
+/-! Retained sausage mass before the actual passage stop. The physical
+curve may include boundary visits; only its retained interior interval is
+identified with the conformal image. All mass is charged to the prescribed
+stopped segment, rather than to later portions of the whole trace. -/
+
+noncomputable section
+open Set Filter MeasureTheory
+open scoped Topology ENNReal NNReal
+
+namespace SLEExactGauge
+
+def segmentSausageCharge (κ : ℝ) (η : ℝ≥0 → ℂ) (s t : ℝ≥0)
+    (v : ℝ) (R : Set ℂ) : ℝ≥0∞ :=
+  ENNReal.ofReal (v ^ (-codimension κ)) * volume (R ∩ sourceSausageSet η s t v)
+
+theorem sourceSausageSet_mono_interval
+    (η : ℝ≥0 → ℂ) {s t a b : ℝ≥0} (hsa : s ≤ a) (hbt : b ≤ t) (v : ℝ) :
+    sourceSausageSet η a b v ⊆ sourceSausageSet η s t v := by
+  rintro z ⟨u, hu, hd⟩
+  exact ⟨u, ⟨hsa.trans hu.1, hu.2.trans hbt⟩, hd⟩
+
+theorem sourceSausageSet_congr_interval
+    {η ξ : ℝ≥0 → ℂ} {s t : ℝ≥0} (heq : EqOn η ξ (Icc s t)) (v : ℝ) :
+    sourceSausageSet η s t v = sourceSausageSet ξ s t v := by
+  ext z
+  constructor <;> rintro ⟨u, hu, hd⟩
+  · exact ⟨u, hu, by simpa only [heq hu] using hd⟩
+  · exact ⟨u, hu, by simpa only [heq hu] using hd⟩
+
+theorem segmentSausageCharge_mono
+    (κ : ℝ) (η : ℝ≥0 → ℂ) {s t a b : ℝ≥0}
+    (hsa : s ≤ a) (hbt : b ≤ t) (v : ℝ) {R S : Set ℂ} (hRS : R ⊆ S) :
+    segmentSausageCharge κ η a b v R ≤ segmentSausageCharge κ η s t v S :=
+  mul_le_mul' le_rfl (measure_mono (inter_subset_inter hRS
+    (sourceSausageSet_mono_interval η hsa hbt v)))
+
+/-- The finite-list conformal transfer charges only the actual stopped
+physical passage. Its values at parameter-boundary times can be supplied by
+the boundary-safe restart theorem. -/
+theorem compact_conformal_stopped_passage_mass
+    {Ω : Type*} [MeasurableSpace Ω] (P : Measure Ω) [IsProbabilityMeasure P]
+    (κ : ℝ) (hκ : 0 < κ) (hκ8 : κ < 8)
+    (γ : Ω → ℝ≥0 → ℂ) (hSLE : IsOrdinaryChordalSLE κ γ P)
+    (Fₙ : ℕ → ℂ → ℂ) (F : ℂ → ℂ)
+    (hFn : ∀ n, DifferentiableOn ℂ (Fₙ n) upperHalfPlane)
+    (hinj : ∀ n, InjOn (Fₙ n) upperHalfPlane)
+    (hF : DifferentiableOn ℂ F upperHalfPlane)
+    (hne : ∀ z ∈ upperHalfPlane, deriv F z ≠ 0)
+    (hconv : TendstoLocallyUniformlyOn Fₙ F atTop upperHalfPlane)
+    (K : Set ℂ) (hK : IsCompact K) (hKn : K.Nonempty) (hKH : K ⊆ upperHalfPlane)
+    (R : Set ℂ) (hR : IsOpen R) (himage : F '' K ⊆ R)
+    (I : Finset (ℝ≥0 × ℝ≥0)) (hI : ∀ J ∈ I, J.1 < J.2)
+    (v : ℕ → ℝ) (hv : ∀ n, 0 < v n) (hlim : Tendsto v atTop (𝓝 0))
+    (η : ℕ → Ω → ℝ≥0 → ℂ) (s t : ℕ → Ω → ℝ≥0) (Rₙ : ℕ → Set ℂ)
+    (G : ℕ → Set Ω) (q : ℝ) (hq : 0 < q)
+    (hG : ∀ᶠ n in atTop, ENNReal.ofReal q ≤ P (G n))
+    (hregion : ∀ᶠ n in atTop, R ⊆ Rₙ n)
+    (hretain : ∀ᶠ n in atTop, ∀ ω, ω ∈ G n →
+      ∃ J ∈ I, γ ω '' Icc J.1 J.2 ⊆ K ∧ s n ω ≤ J.1 ∧ J.2 ≤ t n ω ∧
+        EqOn (η n ω) (fun u => Fₙ n (γ ω u)) (Icc J.1 J.2)) :
+    ∃ a : ℝ, 0 < a ∧ ∀ᶠ n in atTop,
+      ENNReal.ofReal (q / 2) ≤ P {ω | ω ∈ G n ∧ ENNReal.ofReal a ≤
+        segmentSausageCharge κ (η n ω) (s n ω) (t n ω) (v n) (Rₙ n)} := by
+  obtain ⟨c, ell, v₀, hc, hell, hv₀, htransfer⟩ := eventually_compact_sausage_transfer
+    κ Fₙ F hFn hinj hF hne hconv K hK hKn hKH R hR himage
+  have hcoeff : 0 < c ^ 2 * ell ^ codimension κ :=
+    mul_pos (sq_pos_of_pos hc) (Real.rpow_pos_of_pos hell _)
+  have hsmall : ∀ᶠ n in atTop, v n < v₀ := hlim.eventually (gt_mem_nhds hv₀)
+  have hlim' : Tendsto (fun n => ell * v n) atTop (𝓝 0) := by
+    simpa only [mul_zero] using tendsto_const_nhds.mul hlim
+  have htrans : ∀ᶠ n in atTop, ∀ ω, ω ∈ G n → True ∧
+      ∃ J ∈ I, ENNReal.ofReal (c ^ 2 * ell ^ codimension κ) *
+        sourceSausageMass κ (γ ω) J.1 J.2 (ell * v n) ≤
+        segmentSausageCharge κ (η n ω) (s n ω) (t n ω) (v n) (Rₙ n) := by
+    filter_upwards [htransfer, hretain, hsmall, hregion] with n hn hr hs hRsub
+    intro ω hω
+    obtain ⟨J, hJI, hJK, hJs, hJt, heq⟩ := hr ω hω
+    refine ⟨trivial, J, hJI, (hn (γ ω) J.1 J.2 hJK (v n) (hv n) hs).trans ?_⟩
+    change segmentSausageCharge κ (fun u => Fₙ n (γ ω u)) J.1 J.2 (v n) R ≤ _
+    have hsausage := sourceSausageSet_congr_interval heq (v n)
+    unfold segmentSausageCharge
+    rw [← hsausage]
+    exact segmentSausageCharge_mono κ (η n ω) hJs hJt (v n) hRsub
+  obtain ⟨a, ha, hmass⟩ := ribbon_passage_mass_of_eventually_finite_intervals
+    P κ hκ hκ8 γ hSLE I hI (fun n => ell * v n)
+    (fun n => mul_pos hell (hv n)) hlim' G q hq hG
+    (fun n ω => segmentSausageCharge κ (η n ω) (s n ω) (t n ω) (v n) (Rₙ n))
+    (fun _ _ => True) (c ^ 2 * ell ^ codimension κ) hcoeff htrans
+  exact ⟨a, ha, by simpa only [true_and] using hmass⟩
+
+/-- Almost-sure chart identities suffice; exceptional restart paths are
+removed without changing the probabilities of the retained events. -/
+theorem compact_conformal_stopped_passage_mass_ae
+    {Ω : Type*} [MeasurableSpace Ω] (P : Measure Ω) [IsProbabilityMeasure P]
+    (κ : ℝ) (hκ : 0 < κ) (hκ8 : κ < 8)
+    (γ : Ω → ℝ≥0 → ℂ) (hSLE : IsOrdinaryChordalSLE κ γ P)
+    (Fₙ : ℕ → ℂ → ℂ) (F : ℂ → ℂ)
+    (hFn : ∀ n, DifferentiableOn ℂ (Fₙ n) upperHalfPlane)
+    (hinj : ∀ n, InjOn (Fₙ n) upperHalfPlane)
+    (hF : DifferentiableOn ℂ F upperHalfPlane)
+    (hne : ∀ z ∈ upperHalfPlane, deriv F z ≠ 0)
+    (hconv : TendstoLocallyUniformlyOn Fₙ F atTop upperHalfPlane)
+    (K : Set ℂ) (hK : IsCompact K) (hKn : K.Nonempty) (hKH : K ⊆ upperHalfPlane)
+    (R : Set ℂ) (hR : IsOpen R) (himage : F '' K ⊆ R)
+    (I : Finset (ℝ≥0 × ℝ≥0)) (hI : ∀ J ∈ I, J.1 < J.2)
+    (v : ℕ → ℝ) (hv : ∀ n, 0 < v n) (hlim : Tendsto v atTop (𝓝 0))
+    (η : ℕ → Ω → ℝ≥0 → ℂ) (s t : ℕ → Ω → ℝ≥0) (Rₙ : ℕ → Set ℂ)
+    (G : ℕ → Set Ω) (q : ℝ) (hq : 0 < q)
+    (hG : ∀ᶠ n in atTop, ENNReal.ofReal q ≤ P (G n))
+    (hregion : ∀ᶠ n in atTop, R ⊆ Rₙ n)
+    (hretain : ∀ᶠ n in atTop, ∀ᵐ ω ∂P, ω ∈ G n →
+      ∃ J ∈ I, γ ω '' Icc J.1 J.2 ⊆ K ∧ s n ω ≤ J.1 ∧ J.2 ≤ t n ω ∧
+        EqOn (η n ω) (fun u => Fₙ n (γ ω u)) (Icc J.1 J.2)) :
+    ∃ a : ℝ, 0 < a ∧ ∀ᶠ n in atTop,
+      ENNReal.ofReal (q / 2) ≤ P {ω | ω ∈ G n ∧ ENNReal.ofReal a ≤
+        segmentSausageCharge κ (η n ω) (s n ω) (t n ω) (v n) (Rₙ n)} := by
+  let H (n : ℕ) : Set Ω := {ω | ω ∈ G n ∧
+      ∃ J ∈ I, γ ω '' Icc J.1 J.2 ⊆ K ∧ s n ω ≤ J.1 ∧ J.2 ≤ t n ω ∧
+        EqOn (η n ω) (fun u => Fₙ n (γ ω u)) (Icc J.1 J.2)}
+  have hH : ∀ᶠ n in atTop, ENNReal.ofReal q ≤ P (H n) := by
+    filter_upwards [hG, hretain] with n hn hr
+    have he : H n =ᵐ[P] G n := by
+      filter_upwards [hr] with ω hω
+      exact propext ⟨fun h => h.1, fun h => ⟨h, hω h⟩⟩
+    simpa only [measure_congr he] using hn
+  have hr : ∀ᶠ n in atTop, ∀ ω, ω ∈ H n →
+      ∃ J ∈ I, γ ω '' Icc J.1 J.2 ⊆ K ∧ s n ω ≤ J.1 ∧ J.2 ≤ t n ω ∧
+        EqOn (η n ω) (fun u => Fₙ n (γ ω u)) (Icc J.1 J.2) :=
+    Eventually.of_forall fun _ _ hω => hω.2
+  obtain ⟨a, ha, hm⟩ := compact_conformal_stopped_passage_mass P κ hκ hκ8 γ hSLE
+    Fₙ F hFn hinj hF hne hconv K hK hKn hKH R hR himage I hI v hv hlim
+    η s t Rₙ H q hq hH hregion hr
+  refine ⟨a, ha, ?_⟩
+  filter_upwards [hm] with n hn
+  exact hn.trans (measure_mono fun _ hω => ⟨hω.1.1, hω.2⟩)
+
+/-- Countable compact/time certificates are extracted before choosing the
+common mesh. The selected intervals lie before the actual passage stop. -/
+theorem countable_compact_conformal_stopped_passage_mass
+    {Ω : Type*} [MeasurableSpace Ω] (P : Measure Ω) [IsProbabilityMeasure P]
+    (κ : ℝ) (hκ : 0 < κ) (hκ8 : κ < 8)
+    (γ : Ω → ℝ≥0 → ℂ) (hSLE : IsOrdinaryChordalSLE κ γ P)
+    (Fₙ : ℕ → ℂ → ℂ) (F : ℂ → ℂ)
+    (hFn : ∀ n, DifferentiableOn ℂ (Fₙ n) upperHalfPlane)
+    (hinj : ∀ n, InjOn (Fₙ n) upperHalfPlane)
+    (hF : DifferentiableOn ℂ F upperHalfPlane)
+    (hne : ∀ z ∈ upperHalfPlane, deriv F z ≠ 0)
+    (hconv : TendstoLocallyUniformlyOn Fₙ F atTop upperHalfPlane)
+    (K : ℕ → Set ℂ) (hK : ∀ i, IsCompact (K i)) (hKH : ∀ i, K i ⊆ upperHalfPlane)
+    (R : Set ℂ) (hR : IsOpen R) (himage : ∀ i, F '' K i ⊆ R)
+    (J : ℕ → ℝ≥0 × ℝ≥0) (hJ : ∀ i, (J i).1 < (J i).2)
+    (E : Set Ω) (D : ℕ → Set Ω) (hE : MeasurableSet E) (hD : ∀ i, MeasurableSet (D i))
+    (hcover : P (E \ ⋃ i, D i) = 0)
+    (hretain : ∀ i ω, ω ∈ D i → γ ω '' Icc (J i).1 (J i).2 ⊆ K i)
+    (v : ℕ → ℝ) (hv : ∀ n, 0 < v n) (hlim : Tendsto v atTop (𝓝 0))
+    (η : ℕ → Ω → ℝ≥0 → ℂ) (s t : ℕ → Ω → ℝ≥0) (Rₙ : ℕ → Set ℂ)
+    (hregion : ∀ᶠ n in atTop, R ⊆ Rₙ n)
+    (G : ℕ → Set Ω) (q : ℝ) (hq : 0 < q)
+    (hG : ∀ n, ENNReal.ofReal q ≤ P (G n ∩ E))
+    (hwindow : ∀ i, ∀ᶠ n in atTop, ∀ ω, ω ∈ G n ∩ E ∩ D i →
+      s n ω ≤ (J i).1 ∧ (J i).2 ≤ t n ω ∧
+        EqOn (η n ω) (fun u => Fₙ n (γ ω u)) (Icc (J i).1 (J i).2)) :
+    ∃ a : ℝ, 0 < a ∧ ∀ᶠ n in atTop,
+      ENNReal.ofReal (q / 4) ≤ P {ω | ω ∈ G n ∩ E ∧ ENNReal.ofReal a ≤
+        segmentSausageCharge κ (η n ω) (s n ω) (t n ω) (v n) (Rₙ n)} := by
+  classical
+  obtain ⟨N, hN⟩ := varying_events_after_finite_retention P E D G hE hD hcover q hq hG
+  let A := ⋃ i ∈ Finset.range N, D i
+  let Q := ⋃ i ∈ Finset.range N, K i
+  let H : ℕ → Set Ω := fun n => G n ∩ E ∩ A
+  have hQ : IsCompact Q := (Finset.range N).isCompact_biUnion (fun i _ => hK i)
+  have hQH : Q ⊆ upperHalfPlane := iUnion₂_subset (fun i _ => hKH i)
+  have hQR : F '' Q ⊆ R := by
+    rintro w ⟨z, hz, rfl⟩
+    obtain ⟨i, _, hi⟩ := mem_iUnion₂.mp hz
+    exact himage i (mem_image_of_mem F hi)
+  have hQn : Q.Nonempty := by
+    have hHpos : 0 < P (H 0) := (ENNReal.ofReal_pos.mpr (by positivity : 0 < q / 2)).trans_le (hN 0)
+    obtain ⟨ω, hω⟩ := nonempty_of_measure_ne_zero hHpos.ne'
+    obtain ⟨i, hi, hDi⟩ := mem_iUnion₂.mp hω.2
+    exact ⟨γ ω (J i).1, mem_iUnion₂.mpr ⟨i, hi,
+      hretain i ω hDi (mem_image_of_mem (γ ω) ⟨le_rfl, (hJ i).le⟩)⟩⟩
+  let I := (Finset.range N).image J
+  have hI : ∀ L ∈ I, L.1 < L.2 := by
+    intro L hL
+    obtain ⟨i, _, rfl⟩ := Finset.mem_image.mp hL
+    exact hJ i
+  have hwin : ∀ᶠ n in atTop, ∀ i ∈ Finset.range N, ∀ ω, ω ∈ G n ∩ E ∩ D i →
+      s n ω ≤ (J i).1 ∧ (J i).2 ≤ t n ω ∧
+        EqOn (η n ω) (fun u => Fₙ n (γ ω u)) (Icc (J i).1 (J i).2) :=
+    (Finset.eventually_all _).mpr (fun i _ => hwindow i)
+  have hr : ∀ᶠ n in atTop, ∀ ω, ω ∈ H n →
+      ∃ L ∈ I, γ ω '' Icc L.1 L.2 ⊆ Q ∧ s n ω ≤ L.1 ∧ L.2 ≤ t n ω ∧
+        EqOn (η n ω) (fun u => Fₙ n (γ ω u)) (Icc L.1 L.2) := by
+    filter_upwards [hwin] with n hn
+    intro ω hω
+    obtain ⟨i, hi, hDi⟩ := mem_iUnion₂.mp hω.2
+    exact ⟨J i, Finset.mem_image.mpr ⟨i, hi, rfl⟩,
+      (hretain i ω hDi).trans (subset_iUnion₂_of_subset i hi Subset.rfl),
+      hn i hi ω ⟨hω.1, hDi⟩⟩
+  obtain ⟨a, ha, hmass⟩ := compact_conformal_stopped_passage_mass P κ hκ hκ8 γ hSLE
+    Fₙ F hFn hinj hF hne hconv Q hQ hQn hQH R hR hQR I hI v hv hlim
+    η s t Rₙ H (q / 2) (by positivity) (Eventually.of_forall hN) hregion hr
+  refine ⟨a, ha, ?_⟩
+  filter_upwards [hmass] with n hn
+  have hqq : q / 2 / 2 = q / 4 := by ring
+  rw [hqq] at hn
+  exact hn.trans (measure_mono (fun _ hω => ⟨hω.1.1, hω.2⟩))
+
+end SLEExactGauge
+
+end
+
+end OAI

lean/OAI/Probability/SLE/Mass/StoppedInverseMass.lean

@@ -1,105 +1,105 @@
-import OAI.Probability.SLE.Geometry.RestartDerivativeMeasurability
-import OAI.Probability.SLE.Geometry.CanonicalRawMean
-import OAI.Probability.SLE.Mass.WeightedImageRandomMass
-
-namespace OAI
-
-/-! Actual stopped inverse-Loewner transport of the fresh raw terminal
-mass, with measurable charts, derivative weights and exact spatial tests. -/
-
-noncomputable section
-open Set Filter _root_.MeasureTheory _root_.OAI.MeasureTheory ProbabilityTheory Classical
-open scoped NNReal ENNReal Topology
-
-namespace SLEExactGauge.Multipoint
-
-local instance : LocallyCompactSpace upperHalfPlane := isOpen_upperHalfPlane.locallyCompactSpace
-local instance : MeasurableSpace C(ℝ≥0,ℝ) := borel _
-local instance : BorelSpace C(ℝ≥0,ℝ) := ⟨rfl⟩
-
-variable {Ω : Type*} [mΩ : MeasurableSpace Ω]
-  (B : ℝ≥0 → Ω → ℝ) (κ : ℝ) (γ : Ω → ℝ≥0 → ℂ)
-  (G F : Ω → ℝ≥0 → ℂ → ℂ)
-  (hw : ∀ ω, IsCapacityTwoWitness (fun t => Real.sqrt κ*B t ω) (γ ω) (G ω) (F ω))
-  (τ : Ω → ℝ≥0)
-
-def stoppedMassPoint (ω : Ω) (z : upperHalfPlane) : upperHalfPlane :=
-  ⟨F ω (τ ω) ((z:ℂ)+(Real.sqrt κ*B (τ ω) ω:ℝ)),
-    ((hw ω).2.2.2.2.2.2.1 (τ ω) (by
-      simpa only [upperHalfPlane,mem_ofPred_eq,Complex.add_im,Complex.ofReal_im,add_zero]
-        using z.property)).1.1⟩
-
-def stoppedMassWeight (ω : Ω) (z : upperHalfPlane) : ℝ≥0∞ :=
-  ENNReal.ofReal (‖deriv (F ω (τ ω)) ((z:ℂ)+(Real.sqrt κ*B (τ ω) ω:ℝ))‖^dimension κ)
-
-variable (hm : ∀ t, Measurable (B t)) (hc : ∀ ω, Continuous (fun t => B t ω))
-  (hτ : IsStoppingTime (Filtration.natural B (fun t => (hm t).stronglyMeasurable))
-    (fun ω => (τ ω:WithTop ℝ≥0)))
-
-include hm hc hτ γ G hw
-
-theorem stoppedMassPoint_measurable : Measurable[hτ.measurableSpace.prod inferInstance]
-    (fun p : Ω × upperHalfPlane => stoppedMassPoint B κ γ G F hw τ p.1 p.2) := by
-  unfold stoppedMassPoint
-  apply Measurable.subtype_mk
-  exact continuous_eval.measurable.comp
-    (((source_stopped_inversePath_measurable B hm hc κ γ G F hw τ hτ).comp
-      measurable_fst).prodMk measurable_snd)
-
-theorem stoppedMassWeight_measurable (hκ : 0 < κ) :
-    Measurable[hτ.measurableSpace.prod inferInstance]
-      (fun p : Ω × upperHalfPlane => stoppedMassWeight B κ F τ p.1 p.2) := by
-  let : MeasurableSpace (Ω × upperHalfPlane) := hτ.measurableSpace.prod inferInstance
-  have hd := source_stopped_inverse_derivative_measurable B hm hc κ γ G F hw τ hτ
-  have he : 0 ≤ dimension κ := by unfold dimension; linarith
-  exact ((Real.continuous_rpow_const he).measurable.comp hd.norm).ennreal_ofReal
-
-omit hm hτ in
-def stoppedFreshTerminalMass (R : RawCanonicalMass) (ω : Ω) : Measure upperHalfPlane :=
-  weightedImageMass (stoppedMassPoint B κ γ G F hw τ ω) (stoppedMassWeight B κ F τ ω)
-    (R.terminal (sourceRestartDriverPath B hc τ ω))
-
-theorem stoppedFreshTerminalMass_measurable (hκ : 0 < κ) (R : RawCanonicalMass) :
-    Measurable (stoppedFreshTerminalMass B κ γ G F hw τ hc R) := by
-  have hY : Measurable (sourceRestartDriverPath B hc τ) := source_path_measurable _
-    (fun t => (measurable_pi_apply t).comp
-      (brownianRestart_measurable hm hc (stopping_time_measurable_nnreal hτ)))
-  have hM := @weightedImageMass_measurable_of_subsigma Ω upperHalfPlane mΩ inferInstance
-    hτ.measurableSpace hτ.measurableSpace_le
-    (fun ω => R.terminal (sourceRestartDriverPath B hc τ ω))
-    (R.terminal_measurable.comp hY) (fun ω => (R.terminal_radon _).2)
-    (fun p => stoppedMassPoint B κ γ G F hw τ p.1 p.2)
-    (stoppedMassPoint_measurable B κ γ G F hw τ hm hc hτ)
-    (fun p => stoppedMassWeight B κ F τ p.1 p.2)
-    (stoppedMassWeight_measurable B κ γ G F hw τ hm hc hτ hκ)
-  exact hM
-
-theorem CanonicalMass.stoppedFreshTerminalMass_test
-    {P : Measure Ω} [IsProbabilityMeasure P] {hBm : Measurable (Function.uncurry B)}
-    (C : CanonicalMass P κ B hBm γ G) (hB : IsBrownianReal B P) (hκ : 0 < κ)
-    (R : RawCanonicalMass)
-    (he : ∀ᵐ ω ∂P, R.terminal (sourceDriverPath B hc ω) = C.rational.terminal ω)
-    (f : Ω × upperHalfPlane → ℝ≥0∞)
-    (hf : Measurable[hτ.measurableSpace.prod inferInstance] f) :
-    (∫⁻ ω, ∫⁻ x, f (ω,x) ∂(stoppedFreshTerminalMass B κ γ G F hw τ hc R ω) ∂P) =
-      ∫⁻ ω, ∫⁻ z, stoppedMassWeight B κ F τ ω z *
-        f (ω,stoppedMassPoint B κ γ G F hw τ ω z) ∂initialGreenMeasure κ ∂P := by
-  have hp : Measurable (sourceDriverPath B hc) := source_path_measurable _ hm
-  let : IsProbabilityMeasure (P.map (sourceDriverPath B hc)) :=
-    (Measure.isProbabilityMeasure_map_iff hp.aemeasurable).mpr inferInstance
-  have hY : Measurable (sourceRestartDriverPath B hc τ) := source_path_measurable _
-    (fun t => (measurable_pi_apply t).comp
-      (brownianRestart_measurable hm hc (stopping_time_measurable_nnreal hτ)))
-  have h := restart_weighted_mass_test P (P.map (sourceDriverPath B hc))
-    hτ.measurableSpace hτ.measurableSpace_le (sourceRestartDriverPath B hc τ) hY
-    (fun A hA => source_restart_continuous_driver_law hB hm hc τ hτ hA)
-    R.terminal R.terminal_measurable (fun p => (R.terminal_radon p).2) _
-    (stoppedMassPoint_measurable B κ γ G F hw τ hm hc hτ) _
-    (stoppedMassWeight_measurable B κ γ G F hw τ hm hc hτ hκ) f hf
-  rwa [C.raw_terminal_mean hc R he] at h
-
-end SLEExactGauge.Multipoint
-
-end
-
-end OAI
+import OAI.Probability.SLE.Geometry.RestartDerivativeMeasurability
+import OAI.Probability.SLE.Geometry.CanonicalRawMean
+import OAI.Probability.SLE.Mass.WeightedImageRandomMass
+
+namespace OAI
+
+/-! Actual stopped inverse-Loewner transport of the fresh raw terminal
+mass, with measurable charts, derivative weights and exact spatial tests. -/
+
+noncomputable section
+open Set Filter _root_.MeasureTheory _root_.OAI.MeasureTheory ProbabilityTheory Classical
+open scoped NNReal ENNReal Topology
+
+namespace SLEExactGauge.Multipoint
+
+local instance : LocallyCompactSpace upperHalfPlane := isOpen_upperHalfPlane.locallyCompactSpace
+local instance : MeasurableSpace C(ℝ≥0,ℝ) := borel _
+local instance : BorelSpace C(ℝ≥0,ℝ) := ⟨rfl⟩
+
+variable {Ω : Type*} [mΩ : MeasurableSpace Ω]
+  (B : ℝ≥0 → Ω → ℝ) (κ : ℝ) (γ : Ω → ℝ≥0 → ℂ)
+  (G F : Ω → ℝ≥0 → ℂ → ℂ)
+  (hw : ∀ ω, IsCapacityTwoWitness (fun t => Real.sqrt κ*B t ω) (γ ω) (G ω) (F ω))
+  (τ : Ω → ℝ≥0)
+
+def stoppedMassPoint (ω : Ω) (z : upperHalfPlane) : upperHalfPlane :=
+  ⟨F ω (τ ω) ((z:ℂ)+(Real.sqrt κ*B (τ ω) ω:ℝ)),
+    ((hw ω).2.2.2.2.2.2.1 (τ ω) (by
+      simpa only [upperHalfPlane,mem_ofPred_eq,Complex.add_im,Complex.ofReal_im,add_zero]
+        using z.property)).1.1⟩
+
+def stoppedMassWeight (ω : Ω) (z : upperHalfPlane) : ℝ≥0∞ :=
+  ENNReal.ofReal (‖deriv (F ω (τ ω)) ((z:ℂ)+(Real.sqrt κ*B (τ ω) ω:ℝ))‖^dimension κ)
+
+variable (hm : ∀ t, Measurable (B t)) (hc : ∀ ω, Continuous (fun t => B t ω))
+  (hτ : IsStoppingTime (Filtration.natural B (fun t => (hm t).stronglyMeasurable))
+    (fun ω => (τ ω:WithTop ℝ≥0)))
+
+include hm hc hτ γ G hw
+
+theorem stoppedMassPoint_measurable : Measurable[hτ.measurableSpace.prod inferInstance]
+    (fun p : Ω × upperHalfPlane => stoppedMassPoint B κ γ G F hw τ p.1 p.2) := by
+  unfold stoppedMassPoint
+  apply Measurable.subtype_mk
+  exact continuous_eval.measurable.comp
+    (((source_stopped_inversePath_measurable B hm hc κ γ G F hw τ hτ).comp
+      measurable_fst).prodMk measurable_snd)
+
+theorem stoppedMassWeight_measurable (hκ : 0 < κ) :
+    Measurable[hτ.measurableSpace.prod inferInstance]
+      (fun p : Ω × upperHalfPlane => stoppedMassWeight B κ F τ p.1 p.2) := by
+  let : MeasurableSpace (Ω × upperHalfPlane) := hτ.measurableSpace.prod inferInstance
+  have hd := source_stopped_inverse_derivative_measurable B hm hc κ γ G F hw τ hτ
+  have he : 0 ≤ dimension κ := by unfold dimension; linarith
+  exact ((Real.continuous_rpow_const he).measurable.comp hd.norm).ennreal_ofReal
+
+omit hm hτ in
+def stoppedFreshTerminalMass (R : RawCanonicalMass) (ω : Ω) : Measure upperHalfPlane :=
+  weightedImageMass (stoppedMassPoint B κ γ G F hw τ ω) (stoppedMassWeight B κ F τ ω)
+    (R.terminal (sourceRestartDriverPath B hc τ ω))
+
+theorem stoppedFreshTerminalMass_measurable (hκ : 0 < κ) (R : RawCanonicalMass) :
+    Measurable (stoppedFreshTerminalMass B κ γ G F hw τ hc R) := by
+  have hY : Measurable (sourceRestartDriverPath B hc τ) := source_path_measurable _
+    (fun t => (measurable_pi_apply t).comp
+      (brownianRestart_measurable hm hc (stopping_time_measurable_nnreal hτ)))
+  have hM := @weightedImageMass_measurable_of_subsigma Ω upperHalfPlane mΩ inferInstance
+    hτ.measurableSpace hτ.measurableSpace_le
+    (fun ω => R.terminal (sourceRestartDriverPath B hc τ ω))
+    (R.terminal_measurable.comp hY) (fun ω => (R.terminal_radon _).2)
+    (fun p => stoppedMassPoint B κ γ G F hw τ p.1 p.2)
+    (stoppedMassPoint_measurable B κ γ G F hw τ hm hc hτ)
+    (fun p => stoppedMassWeight B κ F τ p.1 p.2)
+    (stoppedMassWeight_measurable B κ γ G F hw τ hm hc hτ hκ)
+  exact hM
+
+theorem CanonicalMass.stoppedFreshTerminalMass_test
+    {P : Measure Ω} [IsProbabilityMeasure P] {hBm : Measurable (Function.uncurry B)}
+    (C : CanonicalMass P κ B hBm γ G) (hB : IsBrownianReal B P) (hκ : 0 < κ)
+    (R : RawCanonicalMass)
+    (he : ∀ᵐ ω ∂P, R.terminal (sourceDriverPath B hc ω) = C.rational.terminal ω)
+    (f : Ω × upperHalfPlane → ℝ≥0∞)
+    (hf : Measurable[hτ.measurableSpace.prod inferInstance] f) :
+    (∫⁻ ω, ∫⁻ x, f (ω,x) ∂(stoppedFreshTerminalMass B κ γ G F hw τ hc R ω) ∂P) =
+      ∫⁻ ω, ∫⁻ z, stoppedMassWeight B κ F τ ω z *
+        f (ω,stoppedMassPoint B κ γ G F hw τ ω z) ∂initialGreenMeasure κ ∂P := by
+  have hp : Measurable (sourceDriverPath B hc) := source_path_measurable _ hm
+  let : IsProbabilityMeasure (P.map (sourceDriverPath B hc)) :=
+    (Measure.isProbabilityMeasure_map_iff hp.aemeasurable).mpr inferInstance
+  have hY : Measurable (sourceRestartDriverPath B hc τ) := source_path_measurable _
+    (fun t => (measurable_pi_apply t).comp
+      (brownianRestart_measurable hm hc (stopping_time_measurable_nnreal hτ)))
+  have h := restart_weighted_mass_test P (P.map (sourceDriverPath B hc))
+    hτ.measurableSpace hτ.measurableSpace_le (sourceRestartDriverPath B hc τ) hY
+    (fun A hA => source_restart_continuous_driver_law hB hm hc τ hτ hA)
+    R.terminal R.terminal_measurable (fun p => (R.terminal_radon p).2) _
+    (stoppedMassPoint_measurable B κ γ G F hw τ hm hc hτ) _
+    (stoppedMassWeight_measurable B κ γ G F hw τ hm hc hτ hκ) f hf
+  rwa [C.raw_terminal_mean hc R he] at h
+
+end SLEExactGauge.Multipoint
+
+end
+
+end OAI

lean/OAI/Probability/SLE/Mass/StrictPastMass.lean

@@ -1,76 +1,76 @@
-import OAI.Probability.SLE.Mass.CanonicalMassFirstVisit
-
-namespace OAI
-
-/-! The expected terminal mass arriving strictly after a deterministic past
-is its current Green mass, including arbitrary events in that past. -/
-
-noncomputable section
-open Set Filter _root_.MeasureTheory _root_.OAI.MeasureTheory ProbabilityTheory
-open scoped Topology NNReal ENNReal
-
-namespace SLEExactGauge.Multipoint.CanonicalMass
-
-variable {Ω : Type*} [MeasurableSpace Ω] {P : Measure Ω}
-  {κ : ℝ} {B : ℝ≥0 → Ω → ℝ} {hBm : Measurable (Function.uncurry B)}
-  {γ : Ω → ℝ≥0 → ℂ} {G : Ω → ℝ≥0 → ℂ → ℂ}
-
-lemma strict_past_mass_kernel
-    (C : CanonicalMass P κ B hBm γ G) (hB : IsBrownianReal B P)
-    (hc : ∀ ω, Continuous (fun t => B t ω)) (h0 : ∀ ω, B 0 ω=0)
-    (hκ : 0<κ) (hκ8 : κ<8) (F : Ω → ℝ≥0 → ℂ → ℂ)
-    (hw : ∀ ω, IsCapacityTwoWitness (fun t => Real.sqrt κ*B t ω) (γ ω) (G ω) (F ω))
-    (t : ℝ≥0) (E : Set Ω)
-    (hE : MeasurableSet[(Filtration.natural B (fun s =>
-      (hBm.comp (measurable_const.prodMk measurable_id) : Measurable (B s)).stronglyMeasurable)) t] E)
-    (K : Set upperHalfPlane) (hK : IsCompact K) :
-    (∫⁻ ω in E, C.rational.terminal ω
-      (K \ {z : upperHalfPlane | (z:ℂ)∈γ ω '' Icc 0 t}) ∂P)=
-      ∫⁻ ω in E, halfPlaneGreenMeasure κ B γ G t ω K ∂P := by
-  let ℱ := Filtration.natural B (fun s =>
-    (hBm.comp (measurable_const.prodMk measurable_id) : Measurable (B s)).stronglyMeasurable)
-  have hNm : Measurable (C.process t) := by
-    simpa only [atTime,extendedCanonicalMass,ENNReal.coe_lt_top,ite_true,ENNReal.toNNReal_coe]
-      using C.atTime_measurable (fun _ => (t:ℝ≥0∞)) measurable_const
-  have hNG : Measurable (fun ω => C.process t ω K) :=
-    (Measure.measurable_coe hK.measurableSet).comp hNm
-  have hGm := halfPlaneGreenMeasure_measurable hBm hc κ γ G F hw t
-  have hp : ∀ᵐ ω ∂P, C.process t ω=(C.rational.terminal ω).restrict
-      {z : upperHalfPlane | (z:ℂ)∈γ ω '' Icc 0 t} := by
-    simpa only [atTime,extendedCanonicalMass,ENNReal.coe_lt_top,ite_true,ENNReal.toNNReal_coe]
-      using C.atTime_eq_restrict_past hB hBm hc h0 hκ hκ8 F hw t
-  have hdecomp : (∫⁻ ω in E, C.rational.terminal ω K ∂P)=
-      (∫⁻ ω in E, C.process t ω K ∂P)+
-      ∫⁻ ω in E, C.rational.terminal ω
-        (K \ {z : upperHalfPlane | (z:ℂ)∈γ ω '' Icc 0 t}) ∂P := by
-    rw [← lintegral_add_left hNG]
-    apply lintegral_congr_ae
-    filter_upwards [ae_restrict_of_ae hp] with ω hω
-    rw [hω,Measure.restrict_apply hK.measurableSet]
-    exact (measure_inter_add_sdiff K
-      (((isCompact_Icc.image (hw ω).1).isClosed.preimage continuous_subtype_val).measurableSet)).symm
-  have hS : IsStoppingTime ℱ (fun _ : Ω => (t:WithTop ℝ≥0)) := isStoppingTime_const ℱ t
-  have hEs : MeasurableSet[hS.measurableSpace] E := by
-    change MeasurableSet[(isStoppingTime_const ℱ t).measurableSpace] E
-    rw [IsStoppingTime.measurableSpace_const]
-    exact hE
-  have hk := congrArg (fun μ : Measure upperHalfPlane => μ K) (C.kernel _ hS E hEs)
-  change ((P.restrict E).bind C.rational.terminal) K=
-    (((P.restrict E).bind (C.process t))+((P.restrict E).bind (halfPlaneGreenMeasure κ B γ G t))) K at hk
-  rw [Measure.add_apply,Measure.bind_apply hK.measurableSet C.rational.terminal_measurable.aemeasurable,
-    Measure.bind_apply hK.measurableSet hNm.aemeasurable,
-    Measure.bind_apply hK.measurableSet hGm.aemeasurable] at hk
-  have hfin : (∫⁻ ω in E, C.process t ω K ∂P)≠∞ := by
-    let : IsFiniteMeasureOnCompacts (initialGreenMeasure κ) := initialGreenMeasure_finite_on_compacts κ
-    have hb := C.atTime_mean_le (fun _ => (t:ℝ≥0∞)) measurable_const E K
-    change ((P.restrict E).bind (C.process t)) K ≤ initialGreenMeasure κ K at hb
-    rw [Measure.bind_apply hK.measurableSet hNm.aemeasurable] at hb
-    exact (hb.trans_lt hK.measure_lt_top).ne
-  apply (ENNReal.add_right_inj hfin).mp
-  simpa only [add_comm] using hdecomp.symm.trans hk
-
-end SLEExactGauge.Multipoint.CanonicalMass
-
-end
-
-end OAI
+import OAI.Probability.SLE.Mass.CanonicalMassFirstVisit
+
+namespace OAI
+
+/-! The expected terminal mass arriving strictly after a deterministic past
+is its current Green mass, including arbitrary events in that past. -/
+
+noncomputable section
+open Set Filter _root_.MeasureTheory _root_.OAI.MeasureTheory ProbabilityTheory
+open scoped Topology NNReal ENNReal
+
+namespace SLEExactGauge.Multipoint.CanonicalMass
+
+variable {Ω : Type*} [MeasurableSpace Ω] {P : Measure Ω}
+  {κ : ℝ} {B : ℝ≥0 → Ω → ℝ} {hBm : Measurable (Function.uncurry B)}
+  {γ : Ω → ℝ≥0 → ℂ} {G : Ω → ℝ≥0 → ℂ → ℂ}
+
+lemma strict_past_mass_kernel
+    (C : CanonicalMass P κ B hBm γ G) (hB : IsBrownianReal B P)
+    (hc : ∀ ω, Continuous (fun t => B t ω)) (h0 : ∀ ω, B 0 ω=0)
+    (hκ : 0<κ) (hκ8 : κ<8) (F : Ω → ℝ≥0 → ℂ → ℂ)
+    (hw : ∀ ω, IsCapacityTwoWitness (fun t => Real.sqrt κ*B t ω) (γ ω) (G ω) (F ω))
+    (t : ℝ≥0) (E : Set Ω)
+    (hE : MeasurableSet[(Filtration.natural B (fun s =>
+      (hBm.comp (measurable_const.prodMk measurable_id) : Measurable (B s)).stronglyMeasurable)) t] E)
+    (K : Set upperHalfPlane) (hK : IsCompact K) :
+    (∫⁻ ω in E, C.rational.terminal ω
+      (K \ {z : upperHalfPlane | (z:ℂ)∈γ ω '' Icc 0 t}) ∂P)=
+      ∫⁻ ω in E, halfPlaneGreenMeasure κ B γ G t ω K ∂P := by
+  let ℱ := Filtration.natural B (fun s =>
+    (hBm.comp (measurable_const.prodMk measurable_id) : Measurable (B s)).stronglyMeasurable)
+  have hNm : Measurable (C.process t) := by
+    simpa only [atTime,extendedCanonicalMass,ENNReal.coe_lt_top,ite_true,ENNReal.toNNReal_coe]
+      using C.atTime_measurable (fun _ => (t:ℝ≥0∞)) measurable_const
+  have hNG : Measurable (fun ω => C.process t ω K) :=
+    (Measure.measurable_coe hK.measurableSet).comp hNm
+  have hGm := halfPlaneGreenMeasure_measurable hBm hc κ γ G F hw t
+  have hp : ∀ᵐ ω ∂P, C.process t ω=(C.rational.terminal ω).restrict
+      {z : upperHalfPlane | (z:ℂ)∈γ ω '' Icc 0 t} := by
+    simpa only [atTime,extendedCanonicalMass,ENNReal.coe_lt_top,ite_true,ENNReal.toNNReal_coe]
+      using C.atTime_eq_restrict_past hB hBm hc h0 hκ hκ8 F hw t
+  have hdecomp : (∫⁻ ω in E, C.rational.terminal ω K ∂P)=
+      (∫⁻ ω in E, C.process t ω K ∂P)+
+      ∫⁻ ω in E, C.rational.terminal ω
+        (K \ {z : upperHalfPlane | (z:ℂ)∈γ ω '' Icc 0 t}) ∂P := by
+    rw [← lintegral_add_left hNG]
+    apply lintegral_congr_ae
+    filter_upwards [ae_restrict_of_ae hp] with ω hω
+    rw [hω,Measure.restrict_apply hK.measurableSet]
+    exact (measure_inter_add_sdiff K
+      (((isCompact_Icc.image (hw ω).1).isClosed.preimage continuous_subtype_val).measurableSet)).symm
+  have hS : IsStoppingTime ℱ (fun _ : Ω => (t:WithTop ℝ≥0)) := isStoppingTime_const ℱ t
+  have hEs : MeasurableSet[hS.measurableSpace] E := by
+    change MeasurableSet[(isStoppingTime_const ℱ t).measurableSpace] E
+    rw [IsStoppingTime.measurableSpace_const]
+    exact hE
+  have hk := congrArg (fun μ : Measure upperHalfPlane => μ K) (C.kernel _ hS E hEs)
+  change ((P.restrict E).bind C.rational.terminal) K=
+    (((P.restrict E).bind (C.process t))+((P.restrict E).bind (halfPlaneGreenMeasure κ B γ G t))) K at hk
+  rw [Measure.add_apply,Measure.bind_apply hK.measurableSet C.rational.terminal_measurable.aemeasurable,
+    Measure.bind_apply hK.measurableSet hNm.aemeasurable,
+    Measure.bind_apply hK.measurableSet hGm.aemeasurable] at hk
+  have hfin : (∫⁻ ω in E, C.process t ω K ∂P)≠∞ := by
+    let : IsFiniteMeasureOnCompacts (initialGreenMeasure κ) := initialGreenMeasure_finite_on_compacts κ
+    have hb := C.atTime_mean_le (fun _ => (t:ℝ≥0∞)) measurable_const E K
+    change ((P.restrict E).bind (C.process t)) K ≤ initialGreenMeasure κ K at hb
+    rw [Measure.bind_apply hK.measurableSet hNm.aemeasurable] at hb
+    exact (hb.trans_lt hK.measure_lt_top).ne
+  apply (ENNReal.add_right_inj hfin).mp
+  simpa only [add_comm] using hdecomp.symm.trans hk
+
+end SLEExactGauge.Multipoint.CanonicalMass
+
+end
+
+end OAI

lean/OAI/Probability/SLE/Mass/SubSigmaRadonLimit.lean

@@ -1,88 +1,88 @@
-import OAI.Probability.SLE.Mass.RandomRadonLimit
-import OAI.Probability.SLE.Mass.RadonTestFamily
-
-namespace OAI
-
-/-! A vague Radon limit has a version measurable in the same sigma-algebra
-as its approximants. The probability measure may use a larger sigma-algebra;
-the exceptional convergence set is detected by countably many tests. -/
-
-noncomputable section
-open Set Filter MeasureTheory Classical
-open scoped Topology CompactlySupported
-
-namespace SLEExactGauge
-
-variable {X : Type*} [TopologicalSpace X] [T2Space X] [LocallyCompactSpace X]
-  [SecondCountableTopology X] [MeasurableSpace X] [BorelSpace X]
-
-theorem exists_subsigma_radon_version_identified
-    {Ω : Type*} (m : MeasurableSpace Ω) (μ : ℕ → Ω → Measure X)
-    (hfinite : ∀ n ω, IsFiniteMeasureOnCompacts (μ n ω))
-    (hmeas : ∀ n (f : C_c(X,ℝ)), Measurable[m] (fun ω => ∫ x, f x ∂μ n ω)) :
-    ∃ η : Ω → Measure X, Measurable[m] η ∧
-      (∀ ω, (η ω).Regular ∧ IsFiniteMeasureOnCompacts (η ω)) ∧
-      ∀ ω (ν : Measure X), ν.Regular →
-        (∀ f : C_c(X,ℝ), Tendsto (fun n => ∫ x, f x ∂μ n ω) atTop (𝓝 (∫ x, f x ∂ν))) →
-        η ω = ν := by
-  let : MeasurableSpace Ω := m
-  let D := localTestFamily X
-  let G : Set Ω := {ω | ∀ j, ∃ a : ℝ,
-    Tendsto (fun n => ∫ x, D.test j x ∂μ n ω) atTop (𝓝 a)}
-  have hG : MeasurableSet[m] G := by
-    let : MeasurableSpace Ω := m
-    simpa only [G,Set.ofPred_forall] using MeasurableSet.iInter
-      (fun j => measurableSet_exists_tendsto (fun n => hmeas n (D.test j)))
-  have hex (ω : Ω) : ∃ η : Measure X, η.Regular ∧
-      ∀ f : C_c(X,ℝ), Tendsto
-        (fun n => if ω ∈ G then ∫ x, f x ∂μ n ω else 0) atTop (𝓝 (∫ x, f x ∂η)) := by
-    by_cases hω : ω ∈ G
-    · let (n : ℕ) : IsFiniteMeasureOnCompacts (μ n ω) := hfinite n ω
-      obtain ⟨η,hη,_,hl⟩ := D.exists_radon_limit (fun n => μ n ω) hω
-      exact ⟨η,hη,fun f => by simpa only [ite_eq_left hω] using hl f⟩
-    · refine ⟨0,inferInstance,fun f => ?_⟩
-      simpa only [ite_eq_right hω,integral_zero_measure] using
-        (tendsto_const_nhds : Tendsto (fun _ : ℕ => (0:ℝ)) atTop (𝓝 0))
-  choose η hηr hηlim using hex
-  have hηm : Measurable[m] η := by
-    let : MeasurableSpace Ω := m
-    apply measurable_radon_of_tests η hηr
-    intro f
-    apply measurable_of_tendsto_metrizable
-      (f := fun n ω => if ω ∈ G then ∫ x, f x ∂μ n ω else 0)
-    · intro n
-      exact (hmeas n f).ite hG measurable_const
-    · exact tendsto_pi_nhds.mpr (fun ω => hηlim ω f)
-  refine ⟨η,hηm,fun ω => ?_,?_⟩
-  · let := hηr ω
-    exact ⟨hηr ω,inferInstance⟩
-  · intro ω ν hr hl
-    have hg : ω ∈ G := fun j => ⟨∫ x, D.test j x ∂ν,hl (D.test j)⟩
-    let := hηr ω
-    let := hr
-    apply radon_test_limit_unique (fun n => μ n ω) (η ω) ν
-    · intro f
-      simpa only [ite_eq_left hg] using hηlim ω f
-    · exact hl
-
-theorem exists_subsigma_radon_version
-    {Ω : Type*} [mΩ : MeasurableSpace Ω] (m : MeasurableSpace Ω) (P : @Measure Ω mΩ)
-    (μ : ℕ → Ω → Measure X) (ν : Ω → Measure X)
-    (hfinite : ∀ n ω, IsFiniteMeasureOnCompacts (μ n ω))
-    (hmeas : ∀ n (f : C_c(X,ℝ)), Measurable[m] (fun ω => ∫ x, f x ∂μ n ω))
-    (hν : ∀ᵐ ω ∂P, (ν ω).Regular)
-    (hlim : ∀ᵐ ω ∂P, ∀ f : C_c(X,ℝ),
-      Tendsto (fun n => ∫ x, f x ∂μ n ω) atTop (𝓝 (∫ x, f x ∂ν ω))) :
-    ∃ η : Ω → Measure X, Measurable[m] η ∧
-      (∀ ω, (η ω).Regular ∧ IsFiniteMeasureOnCompacts (η ω)) ∧ η =ᵐ[P] ν := by
-  obtain ⟨η,hm,hr,he⟩ := exists_subsigma_radon_version_identified m μ hfinite hmeas
-  refine ⟨η,hm,hr,?_⟩
-  filter_upwards [hν,hlim] with ω hν hlim
-  exact he ω (ν ω) hν hlim
-
-
-end SLEExactGauge
-
-end
-
-end OAI
+import OAI.Probability.SLE.Mass.RandomRadonLimit
+import OAI.Probability.SLE.Mass.RadonTestFamily
+
+namespace OAI
+
+/-! A vague Radon limit has a version measurable in the same sigma-algebra
+as its approximants. The probability measure may use a larger sigma-algebra;
+the exceptional convergence set is detected by countably many tests. -/
+
+noncomputable section
+open Set Filter MeasureTheory Classical
+open scoped Topology CompactlySupported
+
+namespace SLEExactGauge
+
+variable {X : Type*} [TopologicalSpace X] [T2Space X] [LocallyCompactSpace X]
+  [SecondCountableTopology X] [MeasurableSpace X] [BorelSpace X]
+
+theorem exists_subsigma_radon_version_identified
+    {Ω : Type*} (m : MeasurableSpace Ω) (μ : ℕ → Ω → Measure X)
+    (hfinite : ∀ n ω, IsFiniteMeasureOnCompacts (μ n ω))
+    (hmeas : ∀ n (f : C_c(X,ℝ)), Measurable[m] (fun ω => ∫ x, f x ∂μ n ω)) :
+    ∃ η : Ω → Measure X, Measurable[m] η ∧
+      (∀ ω, (η ω).Regular ∧ IsFiniteMeasureOnCompacts (η ω)) ∧
+      ∀ ω (ν : Measure X), ν.Regular →
+        (∀ f : C_c(X,ℝ), Tendsto (fun n => ∫ x, f x ∂μ n ω) atTop (𝓝 (∫ x, f x ∂ν))) →
+        η ω = ν := by
+  let : MeasurableSpace Ω := m
+  let D := localTestFamily X
+  let G : Set Ω := {ω | ∀ j, ∃ a : ℝ,
+    Tendsto (fun n => ∫ x, D.test j x ∂μ n ω) atTop (𝓝 a)}
+  have hG : MeasurableSet[m] G := by
+    let : MeasurableSpace Ω := m
+    simpa only [G,Set.ofPred_forall] using MeasurableSet.iInter
+      (fun j => measurableSet_exists_tendsto (fun n => hmeas n (D.test j)))
+  have hex (ω : Ω) : ∃ η : Measure X, η.Regular ∧
+      ∀ f : C_c(X,ℝ), Tendsto
+        (fun n => if ω ∈ G then ∫ x, f x ∂μ n ω else 0) atTop (𝓝 (∫ x, f x ∂η)) := by
+    by_cases hω : ω ∈ G
+    · let (n : ℕ) : IsFiniteMeasureOnCompacts (μ n ω) := hfinite n ω
+      obtain ⟨η,hη,_,hl⟩ := D.exists_radon_limit (fun n => μ n ω) hω
+      exact ⟨η,hη,fun f => by simpa only [ite_eq_left hω] using hl f⟩
+    · refine ⟨0,inferInstance,fun f => ?_⟩
+      simpa only [ite_eq_right hω,integral_zero_measure] using
+        (tendsto_const_nhds : Tendsto (fun _ : ℕ => (0:ℝ)) atTop (𝓝 0))
+  choose η hηr hηlim using hex
+  have hηm : Measurable[m] η := by
+    let : MeasurableSpace Ω := m
+    apply measurable_radon_of_tests η hηr
+    intro f
+    apply measurable_of_tendsto_metrizable
+      (f := fun n ω => if ω ∈ G then ∫ x, f x ∂μ n ω else 0)
+    · intro n
+      exact (hmeas n f).ite hG measurable_const
+    · exact tendsto_pi_nhds.mpr (fun ω => hηlim ω f)
+  refine ⟨η,hηm,fun ω => ?_,?_⟩
+  · let := hηr ω
+    exact ⟨hηr ω,inferInstance⟩
+  · intro ω ν hr hl
+    have hg : ω ∈ G := fun j => ⟨∫ x, D.test j x ∂ν,hl (D.test j)⟩
+    let := hηr ω
+    let := hr
+    apply radon_test_limit_unique (fun n => μ n ω) (η ω) ν
+    · intro f
+      simpa only [ite_eq_left hg] using hηlim ω f
+    · exact hl
+
+theorem exists_subsigma_radon_version
+    {Ω : Type*} [mΩ : MeasurableSpace Ω] (m : MeasurableSpace Ω) (P : @Measure Ω mΩ)
+    (μ : ℕ → Ω → Measure X) (ν : Ω → Measure X)
+    (hfinite : ∀ n ω, IsFiniteMeasureOnCompacts (μ n ω))
+    (hmeas : ∀ n (f : C_c(X,ℝ)), Measurable[m] (fun ω => ∫ x, f x ∂μ n ω))
+    (hν : ∀ᵐ ω ∂P, (ν ω).Regular)
+    (hlim : ∀ᵐ ω ∂P, ∀ f : C_c(X,ℝ),
+      Tendsto (fun n => ∫ x, f x ∂μ n ω) atTop (𝓝 (∫ x, f x ∂ν ω))) :
+    ∃ η : Ω → Measure X, Measurable[m] η ∧
+      (∀ ω, (η ω).Regular ∧ IsFiniteMeasureOnCompacts (η ω)) ∧ η =ᵐ[P] ν := by
+  obtain ⟨η,hm,hr,he⟩ := exists_subsigma_radon_version_identified m μ hfinite hmeas
+  refine ⟨η,hm,hr,?_⟩
+  filter_upwards [hν,hlim] with ω hν hlim
+  exact he ω (ν ω) hν hlim
+
+
+end SLEExactGauge
+
+end
+
+end OAI

lean/OAI/Probability/SLE/Mass/TargetDiscreteMassRecovery.lean

@@ -1,71 +1,71 @@
-import OAI.Probability.SLE.Mass.MassCompensatorRecovery
-import OAI.Probability.SLE.Gauge.MomentCoefficientConvergence
-
-namespace OAI
-
-/-! The exact finite sum in the prescribed coefficient formula agrees
-with the stopped predictable compensator once its potential increments
-have been identified. The endpoint is allowed to be infinite. -/
-
-noncomputable section
-open Set Filter MeasureTheory ProbabilityTheory
-open scoped Topology NNReal ENNReal
-
-namespace SLEExactGauge
-
-lemma compensator_before_extended_sum (n : ℕ) (T : ℝ≥0∞) (q : ℕ → ℝ) :
-    (∑ i ∈ Finset.range (n*2^n),
-      if (compensatorMeshTime n (i+1):ℝ≥0∞) ≤ T then q i else 0) =
-      ∑ i ∈ Finset.range (compensatorStopIndex n T), q i := by
-  by_cases hT : T=∞
-  · simp [hT,compensatorStopIndex]
-  · have he : T=(T.toNNReal:ℝ≥0∞) := (ENNReal.coe_toNNReal hT).symm
-    conv_lhs => rw [he]
-    simp only [ENNReal.coe_le_coe]
-    rw [compensator_before_sum,compensatorStopIndex,ite_eq_right hT]
-
-lemma target_mesh_time (n i : ℕ) :
-    ENNReal.ofReal (((i:ℝ)+1)*Target.mesh n) =
-      (compensatorMeshTime n (i+1):ℝ≥0∞) := by
-  have he : (compensatorMeshTime n (i+1):ℝ)=((i:ℝ)+1)*Target.mesh n := by
-    simp [compensatorMeshTime,Target.mesh]
-  rw [← he,ENNReal.ofReal_coe_nnreal]
-
-lemma target_discreteMass_eq_sum (κ θ : ℝ) (W : Target.WienerLaw)
-    (b : Target.Driver) (ℓ : ℝ) (n : ℕ) :
-    Target.discreteMass κ θ W b ℓ n =
-      ∑ i ∈ Finset.range (compensatorStopIndex n (Target.levelTime κ θ b ℓ)),
-        Target.potentialDifference κ θ W b n i := by
-  unfold Target.discreteMass
-  simp_rw [target_mesh_time]
-  exact compensator_before_extended_sum n _ _
-
-theorem target_discreteMass_tendstoInMeasure
-    {Ω : Type*} [mΩ : MeasurableSpace Ω] (P : Measure Ω) [IsProbabilityMeasure P]
-    (κ θ : ℝ) (W : Target.WienerLaw) (b : Ω → Target.Driver) (ℓ : ℝ)
-    (ℱ : ℕ → 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 ω)
-    (hT : Measurable (fun ω => Target.levelTime κ θ (b ω) ℓ))
-    (hq : ∀ n i, (fun ω => Target.potentialDifference κ θ W (b ω) n i) =ᵐ[P]
-      condExp (ℱ n i) P (meshMassIncrement A n i)) :
-    TendstoInMeasure P (fun n ω => Target.discreteMass κ θ W (b ω) ℓ n) atTop
-      (fun ω => massAtExtendedTime (fun t => A t ω) (L ω)
-        (Target.levelTime κ θ (b ω) ℓ)) := by
-  have h := meshMassCompensator_stopped_tendstoInMeasure P ℱ A L hA hgrid hL hp
-    (fun ω => Target.levelTime κ θ (b ω) ℓ) hT
-  apply h.congr _ (Filter.EventuallyEq.refl _ _)
-  intro n
-  filter_upwards [ae_all_iff.mpr (hq n)] with ω hω
-  rw [target_discreteMass_eq_sum]
-  exact Finset.sum_congr rfl (fun i _ => (hω i).symm)
-
-end SLEExactGauge
-
-end
-
-end OAI
+import OAI.Probability.SLE.Mass.MassCompensatorRecovery
+import OAI.Probability.SLE.Gauge.MomentCoefficientConvergence
+
+namespace OAI
+
+/-! The exact finite sum in the prescribed coefficient formula agrees
+with the stopped predictable compensator once its potential increments
+have been identified. The endpoint is allowed to be infinite. -/
+
+noncomputable section
+open Set Filter MeasureTheory ProbabilityTheory
+open scoped Topology NNReal ENNReal
+
+namespace SLEExactGauge
+
+lemma compensator_before_extended_sum (n : ℕ) (T : ℝ≥0∞) (q : ℕ → ℝ) :
+    (∑ i ∈ Finset.range (n*2^n),
+      if (compensatorMeshTime n (i+1):ℝ≥0∞) ≤ T then q i else 0) =
+      ∑ i ∈ Finset.range (compensatorStopIndex n T), q i := by
+  by_cases hT : T=∞
+  · simp [hT,compensatorStopIndex]
+  · have he : T=(T.toNNReal:ℝ≥0∞) := (ENNReal.coe_toNNReal hT).symm
+    conv_lhs => rw [he]
+    simp only [ENNReal.coe_le_coe]
+    rw [compensator_before_sum,compensatorStopIndex,ite_eq_right hT]
+
+lemma target_mesh_time (n i : ℕ) :
+    ENNReal.ofReal (((i:ℝ)+1)*Target.mesh n) =
+      (compensatorMeshTime n (i+1):ℝ≥0∞) := by
+  have he : (compensatorMeshTime n (i+1):ℝ)=((i:ℝ)+1)*Target.mesh n := by
+    simp [compensatorMeshTime,Target.mesh]
+  rw [← he,ENNReal.ofReal_coe_nnreal]
+
+lemma target_discreteMass_eq_sum (κ θ : ℝ) (W : Target.WienerLaw)
+    (b : Target.Driver) (ℓ : ℝ) (n : ℕ) :
+    Target.discreteMass κ θ W b ℓ n =
+      ∑ i ∈ Finset.range (compensatorStopIndex n (Target.levelTime κ θ b ℓ)),
+        Target.potentialDifference κ θ W b n i := by
+  unfold Target.discreteMass
+  simp_rw [target_mesh_time]
+  exact compensator_before_extended_sum n _ _
+
+theorem target_discreteMass_tendstoInMeasure
+    {Ω : Type*} [mΩ : MeasurableSpace Ω] (P : Measure Ω) [IsProbabilityMeasure P]
+    (κ θ : ℝ) (W : Target.WienerLaw) (b : Ω → Target.Driver) (ℓ : ℝ)
+    (ℱ : ℕ → 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 ω)
+    (hT : Measurable (fun ω => Target.levelTime κ θ (b ω) ℓ))
+    (hq : ∀ n i, (fun ω => Target.potentialDifference κ θ W (b ω) n i) =ᵐ[P]
+      condExp (ℱ n i) P (meshMassIncrement A n i)) :
+    TendstoInMeasure P (fun n ω => Target.discreteMass κ θ W (b ω) ℓ n) atTop
+      (fun ω => massAtExtendedTime (fun t => A t ω) (L ω)
+        (Target.levelTime κ θ (b ω) ℓ)) := by
+  have h := meshMassCompensator_stopped_tendstoInMeasure P ℱ A L hA hgrid hL hp
+    (fun ω => Target.levelTime κ θ (b ω) ℓ) hT
+  apply h.congr _ (Filter.EventuallyEq.refl _ _)
+  intro n
+  filter_upwards [ae_all_iff.mpr (hq n)] with ω hω
+  rw [target_discreteMass_eq_sum]
+  exact Finset.sum_congr rfl (fun i _ => (hω i).symm)
+
+end SLEExactGauge
+
+end
+
+end OAI

lean/OAI/Probability/SLE/Mass/TerminalMassTestLimit.lean

@@ -1,57 +1,57 @@
-import OAI.Probability.SLE.Mass.CanonicalMassExhaustion
-
-namespace OAI
-
-/-! Local exhaustion implies convergence of every compact continuous test.
-This provides the terminal value of the fixed raw driver functional. -/
-
-noncomputable section
-open Set Filter MeasureTheory Classical
-open scoped NNReal ENNReal Topology CompactlySupported
-
-namespace SLEExactGauge
-
-local instance : LocallyCompactSpace upperHalfPlane := isOpen_upperHalfPlane.locallyCompactSpace
-
-lemma compact_test_norm_le_mass (μ : Measure upperHalfPlane)
-    [IsFiniteMeasureOnCompacts μ] (f : C_c(upperHalfPlane,ℝ)) :
-    ‖∫ z, f z ∂μ‖ ≤ ‖f.toBoundedContinuousFunction‖ * (μ (tsupport f)).toReal := by
-  let : IsFiniteMeasure (μ.restrict (tsupport f)) :=
-    ⟨by simpa only [Measure.restrict_apply_univ] using f.hasCompactSupport.measure_lt_top (μ := μ)⟩
-  have he := setIntegral_eq_integral_of_forall_compl_eq_zero (μ := μ)
-    (s := tsupport f) (fun z hz => image_eq_zero_of_notMem_tsupport hz)
-  rw [← he]
-  have hb : ∀ᵐ z ∂μ.restrict (tsupport f), ‖f z‖ ≤ ‖f.toBoundedContinuousFunction‖ :=
-    ae_of_all _ (fun z => f.toBoundedContinuousFunction.norm_coe_le_norm z)
-  have h := norm_integral_le_of_norm_le_const hb
-  simpa only [Measure.real,Measure.restrict_apply_univ] using h
-
-theorem terminal_mass_test_tendsto
-    (ν : Measure upperHalfPlane) [ν.Regular]
-    (N : ℝ≥0 → Measure upperHalfPlane) (hNr : ∀ t, (N t).Regular)
-    (hdom : ∀ t, N t ≤ ν)
-    (hlim : ∀ K : Set upperHalfPlane, IsCompact K →
-      Tendsto (fun t : ℝ≥0 => (ν-N t) K) atTop (𝓝 0))
-    (f : C_c(upperHalfPlane,ℝ)) :
-    Tendsto (fun t : ℝ≥0 => ∫ z, f z ∂N t) atTop (𝓝 (∫ z, f z ∂ν)) := by
-  let (t : ℝ≥0) : IsFiniteMeasureOnCompacts (ν-N t) :=
-    ⟨fun K hK => lt_of_le_of_lt (Measure.sub_le K) hK.measure_lt_top⟩
-  have hrem : Tendsto (fun t : ℝ≥0 => ∫ z, f z ∂(ν-N t)) atTop (𝓝 0) := by
-    apply squeeze_zero_norm (fun t => compact_test_norm_le_mass (ν-N t) f)
-    have hh := (ENNReal.continuousAt_toReal ENNReal.zero_ne_top).tendsto.comp
-      (hlim (tsupport f) f.hasCompactSupport)
-    simpa only [Function.comp_def,ENNReal.toReal_zero,mul_zero] using
-      (tendsto_const_nhds (x := ‖f.toBoundedContinuousFunction‖)).mul hh
-  have he (t : ℝ≥0) : (∫ z, f z ∂ν)-(∫ z, f z ∂(ν-N t)) = ∫ z, f z ∂N t := by
-    let := hNr t
-    have : (ν-N t).Regular := inferInstance
-    have hsum := integral_add_measure (μ := ν-N t) (ν := N t) f.integrable f.integrable
-    rw [sigmaFinite_sub_add_cancel_of_le (hdom t)] at hsum
-    linarith
-  simpa only [he,sub_zero] using (tendsto_const_nhds (x := ∫ z, f z ∂ν)).sub hrem
-
-end SLEExactGauge
-
-end
-
-end OAI
+import OAI.Probability.SLE.Mass.CanonicalMassExhaustion
+
+namespace OAI
+
+/-! Local exhaustion implies convergence of every compact continuous test.
+This provides the terminal value of the fixed raw driver functional. -/
+
+noncomputable section
+open Set Filter MeasureTheory Classical
+open scoped NNReal ENNReal Topology CompactlySupported
+
+namespace SLEExactGauge
+
+local instance : LocallyCompactSpace upperHalfPlane := isOpen_upperHalfPlane.locallyCompactSpace
+
+lemma compact_test_norm_le_mass (μ : Measure upperHalfPlane)
+    [IsFiniteMeasureOnCompacts μ] (f : C_c(upperHalfPlane,ℝ)) :
+    ‖∫ z, f z ∂μ‖ ≤ ‖f.toBoundedContinuousFunction‖ * (μ (tsupport f)).toReal := by
+  let : IsFiniteMeasure (μ.restrict (tsupport f)) :=
+    ⟨by simpa only [Measure.restrict_apply_univ] using f.hasCompactSupport.measure_lt_top (μ := μ)⟩
+  have he := setIntegral_eq_integral_of_forall_compl_eq_zero (μ := μ)
+    (s := tsupport f) (fun z hz => image_eq_zero_of_notMem_tsupport hz)
+  rw [← he]
+  have hb : ∀ᵐ z ∂μ.restrict (tsupport f), ‖f z‖ ≤ ‖f.toBoundedContinuousFunction‖ :=
+    ae_of_all _ (fun z => f.toBoundedContinuousFunction.norm_coe_le_norm z)
+  have h := norm_integral_le_of_norm_le_const hb
+  simpa only [Measure.real,Measure.restrict_apply_univ] using h
+
+theorem terminal_mass_test_tendsto
+    (ν : Measure upperHalfPlane) [ν.Regular]
+    (N : ℝ≥0 → Measure upperHalfPlane) (hNr : ∀ t, (N t).Regular)
+    (hdom : ∀ t, N t ≤ ν)
+    (hlim : ∀ K : Set upperHalfPlane, IsCompact K →
+      Tendsto (fun t : ℝ≥0 => (ν-N t) K) atTop (𝓝 0))
+    (f : C_c(upperHalfPlane,ℝ)) :
+    Tendsto (fun t : ℝ≥0 => ∫ z, f z ∂N t) atTop (𝓝 (∫ z, f z ∂ν)) := by
+  let (t : ℝ≥0) : IsFiniteMeasureOnCompacts (ν-N t) :=
+    ⟨fun K hK => lt_of_le_of_lt (Measure.sub_le K) hK.measure_lt_top⟩
+  have hrem : Tendsto (fun t : ℝ≥0 => ∫ z, f z ∂(ν-N t)) atTop (𝓝 0) := by
+    apply squeeze_zero_norm (fun t => compact_test_norm_le_mass (ν-N t) f)
+    have hh := (ENNReal.continuousAt_toReal ENNReal.zero_ne_top).tendsto.comp
+      (hlim (tsupport f) f.hasCompactSupport)
+    simpa only [Function.comp_def,ENNReal.toReal_zero,mul_zero] using
+      (tendsto_const_nhds (x := ‖f.toBoundedContinuousFunction‖)).mul hh
+  have he (t : ℝ≥0) : (∫ z, f z ∂ν)-(∫ z, f z ∂(ν-N t)) = ∫ z, f z ∂N t := by
+    let := hNr t
+    have : (ν-N t).Regular := inferInstance
+    have hsum := integral_add_measure (μ := ν-N t) (ν := N t) f.integrable f.integrable
+    rw [sigmaFinite_sub_add_cancel_of_le (hdom t)] at hsum
+    linarith
+  simpa only [he,sub_zero] using (tendsto_const_nhds (x := ∫ z, f z ∂ν)).sub hrem
+
+end SLEExactGauge
+
+end
+
+end OAI

lean/OAI/Probability/SLE/Mass/UniformCoverLevels.lean

@@ -1,118 +1,118 @@
-import OAI.Probability.SLE.Gauge.CoverRadiusLevels
-import OAI.Probability.SLE.Gauge.CoverGrid
-
-namespace OAI
-
-/-! Uniform clock geometry over the moving grid centers retained above a
-fixed positive height. The terminal visit level is separated from every
-test endpoint by a full clock unit. -/
-
-noncomputable section
-open Set Filter
-open scoped Topology NNReal ENNReal
-
-namespace SLEExactGauge
-
-def coverVisitLevel (z : ℂ) (T : ℝ) (n : ℕ) : ℝ :=
-  Real.log (2 * z.im) + T * (n : ℝ) - Real.log (512 * Real.pi)
-
-/-- One deterministic cutoff works for every point above the retained height
-and every test index, including the endpoint after the last test. -/
-theorem eventually_uniform_cover_levels {T η : ℝ} (hT : 0 < T) (hη : 0 < η) :
-    ∀ᶠ n : ℕ in atTop, ∀ z : ℂ, η / 2 ≤ z.im →
-      (∀ j : ℕ, n / 3 ≤ j →
-        coverLogLevel z T j = Real.log (2 * z.im) + T * (j : ℝ)) ∧
-      coverLogLevel z T (2 * n / 3 + 1) + 1 ≤ coverVisitLevel z T n ∧
-      4 * coverRadius T n ≤ z.im := by
-  obtain ⟨N, hN⟩ := exists_nat_gt (-Real.log η / T)
-  have hNT : -Real.log η < T * (N : ℝ) := by
-    simpa only [mul_comm] using (div_lt_iff₀ hT).mp hN
-  have hlarge : ∀ᶠ n : ℕ in atTop,
-      3 * (Real.log (512 * Real.pi) + 1 + T) / T ≤ (n : ℝ) :=
-    tendsto_natCast_atTop_atTop.eventually (eventually_ge_atTop _)
-  have hlim : Tendsto (fun n => 4 * coverRadius T n) atTop (𝓝 0) := by
-    simpa only [mul_zero] using (coverRadius_tendsto_zero hT).const_mul 4
-  have hsmall : ∀ᶠ n : ℕ in atTop, 4 * coverRadius T n < η / 2 :=
-    hlim.eventually (gt_mem_nhds (half_pos hη))
-  filter_upwards [eventually_ge_atTop (3 * N), hlarge, hsmall] with n hn hnlarge hnsmall
-  intro z hz
-  have hlog : Real.log η ≤ Real.log (2 * z.im) :=
-    Real.log_le_log hη (by linarith)
-  have hlevels : ∀ j : ℕ, n / 3 ≤ j →
-      coverLogLevel z T j = Real.log (2 * z.im) + T * (j : ℝ) := by
-    intro j hj
-    have hjN : N ≤ j := by omega
-    have hNj : T * (N : ℝ) ≤ T * (j : ℝ) :=
-      mul_le_mul_of_nonneg_left (by exact_mod_cast hjN) hT.le
-    exact max_eq_right (by linarith)
-  refine ⟨hlevels, ?_, hnsmall.le.trans hz⟩
-  rw [hlevels (2 * n / 3 + 1) (by omega)]
-  have hlast : 3 * (2 * n / 3 + 1) ≤ 2 * n + 3 := by omega
-  have hlastR : (3 : ℝ) * (2 * n / 3 + 1 : ℕ) ≤ 2 * n + 3 := by exact_mod_cast hlast
-  have hnT := (div_le_iff₀ hT).mp hnlarge
-  unfold coverVisitLevel
-  nlinarith
-
-lemma coverVisitLevel_nonneg_of_gap (z : ℂ) (T : ℝ) (n : ℕ)
-    (hgap : coverLogLevel z T (2 * n / 3 + 1) + 1 ≤ coverVisitLevel z T n) :
-    0 ≤ coverVisitLevel z T n := by
-  have h0 := coverLogLevel_nonneg z T (2 * n / 3 + 1)
-  linarith
-
-/-- The late visit level is the fixed multiple `512π r_n` of the fine mesh,
-independently of the varying center's height. -/
-lemma coverVisitLevel_radius (z : ℂ) (hz : 0 < z.im) (T : ℝ) (n : ℕ) :
-    (2 * z.im) * Real.exp (-coverVisitLevel z T n) =
-      (512 * Real.pi) * coverRadius T n := by
-  have hz2 : 0 < 2 * z.im := by positivity
-  have hM : 0 < 512 * Real.pi := by positivity
-  have he : -coverVisitLevel z T n = Real.log (512 * Real.pi) +
-      (-Real.log (2 * z.im) + -T * (n : ℝ)) := by
-    unfold coverVisitLevel
-    ring
-  unfold coverRadius
-  rw [he, Real.exp_add, Real.exp_add,
-    Real.exp_log hM, Real.exp_neg, Real.exp_log hz2]
-  field_simp [hz2.ne']
-
-/-- The exact test window inherits the common late-grid cutoff. -/
-theorem eventually_uniform_cover_window_levels {T η : ℝ} (hT : 0 < T) (hη : 0 < η) :
-    ∀ᶠ n : ℕ in atTop, ∀ z : ℂ, η / 2 ≤ z.im →
-      (∀ j ∈ coverTestWindow n,
-        coverLogLevel z T j = Real.log (2 * z.im) + T * (j : ℝ)) ∧
-      coverLogLevel z T (2 * n / 3 + 1) =
-        Real.log (2 * z.im) + T * ((2 * n / 3 + 1 : ℕ) : ℝ) ∧
-      coverLogLevel z T (2 * n / 3 + 1) + 1 ≤ coverVisitLevel z T n ∧
-      4 * coverRadius T n ≤ z.im := by
-  filter_upwards [eventually_uniform_cover_levels hT hη] with n hn
-  intro z hz
-  obtain ⟨hlevel, hgap, hsmall⟩ := hn z hz
-  exact ⟨fun j hj => hlevel j (Finset.mem_Icc.mp hj).1,
-    hlevel _ (by omega), hgap, hsmall⟩
-
-/-- In particular the changing retained grid centers satisfy all clock and
-visit geometry simultaneously; no center-dependent cutoff is required. -/
-theorem eventually_retained_grid_cover_levels {R T η : ℝ} {K : Set ℂ}
-    (hT : 0 < T) (hη : 0 < η) (hK : K ⊆ Metric.closedBall 0 R)
-    (hheight : ∀ z ∈ K, η ≤ z.im) :
-    ∀ᶠ n : ℕ in atTop, ∀ ij ∈ retainedCoverGridIndex R (coverRadius T n) K,
-      let z := coverGridCenter (coverRadius T n) ij
-      z ∈ upperHalfPlane ∧
-      (∀ j ∈ coverTestWindow n,
-        coverLogLevel z T j = Real.log (2 * z.im) + T * (j : ℝ)) ∧
-      coverLogLevel z T (2 * n / 3 + 1) =
-        Real.log (2 * z.im) + T * ((2 * n / 3 + 1 : ℕ) : ℝ) ∧
-      coverLogLevel z T (2 * n / 3 + 1) + 1 ≤ coverVisitLevel z T n ∧
-      4 * coverRadius T n ≤ z.im := by
-  have hsmall := (coverRadius_tendsto_zero hT).eventually (gt_mem_nhds (show 0 < η / 4 by positivity))
-  filter_upwards [eventually_uniform_cover_window_levels hT hη, hsmall] with n hn hnr
-  intro ij hij
-  have hcenter := (retainedCoverGrid_center_bounds hK hheight hij).2
-  have hz : η / 2 ≤ (coverGridCenter (coverRadius T n) ij).im := by linarith
-  exact ⟨lt_of_lt_of_le (half_pos hη) hz, hn _ hz⟩
-
-end SLEExactGauge
-
-end
-
-end OAI
+import OAI.Probability.SLE.Gauge.CoverRadiusLevels
+import OAI.Probability.SLE.Gauge.CoverGrid
+
+namespace OAI
+
+/-! Uniform clock geometry over the moving grid centers retained above a
+fixed positive height. The terminal visit level is separated from every
+test endpoint by a full clock unit. -/
+
+noncomputable section
+open Set Filter
+open scoped Topology NNReal ENNReal
+
+namespace SLEExactGauge
+
+def coverVisitLevel (z : ℂ) (T : ℝ) (n : ℕ) : ℝ :=
+  Real.log (2 * z.im) + T * (n : ℝ) - Real.log (512 * Real.pi)
+
+/-- One deterministic cutoff works for every point above the retained height
+and every test index, including the endpoint after the last test. -/
+theorem eventually_uniform_cover_levels {T η : ℝ} (hT : 0 < T) (hη : 0 < η) :
+    ∀ᶠ n : ℕ in atTop, ∀ z : ℂ, η / 2 ≤ z.im →
+      (∀ j : ℕ, n / 3 ≤ j →
+        coverLogLevel z T j = Real.log (2 * z.im) + T * (j : ℝ)) ∧
+      coverLogLevel z T (2 * n / 3 + 1) + 1 ≤ coverVisitLevel z T n ∧
+      4 * coverRadius T n ≤ z.im := by
+  obtain ⟨N, hN⟩ := exists_nat_gt (-Real.log η / T)
+  have hNT : -Real.log η < T * (N : ℝ) := by
+    simpa only [mul_comm] using (div_lt_iff₀ hT).mp hN
+  have hlarge : ∀ᶠ n : ℕ in atTop,
+      3 * (Real.log (512 * Real.pi) + 1 + T) / T ≤ (n : ℝ) :=
+    tendsto_natCast_atTop_atTop.eventually (eventually_ge_atTop _)
+  have hlim : Tendsto (fun n => 4 * coverRadius T n) atTop (𝓝 0) := by
+    simpa only [mul_zero] using (coverRadius_tendsto_zero hT).const_mul 4
+  have hsmall : ∀ᶠ n : ℕ in atTop, 4 * coverRadius T n < η / 2 :=
+    hlim.eventually (gt_mem_nhds (half_pos hη))
+  filter_upwards [eventually_ge_atTop (3 * N), hlarge, hsmall] with n hn hnlarge hnsmall
+  intro z hz
+  have hlog : Real.log η ≤ Real.log (2 * z.im) :=
+    Real.log_le_log hη (by linarith)
+  have hlevels : ∀ j : ℕ, n / 3 ≤ j →
+      coverLogLevel z T j = Real.log (2 * z.im) + T * (j : ℝ) := by
+    intro j hj
+    have hjN : N ≤ j := by omega
+    have hNj : T * (N : ℝ) ≤ T * (j : ℝ) :=
+      mul_le_mul_of_nonneg_left (by exact_mod_cast hjN) hT.le
+    exact max_eq_right (by linarith)
+  refine ⟨hlevels, ?_, hnsmall.le.trans hz⟩
+  rw [hlevels (2 * n / 3 + 1) (by omega)]
+  have hlast : 3 * (2 * n / 3 + 1) ≤ 2 * n + 3 := by omega
+  have hlastR : (3 : ℝ) * (2 * n / 3 + 1 : ℕ) ≤ 2 * n + 3 := by exact_mod_cast hlast
+  have hnT := (div_le_iff₀ hT).mp hnlarge
+  unfold coverVisitLevel
+  nlinarith
+
+lemma coverVisitLevel_nonneg_of_gap (z : ℂ) (T : ℝ) (n : ℕ)
+    (hgap : coverLogLevel z T (2 * n / 3 + 1) + 1 ≤ coverVisitLevel z T n) :
+    0 ≤ coverVisitLevel z T n := by
+  have h0 := coverLogLevel_nonneg z T (2 * n / 3 + 1)
+  linarith
+
+/-- The late visit level is the fixed multiple `512π r_n` of the fine mesh,
+independently of the varying center's height. -/
+lemma coverVisitLevel_radius (z : ℂ) (hz : 0 < z.im) (T : ℝ) (n : ℕ) :
+    (2 * z.im) * Real.exp (-coverVisitLevel z T n) =
+      (512 * Real.pi) * coverRadius T n := by
+  have hz2 : 0 < 2 * z.im := by positivity
+  have hM : 0 < 512 * Real.pi := by positivity
+  have he : -coverVisitLevel z T n = Real.log (512 * Real.pi) +
+      (-Real.log (2 * z.im) + -T * (n : ℝ)) := by
+    unfold coverVisitLevel
+    ring
+  unfold coverRadius
+  rw [he, Real.exp_add, Real.exp_add,
+    Real.exp_log hM, Real.exp_neg, Real.exp_log hz2]
+  field_simp [hz2.ne']
+
+/-- The exact test window inherits the common late-grid cutoff. -/
+theorem eventually_uniform_cover_window_levels {T η : ℝ} (hT : 0 < T) (hη : 0 < η) :
+    ∀ᶠ n : ℕ in atTop, ∀ z : ℂ, η / 2 ≤ z.im →
+      (∀ j ∈ coverTestWindow n,
+        coverLogLevel z T j = Real.log (2 * z.im) + T * (j : ℝ)) ∧
+      coverLogLevel z T (2 * n / 3 + 1) =
+        Real.log (2 * z.im) + T * ((2 * n / 3 + 1 : ℕ) : ℝ) ∧
+      coverLogLevel z T (2 * n / 3 + 1) + 1 ≤ coverVisitLevel z T n ∧
+      4 * coverRadius T n ≤ z.im := by
+  filter_upwards [eventually_uniform_cover_levels hT hη] with n hn
+  intro z hz
+  obtain ⟨hlevel, hgap, hsmall⟩ := hn z hz
+  exact ⟨fun j hj => hlevel j (Finset.mem_Icc.mp hj).1,
+    hlevel _ (by omega), hgap, hsmall⟩
+
+/-- In particular the changing retained grid centers satisfy all clock and
+visit geometry simultaneously; no center-dependent cutoff is required. -/
+theorem eventually_retained_grid_cover_levels {R T η : ℝ} {K : Set ℂ}
+    (hT : 0 < T) (hη : 0 < η) (hK : K ⊆ Metric.closedBall 0 R)
+    (hheight : ∀ z ∈ K, η ≤ z.im) :
+    ∀ᶠ n : ℕ in atTop, ∀ ij ∈ retainedCoverGridIndex R (coverRadius T n) K,
+      let z := coverGridCenter (coverRadius T n) ij
+      z ∈ upperHalfPlane ∧
+      (∀ j ∈ coverTestWindow n,
+        coverLogLevel z T j = Real.log (2 * z.im) + T * (j : ℝ)) ∧
+      coverLogLevel z T (2 * n / 3 + 1) =
+        Real.log (2 * z.im) + T * ((2 * n / 3 + 1 : ℕ) : ℝ) ∧
+      coverLogLevel z T (2 * n / 3 + 1) + 1 ≤ coverVisitLevel z T n ∧
+      4 * coverRadius T n ≤ z.im := by
+  have hsmall := (coverRadius_tendsto_zero hT).eventually (gt_mem_nhds (show 0 < η / 4 by positivity))
+  filter_upwards [eventually_uniform_cover_window_levels hT hη, hsmall] with n hn hnr
+  intro ij hij
+  have hcenter := (retainedCoverGrid_center_bounds hK hheight hij).2
+  have hz : η / 2 ≤ (coverGridCenter (coverRadius T n) ij).im := by linarith
+  exact ⟨lt_of_lt_of_le (half_pos hη) hz, hn _ hz⟩
+
+end SLEExactGauge
+
+end
+
+end OAI

lean/OAI/Probability/SLE/Mass/VerticalDisplacementMass.lean

@@ -1,31 +1,31 @@
-import OAI.Probability.SLE.Loewner.HalfPlaneDisplacementBound
-
-namespace OAI
-
-/-! Reading the hydrodynamic mass from a vertical displacement bound. -/
-noncomputable section
-open Set Filter Complex
-open scoped Topology
-
-namespace SLEExactGauge
-
-lemma hydrodynamic_mass_le_of_displacement {f : ℂ → ℂ} {a b : ℝ}
-    (hcoef : Tendsto (fun z : ℂ => z*f z)
-      (cocompact ℂ ⊓ 𝓟 upperHalfPlane) (𝓝 (-a:ℂ)))
-    (hbound : ∀ z∈upperHalfPlane, ‖f z‖≤b/z.im) : a≤b := by
-  apply le_of_tendsto (hydrodynamic_vertical_limits hcoef).2
-  apply Eventually.of_forall
-  intro n
-  have hi := (Complex.im_le_norm (f (verticalInfinity n))).trans
-    (hbound _ (verticalInfinity_mem n))
-  have hy : 0<(n:ℝ)+1 := by positivity
-  have hb := (le_div_iff₀ hy).mp (show (f (verticalInfinity n)).im≤b/((n:ℝ)+1) from by
-    simpa only [verticalInfinity,mul_im,ofReal_re,I_im,mul_one,ofReal_im,I_re,mul_zero,add_zero]
-      using hi)
-  nlinarith
-
-end SLEExactGauge
-
-end
-
-end OAI
+import OAI.Probability.SLE.Loewner.HalfPlaneDisplacementBound
+
+namespace OAI
+
+/-! Reading the hydrodynamic mass from a vertical displacement bound. -/
+noncomputable section
+open Set Filter Complex
+open scoped Topology
+
+namespace SLEExactGauge
+
+lemma hydrodynamic_mass_le_of_displacement {f : ℂ → ℂ} {a b : ℝ}
+    (hcoef : Tendsto (fun z : ℂ => z*f z)
+      (cocompact ℂ ⊓ 𝓟 upperHalfPlane) (𝓝 (-a:ℂ)))
+    (hbound : ∀ z∈upperHalfPlane, ‖f z‖≤b/z.im) : a≤b := by
+  apply le_of_tendsto (hydrodynamic_vertical_limits hcoef).2
+  apply Eventually.of_forall
+  intro n
+  have hi := (Complex.im_le_norm (f (verticalInfinity n))).trans
+    (hbound _ (verticalInfinity_mem n))
+  have hy : 0<(n:ℝ)+1 := by positivity
+  have hb := (le_div_iff₀ hy).mp (show (f (verticalInfinity n)).im≤b/((n:ℝ)+1) from by
+    simpa only [verticalInfinity,mul_im,ofReal_re,I_im,mul_one,ofReal_im,I_re,mul_zero,add_zero]
+      using hi)
+  nlinarith
+
+end SLEExactGauge
+
+end
+
+end OAI

lean/OAI/Probability/SLE/Mass/WaypointHarmonicMeasure.lean

@@ -1,135 +1,135 @@
-import OAI.Probability.SLE.Geometry.WaypointTubeGeometry
-import OAI.Probability.SLE.Geometry.CrosscutExitSides
-import OAI.Probability.SLE.Geometry.WaypointAngleNumerics
-
-namespace OAI
-
-/-! The actual two-sided physical route events bound the two half-plane
-exit arcs from below.  Uniform route support is proved elsewhere; only the
-generic published conformal Brownian exit law is parameterized here. -/
-
-noncomputable section
-open Set Filter MeasureTheory Metric
-open scoped Topology NNReal ENNReal
-
-namespace SLEExactGauge.RibbonCoordinates
-open Target CrosscutSides
-
-theorem finite_exit_event_measure_le_arc
-    (μ : Measure (Driver × Driver)) (D : Set ℂ) (g : ℂ → ℂ) (w : ℂ)
-    (h : ℂ ≃ₜ ℂ) (hreal : ∀ x : ℝ, h (x : ℂ) = (x : ℂ))
-    (hg : ContinuousOn g D) (E : Set (Driver × Driver)) {dir : ℝ}
-    (hdir : dir = -1 ∨ dir = 1)
-    (hexit : ∀ᵐ b ∂μ, ∀ τ : ℝ, UnitWindowFirstExit D (physicalUnitBrownianPath w b) τ →
-      ∃ x : ℝ, x ≠ 0 ∧ Tendsto (fun t => g (physicalUnitBrownianPath w b t))
-        (𝓝[<] τ) (𝓝 (x : ℂ)))
-    (hgeom : ∀ b ∈ E, ∃ τ : ℝ,
-      UnitWindowFirstExit D (physicalUnitBrownianPath w b) τ ∧ (1 / 4 : ℝ) < τ ∧
-      ∀ t ∈ Ico (1 / 4 : ℝ) τ, (h (g (physicalUnitBrownianPath w b t))).re ≠ 0)
-    (hstart : ∀ b ∈ E, 0 < dir * (h (g (physicalUnitBrownianPath w b (1 / 4)))).re) :
-    μ E ≤ μ (unitWindowExitArc D g w dir) := by
-  apply measure_mono_ae
-  filter_upwards [hexit] with b hb
-  intro he
-  obtain ⟨τ, hτ, haτ, hn⟩ := hgeom b he
-  obtain ⟨x, hx, hlim⟩ := hb τ hτ
-  refine ⟨τ, hτ, x, ?_, hlim⟩
-  have hs := hstart b he
-  rcases hdir with rfl | rfl
-  · have hxneg := negative_first_exit_belongs_to_arc D g h hreal hg
-      (physicalUnitBrownianPath w b) (physicalUnitBrownianPath_continuous w b)
-      hτ haτ hn (by nlinarith) x hx hlim
-    nlinarith
-  · have hxpos := positive_first_exit_belongs_to_arc D g h hreal hg
-      (physicalUnitBrownianPath w b) (physicalUnitBrownianPath_continuous w b)
-      hτ haτ hn (by simpa using hs) x hx hlim
-    simpa using hxpos
-
-theorem ribbon_tube_harmonic_bounds
-    (hopen : PublishedPlanarDiskOpenness) (hexitLaw : PublishedHalfPlaneConformalExitLaw)
-    (W : WienerLaw) (hW : IsWiener W) (K : ℝ≥0) (hK : 0 < (K : ℝ))
-    (P : ℂ → ℂ) (hP : ContinuousOn P closedRibbon) (hi : InjOn P closedRibbon)
-    (hH : ∀ z ∈ closedRibbon, 0 < z.re → P z ∈ upperHalfPlane)
-    {k ε x : ℝ} (hk : 1 ≤ k) (hε : 0 < ε) (hεsmall : ε ≤ 1 / 8)
-    (hx : |x| ≤ 1 / 16)
-    (hlower : ∀ u ∈ crossingPatch k, ∀ v ∈ crossingPatch k,
-      dist u v ≤ K * dist (P u) (P v))
-    (γ xp : ℝ≥0 → ℂ) (hγc : Continuous γ) (T : ℝ≥0) (hT : 0 < T)
-    (hxp : ContinuousOn xp (Icc 0 T)) (hγ : EqOn γ (P ∘ xp) (Icc 0 T))
-    (hxp0 : (xp 0).re = 0) (hxpT : (xp T).re = k)
-    (hcoords : MapsTo xp (Icc 0 T) closedRibbon)
-    (hcore : ∀ t ∈ Icc 0 T, (xp t).re ≤ k ∧ |(xp t).im| ≤ ε)
-    (hunbounded : ¬ Bornology.IsBounded (P '' futureRibbon k))
-    (g F : ℂ → ℂ)
-    (hg : DifferentiableOn ℂ g (survivingDomain γ T))
-    (hF : DifferentiableOn ℂ F upperHalfPlane)
-    (hgH : MapsTo g (survivingDomain γ T) upperHalfPlane)
-    (hFD : MapsTo F upperHalfPlane (survivingDomain γ T))
-    (hFg : ∀ z ∈ survivingDomain γ T, F (g z) = z)
-    (hgF : ∀ z ∈ upperHalfPlane, g (F z) = z)
-    (h : ℂ ≃ₜ ℂ) (hreal : ∀ x : ℝ, h (x : ℂ) = (x : ℂ))
-    (hcut : ∀ z ∈ survivingDomain γ T, (h (g z)).re = 0 →
-      ∃ u : ℝ, 0 ≤ u ∧ P (guideCoordinate k x u) = z)
-    (hloc : ContinuousOn (fun z => h (g (P z)))
-      (ball ((k + 1 / 2 : ℝ) : ℂ) (1 / 4)))
-    (hloci : InjOn (fun z => h (g (P z)))
-      (ball ((k + 1 / 2 : ℝ) : ℂ) (1 / 4)))
-    (hlocz : ∀ z ∈ ball ((k + 1 / 2 : ℝ) : ℂ) (1 / 4),
-      (h (g (P z))).re = 0 ↔ z.im = 0)
-    (q : ℝ≥0∞)
-    (hprob : ∀ side : ℝ, (side = -1 ∨ side = 1) →
-      q ≤ (W.prod W) {b | ∀ t ∈ Icc (0 : ℝ) 3,
-        dist (physicalUnitBrownianPath (P ((k + 1 / 2 : ℝ) : ℂ)) b t)
-          (P (waypointRoute k side t)) < (1 / 32 : ℝ) / K}) :
-    q ≤ ENNReal.ofReal ((g (P ((k + 1 / 2 : ℝ) : ℂ))).arg / Real.pi) ∧
-      q ≤ ENNReal.ofReal (1 - (g (P ((k + 1 / 2 : ℝ) : ℂ))).arg / Real.pi) := by
-  let D := survivingDomain γ T
-  let w := P ((k + 1 / 2 : ℝ) : ℂ)
-  let E := fun side : ℝ => {b | ∀ t ∈ Icc (0 : ℝ) 3,
-    dist (physicalUnitBrownianPath w b t) (P (waypointRoute k side t)) < (1 / 32 : ℝ) / K}
-  have hpast : γ '' Icc 0 T ⊆ P '' {z ∈ closedRibbon | z.re ≤ k} := by
-    rintro z ⟨s, hs, rfl⟩
-    exact ⟨xp s, ⟨hcoords hs, (hcore s hs).1⟩, (hγ hs).symm⟩
-  have hwD : w ∈ D := by
-    apply futureRibbon_survives P hP hi (by linarith) hH γ T hpast hunbounded
-    exact ⟨((k + 1 / 2 : ℝ) : ℂ), ��by simp, by simp⟩, rfl⟩
-  obtain ⟨hae, hnegBound, hposBound⟩ := hexitLaw W hW D g F
-    (isOpen_survivingDomain hγc T) (fun z hz => hz.1.1) hg hF hgH hFD hFg hgF w hwD
-  obtain ⟨side, hside, hpos, hneg⟩ := physical_waypoint_tubes_opposite_sides hopen P hP hi
-    K hK hk hlower (fun z => h (g (P z))) (fun z => (h (g z)).re)
-    hloc hloci hlocz (fun _ _ => rfl)
-  have hgeom (side' : ℝ) (hside' : side' = -1 ∨ side' = 1) (b : Driver × Driver)
-      (hb : b ∈ E side') : ∃ τ : ℝ,
-      UnitWindowFirstExit D (physicalUnitBrownianPath w b) τ ∧ (1 / 4 : ℝ) < τ ∧
-      ∀ t ∈ Ico (1 / 4 : ℝ) τ, (h (g (physicalUnitBrownianPath w b t))).re ≠ 0 := by
-    let ζ := physicalUnitBrownianPath w b
-    have hζ : Continuous ζ := physicalUnitBrownianPath_continuous w b
-    obtain ⟨hearly, havoid, hhit⟩ := physical_waypoint_tube_geometry hopen P hP hi hH K hK
-      hk hε hεsmall hx hside' hlower γ xp T hT hxp hγ hxp0 hxpT hcoords hcore hunbounded
-      ζ hζ hb
-    obtain ⟨τ, hτ, hout, hin⟩ := waypoint_first_exit_after_early_prefix γ hγc T ζ
-      hζ.continuousOn hearly hhit
-    refine ⟨τ, ⟨⟨by linarith [hτ.1], hτ.2⟩, hout, hin⟩, by linarith [hτ.1], ?_⟩
-    intro t ht he
-    obtain ⟨u, hu, heq⟩ := hcut (ζ t) (hin ⟨by linarith [ht.1], ht.2⟩) he
-    exact havoid t ⟨ht.1, ht.2.le.trans hτ.2⟩ u hu heq.symm
-  have hposProb : q ≤ (W.prod W) (unitWindowExitArc D g w 1) := by
-    refine (hprob side hside).trans (finite_exit_event_measure_le_arc (W.prod W) D g w h hreal
-      hg.continuousOn (E side) (Or.inr rfl) hae (hgeom side hside) ?_)
-    intro b hb
-    simpa only [one_mul] using hpos _ (hb _ (by norm_num))
-  have hsideNeg : -side = -1 ∨ -side = 1 := by
-    rcases hside with rfl | rfl <;> norm_num
-  have hnegProb : q ≤ (W.prod W) (unitWindowExitArc D g w (-1)) := by
-    refine (hprob (-side) hsideNeg).trans (finite_exit_event_measure_le_arc (W.prod W) D g w h hreal
-      hg.continuousOn (E (-side)) (Or.inl rfl) hae (hgeom (-side) hsideNeg) ?_)
-    intro b hb
-    have hh := hneg _ (hb _ (by norm_num))
-    nlinarith
-  exact ⟨hnegProb.trans hnegBound, hposProb.trans hposBound⟩
-
-end SLEExactGauge.RibbonCoordinates
-
-end
-
-end OAI
+import OAI.Probability.SLE.Geometry.WaypointTubeGeometry
+import OAI.Probability.SLE.Geometry.CrosscutExitSides
+import OAI.Probability.SLE.Geometry.WaypointAngleNumerics
+
+namespace OAI
+
+/-! The actual two-sided physical route events bound the two half-plane
+exit arcs from below.  Uniform route support is proved elsewhere; only the
+generic published conformal Brownian exit law is parameterized here. -/
+
+noncomputable section
+open Set Filter MeasureTheory Metric
+open scoped Topology NNReal ENNReal
+
+namespace SLEExactGauge.RibbonCoordinates
+open Target CrosscutSides
+
+theorem finite_exit_event_measure_le_arc
+    (μ : Measure (Driver × Driver)) (D : Set ℂ) (g : ℂ → ℂ) (w : ℂ)
+    (h : ℂ ≃ₜ ℂ) (hreal : ∀ x : ℝ, h (x : ℂ) = (x : ℂ))
+    (hg : ContinuousOn g D) (E : Set (Driver × Driver)) {dir : ℝ}
+    (hdir : dir = -1 ∨ dir = 1)
+    (hexit : ∀ᵐ b ∂μ, ∀ τ : ℝ, UnitWindowFirstExit D (physicalUnitBrownianPath w b) τ →
+      ∃ x : ℝ, x ≠ 0 ∧ Tendsto (fun t => g (physicalUnitBrownianPath w b t))
+        (𝓝[<] τ) (𝓝 (x : ℂ)))
+    (hgeom : ∀ b ∈ E, ∃ τ : ℝ,
+      UnitWindowFirstExit D (physicalUnitBrownianPath w b) τ ∧ (1 / 4 : ℝ) < τ ∧
+      ∀ t ∈ Ico (1 / 4 : ℝ) τ, (h (g (physicalUnitBrownianPath w b t))).re ≠ 0)
+    (hstart : ∀ b ∈ E, 0 < dir * (h (g (physicalUnitBrownianPath w b (1 / 4)))).re) :
+    μ E ≤ μ (unitWindowExitArc D g w dir) := by
+  apply measure_mono_ae
+  filter_upwards [hexit] with b hb
+  intro he
+  obtain ⟨τ, hτ, haτ, hn⟩ := hgeom b he
+  obtain ⟨x, hx, hlim⟩ := hb τ hτ
+  refine ⟨τ, hτ, x, ?_, hlim⟩
+  have hs := hstart b he
+  rcases hdir with rfl | rfl
+  · have hxneg := negative_first_exit_belongs_to_arc D g h hreal hg
+      (physicalUnitBrownianPath w b) (physicalUnitBrownianPath_continuous w b)
+      hτ haτ hn (by nlinarith) x hx hlim
+    nlinarith
+  · have hxpos := positive_first_exit_belongs_to_arc D g h hreal hg
+      (physicalUnitBrownianPath w b) (physicalUnitBrownianPath_continuous w b)
+      hτ haτ hn (by simpa using hs) x hx hlim
+    simpa using hxpos
+
+theorem ribbon_tube_harmonic_bounds
+    (hopen : PublishedPlanarDiskOpenness) (hexitLaw : PublishedHalfPlaneConformalExitLaw)
+    (W : WienerLaw) (hW : IsWiener W) (K : ℝ≥0) (hK : 0 < (K : ℝ))
+    (P : ℂ → ℂ) (hP : ContinuousOn P closedRibbon) (hi : InjOn P closedRibbon)
+    (hH : ∀ z ∈ closedRibbon, 0 < z.re → P z ∈ upperHalfPlane)
+    {k ε x : ℝ} (hk : 1 ≤ k) (hε : 0 < ε) (hεsmall : ε ≤ 1 / 8)
+    (hx : |x| ≤ 1 / 16)
+    (hlower : ∀ u ∈ crossingPatch k, ∀ v ∈ crossingPatch k,
+      dist u v ≤ K * dist (P u) (P v))
+    (γ xp : ℝ≥0 → ℂ) (hγc : Continuous γ) (T : ℝ≥0) (hT : 0 < T)
+    (hxp : ContinuousOn xp (Icc 0 T)) (hγ : EqOn γ (P ∘ xp) (Icc 0 T))
+    (hxp0 : (xp 0).re = 0) (hxpT : (xp T).re = k)
+    (hcoords : MapsTo xp (Icc 0 T) closedRibbon)
+    (hcore : ∀ t ∈ Icc 0 T, (xp t).re ≤ k ∧ |(xp t).im| ≤ ε)
+    (hunbounded : ¬ Bornology.IsBounded (P '' futureRibbon k))
+    (g F : ℂ → ℂ)
+    (hg : DifferentiableOn ℂ g (survivingDomain γ T))
+    (hF : DifferentiableOn ℂ F upperHalfPlane)
+    (hgH : MapsTo g (survivingDomain γ T) upperHalfPlane)
+    (hFD : MapsTo F upperHalfPlane (survivingDomain γ T))
+    (hFg : ∀ z ∈ survivingDomain γ T, F (g z) = z)
+    (hgF : ∀ z ∈ upperHalfPlane, g (F z) = z)
+    (h : ℂ ≃ₜ ℂ) (hreal : ∀ x : ℝ, h (x : ℂ) = (x : ℂ))
+    (hcut : ∀ z ∈ survivingDomain γ T, (h (g z)).re = 0 →
+      ∃ u : ℝ, 0 ≤ u ∧ P (guideCoordinate k x u) = z)
+    (hloc : ContinuousOn (fun z => h (g (P z)))
+      (ball ((k + 1 / 2 : ℝ) : ℂ) (1 / 4)))
+    (hloci : InjOn (fun z => h (g (P z)))
+      (ball ((k + 1 / 2 : ℝ) : ℂ) (1 / 4)))
+    (hlocz : ∀ z ∈ ball ((k + 1 / 2 : ℝ) : ℂ) (1 / 4),
+      (h (g (P z))).re = 0 ↔ z.im = 0)
+    (q : ℝ≥0∞)
+    (hprob : ∀ side : ℝ, (side = -1 ∨ side = 1) →
+      q ≤ (W.prod W) {b | ∀ t ∈ Icc (0 : ℝ) 3,
+        dist (physicalUnitBrownianPath (P ((k + 1 / 2 : ℝ) : ℂ)) b t)
+          (P (waypointRoute k side t)) < (1 / 32 : ℝ) / K}) :
+    q ≤ ENNReal.ofReal ((g (P ((k + 1 / 2 : ℝ) : ℂ))).arg / Real.pi) ∧
+      q ≤ ENNReal.ofReal (1 - (g (P ((k + 1 / 2 : ℝ) : ℂ))).arg / Real.pi) := by
+  let D := survivingDomain γ T
+  let w := P ((k + 1 / 2 : ℝ) : ℂ)
+  let E := fun side : ℝ => {b | ∀ t ∈ Icc (0 : ℝ) 3,
+    dist (physicalUnitBrownianPath w b t) (P (waypointRoute k side t)) < (1 / 32 : ℝ) / K}
+  have hpast : γ '' Icc 0 T ⊆ P '' {z ∈ closedRibbon | z.re ≤ k} := by
+    rintro z ⟨s, hs, rfl⟩
+    exact ⟨xp s, ⟨hcoords hs, (hcore s hs).1⟩, (hγ hs).symm⟩
+  have hwD : w ∈ D := by
+    apply futureRibbon_survives P hP hi (by linarith) hH γ T hpast hunbounded
+    exact ⟨((k + 1 / 2 : ℝ) : ℂ), ⟨by simp, by simp⟩, rfl⟩
+  obtain ⟨hae, hnegBound, hposBound⟩ := hexitLaw W hW D g F
+    (isOpen_survivingDomain hγc T) (fun z hz => hz.1.1) hg hF hgH hFD hFg hgF w hwD
+  obtain ⟨side, hside, hpos, hneg⟩ := physical_waypoint_tubes_opposite_sides hopen P hP hi
+    K hK hk hlower (fun z => h (g (P z))) (fun z => (h (g z)).re)
+    hloc hloci hlocz (fun _ _ => rfl)
+  have hgeom (side' : ℝ) (hside' : side' = -1 ∨ side' = 1) (b : Driver × Driver)
+      (hb : b ∈ E side') : ∃ τ : ℝ,
+      UnitWindowFirstExit D (physicalUnitBrownianPath w b) τ ∧ (1 / 4 : ℝ) < τ ∧
+      ∀ t ∈ Ico (1 / 4 : ℝ) τ, (h (g (physicalUnitBrownianPath w b t))).re ≠ 0 := by
+    let ζ := physicalUnitBrownianPath w b
+    have hζ : Continuous ζ := physicalUnitBrownianPath_continuous w b
+    obtain ⟨hearly, havoid, hhit⟩ := physical_waypoint_tube_geometry hopen P hP hi hH K hK
+      hk hε hεsmall hx hside' hlower γ xp T hT hxp hγ hxp0 hxpT hcoords hcore hunbounded
+      ζ hζ hb
+    obtain ⟨τ, hτ, hout, hin⟩ := waypoint_first_exit_after_early_prefix γ hγc T ζ
+      hζ.continuousOn hearly hhit
+    refine ⟨τ, ⟨⟨by linarith [hτ.1], hτ.2⟩, hout, hin⟩, by linarith [hτ.1], ?_⟩
+    intro t ht he
+    obtain ⟨u, hu, heq⟩ := hcut (ζ t) (hin ⟨by linarith [ht.1], ht.2⟩) he
+    exact havoid t ⟨ht.1, ht.2.le.trans hτ.2⟩ u hu heq.symm
+  have hposProb : q ≤ (W.prod W) (unitWindowExitArc D g w 1) := by
+    refine (hprob side hside).trans (finite_exit_event_measure_le_arc (W.prod W) D g w h hreal
+      hg.continuousOn (E side) (Or.inr rfl) hae (hgeom side hside) ?_)
+    intro b hb
+    simpa only [one_mul] using hpos _ (hb _ (by norm_num))
+  have hsideNeg : -side = -1 ∨ -side = 1 := by
+    rcases hside with rfl | rfl <;> norm_num
+  have hnegProb : q ≤ (W.prod W) (unitWindowExitArc D g w (-1)) := by
+    refine (hprob (-side) hsideNeg).trans (finite_exit_event_measure_le_arc (W.prod W) D g w h hreal
+      hg.continuousOn (E (-side)) (Or.inl rfl) hae (hgeom (-side) hsideNeg) ?_)
+    intro b hb
+    have hh := hneg _ (hb _ (by norm_num))
+    nlinarith
+  exact ⟨hnegProb.trans hnegBound, hposProb.trans hposBound⟩
+
+end SLEExactGauge.RibbonCoordinates
+
+end
+
+end OAI

lean/OAI/Probability/SLE/Mass/WeightedCompactMass.lean

@@ -1,108 +1,108 @@
-import OAI.Probability.SLE.Mass.CanonicalMassContinuity
-import OAI.Probability.SLE.Geometry.ConformalRestartTransport
-
-namespace OAI
-
-/-! Bounded compact weights preserve the scalar continuity estimates
-used for the canonical disk mass. -/
-
-noncomputable section
-open Set Filter _root_.MeasureTheory _root_.OAI.MeasureTheory
-open scoped Topology NNReal ENNReal
-
-namespace SLEExactGauge
-
-lemma integral_weight_difference_le
-    {X : Type*} [MeasurableSpace X] (μ ν : Measure X)
-    [IsFiniteMeasure μ] [IsFiniteMeasure ν] (hμν : μ ≤ ν)
-    (f : X → ℝ) (hf : Integrable f ν) (M : ℝ)
-    (h0 : 0 ≤ᵐ[ν] f) (hM : ∀ᵐ x ∂ν, f x ≤ M) :
-    0 ≤ (∫ x, f x ∂ν)-(∫ x, f x ∂μ) ∧
-      (∫ x, f x ∂ν)-(∫ x, f x ∂μ) ≤ M*((ν univ).toReal-(μ univ).toReal) := by
-  let ξ := ν-μ
-  have hξν : ξ ≤ ν := Measure.sub_le
-  have hξ : Integrable f ξ := hf.mono_measure hξν
-  have hμ : Integrable f μ := hf.mono_measure hμν
-  have he : (∫ x, f x ∂ν) = (∫ x, f x ∂ξ)+(∫ x, f x ∂μ) := by
-    rw [← sigmaFinite_sub_add_cancel_of_le hμν]
-    exact integral_add_measure hξ hμ
-  have hn : 0 ≤ ∫ x, f x ∂ξ := integral_nonneg_of_ae (ae_mono hξν h0)
-  have hi : (∫ x, f x ∂ξ) ≤ ∫ _ : X, M ∂ξ :=
-    integral_mono_ae hξ (integrable_const M) (ae_mono hξν hM)
-  have hv : (ξ univ).toReal = (ν univ).toReal-(μ univ).toReal := by
-    rw [Measure.sub_apply MeasurableSet.univ hμν,
-      ENNReal.toReal_sub_of_le (hμν univ) (measure_ne_top ν univ)]
-  simp only [integral_const,smul_eq_mul,measureReal_def,hv] at hi
-  constructor
-  · linarith
-  · rw [mul_comm] at hi
-    linarith
-
-namespace Multipoint
-
-lemma compact_weight_bounded (w : C(upperHalfPlane,ℝ≥0))
-    (K : Set upperHalfPlane) (hK : IsCompact K) :
-    ∃ M : ℝ≥0, ∀ z ∈ K, w z ≤ M := by
-  obtain ⟨M,hM⟩ := hK.bddAbove_image w.continuous.continuousOn
-  exact ⟨M,fun z hz => hM (mem_image_of_mem _ hz)⟩
-
-lemma compact_weight_integrable (w : C(upperHalfPlane,ℝ≥0))
-    (K : Set upperHalfPlane) (hK : IsCompact K)
-    (μ : Measure upperHalfPlane) [IsFiniteMeasureOnCompacts μ] :
-    IntegrableOn (fun z => (w z:ℝ)) K μ :=
-  (continuous_subtype_val.comp w.continuous).continuousOn.integrableOn_compact hK
-
-lemma compact_weight_difference_le
-    (w : C(upperHalfPlane,ℝ≥0)) (K : Set upperHalfPlane) (hK : IsCompact K)
-    (M : ℝ≥0) (hM : ∀ z ∈ K, w z ≤ M)
-    (μ ν : Measure upperHalfPlane)
-    [IsFiniteMeasureOnCompacts μ] [IsFiniteMeasureOnCompacts ν] (hμν : μ ≤ ν) :
-    |(∫ z in K, (w z:ℝ) ∂ν)-(∫ z in K, (w z:ℝ) ∂μ)| ≤
-      (M:ℝ)*|(ν K).toReal-(μ K).toReal| := by
-  let : IsFiniteMeasure (μ.restrict K) := ⟨by simpa using hK.measure_lt_top (μ := μ)⟩
-  let : IsFiniteMeasure (ν.restrict K) := ⟨by simpa using hK.measure_lt_top (μ := ν)⟩
-  have h := integral_weight_difference_le (μ.restrict K) (ν.restrict K)
-    (Measure.restrict_mono le_rfl hμν) (fun z => (w z:ℝ))
-    (compact_weight_integrable w K hK ν) M
-    (ae_of_all _ (fun z => (w z).coe_nonneg))
-    ((ae_restrict_mem hK.measurableSet).mono (fun z hz => NNReal.coe_le_coe.mpr (hM z hz)))
-  have hv : (μ K).toReal ≤ (ν K).toReal :=
-    ENNReal.toReal_mono hK.measure_ne_top (hμν K)
-  simpa only [Measure.restrict_apply_univ,abs_of_nonneg h.1,
-    abs_of_nonneg (sub_nonneg.mpr hv)] using h.2
-
-theorem ContinuousMassPath.weighted_compact_continuous
-    {γ : ℝ≥0 → ℂ} {μ : ℚ → Measure upperHalfPlane} {ν : Measure upperHalfPlane}
-    {N : ℝ≥0 → Measure upperHalfPlane} (hp : ContinuousMassPath γ μ ν N)
-    (hN : ∀ t, IsFiniteMeasureOnCompacts (N t))
-    (w : C(upperHalfPlane,ℝ≥0)) (K : Set upperHalfPlane) (hK : IsCompact K) :
-    Continuous (fun t => ∫ z in K, (w z:ℝ) ∂N t) := by
-  obtain ⟨M,hM⟩ := compact_weight_bounded w K hK
-  apply continuous_iff_continuousAt.mpr
-  intro t₀
-  rw [Metric.continuousAt_iff]
-  intro ε hε
-  have hpos : 0 < ε/((M:ℝ)+1) := div_pos hε (by positivity)
-  obtain ⟨δ,hδ,hvar⟩ := hp.local_variation K hK t₀ _ hpos
-  refine ⟨δ,hδ,?_⟩
-  intro t ht
-  let := hN t
-  let := hN t₀
-  have ht' : dist (t:ℝ) (t₀:ℝ) < δ := ht
-  have hsmall := hvar t t₀ ht' (by simpa using hδ) K hK.measurableSet Subset.rfl
-  have hb : |(∫ z in K, (w z:ℝ) ∂N t)-(∫ z in K, (w z:ℝ) ∂N t₀)| ≤
-      (M:ℝ)*|((N t) K).toReal-((N t₀) K).toReal| := by
-    rcases le_total t t₀ with htt | htt
-    · have h := compact_weight_difference_le w K hK M hM (N t) (N t₀) (hp.monotone htt)
-      simpa only [abs_sub_comm] using h
-    · exact compact_weight_difference_le w K hK M hM (N t₀) (N t) (hp.monotone htt)
-  rw [Real.dist_eq]
-  have he : ε/((M:ℝ)+1)*((M:ℝ)+1)=ε := div_mul_cancel₀ _ (by positivity)
-  nlinarith [abs_nonneg (((N t) K).toReal-((N t₀) K).toReal),M.coe_nonneg]
-
-end Multipoint
-end SLEExactGauge
-
-end
-
-end OAI
+import OAI.Probability.SLE.Mass.CanonicalMassContinuity
+import OAI.Probability.SLE.Geometry.ConformalRestartTransport
+
+namespace OAI
+
+/-! Bounded compact weights preserve the scalar continuity estimates
+used for the canonical disk mass. -/
+
+noncomputable section
+open Set Filter _root_.MeasureTheory _root_.OAI.MeasureTheory
+open scoped Topology NNReal ENNReal
+
+namespace SLEExactGauge
+
+lemma integral_weight_difference_le
+    {X : Type*} [MeasurableSpace X] (μ ν : Measure X)
+    [IsFiniteMeasure μ] [IsFiniteMeasure ν] (hμν : μ ≤ ν)
+    (f : X → ℝ) (hf : Integrable f ν) (M : ℝ)
+    (h0 : 0 ≤ᵐ[ν] f) (hM : ∀ᵐ x ∂ν, f x ≤ M) :
+    0 ≤ (∫ x, f x ∂ν)-(∫ x, f x ∂μ) ∧
+      (∫ x, f x ∂ν)-(∫ x, f x ∂μ) ≤ M*((ν univ).toReal-(μ univ).toReal) := by
+  let ξ := ν-μ
+  have hξν : ξ ≤ ν := Measure.sub_le
+  have hξ : Integrable f ξ := hf.mono_measure hξν
+  have hμ : Integrable f μ := hf.mono_measure hμν
+  have he : (∫ x, f x ∂ν) = (∫ x, f x ∂ξ)+(∫ x, f x ∂μ) := by
+    rw [← sigmaFinite_sub_add_cancel_of_le hμν]
+    exact integral_add_measure hξ hμ
+  have hn : 0 ≤ ∫ x, f x ∂ξ := integral_nonneg_of_ae (ae_mono hξν h0)
+  have hi : (∫ x, f x ∂ξ) ≤ ∫ _ : X, M ∂ξ :=
+    integral_mono_ae hξ (integrable_const M) (ae_mono hξν hM)
+  have hv : (ξ univ).toReal = (ν univ).toReal-(μ univ).toReal := by
+    rw [Measure.sub_apply MeasurableSet.univ hμν,
+      ENNReal.toReal_sub_of_le (hμν univ) (measure_ne_top ν univ)]
+  simp only [integral_const,smul_eq_mul,measureReal_def,hv] at hi
+  constructor
+  · linarith
+  · rw [mul_comm] at hi
+    linarith
+
+namespace Multipoint
+
+lemma compact_weight_bounded (w : C(upperHalfPlane,ℝ≥0))
+    (K : Set upperHalfPlane) (hK : IsCompact K) :
+    ∃ M : ℝ≥0, ∀ z ∈ K, w z ≤ M := by
+  obtain ⟨M,hM⟩ := hK.bddAbove_image w.continuous.continuousOn
+  exact ⟨M,fun z hz => hM (mem_image_of_mem _ hz)⟩
+
+lemma compact_weight_integrable (w : C(upperHalfPlane,ℝ≥0))
+    (K : Set upperHalfPlane) (hK : IsCompact K)
+    (μ : Measure upperHalfPlane) [IsFiniteMeasureOnCompacts μ] :
+    IntegrableOn (fun z => (w z:ℝ)) K μ :=
+  (continuous_subtype_val.comp w.continuous).continuousOn.integrableOn_compact hK
+
+lemma compact_weight_difference_le
+    (w : C(upperHalfPlane,ℝ≥0)) (K : Set upperHalfPlane) (hK : IsCompact K)
+    (M : ℝ≥0) (hM : ∀ z ∈ K, w z ≤ M)
+    (μ ν : Measure upperHalfPlane)
+    [IsFiniteMeasureOnCompacts μ] [IsFiniteMeasureOnCompacts ν] (hμν : μ ≤ ν) :
+    |(∫ z in K, (w z:ℝ) ∂ν)-(∫ z in K, (w z:ℝ) ∂μ)| ≤
+      (M:ℝ)*|(ν K).toReal-(μ K).toReal| := by
+  let : IsFiniteMeasure (μ.restrict K) := ⟨by simpa using hK.measure_lt_top (μ := μ)⟩
+  let : IsFiniteMeasure (ν.restrict K) := ⟨by simpa using hK.measure_lt_top (μ := ν)⟩
+  have h := integral_weight_difference_le (μ.restrict K) (ν.restrict K)
+    (Measure.restrict_mono le_rfl hμν) (fun z => (w z:ℝ))
+    (compact_weight_integrable w K hK ν) M
+    (ae_of_all _ (fun z => (w z).coe_nonneg))
+    ((ae_restrict_mem hK.measurableSet).mono (fun z hz => NNReal.coe_le_coe.mpr (hM z hz)))
+  have hv : (μ K).toReal ≤ (ν K).toReal :=
+    ENNReal.toReal_mono hK.measure_ne_top (hμν K)
+  simpa only [Measure.restrict_apply_univ,abs_of_nonneg h.1,
+    abs_of_nonneg (sub_nonneg.mpr hv)] using h.2
+
+theorem ContinuousMassPath.weighted_compact_continuous
+    {γ : ℝ≥0 → ℂ} {μ : ℚ → Measure upperHalfPlane} {ν : Measure upperHalfPlane}
+    {N : ℝ≥0 → Measure upperHalfPlane} (hp : ContinuousMassPath γ μ ν N)
+    (hN : ∀ t, IsFiniteMeasureOnCompacts (N t))
+    (w : C(upperHalfPlane,ℝ≥0)) (K : Set upperHalfPlane) (hK : IsCompact K) :
+    Continuous (fun t => ∫ z in K, (w z:ℝ) ∂N t) := by
+  obtain ⟨M,hM⟩ := compact_weight_bounded w K hK
+  apply continuous_iff_continuousAt.mpr
+  intro t₀
+  rw [Metric.continuousAt_iff]
+  intro ε hε
+  have hpos : 0 < ε/((M:ℝ)+1) := div_pos hε (by positivity)
+  obtain ⟨δ,hδ,hvar⟩ := hp.local_variation K hK t₀ _ hpos
+  refine ⟨δ,hδ,?_⟩
+  intro t ht
+  let := hN t
+  let := hN t₀
+  have ht' : dist (t:ℝ) (t₀:ℝ) < δ := ht
+  have hsmall := hvar t t₀ ht' (by simpa using hδ) K hK.measurableSet Subset.rfl
+  have hb : |(∫ z in K, (w z:ℝ) ∂N t)-(∫ z in K, (w z:ℝ) ∂N t₀)| ≤
+      (M:ℝ)*|((N t) K).toReal-((N t₀) K).toReal| := by
+    rcases le_total t t₀ with htt | htt
+    · have h := compact_weight_difference_le w K hK M hM (N t) (N t₀) (hp.monotone htt)
+      simpa only [abs_sub_comm] using h
+    · exact compact_weight_difference_le w K hK M hM (N t₀) (N t) (hp.monotone htt)
+  rw [Real.dist_eq]
+  have he : ε/((M:ℝ)+1)*((M:ℝ)+1)=ε := div_mul_cancel₀ _ (by positivity)
+  nlinarith [abs_nonneg (((N t) K).toReal-((N t₀) K).toReal),M.coe_nonneg]
+
+end Multipoint
+end SLEExactGauge
+
+end
+
+end OAI

lean/OAI/Probability/SLE/Mass/WeightedImageRandomMass.lean

@@ -1,97 +1,97 @@
-import OAI.Probability.SLE.Mass.RestartRandomMassTesting
-
-namespace OAI
-
-/-! Measurable weighted images of locally finite random half-plane measures.
-The weight and image map can be chosen from the stopped past. -/
-
-noncomputable section
-open Set Filter MeasureTheory Classical
-open scoped ENNReal
-
-namespace SLEExactGauge
-
-def weightedImageMass {X : Type*} [MeasurableSpace X]
-    (J : upperHalfPlane → X) (w : upperHalfPlane → ℝ≥0∞)
-    (μ : Measure upperHalfPlane) : Measure X :=
-  (μ.withDensity w).map J
-
-lemma weightedImageMass_apply {X : Type*} [MeasurableSpace X]
-    (J : upperHalfPlane → X) (hJ : Measurable J)
-    (w : upperHalfPlane → ℝ≥0∞) (μ : Measure upperHalfPlane)
-    (A : Set X) (hA : MeasurableSet A) :
-    weightedImageMass J w μ A = ∫⁻ z, (J ⁻¹' A).indicator w z ∂μ := by
-  rw [weightedImageMass,Measure.map_apply hJ hA,withDensity_apply _ (hJ hA),
-    lintegral_indicator (hJ hA)]
-
-theorem weightedImageMass_measurable
-    {Ω X : Type*} [MeasurableSpace Ω] [MeasurableSpace X]
-    (μ : Ω → Measure upperHalfPlane) (hμ : Measurable μ)
-    (hfin : ∀ ω, IsFiniteMeasureOnCompacts (μ ω))
-    (J : Ω × upperHalfPlane → X) (hJ : Measurable J)
-    (w : Ω × upperHalfPlane → ℝ≥0∞) (hw : Measurable w) :
-    Measurable (fun ω => weightedImageMass (fun z => J (ω,z))
-      (fun z => w (ω,z)) (μ ω)) := by
-  apply Measure.measurable_of_measurable_coe
-  intro A hA
-  have he (ω : Ω) := weightedImageMass_apply (fun z => J (ω,z))
-    (hJ.comp (measurable_const.prodMk measurable_id)) (fun z => w (ω,z)) (μ ω) A hA
-  simp_rw [he]
-  exact halfPlane_random_test_measurable μ hμ hfin
-    ((J ⁻¹' A).indicator w) (hw.indicator (hJ hA))
-
-lemma weightedImageMass_lintegral {X : Type*} [MeasurableSpace X]
-    (J : upperHalfPlane → X) (hJ : Measurable J)
-    (w : upperHalfPlane → ℝ≥0∞) (hw : Measurable w)
-    (μ : Measure upperHalfPlane) (f : X → ℝ≥0∞) (hf : Measurable f) :
-    (∫⁻ x, f x ∂weightedImageMass J w μ) = ∫⁻ z, w z*f (J z) ∂μ := by
-  rw [weightedImageMass,lintegral_map hf hJ]
-  exact lintegral_withDensity_eq_lintegral_mul μ hw
-    (show Measurable (fun z => f (J z)) from hf.comp hJ)
-
-theorem weightedImageMass_measurable_of_subsigma
-    {Ω X : Type*} [mΩ : MeasurableSpace Ω] [MeasurableSpace X]
-    (m : MeasurableSpace Ω) (hm : m ≤ mΩ)
-    (μ : Ω → Measure upperHalfPlane) (hμ : Measurable[mΩ] μ)
-    (hfin : ∀ ω, IsFiniteMeasureOnCompacts (μ ω))
-    (J : Ω × upperHalfPlane → X) (hJ : Measurable[m.prod inferInstance] J)
-    (w : Ω × upperHalfPlane → ℝ≥0∞) (hw : Measurable[m.prod inferInstance] w) :
-    Measurable[mΩ] (fun ω => weightedImageMass (fun z => J (ω,z))
-      (fun z => w (ω,z)) (μ ω)) := by
-  let : MeasurableSpace Ω := mΩ
-  have hle : m.prod (inferInstance : MeasurableSpace upperHalfPlane) ≤ mΩ.prod inferInstance :=
-    sup_le_sup (MeasurableSpace.comap_mono hm) le_rfl
-  exact weightedImageMass_measurable μ hμ hfin J (hJ.mono hle le_rfl) w (hw.mono hle le_rfl)
-
-theorem restart_weighted_mass_test
-    {Ω X Y : Type*} [mΩ : MeasurableSpace Ω] [mX : MeasurableSpace X]
-    [mY : MeasurableSpace Y]
-    (P : Measure Ω) [IsFiniteMeasure P] (ν : Measure X) [IsFiniteMeasure ν]
-    (m : MeasurableSpace Ω) (hm : m ≤ mΩ)
-    (V : Ω → X) (hV : Measurable[mΩ] V)
-    (hlaw : ∀ A : Set Ω, MeasurableSet[m] A →
-      @Measure.map Ω X mΩ mX V (P.restrict A) = P A • ν)
-    (M : X → Measure upperHalfPlane) (hM : Measurable M)
-    (hMf : ∀ x, IsFiniteMeasureOnCompacts (M x))
-    (J : Ω × upperHalfPlane → Y) (hJ : Measurable[m.prod inferInstance] J)
-    (w : Ω × upperHalfPlane → ℝ≥0∞) (hw : Measurable[m.prod inferInstance] w)
-    (f : Ω × Y → ℝ≥0∞) (hf : Measurable[m.prod mY] f) :
-    (∫⁻ ω, ∫⁻ y, f (ω,y) ∂weightedImageMass (fun z => J (ω,z))
-        (fun z => w (ω,z)) (M (V ω)) ∂P) =
-      ∫⁻ ω, ∫⁻ z, w (ω,z)*f (ω,J (ω,z)) ∂ν.bind M ∂P := by
-  let : MeasurableSpace Ω := mΩ
-  have htest : Measurable[m.prod inferInstance]
-      (fun p : Ω × upperHalfPlane => w p*f (p.1,J p)) :=
-    hw.mul (hf.comp (measurable_fst.prodMk hJ))
-  have he (ω : Ω) := weightedImageMass_lintegral (fun z => J (ω,z))
-    (hJ.comp (measurable_const.prodMk measurable_id)) (fun z => w (ω,z))
-    (hw.comp (measurable_const.prodMk measurable_id)) (M (V ω)) (fun y => f (ω,y))
-    (hf.comp (measurable_const.prodMk measurable_id))
-  simp_rw [he]
-  exact restart_random_mass_test P ν m hm V hV hlaw M hM hMf _ htest
-
-end SLEExactGauge
-
-end
-
-end OAI
+import OAI.Probability.SLE.Mass.RestartRandomMassTesting
+
+namespace OAI
+
+/-! Measurable weighted images of locally finite random half-plane measures.
+The weight and image map can be chosen from the stopped past. -/
+
+noncomputable section
+open Set Filter MeasureTheory Classical
+open scoped ENNReal
+
+namespace SLEExactGauge
+
+def weightedImageMass {X : Type*} [MeasurableSpace X]
+    (J : upperHalfPlane → X) (w : upperHalfPlane → ℝ≥0∞)
+    (μ : Measure upperHalfPlane) : Measure X :=
+  (μ.withDensity w).map J
+
+lemma weightedImageMass_apply {X : Type*} [MeasurableSpace X]
+    (J : upperHalfPlane → X) (hJ : Measurable J)
+    (w : upperHalfPlane → ℝ≥0∞) (μ : Measure upperHalfPlane)
+    (A : Set X) (hA : MeasurableSet A) :
+    weightedImageMass J w μ A = ∫⁻ z, (J ⁻¹' A).indicator w z ∂μ := by
+  rw [weightedImageMass,Measure.map_apply hJ hA,withDensity_apply _ (hJ hA),
+    lintegral_indicator (hJ hA)]
+
+theorem weightedImageMass_measurable
+    {Ω X : Type*} [MeasurableSpace Ω] [MeasurableSpace X]
+    (μ : Ω → Measure upperHalfPlane) (hμ : Measurable μ)
+    (hfin : ∀ ω, IsFiniteMeasureOnCompacts (μ ω))
+    (J : Ω × upperHalfPlane → X) (hJ : Measurable J)
+    (w : Ω × upperHalfPlane → ℝ≥0∞) (hw : Measurable w) :
+    Measurable (fun ω => weightedImageMass (fun z => J (ω,z))
+      (fun z => w (ω,z)) (μ ω)) := by
+  apply Measure.measurable_of_measurable_coe
+  intro A hA
+  have he (ω : Ω) := weightedImageMass_apply (fun z => J (ω,z))
+    (hJ.comp (measurable_const.prodMk measurable_id)) (fun z => w (ω,z)) (μ ω) A hA
+  simp_rw [he]
+  exact halfPlane_random_test_measurable μ hμ hfin
+    ((J ⁻¹' A).indicator w) (hw.indicator (hJ hA))
+
+lemma weightedImageMass_lintegral {X : Type*} [MeasurableSpace X]
+    (J : upperHalfPlane → X) (hJ : Measurable J)
+    (w : upperHalfPlane → ℝ≥0∞) (hw : Measurable w)
+    (μ : Measure upperHalfPlane) (f : X → ℝ≥0∞) (hf : Measurable f) :
+    (∫⁻ x, f x ∂weightedImageMass J w μ) = ∫⁻ z, w z*f (J z) ∂μ := by
+  rw [weightedImageMass,lintegral_map hf hJ]
+  exact lintegral_withDensity_eq_lintegral_mul μ hw
+    (show Measurable (fun z => f (J z)) from hf.comp hJ)
+
+theorem weightedImageMass_measurable_of_subsigma
+    {Ω X : Type*} [mΩ : MeasurableSpace Ω] [MeasurableSpace X]
+    (m : MeasurableSpace Ω) (hm : m ≤ mΩ)
+    (μ : Ω → Measure upperHalfPlane) (hμ : Measurable[mΩ] μ)
+    (hfin : ∀ ω, IsFiniteMeasureOnCompacts (μ ω))
+    (J : Ω × upperHalfPlane → X) (hJ : Measurable[m.prod inferInstance] J)
+    (w : Ω × upperHalfPlane → ℝ≥0∞) (hw : Measurable[m.prod inferInstance] w) :
+    Measurable[mΩ] (fun ω => weightedImageMass (fun z => J (ω,z))
+      (fun z => w (ω,z)) (μ ω)) := by
+  let : MeasurableSpace Ω := mΩ
+  have hle : m.prod (inferInstance : MeasurableSpace upperHalfPlane) ≤ mΩ.prod inferInstance :=
+    sup_le_sup (MeasurableSpace.comap_mono hm) le_rfl
+  exact weightedImageMass_measurable μ hμ hfin J (hJ.mono hle le_rfl) w (hw.mono hle le_rfl)
+
+theorem restart_weighted_mass_test
+    {Ω X Y : Type*} [mΩ : MeasurableSpace Ω] [mX : MeasurableSpace X]
+    [mY : MeasurableSpace Y]
+    (P : Measure Ω) [IsFiniteMeasure P] (ν : Measure X) [IsFiniteMeasure ν]
+    (m : MeasurableSpace Ω) (hm : m ≤ mΩ)
+    (V : Ω → X) (hV : Measurable[mΩ] V)
+    (hlaw : ∀ A : Set Ω, MeasurableSet[m] A →
+      @Measure.map Ω X mΩ mX V (P.restrict A) = P A • ν)
+    (M : X → Measure upperHalfPlane) (hM : Measurable M)
+    (hMf : ∀ x, IsFiniteMeasureOnCompacts (M x))
+    (J : Ω × upperHalfPlane → Y) (hJ : Measurable[m.prod inferInstance] J)
+    (w : Ω × upperHalfPlane → ℝ≥0∞) (hw : Measurable[m.prod inferInstance] w)
+    (f : Ω × Y → ℝ≥0∞) (hf : Measurable[m.prod mY] f) :
+    (∫⁻ ω, ∫⁻ y, f (ω,y) ∂weightedImageMass (fun z => J (ω,z))
+        (fun z => w (ω,z)) (M (V ω)) ∂P) =
+      ∫⁻ ω, ∫⁻ z, w (ω,z)*f (ω,J (ω,z)) ∂ν.bind M ∂P := by
+  let : MeasurableSpace Ω := mΩ
+  have htest : Measurable[m.prod inferInstance]
+      (fun p : Ω × upperHalfPlane => w p*f (p.1,J p)) :=
+    hw.mul (hf.comp (measurable_fst.prodMk hJ))
+  have he (ω : Ω) := weightedImageMass_lintegral (fun z => J (ω,z))
+    (hJ.comp (measurable_const.prodMk measurable_id)) (fun z => w (ω,z))
+    (hw.comp (measurable_const.prodMk measurable_id)) (M (V ω)) (fun y => f (ω,y))
+    (hf.comp (measurable_const.prodMk measurable_id))
+  simp_rw [he]
+  exact restart_random_mass_test P ν m hm V hV hlaw M hM hMf _ htest
+
+end SLEExactGauge
+
+end
+
+end OAI

lean/OAI/Probability/SLE/Mass/WeightedLevelMoments.lean

@@ -1,188 +1,188 @@
-import OAI.Probability.SLE.Mass.LevelRadonMoments
-import OAI.Probability.SLE.Gauge.WeightedMomentIntegration
-
-namespace OAI
-
-/-! The actual multipoint estimate with spatial weights retained. This
-retains the near-diagonal gain needed for nonatomicity. -/
-
-noncomputable section
-open Set Filter MeasureTheory ProbabilityTheory Classical
-open scoped NNReal ENNReal Topology CompactlySupported
-
-namespace SLEExactGauge.Multipoint
-
-def weightedLevelMass {Ω : Type*} (κ : ℝ) (B : ℝ≥0 → Ω → ℝ)
-    (γ : Ω → ℝ≥0 → ℂ) (G : Ω → ℝ≥0 → ℂ → ℂ)
-    (u : ℝ) (K : Set ℂ) (f : ℂ → ℝ≥0∞) (ω : Ω) : ℝ≥0∞ :=
-  ∫⁻ z in K, f z * ENNReal.ofReal (stoppedGreen κ (fun t => Real.sqrt κ * B t ω)
-    (γ ω) (G ω) z u)
-
-theorem weightedLevelMass_moment_identity
-    {Ω : Type*} [MeasurableSpace Ω] (P : Measure Ω) [SigmaFinite P]
-    {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 ω))
-    (K : Set ℂ) (f : ℂ → ℝ≥0∞) (hf : Measurable f) (m : ℕ) :
-    (∫⁻ ω, weightedLevelMass κ B γ G u K f ω ^ m ∂P) =
-      ∫⁻ z : Fin m → ℂ, (∏ i, f (z i)) *
-        (∫⁻ ω, ENNReal.ofReal (∏ i, stoppedGreen κ (fun t => Real.sqrt κ * B t ω)
-          (γ ω) (G ω) (z i) u) ∂P) ∂Measure.pi (fun _ : Fin m => volume.restrict K) := by
-  have hW := (actual_stoppedGreen_joint_measurable hm hBc κ u hu γ G F hw).ennreal_ofReal
-  unfold weightedLevelMass
-  rw [lintegral_weighted_mass_pow_eq P (volume.restrict K)
-    (fun ω z => ENNReal.ofReal (stoppedGreen κ
-      (fun t => Real.sqrt κ * B t ω) (γ ω) (G ω) z u)) hW f hf m]
-  apply lintegral_congr
-  intro z
-  apply congrArg (fun v : ℝ≥0∞ => (∏ i, f (z i)) * v)
-  apply lintegral_congr
-  intro ω
-  exact (ENNReal.ofReal_prod_of_nonneg (fun i _ => stoppedGreen_nonneg (hw ω) κ _ _)).symm
-
-theorem actual_product_le_cappedKernel
-    {Ω : 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)
-    {m : ℕ} (z : Fin m → ℂ) (hz : ∀ i, z i ∈ upperHalfPlane) (hzi : Function.Injective z)
-    (b : ℝ) (hb : 0 < b) (hbR : ∀ i, b ≤ 2*(z i).im) (u : ℝ) :
-    (∫⁻ ω, ENNReal.ofReal (∏ i, stoppedGreen κ
-      (fun t => Real.sqrt κ * B t ω) (γ ω) (G ω) (z i) u) ∂P) ≤
-      ENNReal.ofReal (multipointConstant κ m) * cappedDistanceKernel (codimension κ) b z := by
-  have hc := stoppedGreen_common_level_product_bound hB hm hBm hBc hB0 hκ hκ8 γ G F hw
-    hgrowth z hz hzi (cappedDistance b z) (fun i => cap_pos hb hzi i)
-    (fun i => (cap_le_fixed b z i).trans (hbR i))
-    (fun i j hij => cap_le_dist b z i j hij) u
-  apply hc.trans_eq
-  rw [ENNReal.ofReal_mul (by positivity)]
-  congr 1
-  · simp only [multipointConstant,Fintype.card_fin]
-  · exact ENNReal.ofReal_prod_of_nonneg
-      (fun i _ => Real.rpow_nonneg (cap_pos hb hzi i).le _)
-
-theorem weightedLevelMass_moment_le_cappedKernel
-    {Ω : 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)
-    (K : Set ℂ) (hK : MeasurableSet K) (hKH : K ⊆ upperHalfPlane)
-    (f : ℂ → ℝ≥0∞) (hf : Measurable f)
-    (b : ℝ) (hb : 0 < b) (hbR : ∀ z ∈ K, b ≤ 2*z.im) (m : ℕ)
-    (u : ℝ) (hu : 0 ≤ u) :
-    (∫⁻ ω, weightedLevelMass κ B γ G u K f ω ^ m ∂P) ≤
-      ENNReal.ofReal (multipointConstant κ m) *
-        ∫⁻ z : Fin m → ℂ, (∏ i, f (z i)) * cappedDistanceKernel (codimension κ) b z
-          ∂Measure.pi (fun _ : Fin m => volume.restrict K) := by
-  let : IsProbabilityMeasure P := hB.isGaussianProcess.isProbabilityMeasure
-  rw [weightedLevelMass_moment_identity P hm hBc κ u hu γ G F hw K f hf m]
-  have hk : Measurable (fun z : Fin m → ℂ =>
-      (∏ i, f (z i)) * cappedDistanceKernel (codimension κ) b z) :=
-    (Finset.measurable_prod _ (fun i _ => hf.comp (measurable_pi_apply i))).mul
-      (measurable_cappedDistanceKernel _ _)
-  rw [← lintegral_const_mul _ hk]
-  apply lintegral_mono_ae
-  filter_upwards [ae_tuple_mem (ι := Fin m) K hK,ae_tuple_injective (ι := Fin m) K] with z hz hzi
-  have he := actual_product_le_cappedKernel hB hm hBm hBc hB0 hκ hκ8 γ G F hw hgrowth
-    z (fun i => hKH (hz i)) hzi b hb (fun i => hbR (z i) (hz i)) u
-  exact (mul_le_mul' le_rfl he).trans_eq (by ac_rfl)
-
-lemma levelApproximationTest_le_weightedLevelMass
-    {Ω : 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 ω))
-    (K : Set ℂ) (hK : MeasurableSet K) (f : ℂ → ℝ≥0∞) (hf : Measurable f)
-    (hz : ∀ z ∉ K, f z = 0) (t : ℝ≥0∞) (ω : Ω) :
-    levelApproximationTest κ B γ G u t f ω ≤ weightedLevelMass κ B γ G u K f ω := by
-  have hd := levelApproximationDensity_joint_measurable hm hBc κ u hu γ G F hw t
-  change (∫⁻ z, f z ∂volume.withDensity _) ≤ _
-  rw [lintegral_withDensity_eq_lintegral_mul volume hd.of_uncurry_left hf]
-  have he : (fun z => levelApproximationDensity κ B γ G u t ω z * f z) =
-      K.indicator (fun z => levelApproximationDensity κ B γ G u t ω z * f z) := by
-    funext z
-    by_cases hzK : z ∈ K
-    · simp only [indicator_of_mem hzK]
-    · simp only [indicator_of_notMem hzK,hz z hzK,mul_zero]
-  change (∫⁻ z, levelApproximationDensity κ B γ G u t ω z * f z) ≤ _
-  rw [he,lintegral_indicator hK]
-  apply lintegral_mono
-  intro z
-  unfold levelApproximationDensity
-  dsimp only
-  split_ifs
-  · exact (mul_comm _ _).le
-  · simp only [zero_mul,zero_le]
-
-theorem levelApproximationTest_moment_le_cappedKernel
-    {Ω : 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)
-    (K : Set ℂ) (hK : MeasurableSet K) (hKH : K ⊆ upperHalfPlane)
-    (f : ℂ → ℝ≥0∞) (hf : Measurable f) (hz : ∀ z ∉ K, f z = 0)
-    (b : ℝ) (hb : 0 < b) (hbR : ∀ z ∈ K, b ≤ 2*z.im) (m : ℕ)
-    (u : ℝ) (hu : 0 ≤ u) (t : ℝ≥0∞) :
-    (∫⁻ ω, levelApproximationTest κ B γ G u t f ω ^ m ∂P) ≤
-      ENNReal.ofReal (multipointConstant κ m) *
-        ∫⁻ z : Fin m → ℂ, (∏ i, f (z i)) * cappedDistanceKernel (codimension κ) b z
-          ∂Measure.pi (fun _ : Fin m => volume.restrict K) := by
-  apply (lintegral_mono (fun ω => pow_le_pow_left'
-    (levelApproximationTest_le_weightedLevelMass hm hBc κ u hu γ G F hw K hK f hf hz t ω) m)).trans
-  exact weightedLevelMass_moment_le_cappedKernel hB hm hBm hBc hB0 hκ hκ8 γ G F hw hgrowth
-    K hK hKH f hf b hb hbR m u hu
-
-theorem level_radon_limit_test_moment_le
-    {Ω : Type*} [MeasurableSpace Ω] {P : Measure Ω} {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) (hw₁ : ∀ n, ∑ i ∈ s n, w n i = 1)
-    (t : ℝ≥0∞) (ν : Ω → Measure upperHalfPlane)
-    (hlim : ∀ᵐ ω ∂P, ∀ f : C_c(upperHalfPlane,ℝ),
-      Tendsto (fun n => ∫ z, f z ∂convexLevelMeasure κ B γ G u s w n t ω)
-        atTop (𝓝 (∫ z, f z ∂ν ω)))
-    (f : C_c(upperHalfPlane,ℝ)) (hf : ∀ z, 0 ≤ f z) (m : ℕ) (M : ℝ≥0∞)
-    (hbound : ∀ n, (∫⁻ ω, ENNReal.ofReal
-      (∫ z, f z ∂halfPlaneLevelMeasure κ B γ G (u n) t ω)^m ∂P) ≤ M) :
-    (∫⁻ ω, ENNReal.ofReal (∫ z, f z ∂ν ω)^m ∂P) ≤ M := by
-  apply lintegral_le_of_ae_tendsto_bound P
-    (fun n ω => ENNReal.ofReal (∫ z, f z ∂convexLevelMeasure κ B γ G u s w n t ω)^m)
-    (fun ω => ENNReal.ofReal (∫ z, f z ∂ν ω)^m)
-    (fun n => ((convexLevelMeasure_test_measurable hm hBc hκ hκ8 γ G F hw u hu s w hw₀ n t f).ennreal_ofReal.pow_const m).aemeasurable)
-  · filter_upwards [hlim] with ω hω
-    exact (ENNReal.continuous_pow m).continuousAt.tendsto.comp
-      ((ENNReal.continuous_ofReal.tendsto _).comp (hω f))
-  · intro n
-    have hb := lintegral_pow_convex_sum_le P (s n) (w n)
-      (fun i ω => ∫ z, f z ∂halfPlaneLevelMeasure κ B γ G (u (n+i)) t ω)
-      (hw₀ n) (hw₁ n) (fun i _ ω => integral_nonneg hf)
-      (fun i _ => by
-        simp_rw [integral_halfPlaneLevelMeasure]
-        exact levelApproximationRealTest_measurable hm hBc κ (u (n+i)) (hu _) γ G F hw t
-          _ (extendHalfPlaneTest_measurable f f.continuous.measurable))
-      m M (fun i _ => hbound (n+i))
-    simpa only [integral_convexLevelMeasure hκ hκ8 γ G F _ (hBc _) (hw _) u s w n t (hw₀ n) f,
-      integral_halfPlaneLevelMeasure] using hb
-
-end SLEExactGauge.Multipoint
-
-end
-
-end OAI
+import OAI.Probability.SLE.Mass.LevelRadonMoments
+import OAI.Probability.SLE.Gauge.WeightedMomentIntegration
+
+namespace OAI
+
+/-! The actual multipoint estimate with spatial weights retained. This
+retains the near-diagonal gain needed for nonatomicity. -/
+
+noncomputable section
+open Set Filter MeasureTheory ProbabilityTheory Classical
+open scoped NNReal ENNReal Topology CompactlySupported
+
+namespace SLEExactGauge.Multipoint
+
+def weightedLevelMass {Ω : Type*} (κ : ℝ) (B : ℝ≥0 → Ω → ℝ)
+    (γ : Ω → ℝ≥0 → ℂ) (G : Ω → ℝ≥0 → ℂ → ℂ)
+    (u : ℝ) (K : Set ℂ) (f : ℂ → ℝ≥0∞) (ω : Ω) : ℝ≥0∞ :=
+  ∫⁻ z in K, f z * ENNReal.ofReal (stoppedGreen κ (fun t => Real.sqrt κ * B t ω)
+    (γ ω) (G ω) z u)
+
+theorem weightedLevelMass_moment_identity
+    {Ω : Type*} [MeasurableSpace Ω] (P : Measure Ω) [SigmaFinite P]
+    {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 ω))
+    (K : Set ℂ) (f : ℂ → ℝ≥0∞) (hf : Measurable f) (m : ℕ) :
+    (∫⁻ ω, weightedLevelMass κ B γ G u K f ω ^ m ∂P) =
+      ∫⁻ z : Fin m → ℂ, (∏ i, f (z i)) *
+        (∫⁻ ω, ENNReal.ofReal (∏ i, stoppedGreen κ (fun t => Real.sqrt κ * B t ω)
+          (γ ω) (G ω) (z i) u) ∂P) ∂Measure.pi (fun _ : Fin m => volume.restrict K) := by
+  have hW := (actual_stoppedGreen_joint_measurable hm hBc κ u hu γ G F hw).ennreal_ofReal
+  unfold weightedLevelMass
+  rw [lintegral_weighted_mass_pow_eq P (volume.restrict K)
+    (fun ω z => ENNReal.ofReal (stoppedGreen κ
+      (fun t => Real.sqrt κ * B t ω) (γ ω) (G ω) z u)) hW f hf m]
+  apply lintegral_congr
+  intro z
+  apply congrArg (fun v : ℝ≥0∞ => (∏ i, f (z i)) * v)
+  apply lintegral_congr
+  intro ω
+  exact (ENNReal.ofReal_prod_of_nonneg (fun i _ => stoppedGreen_nonneg (hw ω) κ _ _)).symm
+
+theorem actual_product_le_cappedKernel
+    {Ω : 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)
+    {m : ℕ} (z : Fin m → ℂ) (hz : ∀ i, z i ∈ upperHalfPlane) (hzi : Function.Injective z)
+    (b : ℝ) (hb : 0 < b) (hbR : ∀ i, b ≤ 2*(z i).im) (u : ℝ) :
+    (∫⁻ ω, ENNReal.ofReal (∏ i, stoppedGreen κ
+      (fun t => Real.sqrt κ * B t ω) (γ ω) (G ω) (z i) u) ∂P) ≤
+      ENNReal.ofReal (multipointConstant κ m) * cappedDistanceKernel (codimension κ) b z := by
+  have hc := stoppedGreen_common_level_product_bound hB hm hBm hBc hB0 hκ hκ8 γ G F hw
+    hgrowth z hz hzi (cappedDistance b z) (fun i => cap_pos hb hzi i)
+    (fun i => (cap_le_fixed b z i).trans (hbR i))
+    (fun i j hij => cap_le_dist b z i j hij) u
+  apply hc.trans_eq
+  rw [ENNReal.ofReal_mul (by positivity)]
+  congr 1
+  · simp only [multipointConstant,Fintype.card_fin]
+  · exact ENNReal.ofReal_prod_of_nonneg
+      (fun i _ => Real.rpow_nonneg (cap_pos hb hzi i).le _)
+
+theorem weightedLevelMass_moment_le_cappedKernel
+    {Ω : 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)
+    (K : Set ℂ) (hK : MeasurableSet K) (hKH : K ⊆ upperHalfPlane)
+    (f : ℂ → ℝ≥0∞) (hf : Measurable f)
+    (b : ℝ) (hb : 0 < b) (hbR : ∀ z ∈ K, b ≤ 2*z.im) (m : ℕ)
+    (u : ℝ) (hu : 0 ≤ u) :
+    (∫⁻ ω, weightedLevelMass κ B γ G u K f ω ^ m ∂P) ≤
+      ENNReal.ofReal (multipointConstant κ m) *
+        ∫⁻ z : Fin m → ℂ, (∏ i, f (z i)) * cappedDistanceKernel (codimension κ) b z
+          ∂Measure.pi (fun _ : Fin m => volume.restrict K) := by
+  let : IsProbabilityMeasure P := hB.isGaussianProcess.isProbabilityMeasure
+  rw [weightedLevelMass_moment_identity P hm hBc κ u hu γ G F hw K f hf m]
+  have hk : Measurable (fun z : Fin m → ℂ =>
+      (∏ i, f (z i)) * cappedDistanceKernel (codimension κ) b z) :=
+    (Finset.measurable_prod _ (fun i _ => hf.comp (measurable_pi_apply i))).mul
+      (measurable_cappedDistanceKernel _ _)
+  rw [← lintegral_const_mul _ hk]
+  apply lintegral_mono_ae
+  filter_upwards [ae_tuple_mem (ι := Fin m) K hK,ae_tuple_injective (ι := Fin m) K] with z hz hzi
+  have he := actual_product_le_cappedKernel hB hm hBm hBc hB0 hκ hκ8 γ G F hw hgrowth
+    z (fun i => hKH (hz i)) hzi b hb (fun i => hbR (z i) (hz i)) u
+  exact (mul_le_mul' le_rfl he).trans_eq (by ac_rfl)
+
+lemma levelApproximationTest_le_weightedLevelMass
+    {Ω : 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 ω))
+    (K : Set ℂ) (hK : MeasurableSet K) (f : ℂ → ℝ≥0∞) (hf : Measurable f)
+    (hz : ∀ z ∉ K, f z = 0) (t : ℝ≥0∞) (ω : Ω) :
+    levelApproximationTest κ B γ G u t f ω ≤ weightedLevelMass κ B γ G u K f ω := by
+  have hd := levelApproximationDensity_joint_measurable hm hBc κ u hu γ G F hw t
+  change (∫⁻ z, f z ∂volume.withDensity _) ≤ _
+  rw [lintegral_withDensity_eq_lintegral_mul volume hd.of_uncurry_left hf]
+  have he : (fun z => levelApproximationDensity κ B γ G u t ω z * f z) =
+      K.indicator (fun z => levelApproximationDensity κ B γ G u t ω z * f z) := by
+    funext z
+    by_cases hzK : z ∈ K
+    · simp only [indicator_of_mem hzK]
+    · simp only [indicator_of_notMem hzK,hz z hzK,mul_zero]
+  change (∫⁻ z, levelApproximationDensity κ B γ G u t ω z * f z) ≤ _
+  rw [he,lintegral_indicator hK]
+  apply lintegral_mono
+  intro z
+  unfold levelApproximationDensity
+  dsimp only
+  split_ifs
+  · exact (mul_comm _ _).le
+  · simp only [zero_mul,zero_le]
+
+theorem levelApproximationTest_moment_le_cappedKernel
+    {Ω : 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)
+    (K : Set ℂ) (hK : MeasurableSet K) (hKH : K ⊆ upperHalfPlane)
+    (f : ℂ → ℝ≥0∞) (hf : Measurable f) (hz : ∀ z ∉ K, f z = 0)
+    (b : ℝ) (hb : 0 < b) (hbR : ∀ z ∈ K, b ≤ 2*z.im) (m : ℕ)
+    (u : ℝ) (hu : 0 ≤ u) (t : ℝ≥0∞) :
+    (∫⁻ ω, levelApproximationTest κ B γ G u t f ω ^ m ∂P) ≤
+      ENNReal.ofReal (multipointConstant κ m) *
+        ∫⁻ z : Fin m → ℂ, (∏ i, f (z i)) * cappedDistanceKernel (codimension κ) b z
+          ∂Measure.pi (fun _ : Fin m => volume.restrict K) := by
+  apply (lintegral_mono (fun ω => pow_le_pow_left'
+    (levelApproximationTest_le_weightedLevelMass hm hBc κ u hu γ G F hw K hK f hf hz t ω) m)).trans
+  exact weightedLevelMass_moment_le_cappedKernel hB hm hBm hBc hB0 hκ hκ8 γ G F hw hgrowth
+    K hK hKH f hf b hb hbR m u hu
+
+theorem level_radon_limit_test_moment_le
+    {Ω : Type*} [MeasurableSpace Ω] {P : Measure Ω} {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) (hw₁ : ∀ n, ∑ i ∈ s n, w n i = 1)
+    (t : ℝ≥0∞) (ν : Ω → Measure upperHalfPlane)
+    (hlim : ∀ᵐ ω ∂P, ∀ f : C_c(upperHalfPlane,ℝ),
+      Tendsto (fun n => ∫ z, f z ∂convexLevelMeasure κ B γ G u s w n t ω)
+        atTop (𝓝 (∫ z, f z ∂ν ω)))
+    (f : C_c(upperHalfPlane,ℝ)) (hf : ∀ z, 0 ≤ f z) (m : ℕ) (M : ℝ≥0∞)
+    (hbound : ∀ n, (∫⁻ ω, ENNReal.ofReal
+      (∫ z, f z ∂halfPlaneLevelMeasure κ B γ G (u n) t ω)^m ∂P) ≤ M) :
+    (∫⁻ ω, ENNReal.ofReal (∫ z, f z ∂ν ω)^m ∂P) ≤ M := by
+  apply lintegral_le_of_ae_tendsto_bound P
+    (fun n ω => ENNReal.ofReal (∫ z, f z ∂convexLevelMeasure κ B γ G u s w n t ω)^m)
+    (fun ω => ENNReal.ofReal (∫ z, f z ∂ν ω)^m)
+    (fun n => ((convexLevelMeasure_test_measurable hm hBc hκ hκ8 γ G F hw u hu s w hw₀ n t f).ennreal_ofReal.pow_const m).aemeasurable)
+  · filter_upwards [hlim] with ω hω
+    exact (ENNReal.continuous_pow m).continuousAt.tendsto.comp
+      ((ENNReal.continuous_ofReal.tendsto _).comp (hω f))
+  · intro n
+    have hb := lintegral_pow_convex_sum_le P (s n) (w n)
+      (fun i ω => ∫ z, f z ∂halfPlaneLevelMeasure κ B γ G (u (n+i)) t ω)
+      (hw₀ n) (hw₁ n) (fun i _ ω => integral_nonneg hf)
+      (fun i _ => by
+        simp_rw [integral_halfPlaneLevelMeasure]
+        exact levelApproximationRealTest_measurable hm hBc κ (u (n+i)) (hu _) γ G F hw t
+          _ (extendHalfPlaneTest_measurable f f.continuous.measurable))
+      m M (fun i _ => hbound (n+i))
+    simpa only [integral_convexLevelMeasure hκ hκ8 γ G F _ (hBc _) (hw _) u s w n t (hw₀ n) f,
+      integral_halfPlaneLevelMeasure] using hb
+
+end SLEExactGauge.Multipoint
+
+end
+
+end OAI

lean/OAI/Probability/SLE/MeasureSupport.lean

@@ -1,698 +1,698 @@
-import Mathlib
-import OAI.Probability.SLE.InverseMoments
-import OAI.Probability.SLE.SausagePointBound
-import OAI.Probability.SLE.SpatialMeans
-
-namespace OAI
-
-/-! Measure Support for chordal SLE. -/
-
-section
-section
-open Set Filter MeasureTheory ProbabilityTheory Metric Classical
-open scoped Topology NNReal ENNReal
-namespace SLEExactGauge
-noncomputable def spatialGreenMass (κ : ℝ) (U : ℝ≥0 → ℝ) (γ : ℝ≥0 → ℂ)
-    (G : ℝ≥0 → ℂ → ℂ) (r : ℝ) (A : Set ℂ) : ℝ≥0∞ :=
-  ∫⁻ z in A, ENNReal.ofReal (spatialGreenWeight κ U γ G z r)
-
-namespace RegularSLEPresentation
-variable {Ω : Type*} [MeasurableSpace Ω] {P : Measure Ω}
-    {κ : ℝ} {γ : Ω → ℝ≥0 → ℂ} (a : RegularSLEPresentation P κ γ)
-
-lemma spatialGreenMass_measurable (r : ℝ) (A : Set ℂ) :
-    Measurable (fun ω : a.samples => spatialGreenMass κ
-      (fun t => Real.sqrt κ * a.B t ω) (γ ω) (a.G ω) r A) :=
-  (a.spatialGreenWeight_measurable r).ennreal_ofReal.lintegral_prod_left'
-
- 
-
-lemma spatialGreenMass_expectation [IsProbabilityMeasure P]
-    (hκ : 0 < κ) (hκ8 : κ < 8) (r : ℝ) (hr : 0 < r)
-    (A : Set ℂ) (hA : MeasurableSet A) (hheight : ∀ z ∈ A, r ≤ z.im) :
-    (∫⁻ ω : a.samples, spatialGreenMass κ (fun t => Real.sqrt κ * a.B t ω)
-      (γ ω) (a.G ω) r A ∂(P.comap Subtype.val)) =
-      ∫⁻ z in A, ENNReal.ofReal (initialGreen κ z) := by
-  let μ : Measure a.samples := P.comap Subtype.val
-  let : IsProbabilityMeasure μ := a.probability
-  simp only [spatialGreenMass]
-  rw [← lintegral_lintegral_swap (a.spatialGreenWeight_measurable r).ennreal_ofReal.aemeasurable]
-  apply setLIntegral_congr_fun hA
-  intro z hz
-  obtain ⟨hi, he⟩ := a.spatialGreen_expectation hκ hκ8 z r hr (hheight z hz)
-  change (∫⁻ ω : a.samples, ENNReal.ofReal (spatialGreenWeight κ
-    (fun t => Real.sqrt κ * a.B t ω) (γ ω) (a.G ω) z r) ∂μ) = ENNReal.ofReal (initialGreen κ z)
-  rw [← he]
-  exact (ofReal_integral_eq_lintegral_ofReal hi (Eventually.of_forall fun ω => by
-    dsimp only [Pi.zero_apply, spatialGreenWeight]
-    split_ifs
-    · exact le_rfl
-    · exact greenDensity_nonneg (a.witness ω) κ _ z)).symm
-
- 
-
-lemma spatialGreenMass_expectation_le [IsProbabilityMeasure P]
-    (hκ : 0 < κ) (hκ8 : κ < 8) (r : ℝ) (hr : 0 < r)
-    (A : Set ℂ) (hA : MeasurableSet A) (hheight : ∀ z ∈ A, r ≤ z.im) :
-    (∫⁻ ω : a.samples, spatialGreenMass κ (fun t => Real.sqrt κ * a.B t ω)
-      (γ ω) (a.G ω) r A ∂(P.comap Subtype.val)) ≤
-      ENNReal.ofReal ((2 : ℝ) ^ (-codimension κ) * r ^ (-codimension κ)) * volume A := by
-  rw [a.spatialGreenMass_expectation hκ hκ8 r hr A hA hheight]
-  calc
-    _ ≤ ∫⁻ _z in A, ENNReal.ofReal ((2 : ℝ) ^ (-codimension κ) * r ^ (-codimension κ)) := by
-      apply setLIntegral_mono' hA
-      intro z hz
-      apply ENNReal.ofReal_le_ofReal
-      calc
-        _ ≤ (2 : ℝ) ^ (-codimension κ) * z.im ^ (-codimension κ) :=
-          initialGreen_le_height κ hκ hκ8 z (hr.trans_le (hheight z hz))
-        _ ≤ _ := mul_le_mul_of_nonneg_left
-          (Real.rpow_le_rpow_of_nonpos hr (hheight z hz) (neg_nonpos.mpr (codimension_pos κ hκ8).le))
-          (Real.rpow_nonneg (by norm_num) _)
-    _ = _ := by rw [lintegral_const, Measure.restrict_apply_univ]
-
-end RegularSLEPresentation
-end SLEExactGauge
-end
-
- 
-section
-
-open Set Filter MeasureTheory ProbabilityTheory Classical
-open scoped Topology NNReal ENNReal
-namespace SLEExactGauge
-
- 
-
-lemma finite_density_crossing_bound
-    {Ω : Type*} [mΩ : MeasurableSpace Ω] (P Q : Measure Ω)
-    (F : Filtration ℕ mΩ) (B : ℕ → Set Ω)
-    (hBm : ∀ n, MeasurableSet[F n] (B n)) (c : ℝ≥0∞)
-    (hQ : ∀ n A, MeasurableSet[F n] A → A ⊆ B n → Q A ≤ c * P A)
-    (n : ℕ) : Q (⋃ i ∈ Finset.range n, B i) ≤ c * P (⋃ i ∈ Finset.range n, B i) := by
-  classical
-  let E (n : ℕ) : Set Ω := ⋃ i ∈ Finset.range n, B i
-  have hEm (n : ℕ) : MeasurableSet[F n] (E n) := by
-    apply MeasurableSet.iUnion
-    intro i
-    apply MeasurableSet.iUnion
-    intro hi
-    exact F.mono (Nat.le_of_lt (Finset.mem_range.mp hi)) _ (hBm i)
-  have hrec (n : ℕ) : E (n + 1) = E n ∪ (B n \ E n) := by
-    calc
-      E (n + 1) = B n ∪ E n := by
-        ext ω
-        simp only [E, Finset.range_add_one, Finset.mem_insert, mem_iUnion, mem_union]
-        aesop
-      _ = E n ∪ (B n \ E n) := by
-        ext ω
-        by_cases h : ω ∈ E n <;> simp [h]
-  change Q (E n) ≤ c * P (E n)
-  induction n with
-  | zero => simp [E]
-  | succ n ih =>
-      have hD := (hBm n).diff (hEm n)
-      have hd : Disjoint (E n) (B n \ E n) := disjoint_sdiff_right
-      rw [hrec n, measure_union hd (F.le n _ hD), measure_union hd (F.le n _ hD), mul_add]
-      exact add_le_add ih (hQ n _ hD sdiff_subset)
-
-lemma finite_density_crossing_bound_of_subset
-    {Ω : Type*} [mΩ : MeasurableSpace Ω] (P Q : Measure Ω)
-    (F : Filtration ℕ mΩ) (B : ℕ → Set Ω)
-    (hBm : ∀ n, MeasurableSet[F n] (B n)) (c : ℝ≥0∞)
-    (hQ : ∀ n A, MeasurableSet[F n] A → A ⊆ B n → Q A ≤ c * P A)
-    (A : Set Ω) (hA : ∀ n, B n ⊆ A) (n : ℕ) :
-    Q (⋃ i ∈ Finset.range n, B i) ≤ c * P A := by
-  refine (finite_density_crossing_bound P Q F B hBm c hQ n).trans ?_
-  exact mul_le_mul (show c ≤ c from le_rfl)
-    (show P (⋃ i ∈ Finset.range n, B i) ≤ P A from
-      measure_mono (iUnion₂_subset fun i _ => hA i)) bot_le bot_le
-
-end SLEExactGauge
-end
-
- 
-section
-
-open Set Filter MeasureTheory ProbabilityTheory Classical
-open scoped Topology NNReal ENNReal
-namespace SLEExactGauge
-variable {Ω : Type*} [mΩ : MeasurableSpace Ω]
-  {B : ℝ≥0 → Ω → ℝ} {hm : ∀ t, Measurable (B t)}
-  {κ : ℝ} {z : ℂ} {u : ℝ} {ε : ℕ → ℝ}
-
-lemma limitRadiusKernel_pos_iff
-    (a : ∀ n, AngularLocalization B hm κ z u (ε n)) (hu : 0 ≤ u)
-    (p α : ℝ) (ω : Ω) :
-    0 < limitRadiusKernel a p α u ω ↔ localizedRadiusStop a ω < ⊤ := by
-  have hx : (∃ n, max u 0 ≤ (a n).clock.S ((a n).τ ω) ω) ↔ ∃ n, ω ∈ (a n).hit := by
-    simp only [max_eq_left hu]
-    constructor
-    · rintro ⟨n, hn⟩
-      exact ⟨n, le_antisymm ((a n).clock_upper ω) hn⟩
-    · rintro ⟨n, hn⟩
-      exact ⟨n, le_of_eq hn.symm⟩
-  by_cases hh : ∃ n, ω ∈ (a n).hit
-  · have he := hx.mpr hh
-    obtain ⟨n, hn⟩ := hh
-    rw [localizedRadiusStop_eq_hit a ω n hn, limitRadiusKernel, dite_eq_left he,
-      AngularLocalization.radiusKernel, ite_eq_left (Nat.find_spec he)]
-    exact iff_of_true (Real.exp_pos _) (WithTop.coe_lt_top _)
-  · rw [localizedRadiusStop_eq_top a ω (not_exists.mp hh), limitRadiusKernel,
-      dite_eq_right (fun h => hh (hx.mp h))]
-    simp
-
-lemma finiteCenteredLaw_eq_radiusKernel
-    {P : Measure Ω} (a : ∀ n, AngularLocalization B hm κ z u (ε n))
-    (hε : Antitone ε) (hεlim : Tendsto ε atTop (𝓝 0))
-    (hBc : ∀ ω, Continuous (fun t => B t ω)) (hz : z ∈ upperHalfPlane) (hu : 0 ≤ u)
-    (γ : Ω → ℝ≥0 → ℂ) (G F : Ω → ℝ≥0 → ℂ → ℂ)
-    (hw : ∀ᵐ ω ∂P, IsCapacityTwoWitness
-      (fun t => Real.sqrt κ * B t ω) (γ ω) (G ω) (F ω)) :
-    finiteCenteredLaw P κ B γ G z u = P.withDensity
-      (fun ω => ENNReal.ofReal (limitRadiusKernel a (codimension κ) (greenExponent κ) u ω /
-        initialGreen κ z)) := by
-  apply withDensity_congr_ae
-  filter_upwards [hw] with ω hω
-  rw [limitRadiusKernel_eq_stoppedGreen a hε hεlim hBc hz hu ω (γ ω) (G ω) (F ω) hω]
-
-lemma radiusKernel_density_bound
-    {P : Measure Ω} (a : ∀ n, AngularLocalization B hm κ z u (ε n))
-    (hε : Antitone ε) (hεlim : Tendsto ε atTop (𝓝 0))
-    (hBc : ∀ ω, Continuous (fun t => B t ω)) (hz : z ∈ upperHalfPlane) (hu : 0 ≤ u)
-    (γ : Ω → ℝ≥0 → ℂ) (G F : Ω → ℝ≥0 → ℂ → ℂ)
-    (hw : ∀ᵐ ω ∂P, IsCapacityTwoWitness
-      (fun t => Real.sqrt κ * B t ω) (γ ω) (G ω) (F ω))
-    (δ : ℝ) (A : Set Ω) (hA : MeasurableSet A)
-    (hδ : ∀ ω ∈ A, limitRadiusKernel a (codimension κ) (greenExponent κ) u ω ≤ δ) :
-    finiteCenteredLaw P κ B γ G z u A ≤ ENNReal.ofReal (δ / initialGreen κ z) * P A := by
-  rw [finiteCenteredLaw_eq_radiusKernel a hε hεlim hBc hz hu γ G F hw, withDensity_apply _ hA]
-  calc
-    _ ≤ ∫⁻ ω in A, ENNReal.ofReal (δ / initialGreen κ z) ∂P := by
-      apply lintegral_mono_ae
-      filter_upwards [ae_restrict_mem hA] with ω hω
-      exact ENNReal.ofReal_le_ofReal (div_le_div_of_nonneg_right (hδ ω hω) (initialGreen_pos κ z hz).le)
-    _ = _ := by simp
-
-lemma finiteCenteredLaw_consistent_at_radius
-    {P : Measure Ω} [IsProbabilityMeasure P]
-    (hB : IsBrownianReal B P)
-    (hBm : Measurable (fun q : ℝ≥0 × Ω => B q.1 q.2))
-    (hBc : ∀ ω, Continuous (fun t => B t ω)) (hB0 : ∀ ω, B 0 ω = 0)
-    (hκ : 0 < κ) (hκ8 : κ < 8)
-    (γ : Ω → ℝ≥0 → ℂ) (G F : Ω → ℝ≥0 → ℂ → ℂ)
-    (hw : ∀ᵐ ω ∂P, IsCapacityTwoWitness
-      (fun t => Real.sqrt κ * B t ω) (γ ω) (G ω) (F ω)) (hz : z ∈ upperHalfPlane)
-    {v : ℝ} (a : ∀ n, AngularLocalization B hm κ z u (ε n))
-    (b : ∀ n, AngularLocalization B hm κ z v (ε n))
-    (hε : Antitone ε) (hεlim : Tendsto ε atTop (𝓝 0)) (hu : 0 ≤ u) (huv : u ≤ v)
-    (A : Set Ω) (hA : MeasurableSet[(localizedRadiusStop_stopping a).measurableSpace] A) :
-    finiteCenteredLaw P κ B γ G z v A = finiteCenteredLaw P κ B γ G z u A := by
-  have hAm := (localizedRadiusStop_stopping a).measurableSpace_le _ hA
-  rw [finiteCenteredLaw_apply hB κ hκ hκ8 γ G F hw z hz v (hu.trans huv) A hAm,
-    finiteCenteredLaw_apply hB κ hκ hκ8 γ G F hw z hz u hu A hAm,
-    finite_stopped_green_consistent_regular hB hBm hBc hB0 hκ hκ8 γ G F hw hz
-      a b hεlim hε hu huv A hA]
-
-end SLEExactGauge
-end
-
- 
-section
-
-open Set Filter MeasureTheory ProbabilityTheory Classical
-open scoped Topology NNReal ENNReal
-namespace SLEExactGauge
-
-lemma finite_radius_density_crossing
-    {Ω : Type*} [mΩ : MeasurableSpace Ω] {P : Measure Ω} [IsProbabilityMeasure P]
-    {B : ℝ≥0 → Ω → ℝ} {hm : ∀ t, Measurable (B t)}
-    (hB : IsBrownianReal B P)
-    (hBm : Measurable (fun q : ℝ≥0 × Ω => B q.1 q.2))
-    (hBc : ∀ ω, Continuous (fun t => B t ω)) (hB0 : ∀ ω, B 0 ω = 0)
-    {κ : ℝ} (hκ : 0 < κ) (hκ8 : κ < 8)
-    (γ : Ω → ℝ≥0 → ℂ) (G F : Ω → ℝ≥0 → ℂ → ℂ)
-    (hw : ∀ᵐ ω ∂P, IsCapacityTwoWitness
-      (fun t => Real.sqrt κ * B t ω) (γ ω) (G ω) (F ω))
-    {z : ℂ} (hz : z ∈ upperHalfPlane) {ε : ℕ → ℝ}
-    (a : ∀ u : ℝ≥0, ∀ n, AngularLocalization B hm κ z u (ε n))
-    (hε : Antitone ε) (hεlim : Tendsto ε atTop (𝓝 0))
-    (v U : ℝ≥0) (s : ℕ → ℝ≥0) (hs : Monotone s)
-    (hvs : ∀ n, v ≤ s n) (hsU : ∀ n, s n ≤ U) (δ : ℝ) (N : ℕ) :
-    finiteCenteredLaw P κ B γ G z U
-      (⋃ i ∈ Finset.range N, {ω | 0 < limitRadiusKernel (a (s i)) (codimension κ) (greenExponent κ) (s i) ω ∧
-        limitRadiusKernel (a (s i)) (codimension κ) (greenExponent κ) (s i) ω ≤ δ}) ≤
-      ENNReal.ofReal (δ / initialGreen κ z) * P {ω | localizedRadiusStop (a v) ω < ⊤} := by
-  let K (n : ℕ) := limitRadiusKernel (a (s n)) (codimension κ) (greenExponent κ) (s n)
-  let E (n : ℕ) : Set Ω := {ω | 0 < K n ω ∧ K n ω ≤ δ}
-  let H : Filtration ℕ mΩ :=
-    { seq := fun n => radiusFiltration a (s n)
-      mono' := fun n m hnm => (radiusFiltration a).mono (hs hnm)
-      le' := fun n => (radiusFiltration a).le (s n) }
-  have hKm (n : ℕ) : Measurable[H n] (K n) :=
-    limitRadiusKernel_terminal_measurable (a (s n)) hε hBc (s n).coe_nonneg _ _
-  have hEm (n : ℕ) : MeasurableSet[H n] (E n) :=
-    measurableSet_Ioc.preimage (hKm n)
-  apply finite_density_crossing_bound_of_subset P (finiteCenteredLaw P κ B γ G z U)
-    H E hEm (ENNReal.ofReal (δ / initialGreen κ z))
-  · intro n A hA hAE
-    rw [finiteCenteredLaw_consistent_at_radius hB hBm hBc hB0 hκ hκ8 γ G F hw hz
-      (a (s n)) (a U) hε hεlim (s n).coe_nonneg (show (s n : ℝ) ≤ U from hsU n) A hA]
-    exact radiusKernel_density_bound (a (s n)) hε hεlim hBc hz (s n).coe_nonneg γ G F hw
-      δ A (H.le n _ hA) (fun ω hω => (hAE hω).2)
-  · intro n ω hω
-    have hp := (limitRadiusKernel_pos_iff (a (s n)) (s n).coe_nonneg
-      (codimension κ) (greenExponent κ) ω).mp hω.1
-    exact lt_of_le_of_lt (localizedRadiusStop_mono (a v) (a (s n))
-      (show (v : ℝ) ≤ s n from hvs n) ω) hp
-
-lemma radius_kernel_scale_cancel (κ v w L C : ℝ) (z : ℂ) (hz : z ∈ upperHalfPlane)
-    (hL : L ≠ 0) :
-    (Real.exp (codimension κ * (w - Real.log 2 - Real.log z.im)) / L / initialGreen κ z) *
-      (C * Real.exp (-codimension κ * v) * (Real.sin (Complex.arg z)) ^ greenExponent κ) =
-      C * Real.exp (codimension κ * (w - v)) / L := by
-  have hI := (initialGreen_pos κ z hz).ne'
-  have he : Real.exp (-codimension κ * v) * (Real.sin (Complex.arg z)) ^ greenExponent κ =
-      initialGreen κ z / Real.exp (codimension κ * (v - Real.log 2 - Real.log z.im)) :=
-    (initialGreen_div_zeroKernel κ v z hz).symm
-  rw [mul_assoc C, he]
-  rw [show (Real.exp (codimension κ * (w - Real.log 2 - Real.log z.im)) / L / initialGreen κ z) *
-      (C * (initialGreen κ z / Real.exp (codimension κ * (v - Real.log 2 - Real.log z.im)))) =
-      C * (Real.exp (codimension κ * (w - Real.log 2 - Real.log z.im)) /
-        Real.exp (codimension κ * (v - Real.log 2 - Real.log z.im))) / L by
-      field_simp]
-  rw [← Real.exp_sub]
-  congr 2
-  ring_nf
-
-end SLEExactGauge
-end
-
- 
-section
-
-open Set Filter MeasureTheory ProbabilityTheory Classical
-open scoped Topology NNReal ENNReal
-namespace SLEExactGauge
-
-lemma finite_radius_scaled_crossing
-    {Ω : Type*} [mΩ : MeasurableSpace Ω] {P : Measure Ω} [IsProbabilityMeasure P]
-    {B : ℝ≥0 → Ω → ℝ} {hm : ∀ t, Measurable (B t)}
-    (hB : IsBrownianReal B P)
-    (hBm : Measurable (fun q : ℝ≥0 × Ω => B q.1 q.2))
-    (hBc : ∀ ω, Continuous (fun t => B t ω)) (hB0 : ∀ ω, B 0 ω = 0)
-    {κ : ℝ} (hκ : 0 < κ) (hκ8 : κ < 8)
-    (γ : Ω → ℝ≥0 → ℂ) (G F : Ω → ℝ≥0 → ℂ → ℂ)
-    (hw : ∀ᵐ ω ∂P, IsCapacityTwoWitness
-      (fun t => Real.sqrt κ * B t ω) (γ ω) (G ω) (F ω))
-    {z : ℂ} (hz : z ∈ upperHalfPlane) {ε : ℕ → ℝ}
-    (a : ∀ u : ℝ≥0, ∀ n, AngularLocalization B hm κ z u (ε n))
-    (hε : Antitone ε) (hεlim : Tendsto ε atTop (𝓝 0))
-    (v U : ℝ≥0) (hv : 1 ≤ (v : ℝ)) (s : ℕ → ℝ≥0) (hs : Monotone s)
-    (hvs : ∀ n, v ≤ s n) (hsU : ∀ n, s n ≤ U) (w L : ℝ) (hL : 0 < L) (N : ℕ) :
-    finiteCenteredLaw P κ B γ G z U
-      (⋃ i ∈ Finset.range N, {ω | 0 < limitRadiusKernel (a (s i)) (codimension κ) (greenExponent κ) (s i) ω ∧
-        limitRadiusKernel (a (s i)) (codimension κ) (greenExponent κ) (s i) ω ≤
-          Real.exp (codimension κ * (w - Real.log 2 - Real.log z.im)) / L}) ≤
-      ENNReal.ofReal (uniformInverseAngleConstant κ 1 * Real.exp (codimension κ * (w - v)) / L) := by
-  let C := uniformInverseAngleConstant κ 1
-  have hC : 0 < C := uniformInverseAngleConstant_pos κ 1 hκ hκ8 (by norm_num)
-  let Kv := Real.exp (codimension κ * ((v : ℝ) - Real.log 2 - Real.log z.im))
-  let δ := Real.exp (codimension κ * (w - Real.log 2 - Real.log z.im)) / L
-  have hδ : 0 ≤ δ / initialGreen κ z := div_nonneg (div_pos (Real.exp_pos _) hL).le
-    (initialGreen_pos κ z hz).le
-  have hPe : P {ω | localizedRadiusStop (a v) ω < ⊤} =
-      P {ω | radiusLevelTime (γ ω) (G ω) z v < ∞} := by
-    apply measure_congr
-    filter_upwards [hw] with ω hω
-    rw [localizedRadiusStop_eq_source (a v) hεlim hBc hz ω (γ ω) (G ω) (F ω) hω]
-    rfl
-  have hPr : (P {ω | localizedRadiusStop (a v) ω < ⊤}).toReal ≤ C * initialGreen κ z / Kv := by
-    rw [hPe]
-    refine (radius_approach_regular hB hBm hBc hB0 κ hκ hκ8 γ G F hw z hz v hv).trans_eq ?_
-    dsimp only [C, Kv]
-    rw [mul_div_assoc, initialGreen_div_zeroKernel κ v z hz, mul_assoc]
-  have hPn : P {ω | localizedRadiusStop (a v) ω < ⊤} ≤ ENNReal.ofReal (C * initialGreen κ z / Kv) :=
-    (ENNReal.le_ofReal_iff_toReal_le (measure_ne_top _ _) (div_nonneg (mul_nonneg hC.le (initialGreen_pos κ z hz).le) (Real.exp_pos _).le)).mpr hPr
-  calc
-    _ ≤ ENNReal.ofReal (δ / initialGreen κ z) * P {ω | localizedRadiusStop (a v) ω < ⊤} :=
-      finite_radius_density_crossing hB hBm hBc hB0 hκ hκ8 γ G F hw hz a hε hεlim v U s hs hvs hsU δ N
-    _ ≤ ENNReal.ofReal (δ / initialGreen κ z) * ENNReal.ofReal (C * initialGreen κ z / Kv) :=
-      mul_le_mul le_rfl hPn bot_le bot_le
-    _ = ENNReal.ofReal ((δ / initialGreen κ z) * (C * initialGreen κ z / Kv)) :=
-      (ENNReal.ofReal_mul hδ).symm
-    _ = _ := by
-      congr 1
-      have he := radius_kernel_scale_cancel κ v w L C z hz hL.ne'
-      change (δ / initialGreen κ z) * (C * initialGreen κ z /
-        Real.exp (codimension κ * ((v : ℝ) - Real.log 2 - Real.log z.im))) = _
-      rw [mul_div_assoc C, initialGreen_div_zeroKernel κ v z hz, ← mul_assoc C]
-      exact he
-
-end SLEExactGauge
-end
-
- 
-section
-
-open Set Filter MeasureTheory ProbabilityTheory Classical
-open scoped Topology NNReal ENNReal
-namespace SLEExactGauge
-variable {Ω : Type*} [mΩ : MeasurableSpace Ω]
-  {B : ℝ≥0 → Ω → ℝ} {hm : ∀ t, Measurable (B t)}
-  {κ : ℝ} {z : ℂ} {u v : ℝ} {ε : ℕ → ℝ}
-
-lemma limitRadiusKernel_eq_of_surviving_cutoff
-    (a : ∀ n, AngularLocalization B hm κ z u (ε n)) (hε : Antitone ε)
-    (p α s : ℝ) (hs : 0 ≤ s) (ω : Ω) (n : ℕ)
-    (hn : s ≤ (a n).clock.S ((a n).τ ω) ω) :
-    limitRadiusKernel a p α s ω = (a n).radiusValue p α s ω := by
-  obtain ⟨m, hm, hlim⟩ := ((eventually_ge_atTop n).and (radiusKernel_eventually_limit a hε p α s ω)).exists
-  rw [max_eq_left hs] at hlim
-  rw [← hlim, ← (a n).radiusKernel_eq_of_live (a m) le_rfl (hε hm) p α s hs ω hn,
-    AngularLocalization.radiusKernel, ite_eq_left hn]
-
-lemma limitRadiusKernel_eq_below
-    (a : ∀ n, AngularLocalization B hm κ z u (ε n))
-    (b : ∀ n, AngularLocalization B hm κ z v (ε n)) (hε : Antitone ε)
-    (huv : u ≤ v) (p α s : ℝ) (hs : 0 ≤ s) (hsu : s ≤ u) (ω : Ω) :
-    limitRadiusKernel a p α s ω = limitRadiusKernel b p α s ω := by
-  obtain ⟨n, hn, hm⟩ := ((radiusKernel_eventually_limit a hε p α s ω).and
-    (radiusKernel_eventually_limit b hε p α s ω)).exists
-  rw [max_eq_left hs] at hn hm
-  rw [← hn, ← hm]
-  exact (a n).radiusKernel_eq_below (b n) huv p α s hs hsu ω
-
-lemma exists_cutoff_of_radiusStop_lt_top
-    (a : ∀ n, AngularLocalization B hm κ z u (ε n)) (ω : Ω)
-    (hω : localizedRadiusStop a ω < ⊤) : ∃ n, ω ∈ (a n).hit := by
-  by_contra hn
-  rw [localizedRadiusStop_eq_top a ω (not_exists.mp hn)] at hω
-  exact lt_irrefl _ hω
-
-lemma limitRadiusKernel_continuousOn_of_live
-    (a : ∀ n, AngularLocalization B hm κ z u (ε n)) (hε : Antitone ε)
-    (hBc : ∀ ω, Continuous (fun t => B t ω)) (p α : ℝ) (ω : Ω)
-    (hω : localizedRadiusStop a ω < ⊤) :
-    ContinuousOn (fun s => limitRadiusKernel a p α s ω) (Icc 0 u) := by
-  obtain ⟨n, hn⟩ := exists_cutoff_of_radiusStop_lt_top a ω hω
-  apply ((a n).radiusValue_continuous hBc p α ω).continuousOn.congr
-  intro s hs
-  exact limitRadiusKernel_eq_of_surviving_cutoff a hε p α s hs.1 ω n (hs.2.trans_eq hn.symm)
-
-lemma limitRadiusKernel_pos_of_live
-    (a : ∀ n, AngularLocalization B hm κ z u (ε n)) (hε : Antitone ε)
-    (p α s : ℝ) (hs : s ∈ Icc 0 u) (ω : Ω) (hω : localizedRadiusStop a ω < ⊤) :
-    0 < limitRadiusKernel a p α s ω := by
-  obtain ⟨n, hn⟩ := exists_cutoff_of_radiusStop_lt_top a ω hω
-  rw [limitRadiusKernel_eq_of_surviving_cutoff a hε p α s hs.1 ω n (hs.2.trans_eq hn.symm)]
-  exact powerLogDensity_pos _ _ _ _ _
-
-lemma radius_limit_clock_angle
-    (a : ∀ n, AngularLocalization B hm κ z u (ε n)) (hε : Antitone ε)
-    (p α s : ℝ) (hs : s ∈ Icc 0 u) (ω : Ω) (hω : localizedRadiusStop a ω < ⊤) :
-    limitRadiusKernel a p α s ω = Real.exp (p * (s - Real.log 2 - Real.log z.im)) *
-      (limitRadiusKernel a 0 2 s ω) ^ (α / 2) := by
-  obtain ⟨n, hn⟩ := exists_cutoff_of_radiusStop_lt_top a ω hω
-  have hs' : s ≤ (a n).clock.S ((a n).τ ω) ω := hs.2.trans_eq hn.symm
-  rw [limitRadiusKernel_eq_of_surviving_cutoff a hε p α s hs.1 ω n hs',
-    limitRadiusKernel_eq_of_surviving_cutoff a hε 0 2 s hs.1 ω n hs']
-  unfold AngularLocalization.radiusValue
-  rw [powerLogDensity_radius_angle κ p α (Real.log z.im),
-    powerLogDensity_radius_angle κ 0 2 (Real.log z.im)]
-  norm_num only [zero_mul, Real.exp_zero, one_mul, div_self (by norm_num : (2 : ℝ) ≠ 0), Real.rpow_one]
-  have he := (a n).clock.clock_inverse s ω
-  change (a n).clock.S ((a n).clock.inverse s ω) ω =
-    min (max s 0) ((a n).clock.S ((a n).τ ω) ω) at he
-  rw [max_eq_left hs.1, min_eq_left hs'] at he
-  change logRadiusClock (Real.log z.im)
-    ((a n).solution.Q ((a n).clock.inverse s ω) ω) = s at he
-  rw [he]
-
-end SLEExactGauge
-end
-
- 
-section
-
-open Set MeasureTheory Classical
-open scoped ENNReal
-namespace SLEExactGauge
-
-lemma finite_grid_from_monotone
-    {Ω T : Type*} [MeasurableSpace Ω] [LinearOrder T]
-    (Q : Measure Ω) (E : T → Set Ω) (v U : T) (hvU : v ≤ U) (c : ℝ≥0∞)
-    (h : ∀ s : ℕ → T, Monotone s → (∀ n, v ≤ s n) → (∀ n, s n ≤ U) →
-      ∀ N, Q (⋃ i ∈ Finset.range N, E (s i)) ≤ c)
-    (t : Finset T) (ht : ∀ x ∈ t, x ∈ Icc v U) :
-    Q (⋃ x ∈ t, E x) ≤ c := by
-  let f := t.orderEmbOfFin rfl
-  let s (n : ℕ) : T := if hn : n < t.card then f ⟨n, hn⟩ else U
-  have hmem (i : Fin t.card) : f i ∈ t := t.orderEmbOfFin_mem rfl i
-  have hs : Monotone s := by
-    intro n m hnm
-    dsimp only [s]
-    split_ifs with hn hm hm
-    · exact f.monotone hnm
-    · exact (ht _ (hmem _)).2
-    · omega
-    · exact le_rfl
-  have hl (n : ℕ) : v ≤ s n := by
-    dsimp only [s]; split_ifs with hn
-    · exact (ht _ (hmem _)).1
-    · exact hvU
-  have hu (n : ℕ) : s n ≤ U := by
-    dsimp only [s]; split_ifs with hn
-    · exact (ht _ (hmem _)).2
-    · exact le_rfl
-  have he : (⋃ x ∈ t, E x) = ⋃ i ∈ Finset.range t.card, E (s i) := by
-    ext ω
-    simp only [mem_iUnion, Finset.mem_range]
-    constructor
-    · rintro ⟨x, hx, hω⟩
-      have hex : ∃ i, f i = x := by
-        change x ∈ Set.range f
-        rw [Finset.range_orderEmbOfFin]
-        exact hx
-      obtain ⟨i, rfl⟩ := hex
-      refine ⟨i.val, i.isLt, ?_⟩
-      simpa only [s, dite_eq_left i.isLt] using hω
-    · rintro ⟨i, hi, hω⟩
-      refine ⟨f ⟨i, hi⟩, hmem _, ?_⟩
-      simpa only [s, dite_eq_left hi] using hω
-  rw [he]
-  exact h s hs hl hu t.card
-
-lemma countable_grid_from_monotone
-    {Ω T : Type*} [MeasurableSpace Ω] [LinearOrder T]
-    (Q : Measure Ω) (E : T → Set Ω) (v U : T) (hvU : v ≤ U) (c : ℝ≥0∞)
-    (h : ∀ s : ℕ → T, Monotone s → (∀ n, v ≤ s n) → (∀ n, s n ≤ U) →
-      ∀ N, Q (⋃ i ∈ Finset.range N, E (s i)) ≤ c)
-    (s : ℕ → T) (hs : ∀ n, s n ∈ Icc v U) : Q (⋃ n, E (s n)) ≤ c := by
-  have hf (N : ℕ) : Q (⋃ i ∈ Finset.range N, E (s i)) ≤ c := by
-    have hh := finite_grid_from_monotone Q E v U hvU c h
-      ((Finset.range N).image s) (by simpa using (fun i (_ : i ∈ Finset.range N) => hs i))
-    simpa using hh
-  have he : (⋃ n, E (s n)) = ⋃ N, ⋃ i ∈ Finset.range N, E (s i) := by
-    ext ω
-    simp only [mem_iUnion, Finset.mem_range]
-    constructor
-    · rintro ⟨i, hi⟩; exact ⟨i+1, i, Nat.lt_succ_self i, hi⟩
-    · rintro ⟨N, i, _, hi⟩; exact ⟨i, hi⟩
-  have hmono : Monotone (fun N => ⋃ i ∈ Finset.range N, E (s i)) := by
-    intro n m hnm ω hω
-    obtain ⟨i, hi, hω⟩ := mem_iUnion₂.mp hω
-    exact mem_iUnion₂.mpr ⟨i, Finset.mem_range.mpr ((Finset.mem_range.mp hi).trans_le hnm), hω⟩
-  rw [he, hmono.measure_iUnion]
-  exact iSup_le hf
-
-end SLEExactGauge
-end
-
- 
-section
-
-open Set MeasureTheory Classical TopologicalSpace
-open scoped ENNReal Topology NNReal
-namespace SLEExactGauge
-
-lemma continuous_crossing_from_monotone
-    {Ω : Type*} [MeasurableSpace Ω]
-    (Q : Measure Ω) (K : ℝ≥0 → Ω → ℝ) (live : Set Ω)
-    (v w U : ℝ≥0) (hvw : v ≤ w) (hwU : w ≤ U) (δ : ℝ) (c : ℝ≥0∞)
-    (hc : ∀ ω ∈ live, ContinuousOn (fun s => K s ω) (Icc v w))
-    (hp : ∀ ω ∈ live, ∀ s ∈ Icc v w, 0 < K s ω)
-    (h : ∀ s : ℕ → ℝ≥0, Monotone s → (∀ n, v ≤ s n) → (∀ n, s n ≤ U) →
-      ∀ N, Q (⋃ i ∈ Finset.range N, {ω | 0 < K (s i) ω ∧ K (s i) ω ≤ δ}) ≤ c) :
-    Q {ω | ω ∈ live ∧ ∃ s ∈ Icc v w, K s ω < δ} ≤ c := by
-  let T := ↥(Icc v w)
-  let : Nonempty T := ⟨⟨v, le_rfl, hvw⟩⟩
-  let s (n : ℕ) : ℝ≥0 := (denseSeq T n).val
-  have hs (n : ℕ) : s n ∈ Icc v U :=
-    ⟨(denseSeq T n).property.1, (denseSeq T n).property.2.trans hwU⟩
-  refine (measure_mono (show {ω | ω ∈ live ∧ ∃ s ∈ Icc v w, K s ω < δ} ⊆
-    ⋃ n, {ω | 0 < K (s n) ω ∧ K (s n) ω ≤ δ} from ?_)).trans
-    (countable_grid_from_monotone Q (fun s => {ω | 0 < K s ω ∧ K s ω ≤ δ})
-      v U (hvw.trans hwU) c h s hs)
-  intro ω hω
-  have hcont : Continuous (fun t : T => K t.val ω) :=
-    (hc ω hω.1).domRestrict
-  obtain ⟨t, ht, hlt⟩ := hω.2
-  obtain ⟨n, hn⟩ := (denseRange_denseSeq T).exists_mem_open
-    (isOpen_lt hcont continuous_const) ⟨⟨t, ht⟩, hlt⟩
-  exact mem_iUnion.mpr ⟨n, hp ω hω.1 _ (denseSeq T n).property, hn.le⟩
-
-end SLEExactGauge
-end
-
- 
-section
-
-open Set Filter MeasureTheory ProbabilityTheory Classical
-open scoped Topology NNReal ENNReal
-namespace SLEExactGauge
-variable {Ω : Type*} [mΩ : MeasurableSpace Ω]
-  {B : ℝ≥0 → Ω → ℝ} {hm : ∀ t, Measurable (B t)}
-  {κ : ℝ} {z : ℂ} {ε : ℕ → ℝ}
-
-lemma terminalRadiusKernel_continuousOn
-    (a : ∀ u : ℝ≥0, ∀ n, AngularLocalization B hm κ z u (ε n)) (hε : Antitone ε)
-    (hBc : ∀ ω, Continuous (fun t => B t ω)) (p α : ℝ)
-    (U : ℝ≥0) (ω : Ω) (hω : localizedRadiusStop (a U) ω < ⊤) :
-    ContinuousOn (fun s : ℝ≥0 => limitRadiusKernel (a s) p α s ω) (Icc 0 U) := by
-  have he (s : ℝ≥0) (hs : s ∈ Icc 0 U) :
-      limitRadiusKernel (a s) p α s ω = limitRadiusKernel (a U) p α s ω :=
-    limitRadiusKernel_eq_below (a s) (a U) hε (show (s : ℝ) ≤ U from hs.2) p α s
-      s.coe_nonneg le_rfl ω
-  have hc := (limitRadiusKernel_continuousOn_of_live (a U) hε hBc p α ω hω).comp
-    continuous_subtype_val.continuousOn (show MapsTo (fun s : ℝ≥0 => (s : ℝ)) (Icc 0 U) (Icc 0 (U : ℝ)) from
-      fun s hs => ⟨s.coe_nonneg, hs.2⟩)
-  exact hc.congr he
-
-lemma terminalRadiusKernel_pos
-    (a : ∀ u : ℝ≥0, ∀ n, AngularLocalization B hm κ z u (ε n)) (hε : Antitone ε)
-    (p α : ℝ) (U s : ℝ≥0) (hs : s ≤ U) (ω : Ω)
-    (hω : localizedRadiusStop (a U) ω < ⊤) :
-    0 < limitRadiusKernel (a s) p α s ω := by
-  rw [limitRadiusKernel_eq_below (a s) (a U) hε (show (s : ℝ) ≤ U from hs) p α s
-    s.coe_nonneg le_rfl ω]
-  exact limitRadiusKernel_pos_of_live (a U) hε p α s ⟨s.coe_nonneg, hs⟩ ω hω
-
-lemma continuous_radius_scaled_crossing
-    {P : Measure Ω} [IsProbabilityMeasure P]
-    (hB : IsBrownianReal B P)
-    (hBm : Measurable (fun q : ℝ≥0 × Ω => B q.1 q.2))
-    (hBc : ∀ ω, Continuous (fun t => B t ω)) (hB0 : ∀ ω, B 0 ω = 0)
-    (hκ : 0 < κ) (hκ8 : κ < 8)
-    (γ : Ω → ℝ≥0 → ℂ) (G F : Ω → ℝ≥0 → ℂ → ℂ)
-    (hw : ∀ᵐ ω ∂P, IsCapacityTwoWitness
-      (fun t => Real.sqrt κ * B t ω) (γ ω) (G ω) (F ω))
-    (hz : z ∈ upperHalfPlane)
-    (a : ∀ u : ℝ≥0, ∀ n, AngularLocalization B hm κ z u (ε n))
-    (hε : Antitone ε) (hεlim : Tendsto ε atTop (𝓝 0))
-    (v w U : ℝ≥0) (hv : 1 ≤ (v : ℝ)) (hvw : v ≤ w) (hwU : w ≤ U)
-    (L : ℝ) (hL : 0 < L) :
-    finiteCenteredLaw P κ B γ G z U
-      {ω | localizedRadiusStop (a U) ω < ⊤ ∧ ∃ s ∈ Icc v w,
-        limitRadiusKernel (a s) (codimension κ) (greenExponent κ) s ω <
-          Real.exp (codimension κ * ((w : ℝ) - Real.log 2 - Real.log z.im)) / L} ≤
-      ENNReal.ofReal (uniformInverseAngleConstant κ 1 * Real.exp (codimension κ * ((w : ℝ) - v)) / L) := by
-  apply continuous_crossing_from_monotone _ _ _ v w U hvw hwU
-  · intro ω hω
-    exact (terminalRadiusKernel_continuousOn a hε hBc _ _ U ω hω).mono
-      (Icc_subset_Icc (show (0 : ℝ≥0) ≤ v from bot_le) hwU)
-  · intro ω hω s hs
-    exact terminalRadiusKernel_pos a hε _ _ U s (hs.2.trans hwU) ω hω
-  · intro s hs hvs hsU N
-    exact finite_radius_scaled_crossing hB hBm hBc hB0 hκ hκ8 γ G F hw hz
-      a hε hεlim v U hv s hs hvs hsU w L hL N
-
-end SLEExactGauge
-end
-
- 
-section
-
-open Set Filter MeasureTheory ProbabilityTheory Classical
-open scoped Topology NNReal ENNReal
-namespace SLEExactGauge
-variable {Ω : Type*} [mΩ : MeasurableSpace Ω]
-  {B : ℝ≥0 → Ω → ℝ} {hm : ∀ t, Measurable (B t)}
-  {κ : ℝ} {z : ℂ} {ε : ℕ → ℝ}
-
-noncomputable def radiusInverseAngle
-    (a : ∀ u : ℝ≥0, ∀ n, AngularLocalization B hm κ z u (ε n))
-    (s : ℝ≥0) (�� : Ω) : ℝ :=
-  (limitRadiusKernel (a s) 0 2 s ω) ^ (-greenExponent κ / 2)
-
-lemma radiusInverseAngle_product
-    (a : ∀ u : ℝ≥0, ∀ n, AngularLocalization B hm κ z u (ε n)) (hε : Antitone ε)
-    (s : ℝ≥0) (ω : Ω) (hω : localizedRadiusStop (a s) ω < ⊤) :
-    limitRadiusKernel (a s) (codimension κ) (greenExponent κ) s ω * radiusInverseAngle a s ω =
-      Real.exp (codimension κ * ((s : ℝ) - Real.log 2 - Real.log z.im)) := by
-  rw [radiusInverseAngle, ← limitRadiusKernel_inverse_factor (a s) hε, sub_self,
-    radius_limit_clock_angle (a s) hε (codimension κ) 0 s ⟨s.coe_nonneg, le_rfl⟩ ω hω]
-  simp
-
-lemma radiusInverseAngle_large_imp_crossing
-    (a : ∀ u : ℝ≥0, ∀ n, AngularLocalization B hm κ z u (ε n)) (hε : Antitone ε)
-    (hκ8 : κ < 8) (s w U : ℝ≥0) (hsw : s ≤ w) (hwU : w ≤ U)
-    (L : ℝ) (hL : 0 < L) (ω : Ω) (hω : localizedRadiusStop (a U) ω < ⊤)
-    (hV : L < radiusInverseAngle a s ω) :
-    limitRadiusKernel (a s) (codimension κ) (greenExponent κ) s ω <
-      Real.exp (codimension κ * ((w : ℝ) - Real.log 2 - Real.log z.im)) / L := by
-  have hls : localizedRadiusStop (a s) ω < ⊤ :=
-    lt_of_le_of_lt (localizedRadiusStop_mono (a s) (a U) (show (s : ℝ) ≤ U from hsw.trans hwU) ω) hω
-  have hK := terminalRadiusKernel_pos a hε (codimension κ) (greenExponent κ) U s (hsw.trans hwU) ω hω
-  apply (lt_div_iff₀ hL).mpr
-  calc
-    _ < limitRadiusKernel (a s) (codimension κ) (greenExponent κ) s ω * radiusInverseAngle a s ω :=
-      mul_lt_mul_of_pos_left hV hK
-    _ = Real.exp (codimension κ * ((s : ℝ) - Real.log 2 - Real.log z.im)) :=
-      radiusInverseAngle_product a hε s ω hls
-    _ ≤ _ := Real.exp_le_exp.mpr (mul_le_mul_of_nonneg_left (sub_le_sub_right (sub_le_sub_right (show (s : ℝ) ≤ w from hsw) _) _) (codimension_pos κ hκ8).le)
-
-lemma inverse_angle_window_bound
-    {P : Measure Ω} [IsProbabilityMeasure P]
-    (hB : IsBrownianReal B P)
-    (hBm : Measurable (fun q : ℝ≥0 × Ω => B q.1 q.2))
-    (hBc : ∀ ω, Continuous (fun t => B t ω)) (hB0 : ∀ ω, B 0 ω = 0)
-    (hκ : 0 < κ) (hκ8 : κ < 8)
-    (γ : Ω → ℝ≥0 → ℂ) (G F : Ω → ℝ≥0 → ℂ → ℂ)
-    (hw : ∀ᵐ ω ∂P, IsCapacityTwoWitness
-      (fun t => Real.sqrt κ * B t ω) (γ ω) (G ω) (F ω))
-    (hz : z ∈ upperHalfPlane)
-    (a : ∀ u : ℝ≥0, ∀ n, AngularLocalization B hm κ z u (ε n))
-    (hε : Antitone ε) (hεlim : Tendsto ε atTop (𝓝 0))
-    (v w U : ℝ≥0) (hv : 1 ≤ (v : ℝ)) (hvw : v ≤ w) (hwU : w ≤ U)
-    (L : ℝ) (hL : 0 < L) :
-    finiteCenteredLaw P κ B γ G z U
-      {ω | localizedRadiusStop (a U) ω < ⊤ ∧ ∃ s ∈ Icc v w, L < radiusInverseAngle a s ω} ≤
-      ENNReal.ofReal (uniformInverseAngleConstant κ 1 * Real.exp (codimension κ * ((w : ℝ) - v)) / L) := by
-  refine (measure_mono (s := {ω | localizedRadiusStop (a U) ω < ⊤ ∧ ∃ s ∈ Icc v w, L < radiusInverseAngle a s ω})
-    (t := {ω | localizedRadiusStop (a U) ω < ⊤ ∧ ∃ s ∈ Icc v w,
-      limitRadiusKernel (a s) (codimension κ) (greenExponent κ) s ω <
-        Real.exp (codimension κ * ((w : ℝ) - Real.log 2 - Real.log z.im)) / L}) ?_).trans
-    (continuous_radius_scaled_crossing hB hBm hBc hB0 hκ hκ8 γ G F hw hz a hε hεlim
-      v w U hv hvw hwU L hL)
-  rintro ω ⟨hω, s, hs, hV⟩
-  exact ⟨hω, s, hs, radiusInverseAngle_large_imp_crossing a hε hκ8 s w U hs.2 hwU L hL ω hω hV⟩
-
-end SLEExactGauge
-end
-
- 
-section
-
-open Set Filter MeasureTheory ProbabilityTheory Classical
-open scoped Topology NNReal ENNReal
-namespace SLEExactGauge
-variable {Ω : Type*} [mΩ : MeasurableSpace Ω]
-  {B : ℝ≥0 → Ω → ℝ} {hm : ∀ t, Measurable (B t)}
-  {κ : ℝ} {z : ℂ} {ε : ℕ → ℝ}
-
-end SLEExactGauge
-end
-end
-
-end OAI
+import Mathlib
+import OAI.Probability.SLE.InverseMoments
+import OAI.Probability.SLE.SausagePointBound
+import OAI.Probability.SLE.SpatialMeans
+
+namespace OAI
+
+/-! Measure Support for chordal SLE. -/
+
+section
+section
+open Set Filter MeasureTheory ProbabilityTheory Metric Classical
+open scoped Topology NNReal ENNReal
+namespace SLEExactGauge
+noncomputable def spatialGreenMass (κ : ℝ) (U : ℝ≥0 → ℝ) (γ : ℝ≥0 → ℂ)
+    (G : ℝ≥0 → ℂ → ℂ) (r : ℝ) (A : Set ℂ) : ℝ≥0∞ :=
+  ∫⁻ z in A, ENNReal.ofReal (spatialGreenWeight κ U γ G z r)
+
+namespace RegularSLEPresentation
+variable {Ω : Type*} [MeasurableSpace Ω] {P : Measure Ω}
+    {κ : ℝ} {γ : Ω → ℝ≥0 → ℂ} (a : RegularSLEPresentation P κ γ)
+
+lemma spatialGreenMass_measurable (r : ℝ) (A : Set ℂ) :
+    Measurable (fun ω : a.samples => spatialGreenMass κ
+      (fun t => Real.sqrt κ * a.B t ω) (γ ω) (a.G ω) r A) :=
+  (a.spatialGreenWeight_measurable r).ennreal_ofReal.lintegral_prod_left'
+
+ 
+
+lemma spatialGreenMass_expectation [IsProbabilityMeasure P]
+    (hκ : 0 < κ) (hκ8 : κ < 8) (r : ℝ) (hr : 0 < r)
+    (A : Set ℂ) (hA : MeasurableSet A) (hheight : ∀ z ∈ A, r ≤ z.im) :
+    (∫⁻ ω : a.samples, spatialGreenMass κ (fun t => Real.sqrt κ * a.B t ω)
+      (γ ω) (a.G ω) r A ∂(P.comap Subtype.val)) =
+      ∫⁻ z in A, ENNReal.ofReal (initialGreen κ z) := by
+  let μ : Measure a.samples := P.comap Subtype.val
+  let : IsProbabilityMeasure μ := a.probability
+  simp only [spatialGreenMass]
+  rw [← lintegral_lintegral_swap (a.spatialGreenWeight_measurable r).ennreal_ofReal.aemeasurable]
+  apply setLIntegral_congr_fun hA
+  intro z hz
+  obtain ⟨hi, he⟩ := a.spatialGreen_expectation hκ hκ8 z r hr (hheight z hz)
+  change (∫⁻ ω : a.samples, ENNReal.ofReal (spatialGreenWeight κ
+    (fun t => Real.sqrt κ * a.B t ω) (γ ω) (a.G ω) z r) ∂μ) = ENNReal.ofReal (initialGreen κ z)
+  rw [← he]
+  exact (ofReal_integral_eq_lintegral_ofReal hi (Eventually.of_forall fun ω => by
+    dsimp only [Pi.zero_apply, spatialGreenWeight]
+    split_ifs
+    · exact le_rfl
+    · exact greenDensity_nonneg (a.witness ω) κ _ z)).symm
+
+ 
+
+lemma spatialGreenMass_expectation_le [IsProbabilityMeasure P]
+    (hκ : 0 < κ) (hκ8 : κ < 8) (r : ℝ) (hr : 0 < r)
+    (A : Set ℂ) (hA : MeasurableSet A) (hheight : ∀ z ∈ A, r ≤ z.im) :
+    (∫⁻ ω : a.samples, spatialGreenMass κ (fun t => Real.sqrt κ * a.B t ω)
+      (γ ω) (a.G ω) r A ∂(P.comap Subtype.val)) ≤
+      ENNReal.ofReal ((2 : ℝ) ^ (-codimension κ) * r ^ (-codimension κ)) * volume A := by
+  rw [a.spatialGreenMass_expectation hκ hκ8 r hr A hA hheight]
+  calc
+    _ ≤ ∫⁻ _z in A, ENNReal.ofReal ((2 : ℝ) ^ (-codimension κ) * r ^ (-codimension κ)) := by
+      apply setLIntegral_mono' hA
+      intro z hz
+      apply ENNReal.ofReal_le_ofReal
+      calc
+        _ ≤ (2 : ℝ) ^ (-codimension κ) * z.im ^ (-codimension κ) :=
+          initialGreen_le_height κ hκ hκ8 z (hr.trans_le (hheight z hz))
+        _ ≤ _ := mul_le_mul_of_nonneg_left
+          (Real.rpow_le_rpow_of_nonpos hr (hheight z hz) (neg_nonpos.mpr (codimension_pos κ hκ8).le))
+          (Real.rpow_nonneg (by norm_num) _)
+    _ = _ := by rw [lintegral_const, Measure.restrict_apply_univ]
+
+end RegularSLEPresentation
+end SLEExactGauge
+end
+
+ 
+section
+
+open Set Filter MeasureTheory ProbabilityTheory Classical
+open scoped Topology NNReal ENNReal
+namespace SLEExactGauge
+
+ 
+
+lemma finite_density_crossing_bound
+    {Ω : Type*} [mΩ : MeasurableSpace Ω] (P Q : Measure Ω)
+    (F : Filtration ℕ mΩ) (B : ℕ → Set Ω)
+    (hBm : ∀ n, MeasurableSet[F n] (B n)) (c : ℝ≥0∞)
+    (hQ : ∀ n A, MeasurableSet[F n] A → A ⊆ B n → Q A ≤ c * P A)
+    (n : ℕ) : Q (⋃ i ∈ Finset.range n, B i) ≤ c * P (⋃ i ∈ Finset.range n, B i) := by
+  classical
+  let E (n : ℕ) : Set Ω := ⋃ i ∈ Finset.range n, B i
+  have hEm (n : ℕ) : MeasurableSet[F n] (E n) := by
+    apply MeasurableSet.iUnion
+    intro i
+    apply MeasurableSet.iUnion
+    intro hi
+    exact F.mono (Nat.le_of_lt (Finset.mem_range.mp hi)) _ (hBm i)
+  have hrec (n : ℕ) : E (n + 1) = E n ∪ (B n \ E n) := by
+    calc
+      E (n + 1) = B n ∪ E n := by
+        ext ω
+        simp only [E, Finset.range_add_one, Finset.mem_insert, mem_iUnion, mem_union]
+        aesop
+      _ = E n ∪ (B n \ E n) := by
+        ext ω
+        by_cases h : ω ∈ E n <;> simp [h]
+  change Q (E n) ≤ c * P (E n)
+  induction n with
+  | zero => simp [E]
+  | succ n ih =>
+      have hD := (hBm n).diff (hEm n)
+      have hd : Disjoint (E n) (B n \ E n) := disjoint_sdiff_right
+      rw [hrec n, measure_union hd (F.le n _ hD), measure_union hd (F.le n _ hD), mul_add]
+      exact add_le_add ih (hQ n _ hD sdiff_subset)
+
+lemma finite_density_crossing_bound_of_subset
+    {Ω : Type*} [mΩ : MeasurableSpace Ω] (P Q : Measure Ω)
+    (F : Filtration ℕ mΩ) (B : ℕ → Set Ω)
+    (hBm : ∀ n, MeasurableSet[F n] (B n)) (c : ℝ≥0∞)
+    (hQ : ∀ n A, MeasurableSet[F n] A → A ⊆ B n → Q A ≤ c * P A)
+    (A : Set Ω) (hA : ∀ n, B n ⊆ A) (n : ℕ) :
+    Q (⋃ i ∈ Finset.range n, B i) ≤ c * P A := by
+  refine (finite_density_crossing_bound P Q F B hBm c hQ n).trans ?_
+  exact mul_le_mul (show c ≤ c from le_rfl)
+    (show P (⋃ i ∈ Finset.range n, B i) ≤ P A from
+      measure_mono (iUnion₂_subset fun i _ => hA i)) bot_le bot_le
+
+end SLEExactGauge
+end
+
+ 
+section
+
+open Set Filter MeasureTheory ProbabilityTheory Classical
+open scoped Topology NNReal ENNReal
+namespace SLEExactGauge
+variable {Ω : Type*} [mΩ : MeasurableSpace Ω]
+  {B : ℝ≥0 → Ω → ℝ} {hm : ∀ t, Measurable (B t)}
+  {κ : ℝ} {z : ℂ} {u : ℝ} {ε : ℕ → ℝ}
+
+lemma limitRadiusKernel_pos_iff
+    (a : ∀ n, AngularLocalization B hm κ z u (ε n)) (hu : 0 ≤ u)
+    (p α : ℝ) (ω : Ω) :
+    0 < limitRadiusKernel a p α u ω ↔ localizedRadiusStop a ω < ⊤ := by
+  have hx : (∃ n, max u 0 ≤ (a n).clock.S ((a n).τ ω) ω) ↔ ∃ n, ω ∈ (a n).hit := by
+    simp only [max_eq_left hu]
+    constructor
+    · rintro ⟨n, hn⟩
+      exact ⟨n, le_antisymm ((a n).clock_upper ω) hn⟩
+    · rintro ⟨n, hn⟩
+      exact ⟨n, le_of_eq hn.symm⟩
+  by_cases hh : ∃ n, ω ∈ (a n).hit
+  · have he := hx.mpr hh
+    obtain ⟨n, hn⟩ := hh
+    rw [localizedRadiusStop_eq_hit a ω n hn, limitRadiusKernel, dite_eq_left he,
+      AngularLocalization.radiusKernel, ite_eq_left (Nat.find_spec he)]
+    exact iff_of_true (Real.exp_pos _) (WithTop.coe_lt_top _)
+  · rw [localizedRadiusStop_eq_top a ω (not_exists.mp hh), limitRadiusKernel,
+      dite_eq_right (fun h => hh (hx.mp h))]
+    simp
+
+lemma finiteCenteredLaw_eq_radiusKernel
+    {P : Measure Ω} (a : ∀ n, AngularLocalization B hm κ z u (ε n))
+    (hε : Antitone ε) (hεlim : Tendsto ε atTop (𝓝 0))
+    (hBc : ∀ ω, Continuous (fun t => B t ω)) (hz : z ∈ upperHalfPlane) (hu : 0 ≤ u)
+    (γ : Ω → ℝ≥0 → ℂ) (G F : Ω → ℝ≥0 → ℂ → ℂ)
+    (hw : ∀ᵐ ω ∂P, IsCapacityTwoWitness
+      (fun t => Real.sqrt κ * B t ω) (γ ω) (G ω) (F ω)) :
+    finiteCenteredLaw P κ B γ G z u = P.withDensity
+      (fun ω => ENNReal.ofReal (limitRadiusKernel a (codimension κ) (greenExponent κ) u ω /
+        initialGreen κ z)) := by
+  apply withDensity_congr_ae
+  filter_upwards [hw] with ω hω
+  rw [limitRadiusKernel_eq_stoppedGreen a hε hεlim hBc hz hu ω (γ ω) (G ω) (F ω) hω]
+
+lemma radiusKernel_density_bound
+    {P : Measure Ω} (a : ∀ n, AngularLocalization B hm κ z u (ε n))
+    (hε : Antitone ε) (hεlim : Tendsto ε atTop (𝓝 0))
+    (hBc : ∀ ω, Continuous (fun t => B t ω)) (hz : z ∈ upperHalfPlane) (hu : 0 ≤ u)
+    (γ : Ω → ℝ≥0 → ℂ) (G F : Ω → ℝ≥0 → ℂ → ℂ)
+    (hw : ∀ᵐ ω ∂P, IsCapacityTwoWitness
+      (fun t => Real.sqrt κ * B t ω) (γ ω) (G ω) (F ω))
+    (δ : ℝ) (A : Set Ω) (hA : MeasurableSet A)
+    (hδ : ∀ ω ∈ A, limitRadiusKernel a (codimension κ) (greenExponent κ) u ω ≤ δ) :
+    finiteCenteredLaw P κ B γ G z u A ≤ ENNReal.ofReal (δ / initialGreen κ z) * P A := by
+  rw [finiteCenteredLaw_eq_radiusKernel a hε hεlim hBc hz hu γ G F hw, withDensity_apply _ hA]
+  calc
+    _ ≤ ∫⁻ ω in A, ENNReal.ofReal (δ / initialGreen κ z) ∂P := by
+      apply lintegral_mono_ae
+      filter_upwards [ae_restrict_mem hA] with ω hω
+      exact ENNReal.ofReal_le_ofReal (div_le_div_of_nonneg_right (hδ ω hω) (initialGreen_pos κ z hz).le)
+    _ = _ := by simp
+
+lemma finiteCenteredLaw_consistent_at_radius
+    {P : Measure Ω} [IsProbabilityMeasure P]
+    (hB : IsBrownianReal B P)
+    (hBm : Measurable (fun q : ℝ≥0 × Ω => B q.1 q.2))
+    (hBc : ∀ ω, Continuous (fun t => B t ω)) (hB0 : ∀ ω, B 0 ω = 0)
+    (hκ : 0 < κ) (hκ8 : κ < 8)
+    (γ : Ω → ℝ≥0 → ℂ) (G F : Ω → ℝ≥0 → ℂ → ℂ)
+    (hw : ∀ᵐ ω ∂P, IsCapacityTwoWitness
+      (fun t => Real.sqrt κ * B t ω) (γ ω) (G ω) (F ω)) (hz : z ∈ upperHalfPlane)
+    {v : ℝ} (a : ∀ n, AngularLocalization B hm κ z u (ε n))
+    (b : ∀ n, AngularLocalization B hm κ z v (ε n))
+    (hε : Antitone ε) (hεlim : Tendsto ε atTop (𝓝 0)) (hu : 0 ≤ u) (huv : u ≤ v)
+    (A : Set Ω) (hA : MeasurableSet[(localizedRadiusStop_stopping a).measurableSpace] A) :
+    finiteCenteredLaw P κ B γ G z v A = finiteCenteredLaw P κ B γ G z u A := by
+  have hAm := (localizedRadiusStop_stopping a).measurableSpace_le _ hA
+  rw [finiteCenteredLaw_apply hB κ hκ hκ8 γ G F hw z hz v (hu.trans huv) A hAm,
+    finiteCenteredLaw_apply hB κ hκ hκ8 γ G F hw z hz u hu A hAm,
+    finite_stopped_green_consistent_regular hB hBm hBc hB0 hκ hκ8 γ G F hw hz
+      a b hεlim hε hu huv A hA]
+
+end SLEExactGauge
+end
+
+ 
+section
+
+open Set Filter MeasureTheory ProbabilityTheory Classical
+open scoped Topology NNReal ENNReal
+namespace SLEExactGauge
+
+lemma finite_radius_density_crossing
+    {Ω : Type*} [mΩ : MeasurableSpace Ω] {P : Measure Ω} [IsProbabilityMeasure P]
+    {B : ℝ≥0 → Ω → ℝ} {hm : ∀ t, Measurable (B t)}
+    (hB : IsBrownianReal B P)
+    (hBm : Measurable (fun q : ℝ≥0 × Ω => B q.1 q.2))
+    (hBc : ∀ ω, Continuous (fun t => B t ω)) (hB0 : ∀ ω, B 0 ω = 0)
+    {κ : ℝ} (hκ : 0 < κ) (hκ8 : κ < 8)
+    (γ : Ω → ℝ≥0 → ℂ) (G F : Ω → ℝ≥0 → ℂ → ℂ)
+    (hw : ∀ᵐ ω ∂P, IsCapacityTwoWitness
+      (fun t => Real.sqrt κ * B t ω) (γ ω) (G ω) (F ω))
+    {z : ℂ} (hz : z ∈ upperHalfPlane) {ε : ℕ → ℝ}
+    (a : ∀ u : ℝ≥0, ∀ n, AngularLocalization B hm κ z u (ε n))
+    (hε : Antitone ε) (hεlim : Tendsto ε atTop (𝓝 0))
+    (v U : ℝ≥0) (s : ℕ → ℝ≥0) (hs : Monotone s)
+    (hvs : ∀ n, v ≤ s n) (hsU : ∀ n, s n ≤ U) (δ : ℝ) (N : ℕ) :
+    finiteCenteredLaw P κ B γ G z U
+      (⋃ i ∈ Finset.range N, {ω | 0 < limitRadiusKernel (a (s i)) (codimension κ) (greenExponent κ) (s i) ω ∧
+        limitRadiusKernel (a (s i)) (codimension κ) (greenExponent κ) (s i) ω ≤ δ}) ≤
+      ENNReal.ofReal (δ / initialGreen κ z) * P {ω | localizedRadiusStop (a v) ω < ⊤} := by
+  let K (n : ℕ) := limitRadiusKernel (a (s n)) (codimension κ) (greenExponent κ) (s n)
+  let E (n : ℕ) : Set Ω := {ω | 0 < K n ω ∧ K n ω ≤ δ}
+  let H : Filtration ℕ mΩ :=
+    { seq := fun n => radiusFiltration a (s n)
+      mono' := fun n m hnm => (radiusFiltration a).mono (hs hnm)
+      le' := fun n => (radiusFiltration a).le (s n) }
+  have hKm (n : ℕ) : Measurable[H n] (K n) :=
+    limitRadiusKernel_terminal_measurable (a (s n)) hε hBc (s n).coe_nonneg _ _
+  have hEm (n : ℕ) : MeasurableSet[H n] (E n) :=
+    measurableSet_Ioc.preimage (hKm n)
+  apply finite_density_crossing_bound_of_subset P (finiteCenteredLaw P κ B γ G z U)
+    H E hEm (ENNReal.ofReal (δ / initialGreen κ z))
+  · intro n A hA hAE
+    rw [finiteCenteredLaw_consistent_at_radius hB hBm hBc hB0 hκ hκ8 γ G F hw hz
+      (a (s n)) (a U) hε hεlim (s n).coe_nonneg (show (s n : ℝ) ≤ U from hsU n) A hA]
+    exact radiusKernel_density_bound (a (s n)) hε hεlim hBc hz (s n).coe_nonneg γ G F hw
+      δ A (H.le n _ hA) (fun ω hω => (hAE hω).2)
+  · intro n ω hω
+    have hp := (limitRadiusKernel_pos_iff (a (s n)) (s n).coe_nonneg
+      (codimension κ) (greenExponent κ) ω).mp hω.1
+    exact lt_of_le_of_lt (localizedRadiusStop_mono (a v) (a (s n))
+      (show (v : ℝ) ≤ s n from hvs n) ω) hp
+
+lemma radius_kernel_scale_cancel (κ v w L C : ℝ) (z : ℂ) (hz : z ∈ upperHalfPlane)
+    (hL : L ≠ 0) :
+    (Real.exp (codimension κ * (w - Real.log 2 - Real.log z.im)) / L / initialGreen κ z) *
+      (C * Real.exp (-codimension κ * v) * (Real.sin (Complex.arg z)) ^ greenExponent κ) =
+      C * Real.exp (codimension κ * (w - v)) / L := by
+  have hI := (initialGreen_pos κ z hz).ne'
+  have he : Real.exp (-codimension κ * v) * (Real.sin (Complex.arg z)) ^ greenExponent κ =
+      initialGreen κ z / Real.exp (codimension κ * (v - Real.log 2 - Real.log z.im)) :=
+    (initialGreen_div_zeroKernel κ v z hz).symm
+  rw [mul_assoc C, he]
+  rw [show (Real.exp (codimension κ * (w - Real.log 2 - Real.log z.im)) / L / initialGreen κ z) *
+      (C * (initialGreen κ z / Real.exp (codimension κ * (v - Real.log 2 - Real.log z.im)))) =
+      C * (Real.exp (codimension κ * (w - Real.log 2 - Real.log z.im)) /
+        Real.exp (codimension κ * (v - Real.log 2 - Real.log z.im))) / L by
+      field_simp]
+  rw [← Real.exp_sub]
+  congr 2
+  ring_nf
+
+end SLEExactGauge
+end
+
+ 
+section
+
+open Set Filter MeasureTheory ProbabilityTheory Classical
+open scoped Topology NNReal ENNReal
+namespace SLEExactGauge
+
+lemma finite_radius_scaled_crossing
+    {Ω : Type*} [mΩ : MeasurableSpace Ω] {P : Measure Ω} [IsProbabilityMeasure P]
+    {B : ℝ≥0 → Ω → ℝ} {hm : ∀ t, Measurable (B t)}
+    (hB : IsBrownianReal B P)
+    (hBm : Measurable (fun q : ℝ≥0 × Ω => B q.1 q.2))
+    (hBc : ∀ ω, Continuous (fun t => B t ω)) (hB0 : ∀ ω, B 0 ω = 0)
+    {κ : ℝ} (hκ : 0 < κ) (hκ8 : κ < 8)
+    (γ : Ω → ℝ≥0 → ℂ) (G F : Ω → ℝ≥0 → ℂ → ℂ)
+    (hw : ∀ᵐ ω ∂P, IsCapacityTwoWitness
+      (fun t => Real.sqrt κ * B t ω) (γ ω) (G ω) (F ω))
+    {z : ℂ} (hz : z ∈ upperHalfPlane) {ε : ℕ → ℝ}
+    (a : ∀ u : ℝ≥0, ∀ n, AngularLocalization B hm κ z u (ε n))
+    (hε : Antitone ε) (hεlim : Tendsto ε atTop (𝓝 0))
+    (v U : ℝ≥0) (hv : 1 ≤ (v : ℝ)) (s : ℕ → ℝ≥0) (hs : Monotone s)
+    (hvs : ∀ n, v ≤ s n) (hsU : ∀ n, s n ≤ U) (w L : ℝ) (hL : 0 < L) (N : ℕ) :
+    finiteCenteredLaw P κ B γ G z U
+      (⋃ i ∈ Finset.range N, {ω | 0 < limitRadiusKernel (a (s i)) (codimension κ) (greenExponent κ) (s i) ω ∧
+        limitRadiusKernel (a (s i)) (codimension κ) (greenExponent κ) (s i) ω ≤
+          Real.exp (codimension κ * (w - Real.log 2 - Real.log z.im)) / L}) ≤
+      ENNReal.ofReal (uniformInverseAngleConstant κ 1 * Real.exp (codimension κ * (w - v)) / L) := by
+  let C := uniformInverseAngleConstant κ 1
+  have hC : 0 < C := uniformInverseAngleConstant_pos κ 1 hκ hκ8 (by norm_num)
+  let Kv := Real.exp (codimension κ * ((v : ℝ) - Real.log 2 - Real.log z.im))
+  let δ := Real.exp (codimension κ * (w - Real.log 2 - Real.log z.im)) / L
+  have hδ : 0 ≤ δ / initialGreen κ z := div_nonneg (div_pos (Real.exp_pos _) hL).le
+    (initialGreen_pos κ z hz).le
+  have hPe : P {ω | localizedRadiusStop (a v) ω < ⊤} =
+      P {ω | radiusLevelTime (γ ω) (G ω) z v < ∞} := by
+    apply measure_congr
+    filter_upwards [hw] with ω hω
+    rw [localizedRadiusStop_eq_source (a v) hεlim hBc hz ω (γ ω) (G ω) (F ω) hω]
+    rfl
+  have hPr : (P {ω | localizedRadiusStop (a v) ω < ⊤}).toReal ≤ C * initialGreen κ z / Kv := by
+    rw [hPe]
+    refine (radius_approach_regular hB hBm hBc hB0 κ hκ hκ8 γ G F hw z hz v hv).trans_eq ?_
+    dsimp only [C, Kv]
+    rw [mul_div_assoc, initialGreen_div_zeroKernel κ v z hz, mul_assoc]
+  have hPn : P {ω | localizedRadiusStop (a v) ω < ⊤} ≤ ENNReal.ofReal (C * initialGreen κ z / Kv) :=
+    (ENNReal.le_ofReal_iff_toReal_le (measure_ne_top _ _) (div_nonneg (mul_nonneg hC.le (initialGreen_pos κ z hz).le) (Real.exp_pos _).le)).mpr hPr
+  calc
+    _ ≤ ENNReal.ofReal (δ / initialGreen κ z) * P {ω | localizedRadiusStop (a v) ω < ⊤} :=
+      finite_radius_density_crossing hB hBm hBc hB0 hκ hκ8 γ G F hw hz a hε hεlim v U s hs hvs hsU δ N
+    _ ≤ ENNReal.ofReal (δ / initialGreen κ z) * ENNReal.ofReal (C * initialGreen κ z / Kv) :=
+      mul_le_mul le_rfl hPn bot_le bot_le
+    _ = ENNReal.ofReal ((δ / initialGreen κ z) * (C * initialGreen κ z / Kv)) :=
+      (ENNReal.ofReal_mul hδ).symm
+    _ = _ := by
+      congr 1
+      have he := radius_kernel_scale_cancel κ v w L C z hz hL.ne'
+      change (δ / initialGreen κ z) * (C * initialGreen κ z /
+        Real.exp (codimension κ * ((v : ℝ) - Real.log 2 - Real.log z.im))) = _
+      rw [mul_div_assoc C, initialGreen_div_zeroKernel κ v z hz, ← mul_assoc C]
+      exact he
+
+end SLEExactGauge
+end
+
+ 
+section
+
+open Set Filter MeasureTheory ProbabilityTheory Classical
+open scoped Topology NNReal ENNReal
+namespace SLEExactGauge
+variable {Ω : Type*} [mΩ : MeasurableSpace Ω]
+  {B : ℝ≥0 → Ω → ℝ} {hm : ∀ t, Measurable (B t)}
+  {κ : ℝ} {z : ℂ} {u v : ℝ} {ε : ℕ → ℝ}
+
+lemma limitRadiusKernel_eq_of_surviving_cutoff
+    (a : ∀ n, AngularLocalization B hm κ z u (ε n)) (hε : Antitone ε)
+    (p α s : ℝ) (hs : 0 ≤ s) (ω : Ω) (n : ℕ)
+    (hn : s ≤ (a n).clock.S ((a n).τ ω) ω) :
+    limitRadiusKernel a p α s ω = (a n).radiusValue p α s ω := by
+  obtain ⟨m, hm, hlim⟩ := ((eventually_ge_atTop n).and (radiusKernel_eventually_limit a hε p α s ω)).exists
+  rw [max_eq_left hs] at hlim
+  rw [← hlim, ← (a n).radiusKernel_eq_of_live (a m) le_rfl (hε hm) p α s hs ω hn,
+    AngularLocalization.radiusKernel, ite_eq_left hn]
+
+lemma limitRadiusKernel_eq_below
+    (a : ∀ n, AngularLocalization B hm κ z u (ε n))
+    (b : ∀ n, AngularLocalization B hm κ z v (ε n)) (hε : Antitone ε)
+    (huv : u ≤ v) (p α s : ℝ) (hs : 0 ≤ s) (hsu : s ≤ u) (ω : Ω) :
+    limitRadiusKernel a p α s ω = limitRadiusKernel b p α s ω := by
+  obtain ⟨n, hn, hm⟩ := ((radiusKernel_eventually_limit a hε p α s ω).and
+    (radiusKernel_eventually_limit b hε p α s ω)).exists
+  rw [max_eq_left hs] at hn hm
+  rw [← hn, ← hm]
+  exact (a n).radiusKernel_eq_below (b n) huv p α s hs hsu ω
+
+lemma exists_cutoff_of_radiusStop_lt_top
+    (a : ∀ n, AngularLocalization B hm κ z u (ε n)) (ω : Ω)
+    (hω : localizedRadiusStop a ω < ⊤) : ∃ n, ω ∈ (a n).hit := by
+  by_contra hn
+  rw [localizedRadiusStop_eq_top a ω (not_exists.mp hn)] at hω
+  exact lt_irrefl _ hω
+
+lemma limitRadiusKernel_continuousOn_of_live
+    (a : ∀ n, AngularLocalization B hm κ z u (ε n)) (hε : Antitone ε)
+    (hBc : ∀ ω, Continuous (fun t => B t ω)) (p α : ℝ) (ω : Ω)
+    (hω : localizedRadiusStop a ω < ⊤) :
+    ContinuousOn (fun s => limitRadiusKernel a p α s ω) (Icc 0 u) := by
+  obtain ⟨n, hn⟩ := exists_cutoff_of_radiusStop_lt_top a ω hω
+  apply ((a n).radiusValue_continuous hBc p α ω).continuousOn.congr
+  intro s hs
+  exact limitRadiusKernel_eq_of_surviving_cutoff a hε p α s hs.1 ω n (hs.2.trans_eq hn.symm)
+
+lemma limitRadiusKernel_pos_of_live
+    (a : ∀ n, AngularLocalization B hm κ z u (ε n)) (hε : Antitone ε)
+    (p α s : ℝ) (hs : s ∈ Icc 0 u) (ω : Ω) (hω : localizedRadiusStop a ω < ⊤) :
+    0 < limitRadiusKernel a p α s ω := by
+  obtain ⟨n, hn⟩ := exists_cutoff_of_radiusStop_lt_top a ω hω
+  rw [limitRadiusKernel_eq_of_surviving_cutoff a hε p α s hs.1 ω n (hs.2.trans_eq hn.symm)]
+  exact powerLogDensity_pos _ _ _ _ _
+
+lemma radius_limit_clock_angle
+    (a : ∀ n, AngularLocalization B hm κ z u (ε n)) (hε : Antitone ε)
+    (p α s : ℝ) (hs : s ∈ Icc 0 u) (ω : Ω) (hω : localizedRadiusStop a ω < ⊤) :
+    limitRadiusKernel a p α s ω = Real.exp (p * (s - Real.log 2 - Real.log z.im)) *
+      (limitRadiusKernel a 0 2 s ω) ^ (α / 2) := by
+  obtain ⟨n, hn⟩ := exists_cutoff_of_radiusStop_lt_top a ω hω
+  have hs' : s ≤ (a n).clock.S ((a n).τ ω) ω := hs.2.trans_eq hn.symm
+  rw [limitRadiusKernel_eq_of_surviving_cutoff a hε p α s hs.1 ω n hs',
+    limitRadiusKernel_eq_of_surviving_cutoff a hε 0 2 s hs.1 ω n hs']
+  unfold AngularLocalization.radiusValue
+  rw [powerLogDensity_radius_angle κ p α (Real.log z.im),
+    powerLogDensity_radius_angle κ 0 2 (Real.log z.im)]
+  norm_num only [zero_mul, Real.exp_zero, one_mul, div_self (by norm_num : (2 : ℝ) ≠ 0), Real.rpow_one]
+  have he := (a n).clock.clock_inverse s ω
+  change (a n).clock.S ((a n).clock.inverse s ω) ω =
+    min (max s 0) ((a n).clock.S ((a n).τ ω) ω) at he
+  rw [max_eq_left hs.1, min_eq_left hs'] at he
+  change logRadiusClock (Real.log z.im)
+    ((a n).solution.Q ((a n).clock.inverse s ω) ω) = s at he
+  rw [he]
+
+end SLEExactGauge
+end
+
+ 
+section
+
+open Set MeasureTheory Classical
+open scoped ENNReal
+namespace SLEExactGauge
+
+lemma finite_grid_from_monotone
+    {Ω T : Type*} [MeasurableSpace Ω] [LinearOrder T]
+    (Q : Measure Ω) (E : T → Set Ω) (v U : T) (hvU : v ≤ U) (c : ℝ≥0∞)
+    (h : ∀ s : ℕ → T, Monotone s → (∀ n, v ≤ s n) → (∀ n, s n ≤ U) →
+      ∀ N, Q (⋃ i ∈ Finset.range N, E (s i)) ≤ c)
+    (t : Finset T) (ht : ∀ x ∈ t, x ∈ Icc v U) :
+    Q (⋃ x ∈ t, E x) ≤ c := by
+  let f := t.orderEmbOfFin rfl
+  let s (n : ℕ) : T := if hn : n < t.card then f ⟨n, hn⟩ else U
+  have hmem (i : Fin t.card) : f i ∈ t := t.orderEmbOfFin_mem rfl i
+  have hs : Monotone s := by
+    intro n m hnm
+    dsimp only [s]
+    split_ifs with hn hm hm
+    · exact f.monotone hnm
+    · exact (ht _ (hmem _)).2
+    · omega
+    · exact le_rfl
+  have hl (n : ℕ) : v ≤ s n := by
+    dsimp only [s]; split_ifs with hn
+    · exact (ht _ (hmem _)).1
+    · exact hvU
+  have hu (n : ℕ) : s n ≤ U := by
+    dsimp only [s]; split_ifs with hn
+    · exact (ht _ (hmem _)).2
+    · exact le_rfl
+  have he : (⋃ x ∈ t, E x) = ⋃ i ∈ Finset.range t.card, E (s i) := by
+    ext ω
+    simp only [mem_iUnion, Finset.mem_range]
+    constructor
+    · rintro ⟨x, hx, hω⟩
+      have hex : ∃ i, f i = x := by
+        change x ∈ Set.range f
+        rw [Finset.range_orderEmbOfFin]
+        exact hx
+      obtain ⟨i, rfl⟩ := hex
+      refine ⟨i.val, i.isLt, ?_⟩
+      simpa only [s, dite_eq_left i.isLt] using hω
+    · rintro ⟨i, hi, hω⟩
+      refine ⟨f ⟨i, hi⟩, hmem _, ?_⟩
+      simpa only [s, dite_eq_left hi] using hω
+  rw [he]
+  exact h s hs hl hu t.card
+
+lemma countable_grid_from_monotone
+    {Ω T : Type*} [MeasurableSpace Ω] [LinearOrder T]
+    (Q : Measure Ω) (E : T → Set Ω) (v U : T) (hvU : v ≤ U) (c : ℝ≥0∞)
+    (h : ∀ s : ℕ → T, Monotone s → (∀ n, v ≤ s n) → (∀ n, s n ≤ U) →
+      ∀ N, Q (⋃ i ∈ Finset.range N, E (s i)) ≤ c)
+    (s : ℕ → T) (hs : ∀ n, s n ∈ Icc v U) : Q (⋃ n, E (s n)) ≤ c := by
+  have hf (N : ℕ) : Q (⋃ i ∈ Finset.range N, E (s i)) ≤ c := by
+    have hh := finite_grid_from_monotone Q E v U hvU c h
+      ((Finset.range N).image s) (by simpa using (fun i (_ : i ∈ Finset.range N) => hs i))
+    simpa using hh
+  have he : (⋃ n, E (s n)) = ⋃ N, ⋃ i ∈ Finset.range N, E (s i) := by
+    ext ω
+    simp only [mem_iUnion, Finset.mem_range]
+    constructor
+    · rintro ⟨i, hi⟩; exact ⟨i+1, i, Nat.lt_succ_self i, hi⟩
+    · rintro ⟨N, i, _, hi⟩; exact ⟨i, hi⟩
+  have hmono : Monotone (fun N => ⋃ i ∈ Finset.range N, E (s i)) := by
+    intro n m hnm ω hω
+    obtain ⟨i, hi, hω⟩ := mem_iUnion₂.mp hω
+    exact mem_iUnion₂.mpr ⟨i, Finset.mem_range.mpr ((Finset.mem_range.mp hi).trans_le hnm), hω⟩
+  rw [he, hmono.measure_iUnion]
+  exact iSup_le hf
+
+end SLEExactGauge
+end
+
+ 
+section
+
+open Set MeasureTheory Classical TopologicalSpace
+open scoped ENNReal Topology NNReal
+namespace SLEExactGauge
+
+lemma continuous_crossing_from_monotone
+    {Ω : Type*} [MeasurableSpace Ω]
+    (Q : Measure Ω) (K : ℝ≥0 → Ω → ℝ) (live : Set Ω)
+    (v w U : ℝ≥0) (hvw : v ≤ w) (hwU : w ≤ U) (δ : ℝ) (c : ℝ≥0∞)
+    (hc : ∀ ω ∈ live, ContinuousOn (fun s => K s ω) (Icc v w))
+    (hp : ∀ ω ∈ live, ∀ s ∈ Icc v w, 0 < K s ω)
+    (h : ∀ s : ℕ → ℝ≥0, Monotone s → (∀ n, v ≤ s n) → (∀ n, s n ≤ U) →
+      ∀ N, Q (⋃ i ∈ Finset.range N, {ω | 0 < K (s i) ω ∧ K (s i) ω ≤ δ}) ≤ c) :
+    Q {ω | ω ∈ live ∧ ∃ s ∈ Icc v w, K s ω < δ} ≤ c := by
+  let T := ↥(Icc v w)
+  let : Nonempty T := ⟨⟨v, le_rfl, hvw⟩⟩
+  let s (n : ℕ) : ℝ≥0 := (denseSeq T n).val
+  have hs (n : ℕ) : s n ∈ Icc v U :=
+    ⟨(denseSeq T n).property.1, (denseSeq T n).property.2.trans hwU⟩
+  refine (measure_mono (show {ω | ω ∈ live ∧ ∃ s ∈ Icc v w, K s ω < δ} ⊆
+    ⋃ n, {ω | 0 < K (s n) ω ∧ K (s n) ω ≤ δ} from ?_)).trans
+    (countable_grid_from_monotone Q (fun s => {ω | 0 < K s ω ∧ K s ω ≤ δ})
+      v U (hvw.trans hwU) c h s hs)
+  intro ω hω
+  have hcont : Continuous (fun t : T => K t.val ω) :=
+    (hc ω hω.1).domRestrict
+  obtain ⟨t, ht, hlt⟩ := hω.2
+  obtain ⟨n, hn⟩ := (denseRange_denseSeq T).exists_mem_open
+    (isOpen_lt hcont continuous_const) ⟨⟨t, ht⟩, hlt⟩
+  exact mem_iUnion.mpr ⟨n, hp ω hω.1 _ (denseSeq T n).property, hn.le⟩
+
+end SLEExactGauge
+end
+
+ 
+section
+
+open Set Filter MeasureTheory ProbabilityTheory Classical
+open scoped Topology NNReal ENNReal
+namespace SLEExactGauge
+variable {Ω : Type*} [mΩ : MeasurableSpace Ω]
+  {B : ℝ≥0 → Ω → ℝ} {hm : ∀ t, Measurable (B t)}
+  {κ : ℝ} {z : ℂ} {ε : ℕ → ℝ}
+
+lemma terminalRadiusKernel_continuousOn
+    (a : ∀ u : ℝ≥0, ∀ n, AngularLocalization B hm κ z u (ε n)) (hε : Antitone ε)
+    (hBc : ∀ ω, Continuous (fun t => B t ω)) (p α : ℝ)
+    (U : ℝ≥0) (ω : Ω) (hω : localizedRadiusStop (a U) ω < ⊤) :
+    ContinuousOn (fun s : ℝ≥0 => limitRadiusKernel (a s) p α s ω) (Icc 0 U) := by
+  have he (s : ℝ≥0) (hs : s ∈ Icc 0 U) :
+      limitRadiusKernel (a s) p α s ω = limitRadiusKernel (a U) p α s ω :=
+    limitRadiusKernel_eq_below (a s) (a U) hε (show (s : ℝ) ≤ U from hs.2) p α s
+      s.coe_nonneg le_rfl ω
+  have hc := (limitRadiusKernel_continuousOn_of_live (a U) hε hBc p α ω hω).comp
+    continuous_subtype_val.continuousOn (show MapsTo (fun s : ℝ≥0 => (s : ℝ)) (Icc 0 U) (Icc 0 (U : ℝ)) from
+      fun s hs => ⟨s.coe_nonneg, hs.2⟩)
+  exact hc.congr he
+
+lemma terminalRadiusKernel_pos
+    (a : ∀ u : ℝ≥0, ∀ n, AngularLocalization B hm κ z u (ε n)) (hε : Antitone ε)
+    (p α : ℝ) (U s : ℝ≥0) (hs : s ≤ U) (ω : Ω)
+    (hω : localizedRadiusStop (a U) ω < ⊤) :
+    0 < limitRadiusKernel (a s) p α s ω := by
+  rw [limitRadiusKernel_eq_below (a s) (a U) hε (show (s : ℝ) ≤ U from hs) p α s
+    s.coe_nonneg le_rfl ω]
+  exact limitRadiusKernel_pos_of_live (a U) hε p α s ⟨s.coe_nonneg, hs⟩ ω hω
+
+lemma continuous_radius_scaled_crossing
+    {P : Measure Ω} [IsProbabilityMeasure P]
+    (hB : IsBrownianReal B P)
+    (hBm : Measurable (fun q : ℝ≥0 × Ω => B q.1 q.2))
+    (hBc : ∀ ω, Continuous (fun t => B t ω)) (hB0 : ∀ ω, B 0 ω = 0)
+    (hκ : 0 < κ) (hκ8 : κ < 8)
+    (γ : Ω → ℝ≥0 → ℂ) (G F : Ω → ℝ≥0 → ℂ → ℂ)
+    (hw : ∀ᵐ ω ∂P, IsCapacityTwoWitness
+      (fun t => Real.sqrt κ * B t ω) (γ ω) (G ω) (F ω))
+    (hz : z ∈ upperHalfPlane)
+    (a : ∀ u : ℝ≥0, ∀ n, AngularLocalization B hm κ z u (ε n))
+    (hε : Antitone ε) (hεlim : Tendsto ε atTop (𝓝 0))
+    (v w U : ℝ≥0) (hv : 1 ≤ (v : ℝ)) (hvw : v ≤ w) (hwU : w ≤ U)
+    (L : ℝ) (hL : 0 < L) :
+    finiteCenteredLaw P κ B γ G z U
+      {ω | localizedRadiusStop (a U) ω < ⊤ ∧ ∃ s ∈ Icc v w,
+        limitRadiusKernel (a s) (codimension κ) (greenExponent κ) s ω <
+          Real.exp (codimension κ * ((w : ℝ) - Real.log 2 - Real.log z.im)) / L} ≤
+      ENNReal.ofReal (uniformInverseAngleConstant κ 1 * Real.exp (codimension κ * ((w : ℝ) - v)) / L) := by
+  apply continuous_crossing_from_monotone _ _ _ v w U hvw hwU
+  · intro ω hω
+    exact (terminalRadiusKernel_continuousOn a hε hBc _ _ U ω hω).mono
+      (Icc_subset_Icc (show (0 : ℝ≥0) ≤ v from bot_le) hwU)
+  · intro ω hω s hs
+    exact terminalRadiusKernel_pos a hε _ _ U s (hs.2.trans hwU) ω hω
+  · intro s hs hvs hsU N
+    exact finite_radius_scaled_crossing hB hBm hBc hB0 hκ hκ8 γ G F hw hz
+      a hε hεlim v U hv s hs hvs hsU w L hL N
+
+end SLEExactGauge
+end
+
+ 
+section
+
+open Set Filter MeasureTheory ProbabilityTheory Classical
+open scoped Topology NNReal ENNReal
+namespace SLEExactGauge
+variable {Ω : Type*} [mΩ : MeasurableSpace Ω]
+  {B : ℝ≥0 → Ω → ℝ} {hm : ∀ t, Measurable (B t)}
+  {κ : ℝ} {z : ℂ} {ε : ℕ → ℝ}
+
+noncomputable def radiusInverseAngle
+    (a : ∀ u : ℝ≥0, ∀ n, AngularLocalization B hm κ z u (ε n))
+    (s : ℝ≥0) (ω : Ω) : ℝ :=
+  (limitRadiusKernel (a s) 0 2 s ω) ^ (-greenExponent κ / 2)
+
+lemma radiusInverseAngle_product
+    (a : ∀ u : ℝ≥0, ∀ n, AngularLocalization B hm κ z u (ε n)) (hε : Antitone ε)
+    (s : ℝ≥0) (ω : Ω) (hω : localizedRadiusStop (a s) ω < ⊤) :
+    limitRadiusKernel (a s) (codimension κ) (greenExponent κ) s ω * radiusInverseAngle a s ω =
+      Real.exp (codimension κ * ((s : ℝ) - Real.log 2 - Real.log z.im)) := by
+  rw [radiusInverseAngle, ← limitRadiusKernel_inverse_factor (a s) hε, sub_self,
+    radius_limit_clock_angle (a s) hε (codimension κ) 0 s ⟨s.coe_nonneg, le_rfl⟩ ω hω]
+  simp
+
+lemma radiusInverseAngle_large_imp_crossing
+    (a : ∀ u : ℝ≥0, ∀ n, AngularLocalization B hm κ z u (ε n)) (hε : Antitone ε)
+    (hκ8 : κ < 8) (s w U : ℝ≥0) (hsw : s ≤ w) (hwU : w ≤ U)
+    (L : ℝ) (hL : 0 < L) (ω : Ω) (hω : localizedRadiusStop (a U) ω < ⊤)
+    (hV : L < radiusInverseAngle a s ω) :
+    limitRadiusKernel (a s) (codimension κ) (greenExponent κ) s ω <
+      Real.exp (codimension κ * ((w : ℝ) - Real.log 2 - Real.log z.im)) / L := by
+  have hls : localizedRadiusStop (a s) ω < ⊤ :=
+    lt_of_le_of_lt (localizedRadiusStop_mono (a s) (a U) (show (s : ℝ) ≤ U from hsw.trans hwU) ω) hω
+  have hK := terminalRadiusKernel_pos a hε (codimension κ) (greenExponent κ) U s (hsw.trans hwU) ω hω
+  apply (lt_div_iff₀ hL).mpr
+  calc
+    _ < limitRadiusKernel (a s) (codimension κ) (greenExponent κ) s ω * radiusInverseAngle a s ω :=
+      mul_lt_mul_of_pos_left hV hK
+    _ = Real.exp (codimension κ * ((s : ℝ) - Real.log 2 - Real.log z.im)) :=
+      radiusInverseAngle_product a hε s ω hls
+    _ ≤ _ := Real.exp_le_exp.mpr (mul_le_mul_of_nonneg_left (sub_le_sub_right (sub_le_sub_right (show (s : ℝ) ≤ w from hsw) _) _) (codimension_pos κ hκ8).le)
+
+lemma inverse_angle_window_bound
+    {P : Measure Ω} [IsProbabilityMeasure P]
+    (hB : IsBrownianReal B P)
+    (hBm : Measurable (fun q : ℝ≥0 × Ω => B q.1 q.2))
+    (hBc : ∀ ω, Continuous (fun t => B t ω)) (hB0 : ∀ ω, B 0 ω = 0)
+    (hκ : 0 < κ) (hκ8 : κ < 8)
+    (γ : Ω → ℝ≥0 → ℂ) (G F : Ω → ℝ≥0 → ℂ → ℂ)
+    (hw : ∀ᵐ ω ∂P, IsCapacityTwoWitness
+      (fun t => Real.sqrt κ * B t ω) (γ ω) (G ω) (F ω))
+    (hz : z ∈ upperHalfPlane)
+    (a : ∀ u : ℝ≥0, ∀ n, AngularLocalization B hm κ z u (ε n))
+    (hε : Antitone ε) (hεlim : Tendsto ε atTop (𝓝 0))
+    (v w U : ℝ≥0) (hv : 1 ≤ (v : ℝ)) (hvw : v ≤ w) (hwU : w ≤ U)
+    (L : ℝ) (hL : 0 < L) :
+    finiteCenteredLaw P κ B γ G z U
+      {ω | localizedRadiusStop (a U) ω < ⊤ ∧ ∃ s ∈ Icc v w, L < radiusInverseAngle a s ω} ≤
+      ENNReal.ofReal (uniformInverseAngleConstant κ 1 * Real.exp (codimension κ * ((w : ℝ) - v)) / L) := by
+  refine (measure_mono (s := {ω | localizedRadiusStop (a U) ω < ⊤ ∧ ∃ s ∈ Icc v w, L < radiusInverseAngle a s ω})
+    (t := {ω | localizedRadiusStop (a U) ω < ⊤ ∧ ∃ s ∈ Icc v w,
+      limitRadiusKernel (a s) (codimension κ) (greenExponent κ) s ω <
+        Real.exp (codimension κ * ((w : ℝ) - Real.log 2 - Real.log z.im)) / L}) ?_).trans
+    (continuous_radius_scaled_crossing hB hBm hBc hB0 hκ hκ8 γ G F hw hz a hε hεlim
+      v w U hv hvw hwU L hL)
+  rintro ω ⟨hω, s, hs, hV⟩
+  exact ⟨hω, s, hs, radiusInverseAngle_large_imp_crossing a hε hκ8 s w U hs.2 hwU L hL ω hω hV⟩
+
+end SLEExactGauge
+end
+
+ 
+section
+
+open Set Filter MeasureTheory ProbabilityTheory Classical
+open scoped Topology NNReal ENNReal
+namespace SLEExactGauge
+variable {Ω : Type*} [mΩ : MeasurableSpace Ω]
+  {B : ℝ≥0 → Ω → ℝ} {hm : ∀ t, Measurable (B t)}
+  {κ : ℝ} {z : ℂ} {ε : ℕ → ℝ}
+
+end SLEExactGauge
+end
+end
+
+end OAI

lean/OAI/Probability/SLE/MomentGauge.lean

@@ -1,802 +1,802 @@
-import Mathlib
-
-namespace OAI
-
-/-! Quadratic moment envelopes, Hausdorff gauge admissibility and interval transfer. -/
-
-universe u
-
-noncomputable section
-open MeasureTheory Set Filter Metric
-open scoped NNReal ENNReal Topology
-
-namespace SLEExactGauge.Target
-
-open scoped ContinuousMapZero
-abbrev Driver := C(ℝ≥0, ℝ)₀
-instance : MeasurableSpace Driver := borel Driver
-instance : BorelSpace Driver := ⟨rfl⟩
-abbrev WienerLaw := Measure Driver
-
-def IsWiener (W : WienerLaw) : Prop :=
-  ProbabilityTheory.IsBrownianReal (fun t b => b t) W
-
-def a (κ : ℝ) := 2 / κ
-def d (κ : ℝ) := 1 + 1 / (4 * a κ)
-def α (κ : ℝ) := 2 - d κ
-def p (κ : ℝ) := 4 * a κ - 1
-
-def driverValue (b : Driver) (t : ℝ) : ℝ := b t.toNNReal
-
-def cutoffField (κ : ℝ) (b : Driver) (j : ℕ) (t : ℝ) (z : ℂ) : ℂ :=
-  (a κ : ℂ) * star (z - driverValue b t) /
-    (max (‖z - driverValue b t‖ ^ 2) ((j : ℝ) ^ (-(4 : ℤ))) : ℝ)
-
-def mesh (N : ℕ) : ℝ := (2 : ℝ) ^ (-(N : ℤ))
-
-def eulerSteps (κ : ℝ) (b : Driver) (j N : ℕ) (z : ℂ) : ℕ → ℂ
-  | 0 => z
-  | k + 1 => eulerSteps κ b j N z k +
-      mesh N * cutoffField κ b j ((k : ℝ) * mesh N) (eulerSteps κ b j N z k)
-
-def eulerFlow (κ : ℝ) (b : Driver) (j N : ℕ) (z : ℂ) (t : ℝ) : ℂ :=
-  let k := ⌊t / mesh N⌋₊
-  let w :=  t / mesh N - (k : ℝ)
-  (1 - w : ℝ) * eulerSteps κ b j N z k + w * eulerSteps κ b j N z (k + 1)
-
-def cutoffFlow (κ : ℝ) (b : Driver) (j : ℕ) (z : ℂ) (t : ℝ) : ℂ :=
-  limUnder atTop (fun N : ℕ => eulerFlow κ b j N z t)
-
-def Surviving (κ : ℝ) (b : Driver) (z : ℂ) (t : ℝ) : Prop :=
-  ∃ j : ℕ, 1 ≤ j ∧ (j : ℝ)⁻¹ <
-    sInf ((fun u : ℝ => (cutoffFlow κ b j z u).im) '' Icc 0 t)
-
-instance (κ : ℝ) (b : Driver) (z : ℂ) (t : ℝ) : Decidable (Surviving κ b z t) :=
-  Classical.propDecidable _
-
-def flow (κ : ℝ) (b : Driver) (z : ℂ) (t : ℝ) : ℂ :=
-  if h : Surviving κ b z t then cutoffFlow κ b (Nat.find h) z t else 0
-
-def IsHausdorffGauge (h : ℝ → ℝ) : Prop :=
-  ContinuousOn h (Ici 0) ∧ MonotoneOn h (Ici 0) ∧ h 0 = 0 ∧ ∀ r > 0, 0 < h r
-
-def hausdorff (h : ℝ → ℝ) : OuterMeasure ℂ :=
-  OuterMeasure.mkMetric (fun r => if r = ∞ then ∞ else ENNReal.ofReal (h r.toReal))
-
-def inverseFlow (κ : ℝ) (b : Driver) (t : ℝ) (w : ℂ) : ℂ :=
-  @ite ℂ (∃ z : ℂ, Surviving κ b z t ∧ flow κ b z t = w) (Classical.propDecidable _)
-    (Classical.epsilon (fun z : ℂ => Surviving κ b z t ∧ flow κ b z t = w)) 0
-
-def trace (κ : ℝ) (b : Driver) (t : ℝ) : ℂ :=
-  limUnder (nhdsWithin 0 (Ioi 0)) (fun ε : ℝ =>
-    inverseFlow κ b (κ * t) (driverValue b (κ * t) + ε * Complex.I))
-
-def IsChordalSLE {Ω : Type*} [MeasurableSpace Ω] (κ : ℝ)
-    (γ : Ω → ℝ → ℂ) (P : Measure Ω) : Prop :=
-  ∃ (W : WienerLaw) (B : Ω → Driver),
-    IsWiener W ∧ ProbabilityTheory.HasLaw B W P ∧
-      ∀ᵐ ω ∂P, ∀ t : ℝ, 0 ≤ t → γ ω t = trace κ (B ω) t
-
-end SLEExactGauge.Target
-
-namespace SLEExactGauge.QuadraticEnvelope
-
-variable {ι : Type*}
-
-def profile (b R : ι → ℝ) (d : ℝ) (i : ι) (r : ℝ) : ℝ :=
-  b i * R i ^ d * max 1 ((r / R i) ^ 2)
-
-def full (b R : ι → ℝ) (d : ℝ) (r : ℝ) : ℝ :=
-  if r ≤ 0 then 0 else sInf (range (fun i => profile b R d i r))
-
-variable {b R : ι → ℝ} {d : ℝ}
-
-lemma profile_nonneg (hb : ∀ i, 0 ≤ b i) (hR : ∀ i, 0 < R i)
-    (i : ι) (r : ℝ) : 0 ≤ profile b R d i r := by
-  unfold profile
-  exact mul_nonneg (mul_nonneg (hb i) (Real.rpow_nonneg (hR i).le d))
-    (le_trans zero_le_one (le_max_left _ _))
-
-lemma base_le_profile (hb : ∀ i, 0 ≤ b i) (hR : ∀ i, 0 < R i)
-    (i : ι) (r : ℝ) : b i * R i ^ d ≤ profile b R d i r := by
-  unfold profile
-  exact le_mul_of_one_le_right
-    (mul_nonneg (hb i) (Real.rpow_nonneg (hR i).le d)) (le_max_left _ _)
-
-lemma profile_mono (hb : ∀ i, 0 ≤ b i) (hR : ∀ i, 0 < R i)
-    (i : ι) {r s : ℝ} (hr : 0 ≤ r) (hrs : r ≤ s) :
-    profile b R d i r ≤ profile b R d i s := by
-  apply mul_le_mul_of_nonneg_left _
-    (mul_nonneg (hb i) (Real.rpow_nonneg (hR i).le d))
-  exact max_le_max_left _ <| pow_le_pow_left₀ (div_nonneg hr (hR i).le)
-    (div_le_div_of_nonneg_right hrs (hR i).le) 2
-
-lemma profile_scale_le (hb : ∀ i, 0 ≤ b i) (hR : ∀ i, 0 < R i)
-    (i : ι) {C : ℝ} (hC : 1 ≤ C) (r : ℝ) :
-    profile b R d i (C * r) ≤ C ^ 2 * profile b R d i r := by
-  have hC2 : 1 ≤ C ^ 2 := by nlinarith
-  have hmax : max 1 (((C * r) / R i) ^ 2) ≤
-      C ^ 2 * max 1 ((r / R i) ^ 2) := by
-    apply max_le
-    · exact hC2.trans <| le_mul_of_one_le_right (sq_nonneg C) (le_max_left _ _)
-    · calc
-        (((C * r) / R i) ^ 2) = C ^ 2 * (r / R i) ^ 2 := by ring
-        _ ≤ C ^ 2 * max 1 ((r / R i) ^ 2) :=
-          mul_le_mul_of_nonneg_left (le_max_right _ _) (sq_nonneg C)
-  unfold profile
-  calc
-    _ ≤ b i * R i ^ d * (C ^ 2 * max 1 ((r / R i) ^ 2)) :=
-      mul_le_mul_of_nonneg_left hmax
-        (mul_nonneg (hb i) (Real.rpow_nonneg (hR i).le d))
-    _ = _ := by ring
-
-@[simp] lemma full_zero : full b R d 0 = 0 := by simp [full]
-
-lemma full_of_nonpos {r : ℝ} (hr : r ≤ 0) : full b R d r = 0 := by
-  simp [full, hr]
-
-lemma full_of_pos {r : ℝ} (hr : 0 < r) :
-    full b R d r = sInf (range (fun i => profile b R d i r)) := by
-  simp [full, hr.not_ge]
-
-lemma profiles_bddBelow (hb : ∀ i, 0 ≤ b i) (hR : ∀ i, 0 < R i)
-    (r : ℝ) : BddBelow (range (fun i => profile b R d i r)) := by
-  refine ⟨0, ?_⟩
-  rintro _ ⟨i, rfl⟩
-  exact profile_nonneg hb hR i r
-
-variable [Nonempty ι]
-
-lemma le_full {r v : ℝ} (hr : 0 < r)
-    (hv : ∀ i, v ≤ profile b R d i r) : v ≤ full b R d r := by
-  rw [full_of_pos hr]
-  exact le_csInf (range_nonempty _) (by rintro _ ⟨i, rfl⟩; exact hv i)
-
-lemma full_nonneg (hb : ∀ i, 0 ≤ b i) (hR : ∀ i, 0 < R i)
-    (r : ℝ) : 0 ≤ full b R d r := by
-  by_cases hr : r ≤ 0
-  · rw [full_of_nonpos hr]
-  · exact le_full (lt_of_not_ge hr) (fun i => profile_nonneg hb hR i r)
-
-omit [Nonempty ι] in
-lemma full_le_profile (hb : ∀ i, 0 ≤ b i) (hR : ∀ i, 0 < R i)
-    (i : ι) (r : ℝ) : full b R d r ≤ profile b R d i r := by
-  by_cases hr : r ≤ 0
-  · rw [full_of_nonpos hr]
-    exact profile_nonneg hb hR i r
-  · rw [full_of_pos (lt_of_not_ge hr)]
-    exact csInf_le (profiles_bddBelow hb hR r) (mem_range_self i)
-
-lemma full_monoOn (hb : ∀ i, 0 ≤ b i) (hR : ∀ i, 0 < R i) :
-    MonotoneOn (full b R d) (Ici 0) := by
-  intro r hr s hs hrs
-  by_cases hr0 : r ≤ 0
-  · rw [full_of_nonpos hr0]
-    exact full_nonneg hb hR s
-  · have hrpos := lt_of_not_ge hr0
-    apply le_full (hrpos.trans_le hrs)
-    intro i
-    exact (full_le_profile hb hR i r).trans (profile_mono hb hR i hr hrs)
-
-theorem full_scale_le (hb : ∀ i, 0 ≤ b i) (hR : ∀ i, 0 < R i)
-    {C r : ℝ} (hC : 1 ≤ C) (hr : 0 ≤ r) :
-    full b R d (C * r) ≤ C ^ 2 * full b R d r := by
-  obtain rfl | hrpos := hr.eq_or_lt
-  · simp
-  have hCpos : 0 < C := zero_lt_one.trans_le hC
-  have hC2 : 0 < C ^ 2 := sq_pos_of_pos hCpos
-  have h : full b R d (C * r) / C ^ 2 ≤ full b R d r := by
-    apply le_full hrpos
-    intro i
-    apply (div_le_iff₀ hC2).2
-    calc
-      full b R d (C * r) ≤ profile b R d i (C * r) := full_le_profile hb hR i _
-      _ ≤ C ^ 2 * profile b R d i r := profile_scale_le hb hR i hC r
-      _ = profile b R d i r * C ^ 2 := mul_comm _ _
-  simpa [mul_comm] using (div_le_iff₀ hC2).1 h
-
-lemma power_lower_bound {c r : ℝ} (hc : 0 < c) (hb : ∀ i, c ≤ b i)
-    (hR : ∀ i, 0 < R i) (hd0 : 0 ≤ d) (hd2 : d ≤ 2) (hr : 0 < r) :
-    c * r ^ d ≤ full b R d r := by
-  apply le_full hr
-  intro i
-  have hshape : r ^ d ≤ R i ^ d * max 1 ((r / R i) ^ 2) := by
-    rcases le_total r (R i) with hsmall | hlarge
-    · exact (Real.rpow_le_rpow hr.le hsmall hd0).trans <|
-        le_mul_of_one_le_right (Real.rpow_nonneg (hR i).le d) (le_max_left _ _)
-    · have hratio : 1 ≤ r / R i := (le_div_iff₀ (hR i)).2 (by simpa using hlarge)
-      have hp : (r / R i) ^ d ≤ (r / R i) ^ 2 := by
-        exact_mod_cast Real.rpow_le_rpow_of_exponent_le hratio hd2
-      calc
-        r ^ d = R i ^ d * (r / R i) ^ d := by
-          rw [← Real.mul_rpow (hR i).le (div_nonneg hr.le (hR i).le)]
-          congr 1
-          field_simp [(hR i).ne']
-        _ ≤ R i ^ d * (r / R i) ^ 2 :=
-          mul_le_mul_of_nonneg_left hp (Real.rpow_nonneg (hR i).le d)
-        _ ≤ R i ^ d * max 1 ((r / R i) ^ 2) :=
-          mul_le_mul_of_nonneg_left (le_max_right _ _) (Real.rpow_nonneg (hR i).le d)
-  calc
-    c * r ^ d ≤ b i * r ^ d := mul_le_mul_of_nonneg_right (hb i) (Real.rpow_nonneg hr.le d)
-    _ ≤ b i * (R i ^ d * max 1 ((r / R i) ^ 2)) :=
-      mul_le_mul_of_nonneg_left hshape (hc.le.trans (hb i))
-    _ = profile b R d i r := by rw [profile]; ring
-
-lemma full_pos {c r : ℝ} (hc : 0 < c) (hb : ∀ i, c ≤ b i)
-    (hR : ∀ i, 0 < R i) (hd0 : 0 ≤ d) (hd2 : d ≤ 2) (hr : 0 < r) :
-    0 < full b R d r :=
-  (mul_pos hc (Real.rpow_pos_of_pos hr d)).trans_le
-    (power_lower_bound hc hb hR hd0 hd2 hr)
-
-lemma ratio_bounds (hb : ∀ i, 0 ≤ b i) (hR : ∀ i, 0 < R i)
-    {r s : ℝ} (hr : 0 < r) (hs : 0 < s) :
-    min 1 ((s / r) ^ 2) * full b R d r ≤ full b R d s ∧
-      full b R d s ≤ max 1 ((s / r) ^ 2) * full b R d r := by
-  have hmono := full_monoOn (d := d) hb hR
-  have hnonneg := full_nonneg (d := d) hb hR r
-  constructor
-  · rcases le_total r s with hrs | hsr
-    · calc
-        _ ≤ 1 * full b R d r := mul_le_mul_of_nonneg_right (min_le_left _ _) hnonneg
-        _ = full b R d r := one_mul _
-        _ ≤ full b R d s := hmono hr.le hs.le hrs
-    · have hC : 1 ≤ r / s := (le_div_iff₀ hs).2 (by simpa using hsr)
-      have hscale := full_scale_le (d := d) hb hR hC hs.le
-      rw [div_mul_cancel₀ r hs.ne'] at hscale
-      calc
-        _ ≤ (s / r) ^ 2 * full b R d r :=
-          mul_le_mul_of_nonneg_right (min_le_right _ _) hnonneg
-        _ ≤ (s / r) ^ 2 * ((r / s) ^ 2 * full b R d s) :=
-          mul_le_mul_of_nonneg_left hscale (sq_nonneg _)
-        _ = full b R d s := by field_simp
-  · rcases le_total s r with hsr | hrs
-    · exact (hmono hs.le hr.le hsr).trans <| by
-        simpa using mul_le_mul_of_nonneg_right (le_max_left 1 ((s / r) ^ 2)) hnonneg
-    · have hC : 1 ≤ s / r := (le_div_iff₀ hr).2 (by simpa using hrs)
-      have hscale := full_scale_le (d := d) hb hR hC hr.le
-      rw [div_mul_cancel₀ s hr.ne'] at hscale
-      exact hscale.trans <| mul_le_mul_of_nonneg_right (le_max_right _ _) hnonneg
-
-lemma continuousAt_pos (hb : ∀ i, 0 ≤ b i) (hR : ∀ i, 0 < R i)
-    {r : ℝ} (hr : 0 < r) : ContinuousAt (full b R d) r := by
-  have hlow : ContinuousAt (fun s : ℝ => min 1 ((s / r) ^ 2) * full b R d r) r := by
-    fun_prop
-  have hupp : ContinuousAt (fun s : ℝ => max 1 ((s / r) ^ 2) * full b R d r) r := by
-    fun_prop
-  apply tendsto_of_tendsto_of_tendsto_of_le_of_le'
-    (by simpa [hr.ne'] using hlow.tendsto)
-    (by simpa [hr.ne'] using hupp.tendsto)
-  · filter_upwards [Ioi_mem_nhds hr] with s hs
-    exact (ratio_bounds hb hR hr hs).1
-  · filter_upwards [Ioi_mem_nhds hr] with s hs
-    exact (ratio_bounds hb hR hr hs).2
-
-lemma continuousAt_zero (hb : ∀ i, 0 ≤ b i) (hR : ∀ i, 0 < R i)
-    (hsmall : ∀ ε > 0, ∃ i, b i * R i ^ d < ε) :
-    ContinuousAt (full b R d) 0 := by
-  rw [Metric.continuousAt_iff]
-  intro ε hε
-  obtain ⟨i, hi⟩ := hsmall ε hε
-  refine ⟨R i, hR i, ?_⟩
-  intro x hx
-  rw [full_zero, Real.dist_eq, sub_zero, abs_of_nonneg (full_nonneg hb hR x)]
-  by_cases hx0 : x ≤ 0
-  · rw [full_of_nonpos hx0]
-    exact hε
-  · have hxpos : 0 < x := lt_of_not_ge hx0
-    have hxr : x < R i := by
-      simpa [Real.dist_eq, abs_of_pos hxpos] using hx
-    have hratio : 0 ≤ x / R i := div_nonneg hxpos.le (hR i).le
-    have hratio1 : x / R i ≤ 1 := (div_le_one (hR i)).2 hxr.le
-    have hp : (x / R i) ^ 2 ≤ 1 := by
-      simpa using (pow_le_pow_left₀ hratio hratio1 2)
-    calc
-      full b R d x ≤ profile b R d i x := full_le_profile hb hR i x
-      _ = b i * R i ^ d := by simp [profile, max_eq_left hp]
-      _ < ε := hi
-
-theorem isHausdorffGauge {c : ℝ} (hc : 0 < c) (hb : ∀ i, c ≤ b i)
-    (hR : ∀ i, 0 < R i) (hd0 : 0 ≤ d) (hd2 : d ≤ 2)
-    (hsmall : ∀ ε > 0, ∃ i, b i * R i ^ d < ε) :
-    SLEExactGauge.Target.IsHausdorffGauge (full b R d) := by
-  have hb0 : ∀ i, 0 ≤ b i := fun i => hc.le.trans (hb i)
-  refine ⟨?_, full_monoOn hb0 hR, full_zero, fun r hr => full_pos hc hb hR hd0 hd2 hr⟩
-  intro r hr
-  obtain rfl | hrpos := (show 0 ≤ r from hr).eq_or_lt
-  · exact (continuousAt_zero hb0 hR hsmall).continuousWithinAt
-  · exact (continuousAt_pos hb0 hR hrpos).continuousWithinAt
-
-theorem restore_finite (hb : ∀ i, 0 < b i) (hR : ∀ i, 0 < R i)
-    (discarded : Finset ι) (F : ℝ → ℝ) {M C : ℝ} (hM : 0 ≤ M)
-    (hbound : ∀ r > 0, F r ≤ M)
-    (htail : ∀ i, i ∉ discarded → ∀ r > 0, F r ≤ C * profile b R d i r) :
-    ∃ C' : ℝ, 0 < C' ∧ ∀ r > 0, F r ≤ C' * full b R d r := by
-  let C' := max C 0 + 1 + ∑ i ∈ discarded, M / (b i * R i ^ d)
-  have hbase : ∀ i, 0 < b i * R i ^ d :=
-    fun i => mul_pos (hb i) (Real.rpow_pos_of_pos (hR i) d)
-  have hterm : ∀ i, 0 ≤ M / (b i * R i ^ d) :=
-    fun i => div_nonneg hM (hbase i).le
-  have hsum : 0 ≤ ∑ i ∈ discarded, M / (b i * R i ^ d) :=
-    Finset.sum_nonneg (fun i _ => hterm i)
-  have hC' : 0 < C' := by
-    dsimp [C']
-    linarith [le_max_right C 0]
-  have hCC' : C ≤ C' := by
-    dsimp [C']
-    linarith [le_max_left C 0]
-  have hall : ∀ r > 0, ∀ i, F r ≤ C' * profile b R d i r := by
-    intro r hr i
-    by_cases hi : i ∈ discarded
-    · have hi_le : M / (b i * R i ^ d) ≤ C' := by
-        have hh := Finset.single_le_sum (fun i (_ : i ∈ discarded) => hterm i) hi
-        dsimp [C']
-        linarith [le_max_right C 0]
-      calc
-        F r ≤ M := hbound r hr
-        _ ≤ C' * (b i * R i ^ d) := (div_le_iff₀ (hbase i)).1 hi_le
-        _ ≤ C' * profile b R d i r := mul_le_mul_of_nonneg_left
-          (base_le_profile (fun i => (hb i).le) hR i r) hC'.le
-    · exact (htail i hi r hr).trans <| mul_le_mul_of_nonneg_right hCC'
-        (profile_nonneg (fun i => (hb i).le) hR i r)
-  refine ⟨C', hC', fun r hr => ?_⟩
-  have h : F r / C' ≤ full b R d r := by
-    apply le_full hr
-    intro i
-    exact (div_le_iff₀ hC').2 (by simpa [mul_comm] using hall r hr i)
-  simpa [mul_comm] using (div_le_iff₀ hC').1 h
-
-end SLEExactGauge.QuadraticEnvelope
-
-namespace SLEExactGauge.Target
-
-def diskMap (θ : ℝ) (z : ℂ) : ℂ :=
-  (z - Complex.exp (θ * Complex.I)) / (z - Complex.exp (-θ * Complex.I))
-
-def diskMapInv (θ : ℝ) (x : ℂ) : ℂ :=
-  (Complex.exp (θ * Complex.I) - x * Complex.exp (-θ * Complex.I)) / (1 - x)
-
-def centeredFlow (κ : ℝ) (b : Driver) (z : ℂ) (t : ℝ) : ℂ :=
-  flow κ b z t - driverValue b t
-
-def clock (κ θ : ℝ) (b : Driver) (x : ℂ) (t : ℝ) : ℝ :=
-  ∫ u in Icc (0 : ℝ) t,
-    (flow κ b (diskMapInv θ x) u).im ^ 2 /
-      ‖centeredFlow κ b (diskMapInv θ x) u‖ ^ 4
-
-def initialRadius (θ : ℝ) (x : ℂ) : ℝ :=
-  2 * (diskMapInv θ x).im * ‖deriv (diskMap θ) (diskMapInv θ x)‖
-
-def radius (κ θ : ℝ) (b : Driver) (x : ℂ) (t : ℝ) : ℝ :=
-  initialRadius θ x * Real.exp (-2 * a κ * clock κ θ b x t)
-
-def angle (κ θ : ℝ) (b : Driver) (x : ℂ) (t : ℝ) : ℝ :=
-  Complex.arg (centeredFlow κ b (diskMapInv θ x) t)
-
-def green (κ θ : ℝ) (b : Driver) (x : ℂ) (t : ℝ) : ℝ :=
-  if Surviving κ b (diskMapInv θ x) t then
-    radius κ θ b x t ^ (-α κ) * Real.sin (angle κ θ b x t) ^ p κ
-  else 0
-
-def levelTime (κ θ : ℝ) (b : Driver) (ℓ : ℝ) : ℝ≥0∞ :=
-  sInf {t | ∃ q : ℚ, 0 < q ∧ t = ENNReal.ofReal (q : ℝ) ∧
-    Surviving κ b (diskMapInv θ 0) q ∧ ℓ < clock κ θ b 0 q}
-
-def diskK : Set ℂ := closedBall 0 (1 / 4)
-
-def potential (κ θ : ℝ) (b : Driver) (t : ℝ) : ℝ≥0∞ :=
-  ∫⁻ x in diskK, ENNReal.ofReal (green κ θ b x t)
-
-def concat (b c : Driver) (t : ℝ) : Driver where
-  toFun u := if u ≤ t.toNNReal then b u else b t.toNNReal + c (u - t.toNNReal)
-  continuous_toFun := by
-    apply Continuous.if_le (map_continuous b)
-      (continuous_const.add ((map_continuous c).comp (continuous_id.sub continuous_const)))
-      continuous_id continuous_const
-    intro u hu
-    change u = t.toNNReal at hu
-    subst u
-    simp
-  map_zero' := by simp
-
-def potentialDifference (κ θ : ℝ) (W : WienerLaw) (b : Driver) (h i : ℕ) : ℝ :=
-  let t := (i : ℝ) * mesh h
-  let v := potential κ θ b t
-  let w := ∫⁻ c, potential κ θ (concat b c t) (((i : ℝ) + 1) * mesh h) ∂W
-  if v < ∞ ∧ w < ∞ then v.toReal - w.toReal else 0
-
-def discreteMass (κ θ : ℝ) (W : WienerLaw) (b : Driver) (ℓ : ℝ) (h : ℕ) : ℝ :=
-  ∑ i ∈ Finset.range (h * 2 ^ h),
-    if ENNReal.ofReal (((i : ℝ) + 1) * mesh h) ≤ levelTime κ θ b ℓ
-    then potentialDifference κ θ W b h i else 0
-
-def levelDensity (κ θ : ℝ) (b : Driver) (ℓ : ℝ) : ℝ :=
-  let τ := levelTime κ θ b ℓ
-  if τ < ∞ then Real.exp (2 * a κ * α κ * ℓ) *
-    Real.sin (angle κ θ b 0 τ.toReal) ^ p κ / Real.sin θ ^ p κ else 0
-
-def angleLaw (κ : ℝ) : Measure ℝ :=
-  let unnormalized := (volume.restrict (Ioo (0 : ℝ) Real.pi)).withDensity
-    (fun θ => ENNReal.ofReal (Real.sin θ ^ (4 * a κ)))
-  (unnormalized Set.univ)⁻¹ • unnormalized
-
-def clip (u x : ℝ) : ℝ := min (max x 0) u
-
-def finiteMoment (κ : ℝ) (W : WienerLaw) (n : ℕ) (ℓ : ℝ) : ℝ :=
-  limUnder atTop (fun u : ℕ => limUnder atTop (fun h : ℕ =>
-    ∫ θ, ∫ b, levelDensity κ θ b ℓ *
-      (clip u (discreteMass κ θ W b ℓ h)) ^ n ∂W ∂angleLaw κ))
-
-def moment (κ : ℝ) (W : WienerLaw) (n : ℕ) : ℝ :=
-  limUnder atTop (fun ℓ : ℕ => finiteMoment κ W n ℓ)
-
-def batchLevel (κ : ℝ) (W : WienerLaw) (n : ℕ) : ℕ :=
-  1 + Nat.card {j : ℕ // 1 ≤ j ∧ finiteMoment κ W n j ≤ 3 * moment κ W n / 4}
-
-def threshold (κ : ℝ) (W : WienerLaw) (n : ℕ) : ℝ :=
-  4 * moment κ W (n + 1) / moment κ W n
-
-def multiplicity (κ : ℝ) (W : WienerLaw) (n : ℕ) (k : ℤ) : ℕ :=
-  if (2 : ℝ) ^ k ≤ threshold κ W n then
-    ⌊(4 : ℝ) ^ n * ((2 : ℝ) ^ k) ^ n / moment κ W n⌋₊ else 0
-
-abbrev Entry := ℕ × Option (ℤ × ℕ)
-
-def ValidEntry (κ : ℝ) (W : WienerLaw) (e : Entry) : Prop :=
-  1 ≤ e.1 ∧ match e.2 with
-    | none => True
-    | some (k,j) => j < multiplicity κ W e.1 k
-
-def entryValue (e : Entry) : ℝ :=
-  match e.2 with
-    | none => e.1
-    | some (k,_) => (2 : ℝ) ^ k
-
-def entryPosition (κ : ℝ) (W : WienerLaw) (e : Entry) : ℕ :=
-  match e.2 with
-    | none => ∑' k : ℤ, multiplicity κ W e.1 k
-    | some (k,j) => (∑' l : ℤ, if l < k then multiplicity κ W e.1 l else 0) + j
-
-def entryRadius (κ : ℝ) (W : WienerLaw) (e : Entry) : ℝ :=
-  Real.exp (-(e.1 : ℝ) ^ 2 - 2 * a κ * (entryPosition κ W e : ℝ) *
-    ((batchLevel κ W e.1 : ℝ) + (e.1 : ℝ)))
-
-def entryCost (κ : ℝ) (W : WienerLaw) (e : Entry) (r : ℝ) : ℝ :=
-  entryValue e * entryRadius κ W e ^ d κ * max 1 ((r / entryRadius κ W e) ^ 2)
-
-def gauge (κ : ℝ) (W : WienerLaw) (r : ℝ) : ℝ :=
-  if r ≤ 0 then 0 else sInf {v | ∃ e : Entry, ValidEntry κ W e ∧ v = entryCost κ W e r}
-
-end SLEExactGauge.Target
-
-namespace SLEExactGauge.Intervals
-
-theorem all_real_of_all_rational {X : Type*} (μ : OuterMeasure X) (γ : ℝ → X)
-    (h : ∀ q r : ℚ, 0 < q → q < r →
-      0 < μ (γ '' Icc (q : ℝ) (r : ℝ)) ∧ μ (γ '' Icc (q : ℝ) (r : ℝ)) < ∞) :
-    ∀ s t : ℝ, 0 < s → s < t →
-      0 < μ (γ '' Icc s t) ∧ μ (γ '' Icc s t) < ∞ := by
-  intro s t hs hst
-  obtain ⟨q, hsq, hqt⟩ := exists_rat_btwn hst
-  obtain ⟨r, hqr, hrt⟩ := exists_rat_btwn hqt
-  have hq0 : 0 < q := by exact_mod_cast hs.trans hsq
-  have hqr' : q < r := by exact_mod_cast hqr
-  have hpos := (h q r hq0 hqr').1
-  have hlower : γ '' Icc (q : ℝ) (r : ℝ) ⊆ γ '' Icc s t :=
-    image_mono (Icc_subset_Icc hsq.le hrt.le)
-  obtain ⟨u, hu0, hus⟩ := exists_rat_btwn hs
-  obtain ⟨v, htv⟩ := exists_rat_gt t
-  have hu0' : 0 < u := by exact_mod_cast hu0
-  have huv : u < v := by exact_mod_cast hus.trans (hst.trans htv)
-  have hfinite := (h u v hu0' huv).2
-  have hupper : γ '' Icc s t ⊆ γ '' Icc (u : ℝ) (v : ℝ) :=
-    image_mono (Icc_subset_Icc hus.le htv.le)
-  exact ⟨hpos.trans_le (μ.mono hlower), (μ.mono hupper).trans_lt hfinite⟩
-
-theorem ae_all_real_of_ae_rational {Ω X : Type*} [MeasurableSpace Ω]
-    (P : Measure Ω) (μ : OuterMeasure X) (γ : Ω → ℝ → X)
-    (h : ∀ q r : ℚ, 0 < q → q < r →
-      ∀ᵐ ω ∂P, 0 < μ (γ ω '' Icc (q : ℝ) (r : ℝ)) ∧
-        μ (γ ω '' Icc (q : ℝ) (r : ℝ)) < ∞) :
-    ∀ᵐ ω ∂P, ∀ s t : ℝ, 0 < s → s < t →
-      0 < μ (γ ω '' Icc s t) ∧ μ (γ ω '' Icc s t) < ∞ := by
-  have hall : ∀ᵐ ω ∂P, ∀ q r : ℚ, 0 < q → q < r →
-      0 < μ (γ ω '' Icc (q : ℝ) (r : ℝ)) ∧
-        μ (γ ω '' Icc (q : ℝ) (r : ℝ)) < ∞ := by
-    simpa only [ae_all_iff] using h
-  exact hall.mono (fun ω hω => all_real_of_all_rational μ (γ ω) hω)
-
-end SLEExactGauge.Intervals
-
-namespace SLEExactGauge.Target
-
-abbrev GaugeIndex (κ : ℝ) (W : WienerLaw) := {e : Entry // ValidEntry κ W e}
-
-def cleanupIndex (κ : ℝ) (W : WienerLaw) (n : ℕ) (hn : 1 ≤ n) : GaugeIndex κ W :=
-  ⟨(n, none), hn, trivial⟩
-
-instance (κ : ℝ) (W : WienerLaw) : Nonempty (GaugeIndex κ W) :=
-  ⟨cleanupIndex κ W 1 le_rfl⟩
-
-abbrev weights (κ : ℝ) (W : WienerLaw) (i : GaugeIndex κ W) : ℝ := entryValue i.val
-abbrev radii (κ : ℝ) (W : WienerLaw) (i : GaugeIndex κ W) : ℝ := entryRadius κ W i.val
-
-lemma weights_pos (κ : ℝ) (W : WienerLaw) (i : GaugeIndex κ W) : 0 < weights κ W i := by
-  rcases i with ⟨⟨n, o⟩, hn, _⟩
-  cases o with
-  | none =>
-      change (0 : ℝ) < (n : ℝ)
-      exact Nat.cast_pos.mpr (Nat.succ_le_iff.mp hn)
-  | some kj =>
-      rcases kj with ⟨k, j⟩
-      exact zpow_pos (by norm_num : (0 : ℝ) < 2) k
-
-lemma radii_pos (κ : ℝ) (W : WienerLaw) (i : GaugeIndex κ W) : 0 < radii κ W i :=
-  Real.exp_pos _
-
-lemma gauge_eq_full (κ : ℝ) (W : WienerLaw) :
-    gauge κ W = QuadraticEnvelope.full (weights κ W) (radii κ W) (d κ) := by
-  funext r
-  unfold gauge QuadraticEnvelope.full
-  split_ifs with hr
-  · rfl
-  · congr 1
-    ext v
-    constructor
-    · rintro ⟨e, he, hv⟩
-      exact ⟨⟨e, he⟩, hv.symm⟩
-    · rintro ⟨⟨e, he⟩, hv⟩
-      exact ⟨e, he, hv.symm⟩
-
-lemma internal_a_pos {κ : ℝ} (hκ : 0 < κ) : 0 < a κ := div_pos (by norm_num) hκ
-
-lemma dimension_pos {κ : ℝ} (hκ : 0 < κ) : 0 < d κ := by
-  have ha := internal_a_pos hκ
-  unfold d
-  positivity
-
-lemma cleanup_radius_le {κ : ℝ} (hκ : 0 < κ) (W : WienerLaw) (n : ℕ) (hn : 1 ≤ n) :
-    radii κ W (cleanupIndex κ W n hn) ≤ Real.exp (-(n : ℝ) ^ 2) := by
-  unfold radii cleanupIndex entryRadius
-  apply Real.exp_le_exp.mpr
-  dsimp only
-  have ha := internal_a_pos hκ
-  have hnonneg : 0 ≤ 2 * a κ * (entryPosition κ W (n, none) : ℝ) *
-      ((batchLevel κ W n : ℝ) + (n : ℝ)) := by positivity
-  linarith
-
-lemma cleanup_base_le {κ : ℝ} (hκ : 0 < κ) (W : WienerLaw) (n : ℕ) (hn : 1 ≤ n) :
-    weights κ W (cleanupIndex κ W n hn) * radii κ W (cleanupIndex κ W n hn) ^ d κ ≤
-      (n : ℝ) * Real.exp (-d κ * (n : ℝ) ^ 2) := by
-  have hd := dimension_pos hκ
-  change (n : ℝ) * radii κ W (cleanupIndex κ W n hn) ^ d κ ≤ _
-  calc
-    _ ≤ (n : ℝ) * Real.exp (-(n : ℝ) ^ 2) ^ d κ := by
-      apply mul_le_mul_of_nonneg_left _ (Nat.cast_nonneg n)
-      exact Real.rpow_le_rpow (radii_pos κ W _).le (cleanup_radius_le hκ W n hn) hd.le
-    _ = _ := by rw [← Real.exp_mul]; congr 2; ring
-
-lemma cleanup_small {κ : ℝ} (hκ : 0 < κ) (W : WienerLaw) :
-    ∀ ε > 0, ∃ i : GaugeIndex κ W, weights κ W i * radii κ W i ^ d κ < ε := by
-  have hd := dimension_pos hκ
-  have hlim : Tendsto (fun n : ℕ => (n : ℝ) * Real.exp (-d κ * (n : ℝ))) atTop (𝓝 0) := by
-    convert (tendsto_rpow_mul_exp_neg_mul_atTop_nhds_zero 1 (d κ) hd).comp
-      (tendsto_natCast_atTop_atTop : Tendsto (fun n : ℕ => (n : ℝ)) atTop atTop) using 1
-    ext n
-    simp only [Function.comp_apply, Real.rpow_one]
-  intro ε hε
-  obtain ⟨n, hnε, hn⟩ :=
-    ((hlim.eventually (gt_mem_nhds hε)).and (eventually_ge_atTop 1)).exists
-  refine ⟨cleanupIndex κ W n hn, lt_of_le_of_lt ?_ hnε⟩
-  have hnreal : 1 ≤ (n : ℝ) := by exact_mod_cast hn
-  have hsq : (n : ℝ) ≤ (n : ℝ) ^ 2 := by nlinarith
-  calc
-    _ ≤ (n : ℝ) * Real.exp (-d κ * (n : ℝ) ^ 2) := cleanup_base_le hκ W n hn
-    _ ≤ (n : ℝ) * Real.exp (-d κ * (n : ℝ)) := by
-      apply mul_le_mul_of_nonneg_left _ (Nat.cast_nonneg n)
-      exact Real.exp_le_exp.mpr (mul_le_mul_of_nonpos_left hsq (neg_nonpos.mpr hd.le))
-
-theorem gauge_basic_properties {κ : ℝ} (hκ : 0 < κ) (W : WienerLaw) :
-    ContinuousOn (gauge κ W) (Ici 0) ∧
-    MonotoneOn (gauge κ W) (Ici 0) ∧
-    gauge κ W 0 = 0 ∧
-    (∀ r : ℝ, 0 ≤ gauge κ W r) ∧
-    ∀ C ≥ 1, ∀ r ≥ 0, gauge κ W (C * r) ≤ C ^ 2 * gauge κ W r := by
-  rw [gauge_eq_full]
-  have hb : ∀ i, 0 ≤ weights κ W i := fun i => (weights_pos κ W i).le
-  have hR := radii_pos κ W
-  refine ⟨?_, QuadraticEnvelope.full_monoOn hb hR, QuadraticEnvelope.full_zero,
-    QuadraticEnvelope.full_nonneg hb hR, fun _ hC _ hr => QuadraticEnvelope.full_scale_le hb hR hC hr⟩
-  intro r hr
-  obtain rfl | hrpos := (show 0 ≤ r from hr).eq_or_lt
-  · exact (QuadraticEnvelope.continuousAt_zero hb hR (cleanup_small hκ W)).continuousWithinAt
-  · exact (QuadraticEnvelope.continuousAt_pos hb hR hrpos).continuousWithinAt
-
-
-
-theorem hausdorff_arbitrary_covers (h : ℝ → ℝ) (h0 : h 0 = 0) (E : Set ℂ) :
-    hausdorff h E =
-      ⨆ (δ : ℝ≥0∞) (_ : 0 < δ),
-        ⨅ (U : ℕ → Set ℂ) (_ : E ⊆ ⋃ j, U j) (_ : ∀ j, Metric.ediam (U j) ≤ δ),
-          ∑' j, if Metric.ediam (U j) = ∞ then ∞
-            else ENNReal.ofReal (h (Metric.ediam (U j)).toReal) := by
-  let m : ℝ≥0∞ → ℝ≥0∞ := fun r => if r = ∞ then ∞ else ENNReal.ofReal (h r.toReal)
-  have hm0 : m 0 = 0 := by simp [m, h0]
-  have hnonempty (U : Set ℂ) : (⨆ _ : U.Nonempty, m (Metric.ediam U)) = m (Metric.ediam U) := by
-    by_cases hU : U.Nonempty
-    · simp [hU]
-    · rw [not_nonempty_iff_eq_empty.mp hU]
-      simp [hm0]
-  change OuterMeasure.mkMetric m E = _
-  rw [OuterMeasure.coe_mkMetric, Measure.mkMetric_apply]
-  simp only [hnonempty]
-  rfl
-
-
-
-lemma trace_isChordalSLE (κ : ℝ) {W : WienerLaw} (hW : IsWiener W) :
-    IsChordalSLE κ (trace κ) W := by
-  refine ⟨W, id, hW, ProbabilityTheory.HasLaw.id, ?_⟩
-  exact ae_of_all _ (fun _ _ _ => rfl)
-
-theorem transfer_interval_estimates {κ : ℝ} {h : ℝ → ℝ}
-    (hcanonical : ∀ W : WienerLaw, IsWiener W →
-      ∀ᵐ b ∂W, ∀ s t : ℝ, 0 < s → s < t →
-        0 < hausdorff h (trace κ b '' Icc s t) ∧
-        hausdorff h (trace κ b '' Icc s t) < ∞)
-    {Ω : Type*} [MeasurableSpace Ω] (P : Measure Ω) (γ : Ω → ℝ → ℂ)
-    (hγ : IsChordalSLE κ γ P) :
-    ∀ᵐ ω ∂P, ∀ s t : ℝ, 0 < s → s < t →
-      0 < hausdorff h (γ ω '' Icc s t) ∧
-      hausdorff h (γ ω '' Icc s t) < ∞ := by
-  obtain ⟨W, B, hW, hB, htrace⟩ := hγ
-  have hmap := hcanonical W hW
-  rw [← hB.map_eq] at hmap
-  have hpull := ae_of_ae_map hB.aemeasurable hmap
-  filter_upwards [hpull, htrace] with ω hω htr
-  intro s t hs hst
-  have heq : γ ω '' Icc s t = trace κ (B ω) '' Icc s t := by
-    apply Set.image_congr
-    intro v hv
-    exact htr v (hs.le.trans hv.1)
-  rw [heq]
-  exact hω s t hs hst
-
-
-
-lemma dimension_eq (κ : ℝ) : d κ = 1 + κ / 8 := by
-  unfold d a
-  field_simp
-  ring
-
-lemma dimension_lt_two {κ : ℝ} (hκ8 : κ < 8) : d κ < 2 := by
-  rw [dimension_eq κ]
-  linarith
-
-lemma multiplicity_positive_bounds (κ : ℝ) (W : WienerLaw) {n : ℕ}
-    (hn : 1 ≤ n) (hm1 : 0 < moment κ W 1)
-    (hJ : moment κ W 1 ^ n ≤ moment κ W n) {k : ℤ}
-    (hNk : 0 < multiplicity κ W n k) :
-    moment κ W 1 / 4 ≤ (2 : ℝ) ^ k ∧ (2 : ℝ) ^ k ≤ threshold κ W n := by
-  have hcut : (2 : ℝ) ^ k ≤ threshold κ W n := by
-    by_contra hcut
-    simp [multiplicity, hcut] at hNk
-  have hmn : 0 < moment κ W n := (pow_pos hm1 n).trans_le hJ
-  have hfloor : 0 < ⌊(4 : ℝ) ^ n * ((2 : ℝ) ^ k) ^ n / moment κ W n⌋₊ := by
-    simpa [multiplicity, hcut] using hNk
-  have hw := Nat.floor_pos.mp hfloor
-  have hnum : moment κ W n ≤ ((4 : ℝ) * 2 ^ k) ^ n := by
-    simpa only [one_mul, mul_pow] using (le_div_iff₀ hmn).1 hw
-  have hb : moment κ W 1 ≤ (4 : ℝ) * 2 ^ k :=
-    le_of_pow_le_pow_left₀ (by omega) (by positivity) (hJ.trans hnum)
-  exact ⟨(div_le_iff₀ (by norm_num : (0 : ℝ) < 4)).2 (by linarith), hcut⟩
-
-lemma weights_lower_of_moment_inequalities (κ : ℝ) (W : WienerLaw)
-    (hm1 : 0 < moment κ W 1)
-    (hJ : ∀ n : ℕ, 1 ≤ n → moment κ W 1 ^ n ≤ moment κ W n)
-    (i : GaugeIndex κ W) : min 1 (moment κ W 1 / 4) ≤ weights κ W i := by
-  rcases i with ⟨⟨n, o⟩, hn, ho⟩
-  cases o with
-  | none =>
-      change min 1 (moment κ W 1 / 4) ≤ (n : ℝ)
-      exact (min_le_left _ _).trans (by exact_mod_cast hn)
-  | some kj =>
-      rcases kj with ⟨k, j⟩
-      change j < multiplicity κ W n k at ho
-      change min 1 (moment κ W 1 / 4) ≤ (2 : ℝ) ^ k
-      exact (min_le_right _ _).trans
-        (multiplicity_positive_bounds κ W hn hm1 (hJ n hn)
-          ((Nat.zero_le j).trans_lt ho)).1
-
-theorem gauge_admissible_of_moment_inequalities {κ : ℝ}
-    (hκ0 : 0 < κ) (hκ8 : κ < 8) (W : WienerLaw)
-    (hm1 : 0 < moment κ W 1)
-    (hJ : ∀ n : ℕ, 1 ≤ n → moment κ W 1 ^ n ≤ moment κ W n) :
-    IsHausdorffGauge (gauge κ W) := by
-  rw [gauge_eq_full]
-  exact QuadraticEnvelope.isHausdorffGauge
-    (c := min 1 (moment κ W 1 / 4))
-    (lt_min zero_lt_one (div_pos hm1 (by norm_num)))
-    (weights_lower_of_moment_inequalities κ W hm1 hJ)
-    (radii_pos κ W) (dimension_pos hκ0).le (dimension_lt_two hκ8).le
-    (cleanup_small hκ0 W)
-
-lemma multiplicity_support_finite (κ : ℝ) (W : WienerLaw) {n : ℕ}
-    (hn : 1 ≤ n) (hm1 : 0 < moment κ W 1)
-    (hJ : moment κ W 1 ^ n ≤ moment κ W n) :
-    Set.Finite {k : ℤ | 0 < multiplicity κ W n k} := by
-  have hlog : 0 < Real.log 2 := Real.log_pos (by norm_num)
-  apply (Set.finite_Icc (⌈Real.log (moment κ W 1 / 4) / Real.log 2⌉ : ℤ)
-    (⌊Real.log (threshold κ W n) / Real.log 2⌋ : ℤ)).subset
-  intro k hk
-  obtain ⟨hlo, hhi⟩ := multiplicity_positive_bounds κ W hn hm1 hJ hk
-  constructor
-  · apply Int.ceil_le.mpr
-    apply (div_le_iff₀ hlog).2
-    exact (Real.le_zpow_iff_log_le (div_pos hm1 (by norm_num))
-      (by norm_num : (0 : ℝ) < 2)).1 hlo
-  · apply Int.le_floor.mpr
-    apply (le_div_iff₀ hlog).2
-    exact Real.le_log_of_zpow_le (by norm_num : (0 : ℝ) < 2) hhi
-
-lemma repeated_entries_finite (κ : ℝ) (W : WienerLaw) {n : ℕ}
-    (hn : 1 ≤ n) (hm1 : 0 < moment κ W 1)
-    (hJ : moment κ W 1 ^ n ≤ moment κ W n) :
-    Set.Finite {kj : ℤ × ℕ | kj.2 < multiplicity κ W n kj.1} := by
-  have hfin := (multiplicity_support_finite κ W hn hm1 hJ).biUnion
-    (fun k _ => (Set.finite_Iio (multiplicity κ W n k)).image (fun j : ℕ => (k, j)))
-  apply hfin.subset
-  rintro ⟨k, j⟩ hj
-  exact mem_iUnion.2 ⟨k, mem_iUnion.2 ⟨(Nat.zero_le j).trans_lt hj, j, hj, rfl⟩⟩
-
-lemma batch_entries_finite (κ : ℝ) (W : WienerLaw) {n : ℕ}
-    (hn : 1 ≤ n) (hm1 : 0 < moment κ W 1)
-    (hJ : moment κ W 1 ^ n ≤ moment κ W n) :
-    Set.Finite {e : Entry | e.1 = n ∧ ValidEntry κ W e} := by
-  have hfin := ((repeated_entries_finite κ W hn hm1 hJ).image
-    (fun kj : ℤ × ℕ => (n, (some kj : Option (ℤ × ℕ))))).insert (n, none)
-  apply hfin.subset
-  rintro ⟨m, o⟩ ⟨heq, hm, ho⟩
-  dsimp at heq
-  subst m
-  cases o with
-  | none => exact Or.inl rfl
-  | some kj => exact Or.inr ⟨kj, ho, rfl⟩
-
-lemma early_entries_finite (κ : ℝ) (W : WienerLaw)
-    (hm1 : 0 < moment κ W 1)
-    (hJ : ∀ n : ℕ, 1 ≤ n → moment κ W 1 ^ n ≤ moment κ W n)
-    (n₀ : ℕ) : Set.Finite {e : Entry | ValidEntry κ W e ∧ e.1 < n₀} := by
-  have hfin := (Set.finite_Ico 1 n₀).biUnion (fun n hn =>
-    batch_entries_finite κ W hn.1 hm1 (hJ n hn.1))
-  apply hfin.subset
-  intro e he
-  exact mem_iUnion.2 ⟨e.1, mem_iUnion.2 ⟨⟨he.1.1, he.2⟩, rfl, he.1⟩⟩
-
-theorem gauge_restore_early_batches (κ : ℝ) (W : WienerLaw)
-    (hm1 : 0 < moment κ W 1)
-    (hJ : ∀ n : ℕ, 1 ≤ n → moment κ W 1 ^ n ≤ moment κ W n)
-    (n₀ : ℕ) (F : ℝ → ℝ) {M C : ℝ} (hM : 0 ≤ M)
-    (hbound : ∀ r > 0, F r ≤ M)
-    (htail : ∀ e : Entry, ValidEntry κ W e → n₀ ≤ e.1 →
-      ∀ r > 0, F r ≤ C * entryCost κ W e r) :
-    ∃ C' : ℝ, 0 < C' ∧ ∀ r > 0, F r ≤ C' * gauge κ W r := by
-  classical
-  have hfin : Set.Finite {i : GaugeIndex κ W | i.val.1 < n₀} := by
-    apply ((early_entries_finite κ W hm1 hJ n₀).preimage
-      (f := fun i : GaugeIndex κ W => i.val) Subtype.val_injective.injOn).subset
-    intro i hi
-    exact ⟨i.property, hi⟩
-  rw [gauge_eq_full]
-  apply QuadraticEnvelope.restore_finite (weights_pos κ W) (radii_pos κ W)
-    hfin.toFinset F hM hbound
-  intro i hi r hr
-  have hn : n₀ ≤ i.val.1 := by
-    have hnot : ¬ i.val.1 < n₀ := by simpa using hi
-    exact le_of_not_gt hnot
-  exact htail i.val i.property hn r hr
-
-end SLEExactGauge.Target
-
-end
-
-end OAI
+import Mathlib
+
+namespace OAI
+
+/-! Quadratic moment envelopes, Hausdorff gauge admissibility and interval transfer. -/
+
+universe u
+
+noncomputable section
+open MeasureTheory Set Filter Metric
+open scoped NNReal ENNReal Topology
+
+namespace SLEExactGauge.Target
+
+open scoped ContinuousMapZero
+abbrev Driver := C(ℝ≥0, ℝ)₀
+instance : MeasurableSpace Driver := borel Driver
+instance : BorelSpace Driver := ⟨rfl⟩
+abbrev WienerLaw := Measure Driver
+
+def IsWiener (W : WienerLaw) : Prop :=
+  ProbabilityTheory.IsBrownianReal (fun t b => b t) W
+
+def a (κ : ℝ) := 2 / κ
+def d (κ : ℝ) := 1 + 1 / (4 * a κ)
+def α (κ : ℝ) := 2 - d κ
+def p (κ : ℝ) := 4 * a κ - 1
+
+def driverValue (b : Driver) (t : ℝ) : ℝ := b t.toNNReal
+
+def cutoffField (κ : ℝ) (b : Driver) (j : ℕ) (t : ℝ) (z : ℂ) : ℂ :=
+  (a κ : ℂ) * star (z - driverValue b t) /
+    (max (‖z - driverValue b t‖ ^ 2) ((j : ℝ) ^ (-(4 : ℤ))) : ℝ)
+
+def mesh (N : ℕ) : ℝ := (2 : ℝ) ^ (-(N : ℤ))
+
+def eulerSteps (κ : ℝ) (b : Driver) (j N : ℕ) (z : ℂ) : ℕ → ℂ
+  | 0 => z
+  | k + 1 => eulerSteps κ b j N z k +
+      mesh N * cutoffField κ b j ((k : ℝ) * mesh N) (eulerSteps κ b j N z k)
+
+def eulerFlow (κ : ℝ) (b : Driver) (j N : ℕ) (z : ℂ) (t : ℝ) : ℂ :=
+  let k := ⌊t / mesh N⌋₊
+  let w :=  t / mesh N - (k : ℝ)
+  (1 - w : ℝ) * eulerSteps κ b j N z k + w * eulerSteps κ b j N z (k + 1)
+
+def cutoffFlow (κ : ℝ) (b : Driver) (j : ℕ) (z : ℂ) (t : ℝ) : ℂ :=
+  limUnder atTop (fun N : ℕ => eulerFlow κ b j N z t)
+
+def Surviving (κ : ℝ) (b : Driver) (z : ℂ) (t : ℝ) : Prop :=
+  ∃ j : ℕ, 1 ≤ j ∧ (j : ℝ)⁻¹ <
+    sInf ((fun u : ℝ => (cutoffFlow κ b j z u).im) '' Icc 0 t)
+
+instance (κ : ℝ) (b : Driver) (z : ℂ) (t : ℝ) : Decidable (Surviving κ b z t) :=
+  Classical.propDecidable _
+
+def flow (κ : ℝ) (b : Driver) (z : ℂ) (t : ℝ) : ℂ :=
+  if h : Surviving κ b z t then cutoffFlow κ b (Nat.find h) z t else 0
+
+def IsHausdorffGauge (h : ℝ → ℝ) : Prop :=
+  ContinuousOn h (Ici 0) ∧ MonotoneOn h (Ici 0) ∧ h 0 = 0 ∧ ∀ r > 0, 0 < h r
+
+def hausdorff (h : ℝ → ℝ) : OuterMeasure ℂ :=
+  OuterMeasure.mkMetric (fun r => if r = ∞ then ∞ else ENNReal.ofReal (h r.toReal))
+
+def inverseFlow (κ : ℝ) (b : Driver) (t : ℝ) (w : ℂ) : ℂ :=
+  @ite ℂ (∃ z : ℂ, Surviving κ b z t ∧ flow κ b z t = w) (Classical.propDecidable _)
+    (Classical.epsilon (fun z : ℂ => Surviving κ b z t ∧ flow κ b z t = w)) 0
+
+def trace (κ : ℝ) (b : Driver) (t : ℝ) : ℂ :=
+  limUnder (nhdsWithin 0 (Ioi 0)) (fun ε : ℝ =>
+    inverseFlow κ b (κ * t) (driverValue b (κ * t) + ε * Complex.I))
+
+def IsChordalSLE {Ω : Type*} [MeasurableSpace Ω] (κ : ℝ)
+    (γ : Ω → ℝ → ℂ) (P : Measure Ω) : Prop :=
+  ∃ (W : WienerLaw) (B : Ω → Driver),
+    IsWiener W ∧ ProbabilityTheory.HasLaw B W P ∧
+      ∀ᵐ ω ∂P, ∀ t : ℝ, 0 ≤ t → γ ω t = trace κ (B ω) t
+
+end SLEExactGauge.Target
+
+namespace SLEExactGauge.QuadraticEnvelope
+
+variable {ι : Type*}
+
+def profile (b R : ι → ℝ) (d : ℝ) (i : ι) (r : ℝ) : ℝ :=
+  b i * R i ^ d * max 1 ((r / R i) ^ 2)
+
+def full (b R : ι → ℝ) (d : ℝ) (r : ℝ) : ℝ :=
+  if r ≤ 0 then 0 else sInf (range (fun i => profile b R d i r))
+
+variable {b R : ι → ℝ} {d : ℝ}
+
+lemma profile_nonneg (hb : ∀ i, 0 ≤ b i) (hR : ∀ i, 0 < R i)
+    (i : ι) (r : ℝ) : 0 ≤ profile b R d i r := by
+  unfold profile
+  exact mul_nonneg (mul_nonneg (hb i) (Real.rpow_nonneg (hR i).le d))
+    (le_trans zero_le_one (le_max_left _ _))
+
+lemma base_le_profile (hb : ∀ i, 0 ≤ b i) (hR : ∀ i, 0 < R i)
+    (i : ι) (r : ℝ) : b i * R i ^ d ≤ profile b R d i r := by
+  unfold profile
+  exact le_mul_of_one_le_right
+    (mul_nonneg (hb i) (Real.rpow_nonneg (hR i).le d)) (le_max_left _ _)
+
+lemma profile_mono (hb : ∀ i, 0 ≤ b i) (hR : ∀ i, 0 < R i)
+    (i : ι) {r s : ℝ} (hr : 0 ≤ r) (hrs : r ≤ s) :
+    profile b R d i r ≤ profile b R d i s := by
+  apply mul_le_mul_of_nonneg_left _
+    (mul_nonneg (hb i) (Real.rpow_nonneg (hR i).le d))
+  exact max_le_max_left _ <| pow_le_pow_left₀ (div_nonneg hr (hR i).le)
+    (div_le_div_of_nonneg_right hrs (hR i).le) 2
+
+lemma profile_scale_le (hb : ∀ i, 0 ≤ b i) (hR : ∀ i, 0 < R i)
+    (i : ι) {C : ℝ} (hC : 1 ≤ C) (r : ℝ) :
+    profile b R d i (C * r) ≤ C ^ 2 * profile b R d i r := by
+  have hC2 : 1 ≤ C ^ 2 := by nlinarith
+  have hmax : max 1 (((C * r) / R i) ^ 2) ≤
+      C ^ 2 * max 1 ((r / R i) ^ 2) := by
+    apply max_le
+    · exact hC2.trans <| le_mul_of_one_le_right (sq_nonneg C) (le_max_left _ _)
+    · calc
+        (((C * r) / R i) ^ 2) = C ^ 2 * (r / R i) ^ 2 := by ring
+        _ ≤ C ^ 2 * max 1 ((r / R i) ^ 2) :=
+          mul_le_mul_of_nonneg_left (le_max_right _ _) (sq_nonneg C)
+  unfold profile
+  calc
+    _ ≤ b i * R i ^ d * (C ^ 2 * max 1 ((r / R i) ^ 2)) :=
+      mul_le_mul_of_nonneg_left hmax
+        (mul_nonneg (hb i) (Real.rpow_nonneg (hR i).le d))
+    _ = _ := by ring
+
+@[simp] lemma full_zero : full b R d 0 = 0 := by simp [full]
+
+lemma full_of_nonpos {r : ℝ} (hr : r ≤ 0) : full b R d r = 0 := by
+  simp [full, hr]
+
+lemma full_of_pos {r : ℝ} (hr : 0 < r) :
+    full b R d r = sInf (range (fun i => profile b R d i r)) := by
+  simp [full, hr.not_ge]
+
+lemma profiles_bddBelow (hb : ∀ i, 0 ≤ b i) (hR : ∀ i, 0 < R i)
+    (r : ℝ) : BddBelow (range (fun i => profile b R d i r)) := by
+  refine ⟨0, ?_⟩
+  rintro _ ⟨i, rfl⟩
+  exact profile_nonneg hb hR i r
+
+variable [Nonempty ι]
+
+lemma le_full {r v : ℝ} (hr : 0 < r)
+    (hv : ∀ i, v ≤ profile b R d i r) : v ≤ full b R d r := by
+  rw [full_of_pos hr]
+  exact le_csInf (range_nonempty _) (by rintro _ ⟨i, rfl⟩; exact hv i)
+
+lemma full_nonneg (hb : ∀ i, 0 ≤ b i) (hR : ∀ i, 0 < R i)
+    (r : ℝ) : 0 ≤ full b R d r := by
+  by_cases hr : r ≤ 0
+  · rw [full_of_nonpos hr]
+  · exact le_full (lt_of_not_ge hr) (fun i => profile_nonneg hb hR i r)
+
+omit [Nonempty ι] in
+lemma full_le_profile (hb : ∀ i, 0 ≤ b i) (hR : ∀ i, 0 < R i)
+    (i : ι) (r : ℝ) : full b R d r ≤ profile b R d i r := by
+  by_cases hr : r ≤ 0
+  · rw [full_of_nonpos hr]
+    exact profile_nonneg hb hR i r
+  · rw [full_of_pos (lt_of_not_ge hr)]
+    exact csInf_le (profiles_bddBelow hb hR r) (mem_range_self i)
+
+lemma full_monoOn (hb : ∀ i, 0 ≤ b i) (hR : ∀ i, 0 < R i) :
+    MonotoneOn (full b R d) (Ici 0) := by
+  intro r hr s hs hrs
+  by_cases hr0 : r ≤ 0
+  · rw [full_of_nonpos hr0]
+    exact full_nonneg hb hR s
+  · have hrpos := lt_of_not_ge hr0
+    apply le_full (hrpos.trans_le hrs)
+    intro i
+    exact (full_le_profile hb hR i r).trans (profile_mono hb hR i hr hrs)
+
+theorem full_scale_le (hb : ∀ i, 0 ≤ b i) (hR : ∀ i, 0 < R i)
+    {C r : ℝ} (hC : 1 ≤ C) (hr : 0 ≤ r) :
+    full b R d (C * r) ≤ C ^ 2 * full b R d r := by
+  obtain rfl | hrpos := hr.eq_or_lt
+  · simp
+  have hCpos : 0 < C := zero_lt_one.trans_le hC
+  have hC2 : 0 < C ^ 2 := sq_pos_of_pos hCpos
+  have h : full b R d (C * r) / C ^ 2 ≤ full b R d r := by
+    apply le_full hrpos
+    intro i
+    apply (div_le_iff₀ hC2).2
+    calc
+      full b R d (C * r) ≤ profile b R d i (C * r) := full_le_profile hb hR i _
+      _ ≤ C ^ 2 * profile b R d i r := profile_scale_le hb hR i hC r
+      _ = profile b R d i r * C ^ 2 := mul_comm _ _
+  simpa [mul_comm] using (div_le_iff₀ hC2).1 h
+
+lemma power_lower_bound {c r : ℝ} (hc : 0 < c) (hb : ∀ i, c ≤ b i)
+    (hR : ∀ i, 0 < R i) (hd0 : 0 ≤ d) (hd2 : d ≤ 2) (hr : 0 < r) :
+    c * r ^ d ≤ full b R d r := by
+  apply le_full hr
+  intro i
+  have hshape : r ^ d ≤ R i ^ d * max 1 ((r / R i) ^ 2) := by
+    rcases le_total r (R i) with hsmall | hlarge
+    · exact (Real.rpow_le_rpow hr.le hsmall hd0).trans <|
+        le_mul_of_one_le_right (Real.rpow_nonneg (hR i).le d) (le_max_left _ _)
+    · have hratio : 1 ≤ r / R i := (le_div_iff₀ (hR i)).2 (by simpa using hlarge)
+      have hp : (r / R i) ^ d ≤ (r / R i) ^ 2 := by
+        exact_mod_cast Real.rpow_le_rpow_of_exponent_le hratio hd2
+      calc
+        r ^ d = R i ^ d * (r / R i) ^ d := by
+          rw [← Real.mul_rpow (hR i).le (div_nonneg hr.le (hR i).le)]
+          congr 1
+          field_simp [(hR i).ne']
+        _ ≤ R i ^ d * (r / R i) ^ 2 :=
+          mul_le_mul_of_nonneg_left hp (Real.rpow_nonneg (hR i).le d)
+        _ ≤ R i ^ d * max 1 ((r / R i) ^ 2) :=
+          mul_le_mul_of_nonneg_left (le_max_right _ _) (Real.rpow_nonneg (hR i).le d)
+  calc
+    c * r ^ d ≤ b i * r ^ d := mul_le_mul_of_nonneg_right (hb i) (Real.rpow_nonneg hr.le d)
+    _ ≤ b i * (R i ^ d * max 1 ((r / R i) ^ 2)) :=
+      mul_le_mul_of_nonneg_left hshape (hc.le.trans (hb i))
+    _ = profile b R d i r := by rw [profile]; ring
+
+lemma full_pos {c r : ℝ} (hc : 0 < c) (hb : ∀ i, c ≤ b i)
+    (hR : ∀ i, 0 < R i) (hd0 : 0 ≤ d) (hd2 : d ≤ 2) (hr : 0 < r) :
+    0 < full b R d r :=
+  (mul_pos hc (Real.rpow_pos_of_pos hr d)).trans_le
+    (power_lower_bound hc hb hR hd0 hd2 hr)
+
+lemma ratio_bounds (hb : ∀ i, 0 ≤ b i) (hR : ∀ i, 0 < R i)
+    {r s : ℝ} (hr : 0 < r) (hs : 0 < s) :
+    min 1 ((s / r) ^ 2) * full b R d r ≤ full b R d s ∧
+      full b R d s ≤ max 1 ((s / r) ^ 2) * full b R d r := by
+  have hmono := full_monoOn (d := d) hb hR
+  have hnonneg := full_nonneg (d := d) hb hR r
+  constructor
+  · rcases le_total r s with hrs | hsr
+    · calc
+        _ ≤ 1 * full b R d r := mul_le_mul_of_nonneg_right (min_le_left _ _) hnonneg
+        _ = full b R d r := one_mul _
+        _ ≤ full b R d s := hmono hr.le hs.le hrs
+    · have hC : 1 ≤ r / s := (le_div_iff₀ hs).2 (by simpa using hsr)
+      have hscale := full_scale_le (d := d) hb hR hC hs.le
+      rw [div_mul_cancel₀ r hs.ne'] at hscale
+      calc
+        _ ≤ (s / r) ^ 2 * full b R d r :=
+          mul_le_mul_of_nonneg_right (min_le_right _ _) hnonneg
+        _ ≤ (s / r) ^ 2 * ((r / s) ^ 2 * full b R d s) :=
+          mul_le_mul_of_nonneg_left hscale (sq_nonneg _)
+        _ = full b R d s := by field_simp
+  · rcases le_total s r with hsr | hrs
+    · exact (hmono hs.le hr.le hsr).trans <| by
+        simpa using mul_le_mul_of_nonneg_right (le_max_left 1 ((s / r) ^ 2)) hnonneg
+    · have hC : 1 ≤ s / r := (le_div_iff₀ hr).2 (by simpa using hrs)
+      have hscale := full_scale_le (d := d) hb hR hC hr.le
+      rw [div_mul_cancel₀ s hr.ne'] at hscale
+      exact hscale.trans <| mul_le_mul_of_nonneg_right (le_max_right _ _) hnonneg
+
+lemma continuousAt_pos (hb : ∀ i, 0 ≤ b i) (hR : ∀ i, 0 < R i)
+    {r : ℝ} (hr : 0 < r) : ContinuousAt (full b R d) r := by
+  have hlow : ContinuousAt (fun s : ℝ => min 1 ((s / r) ^ 2) * full b R d r) r := by
+    fun_prop
+  have hupp : ContinuousAt (fun s : ℝ => max 1 ((s / r) ^ 2) * full b R d r) r := by
+    fun_prop
+  apply tendsto_of_tendsto_of_tendsto_of_le_of_le'
+    (by simpa [hr.ne'] using hlow.tendsto)
+    (by simpa [hr.ne'] using hupp.tendsto)
+  · filter_upwards [Ioi_mem_nhds hr] with s hs
+    exact (ratio_bounds hb hR hr hs).1
+  · filter_upwards [Ioi_mem_nhds hr] with s hs
+    exact (ratio_bounds hb hR hr hs).2
+
+lemma continuousAt_zero (hb : ∀ i, 0 ≤ b i) (hR : ∀ i, 0 < R i)
+    (hsmall : ∀ ε > 0, ∃ i, b i * R i ^ d < ε) :
+    ContinuousAt (full b R d) 0 := by
+  rw [Metric.continuousAt_iff]
+  intro ε hε
+  obtain ⟨i, hi⟩ := hsmall ε hε
+  refine ⟨R i, hR i, ?_⟩
+  intro x hx
+  rw [full_zero, Real.dist_eq, sub_zero, abs_of_nonneg (full_nonneg hb hR x)]
+  by_cases hx0 : x ≤ 0
+  · rw [full_of_nonpos hx0]
+    exact hε
+  · have hxpos : 0 < x := lt_of_not_ge hx0
+    have hxr : x < R i := by
+      simpa [Real.dist_eq, abs_of_pos hxpos] using hx
+    have hratio : 0 ≤ x / R i := div_nonneg hxpos.le (hR i).le
+    have hratio1 : x / R i ≤ 1 := (div_le_one (hR i)).2 hxr.le
+    have hp : (x / R i) ^ 2 ≤ 1 := by
+      simpa using (pow_le_pow_left₀ hratio hratio1 2)
+    calc
+      full b R d x ≤ profile b R d i x := full_le_profile hb hR i x
+      _ = b i * R i ^ d := by simp [profile, max_eq_left hp]
+      _ < ε := hi
+
+theorem isHausdorffGauge {c : ℝ} (hc : 0 < c) (hb : ∀ i, c ≤ b i)
+    (hR : ∀ i, 0 < R i) (hd0 : 0 ≤ d) (hd2 : d ≤ 2)
+    (hsmall : ∀ ε > 0, ∃ i, b i * R i ^ d < ε) :
+    SLEExactGauge.Target.IsHausdorffGauge (full b R d) := by
+  have hb0 : ∀ i, 0 ≤ b i := fun i => hc.le.trans (hb i)
+  refine ⟨?_, full_monoOn hb0 hR, full_zero, fun r hr => full_pos hc hb hR hd0 hd2 hr⟩
+  intro r hr
+  obtain rfl | hrpos := (show 0 ≤ r from hr).eq_or_lt
+  · exact (continuousAt_zero hb0 hR hsmall).continuousWithinAt
+  · exact (continuousAt_pos hb0 hR hrpos).continuousWithinAt
+
+theorem restore_finite (hb : ∀ i, 0 < b i) (hR : ∀ i, 0 < R i)
+    (discarded : Finset ι) (F : ℝ → ℝ) {M C : ℝ} (hM : 0 ≤ M)
+    (hbound : ∀ r > 0, F r ≤ M)
+    (htail : ∀ i, i ∉ discarded → ∀ r > 0, F r ≤ C * profile b R d i r) :
+    ∃ C' : ℝ, 0 < C' ∧ ∀ r > 0, F r ≤ C' * full b R d r := by
+  let C' := max C 0 + 1 + ∑ i ∈ discarded, M / (b i * R i ^ d)
+  have hbase : ∀ i, 0 < b i * R i ^ d :=
+    fun i => mul_pos (hb i) (Real.rpow_pos_of_pos (hR i) d)
+  have hterm : ∀ i, 0 ≤ M / (b i * R i ^ d) :=
+    fun i => div_nonneg hM (hbase i).le
+  have hsum : 0 ≤ ∑ i ∈ discarded, M / (b i * R i ^ d) :=
+    Finset.sum_nonneg (fun i _ => hterm i)
+  have hC' : 0 < C' := by
+    dsimp [C']
+    linarith [le_max_right C 0]
+  have hCC' : C ≤ C' := by
+    dsimp [C']
+    linarith [le_max_left C 0]
+  have hall : ∀ r > 0, ∀ i, F r ≤ C' * profile b R d i r := by
+    intro r hr i
+    by_cases hi : i ∈ discarded
+    · have hi_le : M / (b i * R i ^ d) ≤ C' := by
+        have hh := Finset.single_le_sum (fun i (_ : i ∈ discarded) => hterm i) hi
+        dsimp [C']
+        linarith [le_max_right C 0]
+      calc
+        F r ≤ M := hbound r hr
+        _ ≤ C' * (b i * R i ^ d) := (div_le_iff₀ (hbase i)).1 hi_le
+        _ ≤ C' * profile b R d i r := mul_le_mul_of_nonneg_left
+          (base_le_profile (fun i => (hb i).le) hR i r) hC'.le
+    · exact (htail i hi r hr).trans <| mul_le_mul_of_nonneg_right hCC'
+        (profile_nonneg (fun i => (hb i).le) hR i r)
+  refine ⟨C', hC', fun r hr => ?_⟩
+  have h : F r / C' ≤ full b R d r := by
+    apply le_full hr
+    intro i
+    exact (div_le_iff₀ hC').2 (by simpa [mul_comm] using hall r hr i)
+  simpa [mul_comm] using (div_le_iff₀ hC').1 h
+
+end SLEExactGauge.QuadraticEnvelope
+
+namespace SLEExactGauge.Target
+
+def diskMap (θ : ℝ) (z : ℂ) : ℂ :=
+  (z - Complex.exp (θ * Complex.I)) / (z - Complex.exp (-θ * Complex.I))
+
+def diskMapInv (θ : ℝ) (x : ℂ) : ℂ :=
+  (Complex.exp (θ * Complex.I) - x * Complex.exp (-θ * Complex.I)) / (1 - x)
+
+def centeredFlow (κ : ℝ) (b : Driver) (z : ℂ) (t : ℝ) : ℂ :=
+  flow κ b z t - driverValue b t
+
+def clock (κ θ : ℝ) (b : Driver) (x : ℂ) (t : ℝ) : ℝ :=
+  ∫ u in Icc (0 : ℝ) t,
+    (flow κ b (diskMapInv θ x) u).im ^ 2 /
+      ‖centeredFlow κ b (diskMapInv θ x) u‖ ^ 4
+
+def initialRadius (θ : ℝ) (x : ℂ) : ℝ :=
+  2 * (diskMapInv θ x).im * ‖deriv (diskMap θ) (diskMapInv θ x)‖
+
+def radius (κ θ : ℝ) (b : Driver) (x : ℂ) (t : ℝ) : ℝ :=
+  initialRadius θ x * Real.exp (-2 * a κ * clock κ θ b x t)
+
+def angle (κ θ : ℝ) (b : Driver) (x : ℂ) (t : ℝ) : ℝ :=
+  Complex.arg (centeredFlow κ b (diskMapInv θ x) t)
+
+def green (κ θ : ℝ) (b : Driver) (x : ℂ) (t : ℝ) : ℝ :=
+  if Surviving κ b (diskMapInv θ x) t then
+    radius κ θ b x t ^ (-α κ) * Real.sin (angle κ θ b x t) ^ p κ
+  else 0
+
+def levelTime (κ θ : ℝ) (b : Driver) (ℓ : ℝ) : ℝ≥0∞ :=
+  sInf {t | ∃ q : ℚ, 0 < q ∧ t = ENNReal.ofReal (q : ℝ) ∧
+    Surviving κ b (diskMapInv θ 0) q ∧ ℓ < clock κ θ b 0 q}
+
+def diskK : Set ℂ := closedBall 0 (1 / 4)
+
+def potential (κ θ : ℝ) (b : Driver) (t : ℝ) : ℝ≥0∞ :=
+  ∫⁻ x in diskK, ENNReal.ofReal (green κ θ b x t)
+
+def concat (b c : Driver) (t : ℝ) : Driver where
+  toFun u := if u ≤ t.toNNReal then b u else b t.toNNReal + c (u - t.toNNReal)
+  continuous_toFun := by
+    apply Continuous.if_le (map_continuous b)
+      (continuous_const.add ((map_continuous c).comp (continuous_id.sub continuous_const)))
+      continuous_id continuous_const
+    intro u hu
+    change u = t.toNNReal at hu
+    subst u
+    simp
+  map_zero' := by simp
+
+def potentialDifference (κ θ : ℝ) (W : WienerLaw) (b : Driver) (h i : ℕ) : ℝ :=
+  let t := (i : ℝ) * mesh h
+  let v := potential κ θ b t
+  let w := ∫⁻ c, potential κ θ (concat b c t) (((i : ℝ) + 1) * mesh h) ∂W
+  if v < ∞ ∧ w < ∞ then v.toReal - w.toReal else 0
+
+def discreteMass (κ θ : ℝ) (W : WienerLaw) (b : Driver) (ℓ : ℝ) (h : ℕ) : ℝ :=
+  ∑ i ∈ Finset.range (h * 2 ^ h),
+    if ENNReal.ofReal (((i : ℝ) + 1) * mesh h) ≤ levelTime κ θ b ℓ
+    then potentialDifference κ θ W b h i else 0
+
+def levelDensity (κ θ : ℝ) (b : Driver) (ℓ : ℝ) : ℝ :=
+  let τ := levelTime κ θ b ℓ
+  if τ < ∞ then Real.exp (2 * a κ * α κ * ℓ) *
+    Real.sin (angle κ θ b 0 τ.toReal) ^ p κ / Real.sin θ ^ p κ else 0
+
+def angleLaw (κ : ℝ) : Measure ℝ :=
+  let unnormalized := (volume.restrict (Ioo (0 : ℝ) Real.pi)).withDensity
+    (fun θ => ENNReal.ofReal (Real.sin θ ^ (4 * a κ)))
+  (unnormalized Set.univ)⁻¹ • unnormalized
+
+def clip (u x : ℝ) : ℝ := min (max x 0) u
+
+def finiteMoment (κ : ℝ) (W : WienerLaw) (n : ℕ) (ℓ : ℝ) : ℝ :=
+  limUnder atTop (fun u : ℕ => limUnder atTop (fun h : ℕ =>
+    ∫ θ, ∫ b, levelDensity κ θ b ℓ *
+      (clip u (discreteMass κ θ W b ℓ h)) ^ n ∂W ∂angleLaw κ))
+
+def moment (κ : ℝ) (W : WienerLaw) (n : ℕ) : ℝ :=
+  limUnder atTop (fun ℓ : ℕ => finiteMoment κ W n ℓ)
+
+def batchLevel (κ : ℝ) (W : WienerLaw) (n : ℕ) : ℕ :=
+  1 + Nat.card {j : ℕ // 1 ≤ j ∧ finiteMoment κ W n j ≤ 3 * moment κ W n / 4}
+
+def threshold (κ : ℝ) (W : WienerLaw) (n : ℕ) : ℝ :=
+  4 * moment κ W (n + 1) / moment κ W n
+
+def multiplicity (κ : ℝ) (W : WienerLaw) (n : ℕ) (k : ℤ) : ℕ :=
+  if (2 : ℝ) ^ k ≤ threshold κ W n then
+    ⌊(4 : ℝ) ^ n * ((2 : ℝ) ^ k) ^ n / moment κ W n⌋₊ else 0
+
+abbrev Entry := ℕ × Option (ℤ × ℕ)
+
+def ValidEntry (κ : ℝ) (W : WienerLaw) (e : Entry) : Prop :=
+  1 ≤ e.1 ∧ match e.2 with
+    | none => True
+    | some (k,j) => j < multiplicity κ W e.1 k
+
+def entryValue (e : Entry) : ℝ :=
+  match e.2 with
+    | none => e.1
+    | some (k,_) => (2 : ℝ) ^ k
+
+def entryPosition (κ : ℝ) (W : WienerLaw) (e : Entry) : ℕ :=
+  match e.2 with
+    | none => ∑' k : ℤ, multiplicity κ W e.1 k
+    | some (k,j) => (∑' l : ℤ, if l < k then multiplicity κ W e.1 l else 0) + j
+
+def entryRadius (κ : ℝ) (W : WienerLaw) (e : Entry) : ℝ :=
+  Real.exp (-(e.1 : ℝ) ^ 2 - 2 * a κ * (entryPosition κ W e : ℝ) *
+    ((batchLevel κ W e.1 : ℝ) + (e.1 : ℝ)))
+
+def entryCost (κ : ℝ) (W : WienerLaw) (e : Entry) (r : ℝ) : ℝ :=
+  entryValue e * entryRadius κ W e ^ d κ * max 1 ((r / entryRadius κ W e) ^ 2)
+
+def gauge (κ : ℝ) (W : WienerLaw) (r : ℝ) : ℝ :=
+  if r ≤ 0 then 0 else sInf {v | ∃ e : Entry, ValidEntry κ W e ∧ v = entryCost κ W e r}
+
+end SLEExactGauge.Target
+
+namespace SLEExactGauge.Intervals
+
+theorem all_real_of_all_rational {X : Type*} (μ : OuterMeasure X) (γ : ℝ → X)
+    (h : ∀ q r : ℚ, 0 < q → q < r →
+      0 < μ (γ '' Icc (q : ℝ) (r : ℝ)) ∧ μ (γ '' Icc (q : ℝ) (r : ℝ)) < ∞) :
+    ∀ s t : ℝ, 0 < s → s < t →
+      0 < μ (γ '' Icc s t) ∧ μ (γ '' Icc s t) < ∞ := by
+  intro s t hs hst
+  obtain ⟨q, hsq, hqt⟩ := exists_rat_btwn hst
+  obtain ⟨r, hqr, hrt⟩ := exists_rat_btwn hqt
+  have hq0 : 0 < q := by exact_mod_cast hs.trans hsq
+  have hqr' : q < r := by exact_mod_cast hqr
+  have hpos := (h q r hq0 hqr').1
+  have hlower : γ '' Icc (q : ℝ) (r : ℝ) ⊆ γ '' Icc s t :=
+    image_mono (Icc_subset_Icc hsq.le hrt.le)
+  obtain ⟨u, hu0, hus⟩ := exists_rat_btwn hs
+  obtain ⟨v, htv⟩ := exists_rat_gt t
+  have hu0' : 0 < u := by exact_mod_cast hu0
+  have huv : u < v := by exact_mod_cast hus.trans (hst.trans htv)
+  have hfinite := (h u v hu0' huv).2
+  have hupper : γ '' Icc s t ⊆ γ '' Icc (u : ℝ) (v : ℝ) :=
+    image_mono (Icc_subset_Icc hus.le htv.le)
+  exact ⟨hpos.trans_le (μ.mono hlower), (μ.mono hupper).trans_lt hfinite⟩
+
+theorem ae_all_real_of_ae_rational {Ω X : Type*} [MeasurableSpace Ω]
+    (P : Measure Ω) (μ : OuterMeasure X) (γ : Ω → ℝ → X)
+    (h : ∀ q r : ℚ, 0 < q → q < r →
+      ∀ᵐ ω ∂P, 0 < μ (γ ω '' Icc (q : ℝ) (r : ℝ)) ∧
+        μ (γ ω '' Icc (q : ℝ) (r : ℝ)) < ∞) :
+    ∀ᵐ ω ∂P, ∀ s t : ℝ, 0 < s → s < t →
+      0 < μ (γ ω '' Icc s t) ∧ μ (γ ω '' Icc s t) < ∞ := by
+  have hall : ∀ᵐ ω ∂P, ∀ q r : ℚ, 0 < q → q < r →
+      0 < μ (γ ω '' Icc (q : ℝ) (r : ℝ)) ∧
+        μ (γ ω '' Icc (q : ℝ) (r : ℝ)) < ∞ := by
+    simpa only [ae_all_iff] using h
+  exact hall.mono (fun ω hω => all_real_of_all_rational μ (γ ω) hω)
+
+end SLEExactGauge.Intervals
+
+namespace SLEExactGauge.Target
+
+abbrev GaugeIndex (κ : ℝ) (W : WienerLaw) := {e : Entry // ValidEntry κ W e}
+
+def cleanupIndex (κ : ℝ) (W : WienerLaw) (n : ℕ) (hn : 1 ≤ n) : GaugeIndex κ W :=
+  ⟨(n, none), hn, trivial⟩
+
+instance (κ : ℝ) (W : WienerLaw) : Nonempty (GaugeIndex κ W) :=
+  ⟨cleanupIndex κ W 1 le_rfl⟩
+
+abbrev weights (κ : ℝ) (W : WienerLaw) (i : GaugeIndex κ W) : ℝ := entryValue i.val
+abbrev radii (κ : ℝ) (W : WienerLaw) (i : GaugeIndex κ W) : ℝ := entryRadius κ W i.val
+
+lemma weights_pos (κ : ℝ) (W : WienerLaw) (i : GaugeIndex κ W) : 0 < weights κ W i := by
+  rcases i with ⟨⟨n, o⟩, hn, _⟩
+  cases o with
+  | none =>
+      change (0 : ℝ) < (n : ℝ)
+      exact Nat.cast_pos.mpr (Nat.succ_le_iff.mp hn)
+  | some kj =>
+      rcases kj with ⟨k, j⟩
+      exact zpow_pos (by norm_num : (0 : ℝ) < 2) k
+
+lemma radii_pos (κ : ℝ) (W : WienerLaw) (i : GaugeIndex κ W) : 0 < radii κ W i :=
+  Real.exp_pos _
+
+lemma gauge_eq_full (κ : ℝ) (W : WienerLaw) :
+    gauge κ W = QuadraticEnvelope.full (weights κ W) (radii κ W) (d κ) := by
+  funext r
+  unfold gauge QuadraticEnvelope.full
+  split_ifs with hr
+  · rfl
+  · congr 1
+    ext v
+    constructor
+    · rintro ⟨e, he, hv⟩
+      exact ⟨⟨e, he⟩, hv.symm⟩
+    · rintro ⟨⟨e, he⟩, hv⟩
+      exact ⟨e, he, hv.symm⟩
+
+lemma internal_a_pos {κ : ℝ} (hκ : 0 < κ) : 0 < a κ := div_pos (by norm_num) hκ
+
+lemma dimension_pos {κ : ℝ} (hκ : 0 < κ) : 0 < d κ := by
+  have ha := internal_a_pos hκ
+  unfold d
+  positivity
+
+lemma cleanup_radius_le {κ : ℝ} (hκ : 0 < κ) (W : WienerLaw) (n : ℕ) (hn : 1 ≤ n) :
+    radii κ W (cleanupIndex κ W n hn) ≤ Real.exp (-(n : ℝ) ^ 2) := by
+  unfold radii cleanupIndex entryRadius
+  apply Real.exp_le_exp.mpr
+  dsimp only
+  have ha := internal_a_pos hκ
+  have hnonneg : 0 ≤ 2 * a κ * (entryPosition κ W (n, none) : ℝ) *
+      ((batchLevel κ W n : ℝ) + (n : ℝ)) := by positivity
+  linarith
+
+lemma cleanup_base_le {κ : ℝ} (hκ : 0 < κ) (W : WienerLaw) (n : ℕ) (hn : 1 ≤ n) :
+    weights κ W (cleanupIndex κ W n hn) * radii κ W (cleanupIndex κ W n hn) ^ d κ ≤
+      (n : ℝ) * Real.exp (-d κ * (n : ℝ) ^ 2) := by
+  have hd := dimension_pos hκ
+  change (n : ℝ) * radii κ W (cleanupIndex κ W n hn) ^ d κ ≤ _
+  calc
+    _ ≤ (n : ℝ) * Real.exp (-(n : ℝ) ^ 2) ^ d κ := by
+      apply mul_le_mul_of_nonneg_left _ (Nat.cast_nonneg n)
+      exact Real.rpow_le_rpow (radii_pos κ W _).le (cleanup_radius_le hκ W n hn) hd.le
+    _ = _ := by rw [← Real.exp_mul]; congr 2; ring
+
+lemma cleanup_small {κ : ℝ} (hκ : 0 < κ) (W : WienerLaw) :
+    ∀ ε > 0, ∃ i : GaugeIndex κ W, weights κ W i * radii κ W i ^ d κ < ε := by
+  have hd := dimension_pos hκ
+  have hlim : Tendsto (fun n : ℕ => (n : ℝ) * Real.exp (-d κ * (n : ℝ))) atTop (𝓝 0) := by
+    convert (tendsto_rpow_mul_exp_neg_mul_atTop_nhds_zero 1 (d κ) hd).comp
+      (tendsto_natCast_atTop_atTop : Tendsto (fun n : ℕ => (n : ℝ)) atTop atTop) using 1
+    ext n
+    simp only [Function.comp_apply, Real.rpow_one]
+  intro ε hε
+  obtain ⟨n, hnε, hn⟩ :=
+    ((hlim.eventually (gt_mem_nhds hε)).and (eventually_ge_atTop 1)).exists
+  refine ⟨cleanupIndex κ W n hn, lt_of_le_of_lt ?_ hnε⟩
+  have hnreal : 1 ≤ (n : ℝ) := by exact_mod_cast hn
+  have hsq : (n : ℝ) ≤ (n : ℝ) ^ 2 := by nlinarith
+  calc
+    _ ≤ (n : ℝ) * Real.exp (-d κ * (n : ℝ) ^ 2) := cleanup_base_le hκ W n hn
+    _ ≤ (n : ℝ) * Real.exp (-d κ * (n : ℝ)) := by
+      apply mul_le_mul_of_nonneg_left _ (Nat.cast_nonneg n)
+      exact Real.exp_le_exp.mpr (mul_le_mul_of_nonpos_left hsq (neg_nonpos.mpr hd.le))
+
+theorem gauge_basic_properties {κ : ℝ} (hκ : 0 < κ) (W : WienerLaw) :
+    ContinuousOn (gauge κ W) (Ici 0) ∧
+    MonotoneOn (gauge κ W) (Ici 0) ∧
+    gauge κ W 0 = 0 ∧
+    (∀ r : ℝ, 0 ≤ gauge κ W r) ∧
+    ∀ C ≥ 1, ∀ r ≥ 0, gauge κ W (C * r) ≤ C ^ 2 * gauge κ W r := by
+  rw [gauge_eq_full]
+  have hb : ∀ i, 0 ≤ weights κ W i := fun i => (weights_pos κ W i).le
+  have hR := radii_pos κ W
+  refine ⟨?_, QuadraticEnvelope.full_monoOn hb hR, QuadraticEnvelope.full_zero,
+    QuadraticEnvelope.full_nonneg hb hR, fun _ hC _ hr => QuadraticEnvelope.full_scale_le hb hR hC hr⟩
+  intro r hr
+  obtain rfl | hrpos := (show 0 ≤ r from hr).eq_or_lt
+  · exact (QuadraticEnvelope.continuousAt_zero hb hR (cleanup_small hκ W)).continuousWithinAt
+  · exact (QuadraticEnvelope.continuousAt_pos hb hR hrpos).continuousWithinAt
+
+
+
+theorem hausdorff_arbitrary_covers (h : ℝ → ℝ) (h0 : h 0 = 0) (E : Set ℂ) :
+    hausdorff h E =
+      ⨆ (δ : ℝ≥0∞) (_ : 0 < δ),
+        ⨅ (U : ℕ → Set ℂ) (_ : E ⊆ ⋃ j, U j) (_ : ∀ j, Metric.ediam (U j) ≤ δ),
+          ∑' j, if Metric.ediam (U j) = ∞ then ∞
+            else ENNReal.ofReal (h (Metric.ediam (U j)).toReal) := by
+  let m : ℝ≥0∞ → ℝ≥0∞ := fun r => if r = ∞ then ∞ else ENNReal.ofReal (h r.toReal)
+  have hm0 : m 0 = 0 := by simp [m, h0]
+  have hnonempty (U : Set ℂ) : (⨆ _ : U.Nonempty, m (Metric.ediam U)) = m (Metric.ediam U) := by
+    by_cases hU : U.Nonempty
+    · simp [hU]
+    · rw [not_nonempty_iff_eq_empty.mp hU]
+      simp [hm0]
+  change OuterMeasure.mkMetric m E = _
+  rw [OuterMeasure.coe_mkMetric, Measure.mkMetric_apply]
+  simp only [hnonempty]
+  rfl
+
+
+
+lemma trace_isChordalSLE (κ : ℝ) {W : WienerLaw} (hW : IsWiener W) :
+    IsChordalSLE κ (trace κ) W := by
+  refine ⟨W, id, hW, ProbabilityTheory.HasLaw.id, ?_⟩
+  exact ae_of_all _ (fun _ _ _ => rfl)
+
+theorem transfer_interval_estimates {κ : ℝ} {h : ℝ → ℝ}
+    (hcanonical : ∀ W : WienerLaw, IsWiener W →
+      ∀ᵐ b ∂W, ∀ s t : ℝ, 0 < s → s < t →
+        0 < hausdorff h (trace κ b '' Icc s t) ∧
+        hausdorff h (trace κ b '' Icc s t) < ∞)
+    {Ω : Type*} [MeasurableSpace Ω] (P : Measure Ω) (γ : Ω → ℝ → ℂ)
+    (hγ : IsChordalSLE κ γ P) :
+    ∀ᵐ ω ∂P, ∀ s t : ℝ, 0 < s → s < t →
+      0 < hausdorff h (γ ω '' Icc s t) ∧
+      hausdorff h (γ ω '' Icc s t) < ∞ := by
+  obtain ⟨W, B, hW, hB, htrace⟩ := hγ
+  have hmap := hcanonical W hW
+  rw [← hB.map_eq] at hmap
+  have hpull := ae_of_ae_map hB.aemeasurable hmap
+  filter_upwards [hpull, htrace] with ω hω htr
+  intro s t hs hst
+  have heq : γ ω '' Icc s t = trace κ (B ω) '' Icc s t := by
+    apply Set.image_congr
+    intro v hv
+    exact htr v (hs.le.trans hv.1)
+  rw [heq]
+  exact hω s t hs hst
+
+
+
+lemma dimension_eq (κ : ℝ) : d κ = 1 + κ / 8 := by
+  unfold d a
+  field_simp
+  ring
+
+lemma dimension_lt_two {κ : ℝ} (hκ8 : κ < 8) : d κ < 2 := by
+  rw [dimension_eq κ]
+  linarith
+
+lemma multiplicity_positive_bounds (κ : ℝ) (W : WienerLaw) {n : ℕ}
+    (hn : 1 ≤ n) (hm1 : 0 < moment κ W 1)
+    (hJ : moment κ W 1 ^ n ≤ moment κ W n) {k : ℤ}
+    (hNk : 0 < multiplicity κ W n k) :
+    moment κ W 1 / 4 ≤ (2 : ℝ) ^ k ∧ (2 : ℝ) ^ k ≤ threshold κ W n := by
+  have hcut : (2 : ℝ) ^ k ≤ threshold κ W n := by
+    by_contra hcut
+    simp [multiplicity, hcut] at hNk
+  have hmn : 0 < moment κ W n := (pow_pos hm1 n).trans_le hJ
+  have hfloor : 0 < ⌊(4 : ℝ) ^ n * ((2 : ℝ) ^ k) ^ n / moment κ W n⌋₊ := by
+    simpa [multiplicity, hcut] using hNk
+  have hw := Nat.floor_pos.mp hfloor
+  have hnum : moment κ W n ≤ ((4 : ℝ) * 2 ^ k) ^ n := by
+    simpa only [one_mul, mul_pow] using (le_div_iff₀ hmn).1 hw
+  have hb : moment κ W 1 ≤ (4 : ℝ) * 2 ^ k :=
+    le_of_pow_le_pow_left₀ (by omega) (by positivity) (hJ.trans hnum)
+  exact ⟨(div_le_iff₀ (by norm_num : (0 : ℝ) < 4)).2 (by linarith), hcut⟩
+
+lemma weights_lower_of_moment_inequalities (κ : ℝ) (W : WienerLaw)
+    (hm1 : 0 < moment κ W 1)
+    (hJ : ∀ n : ℕ, 1 ≤ n → moment κ W 1 ^ n ≤ moment κ W n)
+    (i : GaugeIndex κ W) : min 1 (moment κ W 1 / 4) ≤ weights κ W i := by
+  rcases i with ⟨⟨n, o⟩, hn, ho⟩
+  cases o with
+  | none =>
+      change min 1 (moment κ W 1 / 4) ≤ (n : ℝ)
+      exact (min_le_left _ _).trans (by exact_mod_cast hn)
+  | some kj =>
+      rcases kj with ⟨k, j⟩
+      change j < multiplicity κ W n k at ho
+      change min 1 (moment κ W 1 / 4) ≤ (2 : ℝ) ^ k
+      exact (min_le_right _ _).trans
+        (multiplicity_positive_bounds κ W hn hm1 (hJ n hn)
+          ((Nat.zero_le j).trans_lt ho)).1
+
+theorem gauge_admissible_of_moment_inequalities {κ : ℝ}
+    (hκ0 : 0 < κ) (hκ8 : κ < 8) (W : WienerLaw)
+    (hm1 : 0 < moment κ W 1)
+    (hJ : ∀ n : ℕ, 1 ≤ n → moment κ W 1 ^ n ≤ moment κ W n) :
+    IsHausdorffGauge (gauge κ W) := by
+  rw [gauge_eq_full]
+  exact QuadraticEnvelope.isHausdorffGauge
+    (c := min 1 (moment κ W 1 / 4))
+    (lt_min zero_lt_one (div_pos hm1 (by norm_num)))
+    (weights_lower_of_moment_inequalities κ W hm1 hJ)
+    (radii_pos κ W) (dimension_pos hκ0).le (dimension_lt_two hκ8).le
+    (cleanup_small hκ0 W)
+
+lemma multiplicity_support_finite (κ : ℝ) (W : WienerLaw) {n : ℕ}
+    (hn : 1 ≤ n) (hm1 : 0 < moment κ W 1)
+    (hJ : moment κ W 1 ^ n ≤ moment κ W n) :
+    Set.Finite {k : ℤ | 0 < multiplicity κ W n k} := by
+  have hlog : 0 < Real.log 2 := Real.log_pos (by norm_num)
+  apply (Set.finite_Icc (⌈Real.log (moment κ W 1 / 4) / Real.log 2⌉ : ℤ)
+    (⌊Real.log (threshold κ W n) / Real.log 2⌋ : ℤ)).subset
+  intro k hk
+  obtain ⟨hlo, hhi⟩ := multiplicity_positive_bounds κ W hn hm1 hJ hk
+  constructor
+  · apply Int.ceil_le.mpr
+    apply (div_le_iff₀ hlog).2
+    exact (Real.le_zpow_iff_log_le (div_pos hm1 (by norm_num))
+      (by norm_num : (0 : ℝ) < 2)).1 hlo
+  · apply Int.le_floor.mpr
+    apply (le_div_iff₀ hlog).2
+    exact Real.le_log_of_zpow_le (by norm_num : (0 : ℝ) < 2) hhi
+
+lemma repeated_entries_finite (κ : ℝ) (W : WienerLaw) {n : ℕ}
+    (hn : 1 ≤ n) (hm1 : 0 < moment κ W 1)
+    (hJ : moment κ W 1 ^ n ≤ moment κ W n) :
+    Set.Finite {kj : ℤ × ℕ | kj.2 < multiplicity κ W n kj.1} := by
+  have hfin := (multiplicity_support_finite κ W hn hm1 hJ).biUnion
+    (fun k _ => (Set.finite_Iio (multiplicity κ W n k)).image (fun j : ℕ => (k, j)))
+  apply hfin.subset
+  rintro ⟨k, j⟩ hj
+  exact mem_iUnion.2 ⟨k, mem_iUnion.2 ⟨(Nat.zero_le j).trans_lt hj, j, hj, rfl⟩⟩
+
+lemma batch_entries_finite (κ : ℝ) (W : WienerLaw) {n : ℕ}
+    (hn : 1 ≤ n) (hm1 : 0 < moment κ W 1)
+    (hJ : moment κ W 1 ^ n ≤ moment κ W n) :
+    Set.Finite {e : Entry | e.1 = n ∧ ValidEntry κ W e} := by
+  have hfin := ((repeated_entries_finite κ W hn hm1 hJ).image
+    (fun kj : ℤ × ℕ => (n, (some kj : Option (ℤ × ℕ))))).insert (n, none)
+  apply hfin.subset
+  rintro ⟨m, o⟩ ⟨heq, hm, ho⟩
+  dsimp at heq
+  subst m
+  cases o with
+  | none => exact Or.inl rfl
+  | some kj => exact Or.inr ⟨kj, ho, rfl⟩
+
+lemma early_entries_finite (κ : ℝ) (W : WienerLaw)
+    (hm1 : 0 < moment κ W 1)
+    (hJ : ∀ n : ℕ, 1 ≤ n → moment κ W 1 ^ n ≤ moment κ W n)
+    (n₀ : ℕ) : Set.Finite {e : Entry | ValidEntry κ W e ∧ e.1 < n₀} := by
+  have hfin := (Set.finite_Ico 1 n₀).biUnion (fun n hn =>
+    batch_entries_finite κ W hn.1 hm1 (hJ n hn.1))
+  apply hfin.subset
+  intro e he
+  exact mem_iUnion.2 ⟨e.1, mem_iUnion.2 ⟨⟨he.1.1, he.2⟩, rfl, he.1⟩⟩
+
+theorem gauge_restore_early_batches (κ : ℝ) (W : WienerLaw)
+    (hm1 : 0 < moment κ W 1)
+    (hJ : ∀ n : ℕ, 1 ≤ n → moment κ W 1 ^ n ≤ moment κ W n)
+    (n₀ : ℕ) (F : ℝ → ℝ) {M C : ℝ} (hM : 0 ≤ M)
+    (hbound : ∀ r > 0, F r ≤ M)
+    (htail : ∀ e : Entry, ValidEntry κ W e → n₀ ≤ e.1 →
+      ∀ r > 0, F r ≤ C * entryCost κ W e r) :
+    ∃ C' : ℝ, 0 < C' ∧ ∀ r > 0, F r ≤ C' * gauge κ W r := by
+  classical
+  have hfin : Set.Finite {i : GaugeIndex κ W | i.val.1 < n₀} := by
+    apply ((early_entries_finite κ W hm1 hJ n₀).preimage
+      (f := fun i : GaugeIndex κ W => i.val) Subtype.val_injective.injOn).subset
+    intro i hi
+    exact ⟨i.property, hi⟩
+  rw [gauge_eq_full]
+  apply QuadraticEnvelope.restore_finite (weights_pos κ W) (radii_pos κ W)
+    hfin.toFinset F hM hbound
+  intro i hi r hr
+  have hn : n₀ ≤ i.val.1 := by
+    have hnot : ¬ i.val.1 < n₀ := by simpa using hi
+    exact le_of_not_gt hnot
+  exact htail i.val i.property hn r hr
+
+end SLEExactGauge.Target
+
+end
+
+end OAI

lean/OAI/Probability/SLE/Multipoint/MultipointAbsorption.lean

@@ -1,70 +1,70 @@
-import OAI.Probability.SLE.Multipoint.MultipointYoung
-
-namespace OAI
-
-/-! Summation of the pairwise Young bounds. The active index set may
-change at the individual activation and completion times. -/
-
-noncomputable section
-open scoped BigOperators
-
-namespace SLEExactGauge.Multipoint
-
-lemma offDiag_vertex_cost_le {ι : Type*} [DecidableEq ι]
-    (s : Finset ι) (A : ι → ℝ) (hA : ∀ i ∈ s, 0 ≤ A i) :
-    (∑ ij ∈ s.offDiag, (A ij.1 + A ij.2)) ≤
-      2 * (s.card : ℝ) * ∑ i ∈ s, A i := by
-  calc
-    _ ≤ ∑ ij ∈ s ×ˢ s, (A ij.1 + A ij.2) := by
-      apply Finset.sum_le_sum_of_subset_of_nonneg
-      · intro ij hij
-        obtain ⟨hi, hj, _⟩ := Finset.mem_offDiag.mp hij
-        exact Finset.mem_product.mpr ⟨hi, hj⟩
-      · intro ij hij _
-        obtain ⟨hi, hj⟩ := Finset.mem_product.mp hij
-        exact add_nonneg (hA _ hi) (hA _ hj)
-    _ = _ := by
-      rw [Finset.sum_product]
-      simp only [Finset.sum_add_distrib, Finset.sum_const, nsmul_eq_mul,
-        ← Finset.mul_sum]
-      ring
-
-/-- Negative one-point drift absorbs every pair contribution. We bound
-the off-diagonal vertex count by the full square; this only changes the
-order-dependent choice of epsilon. -/
-theorem sum_drift_absorption {ι : Type*} [DecidableEq ι]
-    (s : Finset ι) (D A H : ι → ℝ) (cross weight : ι × ι → ℝ)
-    (C k ε L : ℝ) (hε : 0 ≤ ε) (hA : ∀ i ∈ s, 0 ≤ A i)
-    (hbudget : 2*ε*(s.card : ℝ) ≤ k)
-    (hD : ∀ i ∈ s, D i ≤ C*H i-k*A i)
-    (hcross : ∀ ij ∈ s.offDiag, cross ij ≤ ε*(A ij.1+A ij.2)+L*weight ij) :
-    (∑ i ∈ s, D i) + (∑ ij ∈ s.offDiag, cross ij) ≤
-      C*(∑ i ∈ s, H i) + L*(∑ ij ∈ s.offDiag, weight ij) := by
-  have hsumD := Finset.sum_le_sum hD
-  simp only [Finset.sum_sub_distrib, ← Finset.mul_sum] at hsumD
-  have hsumcross := Finset.sum_le_sum hcross
-  simp only [Finset.sum_add_distrib, ← Finset.mul_sum] at hsumcross
-  have hvertices := mul_le_mul_of_nonneg_left (offDiag_vertex_cost_le s A hA) hε
-  rw [Finset.sum_add_distrib] at hvertices
-  have hsumA : 0 ≤ ∑ i ∈ s, A i := Finset.sum_nonneg hA
-  have htotal := mul_le_mul_of_nonneg_right hbudget hsumA
-  nlinarith
-
-lemma absorption_epsilon_pos {k : ℝ} (hk : 0 < k) (m : ℕ) :
-    0 < k/(4*((m : ℝ)+1)) := by positivity
-
-lemma absorption_epsilon_budget {k : ℝ} (hk : 0 ≤ k) (m : ℕ) :
-    2*(k/(4*((m : ℝ)+1)))*(m : ℝ) ≤ k := by
-  have hm : (0 : ℝ) ≤ m := Nat.cast_nonneg m
-  have hden : 0 < 4*((m : ℝ)+1) := by positivity
-  have he : 2*(k/(4*((m : ℝ)+1)))*(m : ℝ) =
-      (2*k*(m : ℝ))/(4*((m : ℝ)+1)) := by ring
-  rw [he]
-  apply (div_le_iff₀ hden).mpr
-  nlinarith
-
-end SLEExactGauge.Multipoint
-
-end
-
-end OAI
+import OAI.Probability.SLE.Multipoint.MultipointYoung
+
+namespace OAI
+
+/-! Summation of the pairwise Young bounds. The active index set may
+change at the individual activation and completion times. -/
+
+noncomputable section
+open scoped BigOperators
+
+namespace SLEExactGauge.Multipoint
+
+lemma offDiag_vertex_cost_le {ι : Type*} [DecidableEq ι]
+    (s : Finset ι) (A : ι → ℝ) (hA : ∀ i ∈ s, 0 ≤ A i) :
+    (∑ ij ∈ s.offDiag, (A ij.1 + A ij.2)) ≤
+      2 * (s.card : ℝ) * ∑ i ∈ s, A i := by
+  calc
+    _ ≤ ∑ ij ∈ s ×ˢ s, (A ij.1 + A ij.2) := by
+      apply Finset.sum_le_sum_of_subset_of_nonneg
+      · intro ij hij
+        obtain ⟨hi, hj, _⟩ := Finset.mem_offDiag.mp hij
+        exact Finset.mem_product.mpr ⟨hi, hj⟩
+      · intro ij hij _
+        obtain ⟨hi, hj⟩ := Finset.mem_product.mp hij
+        exact add_nonneg (hA _ hi) (hA _ hj)
+    _ = _ := by
+      rw [Finset.sum_product]
+      simp only [Finset.sum_add_distrib, Finset.sum_const, nsmul_eq_mul,
+        ← Finset.mul_sum]
+      ring
+
+/-- Negative one-point drift absorbs every pair contribution. We bound
+the off-diagonal vertex count by the full square; this only changes the
+order-dependent choice of epsilon. -/
+theorem sum_drift_absorption {ι : Type*} [DecidableEq ι]
+    (s : Finset ι) (D A H : ι → ℝ) (cross weight : ι × ι → ℝ)
+    (C k ε L : ℝ) (hε : 0 ≤ ε) (hA : ∀ i ∈ s, 0 ≤ A i)
+    (hbudget : 2*ε*(s.card : ℝ) ≤ k)
+    (hD : ∀ i ∈ s, D i ≤ C*H i-k*A i)
+    (hcross : ∀ ij ∈ s.offDiag, cross ij ≤ ε*(A ij.1+A ij.2)+L*weight ij) :
+    (∑ i ∈ s, D i) + (∑ ij ∈ s.offDiag, cross ij) ≤
+      C*(∑ i ∈ s, H i) + L*(∑ ij ∈ s.offDiag, weight ij) := by
+  have hsumD := Finset.sum_le_sum hD
+  simp only [Finset.sum_sub_distrib, ← Finset.mul_sum] at hsumD
+  have hsumcross := Finset.sum_le_sum hcross
+  simp only [Finset.sum_add_distrib, ← Finset.mul_sum] at hsumcross
+  have hvertices := mul_le_mul_of_nonneg_left (offDiag_vertex_cost_le s A hA) hε
+  rw [Finset.sum_add_distrib] at hvertices
+  have hsumA : 0 ≤ ∑ i ∈ s, A i := Finset.sum_nonneg hA
+  have htotal := mul_le_mul_of_nonneg_right hbudget hsumA
+  nlinarith
+
+lemma absorption_epsilon_pos {k : ℝ} (hk : 0 < k) (m : ℕ) :
+    0 < k/(4*((m : ℝ)+1)) := by positivity
+
+lemma absorption_epsilon_budget {k : ℝ} (hk : 0 ≤ k) (m : ℕ) :
+    2*(k/(4*((m : ℝ)+1)))*(m : ℝ) ≤ k := by
+  have hm : (0 : ℝ) ≤ m := Nat.cast_nonneg m
+  have hden : 0 < 4*((m : ℝ)+1) := by positivity
+  have he : 2*(k/(4*((m : ℝ)+1)))*(m : ℝ) =
+      (2*k*(m : ℝ))/(4*((m : ℝ)+1)) := by ring
+  rw [he]
+  apply (div_le_iff₀ hden).mpr
+  nlinarith
+
+end SLEExactGauge.Multipoint
+
+end
+
+end OAI

lean/OAI/Probability/SLE/Multipoint/MultipointActiveCosts.lean

@@ -1,117 +1,117 @@
-import OAI.Probability.SLE.Multipoint.MultipointLogClockTransport
-import OAI.Probability.SLE.Multipoint.MultipointGlobalDiscount
-
-namespace OAI
-
-/-! The raw active costs and their bounds on individual completion
-intervals. Disjoint active intervals contribute zero pair cost. -/
-
-noncomputable section
-open Set MeasureTheory
-open scoped NNReal
-
-namespace SLEExactGauge.Multipoint
-
-def actualSingleCost (κ β a U : ℝ) (B : ℝ≥0 → ℝ)
-    (G : ℝ≥0 → ℂ → ℂ) (z : ℂ) (t : ℝ) : ℝ :=
-  regulator β U (logFactorClock κ (logLoewnerCoordinates G z t)-a)*
-    logVelocity κ (logLoewnerCoordinates G z t) (B t.toNNReal)^2
-
-def actualPairCost (κ β az aw Uz Uw : ℝ) (B : ℝ≥0 → ℝ)
-    (G : ℝ≥0 → ℂ → ℂ) (z w : ℂ) (t : ℝ) : ℝ :=
-  (regulator β Uz (logFactorClock κ (logLoewnerCoordinates G z t)-az)*
-    regulator β Uw (logFactorClock κ (logLoewnerCoordinates G w t)-aw))^(-exponent (greenExponent κ))*
-      (logVelocity κ (logLoewnerCoordinates G z t) (B t.toNNReal)*
-        logVelocity κ (logLoewnerCoordinates G w t) (B t.toNNReal))
-
-lemma actualSingleCost_nonneg (κ β a U : ℝ) (B : ℝ≥0 → ℝ)
-    (G : ℝ≥0 → ℂ → ℂ) (z : ℂ) (t : ℝ) : 0 ≤ actualSingleCost κ β a U B G z t :=
-  mul_nonneg (regulator_pos _ _ _).le (sq_nonneg _)
-
-lemma actualPairCost_nonneg (κ β az aw Uz Uw : ℝ) (B : ℝ≥0 → ℝ)
-    (G : ℝ≥0 → ℂ → ℂ) (z w : ℂ) (t : ℝ) :
-    0 ≤ actualPairCost κ β az aw Uz Uw B G z w t :=
-  mul_nonneg (Real.rpow_nonneg (mul_pos (regulator_pos _ _ _) (regulator_pos _ _ _)).le _)
-    (mul_pos (logVelocity_pos _ _ _) (logVelocity_pos _ _ _)).le
-
-theorem actualSingleCost_bound
-    {κ : ℝ} (hκ : 0 < κ) {B : ℝ≥0 → ℝ} (hB : Continuous B)
-    {γ : ℝ≥0 → ℂ} {G F : ℝ≥0 → ℂ → ℂ}
-    (hw : IsCapacityTwoWitness (fun t => Real.sqrt κ*B t) γ G F)
-    (σ T : ℝ≥0) (hσT : σ ≤ T) (z : ℂ) (hz : z ∈ survivingDomain γ T)
-    (β a U : ℝ) (hβ : 0 < β) (hU : 0 ≤ U)
-    (hstart : σ < T → logFactorClock κ (logLoewnerCoordinates G z σ) = a)
-    (hend : σ < T → logFactorClock κ (logLoewnerCoordinates G z T)-a ≤ U) :
-    IntervalIntegrable (actualSingleCost κ β a U B G z) volume (σ : ℝ) (T : ℝ) ∧
-      (∫ t in (σ : ℝ)..(T : ℝ), actualSingleCost κ β a U B G z t) ≤ 2/(κ*β) := by
-  rcases lt_or_eq_of_le hσT with hlt | rfl
-  · have he : actualSingleCost κ β a U B G z = fun t =>
-        regulator β U (logFactorClock κ (logLoewnerCoordinates G z t)-
-          logFactorClock κ (logLoewnerCoordinates G z σ))*
-          logVelocity κ (logLoewnerCoordinates G z t) (B t.toNNReal)^2 := by
-      funext t
-      rw [actualSingleCost, hstart hlt]
-    rw [he]
-    refine ⟨hw.logFactor_single_intervalIntegrable hB σ T hσT z hz β U,
-      hw.logFactor_single_regulator_integral_le hκ hB σ T hσT z hz hβ hU ?_⟩
-    simpa only [hstart hlt] using hend hlt
-  · exact ⟨by simp, by simp only [intervalIntegral.integral_same]; positivity⟩
-
-def overlapStart (σz σw : ℝ≥0) : ℝ≥0 := max σz σw
-
-def overlapEnd (σz σw Tz Tw : ℝ≥0) : ℝ≥0 := max (overlapStart σz σw) (min Tz Tw)
-
-theorem actualPairCost_bound
-    {κ : ℝ} (hκ : 0 < κ) {B : ℝ≥0 → ℝ} (hB : Continuous B)
-    {γ : ℝ≥0 → ℂ} {G F : ℝ≥0 → ℂ → ℂ}
-    (hw : IsCapacityTwoWitness (fun t => Real.sqrt κ*B t) γ G F)
-    (hgrowth : PublishedDiskUnivalentGrowth) (J : ℂ → ℂ)
-    (hJ : DifferentiableOn ℂ J upperHalfPlane) (hJinj : InjOn J upperHalfPlane)
-    (σz σw Tz Tw : ℝ≥0) (z w : ℂ)
-    (hz : z ∈ survivingDomain γ Tz) (hw' : w ∈ survivingDomain γ Tw) (hne : z ≠ w)
-    (β az aw Uz Uw : ℝ) (hβ : 0 ≤ β) (hM : 0 ≤ exponent (greenExponent κ))
-    (hdecay : 2*(exponent (greenExponent κ)*β) < 2/κ)
-    (hstartz : σz < Tz → logFactorClock κ (logLoewnerCoordinates G z σz) = az)
-    (hstartw : σw < Tw → logFactorClock κ (logLoewnerCoordinates G w σw) = aw)
-    (hgeoz : σz < Tz → σw < Tw → physicalConformalRadius J G σz z ≤ dist (J z) (J w))
-    (hgeow : σz < Tz → σw < Tw → physicalConformalRadius J G σw w ≤ dist (J z) (J w)) :
-    IntervalIntegrable (actualPairCost κ β az aw Uz Uw B G z w) volume
-      (overlapStart σz σw : ℝ) (overlapEnd σz σw Tz Tw : ℝ) ∧
-      (∫ t in (overlapStart σz σw : ℝ)..(overlapEnd σz σw Tz Tw : ℝ),
-        actualPairCost κ β az aw Uz Uw B G z w t) ≤
-          interactionBudget 2 (exponent (greenExponent κ)*(κ*β)) := by
-  have hadm : 2*(exponent (greenExponent κ)*(κ*β)) < 2 := by
-    have hh := (source_pair_exponent_admissible (c := exponent (greenExponent κ)*β) hκ).mpr hdecay
-    convert hh using 1
-    ring
-  by_cases ht : overlapStart σz σw < min Tz Tw
-  · have hzt : σz < Tz := (le_max_left σz σw).trans_lt (ht.trans_le (min_le_left _ _))
-    have hwt : σw < Tw := (le_max_right σz σw).trans_lt (ht.trans_le (min_le_right _ _))
-    have he : actualPairCost κ β az aw Uz Uw B G z w = fun t =>
-        (regulator β Uz (logFactorClock κ (logLoewnerCoordinates G z t)-
-          logFactorClock κ (logLoewnerCoordinates G z σz))*
-         regulator β Uw (logFactorClock κ (logLoewnerCoordinates G w t)-
-          logFactorClock κ (logLoewnerCoordinates G w σw)))^(-exponent (greenExponent κ))*
-         (logVelocity κ (logLoewnerCoordinates G z t) (B t.toNNReal)*
-          logVelocity κ (logLoewnerCoordinates G w t) (B t.toNNReal)) := by
-      funext t
-      rw [actualPairCost, hstartz hzt, hstartw hwt]
-    rw [he, overlapEnd, max_eq_right ht.le]
-    have hzl := survivingDomain_antitone γ (min_le_left Tz Tw) hz
-    have hwl := survivingDomain_antitone γ (min_le_right Tz Tw) hw'
-    exact ⟨hw.logFactor_pair_intervalIntegrable hB σz σw (overlapStart σz σw) (min Tz Tw)
-        (le_max_left _ _) (le_max_right _ _) ht.le z w hzl hwl β _ Uz Uw,
-      hw.logFactor_pair_regulator_integral_le hκ hB hgrowth J hJ hJinj σz σw
-        (overlapStart σz σw) (min Tz Tw) (le_max_left _ _) (le_max_right _ _) ht.le
-        z w hzl hwl hne (hgeoz hzt hwt) (hgeow hzt hwt) hβ hM hdecay Uz Uw⟩
-  · have he : overlapEnd σz σw Tz Tw = overlapStart σz σw :=
-      max_eq_left (le_of_not_gt ht)
-    rw [he]
-    exact ⟨by simp, by simpa only [intervalIntegral.integral_same] using
-      (interactionBudget_pos (by norm_num : (0 : ℝ) < 2) hadm).le⟩
-
-end SLEExactGauge.Multipoint
-
-end
-
-end OAI
+import OAI.Probability.SLE.Multipoint.MultipointLogClockTransport
+import OAI.Probability.SLE.Multipoint.MultipointGlobalDiscount
+
+namespace OAI
+
+/-! The raw active costs and their bounds on individual completion
+intervals. Disjoint active intervals contribute zero pair cost. -/
+
+noncomputable section
+open Set MeasureTheory
+open scoped NNReal
+
+namespace SLEExactGauge.Multipoint
+
+def actualSingleCost (κ β a U : ℝ) (B : ℝ≥0 → ℝ)
+    (G : ℝ≥0 → ℂ → ℂ) (z : ℂ) (t : ℝ) : ℝ :=
+  regulator β U (logFactorClock κ (logLoewnerCoordinates G z t)-a)*
+    logVelocity κ (logLoewnerCoordinates G z t) (B t.toNNReal)^2
+
+def actualPairCost (κ β az aw Uz Uw : ℝ) (B : ℝ≥0 → ℝ)
+    (G : ℝ≥0 → ℂ → ℂ) (z w : ℂ) (t : ℝ) : ℝ :=
+  (regulator β Uz (logFactorClock κ (logLoewnerCoordinates G z t)-az)*
+    regulator β Uw (logFactorClock κ (logLoewnerCoordinates G w t)-aw))^(-exponent (greenExponent κ))*
+      (logVelocity κ (logLoewnerCoordinates G z t) (B t.toNNReal)*
+        logVelocity κ (logLoewnerCoordinates G w t) (B t.toNNReal))
+
+lemma actualSingleCost_nonneg (κ β a U : ℝ) (B : ℝ≥0 → ℝ)
+    (G : ℝ≥0 → ℂ → ℂ) (z : ℂ) (t : ℝ) : 0 ≤ actualSingleCost κ β a U B G z t :=
+  mul_nonneg (regulator_pos _ _ _).le (sq_nonneg _)
+
+lemma actualPairCost_nonneg (κ β az aw Uz Uw : ℝ) (B : ℝ≥0 → ℝ)
+    (G : ℝ≥0 → ℂ → ℂ) (z w : ℂ) (t : ℝ) :
+    0 ≤ actualPairCost κ β az aw Uz Uw B G z w t :=
+  mul_nonneg (Real.rpow_nonneg (mul_pos (regulator_pos _ _ _) (regulator_pos _ _ _)).le _)
+    (mul_pos (logVelocity_pos _ _ _) (logVelocity_pos _ _ _)).le
+
+theorem actualSingleCost_bound
+    {κ : ℝ} (hκ : 0 < κ) {B : ℝ≥0 → ℝ} (hB : Continuous B)
+    {γ : ℝ≥0 → ℂ} {G F : ℝ≥0 → ℂ → ℂ}
+    (hw : IsCapacityTwoWitness (fun t => Real.sqrt κ*B t) γ G F)
+    (σ T : ℝ≥0) (hσT : σ ≤ T) (z : ℂ) (hz : z ∈ survivingDomain γ T)
+    (β a U : ℝ) (hβ : 0 < β) (hU : 0 ≤ U)
+    (hstart : σ < T → logFactorClock κ (logLoewnerCoordinates G z σ) = a)
+    (hend : σ < T → logFactorClock κ (logLoewnerCoordinates G z T)-a ≤ U) :
+    IntervalIntegrable (actualSingleCost κ β a U B G z) volume (σ : ℝ) (T : ℝ) ∧
+      (∫ t in (σ : ℝ)..(T : ℝ), actualSingleCost κ β a U B G z t) ≤ 2/(κ*β) := by
+  rcases lt_or_eq_of_le hσT with hlt | rfl
+  · have he : actualSingleCost κ β a U B G z = fun t =>
+        regulator β U (logFactorClock κ (logLoewnerCoordinates G z t)-
+          logFactorClock κ (logLoewnerCoordinates G z σ))*
+          logVelocity κ (logLoewnerCoordinates G z t) (B t.toNNReal)^2 := by
+      funext t
+      rw [actualSingleCost, hstart hlt]
+    rw [he]
+    refine ⟨hw.logFactor_single_intervalIntegrable hB σ T hσT z hz β U,
+      hw.logFactor_single_regulator_integral_le hκ hB σ T hσT z hz hβ hU ?_⟩
+    simpa only [hstart hlt] using hend hlt
+  · exact ⟨by simp, by simp only [intervalIntegral.integral_same]; positivity⟩
+
+def overlapStart (σz σw : ℝ≥0) : ℝ≥0 := max σz σw
+
+def overlapEnd (σz σw Tz Tw : ℝ≥0) : ℝ≥0 := max (overlapStart σz σw) (min Tz Tw)
+
+theorem actualPairCost_bound
+    {κ : ℝ} (hκ : 0 < κ) {B : ℝ≥0 → ℝ} (hB : Continuous B)
+    {γ : ℝ≥0 → ℂ} {G F : ℝ≥0 → ℂ → ℂ}
+    (hw : IsCapacityTwoWitness (fun t => Real.sqrt κ*B t) γ G F)
+    (hgrowth : PublishedDiskUnivalentGrowth) (J : ℂ → ℂ)
+    (hJ : DifferentiableOn ℂ J upperHalfPlane) (hJinj : InjOn J upperHalfPlane)
+    (σz σw Tz Tw : ℝ≥0) (z w : ℂ)
+    (hz : z ∈ survivingDomain γ Tz) (hw' : w ∈ survivingDomain γ Tw) (hne : z ≠ w)
+    (β az aw Uz Uw : ℝ) (hβ : 0 ≤ β) (hM : 0 ≤ exponent (greenExponent κ))
+    (hdecay : 2*(exponent (greenExponent κ)*β) < 2/κ)
+    (hstartz : σz < Tz → logFactorClock κ (logLoewnerCoordinates G z σz) = az)
+    (hstartw : σw < Tw → logFactorClock κ (logLoewnerCoordinates G w σw) = aw)
+    (hgeoz : σz < Tz → σw < Tw → physicalConformalRadius J G σz z ≤ dist (J z) (J w))
+    (hgeow : σz < Tz → σw < Tw → physicalConformalRadius J G σw w ≤ dist (J z) (J w)) :
+    IntervalIntegrable (actualPairCost κ β az aw Uz Uw B G z w) volume
+      (overlapStart σz σw : ℝ) (overlapEnd σz σw Tz Tw : ℝ) ∧
+      (∫ t in (overlapStart σz σw : ℝ)..(overlapEnd σz σw Tz Tw : ℝ),
+        actualPairCost κ β az aw Uz Uw B G z w t) ≤
+          interactionBudget 2 (exponent (greenExponent κ)*(κ*β)) := by
+  have hadm : 2*(exponent (greenExponent κ)*(κ*β)) < 2 := by
+    have hh := (source_pair_exponent_admissible (c := exponent (greenExponent κ)*β) hκ).mpr hdecay
+    convert hh using 1
+    ring
+  by_cases ht : overlapStart σz σw < min Tz Tw
+  · have hzt : σz < Tz := (le_max_left σz σw).trans_lt (ht.trans_le (min_le_left _ _))
+    have hwt : σw < Tw := (le_max_right σz σw).trans_lt (ht.trans_le (min_le_right _ _))
+    have he : actualPairCost κ β az aw Uz Uw B G z w = fun t =>
+        (regulator β Uz (logFactorClock κ (logLoewnerCoordinates G z t)-
+          logFactorClock κ (logLoewnerCoordinates G z σz))*
+         regulator β Uw (logFactorClock κ (logLoewnerCoordinates G w t)-
+          logFactorClock κ (logLoewnerCoordinates G w σw)))^(-exponent (greenExponent κ))*
+         (logVelocity κ (logLoewnerCoordinates G z t) (B t.toNNReal)*
+          logVelocity κ (logLoewnerCoordinates G w t) (B t.toNNReal)) := by
+      funext t
+      rw [actualPairCost, hstartz hzt, hstartw hwt]
+    rw [he, overlapEnd, max_eq_right ht.le]
+    have hzl := survivingDomain_antitone γ (min_le_left Tz Tw) hz
+    have hwl := survivingDomain_antitone γ (min_le_right Tz Tw) hw'
+    exact ⟨hw.logFactor_pair_intervalIntegrable hB σz σw (overlapStart σz σw) (min Tz Tw)
+        (le_max_left _ _) (le_max_right _ _) ht.le z w hzl hwl β _ Uz Uw,
+      hw.logFactor_pair_regulator_integral_le hκ hB hgrowth J hJ hJinj σz σw
+        (overlapStart σz σw) (min Tz Tw) (le_max_left _ _) (le_max_right _ _) ht.le
+        z w hzl hwl hne (hgeoz hzt hwt) (hgeow hzt hwt) hβ hM hdecay Uz Uw⟩
+  · have he : overlapEnd σz σw Tz Tw = overlapStart σz σw :=
+      max_eq_left (le_of_not_gt ht)
+    rw [he]
+    exact ⟨by simp, by simpa only [intervalIntegral.integral_same] using
+      (interactionBudget_pos (by norm_num : (0 : ℝ) < 2) hadm).le⟩
+
+end SLEExactGauge.Multipoint
+
+end
+
+end OAI

lean/OAI/Probability/SLE/Multipoint/MultipointActualBudget.lean

@@ -1,146 +1,146 @@
-import OAI.Probability.SLE.Multipoint.MultipointActualExpectation
-import OAI.Probability.SLE.Multipoint.MultipointCostAssembly
-import OAI.Probability.SLE.Multipoint.MultipointInitialParameters
-
-namespace OAI
-
-/-! The uniform discount budget for the actual, individually stopped
-Loewner coordinates in an arbitrary conformal image. -/
-
-noncomputable section
-open Set Filter MeasureTheory ProbabilityTheory
-open scoped NNReal
-
-namespace SLEExactGauge.Multipoint
-
-theorem actual_localized_discount_le
-    {Ω ι : Type*} [mΩ : MeasurableSpace Ω] [Fintype ι] [DecidableEq ι]
-    {B : ℝ≥0 → Ω → ℝ} {hm : ∀ t, Measurable (B t)}
-    (hBc : ∀ ω, Continuous (fun t => B t ω))
-    {κ β lo hi M : ℝ} (hκ : 0 < κ) (hκ8 : κ < 8) (hβ : 0 < β)
-    (hdecay : 2*(exponent (greenExponent κ)*β) < 2/κ)
-    {H : ℝ≥0} (z : ι → ℂ) (hne : Function.Injective z)
-    (u₀ u₂ : ι → ℝ) (h₀ : ∀ i, 0 ≤ u₀ i) (hu : ∀ i, u₀ i ≤ u₂ i)
-    (γ : Ω → ℝ≥0 → ℂ) (G F : Ω → ℝ≥0 → ℂ → ℂ)
-    (hw : ∀ ω, IsCapacityTwoWitness (fun t => Real.sqrt κ*B t ω) (γ ω) (G ω) (F ω))
-    (S : LocalizedState B hm κ lo hi M H z
-      (fun i => actualFactorStops γ G z u₀ u₂ H (i,2)) γ G)
-    (horder : ∀ ω i, Monotone (fun k => actualFactorStops γ G z u₀ u₂ H (i,k) ω))
-    (hgrowth : PublishedDiskUnivalentGrowth) (J : ℂ → ℂ)
-    (hJ : DifferentiableOn ℂ J upperHalfPlane) (hJinj : InjOn J upperHalfPlane)
-    (R b : ι → ℝ) (hR : ∀ i, 0 < R i) (hb : ∀ i, 0 < b i)
-    (hRdef : ∀ i, R i = 2*(z i).im*‖deriv J (z i)‖)
-    (hu₀ : ∀ i, u₀ i = Real.log (R i/b i))
-    (hsep : ∀ i j, i ≠ j → b i ≤ dist (J (z i)) (J (z j)))
-    (r : ℝ≥0 → Ω → ℝ) (C : ℝ≥0)
-    (hrm : Measurable (Function.uncurry r)) (hrb : ∀ t ω, |r t ω| ≤ C)
-    (hcost : ∀ ω t, t < S.χ ω → r t ω =
-      productDriftCost (patternActiveSet (phaseAt (actualFactorStops γ G z u₀ u₂ H) t ω)) κ
-        (fun i => phaseRegulatorScale β (sourceClockLevel κ (z i) (u₀ i))
-          (κ/4*(u₂ i-u₀ i)) (phaseAt (actualFactorStops γ G z u₀ u₂ H) t ω i))
-        (fun i => phaseRegulatorSlope β (phaseAt (actualFactorStops γ G z u₀ u₂ H) t ω i))
-        (S.Q t ω) (B t ω)) (ω : Ω) :
-    discountClock r (S.χ ω) ω ≤ uniformDiscountBudget κ β (Finset.univ : Finset ι) := by
-  classical
-  let ρ := actualFactorStops γ G z u₀ u₂ H
-  let a := fun i => sourceClockLevel κ (z i) (u₀ i)
-  let U := fun i => κ/4*(u₂ i-u₀ i)
-  let σ := fun i => min (ρ (i,0) ω) (S.χ ω)
-  let T := fun i => min (ρ (i,2) ω) (S.χ ω)
-  have hσT (i : ι) : σ i ≤ T i := min_le_min (horder ω i (by decide : (0 : Fin 3) ≤ 2)) le_rfl
-  have hTH (i : ι) : T i ≤ S.χ ω := min_le_right _ _
-  have hlive (i : ι) : z i ∈ survivingDomain (γ ω) (T i) := (S.actual ω i).1
-  have hσeq (i : ι) (hlt : σ i < T i) : σ i = ρ (i,0) ω := by
-    apply min_eq_left
-    by_contra h
-    have he : σ i = S.χ ω := min_eq_right (le_of_not_ge h)
-    exact (not_lt_of_ge (hTH i)) (he ▸ hlt)
-  have hσχ (i : ι) : σ i ≤ S.χ ω := min_le_right _ _
-  have hστ (i : ι) : σ i ≤ ρ (i,2) ω :=
-    (min_le_left _ _).trans (horder ω i (by decide : (0 : Fin 3) ≤ 2))
-  have hstart (i : ι) (hlt : σ i < T i) :
-      logFactorClock κ (logLoewnerCoordinates (G ω) (z i) (σ i)) = a i := by
-    have he := (S.actual_at ω i (σ i) (hσχ i) (hστ i)).2
-    have hs : actualFactorStops γ G z u₀ u₂ H (i,0) ω = σ i := (hσeq i hlt).symm
-    have hc := actual_phase_switch_clock hBc hκ hw S horder ω i 0
-      (by rw [hs]; exact hσχ i)
-    rw [hs, he] at hc
-    exact sub_eq_zero.mp (by simpa only [ite_true] using hc)
-  have hend (i : ι) :
-      logFactorClock κ (logLoewnerCoordinates (G ω) (z i) (T i))-a i ≤ U i := by
-    have hc := cutoff_radius_strictly_reached_iff (continuous_const.mul (hBc ω))
-      (hw ω) hκ (z i) (u₂ i) ((h₀ i).trans (hu i)) H (T i)
-      ((hTH i).trans (S.bounded ω)) (hlive i) ω
-    have hle : logFactorClock κ (logLoewnerCoordinates (G ω) (z i) (T i)) ≤
-        sourceClockLevel κ (z i) (u₂ i) := by
-      apply le_of_not_gt
-      intro h
-      have ht : ρ (i,2) ω < T i := by
-        simpa only [ρ, actualFactorStops, factorRadiusLevel, Fin.reduceEq, ite_false, cutoffStop] using hc.mpr h
-      exact (not_lt_of_ge (min_le_left _ _)) ht
-    have he : sourceClockLevel κ (z i) (u₂ i) = a i+U i := by
-      dsimp [a,U,sourceClockLevel]
-      ring
-    rw [he] at hle
-    linarith
-  have hgeo (i j : ι) (hij : i ≠ j) (hlt : σ i < T i) :
-      physicalConformalRadius J (G ω) (σ i) (z i) ≤ dist (J (z i)) (J (z j)) := by
-    have hc := hstart i hlt
-    rw [logFactorClock_eq_logRadiusClock κ (Real.log (z i).im)] at hc
-    have he : logRadiusClock (Real.log (z i).im)
-        (logLoewnerCoordinates (G ω) (z i) (σ i)) = Real.log (R i/b i) := by
-      dsimp [a,sourceClockLevel] at hc
-      rw [← hu₀ i]
-      nlinarith [hκ]
-    rw [(hw ω).physical_radius_at_activation (continuous_const.mul (hBc ω)) J
-      (z i) (R i) (b i) (hR i) (hb i) (hRdef i) (σ i)
-      (S.actual_at ω i (σ i) (hσχ i) (hστ i)).1 he]
-    exact hsep i j hij
-  have hactive (t : ℝ) (ht : t ∈ Ico 0 (S.χ ω : ℝ)) (i : ι)
-      (hi : i ∈ patternActiveSet (phaseAt ρ t.toNNReal ω)) :
-      (σ i : ℝ) ≤ t ∧ t ≤ (T i : ℝ) := by
-    have ha := (phaseAt_active_iff ρ ω i (horder ω i) t.toNNReal).mp
-      (Finset.mem_filter.mp hi).2
-    have htχ : t.toNNReal ≤ S.χ ω := Real.toNNReal_le_iff_le_coe.mpr ht.2.le
-    constructor
-    · have hh := (min_le_left (ρ (i,0) ω) (S.χ ω)).trans ha.1
-      simpa only [Real.coe_toNNReal t ht.1] using (NNReal.coe_le_coe.mpr hh)
-    · have hh : t.toNNReal ≤ T i := le_min ha.2.le htχ
-      simpa only [Real.coe_toNNReal t ht.1] using (NNReal.coe_le_coe.mpr hh)
-  have hQ (t : ℝ) (ht : t ∈ Ico 0 (S.χ ω : ℝ)) (i : ι)
-      (hi : i ∈ patternActiveSet (phaseAt ρ t.toNNReal ω)) :
-      S.Q t ω i = logLoewnerCoordinates (G ω) (z i) t := by
-    have ha := (phaseAt_active_iff ρ ω i (horder ω i) t.toNNReal).mp
-      (Finset.mem_filter.mp hi).2
-    have hh := (S.actual_at ω i t.toNNReal (Real.toNNReal_le_iff_le_coe.mpr ht.2.le) ha.2.le).2
-    simpa only [Real.coe_toNNReal t ht.1] using hh
-  have hrt : ∀ ω, Measurable (fun t => r t ω) :=
-    fun ω => hrm.comp (measurable_id.prodMk measurable_const)
-  have hri : IntervalIntegrable (fun t : ℝ => r t.toNNReal ω) volume 0 (S.χ ω : ℝ) :=
-    ((bounded_rate_locallyIntegrable r hrt C hrb ω).integrableOn_isCompact isCompact_uIcc).intervalIntegrable
-  have hbound := actual_phase_cost_integral_le hκ hκ8 (hBc ω) (hw ω) hgrowth J hJ hJinj
-    (Finset.univ : Finset ι) z (fun _ _ _ _ he => hne he) β hβ hdecay a U
-    (fun i _ => mul_nonneg (div_nonneg hκ.le (by norm_num)) (sub_nonneg.mpr (hu i)))
-    σ T (S.χ ω) (fun i _ => hσT i) (fun i _ => hTH i) (fun i _ => hlive i)
-    (fun i _ => hstart i) (fun i _ _ => hend i)
-    (fun i _ j _ hij hi _ => hgeo i j hij hi)
-    (fun t => S.Q t ω) (fun t => phaseAt ρ t.toNNReal ω)
-    (fun _ _ => Finset.subset_univ _) hactive hQ
-    (fun t ht i hi => by
-      have hh := (actual_phase_regulator hBc hκ hβ.le h₀ hu hw S horder ω t.toNNReal
-        (Real.toNNReal_le_iff_le_coe.mpr ht.2.le) i (Finset.mem_filter.mp hi).2).1
-      simpa only [Real.coe_toNNReal t ht.1,hQ t ht i hi] using hh)
-    (fun t : ℝ => r t.toNNReal ω) hri
-    (fun t ht => by
-      have htχ : t.toNNReal < S.χ ω := by
-        apply NNReal.coe_lt_coe.mp
-        simpa only [Real.coe_toNNReal t ht.1] using ht.2
-      have hh := hcost ω t.toNNReal htχ
-      simpa only [Real.coe_toNNReal t ht.1] using hh)
-  simpa only [discountClock,Real.toNNReal_coe] using hbound
-
-end SLEExactGauge.Multipoint
-
-end
-
-end OAI
+import OAI.Probability.SLE.Multipoint.MultipointActualExpectation
+import OAI.Probability.SLE.Multipoint.MultipointCostAssembly
+import OAI.Probability.SLE.Multipoint.MultipointInitialParameters
+
+namespace OAI
+
+/-! The uniform discount budget for the actual, individually stopped
+Loewner coordinates in an arbitrary conformal image. -/
+
+noncomputable section
+open Set Filter MeasureTheory ProbabilityTheory
+open scoped NNReal
+
+namespace SLEExactGauge.Multipoint
+
+theorem actual_localized_discount_le
+    {Ω ι : Type*} [mΩ : MeasurableSpace Ω] [Fintype ι] [DecidableEq ι]
+    {B : ℝ≥0 → Ω → ℝ} {hm : ∀ t, Measurable (B t)}
+    (hBc : ∀ ω, Continuous (fun t => B t ω))
+    {κ β lo hi M : ℝ} (hκ : 0 < κ) (hκ8 : κ < 8) (hβ : 0 < β)
+    (hdecay : 2*(exponent (greenExponent κ)*β) < 2/κ)
+    {H : ℝ≥0} (z : ι → ℂ) (hne : Function.Injective z)
+    (u₀ u₂ : ι → ℝ) (h₀ : ∀ i, 0 ≤ u₀ i) (hu : ∀ i, u₀ i ≤ u₂ i)
+    (γ : Ω → ℝ≥0 → ℂ) (G F : Ω → ℝ≥0 → ℂ → ℂ)
+    (hw : ∀ ω, IsCapacityTwoWitness (fun t => Real.sqrt κ*B t ω) (γ ω) (G ω) (F ω))
+    (S : LocalizedState B hm κ lo hi M H z
+      (fun i => actualFactorStops γ G z u₀ u₂ H (i,2)) γ G)
+    (horder : ∀ ω i, Monotone (fun k => actualFactorStops γ G z u₀ u₂ H (i,k) ω))
+    (hgrowth : PublishedDiskUnivalentGrowth) (J : ℂ → ℂ)
+    (hJ : DifferentiableOn ℂ J upperHalfPlane) (hJinj : InjOn J upperHalfPlane)
+    (R b : ι → ℝ) (hR : ∀ i, 0 < R i) (hb : ∀ i, 0 < b i)
+    (hRdef : ∀ i, R i = 2*(z i).im*‖deriv J (z i)‖)
+    (hu₀ : ∀ i, u₀ i = Real.log (R i/b i))
+    (hsep : ∀ i j, i ≠ j → b i ≤ dist (J (z i)) (J (z j)))
+    (r : ℝ≥0 → Ω → ℝ) (C : ℝ≥0)
+    (hrm : Measurable (Function.uncurry r)) (hrb : ∀ t ω, |r t ω| ≤ C)
+    (hcost : ∀ ω t, t < S.χ ω → r t ω =
+      productDriftCost (patternActiveSet (phaseAt (actualFactorStops γ G z u₀ u₂ H) t ω)) κ
+        (fun i => phaseRegulatorScale β (sourceClockLevel κ (z i) (u₀ i))
+          (κ/4*(u₂ i-u₀ i)) (phaseAt (actualFactorStops γ G z u₀ u₂ H) t ω i))
+        (fun i => phaseRegulatorSlope β (phaseAt (actualFactorStops γ G z u₀ u₂ H) t ω i))
+        (S.Q t ω) (B t ω)) (ω : Ω) :
+    discountClock r (S.χ ω) ω ≤ uniformDiscountBudget κ β (Finset.univ : Finset ι) := by
+  classical
+  let ρ := actualFactorStops γ G z u₀ u₂ H
+  let a := fun i => sourceClockLevel κ (z i) (u₀ i)
+  let U := fun i => κ/4*(u₂ i-u₀ i)
+  let σ := fun i => min (ρ (i,0) ω) (S.χ ω)
+  let T := fun i => min (ρ (i,2) ω) (S.χ ω)
+  have hσT (i : ι) : σ i ≤ T i := min_le_min (horder ω i (by decide : (0 : Fin 3) ≤ 2)) le_rfl
+  have hTH (i : ι) : T i ≤ S.χ ω := min_le_right _ _
+  have hlive (i : ι) : z i ∈ survivingDomain (γ ω) (T i) := (S.actual ω i).1
+  have hσeq (i : ι) (hlt : σ i < T i) : σ i = ρ (i,0) ω := by
+    apply min_eq_left
+    by_contra h
+    have he : σ i = S.χ ω := min_eq_right (le_of_not_ge h)
+    exact (not_lt_of_ge (hTH i)) (he ▸ hlt)
+  have hσχ (i : ι) : σ i ≤ S.χ ω := min_le_right _ _
+  have hστ (i : ι) : σ i ≤ ρ (i,2) ω :=
+    (min_le_left _ _).trans (horder ω i (by decide : (0 : Fin 3) ≤ 2))
+  have hstart (i : ι) (hlt : σ i < T i) :
+      logFactorClock κ (logLoewnerCoordinates (G ω) (z i) (σ i)) = a i := by
+    have he := (S.actual_at ω i (σ i) (hσχ i) (hστ i)).2
+    have hs : actualFactorStops γ G z u₀ u₂ H (i,0) ω = σ i := (hσeq i hlt).symm
+    have hc := actual_phase_switch_clock hBc hκ hw S horder ω i 0
+      (by rw [hs]; exact hσχ i)
+    rw [hs, he] at hc
+    exact sub_eq_zero.mp (by simpa only [ite_true] using hc)
+  have hend (i : ι) :
+      logFactorClock κ (logLoewnerCoordinates (G ω) (z i) (T i))-a i ≤ U i := by
+    have hc := cutoff_radius_strictly_reached_iff (continuous_const.mul (hBc ω))
+      (hw ω) hκ (z i) (u₂ i) ((h₀ i).trans (hu i)) H (T i)
+      ((hTH i).trans (S.bounded ω)) (hlive i) ω
+    have hle : logFactorClock κ (logLoewnerCoordinates (G ω) (z i) (T i)) ≤
+        sourceClockLevel κ (z i) (u₂ i) := by
+      apply le_of_not_gt
+      intro h
+      have ht : ρ (i,2) ω < T i := by
+        simpa only [ρ, actualFactorStops, factorRadiusLevel, Fin.reduceEq, ite_false, cutoffStop] using hc.mpr h
+      exact (not_lt_of_ge (min_le_left _ _)) ht
+    have he : sourceClockLevel κ (z i) (u₂ i) = a i+U i := by
+      dsimp [a,U,sourceClockLevel]
+      ring
+    rw [he] at hle
+    linarith
+  have hgeo (i j : ι) (hij : i ≠ j) (hlt : σ i < T i) :
+      physicalConformalRadius J (G ω) (σ i) (z i) ≤ dist (J (z i)) (J (z j)) := by
+    have hc := hstart i hlt
+    rw [logFactorClock_eq_logRadiusClock κ (Real.log (z i).im)] at hc
+    have he : logRadiusClock (Real.log (z i).im)
+        (logLoewnerCoordinates (G ω) (z i) (σ i)) = Real.log (R i/b i) := by
+      dsimp [a,sourceClockLevel] at hc
+      rw [← hu₀ i]
+      nlinarith [hκ]
+    rw [(hw ω).physical_radius_at_activation (continuous_const.mul (hBc ω)) J
+      (z i) (R i) (b i) (hR i) (hb i) (hRdef i) (σ i)
+      (S.actual_at ω i (σ i) (hσχ i) (hστ i)).1 he]
+    exact hsep i j hij
+  have hactive (t : ℝ) (ht : t ∈ Ico 0 (S.χ ω : ℝ)) (i : ι)
+      (hi : i ∈ patternActiveSet (phaseAt ρ t.toNNReal ω)) :
+      (σ i : ℝ) ≤ t ∧ t ≤ (T i : ℝ) := by
+    have ha := (phaseAt_active_iff ρ ω i (horder ω i) t.toNNReal).mp
+      (Finset.mem_filter.mp hi).2
+    have htχ : t.toNNReal ≤ S.χ ω := Real.toNNReal_le_iff_le_coe.mpr ht.2.le
+    constructor
+    · have hh := (min_le_left (ρ (i,0) ω) (S.χ ω)).trans ha.1
+      simpa only [Real.coe_toNNReal t ht.1] using (NNReal.coe_le_coe.mpr hh)
+    · have hh : t.toNNReal ≤ T i := le_min ha.2.le htχ
+      simpa only [Real.coe_toNNReal t ht.1] using (NNReal.coe_le_coe.mpr hh)
+  have hQ (t : ℝ) (ht : t ∈ Ico 0 (S.χ ω : ℝ)) (i : ι)
+      (hi : i ∈ patternActiveSet (phaseAt ρ t.toNNReal ω)) :
+      S.Q t ω i = logLoewnerCoordinates (G ω) (z i) t := by
+    have ha := (phaseAt_active_iff ρ ω i (horder ω i) t.toNNReal).mp
+      (Finset.mem_filter.mp hi).2
+    have hh := (S.actual_at ω i t.toNNReal (Real.toNNReal_le_iff_le_coe.mpr ht.2.le) ha.2.le).2
+    simpa only [Real.coe_toNNReal t ht.1] using hh
+  have hrt : ∀ ω, Measurable (fun t => r t ω) :=
+    fun ω => hrm.comp (measurable_id.prodMk measurable_const)
+  have hri : IntervalIntegrable (fun t : ℝ => r t.toNNReal ω) volume 0 (S.χ ω : ℝ) :=
+    ((bounded_rate_locallyIntegrable r hrt C hrb ω).integrableOn_isCompact isCompact_uIcc).intervalIntegrable
+  have hbound := actual_phase_cost_integral_le hκ hκ8 (hBc ω) (hw ω) hgrowth J hJ hJinj
+    (Finset.univ : Finset ι) z (fun _ _ _ _ he => hne he) β hβ hdecay a U
+    (fun i _ => mul_nonneg (div_nonneg hκ.le (by norm_num)) (sub_nonneg.mpr (hu i)))
+    σ T (S.χ ω) (fun i _ => hσT i) (fun i _ => hTH i) (fun i _ => hlive i)
+    (fun i _ => hstart i) (fun i _ _ => hend i)
+    (fun i _ j _ hij hi _ => hgeo i j hij hi)
+    (fun t => S.Q t ω) (fun t => phaseAt ρ t.toNNReal ω)
+    (fun _ _ => Finset.subset_univ _) hactive hQ
+    (fun t ht i hi => by
+      have hh := (actual_phase_regulator hBc hκ hβ.le h₀ hu hw S horder ω t.toNNReal
+        (Real.toNNReal_le_iff_le_coe.mpr ht.2.le) i (Finset.mem_filter.mp hi).2).1
+      simpa only [Real.coe_toNNReal t ht.1,hQ t ht i hi] using hh)
+    (fun t : ℝ => r t.toNNReal ω) hri
+    (fun t ht => by
+      have htχ : t.toNNReal < S.χ ω := by
+        apply NNReal.coe_lt_coe.mp
+        simpa only [Real.coe_toNNReal t ht.1] using ht.2
+      have hh := hcost ω t.toNNReal htχ
+      simpa only [Real.coe_toNNReal t ht.1] using hh)
+  simpa only [discountClock,Real.toNNReal_coe] using hbound
+
+end SLEExactGauge.Multipoint
+
+end
+
+end OAI

lean/OAI/Probability/SLE/Multipoint/MultipointActualCutoffs.lean

@@ -1,57 +1,57 @@
-import OAI.Probability.SLE.Multipoint.MultipointActualPhases
-
-namespace OAI
-
-/-! A countable family of concrete localizations, with the original
-radius stops capped beyond each integration horizon. -/
-
-noncomputable section
-open Set Filter MeasureTheory ProbabilityTheory
-open scoped NNReal
-
-namespace SLEExactGauge.Multipoint
-
-theorem exists_actual_localizations
-    {Ω ι : Type*} [mΩ : MeasurableSpace Ω] [Fintype ι]
-    {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)
-    (z : ι → ℂ) (hz : ∀ i, z i ∈ upperHalfPlane)
-    (u₀ u₂ : ι → ℝ) (h₀ : ∀ i, 0 ≤ u₀ i) (hu : ∀ i, u₀ i ≤ u₂ i)
-    (γ : Ω → ℝ≥0 → ℂ) (G F : Ω → ℝ≥0 → ℂ → ℂ)
-    (hw : ∀ ω, IsCapacityTwoWitness (fun t => Real.sqrt κ*B t ω) (γ ω) (G ω) (F ω))
-    (A : ℝ) (hA : 0 ≤ A) (hzA : ∀ i, |Real.log (z i).im| ≤ A) :
-    Nonempty (∀ n : ℕ, LocalizedState B hm κ (-(A+n+1)) (A+n+1) (A+n+1)
-      ((n : ℝ≥0)+1) z
-      (fun i => actualFactorStops γ G z u₀ u₂ ((n : ℝ≥0)+1) (i,2)) γ G) := by
-  classical
-  have hn (n : ℕ) : 0 ≤ A+(n : ℝ)+1 := by positivity
-  have hex (n : ℕ) : Nonempty (LocalizedState B hm κ (-(A+n+1)) (A+n+1) (A+n+1)
-      ((n : ℝ≥0)+1) z
-      (fun i => actualFactorStops γ G z u₀ u₂ ((n : ℝ≥0)+1) (i,2)) γ G) := by
-    have ht := (actualFactorStops_regular hB hm hBm hBc hB0 κ hκ hκ8 γ G F hw
-      z hz u₀ u₂ h₀ hu ((n : ℝ≥0)+1)).1
-    apply exists_localizedState B hm hBm hBc κ (-(A+n+1)) (A+n+1) (A+n+1)
-      (by linarith [hn n]) ((n : ℝ≥0)+1) z hz
-    · intro i
-      have hi := (abs_le.mp (hzA i)).1
-      linarith [Nat.cast_nonneg (α := ℝ) n]
-    · intro i
-      have hi := (abs_le.mp (hzA i)).2
-      linarith [Nat.cast_nonneg (α := ℝ) n]
-    · intro ω
-      simpa only [hB0 ω,abs_zero] using hn n
-    · exact fun i => ht (i,2)
-    · exact hw
-  exact ⟨fun n => Classical.choice (hex n)⟩
-
-lemma initial_log_height_bound {ι : Type*} [Fintype ι] (z : ι → ℂ) (i : ι) :
-    |Real.log (z i).im| ≤ ‖fun j => Real.log (z j).im‖ := by
-  simpa only [Real.norm_eq_abs] using norm_le_pi_norm (fun j => Real.log (z j).im) i
-
-end SLEExactGauge.Multipoint
-
-end
-
-end OAI
+import OAI.Probability.SLE.Multipoint.MultipointActualPhases
+
+namespace OAI
+
+/-! A countable family of concrete localizations, with the original
+radius stops capped beyond each integration horizon. -/
+
+noncomputable section
+open Set Filter MeasureTheory ProbabilityTheory
+open scoped NNReal
+
+namespace SLEExactGauge.Multipoint
+
+theorem exists_actual_localizations
+    {Ω ι : Type*} [mΩ : MeasurableSpace Ω] [Fintype ι]
+    {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)
+    (z : ι → ℂ) (hz : ∀ i, z i ∈ upperHalfPlane)
+    (u₀ u₂ : ι → ℝ) (h₀ : ∀ i, 0 ≤ u₀ i) (hu : ∀ i, u₀ i ≤ u₂ i)
+    (γ : Ω → ℝ≥0 → ℂ) (G F : Ω → ℝ≥0 → ℂ → ℂ)
+    (hw : ∀ ω, IsCapacityTwoWitness (fun t => Real.sqrt κ*B t ω) (γ ω) (G ω) (F ω))
+    (A : ℝ) (hA : 0 ≤ A) (hzA : ∀ i, |Real.log (z i).im| ≤ A) :
+    Nonempty (∀ n : ℕ, LocalizedState B hm κ (-(A+n+1)) (A+n+1) (A+n+1)
+      ((n : ℝ≥0)+1) z
+      (fun i => actualFactorStops γ G z u₀ u₂ ((n : ℝ≥0)+1) (i,2)) γ G) := by
+  classical
+  have hn (n : ℕ) : 0 ≤ A+(n : ℝ)+1 := by positivity
+  have hex (n : ℕ) : Nonempty (LocalizedState B hm κ (-(A+n+1)) (A+n+1) (A+n+1)
+      ((n : ℝ≥0)+1) z
+      (fun i => actualFactorStops γ G z u₀ u₂ ((n : ℝ≥0)+1) (i,2)) γ G) := by
+    have ht := (actualFactorStops_regular hB hm hBm hBc hB0 κ hκ hκ8 γ G F hw
+      z hz u₀ u₂ h₀ hu ((n : ℝ≥0)+1)).1
+    apply exists_localizedState B hm hBm hBc κ (-(A+n+1)) (A+n+1) (A+n+1)
+      (by linarith [hn n]) ((n : ℝ≥0)+1) z hz
+    · intro i
+      have hi := (abs_le.mp (hzA i)).1
+      linarith [Nat.cast_nonneg (α := ℝ) n]
+    · intro i
+      have hi := (abs_le.mp (hzA i)).2
+      linarith [Nat.cast_nonneg (α := ℝ) n]
+    · intro ω
+      simpa only [hB0 ω,abs_zero] using hn n
+    · exact fun i => ht (i,2)
+    · exact hw
+  exact ⟨fun n => Classical.choice (hex n)⟩
+
+lemma initial_log_height_bound {ι : Type*} [Fintype ι] (z : ι → ℂ) (i : ι) :
+    |Real.log (z i).im| ≤ ‖fun j => Real.log (z j).im‖ := by
+  simpa only [Real.norm_eq_abs] using norm_le_pi_norm (fun j => Real.log (z j).im) i
+
+end SLEExactGauge.Multipoint
+
+end
+
+end OAI

lean/OAI/Probability/SLE/Multipoint/MultipointActualExpectation.lean

@@ -1,124 +1,124 @@
-import OAI.Probability.SLE.Multipoint.MultipointActualPhases
-import OAI.Probability.SLE.Multipoint.MultipointLocalizedExpectation
-import OAI.Probability.SLE.Multipoint.MultipointSelectedRate
-import OAI.Probability.SLE.Multipoint.MultipointStateBounds
-import OAI.Probability.SLE.Multipoint.MultipointTerminalProbability
-
-namespace OAI
-
-/-! The actual localized multipoint product has expectation at most one.
-The bounded discount process is constructed, not supplied as an input. -/
-
-noncomputable section
-open Set Filter MeasureTheory ProbabilityTheory
-open scoped NNReal
-
-namespace SLEExactGauge.Multipoint
-
-theorem actual_localized_product_expectation
-    {Ω ι : Type*} [mΩ : MeasurableSpace Ω] [Fintype ι] [DecidableEq ι]
-    {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)
-    {κ β lo hi M : ℝ} (hκ : 0 < κ) (hκ8 : κ < 8) (hβ : 0 ≤ β) (hβ1 : β ≤ 1)
-    {H : ℝ≥0} (z : ι → ℂ) (hz : ∀ i, z i ∈ upperHalfPlane)
-    (u₀ u₂ : ι → ℝ) (h₀ : ∀ i, 0 ≤ u₀ i) (hu : ∀ i, u₀ i ≤ u₂ i)
-    (γ : Ω → ℝ≥0 → ℂ) (G F : Ω → ℝ≥0 → ℂ → ℂ)
-    (hw : ∀ ω, IsCapacityTwoWitness (fun t => Real.sqrt κ*B t ω) (γ ω) (G ω) (F ω))
-    (S : LocalizedState B hm κ lo hi M H z
-      (fun i => actualFactorStops γ G z u₀ u₂ H (i,2)) γ G) :
-    let ρ := actualFactorStops γ G z u₀ u₂ H
-    let a := fun i => sourceClockLevel κ (z i) (u₀ i)
-    let U := fun i => κ/4*(u₂ i-u₀ i)
-    ∃ (r : ℝ≥0 → Ω → ℝ) (C : ℝ≥0),
-      Measurable (Function.uncurry r) ∧
-      IsProgressive (Filtration.natural B (fun t => (hm t).stronglyMeasurable)) r ∧
-      (∀ t ω, 0 ≤ r t ω ∧ |r t ω| ≤ C) ∧
-      (∀ ω t, t < S.χ ω → r t ω =
-        productDriftCost (patternActiveSet (phaseAt ρ t ω)) κ
-          (fun i => phaseRegulatorScale β (a i) (U i) (phaseAt ρ t ω i))
-          (fun i => phaseRegulatorSlope β (phaseAt ρ t ω i)) (S.Q t ω) (B t ω)) ∧
-      Integrable (fun ω => discountedPatternProduct κ β a U (phaseAt ρ (S.χ ω) ω)
-        (S.Q (S.χ ω) ω,discountClock r (S.χ ω) ω) (B (S.χ ω) ω)) P ∧
-      (∫ ω, discountedPatternProduct κ β a U (phaseAt ρ (S.χ ω) ω)
-        (S.Q (S.χ ω) ω,discountClock r (S.χ ω) ω) (B (S.χ ω) ω) ∂P) ≤ 1 := by
-  classical
-  let : IsProbabilityMeasure P := hB.isGaussianProcess.isProbabilityMeasure
-  dsimp only
-  let ρ := actualFactorStops γ G z u₀ u₂ H
-  let a := fun i => sourceClockLevel κ (z i) (u₀ i)
-  let U := fun i => κ/4*(u₂ i-u₀ i)
-  let l := factorSwitchList ρ
-  obtain ⟨hρstop,horder,hρbound⟩ := actualFactorStops_regular hB hm hBm hBc hB0
-    κ hκ hκ8 γ G F hw z hz u₀ u₂ h₀ hu H
-  have hlstop := factorSwitchList_forall ρ
-    (fun τ => IsStoppingTime (Filtration.natural B (fun t => (hm t).stronglyMeasurable))
-      (fun ω => (τ ω : WithTop ℝ≥0)))
-    (by
-      simpa only [WithTop.coe_zero] using
-        (isStoppingTime_const (Filtration.natural B (fun t => (hm t).stronglyMeasurable))
-          (0 : ℝ≥0))) hρstop
-  have hlbound := factorSwitchList_forall ρ (fun τ => ∀ ω, τ ω ≤ H+1)
-    (fun _ => bot_le) hρbound
-  have hU (i : ι) : 0 ≤ U i := mul_nonneg (div_nonneg hκ.le (by norm_num)) (sub_nonneg.mpr (hu i))
-  let q₀ := fun i => initialLogCoordinates (z i)
-  have hQ0 (ω : Ω) : S.Q 0 ω = q₀ := funext (S.initial ω)
-  let Qbound := ‖q₀‖+(S.L : ℝ)*(H : ℝ)
-  have hQbound (ω : Ω) (t : ℝ≥0) (ht : t ≤ S.χ ω) : ‖S.Q t ω‖ ≤ Qbound := by
-    have hh := lipschitz_state_norm_le (fun u => S.Q u ω) S.L (S.lipschitz ω)
-      H t t.coe_nonneg (by exact_mod_cast ht.trans (S.bounded ω))
-    simpa only [hQ0 ω] using hh
-  let R₀ := max Qbound M
-  have hR₀ : 0 ≤ R₀ := (by positivity : (0 : ℝ) ≤ Qbound).trans (le_max_left _ _)
-  have hnorm₀ (ω : Ω) (t : ℝ≥0) (ht : t ≤ S.χ ω) : ‖(S.Q t ω,B t ω)‖ ≤ R₀ := by
-    rw [Prod.norm_def,Real.norm_eq_abs]
-    exact max_le_max (hQbound ω t ht) (S.driver_bound ω t ht)
-  obtain ⟨r,C,hrm,hrp,hrb,hcost⟩ := exists_localized_discount_rate B hm hBm hBc
-    S.Q S.measurable S.adapted (fun ω => (S.lipschitz ω).continuous) κ β hκ hκ8 a U
-    ρ l H hlstop hlbound (factorSwitchList_mem ρ) (factorSwitchList_zero ρ)
-    S.χ S.stopping S.bounded R₀ hR₀ hnorm₀
-  have hrt (ω : Ω) : Measurable (fun t => r t ω) :=
-    hrm.comp (measurable_id.prodMk measurable_const)
-  let R := max (max Qbound ((C : ℝ)*(H : ℝ))) M
-  have hR : 0 ≤ R := (by positivity : (0 : ℝ) ≤ Qbound).trans
-    ((le_max_left _ _).trans (le_max_left _ _))
-  have hnorm (ω : Ω) (t : ℝ) (ht : 0 ≤ t) (htχ : t ≤ (S.χ ω : ℝ)) :
-      ‖((S.Q t ω,discountClock r t ω),B t.toNNReal ω)‖ ≤ R :=
-    discounted_state_norm_bound S.Q S.L S.lipschitz q₀ hQ0 r hrt C
-      (fun t ω => (hrb t ω).2) B S.χ H S.bounded M
-      (fun ω t ht => by simpa only [Real.norm_eq_abs] using S.driver_bound ω t ht) ω t ht htχ
-  have hclock (ω : Ω) (i : ι) (k : Fin 3) (hk : ρ (i,k) ω ≤ S.χ ω) :
-      logFactorClock κ (S.Q (ρ (i,k) ω) ω i)-a i =
-        if k = 0 then 0 else if k = 1 then U i/2 else U i :=
-    actual_phase_switch_clock hBc hκ hw S horder ω i k hk
-  obtain ⟨hI,hmean⟩ := localized_pattern_expectation_le hB hm hBm hBc S.Q S.V S.L
-    S.measurable S.adapted S.lipschitz S.velocity_measurable S.velocity_bound S.derivative
-    r hrm hrp C (fun t ω => (hrb t ω).2) κ β hκ hκ8 hβ hβ1 a U hU ρ l H
-    hlstop hlbound (factorSwitchList_mem ρ) horder (factorSwitchList_zero ρ)
-    S.χ S.stopping S.bounded R hR hnorm
-    (fun ω t ht i hi => (actual_phase_regulator hBc hκ hβ h₀ hu hw S horder ω t ht.le i
-      (Finset.mem_filter.mp hi).2).2)
-    (fun ω t ht i hi => S.physical_velocity ω t ht i
-      ((phaseAt_active_iff ρ ω i (horder ω i) t).mp (Finset.mem_filter.mp hi).2).2)
-    hcost hclock
-  refine ⟨r,C,hrm,hrp,hrb,hcost,hI,hmean.trans ?_⟩
-  have hinit (ω : Ω) : discountedPatternProduct κ β a U (phaseAt ρ 0 ω)
-      (S.Q 0 ω,discountClock r 0 ω) (B 0 ω) ≤ 1 := by
-    simp only [discountedPatternProduct, discountClock_initial, neg_zero, Real.exp_zero, one_mul]
-    apply initial_phase_product_le_one κ β hκ hκ8 a U hU ρ ω (horder ω) (S.Q 0 ω) (B 0 ω)
-    intro i k hk
-    have hh := hclock ω i k (by rw [hk]; exact bot_le)
-    simpa only [hk, NNReal.coe_zero] using hh
-  have hnonneg (ω : Ω) : 0 ≤ discountedPatternProduct κ β a U (phaseAt ρ 0 ω)
-      (S.Q 0 ω,discountClock r 0 ω) (B 0 ω) :=
-    mul_nonneg (Real.exp_pos _).le (Finset.prod_nonneg (fun i _ =>
-      (phaseFactor_pos κ β (a i) (U i) (phaseAt ρ 0 ω i) (S.Q 0 ω i) (B 0 ω)).le))
-  simpa only [integral_const,probReal_univ,one_smul] using
-    integral_mono_of_nonneg (μ := P) (ae_of_all P hnonneg)
-      (integrable_const (1 : ℝ)) (ae_of_all P hinit)
-
-end SLEExactGauge.Multipoint
-
-end
-
-end OAI
+import OAI.Probability.SLE.Multipoint.MultipointActualPhases
+import OAI.Probability.SLE.Multipoint.MultipointLocalizedExpectation
+import OAI.Probability.SLE.Multipoint.MultipointSelectedRate
+import OAI.Probability.SLE.Multipoint.MultipointStateBounds
+import OAI.Probability.SLE.Multipoint.MultipointTerminalProbability
+
+namespace OAI
+
+/-! The actual localized multipoint product has expectation at most one.
+The bounded discount process is constructed, not supplied as an input. -/
+
+noncomputable section
+open Set Filter MeasureTheory ProbabilityTheory
+open scoped NNReal
+
+namespace SLEExactGauge.Multipoint
+
+theorem actual_localized_product_expectation
+    {Ω ι : Type*} [mΩ : MeasurableSpace Ω] [Fintype ι] [DecidableEq ι]
+    {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)
+    {κ β lo hi M : ℝ} (hκ : 0 < κ) (hκ8 : κ < 8) (hβ : 0 ≤ β) (hβ1 : β ≤ 1)
+    {H : ℝ≥0} (z : ι → ℂ) (hz : ∀ i, z i ∈ upperHalfPlane)
+    (u₀ u₂ : ι → ℝ) (h₀ : ∀ i, 0 ≤ u₀ i) (hu : ∀ i, u₀ i ≤ u₂ i)
+    (γ : Ω → ℝ≥0 → ℂ) (G F : Ω → ℝ≥0 → ℂ → ℂ)
+    (hw : ∀ ω, IsCapacityTwoWitness (fun t => Real.sqrt κ*B t ω) (γ ω) (G ω) (F ω))
+    (S : LocalizedState B hm κ lo hi M H z
+      (fun i => actualFactorStops γ G z u₀ u₂ H (i,2)) γ G) :
+    let ρ := actualFactorStops γ G z u₀ u₂ H
+    let a := fun i => sourceClockLevel κ (z i) (u₀ i)
+    let U := fun i => κ/4*(u₂ i-u₀ i)
+    ∃ (r : ℝ≥0 → Ω → ℝ) (C : ℝ≥0),
+      Measurable (Function.uncurry r) ∧
+      IsProgressive (Filtration.natural B (fun t => (hm t).stronglyMeasurable)) r ∧
+      (∀ t ω, 0 ≤ r t ω ∧ |r t ω| ≤ C) ∧
+      (∀ ω t, t < S.χ ω → r t ω =
+        productDriftCost (patternActiveSet (phaseAt ρ t ω)) κ
+          (fun i => phaseRegulatorScale β (a i) (U i) (phaseAt ρ t ω i))
+          (fun i => phaseRegulatorSlope β (phaseAt ρ t ω i)) (S.Q t ω) (B t ω)) ∧
+      Integrable (fun ω => discountedPatternProduct κ β a U (phaseAt ρ (S.χ ω) ω)
+        (S.Q (S.χ ω) ω,discountClock r (S.χ ω) ω) (B (S.χ ω) ω)) P ∧
+      (∫ ω, discountedPatternProduct κ β a U (phaseAt ρ (S.χ ω) ω)
+        (S.Q (S.χ ω) ω,discountClock r (S.χ ω) ω) (B (S.χ ω) ω) ∂P) ≤ 1 := by
+  classical
+  let : IsProbabilityMeasure P := hB.isGaussianProcess.isProbabilityMeasure
+  dsimp only
+  let ρ := actualFactorStops γ G z u₀ u₂ H
+  let a := fun i => sourceClockLevel κ (z i) (u₀ i)
+  let U := fun i => κ/4*(u₂ i-u₀ i)
+  let l := factorSwitchList ρ
+  obtain ⟨hρstop,horder,hρbound⟩ := actualFactorStops_regular hB hm hBm hBc hB0
+    κ hκ hκ8 γ G F hw z hz u₀ u₂ h₀ hu H
+  have hlstop := factorSwitchList_forall ρ
+    (fun τ => IsStoppingTime (Filtration.natural B (fun t => (hm t).stronglyMeasurable))
+      (fun ω => (τ ω : WithTop ℝ≥0)))
+    (by
+      simpa only [WithTop.coe_zero] using
+        (isStoppingTime_const (Filtration.natural B (fun t => (hm t).stronglyMeasurable))
+          (0 : ℝ≥0))) hρstop
+  have hlbound := factorSwitchList_forall ρ (fun τ => ∀ ω, τ ω ≤ H+1)
+    (fun _ => bot_le) hρbound
+  have hU (i : ι) : 0 ≤ U i := mul_nonneg (div_nonneg hκ.le (by norm_num)) (sub_nonneg.mpr (hu i))
+  let q₀ := fun i => initialLogCoordinates (z i)
+  have hQ0 (ω : Ω) : S.Q 0 ω = q₀ := funext (S.initial ω)
+  let Qbound := ‖q₀‖+(S.L : ℝ)*(H : ℝ)
+  have hQbound (ω : Ω) (t : ℝ≥0) (ht : t ≤ S.χ ω) : ‖S.Q t ω‖ ≤ Qbound := by
+    have hh := lipschitz_state_norm_le (fun u => S.Q u ω) S.L (S.lipschitz ω)
+      H t t.coe_nonneg (by exact_mod_cast ht.trans (S.bounded ω))
+    simpa only [hQ0 ω] using hh
+  let R₀ := max Qbound M
+  have hR₀ : 0 ≤ R₀ := (by positivity : (0 : ℝ) ≤ Qbound).trans (le_max_left _ _)
+  have hnorm₀ (ω : Ω) (t : ℝ≥0) (ht : t ≤ S.χ ω) : ‖(S.Q t ω,B t ω)‖ ≤ R₀ := by
+    rw [Prod.norm_def,Real.norm_eq_abs]
+    exact max_le_max (hQbound ω t ht) (S.driver_bound ω t ht)
+  obtain ⟨r,C,hrm,hrp,hrb,hcost⟩ := exists_localized_discount_rate B hm hBm hBc
+    S.Q S.measurable S.adapted (fun ω => (S.lipschitz ω).continuous) κ β hκ hκ8 a U
+    ρ l H hlstop hlbound (factorSwitchList_mem ρ) (factorSwitchList_zero ρ)
+    S.χ S.stopping S.bounded R₀ hR₀ hnorm₀
+  have hrt (ω : Ω) : Measurable (fun t => r t ω) :=
+    hrm.comp (measurable_id.prodMk measurable_const)
+  let R := max (max Qbound ((C : ℝ)*(H : ℝ))) M
+  have hR : 0 ≤ R := (by positivity : (0 : ℝ) ≤ Qbound).trans
+    ((le_max_left _ _).trans (le_max_left _ _))
+  have hnorm (ω : Ω) (t : ℝ) (ht : 0 ≤ t) (htχ : t ≤ (S.χ ω : ℝ)) :
+      ‖((S.Q t ω,discountClock r t ω),B t.toNNReal ω)‖ ≤ R :=
+    discounted_state_norm_bound S.Q S.L S.lipschitz q₀ hQ0 r hrt C
+      (fun t ω => (hrb t ω).2) B S.χ H S.bounded M
+      (fun ω t ht => by simpa only [Real.norm_eq_abs] using S.driver_bound ω t ht) ω t ht htχ
+  have hclock (ω : Ω) (i : ι) (k : Fin 3) (hk : ρ (i,k) ω ≤ S.χ ω) :
+      logFactorClock κ (S.Q (ρ (i,k) ω) ω i)-a i =
+        if k = 0 then 0 else if k = 1 then U i/2 else U i :=
+    actual_phase_switch_clock hBc hκ hw S horder ω i k hk
+  obtain ⟨hI,hmean⟩ := localized_pattern_expectation_le hB hm hBm hBc S.Q S.V S.L
+    S.measurable S.adapted S.lipschitz S.velocity_measurable S.velocity_bound S.derivative
+    r hrm hrp C (fun t ω => (hrb t ω).2) κ β hκ hκ8 hβ hβ1 a U hU ρ l H
+    hlstop hlbound (factorSwitchList_mem ρ) horder (factorSwitchList_zero ρ)
+    S.χ S.stopping S.bounded R hR hnorm
+    (fun ω t ht i hi => (actual_phase_regulator hBc hκ hβ h₀ hu hw S horder ω t ht.le i
+      (Finset.mem_filter.mp hi).2).2)
+    (fun ω t ht i hi => S.physical_velocity ω t ht i
+      ((phaseAt_active_iff ρ ω i (horder ω i) t).mp (Finset.mem_filter.mp hi).2).2)
+    hcost hclock
+  refine ⟨r,C,hrm,hrp,hrb,hcost,hI,hmean.trans ?_⟩
+  have hinit (ω : Ω) : discountedPatternProduct κ β a U (phaseAt ρ 0 ω)
+      (S.Q 0 ω,discountClock r 0 ω) (B 0 ω) ≤ 1 := by
+    simp only [discountedPatternProduct, discountClock_initial, neg_zero, Real.exp_zero, one_mul]
+    apply initial_phase_product_le_one κ β hκ hκ8 a U hU ρ ω (horder ω) (S.Q 0 ω) (B 0 ω)
+    intro i k hk
+    have hh := hclock ω i k (by rw [hk]; exact bot_le)
+    simpa only [hk, NNReal.coe_zero] using hh
+  have hnonneg (ω : Ω) : 0 ≤ discountedPatternProduct κ β a U (phaseAt ρ 0 ω)
+      (S.Q 0 ω,discountClock r 0 ω) (B 0 ω) :=
+    mul_nonneg (Real.exp_pos _).le (Finset.prod_nonneg (fun i _ =>
+      (phaseFactor_pos κ β (a i) (U i) (phaseAt ρ 0 ω i) (S.Q 0 ω i) (B 0 ω)).le))
+  simpa only [integral_const,probReal_univ,one_smul] using
+    integral_mono_of_nonneg (μ := P) (ae_of_all P hnonneg)
+      (integrable_const (1 : ℝ)) (ae_of_all P hinit)
+
+end SLEExactGauge.Multipoint
+
+end
+
+end OAI

lean/OAI/Probability/SLE/Multipoint/MultipointActualPhases.lean

@@ -1,163 +1,163 @@
-import OAI.Probability.SLE.Multipoint.MultipointLocalizedState
-import OAI.Probability.SLE.Multipoint.MultipointRadiusStatus
-import OAI.Probability.SLE.Multipoint.MultipointPhaseRegulator
-
-namespace OAI
-
-/-! The three actual radius stops and their phase identities along the
-constructed localized state. -/
-
-noncomputable section
-open Set Filter MeasureTheory ProbabilityTheory
-open scoped NNReal
-
-namespace SLEExactGauge.Multipoint
-
-def factorRadiusLevel (u₀ u₂ : ℝ) (k : Fin 3) : ℝ :=
-  if k = 0 then u₀ else if k = 1 then (u₀+u₂)/2 else u₂
-
-lemma factorRadiusLevel_nonneg {u₀ u₂ : ℝ} (h₀ : 0 ≤ u₀) (h₂ : 0 ≤ u₂) (k : Fin 3) :
-    0 ≤ factorRadiusLevel u₀ u₂ k := by
-  fin_cases k <;> norm_num [factorRadiusLevel] <;> positivity
-
-lemma factorRadiusLevel_monotone {u₀ u₂ : ℝ} (hu : u₀ ≤ u₂) :
-    Monotone (factorRadiusLevel u₀ u₂) := by
-  intro i j hij
-  fin_cases i <;> fin_cases j <;> norm_num [factorRadiusLevel] at * <;> linarith
-
-def actualFactorStops {Ω ι : Type*} (γ : Ω → ℝ≥0 → ℂ)
-    (G : Ω → ℝ≥0 → ℂ → ℂ) (z : ι → ℂ) (u₀ u₂ : ι → ℝ) (H : ℝ≥0)
-    (k : ι × Fin 3) : Ω → ℝ≥0 :=
-  cutoffStop (fun ω => radiusLevelTime (γ ω) (G ω) (z k.1)
-    (factorRadiusLevel (u₀ k.1) (u₂ k.1) k.2)) (H+1)
-
-def factorSwitchList {Ω ι : Type*} [Fintype ι]
-    (ρ : (ι × Fin 3) → Ω → ℝ≥0) : List (Ω → ℝ≥0) :=
-  (fun _ => 0) :: (Finset.univ.toList.map ρ)
-
-lemma factorSwitchList_zero {Ω ι : Type*} [Fintype ι]
-    (ρ : (ι × Fin 3) → Ω → ℝ≥0) : (fun _ : Ω => (0 : ℝ≥0)) ∈ factorSwitchList ρ := by
-  simp only [factorSwitchList, List.mem_cons, true_or]
-
-lemma factorSwitchList_mem {Ω ι : Type*} [Fintype ι]
-    (ρ : (ι × Fin 3) → Ω → ℝ≥0) (k : ι × Fin 3) : ρ k ∈ factorSwitchList ρ := by
-  exact List.mem_cons_of_mem _ (List.mem_map.mpr ⟨k,Finset.mem_toList.mpr (Finset.mem_univ _),rfl⟩)
-
-lemma factorSwitchList_forall {Ω ι : Type*} [Fintype ι]
-    (ρ : (ι × Fin 3) → Ω → ℝ≥0) (P : (Ω → ℝ≥0) → Prop)
-    (hzero : P (fun _ => 0)) (hρ : ∀ k, P (ρ k)) : ∀ τ ∈ factorSwitchList ρ, P τ := by
-  intro τ hτ
-  rcases List.mem_cons.mp hτ with rfl | hτ
-  · exact hzero
-  · obtain ⟨k,_,rfl⟩ := List.mem_map.mp hτ
-    exact hρ k
-
-theorem actualFactorStops_regular {Ω ι : Type*} [mΩ : 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 ω))
-    (z : ι → ℂ) (hz : ∀ i, z i ∈ upperHalfPlane) (u₀ u₂ : ι → ℝ)
-    (h₀ : ∀ i, 0 ≤ u₀ i) (hu : ∀ i, u₀ i ≤ u₂ i) (H : ℝ≥0) :
-    (∀ k, IsStoppingTime (Filtration.natural B (fun t => (hm t).stronglyMeasurable))
-      (fun ω => (actualFactorStops γ G z u₀ u₂ H k ω : WithTop ℝ≥0))) ∧
-    (∀ ω i, Monotone (fun k => actualFactorStops γ G z u₀ u₂ H (i,k) ω)) ∧
-    (∀ k ω, actualFactorStops γ G z u₀ u₂ H k ω ≤ H+1) := by
-  refine ⟨?_,?_,?_⟩
-  · intro k
-    exact cutoffStop_stopping _ _ (actual_radiusLevelTime_stopping hB hm hBm hBc hB0 κ hκ hκ8
-      γ G F hw (z k.1) (hz k.1) _ (factorRadiusLevel_nonneg (h₀ k.1) ((h₀ k.1).trans (hu k.1)) k.2)) (H+1)
-  · intro ω i j k hjk
-    apply cutoffStop_mono _ (H+1) ω
-    intro ω'
-    exact radiusLevelTime_mono (continuous_const.mul (hBc ω')) (hw ω') (z i)
-      (factorRadiusLevel_nonneg (h₀ i) ((h₀ i).trans (hu i)) j)
-      (factorRadiusLevel_monotone (hu i) hjk)
-  · exact fun k ω => cutoffStop_le_horizon _ _ ω
-
-lemma LocalizedState.actual_at {Ω ι : Type*} [mΩ : MeasurableSpace Ω] [Fintype ι]
-    {B : ℝ≥0 → Ω → ℝ} {hm : ∀ t, Measurable (B t)}
-    {κ lo hi M : ℝ} {H : ℝ≥0} {z : ι → ℂ} {τ : ι → Ω → ℝ≥0}
-    {γ : Ω → ℝ≥0 → ℂ} {G : Ω → ℝ≥0 → ℂ → ℂ}
-    (S : LocalizedState B hm κ lo hi M H z τ γ G)
-    (ω : Ω) (i : ι) (t : ℝ≥0) (htχ : t ≤ S.χ ω) (htτ : t ≤ τ i ω) :
-    z i ∈ survivingDomain (γ ω) t ∧ S.Q t ω i = logLoewnerCoordinates (G ω) (z i) t := by
-  have ht : t ≤ min (τ i ω) (S.χ ω) := le_min htτ htχ
-  exact ⟨survivingDomain_antitone (γ ω) ht (S.actual ω i).1,
-    (S.actual ω i).2 ⟨t.coe_nonneg, by exact_mod_cast ht⟩⟩
-
-theorem actual_phase_regulator
-    {Ω ι : Type*} [mΩ : MeasurableSpace Ω] [Fintype ι]
-    {B : ℝ≥0 → Ω → ℝ} {hm : ∀ t, Measurable (B t)}
-    (hBc : ∀ ω, Continuous (fun t => B t ω))
-    {κ lo hi M β : ℝ} (hκ : 0 < κ) (hβ : 0 ��� β) {H : ℝ≥0}
-    {z : ι → ℂ} {u₀ u₂ : ι → ℝ} (h₀ : ∀ i, 0 ≤ u₀ i) (hu : ∀ i, u₀ i ≤ u₂ i)
-    {γ : Ω → ℝ≥0 → ℂ} {G F : Ω → ℝ≥0 → ℂ → ℂ}
-    (hw : ∀ ω, IsCapacityTwoWitness (fun t => Real.sqrt κ*B t ω) (γ ω) (G ω) (F ω))
-    (S : LocalizedState B hm κ lo hi M H z
-      (fun i => actualFactorStops γ G z u₀ u₂ H (i,2)) γ G)
-    (horder : ∀ ω i, Monotone (fun k => actualFactorStops γ G z u₀ u₂ H (i,k) ω))
-    (ω : Ω) (t : ℝ≥0) (htχ : t ≤ S.χ ω) (i : ι)
-    (hactive : phaseActive (phaseAt (actualFactorStops γ G z u₀ u₂ H) t ω i)) :
-    let a := sourceClockLevel κ (z i) (u₀ i)
-    let U := κ/4*(u₂ i-u₀ i)
-    let j := phaseAt (actualFactorStops γ G z u₀ u₂ H) t ω i
-    branchRegulator κ (phaseRegulatorScale β a U j) (phaseRegulatorSlope β j) (S.Q t ω i) =
-      regulator β U (logFactorClock κ (S.Q t ω i)-a) ∧
-    branchRegulator κ (phaseRegulatorScale β a U j) (phaseRegulatorSlope β j) (S.Q t ω i) ≤ 1 := by
-  have htt := ((phaseAt_active_iff _ ω i (horder ω i) t).mp hactive).2.le
-  obtain ⟨hlive,he⟩ := S.actual_at ω i t htχ htt
-  have hh := cutoff_radius_factor_thresholds (continuous_const.mul (hBc ω)) (hw ω) hκ
-    (z i) (u₀ i) (u₂ i) (h₀ i) ((h₀ i).trans (hu i)) H t
-    (htχ.trans (S.bounded ω)) hlive ω
-  dsimp only at hh ⊢
-  apply phaseAt_regulator_eq_and_le_one _ ω i (horder ω i) t κ β
-    (sourceClockLevel κ (z i) (u₀ i)) (κ/4*(u₂ i-u₀ i)) hβ (S.Q t ω i) hactive
-  · intro ht
-    rw [he]
-    exact hh.1.mp ht
-  · intro ht
-    rw [he]
-    apply le_of_not_gt
-    intro h
-    exact (not_le_of_gt ht) (hh.2.1.mpr h.le)
-  · intro ht
-    rw [he]
-    exact hh.2.1.mp ht
-  · intro ht
-    rw [he]
-    apply le_of_not_gt
-    intro h
-    exact (not_le_of_gt ht) (hh.2.2.1.mpr h.le)
-
-theorem actual_phase_switch_clock
-    {Ω ι : Type*} [mΩ : MeasurableSpace Ω] [Fintype ι]
-    {B : ℝ≥0 → Ω → ℝ} {hm : ∀ t, Measurable (B t)}
-    (hBc : ∀ ω, Continuous (fun t => B t ω))
-    {κ lo hi M : ℝ} (hκ : 0 < κ) {H : ℝ≥0}
-    {z : ι → ℂ} {u₀ u₂ : ι → ℝ}
-    {γ : Ω → ℝ≥0 → ℂ} {G F : Ω → ℝ≥0 → ℂ → ℂ}
-    (hw : ∀ ω, IsCapacityTwoWitness (fun t => Real.sqrt κ*B t ω) (γ ω) (G ω) (F ω))
-    (S : LocalizedState B hm κ lo hi M H z
-      (fun i => actualFactorStops γ G z u₀ u₂ H (i,2)) γ G)
-    (horder : ∀ ω i, Monotone (fun k => actualFactorStops γ G z u₀ u₂ H (i,k) ω))
-    (ω : Ω) (i : ι) (k : Fin 3)
-    (hk : actualFactorStops γ G z u₀ u₂ H (i,k) ω ≤ S.χ ω) :
-    logFactorClock κ (S.Q (actualFactorStops γ G z u₀ u₂ H (i,k) ω) ω i)-
-      sourceClockLevel κ (z i) (u₀ i) =
-      if k = 0 then 0 else if k = 1 then (κ/4*(u₂ i-u₀ i))/2 else κ/4*(u₂ i-u₀ i) := by
-  let t := actualFactorStops γ G z u₀ u₂ H (i,k) ω
-  have htτ : t ≤ actualFactorStops γ G z u₀ u₂ H (i,2) ω := horder ω i (Fin.le_last k)
-  obtain ⟨hlive,he⟩ := S.actual_at ω i t hk htτ
-  have hclock := (cutoff_radius_eq_iff (continuous_const.mul (hBc ω)) (hw ω) hκ
-    (z i) (factorRadiusLevel (u₀ i) (u₂ i) k) H t (hk.trans (S.bounded ω)) hlive ω).mp rfl
-  rw [he,hclock]
-  fin_cases k <;> norm_num [factorRadiusLevel, sourceClockLevel] <;> ring
-
-end SLEExactGauge.Multipoint
-
-end
-
-end OAI
+import OAI.Probability.SLE.Multipoint.MultipointLocalizedState
+import OAI.Probability.SLE.Multipoint.MultipointRadiusStatus
+import OAI.Probability.SLE.Multipoint.MultipointPhaseRegulator
+
+namespace OAI
+
+/-! The three actual radius stops and their phase identities along the
+constructed localized state. -/
+
+noncomputable section
+open Set Filter MeasureTheory ProbabilityTheory
+open scoped NNReal
+
+namespace SLEExactGauge.Multipoint
+
+def factorRadiusLevel (u₀ u₂ : ℝ) (k : Fin 3) : ℝ :=
+  if k = 0 then u₀ else if k = 1 then (u₀+u₂)/2 else u₂
+
+lemma factorRadiusLevel_nonneg {u₀ u₂ : ℝ} (h₀ : 0 ≤ u₀) (h₂ : 0 ≤ u₂) (k : Fin 3) :
+    0 ≤ factorRadiusLevel u₀ u₂ k := by
+  fin_cases k <;> norm_num [factorRadiusLevel] <;> positivity
+
+lemma factorRadiusLevel_monotone {u₀ u₂ : ℝ} (hu : u₀ ≤ u₂) :
+    Monotone (factorRadiusLevel u₀ u₂) := by
+  intro i j hij
+  fin_cases i <;> fin_cases j <;> norm_num [factorRadiusLevel] at * <;> linarith
+
+def actualFactorStops {Ω ι : Type*} (γ : Ω → ℝ≥0 → ℂ)
+    (G : Ω → ℝ≥0 → ℂ → ℂ) (z : ι → ℂ) (u₀ u₂ : ι → ℝ) (H : ℝ≥0)
+    (k : ι × Fin 3) : Ω → ℝ≥0 :=
+  cutoffStop (fun ω => radiusLevelTime (γ ω) (G ω) (z k.1)
+    (factorRadiusLevel (u₀ k.1) (u₂ k.1) k.2)) (H+1)
+
+def factorSwitchList {Ω ι : Type*} [Fintype ι]
+    (ρ : (ι × Fin 3) → Ω → ℝ≥0) : List (Ω → ℝ≥0) :=
+  (fun _ => 0) :: (Finset.univ.toList.map ρ)
+
+lemma factorSwitchList_zero {Ω ι : Type*} [Fintype ι]
+    (ρ : (ι × Fin 3) → Ω → ℝ≥0) : (fun _ : Ω => (0 : ℝ≥0)) ∈ factorSwitchList ρ := by
+  simp only [factorSwitchList, List.mem_cons, true_or]
+
+lemma factorSwitchList_mem {Ω ι : Type*} [Fintype ι]
+    (ρ : (ι × Fin 3) → Ω → ℝ≥0) (k : ι × Fin 3) : ρ k ∈ factorSwitchList ρ := by
+  exact List.mem_cons_of_mem _ (List.mem_map.mpr ⟨k,Finset.mem_toList.mpr (Finset.mem_univ _),rfl⟩)
+
+lemma factorSwitchList_forall {Ω ι : Type*} [Fintype ι]
+    (ρ : (ι × Fin 3) → Ω → ℝ≥0) (P : (Ω → ℝ≥0) → Prop)
+    (hzero : P (fun _ => 0)) (hρ : ∀ k, P (ρ k)) : ∀ τ ∈ factorSwitchList ρ, P τ := by
+  intro τ hτ
+  rcases List.mem_cons.mp hτ with rfl | hτ
+  · exact hzero
+  · obtain ⟨k,_,rfl⟩ := List.mem_map.mp hτ
+    exact hρ k
+
+theorem actualFactorStops_regular {Ω ι : Type*} [mΩ : 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 ω))
+    (z : ι → ℂ) (hz : ∀ i, z i ∈ upperHalfPlane) (u₀ u₂ : ι → ℝ)
+    (h₀ : ∀ i, 0 ≤ u₀ i) (hu : ∀ i, u₀ i ≤ u₂ i) (H : ℝ≥0) :
+    (∀ k, IsStoppingTime (Filtration.natural B (fun t => (hm t).stronglyMeasurable))
+      (fun ω => (actualFactorStops γ G z u₀ u₂ H k ω : WithTop ℝ≥0))) ∧
+    (∀ ω i, Monotone (fun k => actualFactorStops γ G z u₀ u₂ H (i,k) ω)) ∧
+    (∀ k ω, actualFactorStops γ G z u₀ u₂ H k ω ≤ H+1) := by
+  refine ⟨?_,?_,?_⟩
+  · intro k
+    exact cutoffStop_stopping _ _ (actual_radiusLevelTime_stopping hB hm hBm hBc hB0 κ hκ hκ8
+      γ G F hw (z k.1) (hz k.1) _ (factorRadiusLevel_nonneg (h₀ k.1) ((h₀ k.1).trans (hu k.1)) k.2)) (H+1)
+  · intro ω i j k hjk
+    apply cutoffStop_mono _ (H+1) ω
+    intro ω'
+    exact radiusLevelTime_mono (continuous_const.mul (hBc ω')) (hw ω') (z i)
+      (factorRadiusLevel_nonneg (h₀ i) ((h₀ i).trans (hu i)) j)
+      (factorRadiusLevel_monotone (hu i) hjk)
+  · exact fun k ω => cutoffStop_le_horizon _ _ ω
+
+lemma LocalizedState.actual_at {Ω ι : Type*} [mΩ : MeasurableSpace Ω] [Fintype ι]
+    {B : ℝ≥0 → Ω → ℝ} {hm : ∀ t, Measurable (B t)}
+    {κ lo hi M : ℝ} {H : ℝ≥0} {z : ι → ℂ} {τ : ι → Ω → ℝ≥0}
+    {γ : Ω → ℝ≥0 → ℂ} {G : Ω → ℝ≥0 → ℂ → ℂ}
+    (S : LocalizedState B hm κ lo hi M H z τ γ G)
+    (ω : Ω) (i : ι) (t : ℝ≥0) (htχ : t ≤ S.χ ω) (htτ : t ≤ τ i ω) :
+    z i ∈ survivingDomain (γ ω) t ∧ S.Q t ω i = logLoewnerCoordinates (G ω) (z i) t := by
+  have ht : t ≤ min (τ i ω) (S.χ ω) := le_min htτ htχ
+  exact ⟨survivingDomain_antitone (γ ω) ht (S.actual ω i).1,
+    (S.actual ω i).2 ⟨t.coe_nonneg, by exact_mod_cast ht⟩⟩
+
+theorem actual_phase_regulator
+    {Ω ι : Type*} [mΩ : MeasurableSpace Ω] [Fintype ι]
+    {B : ℝ≥0 → Ω → ℝ} {hm : ∀ t, Measurable (B t)}
+    (hBc : ∀ ω, Continuous (fun t => B t ω))
+    {κ lo hi M β : ℝ} (hκ : 0 < κ) (hβ : 0 ≤ β) {H : ℝ≥0}
+    {z : ι → ℂ} {u₀ u₂ : ι → ℝ} (h₀ : ∀ i, 0 ≤ u₀ i) (hu : ∀ i, u₀ i ≤ u₂ i)
+    {γ : Ω → ℝ≥0 → ℂ} {G F : Ω → ℝ≥0 → ℂ → ℂ}
+    (hw : ∀ ω, IsCapacityTwoWitness (fun t => Real.sqrt κ*B t ω) (γ ω) (G ω) (F ω))
+    (S : LocalizedState B hm κ lo hi M H z
+      (fun i => actualFactorStops γ G z u₀ u₂ H (i,2)) γ G)
+    (horder : ∀ ω i, Monotone (fun k => actualFactorStops γ G z u₀ u₂ H (i,k) ω))
+    (ω : Ω) (t : ℝ≥0) (htχ : t ≤ S.χ ω) (i : ι)
+    (hactive : phaseActive (phaseAt (actualFactorStops γ G z u₀ u₂ H) t ω i)) :
+    let a := sourceClockLevel κ (z i) (u₀ i)
+    let U := κ/4*(u₂ i-u₀ i)
+    let j := phaseAt (actualFactorStops γ G z u₀ u₂ H) t ω i
+    branchRegulator κ (phaseRegulatorScale β a U j) (phaseRegulatorSlope β j) (S.Q t ω i) =
+      regulator β U (logFactorClock κ (S.Q t ω i)-a) ∧
+    branchRegulator κ (phaseRegulatorScale β a U j) (phaseRegulatorSlope β j) (S.Q t ω i) ≤ 1 := by
+  have htt := ((phaseAt_active_iff _ ω i (horder ω i) t).mp hactive).2.le
+  obtain ⟨hlive,he⟩ := S.actual_at ω i t htχ htt
+  have hh := cutoff_radius_factor_thresholds (continuous_const.mul (hBc ω)) (hw ω) hκ
+    (z i) (u₀ i) (u₂ i) (h₀ i) ((h₀ i).trans (hu i)) H t
+    (htχ.trans (S.bounded ω)) hlive ω
+  dsimp only at hh ⊢
+  apply phaseAt_regulator_eq_and_le_one _ ω i (horder ω i) t κ β
+    (sourceClockLevel κ (z i) (u₀ i)) (κ/4*(u₂ i-u₀ i)) hβ (S.Q t ω i) hactive
+  · intro ht
+    rw [he]
+    exact hh.1.mp ht
+  · intro ht
+    rw [he]
+    apply le_of_not_gt
+    intro h
+    exact (not_le_of_gt ht) (hh.2.1.mpr h.le)
+  · intro ht
+    rw [he]
+    exact hh.2.1.mp ht
+  · intro ht
+    rw [he]
+    apply le_of_not_gt
+    intro h
+    exact (not_le_of_gt ht) (hh.2.2.1.mpr h.le)
+
+theorem actual_phase_switch_clock
+    {Ω ι : Type*} [mΩ : MeasurableSpace Ω] [Fintype ι]
+    {B : ℝ≥0 → Ω → ℝ} {hm : ∀ t, Measurable (B t)}
+    (hBc : ∀ ω, Continuous (fun t => B t ω))
+    {κ lo hi M : ℝ} (hκ : 0 < κ) {H : ℝ≥0}
+    {z : ι → ℂ} {u₀ u₂ : ι → ℝ}
+    {γ : Ω → ℝ≥0 → ℂ} {G F : Ω → ℝ≥0 → ℂ → ℂ}
+    (hw : ∀ ω, IsCapacityTwoWitness (fun t => Real.sqrt κ*B t ω) (γ ω) (G ω) (F ω))
+    (S : LocalizedState B hm κ lo hi M H z
+      (fun i => actualFactorStops γ G z u₀ u₂ H (i,2)) γ G)
+    (horder : ∀ ω i, Monotone (fun k => actualFactorStops γ G z u₀ u₂ H (i,k) ω))
+    (ω : Ω) (i : ι) (k : Fin 3)
+    (hk : actualFactorStops γ G z u₀ u₂ H (i,k) ω ≤ S.χ ω) :
+    logFactorClock κ (S.Q (actualFactorStops γ G z u₀ u₂ H (i,k) ω) ω i)-
+      sourceClockLevel κ (z i) (u₀ i) =
+      if k = 0 then 0 else if k = 1 then (κ/4*(u₂ i-u₀ i))/2 else κ/4*(u₂ i-u₀ i) := by
+  let t := actualFactorStops γ G z u₀ u₂ H (i,k) ω
+  have htτ : t ≤ actualFactorStops γ G z u₀ u₂ H (i,2) ω := horder ω i (Fin.le_last k)
+  obtain ⟨hlive,he⟩ := S.actual_at ω i t hk htτ
+  have hclock := (cutoff_radius_eq_iff (continuous_const.mul (hBc ω)) (hw ω) hκ
+    (z i) (factorRadiusLevel (u₀ i) (u₂ i) k) H t (hk.trans (S.bounded ω)) hlive ω).mp rfl
+  rw [he,hclock]
+  fin_cases k <;> norm_num [factorRadiusLevel, sourceClockLevel] <;> ring
+
+end SLEExactGauge.Multipoint
+
+end
+
+end OAI

lean/OAI/Probability/SLE/Multipoint/MultipointActualProbability.lean

@@ -1,86 +1,86 @@
-import OAI.Probability.SLE.Multipoint.MultipointActualBudget
-import OAI.Probability.SLE.Multipoint.MultipointActualCutoffs
-import OAI.Probability.SLE.Multipoint.MultipointCompletionExhaustion
-
-namespace OAI
-
-/-! The fixed-order radius estimate in an arbitrary conformal image.
-The only analytic input not proved here is the stated disk growth bound. -/
-
-noncomputable section
-open Set Filter MeasureTheory ProbabilityTheory
-open scoped NNReal ENNReal
-
-namespace SLEExactGauge.Multipoint
-
-theorem actual_radius_multipoint_bound
-    {Ω ι : Type*} [mΩ : MeasurableSpace Ω] [Fintype ι] [DecidableEq ι]
-    {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) (J : ℂ → ℂ)
-    (hJ : DifferentiableOn ℂ J upperHalfPlane) (hJinj : InjOn J upperHalfPlane)
-    (z : ι → ℂ) (hz : ∀ i, z i ∈ upperHalfPlane) (hne : Function.Injective z)
-    (R b e : ι → ℝ) (he : ∀ i, 0 < e i) (heb : ∀ i, e i ≤ b i)
-    (hbR : ∀ i, b i ≤ R i) (hRdef : ∀ i, R i = 2*(z i).im*‖deriv J (z i)‖)
-    (hsep : ∀ i j, i ≠ j → b i ≤ dist (J (z i)) (J (z j))) :
-    P {ω | ∀ i, radiusLevelTime (γ ω) (G ω) (z i) (Real.log (R i/e i)) < ⊤} ≤
-      ENNReal.ofReal ((3 : ℝ)^(Fintype.card ι) *
-        Real.exp (uniformDiscountBudget κ (sourceBeta κ) (Finset.univ : Finset ι)) *
-        ∏ i, (e i/b i)^(1-κ/8)) := by
-  classical
-  let u₀ := fun i => Real.log (R i/b i)
-  let u₂ := fun i => Real.log (R i/e i)
-  let a := fun i => sourceClockLevel κ (z i) (u₀ i)
-  let U := fun i => κ/4*(u₂ i-u₀ i)
-  let A := ‖fun i => Real.log (z i).im‖
-  let K := uniformDiscountBudget κ (sourceBeta κ) (Finset.univ : Finset ι)
-  have hb (i : ι) : 0 < b i := (he i).trans_le (heb i)
-  have hR (i : ι) : 0 < R i := (hb i).trans_le (hbR i)
-  have hparams (i : ι) := physical_radius_level_parameters hκ (z i)
-    (R i) (b i) (e i) (he i) (heb i) (hbR i)
-  have h₀ (i : ι) : 0 ≤ u₀ i := (hparams i).1
-  have hu (i : ι) : u₀ i ≤ u₂ i := (hparams i).2.1
-  have hU (i : ι) : U i = sourceTarget κ (b i) (e i) := by
-    have hh := (hparams i).2.2.2.1
-    dsimp [U,u₀,u₂,sourceClockLevel] at *
-    linarith
-  obtain ⟨_,hβ,hβ1,hdecay,_⟩ := source_parameters hκ hκ8
-  obtain ⟨S⟩ := exists_actual_localizations hB hm hBm hBc hB0 hκ hκ8 z hz u₀ u₂ h₀ hu
-    γ G F hw A (norm_nonneg _) (initial_log_height_bound z)
-  let ρ := fun n : ℕ => actualFactorStops γ G z u₀ u₂ ((n : ℝ≥0)+1)
-  have horder (n : ℕ) := (actualFactorStops_regular hB hm hBm hBc hB0 κ hκ hκ8
-    γ G F hw z hz u₀ u₂ h₀ hu ((n : ℝ≥0)+1)).2.1
-  have hex (n : ℕ) := actual_localized_product_expectation hB hm hBm hBc hB0 hκ hκ8
-    hβ.le hβ1 z hz u₀ u₂ h₀ hu γ G F hw (S n)
-  choose r C hrm hrp hrb hcost hI hmean using hex
-  let E := {ω | ∀ i, radiusLevelTime (γ ω) (G ω) (z i) (u₂ i) < ⊤}
-  let cutoff := fun n => {ω | phaseAt (ρ n) ((S n).χ ω) ω = fun _ => 3}
-  have hcover : ∀ ω ∈ E, ∀ᶠ n : ℕ in atTop, ω ∈ cutoff n := by
-    intro ω hω
-    filter_upwards [eventually_all_completed_of_finite_radius_levels B hm hBc κ A
-      (norm_nonneg _) z u₀ u₂ γ G F hw S ω hω] with n hn
-    exact hn.2
-  have hbudget (n : ℕ) (ω : Ω) : discountClock (r n) ((S n).χ ω) ω ≤ K :=
-    actual_localized_discount_le hBc hκ hκ8 hβ hdecay z hne u₀ u₂ h₀ hu γ G F hw
-      (S n) (horder n) hgrowth J hJ hJinj R b hR hb hRdef (fun _ => rfl) hsep
-      (r n) (C n) (hrm n) (fun t ω => (hrb n t ω).2) (hcost n) ω
-  have hbound := measure_le_of_completed_phase_products P E cutoff κ (sourceBeta κ) a U K
-    (fun n ω => phaseAt (ρ n) ((S n).χ ω) ω)
-    (fun n ω => (S n).Q ((S n).χ ω) ω)
-    (fun n ω => discountClock (r n) ((S n).χ ω) ω)
-    (fun n ω => B ((S n).χ ω) ω)
-    hcover hI hmean (fun _ _ h => h) (fun n ω _ => hbudget n ω)
-  have hexp := source_radius_targets_exponential (Finset.univ : Finset ι) hκ b e
-    (fun i _ => hb i) (fun i _ => he i)
-  simpa only [E,u₂,K,show U = (fun i => sourceTarget κ (b i) (e i)) from funext hU,
-    hexp] using hbound
-
-end SLEExactGauge.Multipoint
-
-end
-
-end OAI
+import OAI.Probability.SLE.Multipoint.MultipointActualBudget
+import OAI.Probability.SLE.Multipoint.MultipointActualCutoffs
+import OAI.Probability.SLE.Multipoint.MultipointCompletionExhaustion
+
+namespace OAI
+
+/-! The fixed-order radius estimate in an arbitrary conformal image.
+The only analytic input not proved here is the stated disk growth bound. -/
+
+noncomputable section
+open Set Filter MeasureTheory ProbabilityTheory
+open scoped NNReal ENNReal
+
+namespace SLEExactGauge.Multipoint
+
+theorem actual_radius_multipoint_bound
+    {Ω ι : Type*} [mΩ : MeasurableSpace Ω] [Fintype ι] [DecidableEq ι]
+    {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) (J : ℂ → ℂ)
+    (hJ : DifferentiableOn ℂ J upperHalfPlane) (hJinj : InjOn J upperHalfPlane)
+    (z : ι → ℂ) (hz : ∀ i, z i ∈ upperHalfPlane) (hne : Function.Injective z)
+    (R b e : ι → ℝ) (he : ∀ i, 0 < e i) (heb : ∀ i, e i ≤ b i)
+    (hbR : ∀ i, b i ≤ R i) (hRdef : ∀ i, R i = 2*(z i).im*‖deriv J (z i)‖)
+    (hsep : ∀ i j, i ≠ j → b i ≤ dist (J (z i)) (J (z j))) :
+    P {ω | ∀ i, radiusLevelTime (γ ω) (G ω) (z i) (Real.log (R i/e i)) < ⊤} ≤
+      ENNReal.ofReal ((3 : ℝ)^(Fintype.card ι) *
+        Real.exp (uniformDiscountBudget κ (sourceBeta κ) (Finset.univ : Finset ι)) *
+        ∏ i, (e i/b i)^(1-κ/8)) := by
+  classical
+  let u₀ := fun i => Real.log (R i/b i)
+  let u₂ := fun i => Real.log (R i/e i)
+  let a := fun i => sourceClockLevel κ (z i) (u₀ i)
+  let U := fun i => κ/4*(u₂ i-u₀ i)
+  let A := ‖fun i => Real.log (z i).im‖
+  let K := uniformDiscountBudget κ (sourceBeta κ) (Finset.univ : Finset ι)
+  have hb (i : ι) : 0 < b i := (he i).trans_le (heb i)
+  have hR (i : ι) : 0 < R i := (hb i).trans_le (hbR i)
+  have hparams (i : ι) := physical_radius_level_parameters hκ (z i)
+    (R i) (b i) (e i) (he i) (heb i) (hbR i)
+  have h₀ (i : ι) : 0 ≤ u₀ i := (hparams i).1
+  have hu (i : ι) : u₀ i ≤ u₂ i := (hparams i).2.1
+  have hU (i : ι) : U i = sourceTarget κ (b i) (e i) := by
+    have hh := (hparams i).2.2.2.1
+    dsimp [U,u₀,u₂,sourceClockLevel] at *
+    linarith
+  obtain ⟨_,hβ,hβ1,hdecay,_⟩ := source_parameters hκ hκ8
+  obtain ⟨S⟩ := exists_actual_localizations hB hm hBm hBc hB0 hκ hκ8 z hz u₀ u₂ h₀ hu
+    γ G F hw A (norm_nonneg _) (initial_log_height_bound z)
+  let ρ := fun n : ℕ => actualFactorStops γ G z u₀ u₂ ((n : ℝ≥0)+1)
+  have horder (n : ℕ) := (actualFactorStops_regular hB hm hBm hBc hB0 κ hκ hκ8
+    γ G F hw z hz u₀ u₂ h₀ hu ((n : ℝ≥0)+1)).2.1
+  have hex (n : ℕ) := actual_localized_product_expectation hB hm hBm hBc hB0 hκ hκ8
+    hβ.le hβ1 z hz u₀ u₂ h₀ hu γ G F hw (S n)
+  choose r C hrm hrp hrb hcost hI hmean using hex
+  let E := {ω | ∀ i, radiusLevelTime (γ ω) (G ω) (z i) (u₂ i) < ⊤}
+  let cutoff := fun n => {ω | phaseAt (ρ n) ((S n).χ ω) ω = fun _ => 3}
+  have hcover : ∀ ω ∈ E, ∀ᶠ n : ℕ in atTop, ω ∈ cutoff n := by
+    intro ω hω
+    filter_upwards [eventually_all_completed_of_finite_radius_levels B hm hBc κ A
+      (norm_nonneg _) z u₀ u₂ γ G F hw S ω hω] with n hn
+    exact hn.2
+  have hbudget (n : ℕ) (ω : Ω) : discountClock (r n) ((S n).χ ω) ω ≤ K :=
+    actual_localized_discount_le hBc hκ hκ8 hβ hdecay z hne u₀ u₂ h₀ hu γ G F hw
+      (S n) (horder n) hgrowth J hJ hJinj R b hR hb hRdef (fun _ => rfl) hsep
+      (r n) (C n) (hrm n) (fun t ω => (hrb n t ω).2) (hcost n) ω
+  have hbound := measure_le_of_completed_phase_products P E cutoff κ (sourceBeta κ) a U K
+    (fun n ω => phaseAt (ρ n) ((S n).χ ω) ω)
+    (fun n ω => (S n).Q ((S n).χ ω) ω)
+    (fun n ω => discountClock (r n) ((S n).χ ω) ω)
+    (fun n ω => B ((S n).χ ω) ω)
+    hcover hI hmean (fun _ _ h => h) (fun n ω _ => hbudget n ω)
+  have hexp := source_radius_targets_exponential (Finset.univ : Finset ι) hκ b e
+    (fun i _ => hb i) (fun i _ => he i)
+  simpa only [E,u₂,K,show U = (fun i => sourceTarget κ (b i) (e i)) from funext hU,
+    hexp] using hbound
+
+end SLEExactGauge.Multipoint
+
+end
+
+end OAI

lean/OAI/Probability/SLE/Multipoint/MultipointAngular.lean

@@ -1,289 +1,289 @@
-import OAI.Probability.SLE.Multipoint.MultipointRegularizer
-
-namespace OAI
-
-/-! The angular generator calculation for the regularized factors of the
-fixed-order multipoint radius estimate. The angular clock has generator
-`(1/2)∂² + ((1-p)/2) cot(θ) ∂`, with `p = 4a-1`. -/
-
-noncomputable section
-open Set
-
-namespace SLEExactGauge.Multipoint
-
-def sinePower (r θ : ℝ) : ℝ := Real.sin θ ^ r
-
-def sinePowerFirst (r θ : ℝ) : ℝ := r * Real.sin θ ^ (r-1) * Real.cos θ
-
-def sinePowerSecond (r θ : ℝ) : ℝ :=
-  r * (r-1) * Real.sin θ ^ (r-2) * Real.cos θ ^ 2 - r * Real.sin θ ^ r
-
-lemma sinePower_hasDerivAt {r θ : ℝ} (hθ : Real.sin θ ≠ 0) :
-    HasDerivAt (sinePower r) (sinePowerFirst r θ) θ := by
-  apply ((Real.hasDerivAt_sin θ).rpow_const (p := r) (Or.inl hθ)).congr_deriv
-  unfold sinePowerFirst
-  ring
-
-lemma sinePowerFirst_hasDerivAt {r θ : ℝ} (hθ : Real.sin θ ≠ 0) :
-    HasDerivAt (sinePowerFirst r) (sinePowerSecond r θ) θ := by
-  have hd := (((Real.hasDerivAt_sin θ).rpow_const (p := r-1) (Or.inl hθ)).const_mul r).mul
-    (Real.hasDerivAt_cos θ)
-  apply hd.congr_deriv
-  dsimp only [sinePowerSecond]
-  rw [show r-1-1 = r-2 by ring]
-  have hs : Real.sin θ ^ (r-1) * Real.sin θ = Real.sin θ ^ r := by
-    rw [← Real.rpow_add_one hθ]
-    congr 1
-    ring
-  calc
-    _ = r * (r-1) * Real.sin θ ^ (r-2) * Real.cos θ ^ 2 -
-        r * (Real.sin θ ^ (r-1) * Real.sin θ) := by ring
-    _ = _ := by rw [hs]
-
-def sineGenerator (p r θ : ℝ) : ℝ :=
-  sinePowerSecond r θ / 2 + (1-p)/2 * (Real.cos θ/Real.sin θ) * sinePowerFirst r θ
-
-lemma sineGenerator_eq {p r θ : ℝ} (hθ : 0 < Real.sin θ) :
-    sineGenerator p r θ = r*(r-p)/2 * Real.sin θ ^ (r-2) -
-      r*(r+1-p)/2 * Real.sin θ ^ r := by
-  unfold sineGenerator sinePowerSecond sinePowerFirst
-  rw [Real.rpow_sub hθ, Real.rpow_sub hθ, Real.rpow_two, Real.rpow_one]
-  have hcos : Real.cos θ ^ 2 = 1 - Real.sin θ ^ 2 := by
-    nlinarith [Real.sin_sq_add_cos_sq θ]
-  rw [hcos]
-  field_simp [hθ.ne']
-  ring_nf
-  rw [hcos]
-  ring
-
-lemma sineGenerator_eigen {p θ : ℝ} (hθ : 0 < Real.sin θ) :
-    sineGenerator p p θ + p/2 * sinePower p θ = 0 := by
-  rw [sineGenerator_eq hθ]
-  unfold sinePower
-  ring
-
-def angularFactor (p δ θ : ℝ) : ℝ := sinePower p θ + δ*(1+sinePower (q p) θ)
-
-def damping (p δ θ : ℝ) : ℝ := δ / angularFactor p δ θ * sinePower (q p-2) θ
-
-def negativeDrift (p : ℝ) : ℝ := q p * (p-q p)/2
-
-def driftAllowance (p : ℝ) : ℝ := p/2 + (p-q p)*(1+q p)/2 + 2
-
-lemma negativeDrift_pos {p : ℝ} (hp : 0 < p) : 0 < negativeDrift p := by
-  exact div_pos (mul_pos (q_pos hp) (sub_pos.mpr (q_lt_p hp))) (by norm_num)
-
-lemma driftAllowance_pos {p : ℝ} (hp : 0 < p) : 0 < driftAllowance p := by
-  have hq := q_pos hp
-  have hqp := q_lt_p hp
-  dsimp [driftAllowance]
-  positivity
-
-lemma angularFactor_pos {p δ θ : ℝ} (hδ : 0 < δ) (hθ : 0 < Real.sin θ) :
-    0 < angularFactor p δ θ := by
-  unfold angularFactor sinePower
-  positivity
-
-/-- Exact algebraic drift before estimating its negative singular term. -/
-lemma regularized_generator {p δ σ θ : ℝ} (hθ : 0 < Real.sin θ) :
-    sineGenerator p p θ + δ*sineGenerator p (q p) θ +
-      (p/2)*angularFactor p δ θ + δ*σ*(1+sinePower (q p) θ) =
-    δ*(p/2 + (p-q p)*(1+q p)/2*sinePower (q p) θ -
-      negativeDrift p*sinePower (q p-2) θ + σ*(1+sinePower (q p) θ)) := by
-  rw [sineGenerator_eq hθ, sineGenerator_eq hθ]
-  unfold angularFactor sinePower negativeDrift
-  ring
-
-lemma regularized_bracket_le {p σ θ : ℝ} (hp : 0 < p)
-    (hσ : σ ≤ 1) (hθ : 0 ≤ Real.sin θ) (hθ1 : Real.sin θ ≤ 1) :
-    p/2 + (p-q p)*(1+q p)/2*sinePower (q p) θ -
-      negativeDrift p*sinePower (q p-2) θ + σ*(1+sinePower (q p) θ) ≤
-    driftAllowance p - negativeDrift p*sinePower (q p-2) θ := by
-  have hs0 : 0 ≤ sinePower (q p) θ := Real.rpow_nonneg hθ _
-  have hs1 : sinePower (q p) θ ≤ 1 := Real.rpow_le_one hθ hθ1 (q_pos hp).le
-  have hk : 0 ≤ (p-q p)*(1+q p)/2 := by
-    have := q_lt_p hp
-    have := q_pos hp
-    positivity
-  have h1 := mul_le_mul_of_nonneg_left hs1 hk
-  have h2 := mul_le_mul_of_nonneg_right hσ (by linarith : 0 ≤ 1+sinePower (q p) θ)
-  unfold driftAllowance
-  nlinarith
-
-lemma angularFactor_ge_delta {p δ θ : ℝ} (hδ : 0 ≤ δ) (hθ : 0 ≤ Real.sin θ) :
-    δ ≤ angularFactor p δ θ := by
-  unfold angularFactor sinePower
-  have hp := Real.rpow_nonneg hθ p
-  have hq := Real.rpow_nonneg hθ (q p)
-  nlinarith
-
-lemma angularFactor_le_three {p δ θ : ℝ} (hp : 0 < p)
-    (hδ : 0 ≤ δ) (hδ1 : δ ≤ 1) (hθ : 0 ≤ Real.sin θ) :
-    angularFactor p δ θ ≤ 3 := by
-  have hp1 : sinePower p θ ≤ 1 := Real.rpow_le_one hθ (Real.sin_le_one θ) hp.le
-  have hq1 : sinePower (q p) θ ≤ 1 := Real.rpow_le_one hθ (Real.sin_le_one θ) (q_pos hp).le
-  have hq0 : 0 ≤ sinePower (q p) θ := Real.rpow_nonneg hθ _
-  unfold angularFactor
-  nlinarith
-
-lemma angularFactor_endpoint_bounds {p θ : ℝ} (hp : 0 < p) (hθ : 0 ≤ Real.sin θ) :
-    1 ≤ angularFactor p 1 θ ∧ angularFactor p 1 θ ≤ 3 :=
-  ⟨angularFactor_ge_delta zero_le_one hθ,
-    angularFactor_le_three hp zero_le_one le_rfl hθ⟩
-
-def angularFactorFirst (p δ θ : ℝ) : ℝ :=
-  sinePowerFirst p θ + δ*sinePowerFirst (q p) θ
-
-lemma angularFactor_hasDerivAt {p δ θ : ℝ} (hθ : Real.sin θ ≠ 0) :
-    HasDerivAt (angularFactor p δ) (angularFactorFirst p δ θ) θ := by
-  apply ((sinePower_hasDerivAt (r := p) hθ).add
-    (((hasDerivAt_const θ 1).add (sinePower_hasDerivAt (r := q p) hθ)).const_mul δ)).congr_deriv
-  simp only [angularFactorFirst, zero_add]
-
-lemma angularFactorFirst_bound {p δ θ : ℝ} (hp : 0 < p)
-    (hδ : 0 ≤ δ) (hδ1 : δ ≤ 1) (hθ : 0 < Real.sin θ) :
-    |angularFactorFirst p δ θ| ≤ (p+q p)*Real.sin θ ^ (q p-1) := by
-  have hpq : Real.sin θ ^ (p-1) ≤ Real.sin θ ^ (q p-1) :=
-    Real.rpow_le_rpow_of_exponent_ge hθ (Real.sin_le_one θ) (by linarith [q_lt_p hp])
-  have hq := (q_pos hp).le
-  have hpow : 0 ≤ Real.sin θ ^ (q p-1) := Real.rpow_nonneg hθ.le _
-  have hcos : |Real.cos θ| ≤ 1 := abs_le.mpr ⟨Real.neg_one_le_cos θ, Real.cos_le_one θ⟩
-  have hfirst (r : ℝ) (hr : 0 ≤ r) : |sinePowerFirst r θ| ≤ r * Real.sin θ ^ (r-1) := by
-    unfold sinePowerFirst
-    rw [abs_mul, abs_of_nonneg (mul_nonneg hr (Real.rpow_nonneg hθ.le _))]
-    exact mul_le_of_le_one_right (mul_nonneg hr (Real.rpow_nonneg hθ.le _)) hcos
-  calc
-    _ ≤ |sinePowerFirst p θ| + |δ*sinePowerFirst (q p) θ| := abs_add_le _ _
-    _ = |sinePowerFirst p θ| + δ*|sinePowerFirst (q p) θ| := by
-      rw [abs_mul, abs_of_nonneg hδ]
-    _ ≤ p*Real.sin θ ^ (p-1) + δ*(q p*Real.sin θ ^ (q p-1)) :=
-      add_le_add (hfirst p hp.le) (mul_le_mul_of_nonneg_left (hfirst (q p) hq) hδ)
-    _ ≤ p*Real.sin θ ^ (q p-1) + q p*Real.sin θ ^ (q p-1) :=
-      add_le_add (mul_le_mul_of_nonneg_left hpq hp.le)
-        (mul_le_of_le_one_left (mul_nonneg hq hpow) hδ1)
-    _ = _ := by ring
-
-/-- The singular angular derivative is controlled by the damping term.
-The exponent is chosen so that `eta * (q - 2) = q - 1`. -/
-lemma normalized_angularFactorFirst_bound {p δ θ : ℝ} (hp : 0 < p)
-    (hδ : 0 < δ) (hδ1 : δ ≤ 1) (hθ : 0 < Real.sin θ) :
-    |angularFactorFirst p δ θ| / angularFactor p δ θ ≤
-      (p+q p)*3^(eta p)*δ^(-1-eta p)*(damping p δ θ)^(eta p) := by
-  let f := angularFactor p δ θ
-  let e := eta p
-  have hf : 0 < f := angularFactor_pos hδ hθ
-  have hdf : δ ≤ f := angularFactor_ge_delta hδ.le hθ.le
-  have hf3 : f ≤ 3 := angularFactor_le_three hp hδ.le hδ1 hθ.le
-  have he : 0 < e := eta_pos
-  have hD : 0 < damping p δ θ :=
-    mul_pos (div_pos hδ hf) (Real.rpow_pos_of_pos hθ _)
-  have hidentity : Real.sin θ ^ (q p-1) = (f/δ)^e * (damping p δ θ)^e := by
-    rw [← Real.mul_rpow (div_pos hf hδ).le hD.le]
-    have hcancel : f/δ*damping p δ θ = Real.sin θ ^ (q p-2) := by
-      dsimp [damping, sinePower, f]
-      field_simp [hδ.ne', (angularFactor_pos hδ hθ).ne']
-    rw [hcancel, ← Real.rpow_mul hθ.le]
-    congr 1
-    exact ((mul_comm _ _).trans (eta_identity p)).symm
-  have hpq : 0 ≤ p+q p := add_nonneg hp.le (q_pos hp).le
-  calc
-    _ ≤ ((p+q p)*Real.sin θ ^ (q p-1))/f :=
-      div_le_div_of_nonneg_right (angularFactorFirst_bound hp hδ.le hδ1 hθ) hf.le
-    _ ≤ ((p+q p)*Real.sin θ ^ (q p-1))/δ :=
-      div_le_div_of_nonneg_left (mul_nonneg hpq (Real.rpow_nonneg hθ.le _)) hδ hdf
-    _ = (p+q p)/δ * (f/δ)^e * (damping p δ θ)^e := by rw [hidentity]; ring
-    _ ≤ (p+q p)/δ * (3/δ)^e * (damping p δ θ)^e := by
-      apply mul_le_mul_of_nonneg_right _ (Real.rpow_nonneg hD.le _)
-      apply mul_le_mul_of_nonneg_left _ (div_nonneg hpq hδ.le)
-      exact Real.rpow_le_rpow (div_pos hf hδ).le
-        (div_le_div_of_nonneg_right hf3 hδ.le) he.le
-    _ = _ := by
-      rw [Real.div_rpow (by norm_num : (0:ℝ) ≤ 3) hδ.le,
-        Real.rpow_sub hδ, Real.rpow_neg_one]
-      ring
-
-def driftThreshold (p : ℝ) : ℝ :=
-  (negativeDrift p / (2*driftAllowance p)) ^ (1/(2-q p))
-
-lemma driftThreshold_pos {p : ℝ} (hp : 0 < p) : 0 < driftThreshold p := by
-  exact Real.rpow_pos_of_pos (div_pos (negativeDrift_pos hp)
-    (mul_pos (by norm_num) (driftAllowance_pos hp))) _
-
-lemma driftThreshold_lt_one {p : ℝ} (hp : 0 < p) : driftThreshold p < 1 := by
-  have hq := q_pos hp
-  have hq1 := q_lt_one (p := p)
-  have hqp := q_lt_p hp
-  have hk := negativeDrift_pos hp
-  have hA := driftAllowance_pos hp
-  have hden : 0 < 2-q p := by linarith
-  have hsmall : negativeDrift p < 2*driftAllowance p := by
-    unfold negativeDrift driftAllowance
-    nlinarith [mul_nonneg (sub_nonneg.mpr hq1.le) (sub_nonneg.mpr hqp.le)]
-  exact Real.rpow_lt_one (div_pos hk (by positivity)).le
-    ((div_lt_one (by positivity)).mpr hsmall) (by positivity : 0 < 1/(2-q p))
-
-lemma driftThreshold_identity {p : ℝ} (hp : 0 < p) :
-    negativeDrift p * driftThreshold p ^ (q p-2) = 2*driftAllowance p := by
-  have hk := negativeDrift_pos hp
-  have hA := driftAllowance_pos hp
-  have hq2 : 2-q p ≠ 0 := ne_of_gt (by linarith [q_lt_one (p := p)])
-  unfold driftThreshold
-  rw [← Real.rpow_mul (div_pos hk (by positivity)).le]
-  have he : (1/(2-q p))*(q p-2) = -1 := by field_simp; ring
-  rw [he, Real.rpow_neg_one]
-  field_simp
-
-/-- The negative singular part absorbs the bounded drift at small angles;
-away from the endpoints the denominator supplies a fixed lower bound. -/
-lemma regularized_drift_bound {p δ σ θ : ℝ} (hp : 0 < p)
-    (hδ : 0 < δ) (hσ : σ ≤ 1) (hθ : 0 < Real.sin θ) :
-    δ / angularFactor p δ θ *
-      (p/2 + (p-q p)*(1+q p)/2*sinePower (q p) θ -
-        negativeDrift p*sinePower (q p-2) θ + σ*(1+sinePower (q p) θ)) ≤
-    (driftAllowance p * driftThreshold p ^ (-p))*δ -
-      (negativeDrift p/2)*damping p δ θ := by
-  let f := angularFactor p δ θ
-  let S := sinePower (q p-2) θ
-  let A := driftAllowance p
-  let k := negativeDrift p
-  let h := driftThreshold p
-  have hf : 0 < f := angularFactor_pos hδ hθ
-  have hA : 0 < A := driftAllowance_pos hp
-  have hk : 0 < k := negativeDrift_pos hp
-  have hh : 0 < h := driftThreshold_pos hp
-  have hbr := regularized_bracket_le hp hσ hθ.le (Real.sin_le_one θ)
-  have hstart := mul_le_mul_of_nonneg_left hbr (div_pos hδ hf).le
-  change δ/f * _ ≤ A*h^(-p)*δ - (k/2)*(δ/f*S)
-  apply hstart.trans
-  change δ/f * (A-k*S) ≤ A*h^(-p)*δ - (k/2)*(δ/f*S)
-  by_cases hsmall : Real.sin θ ≤ h
-  · have hS : h^(q p-2) ≤ S :=
-      Real.rpow_le_rpow_of_nonpos hθ hsmall (by linarith [q_lt_one (p := p)])
-    have hcancel : A ≤ k/2*S := by
-      have he := driftThreshold_identity hp
-      change k*h^(q p-2) = 2*A at he
-      nlinarith [mul_le_mul_of_nonneg_left hS hk.le]
-    have hnonneg : 0 ≤ A*h^(-p)*δ := by positivity
-    have hneg := mul_nonpos_of_nonneg_of_nonpos (div_pos hδ hf).le
-      (sub_nonpos.mpr hcancel)
-    nlinarith
-  · have hsp : h^p ≤ Real.sin θ ^ p :=
-      Real.rpow_le_rpow hh.le (le_of_not_ge hsmall) hp.le
-    have hsf : Real.sin θ ^ p ≤ f := by
-      dsimp [f, angularFactor, sinePower]
-      exact le_add_of_nonneg_right (by positivity)
-    have hhpow : 0 < h^p := Real.rpow_pos_of_pos hh _
-    have hquot : δ/f ≤ δ/(h^p) := div_le_div_of_nonneg_left hδ.le hhpow (hsp.trans hsf)
-    have hmain := mul_le_mul_of_nonneg_left hquot hA.le
-    have hS0 : 0 ≤ S := Real.rpow_nonneg hθ.le _
-    have hnonneg : 0 ≤ (k/2)*(δ/f*S) := mul_nonneg (by positivity)
-      (mul_nonneg (div_pos hδ hf).le hS0)
-    rw [Real.rpow_neg hh.le]
-    change A*(δ/f) ≤ A*(δ*(h^p)⁻¹) at hmain
-    nlinarith
-
-end SLEExactGauge.Multipoint
-
-end
-
-end OAI
+import OAI.Probability.SLE.Multipoint.MultipointRegularizer
+
+namespace OAI
+
+/-! The angular generator calculation for the regularized factors of the
+fixed-order multipoint radius estimate. The angular clock has generator
+`(1/2)∂² + ((1-p)/2) cot(θ) ∂`, with `p = 4a-1`. -/
+
+noncomputable section
+open Set
+
+namespace SLEExactGauge.Multipoint
+
+def sinePower (r θ : ℝ) : ℝ := Real.sin θ ^ r
+
+def sinePowerFirst (r θ : ℝ) : ℝ := r * Real.sin θ ^ (r-1) * Real.cos θ
+
+def sinePowerSecond (r θ : ℝ) : ℝ :=
+  r * (r-1) * Real.sin θ ^ (r-2) * Real.cos θ ^ 2 - r * Real.sin θ ^ r
+
+lemma sinePower_hasDerivAt {r θ : ℝ} (hθ : Real.sin θ ≠ 0) :
+    HasDerivAt (sinePower r) (sinePowerFirst r θ) θ := by
+  apply ((Real.hasDerivAt_sin θ).rpow_const (p := r) (Or.inl hθ)).congr_deriv
+  unfold sinePowerFirst
+  ring
+
+lemma sinePowerFirst_hasDerivAt {r θ : ℝ} (hθ : Real.sin θ ≠ 0) :
+    HasDerivAt (sinePowerFirst r) (sinePowerSecond r θ) θ := by
+  have hd := (((Real.hasDerivAt_sin θ).rpow_const (p := r-1) (Or.inl hθ)).const_mul r).mul
+    (Real.hasDerivAt_cos θ)
+  apply hd.congr_deriv
+  dsimp only [sinePowerSecond]
+  rw [show r-1-1 = r-2 by ring]
+  have hs : Real.sin θ ^ (r-1) * Real.sin θ = Real.sin θ ^ r := by
+    rw [← Real.rpow_add_one hθ]
+    congr 1
+    ring
+  calc
+    _ = r * (r-1) * Real.sin θ ^ (r-2) * Real.cos θ ^ 2 -
+        r * (Real.sin θ ^ (r-1) * Real.sin θ) := by ring
+    _ = _ := by rw [hs]
+
+def sineGenerator (p r θ : ℝ) : ℝ :=
+  sinePowerSecond r θ / 2 + (1-p)/2 * (Real.cos θ/Real.sin θ) * sinePowerFirst r θ
+
+lemma sineGenerator_eq {p r θ : ℝ} (hθ : 0 < Real.sin θ) :
+    sineGenerator p r θ = r*(r-p)/2 * Real.sin θ ^ (r-2) -
+      r*(r+1-p)/2 * Real.sin θ ^ r := by
+  unfold sineGenerator sinePowerSecond sinePowerFirst
+  rw [Real.rpow_sub hθ, Real.rpow_sub hθ, Real.rpow_two, Real.rpow_one]
+  have hcos : Real.cos θ ^ 2 = 1 - Real.sin θ ^ 2 := by
+    nlinarith [Real.sin_sq_add_cos_sq θ]
+  rw [hcos]
+  field_simp [hθ.ne']
+  ring_nf
+  rw [hcos]
+  ring
+
+lemma sineGenerator_eigen {p θ : ℝ} (hθ : 0 < Real.sin θ) :
+    sineGenerator p p θ + p/2 * sinePower p θ = 0 := by
+  rw [sineGenerator_eq hθ]
+  unfold sinePower
+  ring
+
+def angularFactor (p δ θ : ℝ) : ℝ := sinePower p θ + δ*(1+sinePower (q p) θ)
+
+def damping (p δ θ : ℝ) : ℝ := δ / angularFactor p δ θ * sinePower (q p-2) θ
+
+def negativeDrift (p : ℝ) : ℝ := q p * (p-q p)/2
+
+def driftAllowance (p : ℝ) : ℝ := p/2 + (p-q p)*(1+q p)/2 + 2
+
+lemma negativeDrift_pos {p : ℝ} (hp : 0 < p) : 0 < negativeDrift p := by
+  exact div_pos (mul_pos (q_pos hp) (sub_pos.mpr (q_lt_p hp))) (by norm_num)
+
+lemma driftAllowance_pos {p : ℝ} (hp : 0 < p) : 0 < driftAllowance p := by
+  have hq := q_pos hp
+  have hqp := q_lt_p hp
+  dsimp [driftAllowance]
+  positivity
+
+lemma angularFactor_pos {p δ θ : ℝ} (hδ : 0 < δ) (hθ : 0 < Real.sin θ) :
+    0 < angularFactor p δ θ := by
+  unfold angularFactor sinePower
+  positivity
+
+/-- Exact algebraic drift before estimating its negative singular term. -/
+lemma regularized_generator {p δ σ θ : ℝ} (hθ : 0 < Real.sin θ) :
+    sineGenerator p p θ + δ*sineGenerator p (q p) θ +
+      (p/2)*angularFactor p δ θ + δ*σ*(1+sinePower (q p) θ) =
+    δ*(p/2 + (p-q p)*(1+q p)/2*sinePower (q p) θ -
+      negativeDrift p*sinePower (q p-2) θ + σ*(1+sinePower (q p) θ)) := by
+  rw [sineGenerator_eq hθ, sineGenerator_eq hθ]
+  unfold angularFactor sinePower negativeDrift
+  ring
+
+lemma regularized_bracket_le {p σ θ : ℝ} (hp : 0 < p)
+    (hσ : σ ≤ 1) (hθ : 0 ≤ Real.sin θ) (hθ1 : Real.sin θ ≤ 1) :
+    p/2 + (p-q p)*(1+q p)/2*sinePower (q p) θ -
+      negativeDrift p*sinePower (q p-2) θ + σ*(1+sinePower (q p) θ) ≤
+    driftAllowance p - negativeDrift p*sinePower (q p-2) θ := by
+  have hs0 : 0 ≤ sinePower (q p) θ := Real.rpow_nonneg hθ _
+  have hs1 : sinePower (q p) θ ≤ 1 := Real.rpow_le_one hθ hθ1 (q_pos hp).le
+  have hk : 0 ≤ (p-q p)*(1+q p)/2 := by
+    have := q_lt_p hp
+    have := q_pos hp
+    positivity
+  have h1 := mul_le_mul_of_nonneg_left hs1 hk
+  have h2 := mul_le_mul_of_nonneg_right hσ (by linarith : 0 ≤ 1+sinePower (q p) θ)
+  unfold driftAllowance
+  nlinarith
+
+lemma angularFactor_ge_delta {p δ θ : ℝ} (hδ : 0 ≤ δ) (hθ : 0 ≤ Real.sin θ) :
+    δ ≤ angularFactor p δ θ := by
+  unfold angularFactor sinePower
+  have hp := Real.rpow_nonneg hθ p
+  have hq := Real.rpow_nonneg hθ (q p)
+  nlinarith
+
+lemma angularFactor_le_three {p δ θ : ℝ} (hp : 0 < p)
+    (hδ : 0 ≤ δ) (hδ1 : δ ≤ 1) (hθ : 0 ≤ Real.sin θ) :
+    angularFactor p δ θ ≤ 3 := by
+  have hp1 : sinePower p θ ≤ 1 := Real.rpow_le_one hθ (Real.sin_le_one θ) hp.le
+  have hq1 : sinePower (q p) θ ≤ 1 := Real.rpow_le_one hθ (Real.sin_le_one θ) (q_pos hp).le
+  have hq0 : 0 ≤ sinePower (q p) θ := Real.rpow_nonneg hθ _
+  unfold angularFactor
+  nlinarith
+
+lemma angularFactor_endpoint_bounds {p θ : ℝ} (hp : 0 < p) (hθ : 0 ≤ Real.sin θ) :
+    1 ≤ angularFactor p 1 θ ∧ angularFactor p 1 θ ≤ 3 :=
+  ⟨angularFactor_ge_delta zero_le_one hθ,
+    angularFactor_le_three hp zero_le_one le_rfl hθ⟩
+
+def angularFactorFirst (p δ θ : ℝ) : ℝ :=
+  sinePowerFirst p θ + δ*sinePowerFirst (q p) θ
+
+lemma angularFactor_hasDerivAt {p δ θ : ℝ} (hθ : Real.sin θ ≠ 0) :
+    HasDerivAt (angularFactor p δ) (angularFactorFirst p δ θ) θ := by
+  apply ((sinePower_hasDerivAt (r := p) hθ).add
+    (((hasDerivAt_const θ 1).add (sinePower_hasDerivAt (r := q p) hθ)).const_mul δ)).congr_deriv
+  simp only [angularFactorFirst, zero_add]
+
+lemma angularFactorFirst_bound {p δ θ : ℝ} (hp : 0 < p)
+    (hδ : 0 ≤ δ) (hδ1 : δ ≤ 1) (hθ : 0 < Real.sin θ) :
+    |angularFactorFirst p δ θ| ≤ (p+q p)*Real.sin θ ^ (q p-1) := by
+  have hpq : Real.sin θ ^ (p-1) ≤ Real.sin θ ^ (q p-1) :=
+    Real.rpow_le_rpow_of_exponent_ge hθ (Real.sin_le_one θ) (by linarith [q_lt_p hp])
+  have hq := (q_pos hp).le
+  have hpow : 0 ≤ Real.sin θ ^ (q p-1) := Real.rpow_nonneg hθ.le _
+  have hcos : |Real.cos θ| ≤ 1 := abs_le.mpr ⟨Real.neg_one_le_cos θ, Real.cos_le_one θ⟩
+  have hfirst (r : ℝ) (hr : 0 ≤ r) : |sinePowerFirst r θ| ≤ r * Real.sin θ ^ (r-1) := by
+    unfold sinePowerFirst
+    rw [abs_mul, abs_of_nonneg (mul_nonneg hr (Real.rpow_nonneg hθ.le _))]
+    exact mul_le_of_le_one_right (mul_nonneg hr (Real.rpow_nonneg hθ.le _)) hcos
+  calc
+    _ ≤ |sinePowerFirst p θ| + |δ*sinePowerFirst (q p) θ| := abs_add_le _ _
+    _ = |sinePowerFirst p θ| + δ*|sinePowerFirst (q p) θ| := by
+      rw [abs_mul, abs_of_nonneg hδ]
+    _ ≤ p*Real.sin θ ^ (p-1) + δ*(q p*Real.sin θ ^ (q p-1)) :=
+      add_le_add (hfirst p hp.le) (mul_le_mul_of_nonneg_left (hfirst (q p) hq) hδ)
+    _ ≤ p*Real.sin θ ^ (q p-1) + q p*Real.sin θ ^ (q p-1) :=
+      add_le_add (mul_le_mul_of_nonneg_left hpq hp.le)
+        (mul_le_of_le_one_left (mul_nonneg hq hpow) hδ1)
+    _ = _ := by ring
+
+/-- The singular angular derivative is controlled by the damping term.
+The exponent is chosen so that `eta * (q - 2) = q - 1`. -/
+lemma normalized_angularFactorFirst_bound {p δ θ : ℝ} (hp : 0 < p)
+    (hδ : 0 < δ) (hδ1 : δ ≤ 1) (hθ : 0 < Real.sin θ) :
+    |angularFactorFirst p δ θ| / angularFactor p δ θ ≤
+      (p+q p)*3^(eta p)*δ^(-1-eta p)*(damping p δ θ)^(eta p) := by
+  let f := angularFactor p δ θ
+  let e := eta p
+  have hf : 0 < f := angularFactor_pos hδ hθ
+  have hdf : δ ≤ f := angularFactor_ge_delta hδ.le hθ.le
+  have hf3 : f ≤ 3 := angularFactor_le_three hp hδ.le hδ1 hθ.le
+  have he : 0 < e := eta_pos
+  have hD : 0 < damping p δ θ :=
+    mul_pos (div_pos hδ hf) (Real.rpow_pos_of_pos hθ _)
+  have hidentity : Real.sin θ ^ (q p-1) = (f/δ)^e * (damping p δ θ)^e := by
+    rw [← Real.mul_rpow (div_pos hf hδ).le hD.le]
+    have hcancel : f/δ*damping p δ θ = Real.sin θ ^ (q p-2) := by
+      dsimp [damping, sinePower, f]
+      field_simp [hδ.ne', (angularFactor_pos hδ hθ).ne']
+    rw [hcancel, ← Real.rpow_mul hθ.le]
+    congr 1
+    exact ((mul_comm _ _).trans (eta_identity p)).symm
+  have hpq : 0 ≤ p+q p := add_nonneg hp.le (q_pos hp).le
+  calc
+    _ ≤ ((p+q p)*Real.sin θ ^ (q p-1))/f :=
+      div_le_div_of_nonneg_right (angularFactorFirst_bound hp hδ.le hδ1 hθ) hf.le
+    _ ≤ ((p+q p)*Real.sin θ ^ (q p-1))/δ :=
+      div_le_div_of_nonneg_left (mul_nonneg hpq (Real.rpow_nonneg hθ.le _)) hδ hdf
+    _ = (p+q p)/δ * (f/δ)^e * (damping p δ θ)^e := by rw [hidentity]; ring
+    _ ≤ (p+q p)/δ * (3/δ)^e * (damping p δ θ)^e := by
+      apply mul_le_mul_of_nonneg_right _ (Real.rpow_nonneg hD.le _)
+      apply mul_le_mul_of_nonneg_left _ (div_nonneg hpq hδ.le)
+      exact Real.rpow_le_rpow (div_pos hf hδ).le
+        (div_le_div_of_nonneg_right hf3 hδ.le) he.le
+    _ = _ := by
+      rw [Real.div_rpow (by norm_num : (0:ℝ) ≤ 3) hδ.le,
+        Real.rpow_sub hδ, Real.rpow_neg_one]
+      ring
+
+def driftThreshold (p : ℝ) : ℝ :=
+  (negativeDrift p / (2*driftAllowance p)) ^ (1/(2-q p))
+
+lemma driftThreshold_pos {p : ℝ} (hp : 0 < p) : 0 < driftThreshold p := by
+  exact Real.rpow_pos_of_pos (div_pos (negativeDrift_pos hp)
+    (mul_pos (by norm_num) (driftAllowance_pos hp))) _
+
+lemma driftThreshold_lt_one {p : ℝ} (hp : 0 < p) : driftThreshold p < 1 := by
+  have hq := q_pos hp
+  have hq1 := q_lt_one (p := p)
+  have hqp := q_lt_p hp
+  have hk := negativeDrift_pos hp
+  have hA := driftAllowance_pos hp
+  have hden : 0 < 2-q p := by linarith
+  have hsmall : negativeDrift p < 2*driftAllowance p := by
+    unfold negativeDrift driftAllowance
+    nlinarith [mul_nonneg (sub_nonneg.mpr hq1.le) (sub_nonneg.mpr hqp.le)]
+  exact Real.rpow_lt_one (div_pos hk (by positivity)).le
+    ((div_lt_one (by positivity)).mpr hsmall) (by positivity : 0 < 1/(2-q p))
+
+lemma driftThreshold_identity {p : ℝ} (hp : 0 < p) :
+    negativeDrift p * driftThreshold p ^ (q p-2) = 2*driftAllowance p := by
+  have hk := negativeDrift_pos hp
+  have hA := driftAllowance_pos hp
+  have hq2 : 2-q p ≠ 0 := ne_of_gt (by linarith [q_lt_one (p := p)])
+  unfold driftThreshold
+  rw [← Real.rpow_mul (div_pos hk (by positivity)).le]
+  have he : (1/(2-q p))*(q p-2) = -1 := by field_simp; ring
+  rw [he, Real.rpow_neg_one]
+  field_simp
+
+/-- The negative singular part absorbs the bounded drift at small angles;
+away from the endpoints the denominator supplies a fixed lower bound. -/
+lemma regularized_drift_bound {p δ σ θ : ℝ} (hp : 0 < p)
+    (hδ : 0 < δ) (hσ : σ ≤ 1) (hθ : 0 < Real.sin θ) :
+    δ / angularFactor p δ θ *
+      (p/2 + (p-q p)*(1+q p)/2*sinePower (q p) θ -
+        negativeDrift p*sinePower (q p-2) θ + σ*(1+sinePower (q p) θ)) ≤
+    (driftAllowance p * driftThreshold p ^ (-p))*δ -
+      (negativeDrift p/2)*damping p δ θ := by
+  let f := angularFactor p δ θ
+  let S := sinePower (q p-2) θ
+  let A := driftAllowance p
+  let k := negativeDrift p
+  let h := driftThreshold p
+  have hf : 0 < f := angularFactor_pos hδ hθ
+  have hA : 0 < A := driftAllowance_pos hp
+  have hk : 0 < k := negativeDrift_pos hp
+  have hh : 0 < h := driftThreshold_pos hp
+  have hbr := regularized_bracket_le hp hσ hθ.le (Real.sin_le_one θ)
+  have hstart := mul_le_mul_of_nonneg_left hbr (div_pos hδ hf).le
+  change δ/f * _ ≤ A*h^(-p)*δ - (k/2)*(δ/f*S)
+  apply hstart.trans
+  change δ/f * (A-k*S) ≤ A*h^(-p)*δ - (k/2)*(δ/f*S)
+  by_cases hsmall : Real.sin θ ≤ h
+  · have hS : h^(q p-2) ≤ S :=
+      Real.rpow_le_rpow_of_nonpos hθ hsmall (by linarith [q_lt_one (p := p)])
+    have hcancel : A ≤ k/2*S := by
+      have he := driftThreshold_identity hp
+      change k*h^(q p-2) = 2*A at he
+      nlinarith [mul_le_mul_of_nonneg_left hS hk.le]
+    have hnonneg : 0 ≤ A*h^(-p)*δ := by positivity
+    have hneg := mul_nonpos_of_nonneg_of_nonpos (div_pos hδ hf).le
+      (sub_nonpos.mpr hcancel)
+    nlinarith
+  · have hsp : h^p ≤ Real.sin θ ^ p :=
+      Real.rpow_le_rpow hh.le (le_of_not_ge hsmall) hp.le
+    have hsf : Real.sin θ ^ p ≤ f := by
+      dsimp [f, angularFactor, sinePower]
+      exact le_add_of_nonneg_right (by positivity)
+    have hhpow : 0 < h^p := Real.rpow_pos_of_pos hh _
+    have hquot : δ/f ≤ δ/(h^p) := div_le_div_of_nonneg_left hδ.le hhpow (hsp.trans hsf)
+    have hmain := mul_le_mul_of_nonneg_left hquot hA.le
+    have hS0 : 0 ≤ S := Real.rpow_nonneg hθ.le _
+    have hnonneg : 0 ≤ (k/2)*(δ/f*S) := mul_nonneg (by positivity)
+      (mul_nonneg (div_pos hδ hf).le hS0)
+    rw [Real.rpow_neg hh.le]
+    change A*(δ/f) ≤ A*(δ*(h^p)⁻¹) at hmain
+    nlinarith
+
+end SLEExactGauge.Multipoint
+
+end
+
+end OAI

lean/OAI/Probability/SLE/Multipoint/MultipointBrownianCoefficient.lean

@@ -1,81 +1,81 @@
-import OAI.Probability.SLE.Multipoint.MultipointAngular
-import OAI.Probability.SLE.Multipoint.MultipointYoung
-
-namespace OAI
-
-/-! The Brownian cross coefficient in the regularized multipoint product,
-including the singular powers when `p < 1`. -/
-
-noncomputable section
-
-namespace SLEExactGauge.Multipoint
-
-def angularCoefficientConstant (p : ℝ) : ℝ := (p+q p)*3^(eta p)
-
-lemma angularCoefficientConstant_pos {p : ℝ} (hp : 0 < p) :
-    0 < angularCoefficientConstant p := by
-  unfold angularCoefficientConstant
-  exact mul_pos (add_pos hp (q_pos hp)) (Real.rpow_pos_of_pos (by norm_num) _)
-
-lemma velocity_power_identity {D v e : ℝ} (hD : 0 ≤ D) (hv : 0 < v) :
-    (D*v^2)^e * v^(1-2*e) = D^e*v := by
-  rw [Real.mul_rpow hD (sq_nonneg v), ← Real.rpow_natCast v 2,
-    ← Real.rpow_mul hv.le, mul_assoc, ← Real.rpow_add hv]
-  norm_num
-
-lemma pair_velocity_power_identity {Di Dj vi vj e : ℝ}
-    (hDi : 0 ≤ Di) (hDj : 0 ≤ Dj) (hvi : 0 < vi) (hvj : 0 < vj) :
-    (Di*vi^2)^e*(Dj*vj^2)^e*(vi*vj)^(1-2*e) = Di^e*Dj^e*vi*vj := by
-  rw [Real.mul_rpow hvi.le hvj.le]
-  calc
-    _ = ((Di*vi^2)^e*vi^(1-2*e))*((Dj*vj^2)^e*vj^(1-2*e)) := by ring
-    _ = _ := by rw [velocity_power_identity hDi hvi, velocity_power_identity hDj hvj]; ring
-
-/-- The magnitude of one Brownian cross term is absorbed at its two
-endpoints, leaving exactly the inverse-regulator interaction cost. -/
-theorem angular_pair_absorption {p δi δj θi θj vi vj ε : ℝ}
-    (hp : 0 < p) (hδi : 0 < δi) (hδi1 : δi ≤ 1)
-    (hδj : 0 < δj) (hδj1 : δj ≤ 1)
-    (hθi : 0 < Real.sin θi) (hθj : 0 < Real.sin θj)
-    (hvi : 0 < vi) (hvj : 0 < vj) (hε : 0 < ε) :
-    (|angularFactorFirst p δi θi| / angularFactor p δi θi * vi) *
-      (|angularFactorFirst p δj θj| / angularFactor p δj θj * vj) ≤
-    ε*(damping p δi θi*vi^2+damping p δj θj*vj^2) +
-      youngConstant p (angularCoefficientConstant p ^ 2) ε *
-        (δi*δj)^(-exponent p)*(vi*vj) := by
-  let Di := damping p δi θi
-  let Dj := damping p δj θj
-  let C := angularCoefficientConstant p
-  have hDi : 0 < Di := mul_pos (div_pos hδi (angularFactor_pos hδi hθi))
-    (Real.rpow_pos_of_pos hθi _)
-  have hDj : 0 < Dj := mul_pos (div_pos hδj (angularFactor_pos hδj hθj))
-    (Real.rpow_pos_of_pos hθj _)
-  have hC : 0 < C := angularCoefficientConstant_pos hp
-  have hi := normalized_angularFactorFirst_bound hp hδi hδi1 hθi
-  have hj := normalized_angularFactorFirst_bound hp hδj hδj1 hθj
-  change _ ≤ C*δi^(-1-eta p)*Di^(eta p) at hi
-  change _ ≤ C*δj^(-1-eta p)*Dj^(eta p) at hj
-  have hmul := mul_le_mul hi hj (div_nonneg (abs_nonneg _) (angularFactor_pos hδj hθj).le)
-    (by positivity : 0 ≤ C*δi^(-1-eta p)*Di^(eta p))
-  have hmulv := mul_le_mul_of_nonneg_right hmul (mul_pos hvi hvj).le
-  calc
-    _ ≤ C^2*(δi*δj)^(-1-eta p)*Di^(eta p)*Dj^(eta p)*vi*vj := by
-      rw [Real.mul_rpow hδi.le hδj.le]
-      convert hmulv using 1 <;> ring
-    _ = C^2*(δi*δj)^(-1-eta p)*(Di*vi^2)^(eta p)*
-        (Dj*vj^2)^(eta p)*(vi*vj)^(1-2*eta p) := by
-      calc
-        _ = C^2*(δi*δj)^(-1-eta p)*(Di^(eta p)*Dj^(eta p)*vi*vj) := by ring
-        _ = C^2*(δi*δj)^(-1-eta p)*
-            ((Di*vi^2)^(eta p)*(Dj*vj^2)^(eta p)*(vi*vj)^(1-2*eta p)) := by
-          rw [pair_velocity_power_identity hDi.le hDj.le hvi hvj]
-        _ = _ := by ring
-    _ ≤ _ := weighted_pair_absorption hp (sq_pos_of_pos hC) hε (mul_pos hδi hδj)
-      (mul_nonneg hDi.le (sq_nonneg vi)) (mul_nonneg hDj.le (sq_nonneg vj))
-      (mul_pos hvi hvj).le
-
-end SLEExactGauge.Multipoint
-
-end
-
-end OAI
+import OAI.Probability.SLE.Multipoint.MultipointAngular
+import OAI.Probability.SLE.Multipoint.MultipointYoung
+
+namespace OAI
+
+/-! The Brownian cross coefficient in the regularized multipoint product,
+including the singular powers when `p < 1`. -/
+
+noncomputable section
+
+namespace SLEExactGauge.Multipoint
+
+def angularCoefficientConstant (p : ℝ) : ℝ := (p+q p)*3^(eta p)
+
+lemma angularCoefficientConstant_pos {p : ℝ} (hp : 0 < p) :
+    0 < angularCoefficientConstant p := by
+  unfold angularCoefficientConstant
+  exact mul_pos (add_pos hp (q_pos hp)) (Real.rpow_pos_of_pos (by norm_num) _)
+
+lemma velocity_power_identity {D v e : ℝ} (hD : 0 ≤ D) (hv : 0 < v) :
+    (D*v^2)^e * v^(1-2*e) = D^e*v := by
+  rw [Real.mul_rpow hD (sq_nonneg v), ← Real.rpow_natCast v 2,
+    ← Real.rpow_mul hv.le, mul_assoc, ← Real.rpow_add hv]
+  norm_num
+
+lemma pair_velocity_power_identity {Di Dj vi vj e : ℝ}
+    (hDi : 0 ≤ Di) (hDj : 0 ≤ Dj) (hvi : 0 < vi) (hvj : 0 < vj) :
+    (Di*vi^2)^e*(Dj*vj^2)^e*(vi*vj)^(1-2*e) = Di^e*Dj^e*vi*vj := by
+  rw [Real.mul_rpow hvi.le hvj.le]
+  calc
+    _ = ((Di*vi^2)^e*vi^(1-2*e))*((Dj*vj^2)^e*vj^(1-2*e)) := by ring
+    _ = _ := by rw [velocity_power_identity hDi hvi, velocity_power_identity hDj hvj]; ring
+
+/-- The magnitude of one Brownian cross term is absorbed at its two
+endpoints, leaving exactly the inverse-regulator interaction cost. -/
+theorem angular_pair_absorption {p δi δj θi θj vi vj ε : ℝ}
+    (hp : 0 < p) (hδi : 0 < δi) (hδi1 : δi ≤ 1)
+    (hδj : 0 < δj) (hδj1 : δj ≤ 1)
+    (hθi : 0 < Real.sin θi) (hθj : 0 < Real.sin θj)
+    (hvi : 0 < vi) (hvj : 0 < vj) (hε : 0 < ε) :
+    (|angularFactorFirst p δi θi| / angularFactor p δi θi * vi) *
+      (|angularFactorFirst p δj θj| / angularFactor p δj θj * vj) ≤
+    ε*(damping p δi θi*vi^2+damping p δj θj*vj^2) +
+      youngConstant p (angularCoefficientConstant p ^ 2) ε *
+        (δi*δj)^(-exponent p)*(vi*vj) := by
+  let Di := damping p δi θi
+  let Dj := damping p δj θj
+  let C := angularCoefficientConstant p
+  have hDi : 0 < Di := mul_pos (div_pos hδi (angularFactor_pos hδi hθi))
+    (Real.rpow_pos_of_pos hθi _)
+  have hDj : 0 < Dj := mul_pos (div_pos hδj (angularFactor_pos hδj hθj))
+    (Real.rpow_pos_of_pos hθj _)
+  have hC : 0 < C := angularCoefficientConstant_pos hp
+  have hi := normalized_angularFactorFirst_bound hp hδi hδi1 hθi
+  have hj := normalized_angularFactorFirst_bound hp hδj hδj1 hθj
+  change _ ≤ C*δi^(-1-eta p)*Di^(eta p) at hi
+  change _ ≤ C*δj^(-1-eta p)*Dj^(eta p) at hj
+  have hmul := mul_le_mul hi hj (div_nonneg (abs_nonneg _) (angularFactor_pos hδj hθj).le)
+    (by positivity : 0 ≤ C*δi^(-1-eta p)*Di^(eta p))
+  have hmulv := mul_le_mul_of_nonneg_right hmul (mul_pos hvi hvj).le
+  calc
+    _ ≤ C^2*(δi*δj)^(-1-eta p)*Di^(eta p)*Dj^(eta p)*vi*vj := by
+      rw [Real.mul_rpow hδi.le hδj.le]
+      convert hmulv using 1 <;> ring
+    _ = C^2*(δi*δj)^(-1-eta p)*(Di*vi^2)^(eta p)*
+        (Dj*vj^2)^(eta p)*(vi*vj)^(1-2*eta p) := by
+      calc
+        _ = C^2*(δi*δj)^(-1-eta p)*(Di^(eta p)*Dj^(eta p)*vi*vj) := by ring
+        _ = C^2*(δi*δj)^(-1-eta p)*
+            ((Di*vi^2)^(eta p)*(Dj*vj^2)^(eta p)*(vi*vj)^(1-2*eta p)) := by
+          rw [pair_velocity_power_identity hDi.le hDj.le hvi hvj]
+        _ = _ := by ring
+    _ ≤ _ := weighted_pair_absorption hp (sq_pos_of_pos hC) hε (mul_pos hδi hδj)
+      (mul_nonneg hDi.le (sq_nonneg vi)) (mul_nonneg hDj.le (sq_nonneg vj))
+      (mul_pos hvi hvj).le
+
+end SLEExactGauge.Multipoint
+
+end
+
+end OAI

lean/OAI/Probability/SLE/Multipoint/MultipointBudgetMonotone.lean

@@ -1,58 +1,58 @@
-import OAI.Probability.SLE.Multipoint.MultipointGlobalDiscount
-import OAI.Probability.SLE.Multipoint.MultipointInitialParameters
-
-namespace OAI
-
-/-! The fixed-order constant remains valid after discarding constraints
-whose targets already exceed their caps. -/
-
-noncomputable section
-open Set
-open scoped BigOperators
-
-namespace SLEExactGauge.Multipoint
-
-lemma allPatternYoungConstant_mono {ι : Type*} [DecidableEq ι] {κ : ℝ}
-    (hκ : 0 < κ) (hκ8 : κ < 8) {I J : Finset ι} (hIJ : I ⊆ J) :
-    allPatternYoungConstant κ I ≤ allPatternYoungConstant κ J := by
-  apply Finset.sum_le_sum_of_subset_of_nonneg (Finset.powerset_mono.mpr hIJ)
-  exact fun s _ _ => (patternYoungConstant_pos hκ hκ8 s).le
-
-lemma allPatternYoungConstant_map {ι ν : Type*} [DecidableEq ι] [DecidableEq ν]
-    (κ : ℝ) (f : ι ↪ ν) (I : Finset ι) :
-    allPatternYoungConstant κ (I.map f) = allPatternYoungConstant κ I := by
-  classical
-  unfold allPatternYoungConstant
-  rw [Finset.map_eq_image,Finset.powerset_image,Finset.sum_image]
-  · apply Finset.sum_congr rfl
-    intro s _
-    simp only [patternYoungConstant,Finset.card_image_of_injective s f.injective]
-  · exact Finset.image_injOn_powerset_of_injOn (fun _ _ _ _ h => f.injective h)
-
-lemma uniformDiscountBudget_map {ι ν : Type*} [DecidableEq ι] [DecidableEq ν]
-    (κ β : ℝ) (f : ι ↪ ν) (I : Finset ι) :
-    uniformDiscountBudget κ β (I.map f) = uniformDiscountBudget κ β I := by
-  simp only [uniformDiscountBudget,allPatternYoungConstant_map,Finset.offDiag_card,Finset.card_map]
-
-lemma uniformDiscountBudget_mono {ι : Type*} [DecidableEq ι] {κ : ℝ}
-    (hκ : 0 < κ) (hκ8 : κ < 8) {I J : Finset ι} (hIJ : I ⊆ J) :
-    uniformDiscountBudget κ (sourceBeta κ) I ≤ uniformDiscountBudget κ (sourceBeta κ) J := by
-  obtain ⟨_,hβ,_,_,hdecay⟩ := source_parameters hκ hκ8
-  have hpair := (interactionBudget_pos (by norm_num : (0 : ℝ) < 2) hdecay).le
-  have hcard : (I.card : ℝ) ≤ J.card := by exact_mod_cast Finset.card_le_card hIJ
-  have hoff : (I.offDiag.card : ℝ) ≤ J.offDiag.card := by
-    exact_mod_cast Finset.card_le_card (Finset.offDiag_mono hIJ)
-  unfold uniformDiscountBudget
-  apply mul_le_mul_of_nonneg_left _ hκ.le
-  apply add_le_add
-  · exact mul_le_mul_of_nonneg_left
-      (mul_le_mul_of_nonneg_right hcard (by positivity)) (singleDriftConstant_pos hκ hκ8).le
-  · exact mul_le_mul (allPatternYoungConstant_mono hκ hκ8 hIJ)
-      (mul_le_mul_of_nonneg_right hoff hpair) (mul_nonneg (Nat.cast_nonneg _) hpair)
-      (allPatternYoungConstant_pos hκ hκ8 J).le
-
-end SLEExactGauge.Multipoint
-
-end
-
-end OAI
+import OAI.Probability.SLE.Multipoint.MultipointGlobalDiscount
+import OAI.Probability.SLE.Multipoint.MultipointInitialParameters
+
+namespace OAI
+
+/-! The fixed-order constant remains valid after discarding constraints
+whose targets already exceed their caps. -/
+
+noncomputable section
+open Set
+open scoped BigOperators
+
+namespace SLEExactGauge.Multipoint
+
+lemma allPatternYoungConstant_mono {ι : Type*} [DecidableEq ι] {κ : ℝ}
+    (hκ : 0 < κ) (hκ8 : κ < 8) {I J : Finset ι} (hIJ : I ⊆ J) :
+    allPatternYoungConstant κ I ≤ allPatternYoungConstant κ J := by
+  apply Finset.sum_le_sum_of_subset_of_nonneg (Finset.powerset_mono.mpr hIJ)
+  exact fun s _ _ => (patternYoungConstant_pos hκ hκ8 s).le
+
+lemma allPatternYoungConstant_map {ι ν : Type*} [DecidableEq ι] [DecidableEq ν]
+    (κ : ℝ) (f : ι ↪ ν) (I : Finset ι) :
+    allPatternYoungConstant κ (I.map f) = allPatternYoungConstant κ I := by
+  classical
+  unfold allPatternYoungConstant
+  rw [Finset.map_eq_image,Finset.powerset_image,Finset.sum_image]
+  · apply Finset.sum_congr rfl
+    intro s _
+    simp only [patternYoungConstant,Finset.card_image_of_injective s f.injective]
+  · exact Finset.image_injOn_powerset_of_injOn (fun _ _ _ _ h => f.injective h)
+
+lemma uniformDiscountBudget_map {ι ν : Type*} [DecidableEq ι] [DecidableEq ν]
+    (κ β : ℝ) (f : ι ↪ ν) (I : Finset ι) :
+    uniformDiscountBudget κ β (I.map f) = uniformDiscountBudget κ β I := by
+  simp only [uniformDiscountBudget,allPatternYoungConstant_map,Finset.offDiag_card,Finset.card_map]
+
+lemma uniformDiscountBudget_mono {ι : Type*} [DecidableEq ι] {κ : ℝ}
+    (hκ : 0 < κ) (hκ8 : κ < 8) {I J : Finset ι} (hIJ : I ⊆ J) :
+    uniformDiscountBudget κ (sourceBeta κ) I ≤ uniformDiscountBudget κ (sourceBeta κ) J := by
+  obtain ⟨_,hβ,_,_,hdecay⟩ := source_parameters hκ hκ8
+  have hpair := (interactionBudget_pos (by norm_num : (0 : ℝ) < 2) hdecay).le
+  have hcard : (I.card : ℝ) ≤ J.card := by exact_mod_cast Finset.card_le_card hIJ
+  have hoff : (I.offDiag.card : ℝ) ≤ J.offDiag.card := by
+    exact_mod_cast Finset.card_le_card (Finset.offDiag_mono hIJ)
+  unfold uniformDiscountBudget
+  apply mul_le_mul_of_nonneg_left _ hκ.le
+  apply add_le_add
+  · exact mul_le_mul_of_nonneg_left
+      (mul_le_mul_of_nonneg_right hcard (by positivity)) (singleDriftConstant_pos hκ hκ8).le
+  · exact mul_le_mul (allPatternYoungConstant_mono hκ hκ8 hIJ)
+      (mul_le_mul_of_nonneg_right hoff hpair) (mul_nonneg (Nat.cast_nonneg _) hpair)
+      (allPatternYoungConstant_pos hκ hκ8 J).le
+
+end SLEExactGauge.Multipoint
+
+end
+
+end OAI

lean/OAI/Probability/SLE/Multipoint/MultipointCappedKernel.lean

@@ -1,101 +1,101 @@
-import OAI.Probability.SLE.Multipoint.MultipointKernelGraph
-import OAI.Probability.SLE.Multipoint.MultipointTupleNull
-
-namespace OAI
-
-/-! The exact fixed-cap, nearest-neighbor distance kernel from
-`mp:kernel-integral`, and its expansion into finite graph terms. -/
-
-noncomputable section
-open Set Filter MeasureTheory
-open scoped ENNReal
-
-namespace SLEExactGauge.Multipoint
-
-def capEntry {ι : Type*} [DecidableEq ι] (b : ℝ) (x : ι → ℂ) (i : ι) : Option ι → ℝ
-  | none => b
-  | some j => if j=i then b else dist (x i) (x j)
-
-def cappedDistance {ι : Type*} [Fintype ι] [DecidableEq ι]
-    (b : ℝ) (x : ι → ℂ) (i : ι) : ℝ :=
-  Finset.univ.inf' Finset.univ_nonempty (capEntry b x i)
-
-theorem cap_pos {ι : Type*} [Fintype ι] [DecidableEq ι]
-    {b : ℝ} (hb : 0 < b) {x : ι → ℂ} (hx : Function.Injective x) (i : ι) :
-    0 < cappedDistance b x i := by
-  obtain ⟨o,_,ho⟩ := Finset.exists_mem_eq_inf' Finset.univ_nonempty (capEntry b x i)
-  change 0 < Finset.univ.inf' Finset.univ_nonempty (capEntry b x i)
-  rw [ho]
-  cases o with
-  | none => exact hb
-  | some j =>
-    dsimp only [capEntry]
-    split_ifs with hji
-    · exact hb
-    · exact dist_pos.mpr (fun h => hji (hx h.symm))
-
-theorem cap_le_fixed {ι : Type*} [Fintype ι] [DecidableEq ι]
-    (b : ℝ) (x : ι → ℂ) (i : ι) : cappedDistance b x i ≤ b := by
-  exact Finset.inf'_le (capEntry b x i) (Finset.mem_univ none)
-
-theorem cap_le_dist {ι : Type*} [Fintype ι] [DecidableEq ι]
-    (b : ℝ) (x : ι → ℂ) (i j : ι) (hij : i≠j) :
-    cappedDistance b x i ≤ dist (x i) (x j) := by
-  change Finset.univ.inf' Finset.univ_nonempty (capEntry b x i) ≤ _
-  have h := Finset.inf'_le (capEntry b x i) (Finset.mem_univ (some j))
-  simpa only [capEntry,ite_eq_right hij.symm] using h
-
-theorem continuous_cappedDistance {ι : Type*} [Fintype ι] [DecidableEq ι]
-    (b : ℝ) (i : ι) : Continuous (fun x : ι → ℂ => cappedDistance b x i) := by
-  apply Continuous.finset_inf'_apply Finset.univ_nonempty
-  intro o _
-  cases o with
-  | none => exact continuous_const
-  | some j =>
-    dsimp only [capEntry]
-    split_ifs
-    · exact continuous_const
-    · fun_prop
-
-def cappedDistanceKernel {ι : Type*} [Fintype ι] [DecidableEq ι]
-    (α b : ℝ) (x : ι → ℂ) : ℝ≥0∞ :=
-  ∏ i, ENNReal.ofReal (cappedDistance b x i ^ (-α))
-
-lemma measurable_cappedDistanceKernel {ι : Type*} [Fintype ι] [DecidableEq ι]
-    (α b : ℝ) : Measurable (cappedDistanceKernel (ι := ι) α b) := by
-  apply Finset.measurable_prod
-  intro i _
-  exact (((continuous_cappedDistance b i).measurable.pow_const (-α)).ennreal_ofReal)
-
-def rowChoice {ι : Type*} [DecidableEq ι] (α b : ℝ) (x : ι → ℂ) (i : ι) : Option ι → ℝ≥0∞
-  | none => ENNReal.ofReal (b^(-α))
-  | some j => if j=i then 0 else distanceKernel α (x i) (x j)
-
-lemma cap_reciprocal_le_row {ι : Type*} [Fintype ι] [DecidableEq ι]
-    (α b : ℝ) (x : ι → ℂ) (i : ι) :
-    ENNReal.ofReal (cappedDistance b x i ^ (-α)) ≤ ∑ o, rowChoice α b x i o := by
-  obtain ⟨o,_,ho⟩ := Finset.exists_mem_eq_inf' Finset.univ_nonempty (capEntry b x i)
-  change ENNReal.ofReal ((Finset.univ.inf' Finset.univ_nonempty (capEntry b x i))^(-α)) ≤ _
-  rw [ho]
-  cases o with
-  | none =>
-    exact Finset.single_le_sum (f := rowChoice α b x i)
-      (fun _ _ => bot_le) (Finset.mem_univ none)
-  | some j =>
-    by_cases hji : j=i
-    · simpa only [capEntry,ite_eq_left hji,rowChoice] using
-        (Finset.single_le_sum (f := rowChoice α b x i) (fun _ _ => bot_le) (Finset.mem_univ none))
-    · simpa only [capEntry,ite_eq_right hji,rowChoice,distanceKernel] using
-        (Finset.single_le_sum (f := rowChoice α b x i) (fun _ _ => bot_le) (Finset.mem_univ (some j)))
-
-lemma cappedDistanceKernel_le_expansion {ι : Type*} [Fintype ι] [DecidableEq ι]
-    (α b : ℝ) (x : ι → ℂ) :
-    cappedDistanceKernel α b x ≤ ∑ f : ι → Option ι, ∏ i, rowChoice α b x i (f i) := by
-  rw [← Fintype.prod_sum]
-  exact Finset.prod_le_prod (fun i _ => cap_reciprocal_le_row α b x i)
-
-end SLEExactGauge.Multipoint
-
-end
-
-end OAI
+import OAI.Probability.SLE.Multipoint.MultipointKernelGraph
+import OAI.Probability.SLE.Multipoint.MultipointTupleNull
+
+namespace OAI
+
+/-! The exact fixed-cap, nearest-neighbor distance kernel from
+`mp:kernel-integral`, and its expansion into finite graph terms. -/
+
+noncomputable section
+open Set Filter MeasureTheory
+open scoped ENNReal
+
+namespace SLEExactGauge.Multipoint
+
+def capEntry {ι : Type*} [DecidableEq ι] (b : ℝ) (x : ι → ℂ) (i : ι) : Option ι → ℝ
+  | none => b
+  | some j => if j=i then b else dist (x i) (x j)
+
+def cappedDistance {ι : Type*} [Fintype ι] [DecidableEq ι]
+    (b : ℝ) (x : ι → ℂ) (i : ι) : ℝ :=
+  Finset.univ.inf' Finset.univ_nonempty (capEntry b x i)
+
+theorem cap_pos {ι : Type*} [Fintype ι] [DecidableEq ι]
+    {b : ℝ} (hb : 0 < b) {x : ι → ℂ} (hx : Function.Injective x) (i : ι) :
+    0 < cappedDistance b x i := by
+  obtain ⟨o,_,ho⟩ := Finset.exists_mem_eq_inf' Finset.univ_nonempty (capEntry b x i)
+  change 0 < Finset.univ.inf' Finset.univ_nonempty (capEntry b x i)
+  rw [ho]
+  cases o with
+  | none => exact hb
+  | some j =>
+    dsimp only [capEntry]
+    split_ifs with hji
+    · exact hb
+    · exact dist_pos.mpr (fun h => hji (hx h.symm))
+
+theorem cap_le_fixed {ι : Type*} [Fintype ι] [DecidableEq ι]
+    (b : ℝ) (x : ι → ℂ) (i : ι) : cappedDistance b x i ≤ b := by
+  exact Finset.inf'_le (capEntry b x i) (Finset.mem_univ none)
+
+theorem cap_le_dist {ι : Type*} [Fintype ι] [DecidableEq ι]
+    (b : ℝ) (x : ι → ℂ) (i j : ι) (hij : i≠j) :
+    cappedDistance b x i ≤ dist (x i) (x j) := by
+  change Finset.univ.inf' Finset.univ_nonempty (capEntry b x i) ≤ _
+  have h := Finset.inf'_le (capEntry b x i) (Finset.mem_univ (some j))
+  simpa only [capEntry,ite_eq_right hij.symm] using h
+
+theorem continuous_cappedDistance {ι : Type*} [Fintype ι] [DecidableEq ι]
+    (b : ℝ) (i : ι) : Continuous (fun x : ι → ℂ => cappedDistance b x i) := by
+  apply Continuous.finset_inf'_apply Finset.univ_nonempty
+  intro o _
+  cases o with
+  | none => exact continuous_const
+  | some j =>
+    dsimp only [capEntry]
+    split_ifs
+    · exact continuous_const
+    · fun_prop
+
+def cappedDistanceKernel {ι : Type*} [Fintype ι] [DecidableEq ι]
+    (α b : ℝ) (x : ι → ℂ) : ℝ≥0∞ :=
+  ∏ i, ENNReal.ofReal (cappedDistance b x i ^ (-α))
+
+lemma measurable_cappedDistanceKernel {ι : Type*} [Fintype ι] [DecidableEq ι]
+    (α b : ℝ) : Measurable (cappedDistanceKernel (ι := ι) α b) := by
+  apply Finset.measurable_prod
+  intro i _
+  exact (((continuous_cappedDistance b i).measurable.pow_const (-α)).ennreal_ofReal)
+
+def rowChoice {ι : Type*} [DecidableEq ι] (α b : ℝ) (x : ι → ℂ) (i : ι) : Option ι → ℝ≥0∞
+  | none => ENNReal.ofReal (b^(-α))
+  | some j => if j=i then 0 else distanceKernel α (x i) (x j)
+
+lemma cap_reciprocal_le_row {ι : Type*} [Fintype ι] [DecidableEq ι]
+    (α b : ℝ) (x : ι → ℂ) (i : ι) :
+    ENNReal.ofReal (cappedDistance b x i ^ (-α)) ≤ ∑ o, rowChoice α b x i o := by
+  obtain ⟨o,_,ho⟩ := Finset.exists_mem_eq_inf' Finset.univ_nonempty (capEntry b x i)
+  change ENNReal.ofReal ((Finset.univ.inf' Finset.univ_nonempty (capEntry b x i))^(-α)) ≤ _
+  rw [ho]
+  cases o with
+  | none =>
+    exact Finset.single_le_sum (f := rowChoice α b x i)
+      (fun _ _ => bot_le) (Finset.mem_univ none)
+  | some j =>
+    by_cases hji : j=i
+    · simpa only [capEntry,ite_eq_left hji,rowChoice] using
+        (Finset.single_le_sum (f := rowChoice α b x i) (fun _ _ => bot_le) (Finset.mem_univ none))
+    · simpa only [capEntry,ite_eq_right hji,rowChoice,distanceKernel] using
+        (Finset.single_le_sum (f := rowChoice α b x i) (fun _ _ => bot_le) (Finset.mem_univ (some j)))
+
+lemma cappedDistanceKernel_le_expansion {ι : Type*} [Fintype ι] [DecidableEq ι]
+    (α b : ℝ) (x : ι → ℂ) :
+    cappedDistanceKernel α b x ≤ ∑ f : ι → Option ι, ∏ i, rowChoice α b x i (f i) := by
+  rw [← Fintype.prod_sum]
+  exact Finset.prod_le_prod (fun i _ => cap_reciprocal_le_row α b x i)
+
+end SLEExactGauge.Multipoint
+
+end
+
+end OAI