Sync from openai/math@faee2cf485a8 (part 16)

lean/OAI/Probability/SLE/Gauge/PrescribedOrdinaryTransfer.lean

@@ -1,80 +1,80 @@
-import OAI.Probability.SLE.Gauge.PrescribedAngleMain
-import OAI.Probability.SLE.Geometry.ActualExplicitTransfer
-
-namespace OAI
-
-/-! Transfer of the exact prescribed-gauge criterion from a regular
-Brownian presentation to the original ordinary SLE probability space. -/
-noncomputable section
-open Set Filter _root_.MeasureTheory _root_.OAI.MeasureTheory ProbabilityTheory
-open scoped Topology NNReal ENNReal
-
-namespace SLEExactGauge
-local instance prescribedTransferMeasurable : MeasurableSpace C(ℝ≥0,ℝ) := borel _
-local instance prescribedTransferBorel : BorelSpace C(ℝ≥0,ℝ) := ⟨rfl⟩
-
-theorem RegularSLEPresentation.prescribed_main_of_canonical_angle_bounds
-    {Ω : Type} [MeasurableSpace Ω] {P : Measure Ω} [IsProbabilityMeasure P]
-    {κ : ℝ} {γ : Ω → ℝ≥0 → ℂ} (a : RegularSLEPresentation P κ γ)
-    (hκ : 0<κ) (hκ8 : κ<8) (hγ : ∀ t, Measurable (fun ω => γ ω t))
-    (hgrowth : PublishedDiskUnivalentGrowth)
-    (htrace : PublishedTraceGeneration
-      ((P.comap (Subtype.val : a.samples → Ω)).map (sourceDriverPath a.B a.continuous_B))
-      κ (fun t p => p t))
-    (W : Target.WienerLaw) (hW : Target.IsWiener W)
-    (δ : ℝ) (hδ : 0<δ)
-    (hangle : ∀ v : ℝ, δ≤v → ∀ f : ℝ → ℝ≥0∞, Measurable f →
-      ∀ θ∈Ioo (0:ℝ) Real.pi,
-      (∫⁻ φ, f φ ∂Target.angleLaw κ)/2 ≤
-        canonicalAngleAverage
-          ((P.comap (Subtype.val : a.samples → Ω)).map (sourceDriverPath a.B a.continuous_B))
-          κ v f θ ∧
-      canonicalAngleAverage
-          ((P.comap (Subtype.val : a.samples → Ω)).map (sourceDriverPath a.B a.continuous_B))
-          κ v f θ ≤ 2*(∫⁻ φ, f φ ∂Target.angleLaw κ)) :
-    MainConclusion P (Target.gauge κ W) γ := by
-  let Q := P.comap (Subtype.val : a.samples → Ω)
-  let : IsProbabilityMeasure Q := a.probability
-  have hBm : Measurable (Function.uncurry a.B) :=
-    measurable_uncurry_of_continuous_of_measurable a.continuous_B a.measurable_B
-  obtain ⟨C⟩ := Multipoint.exists_canonicalMass a.brownian hBm a.continuous_B a.zero_B
-    hκ hκ8 (fun ω => γ ω) a.G a.F a.witness hgrowth
-  have hmain := C.prescribed_main_of_canonical_angle_bounds a.brownian a.continuous_B
-    a.zero_B hκ hκ8 a.F a.witness (fun t => (hγ t).comp measurable_subtype_coe)
-    hgrowth htrace W hW δ hδ hangle
-  have hemb : MeasurableEmbedding (Subtype.val : a.samples → Ω) :=
-    MeasurableEmbedding.subtype_coe a.measurable_samples
-  constructor
-  · rw [← a.measurePreserving_val.map_eq,hemb.ae_map_iff]
-    exact hmain.1
-  · intro L hL
-    obtain ⟨hm,M,hM⟩ := hmain.2 L hL
-    refine ⟨(a.measurePreserving_val.aemeasurable_comp_iff hemb).mp hm,M,?_⟩
-    have he := a.measurePreserving_val.lintegral_comp_emb hemb
-      (fun ω => hausdorffGauge (Target.gauge κ W) (wholeTrace (γ ω)∩Metric.closedBall 0 L))
-    rw [← he]
-    exact hM
-
-theorem ordinary_prescribed_main_of_canonical_angle_bounds
-    {Ω : Type} [MeasurableSpace Ω] (P : Measure Ω) [IsProbabilityMeasure P]
-    (κ : ℝ) (hκ : 0<κ) (hκ8 : κ<8)
-    (γ : Ω → ℝ≥0 → ℂ) (hSLE : IsOrdinaryChordalSLE κ γ P)
-    (hgrowth : PublishedDiskUnivalentGrowth)
-    (htrace : PublishedTraceGeneration (ordinaryRegularDriverLaw hSLE) κ (fun t p => p t))
-    (W : Target.WienerLaw) (hW : Target.IsWiener W)
-    (δ : ℝ) (hδ : 0<δ)
-    (hangle : ∀ v : ℝ, δ≤v → ∀ f : ℝ → ℝ≥0∞, Measurable f →
-      ∀ θ∈Ioo (0:ℝ) Real.pi,
-      (∫⁻ φ, f φ ∂Target.angleLaw κ)/2 ≤
-          canonicalAngleAverage (ordinaryRegularDriverLaw hSLE) κ v f θ ∧
-      canonicalAngleAverage (ordinaryRegularDriverLaw hSLE) κ v f θ ≤
-          2*(∫⁻ φ, f φ ∂Target.angleLaw κ)) :
-    MainConclusion P (Target.gauge κ W) γ :=
-  (ordinaryRegularPresentation hSLE).prescribed_main_of_canonical_angle_bounds
-    hκ hκ8 hSLE.1 hgrowth htrace W hW δ hδ hangle
-
-end SLEExactGauge
-
-end
-
-end OAI
+import OAI.Probability.SLE.Gauge.PrescribedAngleMain
+import OAI.Probability.SLE.Geometry.ActualExplicitTransfer
+
+namespace OAI
+
+/-! Transfer of the exact prescribed-gauge criterion from a regular
+Brownian presentation to the original ordinary SLE probability space. -/
+noncomputable section
+open Set Filter _root_.MeasureTheory _root_.OAI.MeasureTheory ProbabilityTheory
+open scoped Topology NNReal ENNReal
+
+namespace SLEExactGauge
+local instance prescribedTransferMeasurable : MeasurableSpace C(ℝ≥0,ℝ) := borel _
+local instance prescribedTransferBorel : BorelSpace C(ℝ≥0,ℝ) := ⟨rfl⟩
+
+theorem RegularSLEPresentation.prescribed_main_of_canonical_angle_bounds
+    {Ω : Type} [MeasurableSpace Ω] {P : Measure Ω} [IsProbabilityMeasure P]
+    {κ : ℝ} {γ : Ω → ℝ≥0 → ℂ} (a : RegularSLEPresentation P κ γ)
+    (hκ : 0<κ) (hκ8 : κ<8) (hγ : ∀ t, Measurable (fun ω => γ ω t))
+    (hgrowth : PublishedDiskUnivalentGrowth)
+    (htrace : PublishedTraceGeneration
+      ((P.comap (Subtype.val : a.samples → Ω)).map (sourceDriverPath a.B a.continuous_B))
+      κ (fun t p => p t))
+    (W : Target.WienerLaw) (hW : Target.IsWiener W)
+    (δ : ℝ) (hδ : 0<δ)
+    (hangle : ∀ v : ℝ, δ≤v → ∀ f : ℝ → ℝ≥0∞, Measurable f →
+      ∀ θ∈Ioo (0:ℝ) Real.pi,
+      (∫⁻ φ, f φ ∂Target.angleLaw κ)/2 ≤
+        canonicalAngleAverage
+          ((P.comap (Subtype.val : a.samples → Ω)).map (sourceDriverPath a.B a.continuous_B))
+          κ v f θ ∧
+      canonicalAngleAverage
+          ((P.comap (Subtype.val : a.samples → Ω)).map (sourceDriverPath a.B a.continuous_B))
+          κ v f θ ≤ 2*(∫⁻ φ, f φ ∂Target.angleLaw κ)) :
+    MainConclusion P (Target.gauge κ W) γ := by
+  let Q := P.comap (Subtype.val : a.samples → Ω)
+  let : IsProbabilityMeasure Q := a.probability
+  have hBm : Measurable (Function.uncurry a.B) :=
+    measurable_uncurry_of_continuous_of_measurable a.continuous_B a.measurable_B
+  obtain ⟨C⟩ := Multipoint.exists_canonicalMass a.brownian hBm a.continuous_B a.zero_B
+    hκ hκ8 (fun ω => γ ω) a.G a.F a.witness hgrowth
+  have hmain := C.prescribed_main_of_canonical_angle_bounds a.brownian a.continuous_B
+    a.zero_B hκ hκ8 a.F a.witness (fun t => (hγ t).comp measurable_subtype_coe)
+    hgrowth htrace W hW δ hδ hangle
+  have hemb : MeasurableEmbedding (Subtype.val : a.samples → Ω) :=
+    MeasurableEmbedding.subtype_coe a.measurable_samples
+  constructor
+  · rw [← a.measurePreserving_val.map_eq,hemb.ae_map_iff]
+    exact hmain.1
+  · intro L hL
+    obtain ⟨hm,M,hM⟩ := hmain.2 L hL
+    refine ⟨(a.measurePreserving_val.aemeasurable_comp_iff hemb).mp hm,M,?_⟩
+    have he := a.measurePreserving_val.lintegral_comp_emb hemb
+      (fun ω => hausdorffGauge (Target.gauge κ W) (wholeTrace (γ ω)∩Metric.closedBall 0 L))
+    rw [← he]
+    exact hM
+
+theorem ordinary_prescribed_main_of_canonical_angle_bounds
+    {Ω : Type} [MeasurableSpace Ω] (P : Measure Ω) [IsProbabilityMeasure P]
+    (κ : ℝ) (hκ : 0<κ) (hκ8 : κ<8)
+    (γ : Ω → ℝ≥0 → ℂ) (hSLE : IsOrdinaryChordalSLE κ γ P)
+    (hgrowth : PublishedDiskUnivalentGrowth)
+    (htrace : PublishedTraceGeneration (ordinaryRegularDriverLaw hSLE) κ (fun t p => p t))
+    (W : Target.WienerLaw) (hW : Target.IsWiener W)
+    (δ : ℝ) (hδ : 0<δ)
+    (hangle : ∀ v : ℝ, δ≤v → ∀ f : ℝ → ℝ≥0∞, Measurable f →
+      ∀ θ∈Ioo (0:ℝ) Real.pi,
+      (∫⁻ φ, f φ ∂Target.angleLaw κ)/2 ≤
+          canonicalAngleAverage (ordinaryRegularDriverLaw hSLE) κ v f θ ∧
+      canonicalAngleAverage (ordinaryRegularDriverLaw hSLE) κ v f θ ≤
+          2*(∫⁻ φ, f φ ∂Target.angleLaw κ)) :
+    MainConclusion P (Target.gauge κ W) γ :=
+  (ordinaryRegularPresentation hSLE).prescribed_main_of_canonical_angle_bounds
+    hκ hκ8 hSLE.1 hgrowth htrace W hW δ hδ hangle
+
+end SLEExactGauge
+
+end
+
+end OAI

lean/OAI/Probability/SLE/Gauge/PrescribedPublishedMain.lean

@@ -1,55 +1,55 @@
-import OAI.Probability.SLE.Angle.CanonicalAngleMixing
-import OAI.Probability.SLE.Gauge.PrescribedOrdinaryTransfer
-
-namespace OAI
-
-/-! The first paper's prescribed moment gauge, from precisely named
-published inputs. The angular mixing estimate is proved internally. -/
-noncomputable section
-open Set Filter _root_.MeasureTheory _root_.OAI.MeasureTheory ProbabilityTheory
-open scoped Topology NNReal ENNReal
-
-namespace SLEExactGauge
-local instance prescribedPublishedMeasurable : MeasurableSpace C(ℝ≥0,ℝ) := borel _
-local instance prescribedPublishedBorel : BorelSpace C(ℝ≥0,ℝ) := ⟨rfl⟩
-
-/-- The exact prescribed gauge gives positive finite mass to every positive-time
-compact trace segment and finite expected mass of the whole trace in bounded disks.
-Published inputs: Duren (1983), section 2.3 (the disk univalent-growth estimate),
-and Rohde--Schramm (2005), Theorem 5.1 (trace generation under the driver law). -/
-theorem RegularSLEPresentation.prescribed_main_of_published_inputs
-    {Ω : Type} [MeasurableSpace Ω] {P : Measure Ω} [IsProbabilityMeasure P]
-    {κ : ℝ} {γ : Ω → ℝ≥0 → ℂ} (a : RegularSLEPresentation P κ γ)
-    (hκ : 0<κ) (hκ8 : κ<8) (hγ : ∀ t, Measurable (fun ω => γ ω t))
-    (hgrowth : PublishedDiskUnivalentGrowth)
-    (htrace : PublishedTraceGeneration
-      ((P.comap (Subtype.val : a.samples → Ω)).map (sourceDriverPath a.B a.continuous_B))
-      κ (fun t p => p t))
-    (W : Target.WienerLaw) (hW : Target.IsWiener W) :
-    MainConclusion P (Target.gauge κ W) γ := by
-  have : IsProbabilityMeasure (P.comap (Subtype.val : a.samples → Ω)) := a.probability
-  have hBm : Measurable (Function.uncurry a.B) :=
-    measurable_uncurry_of_continuous_of_measurable a.continuous_B a.measurable_B
-  apply a.prescribed_main_of_canonical_angle_bounds hκ hκ8 hγ hgrowth htrace W hW
-    (angleSpectralMixingTime κ) (angleSpectralMixingTime_pos hκ)
-  exact canonicalAngleAverage_uniform_bounds a.brownian hBm a.continuous_B a.zero_B
-    hκ hκ8 (fun ω => γ ω) a.G a.F a.witness
-
-/-- The first paper's full prescribed-gauge Hausdorff conclusion for ordinary
-chordal SLE, with only the cited published conformal and trace inputs. -/
-theorem ordinary_prescribed_mainConclusion_of_published_inputs
-    {Ω : Type} [MeasurableSpace Ω] (P : Measure Ω) [IsProbabilityMeasure P]
-    (κ : ℝ) (hκ : 0<κ) (hκ8 : κ<8)
-    (γ : Ω → ℝ≥0 → ℂ) (hSLE : IsOrdinaryChordalSLE κ γ P)
-    (hgrowth : PublishedDiskUnivalentGrowth)
-    (htrace : PublishedTraceGeneration (ordinaryRegularDriverLaw hSLE) κ (fun t p => p t))
-    (W : Target.WienerLaw) (hW : Target.IsWiener W) :
-    MainConclusion P (Target.gauge κ W) γ :=
-  (ordinaryRegularPresentation hSLE).prescribed_main_of_published_inputs
-    hκ hκ8 hSLE.1 hgrowth htrace W hW
-
-end SLEExactGauge
-
-end
-
-end OAI
+import OAI.Probability.SLE.Angle.CanonicalAngleMixing
+import OAI.Probability.SLE.Gauge.PrescribedOrdinaryTransfer
+
+namespace OAI
+
+/-! The first paper's prescribed moment gauge, from precisely named
+published inputs. The angular mixing estimate is proved internally. -/
+noncomputable section
+open Set Filter _root_.MeasureTheory _root_.OAI.MeasureTheory ProbabilityTheory
+open scoped Topology NNReal ENNReal
+
+namespace SLEExactGauge
+local instance prescribedPublishedMeasurable : MeasurableSpace C(ℝ≥0,ℝ) := borel _
+local instance prescribedPublishedBorel : BorelSpace C(ℝ≥0,ℝ) := ⟨rfl⟩
+
+/-- The exact prescribed gauge gives positive finite mass to every positive-time
+compact trace segment and finite expected mass of the whole trace in bounded disks.
+Published inputs: Duren (1983), section 2.3 (the disk univalent-growth estimate),
+and Rohde--Schramm (2005), Theorem 5.1 (trace generation under the driver law). -/
+theorem RegularSLEPresentation.prescribed_main_of_published_inputs
+    {Ω : Type} [MeasurableSpace Ω] {P : Measure Ω} [IsProbabilityMeasure P]
+    {κ : ℝ} {γ : Ω → ℝ≥0 → ℂ} (a : RegularSLEPresentation P κ γ)
+    (hκ : 0<κ) (hκ8 : κ<8) (hγ : ∀ t, Measurable (fun ω => γ ω t))
+    (hgrowth : PublishedDiskUnivalentGrowth)
+    (htrace : PublishedTraceGeneration
+      ((P.comap (Subtype.val : a.samples → Ω)).map (sourceDriverPath a.B a.continuous_B))
+      κ (fun t p => p t))
+    (W : Target.WienerLaw) (hW : Target.IsWiener W) :
+    MainConclusion P (Target.gauge κ W) γ := by
+  have : IsProbabilityMeasure (P.comap (Subtype.val : a.samples → Ω)) := a.probability
+  have hBm : Measurable (Function.uncurry a.B) :=
+    measurable_uncurry_of_continuous_of_measurable a.continuous_B a.measurable_B
+  apply a.prescribed_main_of_canonical_angle_bounds hκ hκ8 hγ hgrowth htrace W hW
+    (angleSpectralMixingTime κ) (angleSpectralMixingTime_pos hκ)
+  exact canonicalAngleAverage_uniform_bounds a.brownian hBm a.continuous_B a.zero_B
+    hκ hκ8 (fun ω => γ ω) a.G a.F a.witness
+
+/-- The first paper's full prescribed-gauge Hausdorff conclusion for ordinary
+chordal SLE, with only the cited published conformal and trace inputs. -/
+theorem ordinary_prescribed_mainConclusion_of_published_inputs
+    {Ω : Type} [MeasurableSpace Ω] (P : Measure Ω) [IsProbabilityMeasure P]
+    (κ : ℝ) (hκ : 0<κ) (hκ8 : κ<8)
+    (γ : Ω → ℝ≥0 → ℂ) (hSLE : IsOrdinaryChordalSLE κ γ P)
+    (hgrowth : PublishedDiskUnivalentGrowth)
+    (htrace : PublishedTraceGeneration (ordinaryRegularDriverLaw hSLE) κ (fun t p => p t))
+    (W : Target.WienerLaw) (hW : Target.IsWiener W) :
+    MainConclusion P (Target.gauge κ W) γ :=
+  (ordinaryRegularPresentation hSLE).prescribed_main_of_published_inputs
+    hκ hκ8 hSLE.1 hgrowth htrace W hW
+
+end SLEExactGauge
+
+end
+
+end OAI

lean/OAI/Probability/SLE/Gauge/PrescribedRadiusFinalLaw.lean

@@ -1,92 +1,92 @@
-import OAI.Probability.SLE.Gauge.PrescribedRadiusTest
-
-namespace OAI
-
-/-! A stopped disk test has the same kernel bound under every later finite
-centered law. The terminal cover is not used in this change of measure. -/
-noncomputable section
-open Set Filter _root_.MeasureTheory _root_.OAI.MeasureTheory ProbabilityTheory Metric
-open scoped Topology NNReal ENNReal
-
-namespace SLEExactGauge.Multipoint
-local instance finalTestMeasurable : MeasurableSpace C(ℝ≥0,ℝ) := borel _
-local instance finalTestBorel : BorelSpace C(ℝ≥0,ℝ) := ⟨rfl⟩
-
-theorem CanonicalMass.prescribed_disk_test_under_final_law
-    {Ω : 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 ω))
-    (h0 : ∀ ω, B 0 ω=0) (hκ : 0 < κ) (hκ8 : κ < 8)
-    (F : Ω → ℝ≥0 → ℂ → ℂ)
-    (hw : ∀ ω, IsCapacityTwoWitness (fun t => Real.sqrt κ*B t ω) (γ ω) (G ω) (F ω))
-    (R : RawCanonicalMass)
-    (he : ∀ᵐ ω ∂P, (∀ t, R.process t (sourceDriverPath B hc ω)=C.process t ω) ∧
-      R.terminal (sourceDriverPath B hc ω)=C.rational.terminal ω)
-    (D : Set C(ℝ≥0,ℝ)) (hD : MeasurableSet D)
-    (hDf : ∀ᵐ p ∂P.map (sourceDriverPath B hc), p∈D)
-    (hDp : ∀ p∈D, PositiveMassPaths (fun t => R.process t p) (R.terminal p))
-    (hgrowth : PublishedDiskUnivalentGrowth)
-    (hpublished : PublishedTraceGeneration (P.map (sourceDriverPath B hc)) κ (fun t p => p t))
-    (z : ℂ) (hz : z ∈ upperHalfPlane) (u v r b V : ℝ)
-    (hu : 0 ≤ u) (hv : 0 < v) (hr : 0 < r)
-    (hR : (2*z.im)*Real.exp (-u)=(2048*Real.pi)*r) (hV : u+v ≤ V) :
-    ∀ A : Set Ω, MeasurableSet[(actual_radiusLevelTime_stopping hB
-      (fun t => (hBm.of_uncurry_left : Measurable (B t))) hBm hc h0
-      κ hκ hκ8 γ G F hw z hz u hu).measurableSpace] A →
-      (∫⁻ ω in A, R.angleDiskTail (P.map (sourceDriverPath B hc)) κ b v
-        (extendedMarkedAngle κ B γ G (fun ω => radiusLevelTime (γ ω) (G ω) z u) z ω)
-        ∂finiteCenteredLaw P κ B γ G z V) ≤
-      finiteCenteredLaw P κ B γ G z V
-        (A∩C.prescribedBallTest (fun ω => radiusLevelTime (γ ω) (G ω) z (u+v))
-          z ((4096*Real.pi)*r)
-          (ENNReal.ofReal (((128*Real.pi)*r)^dimension κ)*ENNReal.ofReal b)) := by
-  have hm (t : ℝ≥0) : Measurable (B t) := hBm.of_uncurry_left
-  let ℱ := Filtration.natural B (fun t => (hm t).stronglyMeasurable)
-  let σ : Ω → WithTop ℝ≥0 := fun ω => radiusLevelTime (γ ω) (G ω) z u
-  let T : Ω → WithTop ℝ≥0 := fun ω => radiusLevelTime (γ ω) (G ω) z (u+v)
-  have hσ : IsStoppingTime ℱ σ :=
-    actual_radiusLevelTime_stopping hB hm hBm hc h0 κ hκ hκ8 γ G F hw z hz u hu
-  have huv : 0 ≤ u+v := add_nonneg hu hv.le
-  have hT : IsStoppingTime ℱ T :=
-    actual_radiusLevelTime_stopping hB hm hBm hc h0 κ hκ hκ8 γ G F hw z hz (u+v) huv
-  have hσT (ω : Ω) : σ ω ≤ T ω :=
-    radiusLevelTime_mono ((hc ω).const_mul _) (hw ω) z hu (by linarith)
-  let f := fun ω => R.angleDiskTail (P.map (sourceDriverPath B hc)) κ b v
-    (extendedMarkedAngle κ B γ G σ z ω)
-  let test := C.prescribedBallTest T z ((4096*Real.pi)*r)
-    (ENNReal.ofReal (((128*Real.pi)*r)^dimension κ)*ENNReal.ofReal b)
-  let Q := finiteCenteredLaw P κ B γ G z (u+v)
-  let QV := finiteCenteredLaw P κ B γ G z V
-  let : IsProbabilityMeasure (P.map (sourceDriverPath B hc)) :=
-    (Measure.isProbabilityMeasure_map_iff (source_path_measurable _ hm).aemeasurable).mpr inferInstance
-  have hfm : Measurable[hσ.measurableSpace] f :=
-    (R.angleDiskTail_measurable _ κ b v).comp
-      (extendedMarkedAngle_measurable B hm hc κ γ G F hw σ hσ z)
-  intro A hA
-  have hleft : (∫⁻ ω in A, f ω ∂QV)=(∫⁻ ω in A, f ω ∂Q) := by
-    have h := @lintegral_eq_of_stopped_events Ω mΩ QV Q hσ.measurableSpace
-      hσ.measurableSpace_le (fun E hE =>
-        finiteCenteredLaw_consistent_at_extended_stop hB hBm hc h0 κ hκ hκ8 γ G F
-          (Eventually.of_forall hw) z hz (u+v) V huv hV σ hσ
-          (Eventually.of_forall hσT) E hE) (A.indicator f) (hfm.indicator hA)
-    simpa only [lintegral_indicator (hσ.measurableSpace_le _ hA)] using h
-  have hAm : MeasurableSet[hT.measurableSpace] A :=
-    hσ.measurableSpace_mono hT hσT A hA
-  have htest : MeasurableSet[hT.measurableSpace] test :=
-    C.prescribedBallTest_measurable T hT _ _ _
-  have hright : QV (A∩test)=Q (A∩test) :=
-    finiteCenteredLaw_consistent_at_radius_stop hB hBm hc h0 κ hκ hκ8 γ G F
-      (Eventually.of_forall hw) z hz (u+v) V huv hV T hT
-      (Eventually.of_forall fun _ => rfl) (A∩test) (hAm.inter htest)
-  change (∫⁻ ω in A, f ω ∂QV) ≤ QV (A∩test)
-  rw [hleft,hright]
-  exact C.prescribed_disk_test_at_radius hB hc h0 hκ hκ8 F hw R he D hD hDf hDp
-    hgrowth hpublished z hz u v r b hu hv hr hR A hA
-
-end SLEExactGauge.Multipoint
-
-end
-
-end OAI
+import OAI.Probability.SLE.Gauge.PrescribedRadiusTest
+
+namespace OAI
+
+/-! A stopped disk test has the same kernel bound under every later finite
+centered law. The terminal cover is not used in this change of measure. -/
+noncomputable section
+open Set Filter _root_.MeasureTheory _root_.OAI.MeasureTheory ProbabilityTheory Metric
+open scoped Topology NNReal ENNReal
+
+namespace SLEExactGauge.Multipoint
+local instance finalTestMeasurable : MeasurableSpace C(ℝ≥0,ℝ) := borel _
+local instance finalTestBorel : BorelSpace C(ℝ≥0,ℝ) := ⟨rfl⟩
+
+theorem CanonicalMass.prescribed_disk_test_under_final_law
+    {Ω : 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 ω))
+    (h0 : ∀ ω, B 0 ω=0) (hκ : 0 < κ) (hκ8 : κ < 8)
+    (F : Ω → ℝ≥0 → ℂ → ℂ)
+    (hw : ∀ ω, IsCapacityTwoWitness (fun t => Real.sqrt κ*B t ω) (γ ω) (G ω) (F ω))
+    (R : RawCanonicalMass)
+    (he : ∀ᵐ ω ∂P, (∀ t, R.process t (sourceDriverPath B hc ω)=C.process t ω) ∧
+      R.terminal (sourceDriverPath B hc ω)=C.rational.terminal ω)
+    (D : Set C(ℝ≥0,ℝ)) (hD : MeasurableSet D)
+    (hDf : ∀ᵐ p ∂P.map (sourceDriverPath B hc), p∈D)
+    (hDp : ∀ p∈D, PositiveMassPaths (fun t => R.process t p) (R.terminal p))
+    (hgrowth : PublishedDiskUnivalentGrowth)
+    (hpublished : PublishedTraceGeneration (P.map (sourceDriverPath B hc)) κ (fun t p => p t))
+    (z : ℂ) (hz : z ∈ upperHalfPlane) (u v r b V : ℝ)
+    (hu : 0 ≤ u) (hv : 0 < v) (hr : 0 < r)
+    (hR : (2*z.im)*Real.exp (-u)=(2048*Real.pi)*r) (hV : u+v ≤ V) :
+    ∀ A : Set Ω, MeasurableSet[(actual_radiusLevelTime_stopping hB
+      (fun t => (hBm.of_uncurry_left : Measurable (B t))) hBm hc h0
+      κ hκ hκ8 γ G F hw z hz u hu).measurableSpace] A →
+      (∫⁻ ω in A, R.angleDiskTail (P.map (sourceDriverPath B hc)) κ b v
+        (extendedMarkedAngle κ B γ G (fun ω => radiusLevelTime (γ ω) (G ω) z u) z ω)
+        ∂finiteCenteredLaw P κ B γ G z V) ≤
+      finiteCenteredLaw P κ B γ G z V
+        (A∩C.prescribedBallTest (fun ω => radiusLevelTime (γ ω) (G ω) z (u+v))
+          z ((4096*Real.pi)*r)
+          (ENNReal.ofReal (((128*Real.pi)*r)^dimension κ)*ENNReal.ofReal b)) := by
+  have hm (t : ℝ≥0) : Measurable (B t) := hBm.of_uncurry_left
+  let ℱ := Filtration.natural B (fun t => (hm t).stronglyMeasurable)
+  let σ : Ω → WithTop ℝ≥0 := fun ω => radiusLevelTime (γ ω) (G ω) z u
+  let T : Ω → WithTop ℝ≥0 := fun ω => radiusLevelTime (γ ω) (G ω) z (u+v)
+  have hσ : IsStoppingTime ℱ σ :=
+    actual_radiusLevelTime_stopping hB hm hBm hc h0 κ hκ hκ8 γ G F hw z hz u hu
+  have huv : 0 ≤ u+v := add_nonneg hu hv.le
+  have hT : IsStoppingTime ℱ T :=
+    actual_radiusLevelTime_stopping hB hm hBm hc h0 κ hκ hκ8 γ G F hw z hz (u+v) huv
+  have hσT (ω : Ω) : σ ω ≤ T ω :=
+    radiusLevelTime_mono ((hc ω).const_mul _) (hw ω) z hu (by linarith)
+  let f := fun ω => R.angleDiskTail (P.map (sourceDriverPath B hc)) κ b v
+    (extendedMarkedAngle κ B γ G σ z ω)
+  let test := C.prescribedBallTest T z ((4096*Real.pi)*r)
+    (ENNReal.ofReal (((128*Real.pi)*r)^dimension κ)*ENNReal.ofReal b)
+  let Q := finiteCenteredLaw P κ B γ G z (u+v)
+  let QV := finiteCenteredLaw P κ B γ G z V
+  let : IsProbabilityMeasure (P.map (sourceDriverPath B hc)) :=
+    (Measure.isProbabilityMeasure_map_iff (source_path_measurable _ hm).aemeasurable).mpr inferInstance
+  have hfm : Measurable[hσ.measurableSpace] f :=
+    (R.angleDiskTail_measurable _ κ b v).comp
+      (extendedMarkedAngle_measurable B hm hc κ γ G F hw σ hσ z)
+  intro A hA
+  have hleft : (∫⁻ ω in A, f ω ∂QV)=(∫⁻ ω in A, f ω ∂Q) := by
+    have h := @lintegral_eq_of_stopped_events Ω mΩ QV Q hσ.measurableSpace
+      hσ.measurableSpace_le (fun E hE =>
+        finiteCenteredLaw_consistent_at_extended_stop hB hBm hc h0 κ hκ hκ8 γ G F
+          (Eventually.of_forall hw) z hz (u+v) V huv hV σ hσ
+          (Eventually.of_forall hσT) E hE) (A.indicator f) (hfm.indicator hA)
+    simpa only [lintegral_indicator (hσ.measurableSpace_le _ hA)] using h
+  have hAm : MeasurableSet[hT.measurableSpace] A :=
+    hσ.measurableSpace_mono hT hσT A hA
+  have htest : MeasurableSet[hT.measurableSpace] test :=
+    C.prescribedBallTest_measurable T hT _ _ _
+  have hright : QV (A∩test)=Q (A∩test) :=
+    finiteCenteredLaw_consistent_at_radius_stop hB hBm hc h0 κ hκ hκ8 γ G F
+      (Eventually.of_forall hw) z hz (u+v) V huv hV T hT
+      (Eventually.of_forall fun _ => rfl) (A∩test) (hAm.inter htest)
+  change (∫⁻ ω in A, f ω ∂QV) ≤ QV (A∩test)
+  rw [hleft,hright]
+  exact C.prescribed_disk_test_at_radius hB hc h0 hκ hκ8 F hw R he D hD hDf hDp
+    hgrowth hpublished z hz u v r b hu hv hr hR A hA
+
+end SLEExactGauge.Multipoint
+
+end
+
+end OAI

lean/OAI/Probability/SLE/Gauge/PrescribedRadiusLevels.lean

@@ -1,82 +1,82 @@
-import OAI.Probability.SLE.Gauge.BatchRadiusGaps
-import OAI.Probability.SLE.Gauge.GaugeEntrySmallness
-
-namespace OAI
-
-/-! Physical logarithmic levels for the exact prescribed radii. Uniformity
-  includes moving centers down to height exp(-n). -/
-noncomputable section
-open Set Filter
-open scoped Topology
-
-namespace SLEExactGauge.Target
-
-def entryPhysicalLevel (κ : ℝ) (W : WienerLaw) (e : Entry) (A : ℝ) (z : ℂ) : ℝ :=
-  Real.log ((2*z.im)/A) + (e.1:ℝ)^2 +
-    2*a κ*(entryPosition κ W e:ℝ)*((batchLevel κ W e.1:ℝ)+(e.1:ℝ))
-
-lemma entryPhysicalLevel_radius (κ : ℝ) (W : WienerLaw) (e : Entry)
-    {A : ℝ} (hA : 0<A) {z : ℂ} (hz : 0<z.im) :
-    (2*z.im)*Real.exp (-entryPhysicalLevel κ W e A z)=A*entryRadius κ W e := by
-  have hp : 0<(2*z.im)/A := by positivity
-  unfold entryPhysicalLevel entryRadius
-  rw [show -(Real.log ((2*z.im)/A)+(e.1:ℝ)^2+
-    2*a κ*(entryPosition κ W e:ℝ)*((batchLevel κ W e.1:ℝ)+(e.1:ℝ))) =
-    -Real.log ((2*z.im)/A)+(-(e.1:ℝ)^2-
-      2*a κ*(entryPosition κ W e:ℝ)*((batchLevel κ W e.1:ℝ)+(e.1:ℝ))) by ring,
-    Real.exp_add,Real.exp_neg,Real.exp_log hp]
-  field_simp
-
-lemma entryPhysicalLevel_gap {κ : ℝ} (hκ : 0<κ) (W : WienerLaw)
-    {n : ℕ} (hn : 1≤n) {o o' : Option (ℤ×ℕ)}
-    (hpos : entryPosition κ W (n,o)<entryPosition κ W (n,o')) (A : ℝ) (z : ℂ) :
-    entryPhysicalLevel κ W (n,o) A z+2*a κ*((batchLevel κ W n:ℝ)+(n:ℝ)) ≤
-      entryPhysicalLevel κ W (n,o') A z := by
-  have hpN : entryPosition κ W (n,o)+1 ≤ entryPosition κ W (n,o') := hpos
-  have hp : (entryPosition κ W (n,o):ℝ)+1 ≤ entryPosition κ W (n,o') := by exact_mod_cast hpN
-  have hcoef : 0 ≤ 2*a κ*((batchLevel κ W n:ℝ)+(n:ℝ)) := by
-    have ha := internal_a_pos hκ
-    positivity
-  have hh := mul_le_mul_of_nonneg_left hp hcoef
-  dsimp only [entryPhysicalLevel]
-  have hnR : (0:ℝ)<n := by exact_mod_cast (Nat.zero_lt_of_lt hn)
-  nlinarith
-
-lemma entryPhysicalLevel_cleanup_gap {κ : ℝ} (hκ : 0<κ) (W : WienerLaw)
-    {n : ℕ} (hn : 1≤n) (hm1 : 0 < moment κ W 1)
-    (hJ : moment κ W 1^n ≤ moment κ W n) {k : ℤ} {j : ℕ}
-    (hj : j < multiplicity κ W n k) (A : ℝ) (z : ℂ) :
-    entryPhysicalLevel κ W (n,some (k,j)) A z +
-      2*a κ*(batchLevel κ W n:ℝ)+2*a κ*(n:ℝ) ≤
-        entryPhysicalLevel κ W (n,none) A z := by
-  have hh := entryPhysicalLevel_gap hκ W hn (entryPosition_lt_cleanup κ W hn hm1 hJ hj) A z
-  linarith
-
-lemma eventually_entryPhysicalLevel_large {κ : ℝ} (hκ : 0<κ) (W : WienerLaw)
-    {A : ℝ} (hA : 0<A) (L : ℝ) :
-    ∀ᶠ n : ℕ in atTop, ∀ (o : Option (ℤ×ℕ)) (z : ℂ),
-      Real.exp (-(n:ℝ)) ≤ z.im → L<entryPhysicalLevel κ W (n,o) A z := by
-  obtain ⟨N,hN⟩ := exists_nat_gt (max 2 (L-Real.log (2/A)))
-  filter_upwards [eventually_ge_atTop N] with n hn
-  intro o z hz
-  have hnR : (N:ℝ) ≤ n := by exact_mod_cast hn
-  have hn2 : (2:ℝ)<n := (lt_of_le_of_lt (le_max_left _ _) hN).trans_le hnR
-  have hnL : L-Real.log (2/A)<(n:ℝ) := (lt_of_le_of_lt (le_max_right _ _) hN).trans_le hnR
-  have hlog : Real.log (2/A)-(n:ℝ) ≤ Real.log ((2*z.im)/A) := by
-    have hp : 0<2/A := by positivity
-    have hh := Real.log_le_log (mul_pos hp (Real.exp_pos (-(n:ℝ))))
-      (mul_le_mul_of_nonneg_left hz hp.le)
-    rw [Real.log_mul hp.ne' (Real.exp_ne_zero _),Real.log_exp] at hh
-    simpa only [sub_eq_add_neg,div_mul_eq_mul_div] using hh
-  have hterm : 0 ≤ 2*a κ*(entryPosition κ W (n,o):ℝ)*
-      ((batchLevel κ W n:ℝ)+(n:ℝ)) := by
-    have ha := internal_a_pos hκ
-    positivity
-  dsimp only [entryPhysicalLevel]
-  nlinarith
-
-end SLEExactGauge.Target
-
-end
-
-end OAI
+import OAI.Probability.SLE.Gauge.BatchRadiusGaps
+import OAI.Probability.SLE.Gauge.GaugeEntrySmallness
+
+namespace OAI
+
+/-! Physical logarithmic levels for the exact prescribed radii. Uniformity
+  includes moving centers down to height exp(-n). -/
+noncomputable section
+open Set Filter
+open scoped Topology
+
+namespace SLEExactGauge.Target
+
+def entryPhysicalLevel (κ : ℝ) (W : WienerLaw) (e : Entry) (A : ℝ) (z : ℂ) : ℝ :=
+  Real.log ((2*z.im)/A) + (e.1:ℝ)^2 +
+    2*a κ*(entryPosition κ W e:ℝ)*((batchLevel κ W e.1:ℝ)+(e.1:ℝ))
+
+lemma entryPhysicalLevel_radius (κ : ℝ) (W : WienerLaw) (e : Entry)
+    {A : ℝ} (hA : 0<A) {z : ℂ} (hz : 0<z.im) :
+    (2*z.im)*Real.exp (-entryPhysicalLevel κ W e A z)=A*entryRadius κ W e := by
+  have hp : 0<(2*z.im)/A := by positivity
+  unfold entryPhysicalLevel entryRadius
+  rw [show -(Real.log ((2*z.im)/A)+(e.1:ℝ)^2+
+    2*a κ*(entryPosition κ W e:ℝ)*((batchLevel κ W e.1:ℝ)+(e.1:ℝ))) =
+    -Real.log ((2*z.im)/A)+(-(e.1:ℝ)^2-
+      2*a κ*(entryPosition κ W e:ℝ)*((batchLevel κ W e.1:ℝ)+(e.1:ℝ))) by ring,
+    Real.exp_add,Real.exp_neg,Real.exp_log hp]
+  field_simp
+
+lemma entryPhysicalLevel_gap {κ : ℝ} (hκ : 0<κ) (W : WienerLaw)
+    {n : ℕ} (hn : 1≤n) {o o' : Option (ℤ×ℕ)}
+    (hpos : entryPosition κ W (n,o)<entryPosition κ W (n,o')) (A : ℝ) (z : ℂ) :
+    entryPhysicalLevel κ W (n,o) A z+2*a κ*((batchLevel κ W n:ℝ)+(n:ℝ)) ≤
+      entryPhysicalLevel κ W (n,o') A z := by
+  have hpN : entryPosition κ W (n,o)+1 ≤ entryPosition κ W (n,o') := hpos
+  have hp : (entryPosition κ W (n,o):ℝ)+1 ≤ entryPosition κ W (n,o') := by exact_mod_cast hpN
+  have hcoef : 0 ≤ 2*a κ*((batchLevel κ W n:ℝ)+(n:ℝ)) := by
+    have ha := internal_a_pos hκ
+    positivity
+  have hh := mul_le_mul_of_nonneg_left hp hcoef
+  dsimp only [entryPhysicalLevel]
+  have hnR : (0:ℝ)<n := by exact_mod_cast (Nat.zero_lt_of_lt hn)
+  nlinarith
+
+lemma entryPhysicalLevel_cleanup_gap {κ : ℝ} (hκ : 0<κ) (W : WienerLaw)
+    {n : ℕ} (hn : 1≤n) (hm1 : 0 < moment κ W 1)
+    (hJ : moment κ W 1^n ≤ moment κ W n) {k : ℤ} {j : ℕ}
+    (hj : j < multiplicity κ W n k) (A : ℝ) (z : ℂ) :
+    entryPhysicalLevel κ W (n,some (k,j)) A z +
+      2*a κ*(batchLevel κ W n:ℝ)+2*a κ*(n:ℝ) ≤
+        entryPhysicalLevel κ W (n,none) A z := by
+  have hh := entryPhysicalLevel_gap hκ W hn (entryPosition_lt_cleanup κ W hn hm1 hJ hj) A z
+  linarith
+
+lemma eventually_entryPhysicalLevel_large {κ : ℝ} (hκ : 0<κ) (W : WienerLaw)
+    {A : ℝ} (hA : 0<A) (L : ℝ) :
+    ∀ᶠ n : ℕ in atTop, ∀ (o : Option (ℤ×ℕ)) (z : ℂ),
+      Real.exp (-(n:ℝ)) ≤ z.im → L<entryPhysicalLevel κ W (n,o) A z := by
+  obtain ⟨N,hN⟩ := exists_nat_gt (max 2 (L-Real.log (2/A)))
+  filter_upwards [eventually_ge_atTop N] with n hn
+  intro o z hz
+  have hnR : (N:ℝ) ≤ n := by exact_mod_cast hn
+  have hn2 : (2:ℝ)<n := (lt_of_le_of_lt (le_max_left _ _) hN).trans_le hnR
+  have hnL : L-Real.log (2/A)<(n:ℝ) := (lt_of_le_of_lt (le_max_right _ _) hN).trans_le hnR
+  have hlog : Real.log (2/A)-(n:ℝ) ≤ Real.log ((2*z.im)/A) := by
+    have hp : 0<2/A := by positivity
+    have hh := Real.log_le_log (mul_pos hp (Real.exp_pos (-(n:ℝ))))
+      (mul_le_mul_of_nonneg_left hz hp.le)
+    rw [Real.log_mul hp.ne' (Real.exp_ne_zero _),Real.log_exp] at hh
+    simpa only [sub_eq_add_neg,div_mul_eq_mul_div] using hh
+  have hterm : 0 ≤ 2*a κ*(entryPosition κ W (n,o):ℝ)*
+      ((batchLevel κ W n:ℝ)+(n:ℝ)) := by
+    have ha := internal_a_pos hκ
+    positivity
+  dsimp only [entryPhysicalLevel]
+  nlinarith
+
+end SLEExactGauge.Target
+
+end
+
+end OAI

lean/OAI/Probability/SLE/Gauge/PrescribedRadiusTest.lean

@@ -1,121 +1,121 @@
-import OAI.Probability.SLE.Gauge.PrescribedDiskConditional
-import OAI.Probability.SLE.Geometry.ExtendedDiskAngle
-
-namespace OAI
-
-/-! The prescribed disk success kernel at the literal radius stop. Finite
-cutoffs exhaust that stop under the actual finite centered law. -/
-noncomputable section
-open Set Filter _root_.MeasureTheory _root_.OAI.MeasureTheory ProbabilityTheory Metric
-open scoped Topology NNReal ENNReal
-
-namespace SLEExactGauge.Multipoint
-local instance radiusTestMeasurable : MeasurableSpace C(ℝ≥0,ℝ) := borel _
-local instance radiusTestBorel : BorelSpace C(ℝ≥0,ℝ) := ⟨rfl⟩
-
-theorem CanonicalMass.prescribed_disk_test_at_radius
-    {Ω : 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 ω))
-    (h0 : ∀ ω, B 0 ω=0) (hκ : 0 < κ) (hκ8 : κ < 8)
-    (F : Ω → ℝ≥0 → ℂ → ℂ)
-    (hw : ∀ ω, IsCapacityTwoWitness (fun t => Real.sqrt κ*B t ω) (γ ω) (G ω) (F ω))
-    (R : RawCanonicalMass)
-    (he : ∀ᵐ ω ∂P, (∀ t, R.process t (sourceDriverPath B hc ω)=C.process t ω) ∧
-      R.terminal (sourceDriverPath B hc ω)=C.rational.terminal ω)
-    (D : Set C(ℝ≥0,ℝ)) (hD : MeasurableSet D)
-    (hDf : ∀ᵐ p ∂P.map (sourceDriverPath B hc), p∈D)
-    (hDp : ∀ p∈D, PositiveMassPaths (fun t => R.process t p) (R.terminal p))
-    (hgrowth : PublishedDiskUnivalentGrowth)
-    (hpublished : PublishedTraceGeneration (P.map (sourceDriverPath B hc)) κ (fun t p => p t))
-    (z : ℂ) (hz : z ∈ upperHalfPlane) (u v r b : ℝ)
-    (hu : 0 ≤ u) (hv : 0 < v) (hr : 0 < r)
-    (hR : (2*z.im)*Real.exp (-u)=(2048*Real.pi)*r) :
-    ∀ A : Set Ω, MeasurableSet[(actual_radiusLevelTime_stopping hB
-      (fun t => (hBm.of_uncurry_left : Measurable (B t))) hBm hc h0
-      κ hκ hκ8 γ G F hw z hz u hu).measurableSpace] A →
-      (∫⁻ ω in A, R.angleDiskTail (P.map (sourceDriverPath B hc)) κ b v
-        (extendedMarkedAngle κ B γ G (fun ω => radiusLevelTime (γ ω) (G ω) z u) z ω)
-        ∂finiteCenteredLaw P κ B γ G z (u+v)) ≤
-      finiteCenteredLaw P κ B γ G z (u+v)
-        (A∩C.prescribedBallTest (fun ω => radiusLevelTime (γ ω) (G ω) z (u+v))
-          z ((4096*Real.pi)*r)
-          (ENNReal.ofReal (((128*Real.pi)*r)^dimension κ)*ENNReal.ofReal b)) := by
-  classical
-  have hm (t : ℝ≥0) : Measurable (B t) := hBm.of_uncurry_left
-  let ℱ := Filtration.natural B (fun t => (hm t).stronglyMeasurable)
-  let σ : Ω → WithTop ℝ≥0 := fun ω => radiusLevelTime (γ ω) (G ω) z u
-  have hσ : IsStoppingTime ℱ σ :=
-    actual_radiusLevelTime_stopping hB hm hBm hc h0 κ hκ hκ8 γ G F hw z hz u hu
-  let Q := finiteCenteredLaw P κ B γ G z (u+v)
-  let f := fun ω => R.angleDiskTail (P.map (sourceDriverPath B hc)) κ b v
-    (extendedMarkedAngle κ B γ G σ z ω)
-  let test := C.prescribedBallTest (fun ω => radiusLevelTime (γ ω) (G ω) z (u+v))
-    z ((4096*Real.pi)*r) (ENNReal.ofReal (((128*Real.pi)*r)^dimension κ)*ENNReal.ofReal b)
-  intro A hA
-  let E := fun n : ℕ => A∩{ω | σ ω≤((n:ℝ≥0):WithTop ℝ≥0)}
-  have hEm (n : ℕ) : MeasurableSet (E n) :=
-    hσ.measurableSpace_le _ (hA.inter (hσ.measurableSet_le' n))
-  have hmono : Monotone E := by
-    intro n k hnk ω hω
-    change ω∈A ∧ σ ω≤((n:ℝ≥0):WithTop ℝ≥0) at hω
-    change ω∈A ∧ σ ω≤((k:ℝ≥0):WithTop ℝ≥0)
-    exact ⟨hω.1,hω.2.trans (WithTop.coe_le_coe.mpr (by exact_mod_cast hnk))⟩
-  have hfinite : ∀ᵐ ω ∂Q, σ ω≠⊤ :=
-    finiteCenteredLaw_earlier_stop_ae_finite hB hc κ hκ hκ8 γ G F (Eventually.of_forall hw)
-      z hz u (u+v) hu (by linarith) σ (Eventually.of_forall fun _ => le_rfl)
-  have hbound (n : ℕ) : (∫⁻ ω in E n, f ω ∂Q) ≤ Q (A∩test) := by
-    let τ := cutoffStop σ n
-    have hτ := cutoffStop_stopping ℱ σ hσ (n:ℝ≥0)
-    have hEn : MeasurableSet[hτ.measurableSpace] (E n) :=
-      cutoffStop_success_measurable ℱ σ hσ n A hA
-    have hstate (ω : Ω) (hω : ω∈E n) :
-        z ∈ survivingDomain (γ ω) (τ ω) ∧
-        fullRadius (G ω) (τ ω) z=(2*z.im)*Real.exp (-u) := by
-      rw [show τ ω=(σ ω).untopD 0 from cutoffStop_eq_on_success σ n ω hω.2]
-      exact actual_radius_level_finite_state (hw ω) ((hc ω).const_mul _) z u
-        (ne_top_of_le_ne_top WithTop.coe_ne_top hω.2)
-    have hh := C.prescribed_disk_conditional_bound hB hc h0 hκ hκ8 F hw R he
-      D hD hDf hDp hgrowth hpublished τ hτ z hz u v r b hu hv hr (E n) hEn
-      (fun ω hω => (hstate ω hω).1) (fun ω hω => (hstate ω hω).2)
-      (fun ω hω => (hstate ω hω).2.trans hR) univ MeasurableSet.univ
-    simp only [univ_inter] at hh
-    have hid (ω : Ω) (hω : ω∈E n) : f ω=R.angleDiskTail
-        (P.map (sourceDriverPath B hc)) κ b v (stoppedMarkedCenter κ B γ G τ z ω).arg := by
-      dsimp only [f,extendedMarkedAngle]
-      rw [ite_eq_right (ne_top_of_le_ne_top WithTop.coe_ne_top hω.2)]
-      congr 2
-      exact (stoppedMarkedCenter_time_congr κ B γ G τ
-        (fun ω => (σ ω).untopD 0) z ω (cutoffStop_eq_on_success σ n ω hω.2)).symm
-    rw [setLIntegral_congr_fun (hEm n) hid]
-    exact hh.trans (measure_mono (inter_subset_inter inter_subset_left subset_rfl))
-  have hcover : A =ᵐ[Q] ⋃ n, E n := by
-    filter_upwards [hfinite] with ω hω
-    apply propext
-    constructor
-    · intro hAω
-      lift σ ω to ℝ≥0 using hω with t ht
-      obtain ⟨n,hn⟩ := exists_nat_ge (t:ℝ)
-      exact mem_iUnion.mpr ⟨n,hAω,by
-        change σ ω≤((n:ℝ≥0):WithTop ℝ≥0)
-        rw [← ht]
-        exact WithTop.coe_le_coe.mpr (by exact_mod_cast hn)⟩
-    · intro hωE
-      obtain ⟨n,hn⟩ := mem_iUnion.mp hωE
-      exact hn.1
-  have habs : (Q.withDensity f).AbsolutelyContinuous Q := withDensity_absolutelyContinuous Q f
-  calc
-    (∫⁻ ω in A, f ω ∂Q) = Q.withDensity f A := (withDensity_apply _ (hσ.measurableSpace_le _ hA)).symm
-    _ = Q.withDensity f (⋃ n, E n) := measure_congr (habs.ae_le hcover)
-    _ = ⨆ n, Q.withDensity f (E n) := hmono.measure_iUnion
-    _ ≤ Q (A∩test) := iSup_le fun n => by
-      rw [withDensity_apply _ (hEm n)]
-      exact hbound n
-
-end SLEExactGauge.Multipoint
-
-end
-
-end OAI
+import OAI.Probability.SLE.Gauge.PrescribedDiskConditional
+import OAI.Probability.SLE.Geometry.ExtendedDiskAngle
+
+namespace OAI
+
+/-! The prescribed disk success kernel at the literal radius stop. Finite
+cutoffs exhaust that stop under the actual finite centered law. -/
+noncomputable section
+open Set Filter _root_.MeasureTheory _root_.OAI.MeasureTheory ProbabilityTheory Metric
+open scoped Topology NNReal ENNReal
+
+namespace SLEExactGauge.Multipoint
+local instance radiusTestMeasurable : MeasurableSpace C(ℝ≥0,ℝ) := borel _
+local instance radiusTestBorel : BorelSpace C(ℝ≥0,ℝ) := ⟨rfl⟩
+
+theorem CanonicalMass.prescribed_disk_test_at_radius
+    {Ω : 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 ω))
+    (h0 : ∀ ω, B 0 ω=0) (hκ : 0 < κ) (hκ8 : κ < 8)
+    (F : Ω → ℝ≥0 → ℂ → ℂ)
+    (hw : ∀ ω, IsCapacityTwoWitness (fun t => Real.sqrt κ*B t ω) (γ ω) (G ω) (F ω))
+    (R : RawCanonicalMass)
+    (he : ∀ᵐ ω ∂P, (∀ t, R.process t (sourceDriverPath B hc ω)=C.process t ω) ∧
+      R.terminal (sourceDriverPath B hc ω)=C.rational.terminal ω)
+    (D : Set C(ℝ≥0,ℝ)) (hD : MeasurableSet D)
+    (hDf : ∀ᵐ p ∂P.map (sourceDriverPath B hc), p∈D)
+    (hDp : ∀ p∈D, PositiveMassPaths (fun t => R.process t p) (R.terminal p))
+    (hgrowth : PublishedDiskUnivalentGrowth)
+    (hpublished : PublishedTraceGeneration (P.map (sourceDriverPath B hc)) κ (fun t p => p t))
+    (z : ℂ) (hz : z ∈ upperHalfPlane) (u v r b : ℝ)
+    (hu : 0 ≤ u) (hv : 0 < v) (hr : 0 < r)
+    (hR : (2*z.im)*Real.exp (-u)=(2048*Real.pi)*r) :
+    ∀ A : Set Ω, MeasurableSet[(actual_radiusLevelTime_stopping hB
+      (fun t => (hBm.of_uncurry_left : Measurable (B t))) hBm hc h0
+      κ hκ hκ8 γ G F hw z hz u hu).measurableSpace] A →
+      (∫⁻ ω in A, R.angleDiskTail (P.map (sourceDriverPath B hc)) κ b v
+        (extendedMarkedAngle κ B γ G (fun ω => radiusLevelTime (γ ω) (G ω) z u) z ω)
+        ∂finiteCenteredLaw P κ B γ G z (u+v)) ≤
+      finiteCenteredLaw P κ B γ G z (u+v)
+        (A∩C.prescribedBallTest (fun ω => radiusLevelTime (γ ω) (G ω) z (u+v))
+          z ((4096*Real.pi)*r)
+          (ENNReal.ofReal (((128*Real.pi)*r)^dimension κ)*ENNReal.ofReal b)) := by
+  classical
+  have hm (t : ℝ≥0) : Measurable (B t) := hBm.of_uncurry_left
+  let ℱ := Filtration.natural B (fun t => (hm t).stronglyMeasurable)
+  let σ : Ω → WithTop ℝ≥0 := fun ω => radiusLevelTime (γ ω) (G ω) z u
+  have hσ : IsStoppingTime ℱ σ :=
+    actual_radiusLevelTime_stopping hB hm hBm hc h0 κ hκ hκ8 γ G F hw z hz u hu
+  let Q := finiteCenteredLaw P κ B γ G z (u+v)
+  let f := fun ω => R.angleDiskTail (P.map (sourceDriverPath B hc)) κ b v
+    (extendedMarkedAngle κ B γ G σ z ω)
+  let test := C.prescribedBallTest (fun ω => radiusLevelTime (γ ω) (G ω) z (u+v))
+    z ((4096*Real.pi)*r) (ENNReal.ofReal (((128*Real.pi)*r)^dimension κ)*ENNReal.ofReal b)
+  intro A hA
+  let E := fun n : ℕ => A∩{ω | σ ω≤((n:ℝ≥0):WithTop ℝ≥0)}
+  have hEm (n : ℕ) : MeasurableSet (E n) :=
+    hσ.measurableSpace_le _ (hA.inter (hσ.measurableSet_le' n))
+  have hmono : Monotone E := by
+    intro n k hnk ω hω
+    change ω∈A ∧ σ ω≤((n:ℝ≥0):WithTop ℝ≥0) at hω
+    change ω∈A ∧ σ ω≤((k:ℝ≥0):WithTop ℝ≥0)
+    exact ⟨hω.1,hω.2.trans (WithTop.coe_le_coe.mpr (by exact_mod_cast hnk))⟩
+  have hfinite : ∀ᵐ ω ∂Q, σ ω≠⊤ :=
+    finiteCenteredLaw_earlier_stop_ae_finite hB hc κ hκ hκ8 γ G F (Eventually.of_forall hw)
+      z hz u (u+v) hu (by linarith) σ (Eventually.of_forall fun _ => le_rfl)
+  have hbound (n : ℕ) : (∫⁻ ω in E n, f ω ∂Q) ≤ Q (A∩test) := by
+    let τ := cutoffStop σ n
+    have hτ := cutoffStop_stopping ℱ σ hσ (n:ℝ≥0)
+    have hEn : MeasurableSet[hτ.measurableSpace] (E n) :=
+      cutoffStop_success_measurable ℱ σ hσ n A hA
+    have hstate (ω : Ω) (hω : ω∈E n) :
+        z ∈ survivingDomain (γ ω) (τ ω) ∧
+        fullRadius (G ω) (τ ω) z=(2*z.im)*Real.exp (-u) := by
+      rw [show τ ω=(σ ω).untopD 0 from cutoffStop_eq_on_success σ n ω hω.2]
+      exact actual_radius_level_finite_state (hw ω) ((hc ω).const_mul _) z u
+        (ne_top_of_le_ne_top WithTop.coe_ne_top hω.2)
+    have hh := C.prescribed_disk_conditional_bound hB hc h0 hκ hκ8 F hw R he
+      D hD hDf hDp hgrowth hpublished τ hτ z hz u v r b hu hv hr (E n) hEn
+      (fun ω hω => (hstate ω hω).1) (fun ω hω => (hstate ω hω).2)
+      (fun ω hω => (hstate ω hω).2.trans hR) univ MeasurableSet.univ
+    simp only [univ_inter] at hh
+    have hid (ω : Ω) (hω : ω∈E n) : f ω=R.angleDiskTail
+        (P.map (sourceDriverPath B hc)) κ b v (stoppedMarkedCenter κ B γ G τ z ω).arg := by
+      dsimp only [f,extendedMarkedAngle]
+      rw [ite_eq_right (ne_top_of_le_ne_top WithTop.coe_ne_top hω.2)]
+      congr 2
+      exact (stoppedMarkedCenter_time_congr κ B γ G τ
+        (fun ω => (σ ω).untopD 0) z ω (cutoffStop_eq_on_success σ n ω hω.2)).symm
+    rw [setLIntegral_congr_fun (hEm n) hid]
+    exact hh.trans (measure_mono (inter_subset_inter inter_subset_left subset_rfl))
+  have hcover : A =ᵐ[Q] ⋃ n, E n := by
+    filter_upwards [hfinite] with ω hω
+    apply propext
+    constructor
+    · intro hAω
+      lift σ ω to ℝ≥0 using hω with t ht
+      obtain ⟨n,hn⟩ := exists_nat_ge (t:ℝ)
+      exact mem_iUnion.mpr ⟨n,hAω,by
+        change σ ω≤((n:ℝ≥0):WithTop ℝ≥0)
+        rw [← ht]
+        exact WithTop.coe_le_coe.mpr (by exact_mod_cast hn)⟩
+    · intro hωE
+      obtain ⟨n,hn⟩ := mem_iUnion.mp hωE
+      exact hn.1
+  have habs : (Q.withDensity f).AbsolutelyContinuous Q := withDensity_absolutelyContinuous Q f
+  calc
+    (∫⁻ ω in A, f ω ∂Q) = Q.withDensity f A := (withDensity_apply _ (hσ.measurableSpace_le _ hA)).symm
+    _ = Q.withDensity f (⋃ n, E n) := measure_congr (habs.ae_le hcover)
+    _ = ⨆ n, Q.withDensity f (E n) := hmono.measure_iUnion
+    _ ≤ Q (A∩test) := iSup_le fun n => by
+      rw [withDensity_apply _ (hEm n)]
+      exact hbound n
+
+end SLEExactGauge.Multipoint
+
+end
+
+end OAI

lean/OAI/Probability/SLE/Gauge/PrescribedRowSum.lean

@@ -1,58 +1,58 @@
-import OAI.Probability.SLE.SimpleTails
-import Mathlib.Analysis.SumIntegralComparisons
-
-namespace OAI
-
-/-! The half-integer row heights have an integrable boundary singularity.
-This is the row sum used in the prescribed cover's missed-cell estimate. -/
-noncomputable section
-open Set Filter MeasureTheory
-open scoped Topology
-
-namespace SLEExactGauge
-
-lemma half_integer_row_sum_bound (α : ℝ) (hα0 : 0 ≤ α) (hα1 : α<1) (N : ℕ) :
-    (∑ j∈Finset.range N, ((j:ℝ)+1/2)^(-α)) ≤
-      (2:ℝ)^α/(1-α)*(N:ℝ)^(1-α) := by
-  have hq : 0<1-α := by linarith
-  have hfi : IntegrableOn (fun x : ℝ => x^(-α)) (Icc 0 (N:ℝ)) := by
-    have ha := (integrableOn_abs_heightPower α (N:ℝ) hα1).mono_set
-      (show Icc (0:ℝ) N ⊆ Icc (-(N:ℝ)) N by
-        intro x hx
-        exact ⟨(neg_nonpos.mpr (Nat.cast_nonneg N)).trans hx.1,hx.2⟩)
-    apply ha.congr_fun _ measurableSet_Icc
-    intro x hx
-    dsimp only
-    rw [abs_of_nonneg hx.1]
-  have hanti : AntitoneOn (fun x : ℝ => x^(-α)) (Ioc 0 (N:ℝ)) := by
-    intro x hx y _ hxy
-    exact Real.rpow_le_rpow_of_nonpos hx.1 hxy (neg_nonpos.mpr hα0)
-  have hsum : (∑ j∈Finset.range N, ((j:ℝ)+1)^(-α)) ≤
-      ∫ x in (0:ℝ)..(N:ℝ), x^(-α) := by
-    have ha : AntitoneOn (fun x : ℝ => x^(-α)) (Ioc 0 (0+(N:ℝ))) := by
-      simpa only [zero_add] using hanti
-    simpa only [zero_add,Nat.cast_add,Nat.cast_one] using
-      ha.sum_le_integral_of_integrableOn (x₀ := 0) (a := N) (by simpa only [zero_add] using hfi)
-  have hint : (∫ x in (0:ℝ)..(N:ℝ), x^(-α)) = (N:ℝ)^(1-α)/(1-α) := by
-    rw [integral_rpow (Or.inl (by linarith : -1 < -α))]
-    rw [show -α+1=1-α by ring,Real.zero_rpow hq.ne',sub_zero]
-  have hhalf (j : ℕ) : ((j:ℝ)+1/2)^(-α) ≤ (2:ℝ)^α*((j:ℝ)+1)^(-α) := by
-    have h := Real.rpow_le_rpow_of_nonpos
-      (show (0:ℝ)<((j:ℝ)+1)/2 by positivity)
-      (show ((j:ℝ)+1)/2 ≤ (j:ℝ)+1/2 by nlinarith [Nat.cast_nonneg (α := ℝ) j])
-      (neg_nonpos.mpr hα0)
-    refine h.trans_eq ?_
-    rw [Real.div_rpow (by positivity) (by norm_num),Real.rpow_neg (by norm_num : (0:ℝ) ≤ 2),div_inv_eq_mul]
-    ring
-  calc
-    _ ≤ ∑ j∈Finset.range N, (2:ℝ)^α*((j:ℝ)+1)^(-α) := Finset.sum_le_sum (fun j _ => hhalf j)
-    _ = (2:ℝ)^α*∑ j∈Finset.range N, ((j:ℝ)+1)^(-α) := (Finset.mul_sum ..).symm
-    _ ≤ (2:ℝ)^α*(∫ x in (0:ℝ)..(N:ℝ), x^(-α)) :=
-      mul_le_mul_of_nonneg_left hsum (Real.rpow_nonneg (by norm_num) _)
-    _ = _ := by rw [hint]; ring
-
-end SLEExactGauge
-
-end
-
-end OAI
+import OAI.Probability.SLE.SimpleTails
+import Mathlib.Analysis.SumIntegralComparisons
+
+namespace OAI
+
+/-! The half-integer row heights have an integrable boundary singularity.
+This is the row sum used in the prescribed cover's missed-cell estimate. -/
+noncomputable section
+open Set Filter MeasureTheory
+open scoped Topology
+
+namespace SLEExactGauge
+
+lemma half_integer_row_sum_bound (α : ℝ) (hα0 : 0 ≤ α) (hα1 : α<1) (N : ℕ) :
+    (∑ j∈Finset.range N, ((j:ℝ)+1/2)^(-α)) ≤
+      (2:ℝ)^α/(1-α)*(N:ℝ)^(1-α) := by
+  have hq : 0<1-α := by linarith
+  have hfi : IntegrableOn (fun x : ℝ => x^(-α)) (Icc 0 (N:ℝ)) := by
+    have ha := (integrableOn_abs_heightPower α (N:ℝ) hα1).mono_set
+      (show Icc (0:ℝ) N ⊆ Icc (-(N:ℝ)) N by
+        intro x hx
+        exact ⟨(neg_nonpos.mpr (Nat.cast_nonneg N)).trans hx.1,hx.2⟩)
+    apply ha.congr_fun _ measurableSet_Icc
+    intro x hx
+    dsimp only
+    rw [abs_of_nonneg hx.1]
+  have hanti : AntitoneOn (fun x : ℝ => x^(-α)) (Ioc 0 (N:ℝ)) := by
+    intro x hx y _ hxy
+    exact Real.rpow_le_rpow_of_nonpos hx.1 hxy (neg_nonpos.mpr hα0)
+  have hsum : (∑ j∈Finset.range N, ((j:ℝ)+1)^(-α)) ≤
+      ∫ x in (0:ℝ)..(N:ℝ), x^(-α) := by
+    have ha : AntitoneOn (fun x : ℝ => x^(-α)) (Ioc 0 (0+(N:ℝ))) := by
+      simpa only [zero_add] using hanti
+    simpa only [zero_add,Nat.cast_add,Nat.cast_one] using
+      ha.sum_le_integral_of_integrableOn (x₀ := 0) (a := N) (by simpa only [zero_add] using hfi)
+  have hint : (∫ x in (0:ℝ)..(N:ℝ), x^(-α)) = (N:ℝ)^(1-α)/(1-α) := by
+    rw [integral_rpow (Or.inl (by linarith : -1 < -α))]
+    rw [show -α+1=1-α by ring,Real.zero_rpow hq.ne',sub_zero]
+  have hhalf (j : ℕ) : ((j:ℝ)+1/2)^(-α) ≤ (2:ℝ)^α*((j:ℝ)+1)^(-α) := by
+    have h := Real.rpow_le_rpow_of_nonpos
+      (show (0:ℝ)<((j:ℝ)+1)/2 by positivity)
+      (show ((j:ℝ)+1)/2 ≤ (j:ℝ)+1/2 by nlinarith [Nat.cast_nonneg (α := ℝ) j])
+      (neg_nonpos.mpr hα0)
+    refine h.trans_eq ?_
+    rw [Real.div_rpow (by positivity) (by norm_num),Real.rpow_neg (by norm_num : (0:ℝ) ≤ 2),div_inv_eq_mul]
+    ring
+  calc
+    _ ≤ ∑ j∈Finset.range N, (2:ℝ)^α*((j:ℝ)+1)^(-α) := Finset.sum_le_sum (fun j _ => hhalf j)
+    _ = (2:ℝ)^α*∑ j∈Finset.range N, ((j:ℝ)+1)^(-α) := (Finset.mul_sum ..).symm
+    _ ≤ (2:ℝ)^α*(∫ x in (0:ℝ)..(N:���), x^(-α)) :=
+      mul_le_mul_of_nonneg_left hsum (Real.rpow_nonneg (by norm_num) _)
+    _ = _ := by rw [hint]; ring
+
+end SLEExactGauge
+
+end
+
+end OAI

lean/OAI/Probability/SLE/Gauge/PrescribedTestPast.lean

@@ -1,93 +1,93 @@
-import OAI.Probability.SLE.Gauge.PrescribedBatchClock
-
-namespace OAI
-
-/-! The history before each test is taken at the preceding test endpoint.
-The intervening radius gap is reserved for angular mixing. -/
-noncomputable section
-open Set Filter
-
-namespace SLEExactGauge.Target
-
-def prescribedTestPastLevel {J : ℕ} (κ : ℝ) (W : WienerLaw) (n : ℕ)
-    (e : Fin J → ℤ×ℕ) (A : ℝ) (z : ℂ) (i : ℕ) : ℝ :=
-  if i=0 then 0 else prescribedBatchLevel κ W n e A z (i-1)+
-    2*a κ*(batchLevel κ W n:ℝ)
-
-lemma prescribedTestPastLevel_nonneg {κ : ℝ} (hκ : 0 < κ) (W : WienerLaw)
-    (n : ℕ) {J : ℕ} (e : Fin J → ℤ×ℕ) (A : ℝ) (z : ℂ)
-    (hl : ∀ o, 0 ≤ entryPhysicalLevel κ W (n,o) A z) (i : ℕ) :
-    0 ≤ prescribedTestPastLevel κ W n e A z i := by
-  have ha := internal_a_pos hκ
-  unfold prescribedTestPastLevel prescribedBatchLevel
-  split_ifs
-  · exact le_rfl
-  · exact add_nonneg (hl _) (by positivity)
-  · exact add_nonneg (hl _) (by positivity)
-
-lemma prescribedTestPastLevel_succ {κ : ℝ} (W : WienerLaw) (n : ℕ)
-    {J : ℕ} (e : Fin J → ℤ×ℕ) (A : ℝ) (z : ℂ) (i : Fin J) :
-    prescribedTestPastLevel κ W n e A z (i.val+1)=
-      entryPhysicalLevel κ W (n,some (e i)) A z+2*a κ*(batchLevel κ W n:ℝ) := by
-  simp only [prescribedTestPastLevel,Nat.add_one_ne_zero,ite_false,Nat.add_sub_cancel,
-    prescribedBatchLevel,dite_eq_left i.isLt,Fin.eta]
-
-lemma prescribedTestPastLevel_monotone {κ : ℝ} (hκ : 0 < κ) (W : WienerLaw)
-    {n J : ℕ} (hn : 1 ≤ n) (hm1 : 0 < moment κ W 1)
-    (hJ : moment κ W 1^n ≤ moment κ W n) (e : Fin J → ℤ×ℕ)
-    (he : ∀ i, (e i).2 < multiplicity κ W n (e i).1)
-    (horder : StrictMono (fun i => entryPosition κ W (n,some (e i))))
-    (A : ℝ) (z : ℂ) (hl : ∀ o, 0 ≤ entryPhysicalLevel κ W (n,o) A z) :
-    Monotone (prescribedTestPastLevel κ W n e A z) := by
-  intro i j hij
-  by_cases hi : i=0
-  · subst i
-    simpa only [prescribedTestPastLevel,ite_true] using
-      prescribedTestPastLevel_nonneg hκ W n e A z hl j
-  · have hj : j ≠ 0 := by omega
-    simp only [prescribedTestPastLevel,ite_eq_right hi,ite_eq_right hj]
-    exact add_le_add
-      (prescribedBatchLevel_monotone hκ W hn hm1 hJ e he horder A z
-        (Nat.sub_le_sub_right hij 1)) le_rfl
-
-lemma prescribedTestPastLevel_gap {κ : ℝ} (hκ : 0 < κ) (W : WienerLaw)
-    {n J : ℕ} (hn : 1 ≤ n) (e : Fin J → ℤ×ℕ)
-    (horder : StrictMono (fun i => entryPosition κ W (n,some (e i))))
-    (A : ℝ) (z : ℂ) (δ : ℝ)
-    (hfirst : ∀ i, δ ≤ entryPhysicalLevel κ W (n,some (e i)) A z)
-    (hδ : δ ≤ 2*a κ*(n:ℝ)) (i : Fin J) :
-    prescribedTestPastLevel κ W n e A z i.val+δ ≤
-      entryPhysicalLevel κ W (n,some (e i)) A z := by
-  by_cases hi : i.val=0
-  · simpa only [prescribedTestPastLevel,hi,ite_true,zero_add] using hfirst i
-  · let j : Fin J := ⟨i.val-1,by omega⟩
-    have heq : i.val=j.val+1 := by dsimp only [j]; omega
-    rw [heq,prescribedTestPastLevel_succ W n e A z j]
-    have hpos := horder (show j < i from by
-      dsimp only [j]
-      exact Nat.sub_lt (Nat.pos_of_ne_zero hi) (by decide))
-    have hh := entryPhysicalLevel_gap hκ W hn hpos A z
-    linarith
-
-lemma eventually_prescribedTestPastLevel_gap {κ : ℝ} (hκ : 0 < κ)
-    (W : WienerLaw) {A : ℝ} (hA : 0 < A) (δ : ℝ) :
-    ∀ᶠ n : ℕ in Filter.atTop, ∀ (J : ℕ) (e : Fin J → ℤ×ℕ),
-      StrictMono (fun i => entryPosition κ W (n,some (e i))) →
-      ∀ z : ℂ, Real.exp (-(n:ℝ)) ≤ z.im → ∀ i : Fin J,
-        prescribedTestPastLevel κ W n e A z i.val+δ ≤
-          entryPhysicalLevel κ W (n,some (e i)) A z := by
-  have ha : 0 < 2*a κ := mul_pos (by norm_num) (internal_a_pos hκ)
-  have hn : ∀ᶠ n : ℕ in Filter.atTop, δ/(2*a κ) ≤ (n:ℝ) :=
-    tendsto_natCast_atTop_atTop.eventually (eventually_ge_atTop _)
-  filter_upwards [eventually_entryPhysicalLevel_large hκ W hA δ,hn,
-    Filter.eventually_ge_atTop 1] with n hlevel hδ hn1
-  intro J e horder z hz i
-  apply prescribedTestPastLevel_gap hκ W hn1 e horder A z δ
-    (fun j => (hlevel (some (e j)) z hz).le) _ i
-  simpa only [mul_comm] using (div_le_iff₀ ha).mp hδ
-
-end SLEExactGauge.Target
-
-end
-
-end OAI
+import OAI.Probability.SLE.Gauge.PrescribedBatchClock
+
+namespace OAI
+
+/-! The history before each test is taken at the preceding test endpoint.
+The intervening radius gap is reserved for angular mixing. -/
+noncomputable section
+open Set Filter
+
+namespace SLEExactGauge.Target
+
+def prescribedTestPastLevel {J : ℕ} (κ : ℝ) (W : WienerLaw) (n : ℕ)
+    (e : Fin J → ℤ×ℕ) (A : ℝ) (z : ℂ) (i : ℕ) : ℝ :=
+  if i=0 then 0 else prescribedBatchLevel κ W n e A z (i-1)+
+    2*a κ*(batchLevel κ W n:ℝ)
+
+lemma prescribedTestPastLevel_nonneg {κ : ℝ} (hκ : 0 < κ) (W : WienerLaw)
+    (n : ℕ) {J : ℕ} (e : Fin J → ℤ×ℕ) (A : ℝ) (z : ℂ)
+    (hl : ∀ o, 0 ≤ entryPhysicalLevel κ W (n,o) A z) (i : ℕ) :
+    0 ≤ prescribedTestPastLevel κ W n e A z i := by
+  have ha := internal_a_pos hκ
+  unfold prescribedTestPastLevel prescribedBatchLevel
+  split_ifs
+  · exact le_rfl
+  · exact add_nonneg (hl _) (by positivity)
+  · exact add_nonneg (hl _) (by positivity)
+
+lemma prescribedTestPastLevel_succ {κ : ℝ} (W : WienerLaw) (n : ℕ)
+    {J : ℕ} (e : Fin J → ℤ×ℕ) (A : ℝ) (z : ℂ) (i : Fin J) :
+    prescribedTestPastLevel κ W n e A z (i.val+1)=
+      entryPhysicalLevel κ W (n,some (e i)) A z+2*a κ*(batchLevel κ W n:ℝ) := by
+  simp only [prescribedTestPastLevel,Nat.add_one_ne_zero,ite_false,Nat.add_sub_cancel,
+    prescribedBatchLevel,dite_eq_left i.isLt,Fin.eta]
+
+lemma prescribedTestPastLevel_monotone {κ : ℝ} (hκ : 0 < κ) (W : WienerLaw)
+    {n J : ℕ} (hn : 1 ≤ n) (hm1 : 0 < moment κ W 1)
+    (hJ : moment κ W 1^n ≤ moment κ W n) (e : Fin J → ℤ×ℕ)
+    (he : ∀ i, (e i).2 < multiplicity κ W n (e i).1)
+    (horder : StrictMono (fun i => entryPosition κ W (n,some (e i))))
+    (A : ℝ) (z : ℂ) (hl : ∀ o, 0 ≤ entryPhysicalLevel κ W (n,o) A z) :
+    Monotone (prescribedTestPastLevel κ W n e A z) := by
+  intro i j hij
+  by_cases hi : i=0
+  · subst i
+    simpa only [prescribedTestPastLevel,ite_true] using
+      prescribedTestPastLevel_nonneg hκ W n e A z hl j
+  · have hj : j ≠ 0 := by omega
+    simp only [prescribedTestPastLevel,ite_eq_right hi,ite_eq_right hj]
+    exact add_le_add
+      (prescribedBatchLevel_monotone hκ W hn hm1 hJ e he horder A z
+        (Nat.sub_le_sub_right hij 1)) le_rfl
+
+lemma prescribedTestPastLevel_gap {κ : ℝ} (hκ : 0 < κ) (W : WienerLaw)
+    {n J : ℕ} (hn : 1 ≤ n) (e : Fin J → ℤ×ℕ)
+    (horder : StrictMono (fun i => entryPosition κ W (n,some (e i))))
+    (A : ℝ) (z : ℂ) (δ : ℝ)
+    (hfirst : ∀ i, δ ≤ entryPhysicalLevel κ W (n,some (e i)) A z)
+    (hδ : δ ≤ 2*a κ*(n:ℝ)) (i : Fin J) :
+    prescribedTestPastLevel κ W n e A z i.val+δ ≤
+      entryPhysicalLevel κ W (n,some (e i)) A z := by
+  by_cases hi : i.val=0
+  · simpa only [prescribedTestPastLevel,hi,ite_true,zero_add] using hfirst i
+  · let j : Fin J := ⟨i.val-1,by omega⟩
+    have heq : i.val=j.val+1 := by dsimp only [j]; omega
+    rw [heq,prescribedTestPastLevel_succ W n e A z j]
+    have hpos := horder (show j < i from by
+      dsimp only [j]
+      exact Nat.sub_lt (Nat.pos_of_ne_zero hi) (by decide))
+    have hh := entryPhysicalLevel_gap hκ W hn hpos A z
+    linarith
+
+lemma eventually_prescribedTestPastLevel_gap {κ : ℝ} (hκ : 0 < κ)
+    (W : WienerLaw) {A : ℝ} (hA : 0 < A) (δ : ℝ) :
+    ∀ᶠ n : ℕ in Filter.atTop, ∀ (J : ℕ) (e : Fin J → ℤ×ℕ),
+      StrictMono (fun i => entryPosition κ W (n,some (e i))) →
+      ∀ z : ℂ, Real.exp (-(n:ℝ)) ≤ z.im → ∀ i : Fin J,
+        prescribedTestPastLevel κ W n e A z i.val+δ ≤
+          entryPhysicalLevel κ W (n,some (e i)) A z := by
+  have ha : 0 < 2*a κ := mul_pos (by norm_num) (internal_a_pos hκ)
+  have hn : ∀ᶠ n : ℕ in Filter.atTop, δ/(2*a κ) ≤ (n:ℝ) :=
+    tendsto_natCast_atTop_atTop.eventually (eventually_ge_atTop _)
+  filter_upwards [eventually_entryPhysicalLevel_large hκ W hA δ,hn,
+    Filter.eventually_ge_atTop 1] with n hlevel hδ hn1
+  intro J e horder z hz i
+  apply prescribedTestPastLevel_gap hκ W hn1 e horder A z δ
+    (fun j => (hlevel (some (e j)) z hz).le) _ i
+  simpa only [mul_comm] using (div_le_iff₀ ha).mp hδ
+
+end SLEExactGauge.Target
+
+end
+
+end OAI

lean/OAI/Probability/SLE/Gauge/PrescribedUniformGeometry.lean

@@ -1,54 +1,54 @@
-import OAI.Probability.SLE.Gauge.PrescribedBatchClock
-
-namespace OAI
-
-/-! One late-batch cutoff supplies all clock and visit geometry, uniformly
-  over every center above the shrinking boundary strip. -/
-noncomputable section
-open Set Filter
-open scoped Topology
-
-namespace SLEExactGauge.Target
-
-theorem eventually_prescribed_uniform_geometry {κ : ℝ} (hκ : 0<κ) (W : WienerLaw)
-    (hm1 : 0 < moment κ W 1)
-    (hJ : ∀ n, 1≤n → moment κ W 1^n ≤ moment κ W n) :
-    ∀ᶠ n : ℕ in atTop, ∀ z : ℂ, Real.exp (-(n:ℝ)) ≤ z.im →
-      (∀ o, 0 ≤ entryPhysicalLevel κ W (n,o) (2048*Real.pi) z) ∧
-      4*entryRadius κ W (n,none) ≤ z.im ∧
-      ∀ (k : ℤ) (j : ℕ), j < multiplicity κ W n k →
-        entryPhysicalLevel κ W (n,some (k,j)) (2048*Real.pi) z+
-          2*a κ*(batchLevel κ W n:ℝ)+1 ≤
-            entryPhysicalLevel κ W (n,none) (2048*Real.pi) z := by
-  have ha : 0<2*a κ := mul_pos (by norm_num) (internal_a_pos hκ)
-  have hlarge : ∀ᶠ n : ℕ in atTop, 1/(2*a κ) ≤ (n:ℝ) :=
-    tendsto_natCast_atTop_atTop.eventually (eventually_ge_atTop _)
-  filter_upwards [eventually_entryPhysicalLevel_large hκ W (by positivity : 0<2048*Real.pi) 0,
-    hlarge,eventually_ge_atTop 3] with n hl hn hn3
-  intro z hz
-  have hn1 : 1≤n := by omega
-  have hnR : (3:ℝ) ≤ n := by exact_mod_cast hn3
-  have hunit : 1 ≤ 2*a κ*(n:ℝ) := by
-    have hh := (div_le_iff₀ ha).mp hn
-    linarith
-  refine ⟨fun o => (hl o z hz).le,?_,?_⟩
-  · apply le_trans _ hz
-    calc
-      _ ≤ 4*Real.exp (-(n:ℝ)^2) :=
-        mul_le_mul_of_nonneg_left (entryRadius_le_batch_exp hκ W (n,none)) (by norm_num)
-      _ ≤ Real.exp (-(n:ℝ)) := by
-        rw [show (4:ℝ)=Real.exp (Real.log 4) by rw [Real.exp_log (by norm_num)],← Real.exp_add]
-        apply Real.exp_le_exp.mpr
-        have hh : Real.log 4 ≤ 3 := by
-          have hl4 := Real.log_le_sub_one_of_pos (by norm_num : (0:ℝ)<4)
-          linarith
-        nlinarith
-  · intro k j hj
-    have hh := entryPhysicalLevel_cleanup_gap hκ W hn1 hm1 (hJ n hn1) hj (2048*Real.pi) z
-    linarith
-
-end SLEExactGauge.Target
-
-end
-
-end OAI
+import OAI.Probability.SLE.Gauge.PrescribedBatchClock
+
+namespace OAI
+
+/-! One late-batch cutoff supplies all clock and visit geometry, uniformly
+  over every center above the shrinking boundary strip. -/
+noncomputable section
+open Set Filter
+open scoped Topology
+
+namespace SLEExactGauge.Target
+
+theorem eventually_prescribed_uniform_geometry {κ : ℝ} (hκ : 0<κ) (W : WienerLaw)
+    (hm1 : 0 < moment κ W 1)
+    (hJ : ∀ n, 1≤n → moment κ W 1^n ≤ moment κ W n) :
+    ∀ᶠ n : ℕ in atTop, ∀ z : ℂ, Real.exp (-(n:ℝ)) ≤ z.im →
+      (∀ o, 0 ≤ entryPhysicalLevel κ W (n,o) (2048*Real.pi) z) ∧
+      4*entryRadius κ W (n,none) ≤ z.im ∧
+      ∀ (k : ℤ) (j : ℕ), j < multiplicity κ W n k →
+        entryPhysicalLevel κ W (n,some (k,j)) (2048*Real.pi) z+
+          2*a κ*(batchLevel κ W n:ℝ)+1 ≤
+            entryPhysicalLevel κ W (n,none) (2048*Real.pi) z := by
+  have ha : 0<2*a κ := mul_pos (by norm_num) (internal_a_pos hκ)
+  have hlarge : ∀ᶠ n : ℕ in atTop, 1/(2*a κ) ≤ (n:ℝ) :=
+    tendsto_natCast_atTop_atTop.eventually (eventually_ge_atTop _)
+  filter_upwards [eventually_entryPhysicalLevel_large hκ W (by positivity : 0<2048*Real.pi) 0,
+    hlarge,eventually_ge_atTop 3] with n hl hn hn3
+  intro z hz
+  have hn1 : 1≤n := by omega
+  have hnR : (3:ℝ) ≤ n := by exact_mod_cast hn3
+  have hunit : 1 ≤ 2*a κ*(n:ℝ) := by
+    have hh := (div_le_iff₀ ha).mp hn
+    linarith
+  refine ⟨fun o => (hl o z hz).le,?_,?_⟩
+  · apply le_trans _ hz
+    calc
+      _ ≤ 4*Real.exp (-(n:ℝ)^2) :=
+        mul_le_mul_of_nonneg_left (entryRadius_le_batch_exp hκ W (n,none)) (by norm_num)
+      _ ≤ Real.exp (-(n:ℝ)) := by
+        rw [show (4:ℝ)=Real.exp (Real.log 4) by rw [Real.exp_log (by norm_num)],← Real.exp_add]
+        apply Real.exp_le_exp.mpr
+        have hh : Real.log 4 ≤ 3 := by
+          have hl4 := Real.log_le_sub_one_of_pos (by norm_num : (0:ℝ)<4)
+          linarith
+        nlinarith
+  · intro k j hj
+    have hh := entryPhysicalLevel_cleanup_gap hκ W hn1 hm1 (hJ n hn1) hj (2048*Real.pi) z
+    linarith
+
+end SLEExactGauge.Target
+
+end
+
+end OAI

lean/OAI/Probability/SLE/Gauge/PrescribedUpperAngle.lean

@@ -1,76 +1,76 @@
-import OAI.Probability.SLE.Gauge.PrescribedCanonicalMixing
-import OAI.Probability.SLE.Gauge.CanonicalPrescribedUpper
-
-namespace OAI
-
-/-! A uniform canonical angle transition bound implies the prescribed-gauge
-upper cover estimate. -/
-noncomputable section
-open Set Filter _root_.MeasureTheory _root_.OAI.MeasureTheory ProbabilityTheory Metric
-open scoped Topology NNReal ENNReal
-
-namespace SLEExactGauge.Multipoint
-local instance upperAngleMeasurable : MeasurableSpace C(ℝ≥0,ℝ) := borel _
-local instance upperAngleBorel : BorelSpace C(ℝ≥0,ℝ) := ⟨rfl⟩
-
-theorem CanonicalMass.prescribed_expectation_of_canonical_angle_bound
-    {Ω : 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 ω))
-    (h0 : ∀ ω, B 0 ω=0) (hκ : 0 < κ) (hκ8 : κ < 8)
-    (F : Ω → ℝ≥0 → ℂ → ℂ)
-    (hw : ∀ ω, IsCapacityTwoWitness (fun t => Real.sqrt κ*B t ω) (γ ω) (G ω) (F ω))
-    (R : RawCanonicalMass)
-    (he : ∀ᵐ ω ∂P, (∀ t, R.process t (sourceDriverPath B hc ω)=C.process t ω) ∧
-      R.terminal (sourceDriverPath B hc ω)=C.rational.terminal ω)
-    (D : Set C(ℝ≥0,ℝ)) (hD : MeasurableSet D)
-    (hDf : ∀ᵐ p ∂P.map (sourceDriverPath B hc), p∈D)
-    (hDp : ∀ p∈D, PositiveMassPaths (fun t => R.process t p) (R.terminal p))
-    (hgrowth : PublishedDiskUnivalentGrowth)
-    (hpublished : PublishedTraceGeneration (P.map (sourceDriverPath B hc)) κ (fun t p => p t))
-    (W : Target.WienerLaw) (hW : Target.IsWiener W)
-    (hγ : ∀ t, Measurable (fun ω => γ ω t))
-    (δ : ℝ) (hδ : 0<δ)
-    (hangle : ∀ (v : ℝ), δ≤v → ∀ (f : ℝ → ℝ≥0∞), Measurable f →
-      ∀ θ∈Ioo (0:ℝ) Real.pi, (∫⁻ φ, f φ ∂Target.angleLaw κ)/2 ≤
-        canonicalAngleAverage (P.map (sourceDriverPath B hc)) κ v f θ)
-    (L : ℝ) (hL : 0≤L) (K : Set ℂ) (hK : IsClosed K)
-    (hKL : K⊆closedBall 0 L) (hH : ∀ z∈K, 0≤z.im) :
-    (∫⁻ ω, Target.hausdorff (Target.gauge κ W) (range (γ ω)∩K) ∂P)<∞ := by
-  classical
-  have hm1 := C.moment_positive hB hc h0 hκ hκ8 F hw hpublished hgrowth W hW 1
-  have hJn (n : ℕ) := C.moment_jensen hB hc h0 hκ hκ8 F hw hgrowth W hW n
-  have hdata (n : ℕ) : ∃ (J : ℕ) (e : Fin J → ℤ×ℕ),
-      (∀ i, (e i).2<Target.multiplicity κ W n (e i).1) ∧
-      (3≤n → Function.Injective e ∧
-        (∀ kj, kj∈range e ↔ kj.2<Target.multiplicity κ W n kj.1) ∧
-        StrictMono (fun i => Target.entryPosition κ W (n,some (e i)))) := by
-    by_cases hn : 3≤n
-    · obtain ⟨J,e,hi,he,ho⟩ := Target.ordered_repeated_batch κ W (by omega) hm1 (hJn n)
-      exact ⟨J,e,fun i => (he _).mp ⟨i,rfl⟩,fun _ => ⟨hi,he,ho⟩⟩
-    · refine ⟨0,Fin.elim0,?_,?_⟩
-      · exact fun i => Fin.elim0 i
-      · exact fun h => False.elim (hn h)
-  choose J e hentries horder using hdata
-  apply C.prescribed_expectation_of_finite_failures hB hc h0 hκ hκ8 F hw hγ hpublished
-    hgrowth W hW J e hentries (4096*Real.pi) ((128*Real.pi)^dimension κ) L
-    (by have hp := Real.pi_gt_three; linarith) (Real.rpow_pos_of_pos (by positivity) _) hL K hK hKL hH
-  filter_upwards [Target.eventually_prescribedTestPastLevel_gap hκ W
-      (by positivity : 0<2048*Real.pi) δ,
-    Target.eventually_entryPhysicalLevel_large hκ W (by positivity : 0<2048*Real.pi) 0,
-    eventually_ge_atTop 3] with n hgap hlevel hn
-  intro ij _hij hy
-  let z := prescribedGridCenter (Target.entryRadius κ W (n,none)) ij
-  have hz : z∈upperHalfPlane := lt_of_lt_of_le (Real.exp_pos _) hy
-  obtain ⟨hi,he',ho⟩ := horder n hn
-  exact C.prescribed_batch_failure_of_canonical_angle_bound hB hc h0 hκ hκ8 F hw R he
-    D hD hDf hDp hgrowth hpublished W hW hn (e n) hi he' ho z hz
-    (fun o => (hlevel o z hy).le) δ hδ (hgap (J n) (e n) ho z hy) hangle
-
-end SLEExactGauge.Multipoint
-
-end
-
-end OAI
+import OAI.Probability.SLE.Gauge.PrescribedCanonicalMixing
+import OAI.Probability.SLE.Gauge.CanonicalPrescribedUpper
+
+namespace OAI
+
+/-! A uniform canonical angle transition bound implies the prescribed-gauge
+upper cover estimate. -/
+noncomputable section
+open Set Filter _root_.MeasureTheory _root_.OAI.MeasureTheory ProbabilityTheory Metric
+open scoped Topology NNReal ENNReal
+
+namespace SLEExactGauge.Multipoint
+local instance upperAngleMeasurable : MeasurableSpace C(ℝ≥0,ℝ) := borel _
+local instance upperAngleBorel : BorelSpace C(ℝ≥0,ℝ) := ⟨rfl⟩
+
+theorem CanonicalMass.prescribed_expectation_of_canonical_angle_bound
+    {Ω : 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 ω))
+    (h0 : ∀ ω, B 0 ω=0) (hκ : 0 < κ) (hκ8 : κ < 8)
+    (F : Ω → ℝ≥0 → ℂ → ℂ)
+    (hw : ∀ ω, IsCapacityTwoWitness (fun t => Real.sqrt κ*B t ω) (γ ω) (G ω) (F ω))
+    (R : RawCanonicalMass)
+    (he : ∀ᵐ ω ∂P, (∀ t, R.process t (sourceDriverPath B hc ω)=C.process t ω) ∧
+      R.terminal (sourceDriverPath B hc ω)=C.rational.terminal ω)
+    (D : Set C(ℝ≥0,ℝ)) (hD : MeasurableSet D)
+    (hDf : ∀ᵐ p ∂P.map (sourceDriverPath B hc), p∈D)
+    (hDp : ∀ p∈D, PositiveMassPaths (fun t => R.process t p) (R.terminal p))
+    (hgrowth : PublishedDiskUnivalentGrowth)
+    (hpublished : PublishedTraceGeneration (P.map (sourceDriverPath B hc)) κ (fun t p => p t))
+    (W : Target.WienerLaw) (hW : Target.IsWiener W)
+    (hγ : ∀ t, Measurable (fun ω => γ ω t))
+    (δ : ℝ) (hδ : 0<δ)
+    (hangle : ∀ (v : ℝ), δ≤v → ∀ (f : ℝ → ℝ≥0∞), Measurable f →
+      ∀ θ∈Ioo (0:ℝ) Real.pi, (∫⁻ φ, f φ ∂Target.angleLaw κ)/2 ≤
+        canonicalAngleAverage (P.map (sourceDriverPath B hc)) κ v f θ)
+    (L : ℝ) (hL : 0≤L) (K : Set ℂ) (hK : IsClosed K)
+    (hKL : K⊆closedBall 0 L) (hH : ∀ z∈K, 0≤z.im) :
+    (∫⁻ ω, Target.hausdorff (Target.gauge κ W) (range (γ ω)∩K) ∂P)<∞ := by
+  classical
+  have hm1 := C.moment_positive hB hc h0 hκ hκ8 F hw hpublished hgrowth W hW 1
+  have hJn (n : ℕ) := C.moment_jensen hB hc h0 hκ hκ8 F hw hgrowth W hW n
+  have hdata (n : ℕ) : ∃ (J : ℕ) (e : Fin J → ℤ×ℕ),
+      (∀ i, (e i).2<Target.multiplicity κ W n (e i).1) ∧
+      (3≤n → Function.Injective e ∧
+        (∀ kj, kj∈range e ↔ kj.2<Target.multiplicity κ W n kj.1) ∧
+        StrictMono (fun i => Target.entryPosition κ W (n,some (e i)))) := by
+    by_cases hn : 3≤n
+    · obtain ⟨J,e,hi,he,ho⟩ := Target.ordered_repeated_batch κ W (by omega) hm1 (hJn n)
+      exact ⟨J,e,fun i => (he _).mp ⟨i,rfl⟩,fun _ => ⟨hi,he,ho⟩⟩
+    · refine ⟨0,Fin.elim0,?_,?_⟩
+      · exact fun i => Fin.elim0 i
+      · exact fun h => False.elim (hn h)
+  choose J e hentries horder using hdata
+  apply C.prescribed_expectation_of_finite_failures hB hc h0 hκ hκ8 F hw hγ hpublished
+    hgrowth W hW J e hentries (4096*Real.pi) ((128*Real.pi)^dimension κ) L
+    (by have hp := Real.pi_gt_three; linarith) (Real.rpow_pos_of_pos (by positivity) _) hL K hK hKL hH
+  filter_upwards [Target.eventually_prescribedTestPastLevel_gap hκ W
+      (by positivity : 0<2048*Real.pi) δ,
+    Target.eventually_entryPhysicalLevel_large hκ W (by positivity : 0<2048*Real.pi) 0,
+    eventually_ge_atTop 3] with n hgap hlevel hn
+  intro ij _hij hy
+  let z := prescribedGridCenter (Target.entryRadius κ W (n,none)) ij
+  have hz : z∈upperHalfPlane := lt_of_lt_of_le (Real.exp_pos _) hy
+  obtain ⟨hi,he',ho⟩ := horder n hn
+  exact C.prescribed_batch_failure_of_canonical_angle_bound hB hc h0 hκ hκ8 F hw R he
+    D hD hDf hDp hgrowth hpublished W hW hn (e n) hi he' ho z hz
+    (fun o => (hlevel o z hy).le) δ hδ (hgap (J n) (e n) ho z hy) hangle
+
+end SLEExactGauge.Multipoint
+
+end
+
+end OAI

lean/OAI/Probability/SLE/Gauge/PrescribedVisitBound.lean

@@ -1,57 +1,57 @@
-import OAI.Probability.SLE.Gauge.PrescribedCandidateCover
-import OAI.Probability.SLE.SausagePointBound
-
-namespace OAI
-
-/-! The ordinary one-point estimate bounds every actual missed cell,
-  including the bottom half-row of the shifted grid. -/
-noncomputable section
-open Set Filter MeasureTheory ProbabilityTheory Metric
-open scoped Topology NNReal ENNReal
-
-namespace SLEExactGauge
-
-theorem prescribed_missed_cell_visit_bound
-    {Ω : Type*} [MeasurableSpace Ω] {P : Measure Ω} [IsProbabilityMeasure P]
-    {B : ℝ≥0 → Ω → ℝ} (hB : IsBrownianReal B P)
-    {κ : ℝ} (hκ : 0<κ) (hκ8 : κ<8)
-    (γ : Ω → ℝ≥0 → ℂ) (G F : Ω → ℝ≥0 → ℂ → ℂ)
-    (hw : ∀ᵐ ω ∂P, IsCapacityTwoWitness
-      (fun t => Real.sqrt κ*B t ω) (γ ω) (G ω) (F ω))
-    (ν : Ω → Measure ℂ) (W : Target.WienerLaw) (n : ℕ)
-    {J : ℕ} (e : Fin J → ℤ×ℕ) (C c R : ℝ) (K : Set ℂ)
-    (ij : ℤ×ℤ) (hij : ij∈prescribedGridIndex R (Target.entryRadius κ W (n,none)) K) :
-    P {ω | ij∈prescribedMissedIndices κ W n e C c R K (range (γ ω)∩K) (ν ω)} ≤
-      ENNReal.ofReal ((sausagePointConstant κ*(4:ℝ)^codimension κ)*
-        (Target.entryRadius κ W (n,none))^codimension κ*
-        (prescribedGridCenter (Target.entryRadius κ W (n,none)) ij).im^(-codimension κ)) := by
-  classical
-  let r := Target.entryRadius κ W (n,none)
-  let z := prescribedGridCenter r ij
-  have hr : 0<r := Real.exp_pos _
-  have hz : 0<z.im := (prescribedGrid_center_height hr hij).2
-  have hsub : {ω | ij∈prescribedMissedIndices κ W n e C c R K (range (γ ω)∩K) (ν ω)} ⊆
-      {ω | ∃ t : ℝ≥0, dist (γ ω t) z < 4*r} := by
-    intro ω hω
-    obtain ⟨x,⟨⟨t,rfl⟩,_⟩,ht⟩ := (Finset.mem_filter.mp hω).2.1
-    refine ⟨t,?_⟩
-    change dist (γ ω t) z ≤ 3*r at ht
-    linarith
-  have hb := normalized_visit_bound hB κ hκ hκ8 γ G F hw z hz.ne' (4*r) (by positivity)
-  have hmul := mul_le_mul_of_nonneg_left hb
-    (Real.rpow_nonneg (by positivity : 0 ≤ 4*r) (codimension κ))
-  rw [← mul_assoc,← Real.rpow_add (by positivity : 0<4*r),add_neg_cancel,
-    Real.rpow_zero,one_mul,abs_of_pos hz,
-    Real.mul_rpow (by norm_num : (0:ℝ) ≤ 4) hr.le] at hmul
-  have hbound : (P {ω | ∃ t : ℝ≥0, dist (γ ω t) z < 4*r}).toReal ≤
-      (sausagePointConstant κ*(4:ℝ)^codimension κ)*r^codimension κ*z.im^(-codimension κ) := by
-    convert hmul using 1
-    ring
-  exact (measure_mono hsub).trans ((ENNReal.le_ofReal_iff_toReal_le (measure_ne_top _ _)
-    (by have hC := sausagePointConstant_pos κ hκ hκ8; positivity)).mpr hbound)
-
-end SLEExactGauge
-
-end
-
-end OAI
+import OAI.Probability.SLE.Gauge.PrescribedCandidateCover
+import OAI.Probability.SLE.SausagePointBound
+
+namespace OAI
+
+/-! The ordinary one-point estimate bounds every actual missed cell,
+  including the bottom half-row of the shifted grid. -/
+noncomputable section
+open Set Filter MeasureTheory ProbabilityTheory Metric
+open scoped Topology NNReal ENNReal
+
+namespace SLEExactGauge
+
+theorem prescribed_missed_cell_visit_bound
+    {Ω : Type*} [MeasurableSpace Ω] {P : Measure Ω} [IsProbabilityMeasure P]
+    {B : ℝ≥0 → Ω → ℝ} (hB : IsBrownianReal B P)
+    {κ : ℝ} (hκ : 0<κ) (hκ8 : κ<8)
+    (γ : Ω → ℝ≥0 → ℂ) (G F : Ω → ℝ≥0 → ℂ → ℂ)
+    (hw : ∀ᵐ ω ∂P, IsCapacityTwoWitness
+      (fun t => Real.sqrt κ*B t ω) (γ ω) (G ω) (F ω))
+    (ν : Ω → Measure ℂ) (W : Target.WienerLaw) (n : ℕ)
+    {J : ℕ} (e : Fin J → ℤ×ℕ) (C c R : ℝ) (K : Set ℂ)
+    (ij : ℤ×ℤ) (hij : ij∈prescribedGridIndex R (Target.entryRadius κ W (n,none)) K) :
+    P {ω | ij∈prescribedMissedIndices κ W n e C c R K (range (γ ω)∩K) (ν ω)} ≤
+      ENNReal.ofReal ((sausagePointConstant κ*(4:ℝ)^codimension κ)*
+        (Target.entryRadius κ W (n,none))^codimension κ*
+        (prescribedGridCenter (Target.entryRadius κ W (n,none)) ij).im^(-codimension κ)) := by
+  classical
+  let r := Target.entryRadius κ W (n,none)
+  let z := prescribedGridCenter r ij
+  have hr : 0<r := Real.exp_pos _
+  have hz : 0<z.im := (prescribedGrid_center_height hr hij).2
+  have hsub : {ω | ij∈prescribedMissedIndices κ W n e C c R K (range (γ ω)∩K) (ν ω)} ⊆
+      {ω | ∃ t : ℝ≥0, dist (γ ω t) z < 4*r} := by
+    intro ω hω
+    obtain ⟨x,⟨⟨t,rfl⟩,_⟩,ht⟩ := (Finset.mem_filter.mp hω).2.1
+    refine ⟨t,?_⟩
+    change dist (γ ω t) z ≤ 3*r at ht
+    linarith
+  have hb := normalized_visit_bound hB κ hκ hκ8 γ G F hw z hz.ne' (4*r) (by positivity)
+  have hmul := mul_le_mul_of_nonneg_left hb
+    (Real.rpow_nonneg (by positivity : 0 ≤ 4*r) (codimension κ))
+  rw [← mul_assoc,← Real.rpow_add (by positivity : 0<4*r),add_neg_cancel,
+    Real.rpow_zero,one_mul,abs_of_pos hz,
+    Real.mul_rpow (by norm_num : (0:ℝ) ≤ 4) hr.le] at hmul
+  have hbound : (P {ω | ∃ t : ℝ≥0, dist (γ ω t) z < 4*r}).toReal ≤
+      (sausagePointConstant κ*(4:ℝ)^codimension κ)*r^codimension κ*z.im^(-codimension κ) := by
+    convert hmul using 1
+    ring
+  exact (measure_mono hsub).trans ((ENNReal.le_ofReal_iff_toReal_le (measure_ne_top _ _)
+    (by have hC := sausagePointConstant_pos κ hκ hκ8; positivity)).mpr hbound)
+
+end SLEExactGauge
+
+end
+
+end OAI

lean/OAI/Probability/SLE/Gauge/ProperRibbonCoordinates.lean

@@ -1,118 +1,118 @@
-import OAI.Probability.SLE.Gauge.RibbonHistoryAdvance
-import Mathlib.Topology.Maps.Proper.CompactlyGenerated
-
-namespace OAI
-
-/-! An escaping terminal straight piece makes the complete normal ribbon
-proper. Its inverse coordinates therefore extend continuously to the
-ambient plane, supplying one actual adapted front process for iteration. -/
-
-noncomputable section
-open Set Filter MeasureTheory Metric
-open scoped Topology NNReal ENNReal
-
-namespace SLEExactGauge.RibbonCoordinates
-
-lemma closedRibbon_isClosed : IsClosed closedRibbon :=
-  (isClosed_le continuous_const Complex.continuous_re).inter
-    (isClosed_le Complex.continuous_im.abs continuous_const)
-
-lemma ribbon_coordinate_norm_bound
-    (P : ℂ → ℂ) (σ : ℝ → ℂ) (T : ℝ) (_hT : 0 ≤ T) (a : ℂ)
-    (htail : ∀ t : ℝ, T ≤ t → σ t = a + ((t - T : ℝ) : ℂ) * Complex.I)
-    (hwidth : ∀ z ∈ closedRibbon, ‖P z - σ z.re‖ ≤ 1)
-    (z : ℂ) (hz : z ∈ closedRibbon) :
-    ‖z‖ ≤ T + |a.im| + ‖P z‖ + 2 := by
-  have hre : z.re ≤ T + |a.im| + ‖P z‖ + 1 := by
-    by_cases hzt : z.re ≤ T
-    · linarith [abs_nonneg a.im, norm_nonneg (P z)]
-    · have him : z.re - T + a.im = (σ z.re).im := by
-        rw [htail z.re (le_of_not_ge hzt)]
-        simp only [Complex.add_im, Complex.mul_im, Complex.ofReal_re,
-          Complex.I_im, mul_one, Complex.ofReal_im, Complex.I_re, mul_zero, add_zero]
-        ring
-      have hσ : ‖σ z.re‖ ≤ ‖P z‖ + 1 := by
-        calc
-          _ ≤ ‖P z‖ + ‖σ z.re - P z‖ := norm_le_insert' _ _
-          _ ≤ _ := add_le_add le_rfl (by simpa only [norm_sub_rev] using hwidth z hz)
-      have hh := Complex.im_le_norm (σ z.re)
-      rw [← him] at hh
-      linarith [neg_abs_le a.im]
-  have hn := Complex.norm_le_abs_re_add_abs_im z
-  rw [abs_of_nonneg hz.1] at hn
-  linarith [hz.2, abs_nonneg a.im, norm_nonneg (P z)]
-
-theorem ribbon_closedEmbedding_of_linear_tail
-    (P : ℂ → ℂ) (hP : ContinuousOn P closedRibbon) (hi : InjOn P closedRibbon)
-    (σ : ℝ → ℂ) (T : ℝ) (hT : 0 ≤ T) (a : ℂ)
-    (htail : ∀ t : ℝ, T ≤ t → σ t = a + ((t - T : ℝ) : ℂ) * Complex.I)
-    (hwidth : ∀ z ∈ closedRibbon, ‖P z - σ z.re‖ ≤ 1) :
-    Topology.IsClosedEmbedding (fun z : closedRibbon => P z) := by
-  have hc : Continuous (fun z : closedRibbon => P z) := hP.domRestrict
-  have hinj : Function.Injective (fun z : closedRibbon => P z) := by
-    intro z w he
-    exact Subtype.ext (hi z.2 w.2 he)
-  have hproper : IsProperMap (fun z : closedRibbon => P z) := by
-    apply isProperMap_iff_isCompact_preimage.mpr
-    refine ⟨hc, fun K hK => ?_⟩
-    obtain ⟨R, hR⟩ := hK.isBounded.exists_norm_le
-    have hclosed : IsClosed (closedRibbon ∩ P ⁻¹' K) :=
-      hP.preimage_isClosed_of_isClosed closedRibbon_isClosed hK.isClosed
-    have hbounded : Bornology.IsBounded (closedRibbon ∩ P ⁻¹' K) := by
-      apply isBounded_iff_forall_norm_le.mpr
-      refine ⟨T + |a.im| + R + 2, fun z hz => ?_⟩
-      exact (ribbon_coordinate_norm_bound P σ T hT a htail hwidth z hz.1).trans
-        (by linarith [hR (P z) hz.2])
-    apply Subtype.isCompact_iff.mpr
-    have he : (Subtype.val '' ((fun z : closedRibbon => P z) ⁻¹' K)) =
-        closedRibbon ∩ P ⁻¹' K := by
-      ext z
-      simp only [mem_image, mem_preimage, mem_inter_iff]
-      constructor
-      · rintro ⟨w, hw, rfl⟩
-        exact ⟨w.2, hw⟩
-      · rintro ⟨hz, hPz⟩
-        exact ⟨⟨z, hz⟩, hPz, rfl⟩
-    rw [he]
-    exact (isCompact_iff_isClosed_bounded).mpr ⟨hclosed, hbounded⟩
-  exact .of_continuous_injective_isClosedMap hc hinj hproper.isClosedMap
-
-lemma coordinateInverse_continuousOn_of_embedding
-    (P : ℂ → ℂ) (he : Topology.IsEmbedding (fun z : closedRibbon => P z)) :
-    ContinuousOn (coordinateInverse P closedRibbon) (P '' closedRibbon) := by
-  let q : (P '' closedRibbon) → closedRibbon := fun z =>
-    ⟨coordinateInverse P closedRibbon z, coordinateInverse_mem z.2⟩
-  have hq : Continuous q := by
-    apply he.continuous_iff.mpr
-    have hf : (fun z : closedRibbon => P z) ∘ q = Subtype.val := by
-      funext z
-      exact coordinateInverse_right z.2
-    rw [hf]
-    exact continuous_subtype_val
-  exact continuousOn_iff_continuous_domRestrict.mpr (continuous_subtype_val.comp hq)
-
-theorem exists_global_ribbon_progress
-    (P : ℂ → ℂ) (he : Topology.IsClosedEmbedding (fun z : closedRibbon => P z)) :
-    ∃ g : C(ℂ, ℝ), ∀ z ∈ closedRibbon, g (P z) = z.re := by
-  have hclosed : IsClosed (P '' closedRibbon) := by
-    have hr : range (fun z : closedRibbon => P z) = P '' closedRibbon := by
-      ext z
-      simp
-    exact hr ▸ he.isClosed_range
-  have hp : ContinuousOn (longitudinalCoordinate P closedRibbon 0) (P '' closedRibbon) := by
-    exact (Complex.continuous_re.comp_continuousOn
-      (coordinateInverse_continuousOn_of_embedding P he.isEmbedding)).sub continuousOn_const
-  obtain ⟨g, hg⟩ := FrontSuccessMeasurability.exists_continuous_progress_extension
-    (longitudinalCoordinate P closedRibbon 0) (P '' closedRibbon) hclosed hp
-  have hi : InjOn P closedRibbon := by
-    intro z hz w hw heq
-    exact congrArg Subtype.val (he.injective (show P (⟨z, hz⟩ : closedRibbon) =
-      P (⟨w, hw⟩ : closedRibbon) from heq))
-  refine ⟨g, fun z hz => ?_⟩
-  rw [← hg (mem_image_of_mem P hz), longitudinalCoordinate, coordinateInverse_left hi hz, sub_zero]
-
-end SLEExactGauge.RibbonCoordinates
-
-end
-
-end OAI
+import OAI.Probability.SLE.Gauge.RibbonHistoryAdvance
+import Mathlib.Topology.Maps.Proper.CompactlyGenerated
+
+namespace OAI
+
+/-! An escaping terminal straight piece makes the complete normal ribbon
+proper. Its inverse coordinates therefore extend continuously to the
+ambient plane, supplying one actual adapted front process for iteration. -/
+
+noncomputable section
+open Set Filter MeasureTheory Metric
+open scoped Topology NNReal ENNReal
+
+namespace SLEExactGauge.RibbonCoordinates
+
+lemma closedRibbon_isClosed : IsClosed closedRibbon :=
+  (isClosed_le continuous_const Complex.continuous_re).inter
+    (isClosed_le Complex.continuous_im.abs continuous_const)
+
+lemma ribbon_coordinate_norm_bound
+    (P : ℂ → ℂ) (σ : ℝ → ℂ) (T : ℝ) (_hT : 0 ≤ T) (a : ℂ)
+    (htail : ∀ t : ℝ, T ≤ t → σ t = a + ((t - T : ℝ) : ℂ) * Complex.I)
+    (hwidth : ∀ z ∈ closedRibbon, ‖P z - σ z.re‖ ≤ 1)
+    (z : ℂ) (hz : z ∈ closedRibbon) :
+    ‖z‖ ≤ T + |a.im| + ‖P z‖ + 2 := by
+  have hre : z.re ≤ T + |a.im| + ‖P z‖ + 1 := by
+    by_cases hzt : z.re ≤ T
+    · linarith [abs_nonneg a.im, norm_nonneg (P z)]
+    · have him : z.re - T + a.im = (σ z.re).im := by
+        rw [htail z.re (le_of_not_ge hzt)]
+        simp only [Complex.add_im, Complex.mul_im, Complex.ofReal_re,
+          Complex.I_im, mul_one, Complex.ofReal_im, Complex.I_re, mul_zero, add_zero]
+        ring
+      have hσ : ‖σ z.re‖ ≤ ‖P z‖ + 1 := by
+        calc
+          _ ≤ ‖P z‖ + ‖σ z.re - P z‖ := norm_le_insert' _ _
+          _ ≤ _ := add_le_add le_rfl (by simpa only [norm_sub_rev] using hwidth z hz)
+      have hh := Complex.im_le_norm (σ z.re)
+      rw [← him] at hh
+      linarith [neg_abs_le a.im]
+  have hn := Complex.norm_le_abs_re_add_abs_im z
+  rw [abs_of_nonneg hz.1] at hn
+  linarith [hz.2, abs_nonneg a.im, norm_nonneg (P z)]
+
+theorem ribbon_closedEmbedding_of_linear_tail
+    (P : ℂ → ℂ) (hP : ContinuousOn P closedRibbon) (hi : InjOn P closedRibbon)
+    (σ : ℝ → ℂ) (T : ℝ) (hT : 0 ≤ T) (a : ℂ)
+    (htail : ∀ t : ℝ, T ≤ t → σ t = a + ((t - T : ℝ) : ℂ) * Complex.I)
+    (hwidth : ∀ z ∈ closedRibbon, ‖P z - σ z.re‖ ≤ 1) :
+    Topology.IsClosedEmbedding (fun z : closedRibbon => P z) := by
+  have hc : Continuous (fun z : closedRibbon => P z) := hP.domRestrict
+  have hinj : Function.Injective (fun z : closedRibbon => P z) := by
+    intro z w he
+    exact Subtype.ext (hi z.2 w.2 he)
+  have hproper : IsProperMap (fun z : closedRibbon => P z) := by
+    apply isProperMap_iff_isCompact_preimage.mpr
+    refine ⟨hc, fun K hK => ?_⟩
+    obtain ⟨R, hR⟩ := hK.isBounded.exists_norm_le
+    have hclosed : IsClosed (closedRibbon ∩ P ⁻¹' K) :=
+      hP.preimage_isClosed_of_isClosed closedRibbon_isClosed hK.isClosed
+    have hbounded : Bornology.IsBounded (closedRibbon ∩ P ⁻¹' K) := by
+      apply isBounded_iff_forall_norm_le.mpr
+      refine ⟨T + |a.im| + R + 2, fun z hz => ?_⟩
+      exact (ribbon_coordinate_norm_bound P σ T hT a htail hwidth z hz.1).trans
+        (by linarith [hR (P z) hz.2])
+    apply Subtype.isCompact_iff.mpr
+    have he : (Subtype.val '' ((fun z : closedRibbon => P z) ⁻¹' K)) =
+        closedRibbon ∩ P ⁻¹' K := by
+      ext z
+      simp only [mem_image, mem_preimage, mem_inter_iff]
+      constructor
+      · rintro ⟨w, hw, rfl⟩
+        exact ⟨w.2, hw⟩
+      · rintro ⟨hz, hPz⟩
+        exact ⟨⟨z, hz⟩, hPz, rfl⟩
+    rw [he]
+    exact (isCompact_iff_isClosed_bounded).mpr ⟨hclosed, hbounded⟩
+  exact .of_continuous_injective_isClosedMap hc hinj hproper.isClosedMap
+
+lemma coordinateInverse_continuousOn_of_embedding
+    (P : ℂ → ℂ) (he : Topology.IsEmbedding (fun z : closedRibbon => P z)) :
+    ContinuousOn (coordinateInverse P closedRibbon) (P '' closedRibbon) := by
+  let q : (P '' closedRibbon) → closedRibbon := fun z =>
+    ⟨coordinateInverse P closedRibbon z, coordinateInverse_mem z.2⟩
+  have hq : Continuous q := by
+    apply he.continuous_iff.mpr
+    have hf : (fun z : closedRibbon => P z) ∘ q = Subtype.val := by
+      funext z
+      exact coordinateInverse_right z.2
+    rw [hf]
+    exact continuous_subtype_val
+  exact continuousOn_iff_continuous_domRestrict.mpr (continuous_subtype_val.comp hq)
+
+theorem exists_global_ribbon_progress
+    (P : ℂ → ℂ) (he : Topology.IsClosedEmbedding (fun z : closedRibbon => P z)) :
+    ∃ g : C(ℂ, ℝ), ∀ z ∈ closedRibbon, g (P z) = z.re := by
+  have hclosed : IsClosed (P '' closedRibbon) := by
+    have hr : range (fun z : closedRibbon => P z) = P '' closedRibbon := by
+      ext z
+      simp
+    exact hr ▸ he.isClosed_range
+  have hp : ContinuousOn (longitudinalCoordinate P closedRibbon 0) (P '' closedRibbon) := by
+    exact (Complex.continuous_re.comp_continuousOn
+      (coordinateInverse_continuousOn_of_embedding P he.isEmbedding)).sub continuousOn_const
+  obtain ⟨g, hg⟩ := FrontSuccessMeasurability.exists_continuous_progress_extension
+    (longitudinalCoordinate P closedRibbon 0) (P '' closedRibbon) hclosed hp
+  have hi : InjOn P closedRibbon := by
+    intro z hz w hw heq
+    exact congrArg Subtype.val (he.injective (show P (⟨z, hz⟩ : closedRibbon) =
+      P (⟨w, hw⟩ : closedRibbon) from heq))
+  refine ⟨g, fun z hz => ?_⟩
+  rw [← hg (mem_image_of_mem P hz), longitudinalCoordinate, coordinateInverse_left hi hz, sub_zero]
+
+end SLEExactGauge.RibbonCoordinates
+
+end
+
+end OAI

lean/OAI/Probability/SLE/Gauge/PublishedRibbonIteration.lean

@@ -1,82 +1,82 @@
-import OAI.Probability.SLE.Gauge.ActualRibbonIteration
-
-namespace OAI
-
-/-! Uniform iteration of actual front-and-mass passages from explicit
-analytic inputs, for any chart and number of steps satisfying the
-deterministic ribbon bounds. -/
-
-noncomputable section
-open Set Filter MeasureTheory ProbabilityTheory
-open scoped Topology NNReal ENNReal
-
-namespace SLEExactGauge
-open RibbonCoordinates Target
-
-local instance publishedIterationPathMeasurable : MeasurableSpace C(ℝ≥0, ℂ) := borel _
-local instance publishedIterationPathBorel : BorelSpace C(ℝ≥0, ℂ) := ⟨rfl⟩
-
-theorem uniform_actual_ribbon_iteration
-    {Ω : Type} [mΩ : MeasurableSpace Ω] (μ : Measure Ω) [IsProbabilityMeasure μ]
-    (κ : ℝ) (hκ : 0 < κ) (hκ8 : κ < 8)
-    (B : ℝ≥0 → Ω → ℝ) (hB : IsBrownianReal B μ)
-    (hm : ∀ t, Measurable (B t)) (hc : ∀ ω, Continuous (fun t => B t ω))
-    (γ : Ω → ℝ≥0 → ℂ) (G F : Ω → ℝ≥0 → ℂ → ℂ)
-    (hw : ∀ ω, IsCapacityTwoWitness (fun t => Real.sqrt κ * B t ω)
-      (γ ω) (G ω) (F ω))
-    (hcompact : PublishedHalfPlaneUnivalentCompactness)
-    (hboundary : PublishedFiniteLoewnerBoundaryExtension)
-    (hsupport : PublishedGeometricTubeSupport μ γ)
-    (hplanar : PublishedPlanarDiskOpenness)
-    (hstraight : PublishedHalfPlaneCrosscutStraightening)
-    (hexit : PublishedHalfPlaneConformalExitLaw)
-    (hwiener : PublishedPlanarWienerUnitSupport)
-    (W : WienerLaw) (hW : IsWiener W)
-    (C L : ℝ≥0) (hC : 0 < C) (hL : 0 < L)
-    (ε : ℝ) (hε : 0 < ε) (hεsmall : ε ≤ 1 / 8) :
-    ∃ q c v₀ : ℝ, 0 < q ∧ q ≤ 1 ∧ 0 < c ∧ 0 < v₀ ∧
-      ∀ (v : ℝ), 0 < v → v < v₀ → ∀ (P : ℂ → ℂ),
-      Topology.IsClosedEmbedding (fun z : closedRibbon => P z) →
-      ContinuousOn P closedRibbon → InjOn P closedRibbon → P 0 = 0 →
-      (∀ z ∈ closedRibbon, 0 < z.re → P z ∈ upperHalfPlane) →
-      Tendsto (fun t : ℝ => ‖P (t : ℂ)‖) atTop atTop →
-      (∀ k : ℝ, LipschitzOnWith C P (ribbonStepPatch k)) →
-      (∀ k : ℝ, ∀ z ∈ ribbonStepPatch k, ∀ w ∈ ribbonStepPatch k,
-        dist z w ≤ L * dist (P z) (P w)) →
-      ∀ (g : C(ℂ, ℝ)), (∀ z ∈ closedRibbon, g (P z) = z.re) → ∀ N : ℕ,
-      (ENNReal.ofReal q) ^ N * μ (GoodRibbonPrefix γ (ribbonIntegerFront g γ 0) P ε) ≤
-        μ (GoodRibbonPrefix γ (ribbonIntegerFront g γ 0) P ε ∩
-          ⋂ n ∈ Finset.range N, actualRibbonSuccess γ g P ε κ v c n) := by
-  obtain ⟨q, c, v₀, hq, hcm, hv₀, hstep⟩ :=
-    uniform_conditional_actual_ribbon_step_extended μ κ hκ hκ8 B hB hm hc γ G F hw
-      hcompact hboundary hsupport hplanar hstraight hexit hwiener W hW
-      C L hC hL ε hε hεsmall
-  refine ⟨min q 1, c, v₀, lt_min hq (by norm_num), min_le_right _ _, hcm, hv₀, ?_⟩
-  intro v hv hvcut P hemb hP hi hP0 hH hescape hu hl g hg N
-  let ℱ := Filtration.natural B (fun t => (hm t).stronglyMeasurable)
-  have ha : Adapted ℱ (fun t ω => γ ω t) := brownian_capacity_trace_adapted B hm hc κ γ G F hw
-  have hγc : ∀ ω, Continuous (γ ω) := fun ω => (hw ω).1
-  have hg0 (ω : Ω) : g (γ ω 0) = 0 := by
-    rw [(hw ω).2.1, ← hP0]
-    exact hg 0 (by constructor <;> norm_num)
-  apply le_trans (mul_le_mul' (pow_le_pow_left'
-    (ENNReal.ofReal_le_ofReal (min_le_left q 1)) N) le_rfl)
-  apply actual_ribbon_successes_lower_bound μ ℱ γ ha hγc g hg0 P hemb ε κ v c
-    (ENNReal.ofReal q) ?_ N
-  intro n A hA hAE
-  let k : ℝ := (n : ℝ) + 1
-  have hk : 1 ≤ k := by dsimp only [k]; linarith [Nat.cast_nonneg (α := ℝ) n]
-  have hτ := ribbonFrontStop_stopping ℱ g γ ha hγc k
-  have hS := ribbonPathStep_measurable P C L ε k κ v c hplanar hεsmall hk hemb hP (hl k)
-  have hb := actual_ribbon_step_on_good_prefix μ ℱ (fun ω t => Real.sqrt κ * B t ω)
-    γ G F (fun ω => continuous_const.mul (hc ω)) hw C L hL ε κ v c hεsmall
-    (ENNReal.ofReal q) P hemb hP hi hH hescape g hg hg0 k hk
-    (fun j _ => hu j) (fun j _ => hl j) hτ
-    (hstep v hv hvcut _ hτ _ hS) A hA hAE
-  simpa only [actualRibbonSuccess, ribbonIntegerFront, k, Nat.cast_add, Nat.cast_one] using hb
-
-end SLEExactGauge
-
-end
-
-end OAI
+import OAI.Probability.SLE.Gauge.ActualRibbonIteration
+
+namespace OAI
+
+/-! Uniform iteration of actual front-and-mass passages from explicit
+analytic inputs, for any chart and number of steps satisfying the
+deterministic ribbon bounds. -/
+
+noncomputable section
+open Set Filter MeasureTheory ProbabilityTheory
+open scoped Topology NNReal ENNReal
+
+namespace SLEExactGauge
+open RibbonCoordinates Target
+
+local instance publishedIterationPathMeasurable : MeasurableSpace C(ℝ≥0, ℂ) := borel _
+local instance publishedIterationPathBorel : BorelSpace C(ℝ≥0, ℂ) := ⟨rfl⟩
+
+theorem uniform_actual_ribbon_iteration
+    {Ω : Type} [mΩ : MeasurableSpace Ω] (μ : Measure Ω) [IsProbabilityMeasure μ]
+    (κ : ℝ) (hκ : 0 < κ) (hκ8 : κ < 8)
+    (B : ℝ≥0 → Ω → ℝ) (hB : IsBrownianReal B μ)
+    (hm : ∀ t, Measurable (B t)) (hc : ∀ ω, Continuous (fun t => B t ω))
+    (γ : Ω → ℝ≥0 → ℂ) (G F : Ω → ℝ≥0 → ℂ → ℂ)
+    (hw : ∀ ω, IsCapacityTwoWitness (fun t => Real.sqrt κ * B t ω)
+      (γ ω) (G ω) (F ω))
+    (hcompact : PublishedHalfPlaneUnivalentCompactness)
+    (hboundary : PublishedFiniteLoewnerBoundaryExtension)
+    (hsupport : PublishedGeometricTubeSupport μ γ)
+    (hplanar : PublishedPlanarDiskOpenness)
+    (hstraight : PublishedHalfPlaneCrosscutStraightening)
+    (hexit : PublishedHalfPlaneConformalExitLaw)
+    (hwiener : PublishedPlanarWienerUnitSupport)
+    (W : WienerLaw) (hW : IsWiener W)
+    (C L : ℝ≥0) (hC : 0 < C) (hL : 0 < L)
+    (ε : ℝ) (hε : 0 < ε) (hεsmall : ε ≤ 1 / 8) :
+    ∃ q c v₀ : ℝ, 0 < q ∧ q ≤ 1 ∧ 0 < c ∧ 0 < v₀ ∧
+      ∀ (v : ℝ), 0 < v → v < v₀ → ∀ (P : ℂ → ℂ),
+      Topology.IsClosedEmbedding (fun z : closedRibbon => P z) →
+      ContinuousOn P closedRibbon → InjOn P closedRibbon → P 0 = 0 →
+      (∀ z ∈ closedRibbon, 0 < z.re → P z ∈ upperHalfPlane) →
+      Tendsto (fun t : ℝ => ‖P (t : ℂ)‖) atTop atTop →
+      (∀ k : ℝ, LipschitzOnWith C P (ribbonStepPatch k)) →
+      (∀ k : ℝ, ∀ z ∈ ribbonStepPatch k, ∀ w ∈ ribbonStepPatch k,
+        dist z w ≤ L * dist (P z) (P w)) →
+      ∀ (g : C(ℂ, ℝ)), (∀ z ∈ closedRibbon, g (P z) = z.re) → ∀ N : ℕ,
+      (ENNReal.ofReal q) ^ N * μ (GoodRibbonPrefix γ (ribbonIntegerFront g γ 0) P ε) ≤
+        μ (GoodRibbonPrefix γ (ribbonIntegerFront g γ 0) P ε ∩
+          ⋂ n ∈ Finset.range N, actualRibbonSuccess γ g P ε κ v c n) := by
+  obtain ⟨q, c, v₀, hq, hcm, hv₀, hstep⟩ :=
+    uniform_conditional_actual_ribbon_step_extended μ κ hκ hκ8 B hB hm hc γ G F hw
+      hcompact hboundary hsupport hplanar hstraight hexit hwiener W hW
+      C L hC hL ε hε hεsmall
+  refine ⟨min q 1, c, v₀, lt_min hq (by norm_num), min_le_right _ _, hcm, hv₀, ?_⟩
+  intro v hv hvcut P hemb hP hi hP0 hH hescape hu hl g hg N
+  let ℱ := Filtration.natural B (fun t => (hm t).stronglyMeasurable)
+  have ha : Adapted ℱ (fun t ω => γ ω t) := brownian_capacity_trace_adapted B hm hc κ γ G F hw
+  have hγc : ∀ ω, Continuous (γ ω) := fun ω => (hw ω).1
+  have hg0 (ω : Ω) : g (γ ω 0) = 0 := by
+    rw [(hw ω).2.1, ← hP0]
+    exact hg 0 (by constructor <;> norm_num)
+  apply le_trans (mul_le_mul' (pow_le_pow_left'
+    (ENNReal.ofReal_le_ofReal (min_le_left q 1)) N) le_rfl)
+  apply actual_ribbon_successes_lower_bound μ ℱ γ ha hγc g hg0 P hemb ε κ v c
+    (ENNReal.ofReal q) ?_ N
+  intro n A hA hAE
+  let k : ℝ := (n : ℝ) + 1
+  have hk : 1 ≤ k := by dsimp only [k]; linarith [Nat.cast_nonneg (α := ℝ) n]
+  have hτ := ribbonFrontStop_stopping ℱ g γ ha hγc k
+  have hS := ribbonPathStep_measurable P C L ε k κ v c hplanar hεsmall hk hemb hP (hl k)
+  have hb := actual_ribbon_step_on_good_prefix μ ℱ (fun ω t => Real.sqrt κ * B t ω)
+    γ G F (fun ω => continuous_const.mul (hc ω)) hw C L hL ε κ v c hεsmall
+    (ENNReal.ofReal q) P hemb hP hi hH hescape g hg hg0 k hk
+    (fun j _ => hu j) (fun j _ => hl j) hτ
+    (hstep v hv hvcut _ hτ _ hS) A hA hAE
+  simpa only [actualRibbonSuccess, ribbonIntegerFront, k, Nat.cast_add, Nat.cast_one] using hb
+
+end SLEExactGauge
+
+end
+
+end OAI

lean/OAI/Probability/SLE/Gauge/RandomBadGrid.lean

@@ -1,121 +1,121 @@
-import OAI.Probability.SLE.Gauge.GoodGridRestriction
-
-namespace OAI
-
-/-! Measurability and almost-sure finiteness of the bad-grid mass sum.
-Only expectations of the actual cell masses occur in the criterion. -/
-
-noncomputable section
-open Set Filter MeasureTheory ProbabilityTheory Metric
-open scoped Topology NNReal ENNReal
-
-namespace SLEExactGauge
-
-lemma measurableSet_random_badGridCells
-    {Ω : Type*} [MeasurableSpace Ω] (μ : Ω → Measure ℂ) (hμ : Measurable μ)
-    (r H : ℝ) : MeasurableSet {p : Ω × ℂ | p.2 ∈ badGridCells (μ p.1) r H} := by
-  classical
-  let Q := fun i : ℤ × ℤ => closedBall (coverGridCenter r i) (2*r)
-  have he : {p : Ω × ℂ | p.2 ∈ badGridCells (μ p.1) r H} =
-      ⋃ i : ℤ × ℤ, {ω | ENNReal.ofReal H < μ ω (Q i)} ×ˢ Q i := by
-    ext p
-    constructor
-    · intro hp
-      obtain ⟨i,hi⟩ := mem_iUnion.mp hp
-      change p.2 ∈ if ENNReal.ofReal H < μ p.1 (Q i) then Q i else ∅ at hi
-      by_cases h : ENNReal.ofReal H < μ p.1 (Q i)
-      · rw [ite_eq_left h] at hi
-        exact mem_iUnion.mpr ⟨i,h,hi⟩
-      · rw [ite_eq_right h] at hi
-        exact hi.elim
-    · intro hp
-      obtain ⟨i,hi⟩ := mem_iUnion.mp hp
-      apply mem_iUnion.mpr
-      refine ⟨i,?_⟩
-      change p.2 ∈ if ENNReal.ofReal H < μ p.1 (Q i) then Q i else ∅
-      rw [ite_eq_left (show ENNReal.ofReal H < μ p.1 (Q i) from hi.1)]
-      exact hi.2
-  rw [he]
-  apply MeasurableSet.iUnion
-  intro i
-  exact (measurableSet_lt measurable_const
-    ((Measure.measurable_coe measurableSet_closedBall).comp hμ)).prod measurableSet_closedBall
-
-lemma random_badGrid_mass_measurable
-    {Ω : Type*} [MeasurableSpace Ω] (μ : Ω → Measure ℂ) (hμ : Measurable μ)
-    (hfin : ∀ ω, IsFiniteMeasure (μ ω)) (r H : ℝ) :
-    Measurable (fun ω => μ ω (badGridCells (μ ω) r H)) := by
-  let K : Kernel Ω ℂ := ⟨μ,hμ⟩
-  exact Kernel.measurable_kernel_prodMk_left_of_finite (κ:=K)
-    (measurableSet_random_badGridCells μ hμ r H) hfin
-
-lemma badGrid_mass_le_sum (μ : Measure ℂ) (r H : ℝ) :
-    μ (badGridCells μ r H) ≤ ∑' i : ℤ × ℤ,
-      if ENNReal.ofReal H < μ (closedBall (coverGridCenter r i) (2*r)) then
-        μ (closedBall (coverGridCenter r i) (2*r)) else 0 := by
-  classical
-  calc
-    _ ≤ ∑' i : ℤ × ℤ, μ (if ENNReal.ofReal H < μ (closedBall (coverGridCenter r i) (2*r)) then
-      closedBall (coverGridCenter r i) (2*r) else ∅) := measure_iUnion_le _
-    _ = _ := by
-      apply tsum_congr
-      intro i
-      split_ifs <;> simp
-
-lemma expected_badGrid_mass_le_sum
-    {Ω : Type*} [MeasurableSpace Ω] (P : Measure Ω)
-    (μ : Ω → Measure ℂ) (hμ : Measurable μ) (r H : ℝ) :
-    (∫⁻ ω, μ ω (badGridCells (μ ω) r H) ∂P) ≤ ∑' i : ℤ × ℤ,
-      ∫⁻ ω, if ENNReal.ofReal H < μ ω (closedBall (coverGridCenter r i) (2*r)) then
-        μ ω (closedBall (coverGridCenter r i) (2*r)) else 0 ∂P := by
-  classical
-  calc
-    _ ≤ ∫⁻ ω, ∑' i : ℤ × ℤ,
-        if ENNReal.ofReal H < μ ω (closedBall (coverGridCenter r i) (2*r)) then
-          μ ω (closedBall (coverGridCenter r i) (2*r)) else 0 ∂P :=
-      lintegral_mono (fun ω => badGrid_mass_le_sum (μ ω) r H)
-    _ = _ := by
-      apply lintegral_tsum
-      intro i
-      exact (Measurable.ite (measurableSet_lt measurable_const
-        ((Measure.measurable_coe measurableSet_closedBall).comp hμ))
-        ((Measure.measurable_coe measurableSet_closedBall).comp hμ) measurable_const).aemeasurable
-
-lemma ae_prescribedBadGrid_sum_finite
-    {Ω : Type*} [MeasurableSpace Ω] (P : Measure Ω)
-    (μ : Ω → Measure ℂ) (hμ : Measurable μ) (hfin : ∀ ω, IsFiniteMeasure (μ ω))
-    (κ : ℝ) (W : Target.WienerLaw) (D : ℝ)
-    (hsum : (∑' e : Target.GaugeIndex κ W,
-      ∫⁻ ω, μ ω (prescribedBadGrid (μ ω) κ W D e) ∂P) ≠ ∞) :
-    ∀ᵐ ω ∂P, (∑' e : Target.GaugeIndex κ W, μ ω (prescribedBadGrid (μ ω) κ W D e)) ≠ ∞ := by
-  have hm (e : Target.GaugeIndex κ W) :
-      Measurable (fun ω => μ ω (prescribedBadGrid (μ ω) κ W D e)) :=
-    random_badGrid_mass_measurable μ hμ hfin _ _
-  have hi : (∫⁻ ω, ∑' e : Target.GaugeIndex κ W,
-      μ ω (prescribedBadGrid (μ ω) κ W D e) ∂P) ≠ ∞ := by
-    rw [lintegral_tsum (fun e => (hm e).aemeasurable)]
-    exact hsum
-  exact (ae_lt_top (Measurable.tsum hm) hi).mono (fun _ h => h.ne)
-
-lemma ae_positive_prescribed_hausdorff_of_bad_mass
-    {Ω : Type*} [MeasurableSpace Ω] (P : Measure Ω)
-    (μ : Ω → Measure ℂ) (hμ : Measurable μ) (hfin : ∀ ω, IsFiniteMeasure (μ ω))
-    (κ : ℝ) (W : Target.WienerLaw)
-    (hg : Target.IsHausdorffGauge (Target.gauge κ W))
-    (hm1 : 0 < Target.moment κ W 1)
-    (hJ : ∀ n : ℕ, 1 ≤ n → Target.moment κ W 1^n ≤ Target.moment κ W n)
-    (D : ℝ) (hD : 0 ≤ D)
-    (hsum : (∑' e : Target.GaugeIndex κ W,
-      ∫⁻ ω, μ ω (prescribedBadGrid (μ ω) κ W D e) ∂P) ≠ ∞) :
-    ∀ᵐ ω ∂P, ∀ E : Set ℂ, MeasurableSet E → 0 < μ ω E →
-      0 < Target.hausdorff (Target.gauge κ W) E := by
-  filter_upwards [ae_prescribedBadGrid_sum_finite P μ hμ hfin κ W D hsum] with ω hω
-  let := hfin ω
-  exact fun E hE hp => positive_prescribed_hausdorff_of_summable_bad_mass
-    (μ ω) κ W hg hm1 hJ D hD hω E hE hp
-
-end SLEExactGauge
-
-end
-
-end OAI
+import OAI.Probability.SLE.Gauge.GoodGridRestriction
+
+namespace OAI
+
+/-! Measurability and almost-sure finiteness of the bad-grid mass sum.
+Only expectations of the actual cell masses occur in the criterion. -/
+
+noncomputable section
+open Set Filter MeasureTheory ProbabilityTheory Metric
+open scoped Topology NNReal ENNReal
+
+namespace SLEExactGauge
+
+lemma measurableSet_random_badGridCells
+    {Ω : Type*} [MeasurableSpace Ω] (μ : Ω → Measure ℂ) (hμ : Measurable μ)
+    (r H : ℝ) : MeasurableSet {p : Ω × ℂ | p.2 ∈ badGridCells (μ p.1) r H} := by
+  classical
+  let Q := fun i : ℤ × ℤ => closedBall (coverGridCenter r i) (2*r)
+  have he : {p : Ω × ℂ | p.2 ∈ badGridCells (μ p.1) r H} =
+      ⋃ i : ℤ × ℤ, {ω | ENNReal.ofReal H < μ ω (Q i)} ×ˢ Q i := by
+    ext p
+    constructor
+    · intro hp
+      obtain ⟨i,hi⟩ := mem_iUnion.mp hp
+      change p.2 ∈ if ENNReal.ofReal H < μ p.1 (Q i) then Q i else ∅ at hi
+      by_cases h : ENNReal.ofReal H < μ p.1 (Q i)
+      · rw [ite_eq_left h] at hi
+        exact mem_iUnion.mpr ⟨i,h,hi⟩
+      · rw [ite_eq_right h] at hi
+        exact hi.elim
+    · intro hp
+      obtain ⟨i,hi⟩ := mem_iUnion.mp hp
+      apply mem_iUnion.mpr
+      refine ⟨i,?_⟩
+      change p.2 ∈ if ENNReal.ofReal H < μ p.1 (Q i) then Q i else ∅
+      rw [ite_eq_left (show ENNReal.ofReal H < μ p.1 (Q i) from hi.1)]
+      exact hi.2
+  rw [he]
+  apply MeasurableSet.iUnion
+  intro i
+  exact (measurableSet_lt measurable_const
+    ((Measure.measurable_coe measurableSet_closedBall).comp hμ)).prod measurableSet_closedBall
+
+lemma random_badGrid_mass_measurable
+    {Ω : Type*} [MeasurableSpace Ω] (μ : Ω → Measure ℂ) (hμ : Measurable μ)
+    (hfin : ∀ ω, IsFiniteMeasure (μ ω)) (r H : ℝ) :
+    Measurable (fun ω => μ ω (badGridCells (μ ω) r H)) := by
+  let K : Kernel Ω ℂ := ⟨μ,hμ⟩
+  exact Kernel.measurable_kernel_prodMk_left_of_finite (κ:=K)
+    (measurableSet_random_badGridCells μ hμ r H) hfin
+
+lemma badGrid_mass_le_sum (μ : Measure ℂ) (r H : ℝ) :
+    μ (badGridCells μ r H) ≤ ∑' i : ℤ × ℤ,
+      if ENNReal.ofReal H < μ (closedBall (coverGridCenter r i) (2*r)) then
+        μ (closedBall (coverGridCenter r i) (2*r)) else 0 := by
+  classical
+  calc
+    _ ≤ ∑' i : ℤ × ℤ, μ (if ENNReal.ofReal H < μ (closedBall (coverGridCenter r i) (2*r)) then
+      closedBall (coverGridCenter r i) (2*r) else ∅) := measure_iUnion_le _
+    _ = _ := by
+      apply tsum_congr
+      intro i
+      split_ifs <;> simp
+
+lemma expected_badGrid_mass_le_sum
+    {Ω : Type*} [MeasurableSpace Ω] (P : Measure Ω)
+    (μ : Ω → Measure ℂ) (hμ : Measurable μ) (r H : ℝ) :
+    (∫⁻ ω, μ ω (badGridCells (μ ω) r H) ∂P) ≤ ∑' i : ℤ × ℤ,
+      ∫⁻ ω, if ENNReal.ofReal H < μ ω (closedBall (coverGridCenter r i) (2*r)) then
+        μ ω (closedBall (coverGridCenter r i) (2*r)) else 0 ∂P := by
+  classical
+  calc
+    _ ≤ ∫⁻ ω, ∑' i : ℤ × ℤ,
+        if ENNReal.ofReal H < μ ω (closedBall (coverGridCenter r i) (2*r)) then
+          μ ω (closedBall (coverGridCenter r i) (2*r)) else 0 ∂P :=
+      lintegral_mono (fun ω => badGrid_mass_le_sum (μ ω) r H)
+    _ = _ := by
+      apply lintegral_tsum
+      intro i
+      exact (Measurable.ite (measurableSet_lt measurable_const
+        ((Measure.measurable_coe measurableSet_closedBall).comp hμ))
+        ((Measure.measurable_coe measurableSet_closedBall).comp hμ) measurable_const).aemeasurable
+
+lemma ae_prescribedBadGrid_sum_finite
+    {Ω : Type*} [MeasurableSpace Ω] (P : Measure Ω)
+    (μ : Ω → Measure ℂ) (hμ : Measurable μ) (hfin : ∀ ω, IsFiniteMeasure (μ ω))
+    (κ : ℝ) (W : Target.WienerLaw) (D : ℝ)
+    (hsum : (∑' e : Target.GaugeIndex κ W,
+      ∫⁻ ω, μ ω (prescribedBadGrid (μ ω) κ W D e) ∂P) ≠ ∞) :
+    ∀ᵐ ω ∂P, (∑' e : Target.GaugeIndex κ W, μ ω (prescribedBadGrid (μ ω) κ W D e)) ≠ ∞ := by
+  have hm (e : Target.GaugeIndex κ W) :
+      Measurable (fun ω => μ ω (prescribedBadGrid (μ ω) κ W D e)) :=
+    random_badGrid_mass_measurable μ hμ hfin _ _
+  have hi : (∫⁻ ω, ∑' e : Target.GaugeIndex κ W,
+      μ ω (prescribedBadGrid (μ ω) κ W D e) ∂P) ≠ ∞ := by
+    rw [lintegral_tsum (fun e => (hm e).aemeasurable)]
+    exact hsum
+  exact (ae_lt_top (Measurable.tsum hm) hi).mono (fun _ h => h.ne)
+
+lemma ae_positive_prescribed_hausdorff_of_bad_mass
+    {Ω : Type*} [MeasurableSpace Ω] (P : Measure Ω)
+    (μ : Ω → Measure ℂ) (hμ : Measurable μ) (hfin : ∀ ω, IsFiniteMeasure (μ ω))
+    (κ : ℝ) (W : Target.WienerLaw)
+    (hg : Target.IsHausdorffGauge (Target.gauge κ W))
+    (hm1 : 0 < Target.moment κ W 1)
+    (hJ : ∀ n : ℕ, 1 ≤ n → Target.moment κ W 1^n ≤ Target.moment κ W n)
+    (D : ℝ) (hD : 0 ≤ D)
+    (hsum : (∑' e : Target.GaugeIndex κ W,
+      ∫⁻ ω, μ ω (prescribedBadGrid (μ ω) κ W D e) ∂P) ≠ ∞) :
+    ∀ᵐ ω ∂P, ∀ E : Set ℂ, MeasurableSet E → 0 < μ ω E →
+      0 < Target.hausdorff (Target.gauge κ W) E := by
+  filter_upwards [ae_prescribedBadGrid_sum_finite P μ hμ hfin κ W D hsum] with ω hω
+  let := hfin ω
+  exact fun E hE hp => positive_prescribed_hausdorff_of_summable_bad_mass
+    (μ ω) κ W hg hm1 hJ D hD hω E hE hp
+
+end SLEExactGauge
+
+end
+
+end OAI

lean/OAI/Probability/SLE/Gauge/RandomPassageBounds.lean

@@ -1,136 +1,136 @@
-import OAI.Probability.SLE.Geometry.FiniteBoundaryRestart
-import OAI.Probability.SLE.Geometry.BoundaryScaleLaw
-import OAI.Probability.SLE.Gauge.CoverChangeOfLaw
-import Mathlib.MeasureTheory.Function.ConditionalExpectation.LebesgueBochner
-
-namespace OAI
-
-/-! Quantitative passage bounds for measurable random stopped charts and
-finite stopped changes of measure. These are integration identities, with
-the actual section estimates supplied by the ribbon proof. -/
-
-noncomputable section
-open Set Filter MeasureTheory ProbabilityTheory
-open scoped Topology NNReal ENNReal
-
-namespace SLEExactGauge
-open BoundaryScaleLaw
-
-local instance : LocallyCompactSpace closedHalfPlane :=
-  isClosed_closedHalfPlane.locallyCompactSpace
-local instance randomPassagePathMeasurable : MeasurableSpace C(ℝ≥0, ℂ) := borel _
-local instance randomPassagePathBorel : BorelSpace C(ℝ≥0, ℂ) := ⟨rfl⟩
-local instance randomPassageClosedMeasurable : MeasurableSpace C(ℝ≥0, closedHalfPlane) := borel _
-local instance randomPassageClosedBorel : BorelSpace C(ℝ≥0, closedHalfPlane) := ⟨rfl⟩
-
-lemma measurable_random_finiteBoundaryPath
-    {Ω : Type*} [MeasurableSpace Ω]
-    (Fb : Ω → C(closedHalfPlane, ℂ)) (hFb : Measurable Fb) :
-    Measurable (fun x : Ω × C(ℝ≥0, ℂ) => finiteBoundaryPath (Fb x.1) x.2) := by
-  have hc : Continuous (fun x : C(ℝ≥0, closedHalfPlane) × C(closedHalfPlane, ℂ) =>
-      x.2.comp x.1) := ContinuousMap.continuous_comp'
-  exact hc.measurable.comp
-    ((measurable_liftClosedPath.comp measurable_snd).prodMk (hFb.comp measurable_fst))
-
-lemma measurableSet_random_finite_frontMassEvent
-    {Ω : Type*} [MeasurableSpace Ω]
-    (Fb : Ω → C(closedHalfPlane, ℂ)) (hFb : Measurable Fb)
-    (p : ℂ → ℝ) (V : Set ℂ) (a : ℂ) (ε κ v c : ℝ) (R K : Set ℂ)
-    (hK : IsClosed K) (hp : ContinuousOn p K) (hV : IsOpen V) (hVK : V ⊆ K) :
-    MeasurableSet {x : Ω × C(ℝ≥0, ℂ) |
-      finiteBoundaryPath (Fb x.1) x.2 ∈ frontMassEvent p V a ε κ v c R} :=
-  (measurableSet_frontMassEvent p V a ε κ v c R K hK hp hV hVK).preimage
-    (measurable_random_finiteBoundaryPath Fb hFb)
-
-lemma restart_condLExp_event_sections
-    {Ω 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 • ν)
-    (C : Set (Ω × X)) (hC : @MeasurableSet (Ω × X) (m.prod mX) C) :
-    (fun ω => ν {x | (ω, x) ∈ C}) =ᵐ[P]
-      P⁻[({ω | (ω, Y ω) ∈ C}).indicator (fun _ => 1) | m] := by
-  have hf : @Measurable (Ω × X) ℝ≥0∞ (m.prod mX) _ (C.indicator (fun _ => 1)) := by
-    let : MeasurableSpace (Ω × X) := m.prod mX
-    exact measurable_const.indicator hC
-  let : MeasurableSpace Ω := mΩ
-  have he := @restart_condLExp_random_test Ω X mΩ mX P inferInstance ν inferInstance m hm Y hY hlaw
-    (C.indicator (fun _ => 1)) hf
-  have hs (ω : Ω) : (∫⁻ x, C.indicator (fun _ => (1 : ℝ≥0∞)) (ω, x) ∂ν) =
-      ν {x | (ω, x) ∈ C} := by
-    change (∫⁻ x, ({x | (ω, x) ∈ C}).indicator (fun _ => (1 : ℝ≥0∞)) x ∂ν) = _
-    have hsec : MeasurableSet {x | (ω, x) ∈ C} :=
-      hC.preimage measurable_prodMk_left
-    rw [lintegral_indicator hsec, setLIntegral_const, one_mul]
-  have hind : (fun ω => C.indicator (fun _ => (1 : ℝ≥0∞)) (ω, Y ω)) =
-      ({ω | (ω, Y ω) ∈ C}).indicator (fun _ => 1) := by
-    funext ω
-    by_cases h : (ω, Y ω) ∈ C <;> simp [h]
-  simpa only [hs, hind] using he
-
-/-- Uniform section bounds integrate on every event in the stopped past.
-No countable list of possible pasts and no independence of steps is used. -/
-theorem restart_event_lower_bound
-    {Ω 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 • ν)
-    (C : Set (Ω × X)) (hC : @MeasurableSet (Ω × X) (m.prod mX) C)
-    (E : Set Ω) (q : ℝ≥0∞)
-    (hsections : ∀ᵐ ω ∂P, ω ∈ E → q ≤ ν {x | (ω, x) ∈ C})
-    (A : Set Ω) (hA : MeasurableSet[m] A) (hAE : A ⊆ E) :
-    q * P A ≤ P (A ∩ {ω | (ω, Y ω) ∈ C}) := by
-  let : MeasurableSpace Ω := mΩ
-  have he := @restart_condLExp_event_sections Ω X mΩ mX P inferInstance ν inferInstance m hm Y hY hlaw C hC
-  have hactual : MeasurableSet[mΩ] {ω | (ω, Y ω) ∈ C} :=
-    hC.preimage ((measurable_id'' hm).prodMk hY)
-  calc
-    _ = ∫⁻ ω in A, q ∂P := (setLIntegral_const A q).symm
-    _ ≤ ∫⁻ ω in A, P⁻[({ω | (ω, Y ω) ∈ C}).indicator (fun _ => 1) | m] ω ∂P := by
-      apply lintegral_mono_ae
-      apply (ae_restrict_iff' (hm A hA)).mpr
-      filter_upwards [he, hsections] with ω hω hsec hωA
-      exact hω ▸ hsec (hAE hωA)
-    _ = ∫⁻ ω in A, ({ω | (ω, Y ω) ∈ C}).indicator (fun _ => (1 : ℝ≥0∞)) ω ∂P :=
-      setLIntegral_condLExp hm P _ hA
-    _ = P (A ∩ {ω | (ω, Y ω) ∈ C}) := by
-      rw [setLIntegral_indicator hactual, setLIntegral_const, one_mul, inter_comm]
-
-/-- A lower bound on the density at a finite stop transfers any event
-observable there to the terminal tilted law. -/
-theorem normalizedDensity_event_lower_bound_of_condExp
-    {Ω : Type*} [mΩ : MeasurableSpace Ω] (P : Measure Ω) [IsFiniteMeasure P]
-    (m : MeasurableSpace Ω) (hm : m ≤ mΩ)
-    (Z M : Ω → ℝ) (hZ : Integrable Z P) (hZpos : 0 ≤ᵐ[P] Z)
-    (hM : M =ᵐ[P] P[Z | m])
-    (a c : ℝ) (ha : 0 < a) (hc : 0 ≤ c)
-    (E : Set Ω) (hE : MeasurableSet[m] E)
-    (hbound : ∀ᵐ ω ∂P, ω ∈ E → c * a ≤ M ω) :
-    ENNReal.ofReal c * P E ≤
-      P.withDensity (fun ω => ENNReal.ofReal (Z ω / a)) E := by
-  let : MeasurableSpace Ω := mΩ
-  have hcond := condLExp_ofReal m hZ hZpos
-  have hmass : ENNReal.ofReal (c * a) * P E ≤ ∫⁻ ω in E, ENNReal.ofReal (Z ω) ∂P := by
-    calc
-      _ = ∫⁻ ω in E, ENNReal.ofReal (c * a) ∂P := (setLIntegral_const E _).symm
-      _ ≤ ∫⁻ ω in E, P⁻[(fun ω => ENNReal.ofReal (Z ω)) | m] ω ∂P := by
-        apply lintegral_mono_ae
-        apply (ae_restrict_iff' (hm E hE)).mpr
-        filter_upwards [hcond, hM, hbound] with ω hω hMω hb hωE
-        rw [hω, ← hMω]
-        exact ENNReal.ofReal_le_ofReal (hb hωE)
-      _ = _ := setLIntegral_condLExp hm P _ hE
-  rw [setLIntegral_eq_mul_normalizedDensity P Z ha (hm E hE),
-    ENNReal.ofReal_mul hc, mul_comm (ENNReal.ofReal c), mul_assoc] at hmass
-  exact (ENNReal.mul_le_mul_iff_right (ENNReal.ofReal_ne_zero_iff.mpr ha)
-    ENNReal.ofReal_ne_top).mp (by simpa only [mul_comm (ENNReal.ofReal a)] using hmass)
-
-end SLEExactGauge
-
-end
-
-end OAI
+import OAI.Probability.SLE.Geometry.FiniteBoundaryRestart
+import OAI.Probability.SLE.Geometry.BoundaryScaleLaw
+import OAI.Probability.SLE.Gauge.CoverChangeOfLaw
+import Mathlib.MeasureTheory.Function.ConditionalExpectation.LebesgueBochner
+
+namespace OAI
+
+/-! Quantitative passage bounds for measurable random stopped charts and
+finite stopped changes of measure. These are integration identities, with
+the actual section estimates supplied by the ribbon proof. -/
+
+noncomputable section
+open Set Filter MeasureTheory ProbabilityTheory
+open scoped Topology NNReal ENNReal
+
+namespace SLEExactGauge
+open BoundaryScaleLaw
+
+local instance : LocallyCompactSpace closedHalfPlane :=
+  isClosed_closedHalfPlane.locallyCompactSpace
+local instance randomPassagePathMeasurable : MeasurableSpace C(ℝ≥0, ℂ) := borel _
+local instance randomPassagePathBorel : BorelSpace C(ℝ≥0, ℂ) := ⟨rfl⟩
+local instance randomPassageClosedMeasurable : MeasurableSpace C(ℝ≥0, closedHalfPlane) := borel _
+local instance randomPassageClosedBorel : BorelSpace C(ℝ≥0, closedHalfPlane) := ⟨rfl⟩
+
+lemma measurable_random_finiteBoundaryPath
+    {Ω : Type*} [MeasurableSpace Ω]
+    (Fb : Ω → C(closedHalfPlane, ℂ)) (hFb : Measurable Fb) :
+    Measurable (fun x : Ω × C(ℝ≥0, ℂ) => finiteBoundaryPath (Fb x.1) x.2) := by
+  have hc : Continuous (fun x : C(ℝ≥0, closedHalfPlane) × C(closedHalfPlane, ℂ) =>
+      x.2.comp x.1) := ContinuousMap.continuous_comp'
+  exact hc.measurable.comp
+    ((measurable_liftClosedPath.comp measurable_snd).prodMk (hFb.comp measurable_fst))
+
+lemma measurableSet_random_finite_frontMassEvent
+    {Ω : Type*} [MeasurableSpace Ω]
+    (Fb : Ω → C(closedHalfPlane, ℂ)) (hFb : Measurable Fb)
+    (p : ℂ → ℝ) (V : Set ℂ) (a : ℂ) (ε κ v c : ℝ) (R K : Set ℂ)
+    (hK : IsClosed K) (hp : ContinuousOn p K) (hV : IsOpen V) (hVK : V ⊆ K) :
+    MeasurableSet {x : Ω × C(ℝ≥0, ℂ) |
+      finiteBoundaryPath (Fb x.1) x.2 ∈ frontMassEvent p V a ε κ v c R} :=
+  (measurableSet_frontMassEvent p V a ε κ v c R K hK hp hV hVK).preimage
+    (measurable_random_finiteBoundaryPath Fb hFb)
+
+lemma restart_condLExp_event_sections
+    {Ω 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 • ν)
+    (C : Set (Ω × X)) (hC : @MeasurableSet (Ω × X) (m.prod mX) C) :
+    (fun ω => ν {x | (ω, x) ∈ C}) =ᵐ[P]
+      P⁻[({ω | (ω, Y ω) ∈ C}).indicator (fun _ => 1) | m] := by
+  have hf : @Measurable (Ω × X) ℝ≥0∞ (m.prod mX) _ (C.indicator (fun _ => 1)) := by
+    let : MeasurableSpace (Ω × X) := m.prod mX
+    exact measurable_const.indicator hC
+  let : MeasurableSpace Ω := mΩ
+  have he := @restart_condLExp_random_test Ω X mΩ mX P inferInstance ν inferInstance m hm Y hY hlaw
+    (C.indicator (fun _ => 1)) hf
+  have hs (ω : Ω) : (∫⁻ x, C.indicator (fun _ => (1 : ℝ≥0∞)) (ω, x) ∂ν) =
+      ν {x | (ω, x) ∈ C} := by
+    change (∫⁻ x, ({x | (ω, x) ∈ C}).indicator (fun _ => (1 : ℝ≥0∞)) x ∂ν) = _
+    have hsec : MeasurableSet {x | (ω, x) ∈ C} :=
+      hC.preimage measurable_prodMk_left
+    rw [lintegral_indicator hsec, setLIntegral_const, one_mul]
+  have hind : (fun ω => C.indicator (fun _ => (1 : ℝ≥0∞)) (ω, Y ω)) =
+      ({ω | (ω, Y ω) ∈ C}).indicator (fun _ => 1) := by
+    funext ω
+    by_cases h : (ω, Y ω) ∈ C <;> simp [h]
+  simpa only [hs, hind] using he
+
+/-- Uniform section bounds integrate on every event in the stopped past.
+No countable list of possible pasts and no independence of steps is used. -/
+theorem restart_event_lower_bound
+    {Ω 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 • ν)
+    (C : Set (Ω × X)) (hC : @MeasurableSet (Ω × X) (m.prod mX) C)
+    (E : Set Ω) (q : ℝ≥0∞)
+    (hsections : ∀ᵐ ω ∂P, ω ∈ E → q ≤ ν {x | (ω, x) ∈ C})
+    (A : Set Ω) (hA : MeasurableSet[m] A) (hAE : A ⊆ E) :
+    q * P A ≤ P (A ∩ {ω | (ω, Y ω) ∈ C}) := by
+  let : MeasurableSpace Ω := mΩ
+  have he := @restart_condLExp_event_sections Ω X mΩ mX P inferInstance ν inferInstance m hm Y hY hlaw C hC
+  have hactual : MeasurableSet[mΩ] {ω | (ω, Y ω) ∈ C} :=
+    hC.preimage ((measurable_id'' hm).prodMk hY)
+  calc
+    _ = ∫⁻ ω in A, q ∂P := (setLIntegral_const A q).symm
+    _ ≤ ∫⁻ ω in A, P⁻[({ω | (ω, Y ω) ∈ C}).indicator (fun _ => 1) | m] ω ∂P := by
+      apply lintegral_mono_ae
+      apply (ae_restrict_iff' (hm A hA)).mpr
+      filter_upwards [he, hsections] with ω hω hsec hωA
+      exact hω ▸ hsec (hAE hωA)
+    _ = ∫⁻ ω in A, ({ω | (ω, Y ω) ∈ C}).indicator (fun _ => (1 : ℝ≥0∞)) ω ∂P :=
+      setLIntegral_condLExp hm P _ hA
+    _ = P (A ∩ {ω | (ω, Y ω) ∈ C}) := by
+      rw [setLIntegral_indicator hactual, setLIntegral_const, one_mul, inter_comm]
+
+/-- A lower bound on the density at a finite stop transfers any event
+observable there to the terminal tilted law. -/
+theorem normalizedDensity_event_lower_bound_of_condExp
+    {Ω : Type*} [mΩ : MeasurableSpace Ω] (P : Measure Ω) [IsFiniteMeasure P]
+    (m : MeasurableSpace Ω) (hm : m ≤ mΩ)
+    (Z M : Ω → ℝ) (hZ : Integrable Z P) (hZpos : 0 ≤ᵐ[P] Z)
+    (hM : M =ᵐ[P] P[Z | m])
+    (a c : ℝ) (ha : 0 < a) (hc : 0 ≤ c)
+    (E : Set Ω) (hE : MeasurableSet[m] E)
+    (hbound : ∀ᵐ ω ∂P, ω ∈ E → c * a ≤ M ω) :
+    ENNReal.ofReal c * P E ≤
+      P.withDensity (fun ω => ENNReal.ofReal (Z ω / a)) E := by
+  let : MeasurableSpace Ω := mΩ
+  have hcond := condLExp_ofReal m hZ hZpos
+  have hmass : ENNReal.ofReal (c * a) * P E ≤ ∫⁻ ω in E, ENNReal.ofReal (Z ω) ∂P := by
+    calc
+      _ = ∫⁻ ω in E, ENNReal.ofReal (c * a) ∂P := (setLIntegral_const E _).symm
+      _ ≤ ∫⁻ ω in E, P⁻[(fun ω => ENNReal.ofReal (Z ω)) | m] ω ∂P := by
+        apply lintegral_mono_ae
+        apply (ae_restrict_iff' (hm E hE)).mpr
+        filter_upwards [hcond, hM, hbound] with ω hω hMω hb hωE
+        rw [hω, ← hMω]
+        exact ENNReal.ofReal_le_ofReal (hb hωE)
+      _ = _ := setLIntegral_condLExp hm P _ hE
+  rw [setLIntegral_eq_mul_normalizedDensity P Z ha (hm E hE),
+    ENNReal.ofReal_mul hc, mul_comm (ENNReal.ofReal c), mul_assoc] at hmass
+  exact (ENNReal.mul_le_mul_iff_right (ENNReal.ofReal_ne_zero_iff.mpr ha)
+    ENNReal.ofReal_ne_top).mp (by simpa only [mul_comm (ENNReal.ofReal a)] using hmass)
+
+end SLEExactGauge
+
+end
+
+end OAI

lean/OAI/Probability/SLE/Gauge/RecenteredRibbonPassage.lean

@@ -1,193 +1,193 @@
-import OAI.Probability.SLE.Geometry.RecenteredGuideCompactness
-import OAI.Probability.SLE.Stochastic.PlanarCoordinatePassage
-import OAI.Probability.SLE.Gauge.RibbonSequenceCompactness
-
-namespace OAI
-
-/-! Actual passage along a recentered conformal subsequence, with its
-finite physical realization constructed from the boundary chart. -/
-
-noncomputable section
-open Set Filter MeasureTheory ProbabilityTheory Metric
-open scoped Topology NNReal ENNReal
-
-namespace SLEExactGauge
-open RibbonCoordinates SequencePassage PassageSuccess FirstFrontPassage
-
-theorem recentered_ribbon_subsequence_passage
-    {Ω : Type} [MeasurableSpace Ω] (P : Measure Ω) [IsProbabilityMeasure P]
-    (κ : ℝ) (hκ : 0 < κ) (hκ8 : κ < 8)
-    (B₀ : ℝ≥0 → Ω → ℝ) (hB₀ : IsBrownianReal B₀ P)
-    (hm : ∀ t, Measurable (B₀ t)) (hc : ∀ ω, Continuous (fun t => B₀ t ω))
-    (γ : Ω → ℝ≥0 → ℂ) (Gbase Fbase : Ω → ℝ≥0 → ℂ → ℂ)
-    (hwbase : ∀ ω, IsCapacityTwoWitness (fun t => Real.sqrt κ * B₀ t ω)
-      (γ ω) (Gbase ω) (Fbase ω))
-    (hcompact : PublishedHalfPlaneUnivalentCompactness)
-    (hboundary : PublishedFiniteLoewnerBoundaryExtension)
-    (hsupport : PublishedGeometricTubeSupport P γ)
-    (hplanar : PublishedPlanarDiskOpenness)
-    (U : ℕ → ℝ≥0 → ℝ) (γₙ : ℕ → ℝ≥0 → ℂ)
-    (G F₀ : ℕ → ℝ≥0 → ℂ → ℂ)
-    (hU : ∀ n, Continuous (U n))
-    (hw : ∀ n, IsCapacityTwoWitness (U n) (γₙ n) (G n) (F₀ n))
-    (T : ℕ → ℝ≥0) (hT : ∀ n, 0 < T n)
-    (hfresh : ∀ n s, s < T n → γₙ n (T n) ∈ survivingDomain (γₙ n) s)
-    (αₙ : ℕ → ℝ → ℂ) (Cg : ℝ≥0) (s c : ℝ)
-    (hCg : 0 < (Cg : ℝ)) (hs : 0 < s) (hcpos : 0 < c)
-    (hαL : ∀ n, LipschitzOnWith Cg (αₙ n) (Icc 0 2))
-    (hα0 : ∀ n, αₙ n 0 = γₙ n (T n))
-    (hchord : ∀ n u, u ∈ Icc (0 : ℝ) 2 → ∀ v, v ∈ Icc (0 : ℝ) 2 →
-      c * |u - v| ≤ dist (αₙ n u) (αₙ n v))
-    (hαD : ∀ n, MapsTo (αₙ n) (Ioc 0 2) (survivingDomain (γₙ n) (T n)))
-    (hclear : ∀ δ : ℝ, 0 < δ → δ ≤ 2 → ∃ r : ℝ, 0 < r ∧
-      ∀ n t, t ∈ Icc δ 2 → ball (αₙ n t) r ⊆ survivingDomain (γₙ n) (T n))
-    (Qₙ : ℕ → ℂ → ℂ) (K : Set ℂ) (hK : IsCompact K)
-    (x₀ : ℂ) (hx₀ : x₀ ∈ K) (C Lq : ℝ≥0) (Rq : ℝ)
-    (hC : 0 < C) (hLq : 0 < Lq)
-    (hQupper : ∀ n, LipschitzOnWith C (Qₙ n) K)
-    (hQlower : ∀ n x, x ∈ K → ∀ y, y ∈ K → dist x y ≤ Lq * dist (Qₙ n x) (Qₙ n y))
-    (hQtip : ∀ n, ‖Qₙ n x₀‖ ≤ Rq)
-    (xₙ : ℕ → ℝ) (ε : ℝ) (hε : 0 < ε)
-    (hxₙ : ∀ n, |xₙ n| ≤ ε / 4)
-    (hcore : {z : ℂ | 0 ≤ z.re ∧ z.re ≤ 2 ∧ |z.im| ≤ ε / 4} ⊆ interior K)
-    (hshape : ∀ n, EqOn (fun t => αₙ n t - γₙ n (T n))
-      (fun t => Qₙ n (guideCoordinate 0 (xₙ n) t)) (Icc 0 2))
-    (hangle : ∀ n, s ≤ (G n (T n) (αₙ n (1 / 2)) - (U n (T n) : ℂ)).im /
-      ‖G n (T n) (αₙ n (1 / 2)) - (U n (T n) : ℂ)‖)
-    (v : ℕ → ℝ) (hv : ∀ n, 0 < v n) (hlim : Tendsto v atTop (𝓝 0)) :
-    ∃ (φ : ℕ → ℕ) (b : ℕ → ℝ) (Fb : ℕ → C(closedHalfPlane, ℂ)),
-      StrictMono φ ∧ (∀ n, 0 < b n) ∧
-      (∀ n (z : closedHalfPlane), z.1 ∈ upperHalfPlane → Fb n z =
-        normalizedInverse (F₀ (φ n) (T (φ n))) (U (φ n) (T (φ n))) (b n) z -
-          γₙ (φ n) (T (φ n))) ∧
-      let η := fun n ω => (finiteBoundaryPath (Fb n)
-        (sourceTracePath γ (fun ω => (hwbase ω).1) ω) : ℝ≥0 → ℂ)
-      ∃ c₁ q : ℝ, 0 < c₁ ∧ 0 < q ∧ ∀ᶠ n in atTop,
-        ENNReal.ofReal q ≤ P {ω |
-          ω ∈ FrontSuccess η (fun n => longitudinalCoordinate (Qₙ (φ n)) K 0)
-            (fun _ => 0) (fun n => physicalPassageRegion (Qₙ (φ n)) K C ε (ε / Lq))
-            (fun n => Qₙ (φ n) 1) (ε / Lq) n ∧
-          ENNReal.ofReal c₁ ≤ segmentSausageCharge κ (η n ω) 0
-            (frontTime (fun t => longitudinalCoordinate (Qₙ (φ n)) K 0 (η n ω t)) 1)
-            (v (φ n)) (physicalMiddleRegion (Qₙ (φ n)) K 0 ε)} := by
-  let ℱ := Filtration.natural B₀ (fun t => (hm t).stronglyMeasurable)
-  have hadapt := brownian_capacity_trace_adapted B₀ hm hc κ γ Gbase Fbase hwbase
-  have hγm (t : ℝ≥0) : Measurable (fun ω => γ ω t) :=
-    (hadapt t).mono (ℱ.le t) le_rfl
-  have hSLE : IsOrdinaryChordalSLE κ γ P :=
-    ⟨hγm, B₀, hB₀, Eventually.of_forall (fun ω => ⟨Gbase ω, Fbase ω, hwbase ω⟩)⟩
-  have hxin : ∀ n, xₙ n ∈ Icc (-ε / 4) (ε / 4) := by
-    intro n
-    have hh := abs_le.mp (hxₙ n)
-    constructor <;> linarith [hh.1, hh.2]
-  obtain ⟨x, hx, ψ, hψ, hxlim⟩ := isCompact_Icc.tendsto_subseq hxin
-  have hxabs : |x| ≤ ε / 4 := abs_le.mpr ⟨by linarith [hx.1], hx.2⟩
-  obtain ⟨Q, χ, hχ, hQconv, hQu, hQl, _⟩ := exists_bilip_uniform_subsequence
-    (fun n => Qₙ (ψ n)) K hK x₀ hx₀ C Lq Rq (fun n => hQupper (ψ n))
-    (fun n => hQlower (ψ n)) (fun n => hQtip (ψ n))
-  let ρ := ψ ∘ χ
-  obtain ⟨b, Fb, βₙ, θ, F, α, β, hb, hext, hβc, hβ0, hβHn, hbarα,
-      hθ, hF, hiF, hFne, homit, hFconv, hαconv, hβconv, _, _, hαclim, _,
-      hβlim0, hβlimc, hβlimi, hβlimH, hrel⟩ :=
-    recentered_actual_guide_compactness P κ hκ hκ8 γ hSLE hcompact hboundary
-      (fun n => U (ρ n)) (fun n => γₙ (ρ n)) (fun n => G (ρ n)) (fun n => F₀ (ρ n))
-      (fun n => hU (ρ n)) (fun n => hw (ρ n)) (fun n => T (ρ n)) (fun n => hT (ρ n))
-      (fun n => hfresh (ρ n)) (fun n => αₙ (ρ n)) Cg s c hCg hs hcpos
-      (fun n => hαL (ρ n)) (fun n => hα0 (ρ n))
-      (fun n => hchord (ρ n)) (fun n => hαD (ρ n))
-      (fun δ hδ hδ2 => by
-        obtain ⟨r, hr, hh⟩ := hclear δ hδ hδ2
-        exact ⟨r, hr, fun n => hh (ρ n)⟩)
-      (fun n => hangle (ρ n))
-  let φ := ρ ∘ θ
-  let b' := fun n => b (θ n)
-  let Fb' := fun n => Fb (θ n)
-  let Fn := fun n z => normalizedInverse (F₀ (φ n) (T (φ n)))
-    (U (φ n) (T (φ n))) (b' n) z - γₙ (φ n) (T (φ n))
-  let α' := fun n t => αₙ (φ n) t - γₙ (φ n) (T (φ n))
-  have hφ : StrictMono φ := (hψ.comp hχ).comp hθ
-  have hQconv' : TendstoUniformlyOn (fun n => Qₙ (φ n)) Q atTop K := by
-    intro u hu
-    exact hθ.tendsto_atTop.eventually (hQconv u hu)
-  have hguideK n t (ht : t ∈ Icc (0 : ℝ) 2) : guideCoordinate 0 (xₙ (φ n)) t ∈ K := by
-    apply interior_subset
-    apply hcore
-    exact ⟨by simpa using ht.1, by simpa using ht.2,
-      (guideCoordinate_im_bound ht.1).trans (hxₙ (φ n))⟩
-  have hshapeLim : EqOn α (fun t => Q (guideCoordinate 0 x t)) (Icc 0 2) :=
-    coordinate_guide_limit_identity (fun n => Qₙ (φ n)) Q K hK.isClosed hQu.continuousOn
-      hQconv' (fun n => xₙ (φ n)) x
-      (hxlim.comp (hχ.comp hθ).tendsto_atTop) α' α hαconv hguideK
-      (fun n => hshape (φ n))
-  have hmem t (ht : t ∈ Icc (0 : ℝ) (3 / 2)) : guideCoordinate 0 x t ∈ interior K := by
-    apply hcore
-    exact ⟨by simpa using ht.1, by simpa using ht.2.trans (by norm_num : (3 / 2 : ℝ) ≤ 2),
-      (guideCoordinate_im_bound ht.1).trans hxabs⟩
-  have hbase : (1 : ℂ) ∈ K := by
-    apply interior_subset
-    apply hcore
-    refine ⟨by norm_num, by norm_num, ?_⟩
-    simpa only [Complex.one_im, abs_zero] using (show 0 ≤ ε / 4 by positivity)
-  let Fbar := fun n z => if hz : z ∈ closedHalfPlane then (Fb' n ⟨z, hz⟩ : OnePoint ℂ)
-    else OnePoint.infty
-  have hbar n : ContinuousOn (Fbar n) closedHalfPlane := by
-    rw [continuousOn_iff_continuous_domRestrict]
-    convert OnePoint.continuous_coe.comp (Fb' n).continuous using 1
-    funext z
-    change (if hz : (z : ℂ) ∈ closedHalfPlane then (Fb' n ⟨z, hz⟩ : OnePoint ℂ)
-      else OnePoint.infty) = (Fb' n z : OnePoint ℂ)
-    rw [dite_eq_left z.2]
-  have hbarext n z (hz : z ∈ upperHalfPlane) : Fbar n z = (Fn n z : OnePoint ℂ) := by
-    have hz' : z ∈ closedHalfPlane := (show 0 < z.im from hz).le
-    dsimp only [Fbar]
-    rw [dite_eq_left hz']
-    exact congrArg (fun z : ℂ => (z : OnePoint ℂ)) (hext (θ n) ⟨z, hz'⟩ hz)
-  have hbarα' n t (ht : t ∈ Icc (0 : ℝ) 2) : Fbar n (βₙ (θ n) t) = (α' n t : OnePoint ℂ) := by
-    dsimp only [Fbar]
-    rw [dite_eq_left (show βₙ (θ n) t ∈ closedHalfPlane from hβHn (θ n) t ht)]
-    exact congrArg (fun z : ℂ => (z : OnePoint ℂ)) (hbarα (θ n) t ht _)
-  let gp := sourceTracePath γ (fun ω => (hwbase ω).1)
-  let η := fun n ω => (finiteBoundaryPath (Fb' n) (gp ω) : ℝ≥0 → ℂ)
-  have hηc n : ∀ᵐ ω ∂P, Continuous (η n ω) :=
-    Eventually.of_forall (fun ω => (finiteBoundaryPath (Fb' n) (gp ω)).continuous)
-  have hηbar n : ∀ᵐ ω ∂P, ∀ t, Fbar n (γ ω t) = (η n ω t : OnePoint ℂ) := by
-    apply Eventually.of_forall
-    intro ω t
-    have hh : ClosedPathProperty (gp ω) := fun t => (hwbase ω).2.2.1 t
-    dsimp only [η]
-    rw [finiteBoundaryPath_apply _ _ hh]
-    dsimp only [Fbar]
-    rw [dite_eq_left (show γ ω t ∈ closedHalfPlane from (hwbase ω).2.2.1 t)]
-    rfl
-  have hαL' n : LipschitzOnWith Cg (α' n) (Icc 0 2) := by
-    apply lipschitzOnWith_iff_dist_le_mul.mpr
-    intro u hu w hw'
-    simpa only [α', dist_sub_right] using (hαL (φ n)).dist_le_mul u hu w hw'
-  have hnorm n := normalized_capacity_charts (hw (φ n)) (T (φ n)) (b' n) (hb (θ n))
-  have hFn n : DifferentiableOn ℂ (Fn n) upperHalfPlane := (hnorm n).1.sub_const _
-  have hiFn n : InjOn (Fn n) upperHalfPlane := by
-    intro z hz w hw' he
-    exact (hnorm n).2.1 hz hw' (sub_left_inj.mp he)
-  obtain ⟨B, _, Tc, _, c₁, q, hc₁, hq, hprob⟩ := planar_coordinate_limit_passage
-    κ hκ hκ8 B₀ hB₀ hm hc γ Gbase Fbase hwbase hboundary.to_onePoint hsupport hplanar
-    (fun n => Qₙ (φ n)) Q K C Lq hC hLq (fun n => hQupper (φ n))
-    (fun n => hQlower (φ n)) hQconv' hQu.continuousOn hbase
-    Fn Fbar F hFn hiFn hbar hbarext hF hiF hFne hFconv
-    α' (fun n => βₙ (θ n)) α β Cg hαL' hαconv hαclim
-    (fun n => hβc (θ n)) (fun n => hβ0 (θ n)) (fun n => hβHn (θ n))
-    hbarα' hβconv hβlimc hβlim0 hβlimi hβlimH hrel homit x ε (ε / Lq)
-    (by linarith) (div_pos hε hLq) hshapeLim hmem
-    (fun n => v (φ n)) (fun n => hv (φ n)) (hlim.comp hφ.tendsto_atTop) η hηc hηbar
-  refine ⟨φ, b', Fb', hφ, (fun n => hb (θ n)), (fun n => hext (θ n)),
-    c₁, q, hc₁, hq, ?_⟩
-  filter_upwards [hprob] with n hn
-  apply hn.trans (measure_mono ?_)
-  rintro ω ⟨⟨hfinite, hhit, hbefore, hpath, hterminal⟩, hmass⟩
-  exact ⟨⟨hfinite, hhit, bot_le.trans_lt hbefore, hpath, hterminal⟩,
-    hmass.trans (segmentSausageCharge_mono κ (η n ω) bot_le le_rfl (v (φ n)) Subset.rfl)⟩
-
-end SLEExactGauge
-
-end
-
-end OAI
+import OAI.Probability.SLE.Geometry.RecenteredGuideCompactness
+import OAI.Probability.SLE.Stochastic.PlanarCoordinatePassage
+import OAI.Probability.SLE.Gauge.RibbonSequenceCompactness
+
+namespace OAI
+
+/-! Actual passage along a recentered conformal subsequence, with its
+finite physical realization constructed from the boundary chart. -/
+
+noncomputable section
+open Set Filter MeasureTheory ProbabilityTheory Metric
+open scoped Topology NNReal ENNReal
+
+namespace SLEExactGauge
+open RibbonCoordinates SequencePassage PassageSuccess FirstFrontPassage
+
+theorem recentered_ribbon_subsequence_passage
+    {Ω : Type} [MeasurableSpace Ω] (P : Measure Ω) [IsProbabilityMeasure P]
+    (κ : ℝ) (hκ : 0 < κ) (hκ8 : κ < 8)
+    (B₀ : ℝ≥0 → Ω → ℝ) (hB₀ : IsBrownianReal B₀ P)
+    (hm : ∀ t, Measurable (B₀ t)) (hc : ∀ ω, Continuous (fun t => B₀ t ω))
+    (γ : Ω → ℝ≥0 → ℂ) (Gbase Fbase : Ω → ℝ≥0 → ℂ → ℂ)
+    (hwbase : ∀ ω, IsCapacityTwoWitness (fun t => Real.sqrt κ * B₀ t ω)
+      (γ ω) (Gbase ω) (Fbase ω))
+    (hcompact : PublishedHalfPlaneUnivalentCompactness)
+    (hboundary : PublishedFiniteLoewnerBoundaryExtension)
+    (hsupport : PublishedGeometricTubeSupport P γ)
+    (hplanar : PublishedPlanarDiskOpenness)
+    (U : ℕ → ℝ≥0 → ℝ) (γₙ : ℕ → ℝ≥0 → ℂ)
+    (G F₀ : ℕ → ℝ≥0 → ℂ → ℂ)
+    (hU : ∀ n, Continuous (U n))
+    (hw : ∀ n, IsCapacityTwoWitness (U n) (γₙ n) (G n) (F₀ n))
+    (T : ℕ → ℝ≥0) (hT : ∀ n, 0 < T n)
+    (hfresh : ∀ n s, s < T n → γₙ n (T n) ∈ survivingDomain (γₙ n) s)
+    (αₙ : ℕ → ℝ → ℂ) (Cg : ℝ≥0) (s c : ℝ)
+    (hCg : 0 < (Cg : ℝ)) (hs : 0 < s) (hcpos : 0 < c)
+    (hαL : ∀ n, LipschitzOnWith Cg (αₙ n) (Icc 0 2))
+    (hα0 : ∀ n, αₙ n 0 = γₙ n (T n))
+    (hchord : ∀ n u, u ∈ Icc (0 : ℝ) 2 → ∀ v, v ∈ Icc (0 : ℝ) 2 →
+      c * |u - v| ≤ dist (αₙ n u) (αₙ n v))
+    (hαD : ∀ n, MapsTo (αₙ n) (Ioc 0 2) (survivingDomain (γₙ n) (T n)))
+    (hclear : ∀ δ : ℝ, 0 < δ → δ ≤ 2 → ∃ r : ℝ, 0 < r ∧
+      ∀ n t, t ∈ Icc δ 2 → ball (αₙ n t) r ⊆ survivingDomain (γₙ n) (T n))
+    (Qₙ : ℕ → ℂ → ℂ) (K : Set ℂ) (hK : IsCompact K)
+    (x₀ : ℂ) (hx₀ : x₀ ∈ K) (C Lq : ℝ≥0) (Rq : ℝ)
+    (hC : 0 < C) (hLq : 0 < Lq)
+    (hQupper : ∀ n, LipschitzOnWith C (Qₙ n) K)
+    (hQlower : ∀ n x, x ∈ K → ∀ y, y ∈ K → dist x y ≤ Lq * dist (Qₙ n x) (Qₙ n y))
+    (hQtip : ∀ n, ‖Qₙ n x₀‖ ≤ Rq)
+    (xₙ : ℕ → ℝ) (ε : ℝ) (hε : 0 < ε)
+    (hxₙ : ∀ n, |xₙ n| ≤ ε / 4)
+    (hcore : {z : ℂ | 0 ≤ z.re ∧ z.re ≤ 2 ∧ |z.im| ≤ ε / 4} ⊆ interior K)
+    (hshape : ∀ n, EqOn (fun t => αₙ n t - γₙ n (T n))
+      (fun t => Qₙ n (guideCoordinate 0 (xₙ n) t)) (Icc 0 2))
+    (hangle : ∀ n, s ≤ (G n (T n) (αₙ n (1 / 2)) - (U n (T n) : ℂ)).im /
+      ‖G n (T n) (αₙ n (1 / 2)) - (U n (T n) : ℂ)‖)
+    (v : ℕ → ℝ) (hv : ∀ n, 0 < v n) (hlim : Tendsto v atTop (𝓝 0)) :
+    ∃ (φ : ℕ → ℕ) (b : ℕ → ℝ) (Fb : ℕ → C(closedHalfPlane, ℂ)),
+      StrictMono φ ∧ (∀ n, 0 < b n) ∧
+      (∀ n (z : closedHalfPlane), z.1 ∈ upperHalfPlane → Fb n z =
+        normalizedInverse (F₀ (φ n) (T (φ n))) (U (φ n) (T (φ n))) (b n) z -
+          γₙ (φ n) (T (φ n))) ∧
+      let η := fun n ω => (finiteBoundaryPath (Fb n)
+        (sourceTracePath γ (fun ω => (hwbase ω).1) ω) : ℝ≥0 → ℂ)
+      ∃ c₁ q : ℝ, 0 < c₁ ∧ 0 < q ∧ ∀ᶠ n in atTop,
+        ENNReal.ofReal q ≤ P {ω |
+          ω ∈ FrontSuccess η (fun n => longitudinalCoordinate (Qₙ (φ n)) K 0)
+            (fun _ => 0) (fun n => physicalPassageRegion (Qₙ (φ n)) K C ε (ε / Lq))
+            (fun n => Qₙ (φ n) 1) (ε / Lq) n ∧
+          ENNReal.ofReal c₁ ≤ segmentSausageCharge κ (η n ω) 0
+            (frontTime (fun t => longitudinalCoordinate (Qₙ (φ n)) K 0 (η n ω t)) 1)
+            (v (φ n)) (physicalMiddleRegion (Qₙ (φ n)) K 0 ε)} := by
+  let ℱ := Filtration.natural B₀ (fun t => (hm t).stronglyMeasurable)
+  have hadapt := brownian_capacity_trace_adapted B₀ hm hc κ γ Gbase Fbase hwbase
+  have hγm (t : ℝ≥0) : Measurable (fun ω => γ ω t) :=
+    (hadapt t).mono (ℱ.le t) le_rfl
+  have hSLE : IsOrdinaryChordalSLE κ γ P :=
+    ⟨hγm, B₀, hB₀, Eventually.of_forall (fun ω => ⟨Gbase ω, Fbase ω, hwbase ω⟩)⟩
+  have hxin : ∀ n, xₙ n ∈ Icc (-ε / 4) (ε / 4) := by
+    intro n
+    have hh := abs_le.mp (hxₙ n)
+    constructor <;> linarith [hh.1, hh.2]
+  obtain ⟨x, hx, ψ, hψ, hxlim⟩ := isCompact_Icc.tendsto_subseq hxin
+  have hxabs : |x| ≤ ε / 4 := abs_le.mpr ⟨by linarith [hx.1], hx.2⟩
+  obtain ⟨Q, χ, hχ, hQconv, hQu, hQl, _⟩ := exists_bilip_uniform_subsequence
+    (fun n => Qₙ (ψ n)) K hK x₀ hx₀ C Lq Rq (fun n => hQupper (ψ n))
+    (fun n => hQlower (ψ n)) (fun n => hQtip (ψ n))
+  let ρ := ψ ∘ χ
+  obtain ⟨b, Fb, βₙ, θ, F, α, β, hb, hext, hβc, hβ0, hβHn, hbarα,
+      hθ, hF, hiF, hFne, homit, hFconv, hαconv, hβconv, _, _, hαclim, _,
+      hβlim0, hβlimc, hβlimi, hβlimH, hrel⟩ :=
+    recentered_actual_guide_compactness P κ hκ hκ8 γ hSLE hcompact hboundary
+      (fun n => U (ρ n)) (fun n => γₙ (ρ n)) (fun n => G (ρ n)) (fun n => F₀ (ρ n))
+      (fun n => hU (ρ n)) (fun n => hw (ρ n)) (fun n => T (ρ n)) (fun n => hT (ρ n))
+      (fun n => hfresh (ρ n)) (fun n => αₙ (ρ n)) Cg s c hCg hs hcpos
+      (fun n => hαL (ρ n)) (fun n => hα0 (ρ n))
+      (fun n => hchord (ρ n)) (fun n => hαD (ρ n))
+      (fun δ hδ hδ2 => by
+        obtain ⟨r, hr, hh⟩ := hclear δ hδ hδ2
+        exact ⟨r, hr, fun n => hh (ρ n)⟩)
+      (fun n => hangle (ρ n))
+  let φ := ρ ∘ θ
+  let b' := fun n => b (θ n)
+  let Fb' := fun n => Fb (θ n)
+  let Fn := fun n z => normalizedInverse (F₀ (φ n) (T (φ n)))
+    (U (φ n) (T (φ n))) (b' n) z - γₙ (φ n) (T (φ n))
+  let α' := fun n t => αₙ (φ n) t - γₙ (φ n) (T (φ n))
+  have hφ : StrictMono φ := (hψ.comp hχ).comp hθ
+  have hQconv' : TendstoUniformlyOn (fun n => Qₙ (φ n)) Q atTop K := by
+    intro u hu
+    exact hθ.tendsto_atTop.eventually (hQconv u hu)
+  have hguideK n t (ht : t ∈ Icc (0 : ℝ) 2) : guideCoordinate 0 (xₙ (φ n)) t ∈ K := by
+    apply interior_subset
+    apply hcore
+    exact ⟨by simpa using ht.1, by simpa using ht.2,
+      (guideCoordinate_im_bound ht.1).trans (hxₙ (φ n))⟩
+  have hshapeLim : EqOn α (fun t => Q (guideCoordinate 0 x t)) (Icc 0 2) :=
+    coordinate_guide_limit_identity (fun n => Qₙ (φ n)) Q K hK.isClosed hQu.continuousOn
+      hQconv' (fun n => xₙ (φ n)) x
+      (hxlim.comp (hχ.comp hθ).tendsto_atTop) α' α hαconv hguideK
+      (fun n => hshape (φ n))
+  have hmem t (ht : t ∈ Icc (0 : ℝ) (3 / 2)) : guideCoordinate 0 x t ∈ interior K := by
+    apply hcore
+    exact ⟨by simpa using ht.1, by simpa using ht.2.trans (by norm_num : (3 / 2 : ℝ) ≤ 2),
+      (guideCoordinate_im_bound ht.1).trans hxabs⟩
+  have hbase : (1 : ℂ) ∈ K := by
+    apply interior_subset
+    apply hcore
+    refine ⟨by norm_num, by norm_num, ?_⟩
+    simpa only [Complex.one_im, abs_zero] using (show 0 ≤ ε / 4 by positivity)
+  let Fbar := fun n z => if hz : z ∈ closedHalfPlane then (Fb' n ⟨z, hz⟩ : OnePoint ℂ)
+    else OnePoint.infty
+  have hbar n : ContinuousOn (Fbar n) closedHalfPlane := by
+    rw [continuousOn_iff_continuous_domRestrict]
+    convert OnePoint.continuous_coe.comp (Fb' n).continuous using 1
+    funext z
+    change (if hz : (z : ℂ) ∈ closedHalfPlane then (Fb' n ⟨z, hz⟩ : OnePoint ℂ)
+      else OnePoint.infty) = (Fb' n z : OnePoint ℂ)
+    rw [dite_eq_left z.2]
+  have hbarext n z (hz : z ∈ upperHalfPlane) : Fbar n z = (Fn n z : OnePoint ℂ) := by
+    have hz' : z ∈ closedHalfPlane := (show 0 < z.im from hz).le
+    dsimp only [Fbar]
+    rw [dite_eq_left hz']
+    exact congrArg (fun z : ℂ => (z : OnePoint ℂ)) (hext (θ n) ⟨z, hz'⟩ hz)
+  have hbarα' n t (ht : t ∈ Icc (0 : ℝ) 2) : Fbar n (βₙ (θ n) t) = (α' n t : OnePoint ℂ) := by
+    dsimp only [Fbar]
+    rw [dite_eq_left (show βₙ (θ n) t ∈ closedHalfPlane from hβHn (θ n) t ht)]
+    exact congrArg (fun z : ℂ => (z : OnePoint ℂ)) (hbarα (θ n) t ht _)
+  let gp := sourceTracePath γ (fun ω => (hwbase ω).1)
+  let η := fun n ω => (finiteBoundaryPath (Fb' n) (gp ω) : ℝ≥0 → ℂ)
+  have hηc n : ∀ᵐ ω ∂P, Continuous (η n ω) :=
+    Eventually.of_forall (fun ω => (finiteBoundaryPath (Fb' n) (gp ω)).continuous)
+  have hηbar n : ∀ᵐ ω ∂P, ∀ t, Fbar n (γ ω t) = (η n ω t : OnePoint ℂ) := by
+    apply Eventually.of_forall
+    intro ω t
+    have hh : ClosedPathProperty (gp ω) := fun t => (hwbase ω).2.2.1 t
+    dsimp only [η]
+    rw [finiteBoundaryPath_apply _ _ hh]
+    dsimp only [Fbar]
+    rw [dite_eq_left (show γ ω t ∈ closedHalfPlane from (hwbase ω).2.2.1 t)]
+    rfl
+  have hαL' n : LipschitzOnWith Cg (α' n) (Icc 0 2) := by
+    apply lipschitzOnWith_iff_dist_le_mul.mpr
+    intro u hu w hw'
+    simpa only [α', dist_sub_right] using (hαL (φ n)).dist_le_mul u hu w hw'
+  have hnorm n := normalized_capacity_charts (hw (φ n)) (T (φ n)) (b' n) (hb (θ n))
+  have hFn n : DifferentiableOn ℂ (Fn n) upperHalfPlane := (hnorm n).1.sub_const _
+  have hiFn n : InjOn (Fn n) upperHalfPlane := by
+    intro z hz w hw' he
+    exact (hnorm n).2.1 hz hw' (sub_left_inj.mp he)
+  obtain ⟨B, _, Tc, _, c₁, q, hc₁, hq, hprob⟩ := planar_coordinate_limit_passage
+    κ hκ hκ8 B₀ hB₀ hm hc γ Gbase Fbase hwbase hboundary.to_onePoint hsupport hplanar
+    (fun n => Qₙ (φ n)) Q K C Lq hC hLq (fun n => hQupper (φ n))
+    (fun n => hQlower (φ n)) hQconv' hQu.continuousOn hbase
+    Fn Fbar F hFn hiFn hbar hbarext hF hiF hFne hFconv
+    α' (fun n => βₙ (θ n)) α β Cg hαL' hαconv hαclim
+    (fun n => hβc (θ n)) (fun n => hβ0 (θ n)) (fun n => hβHn (θ n))
+    hbarα' hβconv hβlimc hβlim0 hβlimi hβlimH hrel homit x ε (ε / Lq)
+    (by linarith) (div_pos hε hLq) hshapeLim hmem
+    (fun n => v (φ n)) (fun n => hv (φ n)) (hlim.comp hφ.tendsto_atTop) η hηc hηbar
+  refine ⟨φ, b', Fb', hφ, (fun n => hb (θ n)), (fun n => hext (θ n)),
+    c₁, q, hc₁, hq, ?_⟩
+  filter_upwards [hprob] with n hn
+  apply hn.trans (measure_mono ?_)
+  rintro ω ⟨⟨hfinite, hhit, hbefore, hpath, hterminal⟩, hmass⟩
+  exact ⟨⟨hfinite, hhit, bot_le.trans_lt hbefore, hpath, hterminal⟩,
+    hmass.trans (segmentSausageCharge_mono κ (η n ω) bot_le le_rfl (v (φ n)) Subset.rfl)⟩
+
+end SLEExactGauge
+
+end
+
+end OAI

lean/OAI/Probability/SLE/Gauge/RestartDenseWeight.lean

@@ -1,83 +1,83 @@
-import OAI.Probability.SLE.Mass.RestartStoppedMass
-import OAI.Probability.SLE.Gauge.CanonicalDenseSections
-
-namespace OAI
-
-/-! A successful canonical dense section, multiplied by its exact centered
-weight, contributes to the actual physical stopped-mass event. This proves
-the pointwise density domination needed in conditional section integration. -/
-
-noncomputable section
-open Set Filter MeasureTheory ProbabilityTheory Metric
-open scoped Topology NNReal ENNReal
-
-namespace SLEExactGauge
-open FrontSuccessMeasurability
-
-local instance denseWeightRealMeasurable : MeasurableSpace C(ℝ≥0, ℝ) := borel _
-local instance denseWeightRealBorel : BorelSpace C(ℝ≥0, ℝ) := ⟨rfl⟩
-local instance denseWeightComplexMeasurable : MeasurableSpace C(ℝ≥0, ℂ) := borel _
-local instance denseWeightComplexBorel : BorelSpace C(ℝ≥0, ℂ) := ⟨rfl⟩
-
-lemma IsCapacityTwoWitness.normalized_restart_dense_weight_le
-    {U : ℝ≥0 → ℝ} {γ : ℝ≥0 → ℂ} {G F G' F' : ℝ≥0 → ℂ → ℂ}
-    (hw : IsCapacityTwoWitness U γ G F) (hU : Continuous U) (T a : ℝ≥0) (ha : 0 < a)
-    (κ : ℝ) (Φ : C(ℝ≥0, ℝ) → C(ℝ≥0, ℂ)) (p : C(ℝ≥0, ℝ))
-    (hb : IsCapacityTwoWitness (normalizedRestartDriver U T a) (Φ p) G' F')
-    (hdriver : (fun t => Real.sqrt κ * p t) = normalizedRestartDriver U T a)
-    (w : ℂ) (hwH : w ∈ upperHalfPlane) (u q : ℝ) (hq : 0 ≤ q)
-    (hbase : fullRadius G T (F T ((a : ℂ) * w + (U T : ℂ))) =
-      (2 * (F T ((a : ℂ) * w + (U T : ℂ))).im) * Real.exp (-u))
-    (Fb : C(closedHalfPlane, ℂ))
-    (hpath : ∀ t, finiteBoundaryPath Fb (Φ p) t = γ (T + a ^ 2 * t))
-    (b r v : ℝ) (m : ℕ) :
-    (canonicalDenseEvent κ Φ Fb q w b r m v (F T ((a : ℂ) * w + (U T : ℂ)))).indicator
-      (fun p => ENNReal.ofReal
-          (greenDensity κ U γ G T (F T ((a : ℂ) * w + (U T : ℂ))) /
-            initialGreen κ (F T ((a : ℂ) * w + (U T : ℂ)))) *
-        canonicalFiniteDensity κ (q, w, p)) p ≤
-      if ENNReal.ofReal (b * r ^ dimension κ * (m : ℝ) ^ codimension κ) ≤
-          stoppedWholeSausageCharge κ ⟨γ, hw.1⟩
-            (radiusLevelTime γ G (F T ((a : ℂ) * w + (U T : ℂ))) (u + q)) v
-            (closedBall (F T ((a : ℂ) * w + (U T : ℂ))) r) then
-        ENNReal.ofReal (stoppedGreen κ U γ G (F T ((a : ℂ) * w + (U T : ℂ))) (u + q) /
-          initialGreen κ (F T ((a : ℂ) * w + (U T : ℂ))))
-      else 0 := by
-  classical
-  have hb' : IsCapacityTwoWitness (fun t => Real.sqrt κ * p t) (Φ p) G' F' := hdriver ▸ hb
-  have hzH : (a : ℂ) * w + (U T : ℂ) ∈ upperHalfPlane := by
-    change 0 < ((a : ℂ) * w + (U T : ℂ)).im
-    simpa only [Complex.add_im, Complex.ofReal_im, add_zero, Complex.mul_im,
-      Complex.ofReal_re, zero_mul] using mul_pos (show 0 < (a : ℝ) from ha) hwH
-  have hphysH := (hw.2.2.2.2.2.2.1 T hzH).1.1
-  by_cases hC : p ∈ canonicalDenseEvent κ Φ Fb q w b r m v (F T ((a : ℂ) * w + (U T : ℂ)))
-  · rw [indicator_of_mem hC, canonicalFiniteDensity_eq κ p hb' q hq w]
-    by_cases hfinite : radiusLevelTime (Φ p) G' w q < ∞
-    · have hmass := hw.normalized_restart_stopped_mass_le hU T a ha hb w u q hbase
-        (finiteBoundaryPath Fb (Φ p)) hpath hfinite κ v
-        (closedBall (F T ((a : ℂ) * w + (U T : ℂ))) r)
-      have hcanon := canonicalRadiusLevel_eq κ p hb' q hq w
-      have hC' : ENNReal.ofReal (b * r ^ dimension κ * (m : ℝ) ^ codimension κ) ≤
-          stoppedWholeSausageCharge κ (finiteBoundaryPath Fb (Φ p))
-            (radiusLevelTime (Φ p) G' w q) v (closedBall (F T ((a : ℂ) * w + (U T : ℂ))) r) := by
-        simpa only [canonicalDenseEvent, mem_ofPred_eq, hcanon] using hC
-      rw [ite_eq_left (hC'.trans hmass)]
-      rw [hdriver, ← ENNReal.ofReal_mul
-        (div_nonneg (greenDensity_nonneg hw κ T _) (initialGreen_pos κ _ hphysH).le)]
-      apply ENNReal.ofReal_le_ofReal
-      have hbound := hw.normalized_restart_stopped_green_lower hU T a ha hb κ w hwH u q hbase
-      calc
-        _ = (greenDensity κ U γ G T (F T ((a : ℂ) * w + (U T : ℂ))) *
-          (stoppedGreen κ (normalizedRestartDriver U T a) (Φ p) G' w q / initialGreen κ w)) /
-          initialGreen κ (F T ((a : ℂ) * w + (U T : ℂ))) := by ring
-        _ ≤ _ := div_le_div_of_nonneg_right hbound (initialGreen_pos κ _ hphysH).le
-    · rw [hdriver, stoppedGreen, ite_eq_right hfinite, zero_div, ENNReal.ofReal_zero, mul_zero]
-      exact bot_le
-  · rw [indicator_of_notMem hC]
-    exact bot_le
-
-end SLEExactGauge
-
-end
-
-end OAI
+import OAI.Probability.SLE.Mass.RestartStoppedMass
+import OAI.Probability.SLE.Gauge.CanonicalDenseSections
+
+namespace OAI
+
+/-! A successful canonical dense section, multiplied by its exact centered
+weight, contributes to the actual physical stopped-mass event. This proves
+the pointwise density domination needed in conditional section integration. -/
+
+noncomputable section
+open Set Filter MeasureTheory ProbabilityTheory Metric
+open scoped Topology NNReal ENNReal
+
+namespace SLEExactGauge
+open FrontSuccessMeasurability
+
+local instance denseWeightRealMeasurable : MeasurableSpace C(ℝ≥0, ℝ) := borel _
+local instance denseWeightRealBorel : BorelSpace C(ℝ≥0, ℝ) := ⟨rfl⟩
+local instance denseWeightComplexMeasurable : MeasurableSpace C(ℝ≥0, ℂ) := borel _
+local instance denseWeightComplexBorel : BorelSpace C(ℝ≥0, ℂ) := ⟨rfl⟩
+
+lemma IsCapacityTwoWitness.normalized_restart_dense_weight_le
+    {U : ℝ≥0 → ℝ} {γ : ℝ≥0 → ℂ} {G F G' F' : ℝ≥0 → ℂ → ℂ}
+    (hw : IsCapacityTwoWitness U γ G F) (hU : Continuous U) (T a : ℝ≥0) (ha : 0 < a)
+    (κ : ℝ) (Φ : C(ℝ≥0, ℝ) → C(ℝ≥0, ℂ)) (p : C(ℝ≥0, ℝ))
+    (hb : IsCapacityTwoWitness (normalizedRestartDriver U T a) (Φ p) G' F')
+    (hdriver : (fun t => Real.sqrt κ * p t) = normalizedRestartDriver U T a)
+    (w : ℂ) (hwH : w ∈ upperHalfPlane) (u q : ℝ) (hq : 0 ≤ q)
+    (hbase : fullRadius G T (F T ((a : ℂ) * w + (U T : ℂ))) =
+      (2 * (F T ((a : ℂ) * w + (U T : ℂ))).im) * Real.exp (-u))
+    (Fb : C(closedHalfPlane, ℂ))
+    (hpath : ∀ t, finiteBoundaryPath Fb (Φ p) t = γ (T + a ^ 2 * t))
+    (b r v : ℝ) (m : ℕ) :
+    (canonicalDenseEvent κ Φ Fb q w b r m v (F T ((a : ℂ) * w + (U T : ℂ)))).indicator
+      (fun p => ENNReal.ofReal
+          (greenDensity κ U γ G T (F T ((a : ℂ) * w + (U T : ℂ))) /
+            initialGreen κ (F T ((a : ℂ) * w + (U T : ℂ)))) *
+        canonicalFiniteDensity κ (q, w, p)) p ≤
+      if ENNReal.ofReal (b * r ^ dimension κ * (m : ℝ) ^ codimension κ) ≤
+          stoppedWholeSausageCharge κ ⟨γ, hw.1⟩
+            (radiusLevelTime γ G (F T ((a : ℂ) * w + (U T : ℂ))) (u + q)) v
+            (closedBall (F T ((a : ℂ) * w + (U T : ℂ))) r) then
+        ENNReal.ofReal (stoppedGreen κ U γ G (F T ((a : ℂ) * w + (U T : ℂ))) (u + q) /
+          initialGreen κ (F T ((a : ℂ) * w + (U T : ℂ))))
+      else 0 := by
+  classical
+  have hb' : IsCapacityTwoWitness (fun t => Real.sqrt κ * p t) (Φ p) G' F' := hdriver ▸ hb
+  have hzH : (a : ℂ) * w + (U T : ℂ) ∈ upperHalfPlane := by
+    change 0 < ((a : ℂ) * w + (U T : ℂ)).im
+    simpa only [Complex.add_im, Complex.ofReal_im, add_zero, Complex.mul_im,
+      Complex.ofReal_re, zero_mul] using mul_pos (show 0 < (a : ℝ) from ha) hwH
+  have hphysH := (hw.2.2.2.2.2.2.1 T hzH).1.1
+  by_cases hC : p ∈ canonicalDenseEvent κ Φ Fb q w b r m v (F T ((a : ℂ) * w + (U T : ℂ)))
+  · rw [indicator_of_mem hC, canonicalFiniteDensity_eq κ p hb' q hq w]
+    by_cases hfinite : radiusLevelTime (Φ p) G' w q < ∞
+    · have hmass := hw.normalized_restart_stopped_mass_le hU T a ha hb w u q hbase
+        (finiteBoundaryPath Fb (Φ p)) hpath hfinite κ v
+        (closedBall (F T ((a : ℂ) * w + (U T : ℂ))) r)
+      have hcanon := canonicalRadiusLevel_eq κ p hb' q hq w
+      have hC' : ENNReal.ofReal (b * r ^ dimension κ * (m : ℝ) ^ codimension κ) ≤
+          stoppedWholeSausageCharge κ (finiteBoundaryPath Fb (Φ p))
+            (radiusLevelTime (Φ p) G' w q) v (closedBall (F T ((a : ℂ) * w + (U T : ℂ))) r) := by
+        simpa only [canonicalDenseEvent, mem_ofPred_eq, hcanon] using hC
+      rw [ite_eq_left (hC'.trans hmass)]
+      rw [hdriver, ← ENNReal.ofReal_mul
+        (div_nonneg (greenDensity_nonneg hw κ T _) (initialGreen_pos κ _ hphysH).le)]
+      apply ENNReal.ofReal_le_ofReal
+      have hbound := hw.normalized_restart_stopped_green_lower hU T a ha hb κ w hwH u q hbase
+      calc
+        _ = (greenDensity κ U γ G T (F T ((a : ℂ) * w + (U T : ℂ))) *
+          (stoppedGreen κ (normalizedRestartDriver U T a) (Φ p) G' w q / initialGreen κ w)) /
+          initialGreen κ (F T ((a : ℂ) * w + (U T : ℂ))) := by ring
+        _ ≤ _ := div_le_div_of_nonneg_right hbound (initialGreen_pos κ _ hphysH).le
+    · rw [hdriver, stoppedGreen, ite_eq_right hfinite, zero_div, ENNReal.ofReal_zero, mul_zero]
+      exact bot_le
+  · rw [indicator_of_notMem hC]
+    exact bot_le
+
+end SLEExactGauge
+
+end
+
+end OAI

lean/OAI/Probability/SLE/Gauge/RestrictedConformalSausage.lean

@@ -1,72 +1,72 @@
-import OAI.Probability.SLE.Gauge.ConformalSausageTransfer
-import OAI.Probability.SLE.Mass.StoppedConformalPassageMass
-
-namespace OAI
-
-/-! Area transport of the part of a stopped sausage in a prescribed
-region. Agreement of the physical trace with the conformal image is only
-needed at the nearby interior witnesses. -/
-
-noncomputable section
-open Set Filter MeasureTheory Metric
-open scoped Topology ENNReal NNReal
-
-namespace SLEExactGauge
-
-theorem restricted_segment_sausage_conformal_transfer
-    (κ : ℝ) (F F' : ℂ → ℂ) (γ η : ℝ≥0 → ℂ) (s t : ℝ≥0)
-    (D K R : Set ℂ) (hD : MeasurableSet D) (hDK : D ⊆ K) (hK : Convex ℝ K)
-    (hinj : InjOn F K) (hF : ∀ z ∈ K, HasDerivAt F (F' z) z)
-    {c v ell : ℝ} (hc : 0 ≤ c) (hv : 0 < v) (hell : 0 < ell)
-    (hlo : ∀ z ∈ D, c ≤ ‖F' z‖)
-    (C : ℝ≥0) (hup : ∀ z ∈ K, ‖F' z‖₊ ≤ C)
-    (hscale : (C : ℝ) * ell ≤ 1)
-    (hnear : ∀ z ∈ D, ∀ y : ℂ, dist z y < ell * v → y ∈ K)
-    (heq : ∀ u ∈ Icc s t, γ u ∈ K → η u = F (γ u))
-    (himage : F '' D ⊆ R) :
-    ENNReal.ofReal (c ^ 2 * ell ^ codimension κ) *
-        segmentSausageCharge κ γ s t (ell * v) D ≤
-      segmentSausageCharge κ η s t v R := by
-  have hLip : LipschitzOnWith C F K :=
-    hK.lipschitzOnWith_of_nnnorm_hasDerivWithin_le
-      (fun z hz => (hF z hz).hasDerivWithinAt) hup
-  apply normalized_conformal_area_lower
-    (hD.inter (source_sausage_isOpen γ s t (ell * v)).measurableSet)
-    (hinj.mono (inter_subset_left.trans hDK))
-    (fun z hz => hF z (hDK hz.1)) hc hv hell (fun z hz => hlo z hz.1)
-  rintro _ ⟨z, ⟨hzD, u, hu, hd⟩, rfl⟩
-  refine ⟨himage (mem_image_of_mem F hzD), u, hu, ?_⟩
-  have huK : γ u ∈ K := hnear z hzD (γ u) hd
-  rw [heq u hu huK]
-  have hdist := hLip.dist_le_mul z (hDK hzD) (γ u) huK
-  by_cases hC : C = 0
-  · have hdist0 : dist (F z) (F (γ u)) ≤ 0 := by
-      simpa only [hC, NNReal.coe_zero, zero_mul] using hdist
-    exact hdist0.trans_lt hv
-  · have hCp : 0 < (C : ℝ) := by exact_mod_cast (pos_iff_ne_zero.mpr hC)
-    calc
-      dist (F z) (F (γ u)) ≤ (C : ℝ) * dist z (γ u) := hdist
-      _ < (C : ℝ) * (ell * v) := mul_lt_mul_of_pos_left hd hCp
-      _ ≤ v := by nlinarith [mul_le_mul_of_nonneg_right hscale hv.le]
-
-lemma conformal_transfer_coefficient
-    (κ : ℝ) {c C a : ℝ} (hC : 0 < C) (ha : 0 < a) :
-    (c * a) ^ 2 * (1 / (C * a)) ^ codimension κ =
-      (c ^ 2 * (1 / C) ^ codimension κ) * a ^ dimension κ := by
-  have he : (1 / (C * a)) = (1 / C) * (1 / a) := by ring
-  rw [he, Real.mul_rpow (by positivity) (by positivity),
-    Real.div_rpow zero_le_one ha.le, Real.one_rpow]
-  calc
-    _ = (c ^ 2 * (1 / C) ^ codimension κ) * (a ^ 2 / a ^ codimension κ) := by ring
-    _ = _ := by
-      congr 1
-      rw [← Real.rpow_two, ← Real.rpow_sub ha]
-      congr 1
-      unfold codimension
-      ring
-
-end SLEExactGauge
-
-end
-
-end OAI
+import OAI.Probability.SLE.Gauge.ConformalSausageTransfer
+import OAI.Probability.SLE.Mass.StoppedConformalPassageMass
+
+namespace OAI
+
+/-! Area transport of the part of a stopped sausage in a prescribed
+region. Agreement of the physical trace with the conformal image is only
+needed at the nearby interior witnesses. -/
+
+noncomputable section
+open Set Filter MeasureTheory Metric
+open scoped Topology ENNReal NNReal
+
+namespace SLEExactGauge
+
+theorem restricted_segment_sausage_conformal_transfer
+    (κ : ℝ) (F F' : ℂ → ℂ) (γ η : ℝ≥0 → ℂ) (s t : ℝ≥0)
+    (D K R : Set ℂ) (hD : MeasurableSet D) (hDK : D ⊆ K) (hK : Convex ℝ K)
+    (hinj : InjOn F K) (hF : ∀ z ∈ K, HasDerivAt F (F' z) z)
+    {c v ell : ℝ} (hc : 0 ≤ c) (hv : 0 < v) (hell : 0 < ell)
+    (hlo : ∀ z ∈ D, c ≤ ‖F' z‖)
+    (C : ℝ≥0) (hup : ∀ z ∈ K, ‖F' z‖₊ ≤ C)
+    (hscale : (C : ℝ) * ell ≤ 1)
+    (hnear : ∀ z ∈ D, ∀ y : ℂ, dist z y < ell * v → y ∈ K)
+    (heq : ∀ u ∈ Icc s t, γ u ∈ K → η u = F (γ u))
+    (himage : F '' D ⊆ R) :
+    ENNReal.ofReal (c ^ 2 * ell ^ codimension κ) *
+        segmentSausageCharge κ γ s t (ell * v) D ≤
+      segmentSausageCharge κ η s t v R := by
+  have hLip : LipschitzOnWith C F K :=
+    hK.lipschitzOnWith_of_nnnorm_hasDerivWithin_le
+      (fun z hz => (hF z hz).hasDerivWithinAt) hup
+  apply normalized_conformal_area_lower
+    (hD.inter (source_sausage_isOpen γ s t (ell * v)).measurableSet)
+    (hinj.mono (inter_subset_left.trans hDK))
+    (fun z hz => hF z (hDK hz.1)) hc hv hell (fun z hz => hlo z hz.1)
+  rintro _ ⟨z, ⟨hzD, u, hu, hd⟩, rfl⟩
+  refine ⟨himage (mem_image_of_mem F hzD), u, hu, ?_⟩
+  have huK : γ u ∈ K := hnear z hzD (γ u) hd
+  rw [heq u hu huK]
+  have hdist := hLip.dist_le_mul z (hDK hzD) (γ u) huK
+  by_cases hC : C = 0
+  · have hdist0 : dist (F z) (F (γ u)) ≤ 0 := by
+      simpa only [hC, NNReal.coe_zero, zero_mul] using hdist
+    exact hdist0.trans_lt hv
+  · have hCp : 0 < (C : ℝ) := by exact_mod_cast (pos_iff_ne_zero.mpr hC)
+    calc
+      dist (F z) (F (γ u)) ≤ (C : ℝ) * dist z (γ u) := hdist
+      _ < (C : ℝ) * (ell * v) := mul_lt_mul_of_pos_left hd hCp
+      _ ≤ v := by nlinarith [mul_le_mul_of_nonneg_right hscale hv.le]
+
+lemma conformal_transfer_coefficient
+    (κ : ℝ) {c C a : ℝ} (hC : 0 < C) (ha : 0 < a) :
+    (c * a) ^ 2 * (1 / (C * a)) ^ codimension κ =
+      (c ^ 2 * (1 / C) ^ codimension κ) * a ^ dimension κ := by
+  have he : (1 / (C * a)) = (1 / C) * (1 / a) := by ring
+  rw [he, Real.mul_rpow (by positivity) (by positivity),
+    Real.div_rpow zero_le_one ha.le, Real.one_rpow]
+  calc
+    _ = (c ^ 2 * (1 / C) ^ codimension κ) * (a ^ 2 / a ^ codimension κ) := by ring
+    _ = _ := by
+      congr 1
+      rw [← Real.rpow_two, ← Real.rpow_sub ha]
+      congr 1
+      unfold codimension
+      ring
+
+end SLEExactGauge
+
+end
+
+end OAI

lean/OAI/Probability/SLE/Gauge/RetainedPassageExtraction.lean

@@ -1,88 +1,88 @@
-import OAI.Probability.SLE.Gauge.RibbonPassageMass
-import OAI.Probability.SLE.Gauge.ConformalCompactSausage
-
-namespace OAI
-
-/-! Countable-to-finite retention in the ribbon passage argument. The loss
-is bounded for every varying early-containment event by the same discarded
-set. Sausage exceptions are subtracted unconditionally. -/
-
-noncomputable section
-open Set Filter MeasureTheory
-open scoped Topology ENNReal NNReal
-
-namespace SLEExactGauge
-
-theorem finite_retention_of_countable_cover
-    {Ω : Type*} [MeasurableSpace Ω] (P : Measure Ω) [IsFiniteMeasure P]
-    (E : Set Ω) (D : ℕ → Set Ω)
-    (hE : MeasurableSet E) (hD : ∀ i, MeasurableSet (D i))
-    (hcover : P (E \ ⋃ i, D i) = 0)
-    (ε : ℝ≥0∞) (hε : 0 < ε) :
-    ∃ N : ℕ, P (E \ ⋃ i ∈ Finset.range N, D i) < ε := by
-  let S : ℕ → Set Ω := fun n => E \ ⋃ i ∈ Finset.range n, D i
-  have hSm : ∀ n, MeasurableSet (S n) := fun n =>
-    hE.diff ((Finset.range n).measurableSet_biUnion (fun i _ => hD i))
-  have hSa : Antitone S := by
-    intro n k hnk ω hω
-    refine ⟨hω.1, ?_⟩
-    intro hn
-    obtain ⟨i, hi, hDi⟩ := mem_iUnion₂.mp hn
-    exact hω.2 (mem_iUnion₂.mpr ⟨i, Finset.range_mono hnk hi, hDi⟩)
-  have hi : ⋂ n, S n = E \ ⋃ i, D i := by
-    ext ω
-    constructor
-    · intro h
-      refine ⟨(mem_iInter.mp h 0).1, ?_⟩
-      intro hω
-      obtain ⟨i, hi⟩ := mem_iUnion.mp hω
-      exact (mem_iInter.mp h (i + 1)).2
-        (mem_iUnion₂.mpr ⟨i, Finset.mem_range.mpr (Nat.lt_succ_self i), hi⟩)
-    · rintro ⟨hEω, hω⟩
-      apply mem_iInter.mpr
-      intro n
-      refine ⟨hEω, ?_⟩
-      intro hn
-      obtain ⟨i, _, hi⟩ := mem_iUnion₂.mp hn
-      exact hω (mem_iUnion.mpr ⟨i, hi⟩)
-  have ht : Tendsto (fun n => P (S n)) atTop (𝓝 0) := by
-    simpa only [Function.comp_def, hi, hcover] using
-      tendsto_measure_iInter_atTop (fun n => (hSm n).nullMeasurableSet)
-        hSa ⟨0, measure_ne_top P _⟩
-  exact (ht.eventually (gt_mem_nhds hε)).exists
-
-/-- Discarding one small set preserves a fixed fraction of every member
-of a varying family; no independence is involved. -/
-theorem varying_events_after_finite_retention
-    {Ω : Type*} [MeasurableSpace Ω] (P : Measure Ω) [IsFiniteMeasure P]
-    (E : Set Ω) (D : ℕ → Set Ω) (G : ℕ → Set Ω)
-    (hE : MeasurableSet E) (hD : ∀ i, MeasurableSet (D i))
-    (hcover : P (E \ ⋃ i, D i) = 0)
-    (q : ℝ) (hq : 0 < q)
-    (hG : ∀ n, ENNReal.ofReal q ≤ P (G n ∩ E)) :
-    ∃ N : ℕ, ∀ n, ENNReal.ofReal (q / 2) ≤
-      P (G n ∩ E ∩ ⋃ i ∈ Finset.range N, D i) := by
-  obtain ⟨N, hN⟩ := finite_retention_of_countable_cover P E D hE hD hcover
-    (ENNReal.ofReal (q / 2)) (ENNReal.ofReal_pos.mpr (by positivity))
-  refine ⟨N, fun n => ?_⟩
-  let R := ⋃ i ∈ Finset.range N, D i
-  have hsub : G n ∩ E ⊆ (G n ∩ E ∩ R) ∪ (E \ R) := by
-    intro ω hω
-    by_cases hR : ω ∈ R
-    · exact Or.inl ⟨hω, hR⟩
-    · exact Or.inr ⟨hω.2, hR⟩
-  have hbound : ENNReal.ofReal q ≤ P (G n ∩ E ∩ R) + P (E \ R) :=
-    (hG n).trans ((measure_mono hsub).trans (measure_union_le _ _))
-  by_contra h
-  have hhalf : ENNReal.ofReal (q / 2) + ENNReal.ofReal (q / 2) =
-      ENNReal.ofReal q := by
-    rw [← ENNReal.ofReal_add (by positivity) (by positivity)]
-    congr 1
-    ring
-  exact (not_lt_of_ge hbound) (hhalf ▸ ENNReal.add_lt_add (lt_of_not_ge h) hN)
-
-end SLEExactGauge
-
-end
-
-end OAI
+import OAI.Probability.SLE.Gauge.RibbonPassageMass
+import OAI.Probability.SLE.Gauge.ConformalCompactSausage
+
+namespace OAI
+
+/-! Countable-to-finite retention in the ribbon passage argument. The loss
+is bounded for every varying early-containment event by the same discarded
+set. Sausage exceptions are subtracted unconditionally. -/
+
+noncomputable section
+open Set Filter MeasureTheory
+open scoped Topology ENNReal NNReal
+
+namespace SLEExactGauge
+
+theorem finite_retention_of_countable_cover
+    {Ω : Type*} [MeasurableSpace Ω] (P : Measure Ω) [IsFiniteMeasure P]
+    (E : Set Ω) (D : ℕ → Set Ω)
+    (hE : MeasurableSet E) (hD : ∀ i, MeasurableSet (D i))
+    (hcover : P (E \ ⋃ i, D i) = 0)
+    (ε : ℝ≥0∞) (hε : 0 < ε) :
+    ∃ N : ℕ, P (E \ ⋃ i ∈ Finset.range N, D i) < ε := by
+  let S : ℕ → Set Ω := fun n => E \ ⋃ i ∈ Finset.range n, D i
+  have hSm : ∀ n, MeasurableSet (S n) := fun n =>
+    hE.diff ((Finset.range n).measurableSet_biUnion (fun i _ => hD i))
+  have hSa : Antitone S := by
+    intro n k hnk ω hω
+    refine ⟨hω.1, ?_⟩
+    intro hn
+    obtain ⟨i, hi, hDi⟩ := mem_iUnion₂.mp hn
+    exact hω.2 (mem_iUnion₂.mpr ⟨i, Finset.range_mono hnk hi, hDi⟩)
+  have hi : ⋂ n, S n = E \ ⋃ i, D i := by
+    ext ω
+    constructor
+    · intro h
+      refine ⟨(mem_iInter.mp h 0).1, ?_⟩
+      intro hω
+      obtain ⟨i, hi⟩ := mem_iUnion.mp hω
+      exact (mem_iInter.mp h (i + 1)).2
+        (mem_iUnion₂.mpr ⟨i, Finset.mem_range.mpr (Nat.lt_succ_self i), hi⟩)
+    · rintro ⟨hEω, hω⟩
+      apply mem_iInter.mpr
+      intro n
+      refine ⟨hEω, ?_⟩
+      intro hn
+      obtain ⟨i, _, hi⟩ := mem_iUnion₂.mp hn
+      exact hω (mem_iUnion.mpr ⟨i, hi⟩)
+  have ht : Tendsto (fun n => P (S n)) atTop (𝓝 0) := by
+    simpa only [Function.comp_def, hi, hcover] using
+      tendsto_measure_iInter_atTop (fun n => (hSm n).nullMeasurableSet)
+        hSa ⟨0, measure_ne_top P _⟩
+  exact (ht.eventually (gt_mem_nhds hε)).exists
+
+/-- Discarding one small set preserves a fixed fraction of every member
+of a varying family; no independence is involved. -/
+theorem varying_events_after_finite_retention
+    {Ω : Type*} [MeasurableSpace Ω] (P : Measure Ω) [IsFiniteMeasure P]
+    (E : Set Ω) (D : ℕ → Set Ω) (G : ℕ → Set Ω)
+    (hE : MeasurableSet E) (hD : ∀ i, MeasurableSet (D i))
+    (hcover : P (E \ ⋃ i, D i) = 0)
+    (q : ℝ) (hq : 0 < q)
+    (hG : ∀ n, ENNReal.ofReal q ≤ P (G n ∩ E)) :
+    ∃ N : ℕ, ∀ n, ENNReal.ofReal (q / 2) ≤
+      P (G n ∩ E ∩ ⋃ i ∈ Finset.range N, D i) := by
+  obtain ⟨N, hN⟩ := finite_retention_of_countable_cover P E D hE hD hcover
+    (ENNReal.ofReal (q / 2)) (ENNReal.ofReal_pos.mpr (by positivity))
+  refine ⟨N, fun n => ?_⟩
+  let R := ⋃ i ∈ Finset.range N, D i
+  have hsub : G n ∩ E ⊆ (G n ∩ E ∩ R) ∪ (E \ R) := by
+    intro ω hω
+    by_cases hR : ω ∈ R
+    · exact Or.inl ⟨hω, hR⟩
+    · exact Or.inr ⟨hω.2, hR⟩
+  have hbound : ENNReal.ofReal q ≤ P (G n ∩ E ∩ R) + P (E \ R) :=
+    (hG n).trans ((measure_mono hsub).trans (measure_union_le _ _))
+  by_contra h
+  have hhalf : ENNReal.ofReal (q / 2) + ENNReal.ofReal (q / 2) =
+      ENNReal.ofReal q := by
+    rw [← ENNReal.ofReal_add (by positivity) (by positivity)]
+    congr 1
+    ring
+  exact (not_lt_of_ge hbound) (hhalf ▸ ENNReal.add_lt_add (lt_of_not_ge h) hN)
+
+end SLEExactGauge
+
+end
+
+end OAI

lean/OAI/Probability/SLE/Gauge/RetainedRegionMargins.lean

@@ -1,191 +1,191 @@
-import OAI.Probability.SLE.Gauge.RetainedTubeSausage
-
-namespace OAI
-
-/-! Physical middle-strip margins are chosen separately for each retained
-compact set. A finite probability retention then permits their finite union;
-no inclusion of the entire limiting open strip in every moving strip is used. -/
-
-noncomputable section
-open Set Filter MeasureTheory Metric
-open scoped Topology NNReal ENNReal
-
-namespace SLEExactGauge.RetainedTubeSausage
-
-/-- Each compact subset of the limiting middle strip has one open physical
-neighborhood lying in every sufficiently late moving middle strip. -/
-theorem eventual_middle_neighborhood
-    (pₙ : ℕ → ℂ → ℝ) (p : ℂ → ℝ) (U : Set ℂ) (hU : IsOpen U)
-    (hp : ContinuousOn p U) (hconv : TendstoLocallyUniformlyOn pₙ p atTop U)
-    (K : Set ℂ) (hK : IsCompact K)
-    (hband : K ⊆ U ∩ {z | (1 / 3 : ℝ) < p z ∧ p z < 2 / 3}) :
-    ∃ R : Set ℂ, IsOpen R ∧ K ⊆ R ∧
-      ∀ᶠ n in atTop, R ⊆ U ∩ {z | (1 / 3 : ℝ) < pₙ n z ∧ pₙ n z < 2 / 3} := by
-  let V := U ∩ p ⁻¹' Ioo (1 / 3 : ℝ) (2 / 3)
-  have hV : IsOpen V := hp.isOpen_inter_preimage hU isOpen_Ioo
-  obtain ⟨δ, hδ, hthick⟩ := hK.exists_cthickening_subset_open hV hband
-  let C := cthickening δ K
-  let R := thickening δ K
-  have hC : IsCompact C := hK.cthickening
-  have hCU : C ⊆ U := hthick.trans inter_subset_left
-  have hCR : R ⊆ C := thickening_subset_cthickening δ K
-  have hpC : IsCompact (p '' C) := hC.image_of_continuousOn (hp.mono hCU)
-  have hpband : p '' C ⊆ Ioo (1 / 3 : ℝ) (2 / 3) := by
-    rintro _ ⟨z, hz, rfl⟩
-    exact (hthick hz).2
-  obtain ⟨ε, hε, heps⟩ := hpC.exists_thickening_subset_open isOpen_Ioo hpband
-  have hu : TendstoUniformlyOn pₙ p atTop C :=
-    (tendstoLocallyUniformlyOn_iff_tendstoUniformlyOn_of_compact hC).mp (hconv.mono hCU)
-  refine ⟨R, isOpen_thickening, self_subset_thickening hδ K, ?_⟩
-  filter_upwards [hu _ (Metric.dist_mem_uniformity hε)] with n hn
-  intro z hz
-  have hzC := hCR hz
-  refine ⟨hCU hzC, heps ?_⟩
-  exact mem_thickening_iff.mpr ⟨p z, mem_image_of_mem p hzC,
-    by simpa only [dist_comm] using hn z hzC⟩
-
-/-- Finite retention permits compact-dependent physical neighborhoods. -/
-theorem countable_stopped_mass_ae_window_compact_regions
-    {Ω : 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 : ∀ i, IsOpen (R i)) (himage : ∀ i, F '' K i ⊆ R i)
-    (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 : ∀ i, ∀ᶠ n in atTop, R i ⊆ Rₙ n)
-    (G : ℕ → Set Ω) (q : ℝ) (hq : 0 < q)
-    (hG : ∀ᶠ n in atTop, ENNReal.ofReal q ≤ P (G n ∩ E))
-    (hwindow : ∀ i, ∀ᶠ n in atTop, ∀ᵐ ω ∂P, ω ∈ 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, hsmall⟩ := finite_retention_of_countable_cover P E D hE hD hcover
-    (ENNReal.ofReal (q / 2)) (ENNReal.ofReal_pos.mpr (by positivity))
-  have hN : ∀ᶠ n in atTop, ENNReal.ofReal (q / 2) ≤
-      P (G n ∩ E ∩ ⋃ i ∈ Finset.range N, D i) := by
-    filter_upwards [hG] with n hn
-    let A := ⋃ i ∈ Finset.range N, D i
-    have hsub : G n ∩ E ⊆ (G n ∩ E ∩ A) ∪ (E \ A) := by
-      intro ω hω
-      by_cases hA : ω ∈ A
-      · exact Or.inl ⟨hω, hA⟩
-      · exact Or.inr ⟨hω.2, hA⟩
-    have hb := hn.trans ((measure_mono hsub).trans (measure_union_le _ _))
-    by_contra h
-    have he : ENNReal.ofReal (q / 2) + ENNReal.ofReal (q / 2) =
-        ENNReal.ofReal q := by
-      rw [← ENNReal.ofReal_add (by positivity) (by positivity)]
-      congr 1
-      ring
-    exact (not_lt_of_ge hb) (he ▸ ENNReal.add_lt_add (lt_of_not_ge h) hsmall)
-  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
-  let R₀ : Set ℂ := ⋃ i ∈ Finset.range N, R i
-  have hR₀ : IsOpen R₀ := isOpen_iUnion fun i => isOpen_iUnion fun _ => hR i
-  have hregion₀ : ∀ᶠ n in atTop, R₀ ⊆ Rₙ n := by
-    have hf := (Finset.eventually_all (Finset.range N)).mpr (fun i _ => hregion i)
-    filter_upwards [hf] with n hn
-    exact iUnion₂_subset (fun i hi => hn i hi)
-  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, hiN, hi⟩ := mem_iUnion₂.mp hz
-    exact mem_iUnion₂.mpr ⟨i, hiN, himage i (mem_image_of_mem F hi)⟩
-  have hQn : Q.Nonempty := by
-    obtain ⟨n, hn⟩ := hN.exists
-    have hHpos : 0 < P (H n) :=
-      (ENNReal.ofReal_pos.mpr (by positivity : 0 < q / 2)).trans_le hn
-    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, ∀ᵐ ω ∂P, ω ∈ 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, ∀ᵐ ω ∂P, ω ∈ 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
-    filter_upwards [(Finset.eventually_all _).mpr hn] with ω hω
-    intro hH
-    obtain ⟨i, hi, hDi⟩ := mem_iUnion₂.mp hH.2
-    exact ⟨J i, Finset.mem_image.mpr ⟨i, hi, rfl⟩,
-      (hretain i ω hDi).trans (subset_iUnion₂_of_subset i hi Subset.rfl),
-      hω i hi ⟨hH.1, hDi⟩⟩
-  obtain ⟨a, ha, hmass⟩ := compact_conformal_stopped_passage_mass_ae 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) 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⟩))
-
-/-- Local coordinate convergence supplies the compact-dependent physical
-margins needed by the retained stopped-mass theorem. -/
-theorem countable_stopped_mass_ae_window_middle_regions
-    {Ω : 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)
-    (pₙ : ℕ → ℂ → ℝ) (p : ℂ → ℝ) (U : Set ℂ) (hU : IsOpen U)
-    (hp : ContinuousOn p U) (hpconv : TendstoLocallyUniformlyOn pₙ p atTop U)
-    (himage : ∀ i, F '' K i ⊆ U ∩ {z | (1 / 3 : ℝ) < p z ∧ p z < 2 / 3})
-    (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, U ∩ {z | (1 / 3 : ℝ) < pₙ n z ∧ pₙ n z < 2 / 3} ⊆ Rₙ n)
-    (G : ℕ → Set Ω) (q : ℝ) (hq : 0 < q)
-    (hG : ∀ᶠ n in atTop, ENNReal.ofReal q ≤ P (G n ∩ E))
-    (hwindow : ∀ i, ∀ᶠ n in atTop, ∀ᵐ ω ∂P, ω ∈ 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
-  have hneighborhood (i : ℕ) := eventual_middle_neighborhood pₙ p U hU hp hpconv
-    (F '' K i) ((hK i).image_of_continuousOn (hF.continuousOn.mono (hKH i))) (himage i)
-  choose R hR himageR hRlate using hneighborhood
-  apply countable_stopped_mass_ae_window_compact_regions P κ hκ hκ8 γ hSLE
-    Fₙ F hFn hinj hF hne hconv K hK hKH R hR himageR J hJ E D hE hD hcover hretain
-    v hv hlim η s t Rₙ ?_ G q hq hG hwindow
-  intro i
-  filter_upwards [hRlate i, hregion] with n hn htarget
-  exact hn.trans htarget
-
-end SLEExactGauge.RetainedTubeSausage
-
-end
-
-end OAI
+import OAI.Probability.SLE.Gauge.RetainedTubeSausage
+
+namespace OAI
+
+/-! Physical middle-strip margins are chosen separately for each retained
+compact set. A finite probability retention then permits their finite union;
+no inclusion of the entire limiting open strip in every moving strip is used. -/
+
+noncomputable section
+open Set Filter MeasureTheory Metric
+open scoped Topology NNReal ENNReal
+
+namespace SLEExactGauge.RetainedTubeSausage
+
+/-- Each compact subset of the limiting middle strip has one open physical
+neighborhood lying in every sufficiently late moving middle strip. -/
+theorem eventual_middle_neighborhood
+    (pₙ : ℕ → ℂ → ℝ) (p : ℂ → ℝ) (U : Set ℂ) (hU : IsOpen U)
+    (hp : ContinuousOn p U) (hconv : TendstoLocallyUniformlyOn pₙ p atTop U)
+    (K : Set ℂ) (hK : IsCompact K)
+    (hband : K ⊆ U ∩ {z | (1 / 3 : ℝ) < p z ∧ p z < 2 / 3}) :
+    ∃ R : Set ℂ, IsOpen R ∧ K ⊆ R ∧
+      ∀ᶠ n in atTop, R ⊆ U ∩ {z | (1 / 3 : ℝ) < pₙ n z ∧ pₙ n z < 2 / 3} := by
+  let V := U ∩ p ⁻¹' Ioo (1 / 3 : ℝ) (2 / 3)
+  have hV : IsOpen V := hp.isOpen_inter_preimage hU isOpen_Ioo
+  obtain ⟨δ, hδ, hthick⟩ := hK.exists_cthickening_subset_open hV hband
+  let C := cthickening δ K
+  let R := thickening δ K
+  have hC : IsCompact C := hK.cthickening
+  have hCU : C ⊆ U := hthick.trans inter_subset_left
+  have hCR : R ⊆ C := thickening_subset_cthickening δ K
+  have hpC : IsCompact (p '' C) := hC.image_of_continuousOn (hp.mono hCU)
+  have hpband : p '' C ⊆ Ioo (1 / 3 : ℝ) (2 / 3) := by
+    rintro _ ⟨z, hz, rfl⟩
+    exact (hthick hz).2
+  obtain ⟨ε, hε, heps⟩ := hpC.exists_thickening_subset_open isOpen_Ioo hpband
+  have hu : TendstoUniformlyOn pₙ p atTop C :=
+    (tendstoLocallyUniformlyOn_iff_tendstoUniformlyOn_of_compact hC).mp (hconv.mono hCU)
+  refine ⟨R, isOpen_thickening, self_subset_thickening hδ K, ?_⟩
+  filter_upwards [hu _ (Metric.dist_mem_uniformity hε)] with n hn
+  intro z hz
+  have hzC := hCR hz
+  refine ⟨hCU hzC, heps ?_⟩
+  exact mem_thickening_iff.mpr ⟨p z, mem_image_of_mem p hzC,
+    by simpa only [dist_comm] using hn z hzC⟩
+
+/-- Finite retention permits compact-dependent physical neighborhoods. -/
+theorem countable_stopped_mass_ae_window_compact_regions
+    {Ω : 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 : ∀ i, IsOpen (R i)) (himage : ∀ i, F '' K i ⊆ R i)
+    (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 : ∀ i, ∀ᶠ n in atTop, R i ⊆ Rₙ n)
+    (G : ℕ → Set Ω) (q : ℝ) (hq : 0 < q)
+    (hG : ∀ᶠ n in atTop, ENNReal.ofReal q ≤ P (G n ∩ E))
+    (hwindow : ∀ i, ∀ᶠ n in atTop, ∀ᵐ ω ∂P, ω ∈ 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, hsmall⟩ := finite_retention_of_countable_cover P E D hE hD hcover
+    (ENNReal.ofReal (q / 2)) (ENNReal.ofReal_pos.mpr (by positivity))
+  have hN : ∀ᶠ n in atTop, ENNReal.ofReal (q / 2) ≤
+      P (G n ∩ E ∩ ⋃ i ∈ Finset.range N, D i) := by
+    filter_upwards [hG] with n hn
+    let A := ⋃ i ∈ Finset.range N, D i
+    have hsub : G n ∩ E ⊆ (G n ∩ E ∩ A) ∪ (E \ A) := by
+      intro ω hω
+      by_cases hA : ω ∈ A
+      · exact Or.inl ⟨hω, hA⟩
+      · exact Or.inr ⟨hω.2, hA⟩
+    have hb := hn.trans ((measure_mono hsub).trans (measure_union_le _ _))
+    by_contra h
+    have he : ENNReal.ofReal (q / 2) + ENNReal.ofReal (q / 2) =
+        ENNReal.ofReal q := by
+      rw [← ENNReal.ofReal_add (by positivity) (by positivity)]
+      congr 1
+      ring
+    exact (not_lt_of_ge hb) (he ▸ ENNReal.add_lt_add (lt_of_not_ge h) hsmall)
+  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
+  let R₀ : Set ℂ := ⋃ i ∈ Finset.range N, R i
+  have hR₀ : IsOpen R₀ := isOpen_iUnion fun i => isOpen_iUnion fun _ => hR i
+  have hregion₀ : ∀ᶠ n in atTop, R₀ ⊆ Rₙ n := by
+    have hf := (Finset.eventually_all (Finset.range N)).mpr (fun i _ => hregion i)
+    filter_upwards [hf] with n hn
+    exact iUnion₂_subset (fun i hi => hn i hi)
+  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, hiN, hi⟩ := mem_iUnion₂.mp hz
+    exact mem_iUnion₂.mpr ⟨i, hiN, himage i (mem_image_of_mem F hi)⟩
+  have hQn : Q.Nonempty := by
+    obtain ⟨n, hn⟩ := hN.exists
+    have hHpos : 0 < P (H n) :=
+      (ENNReal.ofReal_pos.mpr (by positivity : 0 < q / 2)).trans_le hn
+    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, ∀ᵐ ω ∂P, ω ∈ 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, ∀ᵐ ω ∂P, ω ∈ 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
+    filter_upwards [(Finset.eventually_all _).mpr hn] with ω hω
+    intro hH
+    obtain ⟨i, hi, hDi⟩ := mem_iUnion₂.mp hH.2
+    exact ⟨J i, Finset.mem_image.mpr ⟨i, hi, rfl⟩,
+      (hretain i ω hDi).trans (subset_iUnion₂_of_subset i hi Subset.rfl),
+      hω i hi ⟨hH.1, hDi⟩⟩
+  obtain ⟨a, ha, hmass⟩ := compact_conformal_stopped_passage_mass_ae 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) 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⟩))
+
+/-- Local coordinate convergence supplies the compact-dependent physical
+margins needed by the retained stopped-mass theorem. -/
+theorem countable_stopped_mass_ae_window_middle_regions
+    {Ω : 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)
+    (pₙ : ℕ → ℂ → ℝ) (p : ℂ → ℝ) (U : Set ℂ) (hU : IsOpen U)
+    (hp : ContinuousOn p U) (hpconv : TendstoLocallyUniformlyOn pₙ p atTop U)
+    (himage : ∀ i, F '' K i ⊆ U ∩ {z | (1 / 3 : ℝ) < p z ∧ p z < 2 / 3})
+    (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, U ∩ {z | (1 / 3 : ℝ) < pₙ n z ∧ pₙ n z < 2 / 3} ⊆ Rₙ n)
+    (G : ℕ → Set Ω) (q : ℝ) (hq : 0 < q)
+    (hG : ∀ᶠ n in atTop, ENNReal.ofReal q ≤ P (G n ∩ E))
+    (hwindow : ∀ i, ∀ᶠ n in atTop, ∀ᵐ ω ∂P, ω ∈ 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
+  have hneighborhood (i : ℕ) := eventual_middle_neighborhood pₙ p U hU hp hpconv
+    (F '' K i) ((hK i).image_of_continuousOn (hF.continuousOn.mono (hKH i))) (himage i)
+  choose R hR himageR hRlate using hneighborhood
+  apply countable_stopped_mass_ae_window_compact_regions P κ hκ hκ8 γ hSLE
+    Fₙ F hFn hinj hF hne hconv K hK hKH R hR himageR J hJ E D hE hD hcover hretain
+    v hv hlim η s t Rₙ ?_ G q hq hG hwindow
+  intro i
+  filter_upwards [hRlate i, hregion] with n hn htarget
+  exact hn.trans htarget
+
+end SLEExactGauge.RetainedTubeSausage
+
+end
+
+end OAI

lean/OAI/Probability/SLE/Gauge/RetainedTubeSausage.lean

@@ -1,416 +1,416 @@
-import OAI.Probability.SLE.Gauge.PassageRetention
-import OAI.Probability.SLE.Mass.StoppedConformalPassageMass
-
-namespace OAI
-
-/-! Actual open-tube passage certificates imply a positive stopped sausage
-mass. The retained time window is derived from the front coordinate, rather
-than supplied as a separate geometric hypothesis. -/
-
-noncomputable section
-open Set Filter MeasureTheory Metric
-open scoped Topology NNReal ENNReal
-
-namespace SLEExactGauge.RetainedTubeSausage
-open PassageRetention
-
-/-- Uniformly convergent physical coordinates preserve a strict front bound
-on each compact retained parameter set. -/
-theorem eventually_front_lt_on_compact
-    (Fₙ : ℕ → ℂ → ℂ) (F : ℂ → ℂ)
-    (hF : ContinuousOn F upperHalfPlane)
-    (hFconv : TendstoLocallyUniformlyOn Fₙ F atTop upperHalfPlane)
-    (pₙ : ℕ → ℂ → ℝ) (p : ℂ → ℝ) (U : Set ℂ) (hU : IsOpen U)
-    (hp : ContinuousOn p U) (hpconv : TendstoLocallyUniformlyOn pₙ p atTop U)
-    (K : Set ℂ) (hK : IsCompact K) (hKH : K ⊆ upperHalfPlane)
-    (hKU : F '' K ⊆ U) (q : ℝ) (hbound : ∀ z ∈ K, p (F z) < q) :
-    ∀ᶠ n in atTop, ∀ z ∈ K, pₙ n (Fₙ n z) < q := by
-  by_cases hKn : K.Nonempty
-  · let V := U ∩ p ⁻¹' Iio q
-    have hV : IsOpen V := hp.isOpen_inter_preimage hU isOpen_Iio
-    have hFK : IsCompact (F '' K) := hK.image_of_continuousOn (hF.mono hKH)
-    have hFKV : F '' K ⊆ V := by
-      rintro w ⟨z, hz, rfl⟩
-      exact ⟨hKU (mem_image_of_mem F hz), hbound z hz⟩
-    obtain ⟨δ, hδ, hthick⟩ := hFK.exists_cthickening_subset_open hV hFKV
-    let L := cthickening (δ / 2) (F '' K)
-    have hL : IsCompact L := hFK.cthickening
-    have hLV : L ⊆ V := (cthickening_mono (by linarith) (F '' K)).trans hthick
-    have hLn : L.Nonempty := (hKn.image F).mono (self_subset_cthickening _)
-    have hpL : ContinuousOn p L := hp.mono (hLV.trans inter_subset_left)
-    obtain ⟨z₀, hz₀, hmax⟩ := hL.exists_isMaxOn hLn hpL
-    have hz₀q : p z₀ < q := (hLV hz₀).2
-    have huF : TendstoUniformlyOn Fₙ F atTop K :=
-      (tendstoLocallyUniformlyOn_iff_tendstoUniformlyOn_of_compact hK).mp (hFconv.mono hKH)
-    have huP : TendstoUniformlyOn pₙ p atTop L :=
-      (tendstoLocallyUniformlyOn_iff_tendstoUniformlyOn_of_compact hL).mp
-        (hpconv.mono (hLV.trans inter_subset_left))
-    filter_upwards [huF _ (Metric.dist_mem_uniformity (by positivity : 0 < δ / 2)),
-      huP _ (Metric.dist_mem_uniformity (sub_pos.mpr hz₀q))] with n hnF hnP
-    intro z hz
-    have hzL : Fₙ n z ∈ L :=
-      mem_cthickening_of_dist_le _ (F z) (δ / 2) (F '' K)
-        (mem_image_of_mem F hz) (by simpa only [dist_comm] using (hnF z hz).le)
-    have hdiff := hnP (Fₙ n z) hzL
-    have hupper : p (Fₙ n z) ≤ p z₀ := hmax hzL
-    rw [Real.dist_eq] at hdiff
-    have hh := (abs_lt.mp hdiff).1
-    linarith
-  · have hKe : K = ∅ := not_nonempty_iff_eq_empty.mp hKn
-    simp only [hKe, mem_empty_iff_false, IsEmpty.forall_iff, implies_true,
-      eventually_true]
-
-/-- The countable stopped-mass reduction also permits almost-sure window
-and chart identities, as supplied by the actual boundary restart. -/
-theorem countable_stopped_mass_ae_window
-    {Ω : 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, ∀ᵐ ω ∂P, ω ∈ 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, ∀ᵐ ω ∂P, ω ∈ 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, ∀ᵐ ω ∂P, ω ∈ 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
-    filter_upwards [(Finset.eventually_all _).mpr hn] with ω hω
-    intro hH
-    obtain ⟨i, hi, hDi⟩ := mem_iUnion₂.mp hH.2
-    exact ⟨J i, Finset.mem_image.mpr ⟨i, hi, rfl⟩,
-      (hretain i ω hDi).trans (subset_iUnion₂_of_subset i hi Subset.rfl),
-      hω i hi ⟨hH.1, hDi⟩⟩
-  obtain ⟨a, ha, hmass⟩ := compact_conformal_stopped_passage_mass_ae 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⟩))
-
-/-- The countable stopped-mass reduction also permits almost-sure window
-and chart identities, as supplied by the actual boundary restart. -/
-theorem countable_stopped_mass_ae_window_eventually
-    {Ω : 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 in atTop, ENNReal.ofReal q ≤ P (G n ∩ E))
-    (hwindow : ∀ i, ∀ᶠ n in atTop, ∀ᵐ ω ∂P, ω ∈ 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, hsmall⟩ := finite_retention_of_countable_cover P E D hE hD hcover
-    (ENNReal.ofReal (q / 2)) (ENNReal.ofReal_pos.mpr (by positivity))
-  have hN : ∀ᶠ n in atTop, ENNReal.ofReal (q / 2) ≤
-      P (G n ∩ E ∩ ⋃ i ∈ Finset.range N, D i) := by
-    filter_upwards [hG] with n hn
-    let A := ⋃ i ∈ Finset.range N, D i
-    have hsub : G n ∩ E ⊆ (G n ∩ E ∩ A) ∪ (E \ A) := by
-      intro ω hω
-      by_cases hA : ω ∈ A
-      · exact Or.inl ⟨hω, hA⟩
-      · exact Or.inr ⟨hω.2, hA⟩
-    have hb := hn.trans ((measure_mono hsub).trans (measure_union_le _ _))
-    by_contra h
-    have he : ENNReal.ofReal (q / 2) + ENNReal.ofReal (q / 2) =
-        ENNReal.ofReal q := by
-      rw [← ENNReal.ofReal_add (by positivity) (by positivity)]
-      congr 1
-      ring
-    exact (not_lt_of_ge hb) (he ▸ ENNReal.add_lt_add (lt_of_not_ge h) hsmall)
-  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
-    obtain ⟨n, hn⟩ := hN.exists
-    have hHpos : 0 < P (H n) :=
-      (ENNReal.ofReal_pos.mpr (by positivity : 0 < q / 2)).trans_le hn
-    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, ∀ᵐ ω ∂P, ω ∈ 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, ∀ᵐ ω ∂P, ω ∈ 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
-    filter_upwards [(Finset.eventually_all _).mpr hn] with ω hω
-    intro hH
-    obtain ⟨i, hi, hDi⟩ := mem_iUnion₂.mp hH.2
-    exact ⟨J i, Finset.mem_image.mpr ⟨i, hi, rfl⟩,
-      (hretain i ω hDi).trans (subset_iUnion₂_of_subset i hi Subset.rfl),
-      hω i hi ⟨hH.1, hDi⟩⟩
-  obtain ⟨a, ha, hmass⟩ := compact_conformal_stopped_passage_mass_ae 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) 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⟩))
-
-/-- Actual tube passages produce retained sausage mass before the varying
-front stop. Compact intervals and stop windows are both derived here. -/
-theorem retained_tube_stopped_sausage_mass
-    {Ω : Type*} [MeasurableSpace Ω] (P : Measure Ω) [IsProbabilityMeasure P]
-    (κ : ℝ) (hκ : 0 < κ) (hκ8 : κ < 8)
-    (f : Ω → C(ℝ≥0, ℂ)) (hf : Measurable f)
-    (hSLE : IsOrdinaryChordalSLE κ (fun ω => f ω) P)
-    (σ : Ω → ℝ≥0) (hσ : Measurable σ)
-    (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)
-    (O W : Set ℂ) (hO : IsOpen O) (hOH : O ⊆ upperHalfPlane)
-    (pₙ : ℕ → ℂ → ℝ) (p : ℂ → ℝ) (U : Set ℂ) (hU : IsOpen U)
-    (hp : ContinuousOn p U) (hpconv : TendstoLocallyUniformlyOn pₙ p atTop U)
-    (hFOU : MapsTo F O U) (hW : W ⊆ {z | 1 < p (F z)})
-    (E : Set Ω) (hE : MeasurableSet E)
-    (htube : E ⊆ stoppedPhysicalTube (fun ω => f ω) σ O W)
-    (hstart : ∀ ω ∈ E, p (F (f ω (σ ω))) < 1 / 3)
-    (R : Set ℂ) (hR : IsOpen R)
-    (hmiddle : ∀ z ∈ O, 1 / 3 < p (F z) → p (F z) < 2 / 3 → F z ∈ R)
-    (v : ℕ → ℝ) (hv : ∀ n, 0 < v n) (hlim : Tendsto v atTop (𝓝 0))
-    (η : ℕ → Ω → ℝ≥0 → ℂ) (τ : ℕ → Ω → ℝ≥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))
-    (hη : ∀ n, ∀ᵐ ω ∂P, ∀ t : ℝ≥0, σ ω ≤ t → f ω t ∈ upperHalfPlane →
-      η n ω t = Fₙ n (f ω t))
-    (hτ : ∀ n, ∀ᵐ ω ∂P, ω ∈ G n ∩ E →
-      σ ω ≤ τ n ω ∧ 2 / 3 ≤ pₙ n (η n ω (τ n ω))) :
-    ∃ a : ℝ, 0 < a ∧ ∀ᶠ n in atTop,
-      ENNReal.ofReal (q / 4) ≤ P {ω | ω ∈ G n ∩ E ∧ ENNReal.ofReal a ≤
-        segmentSausageCharge κ (η n ω) (σ ω) (τ n ω) (v n) (Rₙ n)} := by
-  let progress := fun z => p (F z)
-  have hprogress : ContinuousOn progress O :=
-    hp.comp (hF.continuousOn.mono hOH) hFOU
-  obtain ⟨K, M, L, N, hK, hM, hL, hN, hDm, hcover⟩ :=
-    stopped_tube_retained_cover f hf σ hσ O W hO hOH progress hprogress hW E htube hstart
-  let D : ℕ → Set Ω := fun i => retainedPassageCertificate f σ K M L N
-    (beyondFrontRegion O progress) (enumerateRetainedPassage i)
-  let Q : ℕ → Set ℂ := fun i => M (enumerateRetainedPassage i).1.2.2.1
-  let J : ℕ → ℝ≥0 × ℝ≥0 := fun i =>
-    (intervalStart (enumerateRetainedPassage i).1, intervalEnd (enumerateRetainedPassage i).1)
-  have hQ : ∀ i, IsCompact (Q i) := fun i => (hM _).1
-  have hQH : ∀ i, Q i ⊆ upperHalfPlane := fun i z hz => hOH ((hM _).2 hz).1
-  have hQR : ∀ i, F '' Q i ⊆ R := by
-    rintro i _ ⟨z, hz, rfl⟩
-    have hh := (hM _).2 hz
-    exact hmiddle z hh.1 hh.2.1 hh.2.2
-  have hJ : ∀ i, (J i).1 < (J i).2 := fun i => intervalStart_lt_end _
-  have hD : ∀ i, MeasurableSet (D i) := fun i => hDm _
-  have hnull : P (E \ ⋃ i, D i) = 0 := by
-    rw [sdiff_eq_empty.mpr (nat_retained_cover f σ K M L N _ E hcover), measure_empty]
-  have hretain : ∀ i ω, ω ∈ D i →
-      (fun t => f ω t) '' Icc (J i).1 (J i).2 ⊆ Q i := by
-    intro i ω hω
-    exact hω.1.2.2.2.1.image_subset
-  have hwindow : ∀ i, ∀ᶠ n in atTop, ∀ᵐ ω ∂P, ω ∈ G n ∩ E ∩ D i →
-      σ ω ≤ (J i).1 ∧ (J i).2 ≤ τ n ω ∧
-        EqOn (η n ω) (fun u => Fₙ n (f ω u)) (Icc (J i).1 (J i).2) := by
-    intro i
-    let j := enumerateRetainedPassage i
-    have hLH : L j.1.2.2.2 ⊆ upperHalfPlane := fun z hz => hOH ((hL _).2 hz).1
-    have hLU : F '' L j.1.2.2.2 ⊆ U := by
-      rintro _ ⟨z, hz, rfl⟩
-      exact hFOU ((hL _).2 hz).1
-    have hlt := eventually_front_lt_on_compact Fₙ F hF.continuousOn hconv pₙ p U hU hp hpconv
-      (L j.1.2.2.2) (hL _).1 hLH hLU (2 / 3) (fun z hz => ((hL _).2 hz).2)
-    filter_upwards [hlt] with n hn
-    filter_upwards [hη n, hτ n] with ω hηω hτω
-    intro hω
-    have hDi : ω ∈ retainedPassageCertificate f σ K M L N
-        (beyondFrontRegion O progress) j := hω.2
-    obtain ⟨⟨hσs, _, _, hmid, hlow⟩, _⟩ := hDi
-    have htau := hτω hω.1
-    have hbefore : intervalEnd j.1 ≤ τ n ω := by
-      by_contra hbad
-      have hmem : f ω (τ n ω) ∈ L j.1.2.2.2 :=
-        hlow.2 ⟨htau.1, (lt_of_not_ge hbad).le⟩
-      have hh := hn _ hmem
-      rw [← hηω (τ n ω) htau.1 (hLH hmem)] at hh
-      exact (not_le_of_gt hh) htau.2
-    refine ⟨hσs.le, hbefore, ?_⟩
-    intro t ht
-    exact hηω t (hσs.le.trans ht.1) (hOH ((hM _).2 (hmid ht)).1)
-  exact countable_stopped_mass_ae_window P κ hκ hκ8 (fun ω => f ω) hSLE
-    Fₙ F hFn hinj hF hne hconv Q hQ hQH R hR hQR J hJ E D hE hD hnull hretain
-    v hv hlim η (fun _ => σ) τ Rₙ hregion G q hq hG hwindow
-/-- Actual tube passages produce retained sausage mass before the varying
-front stop. Compact intervals and stop windows are both derived here. -/
-theorem retained_tube_stopped_sausage_mass_eventually
-    {Ω : Type*} [MeasurableSpace Ω] (P : Measure Ω) [IsProbabilityMeasure P]
-    (κ : ℝ) (hκ : 0 < κ) (hκ8 : κ < 8)
-    (f : Ω → C(ℝ≥0, ℂ)) (hf : Measurable f)
-    (hSLE : IsOrdinaryChordalSLE κ (fun ω => f ω) P)
-    (σ : Ω → ℝ≥0) (hσ : Measurable σ)
-    (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)
-    (O W : Set ℂ) (hO : IsOpen O) (hOH : O ⊆ upperHalfPlane)
-    (pₙ : ℕ → ℂ → ℝ) (p : ℂ → ℝ) (U : Set ℂ) (hU : IsOpen U)
-    (hp : ContinuousOn p U) (hpconv : TendstoLocallyUniformlyOn pₙ p atTop U)
-    (hFOU : MapsTo F O U) (hW : W ⊆ {z | 1 < p (F z)})
-    (E : Set Ω) (hE : MeasurableSet E)
-    (htube : E ⊆ stoppedPhysicalTube (fun ω => f ω) σ O W)
-    (hstart : ∀ ω ∈ E, p (F (f ω (σ ω))) < 1 / 3)
-    (R : Set ℂ) (hR : IsOpen R)
-    (hmiddle : ∀ z ∈ O, 1 / 3 < p (F z) → p (F z) < 2 / 3 → F z ∈ R)
-    (v : ℕ → ℝ) (hv : ∀ n, 0 < v n) (hlim : Tendsto v atTop (𝓝 0))
-    (η : ℕ → Ω → ℝ≥0 → ℂ) (τ : ℕ → Ω → ℝ≥0) (Rₙ : ℕ → Set ℂ)
-    (hregion : ∀ᶠ n in atTop, R ⊆ Rₙ n)
-    (G : ℕ → Set Ω) (q : ℝ) (hq : 0 < q)
-    (hG : ∀ᶠ n in atTop, ENNReal.ofReal q ≤ P (G n ∩ E))
-    (hη : ∀ n, ∀ᵐ ω ∂P, ∀ t : ℝ≥0, σ ω ≤ t → f ω t ∈ upperHalfPlane →
-      η n ω t = Fₙ n (f ω t))
-    (hτ : ∀ n, ∀ᵐ ω ∂P, ω ∈ G n ∩ E →
-      σ ω ≤ τ n ω ∧ 2 / 3 ≤ pₙ n (η n ω (τ n ω))) :
-    ∃ a : ℝ, 0 < a ∧ ∀ᶠ n in atTop,
-      ENNReal.ofReal (q / 4) ≤ P {ω | ω ∈ G n ∩ E ∧ ENNReal.ofReal a ≤
-        segmentSausageCharge κ (η n ω) (σ ω) (τ n ω) (v n) (Rₙ n)} := by
-  let progress := fun z => p (F z)
-  have hprogress : ContinuousOn progress O :=
-    hp.comp (hF.continuousOn.mono hOH) hFOU
-  obtain ⟨K, M, L, N, hK, hM, hL, hN, hDm, hcover⟩ :=
-    stopped_tube_retained_cover f hf σ hσ O W hO hOH progress hprogress hW E htube hstart
-  let D : ℕ → Set Ω := fun i => retainedPassageCertificate f σ K M L N
-    (beyondFrontRegion O progress) (enumerateRetainedPassage i)
-  let Q : ℕ → Set ℂ := fun i => M (enumerateRetainedPassage i).1.2.2.1
-  let J : ℕ → ℝ≥0 × ℝ≥0 := fun i =>
-    (intervalStart (enumerateRetainedPassage i).1, intervalEnd (enumerateRetainedPassage i).1)
-  have hQ : ∀ i, IsCompact (Q i) := fun i => (hM _).1
-  have hQH : ∀ i, Q i ⊆ upperHalfPlane := fun i z hz => hOH ((hM _).2 hz).1
-  have hQR : ∀ i, F '' Q i ⊆ R := by
-    rintro i _ ⟨z, hz, rfl⟩
-    have hh := (hM _).2 hz
-    exact hmiddle z hh.1 hh.2.1 hh.2.2
-  have hJ : ∀ i, (J i).1 < (J i).2 := fun i => intervalStart_lt_end _
-  have hD : ∀ i, MeasurableSet (D i) := fun i => hDm _
-  have hnull : P (E \ ⋃ i, D i) = 0 := by
-    rw [sdiff_eq_empty.mpr (nat_retained_cover f σ K M L N _ E hcover), measure_empty]
-  have hretain : ∀ i ω, ω ∈ D i →
-      (fun t => f ω t) '' Icc (J i).1 (J i).2 ⊆ Q i := by
-    intro i ω hω
-    exact hω.1.2.2.2.1.image_subset
-  have hwindow : ∀ i, ∀ᶠ n in atTop, ∀ᵐ ω ∂P, ω ∈ G n ∩ E ∩ D i →
-      σ ω ≤ (J i).1 ∧ (J i).2 ≤ τ n ω ∧
-        EqOn (η n ω) (fun u => Fₙ n (f ω u)) (Icc (J i).1 (J i).2) := by
-    intro i
-    let j := enumerateRetainedPassage i
-    have hLH : L j.1.2.2.2 ⊆ upperHalfPlane := fun z hz => hOH ((hL _).2 hz).1
-    have hLU : F '' L j.1.2.2.2 ⊆ U := by
-      rintro _ ⟨z, hz, rfl⟩
-      exact hFOU ((hL _).2 hz).1
-    have hlt := eventually_front_lt_on_compact Fₙ F hF.continuousOn hconv pₙ p U hU hp hpconv
-      (L j.1.2.2.2) (hL _).1 hLH hLU (2 / 3) (fun z hz => ((hL _).2 hz).2)
-    filter_upwards [hlt] with n hn
-    filter_upwards [hη n, hτ n] with ω hηω hτω
-    intro hω
-    have hDi : ω ∈ retainedPassageCertificate f σ K M L N
-        (beyondFrontRegion O progress) j := hω.2
-    obtain ⟨⟨hσs, _, _, hmid, hlow⟩, _⟩ := hDi
-    have htau := hτω hω.1
-    have hbefore : intervalEnd j.1 ≤ τ n ω := by
-      by_contra hbad
-      have hmem : f ω (τ n ω) ∈ L j.1.2.2.2 :=
-        hlow.2 ⟨htau.1, (lt_of_not_ge hbad).le⟩
-      have hh := hn _ hmem
-      rw [← hηω (τ n ω) htau.1 (hLH hmem)] at hh
-      exact (not_le_of_gt hh) htau.2
-    refine ⟨hσs.le, hbefore, ?_⟩
-    intro t ht
-    exact hηω t (hσs.le.trans ht.1) (hOH ((hM _).2 (hmid ht)).1)
-  exact countable_stopped_mass_ae_window_eventually P κ hκ hκ8 (fun ω => f ω) hSLE
-    Fₙ F hFn hinj hF hne hconv Q hQ hQH R hR hQR J hJ E D hE hD hnull hretain
-    v hv hlim η (fun _ => σ) τ Rₙ hregion G q hq hG hwindow
-
-end SLEExactGauge.RetainedTubeSausage
-
-end
-
-end OAI
+import OAI.Probability.SLE.Gauge.PassageRetention
+import OAI.Probability.SLE.Mass.StoppedConformalPassageMass
+
+namespace OAI
+
+/-! Actual open-tube passage certificates imply a positive stopped sausage
+mass. The retained time window is derived from the front coordinate, rather
+than supplied as a separate geometric hypothesis. -/
+
+noncomputable section
+open Set Filter MeasureTheory Metric
+open scoped Topology NNReal ENNReal
+
+namespace SLEExactGauge.RetainedTubeSausage
+open PassageRetention
+
+/-- Uniformly convergent physical coordinates preserve a strict front bound
+on each compact retained parameter set. -/
+theorem eventually_front_lt_on_compact
+    (Fₙ : ℕ → ℂ → ℂ) (F : ℂ → ℂ)
+    (hF : ContinuousOn F upperHalfPlane)
+    (hFconv : TendstoLocallyUniformlyOn Fₙ F atTop upperHalfPlane)
+    (pₙ : ℕ → ℂ → ℝ) (p : ℂ → ℝ) (U : Set ℂ) (hU : IsOpen U)
+    (hp : ContinuousOn p U) (hpconv : TendstoLocallyUniformlyOn pₙ p atTop U)
+    (K : Set ℂ) (hK : IsCompact K) (hKH : K ⊆ upperHalfPlane)
+    (hKU : F '' K ⊆ U) (q : ℝ) (hbound : ∀ z ∈ K, p (F z) < q) :
+    ∀ᶠ n in atTop, ∀ z ∈ K, pₙ n (Fₙ n z) < q := by
+  by_cases hKn : K.Nonempty
+  · let V := U ∩ p ⁻¹' Iio q
+    have hV : IsOpen V := hp.isOpen_inter_preimage hU isOpen_Iio
+    have hFK : IsCompact (F '' K) := hK.image_of_continuousOn (hF.mono hKH)
+    have hFKV : F '' K ⊆ V := by
+      rintro w ⟨z, hz, rfl⟩
+      exact ⟨hKU (mem_image_of_mem F hz), hbound z hz⟩
+    obtain ⟨δ, hδ, hthick⟩ := hFK.exists_cthickening_subset_open hV hFKV
+    let L := cthickening (δ / 2) (F '' K)
+    have hL : IsCompact L := hFK.cthickening
+    have hLV : L ⊆ V := (cthickening_mono (by linarith) (F '' K)).trans hthick
+    have hLn : L.Nonempty := (hKn.image F).mono (self_subset_cthickening _)
+    have hpL : ContinuousOn p L := hp.mono (hLV.trans inter_subset_left)
+    obtain ⟨z₀, hz₀, hmax⟩ := hL.exists_isMaxOn hLn hpL
+    have hz₀q : p z₀ < q := (hLV hz₀).2
+    have huF : TendstoUniformlyOn Fₙ F atTop K :=
+      (tendstoLocallyUniformlyOn_iff_tendstoUniformlyOn_of_compact hK).mp (hFconv.mono hKH)
+    have huP : TendstoUniformlyOn pₙ p atTop L :=
+      (tendstoLocallyUniformlyOn_iff_tendstoUniformlyOn_of_compact hL).mp
+        (hpconv.mono (hLV.trans inter_subset_left))
+    filter_upwards [huF _ (Metric.dist_mem_uniformity (by positivity : 0 < δ / 2)),
+      huP _ (Metric.dist_mem_uniformity (sub_pos.mpr hz₀q))] with n hnF hnP
+    intro z hz
+    have hzL : Fₙ n z ∈ L :=
+      mem_cthickening_of_dist_le _ (F z) (δ / 2) (F '' K)
+        (mem_image_of_mem F hz) (by simpa only [dist_comm] using (hnF z hz).le)
+    have hdiff := hnP (Fₙ n z) hzL
+    have hupper : p (Fₙ n z) ≤ p z₀ := hmax hzL
+    rw [Real.dist_eq] at hdiff
+    have hh := (abs_lt.mp hdiff).1
+    linarith
+  · have hKe : K = ∅ := not_nonempty_iff_eq_empty.mp hKn
+    simp only [hKe, mem_empty_iff_false, IsEmpty.forall_iff, implies_true,
+      eventually_true]
+
+/-- The countable stopped-mass reduction also permits almost-sure window
+and chart identities, as supplied by the actual boundary restart. -/
+theorem countable_stopped_mass_ae_window
+    {Ω : 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, ∀ᵐ ω ∂P, ω ∈ 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, ∀ᵐ ω ∂P, ω ∈ 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, ∀ᵐ ω ∂P, ω ∈ 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
+    filter_upwards [(Finset.eventually_all _).mpr hn] with ω hω
+    intro hH
+    obtain ⟨i, hi, hDi⟩ := mem_iUnion₂.mp hH.2
+    exact ⟨J i, Finset.mem_image.mpr ⟨i, hi, rfl⟩,
+      (hretain i ω hDi).trans (subset_iUnion₂_of_subset i hi Subset.rfl),
+      hω i hi ⟨hH.1, hDi⟩⟩
+  obtain ⟨a, ha, hmass⟩ := compact_conformal_stopped_passage_mass_ae 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⟩))
+
+/-- The countable stopped-mass reduction also permits almost-sure window
+and chart identities, as supplied by the actual boundary restart. -/
+theorem countable_stopped_mass_ae_window_eventually
+    {Ω : 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 in atTop, ENNReal.ofReal q ≤ P (G n ∩ E))
+    (hwindow : ∀ i, ∀ᶠ n in atTop, ∀ᵐ ω ∂P, ω ∈ 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, hsmall⟩ := finite_retention_of_countable_cover P E D hE hD hcover
+    (ENNReal.ofReal (q / 2)) (ENNReal.ofReal_pos.mpr (by positivity))
+  have hN : ∀ᶠ n in atTop, ENNReal.ofReal (q / 2) ≤
+      P (G n ∩ E ∩ ⋃ i ∈ Finset.range N, D i) := by
+    filter_upwards [hG] with n hn
+    let A := ⋃ i ∈ Finset.range N, D i
+    have hsub : G n ∩ E ⊆ (G n ∩ E ∩ A) ∪ (E \ A) := by
+      intro ω hω
+      by_cases hA : ω ∈ A
+      · exact Or.inl ⟨hω, hA⟩
+      · exact Or.inr ⟨hω.2, hA⟩
+    have hb := hn.trans ((measure_mono hsub).trans (measure_union_le _ _))
+    by_contra h
+    have he : ENNReal.ofReal (q / 2) + ENNReal.ofReal (q / 2) =
+        ENNReal.ofReal q := by
+      rw [← ENNReal.ofReal_add (by positivity) (by positivity)]
+      congr 1
+      ring
+    exact (not_lt_of_ge hb) (he ▸ ENNReal.add_lt_add (lt_of_not_ge h) hsmall)
+  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
+    obtain ⟨n, hn⟩ := hN.exists
+    have hHpos : 0 < P (H n) :=
+      (ENNReal.ofReal_pos.mpr (by positivity : 0 < q / 2)).trans_le hn
+    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, ∀ᵐ ω ∂P, ω ∈ 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, ∀ᵐ ω ∂P, ω ∈ 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
+    filter_upwards [(Finset.eventually_all _).mpr hn] with ω hω
+    intro hH
+    obtain ⟨i, hi, hDi⟩ := mem_iUnion₂.mp hH.2
+    exact ⟨J i, Finset.mem_image.mpr ⟨i, hi, rfl⟩,
+      (hretain i ω hDi).trans (subset_iUnion₂_of_subset i hi Subset.rfl),
+      hω i hi ⟨hH.1, hDi⟩⟩
+  obtain ⟨a, ha, hmass⟩ := compact_conformal_stopped_passage_mass_ae 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) 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⟩))
+
+/-- Actual tube passages produce retained sausage mass before the varying
+front stop. Compact intervals and stop windows are both derived here. -/
+theorem retained_tube_stopped_sausage_mass
+    {Ω : Type*} [MeasurableSpace Ω] (P : Measure Ω) [IsProbabilityMeasure P]
+    (κ : ℝ) (hκ : 0 < κ) (hκ8 : κ < 8)
+    (f : Ω → C(ℝ≥0, ℂ)) (hf : Measurable f)
+    (hSLE : IsOrdinaryChordalSLE κ (fun ω => f ω) P)
+    (σ : Ω → ℝ≥0) (hσ : Measurable σ)
+    (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)
+    (O W : Set ℂ) (hO : IsOpen O) (hOH : O ⊆ upperHalfPlane)
+    (pₙ : ℕ → ℂ → ℝ) (p : ℂ → ℝ) (U : Set ℂ) (hU : IsOpen U)
+    (hp : ContinuousOn p U) (hpconv : TendstoLocallyUniformlyOn pₙ p atTop U)
+    (hFOU : MapsTo F O U) (hW : W ⊆ {z | 1 < p (F z)})
+    (E : Set Ω) (hE : MeasurableSet E)
+    (htube : E ⊆ stoppedPhysicalTube (fun ω => f ω) σ O W)
+    (hstart : ∀ ω ∈ E, p (F (f ω (σ ω))) < 1 / 3)
+    (R : Set ℂ) (hR : IsOpen R)
+    (hmiddle : ∀ z ∈ O, 1 / 3 < p (F z) → p (F z) < 2 / 3 → F z ∈ R)
+    (v : ℕ → ℝ) (hv : ∀ n, 0 < v n) (hlim : Tendsto v atTop (𝓝 0))
+    (η : ℕ → Ω → ℝ≥0 → ℂ) (τ : ℕ → Ω → ℝ≥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))
+    (hη : ∀ n, ∀ᵐ ω ∂P, ∀ t : ℝ≥0, σ ω ≤ t → f ω t ∈ upperHalfPlane →
+      η n ω t = Fₙ n (f ω t))
+    (hτ : ∀ n, ∀ᵐ ω ∂P, ω ∈ G n ∩ E →
+      σ ω ≤ τ n ω ∧ 2 / 3 ≤ pₙ n (η n ω (τ n ω))) :
+    ∃ a : ℝ, 0 < a ∧ ∀ᶠ n in atTop,
+      ENNReal.ofReal (q / 4) ≤ P {ω | ω ∈ G n ∩ E ∧ ENNReal.ofReal a ≤
+        segmentSausageCharge κ (η n ω) (σ ω) (τ n ω) (v n) (Rₙ n)} := by
+  let progress := fun z => p (F z)
+  have hprogress : ContinuousOn progress O :=
+    hp.comp (hF.continuousOn.mono hOH) hFOU
+  obtain ⟨K, M, L, N, hK, hM, hL, hN, hDm, hcover⟩ :=
+    stopped_tube_retained_cover f hf σ hσ O W hO hOH progress hprogress hW E htube hstart
+  let D : ℕ → Set Ω := fun i => retainedPassageCertificate f σ K M L N
+    (beyondFrontRegion O progress) (enumerateRetainedPassage i)
+  let Q : ℕ → Set ℂ := fun i => M (enumerateRetainedPassage i).1.2.2.1
+  let J : ℕ → ℝ≥0 × ℝ≥0 := fun i =>
+    (intervalStart (enumerateRetainedPassage i).1, intervalEnd (enumerateRetainedPassage i).1)
+  have hQ : ∀ i, IsCompact (Q i) := fun i => (hM _).1
+  have hQH : ∀ i, Q i ⊆ upperHalfPlane := fun i z hz => hOH ((hM _).2 hz).1
+  have hQR : ∀ i, F '' Q i ⊆ R := by
+    rintro i _ ⟨z, hz, rfl⟩
+    have hh := (hM _).2 hz
+    exact hmiddle z hh.1 hh.2.1 hh.2.2
+  have hJ : ∀ i, (J i).1 < (J i).2 := fun i => intervalStart_lt_end _
+  have hD : ∀ i, MeasurableSet (D i) := fun i => hDm _
+  have hnull : P (E \ ⋃ i, D i) = 0 := by
+    rw [sdiff_eq_empty.mpr (nat_retained_cover f σ K M L N _ E hcover), measure_empty]
+  have hretain : ∀ i ω, ω ∈ D i →
+      (fun t => f ω t) '' Icc (J i).1 (J i).2 ⊆ Q i := by
+    intro i ω hω
+    exact hω.1.2.2.2.1.image_subset
+  have hwindow : ∀ i, ∀ᶠ n in atTop, ∀ᵐ ω ∂P, ω ∈ G n ∩ E ∩ D i →
+      σ ω ≤ (J i).1 ∧ (J i).2 ≤ τ n ω ∧
+        EqOn (η n ω) (fun u => Fₙ n (f ω u)) (Icc (J i).1 (J i).2) := by
+    intro i
+    let j := enumerateRetainedPassage i
+    have hLH : L j.1.2.2.2 ⊆ upperHalfPlane := fun z hz => hOH ((hL _).2 hz).1
+    have hLU : F '' L j.1.2.2.2 ⊆ U := by
+      rintro _ ⟨z, hz, rfl⟩
+      exact hFOU ((hL _).2 hz).1
+    have hlt := eventually_front_lt_on_compact Fₙ F hF.continuousOn hconv pₙ p U hU hp hpconv
+      (L j.1.2.2.2) (hL _).1 hLH hLU (2 / 3) (fun z hz => ((hL _).2 hz).2)
+    filter_upwards [hlt] with n hn
+    filter_upwards [hη n, hτ n] with ω hηω hτω
+    intro hω
+    have hDi : ω ∈ retainedPassageCertificate f σ K M L N
+        (beyondFrontRegion O progress) j := hω.2
+    obtain ⟨⟨hσs, _, _, hmid, hlow⟩, _⟩ := hDi
+    have htau := hτω hω.1
+    have hbefore : intervalEnd j.1 ≤ τ n ω := by
+      by_contra hbad
+      have hmem : f ω (τ n ω) ∈ L j.1.2.2.2 :=
+        hlow.2 ⟨htau.1, (lt_of_not_ge hbad).le⟩
+      have hh := hn _ hmem
+      rw [← hηω (τ n ω) htau.1 (hLH hmem)] at hh
+      exact (not_le_of_gt hh) htau.2
+    refine ⟨hσs.le, hbefore, ?_⟩
+    intro t ht
+    exact hηω t (hσs.le.trans ht.1) (hOH ((hM _).2 (hmid ht)).1)
+  exact countable_stopped_mass_ae_window P κ hκ hκ8 (fun ω => f ω) hSLE
+    Fₙ F hFn hinj hF hne hconv Q hQ hQH R hR hQR J hJ E D hE hD hnull hretain
+    v hv hlim η (fun _ => σ) τ Rₙ hregion G q hq hG hwindow
+/-- Actual tube passages produce retained sausage mass before the varying
+front stop. Compact intervals and stop windows are both derived here. -/
+theorem retained_tube_stopped_sausage_mass_eventually
+    {Ω : Type*} [MeasurableSpace Ω] (P : Measure Ω) [IsProbabilityMeasure P]
+    (κ : ℝ) (hκ : 0 < κ) (hκ8 : κ < 8)
+    (f : Ω → C(ℝ≥0, ℂ)) (hf : Measurable f)
+    (hSLE : IsOrdinaryChordalSLE κ (fun ω => f ω) P)
+    (σ : Ω → ℝ≥0) (hσ : Measurable σ)
+    (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)
+    (O W : Set ℂ) (hO : IsOpen O) (hOH : O ⊆ upperHalfPlane)
+    (pₙ : ℕ → ℂ → ℝ) (p : ℂ → ℝ) (U : Set ℂ) (hU : IsOpen U)
+    (hp : ContinuousOn p U) (hpconv : TendstoLocallyUniformlyOn pₙ p atTop U)
+    (hFOU : MapsTo F O U) (hW : W ⊆ {z | 1 < p (F z)})
+    (E : Set Ω) (hE : MeasurableSet E)
+    (htube : E ⊆ stoppedPhysicalTube (fun ω => f ω) σ O W)
+    (hstart : ∀ ω ∈ E, p (F (f ω (σ ω))) < 1 / 3)
+    (R : Set ℂ) (hR : IsOpen R)
+    (hmiddle : ∀ z ∈ O, 1 / 3 < p (F z) → p (F z) < 2 / 3 → F z ∈ R)
+    (v : ℕ → ℝ) (hv : ∀ n, 0 < v n) (hlim : Tendsto v atTop (𝓝 0))
+    (η : ℕ → Ω → ℝ≥0 → ℂ) (τ : ℕ → Ω → ℝ≥0) (Rₙ : ℕ → Set ℂ)
+    (hregion : ∀ᶠ n in atTop, R ⊆ Rₙ n)
+    (G : ℕ → Set Ω) (q : ℝ) (hq : 0 < q)
+    (hG : ∀ᶠ n in atTop, ENNReal.ofReal q ≤ P (G n ∩ E))
+    (hη : ∀ n, ∀ᵐ ω ∂P, ∀ t : ℝ≥0, σ ω ≤ t → f ω t ∈ upperHalfPlane →
+      η n ω t = Fₙ n (f ω t))
+    (hτ : ∀ n, ∀ᵐ ω ∂P, ω ∈ G n ∩ E →
+      σ ω ≤ τ n ω ∧ 2 / 3 ≤ pₙ n (η n ω (τ n ω))) :
+    ∃ a : ℝ, 0 < a ∧ ∀ᶠ n in atTop,
+      ENNReal.ofReal (q / 4) ≤ P {ω | ω ∈ G n ∩ E ∧ ENNReal.ofReal a ≤
+        segmentSausageCharge κ (η n ω) (σ ω) (τ n ω) (v n) (Rₙ n)} := by
+  let progress := fun z => p (F z)
+  have hprogress : ContinuousOn progress O :=
+    hp.comp (hF.continuousOn.mono hOH) hFOU
+  obtain ⟨K, M, L, N, hK, hM, hL, hN, hDm, hcover⟩ :=
+    stopped_tube_retained_cover f hf σ hσ O W hO hOH progress hprogress hW E htube hstart
+  let D : ℕ → Set Ω := fun i => retainedPassageCertificate f σ K M L N
+    (beyondFrontRegion O progress) (enumerateRetainedPassage i)
+  let Q : ℕ → Set ℂ := fun i => M (enumerateRetainedPassage i).1.2.2.1
+  let J : ℕ → ℝ≥0 × ℝ≥0 := fun i =>
+    (intervalStart (enumerateRetainedPassage i).1, intervalEnd (enumerateRetainedPassage i).1)
+  have hQ : ∀ i, IsCompact (Q i) := fun i => (hM _).1
+  have hQH : ∀ i, Q i ⊆ upperHalfPlane := fun i z hz => hOH ((hM _).2 hz).1
+  have hQR : ∀ i, F '' Q i ⊆ R := by
+    rintro i _ ⟨z, hz, rfl⟩
+    have hh := (hM _).2 hz
+    exact hmiddle z hh.1 hh.2.1 hh.2.2
+  have hJ : ∀ i, (J i).1 < (J i).2 := fun i => intervalStart_lt_end _
+  have hD : ∀ i, MeasurableSet (D i) := fun i => hDm _
+  have hnull : P (E \ ⋃ i, D i) = 0 := by
+    rw [sdiff_eq_empty.mpr (nat_retained_cover f σ K M L N _ E hcover), measure_empty]
+  have hretain : ∀ i ω, ω ∈ D i →
+      (fun t => f ω t) '' Icc (J i).1 (J i).2 ⊆ Q i := by
+    intro i ω hω
+    exact hω.1.2.2.2.1.image_subset
+  have hwindow : ∀ i, ∀ᶠ n in atTop, ∀ᵐ ω ∂P, ω ∈ G n ∩ E ∩ D i →
+      σ ω ≤ (J i).1 ∧ (J i).2 ≤ τ n ω ∧
+        EqOn (η n ω) (fun u => Fₙ n (f ω u)) (Icc (J i).1 (J i).2) := by
+    intro i
+    let j := enumerateRetainedPassage i
+    have hLH : L j.1.2.2.2 ⊆ upperHalfPlane := fun z hz => hOH ((hL _).2 hz).1
+    have hLU : F '' L j.1.2.2.2 ⊆ U := by
+      rintro _ ⟨z, hz, rfl⟩
+      exact hFOU ((hL _).2 hz).1
+    have hlt := eventually_front_lt_on_compact Fₙ F hF.continuousOn hconv pₙ p U hU hp hpconv
+      (L j.1.2.2.2) (hL _).1 hLH hLU (2 / 3) (fun z hz => ((hL _).2 hz).2)
+    filter_upwards [hlt] with n hn
+    filter_upwards [hη n, hτ n] with ω hηω hτω
+    intro hω
+    have hDi : ω ∈ retainedPassageCertificate f σ K M L N
+        (beyondFrontRegion O progress) j := hω.2
+    obtain ⟨⟨hσs, _, _, hmid, hlow⟩, _⟩ := hDi
+    have htau := hτω hω.1
+    have hbefore : intervalEnd j.1 ≤ τ n ω := by
+      by_contra hbad
+      have hmem : f ω (τ n ω) ∈ L j.1.2.2.2 :=
+        hlow.2 ⟨htau.1, (lt_of_not_ge hbad).le⟩
+      have hh := hn _ hmem
+      rw [← hηω (τ n ω) htau.1 (hLH hmem)] at hh
+      exact (not_le_of_gt hh) htau.2
+    refine ⟨hσs.le, hbefore, ?_⟩
+    intro t ht
+    exact hηω t (hσs.le.trans ht.1) (hOH ((hM _).2 (hmid ht)).1)
+  exact countable_stopped_mass_ae_window_eventually P κ hκ hκ8 (fun ω => f ω) hSLE
+    Fₙ F hFn hinj hF hne hconv Q hQ hQH R hR hQR J hJ E D hE hD hnull hretain
+    v hv hlim η (fun _ => σ) τ Rₙ hregion G q hq hG hwindow
+
+end SLEExactGauge.RetainedTubeSausage
+
+end
+
+end OAI

lean/OAI/Probability/SLE/Gauge/RibbonAccessGuide.lean

@@ -1,82 +1,82 @@
-import OAI.Probability.SLE.Gauge.RibbonFrontFreshness
-
-namespace OAI
-
-/-! The physical ribbon guide supplies surviving-domain and compactness
-geometry under a two-sided waypoint angle hypothesis. -/
-
-noncomputable section
-open Set Filter Metric
-open scoped Topology NNReal
-
-namespace SLEExactGauge.RibbonCoordinates
-
-theorem ribbon_access_guide_geometry
-    (hpublished : PublishedPlanarDiskOpenness)
-    (P : ℂ → ℂ) (hP : ContinuousOn P closedRibbon) (hi : InjOn P closedRibbon)
-    (hH : ∀ z ∈ closedRibbon, 0 < z.re → P z ∈ upperHalfPlane)
-    (hescape : Tendsto (fun s : ℝ => ‖P (s : ℂ)‖) atTop atTop)
-    (γ xp : ℝ≥0 → ℂ) (T : ℝ≥0) (hxp : ContinuousOn xp (Icc 0 T))
-    (hxp0 : (xp 0).re = 0) (hcoords : MapsTo xp (Icc 0 T) closedRibbon)
-    (hγ : EqOn γ (P ∘ xp) (Icc 0 T))
-    (k x : ℝ) (hk : 0 ≤ k) (hx : |x| ≤ 1 / 4)
-    (htip : xp T = (k : ℂ) + (x : ℂ) * Complex.I)
-    (hfront : ∀ t : ℝ≥0, t < T → (xp t).re < k)
-    (C : ℝ≥0) (K : ℝ) (hK : 0 < K)
-    (hL : LipschitzOnWith C P (guidePatch k))
-    (hlower : ∀ u ∈ guidePatch k, ∀ v ∈ guidePatch k,
-      dist u v ≤ K * dist (P u) (P v)) :
-    let α := fun t => P (guideCoordinate k x t)
-    ContinuousOn α (Icc 0 2) ∧ InjOn α (Icc 0 2) ∧ α 0 = γ T ∧
-      MapsTo α (Ioc 0 2) (survivingDomain γ T) ∧
-      (∀ s : ℝ≥0, s < T → γ T ∈ survivingDomain γ s) ∧
-      LipschitzOnWith (2 * C) α (Icc 0 2) ∧
-      (∀ u ∈ Icc (0 : ℝ) 2, ∀ v ∈ Icc (0 : ℝ) 2,
-        (1 / K) * |u - v| ≤ dist (α u) (α v)) ∧
-      (∀ δ : ℝ, 0 < δ → δ ≤ 2 → ∃ r : ℝ, 0 < r ∧
-        ∀ t ∈ Icc δ 2, ball (α t) r ⊆ survivingDomain γ T) := by
-  dsimp only
-  have htipre : (xp T).re = k := by simp [htip]
-  have htipim : (xp T).im = x := by simp [htip]
-  have hpast : γ '' Icc 0 T ⊆ P '' {z ∈ closedRibbon | z.re ≤ k} := by
-    rintro z ⟨t, ht, rfl⟩
-    refine ⟨xp t, ⟨hcoords ht, ?_⟩, (hγ ht).symm⟩
-    by_cases he : t = T
-    · simpa only [he, htipre] using le_rfl (a := k)
-    · exact (hfront t (lt_of_le_of_ne ht.2 he)).le
-  have hunbounded := futureRibbon_unbounded_of_centerline_escape P k hescape
-  have hguidePatch : MapsTo (guideCoordinate k x) (Icc (0 : ℝ) 2) (guidePatch k) :=
-    fun _ ht => guideCoordinate_mem_patch hx ht
-  have hguideClosed := hguidePatch.mono_right (guidePatch_subset_closedRibbon hk)
-  have hαcont : ContinuousOn (fun t => P (guideCoordinate k x t)) (Icc 0 2) :=
-    hP.comp (guideCoordinate_continuous k x).continuousOn hguideClosed
-  have hαinj : InjOn (fun t => P (guideCoordinate k x t)) (Icc 0 2) := by
-    intro u hu v hv he
-    have hc := hi (hguideClosed hu) (hguideClosed hv) he
-    have hre := congrArg Complex.re hc
-    simp only [guideCoordinate_re] at hre
-    linarith
-  have hα0 : P (guideCoordinate k x 0) = γ T := by
-    rw [guideCoordinate_zero, ← htip]
-    exact (hγ ⟨bot_le, le_rfl⟩).symm
-  have hαD : MapsTo (fun t => P (guideCoordinate k x t)) (Ioc 0 2)
-      (survivingDomain γ T) := by
-    intro t ht
-    apply futureRibbon_survives P hP hi hk hH γ T hpast hunbounded
-    apply mem_image_of_mem
-    change k < (guideCoordinate k x t).re ∧ |(guideCoordinate k x t).im| < 1
-    exact ⟨by rw [guideCoordinate_re]; linarith [ht.1],
-      (guideCoordinate_im_bound ht.1.le).trans_lt (hx.trans_lt (by norm_num))⟩
-  have hfresh := ribbon_front_tip_survives_prior P hP hi hH hescape γ xp T hxp hxp0 hcoords hγ
-    (fun t ht => by rw [htipre]; exact hfront t ht)
-    (by rw [htipim]; exact hx.trans_lt (by norm_num))
-  exact ⟨hαcont, hαinj, hα0, hαD, hfresh, physical_guide_lipschitz P C hx hL,
-    physical_guide_lower_chord P hx hK hlower,
-    fun δ hδ hδ2 => physical_guide_clearance_away hpublished P hP hi hk hx hK
-      hH γ T hpast hunbounded hlower hδ hδ2⟩
-
-end SLEExactGauge.RibbonCoordinates
-
-end
-
-end OAI
+import OAI.Probability.SLE.Gauge.RibbonFrontFreshness
+
+namespace OAI
+
+/-! The physical ribbon guide supplies surviving-domain and compactness
+geometry under a two-sided waypoint angle hypothesis. -/
+
+noncomputable section
+open Set Filter Metric
+open scoped Topology NNReal
+
+namespace SLEExactGauge.RibbonCoordinates
+
+theorem ribbon_access_guide_geometry
+    (hpublished : PublishedPlanarDiskOpenness)
+    (P : ℂ → ℂ) (hP : ContinuousOn P closedRibbon) (hi : InjOn P closedRibbon)
+    (hH : ∀ z ∈ closedRibbon, 0 < z.re → P z ∈ upperHalfPlane)
+    (hescape : Tendsto (fun s : ℝ => ‖P (s : ℂ)‖) atTop atTop)
+    (γ xp : ℝ≥0 → ℂ) (T : ℝ≥0) (hxp : ContinuousOn xp (Icc 0 T))
+    (hxp0 : (xp 0).re = 0) (hcoords : MapsTo xp (Icc 0 T) closedRibbon)
+    (hγ : EqOn γ (P ∘ xp) (Icc 0 T))
+    (k x : ℝ) (hk : 0 ≤ k) (hx : |x| ≤ 1 / 4)
+    (htip : xp T = (k : ℂ) + (x : ℂ) * Complex.I)
+    (hfront : ∀ t : ℝ≥0, t < T → (xp t).re < k)
+    (C : ℝ≥0) (K : ℝ) (hK : 0 < K)
+    (hL : LipschitzOnWith C P (guidePatch k))
+    (hlower : ∀ u ∈ guidePatch k, ∀ v ∈ guidePatch k,
+      dist u v ≤ K * dist (P u) (P v)) :
+    let α := fun t => P (guideCoordinate k x t)
+    ContinuousOn α (Icc 0 2) ∧ InjOn α (Icc 0 2) ∧ α 0 = γ T ∧
+      MapsTo α (Ioc 0 2) (survivingDomain γ T) ∧
+      (∀ s : ℝ≥0, s < T → γ T ∈ survivingDomain γ s) ∧
+      LipschitzOnWith (2 * C) α (Icc 0 2) ∧
+      (∀ u ∈ Icc (0 : ℝ) 2, ∀ v ∈ Icc (0 : ℝ) 2,
+        (1 / K) * |u - v| ≤ dist (α u) (α v)) ∧
+      (∀ δ : ℝ, 0 < δ → δ ≤ 2 → ∃ r : ℝ, 0 < r ∧
+        ∀ t ∈ Icc δ 2, ball (α t) r ⊆ survivingDomain γ T) := by
+  dsimp only
+  have htipre : (xp T).re = k := by simp [htip]
+  have htipim : (xp T).im = x := by simp [htip]
+  have hpast : γ '' Icc 0 T ⊆ P '' {z ∈ closedRibbon | z.re ≤ k} := by
+    rintro z ⟨t, ht, rfl⟩
+    refine ⟨xp t, ⟨hcoords ht, ?_⟩, (hγ ht).symm⟩
+    by_cases he : t = T
+    · simpa only [he, htipre] using le_rfl (a := k)
+    · exact (hfront t (lt_of_le_of_ne ht.2 he)).le
+  have hunbounded := futureRibbon_unbounded_of_centerline_escape P k hescape
+  have hguidePatch : MapsTo (guideCoordinate k x) (Icc (0 : ℝ) 2) (guidePatch k) :=
+    fun _ ht => guideCoordinate_mem_patch hx ht
+  have hguideClosed := hguidePatch.mono_right (guidePatch_subset_closedRibbon hk)
+  have hαcont : ContinuousOn (fun t => P (guideCoordinate k x t)) (Icc 0 2) :=
+    hP.comp (guideCoordinate_continuous k x).continuousOn hguideClosed
+  have hαinj : InjOn (fun t => P (guideCoordinate k x t)) (Icc 0 2) := by
+    intro u hu v hv he
+    have hc := hi (hguideClosed hu) (hguideClosed hv) he
+    have hre := congrArg Complex.re hc
+    simp only [guideCoordinate_re] at hre
+    linarith
+  have hα0 : P (guideCoordinate k x 0) = γ T := by
+    rw [guideCoordinate_zero, ← htip]
+    exact (hγ ⟨bot_le, le_rfl⟩).symm
+  have hαD : MapsTo (fun t => P (guideCoordinate k x t)) (Ioc 0 2)
+      (survivingDomain γ T) := by
+    intro t ht
+    apply futureRibbon_survives P hP hi hk hH γ T hpast hunbounded
+    apply mem_image_of_mem
+    change k < (guideCoordinate k x t).re ∧ |(guideCoordinate k x t).im| < 1
+    exact ⟨by rw [guideCoordinate_re]; linarith [ht.1],
+      (guideCoordinate_im_bound ht.1.le).trans_lt (hx.trans_lt (by norm_num))⟩
+  have hfresh := ribbon_front_tip_survives_prior P hP hi hH hescape γ xp T hxp hxp0 hcoords hγ
+    (fun t ht => by rw [htipre]; exact hfront t ht)
+    (by rw [htipim]; exact hx.trans_lt (by norm_num))
+  exact ⟨hαcont, hαinj, hα0, hαD, hfresh, physical_guide_lipschitz P C hx hL,
+    physical_guide_lower_chord P hx hK hlower,
+    fun δ hδ hδ2 => physical_guide_clearance_away hpublished P hP hi hk hx hK
+      hH γ T hpast hunbounded hlower hδ hδ2⟩
+
+end SLEExactGauge.RibbonCoordinates
+
+end
+
+end OAI

lean/OAI/Probability/SLE/Gauge/RibbonConcatenation.lean

@@ -1,101 +1,101 @@
-import OAI.Probability.SLE.Gauge.DenseCoverCore
-
-namespace OAI
-
-/-! Adapted concatenation and the mass/probability scaling of a serpentine
-ribbon with a quadratic number of narrow steps. -/
-
-noncomputable section
-open Set Filter MeasureTheory
-open scoped Topology ENNReal NNReal
-
-namespace SLEExactGauge
-
-/-- Success probabilities multiply as lower bounds under adapted restarts.
-The successive steps need not be independent. -/
-theorem adapted_successes_lower_bound
-    {Ω : Type*} [mΩ : MeasurableSpace Ω] (P : Measure Ω)
-    (F : Filtration ℕ mΩ) (success : ℕ → Set Ω)
-    (hmeas : ∀ n, MeasurableSet[F (n + 1)] (success n))
-    (q : ℝ≥0∞)
-    (hstep : ∀ n (B : Set Ω), MeasurableSet[F n] B →
-      q * P B ≤ P (B ∩ success n)) :
-    ∀ N : ℕ, q ^ N * P univ ≤ P (⋂ n ∈ Finset.range N, success n) := by
-  intro N
-  induction N with
-  | zero => simp
-  | succ N ih =>
-    let B : Set Ω := ⋂ n ∈ Finset.range N, success n
-    have hB : MeasurableSet[F N] B := by
-      apply MeasurableSet.iInter
-      intro n
-      apply MeasurableSet.iInter
-      intro hn
-      exact (F.mono (Nat.succ_le_of_lt (Finset.mem_range.mp hn))) _ (hmeas n)
-    have he : (⋂ n ∈ Finset.range (N + 1), success n) = B ∩ success N := by
-      ext ω
-      simp only [mem_iInter, Finset.mem_range, mem_inter_iff, B]
-      constructor
-      · intro hω
-        exact ⟨fun n hn => hω n (Nat.lt_succ_of_lt hn), hω N (Nat.lt_succ_self N)⟩
-      · rintro ⟨hω, hN⟩ n hn
-        rcases Nat.lt_succ_iff_lt_or_eq.mp hn with hn | rfl
-        · exact hω n hn
-        · exact hN
-    rw [he, pow_succ]
-    calc
-      q ^ N * q * P univ = q * (q ^ N * P univ) := by ac_rfl
-      _ ≤ q * P B := mul_le_mul' le_rfl ih
-      _ ≤ P (B ∩ success N) := hstep N B hB
-
-lemma ribbon_mass_power_cancellation (κ : ℝ) {m : ℝ} (hm : 0 < m) :
-    m ^ 2 * (1 / m) ^ dimension κ = m ^ codimension κ := by
-  rw [one_div, Real.inv_rpow hm.le, ← Real.rpow_neg hm.le,
-    ← Real.rpow_two, ← Real.rpow_add hm]
-  rfl
-
-/-- The disjoint middle strips of `m²` steps of width `1/m` carry mass of
-order `m^(2-d)`, with no dependence assumption in this deterministic sum. -/
-theorem ribbon_m_squared_mass_lower {ι : Type*} (I : Finset ι)
-    (ν : Measure ℂ) (D : ι → Set ℂ)
-    (hdisj : (I : Set ι).PairwiseDisjoint D)
-    (hmeas : ∀ i ∈ I, MeasurableSet (D i))
-    (κ : ℝ) (m : ℕ) (hm : 0 < m) (hcard : I.card = m ^ 2)
-    (b : ℝ) (_hb : 0 ≤ b)
-    (hmass : ∀ i ∈ I, ENNReal.ofReal (b * (1 / (m : ℝ)) ^ dimension κ) ≤ ν (D i)) :
-    ENNReal.ofReal (b * (m : ℝ) ^ codimension κ) ≤ ν (⋃ i ∈ I, D i) := by
-  have hmR : (0 : ℝ) < m := by exact_mod_cast hm
-  rw [measure_biUnion_finset hdisj hmeas]
-  calc
-    _ = ∑ _i ∈ I, ENNReal.ofReal (b * (1 / (m : ℝ)) ^ dimension κ) := by
-      rw [Finset.sum_const, nsmul_eq_mul, hcard,
-        ← ENNReal.ofReal_natCast, ← ENNReal.ofReal_mul (Nat.cast_nonneg _)]
-      congr 1
-      rw [Nat.cast_pow]
-      calc
-        b * (m : ℝ) ^ codimension κ = b *
-            ((m : ℝ) ^ 2 * (1 / (m : ℝ)) ^ dimension κ) := by
-          rw [ribbon_mass_power_cancellation κ hmR]
-        _ = _ := by ring
-    _ ≤ _ := Finset.sum_le_sum hmass
-
-/-- A quadratic number of fixed-probability passages has the exponential
-cost used by the dense visit. -/
-theorem ribbon_quadratic_probability {q : ℝ} (hq : 0 < q) (hq1 : q ≤ 1) :
-    ∃ C : ℝ, 0 < C ∧ ∀ m : ℕ,
-      Real.exp (-C * (m : ℝ) ^ 2) ≤ q ^ (m ^ 2) := by
-  have hlog : Real.log q ≤ 0 := Real.log_nonpos hq.le hq1
-  refine ⟨1 - Real.log q, by linarith, ?_⟩
-  intro m
-  calc
-    _ ≤ Real.exp ((m ^ 2 : ℕ) * Real.log q) := by
-      apply Real.exp_le_exp.mpr
-      rw [Nat.cast_pow]
-      nlinarith [sq_nonneg (m : ℝ)]
-    _ = q ^ (m ^ 2) := by rw [Real.exp_nat_mul, Real.exp_log hq]
-
-end SLEExactGauge
-
-end
-
-end OAI
+import OAI.Probability.SLE.Gauge.DenseCoverCore
+
+namespace OAI
+
+/-! Adapted concatenation and the mass/probability scaling of a serpentine
+ribbon with a quadratic number of narrow steps. -/
+
+noncomputable section
+open Set Filter MeasureTheory
+open scoped Topology ENNReal NNReal
+
+namespace SLEExactGauge
+
+/-- Success probabilities multiply as lower bounds under adapted restarts.
+The successive steps need not be independent. -/
+theorem adapted_successes_lower_bound
+    {Ω : Type*} [mΩ : MeasurableSpace Ω] (P : Measure Ω)
+    (F : Filtration ℕ mΩ) (success : ℕ → Set Ω)
+    (hmeas : ∀ n, MeasurableSet[F (n + 1)] (success n))
+    (q : ℝ≥0∞)
+    (hstep : ∀ n (B : Set Ω), MeasurableSet[F n] B →
+      q * P B ≤ P (B ∩ success n)) :
+    ∀ N : ℕ, q ^ N * P univ ≤ P (⋂ n ∈ Finset.range N, success n) := by
+  intro N
+  induction N with
+  | zero => simp
+  | succ N ih =>
+    let B : Set Ω := ⋂ n ∈ Finset.range N, success n
+    have hB : MeasurableSet[F N] B := by
+      apply MeasurableSet.iInter
+      intro n
+      apply MeasurableSet.iInter
+      intro hn
+      exact (F.mono (Nat.succ_le_of_lt (Finset.mem_range.mp hn))) _ (hmeas n)
+    have he : (⋂ n ∈ Finset.range (N + 1), success n) = B ∩ success N := by
+      ext ω
+      simp only [mem_iInter, Finset.mem_range, mem_inter_iff, B]
+      constructor
+      · intro hω
+        exact ⟨fun n hn => hω n (Nat.lt_succ_of_lt hn), hω N (Nat.lt_succ_self N)⟩
+      · rintro ⟨hω, hN⟩ n hn
+        rcases Nat.lt_succ_iff_lt_or_eq.mp hn with hn | rfl
+        · exact hω n hn
+        · exact hN
+    rw [he, pow_succ]
+    calc
+      q ^ N * q * P univ = q * (q ^ N * P univ) := by ac_rfl
+      _ ≤ q * P B := mul_le_mul' le_rfl ih
+      _ ≤ P (B ∩ success N) := hstep N B hB
+
+lemma ribbon_mass_power_cancellation (κ : ℝ) {m : ℝ} (hm : 0 < m) :
+    m ^ 2 * (1 / m) ^ dimension κ = m ^ codimension κ := by
+  rw [one_div, Real.inv_rpow hm.le, ← Real.rpow_neg hm.le,
+    ← Real.rpow_two, ← Real.rpow_add hm]
+  rfl
+
+/-- The disjoint middle strips of `m²` steps of width `1/m` carry mass of
+order `m^(2-d)`, with no dependence assumption in this deterministic sum. -/
+theorem ribbon_m_squared_mass_lower {ι : Type*} (I : Finset ι)
+    (ν : Measure ℂ) (D : ι → Set ℂ)
+    (hdisj : (I : Set ι).PairwiseDisjoint D)
+    (hmeas : ∀ i ∈ I, MeasurableSet (D i))
+    (κ : ℝ) (m : ℕ) (hm : 0 < m) (hcard : I.card = m ^ 2)
+    (b : ℝ) (_hb : 0 ≤ b)
+    (hmass : ∀ i ∈ I, ENNReal.ofReal (b * (1 / (m : ℝ)) ^ dimension κ) ≤ ν (D i)) :
+    ENNReal.ofReal (b * (m : ℝ) ^ codimension κ) ≤ ν (⋃ i ∈ I, D i) := by
+  have hmR : (0 : ℝ) < m := by exact_mod_cast hm
+  rw [measure_biUnion_finset hdisj hmeas]
+  calc
+    _ = ∑ _i ∈ I, ENNReal.ofReal (b * (1 / (m : ℝ)) ^ dimension κ) := by
+      rw [Finset.sum_const, nsmul_eq_mul, hcard,
+        ← ENNReal.ofReal_natCast, ← ENNReal.ofReal_mul (Nat.cast_nonneg _)]
+      congr 1
+      rw [Nat.cast_pow]
+      calc
+        b * (m : ℝ) ^ codimension κ = b *
+            ((m : ℝ) ^ 2 * (1 / (m : ℝ)) ^ dimension κ) := by
+          rw [ribbon_mass_power_cancellation κ hmR]
+        _ = _ := by ring
+    _ ≤ _ := Finset.sum_le_sum hmass
+
+/-- A quadratic number of fixed-probability passages has the exponential
+cost used by the dense visit. -/
+theorem ribbon_quadratic_probability {q : ℝ} (hq : 0 < q) (hq1 : q ≤ 1) :
+    ∃ C : ℝ, 0 < C ∧ ∀ m : ℕ,
+      Real.exp (-C * (m : ℝ) ^ 2) ≤ q ^ (m ^ 2) := by
+  have hlog : Real.log q ≤ 0 := Real.log_nonpos hq.le hq1
+  refine ⟨1 - Real.log q, by linarith, ?_⟩
+  intro m
+  calc
+    _ ≤ Real.exp ((m ^ 2 : ℕ) * Real.log q) := by
+      apply Real.exp_le_exp.mpr
+      rw [Nat.cast_pow]
+      nlinarith [sq_nonneg (m : ℝ)]
+    _ = q ^ (m ^ 2) := by rw [Real.exp_nat_mul, Real.exp_log hq]
+
+end SLEExactGauge
+
+end
+
+end OAI

lean/OAI/Probability/SLE/Gauge/RibbonCoordinateCompactness.lean

@@ -1,350 +1,350 @@
-import OAI.Probability.SLE.Gauge.RibbonCoordinateGeometry
-import Mathlib.Topology.ContinuousMap.Bounded.ArzelaAscoli
-
-namespace OAI
-
-/-! Common physical domains and convergence of inverse ribbon coordinates
-on a fixed compact coordinate patch. The uniform lower Lipschitz bound
-controls the inverse without requiring derivative convergence. -/
-
-noncomputable section
-open Set Filter Metric
-open scoped Topology NNReal BoundedContinuousFunction
-
-namespace SLEExactGauge.RibbonCoordinates
-
-def coordinateInverse (P : ℂ → ℂ) (K : Set ℂ) : ℂ → ℂ := Function.invFunOn P K
-
-theorem coordinateInverse_mem {P : ℂ → ℂ} {K : Set ℂ} {z : ℂ}
-    (hz : z ∈ P '' K) : coordinateInverse P K z ∈ K :=
-  Function.invFunOn_mem hz
-
-theorem coordinateInverse_right {P : ℂ → ℂ} {K : Set ℂ} {z : ℂ}
-    (hz : z ∈ P '' K) : P (coordinateInverse P K z) = z :=
-  Function.invFunOn_eq hz
-
-theorem coordinateInverse_left {P : ℂ → ℂ} {K : Set ℂ}
-    (hi : InjOn P K) {z : ℂ} (hz : z ∈ K) :
-    coordinateInverse P K (P z) = z :=
-  hi.leftInvOn_invFunOn hz
-
-/-- Physical coordinate regions agree with inverse-coordinate membership. -/
-theorem coordinate_image_region_iff {P : ℂ → ℂ} {K A : Set ℂ}
-    (hi : InjOn P K) (hA : A ⊆ K) {z : ℂ} :
-    z ∈ P '' A ↔ z ∈ P '' K ∧ coordinateInverse P K z ∈ A := by
-  constructor
-  · rintro ⟨x, hx, rfl⟩
-    exact ⟨mem_image_of_mem P (hA hx), by simpa only [coordinateInverse_left hi (hA hx)] using hx⟩
-  · rintro ⟨hz, hAq⟩
-    exact ⟨coordinateInverse P K z, hAq, coordinateInverse_right hz⟩
-
-theorem coordinateInverse_lipschitz
-    (P : ℂ → ℂ) (K : Set ℂ) (L : ℝ≥0)
-    (hlower : ∀ x ∈ K, ∀ y ∈ K, dist x y ≤ L * dist (P x) (P y)) :
-    LipschitzOnWith L (coordinateInverse P K) (P '' K) := by
-  apply lipschitzOnWith_iff_dist_le_mul.mpr
-  intro x hx y hy
-  have hh := hlower _ (coordinateInverse_mem hx) _ (coordinateInverse_mem hy)
-  simpa only [coordinateInverse_right hx, coordinateInverse_right hy] using hh
-
-theorem lower_lipschitz_uniform_limit
-    (Pₙ : ℕ → ℂ → ℂ) (P : ℂ → ℂ) (K : Set ℂ) (L : ℝ≥0)
-    (hconv : TendstoUniformlyOn Pₙ P atTop K)
-    (hlower : ∀ n x, x ∈ K → ∀ y, y ∈ K → dist x y ≤ L * dist (Pₙ n x) (Pₙ n y)) :
-    ∀ x ∈ K, ∀ y ∈ K, dist x y ≤ L * dist (P x) (P y) := by
-  intro x hx y hy
-  exact ge_of_tendsto (tendsto_const_nhds.mul ((hconv.tendsto_at hx).dist (hconv.tendsto_at hy)))
-    (Eventually.of_forall fun n => hlower n x hx y hy)
-
-/-- Common image containment converts uniform forward convergence into
-uniform inverse convergence on any retained physical set. -/
-theorem coordinateInverse_uniform_on
-    (Pₙ : ℕ → ℂ → ℂ) (P : ℂ → ℂ) (K S : Set ℂ) (L : ℝ≥0)
-    (hconv : TendstoUniformlyOn Pₙ P atTop K)
-    (hlower : ∀ n x, x ∈ K → ∀ y, y ∈ K → dist x y ≤ L * dist (Pₙ n x) (Pₙ n y))
-    (hSP : S ⊆ P '' K) (hcover : ∀ᶠ n in atTop, S ⊆ Pₙ n '' K) :
-    TendstoUniformlyOn (fun n => coordinateInverse (Pₙ n) K) (coordinateInverse P K) atTop S := by
-  apply Metric.tendstoUniformlyOn_iff.mpr
-  intro ε hε
-  have hL : 0 < (L : ℝ) + 1 := by positivity
-  have hη : 0 < ε / ((L : ℝ) + 1) := div_pos hε hL
-  filter_upwards [hcover, Metric.tendstoUniformlyOn_iff.mp hconv _ hη] with n hn hclose
-  intro z hz
-  have hq : coordinateInverse P K z ∈ K := coordinateInverse_mem (hSP hz)
-  have hqn : coordinateInverse (Pₙ n) K z ∈ K := coordinateInverse_mem (hn hz)
-  have he := hlower n _ hqn _ hq
-  rw [coordinateInverse_right (hn hz)] at he
-  have hd := hclose _ hq
-  rw [coordinateInverse_right (hSP hz)] at hd
-  have he' : dist (coordinateInverse P K z) (coordinateInverse (Pₙ n) K z) ≤
-      (L : ℝ) * dist z (Pₙ n (coordinateInverse P K z)) := by
-    simpa only [dist_comm] using he
-  calc
-    _ ≤ (L : ℝ) * dist z (Pₙ n (coordinateInverse P K z)) := he'
-    _ ≤ ((L : ℝ) + 1) * dist z (Pₙ n (coordinateInverse P K z)) :=
-      mul_le_mul_of_nonneg_right (by linarith) dist_nonneg
-    _ < ((L : ℝ) + 1) * (ε / ((L : ℝ) + 1)) := mul_lt_mul_of_pos_left hd hL
-    _ = ε := mul_div_cancel₀ ε hL.ne'
-
-/-- The uniform inverse bound makes every coordinate chart injective. -/
-theorem lower_lipschitz_injOn
-    (P : ℂ → ℂ) (K : Set ℂ) (L : ℝ≥0)
-    (hlower : ∀ x ∈ K, ∀ y ∈ K, dist x y ≤ L * dist (P x) (P y)) :
-    InjOn P K := by
-  intro x hx y hy he
-  have hh := hlower x hx y hy
-  rw [he, dist_self, mul_zero] at hh
-  exact dist_eq_zero.mp (le_antisymm hh dist_nonneg)
-
-/-- The limiting coordinate image has an open interior physical domain. -/
-theorem isOpen_image_interior
-    (hpublished : PublishedPlanarDiskOpenness)
-    (P : ℂ → ℂ) (K : Set ℂ)
-    (hP : ContinuousOn P K) (hi : InjOn P K) :
-    IsOpen (P '' interior K) := by
-  apply isOpen_iff_mem_nhds.mpr
-  rintro z ⟨x, hx, rfl⟩
-  obtain ⟨r, hr, hball⟩ := Metric.isOpen_iff.mp isOpen_interior x hx
-  have hsub : ball x r ⊆ K := hball.trans interior_subset
-  have hopen := hpublished P x r hr (hP.mono hsub) (hi.mono hsub)
-  exact mem_of_superset
-    (hopen.mem_nhds (mem_image_of_mem P (mem_ball_self hr)))
-    (image_mono hball)
-
-/-- Compact physical subsets of the limiting interior image belong to
-all sufficiently late moving interior images. -/
-theorem eventual_compact_image_interior
-    (hpublished : PublishedPlanarDiskOpenness)
-    (Pₙ : ℕ → ℂ → ℂ) (P : ℂ → ℂ) (K S : Set ℂ) (L : ℝ≥0)
-    (hL : 0 < L)
-    (hPn : ∀ n, ContinuousOn (Pₙ n) K)
-    (hconv : TendstoUniformlyOn Pₙ P atTop K)
-    (hlower : ∀ n x, x ∈ K → ∀ y, y ∈ K → dist x y ≤ L * dist (Pₙ n x) (Pₙ n y))
-    (hS : IsCompact S) (hSP : S ⊆ P '' interior K) :
-    ∀ᶠ n in atTop, S ⊆ Pₙ n '' interior K := by
-  have hlim := lower_lipschitz_uniform_limit Pₙ P K L hconv hlower
-  have hi := lower_lipschitz_injOn P K L hlim
-  have hSK : S ⊆ P '' K := hSP.trans (image_mono interior_subset)
-  let Q := coordinateInverse P K '' S
-  have hQ : IsCompact Q := hS.image_of_continuousOn
-    ((coordinateInverse_lipschitz P K L hlim).continuousOn.mono hSK)
-  have hQK : Q ⊆ interior K := by
-    rintro _ ⟨z, hz, rfl⟩
-    obtain ⟨x, hx, he⟩ := hSP hz
-    have hqx : coordinateInverse P K z = x := hi
-      (coordinateInverse_mem (hSK hz)) (interior_subset hx)
-      ((coordinateInverse_right (hSK hz)).trans he.symm)
-    simpa only [hqx] using hx
-  obtain ⟨ρ, hρ, hthick⟩ := hQ.exists_cthickening_subset_open isOpen_interior hQK
-  have hLr : 0 < (L : ℝ) := hL
-  filter_upwards [Metric.tendstoUniformlyOn_iff.mp hconv (ρ / L) (div_pos hρ hLr)] with n hn
-  intro z hz
-  let x := coordinateInverse P K z
-  have hxQ : x ∈ Q := mem_image_of_mem _ hz
-  have hxK : x ∈ K := interior_subset (hQK hxQ)
-  have hball : closedBall x ρ ⊆ interior K := by
-    intro y hy
-    exact hthick (mem_cthickening_of_dist_le y x ρ Q hxQ hy)
-  have hballK := hball.trans interior_subset
-  have hiₙ := lower_lipschitz_injOn (Pₙ n) K L (hlower n)
-  have hopen := hpublished (Pₙ n) x ρ hρ
-    ((hPn n).mono (ball_subset_closedBall.trans hballK))
-    (hiₙ.mono (ball_subset_closedBall.trans hballK))
-  have hcontains := ball_subset_image_ball (Pₙ n) x hρ hLr
-    ((hPn n).mono hballK) hopen
-    (fun y hy => hlower n y (hballK hy) x hxK)
-  apply (image_mono (ball_subset_closedBall.trans hball))
-  apply hcontains
-  have hh := hn x hxK
-  rw [coordinateInverse_right (hSK hz)] at hh
-  simpa only [mem_ball, dist_comm] using hh
-
-/-- The inverse ribbon charts converge locally uniformly on the full
-limiting interior image. Only compact subsets are eventually common. -/
-theorem coordinateInverse_locally_uniform
-    (hpublished : PublishedPlanarDiskOpenness)
-    (Pₙ : ℕ → ℂ → ℂ) (P : ℂ → ℂ) (K : Set ℂ) (L : ℝ≥0)
-    (hL : 0 < L) (hP : ContinuousOn P K)
-    (hPn : ∀ n, ContinuousOn (Pₙ n) K)
-    (hconv : TendstoUniformlyOn Pₙ P atTop K)
-    (hlower : ∀ n x, x ∈ K → ∀ y, y ∈ K → dist x y ≤ L * dist (Pₙ n x) (Pₙ n y)) :
-    TendstoLocallyUniformlyOn (fun n => coordinateInverse (Pₙ n) K)
-      (coordinateInverse P K) atTop (P '' interior K) := by
-  have hlim := lower_lipschitz_uniform_limit Pₙ P K L hconv hlower
-  have hopen := isOpen_image_interior hpublished P K hP
-    (lower_lipschitz_injOn P K L hlim)
-  apply (tendstoLocallyUniformlyOn_iff_forall_isCompact hopen).mpr
-  intro S hSP hS
-  exact coordinateInverse_uniform_on Pₙ P K S L hconv hlower
-    (hSP.trans (image_mono interior_subset))
-    ((eventual_compact_image_interior hpublished Pₙ P K S L hL hPn hconv hlower hS hSP).mono
-      (fun _ h => h.trans (image_mono interior_subset)))
-
-/-- A compact retained physical patch admits one common open neighborhood
-contained in every sufficiently late coordinate image. -/
-theorem common_physical_neighborhood
-    (hpublished : PublishedPlanarDiskOpenness)
-    (Pₙ : ℕ → ℂ → ℂ) (P : ℂ → ℂ) (K A : Set ℂ) (L : ℝ≥0)
-    (hL : 0 < L) (hP : ContinuousOn P K)
-    (hPn : ∀ n, ContinuousOn (Pₙ n) K)
-    (hconv : TendstoUniformlyOn Pₙ P atTop K)
-    (hlower : ∀ n x, x ∈ K → ∀ y, y ∈ K → dist x y ≤ L * dist (Pₙ n x) (Pₙ n y))
-    (hA : IsCompact A) (hAP : A ⊆ P '' interior K) :
-    ∃ U : Set ℂ, IsOpen U ∧ A ⊆ U ∧ IsCompact (closure U) ∧
-      closure U ⊆ P '' interior K ∧
-      (∀ᶠ n in atTop, closure U ⊆ Pₙ n '' interior K) ∧
-      TendstoUniformlyOn (fun n => coordinateInverse (Pₙ n) K)
-        (coordinateInverse P K) atTop (closure U) := by
-  have hlim := lower_lipschitz_uniform_limit Pₙ P K L hconv hlower
-  have hopen := isOpen_image_interior hpublished P K hP
-    (lower_lipschitz_injOn P K L hlim)
-  obtain ⟨ρ, hρ, hthick⟩ := hA.exists_cthickening_subset_open hopen hAP
-  let U := thickening ρ A
-  have hclosure : closure U ⊆ cthickening ρ A := closure_thickening_subset_cthickening ρ A
-  have hUc : IsCompact (closure U) := (hA.cthickening).of_isClosed_subset isClosed_closure hclosure
-  have hUP : closure U ⊆ P '' interior K := hclosure.trans hthick
-  have hlate := eventual_compact_image_interior hpublished Pₙ P K (closure U) L hL hPn
-    hconv hlower hUc hUP
-  exact ⟨U, isOpen_thickening, self_subset_thickening hρ A, hUc, hUP, hlate,
-    coordinateInverse_uniform_on Pₙ P K (closure U) L hconv hlower
-      (hUP.trans (image_mono interior_subset))
-      (hlate.mono (fun _ h => h.trans (image_mono interior_subset)))⟩
-
-/-- The source longitudinal coordinate is the real part of the inverse
-ribbon chart, translated by the current front coordinate. -/
-def longitudinalCoordinate (P : ℂ → ℂ) (K : Set ℂ) (k : ℝ) (z : ℂ) : ℝ :=
-  (coordinateInverse P K z).re - k
-
-theorem longitudinalCoordinate_locally_uniform
-    (hpublished : PublishedPlanarDiskOpenness)
-    (Pₙ : ℕ → ℂ → ℂ) (P : ℂ → ℂ) (K : Set ℂ) (L : ℝ≥0) (k : ℝ)
-    (hL : 0 < L) (hP : ContinuousOn P K)
-    (hPn : ∀ n, ContinuousOn (Pₙ n) K)
-    (hconv : TendstoUniformlyOn Pₙ P atTop K)
-    (hlower : ∀ n x, x ∈ K → ∀ y, y ∈ K → dist x y ≤ L * dist (Pₙ n x) (Pₙ n y)) :
-    TendstoLocallyUniformlyOn (fun n => longitudinalCoordinate (Pₙ n) K k)
-      (longitudinalCoordinate P K k) atTop (P '' interior K) := by
-  have hh := coordinateInverse_locally_uniform hpublished Pₙ P K L hL hP hPn hconv hlower
-  have hu : UniformContinuous (fun z : ℂ => z.re - k) :=
-    Complex.uniformContinuous_re.sub uniformContinuous_const
-  exact hu.comp_tendstoLocallyUniformlyOn hh
-
-theorem longitudinalCoordinate_continuousOn
-    (P : ℂ → ℂ) (K : Set ℂ) (L : ℝ≥0) (k : ℝ)
-    (hlower : ∀ x ∈ K, ∀ y ∈ K, dist x y ≤ L * dist (P x) (P y)) :
-    ContinuousOn (longitudinalCoordinate P K k) (P '' K) := by
-  exact (Complex.continuous_re.comp_continuousOn
-    (coordinateInverse_lipschitz P K L hlower).continuousOn).sub continuousOn_const
-
-/-- A retained compact part of a ribbon has a common open physical chart
-on which the actual longitudinal coordinates are eventually continuous
-and converge locally uniformly. -/
-theorem common_longitudinal_chart
-    (hpublished : PublishedPlanarDiskOpenness)
-    (Pₙ : ℕ → ℂ → ℂ) (P : ℂ → ℂ) (K A : Set ℂ) (L : ℝ≥0) (k : ℝ)
-    (hL : 0 < L) (hP : ContinuousOn P K)
-    (hPn : ∀ n, ContinuousOn (Pₙ n) K)
-    (hconv : TendstoUniformlyOn Pₙ P atTop K)
-    (hlower : ∀ n x, x ∈ K → ∀ y, y ∈ K → dist x y ≤ L * dist (Pₙ n x) (Pₙ n y))
-    (hA : IsCompact A) (hAP : A ⊆ P '' interior K) :
-    ∃ U : Set ℂ, IsOpen U ∧ A ⊆ U ∧ IsCompact (closure U) ∧
-      closure U ⊆ P '' interior K ∧
-      (∀ᶠ n in atTop, U ⊆ Pₙ n '' interior K) ∧
-      ContinuousOn (longitudinalCoordinate P K k) U ∧
-      (∀ᶠ n in atTop, ContinuousOn (longitudinalCoordinate (Pₙ n) K k) U) ∧
-      TendstoLocallyUniformlyOn (fun n => longitudinalCoordinate (Pₙ n) K k)
-        (longitudinalCoordinate P K k) atTop U := by
-  obtain ⟨U, hU, hAU, hUc, hUP, hlate, _⟩ := common_physical_neighborhood
-    hpublished Pₙ P K A L hL hP hPn hconv hlower hA hAP
-  have hUImage : U ⊆ P '' interior K := subset_closure.trans hUP
-  have hlim := lower_lipschitz_uniform_limit Pₙ P K L hconv hlower
-  refine ⟨U, hU, hAU, hUc, hUP, hlate.mono (fun _ h => subset_closure.trans h),
-    (longitudinalCoordinate_continuousOn P K L k hlim).mono
-      (hUImage.trans (image_mono interior_subset)), ?_, ?_⟩
-  · filter_upwards [hlate] with n hn
-    exact (longitudinalCoordinate_continuousOn (Pₙ n) K L k (hlower n)).mono
-      (subset_closure.trans (hn.trans (image_mono interior_subset)))
-  · exact (longitudinalCoordinate_locally_uniform hpublished Pₙ P K L k hL hP hPn
-      hconv hlower).mono hUImage
-
-/-- A compact set with limiting coordinates in an open coordinate region
-has its moving coordinates in that same region for all sufficiently late
-charts. This includes simultaneous longitudinal and transverse margins. -/
-theorem eventual_compact_coordinate_region
-    (Pₙ : ℕ → ℂ → ℂ) (P : ℂ → ℂ) (K S A : Set ℂ) (L : ℝ≥0)
-    (hconv : TendstoUniformlyOn Pₙ P atTop K)
-    (hlower : ∀ n x, x ∈ K → ∀ y, y ∈ K → dist x y ≤ L * dist (Pₙ n x) (Pₙ n y))
-    (hS : IsCompact S) (hSP : S ⊆ P '' K)
-    (hcover : ∀ᶠ n in atTop, S ⊆ Pₙ n '' K)
-    (hA : IsOpen A) (hSA : coordinateInverse P K '' S ⊆ A) :
-    ∀ᶠ n in atTop, S ⊆ Pₙ n '' (K ∩ A) := by
-  have hlim := lower_lipschitz_uniform_limit Pₙ P K L hconv hlower
-  have hcompact : IsCompact (coordinateInverse P K '' S) :=
-    hS.image_of_continuousOn ((coordinateInverse_lipschitz P K L hlim).continuousOn.mono hSP)
-  obtain ⟨ε, hε, heps⟩ := hcompact.exists_thickening_subset_open hA hSA
-  have hu := coordinateInverse_uniform_on Pₙ P K S L hconv hlower hSP hcover
-  filter_upwards [hcover, Metric.tendstoUniformlyOn_iff.mp hu ε hε] with n hn hclose
-  intro z hz
-  refine ⟨coordinateInverse (Pₙ n) K z, ⟨coordinateInverse_mem (hn hz), ?_⟩,
-    coordinateInverse_right (hn hz)⟩
-  exact heps (mem_thickening_iff.mpr ⟨coordinateInverse P K z, mem_image_of_mem _ hz,
-    by simpa only [dist_comm] using hclose z hz⟩)
-
-/-- The admissible two-point patch bounds and a bounded marked point give
-an actual uniformly convergent subsequence of the coordinate maps. Both
-Lipschitz bounds pass to the limit, retaining an embedded limiting patch. -/
-theorem exists_bilip_uniform_subsequence
-    (Pₙ : ℕ → ℂ → ℂ) (K : Set ℂ) (hK : IsCompact K)
-    (x₀ : ℂ) (hx₀ : x₀ ∈ K) (C L : ℝ≥0) (R : ℝ)
-    (hupper : ∀ n, LipschitzOnWith C (Pₙ n) K)
-    (hlower : ∀ n x, x ∈ K → ∀ y, y ∈ K → dist x y ≤ L * dist (Pₙ n x) (Pₙ n y))
-    (htip : ∀ n, ‖Pₙ n x₀‖ ≤ R) :
-    ∃ P : ℂ → ℂ, ∃ φ : ℕ → ℕ, StrictMono φ ∧
-      TendstoUniformlyOn (fun n => Pₙ (φ n)) P atTop K ∧
-      LipschitzOnWith C P K ∧
-      (∀ x ∈ K, ∀ y ∈ K, dist x y ≤ L * dist (P x) (P y)) ∧
-      InjOn P K := by
-  classical
-  let : CompactSpace K := isCompact_iff_compactSpace.mp hK
-  let f : ℕ → K →ᵇ ℂ := fun n => BoundedContinuousFunction.mkOfCompact
-    ⟨K.domRestrict (Pₙ n), (hupper n).continuousOn.domRestrict⟩
-  obtain ⟨M, hM⟩ := hK.isBounded.subset_closedBall x₀
-  have hbound n (x : K) : ‖f n x‖ ≤ R + C * M := by
-    have hd := (hupper n).dist_le_mul x x.property x₀ hx₀
-    have hh := norm_le_norm_add_const_of_dist_le hd
-    exact hh.trans (add_le_add (htip n)
-      (mul_le_mul_of_nonneg_left (hM x.property) C.coe_nonneg))
-  have heq : Equicontinuous ((↑) : Set.range f → K → ℂ) := by
-    apply (LipschitzWith.uniformEquicontinuous _ C ?_).equicontinuous
-    rintro ⟨g, n, rfl⟩
-    exact (hupper n).to_restrict
-  have hcompact : IsCompact (closure (Set.range f)) :=
-    BoundedContinuousFunction.arzela_ascoli (closedBall (0 : ℂ) (R + C * M))
-      (isCompact_closedBall _ _) (Set.range f)
-      (by rintro g x ⟨n, rfl⟩; simpa only [mem_closedBall, dist_zero_right] using hbound n x)
-      heq
-  obtain ⟨b, _, φ, hφ, hlim⟩ := hcompact.tendsto_subseq
-    (fun n => subset_closure (mem_range_self n))
-  have hb : TendstoUniformly (fun n => f (φ n)) b atTop :=
-    BoundedContinuousFunction.tendsto_iff_tendstoUniformly.mp hlim
-  let P : ℂ → ℂ := fun z => if hz : z ∈ K then b ⟨z, hz⟩ else 0
-  have hu : TendstoUniformlyOn (fun n => Pₙ (φ n)) P atTop K := by
-    apply Metric.tendstoUniformlyOn_iff.mpr
-    intro ε hε
-    filter_upwards [Metric.tendstoUniformly_iff.mp hb ε hε] with n hn
-    intro z hz
-    simpa [P, f, hz] using hn ⟨z, hz⟩
-  have hPu : LipschitzOnWith C P K := by
-    apply lipschitzOnWith_iff_dist_le_mul.mpr
-    intro x hx y hy
-    exact le_of_tendsto ((hu.tendsto_at hx).dist (hu.tendsto_at hy))
-      (Eventually.of_forall fun n => (hupper (φ n)).dist_le_mul x hx y hy)
-  have hPl := lower_lipschitz_uniform_limit (fun n => Pₙ (φ n)) P K L hu
-    (fun n => hlower (φ n))
-  exact ⟨P, φ, hφ, hu, hPu, hPl, lower_lipschitz_injOn P K L hPl⟩
-
-end SLEExactGauge.RibbonCoordinates
-
-end
-
-end OAI
+import OAI.Probability.SLE.Gauge.RibbonCoordinateGeometry
+import Mathlib.Topology.ContinuousMap.Bounded.ArzelaAscoli
+
+namespace OAI
+
+/-! Common physical domains and convergence of inverse ribbon coordinates
+on a fixed compact coordinate patch. The uniform lower Lipschitz bound
+controls the inverse without requiring derivative convergence. -/
+
+noncomputable section
+open Set Filter Metric
+open scoped Topology NNReal BoundedContinuousFunction
+
+namespace SLEExactGauge.RibbonCoordinates
+
+def coordinateInverse (P : ℂ → ℂ) (K : Set ℂ) : ℂ → ℂ := Function.invFunOn P K
+
+theorem coordinateInverse_mem {P : ℂ → ℂ} {K : Set ℂ} {z : ℂ}
+    (hz : z ∈ P '' K) : coordinateInverse P K z ∈ K :=
+  Function.invFunOn_mem hz
+
+theorem coordinateInverse_right {P : ℂ → ℂ} {K : Set ℂ} {z : ℂ}
+    (hz : z ∈ P '' K) : P (coordinateInverse P K z) = z :=
+  Function.invFunOn_eq hz
+
+theorem coordinateInverse_left {P : ℂ → ℂ} {K : Set ℂ}
+    (hi : InjOn P K) {z : ℂ} (hz : z ∈ K) :
+    coordinateInverse P K (P z) = z :=
+  hi.leftInvOn_invFunOn hz
+
+/-- Physical coordinate regions agree with inverse-coordinate membership. -/
+theorem coordinate_image_region_iff {P : ℂ → ℂ} {K A : Set ℂ}
+    (hi : InjOn P K) (hA : A ⊆ K) {z : ℂ} :
+    z ∈ P '' A ↔ z ∈ P '' K ∧ coordinateInverse P K z ∈ A := by
+  constructor
+  · rintro ⟨x, hx, rfl⟩
+    exact ⟨mem_image_of_mem P (hA hx), by simpa only [coordinateInverse_left hi (hA hx)] using hx⟩
+  · rintro ⟨hz, hAq⟩
+    exact ⟨coordinateInverse P K z, hAq, coordinateInverse_right hz⟩
+
+theorem coordinateInverse_lipschitz
+    (P : ℂ → ℂ) (K : Set ℂ) (L : ℝ≥0)
+    (hlower : ∀ x ∈ K, ∀ y ∈ K, dist x y ≤ L * dist (P x) (P y)) :
+    LipschitzOnWith L (coordinateInverse P K) (P '' K) := by
+  apply lipschitzOnWith_iff_dist_le_mul.mpr
+  intro x hx y hy
+  have hh := hlower _ (coordinateInverse_mem hx) _ (coordinateInverse_mem hy)
+  simpa only [coordinateInverse_right hx, coordinateInverse_right hy] using hh
+
+theorem lower_lipschitz_uniform_limit
+    (Pₙ : ℕ → ℂ → ℂ) (P : ℂ → ℂ) (K : Set ℂ) (L : ℝ≥0)
+    (hconv : TendstoUniformlyOn Pₙ P atTop K)
+    (hlower : ∀ n x, x ∈ K → ∀ y, y ∈ K → dist x y ≤ L * dist (Pₙ n x) (Pₙ n y)) :
+    ∀ x ∈ K, ∀ y ∈ K, dist x y ≤ L * dist (P x) (P y) := by
+  intro x hx y hy
+  exact ge_of_tendsto (tendsto_const_nhds.mul ((hconv.tendsto_at hx).dist (hconv.tendsto_at hy)))
+    (Eventually.of_forall fun n => hlower n x hx y hy)
+
+/-- Common image containment converts uniform forward convergence into
+uniform inverse convergence on any retained physical set. -/
+theorem coordinateInverse_uniform_on
+    (Pₙ : ℕ → ℂ → ℂ) (P : ℂ → ℂ) (K S : Set ℂ) (L : ℝ≥0)
+    (hconv : TendstoUniformlyOn Pₙ P atTop K)
+    (hlower : ∀ n x, x ∈ K → ∀ y, y ∈ K → dist x y ≤ L * dist (Pₙ n x) (Pₙ n y))
+    (hSP : S ⊆ P '' K) (hcover : ∀ᶠ n in atTop, S ⊆ Pₙ n '' K) :
+    TendstoUniformlyOn (fun n => coordinateInverse (Pₙ n) K) (coordinateInverse P K) atTop S := by
+  apply Metric.tendstoUniformlyOn_iff.mpr
+  intro ε hε
+  have hL : 0 < (L : ℝ) + 1 := by positivity
+  have hη : 0 < ε / ((L : ℝ) + 1) := div_pos hε hL
+  filter_upwards [hcover, Metric.tendstoUniformlyOn_iff.mp hconv _ hη] with n hn hclose
+  intro z hz
+  have hq : coordinateInverse P K z ∈ K := coordinateInverse_mem (hSP hz)
+  have hqn : coordinateInverse (Pₙ n) K z ∈ K := coordinateInverse_mem (hn hz)
+  have he := hlower n _ hqn _ hq
+  rw [coordinateInverse_right (hn hz)] at he
+  have hd := hclose _ hq
+  rw [coordinateInverse_right (hSP hz)] at hd
+  have he' : dist (coordinateInverse P K z) (coordinateInverse (Pₙ n) K z) ≤
+      (L : ℝ) * dist z (Pₙ n (coordinateInverse P K z)) := by
+    simpa only [dist_comm] using he
+  calc
+    _ ≤ (L : ℝ) * dist z (Pₙ n (coordinateInverse P K z)) := he'
+    _ ≤ ((L : ℝ) + 1) * dist z (Pₙ n (coordinateInverse P K z)) :=
+      mul_le_mul_of_nonneg_right (by linarith) dist_nonneg
+    _ < ((L : ℝ) + 1) * (ε / ((L : ℝ) + 1)) := mul_lt_mul_of_pos_left hd hL
+    _ = ε := mul_div_cancel₀ ε hL.ne'
+
+/-- The uniform inverse bound makes every coordinate chart injective. -/
+theorem lower_lipschitz_injOn
+    (P : ℂ → ℂ) (K : Set ℂ) (L : ℝ≥0)
+    (hlower : ∀ x ∈ K, ∀ y ∈ K, dist x y ≤ L * dist (P x) (P y)) :
+    InjOn P K := by
+  intro x hx y hy he
+  have hh := hlower x hx y hy
+  rw [he, dist_self, mul_zero] at hh
+  exact dist_eq_zero.mp (le_antisymm hh dist_nonneg)
+
+/-- The limiting coordinate image has an open interior physical domain. -/
+theorem isOpen_image_interior
+    (hpublished : PublishedPlanarDiskOpenness)
+    (P : ℂ → ℂ) (K : Set ℂ)
+    (hP : ContinuousOn P K) (hi : InjOn P K) :
+    IsOpen (P '' interior K) := by
+  apply isOpen_iff_mem_nhds.mpr
+  rintro z ⟨x, hx, rfl⟩
+  obtain ⟨r, hr, hball⟩ := Metric.isOpen_iff.mp isOpen_interior x hx
+  have hsub : ball x r ⊆ K := hball.trans interior_subset
+  have hopen := hpublished P x r hr (hP.mono hsub) (hi.mono hsub)
+  exact mem_of_superset
+    (hopen.mem_nhds (mem_image_of_mem P (mem_ball_self hr)))
+    (image_mono hball)
+
+/-- Compact physical subsets of the limiting interior image belong to
+all sufficiently late moving interior images. -/
+theorem eventual_compact_image_interior
+    (hpublished : PublishedPlanarDiskOpenness)
+    (Pₙ : ℕ → ℂ → ℂ) (P : ℂ → ℂ) (K S : Set ℂ) (L : ℝ≥0)
+    (hL : 0 < L)
+    (hPn : ∀ n, ContinuousOn (Pₙ n) K)
+    (hconv : TendstoUniformlyOn Pₙ P atTop K)
+    (hlower : ∀ n x, x ∈ K → ∀ y, y ∈ K → dist x y ≤ L * dist (Pₙ n x) (Pₙ n y))
+    (hS : IsCompact S) (hSP : S ⊆ P '' interior K) :
+    ∀ᶠ n in atTop, S ⊆ Pₙ n '' interior K := by
+  have hlim := lower_lipschitz_uniform_limit Pₙ P K L hconv hlower
+  have hi := lower_lipschitz_injOn P K L hlim
+  have hSK : S ⊆ P '' K := hSP.trans (image_mono interior_subset)
+  let Q := coordinateInverse P K '' S
+  have hQ : IsCompact Q := hS.image_of_continuousOn
+    ((coordinateInverse_lipschitz P K L hlim).continuousOn.mono hSK)
+  have hQK : Q ⊆ interior K := by
+    rintro _ ⟨z, hz, rfl⟩
+    obtain ⟨x, hx, he⟩ := hSP hz
+    have hqx : coordinateInverse P K z = x := hi
+      (coordinateInverse_mem (hSK hz)) (interior_subset hx)
+      ((coordinateInverse_right (hSK hz)).trans he.symm)
+    simpa only [hqx] using hx
+  obtain ⟨ρ, hρ, hthick⟩ := hQ.exists_cthickening_subset_open isOpen_interior hQK
+  have hLr : 0 < (L : ℝ) := hL
+  filter_upwards [Metric.tendstoUniformlyOn_iff.mp hconv (ρ / L) (div_pos hρ hLr)] with n hn
+  intro z hz
+  let x := coordinateInverse P K z
+  have hxQ : x ∈ Q := mem_image_of_mem _ hz
+  have hxK : x ∈ K := interior_subset (hQK hxQ)
+  have hball : closedBall x ρ ⊆ interior K := by
+    intro y hy
+    exact hthick (mem_cthickening_of_dist_le y x ρ Q hxQ hy)
+  have hballK := hball.trans interior_subset
+  have hiₙ := lower_lipschitz_injOn (Pₙ n) K L (hlower n)
+  have hopen := hpublished (Pₙ n) x ρ hρ
+    ((hPn n).mono (ball_subset_closedBall.trans hballK))
+    (hiₙ.mono (ball_subset_closedBall.trans hballK))
+  have hcontains := ball_subset_image_ball (Pₙ n) x hρ hLr
+    ((hPn n).mono hballK) hopen
+    (fun y hy => hlower n y (hballK hy) x hxK)
+  apply (image_mono (ball_subset_closedBall.trans hball))
+  apply hcontains
+  have hh := hn x hxK
+  rw [coordinateInverse_right (hSK hz)] at hh
+  simpa only [mem_ball, dist_comm] using hh
+
+/-- The inverse ribbon charts converge locally uniformly on the full
+limiting interior image. Only compact subsets are eventually common. -/
+theorem coordinateInverse_locally_uniform
+    (hpublished : PublishedPlanarDiskOpenness)
+    (Pₙ : ℕ → ℂ → ℂ) (P : ℂ → ℂ) (K : Set ℂ) (L : ℝ≥0)
+    (hL : 0 < L) (hP : ContinuousOn P K)
+    (hPn : ∀ n, ContinuousOn (Pₙ n) K)
+    (hconv : TendstoUniformlyOn Pₙ P atTop K)
+    (hlower : ∀ n x, x ∈ K → ∀ y, y ∈ K → dist x y ≤ L * dist (Pₙ n x) (Pₙ n y)) :
+    TendstoLocallyUniformlyOn (fun n => coordinateInverse (Pₙ n) K)
+      (coordinateInverse P K) atTop (P '' interior K) := by
+  have hlim := lower_lipschitz_uniform_limit Pₙ P K L hconv hlower
+  have hopen := isOpen_image_interior hpublished P K hP
+    (lower_lipschitz_injOn P K L hlim)
+  apply (tendstoLocallyUniformlyOn_iff_forall_isCompact hopen).mpr
+  intro S hSP hS
+  exact coordinateInverse_uniform_on Pₙ P K S L hconv hlower
+    (hSP.trans (image_mono interior_subset))
+    ((eventual_compact_image_interior hpublished Pₙ P K S L hL hPn hconv hlower hS hSP).mono
+      (fun _ h => h.trans (image_mono interior_subset)))
+
+/-- A compact retained physical patch admits one common open neighborhood
+contained in every sufficiently late coordinate image. -/
+theorem common_physical_neighborhood
+    (hpublished : PublishedPlanarDiskOpenness)
+    (Pₙ : ℕ → ℂ → ℂ) (P : ℂ → ℂ) (K A : Set ℂ) (L : ℝ≥0)
+    (hL : 0 < L) (hP : ContinuousOn P K)
+    (hPn : ∀ n, ContinuousOn (Pₙ n) K)
+    (hconv : TendstoUniformlyOn Pₙ P atTop K)
+    (hlower : ∀ n x, x ∈ K → ∀ y, y ∈ K → dist x y ≤ L * dist (Pₙ n x) (Pₙ n y))
+    (hA : IsCompact A) (hAP : A ⊆ P '' interior K) :
+    ∃ U : Set ℂ, IsOpen U ∧ A ⊆ U ∧ IsCompact (closure U) ∧
+      closure U ⊆ P '' interior K ∧
+      (∀ᶠ n in atTop, closure U ⊆ Pₙ n '' interior K) ∧
+      TendstoUniformlyOn (fun n => coordinateInverse (Pₙ n) K)
+        (coordinateInverse P K) atTop (closure U) := by
+  have hlim := lower_lipschitz_uniform_limit Pₙ P K L hconv hlower
+  have hopen := isOpen_image_interior hpublished P K hP
+    (lower_lipschitz_injOn P K L hlim)
+  obtain ⟨ρ, hρ, hthick⟩ := hA.exists_cthickening_subset_open hopen hAP
+  let U := thickening ρ A
+  have hclosure : closure U ⊆ cthickening ρ A := closure_thickening_subset_cthickening ρ A
+  have hUc : IsCompact (closure U) := (hA.cthickening).of_isClosed_subset isClosed_closure hclosure
+  have hUP : closure U ⊆ P '' interior K := hclosure.trans hthick
+  have hlate := eventual_compact_image_interior hpublished Pₙ P K (closure U) L hL hPn
+    hconv hlower hUc hUP
+  exact ⟨U, isOpen_thickening, self_subset_thickening hρ A, hUc, hUP, hlate,
+    coordinateInverse_uniform_on Pₙ P K (closure U) L hconv hlower
+      (hUP.trans (image_mono interior_subset))
+      (hlate.mono (fun _ h => h.trans (image_mono interior_subset)))⟩
+
+/-- The source longitudinal coordinate is the real part of the inverse
+ribbon chart, translated by the current front coordinate. -/
+def longitudinalCoordinate (P : ℂ → ℂ) (K : Set ℂ) (k : ℝ) (z : ℂ) : ℝ :=
+  (coordinateInverse P K z).re - k
+
+theorem longitudinalCoordinate_locally_uniform
+    (hpublished : PublishedPlanarDiskOpenness)
+    (Pₙ : ℕ → ℂ → ℂ) (P : ℂ → ℂ) (K : Set ℂ) (L : ℝ≥0) (k : ℝ)
+    (hL : 0 < L) (hP : ContinuousOn P K)
+    (hPn : ∀ n, ContinuousOn (Pₙ n) K)
+    (hconv : TendstoUniformlyOn Pₙ P atTop K)
+    (hlower : ∀ n x, x ∈ K → ∀ y, y ∈ K → dist x y ≤ L * dist (Pₙ n x) (Pₙ n y)) :
+    TendstoLocallyUniformlyOn (fun n => longitudinalCoordinate (Pₙ n) K k)
+      (longitudinalCoordinate P K k) atTop (P '' interior K) := by
+  have hh := coordinateInverse_locally_uniform hpublished Pₙ P K L hL hP hPn hconv hlower
+  have hu : UniformContinuous (fun z : ℂ => z.re - k) :=
+    Complex.uniformContinuous_re.sub uniformContinuous_const
+  exact hu.comp_tendstoLocallyUniformlyOn hh
+
+theorem longitudinalCoordinate_continuousOn
+    (P : ℂ → ℂ) (K : Set ℂ) (L : ℝ≥0) (k : ℝ)
+    (hlower : ∀ x ∈ K, ∀ y ∈ K, dist x y ≤ L * dist (P x) (P y)) :
+    ContinuousOn (longitudinalCoordinate P K k) (P '' K) := by
+  exact (Complex.continuous_re.comp_continuousOn
+    (coordinateInverse_lipschitz P K L hlower).continuousOn).sub continuousOn_const
+
+/-- A retained compact part of a ribbon has a common open physical chart
+on which the actual longitudinal coordinates are eventually continuous
+and converge locally uniformly. -/
+theorem common_longitudinal_chart
+    (hpublished : PublishedPlanarDiskOpenness)
+    (Pₙ : ℕ → ℂ → ℂ) (P : ℂ → ℂ) (K A : Set ℂ) (L : ℝ≥0) (k : ℝ)
+    (hL : 0 < L) (hP : ContinuousOn P K)
+    (hPn : ∀ n, ContinuousOn (Pₙ n) K)
+    (hconv : TendstoUniformlyOn Pₙ P atTop K)
+    (hlower : ∀ n x, x ∈ K → ∀ y, y ∈ K → dist x y ≤ L * dist (Pₙ n x) (Pₙ n y))
+    (hA : IsCompact A) (hAP : A ⊆ P '' interior K) :
+    ∃ U : Set ℂ, IsOpen U ∧ A ⊆ U ∧ IsCompact (closure U) ∧
+      closure U ⊆ P '' interior K ∧
+      (∀ᶠ n in atTop, U ⊆ Pₙ n '' interior K) ∧
+      ContinuousOn (longitudinalCoordinate P K k) U ∧
+      (∀ᶠ n in atTop, ContinuousOn (longitudinalCoordinate (Pₙ n) K k) U) ∧
+      TendstoLocallyUniformlyOn (fun n => longitudinalCoordinate (Pₙ n) K k)
+        (longitudinalCoordinate P K k) atTop U := by
+  obtain ⟨U, hU, hAU, hUc, hUP, hlate, _⟩ := common_physical_neighborhood
+    hpublished Pₙ P K A L hL hP hPn hconv hlower hA hAP
+  have hUImage : U ⊆ P '' interior K := subset_closure.trans hUP
+  have hlim := lower_lipschitz_uniform_limit Pₙ P K L hconv hlower
+  refine ⟨U, hU, hAU, hUc, hUP, hlate.mono (fun _ h => subset_closure.trans h),
+    (longitudinalCoordinate_continuousOn P K L k hlim).mono
+      (hUImage.trans (image_mono interior_subset)), ?_, ?_⟩
+  · filter_upwards [hlate] with n hn
+    exact (longitudinalCoordinate_continuousOn (Pₙ n) K L k (hlower n)).mono
+      (subset_closure.trans (hn.trans (image_mono interior_subset)))
+  · exact (longitudinalCoordinate_locally_uniform hpublished Pₙ P K L k hL hP hPn
+      hconv hlower).mono hUImage
+
+/-- A compact set with limiting coordinates in an open coordinate region
+has its moving coordinates in that same region for all sufficiently late
+charts. This includes simultaneous longitudinal and transverse margins. -/
+theorem eventual_compact_coordinate_region
+    (Pₙ : ℕ → ℂ → ℂ) (P : ℂ → ℂ) (K S A : Set ℂ) (L : ℝ≥0)
+    (hconv : TendstoUniformlyOn Pₙ P atTop K)
+    (hlower : ∀ n x, x ∈ K → ∀ y, y ∈ K → dist x y ≤ L * dist (Pₙ n x) (Pₙ n y))
+    (hS : IsCompact S) (hSP : S ⊆ P '' K)
+    (hcover : ∀ᶠ n in atTop, S ⊆ Pₙ n '' K)
+    (hA : IsOpen A) (hSA : coordinateInverse P K '' S ⊆ A) :
+    ∀ᶠ n in atTop, S ⊆ Pₙ n '' (K ∩ A) := by
+  have hlim := lower_lipschitz_uniform_limit Pₙ P K L hconv hlower
+  have hcompact : IsCompact (coordinateInverse P K '' S) :=
+    hS.image_of_continuousOn ((coordinateInverse_lipschitz P K L hlim).continuousOn.mono hSP)
+  obtain ⟨ε, hε, heps⟩ := hcompact.exists_thickening_subset_open hA hSA
+  have hu := coordinateInverse_uniform_on Pₙ P K S L hconv hlower hSP hcover
+  filter_upwards [hcover, Metric.tendstoUniformlyOn_iff.mp hu ε hε] with n hn hclose
+  intro z hz
+  refine ⟨coordinateInverse (Pₙ n) K z, ⟨coordinateInverse_mem (hn hz), ?_⟩,
+    coordinateInverse_right (hn hz)⟩
+  exact heps (mem_thickening_iff.mpr ⟨coordinateInverse P K z, mem_image_of_mem _ hz,
+    by simpa only [dist_comm] using hclose z hz⟩)
+
+/-- The admissible two-point patch bounds and a bounded marked point give
+an actual uniformly convergent subsequence of the coordinate maps. Both
+Lipschitz bounds pass to the limit, retaining an embedded limiting patch. -/
+theorem exists_bilip_uniform_subsequence
+    (Pₙ : ℕ → ℂ → ℂ) (K : Set ℂ) (hK : IsCompact K)
+    (x₀ : ℂ) (hx₀ : x₀ ∈ K) (C L : ℝ≥0) (R : ℝ)
+    (hupper : ∀ n, LipschitzOnWith C (Pₙ n) K)
+    (hlower : ∀ n x, x ∈ K → ∀ y, y ∈ K → dist x y ≤ L * dist (Pₙ n x) (Pₙ n y))
+    (htip : ∀ n, ‖Pₙ n x₀‖ ≤ R) :
+    ∃ P : ℂ → ℂ, ∃ φ : ℕ → ℕ, StrictMono φ ∧
+      TendstoUniformlyOn (fun n => Pₙ (φ n)) P atTop K ∧
+      LipschitzOnWith C P K ∧
+      (∀ x ∈ K, ∀ y ∈ K, dist x y ≤ L * dist (P x) (P y)) ∧
+      InjOn P K := by
+  classical
+  let : CompactSpace K := isCompact_iff_compactSpace.mp hK
+  let f : ℕ → K →ᵇ ℂ := fun n => BoundedContinuousFunction.mkOfCompact
+    ⟨K.domRestrict (Pₙ n), (hupper n).continuousOn.domRestrict⟩
+  obtain ⟨M, hM⟩ := hK.isBounded.subset_closedBall x₀
+  have hbound n (x : K) : ‖f n x‖ ≤ R + C * M := by
+    have hd := (hupper n).dist_le_mul x x.property x₀ hx��
+    have hh := norm_le_norm_add_const_of_dist_le hd
+    exact hh.trans (add_le_add (htip n)
+      (mul_le_mul_of_nonneg_left (hM x.property) C.coe_nonneg))
+  have heq : Equicontinuous ((↑) : Set.range f → K → ℂ) := by
+    apply (LipschitzWith.uniformEquicontinuous _ C ?_).equicontinuous
+    rintro ⟨g, n, rfl⟩
+    exact (hupper n).to_restrict
+  have hcompact : IsCompact (closure (Set.range f)) :=
+    BoundedContinuousFunction.arzela_ascoli (closedBall (0 : ℂ) (R + C * M))
+      (isCompact_closedBall _ _) (Set.range f)
+      (by rintro g x ⟨n, rfl⟩; simpa only [mem_closedBall, dist_zero_right] using hbound n x)
+      heq
+  obtain ⟨b, _, φ, hφ, hlim⟩ := hcompact.tendsto_subseq
+    (fun n => subset_closure (mem_range_self n))
+  have hb : TendstoUniformly (fun n => f (φ n)) b atTop :=
+    BoundedContinuousFunction.tendsto_iff_tendstoUniformly.mp hlim
+  let P : ℂ → ℂ := fun z => if hz : z ∈ K then b ⟨z, hz⟩ else 0
+  have hu : TendstoUniformlyOn (fun n => Pₙ (φ n)) P atTop K := by
+    apply Metric.tendstoUniformlyOn_iff.mpr
+    intro ε hε
+    filter_upwards [Metric.tendstoUniformly_iff.mp hb ε hε] with n hn
+    intro z hz
+    simpa [P, f, hz] using hn ⟨z, hz⟩
+  have hPu : LipschitzOnWith C P K := by
+    apply lipschitzOnWith_iff_dist_le_mul.mpr
+    intro x hx y hy
+    exact le_of_tendsto ((hu.tendsto_at hx).dist (hu.tendsto_at hy))
+      (Eventually.of_forall fun n => (hupper (φ n)).dist_le_mul x hx y hy)
+  have hPl := lower_lipschitz_uniform_limit (fun n => Pₙ (φ n)) P K L hu
+    (fun n => hlower (φ n))
+  exact ⟨P, φ, hφ, hu, hPu, hPl, lower_lipschitz_injOn P K L hPl⟩
+
+end SLEExactGauge.RibbonCoordinates
+
+end
+
+end OAI

lean/OAI/Probability/SLE/Gauge/RibbonCoordinateGeometry.lean

@@ -1,348 +1,348 @@
-import OAI.Probability.SLE.Gauge.RibbonSurvival
-import OAI.Probability.SLE.Geometry.PublishedPlanarDiskOpenness
-import Mathlib.Analysis.Normed.Module.Connected
-
-namespace OAI
-
-/-! Coordinate balls in an embedded ribbon. These deterministic lemmas
-turn the local lower Lipschitz bound into physical clearance, and identify
-the future ribbon with part of the actual unbounded surviving component. -/
-
-noncomputable section
-open Set Filter Metric
-open scoped Topology NNReal
-
-namespace SLEExactGauge.RibbonCoordinates
-
-/-- An open coordinate disk whose inverse has Lipschitz constant `K`
-contains the physical disk of radius `r / K`. Compactness of the closed
-coordinate disk prevents an interior physical point from escaping its image. -/
-theorem ball_subset_image_ball
-    (P : ℂ → ℂ) (x : ℂ) {r K : ℝ} (hr : 0 < r) (hK : 0 < K)
-    (hP : ContinuousOn P (closedBall x r))
-    (hopen : IsOpen (P '' ball x r))
-    (hlower : ∀ y ∈ closedBall x r, dist y x ≤ K * dist (P y) (P x)) :
-    ball (P x) (r / K) ⊆ P '' ball x r := by
-  let A := P '' ball x r
-  let Q := P '' closedBall x r
-  have hQ : IsCompact Q := (isCompact_closedBall x r).image_of_continuousOn hP
-  have hAQ : A ⊆ Q := image_mono ball_subset_closedBall
-  have hsub : ball (P x) (r / K) ⊆ A ∪ Qᶜ := by
-    intro z hz
-    by_cases hzQ : z ∈ Q
-    · left
-      obtain ⟨y, hy, rfl⟩ := hzQ
-      refine ⟨y, ?_, rfl⟩
-      have hd := hlower y hy
-      have hz' : dist (P y) (P x) < r / K := hz
-      have hh := (lt_div_iff₀ hK).mp hz'
-      exact lt_of_le_of_lt hd (by nlinarith [hh])
-    · exact Or.inr hzQ
-  apply IsPreconnected.subset_left_of_subset_union hopen hQ.isClosed.isOpen_compl
-    (disjoint_compl_right.mono_left hAQ) hsub _ isPreconnected_ball
-  exact ⟨P x, mem_ball_self (div_pos hr hK), mem_image_of_mem P (mem_ball_self hr)⟩
-
-def closedRibbon : Set ℂ := {z | 0 ≤ z.re ∧ |z.im| ≤ 1}
-def futureRibbon (k : ℝ) : Set ℂ := {z | k < z.re ∧ |z.im| < 1}
-
-theorem futureRibbon_subset_closedRibbon {k : ℝ} (hk : 0 ≤ k) :
-    futureRibbon k ⊆ closedRibbon := by
-  intro z hz
-  exact ⟨hk.trans hz.1.le, hz.2.le⟩
-
-theorem futureRibbon_convex (k : ℝ) : Convex ℝ (futureRibbon k) := by
-  have hre : Convex ℝ {z : ℂ | k < z.re} :=
-    convex_halfSpace_gt Complex.reLm.isLinear k
-  have him : Convex ℝ {z : ℂ | z.im ∈ Ioo (-1 : ℝ) 1} :=
-    (convex_Ioo (-1 : ℝ) 1).is_linear_preimage Complex.imLm.isLinear
-  simpa only [futureRibbon, abs_lt, mem_Ioo, ofPred_and] using hre.inter him
-
-/-- Any unbounded connected free set belongs to the unbounded component
-used in the actual Loewner surviving domain. -/
-theorem free_preconnected_subset_surviving
-    (γ : ℝ≥0 → ℂ) (T : ℝ≥0) (S : Set ℂ)
-    (hS : IsPreconnected S) (hfree : S ⊆ upperHalfPlane \ (γ '' Icc 0 T))
-    (hunbounded : ¬ Bornology.IsBounded S) : S ⊆ survivingDomain γ T := by
-  intro z hz
-  refine ⟨hfree hz, ?_⟩
-  intro hbounded
-  exact hunbounded (hbounded.subset (hS.subset_connectedComponentIn hz hfree))
-
-/-- Embedding excludes all nonlocal pieces of the stopped past from the
-future ribbon. Escape to infinity places the whole future ribbon in the
-surviving component, without assuming a filled-hull containment. -/
-theorem futureRibbon_survives
-    (P : ℂ → ℂ) (hP : ContinuousOn P closedRibbon)
-    (hi : InjOn P closedRibbon) {k : ℝ} (hk : 0 ≤ k)
-    (hH : ∀ z ∈ closedRibbon, 0 < z.re → P z ∈ upperHalfPlane)
-    (γ : ℝ≥0 → ℂ) (T : ℝ≥0)
-    (hpast : γ '' Icc 0 T ⊆ P '' {z ∈ closedRibbon | z.re ≤ k})
-    (hunbounded : ¬ Bornology.IsBounded (P '' futureRibbon k)) :
-    P '' futureRibbon k ⊆ survivingDomain γ T := by
-  have hsub := futureRibbon_subset_closedRibbon hk
-  apply free_preconnected_subset_surviving γ T _
-    ((futureRibbon_convex k).isPreconnected.image P (hP.mono hsub)) _ hunbounded
-  rintro z ⟨y, hy, rfl⟩
-  refine ⟨hH y (hsub hy) (hk.trans_lt hy.1), ?_⟩
-  intro hyPast
-  obtain ⟨x, hx, he⟩ := hpast hyPast
-  have hxy : x = y := hi hx.1 (hsub hy) he
-  exact (not_le_of_gt hy.1) (hxy ▸ hx.2)
-
-/-- A coordinate disk strictly ahead of the front and away from the two
-ribbon edges gives a physical disk in the actual surviving domain. -/
-theorem coordinate_ball_clearance
-    (P : ℂ → ℂ) (hP : ContinuousOn P closedRibbon)
-    (hi : InjOn P closedRibbon) {k : ℝ} (hk : 0 ≤ k)
-    (hH : ∀ z ∈ closedRibbon, 0 < z.re → P z ∈ upperHalfPlane)
-    (γ : ℝ≥0 → ℂ) (T : ℝ≥0)
-    (hpast : γ '' Icc 0 T ⊆ P '' {z ∈ closedRibbon | z.re ≤ k})
-    (hunbounded : ¬ Bornology.IsBounded (P '' futureRibbon k))
-    (x : ℂ) {r K : ℝ} (hr : 0 < r) (hK : 0 < K)
-    (hfront : k + r < x.re) (hedge : |x.im| + r < 1)
-    (hopen : IsOpen (P '' ball x r))
-    (hlower : ∀ y ∈ closedBall x r, dist y x ≤ K * dist (P y) (P x)) :
-    ball (P x) (r / K) ⊆ survivingDomain γ T := by
-  have hball : closedBall x r ⊆ futureRibbon k := by
-    intro y hy
-    have hd : ‖y - x‖ ≤ r := by simpa only [mem_closedBall, dist_eq_norm] using hy
-    have hre := (Complex.abs_re_le_norm (y - x)).trans hd
-    have him := (Complex.abs_im_le_norm (y - x)).trans hd
-    simp only [Complex.sub_re, Complex.sub_im] at hre him
-    refine ⟨by linarith [(abs_le.mp hre).1], ?_⟩
-    have htri : |y.im| ≤ |y.im - x.im| + |x.im| := by
-      simpa only [sub_add_cancel] using abs_add_le (y.im - x.im) x.im
-    linarith
-  exact (ball_subset_image_ball P x hr hK
-    (hP.mono (hball.trans (futureRibbon_subset_closedRibbon hk))) hopen hlower).trans
-    ((image_mono (ball_subset_closedBall.trans hball)).trans
-      (futureRibbon_survives P hP hi hk hH γ T hpast hunbounded))
-
-/-- The paper's access guide, before applying the ribbon coordinate map. -/
-def guideCoordinate (k x t : ℝ) : ℂ :=
-  ((k + t : ℝ) : ℂ) + ((x * max (1 - 4 * t) 0 : ℝ) : ℂ) * Complex.I
-
-@[simp] theorem guideCoordinate_re (k x t : ℝ) :
-    (guideCoordinate k x t).re = k + t := by simp [guideCoordinate]
-
-@[simp] theorem guideCoordinate_im (k x t : ℝ) :
-    (guideCoordinate k x t).im = x * max (1 - 4 * t) 0 := by simp [guideCoordinate]
-
-theorem guideCoordinate_continuous (k x : ℝ) : Continuous (guideCoordinate k x) := by
-  unfold guideCoordinate
-  fun_prop
-
-theorem guideCoordinate_im_bound {k x t : ℝ} (ht : 0 ≤ t) :
-    |(guideCoordinate k x t).im| ≤ |x| := by
-  rw [guideCoordinate_im, abs_mul, abs_of_nonneg (le_max_right (1 - 4 * t) 0)]
-  exact mul_le_of_le_one_right (abs_nonneg x) (max_le (by linarith) (by norm_num))
-
-/-- The longitudinal coordinate gives the lower chord bound directly. -/
-theorem guideCoordinate_lower_chord (k x u v : ℝ) :
-    |u - v| ≤ dist (guideCoordinate k x u) (guideCoordinate k x v) := by
-  have hh := Complex.abs_re_le_norm (guideCoordinate k x u - guideCoordinate k x v)
-  simpa only [Complex.sub_re, guideCoordinate_re, add_sub_add_left_eq_sub,
-    dist_eq_norm] using hh
-
-theorem guideCoordinate_upper_chord (k x u v : ℝ) :
-    dist (guideCoordinate k x u) (guideCoordinate k x v) ≤
-      (1 + 4 * |x|) * |u - v| := by
-  have hmax := abs_max_sub_max_le_abs (1 - 4 * u) (1 - 4 * v) 0
-  have he : (1 - 4 * u) - (1 - 4 * v) = -4 * (u - v) := by ring
-  rw [he, abs_mul] at hmax
-  norm_num at hmax
-  have him : |x * max (1 - 4 * u) 0 - x * max (1 - 4 * v) 0| ≤
-      |x| * (4 * |u - v|) := by
-    rw [← mul_sub, abs_mul]
-    exact mul_le_mul_of_nonneg_left hmax (abs_nonneg x)
-  have hh := Complex.norm_le_abs_re_add_abs_im
-    (guideCoordinate k x u - guideCoordinate k x v)
-  simp only [Complex.sub_re, Complex.sub_im, guideCoordinate_re, guideCoordinate_im,
-    add_sub_add_left_eq_sub] at hh
-  rw [dist_eq_norm]
-  nlinarith
-
-def guideRadius (t : ℝ) : ℝ := min t 1 / 4
-
-theorem guideRadius_pos {t : ℝ} (ht : 0 < t) : 0 < guideRadius t :=
-  div_pos (lt_min ht zero_lt_one) (by norm_num)
-
-/-- The guide is at most a quarter of the ribbon half-width from the
-centerline; its coordinate disks have radius proportional to `min(t,1)`. -/
-theorem guideCoordinate_disk_margins
-    {k x t : ℝ} (hx : |x| ≤ 1 / 4) (ht : 0 < t) :
-    k + guideRadius t < (guideCoordinate k x t).re ∧
-      |(guideCoordinate k x t).im| + guideRadius t < 1 := by
-  have hrt : guideRadius t ≤ t / 4 := div_le_div_of_nonneg_right (min_le_left _ _) (by norm_num)
-  have hr1 : guideRadius t ≤ 1 / 4 := div_le_div_of_nonneg_right (min_le_right _ _) (by norm_num)
-  have hi := (guideCoordinate_im_bound (k := k) (x := x) ht.le).trans hx
-  rw [guideCoordinate_re]
-  constructor <;> linarith
-
-/-- Applying the coordinate disk lemma proves the paper's guide clearance
-for every positive guide time, with the actual surviving domain. -/
-theorem physical_guide_clearance
-    (P : ℂ → ℂ) (hP : ContinuousOn P closedRibbon)
-    (hi : InjOn P closedRibbon) {k x K : ℝ} (hk : 0 ≤ k)
-    (hx : |x| ≤ 1 / 4) (hK : 0 < K)
-    (hH : ∀ z ∈ closedRibbon, 0 < z.re → P z ∈ upperHalfPlane)
-    (γ : ℝ≥0 → ℂ) (T : ℝ≥0)
-    (hpast : γ '' Icc 0 T ⊆ P '' {z ∈ closedRibbon | z.re ≤ k})
-    (hunbounded : ¬ Bornology.IsBounded (P '' futureRibbon k))
-    (hopen : ∀ t ∈ Ioc (0 : ℝ) 2,
-      IsOpen (P '' ball (guideCoordinate k x t) (guideRadius t)))
-    (hlower : ∀ t ∈ Ioc (0 : ℝ) 2,
-      ∀ y ∈ closedBall (guideCoordinate k x t) (guideRadius t),
-        dist y (guideCoordinate k x t) ≤ K * dist (P y) (P (guideCoordinate k x t))) :
-    ∀ t ∈ Ioc (0 : ℝ) 2,
-      ball (P (guideCoordinate k x t)) (min t 1 / (4 * K)) ⊆ survivingDomain γ T := by
-  intro t ht
-  obtain ⟨hfront, hedge⟩ := guideCoordinate_disk_margins (k := k) hx ht.1
-  have hh := coordinate_ball_clearance P hP hi hk hH γ T hpast hunbounded
-    (guideCoordinate k x t) (guideRadius_pos ht.1) hK hfront hedge (hopen t ht) (hlower t ht)
-  simpa only [guideRadius, div_div] using hh
-
-/-- The fixed length-four patch appearing in the admissible ribbon class. -/
-def guidePatch (k : ℝ) : Set ℂ := {z | k ≤ z.re ∧ z.re ≤ k + 3 ∧ |z.im| ≤ 1}
-
-theorem guideCoordinate_disk_subset_patch
-    {k x t : ℝ} (hx : |x| ≤ 1 / 4) (ht : t ∈ Ioc (0 : ℝ) 2) :
-    closedBall (guideCoordinate k x t) (guideRadius t) ⊆ guidePatch k := by
-  intro y hy
-  have hd : ‖y - guideCoordinate k x t‖ ≤ guideRadius t := by
-    simpa only [mem_closedBall, dist_eq_norm] using hy
-  have hre := (Complex.abs_re_le_norm (y - guideCoordinate k x t)).trans hd
-  have him := (Complex.abs_im_le_norm (y - guideCoordinate k x t)).trans hd
-  simp only [Complex.sub_re, Complex.sub_im, guideCoordinate_re, guideCoordinate_im] at hre him
-  obtain ⟨hfront, hedge⟩ := guideCoordinate_disk_margins (k := k) hx ht.1
-  have hr1 : guideRadius t ≤ 1 / 4 :=
-    div_le_div_of_nonneg_right (min_le_right _ _) (by norm_num)
-  have hi := (guideCoordinate_im_bound (k := k) (x := x) ht.1.le).trans hx
-  have htri : |y.im| ≤ |y.im - (guideCoordinate k x t).im| +
-      |(guideCoordinate k x t).im| := by
-    simpa only [sub_add_cancel] using
-      abs_add_le (y.im - (guideCoordinate k x t).im) (guideCoordinate k x t).im
-  change k ≤ y.re ∧ y.re ≤ k + 3 ∧ |y.im| ≤ 1
-  simp only [guideCoordinate_re] at hfront
-  simp only [guideCoordinate_im] at htri hi
-  exact ⟨by linarith [(abs_le.mp hre).1], by linarith [(abs_le.mp hre).2, ht.2],
-    by linarith⟩
-
-theorem guidePatch_subset_closedRibbon {k : ℝ} (hk : 0 ≤ k) :
-    guidePatch k ⊆ closedRibbon := by
-  intro z hz
-  exact ⟨hk.trans hz.1, hz.2.2⟩
-
-/-- The actual fixed patch inverse-Lipschitz bound suffices for all guide
-disks. The only topological parameter is the cited planar disk theorem. -/
-theorem physical_guide_clearance_of_patch
-    (hpublished : PublishedPlanarDiskOpenness)
-    (P : ℂ → ℂ) (hP : ContinuousOn P closedRibbon)
-    (hi : InjOn P closedRibbon) {k x K : ℝ} (hk : 0 ≤ k)
-    (hx : |x| ≤ 1 / 4) (hK : 0 < K)
-    (hH : ∀ z ∈ closedRibbon, 0 < z.re → P z ∈ upperHalfPlane)
-    (γ : ℝ≥0 → ℂ) (T : ℝ≥0)
-    (hpast : γ '' Icc 0 T ⊆ P '' {z ∈ closedRibbon | z.re ≤ k})
-    (hunbounded : ¬ Bornology.IsBounded (P '' futureRibbon k))
-    (hlower : ∀ u ∈ guidePatch k, ∀ v ∈ guidePatch k,
-      dist u v ≤ K * dist (P u) (P v)) :
-    ∀ t ∈ Ioc (0 : ℝ) 2,
-      ball (P (guideCoordinate k x t)) (min t 1 / (4 * K)) ⊆ survivingDomain γ T := by
-  apply physical_guide_clearance P hP hi hk hx hK hH γ T hpast hunbounded
-  · intro t ht
-    have hsub := (ball_subset_closedBall.trans (guideCoordinate_disk_subset_patch hx ht)).trans
-      (guidePatch_subset_closedRibbon hk)
-    exact hpublished P _ _ (guideRadius_pos ht.1) (hP.mono hsub) (hi.mono hsub)
-  · intro t ht y hy
-    have hsub := guideCoordinate_disk_subset_patch (k := k) hx ht
-    exact hlower y (hsub hy) _ (hsub (mem_closedBall_self (guideRadius_pos ht.1).le))
-
-/-- Uniform clearance on every closed interval away from the tip is the
-form used by joint physical/conformal guide compactness. -/
-theorem physical_guide_clearance_away
-    (hpublished : PublishedPlanarDiskOpenness)
-    (P : ℂ → ℂ) (hP : ContinuousOn P closedRibbon)
-    (hi : InjOn P closedRibbon) {k x K : ℝ} (hk : 0 ≤ k)
-    (hx : |x| ≤ 1 / 4) (hK : 0 < K)
-    (hH : ∀ z ∈ closedRibbon, 0 < z.re → P z ∈ upperHalfPlane)
-    (γ : ℝ≥0 → ℂ) (T : ℝ≥0)
-    (hpast : γ '' Icc 0 T ⊆ P '' {z ∈ closedRibbon | z.re ≤ k})
-    (hunbounded : ¬ Bornology.IsBounded (P '' futureRibbon k))
-    (hlower : ∀ u ∈ guidePatch k, ∀ v ∈ guidePatch k,
-      dist u v ≤ K * dist (P u) (P v))
-    {δ : ℝ} (hδ : 0 < δ) (_hδ2 : δ ≤ 2) :
-    ∃ r : ℝ, 0 < r ∧ ∀ t ∈ Icc δ 2,
-      ball (P (guideCoordinate k x t)) r ⊆ survivingDomain γ T := by
-  refine ⟨min δ 1 / (4 * K), div_pos (lt_min hδ zero_lt_one) (by positivity), ?_⟩
-  intro t ht
-  apply (ball_subset_ball ?_).trans (physical_guide_clearance_of_patch hpublished P hP hi
-    hk hx hK hH γ T hpast hunbounded hlower t ⟨hδ.trans_le ht.1, ht.2⟩)
-  exact div_le_div_of_nonneg_right (min_le_min_right 1 ht.1) (by positivity)
-
-theorem guideCoordinate_mem_patch {k x t : ℝ}
-    (hx : |x| ≤ 1 / 4) (ht : t ∈ Icc (0 : ℝ) 2) :
-    guideCoordinate k x t ∈ guidePatch k := by
-  change k ≤ (guideCoordinate k x t).re ∧
-    (guideCoordinate k x t).re ≤ k + 3 ∧ |(guideCoordinate k x t).im| ≤ 1
-  rw [guideCoordinate_re]
-  exact ⟨by linarith [ht.1], by linarith [ht.2],
-    (guideCoordinate_im_bound ht.1).trans (hx.trans (by norm_num))⟩
-
-/-- The fixed coordinate patch speed bound gives the physical guide speed
-bound required by the compactness and access-localization arguments. -/
-theorem physical_guide_lipschitz
-    (P : ℂ → ℂ) (C : ℝ≥0) {k x : ℝ} (hx : |x| ≤ 1 / 4)
-    (hL : LipschitzOnWith C P (guidePatch k)) :
-    LipschitzOnWith (2 * C) (fun t => P (guideCoordinate k x t)) (Icc (0 : ℝ) 2) := by
-  apply lipschitzOnWith_iff_dist_le_mul.mpr
-  intro u hu v hv
-  have hp := hL.dist_le_mul _ (guideCoordinate_mem_patch hx hu) _
-    (guideCoordinate_mem_patch hx hv)
-  have hq := guideCoordinate_upper_chord k x u v
-  have hcq : dist (guideCoordinate k x u) (guideCoordinate k x v) ≤ 2 * |u - v| := by
-    exact hq.trans (mul_le_mul_of_nonneg_right (by linarith) (abs_nonneg _))
-  have hh := mul_le_mul_of_nonneg_left hcq C.coe_nonneg
-  simp only [NNReal.coe_mul, NNReal.coe_ofNat, Real.dist_eq]
-  nlinarith
-
-/-- The lower patch Lipschitz bound makes the physical guide uniformly
-simple, including its initial boundary point. -/
-theorem physical_guide_lower_chord
-    (P : ℂ → ℂ) {k x K : ℝ} (hx : |x| ≤ 1 / 4) (hK : 0 < K)
-    (hlower : ∀ u ∈ guidePatch k, ∀ v ∈ guidePatch k,
-      dist u v ≤ K * dist (P u) (P v)) :
-    ∀ u ∈ Icc (0 : ℝ) 2, ∀ v ∈ Icc (0 : ℝ) 2,
-      (1 / K) * |u - v| ≤ dist (P (guideCoordinate k x u)) (P (guideCoordinate k x v)) := by
-  intro u hu v hv
-  have hh := (guideCoordinate_lower_chord k x u v).trans
-    (hlower _ (guideCoordinate_mem_patch hx hu) _ (guideCoordinate_mem_patch hx hv))
-  rw [one_div_mul_eq_div, div_le_iff₀ hK]
-  simpa only [mul_comm] using hh
-
-@[simp] theorem guideCoordinate_zero (k x : ℝ) :
-    guideCoordinate k x 0 = (k : ℂ) + (x : ℂ) * Complex.I := by simp [guideCoordinate]
-
-@[simp] theorem guideCoordinate_waypoint (k x : ℝ) :
-    guideCoordinate k x (1 / 2) = ((k + 1 / 2 : ℝ) : ℂ) := by
-  norm_num [guideCoordinate]
-
-/-- The paper's escape condition on the centerline supplies the
-unboundedness used to select the actual surviving component. -/
-theorem futureRibbon_unbounded_of_centerline_escape
-    (P : ℂ → ℂ) (k : ℝ)
-    (hescape : Tendsto (fun s : ℝ => ‖P (s : ℂ)‖) atTop atTop) :
-    ¬ Bornology.IsBounded (P '' futureRibbon k) := by
-  intro hb
-  obtain ⟨R, _, hR⟩ := hb.exists_pos_norm_lt
-  obtain ⟨s, hs, hsR⟩ := ((eventually_gt_atTop k).and
-    (hescape.eventually (eventually_gt_atTop R))).exists
-  have hz : (s : ℂ) ∈ futureRibbon k := by
-    change k < (s : ℂ).re ∧ |(s : ℂ).im| < 1
-    simpa using And.intro hs (by norm_num : |(0 : ℝ)| < 1)
-  exact (not_lt_of_ge hsR.le) (hR _ (mem_image_of_mem P hz))
-
-end SLEExactGauge.RibbonCoordinates
-
-end
-
-end OAI
+import OAI.Probability.SLE.Gauge.RibbonSurvival
+import OAI.Probability.SLE.Geometry.PublishedPlanarDiskOpenness
+import Mathlib.Analysis.Normed.Module.Connected
+
+namespace OAI
+
+/-! Coordinate balls in an embedded ribbon. These deterministic lemmas
+turn the local lower Lipschitz bound into physical clearance, and identify
+the future ribbon with part of the actual unbounded surviving component. -/
+
+noncomputable section
+open Set Filter Metric
+open scoped Topology NNReal
+
+namespace SLEExactGauge.RibbonCoordinates
+
+/-- An open coordinate disk whose inverse has Lipschitz constant `K`
+contains the physical disk of radius `r / K`. Compactness of the closed
+coordinate disk prevents an interior physical point from escaping its image. -/
+theorem ball_subset_image_ball
+    (P : ℂ → ℂ) (x : ℂ) {r K : ℝ} (hr : 0 < r) (hK : 0 < K)
+    (hP : ContinuousOn P (closedBall x r))
+    (hopen : IsOpen (P '' ball x r))
+    (hlower : ∀ y ∈ closedBall x r, dist y x ≤ K * dist (P y) (P x)) :
+    ball (P x) (r / K) ⊆ P '' ball x r := by
+  let A := P '' ball x r
+  let Q := P '' closedBall x r
+  have hQ : IsCompact Q := (isCompact_closedBall x r).image_of_continuousOn hP
+  have hAQ : A ⊆ Q := image_mono ball_subset_closedBall
+  have hsub : ball (P x) (r / K) ⊆ A ∪ Qᶜ := by
+    intro z hz
+    by_cases hzQ : z ∈ Q
+    · left
+      obtain ⟨y, hy, rfl⟩ := hzQ
+      refine ⟨y, ?_, rfl⟩
+      have hd := hlower y hy
+      have hz' : dist (P y) (P x) < r / K := hz
+      have hh := (lt_div_iff₀ hK).mp hz'
+      exact lt_of_le_of_lt hd (by nlinarith [hh])
+    · exact Or.inr hzQ
+  apply IsPreconnected.subset_left_of_subset_union hopen hQ.isClosed.isOpen_compl
+    (disjoint_compl_right.mono_left hAQ) hsub _ isPreconnected_ball
+  exact ⟨P x, mem_ball_self (div_pos hr hK), mem_image_of_mem P (mem_ball_self hr)⟩
+
+def closedRibbon : Set ℂ := {z | 0 ≤ z.re ∧ |z.im| ≤ 1}
+def futureRibbon (k : ℝ) : Set ℂ := {z | k < z.re ∧ |z.im| < 1}
+
+theorem futureRibbon_subset_closedRibbon {k : ℝ} (hk : 0 ≤ k) :
+    futureRibbon k ⊆ closedRibbon := by
+  intro z hz
+  exact ⟨hk.trans hz.1.le, hz.2.le⟩
+
+theorem futureRibbon_convex (k : ℝ) : Convex ℝ (futureRibbon k) := by
+  have hre : Convex ℝ {z : ℂ | k < z.re} :=
+    convex_halfSpace_gt Complex.reLm.isLinear k
+  have him : Convex ℝ {z : ℂ | z.im ∈ Ioo (-1 : ℝ) 1} :=
+    (convex_Ioo (-1 : ℝ) 1).is_linear_preimage Complex.imLm.isLinear
+  simpa only [futureRibbon, abs_lt, mem_Ioo, ofPred_and] using hre.inter him
+
+/-- Any unbounded connected free set belongs to the unbounded component
+used in the actual Loewner surviving domain. -/
+theorem free_preconnected_subset_surviving
+    (γ : ℝ≥0 → ℂ) (T : ℝ≥0) (S : Set ℂ)
+    (hS : IsPreconnected S) (hfree : S ⊆ upperHalfPlane \ (γ '' Icc 0 T))
+    (hunbounded : ¬ Bornology.IsBounded S) : S ⊆ survivingDomain γ T := by
+  intro z hz
+  refine ⟨hfree hz, ?_⟩
+  intro hbounded
+  exact hunbounded (hbounded.subset (hS.subset_connectedComponentIn hz hfree))
+
+/-- Embedding excludes all nonlocal pieces of the stopped past from the
+future ribbon. Escape to infinity places the whole future ribbon in the
+surviving component, without assuming a filled-hull containment. -/
+theorem futureRibbon_survives
+    (P : ℂ → ℂ) (hP : ContinuousOn P closedRibbon)
+    (hi : InjOn P closedRibbon) {k : ℝ} (hk : 0 ≤ k)
+    (hH : ∀ z ∈ closedRibbon, 0 < z.re → P z ∈ upperHalfPlane)
+    (γ : ℝ≥0 → ℂ) (T : ℝ≥0)
+    (hpast : γ '' Icc 0 T ⊆ P '' {z ∈ closedRibbon | z.re ≤ k})
+    (hunbounded : ¬ Bornology.IsBounded (P '' futureRibbon k)) :
+    P '' futureRibbon k ⊆ survivingDomain γ T := by
+  have hsub := futureRibbon_subset_closedRibbon hk
+  apply free_preconnected_subset_surviving γ T _
+    ((futureRibbon_convex k).isPreconnected.image P (hP.mono hsub)) _ hunbounded
+  rintro z ⟨y, hy, rfl⟩
+  refine ⟨hH y (hsub hy) (hk.trans_lt hy.1), ?_⟩
+  intro hyPast
+  obtain ⟨x, hx, he⟩ := hpast hyPast
+  have hxy : x = y := hi hx.1 (hsub hy) he
+  exact (not_le_of_gt hy.1) (hxy ▸ hx.2)
+
+/-- A coordinate disk strictly ahead of the front and away from the two
+ribbon edges gives a physical disk in the actual surviving domain. -/
+theorem coordinate_ball_clearance
+    (P : ℂ → ℂ) (hP : ContinuousOn P closedRibbon)
+    (hi : InjOn P closedRibbon) {k : ℝ} (hk : 0 ≤ k)
+    (hH : ∀ z ∈ closedRibbon, 0 < z.re → P z ∈ upperHalfPlane)
+    (γ : ℝ≥0 → ℂ) (T : ℝ≥0)
+    (hpast : γ '' Icc 0 T ⊆ P '' {z ∈ closedRibbon | z.re ≤ k})
+    (hunbounded : ¬ Bornology.IsBounded (P '' futureRibbon k))
+    (x : ℂ) {r K : ℝ} (hr : 0 < r) (hK : 0 < K)
+    (hfront : k + r < x.re) (hedge : |x.im| + r < 1)
+    (hopen : IsOpen (P '' ball x r))
+    (hlower : ∀ y ∈ closedBall x r, dist y x ≤ K * dist (P y) (P x)) :
+    ball (P x) (r / K) ⊆ survivingDomain γ T := by
+  have hball : closedBall x r ⊆ futureRibbon k := by
+    intro y hy
+    have hd : ‖y - x‖ ≤ r := by simpa only [mem_closedBall, dist_eq_norm] using hy
+    have hre := (Complex.abs_re_le_norm (y - x)).trans hd
+    have him := (Complex.abs_im_le_norm (y - x)).trans hd
+    simp only [Complex.sub_re, Complex.sub_im] at hre him
+    refine ⟨by linarith [(abs_le.mp hre).1], ?_⟩
+    have htri : |y.im| ≤ |y.im - x.im| + |x.im| := by
+      simpa only [sub_add_cancel] using abs_add_le (y.im - x.im) x.im
+    linarith
+  exact (ball_subset_image_ball P x hr hK
+    (hP.mono (hball.trans (futureRibbon_subset_closedRibbon hk))) hopen hlower).trans
+    ((image_mono (ball_subset_closedBall.trans hball)).trans
+      (futureRibbon_survives P hP hi hk hH γ T hpast hunbounded))
+
+/-- The paper's access guide, before applying the ribbon coordinate map. -/
+def guideCoordinate (k x t : ℝ) : ℂ :=
+  ((k + t : ℝ) : ℂ) + ((x * max (1 - 4 * t) 0 : ℝ) : ℂ) * Complex.I
+
+@[simp] theorem guideCoordinate_re (k x t : ℝ) :
+    (guideCoordinate k x t).re = k + t := by simp [guideCoordinate]
+
+@[simp] theorem guideCoordinate_im (k x t : ℝ) :
+    (guideCoordinate k x t).im = x * max (1 - 4 * t) 0 := by simp [guideCoordinate]
+
+theorem guideCoordinate_continuous (k x : ℝ) : Continuous (guideCoordinate k x) := by
+  unfold guideCoordinate
+  fun_prop
+
+theorem guideCoordinate_im_bound {k x t : ℝ} (ht : 0 ≤ t) :
+    |(guideCoordinate k x t).im| ≤ |x| := by
+  rw [guideCoordinate_im, abs_mul, abs_of_nonneg (le_max_right (1 - 4 * t) 0)]
+  exact mul_le_of_le_one_right (abs_nonneg x) (max_le (by linarith) (by norm_num))
+
+/-- The longitudinal coordinate gives the lower chord bound directly. -/
+theorem guideCoordinate_lower_chord (k x u v : ℝ) :
+    |u - v| ≤ dist (guideCoordinate k x u) (guideCoordinate k x v) := by
+  have hh := Complex.abs_re_le_norm (guideCoordinate k x u - guideCoordinate k x v)
+  simpa only [Complex.sub_re, guideCoordinate_re, add_sub_add_left_eq_sub,
+    dist_eq_norm] using hh
+
+theorem guideCoordinate_upper_chord (k x u v : ℝ) :
+    dist (guideCoordinate k x u) (guideCoordinate k x v) ≤
+      (1 + 4 * |x|) * |u - v| := by
+  have hmax := abs_max_sub_max_le_abs (1 - 4 * u) (1 - 4 * v) 0
+  have he : (1 - 4 * u) - (1 - 4 * v) = -4 * (u - v) := by ring
+  rw [he, abs_mul] at hmax
+  norm_num at hmax
+  have him : |x * max (1 - 4 * u) 0 - x * max (1 - 4 * v) 0| ≤
+      |x| * (4 * |u - v|) := by
+    rw [← mul_sub, abs_mul]
+    exact mul_le_mul_of_nonneg_left hmax (abs_nonneg x)
+  have hh := Complex.norm_le_abs_re_add_abs_im
+    (guideCoordinate k x u - guideCoordinate k x v)
+  simp only [Complex.sub_re, Complex.sub_im, guideCoordinate_re, guideCoordinate_im,
+    add_sub_add_left_eq_sub] at hh
+  rw [dist_eq_norm]
+  nlinarith
+
+def guideRadius (t : ℝ) : ℝ := min t 1 / 4
+
+theorem guideRadius_pos {t : ℝ} (ht : 0 < t) : 0 < guideRadius t :=
+  div_pos (lt_min ht zero_lt_one) (by norm_num)
+
+/-- The guide is at most a quarter of the ribbon half-width from the
+centerline; its coordinate disks have radius proportional to `min(t,1)`. -/
+theorem guideCoordinate_disk_margins
+    {k x t : ℝ} (hx : |x| ≤ 1 / 4) (ht : 0 < t) :
+    k + guideRadius t < (guideCoordinate k x t).re ∧
+      |(guideCoordinate k x t).im| + guideRadius t < 1 := by
+  have hrt : guideRadius t ≤ t / 4 := div_le_div_of_nonneg_right (min_le_left _ _) (by norm_num)
+  have hr1 : guideRadius t ≤ 1 / 4 := div_le_div_of_nonneg_right (min_le_right _ _) (by norm_num)
+  have hi := (guideCoordinate_im_bound (k := k) (x := x) ht.le).trans hx
+  rw [guideCoordinate_re]
+  constructor <;> linarith
+
+/-- Applying the coordinate disk lemma proves the paper's guide clearance
+for every positive guide time, with the actual surviving domain. -/
+theorem physical_guide_clearance
+    (P : ℂ → ℂ) (hP : ContinuousOn P closedRibbon)
+    (hi : InjOn P closedRibbon) {k x K : ℝ} (hk : 0 ≤ k)
+    (hx : |x| ≤ 1 / 4) (hK : 0 < K)
+    (hH : ∀ z ∈ closedRibbon, 0 < z.re → P z ∈ upperHalfPlane)
+    (γ : ℝ≥0 → ℂ) (T : ℝ≥0)
+    (hpast : γ '' Icc 0 T ⊆ P '' {z ∈ closedRibbon | z.re ≤ k})
+    (hunbounded : ¬ Bornology.IsBounded (P '' futureRibbon k))
+    (hopen : ∀ t ∈ Ioc (0 : ℝ) 2,
+      IsOpen (P '' ball (guideCoordinate k x t) (guideRadius t)))
+    (hlower : ∀ t ∈ Ioc (0 : ℝ) 2,
+      ∀ y ∈ closedBall (guideCoordinate k x t) (guideRadius t),
+        dist y (guideCoordinate k x t) ≤ K * dist (P y) (P (guideCoordinate k x t))) :
+    ∀ t ∈ Ioc (0 : ℝ) 2,
+      ball (P (guideCoordinate k x t)) (min t 1 / (4 * K)) ⊆ survivingDomain γ T := by
+  intro t ht
+  obtain ⟨hfront, hedge⟩ := guideCoordinate_disk_margins (k := k) hx ht.1
+  have hh := coordinate_ball_clearance P hP hi hk hH γ T hpast hunbounded
+    (guideCoordinate k x t) (guideRadius_pos ht.1) hK hfront hedge (hopen t ht) (hlower t ht)
+  simpa only [guideRadius, div_div] using hh
+
+/-- The fixed length-four patch appearing in the admissible ribbon class. -/
+def guidePatch (k : ℝ) : Set ℂ := {z | k ≤ z.re ∧ z.re ≤ k + 3 ∧ |z.im| ≤ 1}
+
+theorem guideCoordinate_disk_subset_patch
+    {k x t : ℝ} (hx : |x| ≤ 1 / 4) (ht : t ∈ Ioc (0 : ℝ) 2) :
+    closedBall (guideCoordinate k x t) (guideRadius t) ⊆ guidePatch k := by
+  intro y hy
+  have hd : ‖y - guideCoordinate k x t‖ ≤ guideRadius t := by
+    simpa only [mem_closedBall, dist_eq_norm] using hy
+  have hre := (Complex.abs_re_le_norm (y - guideCoordinate k x t)).trans hd
+  have him := (Complex.abs_im_le_norm (y - guideCoordinate k x t)).trans hd
+  simp only [Complex.sub_re, Complex.sub_im, guideCoordinate_re, guideCoordinate_im] at hre him
+  obtain ⟨hfront, hedge⟩ := guideCoordinate_disk_margins (k := k) hx ht.1
+  have hr1 : guideRadius t ≤ 1 / 4 :=
+    div_le_div_of_nonneg_right (min_le_right _ _) (by norm_num)
+  have hi := (guideCoordinate_im_bound (k := k) (x := x) ht.1.le).trans hx
+  have htri : |y.im| ≤ |y.im - (guideCoordinate k x t).im| +
+      |(guideCoordinate k x t).im| := by
+    simpa only [sub_add_cancel] using
+      abs_add_le (y.im - (guideCoordinate k x t).im) (guideCoordinate k x t).im
+  change k ≤ y.re ∧ y.re ≤ k + 3 ∧ |y.im| ≤ 1
+  simp only [guideCoordinate_re] at hfront
+  simp only [guideCoordinate_im] at htri hi
+  exact ⟨by linarith [(abs_le.mp hre).1], by linarith [(abs_le.mp hre).2, ht.2],
+    by linarith⟩
+
+theorem guidePatch_subset_closedRibbon {k : ℝ} (hk : 0 ≤ k) :
+    guidePatch k ⊆ closedRibbon := by
+  intro z hz
+  exact ⟨hk.trans hz.1, hz.2.2⟩
+
+/-- The actual fixed patch inverse-Lipschitz bound suffices for all guide
+disks. The only topological parameter is the cited planar disk theorem. -/
+theorem physical_guide_clearance_of_patch
+    (hpublished : PublishedPlanarDiskOpenness)
+    (P : ℂ → ℂ) (hP : ContinuousOn P closedRibbon)
+    (hi : InjOn P closedRibbon) {k x K : ℝ} (hk : 0 ≤ k)
+    (hx : |x| ≤ 1 / 4) (hK : 0 < K)
+    (hH : ∀ z ∈ closedRibbon, 0 < z.re → P z ∈ upperHalfPlane)
+    (γ : ℝ≥0 → ℂ) (T : ℝ≥0)
+    (hpast : γ '' Icc 0 T ⊆ P '' {z ∈ closedRibbon | z.re ≤ k})
+    (hunbounded : ¬ Bornology.IsBounded (P '' futureRibbon k))
+    (hlower : ∀ u ∈ guidePatch k, ∀ v ∈ guidePatch k,
+      dist u v ≤ K * dist (P u) (P v)) :
+    ∀ t ∈ Ioc (0 : ℝ) 2,
+      ball (P (guideCoordinate k x t)) (min t 1 / (4 * K)) ⊆ survivingDomain γ T := by
+  apply physical_guide_clearance P hP hi hk hx hK hH γ T hpast hunbounded
+  · intro t ht
+    have hsub := (ball_subset_closedBall.trans (guideCoordinate_disk_subset_patch hx ht)).trans
+      (guidePatch_subset_closedRibbon hk)
+    exact hpublished P _ _ (guideRadius_pos ht.1) (hP.mono hsub) (hi.mono hsub)
+  · intro t ht y hy
+    have hsub := guideCoordinate_disk_subset_patch (k := k) hx ht
+    exact hlower y (hsub hy) _ (hsub (mem_closedBall_self (guideRadius_pos ht.1).le))
+
+/-- Uniform clearance on every closed interval away from the tip is the
+form used by joint physical/conformal guide compactness. -/
+theorem physical_guide_clearance_away
+    (hpublished : PublishedPlanarDiskOpenness)
+    (P : ℂ → ℂ) (hP : ContinuousOn P closedRibbon)
+    (hi : InjOn P closedRibbon) {k x K : ℝ} (hk : 0 ≤ k)
+    (hx : |x| ≤ 1 / 4) (hK : 0 < K)
+    (hH : ∀ z ∈ closedRibbon, 0 < z.re → P z ∈ upperHalfPlane)
+    (γ : ℝ≥0 → ℂ) (T : ℝ≥0)
+    (hpast : γ '' Icc 0 T ⊆ P '' {z ∈ closedRibbon | z.re ≤ k})
+    (hunbounded : ¬ Bornology.IsBounded (P '' futureRibbon k))
+    (hlower : ∀ u ∈ guidePatch k, ∀ v ∈ guidePatch k,
+      dist u v ≤ K * dist (P u) (P v))
+    {δ : ℝ} (hδ : 0 < δ) (_hδ2 : δ ≤ 2) :
+    ∃ r : ℝ, 0 < r ∧ ∀ t ∈ Icc δ 2,
+      ball (P (guideCoordinate k x t)) r ⊆ survivingDomain γ T := by
+  refine ⟨min δ 1 / (4 * K), div_pos (lt_min hδ zero_lt_one) (by positivity), ?_⟩
+  intro t ht
+  apply (ball_subset_ball ?_).trans (physical_guide_clearance_of_patch hpublished P hP hi
+    hk hx hK hH γ T hpast hunbounded hlower t ⟨hδ.trans_le ht.1, ht.2⟩)
+  exact div_le_div_of_nonneg_right (min_le_min_right 1 ht.1) (by positivity)
+
+theorem guideCoordinate_mem_patch {k x t : ℝ}
+    (hx : |x| ≤ 1 / 4) (ht : t ∈ Icc (0 : ℝ) 2) :
+    guideCoordinate k x t ∈ guidePatch k := by
+  change k ≤ (guideCoordinate k x t).re ∧
+    (guideCoordinate k x t).re ≤ k + 3 ∧ |(guideCoordinate k x t).im| ≤ 1
+  rw [guideCoordinate_re]
+  exact ⟨by linarith [ht.1], by linarith [ht.2],
+    (guideCoordinate_im_bound ht.1).trans (hx.trans (by norm_num))⟩
+
+/-- The fixed coordinate patch speed bound gives the physical guide speed
+bound required by the compactness and access-localization arguments. -/
+theorem physical_guide_lipschitz
+    (P : ℂ → ℂ) (C : ℝ≥0) {k x : ℝ} (hx : |x| ≤ 1 / 4)
+    (hL : LipschitzOnWith C P (guidePatch k)) :
+    LipschitzOnWith (2 * C) (fun t => P (guideCoordinate k x t)) (Icc (0 : ℝ) 2) := by
+  apply lipschitzOnWith_iff_dist_le_mul.mpr
+  intro u hu v hv
+  have hp := hL.dist_le_mul _ (guideCoordinate_mem_patch hx hu) _
+    (guideCoordinate_mem_patch hx hv)
+  have hq := guideCoordinate_upper_chord k x u v
+  have hcq : dist (guideCoordinate k x u) (guideCoordinate k x v) ≤ 2 * |u - v| := by
+    exact hq.trans (mul_le_mul_of_nonneg_right (by linarith) (abs_nonneg _))
+  have hh := mul_le_mul_of_nonneg_left hcq C.coe_nonneg
+  simp only [NNReal.coe_mul, NNReal.coe_ofNat, Real.dist_eq]
+  nlinarith
+
+/-- The lower patch Lipschitz bound makes the physical guide uniformly
+simple, including its initial boundary point. -/
+theorem physical_guide_lower_chord
+    (P : ℂ → ℂ) {k x K : ℝ} (hx : |x| ≤ 1 / 4) (hK : 0 < K)
+    (hlower : ∀ u ∈ guidePatch k, ∀ v ∈ guidePatch k,
+      dist u v ≤ K * dist (P u) (P v)) :
+    ∀ u ∈ Icc (0 : ℝ) 2, ∀ v ∈ Icc (0 : ℝ) 2,
+      (1 / K) * |u - v| ≤ dist (P (guideCoordinate k x u)) (P (guideCoordinate k x v)) := by
+  intro u hu v hv
+  have hh := (guideCoordinate_lower_chord k x u v).trans
+    (hlower _ (guideCoordinate_mem_patch hx hu) _ (guideCoordinate_mem_patch hx hv))
+  rw [one_div_mul_eq_div, div_le_iff₀ hK]
+  simpa only [mul_comm] using hh
+
+@[simp] theorem guideCoordinate_zero (k x : ℝ) :
+    guideCoordinate k x 0 = (k : ℂ) + (x : ℂ) * Complex.I := by simp [guideCoordinate]
+
+@[simp] theorem guideCoordinate_waypoint (k x : ℝ) :
+    guideCoordinate k x (1 / 2) = ((k + 1 / 2 : ℝ) : ℂ) := by
+  norm_num [guideCoordinate]
+
+/-- The paper's escape condition on the centerline supplies the
+unboundedness used to select the actual surviving component. -/
+theorem futureRibbon_unbounded_of_centerline_escape
+    (P : ℂ → ℂ) (k : ℝ)
+    (hescape : Tendsto (fun s : ℝ => ‖P (s : ℂ)‖) atTop atTop) :
+    ¬ Bornology.IsBounded (P '' futureRibbon k) := by
+  intro hb
+  obtain ⟨R, _, hR⟩ := hb.exists_pos_norm_lt
+  obtain ⟨s, hs, hsR⟩ := ((eventually_gt_atTop k).and
+    (hescape.eventually (eventually_gt_atTop R))).exists
+  have hz : (s : ℂ) ∈ futureRibbon k := by
+    change k < (s : ℂ).re ∧ |(s : ℂ).im| < 1
+    simpa using And.intro hs (by norm_num : |(0 : ℝ)| < 1)
+  exact (not_lt_of_ge hsR.le) (hR _ (mem_image_of_mem P hz))
+
+end SLEExactGauge.RibbonCoordinates
+
+end
+
+end OAI

lean/OAI/Probability/SLE/Gauge/RibbonCoordinateLimit.lean

@@ -1,138 +1,138 @@
-import OAI.Probability.SLE.Gauge.RibbonCoordinateCompactness
-
-namespace OAI
-
-/-! Strict half-plane location and actual moving ribbon regions for the
-compact coordinate limits. The middle region has the manuscript's fixed
-longitudinal interval `(1/3,2/3)` and transverse width. -/
-
-noncomputable section
-open Set Filter Metric
-open scoped Topology NNReal
-
-namespace SLEExactGauge.RibbonCoordinates
-
-/-- An open planar set in the closed upper half-plane cannot meet its
-boundary line. -/
-theorem open_nonnegative_height_subset_upperHalfPlane
-    (U : Set ℂ) (hU : IsOpen U) (hheight : ∀ z ∈ U, 0 ≤ z.im) :
-    U ⊆ upperHalfPlane := by
-  intro z hz
-  by_contra hn
-  have hz0 : z.im = 0 := le_antisymm (le_of_not_gt hn) (hheight z hz)
-  obtain ⟨ε, hε, hball⟩ := Metric.isOpen_iff.mp hU z hz
-  let w : ℂ := z - ((ε / 2 : ℝ) : ℂ) * Complex.I
-  have hwsub : w - z = -(((ε / 2 : ℝ) : ℂ) * Complex.I) := by dsimp [w]; ring
-  have hdist : dist w z = ε / 2 := by
-    rw [dist_eq_norm, hwsub, norm_neg, norm_mul, Complex.norm_I, mul_one]
-    simp only [Complex.norm_real, Real.norm_eq_abs, abs_of_pos (half_pos hε)]
-  have hw : w ∈ U := hball (by rw [mem_ball, hdist]; linarith)
-  have him : w.im = z.im - ε / 2 := by simp [w]
-  have hh := hheight w hw
-  rw [him, hz0] at hh
-  linarith
-
-/-- Uniform limits of admissible embedded ribbon patches still have
-strictly positive height at every interior coordinate point. -/
-theorem uniform_limit_interior_upperHalfPlane
-    (hpublished : PublishedPlanarDiskOpenness)
-    (Pₙ : ℕ → ℂ → ℂ) (P : ℂ → ℂ) (K : Set ℂ)
-    (hP : ContinuousOn P K) (hi : InjOn P K)
-    (hconv : TendstoUniformlyOn Pₙ P atTop K)
-    (hheight : ∀ n z, z ∈ K → 0 ≤ (Pₙ n z).im) :
-    MapsTo P (interior K) upperHalfPlane := by
-  have hopen := isOpen_image_interior hpublished P K hP hi
-  have hnonneg : ∀ z ∈ P '' interior K, 0 ≤ z.im := by
-    rintro _ ⟨x, hx, rfl⟩
-    exact ge_of_tendsto ((Complex.continuous_im.tendsto _).comp
-      (hconv.tendsto_at (interior_subset hx)))
-      (Eventually.of_forall (fun n => hheight n x (interior_subset hx)))
-  intro x hx
-  exact open_nonnegative_height_subset_upperHalfPlane _ hopen hnonneg
-    (mem_image_of_mem P hx)
-
-/-- The compactness output needed for a local ribbon patch includes
-strict limiting height, without a separate positivity assumption. -/
-theorem exists_bilip_halfPlane_subsequence
-    (hpublished : PublishedPlanarDiskOpenness)
-    (Pₙ : ℕ → ℂ → ℂ) (K : Set ℂ) (hK : IsCompact K)
-    (x₀ : ℂ) (hx₀ : x₀ ∈ K) (C L : ℝ≥0) (R : ℝ)
-    (hupper : ∀ n, LipschitzOnWith C (Pₙ n) K)
-    (hlower : ∀ n x, x ∈ K → ∀ y, y ∈ K → dist x y ≤ L * dist (Pₙ n x) (Pₙ n y))
-    (htip : ∀ n, ‖Pₙ n x₀‖ ≤ R)
-    (hheight : ∀ n z, z ∈ K → 0 ≤ (Pₙ n z).im) :
-    ∃ P : ℂ → ℂ, ∃ φ : ℕ → ℕ, StrictMono φ ∧
-      TendstoUniformlyOn (fun n => Pₙ (φ n)) P atTop K ∧
-      LipschitzOnWith C P K ∧
-      (∀ x ∈ K, ∀ y ∈ K, dist x y ≤ L * dist (P x) (P y)) ∧
-      InjOn P K ∧ MapsTo P (interior K) upperHalfPlane := by
-  obtain ⟨P, φ, hφ, hconv, hPu, hPl, hi⟩ :=
-    exists_bilip_uniform_subsequence Pₙ K hK x₀ hx₀ C L R hupper hlower htip
-  exact ⟨P, φ, hφ, hconv, hPu, hPl, hi,
-    uniform_limit_interior_upperHalfPlane hpublished (fun n => Pₙ (φ n)) P K
-      hPu.continuousOn hi hconv (fun n => hheight (φ n))⟩
-
-/-- The actual physical middle strip in the source's local coordinates. -/
-def physicalMiddleRegion (P : ℂ → ℂ) (K : Set ℂ) (k ε : ℝ) : Set ℂ :=
-  P '' {w ∈ K | (1 / 3 : ℝ) < w.re - k ∧ w.re - k < 2 / 3 ∧ |w.im| < ε}
-
-/-- Strict transverse margin on a compact common physical patch implies
-that its moving longitudinal band is in the actual moving middle strip. -/
-theorem eventual_middle_region_inclusion
-    (Pₙ : ℕ → ℂ → ℂ) (P : ℂ → ℂ) (K U : Set ℂ) (L : ℝ≥0) (k ε : ℝ)
-    (hconv : TendstoUniformlyOn Pₙ P atTop K)
-    (hlower : ∀ n x, x ∈ K → ∀ y, y ∈ K → dist x y ≤ L * dist (Pₙ n x) (Pₙ n y))
-    (hU : IsCompact (closure U)) (hUP : closure U ⊆ P '' K)
-    (hcover : ∀ᶠ n in atTop, closure U ⊆ Pₙ n '' K)
-    (hwidth : ∀ z ∈ closure U, |(coordinateInverse P K z).im| < ε) :
-    ∀ᶠ n in atTop,
-      U ∩ {z | (1 / 3 : ℝ) < longitudinalCoordinate (Pₙ n) K k z ∧
-        longitudinalCoordinate (Pₙ n) K k z < 2 / 3} ⊆
-      physicalMiddleRegion (Pₙ n) K k ε := by
-  have hopen : IsOpen {w : ℂ | |w.im| < ε} := isOpen_lt Complex.continuous_im.abs continuous_const
-  have hcoord := eventual_compact_coordinate_region Pₙ P K (closure U)
-    {w : ℂ | |w.im| < ε} L hconv hlower hU hUP hcover hopen
-    (by rintro _ ⟨z, hz, rfl⟩; exact hwidth z hz)
-  filter_upwards [hcoord] with n hn
-  rintro z ⟨hz, hband⟩
-  obtain ⟨x, hx, he⟩ := hn (subset_closure hz)
-  have hi := lower_lipschitz_injOn (Pₙ n) K L (hlower n)
-  have heq : coordinateInverse (Pₙ n) K z = x := by
-    rw [← he]
-    exact coordinateInverse_left hi hx.1
-  refine ⟨x, ⟨hx.1, ?_, ?_, hx.2⟩, he⟩
-  · simpa only [longitudinalCoordinate, heq] using hband.1
-  · simpa only [longitudinalCoordinate, heq] using hband.2
-
-/-- Physical terminal control with the inverse patch constant gives the
-source's transverse coordinate bound at the attained front. -/
-theorem source_terminal_offset
-    (P : ℂ → ℂ) (K : Set ℂ) (L : ℝ≥0) (k ε : ℝ) (z : ℂ)
-    (hL : 0 < L)
-    (hlower : ∀ x ∈ K, ∀ y ∈ K, dist x y ≤ L * dist (P x) (P y))
-    (hbase : ((k + 1 : ℝ) : ℂ) ∈ K) (hz : z ∈ P '' K)
-    (hp : longitudinalCoordinate P K k z = 1)
-    (hd : dist z (P ((k + 1 : ℝ) : ℂ)) < ε / (4 * (L : ℝ))) :
-    (coordinateInverse P K z).re = k + 1 ∧
-      |(coordinateInverse P K z).im| < ε / 4 := by
-  constructor
-  · dsimp [longitudinalCoordinate] at hp
-    linarith
-  · have hh := hlower _ (coordinateInverse_mem hz) _ hbase
-    rw [coordinateInverse_right hz] at hh
-    have him : |(coordinateInverse P K z).im| ≤
-        dist (coordinateInverse P K z) ((k + 1 : ℝ) : ℂ) := by
-      simpa only [dist_eq_norm, Complex.sub_im, Complex.ofReal_im, sub_zero]
-        using Complex.abs_im_le_norm (coordinateInverse P K z - ((k + 1 : ℝ) : ℂ))
-    have hLr : 0 < (L : ℝ) := hL
-    have hden : 0 < 4 * (L : ℝ) := by positivity
-    have hd' := (lt_div_iff₀ hden).mp hd
-    have he : (L : ℝ) * dist z (P ((k + 1 : ℝ) : ℂ)) < ε / 4 := by
-      linarith
-    exact (him.trans hh).trans_lt he
-
-end SLEExactGauge.RibbonCoordinates
-
-end
-
-end OAI
+import OAI.Probability.SLE.Gauge.RibbonCoordinateCompactness
+
+namespace OAI
+
+/-! Strict half-plane location and actual moving ribbon regions for the
+compact coordinate limits. The middle region has the manuscript's fixed
+longitudinal interval `(1/3,2/3)` and transverse width. -/
+
+noncomputable section
+open Set Filter Metric
+open scoped Topology NNReal
+
+namespace SLEExactGauge.RibbonCoordinates
+
+/-- An open planar set in the closed upper half-plane cannot meet its
+boundary line. -/
+theorem open_nonnegative_height_subset_upperHalfPlane
+    (U : Set ℂ) (hU : IsOpen U) (hheight : ∀ z ∈ U, 0 ≤ z.im) :
+    U ⊆ upperHalfPlane := by
+  intro z hz
+  by_contra hn
+  have hz0 : z.im = 0 := le_antisymm (le_of_not_gt hn) (hheight z hz)
+  obtain ⟨ε, hε, hball⟩ := Metric.isOpen_iff.mp hU z hz
+  let w : ℂ := z - ((ε / 2 : ℝ) : ℂ) * Complex.I
+  have hwsub : w - z = -(((ε / 2 : ℝ) : ℂ) * Complex.I) := by dsimp [w]; ring
+  have hdist : dist w z = ε / 2 := by
+    rw [dist_eq_norm, hwsub, norm_neg, norm_mul, Complex.norm_I, mul_one]
+    simp only [Complex.norm_real, Real.norm_eq_abs, abs_of_pos (half_pos hε)]
+  have hw : w ∈ U := hball (by rw [mem_ball, hdist]; linarith)
+  have him : w.im = z.im - ε / 2 := by simp [w]
+  have hh := hheight w hw
+  rw [him, hz0] at hh
+  linarith
+
+/-- Uniform limits of admissible embedded ribbon patches still have
+strictly positive height at every interior coordinate point. -/
+theorem uniform_limit_interior_upperHalfPlane
+    (hpublished : PublishedPlanarDiskOpenness)
+    (Pₙ : ℕ → ℂ → ℂ) (P : ℂ → ℂ) (K : Set ℂ)
+    (hP : ContinuousOn P K) (hi : InjOn P K)
+    (hconv : TendstoUniformlyOn Pₙ P atTop K)
+    (hheight : ∀ n z, z ∈ K → 0 ≤ (Pₙ n z).im) :
+    MapsTo P (interior K) upperHalfPlane := by
+  have hopen := isOpen_image_interior hpublished P K hP hi
+  have hnonneg : ∀ z ∈ P '' interior K, 0 ≤ z.im := by
+    rintro _ ⟨x, hx, rfl⟩
+    exact ge_of_tendsto ((Complex.continuous_im.tendsto _).comp
+      (hconv.tendsto_at (interior_subset hx)))
+      (Eventually.of_forall (fun n => hheight n x (interior_subset hx)))
+  intro x hx
+  exact open_nonnegative_height_subset_upperHalfPlane _ hopen hnonneg
+    (mem_image_of_mem P hx)
+
+/-- The compactness output needed for a local ribbon patch includes
+strict limiting height, without a separate positivity assumption. -/
+theorem exists_bilip_halfPlane_subsequence
+    (hpublished : PublishedPlanarDiskOpenness)
+    (Pₙ : ℕ → ℂ → ℂ) (K : Set ℂ) (hK : IsCompact K)
+    (x₀ : ℂ) (hx₀ : x₀ ∈ K) (C L : ℝ≥0) (R : ℝ)
+    (hupper : ∀ n, LipschitzOnWith C (Pₙ n) K)
+    (hlower : ∀ n x, x ∈ K → ∀ y, y ∈ K → dist x y ≤ L * dist (Pₙ n x) (Pₙ n y))
+    (htip : ∀ n, ‖Pₙ n x₀‖ ≤ R)
+    (hheight : ∀ n z, z ∈ K → 0 ≤ (Pₙ n z).im) :
+    ∃ P : ℂ → ℂ, ∃ φ : ℕ → ℕ, StrictMono φ ∧
+      TendstoUniformlyOn (fun n => Pₙ (φ n)) P atTop K ∧
+      LipschitzOnWith C P K ∧
+      (∀ x ∈ K, ∀ y ∈ K, dist x y ≤ L * dist (P x) (P y)) ∧
+      InjOn P K ∧ MapsTo P (interior K) upperHalfPlane := by
+  obtain ⟨P, φ, hφ, hconv, hPu, hPl, hi⟩ :=
+    exists_bilip_uniform_subsequence Pₙ K hK x₀ hx₀ C L R hupper hlower htip
+  exact ⟨P, φ, hφ, hconv, hPu, hPl, hi,
+    uniform_limit_interior_upperHalfPlane hpublished (fun n => Pₙ (φ n)) P K
+      hPu.continuousOn hi hconv (fun n => hheight (φ n))⟩
+
+/-- The actual physical middle strip in the source's local coordinates. -/
+def physicalMiddleRegion (P : ℂ → ℂ) (K : Set ℂ) (k ε : ℝ) : Set ℂ :=
+  P '' {w ∈ K | (1 / 3 : ℝ) < w.re - k ∧ w.re - k < 2 / 3 ∧ |w.im| < ε}
+
+/-- Strict transverse margin on a compact common physical patch implies
+that its moving longitudinal band is in the actual moving middle strip. -/
+theorem eventual_middle_region_inclusion
+    (Pₙ : ℕ → ℂ → ℂ) (P : ℂ → ℂ) (K U : Set ℂ) (L : ℝ≥0) (k ε : ℝ)
+    (hconv : TendstoUniformlyOn Pₙ P atTop K)
+    (hlower : ∀ n x, x ∈ K → ∀ y, y ∈ K → dist x y ≤ L * dist (Pₙ n x) (Pₙ n y))
+    (hU : IsCompact (closure U)) (hUP : closure U ⊆ P '' K)
+    (hcover : ∀ᶠ n in atTop, closure U ⊆ Pₙ n '' K)
+    (hwidth : ∀ z ∈ closure U, |(coordinateInverse P K z).im| < ε) :
+    ∀ᶠ n in atTop,
+      U ∩ {z | (1 / 3 : ℝ) < longitudinalCoordinate (Pₙ n) K k z ∧
+        longitudinalCoordinate (Pₙ n) K k z < 2 / 3} ⊆
+      physicalMiddleRegion (Pₙ n) K k ε := by
+  have hopen : IsOpen {w : ℂ | |w.im| < ε} := isOpen_lt Complex.continuous_im.abs continuous_const
+  have hcoord := eventual_compact_coordinate_region Pₙ P K (closure U)
+    {w : ℂ | |w.im| < ε} L hconv hlower hU hUP hcover hopen
+    (by rintro _ ⟨z, hz, rfl⟩; exact hwidth z hz)
+  filter_upwards [hcoord] with n hn
+  rintro z ⟨hz, hband⟩
+  obtain ⟨x, hx, he⟩ := hn (subset_closure hz)
+  have hi := lower_lipschitz_injOn (Pₙ n) K L (hlower n)
+  have heq : coordinateInverse (Pₙ n) K z = x := by
+    rw [← he]
+    exact coordinateInverse_left hi hx.1
+  refine ⟨x, ⟨hx.1, ?_, ?_, hx.2⟩, he⟩
+  · simpa only [longitudinalCoordinate, heq] using hband.1
+  · simpa only [longitudinalCoordinate, heq] using hband.2
+
+/-- Physical terminal control with the inverse patch constant gives the
+source's transverse coordinate bound at the attained front. -/
+theorem source_terminal_offset
+    (P : ℂ → ℂ) (K : Set ℂ) (L : ℝ≥0) (k ε : ℝ) (z : ℂ)
+    (hL : 0 < L)
+    (hlower : ∀ x ∈ K, ∀ y ∈ K, dist x y ≤ L * dist (P x) (P y))
+    (hbase : ((k + 1 : ℝ) : ℂ) ∈ K) (hz : z ∈ P '' K)
+    (hp : longitudinalCoordinate P K k z = 1)
+    (hd : dist z (P ((k + 1 : ℝ) : ℂ)) < ε / (4 * (L : ℝ))) :
+    (coordinateInverse P K z).re = k + 1 ∧
+      |(coordinateInverse P K z).im| < ε / 4 := by
+  constructor
+  · dsimp [longitudinalCoordinate] at hp
+    linarith
+  · have hh := hlower _ (coordinateInverse_mem hz) _ hbase
+    rw [coordinateInverse_right hz] at hh
+    have him : |(coordinateInverse P K z).im| ≤
+        dist (coordinateInverse P K z) ((k + 1 : ℝ) : ℂ) := by
+      simpa only [dist_eq_norm, Complex.sub_im, Complex.ofReal_im, sub_zero]
+        using Complex.abs_im_le_norm (coordinateInverse P K z - ((k + 1 : ℝ) : ℂ))
+    have hLr : 0 < (L : ℝ) := hL
+    have hden : 0 < 4 * (L : ℝ) := by positivity
+    have hd' := (lt_div_iff₀ hden).mp hd
+    have he : (L : ℝ) * dist z (P ((k + 1 : ℝ) : ℂ)) < ε / 4 := by
+      linarith
+    exact (him.trans hh).trans_lt he
+
+end SLEExactGauge.RibbonCoordinates
+
+end
+
+end OAI

lean/OAI/Probability/SLE/Gauge/RibbonExperimentAssembly.lean

@@ -1,100 +1,100 @@
-import OAI.Probability.SLE.Gauge.RibbonMiddleMass
-import OAI.Probability.SLE.Gauge.RandomPassageBounds
-
-namespace OAI
-
-/-! The dense experiment concatenates full passage-and-mass events only
-on histories where every previous passage has succeeded. Their spatial
-middle strips are then charged to one actual sausage. -/
-
-noncomputable section
-open Set Filter MeasureTheory
-open scoped Topology NNReal ENNReal
-
-namespace SLEExactGauge
-open RibbonCoordinates
-
-lemma adapted_successes_lower_bound_on_previous
-    {Ω : Type*} [mΩ : MeasurableSpace Ω] (P : Measure Ω)
-    (ℱ : Filtration ℕ mΩ) (init : Set Ω) (hinit : MeasurableSet[ℱ 0] init)
-    (success : ℕ → Set Ω) (hmeas : ∀ n, MeasurableSet[ℱ (n + 1)] (success n))
-    (q : ℝ≥0∞)
-    (hstep : ∀ n (A : Set Ω), MeasurableSet[ℱ n] A →
-      A ⊆ init ∩ ⋂ j ∈ Finset.range n, success j → q * P A ≤ P (A ∩ success n)) :
-    ∀ N : ℕ, q ^ N * P init ≤ P (init ∩ ⋂ n ∈ Finset.range N, success n) := by
-  intro N
-  induction N with
-  | zero => simp
-  | succ N ih =>
-    let A := init ∩ ⋂ n ∈ Finset.range N, success n
-    have hA : MeasurableSet[ℱ N] A := by
-      apply ((ℱ.mono (Nat.zero_le N)) _ hinit).inter
-      apply MeasurableSet.iInter
-      intro n
-      apply MeasurableSet.iInter
-      intro hn
-      exact (ℱ.mono (Nat.succ_le_of_lt (Finset.mem_range.mp hn))) _ (hmeas n)
-    have he : (init ∩ ⋂ n ∈ Finset.range (N + 1), success n) = A ∩ success N := by
-      ext ω
-      simp only [A, mem_inter_iff, mem_iInter, Finset.mem_range]
-      constructor
-      · rintro ⟨hi, h⟩
-        exact ⟨⟨hi, fun n hn => h n (Nat.lt_succ_of_lt hn)⟩, h N (Nat.lt_succ_self N)⟩
-      · rintro ⟨⟨hi, h⟩, hN⟩
-        refine ⟨hi, fun n hn => ?_⟩
-        rcases Nat.lt_succ_iff_lt_or_eq.mp hn with hn | rfl
-        · exact h n hn
-        · exact hN
-    rw [he, pow_succ]
-    calc
-      q ^ N * q * P init = q * (q ^ N * P init) := by ac_rfl
-      _ ≤ q * P A := mul_le_mul' le_rfl ih
-      _ ≤ P (A ∩ success N) := hstep N A hA Subset.rfl
-
-lemma ribbon_probability_of_quadratic_completion
-    {q D : ℝ} (hq : 0 < q) (hq1 : q ≤ 1) (hD : 0 ≤ D) :
-    ∃ C : ℝ, 0 < C ∧ ∀ (m N : ℕ), (N : ℝ) ≤ D * (m : ℝ) ^ 2 →
-      Real.exp (-C * (m : ℝ) ^ 2) ≤ q ^ N := by
-  have hlog : Real.log q ≤ 0 := Real.log_nonpos hq.le hq1
-  refine ⟨1 - D * Real.log q, by nlinarith, ?_⟩
-  intro m N hN
-  calc
-    _ ≤ Real.exp ((N : ℝ) * Real.log q) := by
-      apply Real.exp_le_exp.mpr
-      have hh := mul_le_mul_of_nonpos_right hN hlog
-      nlinarith [sq_nonneg (m : ℝ)]
-    _ = q ^ N := by rw [Real.exp_nat_mul, Real.exp_log hq]
-
-/-- The genuine adapted successes force the desired whole-trace mass at
-one prescribed mesh, using only retained disjoint middle strips. -/
-theorem ribbon_experiment_mass_event_probability
-    {Ω : Type*} [mΩ : MeasurableSpace Ω] (μ : Measure Ω)
-    (ℱ : Filtration ℕ mΩ) (init : Set Ω) (hinit : MeasurableSet[ℱ 0] init)
-    (success : ℕ → Set Ω) (hmeas : ∀ n, MeasurableSet[ℱ (n + 1)] (success n))
-    (q : ℝ≥0∞)
-    (hstep : ∀ n (A : Set Ω), MeasurableSet[ℱ n] A →
-      A ⊆ init ∩ ⋂ j ∈ Finset.range n, success j → q * μ A ≤ μ (A ∩ success n))
-    (hpublished : PublishedPlanarDiskOpenness)
-    (P : ℂ → ℂ) (hP : ContinuousOn P closedRibbon) (hiP : InjOn P closedRibbon)
-    {ε : ℝ} (hε : ε ≤ 1) (I : Finset ℕ) (N : ℕ)
-    (κ : ℝ) (γ : Ω → ℝ≥0 → ℂ) (s t : ℕ → Ω → ℝ≥0) (v c ell : ℝ)
-    (hell : 0 < ell) (m : ℕ) (hm : 0 < m) (hcard : I.card = m ^ 2) (D : Set ℂ)
-    (hregions : ∀ i ∈ I, physicalMiddleRegion P closedRibbon i ε ⊆ D)
-    (hmass : ∀ ω ∈ init ∩ ⋂ n ∈ Finset.range N, success n, ∀ i ∈ I,
-      ENNReal.ofReal (c * (ell / (m : ℝ)) ^ dimension κ) ≤
-        segmentSausageCharge κ (γ ω) (s i ω) (t i ω) v
-          (physicalMiddleRegion P closedRibbon i ε)) :
-    q ^ N * μ init ≤ μ {ω |
-      ENNReal.ofReal (c * ell ^ dimension κ * (m : ℝ) ^ codimension κ) ≤
-        wholeSausageCharge κ (γ ω) v D} := by
-  refine (adapted_successes_lower_bound_on_previous μ ℱ init hinit success hmeas q hstep N).trans
-    (measure_mono ?_)
-  intro ω hω
-  exact dense_ribbon_mass_from_steps hpublished P hP hiP hε I κ (γ ω)
-    (fun i => s i ω) (fun i => t i ω) v c ell hell m hm hcard D hregions (hmass ω hω)
-
-end SLEExactGauge
-
-end
-
-end OAI
+import OAI.Probability.SLE.Gauge.RibbonMiddleMass
+import OAI.Probability.SLE.Gauge.RandomPassageBounds
+
+namespace OAI
+
+/-! The dense experiment concatenates full passage-and-mass events only
+on histories where every previous passage has succeeded. Their spatial
+middle strips are then charged to one actual sausage. -/
+
+noncomputable section
+open Set Filter MeasureTheory
+open scoped Topology NNReal ENNReal
+
+namespace SLEExactGauge
+open RibbonCoordinates
+
+lemma adapted_successes_lower_bound_on_previous
+    {Ω : Type*} [mΩ : MeasurableSpace Ω] (P : Measure Ω)
+    (ℱ : Filtration ℕ mΩ) (init : Set Ω) (hinit : MeasurableSet[ℱ 0] init)
+    (success : ℕ → Set Ω) (hmeas : ∀ n, MeasurableSet[ℱ (n + 1)] (success n))
+    (q : ℝ≥0∞)
+    (hstep : ∀ n (A : Set Ω), MeasurableSet[ℱ n] A →
+      A ⊆ init ∩ ⋂ j ∈ Finset.range n, success j → q * P A ≤ P (A ∩ success n)) :
+    ∀ N : ℕ, q ^ N * P init ≤ P (init ∩ ⋂ n ∈ Finset.range N, success n) := by
+  intro N
+  induction N with
+  | zero => simp
+  | succ N ih =>
+    let A := init ∩ ⋂ n ∈ Finset.range N, success n
+    have hA : MeasurableSet[ℱ N] A := by
+      apply ((ℱ.mono (Nat.zero_le N)) _ hinit).inter
+      apply MeasurableSet.iInter
+      intro n
+      apply MeasurableSet.iInter
+      intro hn
+      exact (ℱ.mono (Nat.succ_le_of_lt (Finset.mem_range.mp hn))) _ (hmeas n)
+    have he : (init ∩ ⋂ n ∈ Finset.range (N + 1), success n) = A ∩ success N := by
+      ext ω
+      simp only [A, mem_inter_iff, mem_iInter, Finset.mem_range]
+      constructor
+      · rintro ⟨hi, h⟩
+        exact ⟨⟨hi, fun n hn => h n (Nat.lt_succ_of_lt hn)⟩, h N (Nat.lt_succ_self N)⟩
+      · rintro ⟨⟨hi, h⟩, hN⟩
+        refine ⟨hi, fun n hn => ?_⟩
+        rcases Nat.lt_succ_iff_lt_or_eq.mp hn with hn | rfl
+        · exact h n hn
+        · exact hN
+    rw [he, pow_succ]
+    calc
+      q ^ N * q * P init = q * (q ^ N * P init) := by ac_rfl
+      _ ≤ q * P A := mul_le_mul' le_rfl ih
+      _ ≤ P (A ∩ success N) := hstep N A hA Subset.rfl
+
+lemma ribbon_probability_of_quadratic_completion
+    {q D : ℝ} (hq : 0 < q) (hq1 : q ≤ 1) (hD : 0 ≤ D) :
+    ∃ C : ℝ, 0 < C ∧ ∀ (m N : ℕ), (N : ℝ) ≤ D * (m : ℝ) ^ 2 →
+      Real.exp (-C * (m : ℝ) ^ 2) ≤ q ^ N := by
+  have hlog : Real.log q ≤ 0 := Real.log_nonpos hq.le hq1
+  refine ⟨1 - D * Real.log q, by nlinarith, ?_⟩
+  intro m N hN
+  calc
+    _ ≤ Real.exp ((N : ℝ) * Real.log q) := by
+      apply Real.exp_le_exp.mpr
+      have hh := mul_le_mul_of_nonpos_right hN hlog
+      nlinarith [sq_nonneg (m : ℝ)]
+    _ = q ^ N := by rw [Real.exp_nat_mul, Real.exp_log hq]
+
+/-- The genuine adapted successes force the desired whole-trace mass at
+one prescribed mesh, using only retained disjoint middle strips. -/
+theorem ribbon_experiment_mass_event_probability
+    {Ω : Type*} [mΩ : MeasurableSpace Ω] (μ : Measure Ω)
+    (ℱ : Filtration ℕ mΩ) (init : Set Ω) (hinit : MeasurableSet[ℱ 0] init)
+    (success : ℕ → Set Ω) (hmeas : ∀ n, MeasurableSet[ℱ (n + 1)] (success n))
+    (q : ℝ≥0∞)
+    (hstep : ∀ n (A : Set Ω), MeasurableSet[ℱ n] A →
+      A ⊆ init ∩ ⋂ j ∈ Finset.range n, success j → q * μ A ≤ μ (A ∩ success n))
+    (hpublished : PublishedPlanarDiskOpenness)
+    (P : ℂ → ℂ) (hP : ContinuousOn P closedRibbon) (hiP : InjOn P closedRibbon)
+    {ε : ℝ} (hε : ε ≤ 1) (I : Finset ℕ) (N : ℕ)
+    (κ : ℝ) (γ : Ω → ℝ≥0 → ℂ) (s t : ℕ → Ω → ℝ≥0) (v c ell : ℝ)
+    (hell : 0 < ell) (m : ℕ) (hm : 0 < m) (hcard : I.card = m ^ 2) (D : Set ℂ)
+    (hregions : ∀ i ∈ I, physicalMiddleRegion P closedRibbon i ε ⊆ D)
+    (hmass : ∀ ω ∈ init ∩ ⋂ n ∈ Finset.range N, success n, ∀ i ∈ I,
+      ENNReal.ofReal (c * (ell / (m : ℝ)) ^ dimension κ) ≤
+        segmentSausageCharge κ (γ ω) (s i ω) (t i ω) v
+          (physicalMiddleRegion P closedRibbon i ε)) :
+    q ^ N * μ init ≤ μ {ω |
+      ENNReal.ofReal (c * ell ^ dimension κ * (m : ℝ) ^ codimension κ) ≤
+        wholeSausageCharge κ (γ ω) v D} := by
+  refine (adapted_successes_lower_bound_on_previous μ ℱ init hinit success hmeas q hstep N).trans
+    (measure_mono ?_)
+  intro ω hω
+  exact dense_ribbon_mass_from_steps hpublished P hP hiP hε I κ (γ ω)
+    (fun i => s i ω) (fun i => t i ω) v c ell hell m hm hcard D hregions (hmass ω hω)
+
+end SLEExactGauge
+
+end
+
+end OAI

lean/OAI/Probability/SLE/Gauge/RibbonFrontFreshness.lean

@@ -1,71 +1,71 @@
-import OAI.Probability.SLE.Gauge.RibbonCoordinateGeometry
-import OAI.Probability.SLE.Loewner.FreshTipMapOut
-
-namespace OAI
-
-/-! First arrival at a ribbon front is fresh in the actual Loewner sense:
-the current tip survives every strictly earlier hull. This identifies the
-access prime end with the current driving point through the proved fresh-tip
-chart limit. -/
-
-noncomputable section
-open Set Filter Metric
-open scoped Topology NNReal
-
-namespace SLEExactGauge.RibbonCoordinates
-
-theorem ribbon_front_tip_survives_prior
-    (P : ℂ → ℂ) (hP : ContinuousOn P closedRibbon) (hi : InjOn P closedRibbon)
-    (hH : ∀ z ∈ closedRibbon, 0 < z.re → P z ∈ upperHalfPlane)
-    (hescape : Tendsto (fun s : ℝ => ‖P (s : ℂ)‖) atTop atTop)
-    (γ x : ℝ≥0 → ℂ) (T : ℝ≥0) (hx : ContinuousOn x (Icc 0 T))
-    (hx0 : (x 0).re = 0) (hcoords : MapsTo x (Icc 0 T) closedRibbon)
-    (hγ : EqOn γ (P ∘ x) (Icc 0 T))
-    (hfront : ∀ t : ℝ≥0, t < T → (x t).re < (x T).re)
-    (hinterior : |(x T).im| < 1) :
-    ∀ s : ℝ≥0, s < T → γ T ∈ survivingDomain γ s := by
-  intro s hs
-  have hxs := hx.mono (Icc_subset_Icc_right hs.le)
-  have hrex : ContinuousOn (fun t => (x t).re) (Icc 0 s) :=
-    Complex.continuous_re.comp_continuousOn hxs
-  obtain ⟨t, ht, hmax⟩ := isCompact_Icc.exists_isMaxOn
-    (nonempty_Icc.mpr (show (0 : ℝ≥0) ≤ s from bot_le)) hrex
-  let k := (x t).re
-  have hk : 0 ≤ k := by
-    have hh := hmax (show (0 : ℝ≥0) ∈ Icc 0 s from ⟨le_rfl, bot_le⟩)
-    change (x 0).re ≤ (x t).re at hh
-    simpa only [hx0] using hh
-  have hpast : γ '' Icc 0 s ⊆ P '' {z ∈ closedRibbon | z.re ≤ k} := by
-    rintro z ⟨u, hu, rfl⟩
-    refine ⟨x u, ⟨hcoords ⟨hu.1, hu.2.trans hs.le⟩, hmax hu⟩, ?_⟩
-    exact (hγ ⟨hu.1, hu.2.trans hs.le⟩).symm
-  have htip : x T ∈ futureRibbon k :=
-    ⟨hfront t (ht.2.trans_lt hs), hinterior⟩
-  have hsurv := futureRibbon_survives P hP hi hk hH γ s hpast
-    (futureRibbon_unbounded_of_centerline_escape P k hescape)
-    (mem_image_of_mem P htip)
-  rw [hγ ⟨bot_le, le_rfl⟩]
-  exact hsurv
-
-/-- The actual capacity chart tends to the current driver along the
-surviving domain at a first ribbon front. -/
-theorem IsCapacityTwoWitness.ribbon_front_chart_tendsto
-    {U : ℝ≥0 → ℝ} {γ : ℝ≥0 → ℂ} {G F : ℝ≥0 → ℂ → ℂ}
-    (hw : IsCapacityTwoWitness U γ G F) (hU : Continuous U)
-    (P : ℂ → ℂ) (hP : ContinuousOn P closedRibbon) (hi : InjOn P closedRibbon)
-    (hH : ∀ z ∈ closedRibbon, 0 < z.re → P z ∈ upperHalfPlane)
-    (hescape : Tendsto (fun s : ℝ => ‖P (s : ℂ)‖) atTop atTop)
-    (x : ℝ≥0 → ℂ) (T : ℝ≥0) (hT : 0 < T) (hx : ContinuousOn x (Icc 0 T))
-    (hx0 : (x 0).re = 0) (hcoords : MapsTo x (Icc 0 T) closedRibbon)
-    (hγ : EqOn γ (P ∘ x) (Icc 0 T))
-    (hfront : ∀ t : ℝ≥0, t < T → (x t).re < (x T).re)
-    (hinterior : |(x T).im| < 1) :
-    Tendsto (G T) (𝓝[survivingDomain γ T] (γ T)) (𝓝 (U T : ℂ)) := by
-  exact hw.fresh_tip_chart_tendsto hU hT
-    (ribbon_front_tip_survives_prior P hP hi hH hescape γ x T hx hx0 hcoords hγ hfront hinterior)
-
-end SLEExactGauge.RibbonCoordinates
-
-end
-
-end OAI
+import OAI.Probability.SLE.Gauge.RibbonCoordinateGeometry
+import OAI.Probability.SLE.Loewner.FreshTipMapOut
+
+namespace OAI
+
+/-! First arrival at a ribbon front is fresh in the actual Loewner sense:
+the current tip survives every strictly earlier hull. This identifies the
+access prime end with the current driving point through the proved fresh-tip
+chart limit. -/
+
+noncomputable section
+open Set Filter Metric
+open scoped Topology NNReal
+
+namespace SLEExactGauge.RibbonCoordinates
+
+theorem ribbon_front_tip_survives_prior
+    (P : ℂ → ℂ) (hP : ContinuousOn P closedRibbon) (hi : InjOn P closedRibbon)
+    (hH : ∀ z ∈ closedRibbon, 0 < z.re → P z ∈ upperHalfPlane)
+    (hescape : Tendsto (fun s : ℝ => ‖P (s : ℂ)‖) atTop atTop)
+    (γ x : ℝ≥0 → ℂ) (T : ℝ≥0) (hx : ContinuousOn x (Icc 0 T))
+    (hx0 : (x 0).re = 0) (hcoords : MapsTo x (Icc 0 T) closedRibbon)
+    (hγ : EqOn γ (P ∘ x) (Icc 0 T))
+    (hfront : ∀ t : ℝ≥0, t < T → (x t).re < (x T).re)
+    (hinterior : |(x T).im| < 1) :
+    ∀ s : ℝ≥0, s < T → γ T ∈ survivingDomain γ s := by
+  intro s hs
+  have hxs := hx.mono (Icc_subset_Icc_right hs.le)
+  have hrex : ContinuousOn (fun t => (x t).re) (Icc 0 s) :=
+    Complex.continuous_re.comp_continuousOn hxs
+  obtain ⟨t, ht, hmax⟩ := isCompact_Icc.exists_isMaxOn
+    (nonempty_Icc.mpr (show (0 : ℝ≥0) ≤ s from bot_le)) hrex
+  let k := (x t).re
+  have hk : 0 ≤ k := by
+    have hh := hmax (show (0 : ℝ≥0) ∈ Icc 0 s from ⟨le_rfl, bot_le⟩)
+    change (x 0).re ≤ (x t).re at hh
+    simpa only [hx0] using hh
+  have hpast : γ '' Icc 0 s ⊆ P '' {z ∈ closedRibbon | z.re ≤ k} := by
+    rintro z ⟨u, hu, rfl⟩
+    refine ⟨x u, ⟨hcoords ⟨hu.1, hu.2.trans hs.le⟩, hmax hu⟩, ?_⟩
+    exact (hγ ⟨hu.1, hu.2.trans hs.le⟩).symm
+  have htip : x T ∈ futureRibbon k :=
+    ⟨hfront t (ht.2.trans_lt hs), hinterior⟩
+  have hsurv := futureRibbon_survives P hP hi hk hH γ s hpast
+    (futureRibbon_unbounded_of_centerline_escape P k hescape)
+    (mem_image_of_mem P htip)
+  rw [hγ ⟨bot_le, le_rfl⟩]
+  exact hsurv
+
+/-- The actual capacity chart tends to the current driver along the
+surviving domain at a first ribbon front. -/
+theorem IsCapacityTwoWitness.ribbon_front_chart_tendsto
+    {U : ℝ≥0 → ℝ} {γ : ℝ≥0 → ℂ} {G F : ℝ≥0 → ℂ → ℂ}
+    (hw : IsCapacityTwoWitness U γ G F) (hU : Continuous U)
+    (P : ℂ → ℂ) (hP : ContinuousOn P closedRibbon) (hi : InjOn P closedRibbon)
+    (hH : ∀ z ∈ closedRibbon, 0 < z.re → P z ∈ upperHalfPlane)
+    (hescape : Tendsto (fun s : ℝ => ‖P (s : ℂ)‖) atTop atTop)
+    (x : ℝ≥0 → ℂ) (T : ℝ≥0) (hT : 0 < T) (hx : ContinuousOn x (Icc 0 T))
+    (hx0 : (x 0).re = 0) (hcoords : MapsTo x (Icc 0 T) closedRibbon)
+    (hγ : EqOn γ (P ∘ x) (Icc 0 T))
+    (hfront : ∀ t : ℝ≥0, t < T → (x t).re < (x T).re)
+    (hinterior : |(x T).im| < 1) :
+    Tendsto (G T) (𝓝[survivingDomain γ T] (γ T)) (𝓝 (U T : ℂ)) := by
+  exact hw.fresh_tip_chart_tendsto hU hT
+    (ribbon_front_tip_survives_prior P hP hi hH hescape γ x T hx hx0 hcoords hγ hfront hinterior)
+
+end SLEExactGauge.RibbonCoordinates
+
+end
+
+end OAI

lean/OAI/Probability/SLE/Gauge/RibbonFrontStops.lean

@@ -1,90 +1,90 @@
-import OAI.Probability.SLE.Gauge.ProperRibbonCoordinates
-
-namespace OAI
-
-/-! One globally continuous ribbon progress coordinate supplies all
-integer first-front stopping times. Their order is pathwise, including
-infinite failure times, and successful histories identify them exactly. -/
-
-noncomputable section
-open Set Filter MeasureTheory ProbabilityTheory
-open scoped Topology NNReal ENNReal
-
-namespace SLEExactGauge
-open RibbonCoordinates FirstFrontPassage
-
-lemma firstFrontTime_mono_of_initial
-    (x : ℝ≥0 → ℝ) (hx : Continuous x) {a b : ℝ} (h0 : x 0 ≤ a) (hab : a ≤ b) :
-    firstFrontTime x a ≤ firstFrontTime x b := by
-  by_cases hb : ∃ t : ℝ≥0, 0 ≤ t ∧ x t - b ∈ ({0} : Set ℝ)
-  · have ha : ∃ t : ℝ≥0, 0 ≤ t ∧ x t - a ∈ ({0} : Set ℝ) := by
-      obtain ⟨t, ht, htb⟩ := hb
-      have he : x t = b := sub_eq_zero.mp htb
-      obtain ⟨u, _, hue⟩ := intermediate_value_Icc ht hx.continuousOn
-        ⟨h0, by rw [he]; exact hab⟩
-      exact ⟨u, bot_le, by simp only [hue, sub_self, mem_singleton_iff]⟩
-    unfold firstFrontTime hittingAfter
-    rw [ite_eq_left ha, ite_eq_left hb, WithTop.coe_le_coe]
-    apply le_csInf hb
-    intro t ht
-    have he : x t = b := sub_eq_zero.mp ht.2
-    obtain ⟨u, hu, hue⟩ := intermediate_value_Icc ht.1 hx.continuousOn
-      ⟨h0, by rw [he]; exact hab⟩
-    have hle : sInf {t : ℝ≥0 | 0 ≤ t ∧ x t - a ∈ ({0} : Set ℝ)} ≤ u :=
-      csInf_le (OrderBot.bddBelow _) ⟨bot_le, by simp only [hue, sub_self, mem_singleton_iff]⟩
-    exact hle.trans hu.2
-  · have he : firstFrontTime x b = ⊤ := by
-      unfold firstFrontTime hittingAfter
-      rw [ite_eq_right hb]
-    rw [he]
-    exact le_top
-
-def ribbonFrontStop {Ω : Type*} (g : C(ℂ, ℝ)) (γ : Ω → ℝ≥0 → ℂ)
-    (k : ℝ) (ω : Ω) : WithTop ℝ≥0 := firstFrontTime (fun t => g (γ ω t)) k
-
-lemma ribbonFrontStop_stopping
-    {Ω : Type*} [mΩ : MeasurableSpace Ω] (ℱ : Filtration ℝ≥0 mΩ)
-    (g : C(ℂ, ℝ)) (γ : Ω → ℝ≥0 → ℂ)
-    (ha : Adapted ℱ (fun t ω => γ ω t)) (hc : ∀ ω, Continuous (γ ω)) (k : ℝ) :
-    IsStoppingTime ℱ (ribbonFrontStop g γ k) :=
-  firstFrontTime_isStoppingTime ℱ (fun t ω => g (γ ω t))
-    (fun t => g.continuous.measurable.comp (ha t)) (fun ω => g.continuous.comp (hc ω)) k
-
-lemma ribbonFrontStop_monotone
-    {Ω : Type*} (g : C(ℂ, ℝ)) (γ : Ω → ℝ≥0 → ℂ)
-    (hc : ∀ ω, Continuous (γ ω)) (h0 : ∀ ω, g (γ ω 0) = 0) :
-    ∀ ω, Monotone (fun n : ℕ => ribbonFrontStop g γ (n : ℝ) ω) := by
-  intro ω n k hnk
-  exact firstFrontTime_mono_of_initial _ (g.continuous.comp (hc ω))
-    (by change g (γ ω 0) ≤ (n : ℝ); rw [h0 ω]; positivity) (by exact_mod_cast hnk)
-
-/-- The global first front agrees with the actual time in a successful
-history, irrespective of the extension away from the physical ribbon. -/
-lemma RibbonHistory.global_frontStop_eq
-    {C L : ℝ≥0} {ε : ℝ} (d : RibbonHistory C L ε) (g : C(ℂ, ℝ))
-    (hg : ∀ z ∈ closedRibbon, g (d.chart z) = z.re) :
-    firstFrontTime (fun t => g (d.trace t)) d.front = (d.time : WithTop ℝ≥0) := by
-  have heq (t : ℝ≥0) (ht : t ∈ Icc 0 d.time) :
-      g (d.trace t) = (d.coordinates t).re := by
-    rw [d.trace_coordinates ht]
-    exact hg _ (d.coordinates_ribbon ht)
-  have hattain : g (d.trace d.time) = d.front := by
-    rw [heq _ ⟨bot_le, le_rfl⟩, d.attained]
-    simp
-  have hleast : IsLeast {t : ℝ≥0 | 0 ≤ t ∧ g (d.trace t) - d.front ∈ ({0} : Set ℝ)}
-      d.time := by
-    refine ⟨⟨bot_le, by simp only [hattain, sub_self, mem_singleton_iff]⟩, ?_⟩
-    intro t ht
-    by_contra hn
-    have hlt : t < d.time := lt_of_not_ge hn
-    have hh := d.strict_past t hlt
-    rw [← heq t ⟨bot_le, hlt.le⟩, sub_eq_zero.mp ht.2] at hh
-    exact (lt_irrefl _ hh)
-  unfold firstFrontTime hittingAfter
-  rw [ite_eq_left ⟨d.time, hleast.1⟩, hleast.csInf_eq]
-
-end SLEExactGauge
-
-end
-
-end OAI
+import OAI.Probability.SLE.Gauge.ProperRibbonCoordinates
+
+namespace OAI
+
+/-! One globally continuous ribbon progress coordinate supplies all
+integer first-front stopping times. Their order is pathwise, including
+infinite failure times, and successful histories identify them exactly. -/
+
+noncomputable section
+open Set Filter MeasureTheory ProbabilityTheory
+open scoped Topology NNReal ENNReal
+
+namespace SLEExactGauge
+open RibbonCoordinates FirstFrontPassage
+
+lemma firstFrontTime_mono_of_initial
+    (x : ℝ≥0 → ℝ) (hx : Continuous x) {a b : ℝ} (h0 : x 0 ≤ a) (hab : a ≤ b) :
+    firstFrontTime x a ≤ firstFrontTime x b := by
+  by_cases hb : ∃ t : ℝ≥0, 0 ≤ t ∧ x t - b ∈ ({0} : Set ℝ)
+  · have ha : ∃ t : ℝ≥0, 0 ≤ t ∧ x t - a ∈ ({0} : Set ℝ) := by
+      obtain ⟨t, ht, htb⟩ := hb
+      have he : x t = b := sub_eq_zero.mp htb
+      obtain ⟨u, _, hue⟩ := intermediate_value_Icc ht hx.continuousOn
+        ⟨h0, by rw [he]; exact hab⟩
+      exact ⟨u, bot_le, by simp only [hue, sub_self, mem_singleton_iff]⟩
+    unfold firstFrontTime hittingAfter
+    rw [ite_eq_left ha, ite_eq_left hb, WithTop.coe_le_coe]
+    apply le_csInf hb
+    intro t ht
+    have he : x t = b := sub_eq_zero.mp ht.2
+    obtain ⟨u, hu, hue⟩ := intermediate_value_Icc ht.1 hx.continuousOn
+      ⟨h0, by rw [he]; exact hab⟩
+    have hle : sInf {t : ℝ≥0 | 0 ≤ t ∧ x t - a ∈ ({0} : Set ℝ)} ≤ u :=
+      csInf_le (OrderBot.bddBelow _) ⟨bot_le, by simp only [hue, sub_self, mem_singleton_iff]⟩
+    exact hle.trans hu.2
+  · have he : firstFrontTime x b = ⊤ := by
+      unfold firstFrontTime hittingAfter
+      rw [ite_eq_right hb]
+    rw [he]
+    exact le_top
+
+def ribbonFrontStop {Ω : Type*} (g : C(ℂ, ℝ)) (γ : Ω → ℝ≥0 → ℂ)
+    (k : ℝ) (ω : Ω) : WithTop ℝ≥0 := firstFrontTime (fun t => g (γ ω t)) k
+
+lemma ribbonFrontStop_stopping
+    {Ω : Type*} [mΩ : MeasurableSpace Ω] (ℱ : Filtration ℝ≥0 mΩ)
+    (g : C(ℂ, ℝ)) (γ : Ω → ℝ≥0 → ℂ)
+    (ha : Adapted ℱ (fun t ω => γ ω t)) (hc : ∀ ω, Continuous (γ ω)) (k : ℝ) :
+    IsStoppingTime ℱ (ribbonFrontStop g γ k) :=
+  firstFrontTime_isStoppingTime ℱ (fun t ω => g (γ ω t))
+    (fun t => g.continuous.measurable.comp (ha t)) (fun ω => g.continuous.comp (hc ω)) k
+
+lemma ribbonFrontStop_monotone
+    {Ω : Type*} (g : C(ℂ, ℝ)) (γ : Ω → ℝ≥0 → ℂ)
+    (hc : ∀ ω, Continuous (γ ω)) (h0 : ∀ ω, g (γ ω 0) = 0) :
+    ∀ ω, Monotone (fun n : ℕ => ribbonFrontStop g γ (n : ℝ) ω) := by
+  intro ω n k hnk
+  exact firstFrontTime_mono_of_initial _ (g.continuous.comp (hc ω))
+    (by change g (γ ω 0) ≤ (n : ℝ); rw [h0 ω]; positivity) (by exact_mod_cast hnk)
+
+/-- The global first front agrees with the actual time in a successful
+history, irrespective of the extension away from the physical ribbon. -/
+lemma RibbonHistory.global_frontStop_eq
+    {C L : ℝ≥0} {ε : ℝ} (d : RibbonHistory C L ε) (g : C(ℂ, ℝ))
+    (hg : ∀ z ∈ closedRibbon, g (d.chart z) = z.re) :
+    firstFrontTime (fun t => g (d.trace t)) d.front = (d.time : WithTop ℝ≥0) := by
+  have heq (t : ℝ≥0) (ht : t ∈ Icc 0 d.time) :
+      g (d.trace t) = (d.coordinates t).re := by
+    rw [d.trace_coordinates ht]
+    exact hg _ (d.coordinates_ribbon ht)
+  have hattain : g (d.trace d.time) = d.front := by
+    rw [heq _ ⟨bot_le, le_rfl⟩, d.attained]
+    simp
+  have hleast : IsLeast {t : ℝ≥0 | 0 ≤ t ∧ g (d.trace t) - d.front ∈ ({0} : Set ℝ)}
+      d.time := by
+    refine ⟨⟨bot_le, by simp only [hattain, sub_self, mem_singleton_iff]⟩, ?_⟩
+    intro t ht
+    by_contra hn
+    have hlt : t < d.time := lt_of_not_ge hn
+    have hh := d.strict_past t hlt
+    rw [← heq t ⟨bot_le, hlt.le⟩, sub_eq_zero.mp ht.2] at hh
+    exact (lt_irrefl _ hh)
+  unfold firstFrontTime hittingAfter
+  rw [ite_eq_left ⟨d.time, hleast.1⟩, hleast.csInf_eq]
+
+end SLEExactGauge
+
+end
+
+end OAI

lean/OAI/Probability/SLE/Gauge/RibbonGoodPrefix.lean

@@ -1,129 +1,129 @@
-import OAI.Probability.SLE.Gauge.ActualRibbonHistory
-
-namespace OAI
-
-/-! Narrow actual prefixes are measurable in the possibly infinite front
-past. They are exactly the physical information used to reconstruct the
-history at the next integer front. -/
-
-noncomputable section
-open Set Filter MeasureTheory ProbabilityTheory Metric
-open scoped Topology NNReal ENNReal
-
-namespace SLEExactGauge
-open RibbonCoordinates FirstFrontPassage FrontSuccessMeasurability
-
-local instance goodPrefixPathMeasurable : MeasurableSpace C(ℝ≥0, ℂ) := borel _
-local instance goodPrefixPathBorel : BorelSpace C(ℝ≥0, ℂ) := ⟨rfl⟩
-
-def ribbonCore (P : ℂ → ℂ) (ε : ℝ) : Set ℂ :=
-  P '' {z ∈ closedRibbon | |z.im| ≤ ε}
-
-lemma ribbonCore_isClosed (P : ℂ → ℂ)
-    (he : Topology.IsClosedEmbedding (fun z : closedRibbon => P z)) (ε : ℝ) :
-    IsClosed (ribbonCore P ε) := by
-  have hs : IsClosed {z : closedRibbon | |(z : ℂ).im| ≤ ε} :=
-    isClosed_le (Complex.continuous_im.comp continuous_subtype_val).abs continuous_const
-  have hh := he.isClosedMap _ hs
-  have hset : (fun z : closedRibbon => P z) '' {z : closedRibbon | |(z : ℂ).im| ≤ ε} =
-      ribbonCore P ε := by
-    ext w
-    constructor
-    · rintro ⟨z, hz, rfl⟩
-      exact ⟨z, ⟨z.2, hz⟩, rfl⟩
-    · rintro ⟨z, ⟨hz, hi⟩, rfl⟩
-      exact ⟨⟨z, hz⟩, hi, rfl⟩
-  exact hset ▸ hh
-
-def GoodRibbonPrefix {Ω : Type*} (γ : Ω → ℝ≥0 → ℂ)
-    (τ : Ω → WithTop ℝ≥0) (P : ℂ → ℂ) (ε : ℝ) : Set Ω :=
-  {ω | τ ω ≠ ⊤ ∧ MapsTo (γ ω) (Icc 0 ((τ ω).untopD 0)) (ribbonCore P ε) ∧
-    γ ω ((τ ω).untopD 0) ∈ ribbonCore P (ε / 4)}
-
-lemma stoppedAtPath_eval_time (f : C(ℝ≥0, ℂ)) (τ : WithTop ℝ≥0) :
-    stoppedAtPath f τ (τ.untopD 0) = f (τ.untopD 0) := by
-  cases τ with
-  | top => simp only [stoppedAtPath, ite_true]
-  | coe t => simp only [stoppedAtPath, WithTop.coe_ne_top, ite_false, WithTop.untopD_coe,
-      clampedPath, ContinuousMap.comp_apply, ContinuousMap.coe_mk, min_self, zero_le,
-      max_eq_right]
-
-lemma stoppedAtPath_range_iff (f : C(ℝ≥0, ℂ)) (t : ℝ≥0) (K : Set ℂ) :
-    MapsTo (stoppedAtPath f (t : WithTop ℝ≥0)) univ K ↔ MapsTo f (Icc 0 t) K := by
-  simp only [stoppedAtPath, WithTop.coe_ne_top, ite_false, WithTop.untopD_coe]
-  constructor
-  · intro h u hu
-    have hh := h (mem_univ u)
-    simpa only [clampedPath, ContinuousMap.comp_apply, ContinuousMap.coe_mk,
-      min_eq_left hu.2, max_eq_right hu.1] using hh
-  · intro h u _
-    exact h ⟨le_max_left _ _, max_le bot_le (min_le_right _ _)⟩
-
-lemma measurableSet_path_range_closed
-    {Ω : Type*} [MeasurableSpace Ω] (f : Ω → C(ℝ≥0, ℂ)) (hf : Measurable f)
-    (K : Set ℂ) (hK : IsClosed K) :
-    MeasurableSet {ω | MapsTo (f ω) univ K} := by
-  have hclosed : IsClosed {p : C(ℝ≥0, ℂ) | MapsTo p univ K} := by
-    have he : {p : C(ℝ≥0, ℂ) | MapsTo p univ K} =
-        ⋂ t : ℝ≥0, (fun p : C(ℝ≥0, ℂ) => p t) ⁻¹' K := by
-      ext p
-      simp only [mem_ofPred_eq, MapsTo, mem_univ, forall_const, mem_iInter, mem_preimage]
-    rw [he]
-    exact isClosed_iInter fun t => hK.preimage (continuous_eval_const t)
-  exact hclosed.measurableSet.preimage hf
-
-/-- The successful physical prefix belongs to the actual front past;
-failed samples need not have a finite front time. -/
-theorem goodRibbonPrefix_measurable
-    {Ω : Type*} [mΩ : MeasurableSpace Ω] (ℱ : Filtration ℝ≥0 mΩ)
-    (γ : Ω → ℝ≥0 → ℂ) (ha : Adapted ℱ (fun t ω => γ ω t))
-    (hc : ∀ ω, Continuous (γ ω))
-    (τ : Ω → WithTop ℝ≥0) (hτ : IsStoppingTime ℱ τ)
-    (P : ℂ → ℂ) (he : Topology.IsClosedEmbedding (fun z : closedRibbon => P z)) (ε : ℝ) :
-    MeasurableSet[hτ.measurableSpace] (GoodRibbonPrefix γ τ P ε) := by
-  let f := fun ω => stoppedAtPath (sourceTracePath γ hc ω) (τ ω)
-  have hfm : Measurable[hτ.measurableSpace] f := stoppedAtPath_measurable ℱ γ ha hc τ hτ
-  have htm : Measurable[hτ.measurableSpace] (fun ω => (τ ω).untopD 0) := hτ.measurable.untopD 0
-  have hem : Measurable[hτ.measurableSpace] (fun ω => f ω ((τ ω).untopD 0)) :=
-    continuous_eval.measurable.comp (hfm.prodMk htm)
-  let : MeasurableSpace Ω := hτ.measurableSpace
-  have hm := (measurableSet_eq_fun hτ.measurable
-    (measurable_const : Measurable (fun _ : Ω => (⊤ : WithTop ℝ≥0)))).compl.inter
-    ((measurableSet_path_range_closed f hfm _ (ribbonCore_isClosed P he ε)).inter
-      ((ribbonCore_isClosed P he (ε / 4)).measurableSet.preimage hem))
-  convert hm using 1
-  ext ω
-  change (τ ω ≠ ⊤ ∧ MapsTo (γ ω) (Icc 0 ((τ ω).untopD 0)) (ribbonCore P ε) ∧
-      γ ω ((τ ω).untopD 0) ∈ ribbonCore P (ε / 4)) ↔
-    (τ ω ≠ ⊤ ∧ MapsTo (stoppedAtPath (sourceTracePath γ hc ω) (τ ω)) univ (ribbonCore P ε) ∧
-      stoppedAtPath (sourceTracePath γ hc ω) (τ ω) ((τ ω).untopD 0) ∈ ribbonCore P (ε / 4))
-  cases ht : τ ω with
-  | top => simp only [ne_eq, not_true_eq_false, false_and]
-  | coe t =>
-    simp only [ne_eq, WithTop.coe_ne_top, not_false_eq_true, WithTop.untopD_coe, true_and]
-    rw [stoppedAtPath_range_iff]
-    have hv := stoppedAtPath_eval_time (sourceTracePath γ hc ω) (t : WithTop ℝ≥0)
-    have hv' : stoppedAtPath (sourceTracePath γ hc ω) (t : WithTop ℝ≥0) t = γ ω t := by
-      simpa only [WithTop.untopD_coe, sourceTracePath, ContinuousMap.coe_mk] using hv
-    rw [hv']
-    rfl
-
-lemma RibbonHistory.goodRibbonPrefix
-    {C L : ℝ≥0} {ε : ℝ} (d : RibbonHistory C L ε) :
-    () ∈ GoodRibbonPrefix (fun _ : Unit => d.trace) (fun _ => (d.time : WithTop ℝ≥0))
-      d.chart ε := by
-  refine ⟨WithTop.coe_ne_top, ?_, ?_⟩
-  · intro t ht
-    refine ⟨d.coordinates t, ⟨d.coordinates_ribbon ht, (d.past_core t ht).2⟩, ?_⟩
-    exact (d.trace_coordinates ht).symm
-  · refine ⟨d.coordinates d.time, ⟨d.coordinates_ribbon ⟨bot_le, le_rfl⟩, ?_⟩, ?_⟩
-    · rw [d.attained]
-      simpa only [Complex.add_im, Complex.ofReal_im, Complex.mul_im, Complex.ofReal_re,
-        Complex.I_im, mul_one, Complex.I_re, mul_zero, add_zero, zero_add] using d.offset_bound
-    · exact (d.trace_coordinates ⟨bot_le, le_rfl⟩).symm
-
-end SLEExactGauge
-
-end
-
-end OAI
+import OAI.Probability.SLE.Gauge.ActualRibbonHistory
+
+namespace OAI
+
+/-! Narrow actual prefixes are measurable in the possibly infinite front
+past. They are exactly the physical information used to reconstruct the
+history at the next integer front. -/
+
+noncomputable section
+open Set Filter MeasureTheory ProbabilityTheory Metric
+open scoped Topology NNReal ENNReal
+
+namespace SLEExactGauge
+open RibbonCoordinates FirstFrontPassage FrontSuccessMeasurability
+
+local instance goodPrefixPathMeasurable : MeasurableSpace C(ℝ≥0, ℂ) := borel _
+local instance goodPrefixPathBorel : BorelSpace C(ℝ≥0, ℂ) := ⟨rfl⟩
+
+def ribbonCore (P : ℂ → ℂ) (ε : ℝ) : Set ℂ :=
+  P '' {z ∈ closedRibbon | |z.im| ≤ ε}
+
+lemma ribbonCore_isClosed (P : ℂ → ℂ)
+    (he : Topology.IsClosedEmbedding (fun z : closedRibbon => P z)) (ε : ℝ) :
+    IsClosed (ribbonCore P ε) := by
+  have hs : IsClosed {z : closedRibbon | |(z : ℂ).im| ≤ ε} :=
+    isClosed_le (Complex.continuous_im.comp continuous_subtype_val).abs continuous_const
+  have hh := he.isClosedMap _ hs
+  have hset : (fun z : closedRibbon => P z) '' {z : closedRibbon | |(z : ℂ).im| ≤ ε} =
+      ribbonCore P ε := by
+    ext w
+    constructor
+    · rintro ⟨z, hz, rfl⟩
+      exact ⟨z, ⟨z.2, hz⟩, rfl⟩
+    · rintro ⟨z, ⟨hz, hi⟩, rfl⟩
+      exact ⟨⟨z, hz⟩, hi, rfl⟩
+  exact hset ▸ hh
+
+def GoodRibbonPrefix {Ω : Type*} (γ : Ω → ℝ≥0 → ℂ)
+    (τ : Ω → WithTop ℝ≥0) (P : ℂ → ℂ) (ε : ℝ) : Set Ω :=
+  {ω | τ ω ≠ ⊤ ∧ MapsTo (γ ω) (Icc 0 ((τ ω).untopD 0)) (ribbonCore P ε) ∧
+    γ ω ((τ ω).untopD 0) ∈ ribbonCore P (ε / 4)}
+
+lemma stoppedAtPath_eval_time (f : C(ℝ≥0, ℂ)) (τ : WithTop ℝ≥0) :
+    stoppedAtPath f τ (τ.untopD 0) = f (τ.untopD 0) := by
+  cases τ with
+  | top => simp only [stoppedAtPath, ite_true]
+  | coe t => simp only [stoppedAtPath, WithTop.coe_ne_top, ite_false, WithTop.untopD_coe,
+      clampedPath, ContinuousMap.comp_apply, ContinuousMap.coe_mk, min_self, zero_le,
+      max_eq_right]
+
+lemma stoppedAtPath_range_iff (f : C(ℝ≥0, ℂ)) (t : ℝ≥0) (K : Set ℂ) :
+    MapsTo (stoppedAtPath f (t : WithTop ℝ≥0)) univ K ↔ MapsTo f (Icc 0 t) K := by
+  simp only [stoppedAtPath, WithTop.coe_ne_top, ite_false, WithTop.untopD_coe]
+  constructor
+  · intro h u hu
+    have hh := h (mem_univ u)
+    simpa only [clampedPath, ContinuousMap.comp_apply, ContinuousMap.coe_mk,
+      min_eq_left hu.2, max_eq_right hu.1] using hh
+  · intro h u _
+    exact h ⟨le_max_left _ _, max_le bot_le (min_le_right _ _)⟩
+
+lemma measurableSet_path_range_closed
+    {Ω : Type*} [MeasurableSpace Ω] (f : Ω → C(ℝ≥0, ℂ)) (hf : Measurable f)
+    (K : Set ℂ) (hK : IsClosed K) :
+    MeasurableSet {ω | MapsTo (f ω) univ K} := by
+  have hclosed : IsClosed {p : C(ℝ≥0, ℂ) | MapsTo p univ K} := by
+    have he : {p : C(ℝ≥0, ℂ) | MapsTo p univ K} =
+        ⋂ t : ℝ≥0, (fun p : C(ℝ≥0, ℂ) => p t) ⁻¹' K := by
+      ext p
+      simp only [mem_ofPred_eq, MapsTo, mem_univ, forall_const, mem_iInter, mem_preimage]
+    rw [he]
+    exact isClosed_iInter fun t => hK.preimage (continuous_eval_const t)
+  exact hclosed.measurableSet.preimage hf
+
+/-- The successful physical prefix belongs to the actual front past;
+failed samples need not have a finite front time. -/
+theorem goodRibbonPrefix_measurable
+    {Ω : Type*} [mΩ : MeasurableSpace Ω] (ℱ : Filtration ℝ≥0 mΩ)
+    (γ : Ω → ℝ≥0 → ℂ) (ha : Adapted ℱ (fun t ω => γ ω t))
+    (hc : ∀ ω, Continuous (γ ω))
+    (τ : Ω → WithTop ℝ≥0) (hτ : IsStoppingTime ℱ τ)
+    (P : ℂ → ℂ) (he : Topology.IsClosedEmbedding (fun z : closedRibbon => P z)) (ε : ℝ) :
+    MeasurableSet[hτ.measurableSpace] (GoodRibbonPrefix γ τ P ε) := by
+  let f := fun ω => stoppedAtPath (sourceTracePath γ hc ω) (τ ω)
+  have hfm : Measurable[hτ.measurableSpace] f := stoppedAtPath_measurable ℱ γ ha hc τ hτ
+  have htm : Measurable[hτ.measurableSpace] (fun ω => (τ ω).untopD 0) := hτ.measurable.untopD 0
+  have hem : Measurable[hτ.measurableSpace] (fun ω => f ω ((τ ω).untopD 0)) :=
+    continuous_eval.measurable.comp (hfm.prodMk htm)
+  let : MeasurableSpace Ω := hτ.measurableSpace
+  have hm := (measurableSet_eq_fun hτ.measurable
+    (measurable_const : Measurable (fun _ : Ω => (⊤ : WithTop ℝ≥0)))).compl.inter
+    ((measurableSet_path_range_closed f hfm _ (ribbonCore_isClosed P he ε)).inter
+      ((ribbonCore_isClosed P he (ε / 4)).measurableSet.preimage hem))
+  convert hm using 1
+  ext ω
+  change (τ ω ≠ ⊤ ∧ MapsTo (γ ω) (Icc 0 ((τ ω).untopD 0)) (ribbonCore P ε) ∧
+      γ ω ((τ ω).untopD 0) ∈ ribbonCore P (ε / 4)) ↔
+    (τ ω ≠ ⊤ ∧ MapsTo (stoppedAtPath (sourceTracePath γ hc ω) (τ ω)) univ (ribbonCore P ε) ∧
+      stoppedAtPath (sourceTracePath γ hc ω) (τ ω) ((τ ω).untopD 0) ∈ ribbonCore P (ε / 4))
+  cases ht : τ ω with
+  | top => simp only [ne_eq, not_true_eq_false, false_and]
+  | coe t =>
+    simp only [ne_eq, WithTop.coe_ne_top, not_false_eq_true, WithTop.untopD_coe, true_and]
+    rw [stoppedAtPath_range_iff]
+    have hv := stoppedAtPath_eval_time (sourceTracePath γ hc ω) (t : WithTop ℝ≥0)
+    have hv' : stoppedAtPath (sourceTracePath γ hc ω) (t : WithTop ℝ≥0) t = γ ω t := by
+      simpa only [WithTop.untopD_coe, sourceTracePath, ContinuousMap.coe_mk] using hv
+    rw [hv']
+    rfl
+
+lemma RibbonHistory.goodRibbonPrefix
+    {C L : ℝ≥0} {ε : ℝ} (d : RibbonHistory C L ε) :
+    () ∈ GoodRibbonPrefix (fun _ : Unit => d.trace) (fun _ => (d.time : WithTop ℝ≥0))
+      d.chart ε := by
+  refine ⟨WithTop.coe_ne_top, ?_, ?_⟩
+  · intro t ht
+    refine ⟨d.coordinates t, ⟨d.coordinates_ribbon ht, (d.past_core t ht).2⟩, ?_⟩
+    exact (d.trace_coordinates ht).symm
+  · refine ⟨d.coordinates d.time, ⟨d.coordinates_ribbon ⟨bot_le, le_rfl⟩, ?_⟩, ?_⟩
+    · rw [d.attained]
+      simpa only [Complex.add_im, Complex.ofReal_im, Complex.mul_im, Complex.ofReal_re,
+        Complex.I_im, mul_one, Complex.I_re, mul_zero, add_zero, zero_add] using d.offset_bound
+    · exact (d.trace_coordinates ⟨bot_le, le_rfl⟩).symm
+
+end SLEExactGauge
+
+end
+
+end OAI

lean/OAI/Probability/SLE/Gauge/RibbonHistoryAdvance.lean

@@ -1,263 +1,263 @@
-import OAI.Probability.SLE.Gauge.UniformRibbonStep
-
-namespace OAI
-
-/-! An actual successful passage gives another admissible stopped ribbon
-history. Inverse coordinates are used only on the compact physical patch
-where the successful path is contained. -/
-
-noncomputable section
-open Set Filter MeasureTheory Metric
-open scoped Topology NNReal ENNReal
-
-namespace SLEExactGauge
-open RibbonCoordinates BoundaryScaleLaw FirstFrontPassage PassageSuccess
-
-lemma strict_before_attained_front
-    (x : ℝ≥0 → ℝ) (q : ℝ) (S : ℝ≥0)
-    (hc : ContinuousOn x (Icc 0 S)) (h0 : x 0 < q)
-    (hfirst : firstFrontTime x q = (S : WithTop ℝ≥0)) :
-    ∀ t : ℝ≥0, t < S → x t < q := by
-  intro t ht
-  by_contra hn
-  obtain ⟨u, hu, hue⟩ := intermediate_value_Icc (show (0 : ℝ≥0) ≤ t from bot_le)
-    (hc.mono (Icc_subset_Icc_right ht.le)) ⟨h0.le, le_of_not_gt hn⟩
-  have hh := hittingAfter_le_of_mem (u := fun t (_ : Unit) => x t - q)
-    (ω := ()) (show (0 : ℝ≥0) ≤ u from bot_le)
-    (show x u - q ∈ ({0} : Set ℝ) by simp only [hue, sub_self, mem_singleton_iff])
-  change firstFrontTime x q ≤ (u : WithTop ℝ≥0) at hh
-  rw [hfirst, WithTop.coe_le_coe] at hh
-  exact (not_le_of_gt ht) (hh.trans hu.2)
-
-def RibbonHistory.futureCoordinates {C L : ℝ≥0} {ε : ℝ}
-    (d : RibbonHistory C L ε) (t : ℝ≥0) : ℂ :=
-  (d.front : ℂ) + coordinateInverse d.stepChart ribbonStepCompact (d.trace (d.time + t))
-
-def RibbonHistory.advanceCoordinates {C L : ℝ≥0} {ε : ℝ}
-    (d : RibbonHistory C L ε) (t : ℝ≥0) : ℂ :=
-  if t ≤ d.time then d.coordinates (min t d.time) else d.futureCoordinates (t - d.time)
-
-def RibbonHistory.futureTrace {C L : ℝ≥0} {ε : ℝ}
-    (d : RibbonHistory C L ε) : C(ℝ≥0, ℂ) :=
-  ⟨fun t => d.trace (d.time + t),
-    d.witness.1.comp (continuous_const.add continuous_id)⟩
-
-lemma RibbonHistory.tip_in_stepCompact {C L : ℝ≥0} {ε : ℝ}
-    (d : RibbonHistory C L ε) (hε : ε ≤ 1 / 8) :
-    (d.offset : ℂ) * Complex.I ∈ ribbonStepCompact := by
-  change -(1 / 2 : ℝ) ≤ ((d.offset : ℂ) * Complex.I).re ∧
-    ((d.offset : ℂ) * Complex.I).re ≤ 5 / 2 ∧
-    |((d.offset : ℂ) * Complex.I).im| ≤ 1 / 2
-  simp only [Complex.mul_re, Complex.ofReal_re, Complex.I_re, mul_zero,
-    Complex.ofReal_im, Complex.I_im, sub_self, Complex.mul_im, mul_one, add_zero]
-  exact ⟨by norm_num, by norm_num, by linarith [d.offset_bound]⟩
-
-lemma RibbonHistory.futureCoordinates_zero {C L : ℝ≥0} {ε : ℝ}
-    (d : RibbonHistory C L ε) (hε : ε ≤ 1 / 8) :
-    d.futureCoordinates 0 = d.coordinates d.time := by
-  have htip : d.trace d.time = d.stepChart ((d.offset : ℂ) * Complex.I) := by
-    rw [RibbonHistory.stepChart, ← d.attained]
-    exact d.trace_coordinates ⟨bot_le, le_rfl⟩
-  simp only [RibbonHistory.futureCoordinates, add_zero, htip,
-    coordinateInverse_left (lower_lipschitz_injOn _ _ L d.step_lower)
-      (d.tip_in_stepCompact hε), d.attained]
-
-/-- The completed actual trace retains continuous ribbon coordinates,
-the narrow core, and the strict first-front property required for the
-next application of the uniform step theorem. -/
-theorem RibbonHistory.successful_continuation
-    {C L : ℝ≥0} {ε : ℝ} (d : RibbonHistory C L ε)
-    (hε : ε ≤ 1 / 8) (hL : 0 < L)
-    (S : ℝ≥0)
-    (hfirst : firstFrontTime
-      (fun t => longitudinalCoordinate d.chart closedRibbon d.front
-        (d.trace (d.time + t))) 1 = (S : WithTop ℝ≥0))
-    (hhit : longitudinalCoordinate d.chart closedRibbon d.front
-      (d.trace (d.time + S)) = 1)
-    (hS : 0 < S)
-    (hpath : MapsTo (fun t => d.trace (d.time + t)) (Icc 0 S)
-      (physicalPassageRegion d.stepChart ribbonStepCompact C ε (ε / L)))
-    (hoffset : ‖d.trace (d.time + S) - d.chart ((d.front : ℂ) + 1)‖ < (ε / L) / 4) :
-    ContinuousOn d.advanceCoordinates (Icc 0 (d.time + S)) ∧
-    EqOn d.trace (d.chart ∘ d.advanceCoordinates) (Icc 0 (d.time + S)) ∧
-    (d.advanceCoordinates 0).re = 0 ∧
-    d.advanceCoordinates (d.time + S) =
-      ((d.front + 1 : ℝ) : ℂ) + ((d.futureCoordinates S).im : ℂ) * Complex.I ∧
-    |(d.futureCoordinates S).im| ≤ ε / 4 ∧
-    MapsTo d.advanceCoordinates (Icc 0 (d.time + S)) closedRibbon ∧
-    (∀ t ∈ Icc 0 (d.time + S),
-      (d.advanceCoordinates t).re ≤ d.front + 1 ∧ |(d.advanceCoordinates t).im| ≤ ε) ∧
-    ∀ t : ℝ≥0, t < d.time + S → (d.advanceCoordinates t).re < d.front + 1 := by
-  let p := longitudinalCoordinate d.chart closedRibbon d.front
-  let η := fun t => d.trace (d.time + t)
-  have hi := lower_lipschitz_injOn d.stepChart ribbonStepCompact L d.step_lower
-  have hmap : MapsTo η (Icc 0 S) (d.stepChart '' ribbonStepCompact) := by
-    intro t ht
-    exact image_mono inter_subset_left (hpath ht)
-  have hη : Continuous η := d.witness.1.comp (continuous_const.add continuous_id)
-  have hq : ContinuousOn d.futureCoordinates (Icc 0 S) :=
-    continuousOn_const.add ((coordinateInverse_lipschitz d.stepChart ribbonStepCompact L
-      d.step_lower).continuousOn.comp hη.continuousOn hmap)
-  have hqzero := d.futureCoordinates_zero hε
-  have hpeq (t : ℝ≥0) (ht : t ∈ Icc 0 S) :
-      p (η t) = (d.futureCoordinates t).re - d.front := by
-    dsimp only [p]
-    rw [d.global_progress_eq_step (hmap ht)]
-    simp only [η, longitudinalCoordinate, RibbonHistory.futureCoordinates, Complex.add_re,
-      Complex.ofReal_re, add_sub_cancel_left, sub_zero]
-  have hp : ContinuousOn (fun t => p (η t)) (Icc 0 S) :=
-    ((Complex.continuous_re.comp_continuousOn hq).sub continuousOn_const).congr
-      (fun t ht => hpeq t ht)
-  have hp0 : p (η 0) < 1 := by
-    rw [hpeq 0 ⟨bot_le, bot_le⟩, hqzero, d.attained]
-    simp
-  have hprior := strict_before_attained_front _ 1 S hp hp0 hfirst
-  have hqre : (d.futureCoordinates S).re = d.front + 1 := by
-    have hh := (hpeq S ⟨bot_le, le_rfl⟩).symm.trans hhit
-    linarith
-  have hqcore (t : ℝ≥0) (ht : t ∈ Icc 0 S) :
-      d.futureCoordinates t ∈ closedRibbon ∧ |(d.futureCoordinates t).im| ≤ ε := by
-    obtain ⟨w, ⟨hwK, hwV⟩, he⟩ := hpath ht
-    have hqw : d.futureCoordinates t = (d.front : ℂ) + w := by
-      simp only [RibbonHistory.futureCoordinates, ← he, coordinateInverse_left hi hwK]
-    rw [hqw]
-    exact ⟨d.stepCompact_maps hwK, by
-      simpa only [Complex.add_im, Complex.ofReal_im, zero_add] using hwV.2.2.1.le⟩
-  have hqoffset : |(d.futureCoordinates S).im| ≤ ε / 4 := by
-    have h1 : (1 : ℂ) ∈ ribbonStepCompact := by
-      change -(1 / 2 : ℝ) ≤ 1 ∧ 1 ≤ 5 / 2 ∧ |(0 : ℝ)| ≤ 1 / 2
-      norm_num
-    have hd := d.step_lower _ (coordinateInverse_mem (hmap ⟨bot_le, le_rfl⟩)) 1 h1
-    rw [coordinateInverse_right (hmap ⟨bot_le, le_rfl⟩)] at hd
-    have habs : |(d.futureCoordinates S).im| ≤
-        dist (coordinateInverse d.stepChart ribbonStepCompact (η S)) 1 := by
-      simpa only [RibbonHistory.futureCoordinates, Complex.add_im, Complex.ofReal_im,
-        zero_add, dist_eq_norm, Complex.sub_im, Complex.one_im, sub_zero] using
-        Complex.abs_im_le_norm (coordinateInverse d.stepChart ribbonStepCompact (η S) - 1)
-    have hnorm : dist (η S) (d.stepChart 1) < (ε / L) / 4 := by
-      simpa only [dist_eq_norm, η, RibbonHistory.stepChart] using hoffset
-    have hmul := mul_lt_mul_of_pos_left hnorm (show 0 < (L : ℝ) from hL)
-    have he : (L : ℝ) * ((ε / L) / 4) = ε / 4 := by field_simp
-    exact (habs.trans hd).trans (he ▸ hmul.le)
-  have hsub (t : ℝ≥0) (ht : t ∈ Icc 0 (d.time + S)) : t - d.time ∈ Icc 0 S :=
-    ⟨bot_le, (tsub_le_iff_right).mpr (by simpa only [add_comm] using ht.2)⟩
-  have hleft : ContinuousOn (fun t => d.coordinates (min t d.time))
-      (Icc 0 (d.time + S)) := d.coordinates_continuous.comp
-        (continuous_id.min continuous_const).continuousOn (fun _ _ => ⟨bot_le, min_le_right _ _⟩)
-  have hright : ContinuousOn (fun t => d.futureCoordinates (t - d.time))
-      (Icc 0 (d.time + S)) := hq.comp
-        (continuous_id.sub continuous_const).continuousOn hsub
-  have hcont : ContinuousOn d.advanceCoordinates (Icc 0 (d.time + S)) := by
-    unfold RibbonHistory.advanceCoordinates
-    apply ContinuousOn.if ?_ (hleft.mono inter_subset_left) (hright.mono inter_subset_left)
-    intro t ht
-    have htT : t = d.time := by
-      have hf : t ∈ frontier (Iic d.time) := ht.2
-      simpa only [frontier_Iic, mem_singleton_iff] using hf
-    simp only [htT, min_self, tsub_self, hqzero]
-  have hold (t : ℝ≥0) (ht : t ≤ d.time) : d.advanceCoordinates t = d.coordinates t := by
-    simp only [RibbonHistory.advanceCoordinates, ite_eq_left ht, min_eq_left ht]
-  have hnew (t : ℝ≥0) (ht : d.time < t) :
-      d.advanceCoordinates t = d.futureCoordinates (t - d.time) := by
-    simp only [RibbonHistory.advanceCoordinates, ite_eq_right (not_le_of_gt ht)]
-  have hTS : d.time < d.time + S := lt_add_of_pos_right _ hS
-  refine ⟨hcont, ?_, ?_, ?_, hqoffset, ?_, ?_, ?_⟩
-  · intro t ht
-    by_cases htT : t ≤ d.time
-    · rw [Function.comp_apply, hold t htT]
-      exact d.trace_coordinates ⟨bot_le, htT⟩
-    · rw [Function.comp_apply, hnew t (lt_of_not_ge htT), RibbonHistory.futureCoordinates]
-      change d.trace t = d.stepChart (coordinateInverse d.stepChart ribbonStepCompact
-        (η (t - d.time)))
-      rw [coordinateInverse_right (hmap (hsub t ht))]
-      simp only [η, add_tsub_cancel_of_le (le_of_not_ge htT)]
-  · rw [hold 0 bot_le]
-    exact d.initial_front
-  · rw [hnew _ hTS, add_tsub_cancel_left]
-    apply Complex.ext <;> simp [hqre]
-  · intro t ht
-    by_cases htT : t ≤ d.time
-    · rw [hold t htT]
-      exact d.coordinates_ribbon ⟨bot_le, htT⟩
-    · rw [hnew t (lt_of_not_ge htT)]
-      exact (hqcore _ (hsub t ht)).1
-  · intro t ht
-    by_cases htT : t ≤ d.time
-    · rw [hold t htT]
-      obtain ⟨hr, hi�� := d.past_core t ⟨bot_le, htT⟩
-      exact ⟨by linarith, hi⟩
-    · rw [hnew t (lt_of_not_ge htT)]
-      refine ⟨?_, (hqcore _ (hsub t ht)).2⟩
-      rcases (hsub t ht).2.eq_or_lt with he | hlt
-      · rw [he, hqre]
-      · have hh := hprior _ hlt
-        rw [hpeq _ (hsub t ht)] at hh
-        linarith
-  · intro t ht
-    by_cases htT : t ≤ d.time
-    · rw [hold t htT]
-      linarith [(d.past_core t ⟨bot_le, htT⟩).1]
-    · rw [hnew t (lt_of_not_ge htT)]
-      have hlt : t - d.time < S := by
-        exact (tsub_lt_iff_left (le_of_not_ge htT)).mpr (by simpa only [add_comm] using ht)
-      have hh := hprior _ hlt
-      rw [hpeq _ ⟨bot_le, hlt.le⟩] at hh
-      linarith
-
-/-- A successful full step produces the actual history at the next
-integer front, with the same driver, trace, and Loewner maps. The only
-new geometric data are the deterministic bounds on the next patch. -/
-theorem RibbonHistory.next_history_of_stepEvent
-    {C L : ℝ≥0} {ε : ℝ} (d : RibbonHistory C L ε)
-    (hε : ε ≤ 1 / 8) (hL : 0 < L) (κ v c : ℝ)
-    (hstep : d.futureTrace ∈ d.stepEvent κ v c)
-    (hupper : LipschitzOnWith C d.chart (ribbonStepPatch (d.front + 1)))
-    (hlower : ∀ u ∈ ribbonStepPatch (d.front + 1),
-      ∀ v ∈ ribbonStepPatch (d.front + 1), dist u v ≤ L * dist (d.chart u) (d.chart v)) :
-    ∃ d' : RibbonHistory C L ε,
-      d'.front = d.front + 1 ∧
-      d'.time = d.time + frontTime
-        (fun t => longitudinalCoordinate d.chart closedRibbon d.front (d.futureTrace t)) 1 ∧
-      d'.chart = d.chart ∧ d'.U = d.U ∧ d'.trace = d.trace ∧
-      d'.forward = d.forward ∧ d'.inverse = d.inverse ∧
-      d'.coordinates = d.advanceCoordinates := by
-  let S := frontTime
-    (fun t => longitudinalCoordinate d.chart closedRibbon d.front (d.futureTrace t)) 1
-  obtain ⟨hfirst, hhit, hS, hpath, hoffset⟩ := hstep.1
-  obtain ⟨hcont, htrace, hzero, hattain, hoff, hribbon, hcore, hstrict⟩ :=
-    d.successful_continuation hε hL S hfirst hhit hS hpath hoffset
-  let d' : RibbonHistory C L ε := {
-    U := d.U
-    trace := d.trace
-    forward := d.forward
-    inverse := d.inverse
-    driver_continuous := d.driver_continuous
-    witness := d.witness
-    chart := d.chart
-    chart_continuous := d.chart_continuous
-    chart_injective := d.chart_injective
-    chart_upper := d.chart_upper
-    chart_escape := d.chart_escape
-    front := d.front + 1
-    offset := (d.futureCoordinates S).im
-    front_ge_one := by linarith [d.front_ge_one]
-    offset_bound := hoff
-    patch_upper := hupper
-    patch_lower := hlower
-    time := d.time + S
-    time_pos := d.time_pos.trans_le (le_add_of_nonneg_right bot_le)
-    coordinates := d.advanceCoordinates
-    coordinates_continuous := hcont
-    trace_coordinates := htrace
-    initial_front := hzero
-    attained := hattain
-    coordinates_ribbon := hribbon
-    past_core := hcore
-    strict_past := hstrict }
-  exact ⟨d', rfl, rfl, rfl, rfl, rfl, rfl, rfl, rfl⟩
-
-end SLEExactGauge
-
-end
-
-end OAI
+import OAI.Probability.SLE.Gauge.UniformRibbonStep
+
+namespace OAI
+
+/-! An actual successful passage gives another admissible stopped ribbon
+history. Inverse coordinates are used only on the compact physical patch
+where the successful path is contained. -/
+
+noncomputable section
+open Set Filter MeasureTheory Metric
+open scoped Topology NNReal ENNReal
+
+namespace SLEExactGauge
+open RibbonCoordinates BoundaryScaleLaw FirstFrontPassage PassageSuccess
+
+lemma strict_before_attained_front
+    (x : ℝ≥0 → ℝ) (q : ℝ) (S : ℝ≥0)
+    (hc : ContinuousOn x (Icc 0 S)) (h0 : x 0 < q)
+    (hfirst : firstFrontTime x q = (S : WithTop ℝ≥0)) :
+    ∀ t : ℝ≥0, t < S → x t < q := by
+  intro t ht
+  by_contra hn
+  obtain ⟨u, hu, hue⟩ := intermediate_value_Icc (show (0 : ℝ≥0) ≤ t from bot_le)
+    (hc.mono (Icc_subset_Icc_right ht.le)) ⟨h0.le, le_of_not_gt hn⟩
+  have hh := hittingAfter_le_of_mem (u := fun t (_ : Unit) => x t - q)
+    (ω := ()) (show (0 : ℝ≥0) ≤ u from bot_le)
+    (show x u - q ∈ ({0} : Set ℝ) by simp only [hue, sub_self, mem_singleton_iff])
+  change firstFrontTime x q ≤ (u : WithTop ℝ≥0) at hh
+  rw [hfirst, WithTop.coe_le_coe] at hh
+  exact (not_le_of_gt ht) (hh.trans hu.2)
+
+def RibbonHistory.futureCoordinates {C L : ℝ≥0} {ε : ℝ}
+    (d : RibbonHistory C L ε) (t : ℝ≥0) : ℂ :=
+  (d.front : ℂ) + coordinateInverse d.stepChart ribbonStepCompact (d.trace (d.time + t))
+
+def RibbonHistory.advanceCoordinates {C L : ℝ≥0} {ε : ℝ}
+    (d : RibbonHistory C L ε) (t : ℝ≥0) : ℂ :=
+  if t ≤ d.time then d.coordinates (min t d.time) else d.futureCoordinates (t - d.time)
+
+def RibbonHistory.futureTrace {C L : ℝ≥0} {ε : ℝ}
+    (d : RibbonHistory C L ε) : C(ℝ≥0, ℂ) :=
+  ⟨fun t => d.trace (d.time + t),
+    d.witness.1.comp (continuous_const.add continuous_id)⟩
+
+lemma RibbonHistory.tip_in_stepCompact {C L : ℝ≥0} {ε : ℝ}
+    (d : RibbonHistory C L ε) (hε : ε ≤ 1 / 8) :
+    (d.offset : ℂ) * Complex.I ∈ ribbonStepCompact := by
+  change -(1 / 2 : ℝ) ≤ ((d.offset : ℂ) * Complex.I).re ∧
+    ((d.offset : ℂ) * Complex.I).re ≤ 5 / 2 ∧
+    |((d.offset : ℂ) * Complex.I).im| ≤ 1 / 2
+  simp only [Complex.mul_re, Complex.ofReal_re, Complex.I_re, mul_zero,
+    Complex.ofReal_im, Complex.I_im, sub_self, Complex.mul_im, mul_one, add_zero]
+  exact ⟨by norm_num, by norm_num, by linarith [d.offset_bound]⟩
+
+lemma RibbonHistory.futureCoordinates_zero {C L : ℝ≥0} {ε : ℝ}
+    (d : RibbonHistory C L ε) (hε : ε ≤ 1 / 8) :
+    d.futureCoordinates 0 = d.coordinates d.time := by
+  have htip : d.trace d.time = d.stepChart ((d.offset : ℂ) * Complex.I) := by
+    rw [RibbonHistory.stepChart, ← d.attained]
+    exact d.trace_coordinates ⟨bot_le, le_rfl⟩
+  simp only [RibbonHistory.futureCoordinates, add_zero, htip,
+    coordinateInverse_left (lower_lipschitz_injOn _ _ L d.step_lower)
+      (d.tip_in_stepCompact hε), d.attained]
+
+/-- The completed actual trace retains continuous ribbon coordinates,
+the narrow core, and the strict first-front property required for the
+next application of the uniform step theorem. -/
+theorem RibbonHistory.successful_continuation
+    {C L : ℝ≥0} {ε : ℝ} (d : RibbonHistory C L ε)
+    (hε : ε ≤ 1 / 8) (hL : 0 < L)
+    (S : ℝ≥0)
+    (hfirst : firstFrontTime
+      (fun t => longitudinalCoordinate d.chart closedRibbon d.front
+        (d.trace (d.time + t))) 1 = (S : WithTop ℝ≥0))
+    (hhit : longitudinalCoordinate d.chart closedRibbon d.front
+      (d.trace (d.time + S)) = 1)
+    (hS : 0 < S)
+    (hpath : MapsTo (fun t => d.trace (d.time + t)) (Icc 0 S)
+      (physicalPassageRegion d.stepChart ribbonStepCompact C ε (ε / L)))
+    (hoffset : ‖d.trace (d.time + S) - d.chart ((d.front : ℂ) + 1)‖ < (ε / L) / 4) :
+    ContinuousOn d.advanceCoordinates (Icc 0 (d.time + S)) ∧
+    EqOn d.trace (d.chart ∘ d.advanceCoordinates) (Icc 0 (d.time + S)) ∧
+    (d.advanceCoordinates 0).re = 0 ∧
+    d.advanceCoordinates (d.time + S) =
+      ((d.front + 1 : ℝ) : ℂ) + ((d.futureCoordinates S).im : ℂ) * Complex.I ∧
+    |(d.futureCoordinates S).im| ≤ ε / 4 ∧
+    MapsTo d.advanceCoordinates (Icc 0 (d.time + S)) closedRibbon ∧
+    (∀ t ∈ Icc 0 (d.time + S),
+      (d.advanceCoordinates t).re ≤ d.front + 1 ∧ |(d.advanceCoordinates t).im| ≤ ε) ∧
+    ∀ t : ℝ≥0, t < d.time + S → (d.advanceCoordinates t).re < d.front + 1 := by
+  let p := longitudinalCoordinate d.chart closedRibbon d.front
+  let η := fun t => d.trace (d.time + t)
+  have hi := lower_lipschitz_injOn d.stepChart ribbonStepCompact L d.step_lower
+  have hmap : MapsTo η (Icc 0 S) (d.stepChart '' ribbonStepCompact) := by
+    intro t ht
+    exact image_mono inter_subset_left (hpath ht)
+  have hη : Continuous η := d.witness.1.comp (continuous_const.add continuous_id)
+  have hq : ContinuousOn d.futureCoordinates (Icc 0 S) :=
+    continuousOn_const.add ((coordinateInverse_lipschitz d.stepChart ribbonStepCompact L
+      d.step_lower).continuousOn.comp hη.continuousOn hmap)
+  have hqzero := d.futureCoordinates_zero hε
+  have hpeq (t : ℝ≥0) (ht : t ∈ Icc 0 S) :
+      p (η t) = (d.futureCoordinates t).re - d.front := by
+    dsimp only [p]
+    rw [d.global_progress_eq_step (hmap ht)]
+    simp only [η, longitudinalCoordinate, RibbonHistory.futureCoordinates, Complex.add_re,
+      Complex.ofReal_re, add_sub_cancel_left, sub_zero]
+  have hp : ContinuousOn (fun t => p (η t)) (Icc 0 S) :=
+    ((Complex.continuous_re.comp_continuousOn hq).sub continuousOn_const).congr
+      (fun t ht => hpeq t ht)
+  have hp0 : p (η 0) < 1 := by
+    rw [hpeq 0 ⟨bot_le, bot_le⟩, hqzero, d.attained]
+    simp
+  have hprior := strict_before_attained_front _ 1 S hp hp0 hfirst
+  have hqre : (d.futureCoordinates S).re = d.front + 1 := by
+    have hh := (hpeq S ⟨bot_le, le_rfl⟩).symm.trans hhit
+    linarith
+  have hqcore (t : ℝ≥0) (ht : t ∈ Icc 0 S) :
+      d.futureCoordinates t ∈ closedRibbon ∧ |(d.futureCoordinates t).im| ≤ ε := by
+    obtain ⟨w, ⟨hwK, hwV⟩, he⟩ := hpath ht
+    have hqw : d.futureCoordinates t = (d.front : ℂ) + w := by
+      simp only [RibbonHistory.futureCoordinates, ← he, coordinateInverse_left hi hwK]
+    rw [hqw]
+    exact ⟨d.stepCompact_maps hwK, by
+      simpa only [Complex.add_im, Complex.ofReal_im, zero_add] using hwV.2.2.1.le⟩
+  have hqoffset : |(d.futureCoordinates S).im| ≤ ε / 4 := by
+    have h1 : (1 : ℂ) ∈ ribbonStepCompact := by
+      change -(1 / 2 : ℝ) ≤ 1 ∧ 1 ≤ 5 / 2 ∧ |(0 : ℝ)| ≤ 1 / 2
+      norm_num
+    have hd := d.step_lower _ (coordinateInverse_mem (hmap ⟨bot_le, le_rfl⟩)) 1 h1
+    rw [coordinateInverse_right (hmap ⟨bot_le, le_rfl⟩)] at hd
+    have habs : |(d.futureCoordinates S).im| ≤
+        dist (coordinateInverse d.stepChart ribbonStepCompact (η S)) 1 := by
+      simpa only [RibbonHistory.futureCoordinates, Complex.add_im, Complex.ofReal_im,
+        zero_add, dist_eq_norm, Complex.sub_im, Complex.one_im, sub_zero] using
+        Complex.abs_im_le_norm (coordinateInverse d.stepChart ribbonStepCompact (η S) - 1)
+    have hnorm : dist (η S) (d.stepChart 1) < (ε / L) / 4 := by
+      simpa only [dist_eq_norm, η, RibbonHistory.stepChart] using hoffset
+    have hmul := mul_lt_mul_of_pos_left hnorm (show 0 < (L : ℝ) from hL)
+    have he : (L : ℝ) * ((ε / L) / 4) = ε / 4 := by field_simp
+    exact (habs.trans hd).trans (he ▸ hmul.le)
+  have hsub (t : ℝ≥0) (ht : t ∈ Icc 0 (d.time + S)) : t - d.time ∈ Icc 0 S :=
+    ⟨bot_le, (tsub_le_iff_right).mpr (by simpa only [add_comm] using ht.2)⟩
+  have hleft : ContinuousOn (fun t => d.coordinates (min t d.time))
+      (Icc 0 (d.time + S)) := d.coordinates_continuous.comp
+        (continuous_id.min continuous_const).continuousOn (fun _ _ => ⟨bot_le, min_le_right _ _⟩)
+  have hright : ContinuousOn (fun t => d.futureCoordinates (t - d.time))
+      (Icc 0 (d.time + S)) := hq.comp
+        (continuous_id.sub continuous_const).continuousOn hsub
+  have hcont : ContinuousOn d.advanceCoordinates (Icc 0 (d.time + S)) := by
+    unfold RibbonHistory.advanceCoordinates
+    apply ContinuousOn.if ?_ (hleft.mono inter_subset_left) (hright.mono inter_subset_left)
+    intro t ht
+    have htT : t = d.time := by
+      have hf : t ∈ frontier (Iic d.time) := ht.2
+      simpa only [frontier_Iic, mem_singleton_iff] using hf
+    simp only [htT, min_self, tsub_self, hqzero]
+  have hold (t : ℝ≥0) (ht : t ≤ d.time) : d.advanceCoordinates t = d.coordinates t := by
+    simp only [RibbonHistory.advanceCoordinates, ite_eq_left ht, min_eq_left ht]
+  have hnew (t : ℝ≥0) (ht : d.time < t) :
+      d.advanceCoordinates t = d.futureCoordinates (t - d.time) := by
+    simp only [RibbonHistory.advanceCoordinates, ite_eq_right (not_le_of_gt ht)]
+  have hTS : d.time < d.time + S := lt_add_of_pos_right _ hS
+  refine ⟨hcont, ?_, ?_, ?_, hqoffset, ?_, ?_, ?_⟩
+  · intro t ht
+    by_cases htT : t ≤ d.time
+    · rw [Function.comp_apply, hold t htT]
+      exact d.trace_coordinates ⟨bot_le, htT⟩
+    · rw [Function.comp_apply, hnew t (lt_of_not_ge htT), RibbonHistory.futureCoordinates]
+      change d.trace t = d.stepChart (coordinateInverse d.stepChart ribbonStepCompact
+        (η (t - d.time)))
+      rw [coordinateInverse_right (hmap (hsub t ht))]
+      simp only [η, add_tsub_cancel_of_le (le_of_not_ge htT)]
+  · rw [hold 0 bot_le]
+    exact d.initial_front
+  · rw [hnew _ hTS, add_tsub_cancel_left]
+    apply Complex.ext <;> simp [hqre]
+  · intro t ht
+    by_cases htT : t ≤ d.time
+    · rw [hold t htT]
+      exact d.coordinates_ribbon ⟨bot_le, htT⟩
+    · rw [hnew t (lt_of_not_ge htT)]
+      exact (hqcore _ (hsub t ht)).1
+  · intro t ht
+    by_cases htT : t ≤ d.time
+    · rw [hold t htT]
+      obtain ⟨hr, hi⟩ := d.past_core t ⟨bot_le, htT⟩
+      exact ⟨by linarith, hi⟩
+    · rw [hnew t (lt_of_not_ge htT)]
+      refine ⟨?_, (hqcore _ (hsub t ht)).2⟩
+      rcases (hsub t ht).2.eq_or_lt with he | hlt
+      · rw [he, hqre]
+      · have hh := hprior _ hlt
+        rw [hpeq _ (hsub t ht)] at hh
+        linarith
+  · intro t ht
+    by_cases htT : t ≤ d.time
+    · rw [hold t htT]
+      linarith [(d.past_core t ⟨bot_le, htT⟩).1]
+    · rw [hnew t (lt_of_not_ge htT)]
+      have hlt : t - d.time < S := by
+        exact (tsub_lt_iff_left (le_of_not_ge htT)).mpr (by simpa only [add_comm] using ht)
+      have hh := hprior _ hlt
+      rw [hpeq _ ⟨bot_le, hlt.le⟩] at hh
+      linarith
+
+/-- A successful full step produces the actual history at the next
+integer front, with the same driver, trace, and Loewner maps. The only
+new geometric data are the deterministic bounds on the next patch. -/
+theorem RibbonHistory.next_history_of_stepEvent
+    {C L : ℝ≥0} {ε : ℝ} (d : RibbonHistory C L ε)
+    (hε : ε ≤ 1 / 8) (hL : 0 < L) (κ v c : ℝ)
+    (hstep : d.futureTrace ∈ d.stepEvent κ v c)
+    (hupper : LipschitzOnWith C d.chart (ribbonStepPatch (d.front + 1)))
+    (hlower : ∀ u ∈ ribbonStepPatch (d.front + 1),
+      ∀ v ∈ ribbonStepPatch (d.front + 1), dist u v ≤ L * dist (d.chart u) (d.chart v)) :
+    ∃ d' : RibbonHistory C L ε,
+      d'.front = d.front + 1 ∧
+      d'.time = d.time + frontTime
+        (fun t => longitudinalCoordinate d.chart closedRibbon d.front (d.futureTrace t)) 1 ∧
+      d'.chart = d.chart ∧ d'.U = d.U ∧ d'.trace = d.trace ∧
+      d'.forward = d.forward ∧ d'.inverse = d.inverse ∧
+      d'.coordinates = d.advanceCoordinates := by
+  let S := frontTime
+    (fun t => longitudinalCoordinate d.chart closedRibbon d.front (d.futureTrace t)) 1
+  obtain ⟨hfirst, hhit, hS, hpath, hoffset⟩ := hstep.1
+  obtain ⟨hcont, htrace, hzero, hattain, hoff, hribbon, hcore, hstrict⟩ :=
+    d.successful_continuation hε hL S hfirst hhit hS hpath hoffset
+  let d' : RibbonHistory C L ε := {
+    U := d.U
+    trace := d.trace
+    forward := d.forward
+    inverse := d.inverse
+    driver_continuous := d.driver_continuous
+    witness := d.witness
+    chart := d.chart
+    chart_continuous := d.chart_continuous
+    chart_injective := d.chart_injective
+    chart_upper := d.chart_upper
+    chart_escape := d.chart_escape
+    front := d.front + 1
+    offset := (d.futureCoordinates S).im
+    front_ge_one := by linarith [d.front_ge_one]
+    offset_bound := hoff
+    patch_upper := hupper
+    patch_lower := hlower
+    time := d.time + S
+    time_pos := d.time_pos.trans_le (le_add_of_nonneg_right bot_le)
+    coordinates := d.advanceCoordinates
+    coordinates_continuous := hcont
+    trace_coordinates := htrace
+    initial_front := hzero
+    attained := hattain
+    coordinates_ribbon := hribbon
+    past_core := hcore
+    strict_past := hstrict }
+  exact ⟨d', rfl, rfl, rfl, rfl, rfl, rfl, rfl, rfl⟩
+
+end SLEExactGauge
+
+end
+
+end OAI

lean/OAI/Probability/SLE/Gauge/RibbonLimitPassageGeometry.lean

@@ -1,199 +1,199 @@
-import OAI.Probability.SLE.Gauge.RibbonPassageNeighborhood
-
-namespace OAI
-
-/-! Deterministic ribbon regions used by the limiting splice. The envelope
-extends beyond the attained front, while its front slice is narrowed to
-supply the prescribed physical terminal tolerance. -/
-
-noncomputable section
-open Set Filter Metric
-open scoped Topology NNReal
-
-namespace SLEExactGauge.RibbonCoordinates
-
-def passageCoordinateRegion (C : ℝ≥0) (ε η : ℝ) : Set ℂ :=
-  {w | -(1 / 4 : ℝ) < w.re ∧ w.re < 2 ∧ |w.im| < ε ∧
-    (w.re < 1 / 2 ∨ |w.im| < η / (4 * (C : ℝ)))}
-
-def physicalPassageRegion (P : ℂ → ℂ) (K : Set ℂ) (C : ℝ≥0) (ε η : ℝ) : Set ℂ :=
-  P '' (K ∩ passageCoordinateRegion C ε η)
-
-theorem passageCoordinateRegion_isOpen (C : ℝ≥0) (ε η : ℝ) :
-    IsOpen (passageCoordinateRegion C ε η) := by
-  apply IsOpen.inter (isOpen_lt continuous_const Complex.continuous_re)
-  apply IsOpen.inter (isOpen_lt Complex.continuous_re continuous_const)
-  apply IsOpen.inter (isOpen_lt Complex.continuous_im.abs continuous_const)
-  exact (isOpen_lt Complex.continuous_re continuous_const).union
-    (isOpen_lt Complex.continuous_im.abs continuous_const)
-
-/-- The prescribed access guide stays in the envelope, with its entire
-late part on the centerline, independently of the terminal tolerance. -/
-theorem guideCoordinate_mem_passageRegion
-    (C : ℝ≥0) (hC : 0 < C) {ε η x t : ℝ}
-    (hx : |x| < ε) (hη : 0 < η) (ht : t ∈ Icc (0 : ℝ) (3 / 2)) :
-    guideCoordinate 0 x t ∈ passageCoordinateRegion C ε η := by
-  have him := (guideCoordinate_im_bound (k := 0) (x := x) ht.1).trans_lt hx
-  refine ⟨by rw [guideCoordinate_re]; linarith [ht.1],
-    by rw [guideCoordinate_re]; linarith [ht.2], him, ?_⟩
-  by_cases hsmall : t < 1 / 2
-  · left
-    simpa only [guideCoordinate_re, zero_add] using hsmall
-  · right
-    have htlarge : 1 / 2 ≤ t := le_of_not_gt hsmall
-    have him0 : (guideCoordinate 0 x t).im = 0 := by
-      rw [guideCoordinate_im, max_eq_right (by linarith), mul_zero]
-    rw [him0, abs_zero]
-    exact div_pos hη (mul_pos (by norm_num) hC)
-
-/-- The thin front slice gives the terminal physical tolerance required by
-`FrontSuccess`, using the actual upper patch Lipschitz constant. -/
-theorem physicalPassageRegion_terminal
-    (P : ℂ → ℂ) (K : Set ℂ) (C L : ℝ≥0) (ε η : ℝ)
-    (hC : 0 < C) (hupper : LipschitzOnWith C P K)
-    (hlower : ∀ x ∈ K, ∀ y ∈ K, dist x y ≤ L * dist (P x) (P y))
-    (hbase : (1 : ℂ) ∈ K) {z : ℂ}
-    (hz : z ∈ physicalPassageRegion P K C ε η)
-    (hp : longitudinalCoordinate P K 0 z = 1) :
-    ‖z - P 1‖ < η / 4 := by
-  obtain ⟨w, ⟨hwK, hwV⟩, rfl⟩ := hz
-  have hi := lower_lipschitz_injOn P K L hlower
-  have hwre : w.re = 1 := by
-    simpa only [longitudinalCoordinate, coordinateInverse_left hi hwK, sub_zero] using hp
-  have him : |w.im| < η / (4 * (C : ℝ)) := by
-    rcases hwV.2.2.2 with hsmall | hthin
-    · rw [hwre] at hsmall
-      norm_num at hsmall
-    · exact hthin
-  have hd : dist w (1 : ℂ) = |w.im| := by
-    have he : w - 1 = (w.im : ℂ) * Complex.I := by
-      apply Complex.ext <;> simp [hwre]
-    rw [dist_eq_norm, he, norm_mul, Complex.norm_I, mul_one, Complex.norm_real, Real.norm_eq_abs]
-  have hbound := hupper.dist_le_mul w hwK 1 hbase
-  rw [hd] at hbound
-  have hCpos : 0 < (C : ℝ) := hC
-  have hthin : (C : ℝ) * |w.im| < η / 4 := by
-    have hh := (lt_div_iff₀ (mul_pos (by norm_num : (0 : ℝ) < 4) hCpos)).mp him
-    linarith
-  simpa only [dist_eq_norm] using hbound.trans_lt hthin
-
-/-- The actual limiting guide supplies a common physical neighborhood and
-all varying-region conditions used by the retained-mass passage theorem. -/
-theorem limiting_guide_passage_neighborhood
-    (hpublished : PublishedPlanarDiskOpenness)
-    (Pₙ : ℕ → ℂ → ℂ) (P : ℂ → ℂ) (K : Set ℂ) (C L : ℝ≥0)
-    (hC : 0 < C) (hL : 0 < L)
-    (hupper : ∀ n, LipschitzOnWith C (Pₙ n) K)
-    (hlower : ∀ n x, x ∈ K → ∀ y, y ∈ K → dist x y ≤ L * dist (Pₙ n x) (Pₙ n y))
-    (hconv : TendstoUniformlyOn Pₙ P atTop K)
-    (hP : ContinuousOn P K) (hPH : MapsTo P (interior K) upperHalfPlane)
-    (α : ℝ → ℂ) (hα : ContinuousOn α (Icc 0 2)) (x ε η : ℝ)
-    (hx : |x| < ε) (hη : 0 < η)
-    (hshape : EqOn α (fun t => P (guideCoordinate 0 x t)) (Icc 0 2))
-    (hmem : ∀ t ∈ Icc (0 : ℝ) (3 / 2), guideCoordinate 0 x t ∈ interior K)
-    (hbase : (1 : ℂ) ∈ K) :
-    ∃ U : Set ℂ, IsOpen U ∧ α '' Icc (0 : ℝ) (3 / 2) ⊆ U ∧
-      IsCompact (closure U) ∧ closure U ⊆ P '' interior K ∧
-      U ⊆ upperHalfPlane ∧
-      ContinuousOn (longitudinalCoordinate P K 0) U ∧
-      (∀ᶠ n in atTop, ContinuousOn (longitudinalCoordinate (Pₙ n) K 0) U) ∧
-      TendstoLocallyUniformlyOn (fun n => longitudinalCoordinate (Pₙ n) K 0)
-        (longitudinalCoordinate P K 0) atTop U ∧
-      (∀ᶠ n in atTop, U ⊆ physicalPassageRegion (Pₙ n) K C ε η) ∧
-      (∀ n z, z ∈ physicalPassageRegion (Pₙ n) K C ε η →
-        longitudinalCoordinate (Pₙ n) K 0 z = 1 → ‖z - Pₙ n 1‖ < η / 4) ∧
-      (∀ᶠ n in atTop,
-        U ∩ {z | (1 / 3 : ℝ) < longitudinalCoordinate (Pₙ n) K 0 z ∧
-          longitudinalCoordinate (Pₙ n) K 0 z < 2 / 3} ⊆ physicalMiddleRegion (Pₙ n) K 0 ε) := by
-  let V := passageCoordinateRegion C ε η
-  let A := α '' Icc (0 : ℝ) (3 / 2)
-  have hA : IsCompact A := isCompact_Icc.image_of_continuousOn
-    (hα.mono (Icc_subset_Icc_right (by norm_num)))
-  have hAV : A ⊆ P '' (interior K ∩ V) := by
-    rintro _ ⟨t, ht, rfl⟩
-    exact ⟨guideCoordinate 0 x t, ⟨hmem t ht,
-      guideCoordinate_mem_passageRegion C hC hx hη ht⟩,
-      (hshape ⟨ht.1, ht.2.trans (by norm_num)⟩).symm⟩
-  obtain ⟨U, hU, hAU, hUc, hUPV, hVlate, hKlate, _⟩ :=
-    common_coordinate_region_neighborhood hpublished Pₙ P K A V L hL hP
-      (fun n => (hupper n).continuousOn) hconv hlower hA
-      (passageCoordinateRegion_isOpen C ε η) hAV
-  have hUP : closure U ⊆ P '' interior K := hUPV.trans (image_mono inter_subset_left)
-  have hlim := lower_lipschitz_uniform_limit Pₙ P K L hconv hlower
-  have hi := lower_lipschitz_injOn P K L hlim
-  have hwidth : ∀ z ∈ closure U, |(coordinateInverse P K z).im| < ε := by
-    intro z hz
-    obtain ⟨w, hw, he⟩ := hUPV hz
-    rw [← he, coordinateInverse_left hi (interior_subset hw.1)]
-    exact hw.2.2.2.1
-  refine ⟨U, hU, hAU, hUc, hUP, ?_, ?_, ?_, ?_, ?_, ?_, ?_⟩
-  · exact (subset_closure.trans hUP).trans (image_subset_iff.mpr hPH)
-  · exact (longitudinalCoordinate_continuousOn P K L 0 hlim).mono
-      (subset_closure.trans (hUP.trans (image_mono interior_subset)))
-  · filter_upwards [hKlate] with n hn
-    exact (longitudinalCoordinate_continuousOn (Pₙ n) K L 0 (hlower n)).mono
-      (subset_closure.trans (hn.trans (image_mono interior_subset)))
-  · exact (longitudinalCoordinate_locally_uniform hpublished Pₙ P K L 0 hL hP
-      (fun n => (hupper n).continuousOn) hconv hlower).mono (subset_closure.trans hUP)
-  · exact hVlate.mono (fun _ hn => subset_closure.trans hn)
-  · exact fun n z hz hp => physicalPassageRegion_terminal (Pₙ n) K C L ε η hC
-      (hupper n) (hlower n) hbase hz hp
-  · exact eventual_middle_region_inclusion Pₙ P K U L 0 ε hconv hlower hUc
-      (hUP.trans (image_mono interior_subset))
-      (hKlate.mono (fun _ hn => hn.trans (image_mono interior_subset))) hwidth
-
-/-- Local coordinate convergence and convergence of the starting tips
-supply the fixed early ball used by localization. -/
-theorem eventual_early_coordinate_ball
-    (pₙ : ℕ → ℂ → ℝ) (p : ℂ → ℝ) (U : Set ℂ) (hU : IsOpen U)
-    (hp : ContinuousOn p U) (hconv : TendstoLocallyUniformlyOn pₙ p atTop U)
-    (aₙ : ℕ → ℂ) (a : ℂ) (ha : a ∈ U) (hpa : p a = 0)
-    (halim : Tendsto aₙ atTop (𝓝 a)) :
-    ∃ r : ℝ, 0 < r ∧ ball a (r / 2) ⊆ U ∧
-      (∀ z ∈ ball a (r / 4), p z < 1 / 3) ∧
-      ∀ᶠ n in atTop, ball (aₙ n) r ⊆ U ∩ {z | pₙ n z < 1} := by
-  let W := U ∩ p ⁻¹' Iio (1 / 6 : ℝ)
-  have hW : IsOpen W := hp.isOpen_inter_preimage hU isOpen_Iio
-  have haW : a ∈ W := ⟨ha, by simp only [mem_preimage, mem_Iio, hpa]; norm_num⟩
-  obtain ⟨d, hd, hball⟩ := Metric.isOpen_iff.mp hW a haW
-  let r := d / 4
-  have hr : 0 < r := by dsimp [r]; positivity
-  let C := closedBall a (d / 2)
-  have hCW : C ⊆ W := by
-    intro z hz
-    have hz' : dist z a ≤ d / 2 := hz
-    exact hball (hz'.trans_lt (by linarith))
-  have hCU : C ⊆ U := hCW.trans inter_subset_left
-  have hu : TendstoUniformlyOn pₙ p atTop C :=
-    (tendstoLocallyUniformlyOn_iff_tendstoUniformlyOn_of_compact
-      (isCompact_closedBall a (d / 2))).mp (hconv.mono hCU)
-  refine ⟨r, hr, ?_, ?_, ?_⟩
-  · intro z hz
-    have hrd : r / 2 < d := by dsimp only [r]; linarith
-    exact (hball (lt_trans hz hrd)).1
-  · intro z hz
-    have hrd : r / 4 < d := by dsimp only [r]; linarith
-    have hh := (hball (lt_trans hz hrd)).2
-    exact hh.trans (by norm_num)
-  · filter_upwards [halim.eventually (Metric.ball_mem_nhds a hr),
-      Metric.tendstoUniformlyOn_iff.mp hu (1 / 6) (by norm_num)] with n hn hclose
-    intro z hz
-    have hza : dist z a < d / 2 := by
-      have hh := (dist_triangle z (aₙ n) a).trans_lt (add_lt_add hz hn)
-      dsimp [r] at hh
-      linarith
-    have hzC : z ∈ C := hza.le
-    have hc := hclose z hzC
-    rw [Real.dist_eq] at hc
-    have hpz := (hCW hzC).2
-    refine ⟨hCU hzC, ?_⟩
-    have habs := (abs_lt.mp hc).1
-    change p z < 1 / 6 at hpz
-    change pₙ n z < 1
-    linarith
-
-end SLEExactGauge.RibbonCoordinates
-
-end
-
-end OAI
+import OAI.Probability.SLE.Gauge.RibbonPassageNeighborhood
+
+namespace OAI
+
+/-! Deterministic ribbon regions used by the limiting splice. The envelope
+extends beyond the attained front, while its front slice is narrowed to
+supply the prescribed physical terminal tolerance. -/
+
+noncomputable section
+open Set Filter Metric
+open scoped Topology NNReal
+
+namespace SLEExactGauge.RibbonCoordinates
+
+def passageCoordinateRegion (C : ℝ≥0) (ε η : ℝ) : Set ℂ :=
+  {w | -(1 / 4 : ℝ) < w.re ∧ w.re < 2 ∧ |w.im| < ε ∧
+    (w.re < 1 / 2 ∨ |w.im| < η / (4 * (C : ℝ)))}
+
+def physicalPassageRegion (P : ℂ → ℂ) (K : Set ℂ) (C : ℝ≥0) (ε η : ℝ) : Set ℂ :=
+  P '' (K ∩ passageCoordinateRegion C ε η)
+
+theorem passageCoordinateRegion_isOpen (C : ℝ≥0) (ε η : ℝ) :
+    IsOpen (passageCoordinateRegion C ε η) := by
+  apply IsOpen.inter (isOpen_lt continuous_const Complex.continuous_re)
+  apply IsOpen.inter (isOpen_lt Complex.continuous_re continuous_const)
+  apply IsOpen.inter (isOpen_lt Complex.continuous_im.abs continuous_const)
+  exact (isOpen_lt Complex.continuous_re continuous_const).union
+    (isOpen_lt Complex.continuous_im.abs continuous_const)
+
+/-- The prescribed access guide stays in the envelope, with its entire
+late part on the centerline, independently of the terminal tolerance. -/
+theorem guideCoordinate_mem_passageRegion
+    (C : ℝ≥0) (hC : 0 < C) {ε η x t : ℝ}
+    (hx : |x| < ε) (hη : 0 < η) (ht : t ∈ Icc (0 : ℝ) (3 / 2)) :
+    guideCoordinate 0 x t ∈ passageCoordinateRegion C ε η := by
+  have him := (guideCoordinate_im_bound (k := 0) (x := x) ht.1).trans_lt hx
+  refine ⟨by rw [guideCoordinate_re]; linarith [ht.1],
+    by rw [guideCoordinate_re]; linarith [ht.2], him, ?_⟩
+  by_cases hsmall : t < 1 / 2
+  · left
+    simpa only [guideCoordinate_re, zero_add] using hsmall
+  · right
+    have htlarge : 1 / 2 ≤ t := le_of_not_gt hsmall
+    have him0 : (guideCoordinate 0 x t).im = 0 := by
+      rw [guideCoordinate_im, max_eq_right (by linarith), mul_zero]
+    rw [him0, abs_zero]
+    exact div_pos hη (mul_pos (by norm_num) hC)
+
+/-- The thin front slice gives the terminal physical tolerance required by
+`FrontSuccess`, using the actual upper patch Lipschitz constant. -/
+theorem physicalPassageRegion_terminal
+    (P : ℂ → ℂ) (K : Set ℂ) (C L : ℝ≥0) (ε η : ℝ)
+    (hC : 0 < C) (hupper : LipschitzOnWith C P K)
+    (hlower : ∀ x ∈ K, ∀ y ∈ K, dist x y ≤ L * dist (P x) (P y))
+    (hbase : (1 : ℂ) ∈ K) {z : ℂ}
+    (hz : z ∈ physicalPassageRegion P K C ε η)
+    (hp : longitudinalCoordinate P K 0 z = 1) :
+    ‖z - P 1‖ < η / 4 := by
+  obtain ⟨w, ⟨hwK, hwV⟩, rfl⟩ := hz
+  have hi := lower_lipschitz_injOn P K L hlower
+  have hwre : w.re = 1 := by
+    simpa only [longitudinalCoordinate, coordinateInverse_left hi hwK, sub_zero] using hp
+  have him : |w.im| < η / (4 * (C : ℝ)) := by
+    rcases hwV.2.2.2 with hsmall | hthin
+    · rw [hwre] at hsmall
+      norm_num at hsmall
+    · exact hthin
+  have hd : dist w (1 : ℂ) = |w.im| := by
+    have he : w - 1 = (w.im : ℂ) * Complex.I := by
+      apply Complex.ext <;> simp [hwre]
+    rw [dist_eq_norm, he, norm_mul, Complex.norm_I, mul_one, Complex.norm_real, Real.norm_eq_abs]
+  have hbound := hupper.dist_le_mul w hwK 1 hbase
+  rw [hd] at hbound
+  have hCpos : 0 < (C : ℝ) := hC
+  have hthin : (C : ℝ) * |w.im| < η / 4 := by
+    have hh := (lt_div_iff₀ (mul_pos (by norm_num : (0 : ℝ) < 4) hCpos)).mp him
+    linarith
+  simpa only [dist_eq_norm] using hbound.trans_lt hthin
+
+/-- The actual limiting guide supplies a common physical neighborhood and
+all varying-region conditions used by the retained-mass passage theorem. -/
+theorem limiting_guide_passage_neighborhood
+    (hpublished : PublishedPlanarDiskOpenness)
+    (Pₙ : ℕ → ℂ → ℂ) (P : ℂ → ℂ) (K : Set ℂ) (C L : ℝ≥0)
+    (hC : 0 < C) (hL : 0 < L)
+    (hupper : ∀ n, LipschitzOnWith C (Pₙ n) K)
+    (hlower : ∀ n x, x ∈ K → ∀ y, y ∈ K → dist x y ≤ L * dist (Pₙ n x) (Pₙ n y))
+    (hconv : TendstoUniformlyOn Pₙ P atTop K)
+    (hP : ContinuousOn P K) (hPH : MapsTo P (interior K) upperHalfPlane)
+    (α : ℝ → ℂ) (hα : ContinuousOn α (Icc 0 2)) (x ε η : ℝ)
+    (hx : |x| < ε) (hη : 0 < η)
+    (hshape : EqOn α (fun t => P (guideCoordinate 0 x t)) (Icc 0 2))
+    (hmem : ∀ t ∈ Icc (0 : ℝ) (3 / 2), guideCoordinate 0 x t ∈ interior K)
+    (hbase : (1 : ℂ) ∈ K) :
+    ∃ U : Set ℂ, IsOpen U ∧ α '' Icc (0 : ℝ) (3 / 2) ⊆ U ∧
+      IsCompact (closure U) ∧ closure U ⊆ P '' interior K ∧
+      U ⊆ upperHalfPlane ∧
+      ContinuousOn (longitudinalCoordinate P K 0) U ∧
+      (∀ᶠ n in atTop, ContinuousOn (longitudinalCoordinate (Pₙ n) K 0) U) ∧
+      TendstoLocallyUniformlyOn (fun n => longitudinalCoordinate (Pₙ n) K 0)
+        (longitudinalCoordinate P K 0) atTop U ∧
+      (∀ᶠ n in atTop, U ⊆ physicalPassageRegion (Pₙ n) K C ε η) ∧
+      (∀ n z, z ∈ physicalPassageRegion (Pₙ n) K C ε η →
+        longitudinalCoordinate (Pₙ n) K 0 z = 1 → ‖z - Pₙ n 1‖ < η / 4) ∧
+      (∀ᶠ n in atTop,
+        U ∩ {z | (1 / 3 : ℝ) < longitudinalCoordinate (Pₙ n) K 0 z ∧
+          longitudinalCoordinate (Pₙ n) K 0 z < 2 / 3} ⊆ physicalMiddleRegion (Pₙ n) K 0 ε) := by
+  let V := passageCoordinateRegion C ε η
+  let A := α '' Icc (0 : ℝ) (3 / 2)
+  have hA : IsCompact A := isCompact_Icc.image_of_continuousOn
+    (hα.mono (Icc_subset_Icc_right (by norm_num)))
+  have hAV : A ⊆ P '' (interior K ∩ V) := by
+    rintro _ ⟨t, ht, rfl⟩
+    exact ⟨guideCoordinate 0 x t, ⟨hmem t ht,
+      guideCoordinate_mem_passageRegion C hC hx hη ht⟩,
+      (hshape ⟨ht.1, ht.2.trans (by norm_num)⟩).symm⟩
+  obtain ⟨U, hU, hAU, hUc, hUPV, hVlate, hKlate, _⟩ :=
+    common_coordinate_region_neighborhood hpublished Pₙ P K A V L hL hP
+      (fun n => (hupper n).continuousOn) hconv hlower hA
+      (passageCoordinateRegion_isOpen C ε η) hAV
+  have hUP : closure U ⊆ P '' interior K := hUPV.trans (image_mono inter_subset_left)
+  have hlim := lower_lipschitz_uniform_limit Pₙ P K L hconv hlower
+  have hi := lower_lipschitz_injOn P K L hlim
+  have hwidth : ∀ z ∈ closure U, |(coordinateInverse P K z).im| < ε := by
+    intro z hz
+    obtain ⟨w, hw, he⟩ := hUPV hz
+    rw [← he, coordinateInverse_left hi (interior_subset hw.1)]
+    exact hw.2.2.2.1
+  refine ⟨U, hU, hAU, hUc, hUP, ?_, ?_, ?_, ?_, ?_, ?_, ?_⟩
+  · exact (subset_closure.trans hUP).trans (image_subset_iff.mpr hPH)
+  · exact (longitudinalCoordinate_continuousOn P K L 0 hlim).mono
+      (subset_closure.trans (hUP.trans (image_mono interior_subset)))
+  · filter_upwards [hKlate] with n hn
+    exact (longitudinalCoordinate_continuousOn (Pₙ n) K L 0 (hlower n)).mono
+      (subset_closure.trans (hn.trans (image_mono interior_subset)))
+  · exact (longitudinalCoordinate_locally_uniform hpublished Pₙ P K L 0 hL hP
+      (fun n => (hupper n).continuousOn) hconv hlower).mono (subset_closure.trans hUP)
+  · exact hVlate.mono (fun _ hn => subset_closure.trans hn)
+  · exact fun n z hz hp => physicalPassageRegion_terminal (Pₙ n) K C L ε η hC
+      (hupper n) (hlower n) hbase hz hp
+  · exact eventual_middle_region_inclusion Pₙ P K U L 0 ε hconv hlower hUc
+      (hUP.trans (image_mono interior_subset))
+      (hKlate.mono (fun _ hn => hn.trans (image_mono interior_subset))) hwidth
+
+/-- Local coordinate convergence and convergence of the starting tips
+supply the fixed early ball used by localization. -/
+theorem eventual_early_coordinate_ball
+    (pₙ : ℕ → ℂ → ℝ) (p : ℂ → ℝ) (U : Set ℂ) (hU : IsOpen U)
+    (hp : ContinuousOn p U) (hconv : TendstoLocallyUniformlyOn pₙ p atTop U)
+    (aₙ : ℕ → ℂ) (a : ℂ) (ha : a ∈ U) (hpa : p a = 0)
+    (halim : Tendsto aₙ atTop (𝓝 a)) :
+    ∃ r : ℝ, 0 < r ∧ ball a (r / 2) ⊆ U ∧
+      (∀ z ∈ ball a (r / 4), p z < 1 / 3) ∧
+      ∀ᶠ n in atTop, ball (aₙ n) r ⊆ U ∩ {z | pₙ n z < 1} := by
+  let W := U ∩ p ⁻¹' Iio (1 / 6 : ℝ)
+  have hW : IsOpen W := hp.isOpen_inter_preimage hU isOpen_Iio
+  have haW : a ∈ W := ⟨ha, by simp only [mem_preimage, mem_Iio, hpa]; norm_num⟩
+  obtain ⟨d, hd, hball⟩ := Metric.isOpen_iff.mp hW a haW
+  let r := d / 4
+  have hr : 0 < r := by dsimp [r]; positivity
+  let C := closedBall a (d / 2)
+  have hCW : C ⊆ W := by
+    intro z hz
+    have hz' : dist z a ≤ d / 2 := hz
+    exact hball (hz'.trans_lt (by linarith))
+  have hCU : C ⊆ U := hCW.trans inter_subset_left
+  have hu : TendstoUniformlyOn pₙ p atTop C :=
+    (tendstoLocallyUniformlyOn_iff_tendstoUniformlyOn_of_compact
+      (isCompact_closedBall a (d / 2))).mp (hconv.mono hCU)
+  refine ⟨r, hr, ?_, ?_, ?_⟩
+  · intro z hz
+    have hrd : r / 2 < d := by dsimp only [r]; linarith
+    exact (hball (lt_trans hz hrd)).1
+  · intro z hz
+    have hrd : r / 4 < d := by dsimp only [r]; linarith
+    have hh := (hball (lt_trans hz hrd)).2
+    exact hh.trans (by norm_num)
+  · filter_upwards [halim.eventually (Metric.ball_mem_nhds a hr),
+      Metric.tendstoUniformlyOn_iff.mp hu (1 / 6) (by norm_num)] with n hn hclose
+    intro z hz
+    have hza : dist z a < d / 2 := by
+      have hh := (dist_triangle z (aₙ n) a).trans_lt (add_lt_add hz hn)
+      dsimp [r] at hh
+      linarith
+    have hzC : z ∈ C := hza.le
+    have hc := hclose z hzC
+    rw [Real.dist_eq] at hc
+    have hpz := (hCW hzC).2
+    refine ⟨hCU hzC, ?_⟩
+    have habs := (abs_lt.mp hc).1
+    change p z < 1 / 6 at hpz
+    change pₙ n z < 1
+    linarith
+
+end SLEExactGauge.RibbonCoordinates
+
+end
+
+end OAI

lean/OAI/Probability/SLE/Gauge/RibbonLimitSplice.lean

@@ -1,92 +1,92 @@
-import OAI.Probability.SLE.Gauge.RibbonLimitPassageGeometry
-import OAI.Probability.SLE.Geometry.GuideSplice
-
-namespace OAI
-
-/-! The limiting coordinate guide supplies the actual small-circle splice,
-its open continuation region, and a target strictly beyond the next front. -/
-
-noncomputable section
-open Set Filter Metric
-open scoped Topology NNReal
-
-namespace SLEExactGauge.RibbonCoordinates
-
-def limitingFrontTarget (F : ℂ → ℂ) (p : ℂ → ℝ) (U : Set ℂ) : Set ℂ :=
-  upperHalfPlane ∩ F ⁻¹' (U ∩ p ⁻¹' Ioi 1)
-
-theorem limitingFrontTarget_isOpen
-    (F : ℂ → ℂ) (hF : ContinuousOn F upperHalfPlane)
-    (p : ℂ → ℝ) (U : Set ℂ) (hU : IsOpen U) (hp : ContinuousOn p U) :
-    IsOpen (limitingFrontTarget F p U) :=
-  hF.isOpen_inter_preimage isOpen_upperHalfPlane (hp.isOpen_inter_preimage hU isOpen_Ioi)
-
-/-- No small-image or last-crossing hypothesis is needed for the limiting
-splice: both follow from the actual continuous inverse guide and its
-boundary value. -/
-theorem limiting_guide_splice_geometry
-    (F : ℂ → ℂ) (hF : DifferentiableOn ℂ F upperHalfPlane)
-    (hi : InjOn F upperHalfPlane) (α β : ℝ → ℂ)
-    (hα : ContinuousOn α (Icc 0 (3 / 2 : ℝ)))
-    (hβ : ContinuousOn β (Icc 0 (3 / 2 : ℝ))) (hβ0 : β 0 = 0)
-    (hβH : MapsTo β (Ioc 0 (3 / 2 : ℝ)) upperHalfPlane)
-    (hrel : EqOn (F ∘ β) α (Ioc 0 (3 / 2 : ℝ)))
-    (homit : α 0 ∉ F '' upperHalfPlane)
-    (U : Set ℂ) (hU : IsOpen U) (p : ℂ → ℝ) (hp : ContinuousOn p U)
-    (hαU : α '' Icc (0 : ℝ) (3 / 2) ⊆ U)
-    (hprogress : ∀ t ∈ Icc (0 : ℝ) (3 / 2), p (α t) = t)
-    (r m : ℝ) (hr : 0 < r) (hm : 0 < m) :
-    ∃ B tB : ℝ, 0 < B ∧ B / 2 ≤ m ∧ 0 < tB ∧ tB < 3 / 2 ∧
-      ‖β tB‖ = B ∧ (∀ t ∈ Ioc tB (3 / 2 : ℝ), B < ‖β t‖) ∧
-      (∀ θ ∈ Ioo 0 Real.pi,
-        ‖F (GuideSplice.circlePoint B θ) - α 0‖ < r / 4) ∧
-      (∀ z : ℂ, B / 8 ≤ ‖z‖ → ‖z‖ ≤ B → ‖z‖ / 2 ≤ z.im →
-        ‖F z - α 0‖ < r / 4) ∧
-      F '' (β '' Icc tB (3 / 2 : ℝ)) ⊆ U ∧
-      IsOpen (limitingFrontTarget F p U) ∧
-      β (3 / 2) ∈ limitingFrontTarget F p U ∧
-      (∀ z ∈ limitingFrontTarget F p U, 1 < p (F z)) := by
-  have hT : (0 : ℝ) < 3 / 2 := by norm_num
-  have ha0 := hα 0 ⟨le_rfl, hT.le⟩
-  have haIoc : Tendsto α (𝓝[Ioc (0 : ℝ) (3 / 2)] 0) (𝓝 (α 0)) :=
-    ha0.mono_left (nhdsWithin_mono _ Ioc_subset_Icc_self)
-  have heq : (F ∘ β) =ᶠ[𝓝[Ioc (0 : ℝ) (3 / 2)] 0] α :=
-    eventually_mem_nhdsWithin.mono (fun _ ht => hrel ht)
-  have hlimit : Tendsto (F ∘ β) (𝓝[>] 0) (𝓝 (α 0)) := by
-    rw [← nhdsWithin_Ioc_eq_nhdsGT hT]
-    exact haIoc.congr' heq.symm
-  have homit' : ∀ z, 0 < z.im → F z ≠ α 0 := by
-    intro z hz he
-    exact homit ⟨z, hz, he⟩
-  have hendH : 0 < (β (3 / 2)).im := hβH ⟨hT, le_rfl⟩
-  have hnorm : 0 < ‖β (3 / 2)‖ :=
-    (lt_of_lt_of_le hendH (Complex.im_le_norm _))
-  have hbound : 0 < min (2 * m) ‖β (3 / 2)‖ := lt_min (by positivity) hnorm
-  obtain ⟨B, hB, hcircle, hsector⟩ :=
-    SmallImageSemicircle.access_guide_has_arbitrarily_small_quarter_image_sector hF hi homit'
-      hr hT hβ hβ0 (fun t ht => hβH ht) hlimit _ hbound
-  have hBend : B < ‖β (3 / 2)‖ := hB.2.trans_le (min_le_right _ _)
-  obtain ⟨tB, htB, hcross, hafter⟩ := GuideSplice.exists_last_circle_crossing hB.1 hT le_rfl
-    hβ hβ0 (fun t ht => by have he : t = 3 / 2 := le_antisymm ht.2 ht.1; simpa only [he] using hBend)
-  refine ⟨B, tB, hB.1, ?_, htB.1, htB.2, hcross, hafter, hcircle, hsector, ?_,
-    limitingFrontTarget_isOpen F hF.continuousOn p U hU hp, ?_, ?_⟩
-  · have hh := hB.2.trans_le (min_le_left _ _)
-    linarith
-  · rintro _ ⟨z, ⟨t, ht, rfl⟩, rfl⟩
-    rw [show F (β t) = α t from hrel ⟨htB.1.trans_le ht.1, ht.2⟩]
-    exact hαU (mem_image_of_mem α ⟨htB.1.le.trans ht.1, ht.2⟩)
-  · refine ⟨hendH, ?_, ?_⟩
-    · rw [show F (β (3 / 2)) = α (3 / 2) from hrel ⟨hT, le_rfl⟩]
-      exact hαU (mem_image_of_mem α ⟨hT.le, le_rfl⟩)
-    · change 1 < p (F (β (3 / 2)))
-      rw [show F (β (3 / 2)) = α (3 / 2) from hrel ⟨hT, le_rfl⟩,
-        hprogress _ ⟨hT.le, le_rfl⟩]
-      norm_num
-  · intro z hz
-    exact hz.2.2
-
-end SLEExactGauge.RibbonCoordinates
-
-end
-
-end OAI
+import OAI.Probability.SLE.Gauge.RibbonLimitPassageGeometry
+import OAI.Probability.SLE.Geometry.GuideSplice
+
+namespace OAI
+
+/-! The limiting coordinate guide supplies the actual small-circle splice,
+its open continuation region, and a target strictly beyond the next front. -/
+
+noncomputable section
+open Set Filter Metric
+open scoped Topology NNReal
+
+namespace SLEExactGauge.RibbonCoordinates
+
+def limitingFrontTarget (F : ℂ → ℂ) (p : ℂ → ℝ) (U : Set ℂ) : Set ℂ :=
+  upperHalfPlane ∩ F ⁻¹' (U ∩ p ⁻¹' Ioi 1)
+
+theorem limitingFrontTarget_isOpen
+    (F : ℂ → ℂ) (hF : ContinuousOn F upperHalfPlane)
+    (p : ℂ → ℝ) (U : Set ℂ) (hU : IsOpen U) (hp : ContinuousOn p U) :
+    IsOpen (limitingFrontTarget F p U) :=
+  hF.isOpen_inter_preimage isOpen_upperHalfPlane (hp.isOpen_inter_preimage hU isOpen_Ioi)
+
+/-- No small-image or last-crossing hypothesis is needed for the limiting
+splice: both follow from the actual continuous inverse guide and its
+boundary value. -/
+theorem limiting_guide_splice_geometry
+    (F : ℂ → ℂ) (hF : DifferentiableOn ℂ F upperHalfPlane)
+    (hi : InjOn F upperHalfPlane) (α β : ℝ → ℂ)
+    (hα : ContinuousOn α (Icc 0 (3 / 2 : ℝ)))
+    (hβ : ContinuousOn β (Icc 0 (3 / 2 : ℝ))) (hβ0 : β 0 = 0)
+    (hβH : MapsTo β (Ioc 0 (3 / 2 : ℝ)) upperHalfPlane)
+    (hrel : EqOn (F ∘ β) α (Ioc 0 (3 / 2 : ℝ)))
+    (homit : α 0 ∉ F '' upperHalfPlane)
+    (U : Set ℂ) (hU : IsOpen U) (p : ℂ → ℝ) (hp : ContinuousOn p U)
+    (hαU : α '' Icc (0 : ℝ) (3 / 2) ⊆ U)
+    (hprogress : ∀ t ∈ Icc (0 : ℝ) (3 / 2), p (α t) = t)
+    (r m : ℝ) (hr : 0 < r) (hm : 0 < m) :
+    ∃ B tB : ℝ, 0 < B ∧ B / 2 ≤ m ∧ 0 < tB ∧ tB < 3 / 2 ∧
+      ‖β tB‖ = B ∧ (∀ t ∈ Ioc tB (3 / 2 : ℝ), B < ‖β t‖) ∧
+      (∀ θ ∈ Ioo 0 Real.pi,
+        ‖F (GuideSplice.circlePoint B θ) - α 0‖ < r / 4) ∧
+      (∀ z : ℂ, B / 8 ≤ ‖z‖ → ‖z‖ ≤ B → ‖z‖ / 2 ≤ z.im →
+        ‖F z - α 0‖ < r / 4) ∧
+      F '' (β '' Icc tB (3 / 2 : ℝ)) ⊆ U ∧
+      IsOpen (limitingFrontTarget F p U) ∧
+      β (3 / 2) ∈ limitingFrontTarget F p U ∧
+      (∀ z ∈ limitingFrontTarget F p U, 1 < p (F z)) := by
+  have hT : (0 : ℝ) < 3 / 2 := by norm_num
+  have ha0 := hα 0 ⟨le_rfl, hT.le⟩
+  have haIoc : Tendsto α (𝓝[Ioc (0 : ℝ) (3 / 2)] 0) (𝓝 (α 0)) :=
+    ha0.mono_left (nhdsWithin_mono _ Ioc_subset_Icc_self)
+  have heq : (F ∘ β) =ᶠ[𝓝[Ioc (0 : ℝ) (3 / 2)] 0] α :=
+    eventually_mem_nhdsWithin.mono (fun _ ht => hrel ht)
+  have hlimit : Tendsto (F ∘ β) (𝓝[>] 0) (𝓝 (α 0)) := by
+    rw [← nhdsWithin_Ioc_eq_nhdsGT hT]
+    exact haIoc.congr' heq.symm
+  have homit' : ∀ z, 0 < z.im → F z ≠ α 0 := by
+    intro z hz he
+    exact homit ⟨z, hz, he⟩
+  have hendH : 0 < (β (3 / 2)).im := hβH ⟨hT, le_rfl⟩
+  have hnorm : 0 < ‖β (3 / 2)‖ :=
+    (lt_of_lt_of_le hendH (Complex.im_le_norm _))
+  have hbound : 0 < min (2 * m) ‖β (3 / 2)‖ := lt_min (by positivity) hnorm
+  obtain ⟨B, hB, hcircle, hsector⟩ :=
+    SmallImageSemicircle.access_guide_has_arbitrarily_small_quarter_image_sector hF hi homit'
+      hr hT hβ hβ0 (fun t ht => hβH ht) hlimit _ hbound
+  have hBend : B < ‖β (3 / 2)‖ := hB.2.trans_le (min_le_right _ _)
+  obtain ⟨tB, htB, hcross, hafter⟩ := GuideSplice.exists_last_circle_crossing hB.1 hT le_rfl
+    hβ hβ0 (fun t ht => by have he : t = 3 / 2 := le_antisymm ht.2 ht.1; simpa only [he] using hBend)
+  refine ⟨B, tB, hB.1, ?_, htB.1, htB.2, hcross, hafter, hcircle, hsector, ?_,
+    limitingFrontTarget_isOpen F hF.continuousOn p U hU hp, ?_, ?_⟩
+  · have hh := hB.2.trans_le (min_le_left _ _)
+    linarith
+  · rintro _ ⟨z, ⟨t, ht, rfl⟩, rfl⟩
+    rw [show F (β t) = α t from hrel ⟨htB.1.trans_le ht.1, ht.2⟩]
+    exact hαU (mem_image_of_mem α ⟨htB.1.le.trans ht.1, ht.2⟩)
+  · refine ⟨hendH, ?_, ?_⟩
+    · rw [show F (β (3 / 2)) = α (3 / 2) from hrel ⟨hT, le_rfl⟩]
+      exact hαU (mem_image_of_mem α ⟨hT.le, le_rfl⟩)
+    · change 1 < p (F (β (3 / 2)))
+      rw [show F (β (3 / 2)) = α (3 / 2) from hrel ⟨hT, le_rfl⟩,
+        hprogress _ ⟨hT.le, le_rfl⟩]
+      norm_num
+  · intro z hz
+    exact hz.2.2
+
+end SLEExactGauge.RibbonCoordinates
+
+end
+
+end OAI

lean/OAI/Probability/SLE/Gauge/RibbonMiddleMass.lean

@@ -1,151 +1,151 @@
-import OAI.Probability.SLE.Gauge.RibbonConcatenation
-import OAI.Probability.SLE.Gauge.RibbonCoordinateLimit
-import OAI.Probability.SLE.Gauge.FiniteCoverAssembly
-import OAI.Probability.SLE.Mass.StoppedConformalPassageMass
-
-namespace OAI
-
-/-! The actual source middle strips of an embedded ribbon are disjoint,
-measurable spatial regions. Their stopped passage masses can therefore be
-charged to one whole-trace sausage at the common prescribed mesh. -/
-
-noncomputable section
-open Set Filter MeasureTheory Metric
-open scoped Topology NNReal ENNReal
-
-namespace SLEExactGauge.RibbonCoordinates
-
-def middleStrip (k ε : ℝ) : Set ℂ :=
-  {z | (1 / 3 : ℝ) < z.re - k ∧ z.re - k < 2 / 3 ∧ |z.im| < ε}
-
-theorem middleStrip_open (k ε : ℝ) : IsOpen (middleStrip k ε) :=
-  (isOpen_lt continuous_const (Complex.continuous_re.sub continuous_const)).inter
-    ((isOpen_lt (Complex.continuous_re.sub continuous_const) continuous_const).inter
-      (isOpen_lt Complex.continuous_im.abs continuous_const))
-
-theorem middleStrip_subset_closedRibbon {k ε : ℝ} (hk : 0 ≤ k) (hε : ε ≤ 1) :
-    middleStrip k ε ⊆ closedRibbon := by
-  intro z hz
-  exact ⟨by linarith [hz.1], hz.2.2.le.trans hε⟩
-
-theorem physicalMiddleRegion_eq_image_middleStrip
-    (P : ℂ → ℂ) {k ε : ℝ} (hk : 0 ≤ k) (hε : ε ≤ 1) :
-    physicalMiddleRegion P closedRibbon k ε = P '' middleStrip k ε := by
-  unfold physicalMiddleRegion
-  apply congrArg (fun R : Set ℂ => P '' R)
-  ext z
-  exact ⟨fun hz => hz.2,
-    fun hz => ⟨middleStrip_subset_closedRibbon hk hε hz, hz⟩⟩
-
-theorem middleStrip_pairwise_disjoint (ε : ℝ) :
-    Pairwise (fun i j : ℕ => Disjoint (middleStrip i ε) (middleStrip j ε)) := by
-  intro i j hij
-  rw [disjoint_left]
-  intro z hi hj
-  have hh : (i : ℝ) < (j : ℝ) ∨ (j : ℝ) < (i : ℝ) := by
-    exact_mod_cast lt_or_gt_of_ne hij
-  rcases hh with hh | hh
-  · have hn : i + 1 ≤ j := by exact_mod_cast hh
-    have hnR : (i : ℝ) + 1 ≤ j := by exact_mod_cast hn
-    linarith [hi.2.1, hj.1]
-  · have hn : j + 1 ≤ i := by exact_mod_cast hh
-    have hnR : (j : ℝ) + 1 ≤ i := by exact_mod_cast hn
-    linarith [hi.1, hj.2.1]
-
-theorem physical_middle_regions_pairwise_disjoint
-    (P : ℂ → ℂ) (hiP : InjOn P closedRibbon) {ε : ℝ} (hε : ε ≤ 1) :
-    Pairwise (fun i j : ℕ => Disjoint
-      (physicalMiddleRegion P closedRibbon i ε) (physicalMiddleRegion P closedRibbon j ε)) := by
-  intro i j hij
-  rw [physicalMiddleRegion_eq_image_middleStrip P (Nat.cast_nonneg _) hε,
-    physicalMiddleRegion_eq_image_middleStrip P (Nat.cast_nonneg _) hε, disjoint_left]
-  rintro z ⟨u, hu, he⟩ ⟨v, hv, hve⟩
-  have huv : u = v := hiP
-    (middleStrip_subset_closedRibbon (Nat.cast_nonneg _) hε hu)
-    (middleStrip_subset_closedRibbon (Nat.cast_nonneg _) hε hv) (he.trans hve.symm)
-  exact Set.disjoint_left.mp (middleStrip_pairwise_disjoint ε hij) hu (huv ▸ hv)
-
-theorem isOpen_embedded_middle_region
-    (hpublished : PublishedPlanarDiskOpenness)
-    (P : ℂ → ℂ) (hP : ContinuousOn P closedRibbon) (hiP : InjOn P closedRibbon)
-    {k ε : ℝ} (hk : 0 ≤ k) (hε : ε ≤ 1) :
-    IsOpen (physicalMiddleRegion P closedRibbon k ε) := by
-  rw [physicalMiddleRegion_eq_image_middleStrip P hk hε]
-  apply isOpen_iff_mem_nhds.mpr
-  rintro z ⟨u, hu, rfl⟩
-  obtain ⟨r, hr, hball⟩ := Metric.isOpen_iff.mp (middleStrip_open k ε) u hu
-  have hclosed := hball.trans (middleStrip_subset_closedRibbon hk hε)
-  exact mem_of_superset
-    ((hpublished P u r hr (hP.mono hclosed) (hiP.mono hclosed)).mem_nhds
-      (mem_image_of_mem P (mem_ball_self hr))) (image_mono hball)
-
-theorem segmentSausageCharge_le_whole
-    (κ : ℝ) (γ : ℝ≥0 → ℂ) (s t : ℝ≥0) (v : ℝ) (R : Set ℂ) :
-    segmentSausageCharge κ γ s t v R ≤ wholeSausageCharge κ γ v R := by
-  apply mul_le_mul' le_rfl
-  apply measure_mono
-  rintro z ⟨hz, u, _, hd⟩
-  exact ⟨hz, u, by simpa only [dist_comm] using hd⟩
-
-/-- Exactly the source middle strips are counted, even if their sausages
-also meet other parts of the curve. Spatial disjointness alone suffices. -/
-theorem whole_sausage_charge_from_ribbon_steps
-    (hpublished : PublishedPlanarDiskOpenness)
-    (P : ℂ → ℂ) (hP : ContinuousOn P closedRibbon) (hiP : InjOn P closedRibbon)
-    {ε : ℝ} (hε : ε ≤ 1) (I : Finset ℕ)
-    (κ : ℝ) (γ : ℝ≥0 → ℂ) (s t : ℕ → ℝ≥0) (v b : ℝ) (A : Set ℂ)
-    (hregions : ∀ i ∈ I, physicalMiddleRegion P closedRibbon i ε ⊆ A)
-    (hmass : ∀ i ∈ I, ENNReal.ofReal b ≤
-      segmentSausageCharge κ γ (s i) (t i) v (physicalMiddleRegion P closedRibbon i ε)) :
-    (I.card : ℝ≥0∞) * ENNReal.ofReal b ≤ wholeSausageCharge κ γ v A := by
-  let ν := wholeSausageMeasure κ γ v
-  have hmeas i : MeasurableSet (physicalMiddleRegion P closedRibbon (i : ℕ) ε) :=
-    (isOpen_embedded_middle_region hpublished P hP hiP (Nat.cast_nonneg _) hε).measurableSet
-  calc
-    _ = ∑ _i ∈ I, ENNReal.ofReal b := by rw [Finset.sum_const, nsmul_eq_mul]
-    _ ≤ ∑ i ∈ I, ν (physicalMiddleRegion P closedRibbon i ε) := by
-      apply Finset.sum_le_sum
-      intro i hi
-      rw [wholeSausageMeasure_apply κ γ v (hmeas i)]
-      exact (hmass i hi).trans (segmentSausageCharge_le_whole κ γ (s i) (t i) v _)
-    _ = ν (⋃ i ∈ I, physicalMiddleRegion P closedRibbon i ε) :=
-      (measure_biUnion_finset
-        (fun i _ j _ hij => physical_middle_regions_pairwise_disjoint P hiP hε hij)
-        (fun i _ => hmeas i)).symm
-    _ ≤ wholeSausageCharge κ γ v A := by
-      rw [wholeSausageMeasure_apply κ γ v
-        (I.measurableSet_biUnion (fun i _ => hmeas i))]
-      apply mul_le_mul' le_rfl
-      exact measure_mono (inter_subset_inter (iUnion₂_subset hregions) Subset.rfl)
-
-theorem dense_ribbon_mass_from_steps
-    (hpublished : PublishedPlanarDiskOpenness)
-    (P : ℂ → ℂ) (hP : ContinuousOn P closedRibbon) (hiP : InjOn P closedRibbon)
-    {ε : ℝ} (hε : ε ≤ 1) (I : Finset ℕ)
-    (κ : ℝ) (γ : ℝ≥0 → ℂ) (s t : ℕ → ℝ≥0) (v c ell : ℝ)
-    (hell : 0 < ell) (m : ℕ) (hm : 0 < m) (hcard : I.card = m ^ 2)
-    (A : Set ℂ)
-    (hregions : ∀ i ∈ I, physicalMiddleRegion P closedRibbon i ε ⊆ A)
-    (hmass : ∀ i ∈ I, ENNReal.ofReal (c * (ell / (m : ℝ)) ^ dimension κ) ≤
-      segmentSausageCharge κ γ (s i) (t i) v (physicalMiddleRegion P closedRibbon i ε)) :
-    ENNReal.ofReal (c * ell ^ dimension κ * (m : ℝ) ^ codimension κ) ≤
-      wholeSausageCharge κ γ v A := by
-  have hmR : (0 : ℝ) < m := by exact_mod_cast hm
-  have he : (m : ℝ) ^ 2 * (c * (ell / (m : ℝ)) ^ dimension κ) =
-      c * ell ^ dimension κ * (m : ℝ) ^ codimension κ := by
-    rw [div_eq_mul_one_div, Real.mul_rpow hell.le (one_div_nonneg.mpr hmR.le)]
-    calc
-      _ = c * ell ^ dimension κ *
-          ((m : ℝ) ^ 2 * (1 / (m : ℝ)) ^ dimension κ) := by ring
-      _ = _ := by rw [ribbon_mass_power_cancellation κ hmR]
-  have hh := whole_sausage_charge_from_ribbon_steps hpublished P hP hiP hε I κ γ s t v
-    (c * (ell / (m : ℝ)) ^ dimension κ) A hregions hmass
-  rw [hcard, ← ENNReal.ofReal_natCast, ← ENNReal.ofReal_mul (Nat.cast_nonneg _),
-    Nat.cast_pow, he] at hh
-  exact hh
-
-end SLEExactGauge.RibbonCoordinates
-
-end
-
-end OAI
+import OAI.Probability.SLE.Gauge.RibbonConcatenation
+import OAI.Probability.SLE.Gauge.RibbonCoordinateLimit
+import OAI.Probability.SLE.Gauge.FiniteCoverAssembly
+import OAI.Probability.SLE.Mass.StoppedConformalPassageMass
+
+namespace OAI
+
+/-! The actual source middle strips of an embedded ribbon are disjoint,
+measurable spatial regions. Their stopped passage masses can therefore be
+charged to one whole-trace sausage at the common prescribed mesh. -/
+
+noncomputable section
+open Set Filter MeasureTheory Metric
+open scoped Topology NNReal ENNReal
+
+namespace SLEExactGauge.RibbonCoordinates
+
+def middleStrip (k ε : ℝ) : Set ℂ :=
+  {z | (1 / 3 : ℝ) < z.re - k ∧ z.re - k < 2 / 3 ∧ |z.im| < ε}
+
+theorem middleStrip_open (k ε : ℝ) : IsOpen (middleStrip k ε) :=
+  (isOpen_lt continuous_const (Complex.continuous_re.sub continuous_const)).inter
+    ((isOpen_lt (Complex.continuous_re.sub continuous_const) continuous_const).inter
+      (isOpen_lt Complex.continuous_im.abs continuous_const))
+
+theorem middleStrip_subset_closedRibbon {k ε : ℝ} (hk : 0 ≤ k) (hε : ε ≤ 1) :
+    middleStrip k ε ⊆ closedRibbon := by
+  intro z hz
+  exact ⟨by linarith [hz.1], hz.2.2.le.trans hε⟩
+
+theorem physicalMiddleRegion_eq_image_middleStrip
+    (P : ℂ → ℂ) {k ε : ℝ} (hk : 0 ≤ k) (hε : ε ≤ 1) :
+    physicalMiddleRegion P closedRibbon k ε = P '' middleStrip k ε := by
+  unfold physicalMiddleRegion
+  apply congrArg (fun R : Set ℂ => P '' R)
+  ext z
+  exact ⟨fun hz => hz.2,
+    fun hz => ⟨middleStrip_subset_closedRibbon hk hε hz, hz⟩⟩
+
+theorem middleStrip_pairwise_disjoint (ε : ℝ) :
+    Pairwise (fun i j : ℕ => Disjoint (middleStrip i ε) (middleStrip j ε)) := by
+  intro i j hij
+  rw [disjoint_left]
+  intro z hi hj
+  have hh : (i : ℝ) < (j : ℝ) ∨ (j : ℝ) < (i : ℝ) := by
+    exact_mod_cast lt_or_gt_of_ne hij
+  rcases hh with hh | hh
+  · have hn : i + 1 ≤ j := by exact_mod_cast hh
+    have hnR : (i : ℝ) + 1 ≤ j := by exact_mod_cast hn
+    linarith [hi.2.1, hj.1]
+  · have hn : j + 1 ≤ i := by exact_mod_cast hh
+    have hnR : (j : ℝ) + 1 ≤ i := by exact_mod_cast hn
+    linarith [hi.1, hj.2.1]
+
+theorem physical_middle_regions_pairwise_disjoint
+    (P : ℂ → ℂ) (hiP : InjOn P closedRibbon) {ε : ℝ} (hε : ε ≤ 1) :
+    Pairwise (fun i j : ℕ => Disjoint
+      (physicalMiddleRegion P closedRibbon i ε) (physicalMiddleRegion P closedRibbon j ε)) := by
+  intro i j hij
+  rw [physicalMiddleRegion_eq_image_middleStrip P (Nat.cast_nonneg _) hε,
+    physicalMiddleRegion_eq_image_middleStrip P (Nat.cast_nonneg _) hε, disjoint_left]
+  rintro z ⟨u, hu, he⟩ ⟨v, hv, hve⟩
+  have huv : u = v := hiP
+    (middleStrip_subset_closedRibbon (Nat.cast_nonneg _) hε hu)
+    (middleStrip_subset_closedRibbon (Nat.cast_nonneg _) hε hv) (he.trans hve.symm)
+  exact Set.disjoint_left.mp (middleStrip_pairwise_disjoint ε hij) hu (huv ▸ hv)
+
+theorem isOpen_embedded_middle_region
+    (hpublished : PublishedPlanarDiskOpenness)
+    (P : ℂ → ℂ) (hP : ContinuousOn P closedRibbon) (hiP : InjOn P closedRibbon)
+    {k ε : ℝ} (hk : 0 ≤ k) (hε : ε ≤ 1) :
+    IsOpen (physicalMiddleRegion P closedRibbon k ε) := by
+  rw [physicalMiddleRegion_eq_image_middleStrip P hk hε]
+  apply isOpen_iff_mem_nhds.mpr
+  rintro z ⟨u, hu, rfl⟩
+  obtain ⟨r, hr, hball⟩ := Metric.isOpen_iff.mp (middleStrip_open k ε) u hu
+  have hclosed := hball.trans (middleStrip_subset_closedRibbon hk hε)
+  exact mem_of_superset
+    ((hpublished P u r hr (hP.mono hclosed) (hiP.mono hclosed)).mem_nhds
+      (mem_image_of_mem P (mem_ball_self hr))) (image_mono hball)
+
+theorem segmentSausageCharge_le_whole
+    (κ : ℝ) (γ : ℝ≥0 → ℂ) (s t : ℝ≥0) (v : ℝ) (R : Set ℂ) :
+    segmentSausageCharge κ γ s t v R ≤ wholeSausageCharge κ γ v R := by
+  apply mul_le_mul' le_rfl
+  apply measure_mono
+  rintro z ⟨hz, u, _, hd⟩
+  exact ⟨hz, u, by simpa only [dist_comm] using hd⟩
+
+/-- Exactly the source middle strips are counted, even if their sausages
+also meet other parts of the curve. Spatial disjointness alone suffices. -/
+theorem whole_sausage_charge_from_ribbon_steps
+    (hpublished : PublishedPlanarDiskOpenness)
+    (P : ℂ → ℂ) (hP : ContinuousOn P closedRibbon) (hiP : InjOn P closedRibbon)
+    {ε : ℝ} (hε : ε ≤ 1) (I : Finset ℕ)
+    (κ : ℝ) (γ : ℝ≥0 → ℂ) (s t : ℕ → ℝ≥0) (v b : ℝ) (A : Set ℂ)
+    (hregions : ∀ i ∈ I, physicalMiddleRegion P closedRibbon i ε ⊆ A)
+    (hmass : ∀ i ∈ I, ENNReal.ofReal b ≤
+      segmentSausageCharge κ γ (s i) (t i) v (physicalMiddleRegion P closedRibbon i ε)) :
+    (I.card : ℝ≥0∞) * ENNReal.ofReal b ≤ wholeSausageCharge κ γ v A := by
+  let ν := wholeSausageMeasure κ γ v
+  have hmeas i : MeasurableSet (physicalMiddleRegion P closedRibbon (i : ℕ) ε) :=
+    (isOpen_embedded_middle_region hpublished P hP hiP (Nat.cast_nonneg _) hε).measurableSet
+  calc
+    _ = ∑ _i ∈ I, ENNReal.ofReal b := by rw [Finset.sum_const, nsmul_eq_mul]
+    _ ≤ ∑ i ∈ I, ν (physicalMiddleRegion P closedRibbon i ε) := by
+      apply Finset.sum_le_sum
+      intro i hi
+      rw [wholeSausageMeasure_apply κ γ v (hmeas i)]
+      exact (hmass i hi).trans (segmentSausageCharge_le_whole κ γ (s i) (t i) v _)
+    _ = ν (⋃ i ∈ I, physicalMiddleRegion P closedRibbon i ε) :=
+      (measure_biUnion_finset
+        (fun i _ j _ hij => physical_middle_regions_pairwise_disjoint P hiP hε hij)
+        (fun i _ => hmeas i)).symm
+    _ ≤ wholeSausageCharge κ γ v A := by
+      rw [wholeSausageMeasure_apply κ γ v
+        (I.measurableSet_biUnion (fun i _ => hmeas i))]
+      apply mul_le_mul' le_rfl
+      exact measure_mono (inter_subset_inter (iUnion₂_subset hregions) Subset.rfl)
+
+theorem dense_ribbon_mass_from_steps
+    (hpublished : PublishedPlanarDiskOpenness)
+    (P : ℂ → ℂ) (hP : ContinuousOn P closedRibbon) (hiP : InjOn P closedRibbon)
+    {ε : ℝ} (hε : ε ≤ 1) (I : Finset ℕ)
+    (κ : ℝ) (γ : ℝ≥0 → ℂ) (s t : ℕ → ℝ≥0) (v c ell : ℝ)
+    (hell : 0 < ell) (m : ℕ) (hm : 0 < m) (hcard : I.card = m ^ 2)
+    (A : Set ℂ)
+    (hregions : ∀ i ∈ I, physicalMiddleRegion P closedRibbon i ε ⊆ A)
+    (hmass : ∀ i ∈ I, ENNReal.ofReal (c * (ell / (m : ℝ)) ^ dimension κ) ≤
+      segmentSausageCharge κ γ (s i) (t i) v (physicalMiddleRegion P closedRibbon i ε)) :
+    ENNReal.ofReal (c * ell ^ dimension κ * (m : ℝ) ^ codimension κ) ≤
+      wholeSausageCharge κ γ v A := by
+  have hmR : (0 : ℝ) < m := by exact_mod_cast hm
+  have he : (m : ℝ) ^ 2 * (c * (ell / (m : ℝ)) ^ dimension κ) =
+      c * ell ^ dimension κ * (m : ℝ) ^ codimension κ := by
+    rw [div_eq_mul_one_div, Real.mul_rpow hell.le (one_div_nonneg.mpr hmR.le)]
+    calc
+      _ = c * ell ^ dimension κ *
+          ((m : ℝ) ^ 2 * (1 / (m : ℝ)) ^ dimension κ) := by ring
+      _ = _ := by rw [ribbon_mass_power_cancellation κ hmR]
+  have hh := whole_sausage_charge_from_ribbon_steps hpublished P hP hiP hε I κ γ s t v
+    (c * (ell / (m : ℝ)) ^ dimension κ) A hregions hmass
+  rw [hcard, ← ENNReal.ofReal_natCast, ← ENNReal.ofReal_mul (Nat.cast_nonneg _),
+    Nat.cast_pow, he] at hh
+  exact hh
+
+end SLEExactGauge.RibbonCoordinates
+
+end
+
+end OAI

lean/OAI/Probability/SLE/Gauge/RibbonPassageMass.lean

@@ -1,119 +1,119 @@
-import OAI.Probability.SLE.SausageSeedAll
-
-namespace OAI
-
-/-!
-The last probabilistic transfer in the ribbon step: a finite deterministic
-list of retained time intervals permits subtracting one unconditional
-small-sausage exception from the varying passage events. The sausage
-estimate is never conditioned on passage.
--/
-
-noncomputable section
-open Set Filter MeasureTheory
-open scoped Topology ENNReal NNReal
-
-namespace SLEExactGauge
-
-/-- The finite-list subtraction step of `rc:step`. Passage may select a
-different deterministic interval on each sample and at each mesh. -/
-theorem ribbon_passage_mass_of_eventually_finite_intervals
-    {Ω : Type*} [MeasurableSpace Ω] (P : Measure Ω) [IsProbabilityMeasure P]
-    (κ : ℝ) (hκ : 0 < κ) (hκ8 : κ < 8)
-    (γ : Ω → ℝ≥0 → ℂ) (hSLE : IsOrdinaryChordalSLE κ γ P)
-    (I : Finset (ℝ≥0 × ℝ≥0)) (hI : ∀ J ∈ I, J.1 < J.2)
-    (v : ℕ → ℝ) (hv : ∀ n, 0 < v n) (hlim : Tendsto v atTop (𝓝 0))
-    (G : ℕ → Set Ω) (q : ℝ) (hq : 0 < q)
-    (hG : ∀ᶠ n in atTop, ENNReal.ofReal q ≤ P (G n))
-    (physicalMass : ℕ → Ω → ℝ≥0∞) (passage : ℕ → Ω → Prop)
-    (c : ℝ) (hc : 0 < c)
-    (htransfer : ∀ᶠ n in atTop, ∀ ω, ω ∈ G n → passage n ω ∧
-      ∃ J ∈ I, ENNReal.ofReal c *
-        sourceSausageMass κ (γ ω) J.1 J.2 (v n) ≤ physicalMass n ω) :
-    ∃ a : ℝ, 0 < a ∧ ∀ᶠ n in atTop,
-      ENNReal.ofReal (q / 2) ≤
-        P {ω | ω ∈ G n ∧ passage n ω ∧ ENNReal.ofReal a ≤ physicalMass n ω} := by
-  obtain ⟨b, e₀, hb, he₀, hsmall⟩ := sourceSmallSausageMain_proved
-    Ω inferInstance P inferInstance κ hκ hκ8 γ hSLE I hI (q / 2) (by positivity)
-  refine ⟨c * b, mul_pos hc hb, ?_⟩
-  have hevent : ∀ᶠ n in atTop, v n < e₀ :=
-    (tendsto_order.mp hlim).2 e₀ he₀
-  filter_upwards [hevent, hG, htransfer] with n hn hGn htransfern
-  let bad : Set Ω := {ω | ∃ J ∈ I,
-    sourceSausageMass κ (γ ω) J.1 J.2 (v n) < ENNReal.ofReal b}
-  let good : Set Ω := {ω | ω ∈ G n ∧ passage n ω ∧
-    ENNReal.ofReal (c * b) ≤ physicalMass n ω}
-  have hbad : P bad < ENNReal.ofReal (q / 2) := hsmall (v n) (hv n) hn
-  have hcover : G n ⊆ good ∪ bad := by
-    intro ω hω
-    by_cases hbadω : ω ∈ bad
-    · exact Or.inr hbadω
-    · obtain ⟨hpassage, J, hJI, hmass⟩ := htransfern ω hω
-      left
-      refine ⟨hω, hpassage, ?_⟩
-      have hsausage : ENNReal.ofReal b ≤ sourceSausageMass κ (γ ω) J.1 J.2 (v n) := by
-        by_contra h
-        exact hbadω ⟨J, hJI, lt_of_not_ge h⟩
-      rw [ENNReal.ofReal_mul hc.le]
-      exact (mul_le_mul' le_rfl hsausage).trans hmass
-  change ENNReal.ofReal (q / 2) ≤ P good
-  by_contra hgood
-  have hhalf : ENNReal.ofReal (q / 2) + ENNReal.ofReal (q / 2) =
-      ENNReal.ofReal q := by
-    rw [← ENNReal.ofReal_add (by positivity) (by positivity)]
-    congr 1
-    ring
-  have hlt : P good + P bad < ENNReal.ofReal q := by
-    rw [← hhalf]
-    exact ENNReal.add_lt_add (lt_of_not_ge hgood) hbad
-  exact (not_lt_of_ge hGn)
-    (((measure_mono hcover).trans (measure_union_le good bad)).trans_lt hlt)
-
-/-- A version with transfer and probability bounds at every index. -/
-theorem ribbon_passage_mass_of_finite_intervals
-    {Ω : Type*} [MeasurableSpace Ω] (P : Measure Ω) [IsProbabilityMeasure P]
-    (κ : ℝ) (hκ : 0 < κ) (hκ8 : κ < 8)
-    (γ : Ω → ℝ≥0 → ℂ) (hSLE : IsOrdinaryChordalSLE κ γ P)
-    (I : Finset (ℝ≥0 × ℝ≥0)) (hI : ∀ J ∈ I, J.1 < J.2)
-    (v : ℕ → ℝ) (hv : ∀ n, 0 < v n) (hlim : Tendsto v atTop (𝓝 0))
-    (G : ℕ → Set Ω) (q : ℝ) (hq : 0 < q)
-    (hG : ∀ n, ENNReal.ofReal q ≤ P (G n))
-    (physicalMass : ℕ → Ω → ℝ≥0∞) (passage : ℕ → Ω → Prop)
-    (c : ℝ) (hc : 0 < c)
-    (htransfer : ∀ n ω, ω ∈ G n → passage n ω ∧
-      ∃ J ∈ I, ENNReal.ofReal c *
-        sourceSausageMass κ (γ ω) J.1 J.2 (v n) ≤ physicalMass n ω) :
-    ∃ a : ℝ, 0 < a ∧ ∀ᶠ n in atTop,
-      ENNReal.ofReal (q / 2) ≤
-        P {ω | ω ∈ G n ∧ passage n ω ∧ ENNReal.ofReal a ≤ physicalMass n ω} :=
-  ribbon_passage_mass_of_eventually_finite_intervals P κ hκ hκ8 γ hSLE I hI
-    v hv hlim G q hq (Eventually.of_forall hG) physicalMass passage c hc
-    (Eventually.of_forall htransfer)
-
-/-- The same finite-list transfer with passage already included in `G n`. -/
-theorem ribbon_mass_of_finite_intervals
-    {Ω : Type*} [MeasurableSpace Ω] (P : Measure Ω) [IsProbabilityMeasure P]
-    (κ : ℝ) (hκ : 0 < κ) (hκ8 : κ < 8)
-    (γ : Ω → ℝ≥0 → ℂ) (hSLE : IsOrdinaryChordalSLE κ γ P)
-    (I : Finset (ℝ≥0 × ℝ≥0)) (hI : ∀ J ∈ I, J.1 < J.2)
-    (v : ℕ → ℝ) (hv : ∀ n, 0 < v n) (hlim : Tendsto v atTop (𝓝 0))
-    (G : ℕ → Set Ω) (q : ℝ) (hq : 0 < q)
-    (hG : ∀ n, ENNReal.ofReal q ≤ P (G n))
-    (physicalMass : ℕ → Ω → ℝ≥0∞) (c : ℝ) (hc : 0 < c)
-    (htransfer : ∀ n ω, ω ∈ G n →
-      ∃ J ∈ I, ENNReal.ofReal c *
-        sourceSausageMass κ (γ ω) J.1 J.2 (v n) ≤ physicalMass n ω) :
-    ∃ a : ℝ, 0 < a ∧ ∀ᶠ n in atTop,
-      ENNReal.ofReal (q / 2) ≤
-        P {ω | ω ∈ G n ∧ ENNReal.ofReal a ≤ physicalMass n ω} := by
-  obtain ⟨a, ha, hevent⟩ := ribbon_passage_mass_of_finite_intervals
-    P κ hκ hκ8 γ hSLE I hI v hv hlim G q hq hG physicalMass
-    (fun _ _ => True) c hc (fun n ω hω => ⟨trivial, htransfer n ω hω⟩)
-  refine ⟨a, ha, ?_⟩
-  simpa only [true_and] using hevent
-
-end SLEExactGauge
-
-end
-
-end OAI
+import OAI.Probability.SLE.SausageSeedAll
+
+namespace OAI
+
+/-!
+The last probabilistic transfer in the ribbon step: a finite deterministic
+list of retained time intervals permits subtracting one unconditional
+small-sausage exception from the varying passage events. The sausage
+estimate is never conditioned on passage.
+-/
+
+noncomputable section
+open Set Filter MeasureTheory
+open scoped Topology ENNReal NNReal
+
+namespace SLEExactGauge
+
+/-- The finite-list subtraction step of `rc:step`. Passage may select a
+different deterministic interval on each sample and at each mesh. -/
+theorem ribbon_passage_mass_of_eventually_finite_intervals
+    {Ω : Type*} [MeasurableSpace Ω] (P : Measure Ω) [IsProbabilityMeasure P]
+    (κ : ℝ) (hκ : 0 < κ) (hκ8 : κ < 8)
+    (γ : Ω → ℝ≥0 → ℂ) (hSLE : IsOrdinaryChordalSLE κ γ P)
+    (I : Finset (ℝ≥0 × ℝ≥0)) (hI : ∀ J ∈ I, J.1 < J.2)
+    (v : ℕ → ℝ) (hv : ∀ n, 0 < v n) (hlim : Tendsto v atTop (𝓝 0))
+    (G : ℕ → Set Ω) (q : ℝ) (hq : 0 < q)
+    (hG : ∀ᶠ n in atTop, ENNReal.ofReal q ≤ P (G n))
+    (physicalMass : ℕ → Ω → ℝ≥0∞) (passage : ℕ → Ω → Prop)
+    (c : ℝ) (hc : 0 < c)
+    (htransfer : ∀ᶠ n in atTop, ∀ ω, ω ∈ G n → passage n ω ∧
+      ∃ J ∈ I, ENNReal.ofReal c *
+        sourceSausageMass κ (γ ω) J.1 J.2 (v n) ≤ physicalMass n ω) :
+    ∃ a : ℝ, 0 < a ∧ ∀ᶠ n in atTop,
+      ENNReal.ofReal (q / 2) ≤
+        P {ω | ω ∈ G n ∧ passage n ω ∧ ENNReal.ofReal a ≤ physicalMass n ω} := by
+  obtain ⟨b, e₀, hb, he₀, hsmall⟩ := sourceSmallSausageMain_proved
+    Ω inferInstance P inferInstance κ hκ hκ8 γ hSLE I hI (q / 2) (by positivity)
+  refine ⟨c * b, mul_pos hc hb, ?_⟩
+  have hevent : ∀ᶠ n in atTop, v n < e₀ :=
+    (tendsto_order.mp hlim).2 e₀ he₀
+  filter_upwards [hevent, hG, htransfer] with n hn hGn htransfern
+  let bad : Set Ω := {ω | ∃ J ∈ I,
+    sourceSausageMass κ (γ ω) J.1 J.2 (v n) < ENNReal.ofReal b}
+  let good : Set Ω := {ω | ω ∈ G n ∧ passage n ω ∧
+    ENNReal.ofReal (c * b) ≤ physicalMass n ω}
+  have hbad : P bad < ENNReal.ofReal (q / 2) := hsmall (v n) (hv n) hn
+  have hcover : G n ⊆ good ∪ bad := by
+    intro ω hω
+    by_cases hbadω : ω ∈ bad
+    · exact Or.inr hbadω
+    · obtain ⟨hpassage, J, hJI, hmass⟩ := htransfern ω hω
+      left
+      refine ⟨hω, hpassage, ?_⟩
+      have hsausage : ENNReal.ofReal b ≤ sourceSausageMass κ (γ ω) J.1 J.2 (v n) := by
+        by_contra h
+        exact hbadω ⟨J, hJI, lt_of_not_ge h⟩
+      rw [ENNReal.ofReal_mul hc.le]
+      exact (mul_le_mul' le_rfl hsausage).trans hmass
+  change ENNReal.ofReal (q / 2) ≤ P good
+  by_contra hgood
+  have hhalf : ENNReal.ofReal (q / 2) + ENNReal.ofReal (q / 2) =
+      ENNReal.ofReal q := by
+    rw [← ENNReal.ofReal_add (by positivity) (by positivity)]
+    congr 1
+    ring
+  have hlt : P good + P bad < ENNReal.ofReal q := by
+    rw [← hhalf]
+    exact ENNReal.add_lt_add (lt_of_not_ge hgood) hbad
+  exact (not_lt_of_ge hGn)
+    (((measure_mono hcover).trans (measure_union_le good bad)).trans_lt hlt)
+
+/-- A version with transfer and probability bounds at every index. -/
+theorem ribbon_passage_mass_of_finite_intervals
+    {Ω : Type*} [MeasurableSpace Ω] (P : Measure Ω) [IsProbabilityMeasure P]
+    (κ : ℝ) (hκ : 0 < κ) (hκ8 : κ < 8)
+    (γ : Ω → ℝ≥0 → ℂ) (hSLE : IsOrdinaryChordalSLE κ γ P)
+    (I : Finset (ℝ≥0 × ℝ≥0)) (hI : ∀ J ∈ I, J.1 < J.2)
+    (v : ℕ → ℝ) (hv : ∀ n, 0 < v n) (hlim : Tendsto v atTop (𝓝 0))
+    (G : ℕ → Set Ω) (q : ℝ) (hq : 0 < q)
+    (hG : ∀ n, ENNReal.ofReal q ≤ P (G n))
+    (physicalMass : ℕ → Ω → ℝ≥0∞) (passage : ℕ → Ω → Prop)
+    (c : ℝ) (hc : 0 < c)
+    (htransfer : ∀ n ω, ω ∈ G n → passage n ω ∧
+      ∃ J ∈ I, ENNReal.ofReal c *
+        sourceSausageMass κ (γ ω) J.1 J.2 (v n) ≤ physicalMass n ω) :
+    ∃ a : ℝ, 0 < a ∧ ∀ᶠ n in atTop,
+      ENNReal.ofReal (q / 2) ≤
+        P {ω | ω ∈ G n ∧ passage n ω ∧ ENNReal.ofReal a ≤ physicalMass n ω} :=
+  ribbon_passage_mass_of_eventually_finite_intervals P κ hκ hκ8 γ hSLE I hI
+    v hv hlim G q hq (Eventually.of_forall hG) physicalMass passage c hc
+    (Eventually.of_forall htransfer)
+
+/-- The same finite-list transfer with passage already included in `G n`. -/
+theorem ribbon_mass_of_finite_intervals
+    {Ω : Type*} [MeasurableSpace Ω] (P : Measure Ω) [IsProbabilityMeasure P]
+    (κ : ℝ) (hκ : 0 < κ) (hκ8 : κ < 8)
+    (γ : Ω → ℝ≥0 → ℂ) (hSLE : IsOrdinaryChordalSLE κ γ P)
+    (I : Finset (ℝ≥0 × ℝ≥0)) (hI : ∀ J ∈ I, J.1 < J.2)
+    (v : ℕ → ℝ) (hv : ∀ n, 0 < v n) (hlim : Tendsto v atTop (𝓝 0))
+    (G : ℕ → Set Ω) (q : ℝ) (hq : 0 < q)
+    (hG : ∀ n, ENNReal.ofReal q ≤ P (G n))
+    (physicalMass : ℕ → Ω → ℝ≥0∞) (c : ℝ) (hc : 0 < c)
+    (htransfer : ∀ n ω, ω ∈ G n →
+      ∃ J ∈ I, ENNReal.ofReal c *
+        sourceSausageMass κ (γ ω) J.1 J.2 (v n) ≤ physicalMass n ω) :
+    ∃ a : ℝ, 0 < a ∧ ∀ᶠ n in atTop,
+      ENNReal.ofReal (q / 2) ≤
+        P {ω | ω ∈ G n ∧ ENNReal.ofReal a ≤ physicalMass n ω} := by
+  obtain ⟨a, ha, hevent⟩ := ribbon_passage_mass_of_finite_intervals
+    P κ hκ hκ8 γ hSLE I hI v hv hlim G q hq hG physicalMass
+    (fun _ _ => True) c hc (fun n ω hω => ⟨trivial, htransfer n ω hω⟩)
+  refine ⟨a, ha, ?_⟩
+  simpa only [true_and] using hevent
+
+end SLEExactGauge
+
+end
+
+end OAI

lean/OAI/Probability/SLE/Gauge/RibbonPassageNeighborhood.lean

@@ -1,96 +1,96 @@
-import OAI.Probability.SLE.Gauge.RibbonCoordinateLimit
-
-namespace OAI
-
-/-! Common physical neighborhoods of compact passage routes. Strict
-coordinate margins are retained on the closure before passing to moving
-ribbon charts. -/
-
-noncomputable section
-open Set Filter Metric
-open scoped Topology NNReal
-
-namespace SLEExactGauge.RibbonCoordinates
-
-/-- An embedded coordinate chart maps every open coordinate subset of its
-controlled patch to an open physical subset. -/
-theorem isOpen_image_coordinate_subset
-    (hpublished : PublishedPlanarDiskOpenness)
-    (P : ℂ → ℂ) (K V : Set ℂ) (hP : ContinuousOn P K) (hi : InjOn P K)
-    (hV : IsOpen V) (hVK : V ⊆ K) : IsOpen (P '' V) := by
-  apply isOpen_iff_mem_nhds.mpr
-  rintro z ⟨x, hx, rfl⟩
-  obtain ⟨r, hr, hball⟩ := Metric.isOpen_iff.mp hV x hx
-  have hsub : ball x r ⊆ K := hball.trans hVK
-  have hopen := hpublished P x r hr (hP.mono hsub) (hi.mono hsub)
-  exact mem_of_superset
-    (hopen.mem_nhds (mem_image_of_mem P (mem_ball_self hr)))
-    (image_mono hball)
-
-/-- A compact route strictly inside a coordinate region admits one open
-physical neighborhood whose closure lies in the same region for every
-sufficiently late ribbon chart. -/
-theorem common_coordinate_region_neighborhood
-    (hpublished : PublishedPlanarDiskOpenness)
-    (Pₙ : ℕ → ℂ → ℂ) (P : ℂ → ℂ) (K A V : Set ℂ) (L : ℝ≥0)
-    (hL : 0 < L) (hP : ContinuousOn P K)
-    (hPn : ∀ n, ContinuousOn (Pₙ n) K)
-    (hconv : TendstoUniformlyOn Pₙ P atTop K)
-    (hlower : ∀ n x, x ∈ K → ∀ y, y ∈ K → dist x y ≤ L * dist (Pₙ n x) (Pₙ n y))
-    (hA : IsCompact A) (hV : IsOpen V)
-    (hAV : A ⊆ P '' (interior K ∩ V)) :
-    ∃ U : Set ℂ, IsOpen U ∧ A ⊆ U ∧ IsCompact (closure U) ∧
-      closure U ⊆ P '' (interior K ∩ V) ∧
-      (∀ᶠ n in atTop, closure U ⊆ Pₙ n '' (K ∩ V)) ∧
-      (∀ᶠ n in atTop, closure U ⊆ Pₙ n '' interior K) ∧
-      TendstoUniformlyOn (fun n => coordinateInverse (Pₙ n) K)
-        (coordinateInverse P K) atTop (closure U) := by
-  have hlim := lower_lipschitz_uniform_limit Pₙ P K L hconv hlower
-  have hi := lower_lipschitz_injOn P K L hlim
-  have hopen := isOpen_image_coordinate_subset hpublished P K (interior K ∩ V)
-    hP hi (isOpen_interior.inter hV) (inter_subset_left.trans interior_subset)
-  obtain ⟨ρ, hρ, hthick⟩ := hA.exists_cthickening_subset_open hopen hAV
-  let U := thickening ρ A
-  have hcl : closure U ⊆ cthickening ρ A := closure_thickening_subset_cthickening ρ A
-  have hUc : IsCompact (closure U) := hA.cthickening.of_isClosed_subset isClosed_closure hcl
-  have hUPV : closure U ⊆ P '' (interior K ∩ V) := hcl.trans hthick
-  have hUP : closure U ⊆ P '' interior K := hUPV.trans (image_mono inter_subset_left)
-  have hlate := eventual_compact_image_interior hpublished Pₙ P K (closure U) L hL hPn
-    hconv hlower hUc hUP
-  have hUV : coordinateInverse P K '' closure U ⊆ V := by
-    rintro _ ⟨z, hz, rfl⟩
-    obtain ⟨x, hx, he⟩ := hUPV hz
-    have heq : coordinateInverse P K z = x := by
-      rw [← he]
-      exact coordinateInverse_left hi (interior_subset hx.1)
-    simpa only [heq] using hx.2
-  have hcover : ∀ᶠ n in atTop, closure U ⊆ Pₙ n '' K :=
-    hlate.mono (fun _ h => h.trans (image_mono interior_subset))
-  have hregions := eventual_compact_coordinate_region Pₙ P K (closure U) V L hconv hlower
-    hUc (hUP.trans (image_mono interior_subset)) hcover hV hUV
-  exact ⟨U, isOpen_thickening, self_subset_thickening hρ A, hUc, hUPV, hregions, hlate,
-    coordinateInverse_uniform_on Pₙ P K (closure U) L hconv hlower
-      (hUP.trans (image_mono interior_subset)) hcover⟩
-
-/-- Limiting coordinate guides have exact longitudinal progress and retain
-the source transverse margin. -/
-theorem limit_guide_coordinates
-    (P : ℂ → ℂ) (K : Set ℂ) (hi : InjOn P K)
-    (α : ℝ → ℂ) (x : ℝ)
-    (hshape : EqOn α (fun t => P (guideCoordinate 0 x t)) (Icc 0 2))
-    (hmem : ∀ t ∈ Icc (0 : ℝ) 2, guideCoordinate 0 x t ∈ K) :
-    ∀ t ∈ Icc (0 : ℝ) 2,
-      longitudinalCoordinate P K 0 (α t) = t ∧
-        |(coordinateInverse P K (α t)).im| ≤ |x| := by
-  intro t ht
-  rw [hshape ht, coordinateInverse_left hi (hmem t ht)]
-  constructor
-  · simp only [longitudinalCoordinate, coordinateInverse_left hi (hmem t ht),
-      guideCoordinate_re, zero_add, sub_zero]
-  · exact guideCoordinate_im_bound ht.1
-
-end SLEExactGauge.RibbonCoordinates
-
-end
-
-end OAI
+import OAI.Probability.SLE.Gauge.RibbonCoordinateLimit
+
+namespace OAI
+
+/-! Common physical neighborhoods of compact passage routes. Strict
+coordinate margins are retained on the closure before passing to moving
+ribbon charts. -/
+
+noncomputable section
+open Set Filter Metric
+open scoped Topology NNReal
+
+namespace SLEExactGauge.RibbonCoordinates
+
+/-- An embedded coordinate chart maps every open coordinate subset of its
+controlled patch to an open physical subset. -/
+theorem isOpen_image_coordinate_subset
+    (hpublished : PublishedPlanarDiskOpenness)
+    (P : ℂ → ℂ) (K V : Set ℂ) (hP : ContinuousOn P K) (hi : InjOn P K)
+    (hV : IsOpen V) (hVK : V ⊆ K) : IsOpen (P '' V) := by
+  apply isOpen_iff_mem_nhds.mpr
+  rintro z ⟨x, hx, rfl⟩
+  obtain ⟨r, hr, hball⟩ := Metric.isOpen_iff.mp hV x hx
+  have hsub : ball x r ⊆ K := hball.trans hVK
+  have hopen := hpublished P x r hr (hP.mono hsub) (hi.mono hsub)
+  exact mem_of_superset
+    (hopen.mem_nhds (mem_image_of_mem P (mem_ball_self hr)))
+    (image_mono hball)
+
+/-- A compact route strictly inside a coordinate region admits one open
+physical neighborhood whose closure lies in the same region for every
+sufficiently late ribbon chart. -/
+theorem common_coordinate_region_neighborhood
+    (hpublished : PublishedPlanarDiskOpenness)
+    (Pₙ : ℕ → ℂ → ℂ) (P : ℂ → ℂ) (K A V : Set ℂ) (L : ℝ≥0)
+    (hL : 0 < L) (hP : ContinuousOn P K)
+    (hPn : ∀ n, ContinuousOn (Pₙ n) K)
+    (hconv : TendstoUniformlyOn Pₙ P atTop K)
+    (hlower : ∀ n x, x ∈ K → ∀ y, y ∈ K → dist x y ≤ L * dist (Pₙ n x) (Pₙ n y))
+    (hA : IsCompact A) (hV : IsOpen V)
+    (hAV : A ⊆ P '' (interior K ∩ V)) :
+    ∃ U : Set ℂ, IsOpen U ∧ A ⊆ U ∧ IsCompact (closure U) ∧
+      closure U ⊆ P '' (interior K ∩ V) ∧
+      (∀ᶠ n in atTop, closure U ⊆ Pₙ n '' (K ∩ V)) ∧
+      (∀ᶠ n in atTop, closure U ⊆ Pₙ n '' interior K) ∧
+      TendstoUniformlyOn (fun n => coordinateInverse (Pₙ n) K)
+        (coordinateInverse P K) atTop (closure U) := by
+  have hlim := lower_lipschitz_uniform_limit Pₙ P K L hconv hlower
+  have hi := lower_lipschitz_injOn P K L hlim
+  have hopen := isOpen_image_coordinate_subset hpublished P K (interior K ∩ V)
+    hP hi (isOpen_interior.inter hV) (inter_subset_left.trans interior_subset)
+  obtain ⟨ρ, hρ, hthick⟩ := hA.exists_cthickening_subset_open hopen hAV
+  let U := thickening ρ A
+  have hcl : closure U ⊆ cthickening ρ A := closure_thickening_subset_cthickening ρ A
+  have hUc : IsCompact (closure U) := hA.cthickening.of_isClosed_subset isClosed_closure hcl
+  have hUPV : closure U ⊆ P '' (interior K ∩ V) := hcl.trans hthick
+  have hUP : closure U ⊆ P '' interior K := hUPV.trans (image_mono inter_subset_left)
+  have hlate := eventual_compact_image_interior hpublished Pₙ P K (closure U) L hL hPn
+    hconv hlower hUc hUP
+  have hUV : coordinateInverse P K '' closure U ⊆ V := by
+    rintro _ ⟨z, hz, rfl⟩
+    obtain ⟨x, hx, he⟩ := hUPV hz
+    have heq : coordinateInverse P K z = x := by
+      rw [← he]
+      exact coordinateInverse_left hi (interior_subset hx.1)
+    simpa only [heq] using hx.2
+  have hcover : ∀ᶠ n in atTop, closure U ⊆ Pₙ n '' K :=
+    hlate.mono (fun _ h => h.trans (image_mono interior_subset))
+  have hregions := eventual_compact_coordinate_region Pₙ P K (closure U) V L hconv hlower
+    hUc (hUP.trans (image_mono interior_subset)) hcover hV hUV
+  exact ⟨U, isOpen_thickening, self_subset_thickening hρ A, hUc, hUPV, hregions, hlate,
+    coordinateInverse_uniform_on Pₙ P K (closure U) L hconv hlower
+      (hUP.trans (image_mono interior_subset)) hcover⟩
+
+/-- Limiting coordinate guides have exact longitudinal progress and retain
+the source transverse margin. -/
+theorem limit_guide_coordinates
+    (P : ℂ → ℂ) (K : Set ℂ) (hi : InjOn P K)
+    (α : ℝ → ℂ) (x : ℝ)
+    (hshape : EqOn α (fun t => P (guideCoordinate 0 x t)) (Icc 0 2))
+    (hmem : ∀ t ∈ Icc (0 : ℝ) 2, guideCoordinate 0 x t ∈ K) :
+    ∀ t ∈ Icc (0 : ℝ) 2,
+      longitudinalCoordinate P K 0 (α t) = t ∧
+        |(coordinateInverse P K (α t)).im| ≤ |x| := by
+  intro t ht
+  rw [hshape ht, coordinateInverse_left hi (hmem t ht)]
+  constructor
+  · simp only [longitudinalCoordinate, coordinateInverse_left hi (hmem t ht),
+      guideCoordinate_re, zero_add, sub_zero]
+  · exact guideCoordinate_im_bound ht.1
+
+end SLEExactGauge.RibbonCoordinates
+
+end
+
+end OAI

lean/OAI/Probability/SLE/Gauge/RibbonPassageScaling.lean

@@ -1,173 +1,173 @@
-import OAI.Probability.SLE.Gauge.UniformFrontPassage
-import Mathlib.MeasureTheory.Measure.Lebesgue.EqHaar
-
-namespace OAI
-
-/-! Positive affine rescaling of the physical one-step passage.  A mesh
-`v` becomes `ell * v`; its normalized sausage mass is multiplied by
-`ell ^ dimension κ`, exactly as in the width-rescaled ribbon statement. -/
-
-noncomputable section
-open Set Filter MeasureTheory Metric
-open scoped Topology NNReal ENNReal Pointwise
-
-namespace SLEExactGauge.RibbonPassageScaling
-open FirstFrontPassage PassageSuccess
-
-/-- Translate and dilate the physical coordinates without changing the
-curve parameter. -/
-def affine (a : ℂ) (ell : ℝ) (z : ℂ) : ℂ := a + (ell : ℂ) * z
-
-theorem affine_dist (a : ℂ) {ell : ℝ} (hell : 0 ≤ ell) (z w : ℂ) :
-    dist (affine a ell z) (affine a ell w) = ell * dist z w := by
-  simp only [affine, dist_eq_norm, add_sub_add_left_eq_sub, ← mul_sub, norm_mul,
-    Complex.norm_real, Real.norm_eq_abs, abs_of_nonneg hell]
-
-theorem affine_bijective (a : ℂ) {ell : ℝ} (hell : 0 < ell) :
-    Function.Bijective (affine a ell) := by
-  have he : (ell : ℂ) ≠ 0 := Complex.ofReal_ne_zero.mpr hell.ne'
-  constructor
-  · intro z w h
-    exact mul_left_cancel₀ he (add_left_cancel h)
-  · intro z
-    refine ⟨(z - a) / (ell : ℂ), ?_⟩
-    dsimp [affine]
-    field_simp
-    ring
-
-/-- Planar area scales by the square of the physical length scale, also
-for sets for which no measurability has been assumed. -/
-theorem affine_volume (a : ℂ) {ell : ℝ} (hell : 0 ≤ ell) (S : Set ℂ) :
-    volume (affine a ell '' S) = ENNReal.ofReal (ell ^ 2) * volume S := by
-  have he : affine a ell '' S = (fun z : ℂ => a + z) '' (ell • S) := by
-    rw [← image_smul, image_image]
-    rfl
-  rw [he, image_add_left, measure_preimage_add, Measure.addHaar_smul_of_nonneg volume hell]
-  rw [Complex.finrank_real_complex]
-
-/-- The full sausage, including its intersection with a physical middle
-strip, scales exactly under a positive affine map. -/
-theorem sourceSausageSet_affine
-    (a : ℂ) {ell : ℝ} (hell : 0 < ell) (γ : ℝ≥0 → ℂ) (s t : ℝ≥0) (v : ℝ) :
-    sourceSausageSet (fun u => affine a ell (γ u)) s t (ell * v) =
-      affine a ell '' sourceSausageSet γ s t v := by
-  ext z
-  obtain ⟨w, rfl⟩ := (affine_bijective a hell).2 z
-  constructor
-  · rintro ⟨u, hu, hd⟩
-    rw [affine_dist a hell.le] at hd
-    exact ⟨w, ⟨u, hu, (mul_lt_mul_iff_right₀ hell).mp hd⟩, rfl⟩
-  · rintro ⟨w', ⟨u, hu, hd⟩, he⟩
-    have hw' : w' = w := (affine_bijective a hell).1 he
-    subst w'
-    exact ⟨u, hu, by rw [affine_dist a hell.le]; exact mul_lt_mul_of_pos_left hd hell⟩
-
-theorem segmentSausageCharge_affine
-    (κ : ℝ) (a : ℂ) {ell : ℝ} (hell : 0 < ell)
-    (γ : ℝ≥0 → ℂ) (s t : ℝ≥0) {v : ℝ} (hv : 0 < v) (R : Set ℂ) :
-    segmentSausageCharge κ (fun u => affine a ell (γ u)) s t (ell * v)
-        (affine a ell '' R) =
-      ENNReal.ofReal (ell ^ dimension κ) * segmentSausageCharge κ γ s t v R := by
-  have he : (ell * v) ^ (-codimension κ) * ell ^ 2 =
-      ell ^ dimension κ * v ^ (-codimension κ) := by
-    rw [Real.mul_rpow hell.le hv.le]
-    calc
-      ell ^ (-codimension κ) * v ^ (-codimension κ) * ell ^ 2 =
-          (ell ^ (-codimension κ) * ell ^ (2 : ℝ)) * v ^ (-codimension κ) := by
-            rw [Real.rpow_two]
-            ring
-      _ = ell ^ (-codimension κ + 2) * v ^ (-codimension κ) := by
-        rw [Real.rpow_add hell]
-      _ = _ := by congr 2; unfold codimension; ring
-  simp only [segmentSausageCharge, sourceSausageSet_affine a hell]
-  rw [← image_inter (affine_bijective a hell).1, affine_volume a hell.le]
-  rw [← mul_assoc, ← ENNReal.ofReal_mul (Real.rpow_nonneg (mul_pos hell hv).le _), he,
-    ENNReal.ofReal_mul (Real.rpow_nonneg hell.le _), mul_assoc]
-
-/-- The prescribed mass threshold scales by `ell^d`. -/
-theorem affine_mass_threshold_iff
-    (κ : ℝ) (a : ℂ) {ell : ℝ} (hell : 0 < ell)
-    (γ : ℝ≥0 → ℂ) (s t : ℝ≥0) {v : ℝ} (hv : 0 < v) (R : Set ℂ) (c : ℝ) :
-    ENNReal.ofReal (c * ell ^ dimension κ) ≤
-        segmentSausageCharge κ (fun u => affine a ell (γ u)) s t (ell * v)
-          (affine a ell '' R) ↔
-      ENNReal.ofReal c ≤ segmentSausageCharge κ γ s t v R := by
-  rw [segmentSausageCharge_affine κ a hell γ s t hv R, mul_comm c,
-    ENNReal.ofReal_mul (Real.rpow_pos_of_pos hell _).le]
-  exact ENNReal.mul_le_mul_iff_right ((ENNReal.ofReal_pos.mpr (Real.rpow_pos_of_pos hell _)).ne')
-    ENNReal.ofReal_ne_top
-
-/-- Pulling back the longitudinal coordinate leaves the actual first-front
-clock unchanged. Spatial rescaling does not change curve order. -/
-theorem firstFrontTime_affine
-    (a : ℂ) (ell : ℝ) (γ : ℝ≥0 → ℂ) (p p' : ℂ → ℝ)
-    (hp : ∀ z, p' (affine a ell z) = p z) :
-    firstFrontTime (fun t => p' (affine a ell (γ t))) 1 =
-      firstFrontTime (fun t => p (γ t)) 1 := by
-  congr 1
-  funext t
-  exact hp (γ t)
-
-/-- Affine scaling preserves all actual front-success conditions, including
-whole-prefix containment and the terminal offset. -/
-theorem frontSuccess_affine_iff
-    {Ω : Type*} (η : ℕ → Ω → ℝ≥0 → ℂ) (p p' : ℕ → ℂ → ℝ)
-    (σ : Ω → ℝ≥0) (V : ℕ → Set ℂ) (b : ℕ → ℂ) (ε : ℝ)
-    (a : ℂ) {ell : ℝ} (hell : 0 < ell) (n : ℕ)
-    (hp : ∀ z, p' n (affine a ell z) = p n z) :
-    FrontSuccess (fun j ω t => affine a ell (η j ω t)) p' σ
-        (fun j => affine a ell '' V j) (fun j => affine a ell (b j)) (ell * ε) n =
-      FrontSuccess η p σ V b ε n := by
-  ext ω
-  have hmaps (T : ℝ≥0) :
-      MapsTo (fun t => affine a ell (η n ω t)) (Icc 0 T) (affine a ell '' V n) ↔
-        MapsTo (η n ω) (Icc 0 T) (V n) := by
-    constructor
-    · intro h t ht
-      obtain ⟨z, hz, he⟩ := h ht
-      exact (affine_bijective a hell).1 he ▸ hz
-    · intro h t ht
-      exact mem_image_of_mem _ (h ht)
-  have hterminal (T : ℝ≥0) :
-      ‖affine a ell (η n ω T) - affine a ell (b n)‖ < ell * ε / 4 ↔
-        ‖η n ω T - b n‖ < ε / 4 := by
-    have hd := affine_dist a hell.le (η n ω T) (b n)
-    rw [dist_eq_norm, dist_eq_norm] at hd
-    rw [hd, mul_div_assoc, mul_lt_mul_iff_right₀ hell]
-  simp only [FrontSuccess, mem_ofPred_eq, hp, hmaps, hterminal]
-
-/-- The complete one-step event has the same probability after simultaneous
-spatial, mesh and mass rescaling. This is a deterministic event identity;
-the trace law need not itself have been scaled. -/
-theorem frontSuccess_mass_probability_affine
-    {Ω : Type*} [MeasurableSpace Ω] (P : Measure Ω)
-    (η : ℕ → Ω → ℝ≥0 → ℂ) (p p' : ℕ → ℂ → ℝ)
-    (σ : Ω → ℝ≥0) (V : ℕ → Set ℂ) (b : ℕ → ℂ) (ε : ℝ)
-    (a : ℂ) {ell : ℝ} (hell : 0 < ell) (n : ℕ)
-    (hp : ∀ z, p' n (affine a ell z) = p n z)
-    (κ : ℝ) (R : Set ℂ) {v : ℝ} (hv : 0 < v) (c : ℝ) :
-    P {ω | ω ∈ FrontSuccess (fun j ω t => affine a ell (η j ω t)) p' σ
-          (fun j => affine a ell '' V j) (fun j => affine a ell (b j)) (ell * ε) n ∧
-        ENNReal.ofReal (c * ell ^ dimension κ) ≤
-          segmentSausageCharge κ (fun t => affine a ell (η n ω t)) (σ ω)
-            (frontTime (fun t => p' n (affine a ell (η n ω t))) 1)
-            (ell * v) (affine a ell '' R)} =
-      P {ω | ω ∈ FrontSuccess η p σ V b ε n ∧ ENNReal.ofReal c ≤
-        segmentSausageCharge κ (η n ω) (σ ω)
-          (frontTime (fun t => p n (η n ω t)) 1) v R} := by
-  congr 1
-  ext ω
-  have hevent := frontSuccess_affine_iff η p p' σ V b ε a hell n hp
-  have ht : frontTime (fun t => p' n (affine a ell (η n ω t))) 1 =
-      frontTime (fun t => p n (η n ω t)) 1 := by
-    congr 1
-    funext t
-    exact hp (η n ω t)
-  simp only [mem_ofPred_eq, hevent, ht,
-    affine_mass_threshold_iff κ a hell (η n ω) (σ ω) _ hv R c]
-
-end SLEExactGauge.RibbonPassageScaling
-
-end
-
-end OAI
+import OAI.Probability.SLE.Gauge.UniformFrontPassage
+import Mathlib.MeasureTheory.Measure.Lebesgue.EqHaar
+
+namespace OAI
+
+/-! Positive affine rescaling of the physical one-step passage.  A mesh
+`v` becomes `ell * v`; its normalized sausage mass is multiplied by
+`ell ^ dimension κ`, exactly as in the width-rescaled ribbon statement. -/
+
+noncomputable section
+open Set Filter MeasureTheory Metric
+open scoped Topology NNReal ENNReal Pointwise
+
+namespace SLEExactGauge.RibbonPassageScaling
+open FirstFrontPassage PassageSuccess
+
+/-- Translate and dilate the physical coordinates without changing the
+curve parameter. -/
+def affine (a : ℂ) (ell : ℝ) (z : ℂ) : ℂ := a + (ell : ℂ) * z
+
+theorem affine_dist (a : ℂ) {ell : ℝ} (hell : 0 ≤ ell) (z w : ℂ) :
+    dist (affine a ell z) (affine a ell w) = ell * dist z w := by
+  simp only [affine, dist_eq_norm, add_sub_add_left_eq_sub, ← mul_sub, norm_mul,
+    Complex.norm_real, Real.norm_eq_abs, abs_of_nonneg hell]
+
+theorem affine_bijective (a : ℂ) {ell : ℝ} (hell : 0 < ell) :
+    Function.Bijective (affine a ell) := by
+  have he : (ell : ℂ) ≠ 0 := Complex.ofReal_ne_zero.mpr hell.ne'
+  constructor
+  · intro z w h
+    exact mul_left_cancel₀ he (add_left_cancel h)
+  · intro z
+    refine ⟨(z - a) / (ell : ℂ), ?_⟩
+    dsimp [affine]
+    field_simp
+    ring
+
+/-- Planar area scales by the square of the physical length scale, also
+for sets for which no measurability has been assumed. -/
+theorem affine_volume (a : ℂ) {ell : ℝ} (hell : 0 ≤ ell) (S : Set ℂ) :
+    volume (affine a ell '' S) = ENNReal.ofReal (ell ^ 2) * volume S := by
+  have he : affine a ell '' S = (fun z : ℂ => a + z) '' (ell • S) := by
+    rw [← image_smul, image_image]
+    rfl
+  rw [he, image_add_left, measure_preimage_add, Measure.addHaar_smul_of_nonneg volume hell]
+  rw [Complex.finrank_real_complex]
+
+/-- The full sausage, including its intersection with a physical middle
+strip, scales exactly under a positive affine map. -/
+theorem sourceSausageSet_affine
+    (a : ℂ) {ell : ℝ} (hell : 0 < ell) (γ : ℝ≥0 → ℂ) (s t : ℝ≥0) (v : ℝ) :
+    sourceSausageSet (fun u => affine a ell (γ u)) s t (ell * v) =
+      affine a ell '' sourceSausageSet γ s t v := by
+  ext z
+  obtain ⟨w, rfl⟩ := (affine_bijective a hell).2 z
+  constructor
+  · rintro ⟨u, hu, hd⟩
+    rw [affine_dist a hell.le] at hd
+    exact ⟨w, ⟨u, hu, (mul_lt_mul_iff_right₀ hell).mp hd⟩, rfl⟩
+  · rintro ⟨w', ⟨u, hu, hd⟩, he⟩
+    have hw' : w' = w := (affine_bijective a hell).1 he
+    subst w'
+    exact ⟨u, hu, by rw [affine_dist a hell.le]; exact mul_lt_mul_of_pos_left hd hell⟩
+
+theorem segmentSausageCharge_affine
+    (κ : ℝ) (a : ℂ) {ell : ℝ} (hell : 0 < ell)
+    (γ : ℝ≥0 → ℂ) (s t : ℝ≥0) {v : ℝ} (hv : 0 < v) (R : Set ℂ) :
+    segmentSausageCharge κ (fun u => affine a ell (γ u)) s t (ell * v)
+        (affine a ell '' R) =
+      ENNReal.ofReal (ell ^ dimension κ) * segmentSausageCharge κ γ s t v R := by
+  have he : (ell * v) ^ (-codimension κ) * ell ^ 2 =
+      ell ^ dimension κ * v ^ (-codimension κ) := by
+    rw [Real.mul_rpow hell.le hv.le]
+    calc
+      ell ^ (-codimension κ) * v ^ (-codimension κ) * ell ^ 2 =
+          (ell ^ (-codimension κ) * ell ^ (2 : ℝ)) * v ^ (-codimension κ) := by
+            rw [Real.rpow_two]
+            ring
+      _ = ell ^ (-codimension κ + 2) * v ^ (-codimension κ) := by
+        rw [Real.rpow_add hell]
+      _ = _ := by congr 2; unfold codimension; ring
+  simp only [segmentSausageCharge, sourceSausageSet_affine a hell]
+  rw [← image_inter (affine_bijective a hell).1, affine_volume a hell.le]
+  rw [← mul_assoc, ← ENNReal.ofReal_mul (Real.rpow_nonneg (mul_pos hell hv).le _), he,
+    ENNReal.ofReal_mul (Real.rpow_nonneg hell.le _), mul_assoc]
+
+/-- The prescribed mass threshold scales by `ell^d`. -/
+theorem affine_mass_threshold_iff
+    (κ : ℝ) (a : ℂ) {ell : ℝ} (hell : 0 < ell)
+    (γ : ℝ≥0 → ℂ) (s t : ℝ≥0) {v : ℝ} (hv : 0 < v) (R : Set ℂ) (c : ℝ) :
+    ENNReal.ofReal (c * ell ^ dimension κ) ≤
+        segmentSausageCharge κ (fun u => affine a ell (γ u)) s t (ell * v)
+          (affine a ell '' R) ↔
+      ENNReal.ofReal c ≤ segmentSausageCharge κ γ s t v R := by
+  rw [segmentSausageCharge_affine κ a hell γ s t hv R, mul_comm c,
+    ENNReal.ofReal_mul (Real.rpow_pos_of_pos hell _).le]
+  exact ENNReal.mul_le_mul_iff_right ((ENNReal.ofReal_pos.mpr (Real.rpow_pos_of_pos hell _)).ne')
+    ENNReal.ofReal_ne_top
+
+/-- Pulling back the longitudinal coordinate leaves the actual first-front
+clock unchanged. Spatial rescaling does not change curve order. -/
+theorem firstFrontTime_affine
+    (a : ℂ) (ell : ℝ) (γ : ℝ≥0 → ℂ) (p p' : ℂ → ℝ)
+    (hp : ∀ z, p' (affine a ell z) = p z) :
+    firstFrontTime (fun t => p' (affine a ell (γ t))) 1 =
+      firstFrontTime (fun t => p (γ t)) 1 := by
+  congr 1
+  funext t
+  exact hp (γ t)
+
+/-- Affine scaling preserves all actual front-success conditions, including
+whole-prefix containment and the terminal offset. -/
+theorem frontSuccess_affine_iff
+    {Ω : Type*} (η : ℕ → Ω → ℝ≥0 → ℂ) (p p' : ℕ → ℂ → ℝ)
+    (σ : Ω → ℝ≥0) (V : ℕ → Set ℂ) (b : ℕ → ℂ) (ε : ℝ)
+    (a : ℂ) {ell : ℝ} (hell : 0 < ell) (n : ℕ)
+    (hp : ∀ z, p' n (affine a ell z) = p n z) :
+    FrontSuccess (fun j ω t => affine a ell (η j ω t)) p' σ
+        (fun j => affine a ell '' V j) (fun j => affine a ell (b j)) (ell * ε) n =
+      FrontSuccess η p σ V b ε n := by
+  ext ω
+  have hmaps (T : ℝ≥0) :
+      MapsTo (fun t => affine a ell (η n ω t)) (Icc 0 T) (affine a ell '' V n) ↔
+        MapsTo (η n ω) (Icc 0 T) (V n) := by
+    constructor
+    · intro h t ht
+      obtain ⟨z, hz, he⟩ := h ht
+      exact (affine_bijective a hell).1 he ▸ hz
+    · intro h t ht
+      exact mem_image_of_mem _ (h ht)
+  have hterminal (T : ℝ≥0) :
+      ‖affine a ell (η n ω T) - affine a ell (b n)‖ < ell * ε / 4 ↔
+        ‖η n ω T - b n‖ < ε / 4 := by
+    have hd := affine_dist a hell.le (η n ω T) (b n)
+    rw [dist_eq_norm, dist_eq_norm] at hd
+    rw [hd, mul_div_assoc, mul_lt_mul_iff_right₀ hell]
+  simp only [FrontSuccess, mem_ofPred_eq, hp, hmaps, hterminal]
+
+/-- The complete one-step event has the same probability after simultaneous
+spatial, mesh and mass rescaling. This is a deterministic event identity;
+the trace law need not itself have been scaled. -/
+theorem frontSuccess_mass_probability_affine
+    {Ω : Type*} [MeasurableSpace Ω] (P : Measure Ω)
+    (η : ℕ → Ω → ℝ≥0 → ℂ) (p p' : ℕ → ℂ → ℝ)
+    (σ : Ω → ℝ≥0) (V : ℕ → Set ℂ) (b : ℕ → ℂ) (ε : ℝ)
+    (a : ℂ) {ell : ℝ} (hell : 0 < ell) (n : ℕ)
+    (hp : ∀ z, p' n (affine a ell z) = p n z)
+    (κ : ℝ) (R : Set ℂ) {v : ℝ} (hv : 0 < v) (c : ℝ) :
+    P {ω | ω ∈ FrontSuccess (fun j ω t => affine a ell (η j ω t)) p' σ
+          (fun j => affine a ell '' V j) (fun j => affine a ell (b j)) (ell * ε) n ∧
+        ENNReal.ofReal (c * ell ^ dimension κ) ≤
+          segmentSausageCharge κ (fun t => affine a ell (η n ω t)) (σ ω)
+            (frontTime (fun t => p' n (affine a ell (η n ω t))) 1)
+            (ell * v) (affine a ell '' R)} =
+      P {ω | ω ∈ FrontSuccess η p σ V b ε n ∧ ENNReal.ofReal c ≤
+        segmentSausageCharge κ (η n ω) (σ ω)
+          (frontTime (fun t => p n (η n ω t)) 1) v R} := by
+  congr 1
+  ext ω
+  have hevent := frontSuccess_affine_iff η p p' σ V b ε a hell n hp
+  have ht : frontTime (fun t => p' n (affine a ell (η n ω t))) 1 =
+      frontTime (fun t => p n (η n ω t)) 1 := by
+    congr 1
+    funext t
+    exact hp (η n ω t)
+  simp only [mem_ofPred_eq, hevent, ht,
+    affine_mass_threshold_iff κ a hell (η n ω) (σ ω) _ hv R c]
+
+end SLEExactGauge.RibbonPassageScaling
+
+end
+
+end OAI

lean/OAI/Probability/SLE/Gauge/RibbonPrefixTransport.lean

@@ -1,67 +1,67 @@
-import OAI.Probability.SLE.Gauge.WholeSausageScaling
-import OAI.Probability.SLE.Gauge.RibbonGoodPrefix
-
-namespace OAI
-
-/-! A successful narrow physical prefix is preserved by the exact SLE
-spatial/capacity scaling. The front is transported as its actual first hit,
-not chosen as a separate completion certificate. -/
-
-noncomputable section
-open Set Filter MeasureTheory
-open scoped Topology NNReal ENNReal
-
-namespace SLEExactGauge
-open RibbonCoordinates FirstFrontPassage FrontClockChange ScaleTraceLaw FrontSuccessMeasurability
-
-lemma scalePath_at_scaled_time (c : ℝ≥0) (hc : 0 < c) (p : C(ℝ≥0, ℂ)) (t : ℝ≥0) :
-    scalePath c p (c ^ 2 * t) = (c : ℂ) * p t := by
-  change (c : ℂ) * p ((c ^ 2 * t) / c ^ 2) = _
-  rw [mul_div_cancel_left₀ t (pow_ne_zero 2 hc.ne')]
-
-theorem goodRibbonPrefix_scalePath
-    (c : ℝ≥0) (hc : 0 < c) (p : C(ℝ≥0, ℂ)) (P : ℂ → ℂ)
-    (g g' : C(ℂ, ℝ)) (hgg' : ∀ z : ℂ, g' ((c : ℂ) * z) = g z)
-    (k ε : ℝ)
-    (hpref : () ∈ GoodRibbonPrefix (fun _ : Unit => (p : ℝ≥0 → ℂ))
-      (fun _ => firstFrontTime (fun t => g (p t)) k) P ε) :
-    () ∈ GoodRibbonPrefix (fun _ : Unit => (scalePath c p : ℝ≥0 → ℂ))
-      (fun _ => firstFrontTime (fun t => g' (scalePath c p t)) k)
-      (fun z => (c : ℂ) * P z) ε := by
-  cases hτ : firstFrontTime (fun t => g (p t)) k with
-  | top => exact False.elim (hpref.1 hτ)
-  | coe T =>
-    let e := OrderIso.mulLeft₀ (c ^ 2) (pow_pos hc 2)
-    have heval (t : ℝ≥0) : scalePath c p (e t) = (c : ℂ) * p t :=
-      scalePath_at_scaled_time c hc p t
-    have hclock : (fun t => g' (scalePath c p (e t))) = (fun t => g (p t)) := by
-      funext t
-      rw [heval, hgg']
-    have hhit := firstFrontTime_attained _ (g.continuous.comp p.continuous) k T hτ
-    have hnew := firstFrontTime_of_clock_hit e (fun t => g' (scalePath c p t)) k T
-      (by rw [hclock]; exact hτ) (by rw [heval, hgg']; exact hhit)
-    have hprefix : MapsTo p (Icc 0 T) (ribbonCore P ε) := by
-      simpa only [hτ, WithTop.untopD_coe] using hpref.2.1
-    have hend : p T ∈ ribbonCore P (ε / 4) := by
-      simpa only [hτ, WithTop.untopD_coe] using hpref.2.2
-    change firstFrontTime (fun t => g' (scalePath c p t)) k ≠ ⊤ ∧ _
-    rw [hnew]
-    refine ⟨WithTop.coe_ne_top, ?_, ?_⟩
-    · intro t ht
-      have htt : t ≤ e T := by simpa only [WithTop.untopD_coe] using ht.2
-      have hu : e.symm t ∈ Icc 0 T := ⟨bot_le, by
-        simpa only [e.symm_apply_apply] using e.symm.monotone htt⟩
-      obtain ⟨z, hz, hez⟩ := hprefix hu
-      refine ⟨z, hz, ?_⟩
-      change (c : ℂ) * P z = scalePath c p t
-      rw [hez, ← heval, e.apply_symm_apply]
-    · obtain ⟨z, hz, hez⟩ := hend
-      refine ⟨z, hz, ?_⟩
-      change (c : ℂ) * P z = scalePath c p (e T)
-      rw [heval, hez]
-
-end SLEExactGauge
-
-end
-
-end OAI
+import OAI.Probability.SLE.Gauge.WholeSausageScaling
+import OAI.Probability.SLE.Gauge.RibbonGoodPrefix
+
+namespace OAI
+
+/-! A successful narrow physical prefix is preserved by the exact SLE
+spatial/capacity scaling. The front is transported as its actual first hit,
+not chosen as a separate completion certificate. -/
+
+noncomputable section
+open Set Filter MeasureTheory
+open scoped Topology NNReal ENNReal
+
+namespace SLEExactGauge
+open RibbonCoordinates FirstFrontPassage FrontClockChange ScaleTraceLaw FrontSuccessMeasurability
+
+lemma scalePath_at_scaled_time (c : ℝ≥0) (hc : 0 < c) (p : C(ℝ≥0, ℂ)) (t : ℝ≥0) :
+    scalePath c p (c ^ 2 * t) = (c : ℂ) * p t := by
+  change (c : ℂ) * p ((c ^ 2 * t) / c ^ 2) = _
+  rw [mul_div_cancel_left₀ t (pow_ne_zero 2 hc.ne')]
+
+theorem goodRibbonPrefix_scalePath
+    (c : ℝ≥0) (hc : 0 < c) (p : C(ℝ≥0, ℂ)) (P : ℂ → ℂ)
+    (g g' : C(ℂ, ℝ)) (hgg' : ∀ z : ℂ, g' ((c : ℂ) * z) = g z)
+    (k ε : ℝ)
+    (hpref : () ∈ GoodRibbonPrefix (fun _ : Unit => (p : ℝ≥0 → ℂ))
+      (fun _ => firstFrontTime (fun t => g (p t)) k) P ε) :
+    () ∈ GoodRibbonPrefix (fun _ : Unit => (scalePath c p : ℝ≥0 → ℂ))
+      (fun _ => firstFrontTime (fun t => g' (scalePath c p t)) k)
+      (fun z => (c : ℂ) * P z) ε := by
+  cases hτ : firstFrontTime (fun t => g (p t)) k with
+  | top => exact False.elim (hpref.1 hτ)
+  | coe T =>
+    let e := OrderIso.mulLeft₀ (c ^ 2) (pow_pos hc 2)
+    have heval (t : ℝ≥0) : scalePath c p (e t) = (c : ℂ) * p t :=
+      scalePath_at_scaled_time c hc p t
+    have hclock : (fun t => g' (scalePath c p (e t))) = (fun t => g (p t)) := by
+      funext t
+      rw [heval, hgg']
+    have hhit := firstFrontTime_attained _ (g.continuous.comp p.continuous) k T hτ
+    have hnew := firstFrontTime_of_clock_hit e (fun t => g' (scalePath c p t)) k T
+      (by rw [hclock]; exact hτ) (by rw [heval, hgg']; exact hhit)
+    have hprefix : MapsTo p (Icc 0 T) (ribbonCore P ε) := by
+      simpa only [hτ, WithTop.untopD_coe] using hpref.2.1
+    have hend : p T ∈ ribbonCore P (ε / 4) := by
+      simpa only [hτ, WithTop.untopD_coe] using hpref.2.2
+    change firstFrontTime (fun t => g' (scalePath c p t)) k ≠ ⊤ ∧ _
+    rw [hnew]
+    refine ⟨WithTop.coe_ne_top, ?_, ?_⟩
+    · intro t ht
+      have htt : t ≤ e T := by simpa only [WithTop.untopD_coe] using ht.2
+      have hu : e.symm t ∈ Icc 0 T := ⟨bot_le, by
+        simpa only [e.symm_apply_apply] using e.symm.monotone htt⟩
+      obtain ⟨z, hz, hez⟩ := hprefix hu
+      refine ⟨z, hz, ?_⟩
+      change (c : ℂ) * P z = scalePath c p t
+      rw [hez, ← heval, e.apply_symm_apply]
+    · obtain ⟨z, hz, hez⟩ := hend
+      refine ⟨z, hz, ?_⟩
+      change (c : ℂ) * P z = scalePath c p (e T)
+      rw [heval, hez]
+
+end SLEExactGauge
+
+end
+
+end OAI

lean/OAI/Probability/SLE/Gauge/RibbonRouteLifting.lean

@@ -1,116 +1,116 @@
-import OAI.Probability.SLE.Gauge.RibbonCoordinateGeometry
-import OAI.Probability.SLE.Geometry.RobustTransverseCrossing
-
-namespace OAI
-
-/-! Physical perturbations of a transverse ribbon route admit continuous
-coordinate lifts. The fixed inverse Lipschitz bound then turns a physical
-tube event into a forced hit of the actual stopped past. -/
-
-noncomputable section
-open Set Metric Function
-open scoped Topology NNReal
-
-namespace SLEExactGauge.RibbonCoordinates
-open RectangleCrossing
-
-theorem inverse_coordinate_lipschitz
-    (P : ℂ → ℂ) (S : Set ℂ) (K : ℝ≥0)
-    (hlower : ∀ u ∈ S, ∀ v ∈ S, dist u v ≤ K * dist (P u) (P v)) :
-    LipschitzOnWith K (invFunOn P S) (P '' S) := by
-  apply lipschitzOnWith_iff_dist_le_mul.mpr
-  intro u hu v hv
-  have hh := hlower _ (invFunOn_mem hu) _ (invFunOn_mem hv)
-  simpa only [invFunOn_eq hu, invFunOn_eq hv] using hh
-
-/-- Invariance of domain supplies a physical tube; the patch inverse is
-continuous with exactly the given inverse Lipschitz bound. -/
-theorem physical_tube_has_coordinate_lift
-    (hpublished : PublishedPlanarDiskOpenness)
-    (P : ℂ → ℂ) (S : Set ℂ) (hP : ContinuousOn P S) (hi : InjOn P S)
-    (K : ℝ≥0) (hK : 0 < (K : ℝ))
-    (hlower : ∀ u ∈ S, ∀ v ∈ S, dist u v ≤ K * dist (P u) (P v))
-    (ξ ζ : ℝ → ℂ) (I : Set ℝ) {r : ℝ} (hr : 0 < r)
-    (hξ : ∀ t ∈ I, closedBall (ξ t) r ⊆ S)
-    (hζ : ContinuousOn ζ I)
-    (hnear : ∀ t ∈ I, dist (ζ t) (P (ξ t)) < r / K) :
-    let q := invFunOn P S ∘ ζ
-    ContinuousOn q I ∧ MapsTo q I S ∧ EqOn (P ∘ q) ζ I ∧
-      ∀ t ∈ I, dist (q t) (ξ t) < r := by
-  have hlift t (ht : t ∈ I) :
-      ∃ z ∈ ball (ξ t) r, P z = ζ t := by
-    apply ball_subset_image_ball P (ξ t) hr hK (hP.mono (hξ t ht))
-      (hpublished P _ _ hr (hP.mono (ball_subset_closedBall.trans (hξ t ht)))
-        (hi.mono (ball_subset_closedBall.trans (hξ t ht))))
-      (fun z hz => hlower z (hξ t ht hz) _ (hξ t ht (mem_closedBall_self hr.le)))
-    exact hnear t ht
-  have hζS : MapsTo ζ I (P '' S) := by
-    intro t ht
-    obtain ⟨z, hz, he⟩ := hlift t ht
-    exact ⟨z, hξ t ht (ball_subset_closedBall hz), he⟩
-  dsimp only
-  refine ⟨(inverse_coordinate_lipschitz P S K hlower).continuousOn.comp hζ hζS,
-    (fun t ht => invFunOn_mem (hζS ht)), (fun t ht => invFunOn_eq (hζS ht)), ?_⟩
-  intro t ht
-  obtain ⟨z, hz, he⟩ := hlift t ht
-  have hzS := hξ t ht (ball_subset_closedBall hz)
-  have heq : invFunOn P S (ζ t) = z :=
-    hi (invFunOn_mem (hζS ht)) hzS ((invFunOn_eq (hζS ht)).trans he.symm)
-  simpa only [Function.comp_apply, heq, mem_ball] using hz
-
-def crossingPatch (k : ℝ) : Set ℂ :=
-  {z | k - 1 ≤ z.re ∧ z.re ≤ k + 1 ∧ |z.im| ≤ 1}
-
-theorem crossingPatch_subset_closedRibbon {k : ℝ} (hk : 1 ≤ k) :
-    crossingPatch k ⊆ closedRibbon := by
-  intro z hz
-  exact ⟨by linarith [hz.1], hz.2.2⟩
-
-theorem transverse_template_ball_subset_patch (k : ℝ) {t : ℝ} (ht : t ∈ Icc (0 : ℝ) 1) :
-    closedBall (transverseTemplate k t) (1 / 8) ⊆ crossingPatch k := by
-  intro z hz
-  have hn : ‖z - transverseTemplate k t‖ ≤ 1 / 8 := by
-    simpa only [mem_closedBall, dist_eq_norm] using hz
-  have hre := (Complex.abs_re_le_norm (z - transverseTemplate k t)).trans hn
-  have him := (Complex.abs_im_le_norm (z - transverseTemplate k t)).trans hn
-  simp only [Complex.sub_re, Complex.sub_im, transverseTemplate, Complex.add_re,
-    Complex.add_im, Complex.ofReal_re, Complex.ofReal_im, Complex.mul_re,
-    Complex.mul_im, Complex.I_re, Complex.I_im, mul_zero, mul_one,
-    add_zero, zero_add, sub_zero] at hre him
-  have hr := abs_le.mp hre
-  have hi := abs_le.mp him
-  refine ⟨by linarith, by linarith, abs_le.mpr ⟨by linarith [ht.1], by linarith [ht.2]⟩⟩
-
-/-- A single physical tube radius, independent of the past, forces a hit.
-Every coordinate and continuity condition for the perturbed route is
-derived from the actual patch embedding rather than assumed. -/
-theorem physical_transverse_tube_hits_past
-    (hpublished : PublishedPlanarDiskOpenness)
-    (P : ℂ → ℂ) (hP : ContinuousOn P closedRibbon) (hi : InjOn P closedRibbon)
-    (K : ℝ≥0) (hK : 0 < (K : ℝ)) {k ε T : ℝ}
-    (hk : 1 ≤ k) (hε : 0 < ε) (hεsmall : ε ≤ 1 / 8) (hT : 0 < T)
-    (hlower : ∀ u ∈ crossingPatch k, ∀ v ∈ crossingPatch k,
-      dist u v ≤ K * dist (P u) (P v))
-    (γ xp ζ : ℝ → ℂ) (hxp : ContinuousOn xp (Icc 0 T))
-    (hγ : EqOn γ (P ∘ xp) (Icc 0 T))
-    (hxp0 : (xp 0).re = 0) (hxpT : (xp T).re = k)
-    (hcore : ∀ t ∈ Icc (0 : ℝ) T, |(xp t).im| ≤ ε)
-    (hζ : ContinuousOn ζ (Icc 0 1))
-    (hnear : ∀ t ∈ Icc (0 : ℝ) 1,
-      dist (ζ t) (P (transverseTemplate k t)) < (1 / 8 : ℝ) / K) :
-    ∃ s ∈ Icc (0 : ℝ) T, ∃ t ∈ Icc (0 : ℝ) 1, γ s = ζ t := by
-  have hsub := crossingPatch_subset_closedRibbon hk
-  obtain ⟨hq, _, hmap, hnearq⟩ := physical_tube_has_coordinate_lift hpublished
-    P (crossingPatch k) (hP.mono hsub) (hi.mono hsub) K hK hlower
-    (transverseTemplate k) ζ (Icc 0 1) (by norm_num : (0 : ℝ) < 1 / 8)
-    (fun _ ht => transverse_template_ball_subset_patch k ht) hζ hnear
-  obtain ⟨s, hs, t, ht, he⟩ := near_transverse_template_hits_past xp
-    (invFunOn P (crossingPatch k) ∘ ζ) hT hk hε hεsmall le_rfl hxp hq
-    hxp0 hxpT hcore hnearq
-  exact ⟨s, hs, t, ht, (hγ hs).trans ((congrArg P he).trans (hmap ht))⟩
-
-end SLEExactGauge.RibbonCoordinates
-
-end
-
-end OAI
+import OAI.Probability.SLE.Gauge.RibbonCoordinateGeometry
+import OAI.Probability.SLE.Geometry.RobustTransverseCrossing
+
+namespace OAI
+
+/-! Physical perturbations of a transverse ribbon route admit continuous
+coordinate lifts. The fixed inverse Lipschitz bound then turns a physical
+tube event into a forced hit of the actual stopped past. -/
+
+noncomputable section
+open Set Metric Function
+open scoped Topology NNReal
+
+namespace SLEExactGauge.RibbonCoordinates
+open RectangleCrossing
+
+theorem inverse_coordinate_lipschitz
+    (P : ℂ → ℂ) (S : Set ℂ) (K : ℝ≥0)
+    (hlower : ∀ u ∈ S, ∀ v ∈ S, dist u v ≤ K * dist (P u) (P v)) :
+    LipschitzOnWith K (invFunOn P S) (P '' S) := by
+  apply lipschitzOnWith_iff_dist_le_mul.mpr
+  intro u hu v hv
+  have hh := hlower _ (invFunOn_mem hu) _ (invFunOn_mem hv)
+  simpa only [invFunOn_eq hu, invFunOn_eq hv] using hh
+
+/-- Invariance of domain supplies a physical tube; the patch inverse is
+continuous with exactly the given inverse Lipschitz bound. -/
+theorem physical_tube_has_coordinate_lift
+    (hpublished : PublishedPlanarDiskOpenness)
+    (P : ℂ → ℂ) (S : Set ℂ) (hP : ContinuousOn P S) (hi : InjOn P S)
+    (K : ℝ≥0) (hK : 0 < (K : ℝ))
+    (hlower : ∀ u ∈ S, ∀ v ∈ S, dist u v ≤ K * dist (P u) (P v))
+    (ξ ζ : ℝ → ℂ) (I : Set ℝ) {r : ℝ} (hr : 0 < r)
+    (hξ : ∀ t ∈ I, closedBall (ξ t) r ⊆ S)
+    (hζ : ContinuousOn ζ I)
+    (hnear : ∀ t ∈ I, dist (ζ t) (P (ξ t)) < r / K) :
+    let q := invFunOn P S ∘ ζ
+    ContinuousOn q I ∧ MapsTo q I S ∧ EqOn (P ∘ q) ζ I ∧
+      ∀ t ∈ I, dist (q t) (ξ t) < r := by
+  have hlift t (ht : t ∈ I) :
+      ∃ z ∈ ball (ξ t) r, P z = ζ t := by
+    apply ball_subset_image_ball P (ξ t) hr hK (hP.mono (hξ t ht))
+      (hpublished P _ _ hr (hP.mono (ball_subset_closedBall.trans (hξ t ht)))
+        (hi.mono (ball_subset_closedBall.trans (hξ t ht))))
+      (fun z hz => hlower z (hξ t ht hz) _ (hξ t ht (mem_closedBall_self hr.le)))
+    exact hnear t ht
+  have hζS : MapsTo ζ I (P '' S) := by
+    intro t ht
+    obtain ⟨z, hz, he⟩ := hlift t ht
+    exact ⟨z, hξ t ht (ball_subset_closedBall hz), he⟩
+  dsimp only
+  refine ⟨(inverse_coordinate_lipschitz P S K hlower).continuousOn.comp hζ hζS,
+    (fun t ht => invFunOn_mem (hζS ht)), (fun t ht => invFunOn_eq (hζS ht)), ?_⟩
+  intro t ht
+  obtain ⟨z, hz, he⟩ := hlift t ht
+  have hzS := hξ t ht (ball_subset_closedBall hz)
+  have heq : invFunOn P S (ζ t) = z :=
+    hi (invFunOn_mem (hζS ht)) hzS ((invFunOn_eq (hζS ht)).trans he.symm)
+  simpa only [Function.comp_apply, heq, mem_ball] using hz
+
+def crossingPatch (k : ℝ) : Set ℂ :=
+  {z | k - 1 ≤ z.re ∧ z.re ≤ k + 1 ∧ |z.im| ≤ 1}
+
+theorem crossingPatch_subset_closedRibbon {k : ℝ} (hk : 1 ≤ k) :
+    crossingPatch k ⊆ closedRibbon := by
+  intro z hz
+  exact ⟨by linarith [hz.1], hz.2.2⟩
+
+theorem transverse_template_ball_subset_patch (k : ℝ) {t : ℝ} (ht : t ∈ Icc (0 : ℝ) 1) :
+    closedBall (transverseTemplate k t) (1 / 8) ⊆ crossingPatch k := by
+  intro z hz
+  have hn : ‖z - transverseTemplate k t‖ ≤ 1 / 8 := by
+    simpa only [mem_closedBall, dist_eq_norm] using hz
+  have hre := (Complex.abs_re_le_norm (z - transverseTemplate k t)).trans hn
+  have him := (Complex.abs_im_le_norm (z - transverseTemplate k t)).trans hn
+  simp only [Complex.sub_re, Complex.sub_im, transverseTemplate, Complex.add_re,
+    Complex.add_im, Complex.ofReal_re, Complex.ofReal_im, Complex.mul_re,
+    Complex.mul_im, Complex.I_re, Complex.I_im, mul_zero, mul_one,
+    add_zero, zero_add, sub_zero] at hre him
+  have hr := abs_le.mp hre
+  have hi := abs_le.mp him
+  refine ⟨by linarith, by linarith, abs_le.mpr ⟨by linarith [ht.1], by linarith [ht.2]⟩⟩
+
+/-- A single physical tube radius, independent of the past, forces a hit.
+Every coordinate and continuity condition for the perturbed route is
+derived from the actual patch embedding rather than assumed. -/
+theorem physical_transverse_tube_hits_past
+    (hpublished : PublishedPlanarDiskOpenness)
+    (P : ℂ → ℂ) (hP : ContinuousOn P closedRibbon) (hi : InjOn P closedRibbon)
+    (K : ℝ≥0) (hK : 0 < (K : ℝ)) {k ε T : ℝ}
+    (hk : 1 ≤ k) (hε : 0 < ε) (hεsmall : ε ≤ 1 / 8) (hT : 0 < T)
+    (hlower : ∀ u ∈ crossingPatch k, ∀ v ∈ crossingPatch k,
+      dist u v ≤ K * dist (P u) (P v))
+    (γ xp ζ : ℝ → ℂ) (hxp : ContinuousOn xp (Icc 0 T))
+    (hγ : EqOn γ (P ∘ xp) (Icc 0 T))
+    (hxp0 : (xp 0).re = 0) (hxpT : (xp T).re = k)
+    (hcore : ∀ t ∈ Icc (0 : ℝ) T, |(xp t).im| ≤ ε)
+    (hζ : ContinuousOn ζ (Icc 0 1))
+    (hnear : ∀ t ∈ Icc (0 : ℝ) 1,
+      dist (ζ t) (P (transverseTemplate k t)) < (1 / 8 : ℝ) / K) :
+    ∃ s ∈ Icc (0 : ℝ) T, ∃ t ∈ Icc (0 : ℝ) 1, γ s = ζ t := by
+  have hsub := crossingPatch_subset_closedRibbon hk
+  obtain ⟨hq, _, hmap, hnearq⟩ := physical_tube_has_coordinate_lift hpublished
+    P (crossingPatch k) (hP.mono hsub) (hi.mono hsub) K hK hlower
+    (transverseTemplate k) ζ (Icc 0 1) (by norm_num : (0 : ℝ) < 1 / 8)
+    (fun _ ht => transverse_template_ball_subset_patch k ht) hζ hnear
+  obtain ⟨s, hs, t, ht, he⟩ := near_transverse_template_hits_past xp
+    (invFunOn P (crossingPatch k) ∘ ζ) hT hk hε hεsmall le_rfl hxp hq
+    hxp0 hxpT hcore hnearq
+  exact ⟨s, hs, t, ht, (hγ hs).trans ((congrArg P he).trans (hmap ht))⟩
+
+end SLEExactGauge.RibbonCoordinates
+
+end
+
+end OAI

lean/OAI/Probability/SLE/Gauge/RibbonSequenceCompactness.lean

@@ -1,142 +1,142 @@
-import OAI.Probability.SLE.Geometry.ActualGuideCompactness
-import OAI.Probability.SLE.Gauge.RibbonCoordinateLimit
-
-namespace OAI
-
-/-! Joint extraction of normalized Loewner charts, physical and parameter
-guides, and local ribbon coordinate maps under a raw waypoint-angle bound. -/
-
-noncomputable section
-open Set Filter MeasureTheory Metric
-open scoped Topology NNReal
-
-namespace SLEExactGauge
-
-private theorem uniform_subsequence {X Y : Type*} [UniformSpace Y]
-    {f : ℕ → X → Y} {g : X → Y} {S : Set X}
-    (h : TendstoUniformlyOn f g atTop S) {ψ : ℕ → ℕ} (hψ : StrictMono ψ) :
-    TendstoUniformlyOn (fun n => f (ψ n)) g atTop S := by
-  intro u hu
-  exact hψ.tendsto_atTop.eventually (h u hu)
-
-private theorem locally_uniform_subsequence {X Y : Type*} [TopologicalSpace X] [UniformSpace Y]
-    {f : ℕ → X → Y} {g : X → Y} {S : Set X}
-    (h : TendstoLocallyUniformlyOn f g atTop S) {ψ : ℕ → ℕ} (hψ : StrictMono ψ) :
-    TendstoLocallyUniformlyOn (fun n => f (ψ n)) g atTop S := by
-  intro u hu x hx
-  obtain ⟨V, hV, he⟩ := h u hu x hx
-  exact ⟨V, hV, hψ.tendsto_atTop.eventually he⟩
-
-/-- The physical guide in the joint limit is the guide drawn in the
-limiting coordinate chart. This uses uniform chart convergence, rather
-than assuming the guide identity survives moving evaluation points. -/
-theorem coordinate_guide_limit_identity
-    (Qₙ : ℕ → ℂ → ℂ) (Q : ℂ → ℂ) (K : Set ℂ) (hK : IsClosed K)
-    (hQ : ContinuousOn Q K) (hQconv : TendstoUniformlyOn Qₙ Q atTop K)
-    (xₙ : ℕ → ℝ) (x : ℝ) (hx : Tendsto xₙ atTop (𝓝 x))
-    (αₙ : ℕ → ℝ → ℂ) (α : ℝ → ℂ)
-    (hαconv : TendstoUniformlyOn αₙ α atTop (Icc 0 2))
-    (hmem : ∀ n t, t ∈ Icc (0 : ℝ) 2 →
-      RibbonCoordinates.guideCoordinate 0 (xₙ n) t ∈ K)
-    (hshape : ∀ n t, t ∈ Icc (0 : ℝ) 2 →
-      αₙ n t = Qₙ n (RibbonCoordinates.guideCoordinate 0 (xₙ n) t)) :
-    EqOn α (fun t => Q (RibbonCoordinates.guideCoordinate 0 x t)) (Icc 0 2) := by
-  intro t ht
-  have hqc : Continuous (fun y : ℝ => RibbonCoordinates.guideCoordinate 0 y t) := by
-    unfold RibbonCoordinates.guideCoordinate
-    fun_prop
-  have hqt := (hqc.tendsto x).comp hx
-  have hqK : RibbonCoordinates.guideCoordinate 0 x t ∈ K :=
-    hK.mem_of_tendsto hqt (Eventually.of_forall (fun n => hmem n t ht))
-  have hqwithin : Tendsto (fun n => RibbonCoordinates.guideCoordinate 0 (xₙ n) t)
-      atTop (𝓝[K] (RibbonCoordinates.guideCoordinate 0 x t)) :=
-    tendsto_nhdsWithin_iff.mpr ⟨hqt, Eventually.of_forall (fun n => hmem n t ht)⟩
-  have hlim := hQconv.tendsto_comp (hQ _ hqK) hqwithin
-  have halim : Tendsto (fun n => αₙ n t) atTop
-      (𝓝 (Q (RibbonCoordinates.guideCoordinate 0 x t))) := by
-    convert hlim using 1
-    funext n
-    exact hshape n t ht
-  exact tendsto_nhds_unique (hαconv.tendsto_at ht) halim
-
-/-- The normalized Loewner charts and coordinate charts admit one common
-subsequence under the raw waypoint-angle normalization hypothesis. -/
-theorem actual_ribbon_joint_compactness
-    {Ω : Type} [MeasurableSpace Ω] (P : Measure Ω) [IsProbabilityMeasure P]
-    (κ : ℝ) (hκ : 0 < κ) (hκ8 : κ < 8)
-    (γ : Ω → ℝ≥0 → ℂ) (hSLE : IsOrdinaryChordalSLE κ γ P)
-    (hcompact : PublishedHalfPlaneUnivalentCompactness)
-    (hboundary : PublishedLoewnerBoundaryExtension)
-    (U : ℕ → ℝ≥0 → ℝ) (γₙ : ℕ → ℝ≥0 → ℂ)
-    (G F₀ : ℕ → ℝ≥0 → ℂ → ℂ)
-    (hU : ∀ n, Continuous (U n))
-    (hw : ∀ n, IsCapacityTwoWitness (U n) (γₙ n) (G n) (F₀ n))
-    (T : ℕ → ℝ≥0) (hT : ∀ n, 0 < T n)
-    (hfresh : ∀ n s, s < T n → γₙ n (T n) ∈ survivingDomain (γₙ n) s)
-    (αₙ : ℕ → ℝ → ℂ) (C : ℝ≥0) (s c A : ℝ)
-    (hC : 0 < (C : ℝ)) (hs : 0 < s) (hc : 0 < c)
-    (hαL : ∀ n, LipschitzOnWith C (αₙ n) (Icc 0 2))
-    (hα0 : ∀ n, αₙ n 0 = γₙ n (T n)) (haBound : ∀ n, ‖γₙ n (T n)‖ ≤ A)
-    (hchord : ∀ n u, u ∈ Icc (0 : ℝ) 2 → ∀ v, v ∈ Icc (0 : ℝ) 2 →
-      c * |u - v| ≤ dist (αₙ n u) (αₙ n v))
-    (hαD : ∀ n, MapsTo (αₙ n) (Ioc 0 2) (survivingDomain (γₙ n) (T n)))
-    (hclear : ∀ δ : ℝ, 0 < δ → δ ≤ 2 → ∃ r : ℝ, 0 < r ∧
-      ∀ n t, t ∈ Icc δ 2 → ball (αₙ n t) r ⊆ survivingDomain (γₙ n) (T n))
-    (Qₙ : ℕ → ℂ → ℂ) (K : Set ℂ) (hK : IsCompact K)
-    (x₀ : ℂ) (hx₀ : x₀ ∈ K) (Cq Lq : ℝ≥0) (Rq : ℝ)
-    (hQupper : ∀ n, LipschitzOnWith Cq (Qₙ n) K)
-    (hQlower : ∀ n x, x ∈ K → ∀ y, y ∈ K → dist x y ≤ Lq * dist (Qₙ n x) (Qₙ n y))
-    (hQtip : ∀ n, ‖Qₙ n x₀‖ ≤ Rq)
-    (hQheight : ∀ n z, z ∈ K → 0 ≤ (Qₙ n z).im)
-    (hplanar : PublishedPlanarDiskOpenness)
-    (hangle : ∀ n, s ≤ (G n (T n) (αₙ n (1 / 2)) - (U n (T n) : ℂ)).im /
-      ‖G n (T n) (αₙ n (1 / 2)) - (U n (T n) : ℂ)‖) :
-    ∃ (Q : ℂ → ℂ) (b : ℕ → ℝ) (Fb : ℕ → ℂ → OnePoint ℂ) (βₙ : ℕ → ℝ → ℂ)
-      (φ : ℕ → ℕ) (F : ℂ → ℂ) (α β : ℝ → ℂ),
-      (∀ n, 0 < b n) ∧
-      (∀ n, ContinuousOn (Fb n) {z : ℂ | 0 ≤ z.im}) ∧
-      (∀ n z, z ∈ upperHalfPlane → Fb n z =
-        (normalizedInverse (F₀ n (T n)) (U n (T n)) (b n) z : OnePoint ℂ)) ∧
-      (∀ n, ContinuousOn (βₙ n) (Icc 0 2)) ∧
-      (∀ n, βₙ n 0 = 0) ∧
-      (∀ n t, t ∈ Icc (0 : ℝ) 2 → 0 ≤ (βₙ n t).im) ∧
-      (∀ n t, t ∈ Ioc (0 : ℝ) 2 → βₙ n t =
-        normalizedForward (G n (T n)) (U n (T n)) (b n) (αₙ n t)) ∧
-      (∀ n t, t ∈ Icc (0 : ℝ) 2 → Fb n (βₙ n t) = (αₙ n t : OnePoint ℂ)) ∧
-      StrictMono φ ∧ DifferentiableOn ℂ F upperHalfPlane ∧ InjOn F upperHalfPlane ∧
-      (∀ z ∈ upperHalfPlane, deriv F z ≠ 0) ∧ α 0 ∉ F '' upperHalfPlane ∧
-      TendstoLocallyUniformlyOn
-        (fun n => normalizedInverse (F₀ (φ n) (T (φ n))) (U (φ n) (T (φ n))) (b (φ n)))
-        F atTop upperHalfPlane ∧
-      TendstoUniformlyOn (fun n => αₙ (φ n)) α atTop (Icc 0 2) ∧
-      TendstoUniformlyOn (fun n => βₙ (φ n)) β atTop (Icc 0 2) ∧
-      Tendsto (fun n => γₙ (φ n) (T (φ n))) atTop (𝓝 (α 0)) ∧
-      LipschitzOnWith C α (Icc 0 2) ∧ ContinuousOn α (Icc 0 2) ∧ InjOn α (Icc 0 2) ∧
-      β 0 = 0 ∧ ContinuousOn β (Icc 0 2) ∧ InjOn β (Icc 0 2) ∧
-      MapsTo β (Ioc 0 2) upperHalfPlane ∧ EqOn (F ∘ β) α (Ioc 0 2) ∧
-      TendstoUniformlyOn (fun n => Qₙ (φ n)) Q atTop K ∧
-      LipschitzOnWith Cq Q K ∧
-      (∀ x ∈ K, ∀ y ∈ K, dist x y ≤ Lq * dist (Q x) (Q y)) ∧
-      InjOn Q K ∧ MapsTo Q (interior K) upperHalfPlane := by
-  obtain ⟨b, Fb, βₙ, φ, F, α, β, hb, hbar, hext, hβc, hβ0, hβH, hβeq,
-      hbarα, hφ, hF, hiF, hFne, homitlim, hFconv, hαconv, hβconv, hatip,
-      hαLlim, hαclim, hαilim, hβlim0, hβlimc, hβlimi, hβlimH, hlimrel⟩ :=
-    actual_guide_joint_compactness_with_family P κ hκ hκ8 γ hSLE hcompact hboundary
-      U γₙ G F₀ hU hw T hT hfresh αₙ C s c A hC hs hc hαL hα0 haBound hchord hαD hclear hangle
-  obtain ⟨Q, ψ, hψ, hQconv, hQu, hQl, hQi, hQH⟩ :=
-    RibbonCoordinates.exists_bilip_halfPlane_subsequence hplanar (fun n => Qₙ (φ n))
-      K hK x₀ hx₀ Cq Lq Rq (fun n => hQupper (φ n)) (fun n => hQlower (φ n))
-      (fun n => hQtip (φ n)) (fun n => hQheight (φ n))
-  have hFsub := locally_uniform_subsequence hFconv hψ
-  have hαsub := uniform_subsequence hαconv hψ
-  have hβsub := uniform_subsequence hβconv hψ
-  exact ⟨Q, b, Fb, βₙ, φ ∘ ψ, F, α, β, hb, hbar, hext, hβc, hβ0, hβH,
-    hβeq, hbarα, hφ.comp hψ, hF, hiF, hFne, homitlim, hFsub, hαsub, hβsub,
-    hatip.comp hψ.tendsto_atTop, hαLlim, hαclim, hαilim, hβlim0, hβlimc, hβlimi,
-    hβlimH, hlimrel, hQconv, hQu, hQl, hQi, hQH⟩
-
-end SLEExactGauge
-
-end
-
-end OAI
+import OAI.Probability.SLE.Geometry.ActualGuideCompactness
+import OAI.Probability.SLE.Gauge.RibbonCoordinateLimit
+
+namespace OAI
+
+/-! Joint extraction of normalized Loewner charts, physical and parameter
+guides, and local ribbon coordinate maps under a raw waypoint-angle bound. -/
+
+noncomputable section
+open Set Filter MeasureTheory Metric
+open scoped Topology NNReal
+
+namespace SLEExactGauge
+
+private theorem uniform_subsequence {X Y : Type*} [UniformSpace Y]
+    {f : ℕ → X → Y} {g : X → Y} {S : Set X}
+    (h : TendstoUniformlyOn f g atTop S) {ψ : ℕ → ℕ} (hψ : StrictMono ψ) :
+    TendstoUniformlyOn (fun n => f (ψ n)) g atTop S := by
+  intro u hu
+  exact hψ.tendsto_atTop.eventually (h u hu)
+
+private theorem locally_uniform_subsequence {X Y : Type*} [TopologicalSpace X] [UniformSpace Y]
+    {f : ℕ → X → Y} {g : X → Y} {S : Set X}
+    (h : TendstoLocallyUniformlyOn f g atTop S) {ψ : ℕ → ℕ} (hψ : StrictMono ψ) :
+    TendstoLocallyUniformlyOn (fun n => f (ψ n)) g atTop S := by
+  intro u hu x hx
+  obtain ⟨V, hV, he⟩ := h u hu x hx
+  exact ⟨V, hV, hψ.tendsto_atTop.eventually he⟩
+
+/-- The physical guide in the joint limit is the guide drawn in the
+limiting coordinate chart. This uses uniform chart convergence, rather
+than assuming the guide identity survives moving evaluation points. -/
+theorem coordinate_guide_limit_identity
+    (Qₙ : ℕ → ℂ → ℂ) (Q : ℂ → ℂ) (K : Set ℂ) (hK : IsClosed K)
+    (hQ : ContinuousOn Q K) (hQconv : TendstoUniformlyOn Qₙ Q atTop K)
+    (xₙ : ℕ → ℝ) (x : ℝ) (hx : Tendsto xₙ atTop (𝓝 x))
+    (αₙ : ℕ → ℝ → ℂ) (α : ℝ → ℂ)
+    (hαconv : TendstoUniformlyOn αₙ α atTop (Icc 0 2))
+    (hmem : ∀ n t, t ∈ Icc (0 : ℝ) 2 →
+      RibbonCoordinates.guideCoordinate 0 (xₙ n) t ∈ K)
+    (hshape : ∀ n t, t ∈ Icc (0 : ℝ) 2 →
+      αₙ n t = Qₙ n (RibbonCoordinates.guideCoordinate 0 (xₙ n) t)) :
+    EqOn α (fun t => Q (RibbonCoordinates.guideCoordinate 0 x t)) (Icc 0 2) := by
+  intro t ht
+  have hqc : Continuous (fun y : ℝ => RibbonCoordinates.guideCoordinate 0 y t) := by
+    unfold RibbonCoordinates.guideCoordinate
+    fun_prop
+  have hqt := (hqc.tendsto x).comp hx
+  have hqK : RibbonCoordinates.guideCoordinate 0 x t ∈ K :=
+    hK.mem_of_tendsto hqt (Eventually.of_forall (fun n => hmem n t ht))
+  have hqwithin : Tendsto (fun n => RibbonCoordinates.guideCoordinate 0 (xₙ n) t)
+      atTop (𝓝[K] (RibbonCoordinates.guideCoordinate 0 x t)) :=
+    tendsto_nhdsWithin_iff.mpr ⟨hqt, Eventually.of_forall (fun n => hmem n t ht)⟩
+  have hlim := hQconv.tendsto_comp (hQ _ hqK) hqwithin
+  have halim : Tendsto (fun n => αₙ n t) atTop
+      (𝓝 (Q (RibbonCoordinates.guideCoordinate 0 x t))) := by
+    convert hlim using 1
+    funext n
+    exact hshape n t ht
+  exact tendsto_nhds_unique (hαconv.tendsto_at ht) halim
+
+/-- The normalized Loewner charts and coordinate charts admit one common
+subsequence under the raw waypoint-angle normalization hypothesis. -/
+theorem actual_ribbon_joint_compactness
+    {Ω : Type} [MeasurableSpace Ω] (P : Measure Ω) [IsProbabilityMeasure P]
+    (κ : ℝ) (hκ : 0 < κ) (hκ8 : κ < 8)
+    (γ : Ω → ℝ≥0 → ℂ) (hSLE : IsOrdinaryChordalSLE κ γ P)
+    (hcompact : PublishedHalfPlaneUnivalentCompactness)
+    (hboundary : PublishedLoewnerBoundaryExtension)
+    (U : ℕ → ℝ≥0 → ℝ) (γₙ : ℕ → ℝ≥0 → ℂ)
+    (G F₀ : ℕ → ℝ≥0 → ℂ → ℂ)
+    (hU : ∀ n, Continuous (U n))
+    (hw : ∀ n, IsCapacityTwoWitness (U n) (γₙ n) (G n) (F₀ n))
+    (T : ℕ → ℝ≥0) (hT : ∀ n, 0 < T n)
+    (hfresh : ∀ n s, s < T n → γₙ n (T n) ∈ survivingDomain (γₙ n) s)
+    (αₙ : ℕ → ℝ → ℂ) (C : ℝ≥0) (s c A : ℝ)
+    (hC : 0 < (C : ℝ)) (hs : 0 < s) (hc : 0 < c)
+    (hαL : ∀ n, LipschitzOnWith C (αₙ n) (Icc 0 2))
+    (hα0 : ∀ n, αₙ n 0 = γₙ n (T n)) (haBound : ∀ n, ‖γₙ n (T n)‖ ≤ A)
+    (hchord : ∀ n u, u ∈ Icc (0 : ℝ) 2 → ∀ v, v ∈ Icc (0 : ℝ) 2 →
+      c * |u - v| ≤ dist (αₙ n u) (αₙ n v))
+    (hαD : ∀ n, MapsTo (αₙ n) (Ioc 0 2) (survivingDomain (γₙ n) (T n)))
+    (hclear : ∀ δ : ℝ, 0 < δ → δ ≤ 2 → ∃ r : ℝ, 0 < r ∧
+      ∀ n t, t ∈ Icc δ 2 → ball (αₙ n t) r ⊆ survivingDomain (γₙ n) (T n))
+    (Qₙ : ℕ → ℂ → ℂ) (K : Set ℂ) (hK : IsCompact K)
+    (x₀ : ℂ) (hx₀ : x₀ ∈ K) (Cq Lq : ℝ≥0) (Rq : ℝ)
+    (hQupper : ∀ n, LipschitzOnWith Cq (Qₙ n) K)
+    (hQlower : ∀ n x, x ∈ K → ∀ y, y ∈ K → dist x y ≤ Lq * dist (Qₙ n x) (Qₙ n y))
+    (hQtip : ∀ n, ‖Qₙ n x₀‖ ≤ Rq)
+    (hQheight : ∀ n z, z ∈ K → 0 ≤ (Qₙ n z).im)
+    (hplanar : PublishedPlanarDiskOpenness)
+    (hangle : ∀ n, s ≤ (G n (T n) (αₙ n (1 / 2)) - (U n (T n) : ℂ)).im /
+      ‖G n (T n) (αₙ n (1 / 2)) - (U n (T n) : ℂ)‖) :
+    ∃ (Q : ℂ → ℂ) (b : ℕ → ℝ) (Fb : ℕ → ℂ → OnePoint ℂ) (βₙ : ℕ → ℝ → ℂ)
+      (φ : ℕ → ℕ) (F : ℂ → ℂ) (α β : ℝ → ℂ),
+      (∀ n, 0 < b n) ∧
+      (∀ n, ContinuousOn (Fb n) {z : ℂ | 0 ≤ z.im}) ∧
+      (∀ n z, z ∈ upperHalfPlane → Fb n z =
+        (normalizedInverse (F₀ n (T n)) (U n (T n)) (b n) z : OnePoint ℂ)) ∧
+      (∀ n, ContinuousOn (βₙ n) (Icc 0 2)) ∧
+      (∀ n, βₙ n 0 = 0) ∧
+      (∀ n t, t ∈ Icc (0 : ℝ) 2 → 0 ≤ (βₙ n t).im) ∧
+      (∀ n t, t ∈ Ioc (0 : ℝ) 2 → βₙ n t =
+        normalizedForward (G n (T n)) (U n (T n)) (b n) (αₙ n t)) ∧
+      (∀ n t, t ∈ Icc (0 : ℝ) 2 → Fb n (βₙ n t) = (αₙ n t : OnePoint ℂ)) ∧
+      StrictMono φ ∧ DifferentiableOn ℂ F upperHalfPlane ∧ InjOn F upperHalfPlane ∧
+      (∀ z ∈ upperHalfPlane, deriv F z ≠ 0) ∧ α 0 ∉ F '' upperHalfPlane ∧
+      TendstoLocallyUniformlyOn
+        (fun n => normalizedInverse (F₀ (φ n) (T (φ n))) (U (φ n) (T (φ n))) (b (φ n)))
+        F atTop upperHalfPlane ∧
+      TendstoUniformlyOn (fun n => αₙ (φ n)) α atTop (Icc 0 2) ∧
+      TendstoUniformlyOn (fun n => βₙ (φ n)) β atTop (Icc 0 2) ∧
+      Tendsto (fun n => γₙ (φ n) (T (φ n))) atTop (𝓝 (α 0)) ∧
+      LipschitzOnWith C α (Icc 0 2) ∧ ContinuousOn α (Icc 0 2) ∧ InjOn α (Icc 0 2) ∧
+      β 0 = 0 ∧ ContinuousOn β (Icc 0 2) ∧ InjOn β (Icc 0 2) ∧
+      MapsTo β (Ioc 0 2) upperHalfPlane ∧ EqOn (F ∘ β) α (Ioc 0 2) ∧
+      TendstoUniformlyOn (fun n => Qₙ (φ n)) Q atTop K ∧
+      LipschitzOnWith Cq Q K ∧
+      (∀ x ∈ K, ∀ y ∈ K, dist x y ≤ Lq * dist (Q x) (Q y)) ∧
+      InjOn Q K ∧ MapsTo Q (interior K) upperHalfPlane := by
+  obtain ⟨b, Fb, βₙ, φ, F, α, β, hb, hbar, hext, hβc, hβ0, hβH, hβeq,
+      hbarα, hφ, hF, hiF, hFne, homitlim, hFconv, hαconv, hβconv, hatip,
+      hαLlim, hαclim, hαilim, hβlim0, hβlimc, hβlimi, hβlimH, hlimrel⟩ :=
+    actual_guide_joint_compactness_with_family P κ hκ hκ8 γ hSLE hcompact hboundary
+      U γₙ G F₀ hU hw T hT hfresh αₙ C s c A hC hs hc hαL hα0 haBound hchord hαD hclear hangle
+  obtain ⟨Q, ψ, hψ, hQconv, hQu, hQl, hQi, hQH⟩ :=
+    RibbonCoordinates.exists_bilip_halfPlane_subsequence hplanar (fun n => Qₙ (φ n))
+      K hK x₀ hx₀ Cq Lq Rq (fun n => hQupper (φ n)) (fun n => hQlower (φ n))
+      (fun n => hQtip (φ n)) (fun n => hQheight (φ n))
+  have hFsub := locally_uniform_subsequence hFconv hψ
+  have hαsub := uniform_subsequence hαconv hψ
+  have hβsub := uniform_subsequence hβconv hψ
+  exact ⟨Q, b, Fb, βₙ, φ ∘ ψ, F, α, β, hb, hbar, hext, hβc, hβ0, hβH,
+    hβeq, hbarα, hφ.comp hψ, hF, hiF, hFne, homitlim, hFsub, hαsub, hβsub,
+    hatip.comp hψ.tendsto_atTop, hαLlim, hαclim, hαilim, hβlim0, hβlimc, hβlimi,
+    hβlimH, hlimrel, hQconv, hQu, hQl, hQi, hQH⟩
+
+end SLEExactGauge
+
+end
+
+end OAI

lean/OAI/Probability/SLE/Gauge/RibbonSideCorridors.lean

@@ -1,76 +1,76 @@
-import OAI.Probability.SLE.Gauge.RibbonCoordinateGeometry
-
-namespace OAI
-
-/-! The two strips outside the narrow core are in the actual surviving
-component. Their connection to the unbounded future excludes filled hulls,
-even when the stopped past is not simple. -/
-
-noncomputable section
-open Set Filter Metric
-open scoped Topology NNReal
-
-namespace SLEExactGauge.RibbonCoordinates
-
-def sideCorridor (a b : ℝ) : Set ℂ :=
-  {z | 0 < z.re ∧ z.im ∈ Ioo a b}
-
-theorem sideCorridor_convex (a b : ℝ) : Convex ℝ (sideCorridor a b) := by
-  exact (convex_halfSpace_gt Complex.reLm.isLinear 0).inter
-    ((convex_Ioo a b).is_linear_preimage Complex.imLm.isLinear)
-
-/-- A strip strictly outside the past's core connects to the free future
-and hence is in the unbounded surviving domain. This covers either side. -/
-theorem sideCorridor_survives
-    (P : ℂ → ℂ) (hP : ContinuousOn P closedRibbon) (hi : InjOn P closedRibbon)
-    (hH : ∀ z ∈ closedRibbon, 0 < z.re → P z ∈ upperHalfPlane)
-    (γ : ℝ≥0 → ℂ) (T : ℝ≥0) {k ε a b : ℝ} (hk : 0 ≤ k)
-    (hab : a < b) (ha : -1 ≤ a) (hb : b ≤ 1)
-    (hgap : ∀ x ∈ Ioo a b, ε < |x|)
-    (hpast : γ '' Icc 0 T ⊆
-      P '' {z ∈ closedRibbon | z.re ≤ k ∧ |z.im| ≤ ε})
-    (hunbounded : ¬ Bornology.IsBounded (P '' futureRibbon k)) :
-    P '' sideCorridor a b ⊆ survivingDomain γ T := by
-  have hsideSub : sideCorridor a b ⊆ closedRibbon := by
-    intro z hz
-    exact ⟨hz.1.le, (abs_lt.mpr ⟨ha.trans_lt hz.2.1, hz.2.2.trans_le hb⟩).le⟩
-  have hfutureSub := futureRibbon_subset_closedRibbon hk
-  let S := sideCorridor a b ∪ futureRibbon k
-  have hSsub : S ⊆ closedRibbon := union_subset hsideSub hfutureSub
-  let z : ℂ := ((k + 1 : ℝ) : ℂ) + (((a + b) / 2 : ℝ) : ℂ) * Complex.I
-  have hzre : z.re = k + 1 := by simp [z]
-  have hzim : z.im = (a + b) / 2 := by simp [z]
-  have hzm : z.im ∈ Ioo a b := by rw [hzim]; constructor <;> linarith
-  have hzside : z ∈ sideCorridor a b := ⟨by rw [hzre]; linarith, hzm⟩
-  have hzfuture : z ∈ futureRibbon k :=
-    ⟨by rw [hzre]; linarith,
-      abs_lt.mpr ⟨ha.trans_lt hzm.1, hzm.2.trans_le hb⟩⟩
-  have hSconn : IsPreconnected S :=
-    (sideCorridor_convex a b).isPreconnected.union z hzside hzfuture
-      (futureRibbon_convex k).isPreconnected
-  have hfree : P '' S ⊆ upperHalfPlane \ (γ '' Icc 0 T) := by
-    rintro y ⟨u, hu, rfl⟩
-    have huH : 0 < u.re := by
-      rcases hu with hu | hu
-      · exact hu.1
-      · exact hk.trans_lt hu.1
-    refine ⟨hH u (hSsub hu) huH, ?_⟩
-    intro hp
-    obtain ⟨v, hv, he⟩ := hpast hp
-    have hvu := hi hv.1 (hSsub hu) he
-    rw [hvu] at hv
-    rcases hu with hu | hu
-    · exact (not_le_of_gt (hgap u.im hu.2)) hv.2.2
-    · exact (not_le_of_gt hu.1) hv.2.1
-  have hSunbounded : ¬ Bornology.IsBounded (P '' S) := by
-    intro hbound
-    exact hunbounded (hbound.subset (image_mono subset_union_right))
-  exact (image_mono subset_union_left).trans
-    (free_preconnected_subset_surviving γ T (P '' S)
-      (hSconn.image P (hP.mono hSsub)) hfree hSunbounded)
-
-end SLEExactGauge.RibbonCoordinates
-
-end
-
-end OAI
+import OAI.Probability.SLE.Gauge.RibbonCoordinateGeometry
+
+namespace OAI
+
+/-! The two strips outside the narrow core are in the actual surviving
+component. Their connection to the unbounded future excludes filled hulls,
+even when the stopped past is not simple. -/
+
+noncomputable section
+open Set Filter Metric
+open scoped Topology NNReal
+
+namespace SLEExactGauge.RibbonCoordinates
+
+def sideCorridor (a b : ℝ) : Set ℂ :=
+  {z | 0 < z.re ∧ z.im ∈ Ioo a b}
+
+theorem sideCorridor_convex (a b : ℝ) : Convex ℝ (sideCorridor a b) := by
+  exact (convex_halfSpace_gt Complex.reLm.isLinear 0).inter
+    ((convex_Ioo a b).is_linear_preimage Complex.imLm.isLinear)
+
+/-- A strip strictly outside the past's core connects to the free future
+and hence is in the unbounded surviving domain. This covers either side. -/
+theorem sideCorridor_survives
+    (P : ℂ → ℂ) (hP : ContinuousOn P closedRibbon) (hi : InjOn P closedRibbon)
+    (hH : ∀ z ∈ closedRibbon, 0 < z.re → P z ∈ upperHalfPlane)
+    (γ : ℝ≥0 → ℂ) (T : ℝ≥0) {k ε a b : ℝ} (hk : 0 ≤ k)
+    (hab : a < b) (ha : -1 ≤ a) (hb : b ≤ 1)
+    (hgap : ∀ x ∈ Ioo a b, ε < |x|)
+    (hpast : γ '' Icc 0 T ⊆
+      P '' {z ∈ closedRibbon | z.re ≤ k ∧ |z.im| ≤ ε})
+    (hunbounded : ¬ Bornology.IsBounded (P '' futureRibbon k)) :
+    P '' sideCorridor a b ⊆ survivingDomain γ T := by
+  have hsideSub : sideCorridor a b ⊆ closedRibbon := by
+    intro z hz
+    exact ⟨hz.1.le, (abs_lt.mpr ⟨ha.trans_lt hz.2.1, hz.2.2.trans_le hb⟩).le⟩
+  have hfutureSub := futureRibbon_subset_closedRibbon hk
+  let S := sideCorridor a b ∪ futureRibbon k
+  have hSsub : S ⊆ closedRibbon := union_subset hsideSub hfutureSub
+  let z : ℂ := ((k + 1 : ℝ) : ℂ) + (((a + b) / 2 : ℝ) : ℂ) * Complex.I
+  have hzre : z.re = k + 1 := by simp [z]
+  have hzim : z.im = (a + b) / 2 := by simp [z]
+  have hzm : z.im ∈ Ioo a b := by rw [hzim]; constructor <;> linarith
+  have hzside : z ∈ sideCorridor a b := ⟨by rw [hzre]; linarith, hzm⟩
+  have hzfuture : z ∈ futureRibbon k :=
+    ⟨by rw [hzre]; linarith,
+      abs_lt.mpr ⟨ha.trans_lt hzm.1, hzm.2.trans_le hb⟩⟩
+  have hSconn : IsPreconnected S :=
+    (sideCorridor_convex a b).isPreconnected.union z hzside hzfuture
+      (futureRibbon_convex k).isPreconnected
+  have hfree : P '' S ⊆ upperHalfPlane \ (γ '' Icc 0 T) := by
+    rintro y ⟨u, hu, rfl⟩
+    have huH : 0 < u.re := by
+      rcases hu with hu | hu
+      · exact hu.1
+      · exact hk.trans_lt hu.1
+    refine ⟨hH u (hSsub hu) huH, ?_⟩
+    intro hp
+    obtain ⟨v, hv, he⟩ := hpast hp
+    have hvu := hi hv.1 (hSsub hu) he
+    rw [hvu] at hv
+    rcases hu with hu | hu
+    · exact (not_le_of_gt (hgap u.im hu.2)) hv.2.2
+    · exact (not_le_of_gt hu.1) hv.2.1
+  have hSunbounded : ¬ Bornology.IsBounded (P '' S) := by
+    intro hbound
+    exact hunbounded (hbound.subset (image_mono subset_union_right))
+  exact (image_mono subset_union_left).trans
+    (free_preconnected_subset_surviving γ T (P '' S)
+      (hSconn.image P (hP.mono hSsub)) hfree hSunbounded)
+
+end SLEExactGauge.RibbonCoordinates
+
+end
+
+end OAI

lean/OAI/Probability/SLE/Gauge/RibbonStepPatch.lean

@@ -1,90 +1,90 @@
-import OAI.Probability.SLE.Gauge.RibbonAccessGuide
-import OAI.Probability.SLE.Gauge.RibbonRouteLifting
-import OAI.Probability.SLE.Gauge.RibbonLimitPassageGeometry
-
-namespace OAI
-
-/-! A fixed compact coordinate patch for the actual one-step ribbon. -/
-
-noncomputable section
-open Set Filter Metric
-open scoped Topology NNReal
-
-namespace SLEExactGauge.RibbonCoordinates
-
-/-- The length-four patch used for one step and its two-sided waypoint routes. -/
-def ribbonStepPatch (k : ℝ) : Set ℂ :=
-  {z | k - 1 ≤ z.re ∧ z.re ≤ k + 3 ∧ |z.im| ≤ 1}
-
-/-- A padded compact patch in coordinates relative to the current front. -/
-def ribbonStepCompact : Set ℂ :=
-  {z | -(1 / 2 : ℝ) ≤ z.re ∧ z.re ≤ 5 / 2 ∧ |z.im| ≤ 1 / 2}
-
-theorem ribbonStepCompact_isCompact : IsCompact ribbonStepCompact := by
-  have hc : IsClosed ribbonStepCompact :=
-    (isClosed_le continuous_const Complex.continuous_re).inter
-      ((isClosed_le Complex.continuous_re continuous_const).inter
-        (isClosed_le Complex.continuous_im.abs continuous_const))
-  apply (isCompact_closedBall (0 : ℂ) 4).of_isClosed_subset hc
-  intro z hz
-  have hre : |z.re| ≤ 5 / 2 := abs_le.mpr ⟨by linarith [hz.1], hz.2.1⟩
-  have hn := Complex.norm_le_abs_re_add_abs_im z
-  simpa only [mem_closedBall, dist_zero_right] using
-    (show ‖z‖ ≤ 4 by linarith [hz.2.2])
-
-theorem ribbonStepCompact_interior
-    {z : ℂ} (hre : -(1 / 2 : ℝ) < z.re ∧ z.re < 5 / 2)
-    (him : |z.im| < 1 / 2) : z ∈ interior ribbonStepCompact := by
-  let V : Set ℂ := {z | -(1 / 2 : ℝ) < z.re ∧ z.re < 5 / 2 ∧ |z.im| < 1 / 2}
-  have hV : IsOpen V := (isOpen_lt continuous_const Complex.continuous_re).inter
-    ((isOpen_lt Complex.continuous_re continuous_const).inter
-      (isOpen_lt Complex.continuous_im.abs continuous_const))
-  have hVK : V ⊆ ribbonStepCompact := by
-    intro w hw
-    exact ⟨hw.1.le, hw.2.1.le, hw.2.2.le⟩
-  exact interior_maximal hVK hV ⟨hre.1, hre.2, him⟩
-
-theorem ribbonStepCompact_zero : (0 : ℂ) ∈ ribbonStepCompact := by
-  change -(1 / 2 : ℝ) ≤ 0 ∧ (0 : ℝ) ≤ 5 / 2 ∧ |(0 : ℝ)| ≤ 1 / 2
-  norm_num
-
-theorem ribbonStepCompact_core {ε : ℝ} (hε : ε ≤ 1 / 8) :
-    {z : ℂ | 0 ≤ z.re ∧ z.re ≤ 2 ∧ |z.im| ≤ ε / 4} ⊆
-      interior ribbonStepCompact := by
-  intro z hz
-  apply ribbonStepCompact_interior
-  · constructor <;> linarith [hz.1, hz.2.1]
-  · linarith [hz.2.2]
-
-theorem ribbonStepCompact_passage {ε : ℝ} (hε : ε ≤ 1 / 8)
-    (C : ℝ≥0) (η : ℝ) :
-    ribbonStepCompact ∩ passageCoordinateRegion C ε η ⊆ interior ribbonStepCompact := by
-  intro z hz
-  apply ribbonStepCompact_interior
-  · constructor <;> linarith [hz.2.1, hz.2.2.1]
-  · linarith [hz.2.2.2.1]
-
-theorem guidePatch_subset_ribbonStepPatch (k : ℝ) :
-    guidePatch k ⊆ ribbonStepPatch k := by
-  intro z hz
-  exact ⟨by linarith [hz.1], hz.2.1, hz.2.2⟩
-
-theorem crossingPatch_subset_ribbonStepPatch (k : ℝ) :
-    crossingPatch k ⊆ ribbonStepPatch k := by
-  intro z hz
-  exact ⟨hz.1, by linarith [hz.2.1], hz.2.2⟩
-
-theorem translate_ribbonStepCompact {k : ℝ} {z : ℂ} (hz : z ∈ ribbonStepCompact) :
-    (k : ℂ) + z ∈ ribbonStepPatch k := by
-  change k - 1 ≤ k + z.re ∧ k + z.re ≤ k + 3 ∧ |0 + z.im| ≤ 1
-  exact ⟨by linarith [hz.1], by linarith [hz.2.1], by simpa using hz.2.2.trans (by norm_num)⟩
-
-theorem guideCoordinate_translate (k x t : ℝ) :
-    (k : ℂ) + guideCoordinate 0 x t = guideCoordinate k x t := by
-  apply Complex.ext <;> simp [guideCoordinate]
-
-end SLEExactGauge.RibbonCoordinates
-
-end
-
-end OAI
+import OAI.Probability.SLE.Gauge.RibbonAccessGuide
+import OAI.Probability.SLE.Gauge.RibbonRouteLifting
+import OAI.Probability.SLE.Gauge.RibbonLimitPassageGeometry
+
+namespace OAI
+
+/-! A fixed compact coordinate patch for the actual one-step ribbon. -/
+
+noncomputable section
+open Set Filter Metric
+open scoped Topology NNReal
+
+namespace SLEExactGauge.RibbonCoordinates
+
+/-- The length-four patch used for one step and its two-sided waypoint routes. -/
+def ribbonStepPatch (k : ℝ) : Set ℂ :=
+  {z | k - 1 ≤ z.re ∧ z.re ≤ k + 3 ∧ |z.im| ≤ 1}
+
+/-- A padded compact patch in coordinates relative to the current front. -/
+def ribbonStepCompact : Set ℂ :=
+  {z | -(1 / 2 : ℝ) ≤ z.re ∧ z.re ≤ 5 / 2 ∧ |z.im| ≤ 1 / 2}
+
+theorem ribbonStepCompact_isCompact : IsCompact ribbonStepCompact := by
+  have hc : IsClosed ribbonStepCompact :=
+    (isClosed_le continuous_const Complex.continuous_re).inter
+      ((isClosed_le Complex.continuous_re continuous_const).inter
+        (isClosed_le Complex.continuous_im.abs continuous_const))
+  apply (isCompact_closedBall (0 : ℂ) 4).of_isClosed_subset hc
+  intro z hz
+  have hre : |z.re| ≤ 5 / 2 := abs_le.mpr ⟨by linarith [hz.1], hz.2.1⟩
+  have hn := Complex.norm_le_abs_re_add_abs_im z
+  simpa only [mem_closedBall, dist_zero_right] using
+    (show ‖z‖ ≤ 4 by linarith [hz.2.2])
+
+theorem ribbonStepCompact_interior
+    {z : ℂ} (hre : -(1 / 2 : ℝ) < z.re ∧ z.re < 5 / 2)
+    (him : |z.im| < 1 / 2) : z ∈ interior ribbonStepCompact := by
+  let V : Set ℂ := {z | -(1 / 2 : ℝ) < z.re ∧ z.re < 5 / 2 ∧ |z.im| < 1 / 2}
+  have hV : IsOpen V := (isOpen_lt continuous_const Complex.continuous_re).inter
+    ((isOpen_lt Complex.continuous_re continuous_const).inter
+      (isOpen_lt Complex.continuous_im.abs continuous_const))
+  have hVK : V ⊆ ribbonStepCompact := by
+    intro w hw
+    exact ⟨hw.1.le, hw.2.1.le, hw.2.2.le⟩
+  exact interior_maximal hVK hV ⟨hre.1, hre.2, him⟩
+
+theorem ribbonStepCompact_zero : (0 : ℂ) ∈ ribbonStepCompact := by
+  change -(1 / 2 : ℝ) ≤ 0 ∧ (0 : ℝ) ≤ 5 / 2 ∧ |(0 : ℝ)| ≤ 1 / 2
+  norm_num
+
+theorem ribbonStepCompact_core {ε : ℝ} (hε : ε ≤ 1 / 8) :
+    {z : ℂ | 0 ≤ z.re ∧ z.re ≤ 2 ∧ |z.im| ≤ ε / 4} ⊆
+      interior ribbonStepCompact := by
+  intro z hz
+  apply ribbonStepCompact_interior
+  · constructor <;> linarith [hz.1, hz.2.1]
+  · linarith [hz.2.2]
+
+theorem ribbonStepCompact_passage {ε : ℝ} (hε : ε ≤ 1 / 8)
+    (C : ℝ≥0) (η : ℝ) :
+    ribbonStepCompact ∩ passageCoordinateRegion C ε η ⊆ interior ribbonStepCompact := by
+  intro z hz
+  apply ribbonStepCompact_interior
+  · constructor <;> linarith [hz.2.1, hz.2.2.1]
+  · linarith [hz.2.2.2.1]
+
+theorem guidePatch_subset_ribbonStepPatch (k : ℝ) :
+    guidePatch k ⊆ ribbonStepPatch k := by
+  intro z hz
+  exact ⟨by linarith [hz.1], hz.2.1, hz.2.2⟩
+
+theorem crossingPatch_subset_ribbonStepPatch (k : ℝ) :
+    crossingPatch k ⊆ ribbonStepPatch k := by
+  intro z hz
+  exact ⟨hz.1, by linarith [hz.2.1], hz.2.2⟩
+
+theorem translate_ribbonStepCompact {k : ℝ} {z : ℂ} (hz : z ∈ ribbonStepCompact) :
+    (k : ℂ) + z ∈ ribbonStepPatch k := by
+  change k - 1 ≤ k + z.re ∧ k + z.re ≤ k + 3 ∧ |0 + z.im| ≤ 1
+  exact ⟨by linarith [hz.1], by linarith [hz.2.1], by simpa using hz.2.2.trans (by norm_num)⟩
+
+theorem guideCoordinate_translate (k x t : ℝ) :
+    (k : ℂ) + guideCoordinate 0 x t = guideCoordinate k x t := by
+  apply Complex.ext <;> simp [guideCoordinate]
+
+end SLEExactGauge.RibbonCoordinates
+
+end
+
+end OAI

lean/OAI/Probability/SLE/Gauge/RibbonStepSuccess.lean

@@ -1,85 +1,85 @@
-import OAI.Probability.SLE.Gauge.RibbonGoodPrefix
-
-namespace OAI
-
-/-! Actual passage-and-mass successes are measured in the next global
-front past, with the earlier global front as the mass window's start. -/
-
-noncomputable section
-open Set Filter MeasureTheory ProbabilityTheory Metric
-open scoped Topology NNReal ENNReal
-
-namespace SLEExactGauge
-open RibbonCoordinates FirstFrontPassage FrontSuccessMeasurability
-
-local instance stepSuccessPathMeasurable : MeasurableSpace C(ℝ≥0, ℂ) := borel _
-local instance stepSuccessPathBorel : BorelSpace C(ℝ≥0, ℂ) := ⟨rfl⟩
-
-def RibbonStepSuccess {Ω : Type*} (γ : Ω → ℝ≥0 → ℂ)
-    (σ τ : Ω → WithTop ℝ≥0) (P : ℂ → ℂ) (ε κ v c : ℝ) (R : Set ℂ) : Set Ω :=
-  GoodRibbonPrefix γ τ P ε ∩ {ω | ENNReal.ofReal c ≤
-    segmentSausageCharge κ (γ ω) ((σ ω).untopD 0) ((τ ω).untopD 0) v R}
-
-lemma stoppedAtPath_eq_on_prefix (f : C(ℝ≥0, ℂ)) (t : ℝ≥0) :
-    EqOn (stoppedAtPath f (t : WithTop ℝ≥0)) f (Icc 0 t) := by
-  intro u hu
-  simp only [stoppedAtPath, WithTop.coe_ne_top, ite_false, WithTop.untopD_coe,
-    clampedPath, ContinuousMap.comp_apply, ContinuousMap.coe_mk, min_eq_left hu.2,
-    max_eq_right hu.1]
-
-lemma segmentSausageCharge_shift
-    (κ : ℝ) (γ : ℝ≥0 → ℂ) (T S : ℝ≥0) (v : ℝ) (R : Set ℂ) :
-    segmentSausageCharge κ (fun t => γ (T + t)) 0 S v R =
-      segmentSausageCharge κ γ T (T + S) v R := by
-  have hs : sourceSausageSet (fun t => γ (T + t)) 0 S v =
-      sourceSausageSet γ T (T + S) v := by
-    ext z
-    constructor
-    · rintro ⟨t, ht, hd⟩
-      exact ⟨T + t, ⟨le_add_of_nonneg_right bot_le, add_le_add le_rfl ht.2⟩, hd⟩
-    · rintro ⟨t, ht, hd⟩
-      refine ⟨t - T, ⟨bot_le, ?_⟩, ?_⟩
-      · exact (tsub_le_iff_right).mpr (by simpa only [add_comm] using ht.2)
-      · simpa only [add_tsub_cancel_of_le ht.1] using hd
-  simp only [segmentSausageCharge, hs]
-
-/-- The whole actual step and its sausage lower bound are adapted to the
-next front. Both global front times may be infinite off success. -/
-theorem ribbonStepSuccess_measurable
-    {Ω : Type*} [mΩ : MeasurableSpace Ω] (ℱ : Filtration ℝ≥0 mΩ)
-    (γ : Ω → ℝ≥0 → ℂ) (ha : Adapted ℱ (fun t ω => γ ω t))
-    (hc : ∀ ω, Continuous (γ ω))
-    (σ τ : Ω → WithTop ℝ≥0) (hσ : IsStoppingTime ℱ σ) (hτ : IsStoppingTime ℱ τ)
-    (hστ : σ ≤ τ) (P : ℂ → ℂ)
-    (he : Topology.IsClosedEmbedding (fun z : closedRibbon => P z))
-    (ε κ v c : ℝ) (R : Set ℂ) :
-    MeasurableSet[hτ.measurableSpace] (RibbonStepSuccess γ σ τ P ε κ v c R) := by
-  let f := fun ω => stoppedAtPath (sourceTracePath γ hc ω) (τ ω)
-  have hfm : Measurable[hτ.measurableSpace] f := stoppedAtPath_measurable ℱ γ ha hc τ hτ
-  have htm : Measurable[hτ.measurableSpace] (fun ω => (τ ω).untopD 0) := hτ.measurable.untopD 0
-  have hsm : Measurable[hτ.measurableSpace] (fun ω => (σ ω).untopD 0) :=
-    (hσ.measurable.mono (IsStoppingTime.measurableSpace_mono hσ hτ hστ) le_rfl).untopD 0
-  have hgood := goodRibbonPrefix_measurable ℱ γ ha hc τ hτ P he ε
-  let : MeasurableSpace Ω := hτ.measurableSpace
-  have hm := hgood.inter
-    (measurableSet_le (measurable_const : Measurable (fun _ : Ω => ENNReal.ofReal c))
-      (segmentSausageCharge_measurable f hfm _ _ hsm htm κ v R))
-  convert hm using 1
-  ext ω
-  by_cases hω : ω ∈ GoodRibbonPrefix γ τ P ε
-  · have ht := hω.1
-    lift τ ω to ℝ≥0 using ht with t hτt
-    have hs := sourceSausageSet_congr_interval
-      (s := (σ ω).untopD 0) (t := t)
-      (fun u hu => stoppedAtPath_eq_on_prefix (sourceTracePath γ hc ω) t
-        ⟨bot_le, hu.2⟩) v
-    simp only [RibbonStepSuccess, mem_inter_iff, mem_ofPred_eq, hω, true_and,
-      f, ← hτt, WithTop.untopD_coe, segmentSausageCharge, hs]
-    rfl
-  · simp only [RibbonStepSuccess, mem_inter_iff, mem_ofPred_eq, hω, false_and]
-
-end SLEExactGauge
-
-end
-
-end OAI
+import OAI.Probability.SLE.Gauge.RibbonGoodPrefix
+
+namespace OAI
+
+/-! Actual passage-and-mass successes are measured in the next global
+front past, with the earlier global front as the mass window's start. -/
+
+noncomputable section
+open Set Filter MeasureTheory ProbabilityTheory Metric
+open scoped Topology NNReal ENNReal
+
+namespace SLEExactGauge
+open RibbonCoordinates FirstFrontPassage FrontSuccessMeasurability
+
+local instance stepSuccessPathMeasurable : MeasurableSpace C(ℝ≥0, ℂ) := borel _
+local instance stepSuccessPathBorel : BorelSpace C(ℝ≥0, ℂ) := ⟨rfl⟩
+
+def RibbonStepSuccess {Ω : Type*} (γ : Ω → ℝ≥0 → ℂ)
+    (σ τ : Ω → WithTop ℝ≥0) (P : ℂ → ℂ) (ε κ v c : ℝ) (R : Set ℂ) : Set Ω :=
+  GoodRibbonPrefix γ τ P ε ∩ {ω | ENNReal.ofReal c ≤
+    segmentSausageCharge κ (γ ω) ((σ ω).untopD 0) ((τ ω).untopD 0) v R}
+
+lemma stoppedAtPath_eq_on_prefix (f : C(ℝ≥0, ℂ)) (t : ℝ≥0) :
+    EqOn (stoppedAtPath f (t : WithTop ℝ≥0)) f (Icc 0 t) := by
+  intro u hu
+  simp only [stoppedAtPath, WithTop.coe_ne_top, ite_false, WithTop.untopD_coe,
+    clampedPath, ContinuousMap.comp_apply, ContinuousMap.coe_mk, min_eq_left hu.2,
+    max_eq_right hu.1]
+
+lemma segmentSausageCharge_shift
+    (κ : ℝ) (γ : ℝ≥0 → ℂ) (T S : ℝ≥0) (v : ℝ) (R : Set ℂ) :
+    segmentSausageCharge κ (fun t => γ (T + t)) 0 S v R =
+      segmentSausageCharge κ γ T (T + S) v R := by
+  have hs : sourceSausageSet (fun t => γ (T + t)) 0 S v =
+      sourceSausageSet γ T (T + S) v := by
+    ext z
+    constructor
+    · rintro ⟨t, ht, hd⟩
+      exact ⟨T + t, ⟨le_add_of_nonneg_right bot_le, add_le_add le_rfl ht.2⟩, hd⟩
+    · rintro ⟨t, ht, hd⟩
+      refine ⟨t - T, ⟨bot_le, ?_⟩, ?_⟩
+      · exact (tsub_le_iff_right).mpr (by simpa only [add_comm] using ht.2)
+      · simpa only [add_tsub_cancel_of_le ht.1] using hd
+  simp only [segmentSausageCharge, hs]
+
+/-- The whole actual step and its sausage lower bound are adapted to the
+next front. Both global front times may be infinite off success. -/
+theorem ribbonStepSuccess_measurable
+    {Ω : Type*} [mΩ : MeasurableSpace Ω] (ℱ : Filtration ℝ≥0 mΩ)
+    (γ : Ω → ℝ≥0 → ℂ) (ha : Adapted ℱ (fun t ω => γ ω t))
+    (hc : ∀ ω, Continuous (γ ω))
+    (σ τ : Ω → WithTop ℝ≥0) (hσ : IsStoppingTime ℱ σ) (hτ : IsStoppingTime ℱ τ)
+    (hστ : σ ≤ τ) (P : ℂ → ℂ)
+    (he : Topology.IsClosedEmbedding (fun z : closedRibbon => P z))
+    (ε κ v c : ℝ) (R : Set ℂ) :
+    MeasurableSet[hτ.measurableSpace] (RibbonStepSuccess γ σ τ P ε κ v c R) := by
+  let f := fun ω => stoppedAtPath (sourceTracePath γ hc ω) (τ ω)
+  have hfm : Measurable[hτ.measurableSpace] f := stoppedAtPath_measurable ℱ γ ha hc τ hτ
+  have htm : Measurable[hτ.measurableSpace] (fun ω => (τ ω).untopD 0) := hτ.measurable.untopD 0
+  have hsm : Measurable[hτ.measurableSpace] (fun ω => (σ ω).untopD 0) :=
+    (hσ.measurable.mono (IsStoppingTime.measurableSpace_mono hσ hτ hστ) le_rfl).untopD 0
+  have hgood := goodRibbonPrefix_measurable ℱ γ ha hc τ hτ P he ε
+  let : MeasurableSpace Ω := hτ.measurableSpace
+  have hm := hgood.inter
+    (measurableSet_le (measurable_const : Measurable (fun _ : Ω => ENNReal.ofReal c))
+      (segmentSausageCharge_measurable f hfm _ _ hsm htm κ v R))
+  convert hm using 1
+  ext ω
+  by_cases hω : ω ∈ GoodRibbonPrefix γ τ P ε
+  · have ht := hω.1
+    lift τ ω to ℝ≥0 using ht with t hτt
+    have hs := sourceSausageSet_congr_interval
+      (s := (σ ω).untopD 0) (t := t)
+      (fun u hu => stoppedAtPath_eq_on_prefix (sourceTracePath γ hc ω) t
+        ⟨bot_le, hu.2⟩) v
+    simp only [RibbonStepSuccess, mem_inter_iff, mem_ofPred_eq, hω, true_and,
+      f, ← hτt, WithTop.untopD_coe, segmentSausageCharge, hs]
+    rfl
+  · simp only [RibbonStepSuccess, mem_inter_iff, mem_ofPred_eq, hω, false_and]
+
+end SLEExactGauge
+
+end
+
+end OAI

lean/OAI/Probability/SLE/Gauge/RibbonStepTranslation.lean

@@ -1,134 +1,134 @@
-import OAI.Probability.SLE.Gauge.UniformActualRibbonPassage
-import OAI.Probability.SLE.Gauge.LocalAffinePassage
-import OAI.Probability.SLE.Gauge.RibbonMiddleMass
-
-namespace OAI
-
-/-! The recentered passage uses precisely the original ribbon coordinate
-and original middle strip after translating back by the actual tip. -/
-
-noncomputable section
-open Set Filter MeasureTheory
-open scoped Topology NNReal ENNReal
-
-namespace SLEExactGauge
-open RibbonCoordinates RibbonPassageScaling BoundaryScaleLaw
-
-def RibbonHistory.stepChart {C L : ℝ≥0} {ε : ℝ}
-    (d : RibbonHistory C L ε) (z : ℂ) : ℂ := d.chart ((d.front : ℂ) + z)
-
-lemma RibbonHistory.stepCompact_maps {C L : ℝ≥0} {ε : ℝ}
-    (d : RibbonHistory C L ε) :
-    MapsTo (fun z : ℂ => (d.front : ℂ) + z) ribbonStepCompact closedRibbon := by
-  intro z hz
-  change 0 ≤ d.front + z.re ∧ |0 + z.im| ≤ 1
-  exact ⟨by linarith [d.front_ge_one, hz.1], by simpa using hz.2.2.trans (by norm_num)⟩
-
-lemma RibbonHistory.recenteredChart_injOn {C L : ℝ≥0} {ε : ℝ}
-    (d : RibbonHistory C L ε) : InjOn d.recenteredChart ribbonStepCompact := by
-  intro u hu v hv huv
-  have he := d.chart_injective (d.stepCompact_maps hu) (d.stepCompact_maps hv)
-    (sub_left_inj.mp huv)
-  exact add_left_cancel he
-
-lemma RibbonHistory.step_progress_agrees {C L : ℝ≥0} {ε : ℝ}
-    (d : RibbonHistory C L ε) :
-    ∀ z ∈ d.recenteredChart '' ribbonStepCompact,
-      longitudinalCoordinate d.chart closedRibbon d.front (affine (d.trace d.time) 1 z) =
-        longitudinalCoordinate d.recenteredChart ribbonStepCompact 0 z := by
-  rintro z ⟨w, hw, rfl⟩
-  have he : affine (d.trace d.time) 1 (d.recenteredChart w) =
-      d.chart ((d.front : ℂ) + w) := by
-    simp only [affine, Complex.ofReal_one, one_mul, RibbonHistory.recenteredChart]
-    abel
-  rw [he]
-  simp only [longitudinalCoordinate,
-    coordinateInverse_left d.chart_injective (d.stepCompact_maps hw),
-    coordinateInverse_left d.recenteredChart_injOn hw, Complex.add_re,
-    Complex.ofReal_re, add_sub_cancel_left, sub_zero]
-
-lemma RibbonHistory.affine_recentered {C L : ℝ≥0} {ε : ℝ}
-    (d : RibbonHistory C L ε) :
-    (fun z => affine (d.trace d.time) 1 (d.recenteredChart z)) = d.stepChart := by
-  funext z
-  simp only [affine, Complex.ofReal_one, one_mul, RibbonHistory.recenteredChart,
-    RibbonHistory.stepChart]
-  abel
-
-lemma RibbonHistory.passage_translate {C L : ℝ≥0} {ε : ℝ}
-    (d : RibbonHistory C L ε) :
-    affine (d.trace d.time) 1 ''
-        physicalPassageRegion d.recenteredChart ribbonStepCompact C ε (ε / L) =
-      physicalPassageRegion d.stepChart ribbonStepCompact C ε (ε / L) := by
-  unfold physicalPassageRegion
-  rw [← image_comp]
-  exact congrArg (fun f : ℂ → ℂ => f '' _) d.affine_recentered
-
-lemma RibbonHistory.middle_translate {C L : ℝ≥0} {ε : ℝ}
-    (d : RibbonHistory C L ε) (hε : ε ≤ 1 / 8) :
-    affine (d.trace d.time) 1 ''
-        physicalMiddleRegion d.recenteredChart ribbonStepCompact 0 ε =
-      physicalMiddleRegion d.chart closedRibbon d.front ε := by
-  unfold physicalMiddleRegion
-  rw [← image_comp]
-  rw [show affine (d.trace d.time) 1 ∘ d.recenteredChart = d.stepChart from
-    d.affine_recentered]
-  ext z
-  constructor
-  · rintro ⟨w, ⟨hw, hwl, hwu, hwi⟩, rfl⟩
-    refine ⟨(d.front : ℂ) + w, ⟨d.stepCompact_maps hw, ?_, ?_, ?_⟩, rfl⟩
-    · simpa only [Complex.add_re, Complex.ofReal_re, add_sub_cancel_left, sub_zero] using hwl
-    · simpa only [Complex.add_re, Complex.ofReal_re, add_sub_cancel_left, sub_zero] using hwu
-    · simpa only [Complex.add_im, Complex.ofReal_im, zero_add] using hwi
-  · rintro ⟨w, ⟨_, hwl, hwu, hwi⟩, rfl⟩
-    refine ⟨w - (d.front : ℂ), ⟨?_, ?_, ?_, ?_⟩, ?_⟩
-    · change -(1 / 2 : ℝ) ≤ w.re - d.front ∧ w.re - d.front ≤ 5 / 2 ∧
-        |w.im - 0| ≤ 1 / 2
-      exact ⟨by linarith, by linarith, by simpa using hwi.le.trans (by linarith)⟩
-    · simpa only [Complex.sub_re, Complex.ofReal_re, sub_zero] using hwl
-    · simpa only [Complex.sub_re, Complex.ofReal_re, sub_zero] using hwu
-    · simpa only [Complex.sub_im, Complex.ofReal_im, sub_zero] using hwi
-    · simp only [RibbonHistory.stepChart, add_sub_cancel]
-
-/-- Translating the actual finite boundary image back to its original tip
-preserves the full probability, including the original middle-strip mass. -/
-theorem RibbonHistory.frontMass_probability_translate
-    {Ω : Type*} [MeasurableSpace Ω] (P : Measure Ω)
-    {C L : ℝ≥0} {ε : ℝ} (d : RibbonHistory C L ε) (hε : ε ≤ 1 / 8)
-    (η : Ω → ℝ≥0 → ℂ) (κ v c : ℝ) (hv : 0 < v) :
-    P {ω | (fun t => affine (d.trace d.time) 1 (η ω t)) ∈
-        {f : ℝ≥0 → ℂ | f ∈ PassageSuccess.FrontSuccess
-          (fun _ (f : ℝ≥0 → ℂ) => f)
-          (fun _ => longitudinalCoordinate d.chart closedRibbon d.front) (fun _ => 0)
-          (fun _ => physicalPassageRegion d.stepChart ribbonStepCompact C ε (ε / L))
-          (fun _ => d.chart ((d.front : ℂ) + 1)) (ε / L) 0 ∧
-          ENNReal.ofReal c ≤ segmentSausageCharge κ f 0
-            (FirstFrontPassage.frontTime
-              (fun t => longitudinalCoordinate d.chart closedRibbon d.front (f t)) 1)
-            v (physicalMiddleRegion d.chart closedRibbon d.front ε)}} =
-      P {ω | η ω ∈ PassageSuccess.FrontSuccess
-          (fun _ (f : ℝ≥0 → ℂ) => f)
-          (fun _ => longitudinalCoordinate d.recenteredChart ribbonStepCompact 0) (fun _ => 0)
-          (fun _ => physicalPassageRegion d.recenteredChart ribbonStepCompact C ε (ε / L))
-          (fun _ => d.recenteredChart 1) (ε / L) 0 ∧
-        ENNReal.ofReal c ≤ segmentSausageCharge κ (η ω) 0
-          (FirstFrontPassage.frontTime
-            (fun t => longitudinalCoordinate d.recenteredChart ribbonStepCompact 0 (η ω t)) 1)
-          v (physicalMiddleRegion d.recenteredChart ribbonStepCompact 0 ε)} := by
-  have hh := frontSuccess_mass_probability_affine_local P
-    (fun _ => η) (fun _ => longitudinalCoordinate d.recenteredChart ribbonStepCompact 0)
-    (fun _ => longitudinalCoordinate d.chart closedRibbon d.front) (fun _ => 0)
-    (fun _ => physicalPassageRegion d.recenteredChart ribbonStepCompact C ε (ε / L))
-    (fun _ => d.recenteredChart 1) (ε / L) (d.trace d.time) (by norm_num : (0 : ℝ) < 1) 0
-    (fun z hz => d.step_progress_agrees z (image_mono inter_subset_left hz))
-    κ (physicalMiddleRegion d.recenteredChart ribbonStepCompact 0 ε) hv c
-  have htarget : affine (d.trace d.time) 1 (d.recenteredChart 1) =
-      d.chart ((d.front : ℂ) + 1) := congrFun d.affine_recentered 1
-  simpa only [d.passage_translate, d.middle_translate hε, htarget, one_mul,
-    Real.one_rpow, mul_one, mem_ofPred_eq, PassageSuccess.FrontSuccess] using hh
-
-end SLEExactGauge
-
-end
-
-end OAI
+import OAI.Probability.SLE.Gauge.UniformActualRibbonPassage
+import OAI.Probability.SLE.Gauge.LocalAffinePassage
+import OAI.Probability.SLE.Gauge.RibbonMiddleMass
+
+namespace OAI
+
+/-! The recentered passage uses precisely the original ribbon coordinate
+and original middle strip after translating back by the actual tip. -/
+
+noncomputable section
+open Set Filter MeasureTheory
+open scoped Topology NNReal ENNReal
+
+namespace SLEExactGauge
+open RibbonCoordinates RibbonPassageScaling BoundaryScaleLaw
+
+def RibbonHistory.stepChart {C L : ℝ≥0} {ε : ℝ}
+    (d : RibbonHistory C L ε) (z : ℂ) : ℂ := d.chart ((d.front : ℂ) + z)
+
+lemma RibbonHistory.stepCompact_maps {C L : ℝ≥0} {ε : ℝ}
+    (d : RibbonHistory C L ε) :
+    MapsTo (fun z : ℂ => (d.front : ℂ) + z) ribbonStepCompact closedRibbon := by
+  intro z hz
+  change 0 ≤ d.front + z.re ∧ |0 + z.im| ≤ 1
+  exact ⟨by linarith [d.front_ge_one, hz.1], by simpa using hz.2.2.trans (by norm_num)⟩
+
+lemma RibbonHistory.recenteredChart_injOn {C L : ℝ≥0} {ε : ℝ}
+    (d : RibbonHistory C L ε) : InjOn d.recenteredChart ribbonStepCompact := by
+  intro u hu v hv huv
+  have he := d.chart_injective (d.stepCompact_maps hu) (d.stepCompact_maps hv)
+    (sub_left_inj.mp huv)
+  exact add_left_cancel he
+
+lemma RibbonHistory.step_progress_agrees {C L : ℝ≥0} {ε : ℝ}
+    (d : RibbonHistory C L ε) :
+    ∀ z ∈ d.recenteredChart '' ribbonStepCompact,
+      longitudinalCoordinate d.chart closedRibbon d.front (affine (d.trace d.time) 1 z) =
+        longitudinalCoordinate d.recenteredChart ribbonStepCompact 0 z := by
+  rintro z ⟨w, hw, rfl⟩
+  have he : affine (d.trace d.time) 1 (d.recenteredChart w) =
+      d.chart ((d.front : ℂ) + w) := by
+    simp only [affine, Complex.ofReal_one, one_mul, RibbonHistory.recenteredChart]
+    abel
+  rw [he]
+  simp only [longitudinalCoordinate,
+    coordinateInverse_left d.chart_injective (d.stepCompact_maps hw),
+    coordinateInverse_left d.recenteredChart_injOn hw, Complex.add_re,
+    Complex.ofReal_re, add_sub_cancel_left, sub_zero]
+
+lemma RibbonHistory.affine_recentered {C L : ℝ≥0} {ε : ℝ}
+    (d : RibbonHistory C L ε) :
+    (fun z => affine (d.trace d.time) 1 (d.recenteredChart z)) = d.stepChart := by
+  funext z
+  simp only [affine, Complex.ofReal_one, one_mul, RibbonHistory.recenteredChart,
+    RibbonHistory.stepChart]
+  abel
+
+lemma RibbonHistory.passage_translate {C L : ℝ≥0} {ε : ℝ}
+    (d : RibbonHistory C L ε) :
+    affine (d.trace d.time) 1 ''
+        physicalPassageRegion d.recenteredChart ribbonStepCompact C ε (ε / L) =
+      physicalPassageRegion d.stepChart ribbonStepCompact C ε (ε / L) := by
+  unfold physicalPassageRegion
+  rw [← image_comp]
+  exact congrArg (fun f : ℂ → ℂ => f '' _) d.affine_recentered
+
+lemma RibbonHistory.middle_translate {C L : ℝ≥0} {ε : ℝ}
+    (d : RibbonHistory C L ε) (hε : ε ≤ 1 / 8) :
+    affine (d.trace d.time) 1 ''
+        physicalMiddleRegion d.recenteredChart ribbonStepCompact 0 ε =
+      physicalMiddleRegion d.chart closedRibbon d.front ε := by
+  unfold physicalMiddleRegion
+  rw [← image_comp]
+  rw [show affine (d.trace d.time) 1 ∘ d.recenteredChart = d.stepChart from
+    d.affine_recentered]
+  ext z
+  constructor
+  · rintro ⟨w, ⟨hw, hwl, hwu, hwi⟩, rfl⟩
+    refine ⟨(d.front : ℂ) + w, ⟨d.stepCompact_maps hw, ?_, ?_, ?_⟩, rfl⟩
+    · simpa only [Complex.add_re, Complex.ofReal_re, add_sub_cancel_left, sub_zero] using hwl
+    · simpa only [Complex.add_re, Complex.ofReal_re, add_sub_cancel_left, sub_zero] using hwu
+    · simpa only [Complex.add_im, Complex.ofReal_im, zero_add] using hwi
+  · rintro ⟨w, ⟨_, hwl, hwu, hwi⟩, rfl⟩
+    refine ⟨w - (d.front : ℂ), ⟨?_, ?_, ?_, ?_⟩, ?_⟩
+    · change -(1 / 2 : ℝ) ≤ w.re - d.front ∧ w.re - d.front ≤ 5 / 2 ∧
+        |w.im - 0| ≤ 1 / 2
+      exact ⟨by linarith, by linarith, by simpa using hwi.le.trans (by linarith)⟩
+    · simpa only [Complex.sub_re, Complex.ofReal_re, sub_zero] using hwl
+    · simpa only [Complex.sub_re, Complex.ofReal_re, sub_zero] using hwu
+    · simpa only [Complex.sub_im, Complex.ofReal_im, sub_zero] using hwi
+    · simp only [RibbonHistory.stepChart, add_sub_cancel]
+
+/-- Translating the actual finite boundary image back to its original tip
+preserves the full probability, including the original middle-strip mass. -/
+theorem RibbonHistory.frontMass_probability_translate
+    {Ω : Type*} [MeasurableSpace Ω] (P : Measure Ω)
+    {C L : ℝ≥0} {ε : ℝ} (d : RibbonHistory C L ε) (hε : ε ≤ 1 / 8)
+    (η : Ω → ℝ≥0 → ℂ) (κ v c : ℝ) (hv : 0 < v) :
+    P {ω | (fun t => affine (d.trace d.time) 1 (η ω t)) ∈
+        {f : ℝ≥0 → ℂ | f ∈ PassageSuccess.FrontSuccess
+          (fun _ (f : ℝ≥0 → ℂ) => f)
+          (fun _ => longitudinalCoordinate d.chart closedRibbon d.front) (fun _ => 0)
+          (fun _ => physicalPassageRegion d.stepChart ribbonStepCompact C ε (ε / L))
+          (fun _ => d.chart ((d.front : ℂ) + 1)) (ε / L) 0 ∧
+          ENNReal.ofReal c ≤ segmentSausageCharge κ f 0
+            (FirstFrontPassage.frontTime
+              (fun t => longitudinalCoordinate d.chart closedRibbon d.front (f t)) 1)
+            v (physicalMiddleRegion d.chart closedRibbon d.front ε)}} =
+      P {ω | η ω ∈ PassageSuccess.FrontSuccess
+          (fun _ (f : ℝ≥0 → ℂ) => f)
+          (fun _ => longitudinalCoordinate d.recenteredChart ribbonStepCompact 0) (fun _ => 0)
+          (fun _ => physicalPassageRegion d.recenteredChart ribbonStepCompact C ε (ε / L))
+          (fun _ => d.recenteredChart 1) (ε / L) 0 ∧
+        ENNReal.ofReal c ≤ segmentSausageCharge κ (η ω) 0
+          (FirstFrontPassage.frontTime
+            (fun t => longitudinalCoordinate d.recenteredChart ribbonStepCompact 0 (η ω t)) 1)
+          v (physicalMiddleRegion d.recenteredChart ribbonStepCompact 0 ε)} := by
+  have hh := frontSuccess_mass_probability_affine_local P
+    (fun _ => η) (fun _ => longitudinalCoordinate d.recenteredChart ribbonStepCompact 0)
+    (fun _ => longitudinalCoordinate d.chart closedRibbon d.front) (fun _ => 0)
+    (fun _ => physicalPassageRegion d.recenteredChart ribbonStepCompact C ε (ε / L))
+    (fun _ => d.recenteredChart 1) (ε / L) (d.trace d.time) (by norm_num : (0 : ℝ) < 1) 0
+    (fun z hz => d.step_progress_agrees z (image_mono inter_subset_left hz))
+    κ (physicalMiddleRegion d.recenteredChart ribbonStepCompact 0 ε) hv c
+  have htarget : affine (d.trace d.time) 1 (d.recenteredChart 1) =
+      d.chart ((d.front : ℂ) + 1) := congrFun d.affine_recentered 1
+  simpa only [d.passage_translate, d.middle_translate hε, htarget, one_mul,
+    Real.one_rpow, mul_one, mem_ofPred_eq, PassageSuccess.FrontSuccess] using hh
+
+end SLEExactGauge
+
+end
+
+end OAI

lean/OAI/Probability/SLE/Gauge/RibbonStoppedMassLaw.lean

@@ -1,46 +1,46 @@
-import OAI.Probability.SLE.Gauge.RibbonStoppedMassTransport
-
-namespace OAI
-
-/-! Transfer a completed-ribbon experiment through the actual SLE scaling
-law on continuous traces. No uniform step estimate is reapplied to a chart
-whose spatial scale varies with the number of strips. -/
-
-noncomputable section
-open Set Filter MeasureTheory
-open scoped Topology NNReal ENNReal
-
-namespace SLEExactGauge
-open RibbonCoordinates ScaleTraceLaw RibbonPassageScaling
-
-local instance : MeasurableSpace C(ℝ≥0, ℂ) := borel _
-local instance : BorelSpace C(ℝ≥0, ℂ) := ⟨rfl⟩
-
-lemma ribbonStoppedMass_scale_probability
-    {Ω : Type*} [MeasurableSpace Ω] (μ : Measure Ω)
-    (f : Ω → C(ℝ≥0, ℂ)) (hf : Measurable f)
-    (c : ℝ≥0) (hc : 0 < c)
-    (hlaw : μ.map (fun ω => scalePath c (f ω)) = μ.map f)
-    (P : ℂ → ℂ)
-    (he : Topology.IsClosedEmbedding (fun z : closedRibbon => (c : ℂ) * P z))
-    (g g' : C(ℂ, ℝ)) (hgg' : ∀ z : ℂ, g' ((c : ℂ) * z) = g z)
-    (k ε κ : ℝ) {v : ℝ} (hv : 0 < v) (D : Set ℂ) (b : ℝ≥0∞) :
-    μ {ω | f ω ∈ ribbonStoppedMassEvent P g k ε κ v D b} ≤
-      μ {ω | f ω ∈ ribbonStoppedMassEvent (fun z => (c : ℂ) * P z) g' k ε κ
-        ((c : ℝ) * v) (affine 0 c '' D) (ENNReal.ofReal ((c : ℝ) ^ dimension κ) * b)} := by
-  let E := ribbonStoppedMassEvent (fun z => (c : ℂ) * P z) g' k ε κ
-    ((c : ℝ) * v) (affine 0 c '' D) (ENNReal.ofReal ((c : ℝ) ^ dimension κ) * b)
-  have hE : MeasurableSet E := measurableSet_ribbonStoppedMassEvent _ he g' k ε κ _ _ _
-  calc
-    _ ≤ μ {ω | scalePath c (f ω) ∈ E} := measure_mono (fun ω hω =>
-      mem_ribbonStoppedMassEvent_scalePath c hc (f ω) P g g' hgg' k ε κ hv D b hω)
-    _ = (μ.map (fun ω => scalePath c (f ω))) E :=
-      (Measure.map_apply ((measurable_scalePath c).comp hf) hE).symm
-    _ = (μ.map f) E := by rw [hlaw]
-    _ = _ := Measure.map_apply hf hE
-
-end SLEExactGauge
-
-end
-
-end OAI
+import OAI.Probability.SLE.Gauge.RibbonStoppedMassTransport
+
+namespace OAI
+
+/-! Transfer a completed-ribbon experiment through the actual SLE scaling
+law on continuous traces. No uniform step estimate is reapplied to a chart
+whose spatial scale varies with the number of strips. -/
+
+noncomputable section
+open Set Filter MeasureTheory
+open scoped Topology NNReal ENNReal
+
+namespace SLEExactGauge
+open RibbonCoordinates ScaleTraceLaw RibbonPassageScaling
+
+local instance : MeasurableSpace C(ℝ≥0, ℂ) := borel _
+local instance : BorelSpace C(ℝ≥0, ℂ) := ⟨rfl⟩
+
+lemma ribbonStoppedMass_scale_probability
+    {Ω : Type*} [MeasurableSpace Ω] (μ : Measure Ω)
+    (f : Ω → C(ℝ≥0, ℂ)) (hf : Measurable f)
+    (c : ℝ≥0) (hc : 0 < c)
+    (hlaw : μ.map (fun ω => scalePath c (f ω)) = μ.map f)
+    (P : ℂ → ℂ)
+    (he : Topology.IsClosedEmbedding (fun z : closedRibbon => (c : ℂ) * P z))
+    (g g' : C(ℂ, ℝ)) (hgg' : ∀ z : ℂ, g' ((c : ℂ) * z) = g z)
+    (k ε κ : ℝ) {v : ℝ} (hv : 0 < v) (D : Set ℂ) (b : ℝ≥0∞) :
+    μ {ω | f ω ∈ ribbonStoppedMassEvent P g k ε κ v D b} ≤
+      μ {ω | f ω ∈ ribbonStoppedMassEvent (fun z => (c : ℂ) * P z) g' k ε κ
+        ((c : ℝ) * v) (affine 0 c '' D) (ENNReal.ofReal ((c : ℝ) ^ dimension κ) * b)} := by
+  let E := ribbonStoppedMassEvent (fun z => (c : ℂ) * P z) g' k ε κ
+    ((c : ℝ) * v) (affine 0 c '' D) (ENNReal.ofReal ((c : ℝ) ^ dimension κ) * b)
+  have hE : MeasurableSet E := measurableSet_ribbonStoppedMassEvent _ he g' k ε κ _ _ _
+  calc
+    _ ≤ μ {ω | scalePath c (f ω) ∈ E} := measure_mono (fun ω hω =>
+      mem_ribbonStoppedMassEvent_scalePath c hc (f ω) P g g' hgg' k ε κ hv D b hω)
+    _ = (μ.map (fun ω => scalePath c (f ω))) E :=
+      (Measure.map_apply ((measurable_scalePath c).comp hf) hE).symm
+    _ = (μ.map f) E := by rw [hlaw]
+    _ = _ := Measure.map_apply hf hE
+
+end SLEExactGauge
+
+end
+
+end OAI

lean/OAI/Probability/SLE/Gauge/RibbonStoppedMassTransport.lean

@@ -1,105 +1,105 @@
-import OAI.Probability.SLE.Gauge.RibbonPrefixTransport
-import OAI.Probability.SLE.Gauge.RibbonStepSuccess
-
-namespace OAI
-
-/-! Exact spatial and capacity transport of a completed ribbon's stopped
-mass. The completion is the actual first front of the transported trace. -/
-
-noncomputable section
-open Set Filter MeasureTheory ProbabilityTheory
-open scoped Topology NNReal ENNReal
-
-namespace SLEExactGauge
-open RibbonCoordinates FirstFrontPassage FrontClockChange ScaleTraceLaw
-open FrontSuccessMeasurability RibbonPassageScaling
-
-local instance : MeasurableSpace C(ℝ≥0, ℂ) := borel _
-local instance : BorelSpace C(ℝ≥0, ℂ) := ⟨rfl⟩
-
-lemma firstFrontTime_scalePath_of_finite
-    (c : ℝ≥0) (hc : 0 < c) (p : C(ℝ≥0, ℂ)) (g g' : C(ℂ, ℝ))
-    (hgg' : ∀ z : ℂ, g' ((c : ℂ) * z) = g z) (k : ℝ) (T : ℝ≥0)
-    (hT : firstFrontTime (fun t => g (p t)) k = (T : WithTop ℝ≥0)) :
-    firstFrontTime (fun t => g' (scalePath c p t)) k = ((c ^ 2 * T : ℝ≥0) : WithTop ℝ≥0) := by
-  let e := OrderIso.mulLeft₀ (c ^ 2) (pow_pos hc 2)
-  have heval (t : ℝ≥0) : scalePath c p (e t) = (c : ℂ) * p t :=
-    scalePath_at_scaled_time c hc p t
-  have hclock : (fun t => g' (scalePath c p (e t))) = (fun t => g (p t)) := by
-    funext t
-    rw [heval, hgg']
-  have hhit := firstFrontTime_attained _ (g.continuous.comp p.continuous) k T hT
-  exact firstFrontTime_of_clock_hit e (fun t => g' (scalePath c p t)) k T
-    (by rw [hclock]; exact hT) (by rw [heval, hgg']; exact hhit)
-
-lemma segmentSausageCharge_scalePath
-    (κ : ℝ) (c : ℝ≥0) (hc : 0 < c) (p : C(ℝ≥0, ℂ)) (T : ℝ≥0)
-    {v : ℝ} (hv : 0 < v) (D : Set ℂ) :
-    segmentSausageCharge κ (scalePath c p) 0 (c ^ 2 * T) ((c : ℝ) * v) (affine 0 c '' D) =
-      ENNReal.ofReal ((c : ℝ) ^ dimension κ) * segmentSausageCharge κ p 0 T v D := by
-  let e := OrderIso.mulLeft₀ (c ^ 2) (pow_pos hc 2)
-  have he0 : e 0 = 0 := by change c ^ 2 * 0 = 0; exact mul_zero _
-  have hpath : (fun t => scalePath c p (e t)) = (fun t => affine 0 c (p t)) := by
-    funext t
-    change scalePath c p (c ^ 2 * t) = affine 0 c (p t)
-    simpa only [affine, zero_add] using scalePath_at_scaled_time c hc p t
-  calc
-    _ = segmentSausageCharge κ (fun t => scalePath c p (e t)) 0 T ((c : ℝ) * v)
-        (affine 0 c '' D) := by rw [segmentSausageCharge_clock, he0]; rfl
-    _ = segmentSausageCharge κ (fun t => affine 0 c (p t)) 0 T ((c : ℝ) * v)
-        (affine 0 c '' D) := by rw [hpath]
-    _ = _ := segmentSausageCharge_affine κ 0 (show 0 < (c : ℝ) from hc) p 0 T hv D
-
-def ribbonStoppedMassEvent (P : ℂ → ℂ) (g : C(ℂ, ℝ)) (k ε κ v : ℝ)
-    (D : Set ℂ) (b : ℝ≥0∞) : Set C(ℝ≥0, ℂ) :=
-  {p | p ∈ GoodRibbonPrefix (fun p : C(ℝ≥0, ℂ) => (p : ℝ≥0 → ℂ))
-      (ribbonFrontStop g (fun p : C(ℝ≥0, ℂ) => (p : ℝ≥0 → ℂ)) k) P ε ∧
-    b ≤ segmentSausageCharge κ p 0 ((firstFrontTime (fun t => g (p t)) k).untopD 0) v D}
-
-lemma measurableSet_ribbonStoppedMassEvent
-    (P : ℂ → ℂ) (he : Topology.IsClosedEmbedding (fun z : closedRibbon => P z))
-    (g : C(ℂ, ℝ)) (k ε κ v : ℝ) (D : Set ℂ) (b : ℝ≥0∞) :
-    MeasurableSet (ribbonStoppedMassEvent P g k ε κ v D b) := by
-  let ℱ : Filtration ℝ≥0 (borel C(ℝ≥0, ℂ)) :=
-    Filtration.const ℝ≥0 (borel C(ℝ≥0, ℂ)) le_rfl
-  let γ := fun p : C(ℝ≥0, ℂ) => (p : ℝ≥0 → ℂ)
-  have ha : Adapted ℱ (fun t p => γ p t) := by
-    intro t
-    change @Measurable C(ℝ≥0, ℂ) ℂ (borel C(ℝ≥0, ℂ)) _ (fun p => p t)
-    exact (continuous_eval_const t).measurable
-  have hτ := ribbonFrontStop_stopping ℱ g γ ha (fun p => p.continuous) k
-  have hg : MeasurableSet (GoodRibbonPrefix γ (ribbonFrontStop g γ k) P ε) :=
-    hτ.measurableSpace_le _ (goodRibbonPrefix_measurable ℱ γ ha (fun p => p.continuous) _ hτ P he ε)
-  exact hg.inter (measurableSet_le measurable_const
-    (segmentSausageCharge_measurable id measurable_id (fun _ => 0)
-      (fun p => (firstFrontTime (fun t => g (p t)) k).untopD 0)
-      measurable_const (hτ.measurable'.untopD 0) κ v D))
-
-/-- Transport uses the same actual completed prefix and a deterministically
-scaled mesh, region and mass threshold. -/
-theorem mem_ribbonStoppedMassEvent_scalePath
-    (c : ℝ≥0) (hc : 0 < c) (p : C(ℝ≥0, ℂ)) (P : ℂ → ℂ)
-    (g g' : C(ℂ, ℝ)) (hgg' : ∀ z : ℂ, g' ((c : ℂ) * z) = g z)
-    (k ε κ : ℝ) {v : ℝ} (hv : 0 < v) (D : Set ℂ) (b : ℝ≥0∞)
-    (hp : p ∈ ribbonStoppedMassEvent P g k ε κ v D b) :
-    scalePath c p ∈ ribbonStoppedMassEvent (fun z => (c : ℂ) * P z) g' k ε κ
-      ((c : ℝ) * v) (affine 0 c '' D) (ENNReal.ofReal ((c : ℝ) ^ dimension κ) * b) := by
-  have hpref : () ∈ GoodRibbonPrefix (fun _ : Unit => (p : ℝ≥0 → ℂ))
-      (fun _ => firstFrontTime (fun t => g (p t)) k) P ε := hp.1
-  have hnew := goodRibbonPrefix_scalePath c hc p P g g' hgg' k ε hpref
-  refine ⟨hnew, ?_⟩
-  cases hT : firstFrontTime (fun t => g (p t)) k with
-  | top => exact False.elim (hpref.1 hT)
-  | coe T =>
-    have ht := firstFrontTime_scalePath_of_finite c hc p g g' hgg' k T hT
-    change _ ≤ segmentSausageCharge κ (scalePath c p) 0
-      ((firstFrontTime (fun t => g' (scalePath c p t)) k).untopD 0) _ _
-    rw [ht, WithTop.untopD_coe, segmentSausageCharge_scalePath κ c hc p T hv]
-    apply mul_le_mul' le_rfl
-    simpa only [hT, WithTop.untopD_coe] using hp.2
-
-end SLEExactGauge
-
-end
-
-end OAI
+import OAI.Probability.SLE.Gauge.RibbonPrefixTransport
+import OAI.Probability.SLE.Gauge.RibbonStepSuccess
+
+namespace OAI
+
+/-! Exact spatial and capacity transport of a completed ribbon's stopped
+mass. The completion is the actual first front of the transported trace. -/
+
+noncomputable section
+open Set Filter MeasureTheory ProbabilityTheory
+open scoped Topology NNReal ENNReal
+
+namespace SLEExactGauge
+open RibbonCoordinates FirstFrontPassage FrontClockChange ScaleTraceLaw
+open FrontSuccessMeasurability RibbonPassageScaling
+
+local instance : MeasurableSpace C(ℝ≥0, ℂ) := borel _
+local instance : BorelSpace C(ℝ≥0, ℂ) := ⟨rfl⟩
+
+lemma firstFrontTime_scalePath_of_finite
+    (c : ℝ≥0) (hc : 0 < c) (p : C(ℝ≥0, ℂ)) (g g' : C(ℂ, ℝ))
+    (hgg' : ∀ z : ℂ, g' ((c : ℂ) * z) = g z) (k : ℝ) (T : ℝ≥0)
+    (hT : firstFrontTime (fun t => g (p t)) k = (T : WithTop ℝ≥0)) :
+    firstFrontTime (fun t => g' (scalePath c p t)) k = ((c ^ 2 * T : ℝ≥0) : WithTop ℝ≥0) := by
+  let e := OrderIso.mulLeft₀ (c ^ 2) (pow_pos hc 2)
+  have heval (t : ℝ≥0) : scalePath c p (e t) = (c : ℂ) * p t :=
+    scalePath_at_scaled_time c hc p t
+  have hclock : (fun t => g' (scalePath c p (e t))) = (fun t => g (p t)) := by
+    funext t
+    rw [heval, hgg']
+  have hhit := firstFrontTime_attained _ (g.continuous.comp p.continuous) k T hT
+  exact firstFrontTime_of_clock_hit e (fun t => g' (scalePath c p t)) k T
+    (by rw [hclock]; exact hT) (by rw [heval, hgg']; exact hhit)
+
+lemma segmentSausageCharge_scalePath
+    (κ : ℝ) (c : ℝ≥0) (hc : 0 < c) (p : C(ℝ≥0, ℂ)) (T : ℝ≥0)
+    {v : ℝ} (hv : 0 < v) (D : Set ℂ) :
+    segmentSausageCharge κ (scalePath c p) 0 (c ^ 2 * T) ((c : ℝ) * v) (affine 0 c '' D) =
+      ENNReal.ofReal ((c : ℝ) ^ dimension κ) * segmentSausageCharge κ p 0 T v D := by
+  let e := OrderIso.mulLeft₀ (c ^ 2) (pow_pos hc 2)
+  have he0 : e 0 = 0 := by change c ^ 2 * 0 = 0; exact mul_zero _
+  have hpath : (fun t => scalePath c p (e t)) = (fun t => affine 0 c (p t)) := by
+    funext t
+    change scalePath c p (c ^ 2 * t) = affine 0 c (p t)
+    simpa only [affine, zero_add] using scalePath_at_scaled_time c hc p t
+  calc
+    _ = segmentSausageCharge κ (fun t => scalePath c p (e t)) 0 T ((c : ℝ) * v)
+        (affine 0 c '' D) := by rw [segmentSausageCharge_clock, he0]; rfl
+    _ = segmentSausageCharge κ (fun t => affine 0 c (p t)) 0 T ((c : ℝ) * v)
+        (affine 0 c '' D) := by rw [hpath]
+    _ = _ := segmentSausageCharge_affine κ 0 (show 0 < (c : ℝ) from hc) p 0 T hv D
+
+def ribbonStoppedMassEvent (P : ℂ → ℂ) (g : C(ℂ, ℝ)) (k ε κ v : ℝ)
+    (D : Set ℂ) (b : ℝ≥0∞) : Set C(ℝ≥0, ℂ) :=
+  {p | p ∈ GoodRibbonPrefix (fun p : C(ℝ≥0, ℂ) => (p : ℝ≥0 → ℂ))
+      (ribbonFrontStop g (fun p : C(ℝ≥0, ℂ) => (p : ℝ≥0 → ℂ)) k) P ε ∧
+    b ≤ segmentSausageCharge κ p 0 ((firstFrontTime (fun t => g (p t)) k).untopD 0) v D}
+
+lemma measurableSet_ribbonStoppedMassEvent
+    (P : ℂ → ℂ) (he : Topology.IsClosedEmbedding (fun z : closedRibbon => P z))
+    (g : C(ℂ, ℝ)) (k ε κ v : ℝ) (D : Set ℂ) (b : ℝ≥0∞) :
+    MeasurableSet (ribbonStoppedMassEvent P g k ε κ v D b) := by
+  let ℱ : Filtration ℝ≥0 (borel C(ℝ≥0, ℂ)) :=
+    Filtration.const ℝ≥0 (borel C(ℝ≥0, ℂ)) le_rfl
+  let γ := fun p : C(ℝ≥0, ℂ) => (p : ℝ≥0 → ℂ)
+  have ha : Adapted ℱ (fun t p => γ p t) := by
+    intro t
+    change @Measurable C(ℝ≥0, ℂ) ℂ (borel C(ℝ≥0, ℂ)) _ (fun p => p t)
+    exact (continuous_eval_const t).measurable
+  have hτ := ribbonFrontStop_stopping ℱ g γ ha (fun p => p.continuous) k
+  have hg : MeasurableSet (GoodRibbonPrefix γ (ribbonFrontStop g γ k) P ε) :=
+    hτ.measurableSpace_le _ (goodRibbonPrefix_measurable ℱ γ ha (fun p => p.continuous) _ hτ P he ε)
+  exact hg.inter (measurableSet_le measurable_const
+    (segmentSausageCharge_measurable id measurable_id (fun _ => 0)
+      (fun p => (firstFrontTime (fun t => g (p t)) k).untopD 0)
+      measurable_const (hτ.measurable'.untopD 0) κ v D))
+
+/-- Transport uses the same actual completed prefix and a deterministically
+scaled mesh, region and mass threshold. -/
+theorem mem_ribbonStoppedMassEvent_scalePath
+    (c : ℝ≥0) (hc : 0 < c) (p : C(ℝ≥0, ℂ)) (P : ℂ → ℂ)
+    (g g' : C(ℂ, ℝ)) (hgg' : ∀ z : ℂ, g' ((c : ℂ) * z) = g z)
+    (k ε κ : ℝ) {v : ℝ} (hv : 0 < v) (D : Set ℂ) (b : ℝ≥0∞)
+    (hp : p ∈ ribbonStoppedMassEvent P g k ε κ v D b) :
+    scalePath c p ∈ ribbonStoppedMassEvent (fun z => (c : ℂ) * P z) g' k ε κ
+      ((c : ℝ) * v) (affine 0 c '' D) (ENNReal.ofReal ((c : ℝ) ^ dimension κ) * b) := by
+  have hpref : () ∈ GoodRibbonPrefix (fun _ : Unit => (p : ℝ≥0 → ℂ))
+      (fun _ => firstFrontTime (fun t => g (p t)) k) P ε := hp.1
+  have hnew := goodRibbonPrefix_scalePath c hc p P g g' hgg' k ε hpref
+  refine ⟨hnew, ?_⟩
+  cases hT : firstFrontTime (fun t => g (p t)) k with
+  | top => exact False.elim (hpref.1 hT)
+  | coe T =>
+    have ht := firstFrontTime_scalePath_of_finite c hc p g g' hgg' k T hT
+    change _ ≤ segmentSausageCharge κ (scalePath c p) 0
+      ((firstFrontTime (fun t => g' (scalePath c p t)) k).untopD 0) _ _
+    rw [ht, WithTop.untopD_coe, segmentSausageCharge_scalePath κ c hc p T hv]
+    apply mul_le_mul' le_rfl
+    simpa only [hT, WithTop.untopD_coe] using hp.2
+
+end SLEExactGauge
+
+end
+
+end OAI

lean/OAI/Probability/SLE/Gauge/RibbonSurvival.lean

@@ -1,81 +1,81 @@
-import OAI.Probability.SLE.Geometry.GuideTube
-import OAI.Probability.SLE.NearRealContraction
-
-namespace OAI
-
-/-! Actual surviving-component assertions for access rays and the splice.
-Containment of the past in the initial rectangle implies that every point
-above or beside it belongs to the unbounded surviving component. -/
-
-noncomputable section
-open Set Filter MeasureTheory Metric
-open scoped Topology NNReal
-
-namespace SLEExactGauge
-
-theorem survives_of_unbounded_free_curve
-    (γ : ℝ≥0 → ℂ) (T : ℝ≥0) (α : ℝ≥0 → ℂ) (hα : Continuous α)
-    (hfree : range α ⊆ upperHalfPlane \ (γ '' Icc 0 T))
-    (hunbounded : ¬ Bornology.IsBounded (range α)) :
-    range α ⊆ survivingDomain γ T := by
-  rintro z ⟨u, rfl⟩
-  refine ⟨hfree (mem_range_self u), ?_⟩
-  intro hb
-  apply hunbounded
-  exact hb.subset ((isPreconnected_range hα).subset_connectedComponentIn
-    (mem_range_self u) hfree)
-
-def upwardRay (z : ℂ) (u : ℝ≥0) : ℂ := z + (u : ℝ) * Complex.I
-
-theorem upwardRay_continuous (z : ℂ) : Continuous (upwardRay z) :=
-  continuous_const.add ((Complex.continuous_ofReal.comp NNReal.continuous_coe).mul continuous_const)
-
-theorem upwardRay_unbounded (z : ℂ) : ¬ Bornology.IsBounded (range (upwardRay z)) := by
-  intro hb
-  obtain ⟨R, hR, hbound⟩ := hb.exists_pos_norm_lt
-  let u : ℝ≥0 := ⟨R + |z.im| + 1, by positivity⟩
-  have hu := hbound (upwardRay z u) (mem_range_self u)
-  have hi := Complex.im_le_norm (upwardRay z u)
-  simp only [upwardRay, Complex.add_im, Complex.mul_im, Complex.ofReal_re,
-    Complex.I_im, mul_one, Complex.ofReal_im, Complex.I_re, mul_zero, add_zero] at hi
-  change z.im + (R + |z.im| + 1) ≤ ‖upwardRay z u‖ at hi
-  linarith [neg_le_abs z.im]
-
-theorem outside_initial_rectangle_survives
-    (γ : ℝ≥0 → ℂ) (T : ℝ≥0) (B : ℝ)
-    (hpast : γ '' Icc 0 T ⊆ GuideSplice.closedInitialRectangle B) :
-    upperHalfPlane \ GuideSplice.closedInitialRectangle B ⊆ survivingDomain γ T := by
-  intro z hz
-  have hfree : range (upwardRay z) ⊆ upperHalfPlane \ (γ '' Icc 0 T) := by
-    rintro w ⟨u, rfl⟩
-    have him : (upwardRay z u).im = z.im + (u : ℝ) := by simp [upwardRay]
-    have hre : (upwardRay z u).re = z.re := by simp [upwardRay]
-    refine ⟨by change 0 < (upwardRay z u).im; rw [him]; exact add_pos_of_pos_of_nonneg hz.1 u.coe_nonneg, ?_⟩
-    intro hp
-    have hrect := hpast hp
-    change |(upwardRay z u).re| ≤ B / 16 ∧
-      0 ≤ (upwardRay z u).im ∧ (upwardRay z u).im ≤ B / 4 at hrect
-    apply hz.2
-    change |z.re| ≤ B / 16 ∧ 0 ≤ z.im ∧ z.im ≤ B / 4
-    refine ⟨by simpa only [hre] using hrect.1, hz.1.le, ?_⟩
-    rw [him] at hrect
-    linarith [u.coe_nonneg, hrect.2.2]
-  have hs := survives_of_unbounded_free_curve γ T (upwardRay z)
-    (upwardRay_continuous z) hfree (upwardRay_unbounded z) (mem_range_self 0)
-  simpa only [upwardRay, NNReal.coe_zero, Complex.ofReal_zero, zero_mul, add_zero] using hs
-
-/-- The open continuation tube avoids the actual filled hull whenever the
-past lies in the containing rectangle; no filled-hull containment is assumed. -/
-theorem continuationTube_subset_survivingDomain
-    (γ : ℝ≥0 → ℂ) (T : ℝ≥0) (B : ℝ)
-    (hpast : γ '' Icc 0 T ⊆ GuideSplice.closedInitialRectangle B)
-    (F : ℂ → ℂ) (a : ℂ) (r : ℝ) (O : Set ℂ) :
-    GuideSplice.continuationTube F a r B O ⊆ survivingDomain γ T := by
-  intro z hz
-  exact outside_initial_rectangle_survives γ T B hpast ⟨hz.1.1, hz.2⟩
-
-end SLEExactGauge
-
-end
-
-end OAI
+import OAI.Probability.SLE.Geometry.GuideTube
+import OAI.Probability.SLE.NearRealContraction
+
+namespace OAI
+
+/-! Actual surviving-component assertions for access rays and the splice.
+Containment of the past in the initial rectangle implies that every point
+above or beside it belongs to the unbounded surviving component. -/
+
+noncomputable section
+open Set Filter MeasureTheory Metric
+open scoped Topology NNReal
+
+namespace SLEExactGauge
+
+theorem survives_of_unbounded_free_curve
+    (γ : ℝ≥0 → ℂ) (T : ℝ≥0) (α : ℝ≥0 → ℂ) (hα : Continuous α)
+    (hfree : range α ⊆ upperHalfPlane \ (γ '' Icc 0 T))
+    (hunbounded : ¬ Bornology.IsBounded (range α)) :
+    range α ⊆ survivingDomain γ T := by
+  rintro z ⟨u, rfl⟩
+  refine ⟨hfree (mem_range_self u), ?_⟩
+  intro hb
+  apply hunbounded
+  exact hb.subset ((isPreconnected_range hα).subset_connectedComponentIn
+    (mem_range_self u) hfree)
+
+def upwardRay (z : ℂ) (u : ℝ≥0) : ℂ := z + (u : ℝ) * Complex.I
+
+theorem upwardRay_continuous (z : ℂ) : Continuous (upwardRay z) :=
+  continuous_const.add ((Complex.continuous_ofReal.comp NNReal.continuous_coe).mul continuous_const)
+
+theorem upwardRay_unbounded (z : ℂ) : ¬ Bornology.IsBounded (range (upwardRay z)) := by
+  intro hb
+  obtain ⟨R, hR, hbound⟩ := hb.exists_pos_norm_lt
+  let u : ℝ≥0 := ⟨R + |z.im| + 1, by positivity⟩
+  have hu := hbound (upwardRay z u) (mem_range_self u)
+  have hi := Complex.im_le_norm (upwardRay z u)
+  simp only [upwardRay, Complex.add_im, Complex.mul_im, Complex.ofReal_re,
+    Complex.I_im, mul_one, Complex.ofReal_im, Complex.I_re, mul_zero, add_zero] at hi
+  change z.im + (R + |z.im| + 1) ≤ ‖upwardRay z u‖ at hi
+  linarith [neg_le_abs z.im]
+
+theorem outside_initial_rectangle_survives
+    (γ : ℝ≥0 → ℂ) (T : ℝ≥0) (B : ℝ)
+    (hpast : γ '' Icc 0 T ⊆ GuideSplice.closedInitialRectangle B) :
+    upperHalfPlane \ GuideSplice.closedInitialRectangle B ⊆ survivingDomain γ T := by
+  intro z hz
+  have hfree : range (upwardRay z) ⊆ upperHalfPlane \ (γ '' Icc 0 T) := by
+    rintro w ⟨u, rfl⟩
+    have him : (upwardRay z u).im = z.im + (u : ℝ) := by simp [upwardRay]
+    have hre : (upwardRay z u).re = z.re := by simp [upwardRay]
+    refine ⟨by change 0 < (upwardRay z u).im; rw [him]; exact add_pos_of_pos_of_nonneg hz.1 u.coe_nonneg, ?_⟩
+    intro hp
+    have hrect := hpast hp
+    change |(upwardRay z u).re| ≤ B / 16 ∧
+      0 ≤ (upwardRay z u).im ∧ (upwardRay z u).im ≤ B / 4 at hrect
+    apply hz.2
+    change |z.re| ≤ B / 16 ∧ 0 ≤ z.im ∧ z.im ≤ B / 4
+    refine ⟨by simpa only [hre] using hrect.1, hz.1.le, ?_⟩
+    rw [him] at hrect
+    linarith [u.coe_nonneg, hrect.2.2]
+  have hs := survives_of_unbounded_free_curve γ T (upwardRay z)
+    (upwardRay_continuous z) hfree (upwardRay_unbounded z) (mem_range_self 0)
+  simpa only [upwardRay, NNReal.coe_zero, Complex.ofReal_zero, zero_mul, add_zero] using hs
+
+/-- The open continuation tube avoids the actual filled hull whenever the
+past lies in the containing rectangle; no filled-hull containment is assumed. -/
+theorem continuationTube_subset_survivingDomain
+    (γ : ℝ≥0 → ℂ) (T : ℝ≥0) (B : ℝ)
+    (hpast : γ '' Icc 0 T ⊆ GuideSplice.closedInitialRectangle B)
+    (F : ℂ → ℂ) (a : ℂ) (r : ℝ) (O : Set ℂ) :
+    GuideSplice.continuationTube F a r B O ⊆ survivingDomain γ T := by
+  intro z hz
+  exact outside_initial_rectangle_survives γ T B hpast ⟨hz.1.1, hz.2⟩
+
+end SLEExactGauge
+
+end
+
+end OAI

lean/OAI/Probability/SLE/Gauge/SequencePassage.lean

@@ -1,124 +1,124 @@
-import OAI.Probability.SLE.Geometry.BoundedSpliceProbability
-import OAI.Probability.SLE.Gauge.FirstFrontPassage
-import OAI.Probability.SLE.Geometry.UniformAccessLocalization
-
-namespace OAI
-
-/-! Sequencewise ribbon passage from the actual bounded first-height event.
-The early event is stopped-image containment, and the retained mass window is
-the actual first front crossing constructed from the continuation. -/
-
-noncomputable section
-open Set Filter MeasureTheory ProbabilityTheory Metric
-open scoped Topology NNReal ENNReal
-
-namespace SLEExactGauge.SequencePassage
-open FirstHeightSupport EarlyPassageLocalization FirstFrontPassage
-
-/-- The actual stopped-image events give one positive splice probability.
-The finite initial part of the sequence does not need an early-loss estimate. -/
-theorem eventual_bounded_splice_probability
-    {Ω : Type*} [mΩ : MeasurableSpace Ω] {P : Measure Ω}
-    (κ : ℝ) (hκ : 0 < κ) (hκ8 : κ < 8)
-    (B₀ : ℝ≥0 → Ω → ℝ) (hB₀ : IsBrownianReal B₀ P)
-    (hm : ∀ t, Measurable (B₀ t)) (hc : ∀ ω, Continuous (fun t => B₀ t ω))
-    (γ : Ω → ℝ≥0 → ℂ) (G F₀ : Ω → ℝ≥0 → ℂ → ℂ)
-    (hw : ∀ ω, IsCapacityTwoWitness (fun t => Real.sqrt κ * B₀ t ω)
-      (γ ω) (G ω) (F₀ ω))
-    (hboundary : PublishedLoewnerBoundaryExtension)
-    (hsupport : PublishedGeometricTubeSupport P γ)
-    (B r : ℝ) (hB : 0 < B) (hr : 0 < r) (Tc : ℝ≥0)
-    (F : ℂ → ℂ) (hF : ContinuousOn F upperHalfPlane) (a : ℂ)
-    (O W : Set ℂ) (hO : IsOpen O) (hW : IsOpen W)
-    (β : ℝ → ℂ) (tB T : ℝ) (htB : 0 < tB) (htBT : tB < T)
-    (hβ : ContinuousOn β (Icc 0 T)) (hi : InjOn β (Icc 0 T))
-    (hβH : ∀ t ∈ Ioc 0 T, 0 < (β t).im)
-    (hcross : ‖β tB‖ = B) (hafter : ∀ t ∈ Ioc tB T, B < ‖β t‖)
-    (hcircle : ∀ θ ∈ Ioo 0 Real.pi, ‖F (GuideSplice.circlePoint B θ) - a‖ < r / 4)
-    (hsector : ∀ z : ℂ, B / 8 ≤ ‖z‖ → ‖z‖ ≤ B → ‖z‖ / 2 ≤ z.im →
-      ‖F z - a‖ < r / 4)
-    (htail : F '' (β '' Icc tB T) ⊆ O) (hend : β T ∈ W)
-    (Fbar : ℕ → ℂ → OnePoint ℂ)
-    (hbar : ∀ n, ContinuousOn (Fbar n) closedHalfPlane)
-    (aₙ : ℕ → ℂ) (ρ : ℝ)
-    (hpositive : 0 < P (stoppedNarrowCertificate γ
-      (fun ω => boundedFirstHeightTime (γ ω) B Tc) B Tc))
-    (hmissing : ∀ᶠ n in atTop, P (stoppedNarrowCertificate γ
-      (fun ω => boundedFirstHeightTime (γ ω) B Tc) B Tc \
-        stoppedImageEvent γ (fun ω => boundedFirstHeightTime (γ ω) B Tc)
-          (Fbar n) (aₙ n) ρ) ≤
-      P (stoppedNarrowCertificate γ (fun ω => boundedFirstHeightTime (γ ω) B Tc) B Tc) / 2) :
-    ∃ q : ℝ, 0 < q ∧ ∀ᶠ n in atTop, ENNReal.ofReal q ≤ P
-      (stoppedImageEvent γ (fun ω => boundedFirstHeightTime (γ ω) B Tc)
-        (Fbar n) (aₙ n) ρ ∩
-       (stoppedNarrowCertificate γ (fun ω => boundedFirstHeightTime (γ ω) B Tc) B Tc ∩
-        stoppedPhysicalTube γ (fun ω => boundedFirstHeightTime (γ ω) B Tc)
-          (parameterContinuationRegion F a r O) W)) := by
-  classical
-  let : IsProbabilityMeasure P := hB₀.isGaussianProcess.isProbabilityMeasure
-  let ℱ := Filtration.natural B₀ (fun t => (hm t).stronglyMeasurable)
-  let σ := fun ω => boundedFirstHeightTime (γ ω) B Tc
-  have ha := brownian_capacity_trace_adapted B₀ hm hc κ γ G F₀ hw
-  have hσ := boundedFirstHeightTime_isStoppingTime ℱ γ ha (fun ω => (hw ω).1) B Tc
-  let E := stoppedNarrowCertificate γ σ B Tc
-  let H : ℕ → Set Ω := fun n => stoppedImageEvent γ σ (Fbar n) (aₙ n) ρ
-  let C := stoppedPhysicalTube γ σ (parameterContinuationRegion F a r O) W
-  have hH : ∀ n, MeasurableSet[hσ.measurableSpace] (H n) := fun n =>
-    stoppedImageEvent_measurable ℱ γ ha (fun ω => (hw ω).1)
-      (fun ω t => (hw ω).2.2.1 t) σ hσ Tc
-      (fun ω => boundedFirstHeightTime_le (γ ω) B Tc) (Fbar n) (hbar n) (aₙ n) ρ
-  let H' : ℕ → Set Ω := fun n => if P (E \ H n) ≤ P E / 2 then H n else univ
-  have hH' : ∀ n, MeasurableSet[hσ.measurableSpace] (H' n) := by
-    intro n
-    dsimp only [H']
-    split_ifs
-    · exact hH n
-    · exact MeasurableSet.univ
-  have hmiss : ∀ n, P (E \ H' n) ≤ P E / 2 := by
-    intro n
-    dsimp only [H']
-    split_ifs with hn
-    · exact hn
-    · simp only [sdiff_univ, measure_empty, zero_le]
-  obtain ⟨q, hq, hqH⟩ := bounded_firstHeight_splice_varying_probability
-    κ hκ hκ8 B₀ hB₀ hm hc γ G F₀ hw hboundary hsupport B r hB hr Tc
-    F hF a O W hO hW β tB T htB htBT hβ hi hβH hcross hafter hcircle hsector htail hend
-    H' hH' hpositive hmiss
-  have hqtop : q ≠ ⊤ := ne_top_of_le_ne_top (measure_ne_top P _) (hqH 0)
-  refine ⟨q.toReal, ENNReal.toReal_pos hq.ne' hqtop, ?_⟩
-  filter_upwards [hmissing] with n hn
-  have heq : H' n = H n := ite_eq_left hn
-  rw [ENNReal.ofReal_toReal hqtop]
-  have hh := hqH n
-  rw [heq] at hh
-  exact hh.trans (measure_mono (fun _ hω => ⟨hω.1.2, hω.1.1, hω.2⟩))
-
-/-- The published support input and proved scaling law give a real positive
-lower probability, uniformly in the first-height scale. -/
-theorem uniform_bounded_firstHeight_real_probability
-    {Ω : Type*} [MeasurableSpace Ω] {P : Measure Ω}
-    (κ : ℝ) (hκ : 0 < κ) (hκ8 : κ < 8)
-    (B₀ : ℝ≥0 → Ω → ℝ) (hB₀ : IsBrownianReal B₀ P)
-    (hm : ∀ t, Measurable (B₀ t)) (hc : ∀ ω, Continuous (fun t => B₀ t ω))
-    (γ : Ω → ℝ≥0 → ℂ) (G F₀ : Ω → ℝ≥0 → ℂ → ℂ)
-    (hw : ∀ ω, IsCapacityTwoWitness (fun t => Real.sqrt κ * B₀ t ω)
-      (γ ω) (G ω) (F₀ ω))
-    (hsupport : PublishedGeometricTubeSupport P γ) :
-    ∃ T₀ : ℝ≥0, 0 < T₀ ∧ ∃ q : ℝ, 0 < q ∧ ∀ B : ℝ, 0 < B →
-      ENNReal.ofReal q ≤ P (stoppedNarrowCertificate γ
-        (fun ω => boundedFirstHeightTime (γ ω) B (T₀ * (Real.toNNReal B) ^ 2))
-        B (T₀ * (Real.toNNReal B) ^ 2)) := by
-  let : IsProbabilityMeasure P := hB₀.isGaussianProcess.isProbabilityMeasure
-  obtain ⟨T₀, hT₀, q, hq, hprob⟩ := uniform_boundedFirstHeight_probability
-    κ hκ hκ8 B₀ hB₀ hm hc γ G F₀ hw hsupport
-  have hqtop : q ≠ ⊤ := ne_top_of_le_ne_top (measure_ne_top P _) (hprob 1 zero_lt_one)
-  refine ⟨T₀, hT₀, q.toReal, ENNReal.toReal_pos hq.ne' hqtop, ?_⟩
-  intro B hB
-  have hh := hprob (Real.toNNReal B) (Real.toNNReal_pos.mpr hB)
-  simpa only [ENNReal.ofReal_toReal hqtop, Real.coe_toNNReal B hB.le] using hh
-
-end SLEExactGauge.SequencePassage
-
-end
-
-end OAI
+import OAI.Probability.SLE.Geometry.BoundedSpliceProbability
+import OAI.Probability.SLE.Gauge.FirstFrontPassage
+import OAI.Probability.SLE.Geometry.UniformAccessLocalization
+
+namespace OAI
+
+/-! Sequencewise ribbon passage from the actual bounded first-height event.
+The early event is stopped-image containment, and the retained mass window is
+the actual first front crossing constructed from the continuation. -/
+
+noncomputable section
+open Set Filter MeasureTheory ProbabilityTheory Metric
+open scoped Topology NNReal ENNReal
+
+namespace SLEExactGauge.SequencePassage
+open FirstHeightSupport EarlyPassageLocalization FirstFrontPassage
+
+/-- The actual stopped-image events give one positive splice probability.
+The finite initial part of the sequence does not need an early-loss estimate. -/
+theorem eventual_bounded_splice_probability
+    {Ω : Type*} [mΩ : MeasurableSpace Ω] {P : Measure Ω}
+    (κ : ℝ) (hκ : 0 < κ) (hκ8 : κ < 8)
+    (B₀ : ℝ≥0 → Ω → ℝ) (hB₀ : IsBrownianReal B₀ P)
+    (hm : ∀ t, Measurable (B₀ t)) (hc : ∀ ω, Continuous (fun t => B₀ t ω))
+    (γ : Ω → ℝ≥0 → ℂ) (G F₀ : Ω → ℝ≥0 → ℂ → ℂ)
+    (hw : ∀ ω, IsCapacityTwoWitness (fun t => Real.sqrt κ * B₀ t ω)
+      (γ ω) (G ω) (F₀ ω))
+    (hboundary : PublishedLoewnerBoundaryExtension)
+    (hsupport : PublishedGeometricTubeSupport P γ)
+    (B r : ℝ) (hB : 0 < B) (hr : 0 < r) (Tc : ℝ≥0)
+    (F : ℂ → ℂ) (hF : ContinuousOn F upperHalfPlane) (a : ℂ)
+    (O W : Set ℂ) (hO : IsOpen O) (hW : IsOpen W)
+    (β : ℝ → ℂ) (tB T : ℝ) (htB : 0 < tB) (htBT : tB < T)
+    (hβ : ContinuousOn β (Icc 0 T)) (hi : InjOn β (Icc 0 T))
+    (hβH : ∀ t ∈ Ioc 0 T, 0 < (β t).im)
+    (hcross : ‖β tB‖ = B) (hafter : ∀ t ∈ Ioc tB T, B < ‖β t‖)
+    (hcircle : ∀ θ ∈ Ioo 0 Real.pi, ‖F (GuideSplice.circlePoint B θ) - a‖ < r / 4)
+    (hsector : ∀ z : ℂ, B / 8 ≤ ‖z‖ → ‖z‖ ≤ B → ‖z‖ / 2 ≤ z.im →
+      ‖F z - a‖ < r / 4)
+    (htail : F '' (β '' Icc tB T) ⊆ O) (hend : β T ∈ W)
+    (Fbar : ℕ → ℂ → OnePoint ℂ)
+    (hbar : ∀ n, ContinuousOn (Fbar n) closedHalfPlane)
+    (aₙ : ℕ → ℂ) (ρ : ℝ)
+    (hpositive : 0 < P (stoppedNarrowCertificate γ
+      (fun ω => boundedFirstHeightTime (γ ω) B Tc) B Tc))
+    (hmissing : ∀ᶠ n in atTop, P (stoppedNarrowCertificate γ
+      (fun ω => boundedFirstHeightTime (γ ω) B Tc) B Tc \
+        stoppedImageEvent γ (fun ω => boundedFirstHeightTime (γ ω) B Tc)
+          (Fbar n) (aₙ n) ρ) ≤
+      P (stoppedNarrowCertificate γ (fun ω => boundedFirstHeightTime (γ ω) B Tc) B Tc) / 2) :
+    ∃ q : ℝ, 0 < q ∧ ∀ᶠ n in atTop, ENNReal.ofReal q ≤ P
+      (stoppedImageEvent γ (fun ω => boundedFirstHeightTime (γ ω) B Tc)
+        (Fbar n) (aₙ n) ρ ∩
+       (stoppedNarrowCertificate γ (fun ω => boundedFirstHeightTime (γ ω) B Tc) B Tc ∩
+        stoppedPhysicalTube γ (fun ω => boundedFirstHeightTime (γ ω) B Tc)
+          (parameterContinuationRegion F a r O) W)) := by
+  classical
+  let : IsProbabilityMeasure P := hB₀.isGaussianProcess.isProbabilityMeasure
+  let ℱ := Filtration.natural B₀ (fun t => (hm t).stronglyMeasurable)
+  let σ := fun ω => boundedFirstHeightTime (γ ω) B Tc
+  have ha := brownian_capacity_trace_adapted B₀ hm hc κ γ G F₀ hw
+  have hσ := boundedFirstHeightTime_isStoppingTime ℱ γ ha (fun ω => (hw ω).1) B Tc
+  let E := stoppedNarrowCertificate γ σ B Tc
+  let H : ℕ → Set Ω := fun n => stoppedImageEvent γ σ (Fbar n) (aₙ n) ρ
+  let C := stoppedPhysicalTube γ σ (parameterContinuationRegion F a r O) W
+  have hH : ∀ n, MeasurableSet[hσ.measurableSpace] (H n) := fun n =>
+    stoppedImageEvent_measurable ℱ γ ha (fun ω => (hw ω).1)
+      (fun ω t => (hw ω).2.2.1 t) σ hσ Tc
+      (fun ω => boundedFirstHeightTime_le (γ ω) B Tc) (Fbar n) (hbar n) (aₙ n) ρ
+  let H' : ℕ → Set Ω := fun n => if P (E \ H n) ≤ P E / 2 then H n else univ
+  have hH' : ∀ n, MeasurableSet[hσ.measurableSpace] (H' n) := by
+    intro n
+    dsimp only [H']
+    split_ifs
+    · exact hH n
+    · exact MeasurableSet.univ
+  have hmiss : ∀ n, P (E \ H' n) ≤ P E / 2 := by
+    intro n
+    dsimp only [H']
+    split_ifs with hn
+    · exact hn
+    · simp only [sdiff_univ, measure_empty, zero_le]
+  obtain ⟨q, hq, hqH⟩ := bounded_firstHeight_splice_varying_probability
+    κ hκ hκ8 B₀ hB₀ hm hc γ G F₀ hw hboundary hsupport B r hB hr Tc
+    F hF a O W hO hW β tB T htB htBT hβ hi hβH hcross hafter hcircle hsector htail hend
+    H' hH' hpositive hmiss
+  have hqtop : q ≠ ⊤ := ne_top_of_le_ne_top (measure_ne_top P _) (hqH 0)
+  refine ⟨q.toReal, ENNReal.toReal_pos hq.ne' hqtop, ?_⟩
+  filter_upwards [hmissing] with n hn
+  have heq : H' n = H n := ite_eq_left hn
+  rw [ENNReal.ofReal_toReal hqtop]
+  have hh := hqH n
+  rw [heq] at hh
+  exact hh.trans (measure_mono (fun _ hω => ⟨hω.1.2, hω.1.1, hω.2⟩))
+
+/-- The published support input and proved scaling law give a real positive
+lower probability, uniformly in the first-height scale. -/
+theorem uniform_bounded_firstHeight_real_probability
+    {Ω : Type*} [MeasurableSpace Ω] {P : Measure Ω}
+    (κ : ℝ) (hκ : 0 < κ) (hκ8 : κ < 8)
+    (B₀ : ℝ≥0 → Ω → ℝ) (hB₀ : IsBrownianReal B₀ P)
+    (hm : ∀ t, Measurable (B₀ t)) (hc : ∀ ω, Continuous (fun t => B₀ t ω))
+    (γ : Ω → ℝ≥0 → ℂ) (G F₀ : Ω → ℝ≥0 → ℂ → ℂ)
+    (hw : ∀ ω, IsCapacityTwoWitness (fun t => Real.sqrt κ * B₀ t ω)
+      (γ ω) (G ω) (F₀ ω))
+    (hsupport : PublishedGeometricTubeSupport P γ) :
+    ∃ T₀ : ℝ≥0, 0 < T₀ ∧ ∃ q : ℝ, 0 < q ∧ ∀ B : ℝ, 0 < B →
+      ENNReal.ofReal q ≤ P (stoppedNarrowCertificate γ
+        (fun ω => boundedFirstHeightTime (γ ω) B (T₀ * (Real.toNNReal B) ^ 2))
+        B (T₀ * (Real.toNNReal B) ^ 2)) := by
+  let : IsProbabilityMeasure P := hB₀.isGaussianProcess.isProbabilityMeasure
+  obtain ⟨T₀, hT₀, q, hq, hprob⟩ := uniform_boundedFirstHeight_probability
+    κ hκ hκ8 B₀ hB₀ hm hc γ G F₀ hw hsupport
+  have hqtop : q ≠ ⊤ := ne_top_of_le_ne_top (measure_ne_top P _) (hprob 1 zero_lt_one)
+  refine ⟨T₀, hT₀, q.toReal, ENNReal.toReal_pos hq.ne' hqtop, ?_⟩
+  intro B hB
+  have hh := hprob (Real.toNNReal B) (Real.toNNReal_pos.mpr hB)
+  simpa only [ENNReal.ofReal_toReal hqtop, Real.coe_toNNReal B hB.le] using hh
+
+end SLEExactGauge.SequencePassage
+
+end
+
+end OAI

lean/OAI/Probability/SLE/Gauge/SequencePassageRegions.lean

@@ -1,253 +1,253 @@
-import OAI.Probability.SLE.Gauge.SequencePassage
-import OAI.Probability.SLE.Gauge.PassageSuccessRegions
-
-namespace OAI
-
-/-! Sequence passage with compact-dependent moving middle-strip margins.
-No inclusion of the entire limiting open middle strip is required. -/
-
-noncomputable section
-open Set Filter MeasureTheory ProbabilityTheory Metric
-open scoped Topology NNReal ENNReal
-
-namespace SLEExactGauge.SequencePassage
-open FirstHeightSupport EarlyPassageLocalization FirstFrontPassage PassageSuccess
-
-local instance regionSequencePathMeasurable : MeasurableSpace C(ℝ≥0, ℂ) := borel _
-local instance regionSequencePathBorel : BorelSpace C(ℝ≥0, ℂ) := ⟨rfl⟩
-
-theorem bounded_splice_sequence_success_middle_regions
-    {Ω : Type*} [mΩ : MeasurableSpace Ω] {P : Measure Ω}
-    (κ : ℝ) (hκ : 0 < κ) (hκ8 : κ < 8)
-    (B₀ : ℝ≥0 → Ω → ℝ) (hB₀ : IsBrownianReal B₀ P)
-    (hm : ∀ t, Measurable (B₀ t)) (hc : ∀ ω, Continuous (fun t => B₀ t ω))
-    (γ : Ω → ℝ≥0 → ℂ) (G F₀ : Ω → ℝ≥0 → ℂ → ℂ)
-    (hw : ∀ ω, IsCapacityTwoWitness (fun t => Real.sqrt κ * B₀ t ω)
-      (γ ω) (G ω) (F₀ ω))
-    (hboundary : PublishedLoewnerBoundaryExtension)
-    (hsupport : PublishedGeometricTubeSupport P γ)
-    (B r : ℝ) (hB : 0 < B) (hr : 0 < r) (Tc : ℝ≥0)
-    (F : ℂ → ℂ) (hF : DifferentiableOn ℂ F upperHalfPlane) (a : ℂ)
-    (O W : Set ℂ) (hO : IsOpen O) (hW : IsOpen W)
-    (β : ℝ → ℂ) (tB T : ℝ) (htB : 0 < tB) (htBT : tB < T)
-    (hβ : ContinuousOn β (Icc 0 T)) (hi : InjOn β (Icc 0 T))
-    (hβH : ∀ t ∈ Ioc 0 T, 0 < (β t).im)
-    (hcross : ‖β tB‖ = B) (hafter : ∀ t ∈ Ioc tB T, B < ‖β t‖)
-    (hcircle : ∀ θ ∈ Ioo 0 Real.pi, ‖F (GuideSplice.circlePoint B θ) - a‖ < r / 4)
-    (hsector : ∀ z : ℂ, B / 8 ≤ ‖z‖ → ‖z‖ ≤ B → ‖z‖ / 2 ≤ z.im →
-      ‖F z - a‖ < r / 4)
-    (htail : F '' (β '' Icc tB T) ⊆ O) (hend : β T ∈ W)
-    (Fbar : ℕ → ℂ → OnePoint ℂ)
-    (hbar : ∀ n, ContinuousOn (Fbar n) closedHalfPlane)
-    (aₙ : ℕ → ℂ) (ρ : ℝ)
-    (Fₙ : ℕ → ℂ → ℂ)
-    (hFn : ∀ n, DifferentiableOn ℂ (Fₙ n) upperHalfPlane)
-    (hinj : ∀ n, InjOn (Fₙ n) upperHalfPlane)
-    (hne : ∀ z ∈ upperHalfPlane, deriv F z ≠ 0)
-    (hconv : TendstoLocallyUniformlyOn Fₙ F atTop upperHalfPlane)
-    (hext : ∀ n z, z ∈ upperHalfPlane → Fbar n z = (Fₙ n z : OnePoint ℂ))
-    (pₙ : ℕ → ℂ → ℝ) (p : ℂ → ℝ) (U : Set ℂ) (hU : IsOpen U)
-    (hp : ContinuousOn p U) (hpn : ∀ᶠ n in atTop, ContinuousOn (pₙ n) U)
-    (hpconv : TendstoLocallyUniformlyOn pₙ p atTop U)
-    (hOU : ball a (r / 2) ∪ O ⊆ U)
-    (hWfront : ∀ z ∈ W, 1 < p (F z))
-    (hstartBall : ∀ z ∈ ball a (r / 4), p z < 1 / 3)
-    (hearlyBall : ∀ᶠ n in atTop, ball (aₙ n) ρ ⊆ U ∩ {z | pₙ n z < 1})
-    (V : Set ℂ) (hV : IsOpen V) (hOV : ball a (r / 2) ∪ O ⊆ V)
-    (Vₙ : ℕ → Set ℂ) (hVVₙ : ∀ᶠ n in atTop, V ⊆ Vₙ n)
-    (bₙ : ℕ → ℂ) (ε : ℝ)
-    (hterminal : ∀ n z, z ∈ Vₙ n → pₙ n z = 1 → ‖z - bₙ n‖ < ε / 4)
-    (hearlyAllowed : ∀ᶠ n in atTop, ball (aₙ n) ρ ⊆ Vₙ n)
-    (v : ℕ → ℝ) (hv : ∀ n, 0 < v n) (hlim : Tendsto v atTop (𝓝 0))
-    (η : ℕ → Ω → ℝ≥0 → ℂ) (hηc : ∀ n, ∀ᵐ ω ∂P, Continuous (η n ω))
-    (hηbar : ∀ n, ∀ᵐ ω ∂P, ∀ t, Fbar n (γ ω t) = (η n ω t : OnePoint ℂ))
-    (Rₙ : ℕ → Set ℂ) (hregion : ∀ᶠ n in atTop, U ∩ {z | (1 / 3 : ℝ) < pₙ n z ∧ pₙ n z < 2 / 3} ⊆ Rₙ n)
-    (hpositive : 0 < P (stoppedNarrowCertificate γ
-      (fun ω => boundedFirstHeightTime (γ ω) B Tc) B Tc))
-    (hmissing : ∀ᶠ n in atTop, P (stoppedNarrowCertificate γ
-      (fun ω => boundedFirstHeightTime (γ ω) B Tc) B Tc \
-        stoppedImageEvent γ (fun ω => boundedFirstHeightTime (γ ω) B Tc)
-          (Fbar n) (aₙ n) ρ) ≤
-      P (stoppedNarrowCertificate γ (fun ω => boundedFirstHeightTime (γ ω) B Tc) B Tc) / 2) :
-    ∃ c q : ℝ, 0 < c ∧ 0 < q ∧ ∀ᶠ n in atTop, ENNReal.ofReal q ≤ P {ω |
-      ω ∈ FrontSuccess η pₙ (fun ω => boundedFirstHeightTime (γ ω) B Tc) Vₙ bₙ ε n ∧
-      ENNReal.ofReal c ≤ segmentSausageCharge κ (η n ω)
-        (boundedFirstHeightTime (γ ω) B Tc)
-        (frontTime (fun t => pₙ n (η n ω t)) 1) (v n) (Rₙ n)} := by
-  let : IsProbabilityMeasure P := hB₀.isGaussianProcess.isProbabilityMeasure
-  let ℱ := Filtration.natural B₀ (fun t => (hm t).stronglyMeasurable)
-  let σ := fun ω => boundedFirstHeightTime (γ ω) B Tc
-  have ha := brownian_capacity_trace_adapted B₀ hm hc κ γ G F₀ hw
-  have hγm (t : ℝ≥0) : Measurable (fun ω => γ ω t) := (ha t).mono (ℱ.le t) le_rfl
-  have hSLE : IsOrdinaryChordalSLE κ γ P :=
-    ⟨hγm, B₀, hB₀, Eventually.of_forall (fun ω => ⟨G ω, F₀ ω, hw ω⟩)⟩
-  have hσ := boundedFirstHeightTime_isStoppingTime ℱ γ ha (fun ω => (hw ω).1) B Tc
-  have hσm : Measurable σ := stopping_time_measurable_nnreal hσ
-  let f := sourceTracePath γ (fun ω => (hw ω).1)
-  have hfm : Measurable f := source_path_measurable f hγm
-  let Uparam := parameterContinuationRegion F a r O
-  have hUparam : IsOpen Uparam := parameterContinuationRegion_isOpen hF.continuousOn a r hO
-  let C := stoppedPhysicalTube γ σ Uparam W
-  let E := stoppedNarrowCertificate γ σ B Tc ∩ C
-  let H : ℕ → Set Ω := fun n => stoppedImageEvent γ σ (Fbar n) (aₙ n) ρ
-  have hEm : MeasurableSet E := by
-    apply MeasurableSet.inter
-    · exact hσ.measurableSpace_le _
-        (boundedFirstHeight_certificate_measurable ℱ γ ha (fun ω => (hw ω).1) B Tc)
-    · exact measurableSet_stoppedPhysicalTube γ (fun ω => (hw ω).1) hγm σ hσm Uparam W hUparam hW
-  have hstart : ∀ ω ∈ E, p (F (γ ω (σ ω))) < 1 / 3 := by
-    intro ω hω
-    have hnorm := bounded_firstHeight_norm (f ω) (hw ω).2.1 (hw ω).2.2.1
-      hB Tc hω.1 (σ ω) ⟨bot_le, le_rfl⟩
-    change ‖γ ω (σ ω)‖ < B / 2 at hnorm
-    have hheight : (γ ω (σ ω)).im = B / 4 := hω.1.2.1
-    have him := Complex.im_le_norm (γ ω (σ ω))
-    have hsmall := hsector (γ ω (σ ω)) (by linarith) (by linarith)
-      (by rw [hheight]; linarith)
-    exact hstartBall _ (by simpa only [mem_ball, dist_eq_norm] using hsmall)
-  obtain ⟨q, hq, hprob⟩ := eventual_bounded_splice_probability κ hκ hκ8 B₀ hB₀ hm hc
-    γ G F₀ hw hboundary hsupport B r hB hr Tc F hF.continuousOn a O W hO hW
-    β tB T htB htBT hβ hi hβH hcross hafter hcircle hsector htail hend Fbar hbar aₙ ρ
-    hpositive hmissing
-  have hη : ∀ n, ∀ᵐ ω ∂P, ∀ t : ℝ≥0, σ ω ≤ t → γ ω t ∈ upperHalfPlane →
-      η n ω t = Fₙ n (γ ω t) := by
-    intro n
-    filter_upwards [hηbar n] with ω hω
-    intro t _ ht
-    exact OnePoint.coe_injective ((hω t).symm.trans (hext n _ ht))
-  have hearly : ∀ᶠ n in atTop, ∀ᵐ ω ∂P, ω ∈ H n ∩ E →
-      MapsTo (η n ω) (Icc 0 (σ ω)) U ∧
-        ∀ t ∈ Icc 0 (σ ω), pₙ n (η n ω t) < 1 := by
-    filter_upwards [hearlyBall] with n hn
-    filter_upwards [hηbar n] with ω hω
-    intro hmem
-    have himage : MapsTo (η n ω) (Icc 0 (σ ω)) (ball (aₙ n) ρ) := by
-      intro t ht
-      obtain ⟨z, hz, he⟩ := hmem.1 t ht
-      have heq : z = η n ω t := OnePoint.coe_injective (he.trans (hω t))
-      exact heq ▸ hz
-    exact ⟨fun _ ht => (hn (himage ht)).1, fun _ ht => (hn (himage ht)).2⟩
-  have hearlyV : ∀ᶠ n in atTop, ∀ᵐ ω ∂P, ω ∈ H n ∩ E →
-      MapsTo (η n ω) (Icc 0 (σ ω)) (Vₙ n) := by
-    filter_upwards [hearlyAllowed] with n hn
-    filter_upwards [hηbar n] with ω hω
-    intro hmem t ht
-    obtain ⟨z, hz, he⟩ := hmem.1 t ht
-    have heq : z = η n ω t := OnePoint.coe_injective (he.trans (hω t))
-    exact hn (heq ▸ hz)
-  obtain ⟨c, hcpos, hmass⟩ := retained_tube_firstFront_success_mass_middle_regions P κ hκ hκ8
-    f hfm hSLE σ hσm Fₙ F hFn hinj hF hne hconv Uparam W hUparam inter_subset_left
-    pₙ p U hU hp hpn hpconv (fun _ hz => hOU hz.2) hWfront E hEm inter_subset_right
-    hstart V hV (fun _ hz => hOV hz.2) Vₙ hVVₙ bₙ ε hterminal
-    v hv hlim η Rₙ hregion H q hq hprob hη hηc hearly hearlyV
-  exact ⟨c, q / 8, hcpos, by positivity, hmass⟩
-
-
-theorem localized_sequence_passage_success_middle_regions
-    {Ω : Type*} [mΩ : MeasurableSpace Ω] {P : Measure Ω}
-    (κ : ℝ) (hκ : 0 < κ) (hκ8 : κ < 8)
-    (B₀ : ℝ≥0 → Ω → ℝ) (hB₀ : IsBrownianReal B₀ P)
-    (hm : ∀ t, Measurable (B₀ t)) (hc : ∀ ω, Continuous (fun t => B₀ t ω))
-    (γ : Ω → ℝ≥0 → ℂ) (G F₀ : Ω → ℝ≥0 → ℂ → ℂ)
-    (hw : ∀ ω, IsCapacityTwoWitness (fun t => Real.sqrt κ * B₀ t ω)
-      (γ ω) (G ω) (F₀ ω))
-    (hboundary : PublishedLoewnerBoundaryExtension)
-    (hsupport : PublishedGeometricTubeSupport P γ)
-    (Fₙ : ℕ → ℂ → ℂ) (Fbar : ℕ → ℂ → OnePoint ℂ)
-    (hFn : ∀ n, DifferentiableOn ℂ (Fₙ n) upperHalfPlane)
-    (hinj : ∀ n, InjOn (Fₙ n) upperHalfPlane)
-    (hbar : ∀ n, ContinuousOn (Fbar n) closedHalfPlane)
-    (hext : ∀ n z, z ∈ upperHalfPlane → Fbar n z = (Fₙ n z : OnePoint ℂ))
-    (δ : ℝ) (hδ : 0 < δ) (βₙ : ℕ → ℝ → ℂ)
-    (hβc : ∀ n, ContinuousOn (βₙ n) (Icc 0 δ)) (hβ0 : ∀ n, βₙ n 0 = 0)
-    (hβHn : ∀ n t, t ∈ Icc 0 δ → 0 ≤ (βₙ n t).im)
-    (z : ℂ) (hz : z ≠ 0) (hβconv : Tendsto (fun n => βₙ n δ) atTop (𝓝 z))
-    (αₙ : ℕ → ℝ → ℂ) (aₙ : ℕ → ℂ) (Cg : ℝ≥0)
-    (hα : ∀ n, LipschitzOnWith Cg (αₙ n) (Icc 0 δ)) (hα0 : ∀ n, αₙ n 0 = aₙ n)
-    (hmap : ∀ n t, t ∈ Icc 0 δ → Fbar n (βₙ n t) = (αₙ n t : OnePoint ℂ))
-    (r₀ : ℝ) (hr₀ : 0 < r₀) (hsmallGuide : (Cg : ℝ) * δ ≤ r₀) :
-    ∃ T₀ : ℝ≥0, 0 < T₀ ∧ ∃ q₀ b₀ b A d L₀ : ℝ,
-      0 < q₀ ∧ 0 < b₀ ∧ 0 < b ∧ 0 < A ∧ 0 < d ∧ 1 < L₀ ∧
-      ∀ (L : ℝ), L₀ ≤ L → A * L ^ (-d) ≤ q₀ / 2 →
-      ∀ (B r : ℝ), 0 < B → 0 < r → B / 2 ≤ b₀ * L ^ b →
-      ∀ (F : ℂ → ℂ), DifferentiableOn ℂ F upperHalfPlane →
-      ∀ (a : ℂ) (O W : Set ℂ), IsOpen O → IsOpen W →
-      ∀ (β : ℝ → ℂ) (tB T : ℝ), 0 < tB → tB < T →
-      ContinuousOn β (Icc 0 T) → InjOn β (Icc 0 T) →
-      (∀ t ∈ Ioc 0 T, 0 < (β t).im) → ‖β tB‖ = B →
-      (∀ t ∈ Ioc tB T, B < ‖β t‖) →
-      (∀ θ ∈ Ioo 0 Real.pi, ‖F (GuideSplice.circlePoint B θ) - a‖ < r / 4) →
-      (∀ w : ℂ, B / 8 ≤ ‖w‖ → ‖w‖ ≤ B → ‖w‖ / 2 ≤ w.im → ‖F w - a‖ < r / 4) →
-      F '' (β '' Icc tB T) ⊆ O → β T ∈ W →
-      (∀ w ∈ upperHalfPlane, deriv F w ≠ 0) →
-      TendstoLocallyUniformlyOn Fₙ F atTop upperHalfPlane →
-      ∀ (pₙ : ℕ → ℂ → ℝ) (p : ℂ → ℝ) (U : Set ℂ), IsOpen U →
-      ContinuousOn p U → (∀ᶠ n in atTop, ContinuousOn (pₙ n) U) →
-      TendstoLocallyUniformlyOn pₙ p atTop U →
-      ball a (r / 2) ∪ O ⊆ U → (∀ w ∈ W, 1 < p (F w)) →
-      (∀ w ∈ ball a (r / 4), p w < 1 / 3) →
-      (∀ᶠ n in atTop, ball (aₙ n) (L * r₀) ⊆ U ∩ {w | pₙ n w < 1}) →
-      ∀ (V : Set ℂ), IsOpen V → ball a (r / 2) ∪ O ⊆ V →
-      ∀ (Vₙ : ℕ → Set ℂ), (∀ᶠ n in atTop, V ⊆ Vₙ n) →
-      ∀ (bₙ : ℕ → ℂ) (ε : ℝ),
-      (∀ n w, w ∈ Vₙ n → pₙ n w = 1 → ‖w - bₙ n‖ < ε / 4) →
-      (∀ᶠ n in atTop, ball (aₙ n) (L * r₀) ⊆ Vₙ n) →
-      ∀ (v : ℕ → ℝ), (∀ n, 0 < v n) → Tendsto v atTop (𝓝 0) →
-      ∀ (η : ℕ → Ω → ℝ≥0 → ℂ), (∀ n, ∀ᵐ ω ∂P, Continuous (η n ω)) →
-      (∀ n, ∀ᵐ ω ∂P, ∀ t, Fbar n (γ ω t) = (η n ω t : OnePoint ℂ)) →
-      ∀ (Rₙ : ℕ → Set ℂ),
-      (∀ᶠ n in atTop, U ∩ {w | (1 / 3 : ℝ) < pₙ n w ∧ pₙ n w < 2 / 3} ⊆ Rₙ n) →
-      ∃ c q : ℝ, 0 < c ∧ 0 < q ∧ ∀ᶠ n in atTop, ENNReal.ofReal q ≤ P {ω |
-        ω ∈ FrontSuccess η pₙ
-          (fun ω => boundedFirstHeightTime (γ ω) B (T₀ * (Real.toNNReal B) ^ 2)) Vₙ bₙ ε n ∧
-        ENNReal.ofReal c ≤ segmentSausageCharge κ (η n ω)
-          (boundedFirstHeightTime (γ ω) B (T₀ * (Real.toNNReal B) ^ 2))
-          (frontTime (fun t => pₙ n (η n ω t)) 1) (v n) (Rₙ n)} := by
-  let : IsProbabilityMeasure P := hB₀.isGaussianProcess.isProbabilityMeasure
-  let ℱ := Filtration.natural B₀ (fun t => (hm t).stronglyMeasurable)
-  have ha := brownian_capacity_trace_adapted B₀ hm hc κ γ G F₀ hw
-  have hγm (t : ℝ≥0) : Measurable (fun ω => γ ω t) := (ha t).mono (ℱ.le t) le_rfl
-  have hSLE : IsOrdinaryChordalSLE κ γ P :=
-    ⟨hγm, B₀, hB₀, Eventually.of_forall (fun ω => ⟨G ω, F₀ ω, hw ω⟩)⟩
-  obtain ⟨T₀, hT₀, q₀, hq₀, hheight⟩ := uniform_bounded_firstHeight_real_probability
-    κ hκ hκ8 B₀ hB₀ hm hc γ G F₀ hw hsupport
-  obtain ⟨b, A, d, L₀, hb, hA, hd, hL₀, hloc⟩ :=
-    common_access_gives_firstHeight_localization κ hκ hκ8
-  obtain ⟨b₀, hb₀, hlocseq⟩ := hloc Ω P γ hSLE (fun ω => (hw ω).1)
-    (fun ω => (hw ω).2.1) (fun ω t => (hw ω).2.2.1 t)
-    Fₙ Fbar hFn hinj hbar hext δ hδ βₙ hβc hβ0 hβHn z hz hβconv
-    αₙ aₙ Cg hα hα0 hmap r₀ hr₀ hsmallGuide
-  refine ⟨T₀, hT₀, q₀, b₀, b, A, d, L₀, hq₀, hb₀, hb, hA, hd, hL₀, ?_⟩
-  intro L hL hsmall B r hB hr hBL F hF a O W hO hW β tB T htB htBT hβ hi hβH
-    hcross hafter hcircle hsector htail hend hne hconv pₙ p U hU hp hpn hpconv hOU
-    hWfront hstartBall hearlyBall V hV hOV Vₙ hVVₙ bₙ ε hterminal hearlyAllowed
-    v hv hlim η hηc hηbar Rₙ hregion
-  let Tc := T₀ * (Real.toNNReal B) ^ 2
-  have hheightB := hheight B hB
-  have hpositive : 0 < P (stoppedNarrowCertificate γ
-      (fun ω => boundedFirstHeightTime (γ ω) B Tc) B Tc) :=
-    (ENNReal.ofReal_pos.mpr hq₀).trans_le hheightB
-  have hmissing : ∀ᶠ n in atTop, P (stoppedNarrowCertificate γ
-      (fun ω => boundedFirstHeightTime (γ ω) B Tc) B Tc \
-        stoppedImageEvent γ (fun ω => boundedFirstHeightTime (γ ω) B Tc)
-          (Fbar n) (aₙ n) (L * r₀)) ≤
-      P (stoppedNarrowCertificate γ (fun ω => boundedFirstHeightTime (γ ω) B Tc) B Tc) / 2 := by
-    filter_upwards [hlocseq] with n hn
-    calc
-      _ ≤ ENNReal.ofReal (A * L ^ (-d)) := hn L hL B hB hBL Tc
-      _ ≤ ENNReal.ofReal (q₀ / 2) := ENNReal.ofReal_le_ofReal hsmall
-      _ = ENNReal.ofReal q₀ / 2 := by
-        rw [ENNReal.ofReal_div_of_pos (by norm_num : (0 : ℝ) < 2)]
-        norm_num
-      _ ≤ _ := ENNReal.div_le_div_right hheightB 2
-  exact bounded_splice_sequence_success_middle_regions κ hκ hκ8 B₀ hB₀ hm hc γ G F₀ hw hboundary hsupport
-    B r hB hr Tc F hF a O W hO hW β tB T htB htBT hβ hi hβH hcross hafter hcircle hsector
-    htail hend Fbar hbar aₙ (L * r₀) Fₙ hFn hinj hne hconv hext pₙ p U hU hp hpn hpconv
-    hOU hWfront hstartBall hearlyBall V hV hOV Vₙ hVVₙ bₙ ε hterminal hearlyAllowed
-    v hv hlim η hηc hηbar Rₙ hregion hpositive hmissing
-
-end SLEExactGauge.SequencePassage
-
-end
-
-end OAI
+import OAI.Probability.SLE.Gauge.SequencePassage
+import OAI.Probability.SLE.Gauge.PassageSuccessRegions
+
+namespace OAI
+
+/-! Sequence passage with compact-dependent moving middle-strip margins.
+No inclusion of the entire limiting open middle strip is required. -/
+
+noncomputable section
+open Set Filter MeasureTheory ProbabilityTheory Metric
+open scoped Topology NNReal ENNReal
+
+namespace SLEExactGauge.SequencePassage
+open FirstHeightSupport EarlyPassageLocalization FirstFrontPassage PassageSuccess
+
+local instance regionSequencePathMeasurable : MeasurableSpace C(ℝ≥0, ℂ) := borel _
+local instance regionSequencePathBorel : BorelSpace C(ℝ≥0, ℂ) := ⟨rfl⟩
+
+theorem bounded_splice_sequence_success_middle_regions
+    {Ω : Type*} [mΩ : MeasurableSpace Ω] {P : Measure Ω}
+    (κ : ℝ) (hκ : 0 < κ) (hκ8 : κ < 8)
+    (B₀ : ℝ≥0 → Ω → ℝ) (hB₀ : IsBrownianReal B₀ P)
+    (hm : ∀ t, Measurable (B₀ t)) (hc : ∀ ω, Continuous (fun t => B₀ t ω))
+    (γ : Ω → ℝ≥0 → ℂ) (G F₀ : Ω → ℝ≥0 → ℂ → ℂ)
+    (hw : ∀ ω, IsCapacityTwoWitness (fun t => Real.sqrt κ * B₀ t ω)
+      (γ ω) (G ω) (F₀ ω))
+    (hboundary : PublishedLoewnerBoundaryExtension)
+    (hsupport : PublishedGeometricTubeSupport P γ)
+    (B r : ℝ) (hB : 0 < B) (hr : 0 < r) (Tc : ℝ≥0)
+    (F : ℂ → ℂ) (hF : DifferentiableOn ℂ F upperHalfPlane) (a : ℂ)
+    (O W : Set ℂ) (hO : IsOpen O) (hW : IsOpen W)
+    (β : ℝ → ℂ) (tB T : ℝ) (htB : 0 < tB) (htBT : tB < T)
+    (hβ : ContinuousOn β (Icc 0 T)) (hi : InjOn β (Icc 0 T))
+    (hβH : ∀ t ∈ Ioc 0 T, 0 < (β t).im)
+    (hcross : ‖β tB‖ = B) (hafter : ∀ t ∈ Ioc tB T, B < ‖β t‖)
+    (hcircle : ∀ θ ∈ Ioo 0 Real.pi, ‖F (GuideSplice.circlePoint B θ) - a‖ < r / 4)
+    (hsector : ∀ z : ℂ, B / 8 ≤ ‖z‖ → ‖z‖ ≤ B → ‖z‖ / 2 ≤ z.im →
+      ‖F z - a‖ < r / 4)
+    (htail : F '' (β '' Icc tB T) ⊆ O) (hend : β T ∈ W)
+    (Fbar : ℕ → ℂ → OnePoint ℂ)
+    (hbar : ∀ n, ContinuousOn (Fbar n) closedHalfPlane)
+    (aₙ : ℕ → ℂ) (ρ : ℝ)
+    (Fₙ : ℕ → ℂ → ℂ)
+    (hFn : ∀ n, DifferentiableOn ℂ (Fₙ n) upperHalfPlane)
+    (hinj : ∀ n, InjOn (Fₙ n) upperHalfPlane)
+    (hne : ∀ z ∈ upperHalfPlane, deriv F z ≠ 0)
+    (hconv : TendstoLocallyUniformlyOn Fₙ F atTop upperHalfPlane)
+    (hext : ∀ n z, z ∈ upperHalfPlane → Fbar n z = (Fₙ n z : OnePoint ℂ))
+    (pₙ : ℕ → ℂ → ℝ) (p : ℂ → ℝ) (U : Set ℂ) (hU : IsOpen U)
+    (hp : ContinuousOn p U) (hpn : ∀ᶠ n in atTop, ContinuousOn (pₙ n) U)
+    (hpconv : TendstoLocallyUniformlyOn pₙ p atTop U)
+    (hOU : ball a (r / 2) ∪ O ⊆ U)
+    (hWfront : ∀ z ∈ W, 1 < p (F z))
+    (hstartBall : ∀ z ∈ ball a (r / 4), p z < 1 / 3)
+    (hearlyBall : ∀ᶠ n in atTop, ball (aₙ n) ρ ⊆ U ∩ {z | pₙ n z < 1})
+    (V : Set ℂ) (hV : IsOpen V) (hOV : ball a (r / 2) ∪ O ⊆ V)
+    (Vₙ : ℕ → Set ℂ) (hVVₙ : ∀ᶠ n in atTop, V ⊆ Vₙ n)
+    (bₙ : ℕ → ℂ) (ε : ℝ)
+    (hterminal : ∀ n z, z ∈ Vₙ n → pₙ n z = 1 → ‖z - bₙ n‖ < ε / 4)
+    (hearlyAllowed : ∀ᶠ n in atTop, ball (aₙ n) ρ ⊆ Vₙ n)
+    (v : ℕ → ℝ) (hv : ∀ n, 0 < v n) (hlim : Tendsto v atTop (𝓝 0))
+    (η : ℕ → Ω → ℝ≥0 → ℂ) (hηc : ∀ n, ∀ᵐ ω ∂P, Continuous (η n ω))
+    (hηbar : ∀ n, ∀ᵐ ω ∂P, ∀ t, Fbar n (γ ω t) = (η n ω t : OnePoint ℂ))
+    (Rₙ : ℕ → Set ℂ) (hregion : ∀ᶠ n in atTop, U ∩ {z | (1 / 3 : ℝ) < pₙ n z ∧ pₙ n z < 2 / 3} ⊆ Rₙ n)
+    (hpositive : 0 < P (stoppedNarrowCertificate γ
+      (fun ω => boundedFirstHeightTime (γ ω) B Tc) B Tc))
+    (hmissing : ∀ᶠ n in atTop, P (stoppedNarrowCertificate γ
+      (fun ω => boundedFirstHeightTime (γ ω) B Tc) B Tc \
+        stoppedImageEvent γ (fun ω => boundedFirstHeightTime (γ ω) B Tc)
+          (Fbar n) (aₙ n) ρ) ≤
+      P (stoppedNarrowCertificate γ (fun ω => boundedFirstHeightTime (γ ω) B Tc) B Tc) / 2) :
+    ∃ c q : ℝ, 0 < c ∧ 0 < q ∧ ∀ᶠ n in atTop, ENNReal.ofReal q ≤ P {ω |
+      ω ∈ FrontSuccess η pₙ (fun ω => boundedFirstHeightTime (γ ω) B Tc) Vₙ bₙ ε n ∧
+      ENNReal.ofReal c ≤ segmentSausageCharge κ (η n ω)
+        (boundedFirstHeightTime (γ ω) B Tc)
+        (frontTime (fun t => pₙ n (η n ω t)) 1) (v n) (Rₙ n)} := by
+  let : IsProbabilityMeasure P := hB₀.isGaussianProcess.isProbabilityMeasure
+  let ℱ := Filtration.natural B₀ (fun t => (hm t).stronglyMeasurable)
+  let σ := fun ω => boundedFirstHeightTime (γ ω) B Tc
+  have ha := brownian_capacity_trace_adapted B₀ hm hc κ γ G F₀ hw
+  have hγm (t : ℝ≥0) : Measurable (fun ω => γ ω t) := (ha t).mono (ℱ.le t) le_rfl
+  have hSLE : IsOrdinaryChordalSLE κ γ P :=
+    ⟨hγm, B₀, hB₀, Eventually.of_forall (fun ω => ⟨G ω, F₀ ω, hw ω⟩)⟩
+  have hσ := boundedFirstHeightTime_isStoppingTime ℱ γ ha (fun ω => (hw ω).1) B Tc
+  have hσm : Measurable σ := stopping_time_measurable_nnreal hσ
+  let f := sourceTracePath γ (fun ω => (hw ω).1)
+  have hfm : Measurable f := source_path_measurable f hγm
+  let Uparam := parameterContinuationRegion F a r O
+  have hUparam : IsOpen Uparam := parameterContinuationRegion_isOpen hF.continuousOn a r hO
+  let C := stoppedPhysicalTube γ σ Uparam W
+  let E := stoppedNarrowCertificate γ σ B Tc ∩ C
+  let H : ℕ → Set Ω := fun n => stoppedImageEvent γ σ (Fbar n) (aₙ n) ρ
+  have hEm : MeasurableSet E := by
+    apply MeasurableSet.inter
+    · exact hσ.measurableSpace_le _
+        (boundedFirstHeight_certificate_measurable ℱ γ ha (fun ω => (hw ω).1) B Tc)
+    · exact measurableSet_stoppedPhysicalTube γ (fun ω => (hw ω).1) hγm σ hσm Uparam W hUparam hW
+  have hstart : ∀ ω ∈ E, p (F (γ ω (σ ω))) < 1 / 3 := by
+    intro ω hω
+    have hnorm := bounded_firstHeight_norm (f ω) (hw ω).2.1 (hw ω).2.2.1
+      hB Tc hω.1 (σ ω) ⟨bot_le, le_rfl⟩
+    change ‖γ ω (σ ω)‖ < B / 2 at hnorm
+    have hheight : (γ ω (σ ω)).im = B / 4 := hω.1.2.1
+    have him := Complex.im_le_norm (γ ω (σ ω))
+    have hsmall := hsector (γ ω (σ ω)) (by linarith) (by linarith)
+      (by rw [hheight]; linarith)
+    exact hstartBall _ (by simpa only [mem_ball, dist_eq_norm] using hsmall)
+  obtain ⟨q, hq, hprob⟩ := eventual_bounded_splice_probability κ hκ hκ8 B₀ hB₀ hm hc
+    γ G F₀ hw hboundary hsupport B r hB hr Tc F hF.continuousOn a O W hO hW
+    β tB T htB htBT hβ hi hβH hcross hafter hcircle hsector htail hend Fbar hbar aₙ ρ
+    hpositive hmissing
+  have hη : ∀ n, ∀ᵐ ω ∂P, ∀ t : ℝ≥0, σ ω ≤ t → γ ω t ∈ upperHalfPlane →
+      η n ω t = Fₙ n (γ ω t) := by
+    intro n
+    filter_upwards [hηbar n] with ω hω
+    intro t _ ht
+    exact OnePoint.coe_injective ((hω t).symm.trans (hext n _ ht))
+  have hearly : ∀ᶠ n in atTop, ∀ᵐ ω ∂P, ω ∈ H n ∩ E →
+      MapsTo (η n ω) (Icc 0 (σ ω)) U ∧
+        ∀ t ∈ Icc 0 (σ ω), pₙ n (η n ω t) < 1 := by
+    filter_upwards [hearlyBall] with n hn
+    filter_upwards [hηbar n] with ω hω
+    intro hmem
+    have himage : MapsTo (η n ω) (Icc 0 (σ ω)) (ball (aₙ n) ρ) := by
+      intro t ht
+      obtain ⟨z, hz, he⟩ := hmem.1 t ht
+      have heq : z = η n ω t := OnePoint.coe_injective (he.trans (hω t))
+      exact heq ▸ hz
+    exact ⟨fun _ ht => (hn (himage ht)).1, fun _ ht => (hn (himage ht)).2⟩
+  have hearlyV : ∀ᶠ n in atTop, ∀ᵐ ω ∂P, ω ∈ H n ∩ E →
+      MapsTo (η n ω) (Icc 0 (σ ω)) (Vₙ n) := by
+    filter_upwards [hearlyAllowed] with n hn
+    filter_upwards [hηbar n] with ω hω
+    intro hmem t ht
+    obtain ⟨z, hz, he⟩ := hmem.1 t ht
+    have heq : z = η n ω t := OnePoint.coe_injective (he.trans (hω t))
+    exact hn (heq ▸ hz)
+  obtain ⟨c, hcpos, hmass⟩ := retained_tube_firstFront_success_mass_middle_regions P κ hκ hκ8
+    f hfm hSLE σ hσm Fₙ F hFn hinj hF hne hconv Uparam W hUparam inter_subset_left
+    pₙ p U hU hp hpn hpconv (fun _ hz => hOU hz.2) hWfront E hEm inter_subset_right
+    hstart V hV (fun _ hz => hOV hz.2) Vₙ hVVₙ bₙ ε hterminal
+    v hv hlim η Rₙ hregion H q hq hprob hη hηc hearly hearlyV
+  exact ⟨c, q / 8, hcpos, by positivity, hmass⟩
+
+
+theorem localized_sequence_passage_success_middle_regions
+    {Ω : Type*} [mΩ : MeasurableSpace Ω] {P : Measure Ω}
+    (κ : ℝ) (hκ : 0 < κ) (hκ8 : κ < 8)
+    (B₀ : ℝ≥0 → Ω → ℝ) (hB₀ : IsBrownianReal B₀ P)
+    (hm : ∀ t, Measurable (B₀ t)) (hc : ∀ ω, Continuous (fun t => B₀ t ω))
+    (γ : Ω → ℝ≥0 → ℂ) (G F₀ : Ω → ℝ≥0 → ℂ → ℂ)
+    (hw : ∀ ω, IsCapacityTwoWitness (fun t => Real.sqrt κ * B₀ t ω)
+      (γ ω) (G ω) (F₀ ω))
+    (hboundary : PublishedLoewnerBoundaryExtension)
+    (hsupport : PublishedGeometricTubeSupport P γ)
+    (Fₙ : ℕ → ℂ → ℂ) (Fbar : ℕ → ℂ → OnePoint ℂ)
+    (hFn : ∀ n, DifferentiableOn ℂ (Fₙ n) upperHalfPlane)
+    (hinj : ∀ n, InjOn (Fₙ n) upperHalfPlane)
+    (hbar : ∀ n, ContinuousOn (Fbar n) closedHalfPlane)
+    (hext : ∀ n z, z ∈ upperHalfPlane → Fbar n z = (Fₙ n z : OnePoint ℂ))
+    (δ : ℝ) (hδ : 0 < δ) (βₙ : ℕ → ℝ → ℂ)
+    (hβc : ∀ n, ContinuousOn (βₙ n) (Icc 0 δ)) (hβ0 : ∀ n, βₙ n 0 = 0)
+    (hβHn : ∀ n t, t ∈ Icc 0 δ → 0 ≤ (βₙ n t).im)
+    (z : ℂ) (hz : z ≠ 0) (hβconv : Tendsto (fun n => βₙ n δ) atTop (𝓝 z))
+    (αₙ : ℕ → ℝ → ℂ) (aₙ : ℕ → ℂ) (Cg : ℝ≥0)
+    (hα : ∀ n, LipschitzOnWith Cg (αₙ n) (Icc 0 δ)) (hα0 : ∀ n, αₙ n 0 = aₙ n)
+    (hmap : ∀ n t, t ∈ Icc 0 δ → Fbar n (βₙ n t) = (αₙ n t : OnePoint ℂ))
+    (r₀ : ℝ) (hr₀ : 0 < r₀) (hsmallGuide : (Cg : ℝ) * δ ≤ r₀) :
+    ∃ T₀ : ℝ≥0, 0 < T₀ ∧ ∃ q₀ b₀ b A d L₀ : ℝ,
+      0 < q₀ ∧ 0 < b₀ ∧ 0 < b ∧ 0 < A ∧ 0 < d ∧ 1 < L₀ ∧
+      ∀ (L : ℝ), L₀ ≤ L → A * L ^ (-d) ≤ q₀ / 2 →
+      ∀ (B r : ℝ), 0 < B → 0 < r → B / 2 ≤ b₀ * L ^ b →
+      ∀ (F : ℂ → ℂ), DifferentiableOn ℂ F upperHalfPlane →
+      ∀ (a : ℂ) (O W : Set ℂ), IsOpen O → IsOpen W →
+      ∀ (β : ℝ → ℂ) (tB T : ℝ), 0 < tB → tB < T →
+      ContinuousOn β (Icc 0 T) → InjOn β (Icc 0 T) →
+      (∀ t ∈ Ioc 0 T, 0 < (β t).im) → ‖β tB‖ = B →
+      (∀ t ∈ Ioc tB T, B < ‖β t‖) →
+      (∀ θ ∈ Ioo 0 Real.pi, ‖F (GuideSplice.circlePoint B θ) - a‖ < r / 4) →
+      (∀ w : ℂ, B / 8 ≤ ‖w‖ → ‖w‖ ≤ B → ‖w‖ / 2 ≤ w.im → ‖F w - a‖ < r / 4) →
+      F '' (β '' Icc tB T) ⊆ O → β T ∈ W →
+      (∀ w ∈ upperHalfPlane, deriv F w ≠ 0) →
+      TendstoLocallyUniformlyOn Fₙ F atTop upperHalfPlane →
+      ∀ (pₙ : ℕ → ℂ → ℝ) (p : ℂ → ℝ) (U : Set ℂ), IsOpen U →
+      ContinuousOn p U → (∀ᶠ n in atTop, ContinuousOn (pₙ n) U) →
+      TendstoLocallyUniformlyOn pₙ p atTop U →
+      ball a (r / 2) ∪ O ⊆ U → (∀ w ∈ W, 1 < p (F w)) →
+      (∀ w ∈ ball a (r / 4), p w < 1 / 3) →
+      (∀ᶠ n in atTop, ball (aₙ n) (L * r₀) ⊆ U ∩ {w | pₙ n w < 1}) →
+      ∀ (V : Set ℂ), IsOpen V → ball a (r / 2) ∪ O ⊆ V →
+      ∀ (Vₙ : ℕ → Set ℂ), (∀ᶠ n in atTop, V ⊆ Vₙ n) →
+      ∀ (bₙ : ℕ → ℂ) (ε : ℝ),
+      (∀ n w, w ∈ Vₙ n → pₙ n w = 1 → ‖w - bₙ n‖ < ε / 4) →
+      (∀ᶠ n in atTop, ball (aₙ n) (L * r₀) ⊆ Vₙ n) →
+      ∀ (v : ℕ → ℝ), (∀ n, 0 < v n) → Tendsto v atTop (𝓝 0) →
+      ∀ (η : ℕ → Ω → ℝ≥0 → ℂ), (∀ n, ∀ᵐ ω ∂P, Continuous (η n ω)) →
+      (∀ n, ∀ᵐ ω ∂P, ∀ t, Fbar n (γ ω t) = (η n ω t : OnePoint ℂ)) →
+      ∀ (Rₙ : ℕ → Set ℂ),
+      (∀ᶠ n in atTop, U ∩ {w | (1 / 3 : ℝ) < pₙ n w ∧ pₙ n w < 2 / 3} ⊆ Rₙ n) →
+      ∃ c q : ℝ, 0 < c ∧ 0 < q ∧ ∀ᶠ n in atTop, ENNReal.ofReal q ≤ P {ω |
+        ω ∈ FrontSuccess η pₙ
+          (fun ω => boundedFirstHeightTime (γ ω) B (T₀ * (Real.toNNReal B) ^ 2)) Vₙ bₙ ε n ∧
+        ENNReal.ofReal c ≤ segmentSausageCharge κ (η n ω)
+          (boundedFirstHeightTime (γ ω) B (T₀ * (Real.toNNReal B) ^ 2))
+          (frontTime (fun t => pₙ n (η n ω t)) 1) (v n) (Rₙ n)} := by
+  let : IsProbabilityMeasure P := hB₀.isGaussianProcess.isProbabilityMeasure
+  let ℱ := Filtration.natural B₀ (fun t => (hm t).stronglyMeasurable)
+  have ha := brownian_capacity_trace_adapted B₀ hm hc κ γ G F₀ hw
+  have hγm (t : ℝ≥0) : Measurable (fun ω => γ ω t) := (ha t).mono (ℱ.le t) le_rfl
+  have hSLE : IsOrdinaryChordalSLE κ γ P :=
+    ⟨hγm, B₀, hB₀, Eventually.of_forall (fun ω => ⟨G ω, F₀ ω, hw ω⟩)⟩
+  obtain ⟨T₀, hT₀, q₀, hq₀, hheight⟩ := uniform_bounded_firstHeight_real_probability
+    κ hκ hκ8 B₀ hB₀ hm hc γ G F₀ hw hsupport
+  obtain ⟨b, A, d, L₀, hb, hA, hd, hL₀, hloc⟩ :=
+    common_access_gives_firstHeight_localization κ hκ hκ8
+  obtain ⟨b₀, hb₀, hlocseq⟩ := hloc Ω P γ hSLE (fun ω => (hw ω).1)
+    (fun ω => (hw ω).2.1) (fun ω t => (hw ω).2.2.1 t)
+    Fₙ Fbar hFn hinj hbar hext δ hδ βₙ hβc hβ0 hβHn z hz hβconv
+    αₙ aₙ Cg hα hα0 hmap r₀ hr₀ hsmallGuide
+  refine ⟨T₀, hT₀, q₀, b₀, b, A, d, L₀, hq₀, hb₀, hb, hA, hd, hL₀, ?_⟩
+  intro L hL hsmall B r hB hr hBL F hF a O W hO hW β tB T htB htBT hβ hi hβH
+    hcross hafter hcircle hsector htail hend hne hconv pₙ p U hU hp hpn hpconv hOU
+    hWfront hstartBall hearlyBall V hV hOV Vₙ hVVₙ bₙ ε hterminal hearlyAllowed
+    v hv hlim η hηc hηbar Rₙ hregion
+  let Tc := T₀ * (Real.toNNReal B) ^ 2
+  have hheightB := hheight B hB
+  have hpositive : 0 < P (stoppedNarrowCertificate γ
+      (fun ω => boundedFirstHeightTime (γ ω) B Tc) B Tc) :=
+    (ENNReal.ofReal_pos.mpr hq₀).trans_le hheightB
+  have hmissing : ∀ᶠ n in atTop, P (stoppedNarrowCertificate γ
+      (fun ω => boundedFirstHeightTime (γ ω) B Tc) B Tc \
+        stoppedImageEvent γ (fun ω => boundedFirstHeightTime (γ ω) B Tc)
+          (Fbar n) (aₙ n) (L * r₀)) ≤
+      P (stoppedNarrowCertificate γ (fun ω => boundedFirstHeightTime (γ ω) B Tc) B Tc) / 2 := by
+    filter_upwards [hlocseq] with n hn
+    calc
+      _ ≤ ENNReal.ofReal (A * L ^ (-d)) := hn L hL B hB hBL Tc
+      _ ≤ ENNReal.ofReal (q₀ / 2) := ENNReal.ofReal_le_ofReal hsmall
+      _ = ENNReal.ofReal q₀ / 2 := by
+        rw [ENNReal.ofReal_div_of_pos (by norm_num : (0 : ℝ) < 2)]
+        norm_num
+      _ ≤ _ := ENNReal.div_le_div_right hheightB 2
+  exact bounded_splice_sequence_success_middle_regions κ hκ hκ8 B₀ hB₀ hm hc γ G F₀ hw hboundary hsupport
+    B r hB hr Tc F hF a O W hO hW β tB T htB htBT hβ hi hβH hcross hafter hcircle hsector
+    htail hend Fbar hbar aₙ (L * r₀) Fₙ hFn hinj hne hconv hext pₙ p U hU hp hpn hpconv
+    hOU hWfront hstartBall hearlyBall V hV hOV Vₙ hVVₙ bₙ ε hterminal hearlyAllowed
+    v hv hlim η hηc hηbar Rₙ hregion hpositive hmissing
+
+end SLEExactGauge.SequencePassage
+
+end
+
+end OAI

lean/OAI/Probability/SLE/Gauge/SequencePassageSuccess.lean

@@ -1,256 +1,256 @@
-import OAI.Probability.SLE.Gauge.SequencePassage
-import OAI.Probability.SLE.Gauge.PassageSuccess
-
-namespace OAI
-
-/-! Successful sequence passage: full allowed-ribbon containment and the
-terminal tip offset accompany the actual stopped sausage lower bound. -/
-
-noncomputable section
-open Set Filter MeasureTheory ProbabilityTheory Metric
-open scoped Topology NNReal ENNReal
-
-namespace SLEExactGauge.SequencePassage
-open FirstHeightSupport EarlyPassageLocalization FirstFrontPassage PassageSuccess
-
-local instance successSequencePathMeasurable : MeasurableSpace C(ℝ≥0, ℂ) := borel _
-local instance successSequencePathBorel : BorelSpace C(ℝ≥0, ℂ) := ⟨rfl⟩
-
-theorem bounded_splice_sequence_success
-    {Ω : Type*} [mΩ : MeasurableSpace Ω] {P : Measure Ω}
-    (κ : ℝ) (hκ : 0 < κ) (hκ8 : κ < 8)
-    (B₀ : ℝ≥0 → Ω → ℝ) (hB₀ : IsBrownianReal B₀ P)
-    (hm : ∀ t, Measurable (B₀ t)) (hc : ∀ ω, Continuous (fun t => B₀ t ω))
-    (γ : Ω → ℝ≥0 → ℂ) (G F₀ : Ω → ℝ≥0 → ℂ → ℂ)
-    (hw : ∀ ω, IsCapacityTwoWitness (fun t => Real.sqrt κ * B₀ t ω)
-      (γ ω) (G ω) (F₀ ω))
-    (hboundary : PublishedLoewnerBoundaryExtension)
-    (hsupport : PublishedGeometricTubeSupport P γ)
-    (B r : ℝ) (hB : 0 < B) (hr : 0 < r) (Tc : ℝ≥0)
-    (F : ℂ → ℂ) (hF : DifferentiableOn ℂ F upperHalfPlane) (a : ℂ)
-    (O W : Set ℂ) (hO : IsOpen O) (hW : IsOpen W)
-    (β : ℝ → ℂ) (tB T : ℝ) (htB : 0 < tB) (htBT : tB < T)
-    (hβ : ContinuousOn β (Icc 0 T)) (hi : InjOn β (Icc 0 T))
-    (hβH : ∀ t ∈ Ioc 0 T, 0 < (β t).im)
-    (hcross : ‖β tB‖ = B) (hafter : ∀ t ∈ Ioc tB T, B < ‖β t‖)
-    (hcircle : ∀ θ ∈ Ioo 0 Real.pi, ‖F (GuideSplice.circlePoint B θ) - a‖ < r / 4)
-    (hsector : ∀ z : ℂ, B / 8 ≤ ‖z‖ → ‖z‖ ≤ B → ‖z‖ / 2 ≤ z.im →
-      ‖F z - a‖ < r / 4)
-    (htail : F '' (β '' Icc tB T) ⊆ O) (hend : β T ∈ W)
-    (Fbar : ℕ → ℂ → OnePoint ℂ)
-    (hbar : ∀ n, ContinuousOn (Fbar n) closedHalfPlane)
-    (aₙ : ℕ → ℂ) (ρ : ℝ)
-    (Fₙ : ℕ → ℂ → ℂ)
-    (hFn : ∀ n, DifferentiableOn ℂ (Fₙ n) upperHalfPlane)
-    (hinj : ∀ n, InjOn (Fₙ n) upperHalfPlane)
-    (hne : ∀ z ∈ upperHalfPlane, deriv F z ≠ 0)
-    (hconv : TendstoLocallyUniformlyOn Fₙ F atTop upperHalfPlane)
-    (hext : ∀ n z, z ∈ upperHalfPlane → Fbar n z = (Fₙ n z : OnePoint ℂ))
-    (pₙ : ℕ → ℂ → ℝ) (p : ℂ → ℝ) (U : Set ℂ) (hU : IsOpen U)
-    (hp : ContinuousOn p U) (hpn : ∀ n, ContinuousOn (pₙ n) U)
-    (hpconv : TendstoLocallyUniformlyOn pₙ p atTop U)
-    (hOU : ball a (r / 2) ∪ O ⊆ U)
-    (hWfront : ∀ z ∈ W, 1 < p (F z))
-    (hstartBall : ∀ z ∈ ball a (r / 4), p z < 1 / 3)
-    (hearlyBall : ∀ᶠ n in atTop, ball (aₙ n) ρ ⊆ U ∩ {z | pₙ n z < 1})
-    (V : Set ℂ) (hV : IsOpen V) (hOV : ball a (r / 2) ∪ O ⊆ V)
-    (Vₙ : ℕ → Set ℂ) (hVVₙ : ∀ᶠ n in atTop, V ⊆ Vₙ n)
-    (bₙ : ℕ → ℂ) (ε : ℝ)
-    (hterminal : ∀ n z, z ∈ Vₙ n → pₙ n z = 1 → ‖z - bₙ n‖ < ε / 4)
-    (hearlyAllowed : ∀ᶠ n in atTop, ball (aₙ n) ρ ⊆ Vₙ n)
-    (R : Set ℂ) (hR : IsOpen R)
-    (hmiddle : ∀ z ∈ ball a (r / 2) ∪ O, 1 / 3 < p z → p z < 2 / 3 → z ∈ R)
-    (v : ℕ → ℝ) (hv : ∀ n, 0 < v n) (hlim : Tendsto v atTop (𝓝 0))
-    (η : ℕ → Ω → ℝ≥0 → ℂ) (hηc : ∀ n, ∀ᵐ ω ∂P, Continuous (η n ω))
-    (hηbar : ∀ n, ∀ᵐ ω ∂P, ∀ t, Fbar n (γ ω t) = (η n ω t : OnePoint ℂ))
-    (Rₙ : ℕ → Set ℂ) (hregion : ∀ᶠ n in atTop, R ⊆ Rₙ n)
-    (hpositive : 0 < P (stoppedNarrowCertificate γ
-      (fun ω => boundedFirstHeightTime (γ ω) B Tc) B Tc))
-    (hmissing : ∀ᶠ n in atTop, P (stoppedNarrowCertificate γ
-      (fun ω => boundedFirstHeightTime (γ ω) B Tc) B Tc \
-        stoppedImageEvent γ (fun ω => boundedFirstHeightTime (γ ω) B Tc)
-          (Fbar n) (aₙ n) ρ) ≤
-      P (stoppedNarrowCertificate γ (fun ω => boundedFirstHeightTime (γ ω) B Tc) B Tc) / 2) :
-    ∃ c q : ℝ, 0 < c ∧ 0 < q ∧ ∀ᶠ n in atTop, ENNReal.ofReal q ≤ P {ω |
-      ω ∈ FrontSuccess η pₙ (fun ω => boundedFirstHeightTime (γ ω) B Tc) Vₙ bₙ ε n ∧
-      ENNReal.ofReal c ≤ segmentSausageCharge κ (η n ω)
-        (boundedFirstHeightTime (γ ω) B Tc)
-        (frontTime (fun t => pₙ n (η n ω t)) 1) (v n) (Rₙ n)} := by
-  let : IsProbabilityMeasure P := hB₀.isGaussianProcess.isProbabilityMeasure
-  let ℱ := Filtration.natural B₀ (fun t => (hm t).stronglyMeasurable)
-  let σ := fun ω => boundedFirstHeightTime (γ ω) B Tc
-  have ha := brownian_capacity_trace_adapted B₀ hm hc κ γ G F₀ hw
-  have hγm (t : ℝ≥0) : Measurable (fun ω => γ ω t) := (ha t).mono (ℱ.le t) le_rfl
-  have hSLE : IsOrdinaryChordalSLE κ γ P :=
-    ⟨hγm, B₀, hB₀, Eventually.of_forall (fun ω => ⟨G ω, F₀ ω, hw ω⟩)⟩
-  have hσ := boundedFirstHeightTime_isStoppingTime ℱ γ ha (fun ω => (hw ω).1) B Tc
-  have hσm : Measurable σ := stopping_time_measurable_nnreal hσ
-  let f := sourceTracePath γ (fun ω => (hw ω).1)
-  have hfm : Measurable f := source_path_measurable f hγm
-  let Uparam := parameterContinuationRegion F a r O
-  have hUparam : IsOpen Uparam := parameterContinuationRegion_isOpen hF.continuousOn a r hO
-  let C := stoppedPhysicalTube γ σ Uparam W
-  let E := stoppedNarrowCertificate γ σ B Tc ∩ C
-  let H : ℕ → Set Ω := fun n => stoppedImageEvent γ σ (Fbar n) (aₙ n) ρ
-  have hEm : MeasurableSet E := by
-    apply MeasurableSet.inter
-    · exact hσ.measurableSpace_le _
-        (boundedFirstHeight_certificate_measurable ℱ γ ha (fun ω => (hw ω).1) B Tc)
-    · exact measurableSet_stoppedPhysicalTube γ (fun ω => (hw ω).1) hγm σ hσm Uparam W hUparam hW
-  have hstart : ∀ ω ∈ E, p (F (γ ω (σ ω))) < 1 / 3 := by
-    intro ω hω
-    have hnorm := bounded_firstHeight_norm (f ω) (hw ω).2.1 (hw ω).2.2.1
-      hB Tc hω.1 (σ ω) ⟨bot_le, le_rfl⟩
-    change ‖γ ω (σ ω)‖ < B / 2 at hnorm
-    have hheight : (γ ω (σ ω)).im = B / 4 := hω.1.2.1
-    have him := Complex.im_le_norm (γ ω (σ ω))
-    have hsmall := hsector (γ ω (σ ω)) (by linarith) (by linarith)
-      (by rw [hheight]; linarith)
-    exact hstartBall _ (by simpa only [mem_ball, dist_eq_norm] using hsmall)
-  obtain ⟨q, hq, hprob⟩ := eventual_bounded_splice_probability κ hκ hκ8 B₀ hB₀ hm hc
-    γ G F₀ hw hboundary hsupport B r hB hr Tc F hF.continuousOn a O W hO hW
-    β tB T htB htBT hβ hi hβH hcross hafter hcircle hsector htail hend Fbar hbar aₙ ρ
-    hpositive hmissing
-  have hη : ∀ n, ∀ᵐ ω ∂P, ∀ t : ℝ≥0, σ ω ≤ t → γ ω t ∈ upperHalfPlane →
-      η n ω t = Fₙ n (γ ω t) := by
-    intro n
-    filter_upwards [hηbar n] with ω hω
-    intro t _ ht
-    exact OnePoint.coe_injective ((hω t).symm.trans (hext n _ ht))
-  have hearly : ∀ᶠ n in atTop, ∀ᵐ ω ∂P, ω ∈ H n ∩ E →
-      MapsTo (η n ω) (Icc 0 (σ ω)) U ∧
-        ∀ t ∈ Icc 0 (σ ω), pₙ n (η n ω t) < 1 := by
-    filter_upwards [hearlyBall] with n hn
-    filter_upwards [hηbar n] with ω hω
-    intro hmem
-    have himage : MapsTo (η n ω) (Icc 0 (σ ω)) (ball (aₙ n) ρ) := by
-      intro t ht
-      obtain ⟨z, hz, he⟩ := hmem.1 t ht
-      have heq : z = η n ω t := OnePoint.coe_injective (he.trans (hω t))
-      exact heq ▸ hz
-    exact ⟨fun _ ht => (hn (himage ht)).1, fun _ ht => (hn (himage ht)).2⟩
-  have hearlyV : ∀ᶠ n in atTop, ∀ᵐ ω ∂P, ω ∈ H n ∩ E →
-      MapsTo (η n ω) (Icc 0 (σ ω)) (Vₙ n) := by
-    filter_upwards [hearlyAllowed] with n hn
-    filter_upwards [hηbar n] with ω hω
-    intro hmem t ht
-    obtain ⟨z, hz, he⟩ := hmem.1 t ht
-    have heq : z = η n ω t := OnePoint.coe_injective (he.trans (hω t))
-    exact hn (heq ▸ hz)
-  obtain ⟨c, hcpos, hmass⟩ := retained_tube_firstFront_success_mass P κ hκ hκ8
-    f hfm hSLE σ hσm Fₙ F hFn hinj hF hne hconv Uparam W hUparam inter_subset_left
-    pₙ p U hU hp hpn hpconv (fun _ hz => hOU hz.2) hWfront E hEm inter_subset_right
-    hstart V hV (fun _ hz => hOV hz.2) Vₙ hVVₙ bₙ ε hterminal
-    R hR (fun _ hz => hmiddle _ hz.2) v hv hlim η Rₙ hregion H q hq hprob hη hηc hearly hearlyV
-  exact ⟨c, q / 8, hcpos, by positivity, hmass⟩
-
-
-theorem localized_sequence_passage_success
-    {Ω : Type*} [mΩ : MeasurableSpace Ω] {P : Measure Ω}
-    (κ : ℝ) (hκ : 0 < κ) (hκ8 : κ < 8)
-    (B₀ : ℝ≥0 → Ω → ℝ) (hB₀ : IsBrownianReal B₀ P)
-    (hm : ∀ t, Measurable (B₀ t)) (hc : ∀ ω, Continuous (fun t => B₀ t ω))
-    (γ : Ω → ℝ≥0 → ℂ) (G F₀ : Ω → ℝ≥0 → ℂ → ℂ)
-    (hw : ∀ ω, IsCapacityTwoWitness (fun t => Real.sqrt κ * B₀ t ω)
-      (γ ω) (G ω) (F₀ ω))
-    (hboundary : PublishedLoewnerBoundaryExtension)
-    (hsupport : PublishedGeometricTubeSupport P γ)
-    (Fₙ : ℕ → ℂ → ℂ) (Fbar : ℕ → ℂ → OnePoint ℂ)
-    (hFn : ∀ n, DifferentiableOn ℂ (Fₙ n) upperHalfPlane)
-    (hinj : ∀ n, InjOn (Fₙ n) upperHalfPlane)
-    (hbar : ∀ n, ContinuousOn (Fbar n) closedHalfPlane)
-    (hext : ∀ n z, z ∈ upperHalfPlane → Fbar n z = (Fₙ n z : OnePoint ℂ))
-    (δ : ℝ) (hδ : 0 < δ) (βₙ : ℕ → ℝ → ℂ)
-    (hβc : ∀ n, ContinuousOn (βₙ n) (Icc 0 δ)) (hβ0 : ∀ n, βₙ n 0 = 0)
-    (hβHn : ∀ n t, t ∈ Icc 0 δ → 0 ≤ (βₙ n t).im)
-    (z : ℂ) (hz : z ≠ 0) (hβconv : Tendsto (fun n => βₙ n δ) atTop (𝓝 z))
-    (αₙ : ℕ → ℝ → ℂ) (aₙ : ℕ → ℂ) (Cg : ℝ≥0)
-    (hα : ∀ n, LipschitzOnWith Cg (αₙ n) (Icc 0 δ)) (hα0 : ∀ n, αₙ n 0 = aₙ n)
-    (hmap : ∀ n t, t ∈ Icc 0 δ → Fbar n (βₙ n t) = (αₙ n t : OnePoint ℂ))
-    (r₀ : ℝ) (hr₀ : 0 < r₀) (hsmallGuide : (Cg : ℝ) * δ ≤ r₀) :
-    ∃ T₀ : ℝ≥0, 0 < T₀ ∧ ∃ q₀ b₀ b A d L₀ : ℝ,
-      0 < q₀ ∧ 0 < b₀ ∧ 0 < b ∧ 0 < A ∧ 0 < d ∧ 1 < L₀ ∧
-      ∀ (L : ℝ), L₀ ≤ L → A * L ^ (-d) ≤ q₀ / 2 →
-      ∀ (B r : ℝ), 0 < B → 0 < r → B / 2 ≤ b₀ * L ^ b →
-      ∀ (F : ℂ → ℂ), DifferentiableOn ℂ F upperHalfPlane →
-      ∀ (a : ℂ) (O W : Set ℂ), IsOpen O → IsOpen W →
-      ∀ (β : ℝ → ℂ) (tB T : ℝ), 0 < tB → tB < T →
-      ContinuousOn β (Icc 0 T) → InjOn β (Icc 0 T) →
-      (∀ t ∈ Ioc 0 T, 0 < (β t).im) → ‖β tB‖ = B →
-      (∀ t ∈ Ioc tB T, B < ‖β t‖) →
-      (∀ θ ∈ Ioo 0 Real.pi, ‖F (GuideSplice.circlePoint B θ) - a‖ < r / 4) →
-      (∀ w : ℂ, B / 8 ≤ ‖w‖ → ‖w‖ ≤ B → ‖w‖ / 2 ≤ w.im → ‖F w - a‖ < r / 4) →
-      F '' (β '' Icc tB T) ⊆ O → β T ∈ W →
-      (∀ w ∈ upperHalfPlane, deriv F w ≠ 0) →
-      TendstoLocallyUniformlyOn Fₙ F atTop upperHalfPlane →
-      ∀ (pₙ : ℕ → ℂ → ℝ) (p : ℂ → ℝ) (U : Set ℂ), IsOpen U →
-      ContinuousOn p U → (∀ n, ContinuousOn (pₙ n) U) →
-      TendstoLocallyUniformlyOn pₙ p atTop U →
-      ball a (r / 2) ∪ O ⊆ U → (∀ w ∈ W, 1 < p (F w)) →
-      (∀ w ∈ ball a (r / 4), p w < 1 / 3) →
-      (∀ᶠ n in atTop, ball (aₙ n) (L * r₀) ⊆ U ∩ {w | pₙ n w < 1}) →
-      ∀ (V : Set ℂ), IsOpen V → ball a (r / 2) ∪ O ⊆ V →
-      ∀ (Vₙ : ℕ → Set ℂ), (∀ᶠ n in atTop, V ⊆ Vₙ n) →
-      ∀ (bₙ : ℕ → ℂ) (ε : ℝ),
-      (∀ n w, w ∈ Vₙ n → pₙ n w = 1 → ‖w - bₙ n‖ < ε / 4) →
-      (∀ᶠ n in atTop, ball (aₙ n) (L * r₀) ⊆ Vₙ n) →
-      ∀ (R : Set ℂ), IsOpen R →
-      (∀ w ∈ ball a (r / 2) ∪ O, 1 / 3 < p w → p w < 2 / 3 → w ∈ R) →
-      ∀ (v : ℕ → ℝ), (∀ n, 0 < v n) → Tendsto v atTop (𝓝 0) →
-      ∀ (η : ℕ → Ω → ℝ≥0 → ℂ), (∀ n, ∀ᵐ ω ∂P, Continuous (η n ω)) →
-      (∀ n, ∀ᵐ ω ∂P, ∀ t, Fbar n (γ ω t) = (η n ω t : OnePoint ℂ)) →
-      ∀ (Rₙ : ℕ → Set ℂ), (∀ᶠ n in atTop, R ⊆ Rₙ n) →
-      ∃ c q : ℝ, 0 < c ∧ 0 < q ∧ ∀ᶠ n in atTop, ENNReal.ofReal q ≤ P {ω |
-        ω ∈ FrontSuccess η pₙ
-          (fun ω => boundedFirstHeightTime (γ ω) B (T₀ * (Real.toNNReal B) ^ 2)) Vₙ bₙ ε n ∧
-        ENNReal.ofReal c ≤ segmentSausageCharge κ (η n ω)
-          (boundedFirstHeightTime (γ ω) B (T₀ * (Real.toNNReal B) ^ 2))
-          (frontTime (fun t => pₙ n (η n ω t)) 1) (v n) (Rₙ n)} := by
-  let : IsProbabilityMeasure P := hB₀.isGaussianProcess.isProbabilityMeasure
-  let ℱ := Filtration.natural B₀ (fun t => (hm t).stronglyMeasurable)
-  have ha := brownian_capacity_trace_adapted B₀ hm hc κ γ G F₀ hw
-  have hγm (t : ℝ≥0) : Measurable (fun ω => γ ω t) := (ha t).mono (ℱ.le t) le_rfl
-  have hSLE : IsOrdinaryChordalSLE κ γ P :=
-    ⟨hγm, B₀, hB₀, Eventually.of_forall (fun ω => ⟨G ω, F₀ ω, hw ω⟩)⟩
-  obtain ⟨T₀, hT₀, q₀, hq₀, hheight⟩ := uniform_bounded_firstHeight_real_probability
-    κ hκ hκ8 B₀ hB₀ hm hc γ G F₀ hw hsupport
-  obtain ⟨b, A, d, L₀, hb, hA, hd, hL₀, hloc⟩ :=
-    common_access_gives_firstHeight_localization κ hκ hκ8
-  obtain ⟨b₀, hb₀, hlocseq⟩ := hloc Ω P γ hSLE (fun ω => (hw ω).1)
-    (fun ω => (hw ω).2.1) (fun ω t => (hw ω).2.2.1 t)
-    Fₙ Fbar hFn hinj hbar hext δ hδ βₙ hβc hβ0 hβHn z hz hβconv
-    αₙ aₙ Cg hα hα0 hmap r₀ hr₀ hsmallGuide
-  refine ⟨T₀, hT₀, q₀, b₀, b, A, d, L₀, hq₀, hb₀, hb, hA, hd, hL₀, ?_⟩
-  intro L hL hsmall B r hB hr hBL F hF a O W hO hW β tB T htB htBT hβ hi hβH
-    hcross hafter hcircle hsector htail hend hne hconv pₙ p U hU hp hpn hpconv hOU
-    hWfront hstartBall hearlyBall V hV hOV Vₙ hVVₙ bₙ ε hterminal hearlyAllowed
-    R hR hmiddle v hv hlim η hηc hηbar Rₙ hregion
-  let Tc := T₀ * (Real.toNNReal B) ^ 2
-  have hheightB := hheight B hB
-  have hpositive : 0 < P (stoppedNarrowCertificate γ
-      (fun ω => boundedFirstHeightTime (γ ω) B Tc) B Tc) :=
-    (ENNReal.ofReal_pos.mpr hq₀).trans_le hheightB
-  have hmissing : ∀ᶠ n in atTop, P (stoppedNarrowCertificate γ
-      (fun ω => boundedFirstHeightTime (γ ω) B Tc) B Tc \
-        stoppedImageEvent γ (fun ω => boundedFirstHeightTime (γ ω) B Tc)
-          (Fbar n) (aₙ n) (L * r₀)) ≤
-      P (stoppedNarrowCertificate γ (fun ω => boundedFirstHeightTime (γ ω) B Tc) B Tc) / 2 := by
-    filter_upwards [hlocseq] with n hn
-    calc
-      _ ≤ ENNReal.ofReal (A * L ^ (-d)) := hn L hL B hB hBL Tc
-      _ ≤ ENNReal.ofReal (q₀ / 2) := ENNReal.ofReal_le_ofReal hsmall
-      _ = ENNReal.ofReal q₀ / 2 := by
-        rw [ENNReal.ofReal_div_of_pos (by norm_num : (0 : ℝ) < 2)]
-        norm_num
-      _ ≤ _ := ENNReal.div_le_div_right hheightB 2
-  exact bounded_splice_sequence_success κ hκ hκ8 B₀ hB₀ hm hc γ G F₀ hw hboundary hsupport
-    B r hB hr Tc F hF a O W hO hW β tB T htB htBT hβ hi hβH hcross hafter hcircle hsector
-    htail hend Fbar hbar aₙ (L * r₀) Fₙ hFn hinj hne hconv hext pₙ p U hU hp hpn hpconv
-    hOU hWfront hstartBall hearlyBall V hV hOV Vₙ hVVₙ bₙ ε hterminal hearlyAllowed
-    R hR hmiddle v hv hlim η hηc hηbar Rₙ hregion hpositive hmissing
-
-end SLEExactGauge.SequencePassage
-
-end
-
-end OAI
+import OAI.Probability.SLE.Gauge.SequencePassage
+import OAI.Probability.SLE.Gauge.PassageSuccess
+
+namespace OAI
+
+/-! Successful sequence passage: full allowed-ribbon containment and the
+terminal tip offset accompany the actual stopped sausage lower bound. -/
+
+noncomputable section
+open Set Filter MeasureTheory ProbabilityTheory Metric
+open scoped Topology NNReal ENNReal
+
+namespace SLEExactGauge.SequencePassage
+open FirstHeightSupport EarlyPassageLocalization FirstFrontPassage PassageSuccess
+
+local instance successSequencePathMeasurable : MeasurableSpace C(ℝ≥0, ℂ) := borel _
+local instance successSequencePathBorel : BorelSpace C(ℝ≥0, ℂ) := ⟨rfl⟩
+
+theorem bounded_splice_sequence_success
+    {Ω : Type*} [mΩ : MeasurableSpace Ω] {P : Measure Ω}
+    (κ : ℝ) (hκ : 0 < κ) (hκ8 : κ < 8)
+    (B₀ : ℝ≥0 → Ω → ℝ) (hB₀ : IsBrownianReal B₀ P)
+    (hm : ∀ t, Measurable (B₀ t)) (hc : ∀ ω, Continuous (fun t => B₀ t ω))
+    (γ : Ω → ℝ≥0 → ℂ) (G F₀ : Ω → ℝ≥0 → ℂ → ℂ)
+    (hw : ∀ ω, IsCapacityTwoWitness (fun t => Real.sqrt κ * B₀ t ω)
+      (γ ω) (G ω) (F₀ ω))
+    (hboundary : PublishedLoewnerBoundaryExtension)
+    (hsupport : PublishedGeometricTubeSupport P γ)
+    (B r : ℝ) (hB : 0 < B) (hr : 0 < r) (Tc : ℝ≥0)
+    (F : ℂ → ℂ) (hF : DifferentiableOn ℂ F upperHalfPlane) (a : ℂ)
+    (O W : Set ℂ) (hO : IsOpen O) (hW : IsOpen W)
+    (β : ℝ → ℂ) (tB T : ℝ) (htB : 0 < tB) (htBT : tB < T)
+    (hβ : ContinuousOn β (Icc 0 T)) (hi : InjOn β (Icc 0 T))
+    (hβH : ∀ t ∈ Ioc 0 T, 0 < (β t).im)
+    (hcross : ‖β tB‖ = B) (hafter : ∀ t ∈ Ioc tB T, B < ‖β t‖)
+    (hcircle : ∀ θ ∈ Ioo 0 Real.pi, ‖F (GuideSplice.circlePoint B θ) - a‖ < r / 4)
+    (hsector : ∀ z : ℂ, B / 8 ≤ ‖z‖ → ‖z‖ ≤ B → ‖z‖ / 2 ≤ z.im →
+      ‖F z - a‖ < r / 4)
+    (htail : F '' (β '' Icc tB T) ⊆ O) (hend : β T ∈ W)
+    (Fbar : ℕ → ℂ → OnePoint ℂ)
+    (hbar : ∀ n, ContinuousOn (Fbar n) closedHalfPlane)
+    (aₙ : ℕ → ℂ) (ρ : ℝ)
+    (Fₙ : ℕ → ℂ → ℂ)
+    (hFn : ∀ n, DifferentiableOn ℂ (Fₙ n) upperHalfPlane)
+    (hinj : ∀ n, InjOn (Fₙ n) upperHalfPlane)
+    (hne : ∀ z ∈ upperHalfPlane, deriv F z ≠ 0)
+    (hconv : TendstoLocallyUniformlyOn Fₙ F atTop upperHalfPlane)
+    (hext : ∀ n z, z ∈ upperHalfPlane → Fbar n z = (Fₙ n z : OnePoint ℂ))
+    (pₙ : ℕ → ℂ → ℝ) (p : ℂ → ℝ) (U : Set ℂ) (hU : IsOpen U)
+    (hp : ContinuousOn p U) (hpn : ∀ n, ContinuousOn (pₙ n) U)
+    (hpconv : TendstoLocallyUniformlyOn pₙ p atTop U)
+    (hOU : ball a (r / 2) ∪ O ⊆ U)
+    (hWfront : ∀ z ∈ W, 1 < p (F z))
+    (hstartBall : ∀ z ∈ ball a (r / 4), p z < 1 / 3)
+    (hearlyBall : ∀ᶠ n in atTop, ball (aₙ n) ρ ⊆ U ∩ {z | pₙ n z < 1})
+    (V : Set ℂ) (hV : IsOpen V) (hOV : ball a (r / 2) ∪ O ⊆ V)
+    (Vₙ : ℕ → Set ℂ) (hVVₙ : ∀ᶠ n in atTop, V ⊆ Vₙ n)
+    (bₙ : ℕ → ℂ) (ε : ℝ)
+    (hterminal : ∀ n z, z ∈ Vₙ n → pₙ n z = 1 → ‖z - bₙ n‖ < ε / 4)
+    (hearlyAllowed : ∀ᶠ n in atTop, ball (aₙ n) ρ ⊆ Vₙ n)
+    (R : Set ℂ) (hR : IsOpen R)
+    (hmiddle : ∀ z ∈ ball a (r / 2) ∪ O, 1 / 3 < p z → p z < 2 / 3 → z ∈ R)
+    (v : ℕ → ℝ) (hv : ∀ n, 0 < v n) (hlim : Tendsto v atTop (𝓝 0))
+    (η : ℕ → Ω → ℝ≥0 → ℂ) (hηc : ∀ n, ∀ᵐ ω ∂P, Continuous (η n ω))
+    (hηbar : ∀ n, ∀ᵐ ω ∂P, ∀ t, Fbar n (γ ω t) = (η n ω t : OnePoint ℂ))
+    (Rₙ : ℕ → Set ℂ) (hregion : ∀ᶠ n in atTop, R ⊆ Rₙ n)
+    (hpositive : 0 < P (stoppedNarrowCertificate γ
+      (fun ω => boundedFirstHeightTime (γ ω) B Tc) B Tc))
+    (hmissing : ∀ᶠ n in atTop, P (stoppedNarrowCertificate γ
+      (fun ω => boundedFirstHeightTime (γ ω) B Tc) B Tc \
+        stoppedImageEvent γ (fun ω => boundedFirstHeightTime (γ ω) B Tc)
+          (Fbar n) (aₙ n) ρ) ≤
+      P (stoppedNarrowCertificate γ (fun ω => boundedFirstHeightTime (γ ω) B Tc) B Tc) / 2) :
+    ∃ c q : ℝ, 0 < c ∧ 0 < q ∧ ∀ᶠ n in atTop, ENNReal.ofReal q ≤ P {ω |
+      ω ∈ FrontSuccess η pₙ (fun ω => boundedFirstHeightTime (γ ω) B Tc) Vₙ bₙ ε n ∧
+      ENNReal.ofReal c ≤ segmentSausageCharge κ (η n ω)
+        (boundedFirstHeightTime (γ ω) B Tc)
+        (frontTime (fun t => pₙ n (η n ω t)) 1) (v n) (Rₙ n)} := by
+  let : IsProbabilityMeasure P := hB₀.isGaussianProcess.isProbabilityMeasure
+  let ℱ := Filtration.natural B₀ (fun t => (hm t).stronglyMeasurable)
+  let σ := fun ω => boundedFirstHeightTime (γ ω) B Tc
+  have ha := brownian_capacity_trace_adapted B₀ hm hc κ γ G F₀ hw
+  have hγm (t : ℝ≥0) : Measurable (fun ω => γ ω t) := (ha t).mono (ℱ.le t) le_rfl
+  have hSLE : IsOrdinaryChordalSLE κ γ P :=
+    ⟨hγm, B₀, hB₀, Eventually.of_forall (fun ω => ⟨G ω, F₀ ω, hw ω⟩)⟩
+  have hσ := boundedFirstHeightTime_isStoppingTime ℱ γ ha (fun ω => (hw ω).1) B Tc
+  have hσm : Measurable σ := stopping_time_measurable_nnreal hσ
+  let f := sourceTracePath γ (fun ω => (hw ω).1)
+  have hfm : Measurable f := source_path_measurable f hγm
+  let Uparam := parameterContinuationRegion F a r O
+  have hUparam : IsOpen Uparam := parameterContinuationRegion_isOpen hF.continuousOn a r hO
+  let C := stoppedPhysicalTube γ σ Uparam W
+  let E := stoppedNarrowCertificate γ σ B Tc ∩ C
+  let H : ℕ → Set Ω := fun n => stoppedImageEvent γ σ (Fbar n) (aₙ n) ρ
+  have hEm : MeasurableSet E := by
+    apply MeasurableSet.inter
+    · exact hσ.measurableSpace_le _
+        (boundedFirstHeight_certificate_measurable ℱ γ ha (fun ω => (hw ω).1) B Tc)
+    · exact measurableSet_stoppedPhysicalTube γ (fun ω => (hw ω).1) hγm σ hσm Uparam W hUparam hW
+  have hstart : ∀ ω ∈ E, p (F (γ ω (σ ω))) < 1 / 3 := by
+    intro ω hω
+    have hnorm := bounded_firstHeight_norm (f ω) (hw ω).2.1 (hw ω).2.2.1
+      hB Tc hω.1 (σ ω) ⟨bot_le, le_rfl⟩
+    change ‖γ ω (σ ω)‖ < B / 2 at hnorm
+    have hheight : (γ ω (σ ω)).im = B / 4 := hω.1.2.1
+    have him := Complex.im_le_norm (γ ω (σ ω))
+    have hsmall := hsector (γ ω (σ ω)) (by linarith) (by linarith)
+      (by rw [hheight]; linarith)
+    exact hstartBall _ (by simpa only [mem_ball, dist_eq_norm] using hsmall)
+  obtain ⟨q, hq, hprob⟩ := eventual_bounded_splice_probability κ hκ hκ8 B₀ hB₀ hm hc
+    γ G F₀ hw hboundary hsupport B r hB hr Tc F hF.continuousOn a O W hO hW
+    β tB T htB htBT hβ hi hβH hcross hafter hcircle hsector htail hend Fbar hbar aₙ ρ
+    hpositive hmissing
+  have hη : ∀ n, ∀ᵐ ω ∂P, ∀ t : ℝ≥0, σ ω ≤ t → γ ω t ∈ upperHalfPlane →
+      η n ω t = Fₙ n (γ ω t) := by
+    intro n
+    filter_upwards [hηbar n] with ω hω
+    intro t _ ht
+    exact OnePoint.coe_injective ((hω t).symm.trans (hext n _ ht))
+  have hearly : ∀ᶠ n in atTop, ∀ᵐ ω ∂P, ω ∈ H n ∩ E →
+      MapsTo (η n ω) (Icc 0 (σ ω)) U ∧
+        ∀ t ∈ Icc 0 (σ ω), pₙ n (η n ω t) < 1 := by
+    filter_upwards [hearlyBall] with n hn
+    filter_upwards [hηbar n] with ω hω
+    intro hmem
+    have himage : MapsTo (η n ω) (Icc 0 (σ ω)) (ball (aₙ n) ρ) := by
+      intro t ht
+      obtain ⟨z, hz, he⟩ := hmem.1 t ht
+      have heq : z = η n ω t := OnePoint.coe_injective (he.trans (hω t))
+      exact heq ▸ hz
+    exact ⟨fun _ ht => (hn (himage ht)).1, fun _ ht => (hn (himage ht)).2⟩
+  have hearlyV : ∀ᶠ n in atTop, ∀ᵐ ω ∂P, ω ∈ H n ∩ E →
+      MapsTo (η n ω) (Icc 0 (σ ω)) (Vₙ n) := by
+    filter_upwards [hearlyAllowed] with n hn
+    filter_upwards [hηbar n] with ω hω
+    intro hmem t ht
+    obtain ⟨z, hz, he⟩ := hmem.1 t ht
+    have heq : z = η n ω t := OnePoint.coe_injective (he.trans (hω t))
+    exact hn (heq ▸ hz)
+  obtain ⟨c, hcpos, hmass⟩ := retained_tube_firstFront_success_mass P κ hκ hκ8
+    f hfm hSLE σ hσm Fₙ F hFn hinj hF hne hconv Uparam W hUparam inter_subset_left
+    pₙ p U hU hp hpn hpconv (fun _ hz => hOU hz.2) hWfront E hEm inter_subset_right
+    hstart V hV (fun _ hz => hOV hz.2) Vₙ hVVₙ bₙ ε hterminal
+    R hR (fun _ hz => hmiddle _ hz.2) v hv hlim η Rₙ hregion H q hq hprob hη hηc hearly hearlyV
+  exact ⟨c, q / 8, hcpos, by positivity, hmass⟩
+
+
+theorem localized_sequence_passage_success
+    {Ω : Type*} [mΩ : MeasurableSpace Ω] {P : Measure Ω}
+    (κ : ℝ) (hκ : 0 < κ) (hκ8 : κ < 8)
+    (B₀ : ℝ≥0 → Ω → ℝ) (hB₀ : IsBrownianReal B₀ P)
+    (hm : ∀ t, Measurable (B₀ t)) (hc : ∀ ω, Continuous (fun t => B₀ t ω))
+    (γ : Ω → ℝ≥0 → ℂ) (G F₀ : Ω → ℝ≥0 → ℂ → ℂ)
+    (hw : ∀ ω, IsCapacityTwoWitness (fun t => Real.sqrt κ * B₀ t ω)
+      (γ ω) (G ω) (F₀ ω))
+    (hboundary : PublishedLoewnerBoundaryExtension)
+    (hsupport : PublishedGeometricTubeSupport P γ)
+    (Fₙ : ℕ → ℂ → ℂ) (Fbar : ℕ → ℂ → OnePoint ℂ)
+    (hFn : ∀ n, DifferentiableOn ℂ (Fₙ n) upperHalfPlane)
+    (hinj : ∀ n, InjOn (Fₙ n) upperHalfPlane)
+    (hbar : ∀ n, ContinuousOn (Fbar n) closedHalfPlane)
+    (hext : ∀ n z, z ∈ upperHalfPlane → Fbar n z = (Fₙ n z : OnePoint ℂ))
+    (δ : ℝ) (hδ : 0 < δ) (βₙ : ℕ → ℝ → ℂ)
+    (hβc : ∀ n, ContinuousOn (βₙ n) (Icc 0 δ)) (hβ0 : ∀ n, βₙ n 0 = 0)
+    (hβHn : ∀ n t, t ∈ Icc 0 δ → 0 ≤ (βₙ n t).im)
+    (z : ℂ) (hz : z ≠ 0) (hβconv : Tendsto (fun n => βₙ n δ) atTop (𝓝 z))
+    (αₙ : ℕ → ℝ → ℂ) (aₙ : ℕ → ℂ) (Cg : ℝ≥0)
+    (hα : ∀ n, LipschitzOnWith Cg (αₙ n) (Icc 0 δ)) (hα0 : ∀ n, αₙ n 0 = aₙ n)
+    (hmap : ∀ n t, t ∈ Icc 0 δ → Fbar n (βₙ n t) = (αₙ n t : OnePoint ℂ))
+    (r₀ : ℝ) (hr₀ : 0 < r₀) (hsmallGuide : (Cg : ℝ) * δ ≤ r₀) :
+    ∃ T₀ : ℝ≥0, 0 < T₀ ∧ ∃ q₀ b₀ b A d L₀ : ℝ,
+      0 < q₀ ∧ 0 < b₀ ∧ 0 < b ∧ 0 < A ∧ 0 < d ∧ 1 < L₀ ∧
+      ∀ (L : ℝ), L₀ ≤ L → A * L ^ (-d) ≤ q₀ / 2 →
+      ∀ (B r : ℝ), 0 < B → 0 < r → B / 2 ≤ b₀ * L ^ b →
+      ∀ (F : ℂ → ℂ), DifferentiableOn ℂ F upperHalfPlane →
+      ∀ (a : ℂ) (O W : Set ℂ), IsOpen O → IsOpen W →
+      ∀ (β : ℝ → ℂ) (tB T : ℝ), 0 < tB → tB < T →
+      ContinuousOn β (Icc 0 T) → InjOn β (Icc 0 T) →
+      (∀ t ∈ Ioc 0 T, 0 < (β t).im) → ‖β tB‖ = B →
+      (∀ t ∈ Ioc tB T, B < ‖β t‖) →
+      (∀ θ ∈ Ioo 0 Real.pi, ‖F (GuideSplice.circlePoint B θ) - a‖ < r / 4) →
+      (∀ w : ℂ, B / 8 ≤ ‖w‖ → ‖w‖ ≤ B → ‖w‖ / 2 ≤ w.im → ‖F w - a‖ < r / 4) →
+      F '' (β '' Icc tB T) ⊆ O → β T ∈ W →
+      (∀ w ∈ upperHalfPlane, deriv F w ≠ 0) →
+      TendstoLocallyUniformlyOn Fₙ F atTop upperHalfPlane →
+      ∀ (pₙ : ℕ → ℂ → ℝ) (p : ℂ → ℝ) (U : Set ℂ), IsOpen U →
+      ContinuousOn p U → (∀ n, ContinuousOn (pₙ n) U) →
+      TendstoLocallyUniformlyOn pₙ p atTop U →
+      ball a (r / 2) ∪ O ⊆ U → (∀ w ∈ W, 1 < p (F w)) →
+      (∀ w ∈ ball a (r / 4), p w < 1 / 3) →
+      (∀ᶠ n in atTop, ball (aₙ n) (L * r₀) ⊆ U ∩ {w | pₙ n w < 1}) →
+      ∀ (V : Set ℂ), IsOpen V → ball a (r / 2) ∪ O ⊆ V →
+      ∀ (Vₙ : ℕ → Set ℂ), (∀ᶠ n in atTop, V ⊆ Vₙ n) →
+      ∀ (bₙ : ℕ → ℂ) (ε : ℝ),
+      (∀ n w, w ∈ Vₙ n → pₙ n w = 1 → ‖w - bₙ n‖ < ε / 4) →
+      (∀ᶠ n in atTop, ball (aₙ n) (L * r₀) ⊆ Vₙ n) →
+      ∀ (R : Set ℂ), IsOpen R →
+      (∀ w ∈ ball a (r / 2) ∪ O, 1 / 3 < p w → p w < 2 / 3 → w ∈ R) →
+      ∀ (v : ℕ → ℝ), (∀ n, 0 < v n) → Tendsto v atTop (𝓝 0) →
+      ∀ (η : ℕ → Ω → ℝ≥0 → ℂ), (∀ n, ∀ᵐ ω ∂P, Continuous (η n ω)) →
+      (∀ n, ∀ᵐ ω ∂P, ∀ t, Fbar n (γ ω t) = (η n ω t : OnePoint ℂ)) →
+      ∀ (Rₙ : ℕ → Set ℂ), (∀ᶠ n in atTop, R ⊆ Rₙ n) →
+      ∃ c q : ℝ, 0 < c ∧ 0 < q ∧ ∀ᶠ n in atTop, ENNReal.ofReal q ≤ P {ω |
+        ω ∈ FrontSuccess η pₙ
+          (fun ω => boundedFirstHeightTime (γ ω) B (T₀ * (Real.toNNReal B) ^ 2)) Vₙ bₙ ε n ∧
+        ENNReal.ofReal c ≤ segmentSausageCharge κ (η n ω)
+          (boundedFirstHeightTime (γ ω) B (T₀ * (Real.toNNReal B) ^ 2))
+          (frontTime (fun t => pₙ n (η n ω t)) 1) (v n) (Rₙ n)} := by
+  let : IsProbabilityMeasure P := hB₀.isGaussianProcess.isProbabilityMeasure
+  let ℱ := Filtration.natural B₀ (fun t => (hm t).stronglyMeasurable)
+  have ha := brownian_capacity_trace_adapted B₀ hm hc κ γ G F₀ hw
+  have hγm (t : ℝ≥0) : Measurable (fun ω => γ ω t) := (ha t).mono (ℱ.le t) le_rfl
+  have hSLE : IsOrdinaryChordalSLE κ γ P :=
+    ⟨hγm, B₀, hB₀, Eventually.of_forall (fun ω => ⟨G ω, F₀ ω, hw ω⟩)⟩
+  obtain ⟨T₀, hT₀, q₀, hq₀, hheight⟩ := uniform_bounded_firstHeight_real_probability
+    κ hκ hκ8 B₀ hB₀ hm hc γ G F₀ hw hsupport
+  obtain ⟨b, A, d, L₀, hb, hA, hd, hL₀, hloc⟩ :=
+    common_access_gives_firstHeight_localization κ hκ hκ8
+  obtain ⟨b₀, hb₀, hlocseq⟩ := hloc Ω P γ hSLE (fun ω => (hw ω).1)
+    (fun ω => (hw ω).2.1) (fun ω t => (hw ω).2.2.1 t)
+    Fₙ Fbar hFn hinj hbar hext δ hδ βₙ hβc hβ0 hβHn z hz hβconv
+    αₙ aₙ Cg hα hα0 hmap r₀ hr₀ hsmallGuide
+  refine ⟨T₀, hT₀, q₀, b₀, b, A, d, L₀, hq₀, hb₀, hb, hA, hd, hL₀, ?_⟩
+  intro L hL hsmall B r hB hr hBL F hF a O W hO hW β tB T htB htBT hβ hi hβH
+    hcross hafter hcircle hsector htail hend hne hconv pₙ p U hU hp hpn hpconv hOU
+    hWfront hstartBall hearlyBall V hV hOV Vₙ hVVₙ bₙ ε hterminal hearlyAllowed
+    R hR hmiddle v hv hlim η hηc hηbar Rₙ hregion
+  let Tc := T₀ * (Real.toNNReal B) ^ 2
+  have hheightB := hheight B hB
+  have hpositive : 0 < P (stoppedNarrowCertificate γ
+      (fun ω => boundedFirstHeightTime (γ ω) B Tc) B Tc) :=
+    (ENNReal.ofReal_pos.mpr hq₀).trans_le hheightB
+  have hmissing : ∀ᶠ n in atTop, P (stoppedNarrowCertificate γ
+      (fun ω => boundedFirstHeightTime (γ ω) B Tc) B Tc \
+        stoppedImageEvent γ (fun ω => boundedFirstHeightTime (γ ω) B Tc)
+          (Fbar n) (aₙ n) (L * r₀)) ≤
+      P (stoppedNarrowCertificate γ (fun ω => boundedFirstHeightTime (γ ω) B Tc) B Tc) / 2 := by
+    filter_upwards [hlocseq] with n hn
+    calc
+      _ ≤ ENNReal.ofReal (A * L ^ (-d)) := hn L hL B hB hBL Tc
+      _ ≤ ENNReal.ofReal (q₀ / 2) := ENNReal.ofReal_le_ofReal hsmall
+      _ = ENNReal.ofReal q₀ / 2 := by
+        rw [ENNReal.ofReal_div_of_pos (by norm_num : (0 : ℝ) < 2)]
+        norm_num
+      _ ≤ _ := ENNReal.div_le_div_right hheightB 2
+  exact bounded_splice_sequence_success κ hκ hκ8 B₀ hB₀ hm hc γ G F₀ hw hboundary hsupport
+    B r hB hr Tc F hF a O W hO hW β tB T htB htBT hβ hi hβH hcross hafter hcircle hsector
+    htail hend Fbar hbar aₙ (L * r₀) Fₙ hFn hinj hne hconv hext pₙ p U hU hp hpn hpconv
+    hOU hWfront hstartBall hearlyBall V hV hOV Vₙ hVVₙ bₙ ε hterminal hearlyAllowed
+    R hR hmiddle v hv hlim η hηc hηbar Rₙ hregion hpositive hmissing
+
+end SLEExactGauge.SequencePassage
+
+end
+
+end OAI

lean/OAI/Probability/SLE/Gauge/SerpentineActualAngle.lean

@@ -1,103 +1,103 @@
-import OAI.Probability.SLE.Gauge.SerpentineActualGuide
-import OAI.Probability.SLE.Geometry.GoodPrefixCoordinates
-import OAI.Probability.SLE.Geometry.MarkedAccessAngle
-
-namespace OAI
-
-/-! Successful actual serpentine completion gives the marked-point angle
-uniformly in the number of retained strips and in the trace history. -/
-
-noncomputable section
-open Set Filter Metric
-open scoped Topology NNReal ENNReal
-
-namespace SLEExactGauge.Serpentine
-open RibbonCoordinates FirstFrontPassage Target
-
-theorem uniform_serpentine_actual_angle_nonneg
-    (hopen : PublishedPlanarDiskOpenness)
-    (hstraight : PublishedHalfPlaneCrosscutStraightening)
-    (hexit : PublishedHalfPlaneConformalExitLaw)
-    (hsupport : PublishedPlanarWienerUnitSupport) (W : WienerLaw) (hW : IsWiener W)
-    {s : ℝ} (hs : 0 < s) (hs1 : s ≤ 1) :
-    ∃ s₀ : ℝ, 0 < s₀ ∧ ∀ (U : ℝ≥0 → ℝ) (γ : ℝ≥0 → ℂ)
-      (G F : ℝ≥0 → ℂ → ℂ), IsCapacityTwoWitness U γ G F → Continuous U →
-      ∀ w : ℂ, ‖w‖ ≤ 1 → s ≤ w.im → 0 ≤ w.re →
-      ∀ m : ℕ, 0 < m → ∀ g : C(ℂ, ℝ),
-      (∀ z ∈ closedRibbon, g (physicalFitChart s w m z) = z.re) →
-      ∀ ε : ℝ, ε ≤ 1 / 8 →
-      () ∈ GoodRibbonPrefix (fun _ : Unit => γ)
-        (fun _ => firstFrontTime (fun t => g (γ t)) (fitCompletion s w m))
-        (physicalFitChart s w m) ε →
-      let T := (firstFrontTime (fun t => g (γ t)) (fitCompletion s w m)).untopD 0
-      s₀ ≤ (G T w - (U T : ℂ)).im / ‖G T w - (U T : ℂ)‖ := by
-  obtain ⟨s₀, hs₀, hangle⟩ := uniform_marked_access_angle hopen hstraight hexit hsupport W hW
-    (show 0 < s / 20 by positivity) (show s / 20 ≤ 1 by linarith)
-  refine ⟨s₀, hs₀, ?_⟩
-  intro U γ G F hw hU w hwn hwy hwr m hm g hg ε hε hpref
-  have hchart : physicalExperimentChart s w m = physicalFitChart s w m := by
-    funext z
-    simp only [physicalExperimentChart, ite_eq_left hwr]
-  have hemb : Topology.IsClosedEmbedding (fun z : closedRibbon => physicalFitChart s w m z) := by
-    simpa only [hchart] using physicalExperimentChart_closedEmbedding hs w hwy hm
-  obtain ⟨hP, hi, hH, hescape⟩ := physicalFitChart_geometry hs w hwy hm
-  have hg0 : g (γ 0) = 0 := by
-    rw [hw.2.1, ← physicalFitChart_zero hs w hwy hm]
-    exact hg 0 (by simp [closedRibbon])
-  have hk : 0 < (fitCompletion s w m : ℝ) := by
-    have hbound := (fitCompletion_bounds hs w hwy hm).1
-    have hEntry : 0 ≤ fitEntry s w m :=
-      (by unfold fitHeight; positivity : (0 : ℝ) ≤ fitHeight m).trans (fit_entry_lower hs w hwy hm)
-    have hcol : 0 ≤ columnEntry 0 m (2 * m) := columnEntry_nonneg le_rfl _ _
-    have hmR : (0 : ℝ) < m := by exact_mod_cast hm
-    linarith
-  obtain ⟨T, x, xp, hfirst, hT, hx, hxpc, hγeq, hxp0, htip, hcoords, hcore, hstrict⟩ :=
-    goodRibbonPrefix_coordinates γ hw.1 _ hemb hi g hg hg0 hk hpref
-  have hxq : |x| ≤ 1 / 4 := hx.trans (by linarith)
-  have hx1 : |x| ≤ 1 := hxq.trans (by norm_num)
-  have htipre : (xp T).re = fitCompletion s w m := by simp [htip]
-  have htipim : (xp T).im = x := by simp [htip]
-  have hfresh := ribbon_front_tip_survives_prior _ hP.continuousOn hi hH hescape γ xp T
-    hxpc hxp0 hcoords hγeq (fun t ht => by rw [htipre]; exact hstrict t ht)
-    (by rw [htipim]; exact hxq.trans_lt (by norm_num))
-  have htipphysical : physicalFitChart s w m ((fitCompletion s w m : ℂ) + (x : ℂ) * Complex.I) = γ T := by
-    push_cast at htip
-    rw [← htip]
-    exact (hγeq ⟨bot_le, le_rfl⟩).symm
-  let α := fun u : ℝ≥0 => completeMarkedAccess s w m x u
-  have hαc : Continuous α :=
-    (completeMarkedAccess_continuous hs hs1 w hwy hwn hwr hm x).comp NNReal.continuous_coe
-  have hαi : Function.Injective α := by
-    intro t u he
-    apply NNReal.coe_injective
-    exact completeMarkedAccess_injective hs hs1 w hwy hwn hwr hm hx1 t.coe_nonneg u.coe_nonneg he
-  have hα0 : α 0 = γ T := by
-    change completeMarkedAccess s w m x (0 : ℝ) = γ T
-    rw [completeMarkedAccess_zero hs hs1 w hwy hwn hm x, htipphysical]
-  have hαD := completeMarkedAccess_survives hs hs1 w hwy hwn hwr hm hxq γ xp T hcoords hγeq
-    (fun t ht => (hcore t ht).1)
-  have hαescape : Tendsto α atTop (cocompact ℂ) := by
-    apply tendsto_cocompact_of_tendsto_dist_comp_atTop 0
-    simp only [dist_zero_right]
-    exact (completeMarkedAccess_norm_tendsto hs w hwn hwr m x).comp
-      (NNReal.tendsto_coe_atTop.mpr tendsto_id)
-  have hlocus (z : ℂ) (hz : z ∈ ball (0 : ℂ) ((s / 20) / 12)) :
-      (∃ u : ℝ≥0, 0 < u ∧ α u = markedCornerChart w z) ↔ z.im = 0 :=
-    completeMarkedAccess_corner_nnreal_iff hs hs1 w hwy hwn hwr hm hx1 hz
-  have hclear (right : Bool) (t : ℝ) (ht : t ∈ Icc (1 / 64 : ℝ) 3) (u : ℝ≥0) (_hu : 0 < u) :
-      (s / 20) / 1000 ≤ dist (markedWindowRoute right w (s / 20) t) (α u) := by
-    have hh := completeMarkedAccess_route_clearance hs hs1 w hwy hwn hwr hm hx1
-      (show 1 / 64 ≤ 4 / 3 * t by linarith [ht.1]) u.coe_nonneg
-    cases right
-    · exact hh.1
-    · exact hh.2
-  have hpast := physicalFit_prefix_low_right hs w hwy hwr hm γ xp T hcoords hγeq
-  have hh := hangle U γ G F hw hU T hT hfresh w hwn (show 2 * (s / 20) < w.im by linarith)
-    hpast α hαc hαi hα0 hαD hαescape hlocus hclear
-  simpa only [hfirst, WithTop.untopD_coe] using hh
-
-end SLEExactGauge.Serpentine
-
-end
-
-end OAI
+import OAI.Probability.SLE.Gauge.SerpentineActualGuide
+import OAI.Probability.SLE.Geometry.GoodPrefixCoordinates
+import OAI.Probability.SLE.Geometry.MarkedAccessAngle
+
+namespace OAI
+
+/-! Successful actual serpentine completion gives the marked-point angle
+uniformly in the number of retained strips and in the trace history. -/
+
+noncomputable section
+open Set Filter Metric
+open scoped Topology NNReal ENNReal
+
+namespace SLEExactGauge.Serpentine
+open RibbonCoordinates FirstFrontPassage Target
+
+theorem uniform_serpentine_actual_angle_nonneg
+    (hopen : PublishedPlanarDiskOpenness)
+    (hstraight : PublishedHalfPlaneCrosscutStraightening)
+    (hexit : PublishedHalfPlaneConformalExitLaw)
+    (hsupport : PublishedPlanarWienerUnitSupport) (W : WienerLaw) (hW : IsWiener W)
+    {s : ℝ} (hs : 0 < s) (hs1 : s ≤ 1) :
+    ∃ s₀ : ℝ, 0 < s₀ ∧ ∀ (U : ℝ≥0 → ℝ) (γ : ℝ≥0 → ℂ)
+      (G F : ℝ≥0 → ℂ → ℂ), IsCapacityTwoWitness U γ G F → Continuous U →
+      ∀ w : ℂ, ‖w‖ ≤ 1 → s ≤ w.im → 0 ≤ w.re →
+      ∀ m : ℕ, 0 < m → ∀ g : C(ℂ, ℝ),
+      (∀ z ∈ closedRibbon, g (physicalFitChart s w m z) = z.re) →
+      ∀ ε : ℝ, ε ≤ 1 / 8 →
+      () ∈ GoodRibbonPrefix (fun _ : Unit => γ)
+        (fun _ => firstFrontTime (fun t => g (γ t)) (fitCompletion s w m))
+        (physicalFitChart s w m) ε →
+      let T := (firstFrontTime (fun t => g (γ t)) (fitCompletion s w m)).untopD 0
+      s₀ ≤ (G T w - (U T : ℂ)).im / ‖G T w - (U T : ℂ)‖ := by
+  obtain ⟨s₀, hs₀, hangle⟩ := uniform_marked_access_angle hopen hstraight hexit hsupport W hW
+    (show 0 < s / 20 by positivity) (show s / 20 ≤ 1 by linarith)
+  refine ⟨s₀, hs₀, ?_⟩
+  intro U γ G F hw hU w hwn hwy hwr m hm g hg ε hε hpref
+  have hchart : physicalExperimentChart s w m = physicalFitChart s w m := by
+    funext z
+    simp only [physicalExperimentChart, ite_eq_left hwr]
+  have hemb : Topology.IsClosedEmbedding (fun z : closedRibbon => physicalFitChart s w m z) := by
+    simpa only [hchart] using physicalExperimentChart_closedEmbedding hs w hwy hm
+  obtain ⟨hP, hi, hH, hescape⟩ := physicalFitChart_geometry hs w hwy hm
+  have hg0 : g (γ 0) = 0 := by
+    rw [hw.2.1, ← physicalFitChart_zero hs w hwy hm]
+    exact hg 0 (by simp [closedRibbon])
+  have hk : 0 < (fitCompletion s w m : ℝ) := by
+    have hbound := (fitCompletion_bounds hs w hwy hm).1
+    have hEntry : 0 ≤ fitEntry s w m :=
+      (by unfold fitHeight; positivity : (0 : ℝ) ≤ fitHeight m).trans (fit_entry_lower hs w hwy hm)
+    have hcol : 0 ≤ columnEntry 0 m (2 * m) := columnEntry_nonneg le_rfl _ _
+    have hmR : (0 : ℝ) < m := by exact_mod_cast hm
+    linarith
+  obtain ⟨T, x, xp, hfirst, hT, hx, hxpc, hγeq, hxp0, htip, hcoords, hcore, hstrict⟩ :=
+    goodRibbonPrefix_coordinates γ hw.1 _ hemb hi g hg hg0 hk hpref
+  have hxq : |x| ≤ 1 / 4 := hx.trans (by linarith)
+  have hx1 : |x| ≤ 1 := hxq.trans (by norm_num)
+  have htipre : (xp T).re = fitCompletion s w m := by simp [htip]
+  have htipim : (xp T).im = x := by simp [htip]
+  have hfresh := ribbon_front_tip_survives_prior _ hP.continuousOn hi hH hescape γ xp T
+    hxpc hxp0 hcoords hγeq (fun t ht => by rw [htipre]; exact hstrict t ht)
+    (by rw [htipim]; exact hxq.trans_lt (by norm_num))
+  have htipphysical : physicalFitChart s w m ((fitCompletion s w m : ℂ) + (x : ℂ) * Complex.I) = γ T := by
+    push_cast at htip
+    rw [← htip]
+    exact (hγeq ⟨bot_le, le_rfl⟩).symm
+  let α := fun u : ℝ≥0 => completeMarkedAccess s w m x u
+  have hαc : Continuous α :=
+    (completeMarkedAccess_continuous hs hs1 w hwy hwn hwr hm x).comp NNReal.continuous_coe
+  have hαi : Function.Injective α := by
+    intro t u he
+    apply NNReal.coe_injective
+    exact completeMarkedAccess_injective hs hs1 w hwy hwn hwr hm hx1 t.coe_nonneg u.coe_nonneg he
+  have hα0 : α 0 = γ T := by
+    change completeMarkedAccess s w m x (0 : ℝ) = γ T
+    rw [completeMarkedAccess_zero hs hs1 w hwy hwn hm x, htipphysical]
+  have hαD := completeMarkedAccess_survives hs hs1 w hwy hwn hwr hm hxq γ xp T hcoords hγeq
+    (fun t ht => (hcore t ht).1)
+  have hαescape : Tendsto α atTop (cocompact ℂ) := by
+    apply tendsto_cocompact_of_tendsto_dist_comp_atTop 0
+    simp only [dist_zero_right]
+    exact (completeMarkedAccess_norm_tendsto hs w hwn hwr m x).comp
+      (NNReal.tendsto_coe_atTop.mpr tendsto_id)
+  have hlocus (z : ℂ) (hz : z ∈ ball (0 : ℂ) ((s / 20) / 12)) :
+      (∃ u : ℝ≥0, 0 < u ∧ α u = markedCornerChart w z) ↔ z.im = 0 :=
+    completeMarkedAccess_corner_nnreal_iff hs hs1 w hwy hwn hwr hm hx1 hz
+  have hclear (right : Bool) (t : ℝ) (ht : t ∈ Icc (1 / 64 : ℝ) 3) (u : ℝ≥0) (_hu : 0 < u) :
+      (s / 20) / 1000 ≤ dist (markedWindowRoute right w (s / 20) t) (α u) := by
+    have hh := completeMarkedAccess_route_clearance hs hs1 w hwy hwn hwr hm hx1
+      (show 1 / 64 ≤ 4 / 3 * t by linarith [ht.1]) u.coe_nonneg
+    cases right
+    · exact hh.1
+    · exact hh.2
+  have hpast := physicalFit_prefix_low_right hs w hwy hwr hm γ xp T hcoords hγeq
+  have hh := hangle U γ G F hw hU T hT hfresh w hwn (show 2 * (s / 20) < w.im by linarith)
+    hpast α hαc hαi hα0 hαD hαescape hlocus hclear
+  simpa only [hfirst, WithTop.untopD_coe] using hh
+
+end SLEExactGauge.Serpentine
+
+end
+
+end OAI