diff --git a/lean/OAI/Probability/SLE/Gauge/RibbonMiddleMass.lean b/lean/OAI/Probability/SLE/Gauge/RibbonMiddleMass.lean
new file mode 100644
index 0000000000000000000000000000000000000000..64fd4f98b8d649daa55f7e2dc7a7dd162ea48e8b
--- /dev/null
+++ b/lean/OAI/Probability/SLE/Gauge/RibbonMiddleMass.lean
@@ -0,0 +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
diff --git a/lean/OAI/Probability/SLE/Gauge/RibbonPassageMass.lean b/lean/OAI/Probability/SLE/Gauge/RibbonPassageMass.lean
new file mode 100644
index 0000000000000000000000000000000000000000..3dc73395405df036fe7ee7ae36346531ef7cd48d
--- /dev/null
+++ b/lean/OAI/Probability/SLE/Gauge/RibbonPassageMass.lean
@@ -0,0 +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
diff --git a/lean/OAI/Probability/SLE/Gauge/RibbonPassageNeighborhood.lean b/lean/OAI/Probability/SLE/Gauge/RibbonPassageNeighborhood.lean
new file mode 100644
index 0000000000000000000000000000000000000000..a4f91a6af700a236f269175447e78fdebeb27343
--- /dev/null
+++ b/lean/OAI/Probability/SLE/Gauge/RibbonPassageNeighborhood.lean
@@ -0,0 +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
diff --git a/lean/OAI/Probability/SLE/Gauge/RibbonPassageScaling.lean b/lean/OAI/Probability/SLE/Gauge/RibbonPassageScaling.lean
new file mode 100644
index 0000000000000000000000000000000000000000..848962004186f5e7d52668152b8d0b404ff738ba
--- /dev/null
+++ b/lean/OAI/Probability/SLE/Gauge/RibbonPassageScaling.lean
@@ -0,0 +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
diff --git a/lean/OAI/Probability/SLE/Gauge/RibbonPrefixTransport.lean b/lean/OAI/Probability/SLE/Gauge/RibbonPrefixTransport.lean
new file mode 100644
index 0000000000000000000000000000000000000000..15f33b3e7d2c9b943b36e45ba955e5a87d4b6ba9
--- /dev/null
+++ b/lean/OAI/Probability/SLE/Gauge/RibbonPrefixTransport.lean
@@ -0,0 +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
diff --git a/lean/OAI/Probability/SLE/Gauge/RibbonRouteLifting.lean b/lean/OAI/Probability/SLE/Gauge/RibbonRouteLifting.lean
new file mode 100644
index 0000000000000000000000000000000000000000..bcf2276d70f00fc5542a783bb7eef277f067225a
--- /dev/null
+++ b/lean/OAI/Probability/SLE/Gauge/RibbonRouteLifting.lean
@@ -0,0 +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
diff --git a/lean/OAI/Probability/SLE/Gauge/RibbonSequenceCompactness.lean b/lean/OAI/Probability/SLE/Gauge/RibbonSequenceCompactness.lean
new file mode 100644
index 0000000000000000000000000000000000000000..4079c57668c0929763cd8649d372621c839c4977
--- /dev/null
+++ b/lean/OAI/Probability/SLE/Gauge/RibbonSequenceCompactness.lean
@@ -0,0 +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
diff --git a/lean/OAI/Probability/SLE/Gauge/RibbonSideCorridors.lean b/lean/OAI/Probability/SLE/Gauge/RibbonSideCorridors.lean
new file mode 100644
index 0000000000000000000000000000000000000000..ae6be295051de9efecdbbda2faac26f08f017524
--- /dev/null
+++ b/lean/OAI/Probability/SLE/Gauge/RibbonSideCorridors.lean
@@ -0,0 +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
diff --git a/lean/OAI/Probability/SLE/Gauge/RibbonStepPatch.lean b/lean/OAI/Probability/SLE/Gauge/RibbonStepPatch.lean
new file mode 100644
index 0000000000000000000000000000000000000000..93d17f1a9b41a767fa783b2f1277cea052537249
--- /dev/null
+++ b/lean/OAI/Probability/SLE/Gauge/RibbonStepPatch.lean
@@ -0,0 +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
diff --git a/lean/OAI/Probability/SLE/Gauge/RibbonStepSuccess.lean b/lean/OAI/Probability/SLE/Gauge/RibbonStepSuccess.lean
new file mode 100644
index 0000000000000000000000000000000000000000..8a8d97bce164cb684cba53ccaa655161bbe721c6
--- /dev/null
+++ b/lean/OAI/Probability/SLE/Gauge/RibbonStepSuccess.lean
@@ -0,0 +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
diff --git a/lean/OAI/Probability/SLE/Gauge/RibbonStepTranslation.lean b/lean/OAI/Probability/SLE/Gauge/RibbonStepTranslation.lean
new file mode 100644
index 0000000000000000000000000000000000000000..98670a00241cb4a2c3d3fd0b1bae99613a1a07ed
--- /dev/null
+++ b/lean/OAI/Probability/SLE/Gauge/RibbonStepTranslation.lean
@@ -0,0 +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
diff --git a/lean/OAI/Probability/SLE/Gauge/RibbonStoppedMassLaw.lean b/lean/OAI/Probability/SLE/Gauge/RibbonStoppedMassLaw.lean
new file mode 100644
index 0000000000000000000000000000000000000000..6f20843ca613208a6189c5e19a227993112eb629
--- /dev/null
+++ b/lean/OAI/Probability/SLE/Gauge/RibbonStoppedMassLaw.lean
@@ -0,0 +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
diff --git a/lean/OAI/Probability/SLE/Gauge/RibbonStoppedMassTransport.lean b/lean/OAI/Probability/SLE/Gauge/RibbonStoppedMassTransport.lean
new file mode 100644
index 0000000000000000000000000000000000000000..0495884b77b7b43d619b175ca1bd33ae1e690693
--- /dev/null
+++ b/lean/OAI/Probability/SLE/Gauge/RibbonStoppedMassTransport.lean
@@ -0,0 +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
diff --git a/lean/OAI/Probability/SLE/Gauge/RibbonSurvival.lean b/lean/OAI/Probability/SLE/Gauge/RibbonSurvival.lean
new file mode 100644
index 0000000000000000000000000000000000000000..0ca5f21750929b469c6edada7be40dc5ba51dbfb
--- /dev/null
+++ b/lean/OAI/Probability/SLE/Gauge/RibbonSurvival.lean
@@ -0,0 +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
diff --git a/lean/OAI/Probability/SLE/Gauge/SequencePassage.lean b/lean/OAI/Probability/SLE/Gauge/SequencePassage.lean
new file mode 100644
index 0000000000000000000000000000000000000000..ca80016d0989dc6fac483aa6281db2fc949d724d
--- /dev/null
+++ b/lean/OAI/Probability/SLE/Gauge/SequencePassage.lean
@@ -0,0 +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
diff --git a/lean/OAI/Probability/SLE/Gauge/SequencePassageRegions.lean b/lean/OAI/Probability/SLE/Gauge/SequencePassageRegions.lean
new file mode 100644
index 0000000000000000000000000000000000000000..5c9f370ac5cb087e1461465c3d3ae4b55cdae606
--- /dev/null
+++ b/lean/OAI/Probability/SLE/Gauge/SequencePassageRegions.lean
@@ -0,0 +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
diff --git a/lean/OAI/Probability/SLE/Gauge/SequencePassageSuccess.lean b/lean/OAI/Probability/SLE/Gauge/SequencePassageSuccess.lean
new file mode 100644
index 0000000000000000000000000000000000000000..c588c6c3950b7ce09cc0614ae5a4ff8f268dbefd
--- /dev/null
+++ b/lean/OAI/Probability/SLE/Gauge/SequencePassageSuccess.lean
@@ -0,0 +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
diff --git a/lean/OAI/Probability/SLE/Gauge/SerpentineActualAngle.lean b/lean/OAI/Probability/SLE/Gauge/SerpentineActualAngle.lean
new file mode 100644
index 0000000000000000000000000000000000000000..4a08efcfa34ee684aa8d43f15c72d3128f94d9b4
--- /dev/null
+++ b/lean/OAI/Probability/SLE/Gauge/SerpentineActualAngle.lean
@@ -0,0 +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
diff --git a/lean/OAI/Probability/SLE/Gauge/SerpentineActualAngleReflection.lean b/lean/OAI/Probability/SLE/Gauge/SerpentineActualAngleReflection.lean
new file mode 100644
index 0000000000000000000000000000000000000000..6430371b0a46a9c1f06542fa40462500c1a748ef
--- /dev/null
+++ b/lean/OAI/Probability/SLE/Gauge/SerpentineActualAngleReflection.lean
@@ -0,0 +1,81 @@
+import OAI.Probability.SLE.Gauge.SerpentineActualAngle
+import OAI.Probability.SLE.Geometry.MarkedWitnessReflection
+
+namespace OAI
+
+/-! Reflection removes the sign restriction on the marked point, with
+exactly the same uniform angle constant as the right-hand experiment. -/
+
+noncomputable section
+open Set Filter Metric ComplexConjugate
+open scoped Topology NNReal ENNReal
+
+namespace SLEExactGauge.Serpentine
+open RibbonCoordinates FirstFrontPassage Target
+
+theorem uniform_serpentine_actual_angle
+    (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 →
+      ∀ m : ℕ, 0 < m → ∀ g : C(ℂ, ℝ),
+      (∀ z ∈ closedRibbon, g (physicalExperimentChart s w m z) = z.re) →
+      ∀ ε : ℝ, ε ≤ 1 / 8 →
+      () ∈ GoodRibbonPrefix (fun _ : Unit => γ)
+        (fun _ => firstFrontTime (fun t => g (γ t)) (fitCompletion s w m))
+        (physicalExperimentChart 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_serpentine_actual_angle_nonneg hopen hstraight hexit hsupport W hW hs hs1
+  refine ⟨s₀, hs₀, ?_⟩
+  intro U γ G F hw hU w hwn hwy m hm g hg ε hε hpref
+  by_cases hwr : 0 ≤ w.re
+  · have hchart : physicalExperimentChart s w m = physicalFitChart s w m := by
+      funext z
+      simp only [physicalExperimentChart, ite_eq_left hwr]
+    exact hangle U γ G F hw hU w hwn hwy hwr m hm g
+      (by simpa only [hchart] using hg) ε hε (by simpa only [hchart] using hpref)
+  · have hwneg : w.re < 0 := lt_of_not_ge hwr
+    let γ' : ℝ≥0 → ℂ := loewnerMirror ∘ γ
+    let U' : ℝ≥0 → ℝ := fun t => -U t
+    let G' : ℝ≥0 → ℂ → ℂ := fun t z => loewnerMirror (G t (loewnerMirror z))
+    let F' : ℝ≥0 → ℂ → ℂ := fun t z => loewnerMirror (F t (loewnerMirror z))
+    let g' := mirroredProgress g
+    have hg' : ∀ z ∈ closedRibbon,
+        g' (physicalFitChart s (loewnerMirror w) m z) = z.re := by
+      intro z hz
+      have hh := hg (conj z) (conj_mem_closedRibbon hz)
+      rw [physicalExperimentChart_negative hwneg m] at hh
+      simpa only [g', mirroredProgress, ContinuousMap.coe_mk, reflectedChart,
+        Complex.conj_conj, Complex.conj_re] using hh
+    have hclock : firstFrontTime (fun t => g' (γ' t))
+        (fitCompletion s (loewnerMirror w) m) =
+        firstFrontTime (fun t => g (γ t)) (fitCompletion s w m) := by
+      rw [fitCompletion_mirror]
+      exact mirroredProgress_firstFrontTime g γ _
+    have hpref' : () ∈ GoodRibbonPrefix (fun _ : Unit => γ')
+        (fun _ => firstFrontTime (fun t => g' (γ' t))
+          (fitCompletion s (loewnerMirror w) m))
+        (physicalFitChart s (loewnerMirror w) m) ε := by
+      rw [hclock]
+      rw [goodRibbonPrefix_physical_negative _ _ hwneg m ε] at hpref
+      simpa only [γ', Function.comp_def] using hpref
+    have hh := hangle U' γ' G' F' hw.mirror hU.neg (loewnerMirror w)
+      (by simpa only [loewnerMirror_norm] using hwn)
+      (by simpa only [loewnerMirror_im] using hwy)
+      (by simp only [loewnerMirror_re]; linarith)
+      m hm g' hg' ε hε hpref'
+    dsimp only at hh ⊢
+    rw [hclock] at hh
+    simpa only [U', G', loewnerMirror_twice, mirrored_centered_sine] using hh
+
+end SLEExactGauge.Serpentine
+
+end
+
+end OAI
diff --git a/lean/OAI/Probability/SLE/Gauge/SerpentineActualGuide.lean b/lean/OAI/Probability/SLE/Gauge/SerpentineActualGuide.lean
new file mode 100644
index 0000000000000000000000000000000000000000..fb9dc02ff77f24b4a8393ca47d16898dd2f4c56d
--- /dev/null
+++ b/lean/OAI/Probability/SLE/Gauge/SerpentineActualGuide.lean
@@ -0,0 +1,80 @@
+import OAI.Probability.SLE.Gauge.SerpentinePhysicalGeometry
+import OAI.Probability.SLE.Gauge.SerpentineMarkedRouteClearance
+import OAI.Probability.SLE.Geometry.ActualWaypointStraightening
+
+namespace OAI
+
+/-! The concrete terminal access guide lies in the actual surviving
+component of a successful stopped serpentine trace. -/
+
+noncomputable section
+open Set Filter Metric
+open scoped Topology NNReal
+
+namespace SLEExactGauge.Serpentine
+open RibbonCoordinates
+
+lemma physicalFit_prefix_low_right {s : ℝ} (hs : 0 < s) (w : ℂ) (hw : s ≤ w.im)
+    (hwr : 0 ≤ w.re) {m : ℕ} (hm : 0 < m)
+    (γ xp : ℝ≥0 → ℂ) (T : ℝ≥0)
+    (hcoords : MapsTo xp (Icc 0 T) closedRibbon)
+    (hγ : EqOn γ (physicalFitChart s w m ∘ xp) (Icc 0 T)) :
+    ∀ q ∈ γ '' Icc 0 T, q.im ≤ w.im - 2 * (s / 20) ∨ w.re + 2 * (s / 20) ≤ q.re := by
+  rintro q ⟨t, ht, rfl⟩
+  rw [hγ ht]
+  rcases physicalFitChart_low_or_right hs w hw hm (hcoords ht).2 with hlo | hright
+  · left
+    change (physicalFitChart s w m (xp t)).im ≤ _
+    linarith
+  · right
+    rw [abs_of_nonneg hwr] at hright
+    change _ ≤ (physicalFitChart s w m (xp t)).re
+    linarith
+
+theorem completeMarkedAccess_survives {s : ℝ} (hs : 0 < s) (hs1 : s ≤ 1)
+    (w : ℂ) (hw : s ≤ w.im) (hw1 : ‖w‖ ≤ 1) (hwr : 0 ≤ w.re)
+    {m : ℕ} (hm : 0 < m) {x : ℝ} (hx : |x| ≤ 1 / 4)
+    (γ xp : ℝ≥0 → ℂ) (T : ℝ≥0)
+    (hcoords : MapsTo xp (Icc 0 T) closedRibbon)
+    (hγ : EqOn γ (physicalFitChart s w m ∘ xp) (Icc 0 T))
+    (hfront : ∀ t ∈ Icc 0 T, (xp t).re ≤ fitCompletion s w m) :
+    ∀ u : ℝ≥0, 0 < u → completeMarkedAccess s w m x u ∈ survivingDomain γ T := by
+  obtain ⟨hP, hi, hH, hescape⟩ := physicalFitChart_geometry hs w hw hm
+  have hpast : γ '' Icc 0 T ⊆ physicalFitChart s w m ''
+      {z ∈ closedRibbon | z.re ≤ fitCompletion s w m} := by
+    rintro q ⟨t, ht, rfl⟩
+    exact ⟨xp t, ⟨hcoords ht, hfront t ht⟩, (hγ ht).symm⟩
+  have hfuture := futureRibbon_survives _ hP.continuousOn hi
+    (Nat.cast_nonneg (fitCompletion s w m)) hH γ T hpast
+    (futureRibbon_unbounded_of_centerline_escape _ (fitCompletion s w m) hescape)
+  have hwi := (Complex.im_le_norm w).trans hw1
+  have hR : w.re < fitTerminalX s w := by
+    unfold fitTerminalX
+    rw [abs_of_nonneg hwr]
+    linarith
+  have hhook := markedHook_survives γ T w (lt_of_lt_of_le hs hw) hR
+    (show w.im < 2 by linarith) (show 0 < s / 20 by positivity) (by
+      rintro q ⟨t, ht, rfl⟩
+      rw [hγ ht]
+      refine ⟨physicalFitChart_finite_height_lt_two hs hs1 w hw hw1 hm (hcoords ht) (hfront t ht), ?_⟩
+      rcases physicalFitChart_low_or_right hs w hw hm (hcoords ht).2 with hlo | hright
+      · left
+        change (physicalFitChart s w m (xp t)).im < w.im
+        linarith
+      · right
+        rw [abs_of_nonneg hwr] at hright
+        change w.re < (physicalFitChart s w m (xp t)).re
+        linarith)
+  intro u hu
+  by_cases huT : (u : ℝ) ≤ fitHighTime s w m
+  · rw [completeMarkedAccess, appendMarkedHook, curveJoin_of_le huT]
+    apply hfuture
+    exact mem_image_of_mem _ (guideCoordinate_mem_future hx (by exact_mod_cast hu))
+  · rw [completeMarkedAccess, appendMarkedHook, curveJoin_of_gt (lt_of_not_ge huT)]
+    exact hhook ⟨⟨(u : ℝ) - fitHighTime s w m, by linarith⟩, rfl⟩
+
+end SLEExactGauge.Serpentine
+
+end
+
+end OAI
diff --git a/lean/OAI/Probability/SLE/Gauge/SerpentineActualRadius.lean b/lean/OAI/Probability/SLE/Gauge/SerpentineActualRadius.lean
new file mode 100644
index 0000000000000000000000000000000000000000..2cb9acb89fdbaa1104b9825b5b2c4523ced27338
--- /dev/null
+++ b/lean/OAI/Probability/SLE/Gauge/SerpentineActualRadius.lean
@@ -0,0 +1,103 @@
+import OAI.Probability.SLE.Gauge.SerpentineActualGuide
+import OAI.Probability.SLE.Gauge.SerpentineMarkedReflection
+import OAI.Probability.SLE.Gauge.ExperimentClearance
+import OAI.Probability.SLE.Geometry.MarkedSurvivingBall
+
+namespace OAI
+
+/-! Successful physical prefixes leave a definite ball around the marked
+point in the actual surviving domain, hence finish before a fixed radius level. -/
+
+noncomputable section
+open Set Filter Metric
+open scoped Topology NNReal ENNReal
+
+namespace SLEExactGauge.Serpentine
+open RibbonCoordinates
+
+lemma good_physicalFit_ball_survives {s : ℝ} (hs : 0 < s) (w : ℂ)
+    (hwy : s ≤ w.im) (hwr : 0 ≤ w.re) {m : ℕ} (hm : 0 < m)
+    (γ : ℝ≥0 → ℂ) (τ : WithTop ℝ≥0) (ε : ℝ)
+    (hpref : () ∈ GoodRibbonPrefix (fun _ : Unit => γ) (fun _ => τ)
+      (physicalFitChart s w m) ε) :
+    ball w (s / 20) ⊆ survivingDomain γ (τ.untopD 0) := by
+  apply marked_ball_survives γ (τ.untopD 0) w (by positivity) (by linarith)
+  rintro q ⟨t, ht, rfl⟩
+  obtain ⟨z, ⟨hz, _⟩, he⟩ := hpref.2.1 ht
+  change physicalFitChart s w m z = γ t at he
+  rw [← he]
+  rcases physicalFitChart_low_or_right hs w hwy hm hz.2 with hlo | hright
+  · left
+    linarith
+  · right
+    rw [abs_of_nonneg hwr] at hright
+    linarith
+
+theorem good_physicalExperiment_ball_survives {s : ℝ} (hs : 0 < s) (w : ℂ)
+    (hwy : s ≤ w.im) {m : ℕ} (hm : 0 < m)
+    (γ : ℝ≥0 → ℂ) (τ : WithTop ℝ≥0) (ε : ℝ)
+    (hpref : () ∈ GoodRibbonPrefix (fun _ : Unit => γ) (fun _ => τ)
+      (physicalExperimentChart s w m) ε) :
+    ball w (s / 20) ⊆ survivingDomain γ (τ.untopD 0) := by
+  by_cases hwr : 0 ≤ w.re
+  · have hchart : physicalExperimentChart s w m = physicalFitChart s w m := by
+      funext z
+      simp only [physicalExperimentChart, ite_eq_left hwr]
+    apply good_physicalFit_ball_survives hs w hwy hwr hm γ τ ε
+    simpa only [hchart] using hpref
+  · have hneg : w.re < 0 := lt_of_not_ge hwr
+    have hp : () ∈ GoodRibbonPrefix (fun _ : Unit => (loewnerMirror ∘ γ)) (fun _ => τ)
+        (physicalFitChart s (loewnerMirror w) m) ε := by
+      rw [goodRibbonPrefix_physical_negative _ _ hneg m ε] at hpref
+      simpa only [Function.comp_def] using hpref
+    have hb := good_physicalFit_ball_survives hs (loewnerMirror w)
+      (by simpa only [loewnerMirror_im] using hwy)
+      (by simp only [loewnerMirror_re]; linarith) hm (loewnerMirror ∘ γ) τ ε hp
+    intro z hz
+    apply (loewnerMirror_surviving γ (τ.untopD 0) z).mp
+    apply hb
+    simpa only [mem_ball, loewnerMirror_dist] using hz
+
+def experimentRadiusLevel (s : ℝ) : ℝ := -Real.log (s / 80)
+
+lemma experimentRadiusLevel_nonneg {s : ℝ} (hs : 0 < s) (hs1 : s ≤ 1) :
+    0 ≤ experimentRadiusLevel s := by
+  unfold experimentRadiusLevel
+  exact neg_nonneg.mpr (Real.log_nonpos (by positivity) (by linarith))
+
+lemma experimentRadiusLevel_cutoff {s : ℝ} (hs : 0 < s) (w : ℂ) (hw : ‖w‖ ≤ 1) :
+    (2 * w.im) * Real.exp (-experimentRadiusLevel s) < s / 20 := by
+  have hy := (Complex.im_le_norm w).trans hw
+  rw [experimentRadiusLevel, neg_neg, Real.exp_log (by positivity : 0 < s / 80)]
+  nlinarith
+
+theorem good_physicalExperiment_before_radius
+    {U : ℝ≥0 → ℝ} {γ : ℝ≥0 → ℂ} {G F : ℝ≥0 → ℂ → ℂ}
+    (hU : Continuous U) (hw : IsCapacityTwoWitness U γ G F)
+    {s : ℝ} (hs : 0 < s) (w : ℂ) (hwn : ‖w‖ ≤ 1) (hwy : s ≤ w.im)
+    {m : ℕ} (hm : 0 < m) (τ : WithTop ℝ≥0) (ε : ℝ)
+    (hpref : () ∈ GoodRibbonPrefix (fun _ : Unit => γ) (fun _ => τ)
+      (physicalExperimentChart s w m) ε) :
+    τ < radiusLevelTime γ G w (experimentRadiusLevel s) ∧
+      w ∈ survivingDomain γ (τ.untopD 0) := by
+  have hb := good_physicalExperiment_ball_survives hs w hwy hm γ τ ε hpref
+  have hlive := hb (mem_ball_self (by positivity : 0 < s / 20))
+  refine ⟨?_, hlive⟩
+  have hh := completion_before_radiusLevelTime_of_prefix_lower hU hw (τ.untopD 0) w
+    (experimentRadiusLevel s) (s / 20) (fun t ht => by
+      have hbt := hb.trans (survivingDomain_antitone γ ht)
+      exact ⟨hbt (mem_ball_self (by positivity)),
+        fullRadius_lower_of_surviving_ball hU hw t w (by positivity) hbt⟩)
+    (experimentRadiusLevel_cutoff hs w hwn)
+  cases he : τ with
+  | top => exact (hpref.1 he).elim
+  | coe T =>
+    have hh' : (T : ℝ≥0∞) < radiusLevelTime γ G w (experimentRadiusLevel s) := by
+      simpa only [he, WithTop.untopD_coe] using hh
+    exact_mod_cast hh'
+
+end SLEExactGauge.Serpentine
+
+end
+
+end OAI
diff --git a/lean/OAI/Probability/SLE/Gauge/SerpentineArrayEmbedding.lean b/lean/OAI/Probability/SLE/Gauge/SerpentineArrayEmbedding.lean
new file mode 100644
index 0000000000000000000000000000000000000000..343260cba6948a2aec700ee53b30ee84d9823a51
--- /dev/null
+++ b/lean/OAI/Probability/SLE/Gauge/SerpentineArrayEmbedding.lean
@@ -0,0 +1,198 @@
+import OAI.Probability.SLE.Gauge.SerpentineCurve
+import OAI.Probability.SLE.Gauge.SerpentineEmbedding
+
+namespace OAI
+
+/-! Global normal coordinates for the actual finite serpentine array.
+Every parameter belongs to a straight or circular piece, and the only
+possible normal-band contacts are the prescribed common end sections. -/
+
+noncomputable section
+open Set Metric
+
+namespace SLEExactGauge.Serpentine
+
+def arrayEnd (m j : ℕ) : ℝ := columnEntry 0 m j + 200 * m
+
+lemma array_pieces (m j : ℕ) {t : ℝ} (ht : t ∈ Icc 0 (arrayEnd m j)) :
+    (∃ i ≤ j, ∃ u ∈ Icc (0 : ℝ) (200 * m),
+      t = columnEntry 0 m i + u ∧
+      arraySpine m j t = straightPiece m i u ∧ arrayTangent m j t = straightTangent i) ∨
+    (∃ i < j, ∃ u ∈ Icc (0 : ℝ) (50 * Real.pi),
+      t = columnEntry 0 m i + 200 * m + u ∧
+      arraySpine m j t = circularPiece m i u ∧ arrayTangent m j t = circularTangent i u) := by
+  induction j with
+  | zero =>
+    exact Or.inl ⟨0, le_rfl, t, ⟨ht.1, by simpa only [arrayEnd, columnEntry, Nat.cast_zero, zero_mul, add_zero, zero_add] using ht.2⟩,
+      by simp [columnEntry], rfl, rfl⟩
+  | succ j ih =>
+    have ha : arrayEnd m j < columnEntry 0 m (j + 1) := by
+      rw [arrayEnd, columnEntry_succ]
+      linarith [Real.pi_pos]
+    by_cases hta : t ≤ arrayEnd m j
+    · change t ≤ columnEntry 0 m j + 200 * m at hta
+      rcases ih ⟨ht.1, hta⟩ with ⟨i, hi, u, hu, htu, hs, hT⟩ | ⟨i, hi, u, hu, htu, hs, hT⟩
+      · refine Or.inl ⟨i, hi.trans (Nat.le_succ j), u, hu, htu, ?_, ?_⟩
+        · simpa only [arraySpine, curveJoin_of_le (hta.trans ha.le), curveJoin_of_le hta] using hs
+        · simpa only [arrayTangent, curveJoin_of_le (hta.trans ha.le), curveJoin_of_le hta] using hT
+      · refine Or.inr ⟨i, hi.trans_le (Nat.le_succ j), u, hu, htu, ?_, ?_⟩
+        · simpa only [arraySpine, curveJoin_of_le (hta.trans ha.le), curveJoin_of_le hta] using hs
+        · simpa only [arrayTangent, curveJoin_of_le (hta.trans ha.le), curveJoin_of_le hta] using hT
+    · have hat : columnEntry 0 m j + 200 * m < t := lt_of_not_ge hta
+      by_cases htb : t ≤ columnEntry 0 m (j + 1)
+      · refine Or.inr ⟨j, Nat.lt_succ_self j, t - arrayEnd m j, ?_, ?_, ?_, ?_⟩
+        · constructor
+          · linarith
+          · rw [columnEntry_succ] at htb
+            dsimp [arrayEnd]
+            linarith
+        · dsimp [arrayEnd]; ring
+        · simp only [arraySpine, curveJoin_of_le htb, curveJoin_of_gt hat, arrayEnd]
+        · simp only [arrayTangent, curveJoin_of_le htb, curveJoin_of_gt hat, arrayEnd]
+      · have hbt : columnEntry 0 m (j + 1) < t := lt_of_not_ge htb
+        refine Or.inl ⟨j + 1, le_rfl, t - columnEntry 0 m (j + 1), ?_, by ring, ?_, ?_⟩
+        · constructor
+          · linarith
+          · dsimp only [arrayEnd] at ht
+            linarith [ht.2]
+        · exact arraySpine_tail m (j + 1) hbt.le
+        · exact arrayTangent_tail m (j + 1) hbt.le
+
+lemma normalized_width {m : ℕ} (hm : 0 < m) : ribbonWidth (100 * m) m = 1 := by
+  unfold ribbonWidth
+  have hm' : (m : ℝ) ≠ 0 := by exact_mod_cast hm.ne'
+  field_simp
+
+lemma normalized_spacing {m : ℕ} (hm : 0 < m) : spacing (100 * m) m = 100 := by
+  rw [spacing_eq_width, normalized_width hm, mul_one]
+
+lemma normalized_radius {m : ℕ} (hm : 0 < m) : turnRadius (100 * m) m = 50 := by
+  rw [turnRadius_eq_width, normalized_width hm, mul_one]
+
+lemma normal_straight_eq {m : ℕ} (hm : 0 < m) (j : ℕ) (u a : ℝ) :
+    straightPiece m j u + (a : ℂ) * Complex.I * straightTangent j =
+      columnPoint 0 (100 * m) m j (side j * (-100 * m + u)) a := by
+  apply Complex.ext <;>
+    simp only [straightPiece, straightTangent, columnPoint, columnOffset,
+      normalized_spacing hm, normalized_width hm, Complex.add_re, Complex.add_im,
+      Complex.mul_re, Complex.mul_im, Complex.ofReal_re, Complex.ofReal_im,
+      Complex.I_re, Complex.I_im, Complex.zero_re, Complex.zero_im] <;> ring
+
+lemma normal_circular_eq {m : ℕ} (hm : 0 < m) (j : ℕ) (u a : ℝ) :
+    circularPiece m j u + (a : ℂ) * Complex.I * circularTangent j u =
+      turnPoint 0 (100 * m) m j (u / 50) a := by
+  apply Complex.ext
+  · simp only [circularPiece, circularTangent, turnPoint, columnOffset,
+      normalized_spacing hm, normalized_radius hm, normalized_width hm,
+      Complex.add_re, Complex.add_im, Complex.mul_re, Complex.mul_im,
+      Complex.ofReal_re, Complex.ofReal_im, Complex.I_re, Complex.I_im,
+      Complex.zero_re]
+    ring
+  · simp only [circularPiece, circularTangent, turnPoint, columnOffset,
+      normalized_spacing hm, normalized_radius hm, normalized_width hm,
+      Complex.add_re, Complex.add_im, Complex.mul_re, Complex.mul_im,
+      Complex.ofReal_re, Complex.ofReal_im, Complex.I_re, Complex.I_im,
+      Complex.zero_im]
+    ring_nf
+    rw [side_sq]
+    ring
+
+lemma straight_height_bound (m j : ℕ) {u : ℝ} (hu : u ∈ Icc (0 : ℝ) (200 * m)) :
+    |side j * (-100 * m + u)| ≤ 100 * m := by
+  rw [abs_mul, side_abs, one_mul]
+  exact abs_le.mpr ⟨by linarith [hu.1], by linarith [hu.2]⟩
+
+lemma circular_angle_bound {u : ℝ} (hu : u ∈ Icc (0 : ℝ) (50 * Real.pi)) :
+    u / 50 ∈ Icc (0 : ℝ) Real.pi := by
+  constructor <;> linarith [hu.1, hu.2]
+
+lemma turn_column_time {m : ℕ} (hm : 0 < m) (j k : ℕ) {θ y a b : ℝ}
+    (hθ : θ ∈ Icc (0 : ℝ) Real.pi) (hy : |y| ≤ 100 * m)
+    (ha : |a| ≤ 1) (hb : |b| ≤ 1)
+    (he : turnPoint 0 (100 * m) m j θ a = columnPoint 0 (100 * m) m k y b) :
+    columnEntry 0 m j + 200 * m + 50 * θ =
+      columnEntry 0 m k + (side k * y + 100 * m) ∧ a = b := by
+  have hh : (0 : ℝ) < 100 * m := by positivity
+  rcases turnPoint_column_gluing hh hm 0 hθ hy ha hb he with
+    ⟨hθ, hk, hy, hab⟩ | ⟨hθ, hk, hy, hab⟩
+  · subst θ
+    subst k
+    subst y
+    refine ⟨?_, hab⟩
+    have hs : side j * (side j * (100 * (m : ℝ))) = 100 * m := by
+      rw [← mul_assoc, ← pow_two, side_sq, one_mul]
+    rw [hs]
+    ring
+  · subst θ
+    subst k
+    subst y
+    refine ⟨?_, hab⟩
+    have hs : side (j + 1) * (side j * (100 * (m : ℝ))) = -(100 * m) := by
+      rw [side_succ, neg_mul, ← mul_assoc, ← pow_two, side_sq, one_mul]
+    rw [hs, columnEntry_succ]
+    ring
+
+/-- Normal coordinates over the complete finite array are injective,
+including the endpoints shared by adjacent straight and circular pieces. -/
+theorem array_normal_injective {m : ℕ} (hm : 0 < m) (last : ℕ) :
+    InjOn (normalRibbon (arraySpine m last) (arrayTangent m last))
+      {z : ℂ | z.re ∈ Icc (0 : ℝ) (arrayEnd m last) ∧ |z.im| ≤ 1} := by
+  intro z hz w hw he
+  have hh : (0 : ℝ) < 100 * m := by positivity
+  rcases array_pieces m last hz.1 with ⟨i, _, u, hu, hzu, hzs, hzT⟩ |
+    ⟨i, _, u, hu, hzu, hzs, hzT⟩ <;>
+  rcases array_pieces m last hw.1 with ⟨j, _, v, hv, hwv, hws, hwT⟩ |
+    ⟨j, _, v, hv, hwv, hws, hwT⟩
+  · simp only [normalRibbon] at he
+    rw [hzs, hzT, hws, hwT,
+      normal_straight_eq hm, normal_straight_eq hm] at he
+    have hij := columnPoint_equal_forces_index hh hm 0 _ _ hz.2 hw.2 he
+    subst j
+    obtain ⟨hy, hab⟩ := columnPoint_injective hh hm 0 i he
+    have hs : side i ≠ 0 := by
+      intro h
+      have hh := side_abs i
+      rw [h, abs_zero] at hh
+      norm_num at hh
+    have huv : u = v := by
+      have h := mul_left_cancel₀ hs hy
+      linarith
+    exact Complex.ext (by rw [hzu, hwv, huv]) hab
+  · simp only [normalRibbon] at he
+    rw [hzs, hzT, hws, hwT,
+      normal_straight_eq hm, normal_circular_eq hm] at he
+    obtain ⟨ht, hab⟩ := turn_column_time hm j i (circular_angle_bound hv)
+      (straight_height_bound m i hu) hw.2 hz.2 he.symm
+    have hs : side i * (side i * (-100 * (m : ℝ) + u)) = -100 * m + u := by
+      rw [← mul_assoc, ← pow_two, side_sq, one_mul]
+    rw [hs] at ht
+    exact Complex.ext (by rw [hzu, hwv]; linarith) hab.symm
+  · simp only [normalRibbon] at he
+    rw [hzs, hzT, hws, hwT,
+      normal_circular_eq hm, normal_straight_eq hm] at he
+    obtain ⟨ht, hab⟩ := turn_column_time hm i j (circular_angle_bound hu)
+      (straight_height_bound m j hv) hz.2 hw.2 he
+    have hs : side j * (side j * (-100 * (m : ℝ) + v)) = -100 * m + v := by
+      rw [← mul_assoc, ← pow_two, side_sq, one_mul]
+    rw [hs] at ht
+    exact Complex.ext (by rw [hzu, hwv]; linarith) hab
+  · simp only [normalRibbon] at he
+    rw [hzs, hzT, hws, hwT,
+      normal_circular_eq hm, normal_circular_eq hm] at he
+    have hij : i = j := by
+      by_contra hij
+      rcases lt_or_gt_of_ne hij with hij | hji
+      · exact turnPoint_ne hh hm hij 0 (circular_angle_bound hu) (circular_angle_bound hv)
+          hz.2 hw.2 he
+      · exact turnPoint_ne hh hm hji 0 (circular_angle_bound hv) (circular_angle_bound hu)
+          hw.2 hz.2 he.symm
+    subst j
+    obtain ⟨ht, hab⟩ := turnPoint_injective hh hm 0 i (circular_angle_bound hu)
+      (circular_angle_bound hv) hz.2 hw.2 he
+    exact Complex.ext (by rw [hzu, hwv]; linarith) hab
+
+end SLEExactGauge.Serpentine
+
+end
+
+end OAI
diff --git a/lean/OAI/Probability/SLE/Gauge/SerpentineArrayRegion.lean b/lean/OAI/Probability/SLE/Gauge/SerpentineArrayRegion.lean
new file mode 100644
index 0000000000000000000000000000000000000000..e5ddf47a040806fd9fe972e3a6eeeb81a47bf1b7
--- /dev/null
+++ b/lean/OAI/Probability/SLE/Gauge/SerpentineArrayRegion.lean
@@ -0,0 +1,50 @@
+import OAI.Probability.SLE.Gauge.SerpentineAttachments
+
+namespace OAI
+
+/-! Horizontal confinement of the whole infinite array. This keeps
+every part of the completed experiment away from the marked-point shadow. -/
+
+noncomputable section
+open Set Metric
+
+namespace SLEExactGauge.Serpentine
+
+lemma array_normal_re_lower {m : ℕ} (hm : 0 < m) {z : ℂ}
+    (hz : 0 ≤ z.re ∧ |z.im| ≤ 1) :
+    -(400 * (m : ℝ)) ≤ (normalRibbon (arraySpine m (2 * m)) (arrayTangent m (2 * m)) z).re := by
+  have hh : (0 : ℝ) < 100 * m := by positivity
+  by_cases he : z.re ≤ arrayEnd m (2 * m)
+  · rcases array_pieces m (2 * m) ⟨hz.1, he⟩ with ⟨i, hi, u, hu, _, hs, hT⟩ |
+      ⟨i, hi, u, hu, _, hs, hT⟩
+    · simp only [normalRibbon]
+      rw [hs, hT, normal_straight_eq hm]
+      have hb := columnPoint_bound hh hm hi 0 (straight_height_bound m i hu) hz.2
+      rw [dist_zero_right] at hb
+      have hi := Complex.abs_re_le_norm (columnPoint 0 (100 * m) m i (side i * (-100 * m + u)) z.im)
+      have hl := neg_abs_le (columnPoint 0 (100 * m) m i (side i * (-100 * m + u)) z.im).re
+      linarith
+    · simp only [normalRibbon]
+      rw [hs, hT, normal_circular_eq hm]
+      have hb := turnPoint_bound hh hm (show i + 1 ≤ 2 * m by omega) 0 (u / 50) hz.2
+      rw [dist_zero_right] at hb
+      have hi := Complex.abs_re_le_norm (turnPoint 0 (100 * m) m i (u / 50) z.im)
+      have hl := neg_abs_le (turnPoint 0 (100 * m) m i (u / 50) z.im).re
+      linarith
+  · have hE : columnEntry 0 m (2 * m) ≤ z.re := by
+      have h := lt_of_not_ge he
+      dsimp only [arrayEnd] at h
+      linarith [Nat.cast_nonneg (α := ℝ) m]
+    have ht := array_normal_terminal hm (a := z.im) hE
+    rw [Complex.re_add_im z] at ht
+    rw [ht, columnPoint_re]
+    simp only [columnOffset, normalized_spacing hm, normalized_width hm, side_even,
+      one_mul, Complex.zero_re, zero_add, Nat.cast_mul, Nat.cast_ofNat]
+    have hm' : (1 : ℝ) ≤ m := by exact_mod_cast hm
+    linarith [(abs_le.mp hz.2).2]
+
+end SLEExactGauge.Serpentine
+
+end
+
+end OAI
diff --git a/lean/OAI/Probability/SLE/Gauge/SerpentineAttachments.lean b/lean/OAI/Probability/SLE/Gauge/SerpentineAttachments.lean
new file mode 100644
index 0000000000000000000000000000000000000000..a78615ce9a46ea85a9ac3a78ba276e4e2eca35a1
--- /dev/null
+++ b/lean/OAI/Probability/SLE/Gauge/SerpentineAttachments.lean
@@ -0,0 +1,92 @@
+import OAI.Probability.SLE.Gauge.SerpentineInfiniteArray
+
+namespace OAI
+
+/-! Clearance below the array and the unique attachment to its first
+column. These facts separate the low connector from the array. -/
+
+noncomputable section
+open Set Metric
+
+namespace SLEExactGauge.Serpentine
+
+lemma array_normal_im_lower {m : ℕ} (hm : 0 < m) {z : ℂ}
+    (hz : 0 ≤ z.re ∧ |z.im| ≤ 1) :
+    -(400 * (m : ℝ)) ≤ (normalRibbon (arraySpine m (2 * m)) (arrayTangent m (2 * m)) z).im := by
+  have hh : (0 : ℝ) < 100 * m := by positivity
+  by_cases he : z.re ≤ arrayEnd m (2 * m)
+  · rcases array_pieces m (2 * m) ⟨hz.1, he⟩ with ⟨i, hi, u, hu, _, hs, hT⟩ |
+      ⟨i, hi, u, hu, _, hs, hT⟩
+    · simp only [normalRibbon]
+      rw [hs, hT, normal_straight_eq hm]
+      have hb := columnPoint_bound hh hm hi 0 (straight_height_bound m i hu) hz.2
+      rw [dist_zero_right] at hb
+      have hi := Complex.abs_im_le_norm (columnPoint 0 (100 * m) m i (side i * (-100 * m + u)) z.im)
+      have hl := neg_abs_le (columnPoint 0 (100 * m) m i (side i * (-100 * m + u)) z.im).im
+      linarith
+    · simp only [normalRibbon]
+      rw [hs, hT, normal_circular_eq hm]
+      have hb := turnPoint_bound hh hm (show i + 1 ≤ 2 * m by omega) 0 (u / 50) hz.2
+      rw [dist_zero_right] at hb
+      have hi := Complex.abs_im_le_norm (turnPoint 0 (100 * m) m i (u / 50) z.im)
+      have hl := neg_abs_le (turnPoint 0 (100 * m) m i (u / 50) z.im).im
+      linarith
+  · have hE : columnEntry 0 m (2 * m) ≤ z.re := by
+      have h := lt_of_not_ge he
+      dsimp only [arrayEnd] at h
+      linarith [Nat.cast_nonneg (α := ℝ) m]
+    have ht := array_normal_terminal hm (a := z.im) hE
+    rw [Complex.re_add_im z] at ht
+    rw [ht, columnPoint_im]
+    have h := lt_of_not_ge he
+    dsimp only [arrayEnd] at h
+    simp only [Complex.zero_im, zero_add]
+    linarith
+
+/-- The downward extension of the first column meets the array only at
+its initial cross-section, with identical normal coordinate. -/
+theorem array_downward_attachment {m : ℕ} (hm : 0 < m) {z : ℂ}
+    (hz : 0 ≤ z.re ∧ |z.im| ≤ 1) {y a : ℝ} (hy : y ≤ -(100 * (m : ℝ)))
+    (ha : |a| ≤ 1)
+    (he : normalRibbon (arraySpine m (2 * m)) (arrayTangent m (2 * m)) z =
+      columnPoint 0 (100 * m) m 0 y a) :
+    z.re = 0 ∧ y = -(100 * (m : ℝ)) ∧ z.im = a := by
+  have hh : (0 : ℝ) < 100 * m := by positivity
+  have hs0 : side 0 = 1 := by simp [side]
+  by_cases hE : z.re ≤ arrayEnd m (2 * m)
+  · rcases array_pieces m (2 * m) ⟨hz.1, hE⟩ with ⟨i, _, u, hu, hzu, hs, hT⟩ |
+      ⟨i, hi, u, hu, _, hs, hT⟩
+    · simp only [normalRibbon] at he
+      rw [hs, hT, normal_straight_eq hm] at he
+      have hii := columnPoint_equal_forces_index hh hm 0 _ _ hz.2 ha he
+      subst i
+      obtain ⟨hy', ha'⟩ := columnPoint_injective hh hm 0 0 he
+      rw [hs0, one_mul] at hy'
+      have hu0 : u = 0 := by linarith [hu.1]
+      subst u
+      exact ⟨by simpa [columnEntry] using hzu, by linarith, ha'⟩
+    · simp only [normalRibbon] at he
+      rw [hs, hT, normal_circular_eq hm] at he
+      by_cases hi0 : i = 0
+      · subst i
+        have him := turn_oriented_height hh hm 0 0 (circular_angle_bound hu) hz.2
+        rw [hs0, one_mul, he, columnPoint_im] at him
+        simp only [Complex.zero_im, zero_add] at him
+        linarith
+      · exact (turnPoint_column_ne_nonadjacent hh hm (Or.inl (Nat.pos_of_ne_zero hi0))
+          0 (u / 50) y hz.2 ha he).elim
+  · have hze : columnEntry 0 m (2 * m) ≤ z.re := by
+      have h := lt_of_not_ge hE
+      dsimp only [arrayEnd] at h
+      linarith [Nat.cast_nonneg (α := ℝ) m]
+    have ht := array_normal_terminal hm (a := z.im) hze
+    rw [Complex.re_add_im z] at ht
+    rw [ht] at he
+    have hii := columnPoint_equal_forces_index hh hm 0 _ _ hz.2 ha he
+    omega
+
+end SLEExactGauge.Serpentine
+
+end
+
+end OAI
diff --git a/lean/OAI/Probability/SLE/Gauge/SerpentineCenteredMass.lean b/lean/OAI/Probability/SLE/Gauge/SerpentineCenteredMass.lean
new file mode 100644
index 0000000000000000000000000000000000000000..745f4ad5e943abe6e996029fa0ca142e6000d96a
--- /dev/null
+++ b/lean/OAI/Probability/SLE/Gauge/SerpentineCenteredMass.lean
@@ -0,0 +1,132 @@
+import OAI.Probability.SLE.Gauge.SerpentineActualRadius
+import OAI.Probability.SLE.Gauge.SerpentineActualAngleReflection
+import OAI.Probability.SLE.Gauge.ExtendedExperimentStop
+
+namespace OAI
+
+/-! The stopped physical experiment under the actual finite centered law.
+Both its mass and its successful completion are observable at the front. -/
+
+noncomputable section
+open Set Filter MeasureTheory ProbabilityTheory Metric
+open scoped Topology NNReal ENNReal
+
+namespace SLEExactGauge.Serpentine
+open RibbonCoordinates Target FirstFrontPassage
+
+lemma experimentSteps_add_one {s : ℝ} (hs : 0 < s) (w : ℂ) (hw : s ≤ w.im)
+    {m : ℕ} (hm : 0 < m) : experimentSteps s w m + 1 = fitCompletion s w m := by
+  have hbound := (fitCompletion_bounds hs w hw hm).1
+  have hEntry : 0 ≤ fitEntry s w m :=
+    (by unfold fitHeight; positivity : (0 : ℝ) ≤ fitHeight m).trans (fit_entry_lower hs w hw hm)
+  have hcol : 0 ≤ columnEntry 0 m (2 * m) := columnEntry_nonneg le_rfl _ _
+  have hmR : (0 : ℝ) < m := by exact_mod_cast hm
+  have hk : (0 : ℝ) < fitCompletion s w m := by linarith
+  have hkN : 0 < fitCompletion s w m := by exact_mod_cast hk
+  change fitCompletion s w m - 1 + 1 = fitCompletion s w m
+  omega
+
+lemma experiment_front_eq {Ω : Type*} {s : ℝ} (hs : 0 < s) (w : ℂ) (hw : s ≤ w.im)
+    {m : ℕ} (hm : 0 < m) (g : C(ℂ, ℝ)) (γ : Ω → ℝ≥0 → ℂ) :
+    ribbonIntegerFront g γ (experimentSteps s w m) =
+      ribbonFrontStop g γ (fitCompletion s w m) := by
+  have hh : (experimentSteps s w m : ℝ) + 1 = fitCompletion s w m := by
+    exact_mod_cast experimentSteps_add_one hs w hw hm
+  simp only [ribbonIntegerFront, hh]
+
+lemma exponential_prefactor_quadratic_cost {p C : ℝ} (hp : 0 < p) (hC : 0 < C) :
+    ∃ D : ℝ, 0 < D ∧ ∀ m : ℕ, 0 < m →
+      Real.exp (-D * (m : ℝ) ^ 2) ≤ p * Real.exp (-C * (m : ℝ) ^ 2) := by
+  refine ⟨C + |Real.log p| + 1, by positivity, fun m hm => ?_⟩
+  have hm1 : (1 : ℝ) ≤ m := by exact_mod_cast hm
+  have hlog : -|Real.log p| ≤ Real.log p := neg_abs_le _
+  have hmul := mul_nonneg (abs_nonneg (Real.log p))
+    (show 0 ≤ (m : ℝ) ^ 2 - 1 by nlinarith)
+  calc
+    _ ≤ Real.exp (Real.log p + -C * (m : ℝ) ^ 2) := by
+      apply Real.exp_le_exp.mpr
+      nlinarith [abs_nonneg (Real.log p)]
+    _ = _ := by rw [Real.exp_add, Real.exp_log hp]
+
+theorem uniform_serpentine_centered_stopped_mass
+    {Ω : Type} [mΩ : MeasurableSpace Ω] (μ : Measure Ω) [IsProbabilityMeasure μ]
+    (κ : ℝ) (hκ : 0 < κ) (hκ8 : κ < 8)
+    (B : ℝ≥0 → Ω → ℝ) (hB : IsBrownianReal B μ)
+    (hBm : Measurable (fun p : ℝ≥0 × Ω => B p.1 p.2))
+    (hc : ∀ ω, Continuous (fun t => B t ω)) (hB0 : ∀ ω, B 0 ω = 0)
+    (γ : Ω → ℝ≥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)
+    (ε : ℝ) (hε : 0 < ε) (hεsmall : ε ≤ 1 / 8) :
+    ∃ c v₀ : ℝ, 0 < c ∧ 0 < v₀ ∧ ∀ s : ℝ, 0 < s → s ≤ 1 →
+      ∃ C : ℝ, 0 < C ∧ ∀ w : ℂ, ‖w‖ ≤ 1 → s ≤ w.im → ∀ m : ℕ, 0 < m →
+      ∀ v : ℝ, 0 < v → v < ribbonWidth (halfHeight s) m * v₀ → ∀ g : C(ℂ, ℝ),
+      (∀ z ∈ closedRibbon, g (physicalExperimentChart s w m z) = z.re) →
+      ENNReal.ofReal (Real.exp (-C * (m : ℝ) ^ 2)) ≤
+        finiteCenteredLaw μ κ B γ G w (experimentRadiusLevel s)
+          (RibbonStepSuccess γ (fun _ => 0) (ribbonFrontStop g γ (fitCompletion s w m))
+            (physicalExperimentChart s w m) ε κ v
+            (c * (s / 20000) ^ dimension κ * (m : ℝ) ^ codimension κ)
+            (closedBall (center s w) (s / 20))) := by
+  have hm (t : ℝ≥0) : Measurable (B t) :=
+    hBm.comp (measurable_const.prodMk measurable_id)
+  obtain ⟨c, v₀, hcm, hv₀, hprob⟩ := uniform_serpentine_physical_stopped_mass μ κ hκ hκ8
+    B hB hm hc γ G F hw hcompact hboundary hsupport hplanar hstraight hexit hwiener W hW ε hε hεsmall
+  refine ⟨c, v₀, hcm, hv₀, fun s hs hs1 => ?_⟩
+  obtain ⟨C, hC, hprob⟩ := hprob s hs
+  obtain ⟨s₀, hs₀, hangle⟩ := uniform_serpentine_actual_angle hplanar hstraight hexit hwiener W hW hs hs1
+  obtain ⟨D, hD, hcost⟩ := exponential_prefactor_quadratic_cost
+    (Real.rpow_pos_of_pos hs₀ (greenExponent κ)) hC
+  refine ⟨D, hD, fun w hwn hwy m hmp v hv hvcut g hg => ?_⟩
+  let τ := ribbonFrontStop g γ (fitCompletion s w m)
+  let E := RibbonStepSuccess γ (fun _ => 0) τ (physicalExperimentChart s w m) ε κ v
+    (c * (s / 20000) ^ dimension κ * (m : ℝ) ^ codimension κ)
+    (closedBall (center s w) (s / 20))
+  let ℱ := Filtration.natural B
+    (fun _t => (hBm.comp (measurable_const.prodMk measurable_id)).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 hτ : IsStoppingTime ℱ τ := ribbonFrontStop_stopping ℱ g γ ha hγc _
+  have hE : MeasurableSet[hτ.measurableSpace] E :=
+    ribbonStepSuccess_measurable ℱ γ ha hγc (fun _ => 0) τ
+      (isStoppingTime_const ℱ 0) hτ (fun _ => bot_le) _
+      (physicalExperimentChart_closedEmbedding hs w hwy hmp) ε κ v _ _
+  have hordinary : ENNReal.ofReal (Real.exp (-C * (m : ℝ) ^ 2)) ≤ μ E := by
+    have hh := hprob w hwn hwy m hmp v hv hvcut g hg
+    rw [experiment_front_eq hs w hwy hmp g γ] at hh
+    simpa only [E, τ, RibbonStepSuccess, Set.ofPred_and, Set.ofPred_mem_eq,
+      WithTop.untopD_zero] using hh
+  have hcentered := finiteCenteredLaw_completed_experiment_lower_bound hB hBm hc hB0 κ hκ hκ8
+    γ G F (Eventually.of_forall hw) w (show w ∈ upperHalfPlane from lt_of_lt_of_le hs hwy)
+    (experimentRadiusLevel s) (experimentRadiusLevel_nonneg hs hs1) τ hτ E hE s₀ hs₀.le (by
+      apply Eventually.of_forall
+      intro ω hω
+      have hpref : () ∈ GoodRibbonPrefix (fun _ : Unit => γ ω) (fun _ => τ ω)
+          (physicalExperimentChart s w m) ε := hω.1
+      have hbefore := good_physicalExperiment_before_radius ((hc ω).const_mul _) (hw ω)
+        hs w hwn hwy hmp (τ ω) ε hpref
+      refine ⟨hpref.1, hbefore.1, hbefore.2, ?_⟩
+      rw [Complex.sin_arg]
+      simpa only [τ, ribbonFrontStop, Complex.ofReal_mul] using
+        hangle _ _ _ _ (hw ω) ((hc ω).const_mul _) w hwn hwy m hmp g hg ε hεsmall hpref)
+  calc
+    _ ≤ ENNReal.ofReal (s₀ ^ greenExponent κ) *
+        ENNReal.ofReal (Real.exp (-C * (m : ℝ) ^ 2)) := by
+      rw [← ENNReal.ofReal_mul (Real.rpow_nonneg hs₀.le _)]
+      exact ENNReal.ofReal_le_ofReal (hcost m hmp)
+    _ ≤ ENNReal.ofReal (s₀ ^ greenExponent κ) * μ E := mul_le_mul' le_rfl hordinary
+    _ ≤ _ := hcentered
+
+end SLEExactGauge.Serpentine
+
+end
+
+end OAI
diff --git a/lean/OAI/Probability/SLE/Gauge/SerpentineCompleteCurve.lean b/lean/OAI/Probability/SLE/Gauge/SerpentineCompleteCurve.lean
new file mode 100644
index 0000000000000000000000000000000000000000..eebee0d9f3698e9df724ae5b0fcbfce025d04e3b
--- /dev/null
+++ b/lean/OAI/Probability/SLE/Gauge/SerpentineCompleteCurve.lean
@@ -0,0 +1,112 @@
+import OAI.Probability.SLE.Gauge.SerpentineInfiniteArray
+import OAI.Probability.SLE.Geometry.RoundedConnectorGeometry
+
+namespace OAI
+
+/-! Arclength gluing of the low rounded connector and the upward-continued
+serpentine array. -/
+
+noncomputable section
+open Set Metric
+open scoped NNReal
+
+namespace SLEExactGauge.Serpentine
+
+lemma arraySpine_zero (m j : ℕ) :
+    arraySpine m j 0 = ((-100 * (m : ℝ) : ℝ) : ℂ) +
+      ((-100 * (m : ℝ) : ℝ) : ℂ) * Complex.I := by
+  induction j with
+  | zero => simp [arraySpine, straightPiece, side]
+  | succ j ih =>
+    have hb : (0 : ℝ) ≤ columnEntry 0 m (j + 1) := by unfold columnEntry; positivity
+    have ha : (0 : ℝ) ≤ columnEntry 0 m j + 200 * m := by unfold columnEntry; positivity
+    simpa only [arraySpine, curveJoin_of_le hb, curveJoin_of_le ha] using ih
+
+lemma arrayTangent_zero (m j : ℕ) : arrayTangent m j 0 = Complex.I := by
+  induction j with
+  | zero => simp [arrayTangent, straightTangent, side]
+  | succ j ih =>
+    have hb : (0 : ℝ) ≤ columnEntry 0 m (j + 1) := by unfold columnEntry; positivity
+    have ha : (0 : ℝ) ≤ columnEntry 0 m j + 200 * m := by unfold columnEntry; positivity
+    simpa only [arrayTangent, curveJoin_of_le hb, curveJoin_of_le ha] using ih
+
+lemma lowConnector_after {H r X t : ℝ}
+    (ht : connectorFourth H r X < t) :
+    lowConnector H r X t = connectorTail H r X t ∧
+      lowConnectorTangent H r X t = Complex.I := by
+  simp only [lowConnector, lowConnectorTangent, curveJoin_of_gt ht, and_self]
+
+def connectorEntry (H r X Y : ℝ) : ℝ := connectorFourth H r X + Y - H - 2 * r
+
+def arrayCenter (m : ℕ) (X Y : ℝ) : ℂ :=
+  ((X + 100 * m : ℝ) : ℂ) + ((Y + 100 * m : ℝ) : ℂ) * Complex.I
+
+def completeSpine (m : ℕ) (H r X Y : ℝ) : ℝ → ℂ :=
+  curveJoin (connectorEntry H r X Y) (lowConnector H r X)
+    (fun t => arrayCenter m X Y + arraySpine m (2 * m) (t - connectorEntry H r X Y))
+
+def completeTangent (m : ℕ) (H r X Y : ℝ) : ℝ → ℂ :=
+  curveJoin (connectorEntry H r X Y) (lowConnectorTangent H r X)
+    (fun t => arrayTangent m (2 * m) (t - connectorEntry H r X Y))
+
+lemma completeSpine_hasDerivAt {H r X Y : ℝ} (m : ℕ) (hr : 0 < r)
+    (hX : 2 * r < X) (hY : H + 2 * r < Y) (t : ℝ) :
+    HasDerivAt (completeSpine m H r X Y) (completeTangent m H r X Y t) t := by
+  have hentry : connectorFourth H r X < connectorEntry H r X Y := by
+    unfold connectorEntry
+    linarith
+  have hp : lowConnector H r X (connectorEntry H r X Y) =
+      arrayCenter m X Y + arraySpine m (2 * m)
+        (connectorEntry H r X Y - connectorEntry H r X Y) := by
+    rw [(lowConnector_after hentry).1, sub_self, arraySpine_zero]
+    simp only [connectorTail, connectorEntry, arrayCenter]
+    push_cast
+    ring
+  have hT : lowConnectorTangent H r X (connectorEntry H r X Y) =
+      arrayTangent m (2 * m) (connectorEntry H r X Y - connectorEntry H r X Y) := by
+    rw [(lowConnector_after hentry).2, sub_self, arrayTangent_zero]
+  exact curveJoin_hasDerivAt _ _ _ _ _ (lowConnector_hasDerivAt hr hX)
+    (translate_curve_hasDerivAt _ _ (arraySpine_hasDerivAt m (2 * m)) _ _) hp hT t
+
+lemma completeTangent_norm (m : ℕ) (H r X Y t : ℝ) : ‖completeTangent m H r X Y t‖ = 1 := by
+  unfold completeTangent curveJoin
+  split
+  · exact lowConnectorTangent_norm _ _ _ _
+  · exact arrayTangent_norm _ _ _
+
+lemma completeTangent_lipschitz {H r X Y : ℝ} (m : ℕ) (hr : 50 ≤ r)
+    (hX : 2 * r < X) (hY : H + 2 * r < Y) :
+    LipschitzWith (1 / 50) (completeTangent m H r X Y) := by
+  have hr0 : 0 < r := by linarith
+  have hentry : connectorFourth H r X < connectorEntry H r X Y := by
+    unfold connectorEntry
+    linarith
+  apply curveJoin_lipschitz (lowConnectorTangent_lipschitz hr hX)
+    (shifted_lipschitz (arrayTangent_lipschitz m (2 * m)) _)
+  rw [(lowConnector_after hentry).2, sub_self, arrayTangent_zero]
+
+lemma complete_normal_patch_bounds {H r X Y : ℝ} (m : ℕ) (hr : 50 ≤ r)
+    (hX : 2 * r < X) (hY : H + 2 * r < Y) (k : ℝ) :
+    LipschitzOnWith 2 (normalRibbon (completeSpine m H r X Y) (completeTangent m H r X Y))
+      (RibbonCoordinates.ribbonStepPatch k) ∧
+    ∀ z ∈ RibbonCoordinates.ribbonStepPatch k,
+      ∀ w ∈ RibbonCoordinates.ribbonStepPatch k,
+        dist z w ≤ 2 * dist (normalRibbon (completeSpine m H r X Y) (completeTangent m H r X Y) z)
+          (normalRibbon (completeSpine m H r X Y) (completeTangent m H r X Y) w) := by
+  have hr0 : 0 < r := by linarith
+  have hbound z (hz : z ∈ RibbonCoordinates.ribbonStepPatch k)
+      w (hw : w ∈ RibbonCoordinates.ribbonStepPatch k) :=
+    normalRibbon_patch_bounds (completeSpine m H r X Y) (completeTangent m H r X Y) (k - 1) (k + 3)
+      (by ring_nf; norm_num)
+      (fun t _ => (completeSpine_hasDerivAt m hr0 hX hY t).hasDerivWithinAt)
+      (fun t _ => completeTangent_norm m H r X Y t)
+      (completeTangent_lipschitz m hr hX hY).lipschitzOnWith
+      z w ⟨⟨hz.1, hz.2.1⟩, hz.2.2⟩ ⟨⟨hw.1, hw.2.1⟩, hw.2.2⟩
+  exact ⟨lipschitzOnWith_iff_dist_le_mul.mpr (fun z hz w hw => (hbound z hz w hw).1),
+    fun z hz w hw => (hbound z hz w hw).2⟩
+
+end SLEExactGauge.Serpentine
+
+end
+
+end OAI
diff --git a/lean/OAI/Probability/SLE/Gauge/SerpentineCompleteEmbedding.lean b/lean/OAI/Probability/SLE/Gauge/SerpentineCompleteEmbedding.lean
new file mode 100644
index 0000000000000000000000000000000000000000..86e92d3ff75989fa0d3930e7449dc6433e5500a8
--- /dev/null
+++ b/lean/OAI/Probability/SLE/Gauge/SerpentineCompleteEmbedding.lean
@@ -0,0 +1,110 @@
+import OAI.Probability.SLE.Gauge.SerpentineCompleteCurve
+import OAI.Probability.SLE.Gauge.SerpentineAttachments
+import OAI.Probability.SLE.Geometry.RoundedConnectorRegion
+
+namespace OAI
+
+/-! The low connector and the complete infinite array have one common
+normal cross-section. Hence the entire prescribed ribbon is embedded. -/
+
+noncomputable section
+open Set Metric
+
+namespace SLEExactGauge.Serpentine
+
+lemma complete_normal_of_le (m : ℕ) (H r X Y : ℝ) {z : ℂ}
+    (hz : z.re ≤ connectorEntry H r X Y) :
+    normalRibbon (completeSpine m H r X Y) (completeTangent m H r X Y) z =
+      normalRibbon (lowConnector H r X) (lowConnectorTangent H r X) z := by
+  simp only [normalRibbon, completeSpine, completeTangent, curveJoin_of_le hz]
+
+lemma complete_normal_of_gt (m : ℕ) (H r X Y : ℝ) {z : ℂ}
+    (hz : connectorEntry H r X Y < z.re) :
+    normalRibbon (completeSpine m H r X Y) (completeTangent m H r X Y) z =
+      arrayCenter m X Y + normalRibbon (arraySpine m (2 * m)) (arrayTangent m (2 * m))
+        (z - (connectorEntry H r X Y : ℂ)) := by
+  simp only [normalRibbon, completeSpine, completeTangent, curveJoin_of_gt hz,
+    Complex.sub_re, Complex.sub_im, Complex.ofReal_re, Complex.ofReal_im, sub_zero]
+  abel
+
+lemma complete_normal_cross_disjoint {m : ℕ} (hm : 0 < m) {H r X Y : ℝ}
+    (hr : 50 ≤ r) (hX : 2 * r < X) (hY : H + 2 * r + 1 + 300 * m < Y)
+    {z w : ℂ} (hz : 0 ≤ z.re ∧ |z.im| ≤ 1) (hwa : |w.im| ≤ 1)
+    (hzA : z.re ≤ connectorEntry H r X Y) (hwA : connectorEntry H r X Y < w.re) :
+    normalRibbon (completeSpine m H r X Y) (completeTangent m H r X Y) z ≠
+      normalRibbon (completeSpine m H r X Y) (completeTangent m H r X Y) w := by
+  intro he
+  rw [complete_normal_of_le m H r X Y hzA, complete_normal_of_gt m H r X Y hwA] at he
+  let w' := w - (connectorEntry H r X Y : ℂ)
+  have hw' : 0 ≤ w'.re ∧ |w'.im| ≤ 1 := by
+    dsimp [w']
+    simp only [sub_zero]
+    exact ⟨by linarith, hwa⟩
+  have hr1 : 1 < r := by linarith
+  by_cases hz4 : z.re ≤ connectorFourth H r X
+  · have hlo := lowConnector_normal_im_upper hr1 hX hz4 hz.2
+    have hhi := array_normal_im_lower hm hw'
+    have him := congrArg Complex.im he
+    simp only [arrayCenter, Complex.add_im, Complex.ofReal_im, Complex.mul_im,
+      Complex.ofReal_re, Complex.I_re, Complex.I_im, mul_one, mul_zero, add_zero, zero_add] at him
+    change -(400 * (m : ℝ)) ≤ (normalRibbon (arraySpine m (2 * m)) (arrayTangent m (2 * m)) w').im at hhi
+    change (normalRibbon (lowConnector H r X) (lowConnectorTangent H r X) z).im =
+      Y + 100 * m + (normalRibbon (arraySpine m (2 * m)) (arrayTangent m (2 * m)) w').im at him
+    linarith
+  · have hz4' : connectorFourth H r X < z.re := lt_of_not_ge hz4
+    let y := H + 2 * r + (z.re - connectorFourth H r X) - Y - 100 * m
+    have hy : y ≤ -(100 * (m : ℝ)) := by
+      dsimp [y]
+      dsimp only [connectorEntry] at hzA
+      linarith
+    have hpoint : normalRibbon (arraySpine m (2 * m)) (arrayTangent m (2 * m)) w' =
+        columnPoint 0 (100 * m) m 0 y z.im := by
+      have hs := congrArg (fun q : ℂ => q - arrayCenter m X Y) he
+      simp only [add_sub_cancel_left] at hs
+      rw [normalRibbon, (lowConnector_after hz4').1, (lowConnector_after hz4').2] at hs
+      have heq : normalRibbon (arraySpine m (2 * m)) (arrayTangent m (2 * m)) w' =
+          connectorTail H r X z.re + (z.im : ℂ) * Complex.I * Complex.I - arrayCenter m X Y := by
+        exact hs.symm
+      rw [heq]
+      have hs0 : side 0 = 1 := by simp [side]
+      apply Complex.ext <;>
+        simp only [connectorTail, arrayCenter, columnPoint, columnOffset, Nat.cast_zero,
+          zero_mul, hs0, one_mul, normalized_width hm, Complex.add_re, Complex.add_im,
+          Complex.sub_re, Complex.sub_im, Complex.mul_re, Complex.mul_im, Complex.ofReal_re,
+          Complex.ofReal_im, Complex.zero_re, Complex.zero_im, Complex.I_re, Complex.I_im, y] <;> ring
+    have hzero := (array_downward_attachment hm hw' hy hz.2 hpoint).1
+    dsimp [w'] at hzero
+    linarith
+
+/-- Global embedding of the whole explicit normal ribbon, including its
+real-boundary connector and infinite final vertical continuation. -/
+theorem complete_normal_injective {m : ℕ} (hm : 0 < m) {H r X Y : ℝ}
+    (hr : 50 ≤ r) (hX : 2 * r < X) (hY : H + 2 * r + 1 + 300 * m < Y) :
+    InjOn (normalRibbon (completeSpine m H r X Y) (completeTangent m H r X Y))
+      {z : ℂ | 0 ≤ z.re ∧ |z.im| ≤ 1} := by
+  intro z hz w hw he
+  by_cases hzA : z.re ≤ connectorEntry H r X Y
+  · by_cases hwA : w.re ≤ connectorEntry H r X Y
+    · rw [complete_normal_of_le m H r X Y hzA, complete_normal_of_le m H r X Y hwA] at he
+      exact lowConnector_normal_injective hr hX hz hw he
+    · exact (complete_normal_cross_disjoint hm hr hX hY hz hw.2 hzA (lt_of_not_ge hwA) he).elim
+  · by_cases hwA : w.re ≤ connectorEntry H r X Y
+    · exact (complete_normal_cross_disjoint hm hr hX hY hw hz.2 hwA (lt_of_not_ge hzA) he.symm).elim
+    · rw [complete_normal_of_gt m H r X Y (lt_of_not_ge hzA),
+        complete_normal_of_gt m H r X Y (lt_of_not_ge hwA)] at he
+      have he' := add_left_cancel he
+      have hz' : 0 ≤ (z - (connectorEntry H r X Y : ℂ)).re ∧
+          |(z - (connectorEntry H r X Y : ℂ)).im| ≤ 1 := by
+        simp only [Complex.sub_re, Complex.sub_im, Complex.ofReal_re, Complex.ofReal_im, sub_zero]
+        exact ⟨by linarith, hz.2⟩
+      have hw' : 0 ≤ (w - (connectorEntry H r X Y : ℂ)).re ∧
+          |(w - (connectorEntry H r X Y : ℂ)).im| ≤ 1 := by
+        simp only [Complex.sub_re, Complex.sub_im, Complex.ofReal_re, Complex.ofReal_im, sub_zero]
+        exact ⟨by linarith, hw.2⟩
+      exact sub_left_injective (array_normal_injective_infinite hm hz' hw' he')
+
+end SLEExactGauge.Serpentine
+
+end
+
+end OAI
diff --git a/lean/OAI/Probability/SLE/Gauge/SerpentineConformalGeometry.lean b/lean/OAI/Probability/SLE/Gauge/SerpentineConformalGeometry.lean
new file mode 100644
index 0000000000000000000000000000000000000000..d400ef1f8ebd4cc34dcb45cdb261f6cd6805aa64
--- /dev/null
+++ b/lean/OAI/Probability/SLE/Gauge/SerpentineConformalGeometry.lean
@@ -0,0 +1,170 @@
+import OAI.Probability.SLE.Gauge.RestrictedConformalSausage
+import OAI.Probability.SLE.Geometry.NormalizedConformalBounds
+import OAI.Probability.SLE.Gauge.SerpentineLayout
+
+namespace OAI
+
+/-! A common small displaced experiment disk in normalized half-plane
+coordinates. Its nearby trace witnesses stay in a controlled conformal
+patch, and its image stays in one physical conformal-radius disk. -/
+
+noncomputable section
+open Set Filter MeasureTheory Metric
+open scoped Topology ENNReal NNReal
+
+namespace SLEExactGauge.Serpentine
+
+def conformalExperimentScale (s C : ℝ) : ℝ := min (s / 10) (s / (100 * C))
+
+lemma conformalExperimentScale_bounds {s C : ℝ} (hs : 0 < s) (hC : 0 < C) :
+    0 < conformalExperimentScale s C ∧ conformalExperimentScale s C ≤ s / 10 ∧
+      C * conformalExperimentScale s C ≤ s / 100 := by
+  refine ⟨lt_min (by positivity) (by positivity), min_le_left _ _, ?_⟩
+  have hh := (le_div_iff₀ (by positivity : 0 < 100 * C)).mp
+    (min_le_right (s / 10) (s / (100 * C)))
+  dsimp only [conformalExperimentScale]
+  nlinarith
+
+lemma experiment_patch_subset_compact {s h : ℝ} (hs : 0 < s) (hs1 : s ≤ 1)
+    (hh : h ≤ s / 10) (w : ℂ) (hwn : ‖w‖ = 1) (hwy : s ≤ w.im) :
+    closedBall w h ⊆ normalizedInteriorCompact s := by
+  intro z hz
+  have hn := norm_le_norm_add_const_of_dist_le hz
+  have hi := Complex.im_le_norm (w - z)
+  have hd : ‖w - z‖ ≤ h := by
+    simpa only [mem_closedBall, ← dist_eq_norm, dist_comm] using hz
+  rw [Complex.sub_im] at hi
+  change ‖z‖ ≤ 2 ∧ s / 2 ≤ z.im
+  rw [hwn] at hn
+  constructor <;> linarith
+
+lemma displaced_experiment_dist {h : ℝ} (hh : 0 ≤ h) (w z : ℂ)
+    (hz : z ∈ closedBall (center h w) (h / 20)) :
+    dist z w ≤ 3 * h / 10 := by
+  have hd := (dist_triangle z (center h w) w).trans
+    (add_le_add hz (center_dist hh w).le)
+  linarith
+
+lemma displaced_experiment_subset_patch {h : ℝ} (hh : 0 ≤ h) (w : ℂ) :
+    closedBall (center h w) (h / 20) ⊆ closedBall w h := by
+  intro z hz
+  exact (displaced_experiment_dist hh w z hz).trans (by linarith)
+
+lemma displaced_experiment_near_patch {h u : ℝ} (hh : 0 < h) (hu : u < h / 20)
+    (w z y : ℂ) (hz : z ∈ closedBall (center h w) (h / 20)) (hzy : dist z y < u) :
+    y ∈ closedBall w h := by
+  have hd := dist_triangle y z w
+  rw [dist_comm y z] at hd
+  have hz' := displaced_experiment_dist hh.le w z hz
+  change dist y w ≤ h
+  linarith
+
+/-- Converting any positive deterministic parameter cutoff into a
+cutoff proportional to the physical conformal radius. -/
+lemma conformal_experiment_mesh_cutoff {C a q v : ℝ}
+    (hC : 0 < C) (ha : 0 < a) (hq : 0 < q) (w : ℂ) (hwi : w.im ≤ 1)
+    (hv : v < (C * q / 2) * (2 * w.im * a)) :
+    v / (C * a) < q := by
+  apply (div_lt_iff₀ (mul_pos hC ha)).mpr
+  have hm := mul_le_mul_of_nonneg_left hwi (show 0 ≤ C * q * a by positivity)
+  nlinarith
+
+theorem conformal_experiment_image_subset
+    {s h c C : ℝ} (hs : 0 < s) (hs1 : s ≤ 1) (hh : 0 < h)
+    (hhs : h ≤ s / 10) (hCh : C * h ≤ s / 100) (hC : 0 < C)
+    (F : ℂ → ℂ) (w : ℂ) (hwn : ‖w‖ = 1) (hwy : s ≤ w.im)
+    (hF : DifferentiableOn ℂ F upperHalfPlane)
+    (hbound : ∀ z ∈ normalizedInteriorCompact s,
+      c * ‖deriv F w‖ ≤ ‖deriv F z‖ ∧ ‖deriv F z‖ ≤ C * ‖deriv F w‖) :
+    F '' closedBall (center h w) (h / 20) ⊆
+      closedBall (F w) (2 * w.im * ‖deriv F w‖) := by
+  let B : ℝ≥0 := ⟨C * ‖deriv F w‖, mul_nonneg hC.le (norm_nonneg _)⟩
+  have hK := experiment_patch_subset_compact hs hs1 hhs w hwn hwy
+  have hKH := hK.trans (normalizedInteriorCompact_subset_halfPlane hs)
+  have hLip : LipschitzOnWith B F (closedBall w h) :=
+    (convex_closedBall w h).lipschitzOnWith_of_nnnorm_hasDerivWithin_le
+      (fun z hz => ((hF.differentiableAt (isOpen_upperHalfPlane.mem_nhds (hKH hz))).hasDerivAt).hasDerivWithinAt)
+      (fun z hz => by exact_mod_cast (hbound z (hK hz)).2)
+  rintro _ ⟨z, hz, rfl⟩
+  have hzK := displaced_experiment_subset_patch hh.le w hz
+  have hd := hLip.dist_le_mul z hzK w (mem_closedBall_self hh.le)
+  have hzdist := displaced_experiment_dist hh.le w z hz
+  have hnonneg := norm_nonneg (deriv F w)
+  have hmul := mul_le_mul_of_nonneg_right hCh hnonneg
+  have hdist := mul_le_mul_of_nonneg_left hzdist (show 0 ≤ C * ‖deriv F w‖ by positivity)
+  change dist (F z) (F w) ≤ 2 * w.im * ‖deriv F w‖
+  change dist (F z) (F w) ≤ (C * ‖deriv F w‖) * dist z w at hd
+  nlinarith
+
+theorem conformal_experiment_restricted_transfer
+    (κ : ℝ) {s h c C : ℝ} (hs : 0 < s) (hs1 : s ≤ 1)
+    (hh : 0 < h) (hhs : h ≤ s / 10) (hCh : C * h ≤ s / 100)
+    (hc : 0 < c) (hC : 0 < C)
+    (F : ℂ → ℂ) (w : ℂ) (hwn : ‖w‖ = 1) (hwy : s ≤ w.im)
+    (hF : DifferentiableOn ℂ F upperHalfPlane) (hi : InjOn F upperHalfPlane)
+    (hne : deriv F w ≠ 0)
+    (hbound : ∀ z ∈ normalizedInteriorCompact s,
+      c * ‖deriv F w‖ ≤ ‖deriv F z‖ ∧ ‖deriv F z‖ ≤ C * ‖deriv F w‖)
+    (γ η : ℝ≥0 → ℂ) (a b : ℝ≥0)
+    (heq : ∀ u ∈ Icc a b, γ u ∈ closedBall w h → η u = F (γ u))
+    {v : ℝ} (hv : 0 < v)
+    (hvc : v < (C * h / 40) * (2 * w.im * ‖deriv F w‖)) :
+    ENNReal.ofReal ((c ^ 2 * (1 / C) ^ codimension κ) * ‖deriv F w‖ ^ dimension κ) *
+        segmentSausageCharge κ γ a b (v / (C * ‖deriv F w‖))
+          (closedBall (center h w) (h / 20)) ≤
+      segmentSausageCharge κ η a b v (closedBall (F w) (2 * w.im * ‖deriv F w‖)) := by
+  have hnorm : 0 < ‖deriv F w‖ := norm_pos_iff.mpr hne
+  have hCa : 0 < C * ‖deriv F w‖ := mul_pos hC hnorm
+  have hwi : w.im ≤ 1 := by simpa only [hwn] using Complex.im_le_norm w
+  have hmesh : v / (C * ‖deriv F w‖) < h / 20 := by
+    apply conformal_experiment_mesh_cutoff hC hnorm (by positivity) w hwi
+    convert hvc using 1
+    ring
+  have hK := experiment_patch_subset_compact hs hs1 hhs w hwn hwy
+  have hKH := hK.trans (normalizedInteriorCompact_subset_halfPlane hs)
+  let B : ℝ≥0 := ⟨C * ‖deriv F w‖, hCa.le⟩
+  have hstep : (1 / (C * ‖deriv F w‖)) * v = v / (C * ‖deriv F w‖) := by ring
+  have ht := restricted_segment_sausage_conformal_transfer κ F (deriv F) γ η a b
+    (closedBall (center h w) (h / 20)) (closedBall w h)
+    (closedBall (F w) (2 * w.im * ‖deriv F w‖)) isClosed_closedBall.measurableSet
+    (displaced_experiment_subset_patch hh.le w) (convex_closedBall w h)
+    (hi.mono hKH)
+    (fun z hz => (hF.differentiableAt (isOpen_upperHalfPlane.mem_nhds (hKH hz))).hasDerivAt)
+    (mul_pos hc hnorm).le hv (one_div_pos.mpr hCa)
+    (fun z hz => (hbound z (hK (displaced_experiment_subset_patch hh.le w hz))).1)
+    B (fun z hz => by exact_mod_cast (hbound z (hK hz)).2)
+    (by change (C * ‖deriv F w‖) * (1 / (C * ‖deriv F w‖)) ≤ 1; rw [mul_one_div_cancel hCa.ne'])
+    (fun z hz y hd => displaced_experiment_near_patch hh hmesh w z y hz (by simpa only [hstep] using hd))
+    heq (conformal_experiment_image_subset hs hs1 hh hhs hCh hC F w hwn hwy hF hbound)
+  rw [conformal_transfer_coefficient κ hC hnorm, hstep] at ht
+  exact ht
+
+theorem uniform_conformal_experiment_restricted_transfer
+    (κ : ℝ) (hcompact : PublishedHalfPlaneUnivalentCompactness)
+    {s : ℝ} (hs : 0 < s) (hs1 : s ≤ 1) :
+    ∃ h A C δ : ℝ, 0 < h ∧ h ≤ s ∧ 0 < A ∧ 0 < C ∧ 0 < δ ∧
+      ∀ (F : ℂ → ℂ) (w : ℂ), DifferentiableOn ℂ F upperHalfPlane →
+        InjOn F upperHalfPlane → ‖w‖ = 1 → s ≤ w.im → deriv F w ≠ 0 →
+        ∀ (γ η : ℝ≥0 → ℂ) (a b : ℝ≥0),
+        (∀ u ∈ Icc a b, γ u ∈ closedBall w h → η u = F (γ u)) →
+        ∀ v : ℝ, 0 < v → v < δ * (2 * w.im * ‖deriv F w‖) →
+          ENNReal.ofReal (A * ‖deriv F w‖ ^ dimension κ) *
+              segmentSausageCharge κ γ a b (v / (C * ‖deriv F w‖))
+                (closedBall (center h w) (h / 20)) ≤
+            segmentSausageCharge κ η a b v
+              (closedBall (F w) (2 * w.im * ‖deriv F w‖)) := by
+  obtain ⟨c, C, hc, hC, hbounds⟩ := uniform_waypoint_derivative_ratios hcompact hs hs1
+  let h := conformalExperimentScale s C
+  obtain ⟨hh, hhs, hCh⟩ := conformalExperimentScale_bounds hs hC
+  refine ⟨h, c ^ 2 * (1 / C) ^ codimension κ, C, C * h / 40, hh,
+    hhs.trans (by linarith), by positivity, hC, by positivity, ?_⟩
+  intro F w hF hi hwn hwy hne γ η a b heq v hv hvc
+  exact conformal_experiment_restricted_transfer κ hs hs1 hh hhs hCh hc hC
+    F w hwn hwy hF hi hne (fun z hz => hbounds F w hF hi hwn hwy hne z hz.1 hz.2)
+    γ η a b heq hv hvc
+
+end SLEExactGauge.Serpentine
+
+end
+
+end OAI
diff --git a/lean/OAI/Probability/SLE/Gauge/SerpentineCurve.lean b/lean/OAI/Probability/SLE/Gauge/SerpentineCurve.lean
new file mode 100644
index 0000000000000000000000000000000000000000..d15d23efc6fa311f9448fef67929136b885655bc
--- /dev/null
+++ b/lean/OAI/Probability/SLE/Gauge/SerpentineCurve.lean
@@ -0,0 +1,163 @@
+import OAI.Probability.SLE.Gauge.SerpentinePieces
+import OAI.Probability.SLE.Gauge.SerpentineStepCount
+
+namespace OAI
+
+/-! Explicit arclength parametrization of the finite serpentine array,
+continued vertically along its last column. -/
+
+noncomputable section
+open Set Metric
+open scoped NNReal
+
+namespace SLEExactGauge.Serpentine
+
+lemma columnEntry_succ (A : ℝ) (m j : ℕ) :
+    columnEntry A m (j + 1) = columnEntry A m j + 200 * m + 50 * Real.pi := by
+  simp only [columnEntry, Nat.cast_add, Nat.cast_one]
+  ring
+
+def arraySpine (m : ℕ) : ℕ → ℝ → ℂ
+  | 0 => straightPiece m 0
+  | j + 1 => curveJoin (columnEntry 0 m (j + 1))
+      (curveJoin (columnEntry 0 m j + 200 * m) (arraySpine m j)
+        (fun t => circularPiece m j (t - (columnEntry 0 m j + 200 * m))))
+      (fun t => straightPiece m (j + 1) (t - columnEntry 0 m (j + 1)))
+
+def arrayTangent (m : ℕ) : ℕ → ℝ → ℂ
+  | 0 => fun _ => straightTangent 0
+  | j + 1 => curveJoin (columnEntry 0 m (j + 1))
+      (curveJoin (columnEntry 0 m j + 200 * m) (arrayTangent m j)
+        (fun t => circularTangent j (t - (columnEntry 0 m j + 200 * m))))
+      (fun _ => straightTangent (j + 1))
+
+lemma arraySpine_tail (m j : ℕ) {t : ℝ} (ht : columnEntry 0 m j ≤ t) :
+    arraySpine m j t = straightPiece m j (t - columnEntry 0 m j) := by
+  cases j with
+  | zero => simp [arraySpine, columnEntry]
+  | succ j =>
+    by_cases hlt : columnEntry 0 m (j + 1) < t
+    · simp only [arraySpine, curveJoin_of_gt hlt]
+    · have he : t = columnEntry 0 m (j + 1) := le_antisymm (le_of_not_gt hlt) ht
+      subst t
+      have hcut : columnEntry 0 m j + 200 * m < columnEntry 0 m (j + 1) := by
+        rw [columnEntry_succ]
+        linarith [Real.pi_pos]
+      simp only [arraySpine, curveJoin_of_le le_rfl, curveJoin_of_gt hcut, sub_self]
+      rw [columnEntry_succ]
+      have he : columnEntry 0 m j + 200 * m + 50 * Real.pi -
+          (columnEntry 0 m j + 200 * m) = 50 * Real.pi := by ring
+      rw [he, circular_straight_position_match]
+
+lemma arrayTangent_tail (m j : ℕ) {t : ℝ} (ht : columnEntry 0 m j ≤ t) :
+    arrayTangent m j t = straightTangent j := by
+  cases j with
+  | zero => rfl
+  | succ j =>
+    by_cases hlt : columnEntry 0 m (j + 1) < t
+    · simp only [arrayTangent, curveJoin_of_gt hlt]
+    · have he : t = columnEntry 0 m (j + 1) := le_antisymm (le_of_not_gt hlt) ht
+      subst t
+      have hcut : columnEntry 0 m j + 200 * m < columnEntry 0 m (j + 1) := by
+        rw [columnEntry_succ]
+        linarith [Real.pi_pos]
+      simp only [arrayTangent, curveJoin_of_le le_rfl, curveJoin_of_gt hcut]
+      rw [columnEntry_succ]
+      have he : columnEntry 0 m j + 200 * m + 50 * Real.pi -
+          (columnEntry 0 m j + 200 * m) = 50 * Real.pi := by ring
+      rw [he, circular_straight_tangent_match]
+
+lemma arrayTangent_norm (m j : ℕ) (t : ℝ) : ‖arrayTangent m j t‖ = 1 := by
+  induction j with
+  | zero => exact straightTangent_norm 0
+  | succ j ih =>
+    unfold arrayTangent curveJoin
+    split
+    · split
+      · exact ih
+      · exact circularTangent_norm _ _
+    · exact straightTangent_norm _
+
+lemma arraySpine_hasDerivAt (m j : ℕ) (t : ℝ) :
+    HasDerivAt (arraySpine m j) (arrayTangent m j t) t := by
+  induction j generalizing t with
+  | zero => exact straightPiece_hasDerivAt m 0 t
+  | succ j ih =>
+    let a := columnEntry 0 m j + 200 * m
+    let b := columnEntry 0 m (j + 1)
+    have hc (t : ℝ) : HasDerivAt (fun t => circularPiece m j (t - a))
+        (circularTangent j (t - a)) t := by
+      convert (circularPiece_hasDerivAt m j (t - a)).scomp t
+        ((hasDerivAt_id t).sub_const a) using 1 <;> first | rfl | simp only [one_smul]
+    have hs (t : ℝ) : HasDerivAt (fun t => straightPiece m (j + 1) (t - b))
+        (straightTangent (j + 1)) t := by
+      convert (straightPiece_hasDerivAt m (j + 1) (t - b)).scomp t
+        ((hasDerivAt_id t).sub_const b) using 1 <;> first | rfl | simp only [one_smul]
+    have ha0 : columnEntry 0 m j ≤ a := by dsimp [a]; linarith [Nat.cast_nonneg (α := ℝ) m]
+    have hab : a < b := by dsimp [a, b]; rw [columnEntry_succ]; linarith [Real.pi_pos]
+    have habv : b - a = 50 * Real.pi := by dsimp [a, b]; rw [columnEntry_succ]; ring
+    have he₁ : arraySpine m j a = circularPiece m j (a - a) := by
+      rw [arraySpine_tail m j ha0]
+      have he : a - columnEntry 0 m j = 200 * m := by dsimp [a]; ring
+      rw [he, sub_self, straight_circular_position_match]
+    have hd₁ : arrayTangent m j a = circularTangent j (a - a) := by
+      rw [arrayTangent_tail m j ha0, sub_self, straight_circular_tangent_match]
+    have hfirst := curveJoin_hasDerivAt a (arraySpine m j)
+      (fun t => circularPiece m j (t - a)) (arrayTangent m j)
+      (fun t => circularTangent j (t - a)) ih hc he₁ hd₁
+    have he₂ : curveJoin a (arraySpine m j) (fun t => circularPiece m j (t - a)) b =
+        straightPiece m (j + 1) (b - b) := by
+      rw [curveJoin_of_gt hab, habv, sub_self, circular_straight_position_match]
+    have hd₂ : curveJoin a (arrayTangent m j) (fun t => circularTangent j (t - a)) b =
+        straightTangent (j + 1) := by
+      rw [curveJoin_of_gt hab, habv, circular_straight_tangent_match]
+    exact curveJoin_hasDerivAt b _ _ _ _ hfirst hs he₂ hd₂ t
+
+lemma arrayTangent_lipschitz (m j : ℕ) : LipschitzWith (1 / 50) (arrayTangent m j) := by
+  induction j with
+  | zero => exact (LipschitzWith.const _).weaken (by norm_num)
+  | succ j ih =>
+    let a := columnEntry 0 m j + 200 * m
+    let b := columnEntry 0 m (j + 1)
+    have hc : LipschitzWith (1 / 50) (fun t => circularTangent j (t - a)) := by
+      apply lipschitzWith_iff_dist_le_mul.mpr
+      intro u v
+      simpa only [dist_sub_right] using (circularTangent_lipschitz j).dist_le_mul (u - a) (v - a)
+    have hs : LipschitzWith (1 / 50) (fun _ : ℝ => straightTangent (j + 1)) :=
+      (LipschitzWith.const _).weaken (by norm_num)
+    have ha0 : columnEntry 0 m j ≤ a := by dsimp [a]; linarith [Nat.cast_nonneg (α := ℝ) m]
+    have hab : a < b := by dsimp [a, b]; rw [columnEntry_succ]; linarith [Real.pi_pos]
+    have habv : b - a = 50 * Real.pi := by dsimp [a, b]; rw [columnEntry_succ]; ring
+    have hd₁ : arrayTangent m j a = circularTangent j (a - a) := by
+      rw [arrayTangent_tail m j ha0, sub_self, straight_circular_tangent_match]
+    have hfirst := curveJoin_lipschitz ih hc hd₁
+    have hd₂ : curveJoin a (arrayTangent m j) (fun t => circularTangent j (t - a)) b =
+        straightTangent (j + 1) := by
+      rw [curveJoin_of_gt hab, habv, circular_straight_tangent_match]
+    exact curveJoin_lipschitz hfirst hs hd₂
+
+/-- Every length-four normal coordinate patch of the explicit array has
+uniform upper and inverse Lipschitz constants equal to two. -/
+theorem array_normal_patch_bounds (m j : ℕ) (k : ℝ) :
+    LipschitzOnWith 2 (normalRibbon (arraySpine m j) (arrayTangent m j))
+      (RibbonCoordinates.ribbonStepPatch k) ∧
+    ∀ z ∈ RibbonCoordinates.ribbonStepPatch k,
+      ∀ w ∈ RibbonCoordinates.ribbonStepPatch k,
+        dist z w ≤ 2 * dist (normalRibbon (arraySpine m j) (arrayTangent m j) z)
+          (normalRibbon (arraySpine m j) (arrayTangent m j) w) := by
+  have hbound z (hz : z ∈ RibbonCoordinates.ribbonStepPatch k)
+      w (hw : w ∈ RibbonCoordinates.ribbonStepPatch k) :=
+    normalRibbon_patch_bounds (arraySpine m j) (arrayTangent m j) (k - 1) (k + 3)
+      (by ring_nf; norm_num)
+      (fun t _ => (arraySpine_hasDerivAt m j t).hasDerivWithinAt)
+      (fun t _ => arrayTangent_norm m j t) (arrayTangent_lipschitz m j).lipschitzOnWith
+      z w ⟨⟨hz.1, hz.2.1⟩, hz.2.2⟩ ⟨⟨hw.1, hw.2.1⟩, hw.2.2⟩
+  exact ⟨lipschitzOnWith_iff_dist_le_mul.mpr (fun z hz w hw => (hbound z hz w hw).1),
+    fun z hz w hw => (hbound z hz w hw).2⟩
+
+
+end SLEExactGauge.Serpentine
+
+end
+
+end OAI
diff --git a/lean/OAI/Probability/SLE/Gauge/SerpentineEmbedding.lean b/lean/OAI/Probability/SLE/Gauge/SerpentineEmbedding.lean
new file mode 100644
index 0000000000000000000000000000000000000000..729999bee93aad573898ea69da5ce47bda61d490
--- /dev/null
+++ b/lean/OAI/Probability/SLE/Gauge/SerpentineEmbedding.lean
@@ -0,0 +1,160 @@
+import OAI.Probability.SLE.Gauge.SerpentineLayout
+
+namespace OAI
+
+/-! The only contacts between the straight and circular normal bands are
+their prescribed common end sections. These geometric statements support
+the global embedding of the concatenated serpentine. -/
+
+noncomputable section
+open Set
+
+namespace SLEExactGauge.Serpentine
+
+@[simp] lemma turnPoint_im (c : ℂ) (h : ℝ) (m j : ℕ) (t a : ℝ) :
+    (turnPoint c h m j t a).im = c.im + side j * h +
+      (turnRadius h m + side j * ribbonWidth h m * a) * (side j * Real.sin t) := by
+  simp only [turnPoint, 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, zero_mul, sub_zero, mul_one, add_zero, zero_add]
+
+lemma turnPoint_oriented_im (c : ℂ) (h : ℝ) (m j : ℕ) (t a : ℝ) :
+    side j * ((turnPoint c h m j t a).im - c.im) =
+      h + (turnRadius h m + side j * ribbonWidth h m * a) * Real.sin t := by
+  rw [turnPoint_im]
+  let R := turnRadius h m + side j * ribbonWidth h m * a
+  change side j * (c.im + side j * h + R * (side j * Real.sin t) - c.im) = h + R * Real.sin t
+  calc
+    _ = side j ^ 2 * (h + R * Real.sin t) := by ring
+    _ = _ := by rw [side_sq, one_mul]
+
+lemma columnPoint_equal_forces_index {h : ℝ} (hh : 0 < h) {m i j : ℕ} (hm : 0 < m)
+    (c : ℂ) (y y' : ℝ) {a b : ℝ} (ha : |a| ≤ 1) (hb : |b| ≤ 1)
+    (he : columnPoint c h m i y a = columnPoint c h m j y' b) : i = j := by
+  by_contra hn
+  rcases lt_or_gt_of_ne hn with hij | hji
+  · exact columnPoint_ne hh hm hij c y y' ha hb he
+  · exact columnPoint_ne hh hm hji c y' y hb ha he.symm
+
+lemma columnPoint_injective {h : ℝ} (hh : 0 < h) {m : ℕ} (hm : 0 < m)
+    (c : ℂ) (j : ℕ) {y y' a b : ℝ}
+    (he : columnPoint c h m j y a = columnPoint c h m j y' b) : y = y' ∧ a = b := by
+  have hy := congrArg Complex.im he
+  simp only [columnPoint_im] at hy
+  have ha := congrArg Complex.re he
+  simp only [columnPoint_re] at ha
+  have hs : side j ≠ 0 := by
+    intro hz
+    have hh := side_abs j
+    rw [hz, abs_zero] at hh
+    norm_num at hh
+  refine ⟨by linarith, ?_⟩
+  apply mul_left_cancel₀ (mul_ne_zero hs (ribbonWidth_pos hh hm).ne')
+  nlinarith
+
+/-- A circular normal band can meet a straight band only at angle zero
+or pi; its interior lies strictly above or below all straight passes. -/
+theorem turnPoint_column_contact {h : ℝ} (hh : 0 < h) {m j k : ℕ} (hm : 0 < m)
+    (c : ℂ) {t y a b : ℝ} (ht : t ∈ Icc 0 Real.pi) (hy : |y| ≤ h)
+    (ha : |a| ≤ 1) (he : turnPoint c h m j t a = columnPoint c h m k y b) :
+    t = 0 ∨ t = Real.pi := by
+  by_contra hn
+  push Not at hn
+  have hsin : 0 < Real.sin t := Real.sin_pos_of_pos_of_lt_pi
+    (lt_of_le_of_ne ht.1 (Ne.symm hn.1)) (lt_of_le_of_ne ht.2 hn.2)
+  have hor := turnPoint_oriented_im c h m j t a
+  have hcoeff := turn_radial_coefficient_pos hh hm j ha
+  have hy' : |(turnPoint c h m j t a).im - c.im| ≤ h := by
+    rw [he, columnPoint_im, add_sub_cancel_left]
+    exact hy
+  have hu : side j * ((turnPoint c h m j t a).im - c.im) ≤ h := by
+    calc
+      _ ≤ |side j * ((turnPoint c h m j t a).im - c.im)| := le_abs_self _
+      _ = |(turnPoint c h m j t a).im - c.im| := by rw [abs_mul, side_abs, one_mul]
+      _ ≤ h := hy'
+  nlinarith [mul_pos hcoeff hsin]
+
+/-- Exact gluing sections, including the matching normal coordinate. -/
+theorem turnPoint_column_gluing {h : ℝ} (hh : 0 < h) {m j k : ℕ} (hm : 0 < m)
+    (c : ℂ) {t y a b : ℝ} (ht : t ∈ Icc 0 Real.pi) (hy : |y| ≤ h)
+    (ha : |a| ≤ 1) (hb : |b| ≤ 1)
+    (he : turnPoint c h m j t a = columnPoint c h m k y b) :
+    (t = 0 ∧ k = j ∧ y = side j * h ∧ a = b) ∨
+      (t = Real.pi ∧ k = j + 1 ∧ y = side j * h ∧ a = b) := by
+  rcases turnPoint_column_contact hh hm c ht hy ha he with rfl | rfl
+  · rw [turnPoint_zero] at he
+    have hk := columnPoint_equal_forces_index hh hm c (side j * h) y ha hb he
+    subst k
+    obtain ⟨hy', ha'⟩ := columnPoint_injective hh hm c j he
+    exact Or.inl ⟨rfl, rfl, hy'.symm, ha'⟩
+  · rw [turnPoint_pi] at he
+    have hk := columnPoint_equal_forces_index hh hm c (side j * h) y ha hb he
+    subst k
+    obtain ⟨hy', ha'⟩ := columnPoint_injective hh hm c (j + 1) he
+    exact Or.inr ⟨rfl, rfl, hy'.symm, ha'⟩
+
+@[simp] lemma turnPoint_re (c : ℂ) (h : ℝ) (m j : ℕ) (t a : ℝ) :
+    (turnPoint c h m j t a).re = c.re + columnOffset h m j + turnRadius h m -
+      (turnRadius h m + side j * ribbonWidth h m * a) * Real.cos t := by
+  simp only [turnPoint, 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, zero_mul, sub_zero, mul_one, add_zero, zero_add]
+  ring
+
+lemma turn_horizontal_bound {h : ℝ} (hh : 0 < h) {m : ℕ} (hm : 0 < m)
+    (c : ℂ) (j : ℕ) (t : ℝ) {a : ℝ} (ha : |a| ≤ 1) :
+    |(turnPoint c h m j t a).re - (c.re + columnOffset h m j + turnRadius h m)| ≤
+      turnRadius h m + ribbonWidth h m := by
+  have hr := (turnRadius_pos hh hm).le
+  have hw := (ribbonWidth_pos hh hm).le
+  have hb : |side j * ribbonWidth h m * a| ≤ ribbonWidth h m := by
+    rw [abs_mul, abs_mul, side_abs, one_mul, abs_of_nonneg hw]
+    exact mul_le_of_le_one_right hw ha
+  have ha' := abs_add_le (turnRadius h m) (side j * ribbonWidth h m * a)
+  rw [abs_of_nonneg hr] at ha'
+  rw [turnPoint_re]
+  have he : c.re + columnOffset h m j + turnRadius h m -
+      (turnRadius h m + side j * ribbonWidth h m * a) * Real.cos t -
+      (c.re + columnOffset h m j + turnRadius h m) =
+      -((turnRadius h m + side j * ribbonWidth h m * a) * Real.cos t) := by ring
+  rw [he, abs_neg, abs_mul]
+  exact (mul_le_of_le_one_right (abs_nonneg _) (Real.abs_cos_le_one t)).trans (ha'.trans (by linarith))
+
+lemma turn_oriented_height {h : ℝ} (hh : 0 < h) {m : ℕ} (hm : 0 < m)
+    (c : ℂ) (j : ℕ) {t a : ℝ} (ht : t ∈ Icc 0 Real.pi) (ha : |a| ≤ 1) :
+    h ≤ side j * ((turnPoint c h m j t a).im - c.im) := by
+  rw [turnPoint_oriented_im]
+  exact le_add_of_nonneg_right (mul_nonneg (turn_radial_coefficient_pos hh hm j ha).le
+    (Real.sin_nonneg_of_mem_Icc ht))
+
+/-- Different circular turns have disjoint full normal bands. Neighboring
+turns lie on opposite sides; all other turn pairs have horizontal clearance. -/
+theorem turnPoint_ne {h : ℝ} (hh : 0 < h) {m i j : ℕ} (hm : 0 < m)
+    (hij : i < j) (c : ℂ) {t u a b : ℝ} (ht : t ∈ Icc 0 Real.pi)
+    (hu : u ∈ Icc 0 Real.pi) (ha : |a| ≤ 1) (hb : |b| ≤ 1) :
+    turnPoint c h m i t a ≠ turnPoint c h m j u b := by
+  intro he
+  by_cases hnext : j = i + 1
+  · subst j
+    have h₁ := turn_oriented_height hh hm c i ht ha
+    have h₂ := turn_oriented_height hh hm c (i + 1) hu hb
+    rw [← he, side_succ] at h₂
+    nlinarith
+  · have hfar : i + 2 ≤ j := by omega
+    have hfar' : (i : ℝ) + 2 ≤ j := by exact_mod_cast hfar
+    have hstep := mul_le_mul_of_nonneg_right hfar' (spacing_pos hh hm).le
+    have h₁ := abs_le.mp (turn_horizontal_bound hh hm c i t ha)
+    have h₂ := abs_le.mp (turn_horizontal_bound hh hm c j u hb)
+    rw [← he] at h₂
+    simp only [columnOffset] at h₁ h₂
+    rw [spacing_eq_width] at hstep h₁ h₂
+    rw [turnRadius_eq_width] at h₁ h₂
+    have hw := ribbonWidth_pos hh hm
+    nlinarith
+
+
+end SLEExactGauge.Serpentine
+
+end
+
+end OAI
diff --git a/lean/OAI/Probability/SLE/Gauge/SerpentineEscape.lean b/lean/OAI/Probability/SLE/Gauge/SerpentineEscape.lean
new file mode 100644
index 0000000000000000000000000000000000000000..95ec5cc1c034a37bfab048d176f25c6f6d2be02d
--- /dev/null
+++ b/lean/OAI/Probability/SLE/Gauge/SerpentineEscape.lean
@@ -0,0 +1,90 @@
+import OAI.Probability.SLE.Gauge.SerpentineCompleteCurve
+
+namespace OAI
+
+/-! The final linear tail and bounded normal displacement of the
+complete serpentine. These supply properness of the ribbon chart. -/
+
+noncomputable section
+open Set Filter Metric
+open scoped Topology NNReal
+
+namespace SLEExactGauge.Serpentine
+
+lemma complete_linear_tail (m : ℕ) (H r X Y : ℝ) {t : ℝ}
+    (ht : connectorEntry H r X Y + columnEntry 0 m (2 * m) + 1 ≤ t) :
+    completeSpine m H r X Y t = ((X + 200 * m : ℝ) : ℂ) +
+      ((Y + t - connectorEntry H r X Y - columnEntry 0 m (2 * m) : ℝ) : ℂ) * Complex.I ∧
+    completeTangent m H r X Y t = Complex.I := by
+  have hc : 0 ≤ columnEntry 0 m (2 * m) := by unfold columnEntry; positivity
+  have htA : connectorEntry H r X Y < t := by linarith
+  have htC : columnEntry 0 m (2 * m) ≤ t - connectorEntry H r X Y := by linarith
+  simp only [completeSpine, completeTangent, curveJoin_of_gt htA]
+  rw [arraySpine_tail m (2 * m) htC, arrayTangent_tail m (2 * m) htC]
+  constructor
+  · apply Complex.ext <;>
+      simp only [arrayCenter, straightPiece, side_even, one_mul, Nat.cast_mul, Nat.cast_ofNat,
+        Complex.add_re, Complex.add_im, Complex.mul_re, Complex.mul_im, Complex.ofReal_re,
+        Complex.ofReal_im, Complex.I_re, Complex.I_im] <;> ring
+  · simp only [straightTangent, side_even, Complex.ofReal_one, one_mul]
+
+lemma complete_eventually_ray (m : ℕ) (H r X Y : ℝ) :
+    ∃ T : ℝ, 0 ≤ T ∧ ∀ t : ℝ, T ≤ t →
+      completeSpine m H r X Y t = completeSpine m H r X Y T + ((t - T : ℝ) : ℂ) * Complex.I := by
+  let T := max 0 (connectorEntry H r X Y + columnEntry 0 m (2 * m) + 1)
+  have hT : connectorEntry H r X Y + columnEntry 0 m (2 * m) + 1 ≤ T := le_max_right _ _
+  refine ⟨T, le_max_left _ _, fun t ht => ?_⟩
+  rw [(complete_linear_tail m H r X Y (hT.trans ht)).1,
+    (complete_linear_tail m H r X Y hT).1]
+  push_cast
+  ring
+
+lemma completeSpine_escape (m : ℕ) (H r X Y : ℝ) :
+    Tendsto (completeSpine m H r X Y) atTop (cocompact ℂ) := by
+  have him : Tendsto (fun t => (completeSpine m H r X Y t).im) atTop atTop := by
+    have hh : Tendsto (fun t : ℝ => Y + t - connectorEntry H r X Y - columnEntry 0 m (2 * m))
+        atTop atTop := by
+      simpa only [sub_eq_add_neg, id_eq] using
+        tendsto_atTop_add_const_right atTop (-columnEntry 0 m (2 * m))
+          (tendsto_atTop_add_const_right atTop (-connectorEntry H r X Y)
+            (tendsto_atTop_add_const_left atTop Y tendsto_id))
+    apply hh.congr'
+    filter_upwards [eventually_ge_atTop
+      (connectorEntry H r X Y + columnEntry 0 m (2 * m) + 1)] with t ht
+    rw [(complete_linear_tail m H r X Y ht).1]
+    simp
+  have hn : Tendsto (fun t => ‖completeSpine m H r X Y t‖) atTop atTop := by
+    apply tendsto_atTop_mono (fun t => ?_) him
+    exact (le_abs_self _).trans (Complex.abs_im_le_norm _)
+  apply tendsto_cocompact_of_tendsto_dist_comp_atTop 0
+  simpa only [dist_zero_right] using hn
+
+lemma complete_normal_displacement (m : ℕ) (H r X Y : ℝ) {z : ℂ} (hz : |z.im| ≤ 1) :
+    dist (normalRibbon (completeSpine m H r X Y) (completeTangent m H r X Y) z)
+      (completeSpine m H r X Y z.re) ≤ 1 := by
+  rw [normalRibbon, dist_self_add_left, norm_mul, norm_mul, Complex.norm_real,
+    Real.norm_eq_abs, Complex.norm_I, completeTangent_norm, mul_one, mul_one]
+  exact hz
+
+lemma complete_normal_width (m : ℕ) (H r X Y : ℝ) {z : ℂ} (hz : |z.im| ≤ 1) :
+    ‖normalRibbon (completeSpine m H r X Y) (completeTangent m H r X Y) z -
+      completeSpine m H r X Y z.re‖ ≤ 1 := by
+  simpa only [dist_eq_norm] using complete_normal_displacement m H r X Y hz
+
+lemma complete_normal_continuous {H r X Y : ℝ} (m : ℕ) (hr : 50 ≤ r)
+    (hX : 2 * r < X) (hY : H + 2 * r < Y) :
+    Continuous (normalRibbon (completeSpine m H r X Y) (completeTangent m H r X Y)) := by
+  have hr0 : 0 < r := by linarith
+  have hσ : Continuous (completeSpine m H r X Y) :=
+    continuous_iff_continuousAt.mpr (fun t => (completeSpine_hasDerivAt m hr0 hX hY t).continuousAt)
+  have hT : Continuous (completeTangent m H r X Y) :=
+    (completeTangent_lipschitz m hr hX hY).continuous
+  exact (hσ.comp Complex.continuous_re).add
+    (((Complex.continuous_ofReal.comp Complex.continuous_im).mul continuous_const).mul
+      (hT.comp Complex.continuous_re))
+
+end SLEExactGauge.Serpentine
+
+end
+
+end OAI
diff --git a/lean/OAI/Probability/SLE/Gauge/SerpentineExperimentGeometry.lean b/lean/OAI/Probability/SLE/Gauge/SerpentineExperimentGeometry.lean
new file mode 100644
index 0000000000000000000000000000000000000000..7b8deb6f75833b640f5b3bfe3ef1d15703ee8deb
--- /dev/null
+++ b/lean/OAI/Probability/SLE/Gauge/SerpentineExperimentGeometry.lean
@@ -0,0 +1,179 @@
+import OAI.Probability.SLE.Gauge.SerpentineFittedShadow
+import OAI.Probability.SLE.Gauge.SerpentineReflection
+import OAI.Probability.SLE.Gauge.ProperRibbonCoordinates
+
+namespace OAI
+
+/-! The actual left-or-right displaced serpentine. Reflection is applied
+to both the physical image and the normal coordinate, so the initial chart
+is still `z ↦ I*z`. -/
+
+noncomputable section
+open Set Filter Metric ComplexConjugate
+open scoped NNReal
+
+namespace SLEExactGauge.Serpentine
+open RibbonCoordinates
+
+def experimentChart (s : ℝ) (w : ℂ) (m : ℕ) : ℂ → ℂ :=
+  if 0 ≤ w.re then fitChart s w m else reflectedChart (fitChart s w m)
+
+def experimentSpine (s : ℝ) (w : ℂ) (m : ℕ) (t : ℝ) : ℂ :=
+  if 0 ≤ w.re then fitSpine s w m t else loewnerMirror (fitSpine s w m t)
+
+def physicalExperimentChart (s : ℝ) (w : ℂ) (m : ℕ) (z : ℂ) : ℂ :=
+  if 0 ≤ w.re then physicalFitChart s w m z else loewnerMirror (physicalFitChart s w m (conj z))
+
+lemma loewnerMirror_real_mul (c : ℝ) (z : ℂ) :
+    loewnerMirror ((c : ℂ) * z) = (c : ℂ) * loewnerMirror z := by
+  simp [loewnerMirror, mul_neg]
+
+lemma physicalExperimentChart_eq (s : ℝ) (w : ℂ) (m : ℕ) (z : ℂ) :
+    physicalExperimentChart s w m z = (ribbonWidth (halfHeight s) m : ℂ) * experimentChart s w m z := by
+  by_cases hw : 0 ≤ w.re
+  · simp only [physicalExperimentChart, experimentChart, ite_eq_left hw, physicalFitChart]
+  · simp only [physicalExperimentChart, experimentChart, ite_eq_right hw, physicalFitChart,
+      reflectedChart, loewnerMirror_real_mul]
+
+theorem experimentChart_geometry {s : ℝ} (hs : 0 < s) (w : ℂ) (hw : s ≤ w.im)
+    {m : ℕ} (hm : 0 < m) :
+    Continuous (experimentChart s w m) ∧ InjOn (experimentChart s w m) closedRibbon ∧
+    (∀ k : ℝ, LipschitzOnWith 2 (experimentChart s w m) (ribbonStepPatch k) ∧
+      ∀ z ∈ ribbonStepPatch k, ∀ z' ∈ ribbonStepPatch k,
+        dist z z' ≤ 2 * dist (experimentChart s w m z) (experimentChart s w m z')) ∧
+    (∀ z ∈ closedRibbon, 0 < z.re → experimentChart s w m z ∈ upperHalfPlane) ∧
+    (∀ z ∈ closedRibbon, z.re ≤ 4 → experimentChart s w m z = Complex.I * z) := by
+  have hcont := fitChart_continuous hs w hw hm
+  have hinj := fitChart_injective hs w hw hm
+  have hpatch := fitChart_patch_bounds hs w hw hm
+  have hu := fitChart_upper hs w hw hm
+  have hi : ∀ z ∈ closedRibbon, z.re ≤ 4 → fitChart s w m z = Complex.I * z := by
+    intro z _ hz
+    exact fitChart_initial hs w hw hm (hz.trans (fit_parameters hs w hw hm).2.2.2)
+  by_cases hwr : 0 ≤ w.re
+  · simpa only [experimentChart, ite_eq_left hwr] using ⟨hcont, hinj, hpatch, hu, hi⟩
+  · simp only [experimentChart, ite_eq_right hwr]
+    exact ⟨reflectedChart_continuous hcont, reflectedChart_injective hinj,
+      fun k => ⟨reflectedChart_patch_upper (hpatch k).1,
+        reflectedChart_patch_lower (hpatch k).2⟩,
+      reflectedChart_upper hu, reflectedChart_initial hi⟩
+
+lemma experimentChart_width (s : ℝ) (w : ℂ) (m : ℕ) {z : ℂ} (hz : z ∈ closedRibbon) :
+    ‖experimentChart s w m z - experimentSpine s w m z.re‖ ≤ 1 := by
+  by_cases hwr : 0 ≤ w.re
+  · simpa only [experimentChart, experimentSpine, ite_eq_left hwr] using fitChart_width s w m hz
+  · simpa only [experimentChart, experimentSpine, ite_eq_right hwr] using
+      reflectedChart_width (P := fitChart s w m) (σ := fitSpine s w m)
+        (fun _ hz => fitChart_width s w m hz) z hz
+
+lemma experimentSpine_eventually_ray (s : ℝ) (w : ℂ) (m : ℕ) :
+    ∃ T : ℝ, 0 ≤ T ∧ ∀ t : ℝ, T ≤ t →
+      experimentSpine s w m t = experimentSpine s w m T + ((t - T : ℝ) : ℂ) * Complex.I := by
+  obtain ⟨T, hT, htail⟩ := fitSpine_eventually_ray s w m
+  refine ⟨T, hT, fun t ht => ?_⟩
+  by_cases hwr : 0 ≤ w.re
+  · simpa only [experimentSpine, ite_eq_left hwr] using htail t ht
+  · simp only [experimentSpine, ite_eq_right hwr]
+    rw [htail t ht]
+    simp [loewnerMirror, mul_neg, add_comm]
+
+lemma experimentChart_real_norm (s : ℝ) (w : ℂ) (m : ℕ) (t : ℝ) :
+    ‖experimentChart s w m (t : ℂ)‖ = ‖fitSpine s w m t‖ := by
+  by_cases hwr : 0 ≤ w.re <;>
+    simp [experimentChart, hwr, reflectedChart, fitChart, normalRibbon]
+
+theorem experimentChart_escape (s : ℝ) (w : ℂ) (m : ℕ) :
+    Tendsto (fun t : ℝ => ‖experimentChart s w m (t : ℂ)‖) atTop atTop := by
+  simp only [experimentChart_real_norm]
+  exact tendsto_norm_cocompact_atTop.comp
+    (completeSpine_escape m (fitHeight m) (fitRadius m) (fitX s w m) (fitY s w m))
+
+theorem experimentChart_zero {s : ℝ} (hs : 0 < s) (w : ℂ) (hw : s ≤ w.im)
+    {m : ℕ} (hm : 0 < m) : experimentChart s w m 0 = 0 := by
+  have hh := (experimentChart_geometry hs w hw hm).2.2.2.2 0
+    (by simp [closedRibbon]) (by norm_num)
+  simpa only [mul_zero] using hh
+
+theorem experimentChart_closedEmbedding {s : ℝ} (hs : 0 < s) (w : ℂ) (hw : s ≤ w.im)
+    {m : ℕ} (hm : 0 < m) :
+    Topology.IsClosedEmbedding (fun z : closedRibbon => experimentChart s w m z) := by
+  obtain ⟨hc, hi, _⟩ := experimentChart_geometry hs w hw hm
+  obtain ⟨T, hT, htail⟩ := experimentSpine_eventually_ray s w m
+  exact ribbon_closedEmbedding_of_linear_tail _ hc.continuousOn hi _ T hT
+    (experimentSpine s w m T) htail (fun _ hz => experimentChart_width s w m hz)
+
+theorem experimentChart_global_progress {s : ℝ} (hs : 0 < s) (w : ℂ) (hw : s ≤ w.im)
+    {m : ℕ} (hm : 0 < m) :
+    ∃ g : C(ℂ, ℝ), ∀ z ∈ closedRibbon, g (experimentChart s w m z) = z.re :=
+  exists_global_ribbon_progress _ (experimentChart_closedEmbedding hs w hw hm)
+
+lemma reflected_positiveCenter {s : ℝ} {w : ℂ} (hw : w.re < 0) :
+    loewnerMirror (positiveCenter s w) = center s w := by
+  have hn : ¬ 0 ≤ w.re := not_le.mpr hw
+  apply Complex.ext
+  · simp only [loewnerMirror_re, positiveCenter, center, Complex.add_re, Complex.mul_re,
+      Complex.ofReal_re, Complex.ofReal_im, Complex.I_re, Complex.I_im,
+      mul_zero, zero_mul, sub_zero, add_zero]
+    rw [abs_of_neg hw]
+    simp only [displacementSign, ite_eq_right hn]
+    ring
+  · simp only [loewnerMirror_im, positiveCenter, center, Complex.add_im, Complex.mul_im,
+      Complex.ofReal_re, Complex.ofReal_im, Complex.I_re, Complex.I_im,
+      mul_zero, mul_one, add_zero, zero_add]
+
+theorem physicalExperimentChart_retained_disk {s : ℝ} (hs : 0 < s) (w : ℂ) (hw : s ≤ w.im)
+    {m j i : ℕ} (hm : 0 < m) (hj : j < m) (hi : i < m) {z : ℂ}
+    (hz : z.re ∈ Icc
+      ((retainedStep (connectorEntry (fitHeight m) (fitRadius m) (fitX s w m) (fitY s w m)) m j i : ℝ) + 1 / 3)
+      ((retainedStep (connectorEntry (fitHeight m) (fitRadius m) (fitX s w m) (fitY s w m)) m j i : ℝ) + 2 / 3))
+    (ha : |z.im| ≤ 1) :
+    physicalExperimentChart s w m z ∈ closedBall (center s w) (s / 20) := by
+  by_cases hwr : 0 ≤ w.re
+  · simpa only [physicalExperimentChart, ite_eq_left hwr] using
+      physicalFitChart_retained_disk hs w hw hwr hm hj hi hz ha
+  · have hzc : (conj z).re ∈ Icc
+        ((retainedStep (connectorEntry (fitHeight m) (fitRadius m) (fitX s w m) (fitY s w m)) m j i : ℝ) + 1 / 3)
+        ((retainedStep (connectorEntry (fitHeight m) (fitRadius m) (fitX s w m) (fitY s w m)) m j i : ℝ) + 2 / 3) := by
+      simpa only [Complex.conj_re] using hz
+    have hac : |(conj z).im| ≤ 1 := by simpa only [Complex.conj_im, abs_neg] using ha
+    have hd := physicalFitChart_retained_distance hs w hw hm hj hi hzc hac
+    change dist _ _ ≤ _
+    rw [physicalExperimentChart, ite_eq_right hwr, ← reflected_positiveCenter (lt_of_not_ge hwr),
+      loewnerMirror_dist]
+    linarith
+
+theorem physicalExperimentChart_avoids_shadow {s : ℝ} (hs : 0 < s) (w : ℂ) (hw : s ≤ w.im)
+    {m : ℕ} (hm : 0 < m) {z : ℂ} (ha : |z.im| ≤ 1) :
+    ¬ (|(physicalExperimentChart s w m z).re - w.re| < s / 100 ∧
+      w.im - s / 100 < (physicalExperimentChart s w m z).im) := by
+  by_cases hwr : 0 ≤ w.re
+  · simpa only [physicalExperimentChart, ite_eq_left hwr, abs_of_nonneg hwr] using
+      physicalFitChart_avoids_shadow hs w hw hm ha
+  · have hneg : w.re < 0 := lt_of_not_ge hwr
+    have hac : |(conj z).im| ≤ 1 := by simpa only [Complex.conj_im, abs_neg] using ha
+    have hn := physicalFitChart_avoids_shadow hs w hw hm hac
+    have he : abs (-(physicalFitChart s w m (conj z)).re - w.re) =
+        abs ((physicalFitChart s w m (conj z)).re - |w.re|) := by
+      rw [abs_of_neg hneg]
+      have hh : -(physicalFitChart s w m (conj z)).re - w.re =
+          -((physicalFitChart s w m (conj z)).re - -w.re) := by ring
+      rw [hh, abs_neg]
+    simpa only [physicalExperimentChart, ite_eq_right hwr, loewnerMirror_re, loewnerMirror_im, he] using hn
+
+theorem selected_middle_regions_inside {s : ℝ} (hs : 0 < s) (w : ℂ) (hw : s ≤ w.im)
+    {m : ℕ} (hm : 0 < m) {ε : ℝ} (hε : ε ≤ 1) :
+    ∀ k ∈ retainedSteps (connectorEntry (fitHeight m) (fitRadius m) (fitX s w m) (fitY s w m)) m,
+      physicalMiddleRegion (physicalExperimentChart s w m) closedRibbon k ε ⊆
+        closedBall (center s w) (s / 20) := by
+  intro k hk
+  obtain ⟨⟨j, i⟩, _, rfl⟩ := Finset.mem_image.mp hk
+  rw [physicalMiddleRegion_eq_image_middleStrip _ (Nat.cast_nonneg _) hε]
+  rintro y ⟨z, hz, rfl⟩
+  exact physicalExperimentChart_retained_disk hs w hw hm j.isLt i.isLt
+    ⟨by linarith [hz.1], by linarith [hz.2.1]⟩ (hz.2.2.le.trans hε)
+
+end SLEExactGauge.Serpentine
+
+end
+
+end OAI
diff --git a/lean/OAI/Probability/SLE/Gauge/SerpentineExponentialMass.lean b/lean/OAI/Probability/SLE/Gauge/SerpentineExponentialMass.lean
new file mode 100644
index 0000000000000000000000000000000000000000..abc4b152e4d5233d499f517f0e3849645ea3ec11
--- /dev/null
+++ b/lean/OAI/Probability/SLE/Gauge/SerpentineExponentialMass.lean
@@ -0,0 +1,63 @@
+import OAI.Probability.SLE.Gauge.SerpentineNormalizedMass
+import OAI.Probability.SLE.Gauge.DenseRibbonNumerics
+
+namespace OAI
+
+/-! The concrete stopped dense experiment costs at most exponentially
+in m²; the constants are independent of the marked point and mesh. -/
+
+noncomputable section
+open Set Filter MeasureTheory ProbabilityTheory Metric
+open scoped Topology NNReal ENNReal
+
+namespace SLEExactGauge.Serpentine
+open RibbonCoordinates Target
+
+theorem uniform_serpentine_exponential_stopped_mass
+    {Ω : 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)
+    (ε : ℝ) (hε : 0 < ε) (hεsmall : ε ≤ 1 / 8) :
+    ∃ c v₀ : ℝ, 0 < c ∧ 0 < v₀ ∧ ∀ s : ℝ, 0 < s →
+      ∃ C : ℝ, 0 < C ∧ ∀ v : ℝ, 0 < v → v < v₀ →
+      ∀ w : ℂ, ‖w‖ ≤ 1 → s ≤ w.im → ∀ m : ℕ, 0 < m → ∀ g : C(ℂ, ℝ),
+      (∀ z ∈ closedRibbon, g (experimentChart s w m z) = z.re) →
+      ENNReal.ofReal (Real.exp (-C * (m : ℝ) ^ 2)) ≤ μ {ω |
+        ω ∈ GoodRibbonPrefix γ (ribbonIntegerFront g γ (experimentSteps s w m)) (experimentChart s w m) ε ∧
+        ((m ^ 2 : ℕ) : ℝ≥0∞) * ENNReal.ofReal c ≤ segmentSausageCharge κ (γ ω) 0
+          ((ribbonIntegerFront g γ (experimentSteps s w m) ω).untopD 0) v (normalizedExperimentDisk s w m)} := by
+  obtain ⟨q₀, q, c, v₀, hq₀, hq₀1, hq, hq1, hcm, hv₀, hprob⟩ :=
+    uniform_serpentine_normalized_stopped_mass μ κ hκ hκ8 B hB hm hc γ G F hw
+      hcompact hboundary hsupport hplanar hstraight hexit hwiener W hW ε hε hεsmall
+  have hq₀fin : q₀ ≠ ⊤ := ne_top_of_le_ne_top (by norm_num : (1 : ℝ≥0∞) ≠ ⊤) hq₀1
+  have hp : 0 < q₀.toReal := ENNReal.toReal_pos hq₀.ne' hq₀fin
+  refine ⟨c, v₀, hcm, hv₀, fun s hs => ?_⟩
+  let D := fitEntryBound s + 601 + 100 * Real.pi
+  have hD : 0 ≤ D := by dsimp only [D]; linarith [fitEntryBound_pos hs, Real.pi_pos]
+  obtain ⟨C, hC, hcost⟩ := ribbon_initial_and_steps_quadratic_cost hq hq1 hp hD
+  refine ⟨C, hC, fun v hv hvcut w hwn hwy m hmp g hg => ?_⟩
+  have hcount : (experimentSteps s w m : ℝ) ≤ D * (m : ℝ) ^ 2 := by
+    apply le_trans (Nat.cast_le.mpr (Nat.sub_le _ 1))
+    exact fit_completion_quadratic hs w hwn hwy hmp
+  have hreal := hcost m (experimentSteps s w m) hmp hcount
+  have hENN := ENNReal.ofReal_le_ofReal hreal
+  rw [ENNReal.ofReal_mul (pow_nonneg hq.le _), ENNReal.ofReal_pow hq.le,
+    ENNReal.ofReal_toReal hq₀fin] at hENN
+  exact hENN.trans (hprob v hv hvcut s hs w hwy m hmp g hg)
+
+end SLEExactGauge.Serpentine
+
+end
+
+end OAI
diff --git a/lean/OAI/Probability/SLE/Gauge/SerpentineExteriorBounds.lean b/lean/OAI/Probability/SLE/Gauge/SerpentineExteriorBounds.lean
new file mode 100644
index 0000000000000000000000000000000000000000..397bb325a7f32569be2ea3b6e19201923eba98ec
--- /dev/null
+++ b/lean/OAI/Probability/SLE/Gauge/SerpentineExteriorBounds.lean
@@ -0,0 +1,60 @@
+import OAI.Probability.SLE.Gauge.SerpentineHorizontalBound
+
+namespace OAI
+
+/-! The physical experiment lies strictly between two fixed exterior
+vertical lines. These lines provide unobstructed real-boundary exits. -/
+
+noncomputable section
+open Set Metric
+
+namespace SLEExactGauge.Serpentine
+open RibbonCoordinates
+
+lemma physicalFitChart_re_bounds {s : ℝ} (hs : 0 < s) (hs1 : s ≤ 1)
+    (w : ℂ) (hw : s ≤ w.im) (hw1 : ‖w‖ ≤ 1) {m : ℕ} (hm : 0 < m)
+    {z : ℂ} (hz : z ∈ closedRibbon) :
+    -2 ≤ (physicalFitChart s w m z).re ∧ (physicalFitChart s w m z).re ≤ 2 := by
+  obtain ⟨hr, hx, _, _⟩ := fit_parameters hs w hw hm
+  have hH : 0 ≤ fitHeight m := by unfold fitHeight; positivity
+  have hℓ := (fit_width_pos hs hm).le
+  have hℓ1 := fit_width_le hs hm
+  have hX := fit_scaledX hs w hm
+  have hwr := (Complex.abs_re_le_norm w).trans hw1
+  let A := connectorEntry (fitHeight m) (fitRadius m) (fitX s w m) (fitY s w m)
+  by_cases hA : z.re ≤ A
+  · have hb := lowConnector_normal_re_bounds hH (by linarith : 0 < fitRadius m) hx hz
+    have hlo := mul_le_mul_of_nonneg_left hb.1 hℓ
+    have hhi := mul_le_mul_of_nonneg_left hb.2 hℓ
+    change -2 ≤ ((ribbonWidth (halfHeight s) m : ℂ) *
+      normalRibbon (completeSpine m _ _ _ _) (completeTangent m _ _ _ _) z).re ∧
+      ((ribbonWidth (halfHeight s) m : ℂ) *
+      normalRibbon (completeSpine m _ _ _ _) (completeTangent m _ _ _ _) z).re ≤ 2
+    rw [complete_normal_of_le m _ _ _ _ hA]
+    simp only [Complex.mul_re, Complex.ofReal_re, Complex.ofReal_im, zero_mul, sub_zero]
+    constructor <;> nlinarith
+  · have hz' : 0 ≤ (z - (A : ℂ)).re ∧ |(z - (A : ℂ)).im| ≤ 1 := by
+      simp only [Complex.sub_re, Complex.sub_im, Complex.ofReal_re, Complex.ofReal_im, sub_zero]
+      exact ⟨by linarith, hz.2⟩
+    have hlo := mul_le_mul_of_nonneg_left (array_normal_re_lower hm hz') hℓ
+    have hhi := mul_le_mul_of_nonneg_left (array_normal_re_upper hm hz') hℓ
+    have hcenter := congrArg Complex.re (fit_scaled_arrayCenter hs w hm)
+    simp only [Complex.mul_re, Complex.ofReal_re, Complex.ofReal_im, zero_mul, sub_zero,
+      positiveCenter, Complex.add_re, Complex.mul_re, Complex.I_re, Complex.I_im,
+      mul_zero, sub_zero, add_zero] at hcenter
+    have hmℓ := fit_width_mul hs hm
+    change -2 ≤ ((ribbonWidth (halfHeight s) m : ℂ) *
+      normalRibbon (completeSpine m _ _ _ _) (completeTangent m _ _ _ _) z).re ∧
+      ((ribbonWidth (halfHeight s) m : ℂ) *
+      normalRibbon (completeSpine m _ _ _ _) (completeTangent m _ _ _ _) z).re ≤ 2
+    rw [complete_normal_of_gt m _ _ _ _ (lt_of_not_ge hA)]
+    simp only [Complex.mul_re, Complex.ofReal_re, Complex.ofReal_im, zero_mul, sub_zero,
+      Complex.add_re]
+    dsimp only [A] at hlo hhi
+    constructor <;> nlinarith [abs_nonneg w.re]
+
+end SLEExactGauge.Serpentine
+
+end
+
+end OAI
diff --git a/lean/OAI/Probability/SLE/Gauge/SerpentineFiniteHeight.lean b/lean/OAI/Probability/SLE/Gauge/SerpentineFiniteHeight.lean
new file mode 100644
index 0000000000000000000000000000000000000000..2d2d5101af9a5fc2e08f900659376a67ba8480bd
--- /dev/null
+++ b/lean/OAI/Probability/SLE/Gauge/SerpentineFiniteHeight.lean
@@ -0,0 +1,122 @@
+import OAI.Probability.SLE.Gauge.SerpentineTerminalGuide
+
+namespace OAI
+
+/-! Every point in the finite experiment, before its final integer front,
+is below the height used to attach the marked hook. -/
+
+noncomputable section
+open Set Metric
+
+namespace SLEExactGauge.Serpentine
+open RibbonCoordinates
+
+lemma array_normal_im_upper_before_end {m : ℕ} (hm : 0 < m) {z : ℂ}
+    (hz : 0 ≤ z.re ∧ |z.im| ≤ 1) (hze : z.re ≤ arrayEnd m (2 * m) + 1) :
+    (normalRibbon (arraySpine m (2 * m)) (arrayTangent m (2 * m)) z).im ≤ 401 * m := by
+  have hh : (0 : ℝ) < 100 * m := by positivity
+  by_cases he : z.re ≤ arrayEnd m (2 * m)
+  · rcases array_pieces m (2 * m) ⟨hz.1, he⟩ with ⟨i, hi, u, hu, _, hs, hT⟩ |
+      ⟨i, hi, u, hu, _, hs, hT⟩
+    · simp only [normalRibbon]
+      rw [hs, hT, normal_straight_eq hm]
+      have hb := columnPoint_bound hh hm hi 0 (straight_height_bound m i hu) hz.2
+      rw [dist_zero_right] at hb
+      exact (Complex.im_le_norm _).trans (by linarith)
+    · simp only [normalRibbon]
+      rw [hs, hT, normal_circular_eq hm]
+      have hb := turnPoint_bound hh hm (show i + 1 ≤ 2 * m by omega) 0 (u / 50) hz.2
+      rw [dist_zero_right] at hb
+      exact (Complex.im_le_norm _).trans (by linarith)
+  · have hE : columnEntry 0 m (2 * m) ≤ z.re := by
+      have h := lt_of_not_ge he
+      dsimp only [arrayEnd] at h
+      linarith [Nat.cast_nonneg (α := ℝ) m]
+    have ht := array_normal_terminal hm (a := z.im) hE
+    rw [Complex.re_add_im z] at ht
+    rw [ht, columnPoint_im]
+    have hmr : (1 : ℝ) ≤ m := by exact_mod_cast hm
+    dsimp only [arrayEnd] at hze
+    simp only [Complex.zero_im, zero_add]
+    linarith
+
+lemma lowConnector_im_mono {r X : ℝ} (hr : 0 < r) (hX : 2 * r < X) (H : ℝ) :
+    Monotone (fun t => (lowConnector H r X t).im) :=
+  monotone_of_hasDerivAt_nonneg
+    (fun t => Complex.imCLM.hasFDerivAt.comp_hasDerivAt t (lowConnector_hasDerivAt hr hX t))
+    (fun t => (lowConnectorTangent_nonneg (H := H) hr hX t).2)
+
+lemma physicalFitChart_before_entry_height {s : ℝ} (hs : 0 < s) (w : ℂ) (hw : s ≤ w.im)
+    {m : ℕ} (hm : 0 < m) {z : ℂ} (ha : |z.im| ≤ 1) (hz : z.re ≤ fitEntry s w m) :
+    (physicalFitChart s w m z).im ≤ w.im := by
+  obtain ⟨hr, hx, hy, _⟩ := fit_parameters hs w hw hm
+  have hA4 : connectorFourth (fitHeight m) (fitRadius m) (fitX s w m) < fitEntry s w m := by
+    unfold fitEntry connectorEntry
+    linarith [Nat.cast_nonneg (α := ℝ) m]
+  have hcenter := lowConnector_im_mono (by linarith : 0 < fitRadius m) hx (fitHeight m) hz
+  dsimp only at hcenter
+  rw [(lowConnector_after hA4).1] at hcenter
+  simp only [connectorTail, Complex.add_im, Complex.mul_im, Complex.ofReal_re,
+    Complex.ofReal_im, Complex.I_re, Complex.I_im, mul_one, mul_zero, zero_add] at hcenter
+  have hAeq : fitHeight m + 2 * fitRadius m +
+      (fitEntry s w m - connectorFourth (fitHeight m) (fitRadius m) (fitX s w m)) = fitY s w m := by
+    unfold fitEntry connectorEntry
+    ring
+  rw [hAeq] at hcenter
+  have hnormal : (normalRibbon (lowConnector (fitHeight m) (fitRadius m) (fitX s w m))
+      (lowConnectorTangent (fitHeight m) (fitRadius m) (fitX s w m)) z).im ≤ fitY s w m + 1 := by
+    have hb : ‖normalRibbon (lowConnector (fitHeight m) (fitRadius m) (fitX s w m))
+      (lowConnectorTangent (fitHeight m) (fitRadius m) (fitX s w m)) z -
+        lowConnector (fitHeight m) (fitRadius m) (fitX s w m) z.re‖ ≤ 1 := by
+      simp only [normalRibbon, add_sub_cancel_left, norm_mul, Complex.norm_real,
+        Real.norm_eq_abs, Complex.norm_I, lowConnectorTangent_norm, mul_one]
+      exact ha
+    have hi := (Complex.abs_im_le_norm _).trans hb
+    rw [Complex.sub_im] at hi
+    linarith [le_abs_self ((normalRibbon (lowConnector (fitHeight m) (fitRadius m) (fitX s w m))
+      (lowConnectorTangent (fitHeight m) (fitRadius m) (fitX s w m)) z).im -
+        (lowConnector (fitHeight m) (fitRadius m) (fitX s w m) z.re).im)]
+  have hh := mul_le_mul_of_nonneg_left hnormal (fit_width_pos hs hm).le
+  have hY := fit_scaledY hs w hm
+  have hwidth := fit_width_le hs hm
+  change ((ribbonWidth (halfHeight s) m : ℂ) *
+    normalRibbon (completeSpine m _ _ _ _) (completeTangent m _ _ _ _) z).im ≤ _
+  rw [complete_normal_of_le m _ _ _ _ hz]
+  simp only [Complex.mul_im, Complex.ofReal_re, Complex.ofReal_im, zero_mul, add_zero]
+  nlinarith
+
+lemma physicalFitChart_finite_height_lt_two {s : ℝ} (hs : 0 < s) (hs1 : s ≤ 1)
+    (w : ℂ) (hw : s ≤ w.im) (hw1 : ‖w‖ ≤ 1) {m : ℕ} (hm : 0 < m)
+    {z : ℂ} (hz : z ∈ closedRibbon) (hzK : z.re ≤ fitCompletion s w m) :
+    (physicalFitChart s w m z).im < 2 := by
+  have hwi := (Complex.im_le_norm w).trans hw1
+  by_cases hA : z.re ≤ fitEntry s w m
+  · exact (physicalFitChart_before_entry_height hs w hw hm hz.2 hA).trans_lt (by linarith)
+  · have hz' : 0 ≤ (z - (fitEntry s w m : ℂ)).re ∧
+        |(z - (fitEntry s w m : ℂ)).im| ≤ 1 := by
+      simp only [Complex.sub_re, Complex.sub_im, Complex.ofReal_re, Complex.ofReal_im, sub_zero]
+      exact ⟨by linarith, hz.2⟩
+    have hze : (z - (fitEntry s w m : ℂ)).re ≤ arrayEnd m (2 * m) + 1 := by
+      have hh := (fitCompletion_bounds hs w hw hm).2
+      simp only [Complex.sub_re, Complex.ofReal_re, arrayEnd]
+      linarith
+    have hb := mul_le_mul_of_nonneg_left (array_normal_im_upper_before_end hm hz' hze)
+      (fit_width_pos hs hm).le
+    have hmℓ := fit_width_mul hs hm
+    have hcenter := congrArg Complex.im (fit_scaled_arrayCenter hs w hm)
+    simp only [Complex.mul_im, Complex.ofReal_re, Complex.ofReal_im, zero_mul, add_zero,
+      positiveCenter, Complex.add_im, Complex.mul_im, Complex.I_re, Complex.I_im,
+      mul_one, mul_zero, zero_add] at hcenter
+    change ((ribbonWidth (halfHeight s) m : ℂ) *
+      normalRibbon (completeSpine m _ _ _ _) (completeTangent m _ _ _ _) z).im < _
+    rw [complete_normal_of_gt m _ _ _ _ (lt_of_not_ge hA)]
+    simp only [Complex.mul_im, Complex.ofReal_re, Complex.ofReal_im, zero_mul, add_zero,
+      Complex.add_im]
+    unfold fitEntry at hb
+    nlinarith
+
+end SLEExactGauge.Serpentine
+
+end
+
+end OAI
diff --git a/lean/OAI/Probability/SLE/Gauge/SerpentineFittedChart.lean b/lean/OAI/Probability/SLE/Gauge/SerpentineFittedChart.lean
new file mode 100644
index 0000000000000000000000000000000000000000..d6ff403152a56a56e4490bf1cbd737eb65d29f86
--- /dev/null
+++ b/lean/OAI/Probability/SLE/Gauge/SerpentineFittedChart.lean
@@ -0,0 +1,100 @@
+import OAI.Probability.SLE.Gauge.SerpentineParameters
+import OAI.Probability.SLE.Gauge.SerpentineUpperHalfPlane
+import OAI.Probability.SLE.Gauge.SerpentineRetainedStrips
+
+namespace OAI
+
+/-! The concrete normalized chart, with the universal local constants
+used by the ribbon iteration. The physical width is recorded separately. -/
+
+noncomputable section
+open Set Metric
+open scoped NNReal
+
+namespace SLEExactGauge.Serpentine
+open RibbonCoordinates
+
+def fitSpine (s : ℝ) (w : ℂ) (m : ℕ) : ℝ → ℂ :=
+  completeSpine m (fitHeight m) (fitRadius m) (fitX s w m) (fitY s w m)
+
+def fitTangent (s : ℝ) (w : ℂ) (m : ℕ) : ℝ → ℂ :=
+  completeTangent m (fitHeight m) (fitRadius m) (fitX s w m) (fitY s w m)
+
+def fitChart (s : ℝ) (w : ℂ) (m : ℕ) : ℂ → ℂ :=
+  normalRibbon (fitSpine s w m) (fitTangent s w m)
+
+def positiveCenter (s : ℝ) (w : ℂ) : ℂ :=
+  ((|w.re| + s / 4 : ℝ) : ℂ) + (w.im : ℂ) * Complex.I
+
+lemma fitChart_continuous {s : ℝ} (hs : 0 < s) (w : ℂ) (hw : s ≤ w.im)
+    {m : ℕ} (hm : 0 < m) : Continuous (fitChart s w m) := by
+  obtain ⟨hr, hx, hy, _⟩ := fit_parameters hs w hw hm
+  exact complete_normal_continuous m hr hx (by linarith [Nat.cast_nonneg (α := ℝ) m])
+
+lemma fitChart_injective {s : ℝ} (hs : 0 < s) (w : ℂ) (hw : s ≤ w.im)
+    {m : ℕ} (hm : 0 < m) : InjOn (fitChart s w m) closedRibbon := by
+  obtain ⟨hr, hx, hy, _⟩ := fit_parameters hs w hw hm
+  exact complete_normal_injective hm hr hx hy
+
+lemma fitChart_patch_bounds {s : ℝ} (hs : 0 < s) (w : ℂ) (hw : s ≤ w.im)
+    {m : ℕ} (hm : 0 < m) (k : ℝ) :
+    LipschitzOnWith 2 (fitChart s w m) (ribbonStepPatch k) ∧
+      ∀ z ∈ ribbonStepPatch k, ∀ z' ∈ ribbonStepPatch k,
+        dist z z' ≤ 2 * dist (fitChart s w m z) (fitChart s w m z') := by
+  obtain ⟨hr, hx, hy, _⟩ := fit_parameters hs w hw hm
+  exact complete_normal_patch_bounds m hr hx (by linarith [Nat.cast_nonneg (α := ℝ) m]) k
+
+lemma fitChart_upper {s : ℝ} (hs : 0 < s) (w : ℂ) (hw : s ≤ w.im)
+    {m : ℕ} (hm : 0 < m) :
+    ∀ z ∈ closedRibbon, 0 < z.re → fitChart s w m z ∈ upperHalfPlane := by
+  obtain ⟨hr, hx, hy, hH⟩ := fit_parameters hs w hw hm
+  intro z hz hz0
+  exact complete_normal_upper hm (by linarith) (by linarith) hx
+    (by linarith [Nat.cast_nonneg (α := ℝ) m]) hz0 hz.2
+
+lemma fitChart_initial {s : ℝ} (hs : 0 < s) (w : ℂ) (hw : s ≤ w.im)
+    {m : ℕ} (hm : 0 < m) {z : ℂ} (hz : z.re ≤ fitHeight m) :
+    fitChart s w m z = Complex.I * z := by
+  obtain ⟨hr, hx, _, _⟩ := fit_parameters hs w hw hm
+  have hA := fit_entry_lower hs w hw hm
+  change normalRibbon (completeSpine m (fitHeight m) (fitRadius m) (fitX s w m) (fitY s w m))
+    (completeTangent m (fitHeight m) (fitRadius m) (fitX s w m) (fitY s w m)) z = _
+  rw [complete_normal_of_le m _ _ _ _ (hz.trans hA)]
+  obtain ⟨hσ, hT⟩ := lowConnector_initial (by linarith : 0 < fitRadius m) hx hz
+  rw [normalRibbon, hσ, hT]
+  apply Complex.ext <;>
+    simp only [Complex.add_re, Complex.add_im, Complex.mul_re, Complex.mul_im,
+      Complex.ofReal_re, Complex.ofReal_im, Complex.I_re, Complex.I_im] <;> ring
+
+lemma fitChart_width (s : ℝ) (w : ℂ) (m : ℕ) {z : ℂ} (hz : z ∈ closedRibbon) :
+    ‖fitChart s w m z - fitSpine s w m z.re‖ ≤ 1 :=
+  complete_normal_width m _ _ _ _ hz.2
+
+lemma fitSpine_eventually_ray (s : ℝ) (w : ℂ) (m : ℕ) :
+    ∃ T : ℝ, 0 ≤ T ∧ ∀ t : ℝ, T ≤ t →
+      fitSpine s w m t = fitSpine s w m T + ((t - T : ℝ) : ℂ) * Complex.I :=
+  complete_eventually_ray m _ _ _ _
+
+lemma fit_scaled_arrayCenter {s : ℝ} (hs : 0 < s) (w : ℂ) {m : ℕ} (hm : 0 < m) :
+    (ribbonWidth (halfHeight s) m : ℂ) * arrayCenter m (fitX s w m) (fitY s w m) =
+      positiveCenter s w := by
+  have hℓ := (fit_width_pos hs hm).ne'
+  have hmul := fit_width_mul hs hm
+  apply Complex.ext <;>
+    simp only [arrayCenter, positiveCenter, Complex.add_re, Complex.add_im,
+      Complex.mul_re, Complex.mul_im, Complex.ofReal_re, Complex.ofReal_im,
+      Complex.I_re, Complex.I_im, mul_zero, mul_one, sub_zero, add_zero, zero_add]
+  · unfold fitX
+    rw [mul_add, mul_div_cancel₀ _ hℓ]
+    unfold halfHeight at *
+    nlinarith
+  · unfold fitY
+    rw [mul_add, mul_div_cancel₀ _ hℓ]
+    unfold halfHeight at *
+    nlinarith
+
+end SLEExactGauge.Serpentine
+
+end
+
+end OAI
diff --git a/lean/OAI/Probability/SLE/Gauge/SerpentineFittedRegion.lean b/lean/OAI/Probability/SLE/Gauge/SerpentineFittedRegion.lean
new file mode 100644
index 0000000000000000000000000000000000000000..581f236546975789a689e8b42793b52bfb18bfe3
--- /dev/null
+++ b/lean/OAI/Probability/SLE/Gauge/SerpentineFittedRegion.lean
@@ -0,0 +1,78 @@
+import OAI.Probability.SLE.Gauge.SerpentineFittedChart
+import OAI.Probability.SLE.Gauge.SerpentineArrayRegion
+
+namespace OAI
+
+/-! The retained integer strips lie in the prescribed displaced disk
+after multiplication by the physical width. -/
+
+noncomputable section
+open Set Metric
+
+namespace SLEExactGauge.Serpentine
+
+def physicalFitChart (s : ℝ) (w : ℂ) (m : ℕ) (z : ℂ) : ℂ :=
+  (ribbonWidth (halfHeight s) m : ℂ) * fitChart s w m z
+
+lemma fitChart_retained_distance {s : ℝ} (hs : 0 < s) (w : ℂ) (hw : s ≤ w.im)
+    {m j i : ℕ} (hm : 0 < m) (hj : j < m) (hi : i < m) {z : ℂ}
+    (hz : z.re ∈ Icc
+      ((retainedStep (connectorEntry (fitHeight m) (fitRadius m) (fitX s w m) (fitY s w m)) m j i : ℝ) + 1 / 3)
+      ((retainedStep (connectorEntry (fitHeight m) (fitRadius m) (fitX s w m) (fitY s w m)) m j i : ℝ) + 2 / 3))
+    (ha : |z.im| ≤ 1) :
+    dist (fitChart s w m z) (arrayCenter m (fitX s w m) (fitY s w m)) ≤ 300 * m := by
+  have hA : 0 ≤ connectorEntry (fitHeight m) (fitRadius m) (fitX s w m) (fitY s w m) :=
+    (by unfold fitHeight; positivity : (0 : ℝ) ≤ fitHeight m).trans (fit_entry_lower hs w hw hm)
+  have hmid := retained_middle_in_straight hA hi hz
+  have he : columnEntry (connectorEntry (fitHeight m) (fitRadius m) (fitX s w m) (fitY s w m)) m j =
+      connectorEntry (fitHeight m) (fitRadius m) (fitX s w m) (fitY s w m) + columnEntry 0 m j := by
+    unfold columnEntry
+    ring
+  rw [he] at hmid
+  have hu : z.re - connectorEntry (fitHeight m) (fitRadius m) (fitX s w m) (fitY s w m) -
+      columnEntry 0 m j ∈ Icc (0 : ℝ) (200 * m) := ⟨by linarith [hmid.1], by linarith [hmid.2]⟩
+  unfold fitChart fitSpine fitTangent
+  rw [retained_strip_on_column hm hj hi _ _ _ _ hA hz, dist_self_add_left]
+  have hb := columnPoint_bound (j := j) (by positivity : (0 : ℝ) < 100 * m) hm (by omega) 0
+      (straight_height_bound m j hu) ha
+  rw [dist_zero_right] at hb
+  linarith
+
+lemma physicalFitChart_retained_distance {s : ℝ} (hs : 0 < s) (w : ℂ) (hw : s ≤ w.im)
+    {m j i : ℕ} (hm : 0 < m) (hj : j < m) (hi : i < m) {z : ℂ}
+    (hz : z.re ∈ Icc
+      ((retainedStep (connectorEntry (fitHeight m) (fitRadius m) (fitX s w m) (fitY s w m)) m j i : ℝ) + 1 / 3)
+      ((retainedStep (connectorEntry (fitHeight m) (fitRadius m) (fitX s w m) (fitY s w m)) m j i : ℝ) + 2 / 3))
+    (ha : |z.im| ≤ 1) :
+    dist (physicalFitChart s w m z) (positiveCenter s w) ≤ 3 * s / 200 := by
+  have hd := fitChart_retained_distance hs w hw hm hj hi hz ha
+  have hℓ := fit_width_pos hs hm
+  have hmul := fit_width_mul hs hm
+  rw [physicalFitChart, ← fit_scaled_arrayCenter hs w hm, dist_eq_norm, ← mul_sub, norm_mul,
+    Complex.norm_real, Real.norm_eq_abs, abs_of_pos hℓ]
+  have h := mul_le_mul_of_nonneg_left hd hℓ.le
+  rw [dist_eq_norm] at h
+  nlinarith
+
+lemma positiveCenter_eq_center {s : ℝ} {w : ℂ} (hw : 0 ≤ w.re) :
+    positiveCenter s w = center s w := by
+  apply Complex.ext <;>
+    simp [positiveCenter, center, displacementSign, hw, abs_of_nonneg hw]
+
+lemma physicalFitChart_retained_disk {s : ℝ} (hs : 0 < s) (w : ℂ) (hw : s ≤ w.im)
+    (hwr : 0 ≤ w.re) {m j i : ℕ} (hm : 0 < m) (hj : j < m) (hi : i < m) {z : ℂ}
+    (hz : z.re ∈ Icc
+      ((retainedStep (connectorEntry (fitHeight m) (fitRadius m) (fitX s w m) (fitY s w m)) m j i : ℝ) + 1 / 3)
+      ((retainedStep (connectorEntry (fitHeight m) (fitRadius m) (fitX s w m) (fitY s w m)) m j i : ℝ) + 2 / 3))
+    (ha : |z.im| ≤ 1) :
+    physicalFitChart s w m z ∈ closedBall (center s w) (s / 20) := by
+  have hd := physicalFitChart_retained_distance hs w hw hm hj hi hz ha
+  rw [positiveCenter_eq_center hwr] at hd
+  change dist _ _ ≤ _
+  linarith
+
+end SLEExactGauge.Serpentine
+
+end
+
+end OAI
diff --git a/lean/OAI/Probability/SLE/Gauge/SerpentineFittedShadow.lean b/lean/OAI/Probability/SLE/Gauge/SerpentineFittedShadow.lean
new file mode 100644
index 0000000000000000000000000000000000000000..1e13aa1d121f454849d4183ed481c8f543dcccfe
--- /dev/null
+++ b/lean/OAI/Probability/SLE/Gauge/SerpentineFittedShadow.lean
@@ -0,0 +1,108 @@
+import OAI.Probability.SLE.Gauge.SerpentineFittedRegion
+
+namespace OAI
+
+/-! The complete fitted ribbon avoids a fixed upward shadow of the
+marked point, including the connector and the infinite final tail. -/
+
+noncomputable section
+open Set Metric
+
+namespace SLEExactGauge.Serpentine
+
+lemma fit_width_le {s : ℝ} (hs : 0 < s) {m : ℕ} (hm : 0 < m) :
+    ribbonWidth (halfHeight s) m ≤ s / 20000 := by
+  have hmul := fit_width_mul hs hm
+  have hp := (fit_width_pos hs hm).le
+  have hm' : (1 : ℝ) ≤ m := by exact_mod_cast hm
+  nlinarith
+
+lemma fit_scaledX {s : ℝ} (hs : 0 < s) (w : ℂ) {m : ℕ} (hm : 0 < m) :
+    ribbonWidth (halfHeight s) m * fitX s w m = |w.re| + s / 4 - s / 200 := by
+  unfold fitX halfHeight
+  exact mul_div_cancel₀ _ (fit_width_pos hs hm).ne'
+
+lemma physicalFitChart_low {s : ℝ} (hs : 0 < s) (w : ℂ) (hw : s ≤ w.im)
+    {m : ℕ} (hm : 0 < m) {z : ℂ} (ha : |z.im| ≤ 1)
+    (hz : z.re ≤ connectorFourth (fitHeight m) (fitRadius m) (fitX s w m)) :
+    (physicalFitChart s w m z).im ≤ s / 2 := by
+  obtain ⟨hr, hx, hy, _⟩ := fit_parameters hs w hw hm
+  have hA : z.re ≤ connectorEntry (fitHeight m) (fitRadius m) (fitX s w m) (fitY s w m) := by
+    have hY : fitHeight m + 2 * fitRadius m < fitY s w m := by
+      linarith [Nat.cast_nonneg (α := ℝ) m]
+    unfold connectorEntry
+    linarith
+  have hlow := lowConnector_normal_im_upper (by linarith : 1 < fitRadius m) hx hz ha
+  have hℓ := (fit_width_pos hs hm).le
+  have hmul := fit_width_mul hs hm
+  have hle := fit_width_le hs hm
+  have hscaled := mul_le_mul_of_nonneg_left hlow hℓ
+  change ((ribbonWidth (halfHeight s) m : ℂ) *
+    normalRibbon (completeSpine m _ _ _ _) (completeTangent m _ _ _ _) z).im ≤ _
+  rw [complete_normal_of_le m _ _ _ _ hA]
+  simp only [Complex.mul_im, Complex.ofReal_re, Complex.ofReal_im, zero_mul, add_zero]
+  dsimp only [fitHeight, fitRadius] at hscaled ⊢
+  nlinarith
+
+lemma physicalFitChart_tail_right {s : ℝ} (hs : 0 < s) (w : ℂ) (_hw : s ≤ w.im)
+    {m : ℕ} (hm : 0 < m) {z : ℂ} (ha : |z.im| ≤ 1)
+    (hz : connectorFourth (fitHeight m) (fitRadius m) (fitX s w m) < z.re)
+    (hA : z.re ≤ connectorEntry (fitHeight m) (fitRadius m) (fitX s w m) (fitY s w m)) :
+    s / 5 ≤ (physicalFitChart s w m z).re - |w.re| := by
+  have hℓ := (fit_width_pos hs hm).le
+  have hx := fit_scaledX hs w hm
+  have hle := fit_width_le hs hm
+  have hza := mul_le_mul_of_nonneg_left (abs_le.mp ha).2 hℓ
+  change ((ribbonWidth (halfHeight s) m : ℂ) *
+    normalRibbon (completeSpine m _ _ _ _) (completeTangent m _ _ _ _) z).re - _ ≥ _
+  rw [complete_normal_of_le m _ _ _ _ hA, normalRibbon,
+    (lowConnector_after hz).1, (lowConnector_after hz).2]
+  simp only [connectorTail, Complex.mul_re, Complex.mul_im, Complex.add_re, Complex.add_im,
+    Complex.ofReal_re, Complex.ofReal_im, Complex.I_re, Complex.I_im,
+    mul_zero, zero_mul, mul_one, sub_zero, add_zero, zero_add]
+  nlinarith
+
+lemma physicalFitChart_array_right {s : ℝ} (hs : 0 < s) (w : ℂ)
+    {m : ℕ} (hm : 0 < m) {z : ℂ} (ha : |z.im| ≤ 1)
+    (hA : connectorEntry (fitHeight m) (fitRadius m) (fitX s w m) (fitY s w m) < z.re) :
+    s / 5 ≤ (physicalFitChart s w m z).re - |w.re| := by
+  have hℓ := (fit_width_pos hs hm).le
+  have hmul := fit_width_mul hs hm
+  let A := connectorEntry (fitHeight m) (fitRadius m) (fitX s w m) (fitY s w m)
+  have hz' : 0 ≤ (z - (A : ℂ)).re ∧ |(z - (A : ℂ)).im| ≤ 1 := by
+    simp only [Complex.sub_re, Complex.sub_im, Complex.ofReal_re, Complex.ofReal_im, sub_zero]
+    exact ⟨by dsimp [A]; linarith, ha⟩
+  have hbound := mul_le_mul_of_nonneg_left (array_normal_re_lower hm hz') hℓ
+  have hcenter := congrArg Complex.re (fit_scaled_arrayCenter hs w hm)
+  simp only [Complex.mul_re, Complex.ofReal_re, Complex.ofReal_im, zero_mul, sub_zero,
+    positiveCenter, Complex.add_re, Complex.mul_re, Complex.I_re, Complex.I_im,
+    mul_zero, sub_zero, add_zero] at hcenter
+  change ((ribbonWidth (halfHeight s) m : ℂ) *
+    normalRibbon (completeSpine m _ _ _ _) (completeTangent m _ _ _ _) z).re - _ ≥ _
+  rw [complete_normal_of_gt m _ _ _ _ hA]
+  simp only [Complex.mul_re, Complex.ofReal_re, Complex.ofReal_im, zero_mul, sub_zero,
+    Complex.add_re]
+  dsimp [A] at hbound
+  nlinarith
+
+theorem physicalFitChart_avoids_shadow {s : ℝ} (hs : 0 < s) (w : ℂ) (hw : s ≤ w.im)
+    {m : ℕ} (hm : 0 < m) {z : ℂ} (ha : |z.im| ≤ 1) :
+    ¬ (abs ((physicalFitChart s w m z).re - |w.re|) < s / 100 ∧
+      w.im - s / 100 < (physicalFitChart s w m z).im) := by
+  intro h
+  by_cases h4 : z.re ≤ connectorFourth (fitHeight m) (fitRadius m) (fitX s w m)
+  · have hh := physicalFitChart_low hs w hw hm ha h4
+    linarith [h.2]
+  · by_cases hA : z.re ≤ connectorEntry (fitHeight m) (fitRadius m) (fitX s w m) (fitY s w m)
+    · have hh := physicalFitChart_tail_right hs w hw hm ha (lt_of_not_ge h4) hA
+      have hl := le_abs_self ((physicalFitChart s w m z).re - |w.re|)
+      linarith [h.1]
+    · have hh := physicalFitChart_array_right hs w hm ha (lt_of_not_ge hA)
+      have hl := le_abs_self ((physicalFitChart s w m z).re - |w.re|)
+      linarith [h.1]
+
+end SLEExactGauge.Serpentine
+
+end
+
+end OAI
diff --git a/lean/OAI/Probability/SLE/Gauge/SerpentineHorizontalBound.lean b/lean/OAI/Probability/SLE/Gauge/SerpentineHorizontalBound.lean
new file mode 100644
index 0000000000000000000000000000000000000000..f75706b71314cc62e7fe8b183b29cd5bb30aad1e
--- /dev/null
+++ b/lean/OAI/Probability/SLE/Gauge/SerpentineHorizontalBound.lean
@@ -0,0 +1,85 @@
+import OAI.Probability.SLE.Gauge.SerpentineExperimentGeometry
+
+namespace OAI
+
+/-! The whole completed physical ribbon stays between the exterior
+vertical lines x=-2 and x=2. -/
+
+noncomputable section
+open Set Metric
+
+namespace SLEExactGauge.Serpentine
+
+lemma array_normal_re_upper {m : ℕ} (hm : 0 < m) {z : ℂ}
+    (hz : 0 ≤ z.re ∧ |z.im| ≤ 1) :
+    (normalRibbon (arraySpine m (2 * m)) (arrayTangent m (2 * m)) z).re ≤ 400 * m := by
+  have hh : (0 : ℝ) < 100 * m := by positivity
+  by_cases he : z.re ≤ arrayEnd m (2 * m)
+  · rcases array_pieces m (2 * m) ⟨hz.1, he⟩ with ⟨i, hi, u, hu, _, hs, hT⟩ |
+      ⟨i, hi, u, hu, _, hs, hT⟩
+    · simp only [normalRibbon]
+      rw [hs, hT, normal_straight_eq hm]
+      have hb := columnPoint_bound hh hm hi 0 (straight_height_bound m i hu) hz.2
+      rw [dist_zero_right] at hb
+      have hi := Complex.re_le_norm (columnPoint 0 (100 * m) m i (side i * (-100 * m + u)) z.im)
+      linarith
+    · simp only [normalRibbon]
+      rw [hs, hT, normal_circular_eq hm]
+      have hb := turnPoint_bound hh hm (show i + 1 ≤ 2 * m by omega) 0 (u / 50) hz.2
+      rw [dist_zero_right] at hb
+      exact (Complex.re_le_norm _).trans (by linarith)
+  · have hE : columnEntry 0 m (2 * m) ≤ z.re := by
+      have h := lt_of_not_ge he
+      dsimp only [arrayEnd] at h
+      linarith [Nat.cast_nonneg (α := ℝ) m]
+    have ht := array_normal_terminal hm (a := z.im) hE
+    rw [Complex.re_add_im z] at ht
+    rw [ht, columnPoint_re]
+    simp only [columnOffset, normalized_spacing hm, normalized_width hm, side_even,
+      one_mul, Complex.zero_re, zero_add, Nat.cast_mul, Nat.cast_ofNat]
+    have hm' : (1 : ℝ) ≤ m := by exact_mod_cast hm
+    linarith [(abs_le.mp hz.2).1]
+
+lemma lowConnector_re_bounds {H r X : ℝ} (hH : 0 ≤ H) (hr : 0 < r) (hX : 2 * r < X)
+    {t : ℝ} (ht : 0 ≤ t) :
+    0 ≤ (lowConnector H r X t).re ∧ (lowConnector H r X t).re ≤ X := by
+  have hmono : Monotone (fun t => (lowConnector H r X t).re) :=
+    monotone_of_hasDerivAt_nonneg
+      (fun t => Complex.reCLM.hasFDerivAt.comp_hasDerivAt t (lowConnector_hasDerivAt hr hX t))
+      (fun t => (lowConnectorTangent_nonneg (H := H) hr hX t).1)
+  have hzero := hmono ht
+  dsimp only at hzero
+  rw [(lowConnector_initial hr hX hH).1] at hzero
+  simp only [Complex.ofReal_zero, zero_mul, Complex.zero_re] at hzero
+  let u := max t (connectorFourth H r X + 1)
+  have hu : connectorFourth H r X < u := by
+    have h := le_max_right t (connectorFourth H r X + 1)
+    dsimp only [u]
+    linarith
+  have hup := hmono (le_max_left t (connectorFourth H r X + 1))
+  dsimp only at hup
+  rw [(lowConnector_after hu).1] at hup
+  have hup' : (lowConnector H r X t).re ≤ X := by
+    simpa only [connectorTail, Complex.add_re, Complex.mul_re, Complex.ofReal_re,
+      Complex.ofReal_im, Complex.I_re, Complex.I_im, mul_zero, zero_mul, sub_zero, add_zero] using hup
+  exact ⟨hzero, hup'⟩
+
+lemma lowConnector_normal_re_bounds {H r X : ℝ} (hH : 0 ≤ H) (hr : 0 < r) (hX : 2 * r < X)
+    {z : ℂ} (hz : 0 ≤ z.re ∧ |z.im| ≤ 1) :
+    -1 ≤ (normalRibbon (lowConnector H r X) (lowConnectorTangent H r X) z).re ∧
+      (normalRibbon (lowConnector H r X) (lowConnectorTangent H r X) z).re ≤ X + 1 := by
+  have hcenter := lowConnector_re_bounds hH hr hX hz.1
+  have hdist : ‖normalRibbon (lowConnector H r X) (lowConnectorTangent H r X) z -
+      lowConnector H r X z.re‖ ≤ 1 := by
+    simp only [normalRibbon, add_sub_cancel_left, norm_mul, Complex.norm_real,
+      Real.norm_eq_abs, Complex.norm_I, lowConnectorTangent_norm, mul_one]
+    exact hz.2
+  have hab := (Complex.abs_re_le_norm _).trans hdist
+  rw [Complex.sub_re, abs_le] at hab
+  constructor <;> linarith
+
+end SLEExactGauge.Serpentine
+
+end
+
+end OAI
diff --git a/lean/OAI/Probability/SLE/Gauge/SerpentineInfiniteArray.lean b/lean/OAI/Probability/SLE/Gauge/SerpentineInfiniteArray.lean
new file mode 100644
index 0000000000000000000000000000000000000000..426b89ea6d8d09309a616691e232cea1fd0d228f
--- /dev/null
+++ b/lean/OAI/Probability/SLE/Gauge/SerpentineInfiniteArray.lean
@@ -0,0 +1,90 @@
+import OAI.Probability.SLE.Gauge.SerpentineArrayEmbedding
+import OAI.Probability.SLE.Gauge.SerpentineTerminal
+
+namespace OAI
+
+/-! The finite serpentine remains embedded after continuing its last
+column vertically to infinity. -/
+
+noncomputable section
+open Set Metric
+
+namespace SLEExactGauge.Serpentine
+
+lemma array_normal_terminal {m : ℕ} (hm : 0 < m) {t a : ℝ}
+    (ht : columnEntry 0 m (2 * m) ≤ t) :
+    normalRibbon (arraySpine m (2 * m)) (arrayTangent m (2 * m)) (t + a * Complex.I) =
+      columnPoint 0 (100 * m) m (2 * m) (-100 * m + (t - columnEntry 0 m (2 * m))) a := by
+  simp only [normalRibbon, 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, sub_zero, mul_one, zero_add, add_zero]
+  rw [arraySpine_tail m (2 * m) ht, arrayTangent_tail m (2 * m) ht, normal_straight_eq hm,
+    side_even, one_mul]
+
+lemma array_normal_finite_terminal_disjoint {m : ℕ} (hm : 0 < m) {z w : ℂ}
+    (hz : z.re ∈ Icc (0 : ℝ) (arrayEnd m (2 * m)) ∧ |z.im| ≤ 1)
+    (hw : arrayEnd m (2 * m) < w.re) (hwa : |w.im| ≤ 1) :
+    normalRibbon (arraySpine m (2 * m)) (arrayTangent m (2 * m)) z ≠
+      normalRibbon (arraySpine m (2 * m)) (arrayTangent m (2 * m)) w := by
+  intro he
+  have hh : (0 : ℝ) < 100 * m := by positivity
+  have hwe : columnEntry 0 m (2 * m) ≤ w.re := by
+    dsimp only [arrayEnd] at hw
+    linarith [Nat.cast_nonneg (α := ℝ) m]
+  have hwy : 100 * (m : ℝ) < -100 * m + (w.re - columnEntry 0 m (2 * m)) := by
+    dsimp only [arrayEnd] at hw
+    linarith
+  have htw := array_normal_terminal hm (a := w.im) hwe
+  rw [Complex.re_add_im w] at htw
+  rw [htw] at he
+  rcases array_pieces m (2 * m) hz.1 with ⟨i, _, u, hu, _, hs, hT⟩ |
+    ⟨i, hi, u, hu, _, hs, hT⟩
+  · simp only [normalRibbon] at he
+    rw [hs, hT, normal_straight_eq hm] at he
+    have hii := columnPoint_equal_forces_index hh hm 0 _ _ hz.2 hwa he
+    subst i
+    have hy := congrArg Complex.im he
+    simp only [columnPoint_im, side_even, one_mul] at hy
+    have hsmall := (abs_le.mp (straight_height_bound m (2 * m) hu)).2
+    rw [side_even, one_mul] at hsmall
+    linarith
+  · simp only [normalRibbon] at he
+    rw [hs, hT, normal_circular_eq hm] at he
+    exact turnPoint_terminal_column_ne hh hm hi 0 (circular_angle_bound hu) hwy hz.2 hwa he
+
+/-- The complete upward-continued array is embedded on the whole closed
+width-one normal strip. -/
+theorem array_normal_injective_infinite {m : ℕ} (hm : 0 < m) :
+    InjOn (normalRibbon (arraySpine m (2 * m)) (arrayTangent m (2 * m)))
+      {z : ℂ | 0 ≤ z.re ∧ |z.im| ≤ 1} := by
+  intro z hz w hw he
+  by_cases hzE : z.re ≤ arrayEnd m (2 * m)
+  · by_cases hwE : w.re ≤ arrayEnd m (2 * m)
+    · exact array_normal_injective hm (2 * m) ⟨⟨hz.1, hzE⟩, hz.2⟩ ⟨⟨hw.1, hwE⟩, hw.2⟩ he
+    · exact (array_normal_finite_terminal_disjoint hm ⟨⟨hz.1, hzE⟩, hz.2⟩
+        (lt_of_not_ge hwE) hw.2 he).elim
+  · by_cases hwE : w.re ≤ arrayEnd m (2 * m)
+    · exact (array_normal_finite_terminal_disjoint hm ⟨⟨hw.1, hwE⟩, hw.2⟩
+        (lt_of_not_ge hzE) hz.2 he.symm).elim
+    · have hze : columnEntry 0 m (2 * m) ≤ z.re := by
+        have h := lt_of_not_ge hzE
+        dsimp only [arrayEnd] at h
+        linarith [Nat.cast_nonneg (α := ℝ) m]
+      have hwe : columnEntry 0 m (2 * m) ≤ w.re := by
+        have h := lt_of_not_ge hwE
+        dsimp only [arrayEnd] at h
+        linarith [Nat.cast_nonneg (α := ℝ) m]
+      have htz := array_normal_terminal hm (a := z.im) hze
+      have htw := array_normal_terminal hm (a := w.im) hwe
+      rw [Complex.re_add_im z] at htz
+      rw [Complex.re_add_im w] at htw
+      rw [htz, htw] at he
+      have hh : (0 : ℝ) < 100 * m := by positivity
+      obtain ⟨hy, ha⟩ := columnPoint_injective hh hm 0 (2 * m) he
+      exact Complex.ext (by linarith) ha
+
+end SLEExactGauge.Serpentine
+
+end
+
+end OAI
diff --git a/lean/OAI/Probability/SLE/Gauge/SerpentineInitialPrefix.lean b/lean/OAI/Probability/SLE/Gauge/SerpentineInitialPrefix.lean
new file mode 100644
index 0000000000000000000000000000000000000000..f63d46ff699842fb8321481b5aa32830404aa60d
--- /dev/null
+++ b/lean/OAI/Probability/SLE/Gauge/SerpentineInitialPrefix.lean
@@ -0,0 +1,149 @@
+import OAI.Probability.SLE.Geometry.FirstHeightSupport
+import OAI.Probability.SLE.Gauge.RibbonGoodPrefix
+import OAI.Probability.SLE.Gauge.SerpentineExperimentGeometry
+
+namespace OAI
+
+/-! A single vertical support event starts every fitted serpentine at
+integer front one. Its probability is independent of the marked point
+and of the multiplicity. -/
+
+noncomputable section
+open Set Filter MeasureTheory ProbabilityTheory Metric
+open scoped Topology NNReal ENNReal unitInterval
+
+namespace SLEExactGauge.Serpentine
+open RibbonCoordinates FirstFrontPassage FirstHeightSupport
+
+def initialRiseStrip (ε : ℝ) : Set ℂ := {z | |z.re| < ε / 4}
+
+def initialRiseTarget : Set ℂ := {z | 1 < z.im}
+
+def InitialRise {Ω : Type*} (γ : Ω → ℝ≥0 → ℂ) (ε : ℝ) : Set Ω :=
+  {ω | ∃ T : ℝ≥0, 0 < T ∧ MapsTo (γ ω) (Icc 0 T) (initialRiseStrip ε) ∧
+    γ ω T ∈ initialRiseTarget}
+
+lemma initialRise_positive {Ω : Type*} [MeasurableSpace Ω] (P : Measure Ω)
+    (γ : Ω → ℝ≥0 → ℂ) (hsupport : PublishedGeometricTubeSupport P γ)
+    {ε : ℝ} (hε : 0 < ε) : 0 < P (InitialRise γ ε) := by
+  apply hsupport _ (verticalPath 4) (verticalPath_injective (by norm_num))
+  · intro t ht
+    change 0 < (verticalPath 4 t).im
+    simp only [verticalPath_apply, Complex.mul_im, Complex.ofReal_re, Complex.ofReal_im,
+      Complex.I_im, Complex.I_re, mul_one, mul_zero, add_zero]
+    have ht0 : 0 < (t : ℝ) := by
+      by_contra hn
+      exact ht (Subtype.ext (le_antisymm (le_of_not_gt hn) t.property.1))
+    linarith
+  · exact isOpen_lt Complex.continuous_re.abs continuous_const
+  · exact isOpen_lt continuous_const Complex.continuous_im
+  · rintro z ⟨t, rfl⟩
+    change |(verticalPath 4 t).re| < ε / 4
+    simpa only [verticalPath_apply, Complex.mul_re, Complex.ofReal_re, Complex.ofReal_im,
+      Complex.I_re, Complex.I_im, mul_zero, zero_mul, sub_zero, abs_zero] using
+      (show (0 : ℝ) < ε / 4 by positivity)
+  · change 1 < (((4 / 2 : ℝ) : ℂ) * Complex.I).im
+    norm_num
+
+lemma initial_prefix_coordinates (γ : ℝ≥0 → ℂ) (P : ℂ → ℂ)
+    {ε : ℝ} (hε : ε ≤ 1)
+    (hP : ∀ z ∈ closedRibbon, z.re ≤ 4 → P z = Complex.I * z)
+    {t : ℝ≥0} (hheight : 0 ≤ (γ t).im ∧ (γ t).im ≤ 1)
+    (hstrip : |(γ t).re| < ε / 4) :
+    ∃ z ∈ closedRibbon, |z.im| ≤ ε / 4 ∧ z.re = (γ t).im ∧ P z = γ t := by
+  let z := -Complex.I * γ t
+  have hzre : z.re = (γ t).im := by simp [z]
+  have hzim : z.im = -(γ t).re := by simp [z]
+  have hz : z ∈ closedRibbon := by
+    change 0 ≤ z.re ∧ |z.im| ≤ 1
+    rw [hzre, hzim, abs_neg]
+    exact ⟨hheight.1, by linarith⟩
+  refine ⟨z, hz, ?_, hzre, ?_⟩
+  · rw [hzim, abs_neg]
+    exact hstrip.le
+  · rw [hP z hz (by rw [hzre]; linarith)]
+    dsimp [z]
+    rw [← mul_assoc]
+    norm_num
+
+theorem initialRise_gives_goodPrefix
+    (γ : ℝ≥0 → ℂ) (hγ : Continuous γ) (hγ0 : γ 0 = 0)
+    (hγH : ∀ t, 0 ≤ (γ t).im)
+    (P : ℂ → ℂ) (g : C(ℂ, ℝ)) (hg : ∀ z ∈ closedRibbon, g (P z) = z.re)
+    {ε : ℝ} (hε : 0 < ε) (hε1 : ε ≤ 1)
+    (hP : ∀ z ∈ closedRibbon, z.re ≤ 4 → P z = Complex.I * z)
+    (hrise : () ∈ InitialRise (fun _ : Unit => γ) ε) :
+    () ∈ GoodRibbonPrefix (fun _ : Unit => γ)
+      (fun _ => firstFrontTime (fun t => g (γ t)) 1) P ε := by
+  obtain ⟨T, _, hstrip, htarget⟩ := hrise
+  obtain ⟨τ, _, _, hτT, hhit, hprior⟩ :=
+    exists_first_height γ hγ hγ0 zero_lt_one htarget
+  have hheight (t : ℝ≥0) (ht : t ≤ τ) : 0 ≤ (γ t).im ∧ (γ t).im ≤ 1 := by
+    refine ⟨hγH t, ?_⟩
+    rcases eq_or_lt_of_le ht with rfl | ht
+    · exact hhit.le
+    · exact (hprior t ht).le
+  have hcoord (t : ℝ≥0) (ht : t ≤ τ) := initial_prefix_coordinates γ P hε1 hP
+    (hheight t ht) (hstrip ⟨bot_le, ht.trans hτT.le⟩)
+  have hgheight (t : ℝ≥0) (ht : t ≤ τ) : g (γ t) = (γ t).im := by
+    obtain ⟨z, hz, _, hzre, he⟩ := hcoord t ht
+    exact (congrArg g he.symm).trans ((hg z hz).trans hzre)
+  have hleast : IsLeast {t : ℝ≥0 | 0 ≤ t ∧ g (γ t) - 1 ∈ ({0} : Set ℝ)} τ := by
+    refine ⟨⟨bot_le, ?_⟩, ?_⟩
+    · simp only [hgheight τ le_rfl, hhit, sub_self, mem_singleton_iff]
+    · intro t ht
+      by_contra hn
+      have htτ : t < τ := lt_of_not_ge hn
+      have he : g (γ t) = 1 := sub_eq_zero.mp ht.2
+      rw [hgheight t htτ.le] at he
+      exact (ne_of_lt (hprior t htτ)) he
+  have hfront : firstFrontTime (fun t => g (γ t)) 1 = (τ : WithTop ℝ≥0) := by
+    unfold firstFrontTime hittingAfter
+    rw [ite_eq_left ⟨τ, hleast.1⟩, hleast.csInf_eq]
+  change firstFrontTime (fun t => g (γ t)) 1 ≠ ⊤ ∧ _
+  rw [hfront]
+  refine ⟨WithTop.coe_ne_top, ?_, ?_⟩
+  · intro t ht
+    obtain ⟨z, hz, hzi, _, he⟩ := hcoord t ht.2
+    exact ⟨z, ⟨hz, hzi.trans (by linarith)⟩, he⟩
+  · obtain ⟨z, hz, hzi, _, he⟩ := hcoord τ le_rfl
+    exact ⟨z, ⟨hz, hzi⟩, he⟩
+
+/-- The same positive lower bound works for every chart which is the
+initial vertical strip, and for every global extension of its progress. -/
+theorem uniform_initial_goodPrefix_probability
+    {Ω : Type*} [MeasurableSpace Ω] (μ : Measure Ω)
+    (κ : ℝ) (γ : Ω → ℝ≥0 → ℂ) (hSLE : IsOrdinaryChordalSLE κ γ μ)
+    (hsupport : PublishedGeometricTubeSupport μ γ)
+    {ε : ℝ} (hε : 0 < ε) (hε1 : ε ≤ 1) :
+    ∃ q : ℝ≥0∞, 0 < q ∧ ∀ P : ℂ → ℂ, ∀ g : C(ℂ, ℝ),
+      (∀ z ∈ closedRibbon, g (P z) = z.re) →
+      (∀ z ∈ closedRibbon, z.re ≤ 4 → P z = Complex.I * z) →
+      q ≤ μ (GoodRibbonPrefix γ (ribbonFrontStop g γ 1) P ε) := by
+  refine ⟨μ (InitialRise γ ε), initialRise_positive μ γ hsupport hε, ?_⟩
+  intro P g hg hP
+  apply measure_mono_ae
+  obtain ⟨_, _, htrace⟩ := hSLE.2
+  filter_upwards [htrace] with ω hω
+  intro hrise
+  obtain ⟨G, F, hw⟩ := hω
+  exact initialRise_gives_goodPrefix (γ ω) hw.1 hw.2.1 hw.2.2.1 P g hg hε hε1 hP hrise
+
+theorem uniform_experiment_initial_goodPrefix_probability
+    {Ω : Type*} [MeasurableSpace Ω] (μ : Measure Ω)
+    (κ : ℝ) (γ : Ω → ℝ≥0 → ℂ) (hSLE : IsOrdinaryChordalSLE κ γ μ)
+    (hsupport : PublishedGeometricTubeSupport μ γ)
+    {ε : ℝ} (hε : 0 < ε) (hε1 : ε ≤ 1) :
+    ∃ q : ℝ≥0∞, 0 < q ∧ ∀ s : ℝ, 0 < s → ∀ w : ℂ, s ≤ w.im →
+      ∀ m : ℕ, 0 < m → ∀ g : C(ℂ, ℝ),
+        (∀ z ∈ closedRibbon, g (experimentChart s w m z) = z.re) →
+        q ≤ μ (GoodRibbonPrefix γ (ribbonFrontStop g γ 1) (experimentChart s w m) ε) := by
+  obtain ⟨q, hq, hp⟩ := uniform_initial_goodPrefix_probability μ κ γ hSLE hsupport hε hε1
+  refine ⟨q, hq, fun s hs w hw m hm g hg => ?_⟩
+  exact hp _ g hg (experimentChart_geometry hs w hw hm).2.2.2.2
+
+end SLEExactGauge.Serpentine
+
+end
+
+end OAI
diff --git a/lean/OAI/Probability/SLE/Gauge/SerpentineLayout.lean b/lean/OAI/Probability/SLE/Gauge/SerpentineLayout.lean
new file mode 100644
index 0000000000000000000000000000000000000000..257fa57b59cd9629f928e151499256105a444fed
--- /dev/null
+++ b/lean/OAI/Probability/SLE/Gauge/SerpentineLayout.lean
@@ -0,0 +1,326 @@
+import OAI.Probability.SLE.Gauge.RibbonMiddleMass
+import Mathlib.Analysis.SpecialFunctions.Trigonometric.Deriv
+
+namespace OAI
+
+/-! Explicit columns and circular turns for the dense-visit serpentine.
+The array and its normal bands fit in the displaced disk and stay a fixed
+distance from the marked point. -/
+
+noncomputable section
+open Set Filter MeasureTheory Metric
+open scoped Topology NNReal
+
+namespace SLEExactGauge.Serpentine
+
+def side (j : ℕ) : ℝ := if Even j then 1 else -1
+
+lemma side_abs (j : ℕ) : |side j| = 1 := by
+  unfold side
+  split <;> norm_num
+
+lemma side_sq (j : ℕ) : side j ^ 2 = 1 := by
+  unfold side
+  split <;> norm_num
+
+def displacementSign (w : ℂ) : ℝ := if 0 ≤ w.re then 1 else -1
+
+def center (s : ℝ) (w : ℂ) : ℂ := w + ((displacementSign w * (s / 4) : ℝ) : ℂ)
+
+def halfHeight (s : ℝ) : ℝ := s / 200
+
+def spacing (h : ℝ) (m : ℕ) : ℝ := h / m
+
+def turnRadius (h : ℝ) (m : ℕ) : ℝ := h / (2 * m)
+
+def ribbonWidth (h : ℝ) (m : ℕ) : ℝ := h / (100 * m)
+
+def columnOffset (h : ℝ) (m j : ℕ) : ℝ := -h + j * spacing h m
+
+/-- The closed width-one band over one straight pass, in physical scale. -/
+def columnPoint (c : ℂ) (h : ℝ) (m j : ℕ) (y a : ℝ) : ℂ :=
+  c + ((columnOffset h m j - side j * ribbonWidth h m * a : ℝ) : ℂ) +
+    (y : ℂ) * Complex.I
+
+/-- A circular connector, with its actual normal ribbon coordinate `a`.
+The parameter runs from zero to pi, alternating above and below. -/
+def turnPoint (c : ℂ) (h : ℝ) (m j : ℕ) (t a : ℝ) : ℂ :=
+  c + ((columnOffset h m j + turnRadius h m : ℝ) : ℂ) +
+    (side j * h : ℂ) * Complex.I +
+    ((turnRadius h m + side j * ribbonWidth h m * a : ℝ) : ℂ) *
+      ((-Real.cos t : ℝ) + (side j * Real.sin t : ℂ) * Complex.I)
+
+lemma center_dist {s : ℝ} (hs : 0 ≤ s) (w : ℂ) : dist (center s w) w = s / 4 := by
+  rw [center, dist_self_add_left, Complex.norm_real, Real.norm_eq_abs, abs_mul,
+    abs_of_nonneg (div_nonneg hs (by norm_num))]
+  have hh : |displacementSign w| = 1 := by unfold displacementSign; split <;> norm_num
+  rw [hh, one_mul]
+
+lemma center_im (s : ℝ) (w : ℂ) : (center s w).im = w.im := by
+  simp [center]
+
+lemma displaced_disk_inside
+    {s : ℝ} (hs : 0 < s) (w : ℂ) (hw : s ≤ w.im) :
+    closedBall (center s w) (s / 20) ⊆ ball w (w.im / 2) := by
+  intro z hz
+  have hd := (dist_triangle z (center s w) w).trans
+    (add_le_add hz (le_of_eq (center_dist hs.le w)))
+  change dist z w < w.im / 2
+  linarith
+
+lemma displaced_disk_separated
+    {s : ℝ} (hs : 0 < s) (w z : ℂ) (hz : z ∈ closedBall (center s w) (s / 20)) :
+    s / 5 ≤ dist z w := by
+  have hh := dist_triangle (center s w) z w
+  rw [center_dist hs.le w, dist_comm (center s w) z] at hh
+  change dist z (center s w) ≤ s / 20 at hz
+  linarith
+
+lemma spacing_pos {h : ℝ} (hh : 0 < h) {m : ℕ} (hm : 0 < m) : 0 < spacing h m := by
+  exact div_pos hh (by exact_mod_cast hm)
+
+lemma turnRadius_pos {h : ℝ} (hh : 0 < h) {m : ℕ} (hm : 0 < m) : 0 < turnRadius h m := by
+  unfold turnRadius
+  positivity
+
+lemma ribbonWidth_pos {h : ℝ} (hh : 0 < h) {m : ℕ} (hm : 0 < m) : 0 < ribbonWidth h m := by
+  unfold ribbonWidth
+  positivity
+
+lemma spacing_eq_width (h : ℝ) (m : ℕ) : spacing h m = 100 * ribbonWidth h m := by
+  unfold spacing ribbonWidth
+  by_cases hm : m = 0
+  · simp [hm]
+  · have hmr : (m : ℝ) ≠ 0 := by exact_mod_cast hm
+    field_simp
+
+lemma turnRadius_eq_width (h : ℝ) (m : ℕ) : turnRadius h m = 50 * ribbonWidth h m := by
+  unfold turnRadius ribbonWidth
+  by_cases hm : m = 0
+  · simp [hm]
+  · have hmr : (m : ℝ) ≠ 0 := by exact_mod_cast hm
+    field_simp
+    ring
+
+lemma columnOffset_bounds {h : ℝ} (hh : 0 < h) {m j : ℕ} (hm : 0 < m)
+    (hj : j ≤ 2 * m) : |columnOffset h m j| ≤ h := by
+  have hmr : (0 : ℝ) < m := by exact_mod_cast hm
+  have hjr : (j : ℝ) ≤ 2 * m := by exact_mod_cast hj
+  have hj0 : (0 : ℝ) ≤ j := Nat.cast_nonneg j
+  have hq := spacing_pos hh hm
+  have hmul : (j : ℝ) * spacing h m ≤ 2 * h := by
+    unfold spacing
+    rw [← mul_div_assoc]
+    exact (div_le_iff₀ hmr).mpr (by nlinarith)
+  rw [columnOffset]
+  exact abs_le.mpr ⟨by nlinarith [mul_nonneg hj0 hq.le], by linarith⟩
+
+lemma width_le_halfHeight {h : ℝ} (hh : 0 < h) {m : ℕ} (hm : 0 < m) :
+    ribbonWidth h m ≤ h / 100 := by
+  have hmr : (1 : ℝ) ≤ m := by exact_mod_cast hm
+  unfold ribbonWidth
+  apply div_le_div_of_nonneg_left hh.le (by norm_num)
+  nlinarith
+
+lemma radius_le_halfHeight {h : ℝ} (hh : 0 < h) {m : ℕ} (hm : 0 < m) :
+    turnRadius h m ≤ h / 2 := by
+  have hmr : (1 : ℝ) ≤ m := by exact_mod_cast hm
+  unfold turnRadius
+  apply div_le_div_of_nonneg_left hh.le (by norm_num)
+  nlinarith
+
+lemma columnPoint_bound {h : ℝ} (hh : 0 < h) {m j : ℕ} (hm : 0 < m)
+    (hj : j ≤ 2 * m) (c : ℂ) {y a : ℝ} (hy : |y| ≤ h) (ha : |a| ≤ 1) :
+    dist (columnPoint c h m j y a) c ≤ 3 * h := by
+  have ho := columnOffset_bounds hh hm hj
+  have he := width_le_halfHeight hh hm
+  have hwp := (ribbonWidth_pos hh hm).le
+  have hprod : |side j * ribbonWidth h m * a| ≤ ribbonWidth h m := by
+    rw [abs_mul, abs_mul, side_abs, one_mul, abs_of_nonneg hwp]
+    exact mul_le_of_le_one_right hwp ha
+  have hx : |columnOffset h m j - side j * ribbonWidth h m * a| ≤
+      |columnOffset h m j| + |side j * ribbonWidth h m * a| := by
+    simpa only [sub_eq_add_neg, abs_neg] using
+      abs_add_le (columnOffset h m j) (-(side j * ribbonWidth h m * a))
+  have hn := Complex.norm_le_abs_re_add_abs_im
+    (((columnOffset h m j - side j * ribbonWidth h m * a : ℝ) : ℂ) +
+      (y : ℂ) * Complex.I)
+  simp only [Complex.add_re, Complex.ofReal_re, Complex.mul_re, Complex.ofReal_im,
+    Complex.I_re, Complex.I_im, mul_zero, sub_zero, add_zero, Complex.add_im,
+    Complex.mul_im, mul_one, zero_add] at hn
+  rw [columnPoint, add_assoc, dist_self_add_left]
+  linarith
+
+lemma turnPoint_zero (c : ℂ) (h : ℝ) (m j : ℕ) (a : ℝ) :
+    turnPoint c h m j 0 a = columnPoint c h m j (side j * h) a := by
+  apply Complex.ext
+  · simp [turnPoint, columnPoint]
+    ring
+  · simp [turnPoint, columnPoint]
+
+lemma side_succ (j : ℕ) : side (j + 1) = -side j := by
+  by_cases h : Even j <;> simp [side, Nat.even_add_one, h]
+
+lemma turnPoint_pi (c : ℂ) (h : ℝ) (m j : ℕ) (a : ℝ) :
+    turnPoint c h m j Real.pi a = columnPoint c h m (j + 1) (side j * h) a := by
+  have he : spacing h m = 2 * turnRadius h m := by
+    rw [spacing_eq_width, turnRadius_eq_width]
+    ring
+  apply Complex.ext
+  · simp [turnPoint, columnPoint, columnOffset, side_succ, Nat.cast_add, Nat.cast_one]
+    nlinarith
+  · simp [turnPoint, columnPoint, columnOffset, side_succ, Nat.cast_add, Nat.cast_one]
+
+lemma turn_direction_norm (j : ℕ) (t : ℝ) :
+    ‖((-Real.cos t : ℝ) : ℂ) + (side j * Real.sin t : ℂ) * Complex.I‖ = 1 := by
+  apply (sq_eq_sq₀ (norm_nonneg _) zero_le_one).mp
+  rw [Complex.sq_norm, Complex.normSq_apply]
+  simp only [Complex.add_re, Complex.ofReal_re, Complex.mul_re, Complex.ofReal_im,
+    Complex.I_re, Complex.I_im, mul_zero, sub_zero, add_zero, Complex.add_im,
+    Complex.mul_im, mul_one, zero_add]
+  calc
+    _ = Real.cos t ^ 2 + side j ^ 2 * Real.sin t ^ 2 := by ring
+    _ = 1 ^ 2 := by rw [side_sq, one_mul]; nlinarith [Real.sin_sq_add_cos_sq t]
+
+lemma turnPoint_bound {h : ℝ} (hh : 0 < h) {m j : ℕ} (hm : 0 < m)
+    (hj : j + 1 ≤ 2 * m) (c : ℂ) (t : ℝ) {a : ℝ} (ha : |a| ≤ 1) :
+    dist (turnPoint c h m j t a) c ≤ 4 * h := by
+  have ho := columnOffset_bounds hh hm (show j ≤ 2 * m by omega)
+  have hr := radius_le_halfHeight hh hm
+  have hw := width_le_halfHeight hh hm
+  have hrp := (turnRadius_pos hh hm).le
+  have hwp := (ribbonWidth_pos hh hm).le
+  have hprod : |side j * ribbonWidth h m * a| ≤ ribbonWidth h m := by
+    rw [abs_mul, abs_mul, side_abs, one_mul, abs_of_nonneg hwp]
+    exact mul_le_of_le_one_right hwp ha
+  have hadd := abs_add_le (turnRadius h m) (side j * ribbonWidth h m * a)
+  rw [abs_of_nonneg hrp] at hadd
+  have hcen := abs_add_le (columnOffset h m j) (turnRadius h m)
+  rw [abs_of_nonneg hrp] at hcen
+  have hn : ‖((columnOffset h m j + turnRadius h m : ℝ) : ℂ) +
+      (side j * h : ℂ) * Complex.I +
+      ((turnRadius h m + side j * ribbonWidth h m * a : ℝ) : ℂ) *
+        ((-Real.cos t : ℝ) + (side j * Real.sin t : ℂ) * Complex.I)‖ ≤
+      |columnOffset h m j + turnRadius h m| + h +
+        |turnRadius h m + side j * ribbonWidth h m * a| := by
+    calc
+      _ ≤ (‖((columnOffset h m j + turnRadius h m : ℝ) : ℂ)‖ +
+        ‖(side j * h : ℂ) * Complex.I‖) +
+        ‖((turnRadius h m + side j * ribbonWidth h m * a : ℝ) : ℂ) *
+          ((-Real.cos t : ℝ) + (side j * Real.sin t : ℂ) * Complex.I)‖ :=
+        (norm_add_le _ _).trans (add_le_add (norm_add_le _ _) le_rfl)
+      _ = _ := by
+        simp only [norm_mul, Complex.norm_real, Real.norm_eq_abs, Complex.norm_I,
+          mul_one, side_abs, one_mul, abs_of_pos hh, turn_direction_norm]
+  have he : turnPoint c h m j t a - c =
+      ((columnOffset h m j + turnRadius h m : ℝ) : ℂ) +
+      (side j * h : ℂ) * Complex.I +
+      ((turnRadius h m + side j * ribbonWidth h m * a : ℝ) : ℂ) *
+        ((-Real.cos t : ℝ) + (side j * Real.sin t : ℂ) * Complex.I) := by
+    unfold turnPoint
+    ring
+  rw [dist_eq_norm, he]
+  linarith
+
+lemma column_inside_displaced_disk {s : ℝ} (hs : 0 < s) (w : ℂ)
+    {m j : ℕ} (hm : 0 < m) (hj : j ≤ 2 * m) {y a : ℝ}
+    (hy : |y| ≤ halfHeight s) (ha : |a| ≤ 1) :
+    columnPoint (center s w) (halfHeight s) m j y a ∈ closedBall (center s w) (s / 20) := by
+  have hh : 0 < halfHeight s := by unfold halfHeight; positivity
+  have hb := columnPoint_bound hh hm hj (center s w) hy ha
+  change dist _ _ ≤ s / 20
+  dsimp only [halfHeight] at hb ⊢
+  linarith
+
+
+@[simp] lemma columnPoint_re (c : ℂ) (h : ℝ) (m j : ℕ) (y a : ℝ) :
+    (columnPoint c h m j y a).re = c.re + columnOffset h m j - side j * ribbonWidth h m * a := by
+  simp [columnPoint]
+  ring
+
+@[simp] lemma columnPoint_im (c : ℂ) (h : ℝ) (m j : ℕ) (y a : ℝ) :
+    (columnPoint c h m j y a).im = c.im + y := by simp [columnPoint]
+
+lemma column_separation {h : ℝ} (hh : 0 < h) {m i j : ℕ} (hm : 0 < m)
+    (hij : i < j) (c : ℂ) (y y' : ℝ) {a b : ℝ} (ha : |a| ≤ 1) (hb : |b| ≤ 1) :
+    98 * ribbonWidth h m ≤
+      dist (columnPoint c h m i y a) (columnPoint c h m j y' b) := by
+  have hepos := (ribbonWidth_pos hh hm).le
+  have hnoise (n : ℕ) (u : ℝ) (hu : |u| ≤ 1) :
+      |side n * ribbonWidth h m * u| ≤ ribbonWidth h m := by
+    rw [abs_mul, abs_mul, side_abs, one_mul, abs_of_nonneg hepos]
+    exact mul_le_of_le_one_right hepos hu
+  have hai := abs_le.mp (hnoise i a ha)
+  have hbj := abs_le.mp (hnoise j b hb)
+  have hijr : (i : ℝ) + 1 ≤ j := by exact_mod_cast Nat.succ_le_of_lt hij
+  have hmul := mul_le_mul_of_nonneg_right hijr (spacing_pos hh hm).le
+  have hre : 98 * ribbonWidth h m ≤
+      (columnPoint c h m j y' b).re - (columnPoint c h m i y a).re := by
+    simp only [columnPoint_re, columnOffset] at *
+    rw [spacing_eq_width] at hmul ⊢
+    nlinarith
+  calc
+    _ ≤ (columnPoint c h m j y' b).re - (columnPoint c h m i y a).re := hre
+    _ ≤ |(columnPoint c h m j y' b).re - (columnPoint c h m i y a).re| := le_abs_self _
+    _ ≤ dist (columnPoint c h m i y a) (columnPoint c h m j y' b) := by
+      simpa only [dist_eq_norm, Complex.sub_re, abs_sub_comm] using
+        Complex.abs_re_le_norm (columnPoint c h m i y a - columnPoint c h m j y' b)
+
+lemma columnPoint_ne {h : ℝ} (hh : 0 < h) {m i j : ℕ} (hm : 0 < m)
+    (hij : i < j) (c : ℂ) (y y' : ℝ) {a b : ℝ} (ha : |a| ≤ 1) (hb : |b| ≤ 1) :
+    columnPoint c h m i y a ≠ columnPoint c h m j y' b := by
+  intro he
+  have hd := column_separation hh hm hij c y y' ha hb
+  rw [he, dist_self] at hd
+  have hp := ribbonWidth_pos hh hm
+  linarith
+
+
+lemma turn_radial_coefficient_pos {h : ℝ} (hh : 0 < h) {m : ℕ} (hm : 0 < m)
+    (j : ℕ) {a : ℝ} (ha : |a| ≤ 1) :
+    0 < turnRadius h m + side j * ribbonWidth h m * a := by
+  have he := ribbonWidth_pos hh hm
+  have hb : |side j * ribbonWidth h m * a| ≤ ribbonWidth h m := by
+    rw [abs_mul, abs_mul, side_abs, one_mul, abs_of_pos he]
+    exact mul_le_of_le_one_right he.le ha
+  rw [turnRadius_eq_width]
+  linarith [(abs_le.mp hb).1]
+
+/-- Each circular turn, with its full normal band, is embedded. -/
+theorem turnPoint_injective {h : ℝ} (hh : 0 < h) {m : ℕ} (hm : 0 < m)
+    (c : ℂ) (j : ℕ) {t u a b : ℝ} (ht : t ∈ Icc 0 Real.pi)
+    (hu : u ∈ Icc 0 Real.pi) (ha : |a| ≤ 1) (hb : |b| ≤ 1)
+    (he : turnPoint c h m j t a = turnPoint c h m j u b) : t = u ∧ a = b := by
+  let z := c + ((columnOffset h m j + turnRadius h m : ℝ) : ℂ) +
+    (side j * h : ℂ) * Complex.I
+  have hn (v q : ℝ) (hq : |q| ≤ 1) : dist (turnPoint c h m j v q) z =
+      turnRadius h m + side j * ribbonWidth h m * q := by
+    change dist (z + _) z = _
+    rw [dist_self_add_left, norm_mul, Complex.norm_real, Real.norm_eq_abs,
+      turn_direction_norm, mul_one, abs_of_pos (turn_radial_coefficient_pos hh hm j hq)]
+  have hcoef := congrArg (fun w => dist w z) he
+  rw [hn t a ha, hn u b hb] at hcoef
+  have hs : side j ≠ 0 := by
+    intro hz
+    have hn := side_abs j
+    rw [hz, abs_zero] at hn
+    norm_num at hn
+  have hab : a = b := by
+    apply mul_left_cancel₀ (ribbonWidth_pos hh hm).ne'
+    apply mul_left_cancel₀ hs
+    nlinarith [hcoef]
+  subst b
+  have hre := congrArg Complex.re he
+  simp only [turnPoint, Complex.add_re, Complex.ofReal_re, Complex.mul_re,
+    Complex.ofReal_im, Complex.I_re, Complex.I_im, mul_zero, sub_zero,
+    zero_sub, add_zero, Complex.add_im, Complex.mul_im, mul_one, zero_add] at hre
+  have hcos : Real.cos t = Real.cos u := by
+    nlinarith [turn_radial_coefficient_pos hh hm j ha]
+  exact ⟨Real.injOn_cos ht hu hcos, rfl⟩
+
+
+end SLEExactGauge.Serpentine
+
+end
+
+end OAI
diff --git a/lean/OAI/Probability/SLE/Gauge/SerpentineMarkedClearance.lean b/lean/OAI/Probability/SLE/Gauge/SerpentineMarkedClearance.lean
new file mode 100644
index 0000000000000000000000000000000000000000..1703a53367ed7032b19a4fc5111e4435863097b7
--- /dev/null
+++ b/lean/OAI/Probability/SLE/Gauge/SerpentineMarkedClearance.lean
@@ -0,0 +1,37 @@
+import OAI.Probability.SLE.Gauge.SerpentineExteriorBounds
+import OAI.Probability.SLE.Gauge.SerpentineMarkedRegion
+import OAI.Probability.SLE.Geometry.MarkedRouteClearance
+
+namespace OAI
+
+/-! Actual fitted ribbon points satisfy the geometric separation
+conditions for the two marked-point exit routes. -/
+
+noncomputable section
+open Set Metric
+
+namespace SLEExactGauge.Serpentine
+open RibbonCoordinates
+
+theorem physicalFitChart_markedRoutes_clearance {s : ℝ} (hs : 0 < s) (hs1 : s ≤ 1)
+    (w : ℂ) (hw : s ≤ w.im) (hw1 : ‖w‖ ≤ 1) (hwr : 0 ≤ w.re)
+    {m : ℕ} (hm : 0 < m) {z : ℂ} (hz : z ∈ closedRibbon)
+    (hheight : (physicalFitChart s w m z).im ≤ 2) (t : ℝ) :
+    s / 20 ≤ dist (markedLeftRoute w (s / 20) t) (physicalFitChart s w m z) ∧
+    s / 20 ≤ dist (markedRightRoute w (s / 20) t) (physicalFitChart s w m z) := by
+  apply markedRoutes_past_clearance (by linarith)
+    ((Complex.re_le_norm w).trans hw1) ((Complex.im_le_norm w).trans hw1)
+    (by positivity) (by linarith)
+    (physicalFitChart_re_bounds hs hs1 w hw hw1 hm hz) hheight
+  rcases physicalFitChart_low_or_right hs w hw hm hz.2 with hlo | hright
+  · left
+    linarith
+  · right
+    rw [abs_of_nonneg hwr] at hright
+    linarith
+
+end SLEExactGauge.Serpentine
+
+end
+
+end OAI
diff --git a/lean/OAI/Probability/SLE/Gauge/SerpentineMarkedGuide.lean b/lean/OAI/Probability/SLE/Gauge/SerpentineMarkedGuide.lean
new file mode 100644
index 0000000000000000000000000000000000000000..cbdd8f90bae4e951efb38824c4ff620e6fb5c69e
--- /dev/null
+++ b/lean/OAI/Probability/SLE/Gauge/SerpentineMarkedGuide.lean
@@ -0,0 +1,125 @@
+import OAI.Probability.SLE.Gauge.SerpentineFiniteHeight
+import OAI.Probability.SLE.Geometry.MarkedHookLocal
+
+namespace OAI
+
+/-! The explicit complete physical access guide from the final ribbon
+tip, through the marked point, and then vertically to infinity. -/
+
+noncomputable section
+open Set Filter Metric
+open scoped Topology NNReal
+
+namespace SLEExactGauge.Serpentine
+open RibbonCoordinates
+
+def terminalAccess (s : ℝ) (w : ℂ) (m : ℕ) (x : ℝ) (t : ℝ) : ℂ :=
+  physicalFitChart s w m (guideCoordinate (fitCompletion s w m) x t)
+
+def completeMarkedAccess (s : ℝ) (w : ℂ) (m : ℕ) (x : ℝ) : ℝ → ℂ :=
+  appendMarkedHook (terminalAccess s w m x) (fitHighTime s w m) w
+    (fitTerminalX s w) 2 (s / 20)
+
+lemma terminalAccess_continuous {s : ℝ} (hs : 0 < s) (w : ℂ) (hw : s ≤ w.im)
+    {m : ℕ} (hm : 0 < m) (x : ℝ) : Continuous (terminalAccess s w m x) := by
+  have hp : Continuous (physicalFitChart s w m) :=
+    continuous_const.mul (fitChart_continuous hs w hw hm)
+  exact hp.comp (guideCoordinate_continuous _ _)
+
+lemma terminalAccess_right {s : ℝ} (hs : 0 < s) (w : ℂ) (hw : s ≤ w.im)
+    (hwr : 0 ≤ w.re) {m : ℕ} (hm : 0 < m) {x t : ℝ} (hx : |x| ≤ 1) (ht : 0 ≤ t) :
+    w.re + s / 5 ≤ (terminalAccess s w m x t).re := by
+  have hc := (fitCompletion_bounds hs w hw hm).1
+  have hentry : 0 ≤ columnEntry 0 m (2 * m) := columnEntry_nonneg le_rfl _ _
+  have hmr : (1 : ℝ) ≤ m := by exact_mod_cast hm
+  have hA : fitEntry s w m < (guideCoordinate (fitCompletion s w m) x t).re := by
+    rw [guideCoordinate_re]
+    linarith
+  have him := (guideCoordinate_im_bound (k := (fitCompletion s w m : ℝ)) (x := x) ht).trans hx
+  have hh := physicalFitChart_array_right hs w hm him hA
+  rw [abs_of_nonneg hwr] at hh
+  exact by dsimp [terminalAccess]; linarith
+
+lemma completeMarkedAccess_continuous {s : ℝ} (hs : 0 < s) (hs1 : s ≤ 1)
+    (w : ℂ) (hw : s ≤ w.im) (hw1 : ‖w‖ ≤ 1) (hwr : 0 ≤ w.re)
+    {m : ℕ} (hm : 0 < m) (x : ℝ) : Continuous (completeMarkedAccess s w m x) := by
+  have hwi := (Complex.im_le_norm w).trans hw1
+  apply appendMarkedHook_continuous _ (terminalAccess_continuous hs w hw hm x)
+  · unfold fitTerminalX
+    rw [abs_of_nonneg hwr]
+    linarith
+  · linarith
+  · positivity
+  · exact physicalFitChart_terminal_guide_endpoint hs hs1 w hw hw1 hm x
+
+lemma completeMarkedAccess_injective {s : ℝ} (hs : 0 < s) (hs1 : s ≤ 1)
+    (w : ℂ) (hw : s ≤ w.im) (hw1 : ‖w‖ ≤ 1) (hwr : 0 ≤ w.re)
+    {m : ℕ} (hm : 0 < m) {x : ℝ} (hx : |x| ≤ 1) :
+    InjOn (completeMarkedAccess s w m x) (Ici 0) := by
+  have hT := fitHighTime_large hs hs1 w hw hw1 hm
+  have hwi := (Complex.im_le_norm w).trans hw1
+  have hR : w.re < fitTerminalX s w := by
+    unfold fitTerminalX
+    rw [abs_of_nonneg hwr]
+    linarith
+  apply appendMarkedHook_injective _ (by linarith)
+    ((physicalFitChart_terminal_guide_injective hs w hw hm x).mono Icc_subset_Ici_self)
+    w hR (show w.im < (2 : ℝ) by linarith) (by positivity)
+    (physicalFitChart_terminal_guide_endpoint hs hs1 w hw hw1 hm x)
+  intro t ht
+  refine ⟨physicalFitChart_terminal_guide_strict_height hs w hw hm x ht, Or.inr ?_⟩
+  have hr := terminalAccess_right hs w hw hwr hm hx ht.1
+  dsimp only [terminalAccess] at hr
+  linarith
+
+lemma completeMarkedAccess_zero {s : ℝ} (hs : 0 < s) (hs1 : s ≤ 1)
+    (w : ℂ) (hw : s ≤ w.im) (hw1 : ‖w‖ ≤ 1) {m : ℕ} (hm : 0 < m) (x : ℝ) :
+    completeMarkedAccess s w m x 0 = physicalFitChart s w m ((fitCompletion s w m : ℂ) + (x : ℂ) * Complex.I) := by
+  have hT := fitHighTime_large hs hs1 w hw hw1 hm
+  rw [completeMarkedAccess, appendMarkedHook, curveJoin_of_le (by linarith)]
+  simp [terminalAccess, guideCoordinate]
+
+lemma completeMarkedAccess_hits_marked {s : ℝ} (hs : 0 < s) (hs1 : s ≤ 1)
+    (w : ℂ) (hw : s ≤ w.im) (hw1 : ‖w‖ ≤ 1) (hwr : 0 ≤ w.re)
+    {m : ℕ} (hm : 0 < m) (x : ℝ) :
+    ∃ t : ℝ, 0 < t ∧ completeMarkedAccess s w m x t = w := by
+  have hT := fitHighTime_large hs hs1 w hw hw1 hm
+  have hwi := (Complex.im_le_norm w).trans hw1
+  have hR : w.re < fitTerminalX s w := by
+    unfold fitTerminalX
+    rw [abs_of_nonneg hwr]
+    linarith
+  refine ⟨fitHighTime s w m + ((fitTerminalX s w - w.re) + (2 - w.im)), by linarith, ?_⟩
+  exact appendMarkedHook_passes_marked _ _ w hR (by linarith)
+
+lemma completeMarkedAccess_norm_tendsto {s : ℝ} (hs : 0 < s)
+    (w : ℂ) (hw1 : ‖w‖ ≤ 1) (hwr : 0 ≤ w.re) (m : ℕ) (x : ℝ) :
+    Tendsto (fun t : ℝ => ‖completeMarkedAccess s w m x t‖) atTop atTop := by
+  have hwi : w.im < 2 := lt_of_le_of_lt ((Complex.im_le_norm w).trans hw1) (by norm_num)
+  have hR : w.re < fitTerminalX s w := by
+    unfold fitTerminalX
+    rw [abs_of_nonneg hwr]
+    linarith
+  let D := fitHighTime s w m + ((fitTerminalX s w - w.re) + (2 - w.im) + s / 20)
+  have hlin : Tendsto (fun t : ℝ => t - D + w.im) atTop atTop := by
+    simpa only [sub_eq_add_neg, add_assoc, id_eq] using
+      tendsto_atTop_add_const_right atTop (-D + w.im) tendsto_id
+  have him : Tendsto (fun t : ℝ => (completeMarkedAccess s w m x t).im) atTop atTop := by
+    apply hlin.congr'
+    filter_upwards [eventually_ge_atTop (D + 1)] with t ht
+    have ht' : fitHighTime s w m < t := by dsimp only [D] at ht; linarith
+    have hc : (fitTerminalX s w - w.re) + (2 - w.im) + s / 20 <
+        t - fitHighTime s w m := by dsimp only [D] at ht; linarith
+    rw [completeMarkedAccess, appendMarkedHook, curveJoin_of_gt ht',
+      markedHook_tail w hwi (by positivity) hc]
+    simp only [hookUp, Complex.add_im, Complex.mul_im, Complex.ofReal_re,
+      Complex.ofReal_im, Complex.I_re, Complex.I_im, mul_one, mul_zero, zero_add]
+    dsimp only [D]
+    ring
+  exact tendsto_atTop_mono (fun t => Complex.im_le_norm _) him
+
+end SLEExactGauge.Serpentine
+
+end
+
+end OAI
diff --git a/lean/OAI/Probability/SLE/Gauge/SerpentineMarkedLocal.lean b/lean/OAI/Probability/SLE/Gauge/SerpentineMarkedLocal.lean
new file mode 100644
index 0000000000000000000000000000000000000000..7587be9d9f4e2d067cd7cd3d4eb831c9ac8ec205
--- /dev/null
+++ b/lean/OAI/Probability/SLE/Gauge/SerpentineMarkedLocal.lean
@@ -0,0 +1,104 @@
+import OAI.Probability.SLE.Gauge.SerpentineMarkedGuide
+
+namespace OAI
+
+/-! The explicit marked access guide meets a small corner-chart disk
+exactly along its real diameter. The distant terminal prefix is excluded
+quantitatively, so there are no nonlocal intersections. -/
+
+noncomputable section
+open Set Metric
+open scoped Topology NNReal
+
+namespace SLEExactGauge.Serpentine
+open RibbonCoordinates
+
+lemma terminalAccess_distance {s : ℝ} (hs : 0 < s) (w : ℂ) (hw : s ≤ w.im)
+    (hwr : 0 ≤ w.re) {m : ℕ} (hm : 0 < m) {x t : ℝ} (hx : |x| ≤ 1) (ht : 0 ≤ t) :
+    s / 5 ≤ dist (terminalAccess s w m x t) w := by
+  have hr := terminalAccess_right hs w hw hwr hm hx ht
+  have hb := Complex.abs_re_le_norm (terminalAccess s w m x t - w)
+  rw [Complex.sub_re, ← dist_eq_norm] at hb
+  linarith [le_abs_self ((terminalAccess s w m x t).re - w.re)]
+
+theorem completeMarkedAccess_corner_iff {s : ℝ} (hs : 0 < s) (hs1 : s ≤ 1)
+    (w : ℂ) (hw : s ≤ w.im) (hw1 : ‖w‖ ≤ 1) (hwr : 0 ≤ w.re)
+    {m : ℕ} (hm : 0 < m) {x : ℝ} (hx : |x| ≤ 1) {z : ℂ}
+    (hz : z ∈ ball (0 : ℂ) ((s / 20) / 12)) :
+    (∃ t : ℝ, 0 < t ∧ completeMarkedAccess s w m x t = markedCornerChart w z) ↔ z.im = 0 := by
+  have hn : ‖z‖ < (s / 20) / 12 := by simpa only [mem_ball, dist_zero_right] using hz
+  have hwi : w.im ≤ 1 := (Complex.im_le_norm w).trans hw1
+  have hR : w.re < fitTerminalX s w := by
+    unfold fitTerminalX
+    rw [abs_of_nonneg hwr]
+    linarith
+  have hT := fitHighTime_large hs hs1 w hw hw1 hm
+  have hcorner := markedHook_small_corner_iff (w := w) (z := z) hR
+    (show w.im < 2 by linarith) (show 0 < s / 20 by positivity)
+    (show 0 < (s / 20) / 12 by positivity)
+    (show 3 * ((s / 20) / 12) < 2 - w.im by linarith)
+    (show 3 * ((s / 20) / 12) < s / 20 by linarith) hn
+  constructor
+  · rintro ⟨t, ht, he⟩
+    by_cases htT : t ≤ fitHighTime s w m
+    · rw [completeMarkedAccess, appendMarkedHook, curveJoin_of_le htT] at he
+      have hd := terminalAccess_distance hs w hw hwr hm hx ht.le
+      rw [he] at hd
+      have hb := markedCornerChart_norm w z
+      linarith
+    · rw [completeMarkedAccess, appendMarkedHook, curveJoin_of_gt (lt_of_not_ge htT)] at he
+      exact hcorner.mp ⟨t - fitHighTime s w m, by linarith, he⟩
+  · intro him
+    obtain ⟨u, hu, he⟩ := hcorner.mpr him
+    refine ⟨fitHighTime s w m + u, by linarith, ?_⟩
+    by_cases hu0 : u = 0
+    · subst u
+      rw [add_zero, completeMarkedAccess, appendMarkedHook, curveJoin_of_le le_rfl]
+      change physicalFitChart s w m (guideCoordinate (fitCompletion s w m) x (fitHighTime s w m)) = _
+      rw [physicalFitChart_terminal_guide_endpoint hs hs1 w hw hw1 hm x]
+      simpa [markedHook_zero w hR] using he
+    · have hup : 0 < u := lt_of_le_of_ne hu (Ne.symm hu0)
+      rw [completeMarkedAccess, appendMarkedHook, curveJoin_of_gt (by linarith), add_sub_cancel_left]
+      exact he
+
+theorem completeMarkedAccess_corner_nnreal_iff {s : ℝ} (hs : 0 < s) (hs1 : s ≤ 1)
+    (w : ℂ) (hw : s ≤ w.im) (hw1 : ‖w‖ ≤ 1) (hwr : 0 ≤ w.re)
+    {m : ℕ} (hm : 0 < m) {x : ℝ} (hx : |x| ≤ 1) {z : ℂ}
+    (hz : z ∈ ball (0 : ℂ) ((s / 20) / 12)) :
+    (∃ t : ℝ≥0, 0 < t ∧ completeMarkedAccess s w m x t = markedCornerChart w z) ↔ z.im = 0 := by
+  rw [← completeMarkedAccess_corner_iff hs hs1 w hw hw1 hwr hm hx hz]
+  constructor
+  · rintro ⟨t, ht, he⟩
+    exact ⟨t, by exact_mod_cast ht, he⟩
+  · rintro ⟨t, ht, he⟩
+    exact ⟨⟨t, ht.le⟩, by exact_mod_cast ht, he⟩
+
+lemma completeMarkedAccess_upper {s : ℝ} (hs : 0 < s)
+    (w : ℂ) (hw : s ≤ w.im) (hw1 : ‖w‖ ≤ 1) (hwr : 0 ≤ w.re)
+    {m : ℕ} (hm : 0 < m) {x u : ℝ} (hu : 0 ≤ u) :
+    completeMarkedAccess s w m x u ∈ upperHalfPlane := by
+  have hwi := (Complex.im_le_norm w).trans hw1
+  change 0 < (completeMarkedAccess s w m x u).im
+  by_cases huT : u ≤ fitHighTime s w m
+  · rw [completeMarkedAccess, appendMarkedHook, curveJoin_of_le huT]
+    change 0 < (physicalFitChart s w m (guideCoordinate (fitCompletion s w m) x u)).im
+    rw [physicalFitChart_terminal_guide hs w hw hm x hu]
+    simp only [Complex.add_im, Complex.ofReal_im, Complex.mul_im, Complex.ofReal_re,
+      Complex.I_re, Complex.I_im, mul_one, mul_zero, add_zero, zero_add]
+    have hb := (fitTerminalHeight_bounds hs w hw hm).1
+    have hp := mul_nonneg (fit_width_pos hs hm).le hu
+    linarith
+  · rw [completeMarkedAccess, appendMarkedHook, curveJoin_of_gt (lt_of_not_ge huT)]
+    have hR : w.re < fitTerminalX s w := by
+      unfold fitTerminalX
+      rw [abs_of_nonneg hwr]
+      linarith
+    have hh := markedHook_im_lower hR (show w.im < 2 by linarith)
+      (show 0 < s / 20 by positivity) (show 0 ≤ u - fitHighTime s w m by linarith)
+    linarith
+
+end SLEExactGauge.Serpentine
+
+end
+
+end OAI
diff --git a/lean/OAI/Probability/SLE/Gauge/SerpentineMarkedReflection.lean b/lean/OAI/Probability/SLE/Gauge/SerpentineMarkedReflection.lean
new file mode 100644
index 0000000000000000000000000000000000000000..fde1a329baf47d5c126967a135018e86f091463d
--- /dev/null
+++ b/lean/OAI/Probability/SLE/Gauge/SerpentineMarkedReflection.lean
@@ -0,0 +1,129 @@
+import OAI.Probability.SLE.Gauge.SerpentineMarkedRouteClearance
+import OAI.Probability.SLE.Gauge.RibbonGoodPrefix
+
+namespace OAI
+
+/-! Reflection of the concrete experiment and its actual narrow-prefix
+certificate. It reduces a marked point on the left to the right-hand layout. -/
+
+noncomputable section
+open Set Metric ComplexConjugate
+open scoped Topology NNReal
+
+namespace SLEExactGauge.Serpentine
+open RibbonCoordinates
+
+@[simp] lemma fitX_mirror (s : ℝ) (w : ℂ) (m : ℕ) :
+    fitX s (loewnerMirror w) m = fitX s w m := by simp [fitX]
+
+@[simp] lemma fitY_mirror (s : ℝ) (w : ℂ) (m : ℕ) :
+    fitY s (loewnerMirror w) m = fitY s w m := by simp [fitY]
+
+@[simp] lemma fitChart_mirror (s : ℝ) (w : ℂ) (m : ℕ) (z : ℂ) :
+    fitChart s (loewnerMirror w) m z = fitChart s w m z := by
+  simp only [fitChart, fitSpine, fitTangent, fitX_mirror, fitY_mirror]
+
+@[simp] lemma physicalFitChart_mirror (s : ℝ) (w : ℂ) (m : ℕ) (z : ℂ) :
+    physicalFitChart s (loewnerMirror w) m z = physicalFitChart s w m z := by
+  simp only [physicalFitChart, fitChart_mirror]
+
+@[simp] lemma fitEntry_mirror (s : ℝ) (w : ℂ) (m : ℕ) :
+    fitEntry s (loewnerMirror w) m = fitEntry s w m := by
+  simp only [fitEntry, fitX_mirror, fitY_mirror]
+
+@[simp] lemma fitCompletion_mirror (s : ℝ) (w : ℂ) (m : ℕ) :
+    fitCompletion s (loewnerMirror w) m = fitCompletion s w m := by
+  simp only [fitCompletion, fitEntry_mirror]
+
+@[simp] lemma fitTerminalX_mirror (s : ℝ) (w : ℂ) :
+    fitTerminalX s (loewnerMirror w) = fitTerminalX s w := by simp [fitTerminalX]
+
+@[simp] lemma fitTerminalHeight_mirror (s : ℝ) (w : ℂ) (m : ℕ) :
+    fitTerminalHeight s (loewnerMirror w) m = fitTerminalHeight s w m := by
+  simp only [fitTerminalHeight, fitY_mirror, fitCompletion_mirror, fitEntry_mirror]
+
+@[simp] lemma fitHighTime_mirror (s : ℝ) (w : ℂ) (m : ℕ) :
+    fitHighTime s (loewnerMirror w) m = fitHighTime s w m := by
+  simp only [fitHighTime, fitTerminalHeight_mirror]
+
+lemma physicalExperimentChart_negative {s : ℝ} {w : ℂ} (hw : w.re < 0) (m : ℕ) :
+    physicalExperimentChart s w m = reflectedChart (physicalFitChart s (loewnerMirror w) m) := by
+  funext z
+  simp only [physicalExperimentChart, ite_eq_right (not_le_of_gt hw), reflectedChart,
+    physicalFitChart_mirror]
+
+lemma experimentChart_negative {s : ℝ} {w : ℂ} (hw : w.re < 0) (m : ℕ) :
+    experimentChart s w m = reflectedChart (fitChart s (loewnerMirror w) m) := by
+  funext z
+  simp only [experimentChart, ite_eq_right (not_le_of_gt hw), reflectedChart, fitChart_mirror]
+
+lemma ribbonCore_reflected_iff (P : ℂ → ℂ) (ε : ℝ) (z : ℂ) :
+    z ∈ ribbonCore (reflectedChart P) ε ↔ loewnerMirror z ∈ ribbonCore P ε := by
+  constructor
+  · rintro ⟨u, ⟨hu, hε⟩, he⟩
+    refine ⟨conj u, ⟨conj_mem_closedRibbon hu, ?_⟩, ?_⟩
+    · simpa only [Complex.conj_im, abs_neg] using hε
+    · rw [← he]
+      simp only [reflectedChart, loewnerMirror_twice]
+  · rintro ⟨u, ⟨hu, hε⟩, he⟩
+    refine ⟨conj u, ⟨conj_mem_closedRibbon hu, ?_⟩, ?_⟩
+    · simpa only [Complex.conj_im, abs_neg] using hε
+    · simpa only [reflectedChart, Complex.conj_conj, loewnerMirror_twice] using
+        congrArg loewnerMirror he
+
+lemma goodRibbonPrefix_reflected {Ω : Type*} (γ : Ω → ℝ≥0 → ℂ)
+    (τ : Ω → WithTop ℝ≥0) (P : ℂ → ℂ) (ε : ℝ) :
+    GoodRibbonPrefix γ τ (reflectedChart P) ε =
+      GoodRibbonPrefix (fun ω t => loewnerMirror (γ ω t)) τ P ε := by
+  ext ω
+  change (_ ∧ _ ∧ _) ↔ (_ ∧ _ ∧ _)
+  constructor
+  · rintro ⟨hτ, hp, he⟩
+    exact ⟨hτ, fun t ht => (ribbonCore_reflected_iff P ε _).mp (hp ht),
+      (ribbonCore_reflected_iff P (ε / 4) _).mp he⟩
+  · rintro ⟨hτ, hp, he⟩
+    exact ⟨hτ, fun t ht => (ribbonCore_reflected_iff P ε _).mpr (hp ht),
+      (ribbonCore_reflected_iff P (ε / 4) _).mpr he⟩
+
+lemma goodRibbonPrefix_physical_negative {Ω : Type*} (γ : Ω → ℝ≥0 → ℂ)
+    (τ : Ω → WithTop ℝ≥0) {s : ℝ} {w : ℂ} (hw : w.re < 0) (m : ℕ) (ε : ℝ) :
+    GoodRibbonPrefix γ τ (physicalExperimentChart s w m) ε =
+      GoodRibbonPrefix (fun ω t => loewnerMirror (γ ω t)) τ
+        (physicalFitChart s (loewnerMirror w) m) ε := by
+  rw [physicalExperimentChart_negative hw m]
+  exact goodRibbonPrefix_reflected γ τ _ ε
+
+lemma physicalExperimentChart_reflect_point {s : ℝ} {w : ℂ} (hw : w.re < 0)
+    (m : ℕ) (z : ℂ) :
+    loewnerMirror (physicalExperimentChart s w m z) =
+      physicalFitChart s (loewnerMirror w) m (conj z) := by
+  rw [physicalExperimentChart_negative hw m]
+  simp only [reflectedChart, loewnerMirror_twice]
+
+def mirroredProgress (g : C(ℂ, ℝ)) : C(ℂ, ℝ) :=
+  ⟨fun z => g (loewnerMirror z), g.continuous.comp loewnerMirror.continuous⟩
+
+lemma mirroredProgress_trace (g : C(ℂ, ℝ)) (γ : ℝ≥0 → ℂ) (t : ℝ≥0) :
+    mirroredProgress g ((loewnerMirror ∘ γ) t) = g (γ t) := by
+  simp [mirroredProgress]
+
+lemma mirroredProgress_chart (g : C(ℂ, ℝ)) (P : ℂ → ℂ)
+    (hg : ∀ z ∈ closedRibbon, g (P z) = z.re) :
+    ∀ z ∈ closedRibbon, mirroredProgress g (reflectedChart P z) = z.re := by
+  intro z hz
+  change g (loewnerMirror (loewnerMirror (P (conj z)))) = z.re
+  rw [loewnerMirror_twice]
+  simpa only [Complex.conj_re] using hg (conj z) (conj_mem_closedRibbon hz)
+
+lemma mirroredProgress_firstFrontTime (g : C(ℂ, ℝ)) (γ : ℝ≥0 → ℂ) (k : ℝ) :
+    FirstFrontPassage.firstFrontTime (fun t => mirroredProgress g ((loewnerMirror ∘ γ) t)) k =
+      FirstFrontPassage.firstFrontTime (fun t => g (γ t)) k := by
+  congr 1
+  funext t
+  exact mirroredProgress_trace g γ t
+
+end SLEExactGauge.Serpentine
+
+end
+
+end OAI
diff --git a/lean/OAI/Probability/SLE/Gauge/SerpentineMarkedRegion.lean b/lean/OAI/Probability/SLE/Gauge/SerpentineMarkedRegion.lean
new file mode 100644
index 0000000000000000000000000000000000000000..1de789f83a0f176d953a3a2ecbca0d505e94d7bf
--- /dev/null
+++ b/lean/OAI/Probability/SLE/Gauge/SerpentineMarkedRegion.lean
@@ -0,0 +1,56 @@
+import OAI.Probability.SLE.Gauge.SerpentineFittedShadow
+
+namespace OAI
+
+/-! The connector lies below the marked point, and every later part of
+the rightward serpentine lies strictly to its right. This is the geometric
+separation used to append the marked-point access hook. -/
+
+noncomputable section
+open Set Metric
+
+namespace SLEExactGauge.Serpentine
+
+theorem physicalFitChart_low_or_right {s : ℝ} (hs : 0 < s) (w : ℂ) (hw : s ≤ w.im)
+    {m : ℕ} (hm : 0 < m) {z : ℂ} (ha : |z.im| ≤ 1) :
+    (physicalFitChart s w m z).im ≤ s / 2 ∨
+      |w.re| + s / 5 ≤ (physicalFitChart s w m z).re := by
+  by_cases h4 : z.re ≤ connectorFourth (fitHeight m) (fitRadius m) (fitX s w m)
+  · exact Or.inl (physicalFitChart_low hs w hw hm ha h4)
+  · right
+    by_cases hA : z.re ≤ connectorEntry (fitHeight m) (fitRadius m) (fitX s w m) (fitY s w m)
+    · have hh := physicalFitChart_tail_right hs w hw hm ha (lt_of_not_ge h4) hA
+      linarith
+    · have hh := physicalFitChart_array_right hs w hm ha (lt_of_not_ge hA)
+      linarith
+
+theorem physicalFitChart_marked_distance {s : ℝ} (hs : 0 < s) (w : ℂ) (hw : s ≤ w.im)
+    (hwr : 0 ≤ w.re) {m : ℕ} (hm : 0 < m) {z : ℂ} (ha : |z.im| ≤ 1) :
+    s / 5 ≤ dist (physicalFitChart s w m z) w := by
+  rw [dist_eq_norm]
+  rcases physicalFitChart_low_or_right hs w hw hm ha with hlow | hright
+  · have hh := Complex.abs_im_le_norm (physicalFitChart s w m z - w)
+    rw [Complex.sub_im] at hh
+    have hl := neg_le_abs ((physicalFitChart s w m z).im - w.im)
+    linarith
+  · rw [abs_of_nonneg hwr] at hright
+    have hh := Complex.abs_re_le_norm (physicalFitChart s w m z - w)
+    rw [Complex.sub_re] at hh
+    have hl := le_abs_self ((physicalFitChart s w m z).re - w.re)
+    linarith
+
+theorem physicalFitChart_hook_region {s : ℝ} (hs : 0 < s) (w : ℂ) (hw : s ≤ w.im)
+    (hwr : 0 ≤ w.re) {m : ℕ} (hm : 0 < m) {z : ℂ} (ha : |z.im| ≤ 1) :
+    (physicalFitChart s w m z).im < w.im ∨ w.re < (physicalFitChart s w m z).re := by
+  rcases physicalFitChart_low_or_right hs w hw hm ha with hh | hh
+  · left
+    linarith
+  · right
+    rw [abs_of_nonneg hwr] at hh
+    linarith
+
+end SLEExactGauge.Serpentine
+
+end
+
+end OAI
diff --git a/lean/OAI/Probability/SLE/Gauge/SerpentineMarkedRouteClearance.lean b/lean/OAI/Probability/SLE/Gauge/SerpentineMarkedRouteClearance.lean
new file mode 100644
index 0000000000000000000000000000000000000000..91dc7920ce69fb3e920dbd5efd3d3672f2a89f56
--- /dev/null
+++ b/lean/OAI/Probability/SLE/Gauge/SerpentineMarkedRouteClearance.lean
@@ -0,0 +1,63 @@
+import OAI.Probability.SLE.Gauge.SerpentineMarkedLocal
+import OAI.Probability.SLE.Geometry.MarkedRouteEarlyClearance
+
+namespace OAI
+
+/-! The two exit routes avoid every point of the complete marked access
+guide by one uniform margin, including its distant initial prefix. -/
+
+noncomputable section
+open Set Metric
+
+namespace SLEExactGauge.Serpentine
+open RibbonCoordinates
+
+lemma terminalAccess_bounds {s : ℝ} (hs : 0 < s) (hs1 : s ≤ 1)
+    (w : ℂ) (hw : s ≤ w.im) (hw1 : ‖w‖ ≤ 1) (hwr : 0 ≤ w.re)
+    {m : ℕ} (hm : 0 < m) {x u : ℝ} (hx : |x| ≤ 1)
+    (hu : u ∈ Icc (0 : ℝ) (fitHighTime s w m)) :
+    -2 ≤ (terminalAccess s w m x u).re ∧ (terminalAccess s w m x u).re ≤ 2 ∧
+    (terminalAccess s w m x u).im ≤ 2 ∧ w.re + s / 5 ≤ (terminalAccess s w m x u).re := by
+  have hz : guideCoordinate (fitCompletion s w m) x u ∈ closedRibbon := by
+    refine ⟨?_, (guideCoordinate_im_bound hu.1).trans hx⟩
+    rw [guideCoordinate_re]
+    exact add_nonneg (Nat.cast_nonneg _) hu.1
+  have hre := physicalFitChart_re_bounds hs hs1 w hw hw1 hm hz
+  exact ⟨hre.1, hre.2, physicalFitChart_terminal_guide_height hs w hw hm x hu,
+    terminalAccess_right hs w hw hwr hm hx hu.1⟩
+
+/-- A margin independent of the number of serpentine columns. -/
+theorem completeMarkedAccess_route_clearance {s : ℝ} (hs : 0 < s) (hs1 : s ≤ 1)
+    (w : ℂ) (hw : s ≤ w.im) (hw1 : ‖w‖ ≤ 1) (hwr : 0 ≤ w.re)
+    {m : ℕ} (hm : 0 < m) {x t u : ℝ} (hx : |x| ≤ 1) (ht : 1 / 64 ≤ t) (hu : 0 ≤ u) :
+    (s / 20) / 1000 ≤ dist (markedLeftRoute w (s / 20) t) (completeMarkedAccess s w m x u) ∧
+    (s / 20) / 1000 ≤ dist (markedRightRoute w (s / 20) t) (completeMarkedAccess s w m x u) := by
+  have hwr1 := (Complex.re_le_norm w).trans hw1
+  have hwi1 := (Complex.im_le_norm w).trans hw1
+  have ha : 0 < s / 20 := by positivity
+  have ha1 : s / 20 ≤ 1 := by linarith
+  by_cases huT : u ≤ fitHighTime s w m
+  · rw [completeMarkedAccess, appendMarkedHook, curveJoin_of_le huT]
+    have hb := terminalAccess_bounds hs hs1 w hw hw1 hwr hm hx ⟨hu, huT⟩
+    have hq : w.re + 2 * (s / 20) ≤ (terminalAccess s w m x u).re := by linarith [hb.2.2.2]
+    have hh := markedRoutes_past_clearance (w := w) (q := terminalAccess s w m x u)
+      (t := t) (by linarith) hwr1 hwi1 ha.le ha1 ⟨hb.1, hb.2.1⟩ hb.2.2.1 (Or.inr hq)
+    constructor <;> linarith [hh.1, hh.2]
+  · rw [completeMarkedAccess, appendMarkedHook, curveJoin_of_gt (lt_of_not_ge huT)]
+    have hR : w.re < fitTerminalX s w := by
+      unfold fitTerminalX
+      rw [abs_of_nonneg hwr]
+      linarith
+    have hR2 : fitTerminalX s w ≤ 2 := by
+      unfold fitTerminalX
+      rw [abs_of_nonneg hwr]
+      linarith
+    have hh := markedRoutes_hook_clearance_early hwr hwr1 hwi1 hR hR2 ha ha1 ht
+      (show 0 ≤ u - fitHighTime s w m by linarith)
+    constructor <;> linarith [hh.1, hh.2]
+
+end SLEExactGauge.Serpentine
+
+end
+
+end OAI
diff --git a/lean/OAI/Probability/SLE/Gauge/SerpentineNormalizedMass.lean b/lean/OAI/Probability/SLE/Gauge/SerpentineNormalizedMass.lean
new file mode 100644
index 0000000000000000000000000000000000000000..fd1f5aa4371c98cd1ebacd80d9fbac7b44cd8dff
--- /dev/null
+++ b/lean/OAI/Probability/SLE/Gauge/SerpentineNormalizedMass.lean
@@ -0,0 +1,111 @@
+import OAI.Probability.SLE.Gauge.ActualRibbonStoppedMass
+import OAI.Probability.SLE.Gauge.SerpentineInitialPrefix
+import OAI.Probability.SLE.Gauge.SerpentineRetentionCount
+
+namespace OAI
+
+/-! The concrete connector and serpentine instantiate the actual stopped
+iteration. All m² selected strip masses are present by completion, with
+one positive initial probability and universal one-step constants. -/
+
+noncomputable section
+open Set Filter MeasureTheory ProbabilityTheory Metric
+open scoped Topology NNReal ENNReal
+
+namespace SLEExactGauge.Serpentine
+open RibbonCoordinates Target
+
+def experimentEntry (s : ℝ) (w : ℂ) (m : ℕ) : ℝ :=
+  connectorEntry (fitHeight m) (fitRadius m) (fitX s w m) (fitY s w m)
+
+def experimentSteps (s : ℝ) (w : ℂ) (m : ℕ) : ℕ := completionStep (experimentEntry s w m) m - 1
+
+def normalizedExperimentDisk (s : ℝ) (w : ℂ) (m : ℕ) : Set ℂ :=
+  (fun z : ℂ => (ribbonWidth (halfHeight s) m : ℂ) * z) ⁻¹' closedBall (center s w) (s / 20)
+
+lemma retained_middle_in_normalized_disk {s : ℝ} (hs : 0 < s) (w : ℂ) (hw : s ≤ w.im)
+    {m : ℕ} (hm : 0 < m) {ε : ℝ} (hε : ε ≤ 1) :
+    ∀ k ∈ retainedSteps (experimentEntry s w m) m,
+      physicalMiddleRegion (experimentChart s w m) closedRibbon k ε ⊆ normalizedExperimentDisk s w m := by
+  intro k hk z hz
+  obtain ⟨⟨j, i⟩, _, rfl⟩ := Finset.mem_image.mp hk
+  obtain ⟨a, ⟨ha, hl, hu, hi⟩, rfl⟩ := hz
+  change (ribbonWidth (halfHeight s) m : ℂ) * experimentChart s w m a ∈ closedBall (center s w) (s / 20)
+  rw [← physicalExperimentChart_eq]
+  dsimp only [experimentEntry] at hl hu
+  exact physicalExperimentChart_retained_disk hs w hw hm j.isLt i.isLt
+    ⟨by linarith, by linarith⟩ (hi.le.trans hε)
+
+/-- The actual normalized dense experiment, conditional only on the
+recorded published inputs. Completion is finite on success and all mass
+belongs to the stopped prefix at the prescribed common mesh. -/
+theorem uniform_serpentine_normalized_stopped_mass
+    {Ω : 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)
+    (ε : ℝ) (hε : 0 < ε) (hεsmall : ε ≤ 1 / 8) :
+    ∃ q₀ : ℝ≥0∞, ∃ q c v₀ : ℝ, 0 < q₀ ∧ q₀ ≤ 1 ∧ 0 < q ∧ q ≤ 1 ∧ 0 < c ∧ 0 < v₀ ∧
+      ∀ v : ℝ, 0 < v → v < v₀ → ∀ s : ℝ, 0 < s → ∀ w : ℂ, s ≤ w.im →
+      ∀ m : ℕ, 0 < m → ∀ g : C(ℂ, ℝ),
+      (∀ z ∈ closedRibbon, g (experimentChart s w m z) = z.re) →
+      ENNReal.ofReal q ^ experimentSteps s w m * q₀ ≤ μ {ω |
+        ω ∈ GoodRibbonPrefix γ (ribbonIntegerFront g γ (experimentSteps s w m)) (experimentChart s w m) ε ∧
+        ((m ^ 2 : ℕ) : ℝ≥0∞) * ENNReal.ofReal c ≤ segmentSausageCharge κ (γ ω) 0
+          ((ribbonIntegerFront g γ (experimentSteps s w m) ω).untopD 0) v (normalizedExperimentDisk s w m)} := by
+  obtain ⟨q, c, v₀, hq, hq1, hcm, hv₀, hiter⟩ := uniform_actual_ribbon_iteration μ κ hκ hκ8
+    B hB hm hc γ G F hw hcompact hboundary hsupport hplanar hstraight hexit hwiener W hW
+    2 2 (by norm_num) (by norm_num) ε hε hεsmall
+  have ha := brownian_capacity_trace_adapted B hm hc κ γ G F hw
+  have hγc : ∀ ω, Continuous (γ ω) := fun ω => (hw ω).1
+  have hSLE : IsOrdinaryChordalSLE κ γ μ :=
+    ⟨fun t => (ha t).mono (Filtration.le _ t) le_rfl, B, hB,
+      Filter.Eventually.of_forall (fun ω => ⟨G ω, F ω, hw ω⟩)⟩
+  have hε1 : ε ≤ 1 := by linarith
+  obtain ⟨q₀, hq₀, hinit⟩ := uniform_experiment_initial_goodPrefix_probability μ κ γ hSLE hsupport hε hε1
+  refine ⟨min q₀ 1, q, c, v₀, lt_min hq₀ (by norm_num), min_le_right _ _, hq, hq1, hcm, hv₀, ?_⟩
+  intro v hv hvcut s hs w hwy m hmp g hg
+  obtain ⟨hP, hi, hpatch, hH, hinitial⟩ := experimentChart_geometry hs w hwy hmp
+  have hemb := experimentChart_closedEmbedding hs w hwy hmp
+  have hP0 : experimentChart s w m 0 = 0 := by
+    simpa only [mul_zero] using hinitial 0 (by constructor <;> norm_num) (by norm_num)
+  have hg0 (ω : Ω) : g (γ ω 0) = 0 := by
+    rw [(hw ω).2.1, ← hP0]
+    exact hg 0 (by constructor <;> norm_num)
+  have hA : 0 ≤ experimentEntry s w m :=
+    (by unfold fitHeight; positivity : (0 : ℝ) ≤ fitHeight m).trans (fit_entry_lower hs w hwy hmp)
+  have hb := hiter v hv hvcut _ hemb hP.continuousOn hi hP0 hH
+    (experimentChart_escape s w m) (fun k => (hpatch k).1) (fun k => (hpatch k).2)
+    g hg (experimentSteps s w m)
+  calc
+    _ ≤ ENNReal.ofReal q ^ experimentSteps s w m *
+        μ (GoodRibbonPrefix γ (ribbonIntegerFront g γ 0) (experimentChart s w m) ε) := by
+      apply mul_le_mul' le_rfl
+      apply (min_le_left q₀ 1).trans
+      simpa only [ribbonIntegerFront, Nat.cast_zero, zero_add] using hinit s hs w hwy m hmp g hg
+    _ ≤ _ := hb.trans (measure_mono (by
+      intro ω hω
+      have hI : ∀ i ∈ retainedSteps (experimentEntry s w m) m, 0 < i ∧ i ≤ experimentSteps s w m := by
+        intro i hiI
+        obtain ⟨hi0, hic⟩ := retainedSteps_bounds hA hmp i hiI
+        exact ⟨hi0, by dsimp only [experimentSteps]; omega⟩
+      have hh := actual_successes_force_stopped_mass γ hγc g hg0 _ hplanar hP.continuousOn hi
+        ε κ v c hε1 (experimentSteps s w m) (retainedSteps (experimentEntry s w m) m) hI _
+        (retained_middle_in_normalized_disk hs w hwy hmp hε1) ω hω
+      simpa only [mem_ofPred_eq, retainedSteps_card hA hmp] using hh))
+
+end SLEExactGauge.Serpentine
+
+end
+
+end OAI
diff --git a/lean/OAI/Probability/SLE/Gauge/SerpentineParameters.lean b/lean/OAI/Probability/SLE/Gauge/SerpentineParameters.lean
new file mode 100644
index 0000000000000000000000000000000000000000..adcb0acfe246227c0d290111776725375968b1d3
--- /dev/null
+++ b/lean/OAI/Probability/SLE/Gauge/SerpentineParameters.lean
@@ -0,0 +1,150 @@
+import OAI.Probability.SLE.Gauge.SerpentineEscape
+import OAI.Probability.SLE.Gauge.SerpentineShadow
+
+namespace OAI
+
+/-! Concrete normalized connector parameters for the dense-visit layout.
+All constants depend only on the fixed positive angle lower bound. -/
+
+noncomputable section
+open Set Metric
+
+namespace SLEExactGauge.Serpentine
+
+def fitHeight (m : ℕ) : ℝ := 2500 * m
+
+def fitRadius (m : ℕ) : ℝ := 625 * m
+
+def fitX (s : ℝ) (w : ℂ) (m : ℕ) : ℝ :=
+  (|w.re| + s / 4 - halfHeight s) / ribbonWidth (halfHeight s) m
+
+def fitY (s : ℝ) (w : ℂ) (m : ℕ) : ℝ :=
+  (w.im - halfHeight s) / ribbonWidth (halfHeight s) m
+
+def fitEntryBound (s : ℝ) : ℝ := 40000 / s + 10000 + 1000 * Real.pi
+
+lemma fit_width_pos {s : ℝ} (hs : 0 < s) {m : ℕ} (hm : 0 < m) :
+    0 < ribbonWidth (halfHeight s) m := by
+  apply ribbonWidth_pos (by unfold halfHeight; positivity) hm
+
+lemma fit_width_eq (s : ℝ) (m : ℕ) :
+    ribbonWidth (halfHeight s) m = s / (20000 * m) := by
+  unfold ribbonWidth halfHeight
+  ring
+
+lemma fit_width_mul {s : ℝ} (_hs : 0 < s) {m : ℕ} (hm : 0 < m) :
+    ribbonWidth (halfHeight s) m * m = s / 20000 := by
+  rw [fit_width_eq]
+  have hm' : (m : ℝ) ≠ 0 := by exact_mod_cast hm.ne'
+  field_simp
+
+lemma fitX_eq {s : ℝ} (hs : 0 < s) (w : ℂ) {m : ℕ} (hm : 0 < m) :
+    fitX s w m = (20000 * |w.re| / s + 4900) * m := by
+  unfold fitX
+  rw [fit_width_eq]
+  unfold halfHeight
+  have hm' : (m : ℝ) ≠ 0 := by exact_mod_cast hm.ne'
+  field_simp [hs.ne', hm']
+  ring
+
+lemma fitY_eq {s : ℝ} (hs : 0 < s) (w : ℂ) {m : ℕ} (hm : 0 < m) :
+    fitY s w m = (20000 * w.im / s - 100) * m := by
+  unfold fitY
+  rw [fit_width_eq]
+  unfold halfHeight
+  have hm' : (m : ℝ) ≠ 0 := by exact_mod_cast hm.ne'
+  field_simp [hs.ne', hm']
+  ring
+
+lemma fitX_lower {s : ℝ} (hs : 0 < s) (w : ℂ) {m : ℕ} (hm : 0 < m) :
+    4900 * (m : ℝ) ≤ fitX s w m := by
+  rw [fitX_eq hs w hm]
+  have h := div_nonneg (mul_nonneg (by norm_num : (0 : ℝ) ≤ 20000) (abs_nonneg w.re)) hs.le
+  nlinarith [Nat.cast_nonneg (α := ℝ) m]
+
+lemma fitY_lower {s : ℝ} (hs : 0 < s) (w : ℂ) (hw : s ≤ w.im) {m : ℕ} (hm : 0 < m) :
+    19900 * (m : ℝ) ≤ fitY s w m := by
+  rw [fitY_eq hs w hm]
+  have h : (20000 : ℝ) ≤ 20000 * w.im / s := (le_div_iff₀ hs).mpr (by nlinarith)
+  nlinarith [Nat.cast_nonneg (α := ℝ) m]
+
+lemma fitX_upper {s : ℝ} (hs : 0 < s) (w : ℂ) (hw : ‖w‖ ≤ 1) {m : ℕ} (hm : 0 < m) :
+    fitX s w m ≤ (20000 / s + 4900) * m := by
+  rw [fitX_eq hs w hm]
+  have hre : |w.re| ≤ 1 := (Complex.abs_re_le_norm w).trans hw
+  have h : 20000 * |w.re| / s ≤ 20000 / s := by
+    apply div_le_div_of_nonneg_right _ hs.le
+    nlinarith
+  exact mul_le_mul_of_nonneg_right (by linarith) (Nat.cast_nonneg m)
+
+lemma fitY_upper {s : ℝ} (hs : 0 < s) (w : ℂ) (hw : ‖w‖ ≤ 1) {m : ℕ} (hm : 0 < m) :
+    fitY s w m ≤ (20000 / s) * m := by
+  rw [fitY_eq hs w hm]
+  have him : w.im ≤ 1 := (Complex.im_le_norm w).trans hw
+  have h : 20000 * w.im / s ≤ 20000 / s := by
+    apply div_le_div_of_nonneg_right _ hs.le
+    nlinarith
+  exact mul_le_mul_of_nonneg_right (by linarith) (Nat.cast_nonneg m)
+
+/-- The fixed numerical parameters satisfy all proved global embedding
+and local ribbon estimates, with ample strict separation. -/
+theorem fit_parameters {s : ℝ} (hs : 0 < s) (w : ℂ) (hw : s ≤ w.im)
+    {m : ℕ} (hm : 0 < m) :
+    50 ≤ fitRadius m ∧ 2 * fitRadius m < fitX s w m ∧
+      fitHeight m + 2 * fitRadius m + 1 + 300 * m < fitY s w m ∧
+      4 ≤ fitHeight m := by
+  have hm' : (1 : ℝ) ≤ m := by exact_mod_cast hm
+  have hx := fitX_lower hs w hm
+  have hy := fitY_lower hs w hw hm
+  dsimp only [fitRadius, fitHeight]
+  constructor
+  · nlinarith
+  constructor
+  · nlinarith
+  constructor <;> nlinarith
+
+lemma fitEntryBound_pos {s : ℝ} (hs : 0 < s) : 0 < fitEntryBound s := by
+  unfold fitEntryBound
+  positivity
+
+lemma connectorEntry_eq (H r X Y : ℝ) :
+    connectorEntry H r X Y = Real.pi * r + X + Y - 4 * r := by
+  unfold connectorEntry connectorFourth connectorThird connectorSecond quarterLength
+  ring
+
+lemma fit_entry_upper {s : ℝ} (hs : 0 < s) (w : ℂ) (hw : ‖w‖ ≤ 1)
+    {m : ℕ} (hm : 0 < m) :
+    connectorEntry (fitHeight m) (fitRadius m) (fitX s w m) (fitY s w m) ≤ fitEntryBound s * m := by
+  have hx := fitX_upper hs w hw hm
+  have hy := fitY_upper hs w hw hm
+  rw [connectorEntry_eq]
+  dsimp only [fitRadius, fitEntryBound]
+  have hdiv : 40000 / s = 2 * (20000 / s) := by ring
+  rw [hdiv]
+  nlinarith [mul_nonneg Real.pi_pos.le (Nat.cast_nonneg (α := ℝ) m)]
+
+lemma fit_entry_lower {s : ℝ} (hs : 0 < s) (w : ℂ) (hw : s ≤ w.im)
+    {m : ℕ} (hm : 0 < m) :
+    fitHeight m ≤ connectorEntry (fitHeight m) (fitRadius m) (fitX s w m) (fitY s w m) := by
+  have hx := fitX_lower hs w hm
+  have hy := fitY_lower hs w hw hm
+  have hm' : (0 : ℝ) ≤ m := Nat.cast_nonneg m
+  rw [connectorEntry_eq]
+  dsimp only [fitHeight, fitRadius]
+  nlinarith [Real.pi_pos]
+
+lemma fit_completion_quadratic {s : ℝ} (hs : 0 < s) (w : ℂ) (hw : ‖w‖ ≤ 1)
+    (hwy : s ≤ w.im) {m : ℕ} (hm : 0 < m) :
+    (completionStep (connectorEntry (fitHeight m) (fitRadius m) (fitX s w m) (fitY s w m)) m : ℝ) ≤
+      (fitEntryBound s + 601 + 100 * Real.pi) * (m : ℝ) ^ 2 := by
+  apply completionStep_quadratic_bound
+  · exact (by unfold fitHeight; positivity : (0 : ℝ) ≤ fitHeight m).trans (fit_entry_lower hs w hwy hm)
+  · exact (fitEntryBound_pos hs).le
+  · exact hm
+  · exact fit_entry_upper hs w hw hm
+
+end SLEExactGauge.Serpentine
+
+end
+
+end OAI
diff --git a/lean/OAI/Probability/SLE/Gauge/SerpentinePhysicalGeometry.lean b/lean/OAI/Probability/SLE/Gauge/SerpentinePhysicalGeometry.lean
new file mode 100644
index 0000000000000000000000000000000000000000..3c54082530a84d155e9d98cdfa93b13234fa89c8
--- /dev/null
+++ b/lean/OAI/Probability/SLE/Gauge/SerpentinePhysicalGeometry.lean
@@ -0,0 +1,47 @@
+import OAI.Probability.SLE.Gauge.SerpentinePhysicalMass
+
+namespace OAI
+
+/-! Properness and half-plane geometry of the physical fitted chart.
+Only the normalized chart is used in the uniform probabilistic iteration. -/
+
+noncomputable section
+open Set Filter Metric
+open scoped Topology NNReal
+
+namespace SLEExactGauge.Serpentine
+open RibbonCoordinates
+
+theorem physicalFitChart_geometry {s : ℝ} (hs : 0 < s) (w : ℂ) (hw : s ≤ w.im)
+    {m : ℕ} (hm : 0 < m) :
+    Continuous (physicalFitChart s w m) ∧ InjOn (physicalFitChart s w m) closedRibbon ∧
+      (∀ z ∈ closedRibbon, 0 < z.re → physicalFitChart s w m z ∈ upperHalfPlane) ∧
+      Tendsto (fun t : ℝ => ‖physicalFitChart s w m (t : ℂ)‖) atTop atTop := by
+  have hℓ := fit_width_pos hs hm
+  refine ⟨continuous_const.mul (fitChart_continuous hs w hw hm), ?_, ?_, ?_⟩
+  · intro z hz z' hz' he
+    apply fitChart_injective hs w hw hm hz hz'
+    exact mul_left_cancel₀ (Complex.ofReal_ne_zero.mpr hℓ.ne') he
+  · intro z hz hz0
+    have hh : 0 < (fitChart s w m z).im := fitChart_upper hs w hw hm z hz hz0
+    change 0 < ((ribbonWidth (halfHeight s) m : ℂ) * fitChart s w m z).im
+    simpa only [Complex.mul_im, Complex.ofReal_re, Complex.ofReal_im, zero_mul, add_zero] using mul_pos hℓ hh
+  · have hn : Tendsto (fun t : ℝ => ‖fitChart s w m (t : ℂ)‖) atTop atTop := by
+      simpa only [fitChart, normalRibbon, Complex.ofReal_im, Complex.ofReal_re,
+        Complex.ofReal_zero, zero_mul, zero_add, add_zero, fitSpine, Function.comp_def] using
+        tendsto_norm_cocompact_atTop.comp
+          (completeSpine_escape m (fitHeight m) (fitRadius m) (fitX s w m) (fitY s w m))
+    have hh := hn.const_mul_atTop hℓ
+    simpa only [physicalFitChart, norm_mul, Complex.norm_real, Real.norm_eq_abs, abs_of_pos hℓ] using hh
+
+lemma physicalFitChart_zero {s : ℝ} (hs : 0 < s) (w : ℂ) (hw : s ≤ w.im)
+    {m : ℕ} (hm : 0 < m) : physicalFitChart s w m 0 = 0 := by
+  have he := fitChart_initial hs w hw hm
+    (z := 0) (show (0 : ℂ).re ≤ fitHeight m by unfold fitHeight; positivity)
+  simp only [physicalFitChart, he, mul_zero]
+
+end SLEExactGauge.Serpentine
+
+end
+
+end OAI
diff --git a/lean/OAI/Probability/SLE/Gauge/SerpentinePhysicalMass.lean b/lean/OAI/Probability/SLE/Gauge/SerpentinePhysicalMass.lean
new file mode 100644
index 0000000000000000000000000000000000000000..2d5a9b895dc93574a076bce5614f8c2e04a9c35c
--- /dev/null
+++ b/lean/OAI/Probability/SLE/Gauge/SerpentinePhysicalMass.lean
@@ -0,0 +1,136 @@
+import OAI.Probability.SLE.Gauge.SerpentineExponentialMass
+import OAI.Probability.SLE.Gauge.RibbonStoppedMassLaw
+
+namespace OAI
+
+/-! The stopped dense serpentine experiment in the original half-plane
+coordinates, with one common physical sausage mesh and its exact m^(2-d)
+mass threshold. -/
+
+noncomputable section
+open Set Filter MeasureTheory ProbabilityTheory Metric
+open scoped Topology NNReal ENNReal
+
+namespace SLEExactGauge.Serpentine
+open RibbonCoordinates Target ScaleTraceLaw RibbonPassageScaling
+
+local instance : MeasurableSpace C(ℝ≥0, ℂ) := borel _
+local instance : BorelSpace C(ℝ≥0, ℂ) := ⟨rfl⟩
+
+lemma physicalExperimentChart_closedEmbedding {s : ℝ} (hs : 0 < s) (w : ℂ)
+    (hw : s ≤ w.im) {m : ℕ} (hm : 0 < m) :
+    Topology.IsClosedEmbedding (fun z : closedRibbon => physicalExperimentChart s w m z) := by
+  have hℓ := fit_width_pos hs hm
+  have hh := (Homeomorph.mulLeft₀ (ribbonWidth (halfHeight s) m : ℂ)
+    (Complex.ofReal_ne_zero.mpr hℓ.ne')).isClosedEmbedding.comp
+    (experimentChart_closedEmbedding hs w hw hm)
+  change Topology.IsClosedEmbedding (fun z : closedRibbon =>
+    (ribbonWidth (halfHeight s) m : ℂ) * experimentChart s w m z) at hh
+  simpa only [Function.comp_def, physicalExperimentChart_eq] using hh
+
+lemma normalizedExperimentDisk_scaled {s : ℝ} (hs : 0 < s) (w : ℂ)
+    {m : ℕ} (hm : 0 < m) :
+    affine 0 (ribbonWidth (halfHeight s) m) '' normalizedExperimentDisk s w m =
+      closedBall (center s w) (s / 20) := by
+  have hℓ := fit_width_pos hs hm
+  change (fun z : ℂ => 0 + (ribbonWidth (halfHeight s) m : ℂ) * z) ''
+    ((fun z : ℂ => (ribbonWidth (halfHeight s) m : ℂ) * z) ⁻¹' closedBall (center s w) (s / 20)) = _
+  have hh := Set.image_preimage_eq (closedBall (center s w) (s / 20)) (affine_bijective 0 hℓ).surjective
+  change (fun z : ℂ => 0 + (ribbonWidth (halfHeight s) m : ℂ) * z) ''
+    ((fun z : ℂ => 0 + (ribbonWidth (halfHeight s) m : ℂ) * z) ⁻¹'
+      closedBall (center s w) (s / 20)) = _ at hh
+  simpa only [zero_add] using hh
+
+lemma physical_ribbon_mass_threshold (κ c s : ℝ) (hs : 0 < s)
+    (m : ℕ) (hm : 0 < m) :
+    ENNReal.ofReal (ribbonWidth (halfHeight s) m ^ dimension κ) *
+        (((m ^ 2 : ℕ) : ℝ≥0∞) * ENNReal.ofReal c) =
+      ENNReal.ofReal (c * (s / 20000) ^ dimension κ * (m : ℝ) ^ codimension κ) := by
+  have he : ribbonWidth (halfHeight s) m = (s / 20000) / (m : ℝ) := by
+    rw [fit_width_eq]
+    rw [div_div]
+  rw [← ENNReal.ofReal_natCast, ← ENNReal.ofReal_mul (by positivity : (0 : ℝ) ≤ (m ^ 2 : ℕ)),
+    ← ENNReal.ofReal_mul (Real.rpow_nonneg (fit_width_pos hs hm).le _)]
+  congr 1
+  rw [he]
+  simp only [Nat.cast_pow]
+  exact ribbon_mass_after_width_scaling κ c (s / 20000) (by positivity) m hm
+
+theorem uniform_serpentine_physical_stopped_mass
+    {Ω : 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)
+    (ε : ℝ) (hε : 0 < ε) (hεsmall : ε ≤ 1 / 8) :
+    ∃ c v₀ : ℝ, 0 < c ∧ 0 < v₀ ∧ ∀ s : ℝ, 0 < s →
+      ∃ C : ℝ, 0 < C ∧ ∀ w : ℂ, ‖w‖ ≤ 1 → s ≤ w.im → ∀ m : ℕ, 0 < m →
+      ∀ v : ℝ, 0 < v → v < ribbonWidth (halfHeight s) m * v₀ → ∀ g : C(ℂ, ℝ),
+      (∀ z ∈ closedRibbon, g (physicalExperimentChart s w m z) = z.re) →
+      ENNReal.ofReal (Real.exp (-C * (m : ℝ) ^ 2)) ≤ μ {ω |
+        ω ∈ GoodRibbonPrefix γ (ribbonIntegerFront g γ (experimentSteps s w m))
+          (physicalExperimentChart s w m) ε ∧
+        ENNReal.ofReal (c * (s / 20000) ^ dimension κ * (m : ℝ) ^ codimension κ) ≤
+          segmentSausageCharge κ (γ ω) 0
+            ((ribbonIntegerFront g γ (experimentSteps s w m) ω).untopD 0)
+            v (closedBall (center s w) (s / 20))} := by
+  obtain ⟨c, v₀, hcm, hv₀, hprob⟩ := uniform_serpentine_exponential_stopped_mass μ κ hκ hκ8
+    B hB hm hc γ G F hw hcompact hboundary hsupport hplanar hstraight hexit hwiener W hW ε hε hεsmall
+  let f := sourceTracePath γ (fun ω => (hw ω).1)
+  have ha := brownian_capacity_trace_adapted B hm hc κ γ G F hw
+  have hfm : Measurable f := source_path_measurable _
+    (fun t => (ha t).mono (Filtration.le _ t) le_rfl)
+  refine ⟨c, v₀, hcm, hv₀, fun s hs => ?_⟩
+  obtain ⟨C, hC, hprob⟩ := hprob s hs
+  refine ⟨C, hC, fun w hwn hwy m hmp v hv hvcut g hg => ?_⟩
+  let ℓ := ribbonWidth (halfHeight s) m
+  have hℓ : 0 < ℓ := fit_width_pos hs hmp
+  let ell : ℝ≥0 := ⟨ℓ, hℓ.le⟩
+  have hell : 0 < ell := hℓ
+  let gn : C(ℂ, ℝ) := g.comp ⟨fun z : ℂ => (ℓ : ℂ) * z, continuous_const.mul continuous_id⟩
+  have hgg (z : ℂ) : g ((ell : ℂ) * z) = gn z := rfl
+  have hgn (z : ℂ) (hz : z ∈ closedRibbon) : gn (experimentChart s w m z) = z.re := by
+    change g ((ℓ : ℂ) * experimentChart s w m z) = z.re
+    rw [← physicalExperimentChart_eq]
+    exact hg z hz
+  have hvn : 0 < v / ℓ := div_pos hv hℓ
+  have hvncut : v / ℓ < v₀ := (div_lt_iff₀ hℓ).mpr (by simpa only [mul_comm] using hvcut)
+  have hstart := hprob (v / ℓ) hvn hvncut w hwn hwy m hmp gn hgn
+  have he : Topology.IsClosedEmbedding (fun z : closedRibbon => (ell : ℂ) * experimentChart s w m z) := by
+    have he' := physicalExperimentChart_closedEmbedding hs w hwy hmp
+    simp only [physicalExperimentChart_eq] at he'
+    change Topology.IsClosedEmbedding (fun z : closedRibbon =>
+      (ribbonWidth (halfHeight s) m : ℂ) * experimentChart s w m z)
+    exact he'
+  have htrans := ribbonStoppedMass_scale_probability μ f hfm ell hell
+    (scaled_trace_path_law κ hκ hκ8 B hB hm hc γ G F hw ell hell)
+    (experimentChart s w m) he gn g hgg ((experimentSteps s w m : ℝ) + 1) ε κ hvn
+    (normalizedExperimentDisk s w m) (((m ^ 2 : ℕ) : ℝ≥0∞) * ENNReal.ofReal c)
+  have hmass := physical_ribbon_mass_threshold κ c s hs m hmp
+  have hmesh : (ell : ℝ) * (v / ℓ) = v := mul_div_cancel₀ v hℓ.ne'
+  have hregion : affine 0 (ell : ℝ) '' normalizedExperimentDisk s w m =
+      closedBall (center s w) (s / 20) := normalizedExperimentDisk_scaled hs w hmp
+  apply hstart.trans
+  have hchart : (fun z : ℂ => (ell : ℂ) * experimentChart s w m z) = physicalExperimentChart s w m := by
+    funext z
+    exact (physicalExperimentChart_eq s w m z).symm
+  have hmass' : ENNReal.ofReal ((ell : ℝ) ^ dimension κ) *
+      (((m ^ 2 : ℕ) : ℝ≥0∞) * ENNReal.ofReal c) =
+      ENNReal.ofReal (c * (s / 20000) ^ dimension κ * (m : ℝ) ^ codimension κ) := hmass
+  simpa only [ribbonStoppedMassEvent, GoodRibbonPrefix, mem_ofPred_eq, f, sourceTracePath,
+    ContinuousMap.coe_mk, ribbonIntegerFront, ribbonFrontStop, hmesh, hregion, hmass', hchart] using htrans
+
+end SLEExactGauge.Serpentine
+
+end
+
+end OAI
diff --git a/lean/OAI/Probability/SLE/Gauge/SerpentinePieces.lean b/lean/OAI/Probability/SLE/Gauge/SerpentinePieces.lean
new file mode 100644
index 0000000000000000000000000000000000000000..267f44a70970e6f8f0a6c90ab52c0caee68475bb
--- /dev/null
+++ b/lean/OAI/Probability/SLE/Gauge/SerpentinePieces.lean
@@ -0,0 +1,117 @@
+import OAI.Probability.SLE.Geometry.CurveJoin
+import OAI.Probability.SLE.Gauge.SerpentineLayout
+
+namespace OAI
+
+/-! Unit-speed straight and semicircular pieces in ribbon-width units.
+Their tangents match at each join and have the uniform Lipschitz bound
+1/50 required by the fixed local ribbon constants. -/
+
+noncomputable section
+open Set Metric
+open scoped NNReal
+
+namespace SLEExactGauge.Serpentine
+
+def straightPiece (m j : ℕ) (t : ℝ) : ℂ :=
+  ((-100 * (m : ℝ) + 100 * j : ℝ) : ℂ) +
+    ((side j * (-100 * (m : ℝ) + t) : ℝ) : ℂ) * Complex.I
+
+def straightTangent (j : ℕ) : ℂ := (side j : ℂ) * Complex.I
+
+def circularPiece (m j : ℕ) (t : ℝ) : ℂ :=
+  ((-100 * (m : ℝ) + 100 * j + 50 - 50 * Real.cos (t / 50) : ℝ) : ℂ) +
+    ((side j * (100 * (m : ℝ) + 50 * Real.sin (t / 50)) : ℝ) : ℂ) * Complex.I
+
+def circularTangent (j : ℕ) (t : ℝ) : ℂ :=
+  (Real.sin (t / 50) : ℂ) + ((side j * Real.cos (t / 50) : ℝ) : ℂ) * Complex.I
+
+lemma straightPiece_hasDerivAt (m j : ℕ) (t : ℝ) :
+    HasDerivAt (straightPiece m j) (straightTangent j) t := by
+  have hd := (((hasDerivAt_id t).const_add (-100 * (m : ℝ))).const_mul (side j)).ofReal_comp
+  convert (hd.mul_const Complex.I).const_add (((-100 * (m : ℝ) + 100 * j : ℝ) : ℂ)) using 1 <;> try rfl
+  simp only [straightTangent, mul_one]
+
+lemma circularPiece_hasDerivAt (m j : ℕ) (t : ℝ) :
+    HasDerivAt (circularPiece m j) (circularTangent j t) t := by
+  have ht : HasDerivAt (fun u : ℝ => u / 50) (1 / 50) t :=
+    (hasDerivAt_id t).div_const 50
+  have hx := (ht.cos.const_mul 50).const_sub (-100 * (m : ℝ) + 100 * j + 50)
+  have hy := ((ht.sin.const_mul 50).const_add (100 * (m : ℝ))).const_mul (side j)
+  convert hx.ofReal_comp.add (hy.ofReal_comp.mul_const Complex.I) using 1 <;> try rfl
+  all_goals simp only [circularTangent]
+  all_goals push_cast
+  all_goals ring
+
+lemma straightTangent_norm (j : ℕ) : ‖straightTangent j‖ = 1 := by
+  simp only [straightTangent, norm_mul, Complex.norm_real, Real.norm_eq_abs, side_abs,
+    Complex.norm_I, mul_one]
+
+lemma circularTangent_norm (j : ℕ) (t : ℝ) : ‖circularTangent j t‖ = 1 := by
+  apply (sq_eq_sq₀ (norm_nonneg _) zero_le_one).mp
+  rw [circularTangent, Complex.sq_norm, Complex.normSq_apply]
+  simp only [Complex.add_re, Complex.ofReal_re, Complex.mul_re, Complex.ofReal_im,
+    Complex.I_re, Complex.I_im, mul_zero, sub_zero, add_zero, Complex.add_im,
+    Complex.mul_im, mul_one, zero_add]
+  calc
+    _ = Real.sin (t / 50) ^ 2 + side j ^ 2 * Real.cos (t / 50) ^ 2 := by ring
+    _ = 1 ^ 2 := by rw [side_sq, one_mul]; nlinarith [Real.sin_sq_add_cos_sq (t / 50)]
+
+lemma circularTangent_hasDerivAt (j : ℕ) (t : ℝ) :
+    HasDerivAt (circularTangent j)
+      (((Real.cos (t / 50) / 50 : ℝ) : ℂ) - ((side j * Real.sin (t / 50) / 50 : ℝ) : ℂ) * Complex.I) t := by
+  have ht : HasDerivAt (fun u : ℝ => u / 50) (1 / 50) t :=
+    (hasDerivAt_id t).div_const 50
+  convert ht.sin.ofReal_comp.add ((ht.cos.const_mul (side j)).ofReal_comp.mul_const Complex.I)
+    using 1 <;> try rfl
+  all_goals push_cast
+  all_goals ring
+
+lemma circularTangent_deriv_norm (j : ℕ) (t : ℝ) :
+    ‖((Real.cos (t / 50) / 50 : ℝ) : ℂ) -
+      ((side j * Real.sin (t / 50) / 50 : ℝ) : ℂ) * Complex.I‖ = (1 / 50 : ℝ) := by
+  apply (sq_eq_sq₀ (norm_nonneg _) (by norm_num : (0 : ℝ) ≤ 1 / 50)).mp
+  rw [Complex.sq_norm, Complex.normSq_apply]
+  simp only [Complex.sub_re, Complex.sub_im, Complex.ofReal_re,
+    Complex.ofReal_im, Complex.mul_re, Complex.mul_im, Complex.I_re, Complex.I_im,
+    mul_zero, sub_zero, zero_sub, mul_one, add_zero]
+  calc
+    _ = (Real.cos (t / 50) ^ 2 + side j ^ 2 * Real.sin (t / 50) ^ 2) / 50 ^ 2 := by ring
+    _ = (1 / 50 : ℝ) ^ 2 := by
+      rw [side_sq, one_mul]
+      nlinarith [Real.sin_sq_add_cos_sq (t / 50)]
+
+lemma circularTangent_lipschitz (j : ℕ) : LipschitzWith (1 / 50) (circularTangent j) := by
+  apply lipschitzWith_of_nnnorm_deriv_le (fun t => (circularTangent_hasDerivAt j t).differentiableAt)
+  intro t
+  rw [(circularTangent_hasDerivAt j t).deriv]
+  exact_mod_cast (circularTangent_deriv_norm j t).le
+
+lemma straight_circular_position_match (m j : ℕ) :
+    straightPiece m j (200 * m) = circularPiece m j 0 := by
+  apply Complex.ext
+  · simp [straightPiece, circularPiece]
+  · simp only [straightPiece, circularPiece, Complex.add_im, Complex.ofReal_im,
+      Complex.mul_im, Complex.I_re, Complex.I_im, Complex.ofReal_re,
+      mul_zero, mul_one, add_zero, zero_add, zero_div, Real.sin_zero]
+    ring
+
+lemma circular_straight_position_match (m j : ℕ) :
+    circularPiece m j (50 * Real.pi) = straightPiece m (j + 1) 0 := by
+  apply Complex.ext
+  · simp [straightPiece, circularPiece, side_succ]
+    ring
+  · simp [straightPiece, circularPiece, side_succ]
+
+lemma straight_circular_tangent_match (j : ℕ) :
+    straightTangent j = circularTangent j 0 := by simp [straightTangent, circularTangent]
+
+lemma circular_straight_tangent_match (j : ℕ) :
+    circularTangent j (50 * Real.pi) = straightTangent (j + 1) := by
+  simp [straightTangent, circularTangent, side_succ]
+
+end SLEExactGauge.Serpentine
+
+end
+
+end OAI
diff --git a/lean/OAI/Probability/SLE/Gauge/SerpentineReflection.lean b/lean/OAI/Probability/SLE/Gauge/SerpentineReflection.lean
new file mode 100644
index 0000000000000000000000000000000000000000..26506e4d0afc1862eff3ed40722a1344867a8851
--- /dev/null
+++ b/lean/OAI/Probability/SLE/Gauge/SerpentineReflection.lean
@@ -0,0 +1,76 @@
+import OAI.Probability.SLE.Gauge.SerpentineCompleteEmbedding
+import OAI.Probability.SLE.LoewnerReflection
+
+namespace OAI
+
+/-! Reflecting the deterministic ribbon to the left of the imaginary
+axis preserves its chart geometry. No stochastic symmetry is used. -/
+
+noncomputable section
+open Set Metric ComplexConjugate
+open scoped NNReal
+
+namespace SLEExactGauge.Serpentine
+open RibbonCoordinates
+
+def reflectedChart (P : ℂ → ℂ) (z : ℂ) : ℂ := loewnerMirror (P (conj z))
+
+lemma conj_mem_closedRibbon {z : ℂ} (hz : z ∈ closedRibbon) : conj z ∈ closedRibbon := by
+  simpa only [closedRibbon, mem_ofPred_eq, Complex.conj_re, Complex.conj_im, abs_neg] using hz
+
+lemma conj_mem_stepPatch {k : ℝ} {z : ℂ} (hz : z ∈ ribbonStepPatch k) :
+    conj z ∈ ribbonStepPatch k := by
+  simpa only [ribbonStepPatch, mem_ofPred_eq, Complex.conj_re, Complex.conj_im, abs_neg] using hz
+
+lemma reflectedChart_continuous {P : ℂ → ℂ} (hP : Continuous P) : Continuous (reflectedChart P) :=
+  loewnerMirror.continuous.comp (hP.comp Complex.continuous_conj)
+
+lemma reflectedChart_injective {P : ℂ → ℂ} (hP : InjOn P closedRibbon) :
+    InjOn (reflectedChart P) closedRibbon := by
+  intro z hz w hw he
+  have hh := hP (conj_mem_closedRibbon hz) (conj_mem_closedRibbon hw) (loewnerMirror.injective he)
+  exact Complex.conjLIE.injective hh
+
+lemma reflectedChart_patch_upper {P : ℂ → ℂ} {C : ℝ≥0} {k : ℝ}
+    (hP : LipschitzOnWith C P (ribbonStepPatch k)) :
+    LipschitzOnWith C (reflectedChart P) (ribbonStepPatch k) := by
+  apply lipschitzOnWith_iff_dist_le_mul.mpr
+  intro z hz w hw
+  simpa only [reflectedChart, loewnerMirror_dist, Complex.dist_conj_conj] using
+    hP.dist_le_mul _ (conj_mem_stepPatch hz) _ (conj_mem_stepPatch hw)
+
+lemma reflectedChart_patch_lower {P : ℂ → ℂ} {L k : ℝ}
+    (hP : ∀ z ∈ ribbonStepPatch k, ∀ w ∈ ribbonStepPatch k, dist z w ≤ L * dist (P z) (P w)) :
+    ∀ z ∈ ribbonStepPatch k, ∀ w ∈ ribbonStepPatch k,
+      dist z w ≤ L * dist (reflectedChart P z) (reflectedChart P w) := by
+  intro z hz w hw
+  simpa only [reflectedChart, loewnerMirror_dist, Complex.dist_conj_conj] using
+    hP (conj z) (conj_mem_stepPatch hz) (conj w) (conj_mem_stepPatch hw)
+
+lemma reflectedChart_upper {P : ℂ → ℂ}
+    (hP : ∀ z ∈ closedRibbon, 0 < z.re → P z ∈ upperHalfPlane) :
+    ∀ z ∈ closedRibbon, 0 < z.re → reflectedChart P z ∈ upperHalfPlane := by
+  intro z hz hz0
+  have hh := hP (conj z) (conj_mem_closedRibbon hz) (by simpa using hz0)
+  simpa only [reflectedChart, upperHalfPlane, mem_ofPred_eq, loewnerMirror_im] using hh
+
+lemma reflectedChart_initial {P : ℂ → ℂ} {H : ℝ}
+    (hP : ∀ z ∈ closedRibbon, z.re ≤ H → P z = Complex.I * z) :
+    ∀ z ∈ closedRibbon, z.re ≤ H → reflectedChart P z = Complex.I * z := by
+  intro z hz hzH
+  rw [reflectedChart, hP (conj z) (conj_mem_closedRibbon hz) (by simpa using hzH)]
+  simp [loewnerMirror]
+
+lemma reflectedChart_width {P : ℂ → ℂ} {σ : ℝ → ℂ}
+    (hwidth : ∀ z ∈ closedRibbon, ‖P z - σ z.re‖ ≤ 1) :
+    ∀ z ∈ closedRibbon, ‖reflectedChart P z - loewnerMirror (σ z.re)‖ ≤ 1 := by
+  intro z hz
+  have hh := hwidth (conj z) (conj_mem_closedRibbon hz)
+  rw [← dist_eq_norm, reflectedChart, loewnerMirror_dist]
+  simpa only [dist_eq_norm, Complex.conj_re] using hh
+
+end SLEExactGauge.Serpentine
+
+end
+
+end OAI
diff --git a/lean/OAI/Probability/SLE/Gauge/SerpentineRetainedStrips.lean b/lean/OAI/Probability/SLE/Gauge/SerpentineRetainedStrips.lean
new file mode 100644
index 0000000000000000000000000000000000000000..95e1d6c495ee5977d5d059532c519343ebd0eec0
--- /dev/null
+++ b/lean/OAI/Probability/SLE/Gauge/SerpentineRetainedStrips.lean
@@ -0,0 +1,90 @@
+import OAI.Probability.SLE.Gauge.SerpentineParameters
+import OAI.Probability.SLE.Gauge.SerpentineStepCount
+import OAI.Probability.SLE.Gauge.SerpentineCompleteEmbedding
+
+namespace OAI
+
+/-! The prescribed integer middle strips are actual straight portions
+of the joined serpentine, with exactly m² distinct retained indices. -/
+
+noncomputable section
+open Set Metric
+
+namespace SLEExactGauge.Serpentine
+
+lemma columnEntry_mono (A : ℝ) (m : ℕ) {i j : ℕ} (hij : i ≤ j) :
+    columnEntry A m i ≤ columnEntry A m j := by
+  have hij' : (i : ℝ) ≤ j := by exact_mod_cast hij
+  have hD : 0 ≤ 200 * (m : ℝ) + 50 * Real.pi := by positivity
+  unfold columnEntry
+  nlinarith
+
+lemma array_preserves_column {m i last : ℕ} (hi : i ≤ last) {t : ℝ}
+    (ht : t ≤ arrayEnd m i) :
+    arraySpine m last t = arraySpine m i t ∧ arrayTangent m last t = arrayTangent m i t := by
+  induction last with
+  | zero =>
+    have hi0 : i = 0 := by omega
+    subst i
+    exact ⟨rfl, rfl⟩
+  | succ last ih =>
+    by_cases hil : i = last + 1
+    · subst i; exact ⟨rfl, rfl⟩
+    · have hil' : i ≤ last := by omega
+      have ht' : t ≤ columnEntry 0 m last + 200 * m := by
+        have he := columnEntry_mono 0 m hil'
+        dsimp only [arrayEnd] at ht
+        linarith
+      have hc : t ≤ columnEntry 0 m (last + 1) := by
+        rw [columnEntry_succ]
+        linarith [Real.pi_pos]
+      obtain ⟨hs, hT⟩ := ih hil'
+      constructor
+      · simpa only [arraySpine, curveJoin_of_le hc, curveJoin_of_le ht'] using hs
+      · simpa only [arrayTangent, curveJoin_of_le hc, curveJoin_of_le ht'] using hT
+
+lemma array_on_column {m i last : ℕ} (hi : i ≤ last) {t : ℝ}
+    (ht : t ∈ Icc (columnEntry 0 m i) (arrayEnd m i)) :
+    arraySpine m last t = straightPiece m i (t - columnEntry 0 m i) ∧
+      arrayTangent m last t = straightTangent i := by
+  obtain ⟨hs, hT⟩ := array_preserves_column hi ht.2
+  rw [hs, hT, arraySpine_tail m i ht.1, arrayTangent_tail m i ht.1]
+  exact ⟨rfl, rfl⟩
+
+lemma complete_normal_on_column {m i : ℕ} (hm : 0 < m) (hi : i ≤ 2 * m)
+    (H r X Y : ℝ) {z : ℂ}
+    (hz : z.re - connectorEntry H r X Y ∈
+      Ioo (columnEntry 0 m i) (arrayEnd m i)) :
+    normalRibbon (completeSpine m H r X Y) (completeTangent m H r X Y) z =
+      arrayCenter m X Y + columnPoint 0 (100 * m) m i
+        (side i * (-100 * m + (z.re - connectorEntry H r X Y - columnEntry 0 m i))) z.im := by
+  have hentry : connectorEntry H r X Y < z.re := by
+    have he : 0 ≤ columnEntry 0 m i := by unfold columnEntry; positivity
+    linarith [hz.1]
+  rw [complete_normal_of_gt m H r X Y hentry]
+  have hpart := array_on_column hi ⟨hz.1.le, hz.2.le⟩
+  simp only [normalRibbon, Complex.sub_re, Complex.sub_im, Complex.ofReal_re,
+    Complex.ofReal_im, sub_zero]
+  rw [hpart.1, hpart.2, normal_straight_eq hm]
+
+lemma retained_strip_on_column {m j i : ℕ} (hm : 0 < m) (hj : j < m) (hi : i < m)
+    (H r X Y : ℝ) (hA : 0 ≤ connectorEntry H r X Y) {z : ℂ}
+    (hz : z.re ∈ Icc
+      ((retainedStep (connectorEntry H r X Y) m j i : ℝ) + 1 / 3)
+      ((retainedStep (connectorEntry H r X Y) m j i : ℝ) + 2 / 3)) :
+    normalRibbon (completeSpine m H r X Y) (completeTangent m H r X Y) z =
+      arrayCenter m X Y + columnPoint 0 (100 * m) m j
+        (side j * (-100 * m + (z.re - connectorEntry H r X Y - columnEntry 0 m j))) z.im := by
+  apply complete_normal_on_column hm (by omega)
+  have he := retained_middle_in_straight hA hi hz
+  have hc : columnEntry (connectorEntry H r X Y) m j =
+      connectorEntry H r X Y + columnEntry 0 m j := by unfold columnEntry; ring
+  rw [hc] at he
+  dsimp only [arrayEnd]
+  constructor <;> linarith [he.1, he.2]
+
+end SLEExactGauge.Serpentine
+
+end
+
+end OAI
diff --git a/lean/OAI/Probability/SLE/Gauge/SerpentineRetentionCount.lean b/lean/OAI/Probability/SLE/Gauge/SerpentineRetentionCount.lean
new file mode 100644
index 0000000000000000000000000000000000000000..e7edbf230cf9bebac5bce5b374a678b899c96e6a
--- /dev/null
+++ b/lean/OAI/Probability/SLE/Gauge/SerpentineRetentionCount.lean
@@ -0,0 +1,38 @@
+import OAI.Probability.SLE.Gauge.SerpentineParameters
+
+namespace OAI
+
+/-! All selected integer strips occur strictly before the rounded
+completion, with exactly m² distinct selected steps. -/
+
+noncomputable section
+open Set
+
+namespace SLEExactGauge.Serpentine
+
+lemma retainedStep_pos (A : ℝ) (m j i : ℕ) : 0 < retainedStep A m j i := by
+  unfold retainedStep
+  omega
+
+lemma retainedStep_lt_completion {A : ℝ} (hA : 0 ≤ A) {m j i : ℕ}
+    (hm : 0 < m) (hj : j < m) (hi : i < m) :
+    retainedStep A m j i < completionStep A m := by
+  have hupper := (retainedStep_bounds (j := j) hA hi).2
+  have hsep := columnEntry_separation (A := A) hm (show j < 2 * m by omega)
+  have hceil := Nat.le_ceil (columnEntry A m (2 * m) + 200 * (m : ℝ))
+  change columnEntry A m (2 * m) + 200 * (m : ℝ) ≤ (completionStep A m : ℝ) at hceil
+  have hm' : (1 : ℝ) ≤ m := by exact_mod_cast hm
+  have hr : (retainedStep A m j i : ℝ) < completionStep A m := by linarith
+  exact_mod_cast hr
+
+theorem retainedSteps_bounds {A : ℝ} (hA : 0 ≤ A) {m : ℕ} (hm : 0 < m) :
+    ∀ k ∈ retainedSteps A m, 0 < k ∧ k < completionStep A m := by
+  intro k hk
+  obtain ⟨⟨j, i⟩, _, rfl⟩ := Finset.mem_image.mp hk
+  exact ⟨retainedStep_pos A m j i, retainedStep_lt_completion hA hm j.isLt i.isLt⟩
+
+end SLEExactGauge.Serpentine
+
+end
+
+end OAI
diff --git a/lean/OAI/Probability/SLE/Gauge/SerpentineShadow.lean b/lean/OAI/Probability/SLE/Gauge/SerpentineShadow.lean
new file mode 100644
index 0000000000000000000000000000000000000000..f8cdcfdb74fbf0caea0f1f15b4c614a442bd9c8c
--- /dev/null
+++ b/lean/OAI/Probability/SLE/Gauge/SerpentineShadow.lean
@@ -0,0 +1,88 @@
+import OAI.Probability.SLE.Gauge.SerpentineLayout
+
+namespace OAI
+
+/-! The displaced array and its vertical attachments avoid an explicit
+upward shadow from the marked point. This gives the free upward route
+used to control the conformal radius of every completed prefix. -/
+
+noncomputable section
+open Set Metric
+
+namespace SLEExactGauge.Serpentine
+
+lemma center_horizontal_distance {s : ℝ} (hs : 0 ≤ s) (w : ℂ) :
+    |(center s w).re - w.re| = s / 4 := by
+  simp only [center, Complex.add_re, Complex.ofReal_re, add_sub_cancel_left, abs_mul]
+  have hh : |displacementSign w| = 1 := by unfold displacementSign; split <;> norm_num
+  rw [hh, one_mul, abs_of_nonneg (div_nonneg hs (by norm_num))]
+
+lemma disk_horizontal_separation {s : ℝ} (hs : 0 < s) (w z : ℂ)
+    (hz : z ∈ closedBall (center s w) (s / 20)) :
+    s / 5 ≤ |z.re - w.re| := by
+  have ha := abs_sub_le (center s w).re z.re w.re
+  have hb : |(center s w).re - z.re| ≤ s / 20 := by
+    have hn := Complex.abs_re_le_norm (center s w - z)
+    have hd : ‖center s w - z‖ ≤ s / 20 := by
+      rw [← dist_eq_norm, dist_comm]
+      exact hz
+    have hn' : |(center s w).re - z.re| ≤ ‖center s w - z‖ := by
+      simpa only [Complex.sub_re] using hn
+    exact hn'.trans hd
+  rw [center_horizontal_distance hs.le w] at ha
+  linarith
+
+lemma column_avoids_upward_shadow {s : ℝ} (hs : 0 < s) (w : ℂ)
+    {m j : ℕ} (hm : 0 < m) (hj : j ≤ 2 * m) {y a : ℝ}
+    (hy : |y| ≤ halfHeight s) (ha : |a| ≤ 1) :
+    ¬ (|((columnPoint (center s w) (halfHeight s) m j y a).re - w.re)| < s / 100 ∧
+      w.im - s / 100 < (columnPoint (center s w) (halfHeight s) m j y a).im) := by
+  have hh := disk_horizontal_separation hs w _ (column_inside_displaced_disk hs w hm hj hy ha)
+  intro h
+  linarith [h.1]
+
+lemma turn_inside_displaced_disk {s : ℝ} (hs : 0 < s) (w : ℂ)
+    {m j : ℕ} (hm : 0 < m) (hj : j + 1 ≤ 2 * m) (t : ℝ) {a : ℝ} (ha : |a| ≤ 1) :
+    turnPoint (center s w) (halfHeight s) m j t a ∈ closedBall (center s w) (s / 20) := by
+  have hh : 0 < halfHeight s := by unfold halfHeight; positivity
+  have hb := turnPoint_bound hh hm hj (center s w) t ha
+  change dist _ _ ≤ s / 20
+  dsimp only [halfHeight] at hb ⊢
+  linarith
+
+lemma turn_avoids_upward_shadow {s : ℝ} (hs : 0 < s) (w : ℂ)
+    {m j : ℕ} (hm : 0 < m) (hj : j + 1 ≤ 2 * m) (t : ℝ) {a : ℝ} (ha : |a| ≤ 1) :
+    ¬ (|(turnPoint (center s w) (halfHeight s) m j t a).re - w.re| < s / 100 ∧
+      w.im - s / 100 < (turnPoint (center s w) (halfHeight s) m j t a).im) := by
+  have hh := disk_horizontal_separation hs w _ (turn_inside_displaced_disk hs w hm hj t ha)
+  intro h
+  linarith [h.1]
+
+/-- The low part of the connector lies below the shadow. -/
+lemma low_connector_avoids_upward_shadow {s : ℝ} (hs : 0 < s) (w z : ℂ)
+    (hw : s ≤ w.im) (hz : z.im ≤ s / 2) :
+    ¬ (|z.re - w.re| < s / 100 ∧ w.im - s / 100 < z.im) := by
+  intro h
+  linarith [h.2]
+
+/-- The vertical attachment over either outer column stays horizontally
+separated, regardless of its height. -/
+lemma attachment_avoids_upward_shadow {s : ℝ} (hs : 0 < s) (w z : ℂ)
+    {x : ℝ} (hx : |x| ≤ halfHeight s)
+    (hz : |z.re - ((center s w).re + x)| ≤ s / 1000) :
+    ¬ (|z.re - w.re| < s / 100 ∧ w.im - s / 100 < z.im) := by
+  have h1 := abs_sub_le (center s w).re (((center s w).re + x)) w.re
+  have h2 := abs_sub_le (((center s w).re + x)) z.re w.re
+  have hxx : |(center s w).re - ((center s w).re + x)| = |x| := by
+    rw [sub_add_eq_sub_sub, sub_self, zero_sub, abs_neg]
+  rw [center_horizontal_distance hs.le w, hxx] at h1
+  rw [abs_sub_comm (((center s w).re + x)) z.re] at h2
+  dsimp only [halfHeight] at hx
+  intro h
+  linarith [h.1]
+
+end SLEExactGauge.Serpentine
+
+end
+
+end OAI
diff --git a/lean/OAI/Probability/SLE/Gauge/SerpentineStepCount.lean b/lean/OAI/Probability/SLE/Gauge/SerpentineStepCount.lean
new file mode 100644
index 0000000000000000000000000000000000000000..c8a2d2c8574c4eb6b05c43969e0b5a98a55d26c9
--- /dev/null
+++ b/lean/OAI/Probability/SLE/Gauge/SerpentineStepCount.lean
@@ -0,0 +1,121 @@
+import OAI.Probability.SLE.Gauge.RibbonConcatenation
+
+namespace OAI
+
+/-! Integer unit-step alignment inside the actual straight passes of the
+serpentine array. A full unit middle strip is retained in each selected
+step; rounding the column entry times does not lose the quadratic count. -/
+
+noncomputable section
+open Set
+open scoped NNReal
+
+namespace SLEExactGauge.Serpentine
+
+/-- Column entry times in ribbon-width units: straight length `200m`,
+then a semicircle of radius 50. The connector contributes `A`. -/
+def columnEntry (A : ℝ) (m j : ℕ) : ℝ :=
+  A + j * (200 * (m : ℝ) + 50 * Real.pi)
+
+def retainedStep (A : ℝ) (m j i : ℕ) : ℕ := ⌈columnEntry A m j⌉₊ + i + 1
+
+lemma columnEntry_nonneg {A : ℝ} (hA : 0 ≤ A) (m j : ℕ) :
+    0 ≤ columnEntry A m j := by
+  unfold columnEntry
+  positivity
+
+lemma retainedStep_bounds {A : ℝ} (hA : 0 ≤ A) {m j i : ℕ}
+    (hi : i < m) :
+    columnEntry A m j + 1 ≤ retainedStep A m j i ∧
+      (retainedStep A m j i : ℝ) < columnEntry A m j + m + 1 := by
+  have hl := Nat.le_ceil (columnEntry A m j)
+  have hu := Nat.ceil_lt_add_one (columnEntry_nonneg hA m j)
+  have hir : (i : ℝ) + 1 ≤ m := by exact_mod_cast Nat.succ_le_of_lt hi
+  simp only [retainedStep, Nat.cast_add, Nat.cast_one]
+  constructor
+  · have hiz : (0 : ℝ) ≤ i := Nat.cast_nonneg i
+    linarith
+  · linarith
+
+/-- The complete closed middle interval of each chosen integer step lies
+strictly in its corresponding straight pass. -/
+theorem retained_middle_in_straight {A : ℝ} (hA : 0 ≤ A) {m j i : ℕ}
+    (hi : i < m) :
+    Icc ((retainedStep A m j i : ℝ) + 1 / 3)
+      ((retainedStep A m j i : ℝ) + 2 / 3) ⊆
+      Ioo (columnEntry A m j) (columnEntry A m j + 200 * m) := by
+  have hm : (1 : ℝ) ≤ m := by exact_mod_cast Nat.succ_le_of_lt (Nat.zero_le i |>.trans_lt hi)
+  obtain ⟨hl, hu⟩ := retainedStep_bounds hA hi
+  intro t ht
+  constructor <;> linarith [ht.1, ht.2]
+
+lemma columnEntry_separation {A : ℝ} {m j k : ℕ} (hm : 0 < m) (hjk : j < k) :
+    columnEntry A m j + 200 * m ≤ columnEntry A m k := by
+  have hjkr : (j : ℝ) + 1 ≤ k := by exact_mod_cast Nat.succ_le_of_lt hjk
+  have hperiod : 0 ≤ 200 * (m : ℝ) + 50 * Real.pi := by positivity
+  have hh := mul_le_mul_of_nonneg_right hjkr hperiod
+  unfold columnEntry
+  nlinarith [Real.pi_pos]
+
+lemma retainedStep_strict_column {A : ℝ} (hA : 0 ≤ A) {m j k i l : ℕ}
+    (hm : 0 < m) (hjk : j < k) (hi : i < m) (hl : l < m) :
+    retainedStep A m j i < retainedStep A m k l := by
+  obtain ⟨_, hui⟩ := retainedStep_bounds hA hi
+  obtain ⟨hll, _⟩ := retainedStep_bounds hA hl
+  have hsep := columnEntry_separation (A := A) hm hjk
+  have hmr : (1 : ℝ) ≤ m := by exact_mod_cast hm
+  have hh : (retainedStep A m j i : ℝ) < retainedStep A m k l := by linarith
+  exact_mod_cast hh
+
+theorem retainedStep_injective {A : ℝ} (hA : 0 ≤ A) {m : ℕ} (hm : 0 < m) :
+    Function.Injective (fun ji : Fin m × Fin m => retainedStep A m ji.1 ji.2) := by
+  rintro ⟨j, i⟩ ⟨k, l⟩ he
+  have hjk : j = k := by
+    by_contra hn
+    rcases lt_or_gt_of_ne hn with hlt | hgt
+    · have hh := retainedStep_strict_column hA hm hlt i.isLt l.isLt
+      exact (ne_of_lt hh) he
+    · have hh := retainedStep_strict_column hA hm hgt l.isLt i.isLt
+      exact (ne_of_lt hh) he.symm
+  subst k
+  have hil : i = l := by
+    apply Fin.ext
+    change ⌈columnEntry A m (j : ℕ)⌉₊ + (i : ℕ) + 1 =
+      ⌈columnEntry A m (j : ℕ)⌉₊ + (l : ℕ) + 1 at he
+    omega
+  subst l
+  rfl
+
+def retainedSteps (A : ℝ) (m : ℕ) : Finset ℕ :=
+  Finset.univ.image (fun ji : Fin m × Fin m => retainedStep A m ji.1 ji.2)
+
+theorem retainedSteps_card {A : ℝ} (hA : 0 ≤ A) {m : ℕ} (hm : 0 < m) :
+    (retainedSteps A m).card = m ^ 2 := by
+  rw [retainedSteps, Finset.card_image_of_injective _ (retainedStep_injective hA hm)]
+  simp [pow_two]
+
+/-- Rounded completion of all `2m+1` passes, before extending vertically. -/
+def completionStep (A : ℝ) (m : ℕ) : ℕ :=
+  ⌈columnEntry A m (2 * m) + 200 * (m : ℝ)⌉₊
+
+theorem completionStep_quadratic_bound {A A₀ : ℝ} (hA : 0 ≤ A) (hA₀ : 0 ≤ A₀)
+    {m : ℕ} (hm : 0 < m) (hbound : A ≤ A₀ * m) :
+    (completionStep A m : ℝ) ≤ (A₀ + 601 + 100 * Real.pi) * (m : ℝ) ^ 2 := by
+  have hmr : (1 : ℝ) ≤ m := by exact_mod_cast hm
+  have hsq : (m : ℝ) ≤ (m : ℝ) ^ 2 := by nlinarith
+  have hAn := mul_le_mul_of_nonneg_left hsq hA₀
+  have hπn := mul_le_mul_of_nonneg_left hsq (show 0 ≤ 100 * Real.pi by positivity)
+  have hl := Nat.ceil_lt_add_one
+    (show 0 ≤ columnEntry A m (2 * m) + 200 * (m : ℝ) by
+      exact add_nonneg (columnEntry_nonneg hA m (2 * m)) (by positivity))
+  change (completionStep A m : ℝ) < _ at hl
+  unfold completionStep columnEntry at *
+  push_cast at hl ⊢
+  nlinarith
+
+
+end SLEExactGauge.Serpentine
+
+end
+
+end OAI
diff --git a/lean/OAI/Probability/SLE/Gauge/SerpentineTerminal.lean b/lean/OAI/Probability/SLE/Gauge/SerpentineTerminal.lean
new file mode 100644
index 0000000000000000000000000000000000000000..6d7c7d959e1513ab977b3c733eae578ec70d2bd0
--- /dev/null
+++ b/lean/OAI/Probability/SLE/Gauge/SerpentineTerminal.lean
@@ -0,0 +1,59 @@
+import OAI.Probability.SLE.Gauge.SerpentineEmbedding
+
+namespace OAI
+
+noncomputable section
+open Set
+
+namespace SLEExactGauge.Serpentine
+
+/-- A turn cannot meet any column except its two attached columns,
+regardless of the height on that column. -/
+theorem turnPoint_column_ne_nonadjacent {h : ℝ} (hh : 0 < h) {m i k : ℕ} (hm : 0 < m)
+    (hk : k < i ∨ i + 2 ≤ k) (c : ℂ) (t y : ℝ) {a b : ℝ}
+    (ha : |a| ≤ 1) (hb : |b| ≤ 1) :
+    turnPoint c h m i t a ≠ columnPoint c h m k y b := by
+  intro he
+  have ht := abs_le.mp (turn_horizontal_bound hh hm c i t ha)
+  have hc := congrArg Complex.re he
+  rw [columnPoint_re] at hc
+  have hw := ribbonWidth_pos hh hm
+  have hb' : |side k * ribbonWidth h m * b| ≤ ribbonWidth h m := by
+    rw [abs_mul, abs_mul, side_abs, one_mul, abs_of_pos hw]
+    exact mul_le_of_le_one_right hw.le hb
+  have hb'' := abs_le.mp hb'
+  simp only [columnOffset] at ht hc
+  rw [turnRadius_eq_width, spacing_eq_width] at ht
+  rw [spacing_eq_width] at hc
+  rcases hk with hk | hk
+  · have hki : (k : ℝ) + 1 ≤ i := by exact_mod_cast hk
+    nlinarith
+  · have hik : (i : ℝ) + 2 ≤ k := by exact_mod_cast hk
+    nlinarith
+
+lemma side_even (m : ℕ) : side (2 * m) = 1 := by
+  simp only [side, ite_eq_left (even_two_mul m)]
+
+/-- The upward terminal continuation is disjoint from every turn.
+The preceding turn bends downwards; earlier turns are horizontally
+separated from the terminal column. -/
+theorem turnPoint_terminal_column_ne {h : ℝ} (hh : 0 < h) {m i : ℕ} (hm : 0 < m)
+    (hi : i < 2 * m) (c : ℂ) {t y a b : ℝ} (ht : t ∈ Icc 0 Real.pi)
+    (hy : h < y) (ha : |a| ≤ 1) (hb : |b| ≤ 1) :
+    turnPoint c h m i t a ≠ columnPoint c h m (2 * m) y b := by
+  by_cases hil : i + 1 = 2 * m
+  · intro he
+    have hs : side i = -1 := by
+      have hh := side_succ i
+      rw [hil, side_even] at hh
+      linarith
+    have hh := turn_oriented_height hh hm c i ht ha
+    rw [hs, he, columnPoint_im] at hh
+    linarith
+  · exact turnPoint_column_ne_nonadjacent hh hm (Or.inr (by omega)) c t y ha hb
+
+end SLEExactGauge.Serpentine
+
+end
+
+end OAI
diff --git a/lean/OAI/Probability/SLE/Gauge/SerpentineTerminalGuide.lean b/lean/OAI/Probability/SLE/Gauge/SerpentineTerminalGuide.lean
new file mode 100644
index 0000000000000000000000000000000000000000..b9c332fd0c0531f0500634a5137f914f088f2cf5
--- /dev/null
+++ b/lean/OAI/Probability/SLE/Gauge/SerpentineTerminalGuide.lean
@@ -0,0 +1,163 @@
+import OAI.Probability.SLE.Gauge.SerpentineMarkedClearance
+
+namespace OAI
+
+/-! The actual last front is on the terminal vertical piece. Its access
+guide reaches height two before the explicit marked hook is attached. -/
+
+noncomputable section
+open Set Metric
+
+namespace SLEExactGauge.Serpentine
+open RibbonCoordinates
+
+def fitEntry (s : ℝ) (w : ℂ) (m : ℕ) : ℝ :=
+  connectorEntry (fitHeight m) (fitRadius m) (fitX s w m) (fitY s w m)
+
+def fitCompletion (s : ℝ) (w : ℂ) (m : ℕ) : ℕ := completionStep (fitEntry s w m) m
+
+def fitTerminalX (s : ℝ) (w : ℂ) : ℝ := |w.re| + s / 4 + s / 200
+
+def fitTerminalHeight (s : ℝ) (w : ℂ) (m : ℕ) : ℝ :=
+  ribbonWidth (halfHeight s) m *
+    (fitY s w m + fitCompletion s w m - fitEntry s w m - columnEntry 0 m (2 * m))
+
+def fitHighTime (s : ℝ) (w : ℂ) (m : ℕ) : ℝ :=
+  (2 - fitTerminalHeight s w m) / ribbonWidth (halfHeight s) m
+
+lemma fitCompletion_bounds {s : ℝ} (hs : 0 < s) (w : ℂ) (hw : s ≤ w.im)
+    {m : ℕ} (hm : 0 < m) :
+    fitEntry s w m + columnEntry 0 m (2 * m) + 200 * m ≤ fitCompletion s w m ∧
+    (fitCompletion s w m : ℝ) < fitEntry s w m + columnEntry 0 m (2 * m) + 200 * m + 1 := by
+  have hA : 0 ≤ fitEntry s w m := by
+    have h := fit_entry_lower hs w hw hm
+    exact le_trans (by unfold fitHeight; positivity) h
+  have hlo := Nat.le_ceil (columnEntry (fitEntry s w m) m (2 * m) + 200 * m)
+  have hhi := Nat.ceil_lt_add_one
+    (add_nonneg (columnEntry_nonneg hA m (2 * m)) (by positivity : (0 : ℝ) ≤ 200 * m))
+  change _ ≤ (fitCompletion s w m : ℝ) at hlo
+  change (fitCompletion s w m : ℝ) < _ at hhi
+  have he : columnEntry (fitEntry s w m) m (2 * m) =
+      fitEntry s w m + columnEntry 0 m (2 * m) := by simp [columnEntry]
+  rw [he] at hlo hhi
+  exact ⟨hlo, hhi⟩
+
+lemma fit_scaledY {s : ℝ} (hs : 0 < s) (w : ℂ) {m : ℕ} (hm : 0 < m) :
+    ribbonWidth (halfHeight s) m * fitY s w m = w.im - s / 200 := by
+  unfold fitY halfHeight
+  exact mul_div_cancel₀ _ (fit_width_pos hs hm).ne'
+
+lemma fitTerminalHeight_bounds {s : ℝ} (hs : 0 < s) (w : ℂ) (hw : s ≤ w.im)
+    {m : ℕ} (hm : 0 < m) :
+    w.im + s / 200 ≤ fitTerminalHeight s w m ∧
+    fitTerminalHeight s w m < w.im + s / 200 + ribbonWidth (halfHeight s) m := by
+  obtain ⟨hlo, hhi⟩ := fitCompletion_bounds hs w hw hm
+  have hℓ := fit_width_pos hs hm
+  have hl := mul_le_mul_of_nonneg_left hlo hℓ.le
+  have hh := mul_lt_mul_of_pos_left hhi hℓ
+  have hY := fit_scaledY hs w hm
+  have hmℓ := fit_width_mul hs hm
+  unfold fitTerminalHeight
+  constructor <;> nlinarith
+
+lemma physicalFitChart_terminal {s : ℝ} (hs : 0 < s) (w : ℂ) (hw : s ≤ w.im)
+    {m : ℕ} (hm : 0 < m) {z : ℂ} (hz : (fitCompletion s w m : ℝ) ≤ z.re) :
+    physicalFitChart s w m z =
+      ((fitTerminalX s w - ribbonWidth (halfHeight s) m * z.im : ℝ) : ℂ) +
+      ((fitTerminalHeight s w m + ribbonWidth (halfHeight s) m *
+        (z.re - fitCompletion s w m) : ℝ) : ℂ) * Complex.I := by
+  have hthreshold : fitEntry s w m + columnEntry 0 m (2 * m) + 1 ≤ z.re := by
+    have h := (fitCompletion_bounds hs w hw hm).1
+    have hmr : (1 : ℝ) ≤ m := by exact_mod_cast hm
+    linarith
+  obtain ⟨hσ, hT⟩ := complete_linear_tail m (fitHeight m) (fitRadius m)
+    (fitX s w m) (fitY s w m) hthreshold
+  have hX := fit_scaledX hs w hm
+  have hmℓ := fit_width_mul hs hm
+  change ((ribbonWidth (halfHeight s) m : ℂ) *
+    (completeSpine m _ _ _ _ z.re + (z.im : ℂ) * Complex.I * completeTangent m _ _ _ _ z.re)) = _
+  rw [hσ, hT]
+  apply Complex.ext <;>
+    simp only [Complex.add_re, Complex.add_im, Complex.mul_re, Complex.mul_im,
+      Complex.ofReal_re, Complex.ofReal_im, Complex.I_re, Complex.I_im,
+      mul_zero, zero_mul, mul_one, sub_zero, add_zero, zero_add]
+  · unfold fitTerminalX
+    nlinarith
+  · unfold fitTerminalHeight fitEntry
+    ring
+
+lemma fitHighTime_large {s : ℝ} (hs : 0 < s) (hs1 : s ≤ 1) (w : ℂ)
+    (hw : s ≤ w.im) (hw1 : ‖w‖ ≤ 1) {m : ℕ} (hm : 0 < m) :
+    1 < fitHighTime s w m := by
+  have hheight := (fitTerminalHeight_bounds hs w hw hm).2
+  have hwi := (Complex.im_le_norm w).trans hw1
+  have hwidth := fit_width_le hs hm
+  rw [fitHighTime, lt_div_iff₀ (fit_width_pos hs hm)]
+  nlinarith
+
+/-- Exact physical formula for the tapered terminal access guide. -/
+lemma physicalFitChart_terminal_guide {s : ℝ} (hs : 0 < s) (w : ℂ) (hw : s ≤ w.im)
+    {m : ℕ} (hm : 0 < m) (x : ℝ) {t : ℝ} (ht : 0 ≤ t) :
+    physicalFitChart s w m (guideCoordinate (fitCompletion s w m) x t) =
+      ((fitTerminalX s w - ribbonWidth (halfHeight s) m * x * max (1 - 4 * t) 0 : ℝ) : ℂ) +
+      ((fitTerminalHeight s w m + ribbonWidth (halfHeight s) m * t : ℝ) : ℂ) * Complex.I := by
+  rw [physicalFitChart_terminal hs w hw hm (by rw [guideCoordinate_re]; linarith),
+    guideCoordinate_re, guideCoordinate_im]
+  push_cast
+  ring
+
+lemma physicalFitChart_terminal_guide_endpoint {s : ℝ} (hs : 0 < s) (hs1 : s ≤ 1)
+    (w : ℂ) (hw : s ≤ w.im) (hw1 : ‖w‖ ≤ 1) {m : ℕ} (hm : 0 < m) (x : ℝ) :
+    physicalFitChart s w m (guideCoordinate (fitCompletion s w m) x (fitHighTime s w m)) =
+      (fitTerminalX s w : ℂ) + (2 : ℂ) * Complex.I := by
+  have hT := fitHighTime_large hs hs1 w hw hw1 hm
+  rw [physicalFitChart_terminal_guide hs w hw hm x (by linarith),
+    max_eq_right (by linarith : 1 - 4 * fitHighTime s w m ≤ 0), mul_zero, sub_zero]
+  have he : fitTerminalHeight s w m + ribbonWidth (halfHeight s) m * fitHighTime s w m = 2 := by
+    unfold fitHighTime
+    rw [mul_div_cancel₀ _ (fit_width_pos hs hm).ne']
+    ring
+  rw [he]
+  norm_num
+
+lemma physicalFitChart_terminal_guide_height {s : ℝ} (hs : 0 < s) (w : ℂ) (hw : s ≤ w.im)
+    {m : ℕ} (hm : 0 < m) (x : ℝ) {t : ℝ}
+    (ht : t ∈ Icc (0 : ℝ) (fitHighTime s w m)) :
+    (physicalFitChart s w m (guideCoordinate (fitCompletion s w m) x t)).im ≤ 2 := by
+  rw [physicalFitChart_terminal_guide hs w hw hm x ht.1]
+  simp only [Complex.add_im, Complex.ofReal_im, Complex.mul_im, Complex.ofReal_re,
+    Complex.I_re, Complex.I_im, mul_one, mul_zero, add_zero, zero_add]
+  have h := mul_le_mul_of_nonneg_left ht.2 (fit_width_pos hs hm).le
+  unfold fitHighTime at h
+  rw [mul_div_cancel₀ _ (fit_width_pos hs hm).ne'] at h
+  linarith
+
+lemma physicalFitChart_terminal_guide_strict_height {s : ℝ} (hs : 0 < s) (w : ℂ) (hw : s ≤ w.im)
+    {m : ℕ} (hm : 0 < m) (x : ℝ) {t : ℝ}
+    (ht : t ∈ Ico (0 : ℝ) (fitHighTime s w m)) :
+    (physicalFitChart s w m (guideCoordinate (fitCompletion s w m) x t)).im < 2 := by
+  rw [physicalFitChart_terminal_guide hs w hw hm x ht.1]
+  simp only [Complex.add_im, Complex.ofReal_im, Complex.mul_im, Complex.ofReal_re,
+    Complex.I_re, Complex.I_im, mul_one, mul_zero, add_zero, zero_add]
+  have h := mul_lt_mul_of_pos_left ht.2 (fit_width_pos hs hm)
+  unfold fitHighTime at h
+  rw [mul_div_cancel₀ _ (fit_width_pos hs hm).ne'] at h
+  linarith
+
+lemma physicalFitChart_terminal_guide_injective {s : ℝ} (hs : 0 < s) (w : ℂ) (hw : s ≤ w.im)
+    {m : ℕ} (hm : 0 < m) (x : ℝ) :
+    InjOn (fun t => physicalFitChart s w m (guideCoordinate (fitCompletion s w m) x t)) (Ici 0) := by
+  intro t ht u hu he
+  have him := congrArg Complex.im he
+  dsimp only at him
+  rw [physicalFitChart_terminal_guide hs w hw hm x ht,
+    physicalFitChart_terminal_guide hs w hw hm x hu] at him
+  simp only [Complex.add_im, Complex.ofReal_im, Complex.mul_im, Complex.ofReal_re,
+    Complex.I_re, Complex.I_im, mul_one, mul_zero, add_zero, zero_add] at him
+  nlinarith [fit_width_pos hs hm]
+
+end SLEExactGauge.Serpentine
+
+end
+
+end OAI
diff --git a/lean/OAI/Probability/SLE/Gauge/SerpentineUpperHalfPlane.lean b/lean/OAI/Probability/SLE/Gauge/SerpentineUpperHalfPlane.lean
new file mode 100644
index 0000000000000000000000000000000000000000..c003883a173b461d57a1aff0ddc6dbfa1a40aec4
--- /dev/null
+++ b/lean/OAI/Probability/SLE/Gauge/SerpentineUpperHalfPlane.lean
@@ -0,0 +1,88 @@
+import OAI.Probability.SLE.Gauge.SerpentineCompleteEmbedding
+
+namespace OAI
+
+/-! The complete normal ribbon starts on the real boundary and every
+positive longitudinal coordinate lies in the upper half-plane. -/
+
+noncomputable section
+open Set Metric
+
+namespace SLEExactGauge.Serpentine
+
+lemma lowConnector_normal_im_pos {H r X : ℝ} (hH : 1 < H) (hr : 1 < r) (hX : 2 * r < X)
+    {z : ℂ} (hz : 0 < z.re) (ha : |z.im| ≤ 1) :
+    0 < (normalRibbon (lowConnector H r X) (lowConnectorTangent H r X) z).im := by
+  have hr0 : 0 < r := by linarith
+  obtain ⟨hc1, hc2, hc3⟩ := connector_cuts (H := H) hr0 hX
+  by_cases h4 : z.re ≤ connectorFourth H r X
+  · by_cases h3 : z.re ≤ connectorThird H r X
+    · by_cases h2 : z.re ≤ connectorSecond H r
+      · by_cases h1 : z.re ≤ H
+        · simp only [normalRibbon, lowConnector, lowConnectorTangent, curveJoin_of_le h4,
+            curveJoin_of_le h3, curveJoin_of_le h2, curveJoin_of_le h1, connectorInitial,
+            Complex.add_im, Complex.mul_im, Complex.mul_re, Complex.ofReal_re, Complex.ofReal_im,
+            Complex.I_re, Complex.I_im, mul_zero, mul_one, sub_zero, add_zero]
+          exact hz
+        · have ht : z.re - H ∈ Icc (0 : ℝ) (quarterLength r) := by
+            constructor
+            · linarith
+            · dsimp only [connectorSecond] at h2
+              linarith
+          have hb := (quarterNormal_bounds hr ht ha).2.2.1
+          simp only [normalRibbon, lowConnector, lowConnectorTangent, curveJoin_of_le h4,
+            curveJoin_of_le h3, curveJoin_of_le h2, curveJoin_of_gt (lt_of_not_ge h1), connectorFirstTurn]
+          rw [add_assoc]
+          change 0 < ((H : ℂ) * Complex.I + quarterNormal r (z.re - H) z.im).im
+          simp only [Complex.add_im, Complex.mul_im, Complex.ofReal_re, Complex.ofReal_im,
+            Complex.I_re, Complex.I_im, mul_one, mul_zero, add_zero]
+          linarith
+      · simp only [normalRibbon, lowConnector, lowConnectorTangent, curveJoin_of_le h4,
+          curveJoin_of_le h3, curveJoin_of_gt (lt_of_not_ge h2), connectorHorizontal,
+          Complex.add_im, Complex.mul_im, Complex.ofReal_re, Complex.ofReal_im,
+          Complex.I_re, Complex.I_im, mul_zero, mul_one, add_zero, zero_add]
+        linarith [(abs_le.mp ha).1]
+    · have ht : z.re - connectorThird H r X ∈ Icc (0 : ℝ) (quarterLength r) := by
+        constructor
+        · linarith
+        · dsimp only [connectorFourth] at h4
+          linarith
+      have hb := (upperQuarterNormal_bounds hr ht ha).2.2.1
+      simp only [normalRibbon, lowConnector, lowConnectorTangent, curveJoin_of_le h4,
+        curveJoin_of_gt (lt_of_not_ge h3), connectorLastTurn]
+      rw [add_assoc]
+      change 0 < ((((X - r : ℝ) : ℂ) + ((H + r : ℝ) : ℂ) * Complex.I) +
+        upperQuarterNormal r (z.re - connectorThird H r X) z.im).im
+      simp only [Complex.add_im, Complex.mul_im, Complex.ofReal_re, Complex.ofReal_im,
+        Complex.I_re, Complex.I_im, mul_one, mul_zero, add_zero, zero_add]
+      linarith
+  · simp only [normalRibbon, lowConnector, lowConnectorTangent, curveJoin_of_gt (lt_of_not_ge h4),
+      connectorTail, Complex.add_im, Complex.mul_im, Complex.mul_re,
+      Complex.ofReal_re, Complex.ofReal_im, Complex.I_re, Complex.I_im,
+      mul_zero, mul_one, sub_zero, add_zero, zero_add]
+    linarith
+
+/-- The actual entire ribbon lies above the real boundary at every
+positive longitudinal parameter. -/
+theorem complete_normal_upper {m : ℕ} (hm : 0 < m) {H r X Y : ℝ}
+    (hH : 1 < H) (hr : 1 < r) (hX : 2 * r < X) (hY : 300 * (m : ℝ) < Y)
+    {z : ℂ} (hz : 0 < z.re) (ha : |z.im| ≤ 1) :
+    0 < (normalRibbon (completeSpine m H r X Y) (completeTangent m H r X Y) z).im := by
+  by_cases hA : z.re ≤ connectorEntry H r X Y
+  · rw [complete_normal_of_le m H r X Y hA]
+    exact lowConnector_normal_im_pos hH hr hX hz ha
+  · have hz' : 0 ≤ (z - (connectorEntry H r X Y : ℂ)).re ∧
+        |(z - (connectorEntry H r X Y : ℂ)).im| ≤ 1 := by
+      simp only [Complex.sub_re, Complex.sub_im, Complex.ofReal_re, Complex.ofReal_im, sub_zero]
+      exact ⟨by linarith, ha⟩
+    have hb := array_normal_im_lower hm hz'
+    rw [complete_normal_of_gt m H r X Y (lt_of_not_ge hA)]
+    simp only [arrayCenter, Complex.add_im, Complex.ofReal_im, Complex.mul_im,
+      Complex.ofReal_re, Complex.I_re, Complex.I_im, mul_one, mul_zero, add_zero, zero_add]
+    linarith
+
+end SLEExactGauge.Serpentine
+
+end
+
+end OAI
diff --git a/lean/OAI/Probability/SLE/Gauge/ShrinkingCoverAtoms.lean b/lean/OAI/Probability/SLE/Gauge/ShrinkingCoverAtoms.lean
new file mode 100644
index 0000000000000000000000000000000000000000..6115c039e0e846f4b4fe0e1c6ceecb85773b4f33
--- /dev/null
+++ b/lean/OAI/Probability/SLE/Gauge/ShrinkingCoverAtoms.lean
@@ -0,0 +1,79 @@
+import Mathlib.MeasureTheory.Integral.Lebesgue.Add
+import Mathlib.MeasureTheory.Measure.GiryMonad
+import Mathlib.MeasureTheory.Measure.Typeclasses.NullSingletonClass
+import Mathlib.Topology.Order.LiminfLimsup
+
+namespace OAI
+
+/-! The nonatomicity step of `mass:construction`: a squared atom is
+bounded by every squared covering mass sum. Fatou therefore rules out
+all atoms at once, without a countable union over points. -/
+
+noncomputable section
+open Set Filter MeasureTheory
+open scoped ENNReal Topology
+
+namespace SLEExactGauge
+
+variable {X Ω : Type*} [MeasurableSpace X] [MeasurableSpace Ω]
+
+/-- One atom is charged to one cell in any finite cover. -/
+lemma singleton_sq_le_cover_sum (μ : Measure X) (I : Finset ℕ) (C : ℕ → Set X)
+    {x : X} (hcover : ∃ i ∈ I, x ∈ C i) :
+    (μ {x})^2 ≤ ∑ i ∈ I, (μ (C i))^2 := by
+  obtain ⟨i,hi,hxi⟩ := hcover
+  have hsub : ({x} : Set X) ⊆ C i := singleton_subset_iff.mpr hxi
+  exact (pow_le_pow_left' (measure_mono hsub) 2).trans
+    (Finset.single_le_sum (f := fun j => (μ (C j))^2) (fun _ _ => zero_le) hi)
+
+/-- Vanishing expected upper bounds for squared atoms exclude every atom
+on a set simultaneously almost surely. -/
+theorem ae_null_singletons_on_of_square_bounds (P : Measure Ω) (μ : Ω → Measure X)
+    (K : Set X) (A : ℕ → Ω → ℝ≥0∞) (hA : ∀ n, Measurable (A n))
+    (hbound : ∀ ω x, x ∈ K → ∀ n, (μ ω {x})^2 ≤ A n ω)
+    (hlim : Tendsto (fun n => ∫⁻ ω, A n ω ∂P) atTop (𝓝 0)) :
+    ∀ᵐ ω ∂P, ∀ x ∈ K, μ ω {x}=0 := by
+  have hfatou : (∫⁻ ω, liminf (fun n => A n ω) atTop ∂P) ≤ 0 := by
+    simpa only [hlim.liminf_eq] using lintegral_liminf_le (μ := P) (u := atTop) hA
+  have hz : ∀ᵐ ω ∂P, liminf (fun n => A n ω) atTop=0 :=
+    (lintegral_eq_zero_iff (Measurable.liminf hA)).mp (le_antisymm hfatou bot_le)
+  filter_upwards [hz] with ω hω
+  intro x hx
+  have hb : (μ ω {x})^2 ≤ liminf (fun n => A n ω) atTop :=
+    le_liminf_of_le (by isBoundedDefault) (Eventually.of_forall (hbound ω x hx))
+  rw [hω] at hb
+  exact eq_zero_of_pow_eq_zero (le_antisymm hb bot_le)
+
+/-- The finite-cover form used for compact exhaustion. Cover diameters
+need not be named here: all geometric decay is captured in the expected
+squared mass sum. -/
+theorem ae_null_singletons_on_of_cover_sums (P : Measure Ω) (μ : Ω → Measure X)
+    (hμ : Measurable μ) (K : Set X) (I : ℕ → Finset ℕ) (C : ℕ → ℕ → Set X)
+    (hC : ∀ n i, MeasurableSet (C n i))
+    (hcover : ∀ n x, x ∈ K → ∃ i ∈ I n, x ∈ C n i)
+    (hlim : Tendsto (fun n => ∫⁻ ω, ∑ i ∈ I n, (μ ω (C n i))^2 ∂P) atTop (𝓝 0)) :
+    ∀ᵐ ω ∂P, ∀ x ∈ K, μ ω {x}=0 := by
+  apply ae_null_singletons_on_of_square_bounds P μ K
+    (fun n ω => ∑ i ∈ I n, (μ ω (C n i))^2) _ _ hlim
+  · intro n
+    exact Finset.measurable_sum (I n) (fun i _ => ((Measure.measurable_coe (hC n i)).comp hμ).pow_const 2)
+  · intro ω x hx n
+    exact singleton_sq_le_cover_sum (μ ω) (I n) (C n) (hcover n x hx)
+
+/-- A countable covering of the whole space upgrades the compact-by-compact
+criterion to a nonatomic random measure. -/
+theorem ae_nullSingletonClass_of_exhaustion (P : Measure Ω) (μ : Ω → Measure X)
+    (K : ℕ → Set X) (hcover : ∀ x, ∃ j, x ∈ K j)
+    (hK : ∀ j, ∀ᵐ ω ∂P, ∀ x ∈ K j, μ ω {x}=0) :
+    ∀ᵐ ω ∂P, NullSingletonClass (μ ω) := by
+  filter_upwards [ae_all_iff.mpr hK] with ω hω
+  constructor
+  intro x
+  obtain ⟨j,hj⟩ := hcover x
+  exact hω j x hj
+
+end SLEExactGauge
+
+end
+
+end OAI
diff --git a/lean/OAI/Probability/SLE/Gauge/StoppedSplicePassage.lean b/lean/OAI/Probability/SLE/Gauge/StoppedSplicePassage.lean
new file mode 100644
index 0000000000000000000000000000000000000000..11a6c37df3ec9881fdd8825d187d6a82321eba60
--- /dev/null
+++ b/lean/OAI/Probability/SLE/Gauge/StoppedSplicePassage.lean
@@ -0,0 +1,128 @@
+import OAI.Probability.SLE.Geometry.ActualStoppedTubeSupport
+import OAI.Probability.SLE.Gauge.RibbonSurvival
+
+namespace OAI
+
+/-! The actual semicircle splice gives conditional passage after a narrow
+first-height stop. The physical tube here is in the original parameter
+plane, so compact continuation prefixes stay strictly inside the half-plane
+and can subsequently be transported through a locally convergent family. -/
+
+noncomputable section
+open Set Filter MeasureTheory ProbabilityTheory Metric
+open scoped Topology NNReal unitInterval ENNReal
+
+namespace SLEExactGauge
+
+def parameterContinuationRegion (F : ℂ → ℂ) (a : ℂ) (r : ℝ) (O : Set ℂ) : Set ℂ :=
+  upperHalfPlane ∩ F ⁻¹' (ball a (r / 2) ∪ O)
+
+theorem parameterContinuationRegion_isOpen
+    {F : ℂ → ℂ} (hF : ContinuousOn F upperHalfPlane)
+    (a : ℂ) (r : ℝ) {O : Set ℂ} (hO : IsOpen O) :
+    IsOpen (parameterContinuationRegion F a r O) :=
+  hF.isOpen_inter_preimage isOpen_upperHalfPlane (isOpen_ball.union hO)
+
+theorem exists_physical_splice_route
+    (γ : ℝ≥0 → ℂ) (τ : ℝ≥0) {B r tB T : ℝ} (hB : 0 < B) (hr : 0 < r)
+    (hheight : (γ τ).im = B / 4) (hx : |(γ τ).re| < B / 16)
+    (hpast : γ '' Icc 0 τ ⊆ GuideSplice.closedInitialRectangle B)
+    (F : ℂ → ℂ) (a : ℂ) (O : Set ℂ) (β : ℝ → ℂ)
+    (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) :
+    ∃ p : Path (γ τ) (β T), Function.Injective p ∧
+      (∀ t, t ≠ 0 → p t ∈ survivingDomain γ τ) ∧
+      range p ⊆ parameterContinuationRegion F a r O := by
+  let x := (γ τ).re
+  let ζ : ℂ := (x : ℂ) + ((B / 4 : ℝ) : ℂ) * Complex.I
+  have htip : γ τ = ζ := by
+    apply Complex.ext <;> simp [ζ, x, hheight]
+  have hα : (GuideSplice.connectorTop B x).arg ∈ Ioo 0 Real.pi := by
+    apply GuideSplice.arg_mem_upper_interval
+    simpa [GuideSplice.connectorTop] using
+      Real.sqrt_pos.mpr (GuideSplice.circle_height_pos hB hx)
+  have hω : (β tB).arg ∈ Ioo 0 Real.pi :=
+    GuideSplice.arg_mem_upper_interval (hβH tB ⟨htB, htBT.le⟩)
+  obtain ⟨p, hp, _, hpH, _, hpr⟩ := GuideSplice.exists_simple_splice_path hB hx
+    htB htBT hβ hi hβH hcross hafter
+  have hrest := GuideSplice.continuationRoute_rest_subset_tube hr hB hx hα hω htB
+    hβH hcross hafter hcircle hsector htail
+  have hsurv := continuationTube_subset_survivingDomain γ τ B hpast F a r O
+  have hpne (t : unitInterval) (ht : t ≠ 0) : p t ≠ ζ := by
+    intro he
+    apply ht
+    apply hp
+    simpa only [Path.source] using he
+  refine ⟨p.cast htip rfl, hp, ?_, ?_⟩
+  · intro t ht
+    apply hsurv
+    apply hrest
+    exact ⟨hpr ▸ mem_range_self t, hpne t ht⟩
+  · intro z hz
+    refine ⟨hpH hz, ?_⟩
+    by_cases he : z = ζ
+    · subst z
+      have hζV : ζ ∈ GuideSplice.verticalConnector B x := by
+        simp only [ζ, GuideSplice.verticalConnector, mem_ofPred_eq, Complex.add_re,
+          Complex.ofReal_re, Complex.mul_re, Complex.I_re, Complex.ofReal_im,
+          Complex.I_im, mul_zero, sub_self, add_zero, Complex.add_im,
+          Complex.mul_im, mul_one, zero_add]
+        exact ⟨trivial, le_rfl, (GuideSplice.circle_height_gt_quarter hB hx).le⟩
+      exact Or.inl (ball_subset_ball (by linarith)
+        (GuideSplice.initial_splice_image_subset_quarter_ball hB hx hα hω
+          hcircle hsector (mem_image_of_mem F (Or.inl hζV))))
+    · exact (hrest ⟨hpr ▸ hz, he⟩).1.2
+
+theorem conditional_stopped_splice_positive
+    {Ω : 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 γ)
+    (τ : Ω → ℝ≥0)
+    (hτ : IsStoppingTime (Filtration.natural B₀ (fun t => (hm t).stronglyMeasurable))
+      (fun ω => (τ ω : WithTop ℝ≥0)))
+    (B r : ℝ) (hB : 0 < B) (hr : 0 < r) (E : Set Ω)
+    (hgeometry : ∀ ω ∈ E, 0 < τ ω ∧ (γ ω (τ ω)).im = B / 4 ∧
+      |(γ ω (τ ω)).re| < B / 16 ∧
+      (∀ u : ℝ≥0, u < τ ω → (γ ω u).im < (γ ω (τ ω)).im) ∧
+      γ ω '' Icc 0 (τ ω) ⊆ GuideSplice.closedInitialRectangle B)
+    (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) :
+    ∀ᵐ ω ∂P, ω ∈ E →
+      0 < P⁻[(stoppedPhysicalTube γ τ (parameterContinuationRegion F a r O) W).indicator
+        (fun _ => 1) | hτ.measurableSpace] ω := by
+  apply conditional_stopped_physical_tube_positive κ hκ hκ8 B₀ hB₀ hm hc γ G F₀ hw
+    hboundary hsupport τ hτ _ W (parameterContinuationRegion_isOpen hF a r hO) hW E
+  · intro ω hω
+    obtain ⟨hτpos, hh, _, hprior, _⟩ := hgeometry ω hω
+    exact ⟨hτpos, by rw [hh]; positivity, hprior⟩
+  · intro ω hω
+    obtain ⟨_, hh, hx, _, hpast⟩ := hgeometry ω hω
+    obtain ⟨p, hp, hpD, hpO⟩ := exists_physical_splice_route (γ ω) (τ ω) hB hr hh hx hpast
+      F a O β htB htBT hβ hi hβH hcross hafter hcircle hsector htail
+    exact ⟨β T, p, hp, hpD, hpO, hend⟩
+
+end SLEExactGauge
+
+end
+
+end OAI
diff --git a/lean/OAI/Probability/SLE/Gauge/StoppedTubePassage.lean b/lean/OAI/Probability/SLE/Gauge/StoppedTubePassage.lean
new file mode 100644
index 0000000000000000000000000000000000000000..a606b2e0078bd23cd4ca1dabc991cc6797f08c35
--- /dev/null
+++ b/lean/OAI/Probability/SLE/Gauge/StoppedTubePassage.lean
@@ -0,0 +1,163 @@
+import OAI.Probability.SLE.StoppedMeasures
+import OAI.Probability.SLE.Geometry.GeometricTubeSupport
+import OAI.Probability.SLE.Gauge.VaryingPassageEvents
+
+namespace OAI
+
+/-! Passage after a stopping time from countably many open tube certificates.
+The stopped trace law gives independence for each fixed tube. A countable
+cover of pasts then gives pointwise positive conditional passage probability;
+no common support probability is assumed. -/
+
+noncomputable section
+open Set Filter MeasureTheory ProbabilityTheory
+open scoped Topology ENNReal NNReal
+
+namespace SLEExactGauge
+
+local instance : MeasurableSpace C(ℝ≥0, ℝ) := borel _
+local instance : BorelSpace C(ℝ≥0, ℝ) := ⟨rfl⟩
+local instance : MeasurableSpace C(ℝ≥0, ℂ) := borel _
+local instance : BorelSpace C(ℝ≥0, ℂ) := ⟨rfl⟩
+
+/-- A fixed positive-law test, certified on a past event, forces the
+conditional passage probability to be positive on that event. -/
+theorem conditional_passage_positive_on_certificate
+    {Ω X : Type*} [mΩ : MeasurableSpace Ω] [mX : MeasurableSpace X]
+    (P : Measure Ω) [IsFiniteMeasure P] (ν : Measure X)
+    (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 • ν)
+    (A C : Set Ω) (hA : MeasurableSet[m] A) (hC : MeasurableSet[mΩ] C)
+    (B : Set X) (hB : MeasurableSet B) (hBpos : 0 < ν B)
+    (hcert : A ∩ Y ⁻¹' B ⊆ C) :
+    ∀ᵐ ω ∂P, ω ∈ A → 0 < P⁻[C.indicator (fun _ => 1) | m] ω := by
+  let : MeasurableSpace Ω := mΩ
+  let q := P⁻[C.indicator (fun _ => 1) | m]
+  let Z := A ∩ {ω | q ω = 0}
+  have hZ : MeasurableSet[m] Z :=
+    hA.inter (measurableSet_eq_fun (measurable_condLExp m P _) measurable_const)
+  have hzero : P (Z ∩ C) = 0 := by
+    calc
+      P (Z ∩ C) = ∫⁻ ω in Z, C.indicator (fun _ => 1) ω ∂P := by
+        rw [setLIntegral_indicator hC, setLIntegral_const, one_mul]
+        congr 1
+        exact inter_comm Z C
+      _ = ∫⁻ ω in Z, q ω ∂P := (setLIntegral_condLExp hm P _ hZ).symm
+      _ = 0 := by
+        apply (setLIntegral_eq_zero_iff (hm Z hZ)
+          ((measurable_condLExp m P _).mono hm le_rfl)).mpr
+        exact Eventually.of_forall (fun ω hω => hω.2)
+  have hproduct : P Z * ν B = 0 := by
+    apply le_antisymm ?_ bot_le
+    calc
+      P Z * ν B = ((P.restrict Z).map Y) B := by
+        rw [hlaw Z hZ, Measure.smul_apply, smul_eq_mul]
+      _ = P (Y ⁻¹' B ∩ Z) := by
+        rw [Measure.map_apply hY hB, Measure.restrict_apply (hY hB)]
+      _ ≤ P (Z ∩ C) := measure_mono (by
+        rintro ω ⟨hωB, hωZ⟩
+        exact ⟨hωZ, hcert ⟨hωZ.1, hωB⟩⟩)
+      _ = 0 := hzero
+  have hZzero : P Z = 0 :=
+    (mul_eq_zero.mp hproduct).resolve_right hBpos.ne'
+  filter_upwards [measure_eq_zero_iff_ae_notMem.mp hZzero] with ω hω hωA
+  by_contra h
+  exact hω ⟨hωA, le_antisymm (not_lt.mp h) bot_le⟩
+
+/-- Countably many past-measurable tube certificates suffice even when
+their positive support probabilities depend on the certificate. -/
+theorem conditional_passage_positive_of_countable_certificates
+    {Ω X : Type*} [mΩ : MeasurableSpace Ω] [mX : MeasurableSpace X]
+    (P : Measure Ω) [IsFiniteMeasure P] (ν : Measure X)
+    (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 • ν)
+    (E C : Set Ω) (hC : MeasurableSet[mΩ] C)
+    (A : ℕ → Set Ω) (hA : ∀ i, MeasurableSet[m] (A i))
+    (B : ℕ → Set X) (hB : ∀ i, MeasurableSet (B i))
+    (hBpos : ∀ i, 0 < ν (B i))
+    (hcert : ∀ i, A i ∩ Y ⁻¹' B i ⊆ C)
+    (hcover : E ⊆ ⋃ i, A i) :
+    ∀ᵐ ω ∂P, ω ∈ E → 0 < P⁻[C.indicator (fun _ => 1) | m] ω := by
+  let : MeasurableSpace Ω := mΩ
+  have hall : ∀ᵐ ω ∂P, ∀ i, ω ∈ A i →
+      0 < P⁻[C.indicator (fun _ => 1) | m] ω :=
+    ae_all_iff.mpr (fun i => conditional_passage_positive_on_certificate
+      P ν m hm Y hY hlaw (A i) C (hA i) hC (B i) (hB i) (hBpos i) (hcert i))
+  filter_upwards [hall] with ω hω hωE
+  obtain ⟨i, hi⟩ := mem_iUnion.mp (hcover hωE)
+  exact hω i hi
+
+/-- The actual Brownian stopped trace law and the published geometric
+support input give conditional positivity for countably certified geometric
+continuations. The same realization also has the actual conformal restart
+identity, so the certificates can be checked in the original domain. -/
+theorem stopped_geometric_tube_passages
+    {Ω : 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 ω))
+    (hpublished : PublishedGeometricTubeSupport P γ) :
+    ∃ Φ : C(ℝ≥0, ℝ) → C(ℝ≥0, ℂ), Measurable Φ ∧
+      (∀ ω, Φ (sourceDriverPath B hc ω) =
+        sourceTracePath γ (fun ω => (hw ω).1) ω) ∧
+      ∀ (τ : Ω → ℝ≥0)
+        (hτ : IsStoppingTime
+          (Filtration.natural B (fun t => (hm t).stronglyMeasurable))
+          (fun ω => (τ ω : WithTop ℝ≥0))),
+        (∀ᵐ ω ∂P, ∀ t : ℝ≥0,
+          Φ (sourceRestartDriverPath B hc τ ω) t ∈ upperHalfPlane →
+          γ ω (τ ω + t) = F ω (τ ω)
+            (Φ (sourceRestartDriverPath B hc τ ω) t +
+              (Real.sqrt κ * B (τ ω) ω : ℝ))) ∧
+        ∀ (E C : Set Ω), MeasurableSet[mΩ] C →
+        ∀ (A : ℕ → Set Ω), (∀ i, MeasurableSet[hτ.measurableSpace] (A i)) →
+        ∀ (z : ℕ → ℂ) (p : ∀ i, Path (0 : ℂ) (z i)),
+          (∀ i, Function.Injective (p i)) →
+          (∀ i t, t ≠ 0 → p i t ∈ upperHalfPlane) →
+        ∀ (N V : ℕ → Set ℂ), (∀ i, IsOpen (N i)) → (∀ i, IsOpen (V i)) →
+          (∀ i, range (p i) ⊆ N i) → (∀ i, z i ∈ V i) →
+          (∀ i, A i ∩ (fun ω => Φ (sourceRestartDriverPath B hc τ ω)) ⁻¹'
+            pathTubeEvent (N i) (V i) ⊆ C) →
+          E ⊆ ⋃ i, A i →
+          ∀ᵐ ω ∂P, ω ∈ E →
+            0 < P⁻[C.indicator (fun _ => 1) | hτ.measurableSpace] ω := by
+  let : IsProbabilityMeasure P := hB.isGaussianProcess.isProbabilityMeasure
+  obtain ⟨Φ, hΦm, hΦ, hlaw⟩ :=
+    sourceStoppedTraceLaw κ hκ hκ8 B hB hm hc γ G F hw
+  refine ⟨Φ, hΦm, hΦ, ?_⟩
+  intro τ hτ
+  refine ⟨(hlaw τ hτ).2, ?_⟩
+  intro E C hC A hA z p hp hpH N V hN hV hpN hzV hcert hcover
+  let : MeasurableSpace Ω := mΩ
+  let gp := sourceTracePath γ (fun ω => (hw ω).1)
+  have hgm : Measurable gp := by
+    have he : gp = fun ω => Φ (sourceDriverPath B hc ω) := funext fun ω => (hΦ ω).symm
+    rw [he]
+    exact hΦm.comp (source_path_measurable (sourceDriverPath B hc) hm)
+  have hrm : Measurable (sourceRestartDriverPath B hc τ) :=
+    source_path_measurable _ (fun t => (measurable_pi_apply t).comp
+      (brownianRestart_measurable hm hc (stopping_time_measurable_nnreal hτ)))
+  have htests : ∀ i, 0 < P.map gp (pathTubeEvent (N i) (V i)) := by
+    intro i
+    rw [Measure.map_apply hgm (measurableSet_pathTubeEvent (hN i) (hV i))]
+    exact hpublished (z i) (p i) (hp i) (hpH i) (N i) (V i)
+      (hN i) (hV i) (hpN i) (hzV i)
+  exact conditional_passage_positive_of_countable_certificates P (P.map gp)
+    hτ.measurableSpace hτ.measurableSpace_le
+    (fun ω => Φ (sourceRestartDriverPath B hc τ ω)) (hΦm.comp hrm)
+    ((hlaw τ hτ).1) E C hC A hA
+    (fun i => pathTubeEvent (N i) (V i))
+    (fun i => measurableSet_pathTubeEvent (hN i) (hV i)) htests hcert hcover
+
+end SLEExactGauge
+
+end
+
+end OAI
diff --git a/lean/OAI/Probability/SLE/Gauge/StrictPastCountable.lean b/lean/OAI/Probability/SLE/Gauge/StrictPastCountable.lean
new file mode 100644
index 0000000000000000000000000000000000000000..45cb7c5584da70c1df408201580d4efdc3203447
--- /dev/null
+++ b/lean/OAI/Probability/SLE/Gauge/StrictPastCountable.lean
@@ -0,0 +1,82 @@
+import OAI.Probability.SLE.Gauge.StrictPastExpectation
+
+namespace OAI
+
+/-! Countable exhaustion of the strict past-mass identity. -/
+
+noncomputable section
+open Set Filter _root_.MeasureTheory _root_.OAI.MeasureTheory ProbabilityTheory
+open scoped Topology NNReal ENNReal
+attribute [local instance] Classical.propDecidable
+
+namespace SLEExactGauge.Multipoint.CanonicalMass
+
+variable {Ω : Type*} [mΩ : MeasurableSpace Ω] {P : Measure Ω}
+  {κ : ℝ} {B : ℝ≥0 → Ω → ℝ} {hBm : Measurable (Function.uncurry B)}
+  {γ : Ω → ℝ≥0 → ℂ} {G : Ω → ℝ≥0 → ℂ → ℂ}
+  (C : CanonicalMass P κ B hBm γ G) (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 ω))
+
+include C hB hc h0 hκ hκ8 F hw
+
+lemma finite_strict_past_mass_aemeasurable (I : Finset ℝ≥0) (E : ℝ≥0 → Set Ω)
+    (hE : ∀ t∈I, MeasurableSet[(Filtration.natural B (fun s =>
+      (hBm.comp (measurable_const.prodMk measurable_id) : Measurable (B s)).stronglyMeasurable)) t] (E t))
+    (K : Set upperHalfPlane) (hK : IsCompact K) :
+    AEMeasurable (fun ω => C.rational.terminal ω (K ∩ ⋃ t∈I,
+      if ω∈E t then {z : upperHalfPlane | (z:ℂ)∈γ ω '' Icc 0 t}ᶜ else ∅)) P := by
+  let ℱ := Filtration.natural B (fun s =>
+    (hBm.comp (measurable_const.prodMk measurable_id) : Measurable (B s)).stronglyMeasurable)
+  let f (t : ℝ≥0) := (firstPastSuccess I E t).indicator (fun ω => C.rational.terminal ω
+    (K \ {z : upperHalfPlane | (z:ℂ)∈γ ω '' Icc 0 t}))
+  have hf (t) (ht : t∈I) : AEMeasurable (f t) P :=
+    (C.strict_past_mass_aemeasurable hB hc h0 hκ hκ8 F hw t K hK).indicator
+      ((ℱ.le t) _ (firstPastSuccess_measurable ℱ I E hE ht))
+  have hm := I.aemeasurable_sum hf
+  apply hm.congr
+  filter_upwards [] with ω
+  simp only [Finset.sum_apply]
+  symm
+  simpa only [f,Set.indicator,mem_ofPred_eq] using firstPastSuccess_future_mass
+    (C.rational.terminal ω) K I E
+    (fun t => {z : upperHalfPlane | (z:ℂ)∈γ ω '' Icc 0 t})
+    (fun s t hst z hz => by
+      obtain ⟨r,hr,he⟩ := hz
+      exact ⟨r,⟨hr.1,hr.2.trans hst⟩,he⟩) ω
+
+lemma countable_strict_past_expectation (J : ℕ → Finset ℝ≥0) (hJ : Monotone J)
+    (E : ℝ≥0 → Set Ω)
+    (hE : ∀ t, MeasurableSet[(Filtration.natural B (fun s =>
+      (hBm.comp (measurable_const.prodMk measurable_id) : Measurable (B s)).stronglyMeasurable)) t] (E t))
+    (K : Set upperHalfPlane) (hK : IsCompact K) :
+    (∫⁻ ω, C.rational.terminal ω (K ∩ ⋃ n, ⋃ t∈J n,
+      if ω∈E t then {z : upperHalfPlane | (z:ℂ)∈γ ω '' Icc 0 t}ᶜ else ∅) ∂P)=
+      ⨆ n, ∑ t∈J n, ∫⁻ ω in firstPastSuccess (J n) E t,
+        halfPlaneGreenMeasure κ B γ G t ω K ∂P := by
+  let A (n : ℕ) (ω : Ω) := K ∩ ⋃ t∈J n,
+    if ω∈E t then {z : upperHalfPlane | (z:ℂ)∈γ ω '' Icc 0 t}ᶜ else ∅
+  have hAm (ω) : Monotone (fun n => A n ω) := by
+    intro n m hnm z hz
+    obtain ⟨hzK,hz⟩ := hz
+    obtain ⟨t,ht,hzt⟩ := mem_iUnion₂.mp hz
+    exact ⟨hzK,mem_iUnion₂.mpr ⟨t,hJ hnm ht,hzt⟩⟩
+  have hfm (n) : AEMeasurable (fun ω => C.rational.terminal ω (A n ω)) P :=
+    C.finite_strict_past_mass_aemeasurable hB hc h0 hκ hκ8 F hw (J n) E (fun t _ => hE t) K hK
+  calc
+    _ = ∫⁻ ω, ⨆ n, C.rational.terminal ω (A n ω) ∂P := by
+      apply lintegral_congr
+      intro ω
+      rw [inter_iUnion]
+      exact (hAm ω).measure_iUnion
+    _ = ⨆ n, ∫⁻ ω, C.rational.terminal ω (A n ω) ∂P :=
+      lintegral_iSup' hfm (Eventually.of_forall (fun ω n m hnm => measure_mono (hAm ω hnm)))
+    _ = _ := iSup_congr (fun n => C.finite_strict_past_expectation hB hc h0 hκ hκ8 F hw
+      (J n) E (fun t _ => hE t) K hK)
+
+end SLEExactGauge.Multipoint.CanonicalMass
+
+end
+
+end OAI
diff --git a/lean/OAI/Probability/SLE/Gauge/StrictPastExpectation.lean b/lean/OAI/Probability/SLE/Gauge/StrictPastExpectation.lean
new file mode 100644
index 0000000000000000000000000000000000000000..554277d93605eb0ef3e7d6f84a486ea46f38a862
--- /dev/null
+++ b/lean/OAI/Probability/SLE/Gauge/StrictPastExpectation.lean
@@ -0,0 +1,86 @@
+import OAI.Probability.SLE.Geometry.FirstSuccessfulPast
+
+namespace OAI
+
+/-! The finite past-mass identity before exhaustion over rational times. -/
+
+noncomputable section
+open Set Filter _root_.MeasureTheory _root_.OAI.MeasureTheory ProbabilityTheory
+open scoped Topology NNReal ENNReal
+attribute [local instance] Classical.propDecidable
+
+namespace SLEExactGauge.Multipoint.CanonicalMass
+
+variable {Ω : Type*} [mΩ : MeasurableSpace Ω] {P : Measure Ω}
+  {κ : ℝ} {B : ℝ≥0 → Ω → ℝ} {hBm : Measurable (Function.uncurry B)}
+  {γ : Ω → ℝ≥0 → ℂ} {G : Ω → ℝ≥0 → ℂ → ℂ}
+  (C : CanonicalMass P κ B hBm γ G) (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 ω))
+
+include C hB hc h0 hκ hκ8 F hw
+
+lemma strict_past_mass_aemeasurable (t : ℝ≥0) (K : Set upperHalfPlane) (hK : IsCompact K) :
+    AEMeasurable (fun ω => C.rational.terminal ω
+      (K \ {z : upperHalfPlane | (z:ℂ)∈γ ω '' Icc 0 t})) P := by
+  have hNm : Measurable (C.process t) := by
+    simpa only [atTime,extendedCanonicalMass,ENNReal.coe_lt_top,ite_true,ENNReal.toNNReal_coe]
+      using C.atTime_measurable (fun _ => (t:ℝ≥0∞)) measurable_const
+  have hm : Measurable (fun ω => C.rational.terminal ω K-C.process t ω K) :=
+    ((Measure.measurable_coe hK.measurableSet).comp C.rational.terminal_measurable).sub
+      ((Measure.measurable_coe hK.measurableSet).comp hNm)
+  apply hm.aemeasurable.congr
+  have hp : ∀ᵐ ω ∂P, C.process t ω=(C.rational.terminal ω).restrict
+      {z : upperHalfPlane | (z:ℂ)∈γ ω '' Icc 0 t} := by
+    simpa only [atTime,extendedCanonicalMass,ENNReal.coe_lt_top,ite_true,ENNReal.toNNReal_coe]
+      using C.atTime_eq_restrict_past hB hBm hc h0 hκ hκ8 F hw t
+  filter_upwards [hp] with ω hω
+  have hsum : C.process t ω K+C.rational.terminal ω
+      (K \ {z : upperHalfPlane | (z:ℂ)∈γ ω '' Icc 0 t})=C.rational.terminal ω K := by
+    rw [hω,Measure.restrict_apply hK.measurableSet]
+    exact measure_inter_add_sdiff K
+      (((isCompact_Icc.image (hw ω).1).isClosed.preimage continuous_subtype_val).measurableSet)
+  let := (C.radon t ω).2
+  rw [← hsum,ENNReal.add_sub_cancel_left hK.measure_lt_top.ne]
+
+lemma finite_strict_past_expectation (I : Finset ℝ≥0) (E : ℝ≥0 → Set Ω)
+    (hE : ∀ t∈I, MeasurableSet[(Filtration.natural B (fun s =>
+      (hBm.comp (measurable_const.prodMk measurable_id) : Measurable (B s)).stronglyMeasurable)) t] (E t))
+    (K : Set upperHalfPlane) (hK : IsCompact K) :
+    (∫⁻ ω, C.rational.terminal ω (K ∩ ⋃ t∈I,
+      if ω∈E t then {z : upperHalfPlane | (z:ℂ)∈γ ω '' Icc 0 t}ᶜ else ∅) ∂P)=
+      ∑ t∈I, ∫⁻ ω in firstPastSuccess I E t, halfPlaneGreenMeasure κ B γ G t ω K ∂P := by
+  let ℱ := Filtration.natural B (fun s =>
+    (hBm.comp (measurable_const.prodMk measurable_id) : Measurable (B s)).stronglyMeasurable)
+  let f (t : ℝ≥0) := (firstPastSuccess I E t).indicator (fun ω => C.rational.terminal ω
+    (K \ {z : upperHalfPlane | (z:ℂ)∈γ ω '' Icc 0 t}))
+  have hfirst (t) (ht : t∈I) : MeasurableSet (firstPastSuccess I E t) :=
+    (ℱ.le t) _ (firstPastSuccess_measurable ℱ I E hE ht)
+  have hf (t) (ht : t∈I) : AEMeasurable (f t) P :=
+    (C.strict_past_mass_aemeasurable hB hc h0 hκ hκ8 F hw t K hK).indicator (hfirst t ht)
+  calc
+    _ = ∫⁻ ω, ∑ t∈I, f t ω ∂P := by
+      apply lintegral_congr
+      intro ω
+      simpa only [f,Set.indicator,mem_ofPred_eq] using firstPastSuccess_future_mass
+        (C.rational.terminal ω) K I E
+        (fun t => {z : upperHalfPlane | (z:ℂ)∈γ ω '' Icc 0 t})
+        (fun s t hst z hz => by
+          obtain ⟨r,hr,he⟩ := hz
+          exact ⟨r,⟨hr.1,hr.2.trans hst⟩,he⟩) ω
+    _ = ∑ t∈I, ∫⁻ ω, f t ω ∂P := lintegral_finsetSum' I hf
+    _ = _ := by
+      apply Finset.sum_congr rfl
+      intro t ht
+      rw [show f t=(firstPastSuccess I E t).indicator (fun ω => C.rational.terminal ω
+        (K \ {z : upperHalfPlane | (z:ℂ)∈γ ω '' Icc 0 t})) from rfl,
+        lintegral_indicator (hfirst t ht)]
+      exact C.strict_past_mass_kernel hB hc h0 hκ hκ8 F hw t _
+        (firstPastSuccess_measurable ℱ I E hE ht) K hK
+
+end SLEExactGauge.Multipoint.CanonicalMass
+
+end
+
+end OAI
diff --git a/lean/OAI/Probability/SLE/Gauge/StrictPastSpatial.lean b/lean/OAI/Probability/SLE/Gauge/StrictPastSpatial.lean
new file mode 100644
index 0000000000000000000000000000000000000000..280e67581f6c66e8a159e1937c0f75d1e0d8caa1
--- /dev/null
+++ b/lean/OAI/Probability/SLE/Gauge/StrictPastSpatial.lean
@@ -0,0 +1,67 @@
+import OAI.Probability.SLE.Gauge.StrictPastExpectation
+import OAI.Probability.SLE.Geometry.GreenCompactDecay
+
+namespace OAI
+
+/-! Spatial Green-integral versions of the strict past-mass identities. -/
+
+noncomputable section
+open Set Filter _root_.MeasureTheory _root_.OAI.MeasureTheory ProbabilityTheory
+open scoped Topology NNReal ENNReal
+attribute [local instance] Classical.propDecidable
+
+namespace SLEExactGauge.Multipoint.CanonicalMass
+
+variable {Ω : Type*} [mΩ : MeasurableSpace Ω] {P : Measure Ω}
+  {κ : ℝ} {B : ℝ≥0 → Ω → ℝ} {hBm : Measurable (Function.uncurry B)}
+  {γ : Ω → ℝ≥0 → ℂ} {G : Ω → ℝ≥0 → ℂ → ℂ}
+  (C : CanonicalMass P κ B hBm γ G) (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 ω))
+
+include C hB hc h0 hκ hκ8 F hw
+
+lemma strict_past_mass_spatial (t : ℝ≥0) (E : Set Ω)
+    (hE : MeasurableSet[(Filtration.natural B (fun s =>
+      (hBm.comp (measurable_const.prodMk measurable_id) : Measurable (B s)).stronglyMeasurable)) t] E)
+    (K : Set upperHalfPlane) (hK : IsCompact K) :
+    (∫⁻ ω in E, C.rational.terminal ω
+      (K \ {z : upperHalfPlane | (z:ℂ)∈γ ω '' Icc 0 t}) ∂P)=
+      ∫⁻ z in (Subtype.val : upperHalfPlane → ℂ) '' K, ∫⁻ ω in E,
+        ENNReal.ofReal (greenDensity κ (fun s => Real.sqrt κ*B s ω) (γ ω) (G ω) t z) ∂P ∂volume := by
+  let : IsProbabilityMeasure P := hB.isGaussianProcess.isProbabilityMeasure
+  rw [C.strict_past_mass_kernel hB hc h0 hκ hκ8 F hw t E hE K hK]
+  rw [← Measure.bind_apply hK.measurableSet
+    (halfPlaneGreenMeasure_measurable hBm hc κ γ G F hw t).aemeasurable]
+  exact halfPlaneGreenMeasure_mean_apply (P.restrict E) hBm hc κ γ G F hw t K hK.measurableSet
+
+lemma finite_strict_past_spatial (I : Finset ℝ≥0) (E : ℝ≥0 → Set Ω)
+    (hE : ∀ t∈I, MeasurableSet[(Filtration.natural B (fun s =>
+      (hBm.comp (measurable_const.prodMk measurable_id) : Measurable (B s)).stronglyMeasurable)) t] (E t))
+    (K : Set upperHalfPlane) (hK : IsCompact K) :
+    (∫⁻ ω, C.rational.terminal ω (K ∩ ⋃ t∈I,
+      if ω∈E t then {z : upperHalfPlane | (z:ℂ)∈γ ω '' Icc 0 t}ᶜ else ∅) ∂P)=
+      ∫⁻ z in (Subtype.val : upperHalfPlane → ℂ) '' K,
+        ∑ t∈I, ∫⁻ ω in firstPastSuccess I E t,
+          ENNReal.ofReal (greenDensity κ (fun s => Real.sqrt κ*B s ω) (γ ω) (G ω) t z) ∂P ∂volume := by
+  let : IsProbabilityMeasure P := hB.isGaussianProcess.isProbabilityMeasure
+  rw [C.finite_strict_past_expectation hB hc h0 hκ hκ8 F hw I E hE K hK]
+  have hswap (t : ℝ≥0) :
+      (∫⁻ ω in firstPastSuccess I E t, halfPlaneGreenMeasure κ B γ G t ω K ∂P)=
+        ∫⁻ z in (Subtype.val : upperHalfPlane → ℂ) '' K, ∫⁻ ω in firstPastSuccess I E t,
+          ENNReal.ofReal (greenDensity κ (fun s => Real.sqrt κ*B s ω) (γ ω) (G ω) t z) ∂P ∂volume := by
+    rw [← Measure.bind_apply hK.measurableSet
+      (halfPlaneGreenMeasure_measurable hBm hc κ γ G F hw t).aemeasurable]
+    exact halfPlaneGreenMeasure_mean_apply (P.restrict _) hBm hc κ γ G F hw t K hK.measurableSet
+  simp_rw [hswap]
+  symm
+  apply lintegral_finsetSum
+  intro t _
+  exact (actual_greenDensity_joint_measurable hBm hc κ γ G F hw t).ennreal_ofReal.lintegral_prod_left'
+
+end SLEExactGauge.Multipoint.CanonicalMass
+
+end
+
+end OAI
diff --git a/lean/OAI/Probability/SLE/Gauge/StrictPastTilted.lean b/lean/OAI/Probability/SLE/Gauge/StrictPastTilted.lean
new file mode 100644
index 0000000000000000000000000000000000000000..3a64b04bced85df048c4d34bb195d75a01c9e4be
--- /dev/null
+++ b/lean/OAI/Probability/SLE/Gauge/StrictPastTilted.lean
@@ -0,0 +1,109 @@
+import OAI.Probability.SLE.Geometry.FinitePastKernel
+import OAI.Probability.SLE.Gauge.StrictPastSpatial
+
+namespace OAI
+
+/-! The strict past-mass formula expressed through finite centered laws.
+Every spatial integrand is identified before applying monotone convergence. -/
+
+noncomputable section
+open Set Filter _root_.MeasureTheory _root_.OAI.MeasureTheory ProbabilityTheory
+open scoped Topology NNReal ENNReal
+attribute [local instance] Classical.propDecidable
+
+namespace SLEExactGauge.Multipoint
+
+variable {Ω : Type*} [mΩ : MeasurableSpace Ω] {P : Measure Ω}
+  {κ : ℝ} {B : ℝ≥0 → Ω → ℝ}
+  (hB : IsBrownianReal B P) (hBm : Measurable (Function.uncurry B))
+  (hc : ∀ ω, Continuous (fun t => B t ω)) (h0 : ∀ ω, B 0 ω = 0)
+  (hκ : 0 < κ) (hκ8 : κ < 8)
+  (γ : Ω → ℝ≥0 → ℂ) (G F : Ω → ℝ≥0 → ℂ → ℂ)
+  (hw : ∀ ω, IsCapacityTwoWitness (fun t => Real.sqrt κ * B t ω) (γ ω) (G ω) (F ω))
+
+include hB hBm hc h0 hκ hκ8 γ G F hw
+
+lemma finiteCenteredLaw_tests_spatial_tendsto
+    (u : ℕ → ℝ) (hu : ∀ n, 0 ≤ u n) (hmono : Monotone u)
+    (hlim : Tendsto u atTop atTop) (I : Finset ℝ≥0) (E : ℝ≥0 → Set Ω)
+    (hE : ∀ t∈I, MeasurableSet[(Filtration.natural B (fun s =>
+      (hBm.comp (measurable_const.prodMk measurable_id) : Measurable (B s)).stronglyMeasurable)) t] (E t))
+    (K : Set ℂ) (hK : MeasurableSet K) (hKH : K ⊆ upperHalfPlane) :
+    Tendsto (fun n => ∫⁻ z in K, ENNReal.ofReal (initialGreen κ z) *
+      finiteCenteredLaw P κ B γ G z (u n)
+        (finiteStrictPastEvent I E (fun ω => radiusLevelTime (γ ω) (G ω) z (u n))) ∂volume) atTop
+      (𝓝 (∫⁻ z in K, ∑ t∈I, ∫⁻ ω in firstPastSuccess I E t,
+        ENNReal.ofReal (greenDensity κ (fun s => Real.sqrt κ * B s ω) (γ ω) (G ω) t z) ∂P ∂volume)) := by
+  let : IsProbabilityMeasure P := hB.isGaussianProcess.isProbabilityMeasure
+  have hlevel (n : ℕ) :
+      (∫⁻ z in K, ENNReal.ofReal (initialGreen κ z) * finiteCenteredLaw P κ B γ G z (u n)
+        (finiteStrictPastEvent I E (fun ω => radiusLevelTime (γ ω) (G ω) z (u n))) ∂volume) =
+      ∑ t∈I, ∫⁻ z in K, ∫⁻ ω in firstPastSuccess I E t,
+        ENNReal.ofReal (levelCurrentGreen κ B γ G (u n) t z ω) ∂P ∂volume := by
+    calc
+      _ = ∫⁻ z in K, ∑ t∈I, ∫⁻ ω in firstPastSuccess I E t,
+          ENNReal.ofReal (levelCurrentGreen κ B γ G (u n) t z ω) ∂P ∂volume := by
+        apply setLIntegral_congr_fun hK
+        intro z hz
+        exact finiteCenteredLaw_tests hB hBm hc h0 hκ hκ8 γ G F hw z (hKH hz)
+          (u n) (hu n) I E hE
+      _ = _ := by
+        apply lintegral_finsetSum
+        intro t _
+        exact (levelCurrentGreen_joint_measurable hBm hc κ (u n) (hu n) γ G F hw t).ennreal_ofReal.lintegral_prod_left'
+  have hlast :
+      (∫⁻ z in K, ∑ t∈I, ∫⁻ ω in firstPastSuccess I E t,
+        ENNReal.ofReal (greenDensity κ (fun s => Real.sqrt κ * B s ω) (γ ω) (G ω) t z) ∂P ∂volume) =
+      ∑ t∈I, ∫⁻ z in K, ∫⁻ ω in firstPastSuccess I E t,
+        ENNReal.ofReal (greenDensity κ (fun s => Real.sqrt κ * B s ω) (γ ω) (G ω) t z) ∂P ∂volume := by
+    apply lintegral_finsetSum
+    intro t _
+    exact (actual_greenDensity_joint_measurable hBm hc κ γ G F hw t).ennreal_ofReal.lintegral_prod_left'
+  rw [hlast]
+  simp_rw [hlevel]
+  apply tendsto_finsetSum
+  intro t _
+  have hh := currentGreen_spatial_mean_tendsto P hBm hc κ γ G F hw u hu hmono hlim
+    t K (fun _ => 1) measurable_const (firstPastSuccess I E t)
+  have hs (n : ℕ) :
+      (∫⁻ z in K, ∫⁻ ω in firstPastSuccess I E t,
+        ENNReal.ofReal (levelCurrentGreen κ B γ G (u n) t z ω) ∂P ∂volume) =
+      ∫⁻ ω in firstPastSuccess I E t, ∫⁻ z in K,
+        ENNReal.ofReal (levelCurrentGreen κ B γ G (u n) t z ω) ∂volume ∂P :=
+    (lintegral_lintegral_swap
+      (levelCurrentGreen_joint_measurable hBm hc κ (u n) (hu n) γ G F hw t).ennreal_ofReal.aemeasurable).symm
+  have hs' :
+      (∫⁻ z in K, ∫⁻ ω in firstPastSuccess I E t,
+        ENNReal.ofReal (greenDensity κ (fun s => Real.sqrt κ * B s ω) (γ ω) (G ω) t z) ∂P ∂volume) =
+      ∫⁻ ω in firstPastSuccess I E t, ∫⁻ z in K,
+        ENNReal.ofReal (greenDensity κ (fun s => Real.sqrt κ * B s ω) (γ ω) (G ω) t z) ∂volume ∂P :=
+    (lintegral_lintegral_swap
+      (actual_greenDensity_joint_measurable hBm hc κ γ G F hw t).ennreal_ofReal.aemeasurable).symm
+  simpa only [one_mul, hs, hs'] using hh
+
+namespace CanonicalMass
+
+lemma finite_strict_past_tilted_limit
+    (C : CanonicalMass P κ B hBm γ G)
+    (u : ℕ → ℝ) (hu : ∀ n, 0 ≤ u n) (hmono : Monotone u)
+    (hlim : Tendsto u atTop atTop) (I : Finset ℝ≥0) (E : ℝ≥0 → Set Ω)
+    (hE : ∀ t∈I, MeasurableSet[(Filtration.natural B (fun s =>
+      (hBm.comp (measurable_const.prodMk measurable_id) : Measurable (B s)).stronglyMeasurable)) t] (E t))
+    (K : Set upperHalfPlane) (hK : IsCompact K) :
+    Tendsto (fun n => ∫⁻ z in (Subtype.val : upperHalfPlane → ℂ) '' K,
+      ENNReal.ofReal (initialGreen κ z) * finiteCenteredLaw P κ B γ G z (u n)
+        (finiteStrictPastEvent I E (fun ω => radiusLevelTime (γ ω) (G ω) z (u n))) ∂volume) atTop
+      (𝓝 (∫⁻ ω, C.rational.terminal ω (K ∩ ⋃ t∈I,
+        if ω∈E t then {z : upperHalfPlane | (z:ℂ)∈γ ω '' Icc 0 t}ᶜ else ∅) ∂P)) := by
+  rw [C.finite_strict_past_spatial hB hc h0 hκ hκ8 F hw I E hE K hK]
+  apply finiteCenteredLaw_tests_spatial_tendsto hB hBm hc h0 hκ hκ8 γ G F hw u hu hmono hlim I E hE
+    _ (hK.image continuous_subtype_val).measurableSet
+  rintro _ ⟨z,_,rfl⟩
+  exact z.property
+
+end CanonicalMass
+end SLEExactGauge.Multipoint
+
+end
+
+end OAI
diff --git a/lean/OAI/Probability/SLE/Gauge/UniformActualRibbonPassage.lean b/lean/OAI/Probability/SLE/Gauge/UniformActualRibbonPassage.lean
new file mode 100644
index 0000000000000000000000000000000000000000..eacee98da87c4ba61273622d37457104cdf1ec49
--- /dev/null
+++ b/lean/OAI/Probability/SLE/Gauge/UniformActualRibbonPassage.lean
@@ -0,0 +1,191 @@
+import OAI.Probability.SLE.Gauge.UniformRecenteredPassage
+import OAI.Probability.SLE.Geometry.ActualWaypointAngle
+import OAI.Probability.SLE.Gauge.RibbonStepPatch
+
+namespace OAI
+
+/-! Uniform one-step passage for actual ribbon histories. The two-sided
+waypoint angle and the compactness hypotheses are derived from the fixed
+patch bounds, the actual first-front past, and the published analytic and
+probabilistic inputs. -/
+
+noncomputable section
+open Set Filter MeasureTheory ProbabilityTheory Metric
+open scoped Topology NNReal ENNReal
+
+namespace SLEExactGauge
+open RibbonCoordinates BoundaryScaleLaw Target
+
+/-- Data at an actual attained ribbon front, before any restart. -/
+structure RibbonHistory (C L : ℝ≥0) (ε : ℝ) where
+  U : ℝ≥0 → ℝ
+  trace : ℝ≥0 → ℂ
+  forward : ℝ≥0 → ℂ → ℂ
+  inverse : ℝ≥0 → ℂ → ℂ
+  driver_continuous : Continuous U
+  witness : IsCapacityTwoWitness U trace forward inverse
+  chart : ℂ → ℂ
+  chart_continuous : ContinuousOn chart closedRibbon
+  chart_injective : InjOn chart closedRibbon
+  chart_upper : ∀ z ∈ closedRibbon, 0 < z.re → chart z ∈ upperHalfPlane
+  chart_escape : Tendsto (fun t : ℝ => ‖chart (t : ℂ)‖) atTop atTop
+  front : ℝ
+  offset : ℝ
+  front_ge_one : 1 ≤ front
+  offset_bound : |offset| ≤ ε / 4
+  patch_upper : LipschitzOnWith C chart (ribbonStepPatch front)
+  patch_lower : ∀ u ∈ ribbonStepPatch front, ∀ v ∈ ribbonStepPatch front,
+    dist u v ≤ L * dist (chart u) (chart v)
+  time : ℝ≥0
+  time_pos : 0 < time
+  coordinates : ℝ≥0 → ℂ
+  coordinates_continuous : ContinuousOn coordinates (Icc 0 time)
+  trace_coordinates : EqOn trace (chart ∘ coordinates) (Icc 0 time)
+  initial_front : (coordinates 0).re = 0
+  attained : coordinates time = (front : ℂ) + (offset : ℂ) * Complex.I
+  coordinates_ribbon : MapsTo coordinates (Icc 0 time) closedRibbon
+  past_core : ∀ t ∈ Icc 0 time, (coordinates t).re ≤ front ∧ |(coordinates t).im| ≤ ε
+  strict_past : ∀ t : ℝ≥0, t < time → (coordinates t).re < front
+
+def RibbonHistory.guide {C L : ℝ≥0} {ε : ℝ} (d : RibbonHistory C L ε) (t : ℝ) : ℂ :=
+  d.chart (guideCoordinate d.front d.offset t)
+
+def RibbonHistory.recenteredChart {C L : ℝ≥0} {ε : ℝ}
+    (d : RibbonHistory C L ε) (z : ℂ) : ℂ :=
+  d.chart ((d.front : ℂ) + z) - d.trace d.time
+
+theorem uniform_actual_ribbon_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)
+    (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) :
+    ∃ Fb : RibbonHistory C L ε → C(closedHalfPlane, ℂ),
+      (∀ d (z : closedHalfPlane), z.1 ∈ upperHalfPlane → Fb d z =
+        d.inverse d.time ((d.U d.time : ℂ) + z) - d.trace d.time) ∧
+      ∃ q c v₀ : ℝ, 0 < q ∧ 0 < c ∧ 0 < v₀ ∧
+        ∀ d : RibbonHistory C L ε, ∀ v : ℝ, 0 < v → v < v₀ →
+          ENNReal.ofReal q ≤ P {ω |
+            finiteBoundaryPath (Fb d) (sourceTracePath γ (fun ω => (hwbase ω).1) ω) ∈
+              frontMassEvent (longitudinalCoordinate d.recenteredChart ribbonStepCompact 0)
+                (physicalPassageRegion d.recenteredChart ribbonStepCompact C ε (ε / L))
+                (d.recenteredChart 1) (ε / L) κ v c
+                (physicalMiddleRegion d.recenteredChart ribbonStepCompact 0 ε)} := by
+  have hLr : 0 < (L : ℝ) := hL
+  have hx (d : RibbonHistory C L ε) : |d.offset| ≤ 1 / 4 := by
+    linarith [d.offset_bound]
+  have hguideL (d : RibbonHistory C L ε) :
+      LipschitzOnWith C d.chart (guidePatch d.front) :=
+    d.patch_upper.mono (guidePatch_subset_ribbonStepPatch _)
+  have hguideLower (d : RibbonHistory C L ε) :
+      ∀ u ∈ guidePatch d.front, ∀ v ∈ guidePatch d.front,
+        dist u v ≤ L * dist (d.chart u) (d.chart v) := by
+    intro u hu v hv
+    exact d.patch_lower u (guidePatch_subset_ribbonStepPatch _ hu)
+      v (guidePatch_subset_ribbonStepPatch _ hv)
+  have hgeom (d : RibbonHistory C L ε) := ribbon_access_guide_geometry hplanar
+    d.chart d.chart_continuous d.chart_injective d.chart_upper d.chart_escape
+    d.trace d.coordinates d.time d.coordinates_continuous d.initial_front
+    d.coordinates_ribbon d.trace_coordinates d.front d.offset
+    (by linarith [d.front_ge_one]) (hx d) d.attained d.strict_past C L hLr
+    (hguideL d) (hguideLower d)
+  have hpast (d : RibbonHistory C L ε) :
+      d.trace '' Icc 0 d.time ⊆ d.chart '' {z ∈ closedRibbon | z.re ≤ d.front} := by
+    rintro z ⟨t, ht, rfl⟩
+    exact ⟨d.coordinates t, ⟨d.coordinates_ribbon ht, (d.past_core t ht).1⟩,
+      (d.trace_coordinates ht).symm⟩
+  have hclear : ∀ δ : ℝ, 0 < δ → δ ≤ 2 → ∃ r : ℝ, 0 < r ∧
+      ∀ (d : RibbonHistory C L ε) t, t ∈ Icc δ 2 →
+        ball (d.guide t) r ⊆ survivingDomain d.trace d.time := by
+    intro δ hδ _
+    refine ⟨min δ 1 / (4 * L), div_pos (lt_min hδ zero_lt_one) (by positivity), ?_⟩
+    intro d t ht
+    apply (ball_subset_ball ?_).trans
+      (physical_guide_clearance_of_patch hplanar d.chart d.chart_continuous d.chart_injective
+        (by linarith [d.front_ge_one]) (hx d) hLr d.chart_upper d.trace d.time (hpast d)
+        (futureRibbon_unbounded_of_centerline_escape d.chart d.front d.chart_escape)
+        (hguideLower d) t ⟨hδ.trans_le ht.1, ht.2⟩)
+    exact div_le_div_of_nonneg_right (min_le_min_right 1 ht.1) (by positivity)
+  obtain ⟨s, hs, hangle⟩ := uniform_actual_ribbon_waypoint_angle hplanar hstraight hexit
+    hwiener W hW C L hLr
+  have hang (d : RibbonHistory C L ε) :
+      s ≤ (d.forward d.time (d.guide (1 / 2)) - (d.U d.time : ℂ)).im /
+        ‖d.forward d.time (d.guide (1 / 2)) - (d.U d.time : ℂ)‖ := by
+    have hh := hangle d.U d.trace d.forward d.inverse d.witness d.driver_continuous
+      d.chart d.chart_continuous d.chart_injective d.chart_upper d.chart_escape
+      d.front ε d.offset d.front_ge_one hε hεsmall (by linarith [d.offset_bound])
+      (d.patch_upper.mono (crossingPatch_subset_ribbonStepPatch _))
+      (fun u hu v hv => d.patch_lower u (crossingPatch_subset_ribbonStepPatch _ hu)
+        v (crossingPatch_subset_ribbonStepPatch _ hv))
+      d.coordinates d.time d.time_pos d.coordinates_continuous d.trace_coordinates
+      d.initial_front d.attained d.coordinates_ribbon d.past_core d.strict_past
+    simpa only [RibbonHistory.guide, guideCoordinate_waypoint] using hh
+  have hQU (d : RibbonHistory C L ε) :
+      LipschitzOnWith C d.recenteredChart ribbonStepCompact := by
+    apply lipschitzOnWith_iff_dist_le_mul.mpr
+    intro u hu v hv
+    simpa only [RibbonHistory.recenteredChart, dist_sub_right, dist_add_left] using
+      d.patch_upper.dist_le_mul _ (translate_ribbonStepCompact hu) _
+        (translate_ribbonStepCompact hv)
+  have hQL (d : RibbonHistory C L ε) :
+      ∀ u ∈ ribbonStepCompact, ∀ v ∈ ribbonStepCompact,
+        dist u v ≤ L * dist (d.recenteredChart u) (d.recenteredChart v) := by
+    intro u hu v hv
+    simpa only [RibbonHistory.recenteredChart, dist_sub_right, dist_add_left] using
+      d.patch_lower _ (translate_ribbonStepCompact hu) _ (translate_ribbonStepCompact hv)
+  have hQ0 (d : RibbonHistory C L ε) : ‖d.recenteredChart 0‖ ≤ C := by
+    have htip : d.chart ((d.front : ℂ) + (d.offset : ℂ) * Complex.I) = d.trace d.time := by
+      rw [← d.attained]
+      exact (d.trace_coordinates ⟨bot_le, le_rfl⟩).symm
+    have hmem : (d.front : ℂ) + (d.offset : ℂ) * Complex.I ∈ ribbonStepPatch d.front := by
+      change d.front - 1 ≤ ((d.front : ℂ) + (d.offset : ℂ) * Complex.I).re ∧
+        ((d.front : ℂ) + (d.offset : ℂ) * Complex.I).re ≤ d.front + 3 ∧
+        |((d.front : ℂ) + (d.offset : ℂ) * Complex.I).im| ≤ 1
+      simp only [Complex.add_re, Complex.mul_re, Complex.ofReal_re, Complex.ofReal_im,
+        Complex.I_re, Complex.I_im, mul_zero, mul_one, sub_zero, add_zero,
+        Complex.add_im, Complex.mul_im, zero_add]
+      exact ⟨by linarith, by linarith, (hx d).trans (by norm_num)⟩
+    have hzero : (d.front : ℂ) ∈ ribbonStepPatch d.front := by
+      change d.front - 1 ≤ d.front ∧ d.front ≤ d.front + 3 ∧ |(0 : ℝ)| ≤ 1
+      constructor
+      · linarith
+      · constructor <;> norm_num
+    have hd := d.patch_upper.dist_le_mul _ hzero _ hmem
+    have hdist : dist (d.front : ℂ) ((d.front : ℂ) + (d.offset : ℂ) * Complex.I) =
+        |d.offset| := by
+      rw [dist_self_add_right, norm_mul, Complex.norm_I, mul_one, Complex.norm_real,
+        Real.norm_eq_abs]
+    rw [hdist, htip, dist_eq_norm] at hd
+    simpa only [RibbonHistory.recenteredChart, add_zero] using
+      hd.trans (mul_le_of_le_one_right C.coe_nonneg ((hx d).trans (by norm_num)))
+  apply uniform_recentered_passage_from_geometry P κ hκ hκ8 B₀ hB₀ hm hc γ Gbase Fbase
+    hwbase hcompact hboundary hsupport hplanar
+    RibbonHistory.U RibbonHistory.trace RibbonHistory.forward RibbonHistory.inverse
+    RibbonHistory.driver_continuous RibbonHistory.witness RibbonHistory.time RibbonHistory.time_pos
+    (fun d => (hgeom d).2.2.2.2.1) RibbonHistory.guide (2 * C) s (1 / L)
+    (by positivity) hs (one_div_pos.mpr hLr)
+    (fun d => (hgeom d).2.2.2.2.2.1) (fun d => (hgeom d).2.2.1)
+    (fun d => (hgeom d).2.2.2.2.2.2.1) (fun d => (hgeom d).2.2.2.1)
+    hclear RibbonHistory.recenteredChart ribbonStepCompact ribbonStepCompact_isCompact
+    0 ribbonStepCompact_zero C L C hC hL hQU hQL hQ0 RibbonHistory.offset ε hε
+    RibbonHistory.offset_bound (ribbonStepCompact_core hεsmall)
+    (fun d t _ => by simp only [RibbonHistory.recenteredChart, RibbonHistory.guide,
+      guideCoordinate_translate]) hang (ribbonStepCompact_passage hεsmall C (ε / L))
+
+end SLEExactGauge
+
+end
+
+end OAI
diff --git a/lean/OAI/Probability/SLE/Gauge/UniformFrontPassage.lean b/lean/OAI/Probability/SLE/Gauge/UniformFrontPassage.lean
new file mode 100644
index 0000000000000000000000000000000000000000..c89730d3507b679c5d14d468433505685e8c9857
--- /dev/null
+++ b/lean/OAI/Probability/SLE/Gauge/UniformFrontPassage.lean
@@ -0,0 +1,171 @@
+import OAI.Probability.SLE.Geometry.FrontSuccessStopped
+import OAI.Probability.SLE.Gauge.UniformPassageThreshold
+
+namespace OAI
+
+/-! The uniform quantifier step for actual front passages.  A compactness
+argument need only produce an eventual positive success probability along
+one strictly increasing subsequence of each vanishing-mesh sequence. -/
+
+noncomputable section
+open Set Filter MeasureTheory
+open scoped Topology NNReal ENNReal
+
+namespace SLEExactGauge
+
+/-- The diagonal obstruction to a uniform passage estimate persists along
+all subsequences, so compactness need only control one of them. -/
+theorem uniform_passage_threshold_of_subsequences
+    {A : Type*} (p : A → ℝ → ℝ → ℝ≥0∞)
+    (hmono : ∀ a v, Antitone (p a v))
+    (hsequence : ∀ (a : ℕ → A) (v : ℕ → ℝ), (∀ n, 0 < v n) →
+      Tendsto v atTop (𝓝 0) →
+      ∃ φ : ℕ → ℕ, StrictMono φ ∧ ∃ c : ℝ, 0 < c ∧ ∃ q : ℝ≥0∞, 0 < q ∧
+        ∀ᶠ n in atTop, q ≤ p (a (φ n)) (v (φ n)) c) :
+    ∃ q c v₀ : ℝ, 0 < q ∧ 0 < c ∧ 0 < v₀ ∧
+      ∀ a : A, ∀ v : ℝ, 0 < v → v < v₀ → ENNReal.ofReal q ≤ p a v c := by
+  classical
+  by_contra h
+  push Not at h
+  let ε : ℕ → ℝ := fun n => 1 / ((n : ℝ) + 1)
+  have hε (n : ℕ) : 0 < ε n := by dsimp [ε]; positivity
+  have hfail (n : ℕ) : ∃ a : A, ∃ v : ℝ,
+      0 < v ∧ v < ε n ∧ p a v (ε n) < ENNReal.ofReal (ε n) := by
+    obtain ⟨a, v, hv, hvs, hp⟩ := h (ε n) (ε n) (ε n) (hε n) (hε n) (hε n)
+    exact ⟨a, v, hv, hvs, hp⟩
+  choose a v hv hvs hbad using hfail
+  have hεlim : Tendsto ε atTop (𝓝 0) := tendsto_one_div_add_atTop_nhds_zero_nat
+  have hvlim : Tendsto v atTop (𝓝 0) :=
+    squeeze_zero (fun n => (hv n).le) (fun n => (hvs n).le) hεlim
+  obtain ⟨φ, hφ, c, hc, q, hq, hlower⟩ := hsequence a v hv hvlim
+  have hεsub : Tendsto (fun n => ε (φ n)) atTop (𝓝 0) := hεlim.comp hφ.tendsto_atTop
+  have hsmall : ∀ᶠ n in atTop, ε (φ n) ≤ c :=
+    (hεsub.eventually (gt_mem_nhds hc)).mono fun _ hn => hn.le
+  have hupper : ∀ᶠ n in atTop, q ≤ ENNReal.ofReal (ε (φ n)) := by
+    filter_upwards [hlower, hsmall] with n hn hs
+    exact (hn.trans (hmono (a (φ n)) (v (φ n)) hs)).trans (hbad (φ n)).le
+  have hlim : Tendsto (fun n => ENNReal.ofReal (ε (φ n))) atTop (𝓝 0) := by
+    simpa only [Function.comp_def, ENNReal.ofReal_zero] using
+      (ENNReal.continuous_ofReal.tendsto 0).comp hεsub
+  exact (not_le_of_gt hq) (ge_of_tendsto hlim hupper)
+
+namespace FirstFrontPassage
+
+/-- Before an attained first hit, a continuous coordinate that started
+below the front remains strictly below it. -/
+theorem lt_before_firstFrontTime
+    (x : ℝ≥0 → ℝ) (q : ℝ) (τ : ℝ≥0)
+    (hτ : firstFrontTime x q = (τ : WithTop ℝ≥0))
+    (hc : ContinuousOn x (Icc 0 τ)) (hstart : x 0 < q)
+    (t : ℝ≥0) (ht : t < τ) : x t < q := by
+  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)) ⟨hstart.le, le_of_not_gt hn⟩
+  have hh := hittingAfter_le_of_mem (u := fun s (_ : Unit) => x s - q)
+    (ω := ()) hu.1 (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 [hτ, WithTop.coe_le_coe] at hh
+  exact (not_le_of_gt ht) (hh.trans hu.2)
+
+end FirstFrontPassage
+
+namespace PassageSuccess
+open FirstFrontPassage
+
+/-- The open-envelope success event gives exactly the strict pre-front
+containment used by the manuscript. The front point itself is specified
+separately by its attained coordinate and terminal offset. -/
+theorem frontSuccess_source_prefix
+    {Ω : Type*} (η : ℕ → Ω → ℝ≥0 → ℂ) (p : ℕ → ℂ → ℝ)
+    (σ : Ω → ℝ≥0) (V : ℕ → Set ℂ) (a : ℕ → ℂ) (ε : ℝ) (n : ℕ)
+    (ω : Ω) (hω : ω ∈ FrontSuccess η p σ V a ε n)
+    (hc : ContinuousOn (fun t => p n (η n ω t))
+      (Icc 0 (frontTime (fun t => p n (η n ω t)) 1)))
+    (hstart : p n (η n ω 0) < 1) :
+    MapsTo (η n ω) (Ico 0 (frontTime (fun t => p n (η n ω t)) 1))
+      (V n ∩ {z | p n z < 1}) ∧
+    p n (η n ω (frontTime (fun t => p n (η n ω t)) 1)) = 1 ∧
+    ‖η n ω (frontTime (fun t => p n (η n ω t)) 1) - a n‖ < ε / 4 := by
+  obtain ⟨htime, hhit, _, hpath, hterminal⟩ := hω
+  refine ⟨?_, hhit, hterminal⟩
+  intro t ht
+  exact ⟨hpath ⟨ht.1, ht.2.le⟩,
+    lt_before_firstFrontTime _ 1 _ htime hc hstart t ht.2⟩
+
+/-- Probability of the concrete full-prefix front success and its physical
+sausage mass.  The index records an admissible physical configuration. -/
+def frontPassageProbability
+    {A Ω : Type*} [MeasurableSpace Ω] (P : Measure Ω)
+    (η : A → Ω → ℝ≥0 → ℂ) (p : A → ℂ → ℝ) (σ : A → Ω → ℝ≥0)
+    (V : A → Set ℂ) (a : A → ℂ) (ε : A → ℝ) (κ : ℝ) (R : A → Set ℂ)
+    (d : A) (v c : ℝ) : ℝ≥0∞ :=
+  P {ω | ω ∈ FrontSuccess (fun _ => η d) (fun _ => p d) (σ d)
+        (fun _ => V d) (fun _ => a d) (ε d) 0 ∧ ENNReal.ofReal c ≤
+      segmentSausageCharge κ (η d ω) (σ d ω)
+        (frontTime (fun t => p d (η d ω t)) 1) v (R d)}
+
+/-- Increasing the required mass only decreases the concrete passage
+probability; no probability or measurability assumption is needed here. -/
+theorem frontPassageProbability_antitone
+    {A Ω : Type*} [MeasurableSpace Ω] (P : Measure Ω)
+    (η : A → Ω → ℝ≥0 → ℂ) (p : A → ℂ → ℝ) (σ : A → Ω → ℝ≥0)
+    (V : A → Set ℂ) (a : A → ℂ) (ε : A → ℝ) (κ : ℝ) (R : A → Set ℂ)
+    (d : A) (v : ℝ) : Antitone (frontPassageProbability P η p σ V a ε κ R d v) := by
+  intro c₁ c₂ hc
+  apply measure_mono
+  intro ω hω
+  exact ⟨hω.1, (ENNReal.ofReal_le_ofReal hc).trans hω.2⟩
+
+/-- A later retained starting point gives a subset of the full passage
+success-and-mass event. This removes the auxiliary first-height stop from
+the final one-step conclusion. -/
+theorem frontPassageProbability_mono_start
+    {A Ω : Type*} [MeasurableSpace Ω] (P : Measure Ω)
+    (η : A → Ω → ℝ≥0 → ℂ) (p : A → ℂ → ℝ) (σ₁ σ₂ : A → Ω → ℝ≥0)
+    (V : A → Set ℂ) (a : A → ℂ) (ε : A → ℝ) (κ : ℝ) (R : A → Set ℂ)
+    (d : A) (v c : ℝ) (hσ : ∀ ω, σ₁ d ω ≤ σ₂ d ω) :
+    frontPassageProbability P η p σ₂ V a ε κ R d v c ≤
+      frontPassageProbability P η p σ₁ V a ε κ R d v c := by
+  apply measure_mono
+  rintro ω ⟨hfront, hmass⟩
+  obtain ⟨hfinite, hhit, hbefore, hpath, hterminal⟩ := hfront
+  refine ⟨⟨hfinite, hhit, (hσ ω).trans_lt hbefore, hpath, hterminal⟩, ?_⟩
+  exact hmass.trans (segmentSausageCharge_mono κ (η d ω) (hσ ω) le_rfl v Subset.rfl)
+
+theorem frontPassageProbability_le_from_zero
+    {A Ω : Type*} [MeasurableSpace Ω] (P : Measure Ω)
+    (η : A → Ω → ℝ≥0 → ℂ) (p : A → ℂ → ℝ) (σ : A → Ω → ℝ≥0)
+    (V : A → Set ℂ) (a : A → ℂ) (ε : A → ℝ) (κ : ℝ) (R : A → Set ℂ)
+    (d : A) (v c : ℝ) :
+    frontPassageProbability P η p σ V a ε κ R d v c ≤
+      frontPassageProbability P η p (fun _ _ => 0) V a ε κ R d v c :=
+  frontPassageProbability_mono_start P η p (fun _ _ => 0) σ V a ε κ R d v c (fun _ => bot_le)
+
+/-- Once actual conformal compactness and the sequence passage theorem
+supply the subsequential estimate, the full uniform passage constants
+follow for the original concrete success-and-mass event. -/
+theorem uniform_frontPassage_probability_of_subsequences
+    {A Ω : Type*} [MeasurableSpace Ω] (P : Measure Ω)
+    (η : A → Ω → ℝ≥0 → ℂ) (p : A → ℂ → ℝ) (σ : A → Ω → ℝ≥0)
+    (V : A → Set ℂ) (a : A → ℂ) (ε : A → ℝ) (κ : ℝ) (R : A → Set ℂ)
+    (hsequence : ∀ (d : ℕ → A) (v : ℕ → ℝ), (∀ n, 0 < v n) →
+      Tendsto v atTop (𝓝 0) →
+      ∃ φ : ℕ → ℕ, StrictMono φ ∧ ∃ c q : ℝ, 0 < c ∧ 0 < q ∧
+        ∀ᶠ n in atTop, ENNReal.ofReal q ≤
+          frontPassageProbability P η p σ V a ε κ R (d (φ n)) (v (φ n)) c) :
+    ∃ q c v₀ : ℝ, 0 < q ∧ 0 < c ∧ 0 < v₀ ∧
+      ∀ d : A, ∀ v : ℝ, 0 < v → v < v₀ → ENNReal.ofReal q ≤
+        frontPassageProbability P η p σ V a ε κ R d v c := by
+  apply uniform_passage_threshold_of_subsequences
+    (frontPassageProbability P η p σ V a ε κ R)
+    (frontPassageProbability_antitone P η p σ V a ε κ R)
+  intro d v hv hlim
+  obtain ⟨φ, hφ, c, q, hc, hq, hlower⟩ := hsequence d v hv hlim
+  exact ⟨φ, hφ, c, hc, ENNReal.ofReal q, ENNReal.ofReal_pos.mpr hq, hlower⟩
+
+end PassageSuccess
+end SLEExactGauge
+
+end
+
+end OAI
diff --git a/lean/OAI/Probability/SLE/Gauge/UniformPassageThreshold.lean b/lean/OAI/Probability/SLE/Gauge/UniformPassageThreshold.lean
new file mode 100644
index 0000000000000000000000000000000000000000..03749af7bd3fa0d897d90ccdc9adfa0ee9990230
--- /dev/null
+++ b/lean/OAI/Probability/SLE/Gauge/UniformPassageThreshold.lean
@@ -0,0 +1,52 @@
+import Mathlib
+
+namespace OAI
+
+/-! The diagonal quantifier step in the uniform ribbon passage proof.
+Uniform probability, mass threshold and mesh cutoff follow once every
+vanishing-mesh sequence admits one positive eventual lower bound. -/
+
+noncomputable section
+open Set Filter
+open scoped Topology ENNReal
+
+namespace SLEExactGauge
+
+theorem uniform_passage_threshold_of_sequences
+    {A : Type*} (p : A → ℝ → ℝ → ℝ≥0∞)
+    (hmono : ∀ a v, Antitone (p a v))
+    (hsequence : ∀ (a : ℕ → A) (v : ℕ → ℝ), (∀ n, 0 < v n) →
+      Tendsto v atTop (𝓝 0) →
+      ∃ c : ℝ, 0 < c ∧ ∃ q : ℝ≥0∞, 0 < q ∧
+        ∀ᶠ n in atTop, q ≤ p (a n) (v n) c) :
+    ∃ q c v₀ : ℝ, 0 < q ∧ 0 < c ∧ 0 < v₀ ∧
+      ∀ a : A, ∀ v : ℝ, 0 < v → v < v₀ → ENNReal.ofReal q ≤ p a v c := by
+  classical
+  by_contra h
+  push Not at h
+  let ε : ℕ → ℝ := fun n => 1 / ((n : ℝ) + 1)
+  have hε (n : ℕ) : 0 < ε n := by dsimp [ε]; positivity
+  have hfail (n : ℕ) : ∃ a : A, ∃ v : ℝ,
+      0 < v ∧ v < ε n ∧ p a v (ε n) < ENNReal.ofReal (ε n) := by
+    obtain ⟨a, v, hv, hvs, hp⟩ := h (ε n) (ε n) (ε n) (hε n) (hε n) (hε n)
+    exact ⟨a, v, hv, hvs, hp⟩
+  choose a v hv hvs hbad using hfail
+  have hεlim : Tendsto ε atTop (𝓝 0) := tendsto_one_div_add_atTop_nhds_zero_nat
+  have hvlim : Tendsto v atTop (𝓝 0) :=
+    squeeze_zero (fun n => (hv n).le) (fun n => (hvs n).le) hεlim
+  obtain ⟨c, hc, q, hq, hlower⟩ := hsequence a v hv hvlim
+  have hsmall : ∀ᶠ n in atTop, ε n ≤ c :=
+    (hεlim.eventually (gt_mem_nhds hc)).mono fun _ h => h.le
+  have hupper : ∀ᶠ n in atTop, q ≤ ENNReal.ofReal (ε n) := by
+    filter_upwards [hlower, hsmall] with n hn hs
+    exact (hn.trans (hmono (a n) (v n) hs)).trans (hbad n).le
+  have hlim : Tendsto (fun n => ENNReal.ofReal (ε n)) atTop (𝓝 0) := by
+    simpa only [Function.comp_def, ENNReal.ofReal_zero] using
+      (ENNReal.continuous_ofReal.tendsto 0).comp hεlim
+  exact (not_le_of_gt hq) (ge_of_tendsto hlim hupper)
+
+end SLEExactGauge
+
+end
+
+end OAI
diff --git a/lean/OAI/Probability/SLE/Gauge/UniformRecenteredPassage.lean b/lean/OAI/Probability/SLE/Gauge/UniformRecenteredPassage.lean
new file mode 100644
index 0000000000000000000000000000000000000000..9600087c54f3ac3da9b62c181eda27b1200ea8f7
--- /dev/null
+++ b/lean/OAI/Probability/SLE/Gauge/UniformRecenteredPassage.lean
@@ -0,0 +1,157 @@
+import OAI.Probability.SLE.Gauge.RecenteredRibbonPassage
+import OAI.Probability.SLE.Geometry.BoundaryScaleLaw
+
+namespace OAI
+
+/-! Uniform passage constants for actual recentered ribbon configurations.
+The finite chart realization and normalization law are constructed, and
+subsequence compactness supplies the diagonal estimate. -/
+
+noncomputable section
+open Set Filter MeasureTheory ProbabilityTheory Metric
+open scoped Topology NNReal ENNReal
+
+namespace SLEExactGauge
+open RibbonCoordinates BoundaryScaleLaw
+
+local instance uniformRecenteredPathMeasurable : MeasurableSpace C(ℝ≥0, ℂ) := borel _
+local instance uniformRecenteredPathBorel : BorelSpace C(ℝ≥0, ℂ) := ⟨rfl⟩
+
+theorem uniform_recentered_passage_from_geometry
+    {A Ω : 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 : A → ℝ≥0 → ℝ) (γₙ : A → ℝ≥0 → ℂ)
+    (G F₀ : A → ℝ≥0 → ℂ → ℂ)
+    (hU : ∀ n, Continuous (U n))
+    (hw : ∀ n, IsCapacityTwoWitness (U n) (γₙ n) (G n) (F₀ n))
+    (T : A → ℝ≥0) (hT : ∀ n, 0 < T n)
+    (hfresh : ∀ n s, s < T n → γₙ n (T n) ∈ survivingDomain (γₙ n) s)
+    (αₙ : A → ℝ → ℂ) (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ₙ : A → ℂ → ℂ) (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ₙ : A → ℝ) (ε : ℝ) (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) : ℂ)‖)
+    (hregion : K ∩ passageCoordinateRegion C ε (ε / Lq) ⊆ interior K) :
+    ∃ Fb : A → C(closedHalfPlane, ℂ),
+      (∀ d (z : closedHalfPlane), z.1 ∈ upperHalfPlane → Fb d z =
+        F₀ d (T d) ((U d (T d) : ℂ) + z) - γₙ d (T d)) ∧
+      ∃ q c v₀ : ℝ, 0 < q ∧ 0 < c ∧ 0 < v₀ ∧
+        ∀ d : A, ∀ v : ℝ, 0 < v → v < v₀ →
+          ENNReal.ofReal q ≤ P {ω |
+            finiteBoundaryPath (Fb d) (sourceTracePath γ (fun ω => (hwbase ω).1) ω) ∈
+              BoundaryScaleLaw.frontMassEvent (longitudinalCoordinate (Qₙ d) K 0)
+                (physicalPassageRegion (Qₙ d) K C ε (ε / Lq)) (Qₙ d 1)
+                (ε / Lq) κ v c (physicalMiddleRegion (Qₙ d) K 0 ε)} := by
+  choose Fb₀ hFb₀ _ using fun d => normalized_finite_capacity_inverse_boundary_extension
+    hboundary (hU d) (hw d) (T d) 1 zero_lt_one
+  let Fb : A → C(closedHalfPlane, ℂ) := fun d => Fb₀ d - ContinuousMap.const _ (γₙ d (T d))
+  have hext d (z : closedHalfPlane) (hz : z.1 ∈ upperHalfPlane) : Fb d z =
+      F₀ d (T d) ((U d (T d) : ℂ) + z) - γₙ d (T d) := by
+    change Fb₀ d z - γₙ d (T d) = _
+    rw [hFb₀ d z hz]
+    simp only [Complex.ofReal_one, one_mul]
+  let gp := sourceTracePath γ (fun ω => (hwbase ω).1)
+  let prob := fun d v c => P {ω | finiteBoundaryPath (Fb d) (gp ω) ∈
+    frontMassEvent (longitudinalCoordinate (Qₙ d) K 0)
+      (physicalPassageRegion (Qₙ d) K C ε (ε / Lq)) (Qₙ d 1)
+      (ε / Lq) κ v c (physicalMiddleRegion (Qₙ d) K 0 ε)}
+  have hmono : ∀ d v, Antitone (prob d v) := by
+    intro d v c₁ c₂ hc'
+    apply measure_mono
+    intro ω hω
+    exact ⟨hω.1, (ENNReal.ofReal_le_ofReal hc').trans hω.2⟩
+  have hgp : Measurable gp := by
+    apply source_path_measurable
+    intro t
+    exact (brownian_capacity_trace_adapted B₀ hm hc κ γ Gbase Fbase hwbase t).mono
+      ((Filtration.natural B₀ (fun t => (hm t).stronglyMeasurable)).le t) le_rfl
+  have hclosed : ∀ᵐ ω ∂P, ClosedPathProperty (gp ω) :=
+    Eventually.of_forall (fun ω t => (hwbase ω).2.2.1 t)
+  have hVopen d : IsOpen (physicalPassageRegion (Qₙ d) K C ε (ε / Lq)) := by
+    have hi := lower_lipschitz_injOn (Qₙ d) K Lq (hQlower d)
+    have he : K ∩ passageCoordinateRegion C ε (ε / Lq) =
+        interior K ∩ passageCoordinateRegion C ε (ε / Lq) :=
+      Subset.antisymm (fun _ hz => ⟨hregion hz, hz.2⟩)
+        (fun _ hz => ⟨interior_subset hz.1, hz.2⟩)
+    unfold physicalPassageRegion
+    rw [he]
+    exact isOpen_image_coordinate_subset hplanar (Qₙ d) K _ (hQupper d).continuousOn hi
+      (isOpen_interior.inter (passageCoordinateRegion_isOpen _ _ _))
+      (inter_subset_left.trans interior_subset)
+  have hVK d : physicalPassageRegion (Qₙ d) K C ε (ε / Lq) ⊆ Qₙ d '' K :=
+    image_mono inter_subset_left
+  have hpc d : ContinuousOn (longitudinalCoordinate (Qₙ d) K 0) (Qₙ d '' K) :=
+    longitudinalCoordinate_continuousOn (Qₙ d) K Lq 0 (hQlower d)
+  have hpK d : IsClosed (Qₙ d '' K) := (hK.image_of_continuousOn (hQupper d).continuousOn).isClosed
+  obtain ⟨q, c₁, v₀, hq, hc₁, hv₀, hprob⟩ :=
+      uniform_passage_threshold_of_subsequences prob hmono (by
+        intro d v hv hlim
+        obtain ⟨φ, b, Fbn, hφ, hb, hFbn, c, q, hcpos', hqpos, hseq⟩ :=
+          recentered_ribbon_subsequence_passage P κ hκ hκ8 B₀ hB₀ hm hc γ Gbase Fbase hwbase
+            hcompact hboundary hsupport hplanar
+            (fun n => U (d n)) (fun n => γₙ (d n)) (fun n => G (d n)) (fun n => F₀ (d n))
+            (fun n => hU (d n)) (fun n => hw (d n)) (fun n => T (d n)) (fun n => hT (d n))
+            (fun n => hfresh (d n)) (fun n => αₙ (d n)) Cg s c hCg hs hcpos
+            (fun n => hαL (d n)) (fun n => hα0 (d n)) (fun n => hchord (d n))
+            (fun n => hαD (d n))
+            (fun δ hδ hδ2 => by
+              obtain ⟨r, hr, hh⟩ := hclear δ hδ hδ2
+              exact ⟨r, hr, fun n => hh (d n)⟩)
+            (fun n => Qₙ (d n)) K hK x₀ hx₀ C Lq Rq hC hLq
+            (fun n => hQupper (d n)) (fun n => hQlower (d n)) (fun n => hQtip (d n))
+            (fun n => xₙ (d n)) ε hε (fun n => hxₙ (d n)) hcore
+            (fun n => hshape (d n)) (fun n => hangle (d n)) v hv hlim
+        refine ⟨φ, hφ, c, hcpos', ENNReal.ofReal q, ENNReal.ofReal_pos.mpr hqpos, ?_⟩
+        filter_upwards [hseq] with n hn
+        let ell : ℝ≥0 := ⟨b n, (hb n).le⟩
+        have hell : 0 < ell := by exact_mod_cast hb n
+        have hFbeq : Fbn n = (Fb (d (φ n))).comp (scaleClosed ell) := by
+          apply normalized_boundary_eq
+            (fun z => F₀ (d (φ n)) (T (d (φ n))) z - γₙ (d (φ n)) (T (d (φ n))))
+            (U (d (φ n)) (T (d (φ n)))) ell hell _ _ (hext (d (φ n)))
+          intro z hz
+          exact hFbn n z hz
+        have hscale := ScaleTraceLaw.scaled_trace_path_law κ hκ hκ8 B₀ hB₀ hm hc
+          γ Gbase Fbase hwbase ell hell
+        have he := frontMassEvent_boundary_scale_probability P gp hgp hclosed ell hell
+          (Fb (d (φ n))) hscale (longitudinalCoordinate (Qₙ (d (φ n))) K 0)
+          (physicalPassageRegion (Qₙ (d (φ n))) K C ε (ε / Lq)) (Qₙ (d (φ n)) 1)
+          (ε / Lq) κ (v (φ n)) c (physicalMiddleRegion (Qₙ (d (φ n))) K 0 ε)
+          (Qₙ (d (φ n)) '' K) (hpK _) (hpc _) (hVopen _) (hVK _)
+        rw [← hFbeq] at he
+        dsimp only [prob]
+        rw [← he]
+        exact hn)
+  exact ⟨Fb, hext, q, c₁, v₀, hq, hc₁, hv₀, hprob⟩
+
+end SLEExactGauge
+
+end
+
+end OAI
diff --git a/lean/OAI/Probability/SLE/Gauge/UniformRibbonStep.lean b/lean/OAI/Probability/SLE/Gauge/UniformRibbonStep.lean
new file mode 100644
index 0000000000000000000000000000000000000000..af83e8c96e2c3a68f7829bb9cc81299d0f52771e
--- /dev/null
+++ b/lean/OAI/Probability/SLE/Gauge/UniformRibbonStep.lean
@@ -0,0 +1,152 @@
+import OAI.Probability.SLE.Gauge.RibbonStepTranslation
+
+namespace OAI
+
+/-! Uniform one-step probability in the original physical ribbon, for any
+actual continuous boundary realization of the stopped inverse map. -/
+
+noncomputable section
+open Set Filter MeasureTheory ProbabilityTheory
+open scoped Topology NNReal ENNReal
+
+namespace SLEExactGauge
+open RibbonCoordinates BoundaryScaleLaw RibbonPassageScaling Target
+
+local instance uniformStepPathMeasurable : MeasurableSpace C(ℝ≥0, ℂ) := borel _
+local instance uniformStepPathBorel : BorelSpace C(ℝ≥0, ℂ) := ⟨rfl⟩
+
+def translateFiniteBoundary (a : ℂ) (f : C(closedHalfPlane, ℂ)) :
+    C(closedHalfPlane, ℂ) := ⟨fun z => a + f z, continuous_const.add f.continuous⟩
+
+lemma finiteBoundaryPath_translate (a : ℂ) (f : C(closedHalfPlane, ℂ))
+    (p : C(ℝ≥0, ℂ)) (t : ℝ≥0) :
+    finiteBoundaryPath (translateFiniteBoundary a f) p t =
+      affine a 1 (finiteBoundaryPath f p t) := by
+  simp only [finiteBoundaryPath, translateFiniteBoundary, ContinuousMap.comp_apply,
+    ContinuousMap.coe_mk, affine, Complex.ofReal_one, one_mul]
+
+def RibbonHistory.stepEvent {C L : ℝ≥0} {ε : ℝ}
+    (d : RibbonHistory C L ε) (κ v c : ℝ) : Set C(ℝ≥0, ℂ) :=
+  frontMassEvent (longitudinalCoordinate d.chart closedRibbon d.front)
+    (physicalPassageRegion d.stepChart ribbonStepCompact C ε (ε / L))
+    (d.chart ((d.front : ℂ) + 1)) (ε / L) κ v c
+    (physicalMiddleRegion d.chart closedRibbon d.front ε)
+
+lemma RibbonHistory.finiteBoundary_step_probability
+    {Ω : Type*} [MeasurableSpace Ω] (P : Measure Ω)
+    {C L : ℝ≥0} {ε : ℝ} (d : RibbonHistory C L ε) (hε : ε ≤ 1 / 8)
+    (f : C(closedHalfPlane, ℂ)) (p : Ω → C(ℝ≥0, ℂ))
+    (κ v c : ℝ) (hv : 0 < v) :
+    P {ω | finiteBoundaryPath (translateFiniteBoundary (d.trace d.time) f) (p ω) ∈
+        d.stepEvent κ v c} =
+      P {ω | finiteBoundaryPath f (p ω) ∈
+        frontMassEvent (longitudinalCoordinate d.recenteredChart ribbonStepCompact 0)
+          (physicalPassageRegion d.recenteredChart ribbonStepCompact C ε (ε / L))
+          (d.recenteredChart 1) (ε / L) κ v c
+          (physicalMiddleRegion d.recenteredChart ribbonStepCompact 0 ε)} := by
+  have hη (ω : Ω) : (finiteBoundaryPath
+      (translateFiniteBoundary (d.trace d.time) f) (p ω) : ℝ≥0 → ℂ) =
+      fun t => affine (d.trace d.time) 1 (finiteBoundaryPath f (p ω) t) := by
+    funext t
+    exact finiteBoundaryPath_translate _ _ _ _
+  have hh := d.frontMass_probability_translate P hε
+    (fun ω => (finiteBoundaryPath f (p ω) : ℝ≥0 → ℂ)) κ v c hv
+  simpa only [RibbonHistory.stepEvent, frontMassEvent, hη, finiteBoundaryPath_translate,
+    PassageSuccess.FrontSuccess, mem_ofPred_eq] using hh
+
+lemma RibbonHistory.step_lower {C L : ℝ≥0} {ε : ℝ} (d : RibbonHistory C L ε) :
+    ∀ u ∈ ribbonStepCompact, ∀ v ∈ ribbonStepCompact,
+      dist u v ≤ L * dist (d.stepChart u) (d.stepChart v) := by
+  intro u hu v hv
+  simpa only [RibbonHistory.stepChart, dist_add_left] using
+    d.patch_lower _ (translate_ribbonStepCompact hu) _ (translate_ribbonStepCompact hv)
+
+lemma RibbonHistory.stepChart_continuousOn {C L : ℝ≥0} {ε : ℝ}
+    (d : RibbonHistory C L ε) : ContinuousOn d.stepChart ribbonStepCompact :=
+  d.chart_continuous.comp (continuous_const.add continuous_id).continuousOn d.stepCompact_maps
+
+lemma RibbonHistory.global_progress_eq_step {C L : ℝ≥0} {ε : ℝ}
+    (d : RibbonHistory C L ε) :
+    EqOn (longitudinalCoordinate d.chart closedRibbon d.front)
+      (longitudinalCoordinate d.stepChart ribbonStepCompact 0)
+      (d.stepChart '' ribbonStepCompact) := by
+  have hi := lower_lipschitz_injOn d.stepChart ribbonStepCompact L d.step_lower
+  rintro z ⟨w, hw, rfl⟩
+  simp only [longitudinalCoordinate, RibbonHistory.stepChart,
+    coordinateInverse_left d.chart_injective (d.stepCompact_maps hw), Complex.add_re,
+    Complex.ofReal_re, add_sub_cancel_left, sub_zero]
+  exact congrArg Complex.re (coordinateInverse_left hi hw).symm
+
+lemma RibbonHistory.stepEvent_measurable {C L : ℝ≥0} {ε : ℝ}
+    (d : RibbonHistory C L ε) (hplanar : PublishedPlanarDiskOpenness)
+    (hε : ε ≤ 1 / 8) (κ v c : ℝ) : MeasurableSet (d.stepEvent κ v c) := by
+  have hK := ribbonStepCompact_isCompact.image_of_continuousOn d.stepChart_continuousOn
+  have hp : ContinuousOn (longitudinalCoordinate d.chart closedRibbon d.front)
+      (d.stepChart '' ribbonStepCompact) :=
+    (longitudinalCoordinate_continuousOn d.stepChart ribbonStepCompact L 0 d.step_lower).congr
+      (fun z hz => d.global_progress_eq_step hz)
+  have hV : IsOpen (physicalPassageRegion d.stepChart ribbonStepCompact C ε (ε / L)) := by
+    have he : ribbonStepCompact ∩ passageCoordinateRegion C ε (ε / L) =
+        interior ribbonStepCompact ∩ passageCoordinateRegion C ε (ε / L) := by
+      apply Subset.antisymm
+      · exact fun z hz => ⟨ribbonStepCompact_passage hε C (ε / L) hz, hz.2⟩
+      · exact inter_subset_inter_left _ interior_subset
+    unfold physicalPassageRegion
+    rw [he]
+    exact isOpen_image_coordinate_subset hplanar d.stepChart ribbonStepCompact _
+      d.stepChart_continuousOn (lower_lipschitz_injOn _ _ L d.step_lower)
+      (isOpen_interior.inter (passageCoordinateRegion_isOpen C ε (ε / L)))
+      (inter_subset_left.trans interior_subset)
+  exact measurableSet_frontMassEvent _ _ _ _ κ v c _ _ hK.isClosed hp hV
+    (image_mono inter_subset_left)
+
+/-- This is the uniform one-step estimate for an actual stopped history.
+The boundary chart can be the already past-measurable chart used in its
+restart law; no measurable selection of compactness outputs is required. -/
+theorem uniform_actual_ribbon_step
+    {Ω : Type} [MeasurableSpace Ω] (P : Measure Ω) [IsProbabilityMeasure P]
+    (κ : ℝ) (hκ : 0 < κ) (hκ8 : κ < 8)
+    (B : ℝ≥0 → Ω → ℝ) (hB : IsBrownianReal B P)
+    (hm : ∀ t, Measurable (B t)) (hcont : ∀ ω, 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 P γ)
+    (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 ∧ 0 < c ∧ 0 < v₀ ∧
+      ∀ (d : RibbonHistory C L ε) (Fb : C(closedHalfPlane, ℂ)),
+        (∀ z : closedHalfPlane, z.1 ∈ upperHalfPlane →
+          Fb z = d.inverse d.time ((d.U d.time : ℂ) + z)) →
+        ∀ v : ℝ, 0 < v → v < v₀ →
+          ENNReal.ofReal q ≤ P {ω |
+            finiteBoundaryPath Fb (sourceTracePath γ (fun ω => (hw ω).1) ω) ∈
+              d.stepEvent κ v c} := by
+  obtain ⟨Fc, hFc, q, c, v₀, hq, hc, hv₀, hprob⟩ :=
+    uniform_actual_ribbon_passage P κ hκ hκ8 B hB hm hcont γ G F hw
+      hcompact hboundary hsupport hplanar hstraight hexit hwiener W hW C L hC hL
+      ε hε hεsmall
+  refine ⟨q, c, v₀, hq, hc, hv₀, ?_⟩
+  intro d Fb hFb v hv hvcut
+  have he : Fb = translateFiniteBoundary (d.trace d.time) (Fc d) := by
+    apply finite_boundary_ext
+    intro z hz
+    change Fb z = d.trace d.time + Fc d z
+    rw [hFb z hz, hFc d z hz]
+    abel
+  rw [he, d.finiteBoundary_step_probability P hεsmall (Fc d)
+    (sourceTracePath γ (fun ω => (hw ω).1)) κ v c hv]
+  exact hprob d v hv hvcut
+
+end SLEExactGauge
+
+end
+
+end OAI
diff --git a/lean/OAI/Probability/SLE/Gauge/VaryingPassageEvents.lean b/lean/OAI/Probability/SLE/Gauge/VaryingPassageEvents.lean
new file mode 100644
index 0000000000000000000000000000000000000000..181a9e40ab2fe1542d08efacaa3125a900d1c674
--- /dev/null
+++ b/lean/OAI/Probability/SLE/Gauge/VaryingPassageEvents.lean
@@ -0,0 +1,103 @@
+import Mathlib
+
+namespace OAI
+
+/-!
+The `rc:varying-good-events` step of the ribbon argument. Positivity of a
+conditional passage probability on one event gives a fixed lower probability
+after intersecting with varying early-containment events. No uniform
+conditional passage bound is assumed.
+-/
+
+noncomputable section
+open Set Filter MeasureTheory
+open scoped Topology ENNReal
+
+namespace SLEExactGauge
+
+theorem varying_passage_events_lower_bound
+    {Ω : Type*} [mΩ : MeasurableSpace Ω] (P : Measure Ω) [IsFiniteMeasure P]
+    (m : MeasurableSpace Ω) (hm : m ≤ mΩ)
+    (E C : Set Ω) (G : ℕ → Set Ω)
+    (hE : MeasurableSet[m] E) (hC : MeasurableSet[mΩ] C)
+    (hG : ∀ n, MeasurableSet[m] (G n)) (hEpos : 0 < P E)
+    (hpassage : ∀ᵐ ω ∂P, ω ∈ E → 0 < P⁻[C.indicator (fun _ => 1) | m] ω)
+    (hmissing : ∀ n, P (E \ G n) ≤ P E / 2) :
+    ∃ q₂ : ℝ≥0∞, 0 < q₂ ∧ ∀ n, q₂ ≤ P (E ∩ G n ∩ C) := by
+  let : MeasurableSpace Ω := mΩ
+  let q : Ω → ℝ≥0∞ := P⁻[C.indicator (fun _ => 1) | m]
+  have hqm : Measurable[m] q := measurable_condLExp m P _
+  have hqmΩ : Measurable q := hqm.mono hm le_rfl
+  let b : ℕ → ℝ≥0∞ := fun n => (1 / 2 : ℝ≥0∞) ^ n
+  let S : ℕ → Set Ω := fun n => E ∩ {ω | q ω < b n}
+  have hSm (n : ℕ) : MeasurableSet (S n) :=
+    (hm E hE).inter (measurableSet_lt hqmΩ measurable_const)
+  have hSanti : Antitone S := by
+    intro n k hnk ω hω
+    exact ⟨hω.1, hω.2.trans_le
+      (pow_le_pow_right_of_le_one' (by norm_num : (1 / 2 : ℝ≥0∞) ≤ 1) hnk)⟩
+  have hblim : Tendsto b atTop (𝓝 0) :=
+    ENNReal.tendsto_pow_atTop_nhds_zero_of_lt_one (by norm_num)
+  have hinter : P (⋂ n, S n) = 0 := by
+    apply measure_eq_zero_iff_ae_notMem.mpr
+    filter_upwards [hpassage] with ω hω
+    intro hmem
+    have hEω : ω ∈ E := (mem_iInter.mp hmem 0).1
+    have hle : q ω ≤ 0 := ge_of_tendsto hblim
+      (Eventually.of_forall fun n => ((mem_iInter.mp hmem n).2).le)
+    exact (not_le_of_gt (hω hEω)) hle
+  have hsmalllim : Tendsto (fun n => P (S n)) atTop (𝓝 0) := by
+    simpa only [Function.comp_def, hinter] using
+      tendsto_measure_iInter_atTop (fun n => (hSm n).nullMeasurableSet)
+        hSanti ⟨0, measure_ne_top P _⟩
+  have hquarter : 0 < P E / 4 := ENNReal.div_pos hEpos.ne' (by norm_num)
+  obtain ⟨N, hN⟩ :=
+    (hsmalllim.eventually (gt_mem_nhds hquarter)).exists
+  let q₁ : ℝ≥0∞ := b N
+  have hq₁ : 0 < q₁ := by
+    exact ENNReal.pow_pos (ENNReal.div_pos one_ne_zero (by norm_num)) N
+  refine ⟨q₁ * (P E / 4), ENNReal.mul_pos hq₁.ne' hquarter.ne', ?_⟩
+  intro n
+  let A : Set Ω := E ∩ G n
+  let B : Set Ω := A ∩ {ω | q₁ ≤ q ω}
+  have hAm : MeasurableSet[m] A := hE.inter (hG n)
+  have hBm : MeasurableSet[m] B :=
+    hAm.inter (measurableSet_le measurable_const hqm)
+  have hcover : E ⊆ B ∪ (E \ G n) ∪ S N := by
+    intro ω hω
+    by_cases hωG : ω ∈ G n
+    · by_cases hωq : q₁ ≤ q ω
+      · exact Or.inl (Or.inl ⟨⟨hω, hωG⟩, hωq⟩)
+      · exact Or.inr ⟨hω, lt_of_not_ge hωq⟩
+    · exact Or.inl (Or.inr ⟨hω, hωG⟩)
+  have hcovermeasure : P E ≤ P B + P (E \ G n) + P (S N) :=
+    (measure_mono hcover).trans
+      ((measure_union_le _ _).trans (add_le_add (measure_union_le _ _) le_rfl))
+  have hBmass : P E / 4 ≤ P B := by
+    have hcR := ENNReal.toReal_mono (by finiteness) hcovermeasure
+    rw [ENNReal.toReal_add (by finiteness) (by finiteness),
+      ENNReal.toReal_add (by finiteness) (by finiteness)] at hcR
+    have hmR := ENNReal.toReal_mono (by finiteness) (hmissing n)
+    have hsR := ENNReal.toReal_mono (by finiteness) hN.le
+    norm_num only [ENNReal.toReal_div, ENNReal.toReal_ofNat] at hmR hsR
+    apply (ENNReal.toReal_le_toReal (by finiteness) (by finiteness)).mp
+    norm_num only [ENNReal.toReal_div, ENNReal.toReal_ofNat]
+    linarith
+  calc
+    q₁ * (P E / 4) ≤ q₁ * P B := mul_le_mul' le_rfl hBmass
+    _ = ∫⁻ _ in B, q₁ ∂P := (setLIntegral_const _ _).symm
+    _ ≤ ∫⁻ ω in B, q ω ∂P :=
+      setLIntegral_mono' (hm B hBm) (fun _ hω => hω.2)
+    _ ≤ ∫⁻ ω in A, q ω ∂P := lintegral_mono_set inter_subset_left
+    _ = ∫⁻ ω in A, C.indicator (fun _ => 1) ω ∂P :=
+      setLIntegral_condLExp hm P _ hAm
+    _ = P (E ∩ G n ∩ C) := by
+      rw [setLIntegral_indicator hC, setLIntegral_const, one_mul]
+      congr 1
+      exact inter_comm C A
+
+end SLEExactGauge
+
+end
+
+end OAI
diff --git a/lean/OAI/Probability/SLE/Gauge/WaypointBrownianPassages.lean b/lean/OAI/Probability/SLE/Gauge/WaypointBrownianPassages.lean
new file mode 100644
index 0000000000000000000000000000000000000000..3c0233bc2176f894c40f14e5ec3989ed82aac509
--- /dev/null
+++ b/lean/OAI/Probability/SLE/Gauge/WaypointBrownianPassages.lean
@@ -0,0 +1,158 @@
+import OAI.Probability.SLE.Geometry.WaypointRouteProbability
+
+namespace OAI
+
+/-! Uniform Brownian waypoint tube events stay initially in the surviving
+domain, then avoid the complete access guide and hit the stopped past. -/
+
+noncomputable section
+open Set Metric MeasureTheory
+open scoped Topology NNReal ENNReal
+
+namespace SLEExactGauge.RibbonCoordinates
+open Target
+
+theorem early_waypoint_coordinate_ball_safe
+    (k side : ℝ) (hside : |side| = 1) {ε t : ℝ}
+    (hk : 1 ≤ k) (hεsmall : ε ≤ 1 / 8) (ht : t ∈ Icc (0 : ℝ) 2) :
+    ball (waypointRoute k side t) (1 / 32) ⊆
+      futureRibbon k ∪ sideCorridor ε 1 ∪ sideCorridor (-1) (-ε) := by
+  intro z hz
+  have hn : ‖z - waypointRoute k side t‖ < 1 / 32 := by
+    simpa only [mem_ball, dist_eq_norm] using hz
+  have hre := (Complex.abs_re_le_norm (z - waypointRoute k side t)).trans_lt hn
+  have him := (Complex.abs_im_le_norm (z - waypointRoute k side t)).trans_lt hn
+  rw [Complex.sub_re, waypointRoute_re] at hre
+  rw [Complex.sub_im] at him
+  have hr := abs_lt.mp hre
+  have hi := abs_lt.mp him
+  have hrouteim := abs_le.mp (waypointRoute_im_bound k side hside t)
+  have hzim : |z.im| < 1 := abs_lt.mpr ⟨by linarith, by linarith⟩
+  by_cases ht1 : t ≤ 1
+  · left; left
+    rw [unitClip_of_nonpos (by linarith : t - 1 ≤ 0)] at hr
+    exact ⟨by linarith, hzim⟩
+  · have hclip0 := unitClip_nonneg (t - 1)
+    have hclip1 := unitClip_le_one (t - 1)
+    have hzr : 0 < z.re := by linarith
+    have hrouteabs : |(waypointRoute k side t).im| = 1 / 2 := by
+      rw [waypointRoute_im, unitClip_of_one_le (by linarith : 1 ≤ t),
+        unitClip_of_nonpos (by linarith [ht.2] : t - 2 ≤ 0), abs_mul, hside]
+      norm_num
+    have hh : |(waypointRoute k side t).im| ≤
+        |(waypointRoute k side t).im - z.im| + |z.im| := by
+      simpa only [sub_add_cancel] using abs_add_le
+        ((waypointRoute k side t).im - z.im) z.im
+    rw [abs_sub_comm] at hh
+    have hgap : ε < |z.im| := by linarith
+    by_cases hz0 : 0 ≤ z.im
+    · left; right
+      exact ⟨hzr, by simpa only [abs_of_nonneg hz0] using hgap, (abs_lt.mp hzim).2⟩
+    · right
+      rw [abs_of_neg (lt_of_not_ge hz0)] at hgap
+      exact ⟨hzr, (abs_lt.mp hzim).1, by linarith⟩
+
+theorem physical_early_waypoint_tube_survives
+    (hpublished : PublishedPlanarDiskOpenness)
+    (P : ℂ → ℂ) (hP : ContinuousOn P closedRibbon) (hi : InjOn P closedRibbon)
+    (hH : ∀ z ∈ closedRibbon, 0 < z.re → P z ∈ upperHalfPlane)
+    (K : ℝ≥0) (hK : 0 < (K : ℝ)) (γ : ℝ≥0 → ℂ) (T : ℝ≥0)
+    {k ε side : ℝ} (hk : 1 ≤ k) (hε : 0 < ε) (hεsmall : ε ≤ 1 / 8)
+    (hside : |side| = 1)
+    (hpast : γ '' Icc 0 T ⊆ P '' {z ∈ closedRibbon | z.re ≤ k ∧ |z.im| ≤ ε})
+    (hunbounded : ¬ Bornology.IsBounded (P '' futureRibbon k))
+    (hlower : ∀ u ∈ crossingPatch k, ∀ v ∈ crossingPatch k,
+      dist u v ≤ K * dist (P u) (P v))
+    (ζ : ℝ → ℂ)
+    (hnear : ∀ t ∈ Icc (0 : ℝ) 2,
+      dist (ζ t) (P (waypointRoute k side t)) < (1 / 32 : ℝ) / K) :
+    MapsTo ζ (Icc 0 2) (survivingDomain γ T) := by
+  have hk0 : 0 ≤ k := by linarith
+  have hfuture := futureRibbon_survives P hP hi hk0 hH γ T
+    (by rintro z ⟨u, hu, rfl⟩; obtain ⟨v, hv, he⟩ := hpast ⟨u, hu, rfl⟩;
+        exact ⟨v, ⟨hv.1, hv.2.1⟩, he⟩) hunbounded
+  have hupper := sideCorridor_survives P hP hi hH γ T hk0
+    (show ε < 1 by linarith) (show -1 ≤ ε by linarith) le_rfl
+    (fun x hx => hx.1.trans_le (le_abs_self x)) hpast hunbounded
+  have hlowerSide := sideCorridor_survives P hP hi hH γ T hk0
+    (show -1 < -ε by linarith) le_rfl (show -ε ≤ 1 by linarith)
+    (fun x hx => (show ε < -x by linarith [hx.2]).trans_le (neg_le_abs x)) hpast hunbounded
+  intro t ht
+  have hpatch := waypointRoute_ball_subset_patch k side hside t
+  have hsub := crossingPatch_subset_closedRibbon hk
+  have hball := ball_subset_closedBall.trans (hpatch.trans hsub)
+  obtain ⟨z, hz, he⟩ := ball_subset_image_ball P (waypointRoute k side t)
+    (by norm_num : (0 : ℝ) < 1 / 32) hK (hP.mono (hpatch.trans hsub))
+    (hpublished P _ _ (by norm_num) (hP.mono hball) (hi.mono hball))
+    (fun z hz => hlower z (hpatch hz) _ (hpatch (mem_closedBall_self (by norm_num))))
+    (hnear t ht)
+  rw [← he]
+  rcases early_waypoint_coordinate_ball_safe k side hside hk hεsmall ht hz with
+    (hf | hu) | hl
+  · exact hfuture (mem_image_of_mem P hf)
+  · exact hupper (mem_image_of_mem P hu)
+  · exact hlowerSide (mem_image_of_mem P hl)
+
+/-- One positive probability gives the complete route geometry: the early
+part survives, the later part avoids the full guide, and the final leg
+hits the actual stopped past. No harmonic-measure labels are assumed. -/
+theorem uniform_brownian_waypoint_passage_geometry
+    (hopen : PublishedPlanarDiskOpenness) (hsupport : PublishedPlanarWienerUnitSupport)
+    (W : WienerLaw) (hW : IsWiener W) (C K : ℝ≥0) (hK : 0 < (K : ℝ)) :
+    ∃ q : ℝ≥0∞, 0 < q ∧ ∀ P : ℂ → ℂ,
+      ContinuousOn P closedRibbon → InjOn P closedRibbon →
+      (∀ z ∈ closedRibbon, 0 < z.re → P z ∈ upperHalfPlane) →
+      ∀ k ε x side : ℝ, 1 ≤ k → 0 < ε → ε ≤ 1 / 8 → |x| ≤ 1 / 16 →
+      (side = -1 ∨ side = 1) → LipschitzOnWith C P (crossingPatch k) →
+      (∀ u ∈ crossingPatch k, ∀ v ∈ crossingPatch k,
+        dist u v ≤ K * dist (P u) (P v)) →
+      ∀ (γ xp : ℝ≥0 → ℂ) (T : ℝ≥0), 0 < T →
+      ContinuousOn xp (Icc 0 T) → EqOn γ (P ∘ xp) (Icc 0 T) →
+      (xp 0).re = 0 → (xp T).re = k →
+      MapsTo xp (Icc 0 T) closedRibbon →
+      (∀ t ∈ Icc 0 T, (xp t).re ≤ k ∧ |(xp t).im| ≤ ε) →
+      (¬ Bornology.IsBounded (P '' futureRibbon k)) →
+      q ≤ (W.prod W) {b |
+        let ζ := physicalUnitBrownianPath (P ((k + 1 / 2 : ℝ) : ℂ)) b
+        MapsTo ζ (Icc 0 2) (survivingDomain γ T) ∧
+        (∀ t ∈ Icc (1 / 4 : ℝ) 3, ∀ u : ℝ, 0 ≤ u → ζ t ≠ P (guideCoordinate k x u)) ∧
+        ∃ s ∈ Icc 0 T, ∃ t ∈ Icc (0 : ℝ) 3, γ s = ζ t} := by
+  obtain ⟨q, hq, hprob⟩ := uniform_physical_waypoint_tube_probability hsupport W hW C
+    (div_pos (by norm_num : (0 : ℝ) < 1 / 32) hK)
+  refine ⟨q, hq, ?_⟩
+  intro P hP hi hH k ε x side hk hε hεsmall hx hside hL hlower γ xp T hT
+    hxp hγ hxp0 hxpT hcoords hcore hunbounded
+  have habs : |side| = 1 := by rcases hside with rfl | rfl <;> norm_num
+  have hpast : γ '' Icc 0 T ⊆ P '' {z ∈ closedRibbon | z.re ≤ k ∧ |z.im| ≤ ε} := by
+    rintro z ⟨s, hs, rfl⟩
+    exact ⟨xp s, ⟨hcoords hs, hcore s hs⟩, (hγ hs).symm⟩
+  refine (hprob P k side habs hL).trans (measure_mono ?_)
+  intro b hb
+  let ζ := physicalUnitBrownianPath (P ((k + 1 / 2 : ℝ) : ℂ)) b
+  refine ⟨physical_early_waypoint_tube_survives hopen P hP hi hH K hK γ T hk hε hεsmall
+    habs hpast hunbounded hlower ζ (fun t ht => hb t ⟨ht.1, ht.2.trans (by norm_num)⟩), ?_, ?_⟩
+  · intro t ht u hu he
+    have hh := physical_waypointRoute_avoids_complete_guide hopen P hP hi K hK hk hx habs
+      hlower ht.1 hu
+    apply hh
+    rw [← he]
+    exact hb t ⟨by linarith [ht.1], ht.2⟩
+  · let γr : ℝ → ℂ := fun s => γ s.toNNReal
+    let xpr : ℝ → ℂ := fun s => xp s.toNNReal
+    have hmap : MapsTo Real.toNNReal (Icc (0 : ℝ) T) (Icc 0 T) := by
+      intro s hs
+      exact ⟨bot_le, (Real.toNNReal_le_iff_le_coe).mpr hs.2⟩
+    have hcont : ContinuousOn xpr (Icc (0 : ℝ) T) :=
+      hxp.comp (by fun_prop) hmap
+    obtain ⟨s, hs, t, ht, he⟩ := physical_waypoint_tube_hits_past hopen P hP hi K hK hk
+      hε hεsmall (by exact_mod_cast hT : (0 : ℝ) < T) hside hlower γr xpr ζ hcont
+      (fun s hs => hγ (hmap hs)) (by simpa [xpr] using hxp0)
+      (by simpa [xpr] using hxpT) (fun s hs => (hcore _ (hmap hs)).2)
+      (physicalUnitBrownianPath_continuous _ b).continuousOn hb
+    exact ⟨s.toNNReal, hmap hs, t, ht, he⟩
+
+end SLEExactGauge.RibbonCoordinates
+
+end
+
+end OAI
diff --git a/lean/OAI/Probability/SLE/Gauge/WeightedMomentIntegration.lean b/lean/OAI/Probability/SLE/Gauge/WeightedMomentIntegration.lean
new file mode 100644
index 0000000000000000000000000000000000000000..7e18ca93ae7b9e9c2d3e05d3977c4be9f9cf990f
--- /dev/null
+++ b/lean/OAI/Probability/SLE/Gauge/WeightedMomentIntegration.lean
@@ -0,0 +1,32 @@
+import OAI.Probability.SLE.Multipoint.MultipointMomentIntegration
+
+namespace OAI
+
+noncomputable section
+open MeasureTheory
+open scoped ENNReal
+
+namespace SLEExactGauge.Multipoint
+
+lemma lintegral_weighted_mass_pow_eq
+    {Ω X : Type*} [MeasurableSpace Ω] [MeasurableSpace X]
+    (P : Measure Ω) (μ : Measure X) [SigmaFinite P] [SigmaFinite μ]
+    (W : Ω → X → ℝ≥0∞) (hW : Measurable (Function.uncurry W))
+    (f : X → ℝ≥0∞) (hf : Measurable f) (m : ℕ) :
+    (∫⁻ ω, (∫⁻ z, f z * W ω z ∂μ)^m ∂P) =
+      ∫⁻ z : Fin m → X, (∏ i, f (z i)) * (∫⁻ ω, ∏ i, W ω (z i) ∂P)
+        ∂Measure.pi (fun _ : Fin m => μ) := by
+  rw [lintegral_mass_pow_eq P μ (fun ω z => f z * W ω z)
+    ((hf.comp measurable_snd).mul hW) m]
+  apply lintegral_congr
+  intro z
+  have hg : Measurable (fun ω => ∏ i, W ω (z i)) :=
+    Finset.measurable_prod _ (fun i _ => hW.comp (measurable_id.prodMk measurable_const))
+  simp_rw [Finset.prod_mul_distrib]
+  exact lintegral_const_mul _ hg
+
+end SLEExactGauge.Multipoint
+
+end
+
+end OAI
diff --git a/lean/OAI/Probability/SLE/Gauge/WholeSausageScaling.lean b/lean/OAI/Probability/SLE/Gauge/WholeSausageScaling.lean
new file mode 100644
index 0000000000000000000000000000000000000000..7ef04c00f8ff4bf94515a5a83b873a1193675126
--- /dev/null
+++ b/lean/OAI/Probability/SLE/Gauge/WholeSausageScaling.lean
@@ -0,0 +1,79 @@
+import OAI.Probability.SLE.Gauge.RibbonPassageScaling
+import OAI.Probability.SLE.Loewner.ScaleTraceLaw
+
+namespace OAI
+
+/-! Exact whole-sausage scaling at the one common physical mesh. The
+capacity time change does not change the trace's range. -/
+
+noncomputable section
+open Set Filter MeasureTheory Metric
+open scoped Topology NNReal ENNReal
+
+namespace SLEExactGauge
+open RibbonPassageScaling ScaleTraceLaw
+
+lemma wholeSausageSet_surjective_clock (γ : ℝ≥0 → ℂ) (e : ℝ≥0 → ℝ≥0)
+    (he : Function.Surjective e) (v : ℝ) :
+    wholeSausageSet (γ ∘ e) v = wholeSausageSet γ v := by
+  ext z
+  constructor
+  · rintro ⟨t, ht⟩
+    exact ⟨e t, ht⟩
+  · rintro ⟨t, ht⟩
+    obtain ⟨u, rfl⟩ := he t
+    exact ⟨u, ht⟩
+
+lemma wholeSausageSet_affine (a : ℂ) {ell : ℝ} (hell : 0 < ell)
+    (γ : ℝ≥0 → ℂ) (v : ℝ) :
+    wholeSausageSet (fun t => affine a ell (γ t)) (ell * v) =
+      affine a ell '' wholeSausageSet γ v := by
+  ext z
+  obtain ⟨w, rfl⟩ := (affine_bijective a hell).2 z
+  constructor
+  · rintro ⟨t, ht⟩
+    rw [affine_dist a hell.le] at ht
+    exact ⟨w, ⟨t, (mul_lt_mul_iff_right₀ hell).mp ht⟩, rfl⟩
+  · rintro ⟨w', ⟨t, ht⟩, he⟩
+    have hw : w' = w := (affine_bijective a hell).1 he
+    subst w'
+    exact ⟨t, by rw [affine_dist a hell.le]; exact mul_lt_mul_of_pos_left ht hell⟩
+
+theorem wholeSausageCharge_affine (κ : ℝ) (a : ℂ) {ell : ℝ} (hell : 0 < ell)
+    (γ : ℝ≥0 → ℂ) {v : ℝ} (hv : 0 < v) (R : Set ℂ) :
+    wholeSausageCharge κ (fun t => affine a ell (γ t)) (ell * v) (affine a ell '' R) =
+      ENNReal.ofReal (ell ^ dimension κ) * wholeSausageCharge κ γ 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 κ) * 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 [wholeSausageCharge, wholeSausageSet_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]
+
+theorem wholeSausageCharge_scalePath (κ : ℝ) (c : ℝ≥0) (hc : 0 < c)
+    (p : C(ℝ≥0, ℂ)) {v : ℝ} (hv : 0 < v) (R : Set ℂ) :
+    wholeSausageCharge κ (scalePath c p) ((c : ℝ) * v) (affine 0 c '' R) =
+      ENNReal.ofReal ((c : ℝ) ^ dimension κ) * wholeSausageCharge κ p v R := by
+  have he : Function.Surjective (fun t : ℝ≥0 => t / c ^ 2) := by
+    intro t
+    exact ⟨t * c ^ 2, mul_div_cancel_right₀ t (pow_ne_zero 2 hc.ne')⟩
+  have hp : (scalePath c p : ℝ≥0 → ℂ) =
+      (fun t => affine 0 c (p t)) ∘ (fun t => t / c ^ 2) := by
+    funext t
+    change (c : ℂ) * p (t / c ^ 2) = 0 + (c : ℂ) * p (t / c ^ 2)
+    exact (zero_add _).symm
+  simp only [wholeSausageCharge, hp, wholeSausageSet_surjective_clock _ _ he]
+  exact wholeSausageCharge_affine κ 0 (show 0 < (c : ℝ) from hc) p hv R
+
+end SLEExactGauge
+
+end
+
+end OAI
diff --git a/lean/OAI/Probability/SLE/Gauge/WindowDenseTests.lean b/lean/OAI/Probability/SLE/Gauge/WindowDenseTests.lean
new file mode 100644
index 0000000000000000000000000000000000000000..65561c2cceade37d899532ed865001ac62308969
--- /dev/null
+++ b/lean/OAI/Probability/SLE/Gauge/WindowDenseTests.lean
@@ -0,0 +1,55 @@
+import OAI.Probability.SLE.Gauge.DenseCoverAdaptedTests
+
+namespace OAI
+
+/-! Adapted tests need conditional estimates only inside the retained
+scale window. The discarded early scales need no dense estimate. -/
+
+noncomputable section
+open Set Filter MeasureTheory
+open scoped Topology NNReal ENNReal
+
+namespace SLEExactGauge
+
+theorem cover_window_failure_bound_on_window
+    {Ω : Type*} [mΩ : MeasurableSpace Ω] (μ : Measure Ω) [IsProbabilityMeasure μ]
+    (F : Filtration ℕ mΩ) (success : ℕ → Set Ω)
+    (n : ℕ) (hn : 1 ≤ n)
+    (hmeas : ∀ j ∈ coverTestWindow n, MeasurableSet[F (j + 1)] (success j))
+    (hstep : ∀ j ∈ coverTestWindow n, ∀ B : Set Ω, MeasurableSet[F j] B →
+      ENNReal.ofReal (1 / Real.sqrt (n : ℝ)) * μ B ≤ μ (B ∩ success j)) :
+    μ (⋂ j ∈ coverTestWindow n, (success j)ᶜ) ≤
+      ENNReal.ofReal (Real.exp (-Real.sqrt (n : ℝ) / 4)) := by
+  classical
+  let S : ℕ → Set Ω := fun j => if j ∈ coverTestWindow n then success j else univ
+  have hS (j : ℕ) : MeasurableSet[F (j + 1)] (S j) := by
+    dsimp only [S]
+    split_ifs with hj
+    · exact hmeas j hj
+    · exact MeasurableSet.univ
+  have hp : ENNReal.ofReal (1 / Real.sqrt (n : ℝ)) ≤ 1 := by
+    apply ENNReal.ofReal_le_one.mpr
+    have hnr : (1 : ℝ) ≤ n := by exact_mod_cast hn
+    have hs : 1 ≤ Real.sqrt (n : ℝ) := by
+      simpa only [Real.sqrt_one] using Real.sqrt_le_sqrt hnr
+    exact (div_le_one (zero_lt_one.trans_le hs)).mpr hs
+  have hstep' (j : ℕ) (B : Set Ω) (hB : MeasurableSet[F j] B) :
+      ENNReal.ofReal (1 / Real.sqrt (n : ℝ)) * μ B ≤ μ (B ∩ S j) := by
+    dsimp only [S]
+    split_ifs with hj
+    · exact hstep j hj B hB
+    · simpa only [inter_univ, one_mul] using mul_le_mul' hp (le_refl (μ B))
+  have he : (⋂ j ∈ coverTestWindow n, (S j)ᶜ) =
+      ⋂ j ∈ coverTestWindow n, (success j)ᶜ := by
+    apply iInter_congr
+    intro j
+    apply iInter_congr
+    intro hj
+    simp only [S, ite_eq_left hj]
+  simpa only [he] using cover_window_failure_bound μ F S hS n hn hstep'
+
+end SLEExactGauge
+
+end
+
+end OAI
diff --git a/lean/OAI/Probability/SLE/Geometry/AccessGuideCollapse.lean b/lean/OAI/Probability/SLE/Geometry/AccessGuideCollapse.lean
new file mode 100644
index 0000000000000000000000000000000000000000..a68a6c9db97ae6e82985c59d9c4f587a0f49e347
--- /dev/null
+++ b/lean/OAI/Probability/SLE/Geometry/AccessGuideCollapse.lean
@@ -0,0 +1,111 @@
+import OAI.Probability.SLE.Loewner.SlitSupport
+import OAI.Probability.SLE.StripProbabilities
+
+namespace OAI
+
+/-! Uniform collapse of access guides from the already proved conformal
+localization estimate and pointwise slit support. An interior separated set
+prevents arbitrarily small physical images of a unit-modulus access guide. -/
+
+noncomputable section
+open Set Filter MeasureTheory Metric
+open scoped Topology ENNReal NNReal
+
+namespace SLEExactGauge
+
+theorem uniform_access_image_radius_lower_bound
+    {Ω : Type*} [MeasurableSpace Ω] (P : Measure Ω) [IsProbabilityMeasure P]
+    (κ : ℝ) (hκ : 0 < κ) (hκ8 : κ < 8)
+    (γ : Ω → ℝ≥0 → ℂ) (hSLE : IsOrdinaryChordalSLE κ γ P)
+    (T : ℝ≥0) (R : ℝ) (Q : Set ℂ) (hQ : Q ⊆ upperHalfPlane)
+    (hvisit : 0 < P {ω | (∀ t ∈ Icc 0 T, ‖γ ω t‖ < R) ∧ γ ω T ∈ Q})
+    (r₀ : ℝ) (hr₀ : 0 < r₀) :
+    ∃ rmin : ℝ, 0 < rmin ∧
+      ∀ (F : ℂ → ℂ) (Fbar : ℂ → OnePoint ℂ),
+      DifferentiableOn ℂ F upperHalfPlane → InjOn F upperHalfPlane →
+      ContinuousOn Fbar {z : ℂ | 0 ≤ z.im} →
+      (∀ z ∈ upperHalfPlane, Fbar z = (F z : OnePoint ℂ)) →
+      ∀ (a : ℂ) (r : ℝ), 0 < r →
+      (∀ z ∈ Q, r₀ ≤ ‖F z - a‖) →
+      ∀ (η : ℝ → ℂ) (S : ℝ), 0 < S → ContinuousOn η (Icc 0 S) →
+      η 0 = 0 → ‖η S‖ = 1 → (∀ t ∈ Icc 0 S, 0 ≤ (η t).im) →
+      (∀ t ∈ Icc 0 S, ∃ w : ℂ,
+        Fbar (η t) = (w : OnePoint ℂ) ∧ ‖w - a‖ ≤ r) → rmin ≤ r := by
+  obtain ⟨b, C, c, L₀, hb, _, hc, hL₀, hloc⟩ :=
+    sourceUniformConformalLocalization κ hκ hκ8
+  let E : Set Ω := {ω | (∀ t ∈ Icc 0 T, ‖γ ω t‖ < R) ∧ γ ω T ∈ Q}
+  have ht : Tendsto (fun L : ℝ => ENNReal.ofReal (C * L ^ (-c))) atTop (𝓝 0) := by
+    simpa only [Function.comp_def, mul_zero, ENNReal.ofReal_zero] using
+      ENNReal.continuous_ofReal.continuousAt.tendsto.comp
+        ((tendsto_rpow_neg_atTop hc).const_mul C)
+  have hlarge := (eventually_ge_atTop L₀).and
+    (((tendsto_rpow_atTop hb).eventually_gt_atTop R).and
+      (ht.eventually (gt_mem_nhds hvisit)))
+  obtain ⟨L, hL, hLR, hLprob⟩ := hlarge.exists
+  have hLp : 0 < L := (zero_lt_one.trans hL₀).trans_le hL
+  refine ⟨r₀ / L, div_pos hr₀ hLp, ?_⟩
+  intro F Fbar hF hinj hbar hext a r hr hsep η S hS hη hη0 hηS hupper himage
+  by_contra! hsmall
+  have hLr : L * r < r₀ := by
+    have hh := (lt_div_iff₀ hLp).mp hsmall
+    simpa only [mul_comm] using hh
+  have hbound := hloc Ω inferInstance P inferInstance γ hSLE F Fbar hF hinj
+    hbar hext a r hr η S hS hη hη0 hηS hupper himage L hL
+  have hsub : E ⊆ {ω | ∃ t : ℝ≥0, BeforeFirstModulus (γ ω) (L ^ b) t ∧
+      Fbar (γ ω t) ∉ (fun z : ℂ => (z : OnePoint ℂ)) '' ball a (L * r)} := by
+    rintro ω ⟨hω, hωQ⟩
+    refine ⟨T, ?_, ?_⟩
+    · intro s hs
+      exact (hω s ⟨zero_le, hs.le⟩).trans hLR
+    · rintro ⟨w, hw, he⟩
+      have heq : w = F (γ ω T) :=
+        OnePoint.coe_injective (he.trans (hext _ (hQ hωQ)))
+      subst w
+      have hh : ‖F (γ ω T) - a‖ < L * r := by
+        simpa only [mem_ball, dist_eq_norm] using hw
+      exact (not_lt_of_ge (hsep _ hωQ)) (hh.trans hLr)
+  exact (not_lt_of_ge ((measure_mono hsub).trans hbound)) hLprob
+
+/-- The separated interior set and published pointwise support rule out the
+bad sequence in the access-guide compactness argument. All map and guide
+conditions refer to the actual complex maps, rather than to an abstract state. -/
+theorem no_shrinking_access_guides_of_published_support
+    {Ω : Type*} [MeasurableSpace Ω] (P : Measure Ω) [IsProbabilityMeasure P]
+    (κ : ℝ) (hκ : 0 < κ) (hκ8 : κ < 8)
+    (γ : Ω → ℝ≥0 → ℂ) (hSLE : IsOrdinaryChordalSLE κ γ P)
+    (hpublished : PublishedSimpleTraceSupport P γ)
+    (T : ℝ≥0) (hT : 0 < T) (β : ℝ≥0 → ℂ) (U : ℝ≥0 → ℝ)
+    (hU : Continuous U) (hβ : IsCapacityTwoTrace U β)
+    (hinjβ : InjOn β (Icc 0 T)) (hβH : ∀ t ∈ Ioc 0 T, β t ∈ upperHalfPlane)
+    (R : ℝ) (hβR : β '' Icc 0 T ⊆ ball 0 R)
+    (Q : Set ℂ) (hQopen : IsOpen Q) (hQ : Q ⊆ upperHalfPlane) (hβQ : β T ∈ Q)
+    (F : ℕ → ℂ → ℂ) (Fbar : ℕ → ℂ → OnePoint ℂ)
+    (hF : ∀ n, DifferentiableOn ℂ (F n) upperHalfPlane)
+    (hinj : ∀ n, InjOn (F n) upperHalfPlane)
+    (hbar : ∀ n, ContinuousOn (Fbar n) {z : ℂ | 0 ≤ z.im})
+    (hext : ∀ n z, z ∈ upperHalfPlane → Fbar n z = (F n z : OnePoint ℂ))
+    (a : ℕ → ℂ) (r : ℕ → ℝ) (hr : ∀ n, 0 < r n)
+    (hlim : Tendsto r atTop (𝓝 0)) (r₀ : ℝ) (hr₀ : 0 < r₀)
+    (hsep : ∀ᶠ n in atTop, ∀ z ∈ Q, r₀ ≤ ‖F n z - a n‖)
+    (η : ℕ → ℝ → ℂ) (S : ℕ → ℝ) (hS : ∀ n, 0 < S n)
+    (hη : ∀ n, ContinuousOn (η n) (Icc 0 (S n)))
+    (hη0 : ∀ n, η n 0 = 0) (hηS : ∀ n, ‖η n (S n)‖ = 1)
+    (hupper : ∀ n t, t ∈ Icc 0 (S n) → 0 ≤ (η n t).im)
+    (himage : ∀ n t, t ∈ Icc 0 (S n) → ∃ w : ℂ,
+      Fbar n (η n t) = (w : OnePoint ℂ) ∧ ‖w - a n‖ ≤ r n) : False := by
+  have hp := slit_tube_support_of_published_support P γ hpublished T hT β U hU hβ
+    hinjβ hβH (ball 0 R) Q isOpen_ball hQopen hβR hβQ
+  have hvisit : 0 < P {ω | (∀ t ∈ Icc 0 T, ‖γ ω t‖ < R) ∧ γ ω T ∈ Q} := by
+    simpa only [mem_ball, dist_zero_right] using hp
+  obtain ⟨rmin, hrmin, hbound⟩ := uniform_access_image_radius_lower_bound
+    P κ hκ hκ8 γ hSLE T R Q hQ hvisit r₀ hr₀
+  obtain ⟨n, hn, hsepn⟩ := ((hlim.eventually (gt_mem_nhds hrmin)).and hsep).exists
+  exact (not_lt_of_ge (hbound (F n) (Fbar n) (hF n) (hinj n) (hbar n)
+    (hext n) (a n) (r n) (hr n) hsepn (η n) (S n) (hS n) (hη n)
+    (hη0 n) (hηS n) (hupper n) (himage n))) hn
+
+end SLEExactGauge
+
+end
+
+end OAI
diff --git a/lean/OAI/Probability/SLE/Geometry/ActualCompactAvoidance.lean b/lean/OAI/Probability/SLE/Geometry/ActualCompactAvoidance.lean
new file mode 100644
index 0000000000000000000000000000000000000000..d7839c75568e0cb697a83d7ebedacb6d05aa727b
--- /dev/null
+++ b/lean/OAI/Probability/SLE/Geometry/ActualCompactAvoidance.lean
@@ -0,0 +1,76 @@
+import OAI.Probability.SLE.Loewner.LoewnerCompactDriverNeighborhood
+import OAI.Probability.SLE.Stochastic.BrownianFiniteTube
+import OAI.Probability.SLE.Geometry.ActualFirstHeightSupport
+
+namespace OAI
+
+/-! Positive probability of preserving a compact surviving set of a
+prescribed continuous Loewner driver. This controls compact interior
+obstacles in the geometric-support construction. -/
+noncomputable section
+open Set Filter _root_.MeasureTheory _root_.OAI.MeasureTheory ProbabilityTheory
+open scoped Topology NNReal ENNReal
+
+namespace SLEExactGauge
+
+theorem regular_scaled_driver_tube_positive
+    {Ω : Type*} [MeasurableSpace Ω] {P : Measure Ω} [IsProbabilityMeasure P]
+    {κ : ℝ} {γ : Ω → ℝ≥0 → ℂ} (a : RegularSLEPresentation P κ γ)
+    (hκ : 0 < κ) (V : C(ℝ≥0,ℝ)) (hV0 : V 0=0)
+    (T : ℝ≥0) (hT : 0 < T) {δ : ℝ} (hδ : 0 < δ) :
+    0 < (P.comap (Subtype.val : a.samples → Ω))
+      {ω | ∀ t ∈ Icc 0 T, |Real.sqrt κ*a.B t ω-V t| < δ} := by
+  have hroot : 0 < Real.sqrt κ := Real.sqrt_pos.mpr hκ
+  let f : C(ℝ≥0,ℝ) := ⟨fun t => V t / Real.sqrt κ,
+    V.continuous.div_const _⟩
+  have hf0 : f 0=0 := by simp [f,hV0]
+  have hp := brownian_finite_uniform_tube_positive a.B a.brownian a.measurable_B
+    a.continuous_B a.zero_B T hT f hf0 (div_pos hδ hroot)
+  apply hp.trans_le (measure_mono ?_)
+  intro ω hω t ht
+  have hh := hω t ht
+  change |a.B t ω-V t / Real.sqrt κ| < δ/Real.sqrt κ at hh
+  have he : Real.sqrt κ*a.B t ω-V t =
+      Real.sqrt κ*(a.B t ω-V t/Real.sqrt κ) := by field_simp
+  rw [he,abs_mul,abs_of_pos hroot]
+  simpa only [mul_comm] using (lt_div_iff₀ hroot).mp hh
+
+theorem regular_compact_survival_positive
+    {Ω : Type*} [MeasurableSpace Ω] {P : Measure Ω} [IsProbabilityMeasure P]
+    {κ : ℝ} {γ : Ω → ℝ≥0 → ℂ} (a : RegularSLEPresentation P κ γ)
+    (hκ : 0 < κ) (V : C(ℝ≥0,ℝ)) (hV0 : V 0=0)
+    {β : ℝ≥0 → ℂ} {H J : ℝ≥0 → ℂ → ℂ}
+    (hv : IsCapacityTwoWitness V β H J) (T : ℝ≥0) (hT : 0 < T)
+    {K : Set ℂ} (hK : IsCompact K) (hKD : K ⊆ survivingDomain β T) :
+    0 < (P.comap (Subtype.val : a.samples → Ω))
+      {ω | K ⊆ survivingDomain (γ ω) T} := by
+  obtain ⟨δ,hδ,hkeep⟩ := driver_neighborhood_preserves_compact hv T hK hKD
+  have hp := regular_scaled_driver_tube_positive a hκ V hV0 T hT hδ
+  apply hp.trans_le (measure_mono ?_)
+  intro ω hω
+  apply hkeep (fun t => Real.sqrt κ*a.B t ω) (γ ω) (a.G ω) (a.F ω) (a.witness ω)
+  exact fun t ht => (hω t ht).le
+
+theorem ordinary_compact_survival_positive
+    {Ω : Type*} [MeasurableSpace Ω] (P : Measure Ω) [IsProbabilityMeasure P]
+    (κ : ℝ) (hκ : 0 < κ) (γ : Ω → ℝ≥0 → ℂ)
+    (hSLE : IsOrdinaryChordalSLE κ γ P)
+    (V : C(ℝ≥0,ℝ)) (hV0 : V 0=0)
+    {β : ℝ≥0 → ℂ} {H J : ℝ≥0 → ℂ → ℂ}
+    (hv : IsCapacityTwoWitness V β H J) (T : ℝ≥0) (hT : 0 < T)
+    {K : Set ℂ} (hK : IsCompact K) (hKD : K ⊆ survivingDomain β T) :
+    0 < P {ω | K ⊆ survivingDomain (γ ω) T} := by
+  obtain ⟨a⟩ := exists_regular_sle_presentation hSLE
+  have hp := regular_compact_survival_positive a hκ V hV0 hv T hT hK hKD
+  apply hp.trans_le
+  have hh := Measure.le_map_apply (μ := P.comap (Subtype.val : a.samples → Ω))
+    a.measurePreserving_val.measurable.aemeasurable
+    {ω | K ⊆ survivingDomain (γ ω) T}
+  rw [a.measurePreserving_val.map_eq] at hh
+  convert! hh using 1
+
+end SLEExactGauge
+
+end
+
+end OAI
diff --git a/lean/OAI/Probability/SLE/Geometry/ActualConformalExitLaw.lean b/lean/OAI/Probability/SLE/Geometry/ActualConformalExitLaw.lean
new file mode 100644
index 0000000000000000000000000000000000000000..96aece0426a483874e09fb69154138e60fa9e872
--- /dev/null
+++ b/lean/OAI/Probability/SLE/Geometry/ActualConformalExitLaw.lean
@@ -0,0 +1,43 @@
+import OAI.Probability.SLE.Geometry.UnitWindowPlanarExit
+
+namespace OAI
+
+/-! The published finite-window conformal exit input, proved from the
+original planar Wiener law and bounded harmonic localization. -/
+noncomputable section
+open Set Filter MeasureTheory ProbabilityTheory
+open scoped Topology NNReal ENNReal
+
+namespace SLEExactGauge
+open Target RibbonCoordinates
+
+lemma unitWindowExitArc_subset_planar (D : Set ℂ) (g : ℂ → ℂ) (w : ℂ) (positive : Bool) :
+    unitWindowExitArc D g w (if positive then 1 else -1) ⊆
+      planarHalfPlaneExitArc D g w 1 positive := by
+  rintro b ⟨τ,hτ,x,hx,hl⟩
+  obtain ⟨hS,hS1,hp,he⟩ := unitWindowFirstExit_planar hτ
+  refine ⟨unitWindowStop τ,hS,hS1,hp,he,x,?_,?_⟩
+  · cases positive <;> simp only [Bool.false_eq_true,↓reduceIte] at hx ⊢ <;> linarith
+  · exact (unitWindow_map_limit_iff w b g hτ.1 (x:ℂ)).mp hl
+
+theorem actual_halfPlaneConformalExitLaw : PublishedHalfPlaneConformalExitLaw := by
+  intro W hW D g f hD _hDH hg hf hgH hfD hfg _hgf w hw
+  refine ⟨?_,?_,?_⟩
+  · have hl := halfPlane_finite_exit_limit W hW hD hg hf hgH hfD hfg w hw 1
+    filter_upwards [hl] with b hb
+    intro τ hτ
+    obtain ⟨hS,hS1,hp,he⟩ := unitWindowFirstExit_planar hτ
+    obtain ⟨x,hx,hm⟩ := hb (unitWindowStop τ) hS hS1 hp he
+    exact ⟨x,hx,(unitWindow_map_limit_iff w b g hτ.1 (x:ℂ)).mpr hm⟩
+  · have hh := (measure_mono (unitWindowExitArc_subset_planar D g w false)).trans
+      (planarHalfPlaneExitArc_bound W hW hD w hw hg hgH 1 false)
+    simpa only [Bool.false_eq_true,↓reduceIte,halfPlaneExitWeight] using hh
+  · have hh := (measure_mono (unitWindowExitArc_subset_planar D g w true)).trans
+      (planarHalfPlaneExitArc_bound W hW hD w hw hg hgH 1 true)
+    simpa only [↓reduceIte,halfPlaneExitWeight] using hh
+
+end SLEExactGauge
+
+end
+
+end OAI
diff --git a/lean/OAI/Probability/SLE/Geometry/ActualCrosscutStraightening.lean b/lean/OAI/Probability/SLE/Geometry/ActualCrosscutStraightening.lean
new file mode 100644
index 0000000000000000000000000000000000000000..645bd0ad6e1435edb50945293db3a86ae2267899
--- /dev/null
+++ b/lean/OAI/Probability/SLE/Geometry/ActualCrosscutStraightening.lean
@@ -0,0 +1,49 @@
+import OAI.Probability.SLE.Geometry.PublishedCrosscutStraightening
+import OAI.Probability.SLE.Geometry.DiskCrosscutHomeomorph
+import OAI.Probability.SLE.Geometry.HalfPlaneDiskTransport
+import OAI.Probability.SLE.Geometry.ClosedHalfPlaneExtension
+import OAI.Probability.SLE.Geometry.CrosscutParameterInverse
+
+namespace OAI
+
+/-! The relative half-plane crosscut theorem from the specified-boundary
+Schönflies extension. -/
+noncomputable section
+open Set Complex Filter Metric
+open scoped Topology NNReal
+
+namespace SLEExactGauge
+
+theorem actual_halfPlaneCrosscutStraightening : PublishedHalfPlaneCrosscutStraightening := by
+  intro β hc hi h0 hH hinfty
+  have hβ (t : ℝ≥0) : 0 ≤ (β t).im := by
+    by_cases ht : t=0
+    · simp [ht,h0]
+    · exact (hH t (pos_iff_ne_zero.mpr ht)).le
+  obtain ⟨hpc,hpi,hpint⟩ := compactifiedCrosscut_properties β hc hi h0 hH hinfty
+  obtain ⟨e,hep,hef⟩ := disk_crosscut_homeomorph (compactifiedCrosscut β) hpc hpi
+    (compactifiedCrosscut_zero β h0) (compactifiedCrosscut_one β) hpint
+  have he1 : e ⟨1,by norm_num⟩=⟨1,by norm_num⟩ :=
+    Subtype.ext (hef ⟨1,by norm_num⟩ (by norm_num))
+  obtain ⟨F,hF,hFr,hFH⟩ := closedHalfPlane_extension (halfPlaneDiskTransport e he1)
+    (halfPlaneDiskTransport_boundary e he1 hef)
+  refine ⟨F,hFr,hFH,?_⟩
+  intro t
+  rw [hF (β t) (hβ t),halfPlaneDiskTransport_apply]
+  have hs := rayDiskParameter_mem t
+  have hpt := compactifiedCrosscut_rayDiskParameter β t
+  have hball : halfPlaneCayley (β t) ∈ closedBall (0:ℂ) 1 := by
+    simpa only [mem_closedBall,dist_zero_right] using halfPlaneCayley_norm_le (hβ t)
+  have hps : compactifiedCrosscut β (rayDiskParameter t) ∈ closedBall (0:ℂ) 1 :=
+    hpt.symm ▸ hball
+  have heq := hep (rayDiskParameter t) ⟨hs.1,hs.2.le⟩ hps
+  have heq' : (e ⟨halfPlaneCayley (β t),hball⟩:ℂ)=diskDiameter (rayDiskParameter t) := by
+    simpa only [hpt] using heq
+  rw [heq',diskDiameter_rayDiskParameter,halfPlaneCayleyInv_cayley]
+  simp
+
+end SLEExactGauge
+
+end
+
+end OAI
diff --git a/lean/OAI/Probability/SLE/Geometry/ActualExplicitMain.lean b/lean/OAI/Probability/SLE/Geometry/ActualExplicitMain.lean
new file mode 100644
index 0000000000000000000000000000000000000000..cb2654518cfd4c4e41062636a0d3d6f94f4e7035
--- /dev/null
+++ b/lean/OAI/Probability/SLE/Geometry/ActualExplicitMain.lean
@@ -0,0 +1,101 @@
+import OAI.Probability.SLE.Gauge.ActualDenseCoverProbability
+import OAI.Probability.SLE.Gauge.DenseCoverExpectation
+import OAI.Probability.SLE.Geometry.SpatialExhaustion
+
+namespace OAI
+
+/-! The explicit-gauge main theorem for a regular Brownian-driven Loewner
+presentation, conditional on the precise published inputs used in the
+geometric and stochastic construction. -/
+
+noncomputable section
+open Set Filter MeasureTheory ProbabilityTheory Metric
+open scoped Topology NNReal ENNReal
+
+namespace SLEExactGauge
+open Target
+
+local instance actualMainDriverMeasurable : MeasurableSpace C(ℝ≥0, ℝ) := borel _
+local instance actualMainDriverBorel : BorelSpace C(ℝ≥0, ℝ) := ⟨rfl⟩
+
+lemma compact_upperHalfPlane_height_lower_bound {K : Set ℂ}
+    (hK : IsCompact K) (hH : K ⊆ upperHalfPlane) :
+    ∃ η : ℝ, 0 < η ∧ ∀ z ∈ K, η ≤ z.im := by
+  by_cases hne : K.Nonempty
+  · obtain ⟨z, hz, hmin⟩ := hK.exists_isMinOn hne Complex.continuous_im.continuousOn
+    exact ⟨z.im, hH hz, hmin⟩
+  · refine ⟨1, zero_lt_one, ?_⟩
+    intro z hz
+    exact False.elim (hne ⟨z, hz⟩)
+
+theorem regular_driver_gauge_mainConclusion
+    {Ω : Type} [MeasurableSpace Ω] (P : Measure Ω) [IsProbabilityMeasure P]
+    (κ : ℝ) (hκ : 0 < κ) (hκ8 : κ < 8)
+    (B : ℝ≥0 → Ω → ℝ) (hB : IsBrownianReal B P)
+    (hBm : Measurable (fun p : ℝ≥0 × Ω => B p.1 p.2))
+    (hc : ∀ ω, Continuous (fun t => B t ω)) (hB0 : ∀ ω, B 0 ω = 0)
+    (γ : Ω → ℝ≥0 → ℂ) (G F : Ω → ℝ≥0 → ℂ → ℂ)
+    (hγm : ∀ t, Measurable (fun ω => γ ω t))
+    (hw : ∀ ω, IsCapacityTwoWitness (fun t => Real.sqrt κ * B t ω) (γ ω) (G ω) (F ω))
+    (htrace : PublishedTraceGeneration (P.map (sourceDriverPath B hc)) κ (fun t p => p t))
+    (hcompact : PublishedHalfPlaneUnivalentCompactness)
+    (hboundary : PublishedFiniteLoewnerBoundaryExtension)
+    (hsupport : PublishedGeometricTubeSupport P γ)
+    (hplanar : PublishedPlanarDiskOpenness)
+    (hstraight : PublishedHalfPlaneCrosscutStraightening)
+    (hexit : PublishedHalfPlaneConformalExitLaw)
+    (hwiener : PublishedPlanarWienerUnitSupport)
+    (W : WienerLaw) (hW : IsWiener W)
+    (h : ℝ → ℝ) (hh : IsGauge h) (hf : HasSmallRadiusFormula h (hFormula κ)) :
+    MainConclusion P h γ := by
+  have hSLE : IsOrdinaryChordalSLE κ γ P :=
+    ⟨hγm, B, hB, Eventually.of_forall (fun ω => ⟨G ω, F ω, hw ω⟩)⟩
+  obtain ⟨T, b, c, hT, hb, hcpos, v, hv, _, hprob⟩ :=
+    uniform_actual_dense_cover_probability P κ hκ hκ8 B hB hBm hc hB0 γ G F hγm hw
+      htrace hcompact hboundary hsupport hplanar hstraight hexit hwiener W hW
+  obtain ⟨C, _, hbound⟩ := expected_hausdorff_of_dense_candidates P κ hκ hκ8 γ hSLE
+    (fun ω => (hw ω).1) hT hb hcpos h hh hf
+  apply mainConclusion_of_uniform_compact_interior_bounds P κ hκ hκ8 γ hSLE h hh hf
+  intro R hR
+  refine ⟨(C : ℝ≥0∞) * wholeSausageChargeBound κ (R + 3), ?_, ?_⟩
+  · exact ENNReal.mul_lt_top ENNReal.coe_lt_top (wholeSausageChargeBound_lt_top κ _ hκ hκ8)
+  · intro t K hK hKR
+    obtain ⟨η, hη, hheight⟩ := compact_upperHalfPlane_height_lower_bound hK
+      (fun z hz => (hKR hz).1)
+    obtain ⟨D, hD, hmiss⟩ := hprob η hη
+    have hwhole := hbound R hR.le K (fun z hz => (hKR hz).2) v hv D hD.le
+      (by simpa only [denseMissedProbabilityBound] using hmiss R K (fun z hz => (hKR hz).2) hheight)
+    refine (lintegral_mono fun ω => measure_mono ?_).trans hwhole
+    intro z hz
+    exact ⟨hz.1, image_subset_range (γ ω) (Icc 0 t) hz.2⟩
+
+/-- The regular-driver form of the explicit exact-gauge result. The same
+conclusion includes finite expected measure in every bounded disk. -/
+theorem regular_driver_explicit_mainConclusion
+    {Ω : Type} [MeasurableSpace Ω] (P : Measure Ω) [IsProbabilityMeasure P]
+    (κ : ℝ) (hκ : 0 < κ) (hκ8 : κ < 8)
+    (B : ℝ≥0 → Ω → ℝ) (hB : IsBrownianReal B P)
+    (hBm : Measurable (fun p : ℝ≥0 × Ω => B p.1 p.2))
+    (hc : ∀ ω, Continuous (fun t => B t ω)) (hB0 : ∀ ω, B 0 ω = 0)
+    (γ : Ω → ℝ≥0 → ℂ) (G F : Ω → ℝ≥0 → ℂ → ℂ)
+    (hγm : ∀ t, Measurable (fun ω => γ ω t))
+    (hw : ∀ ω, IsCapacityTwoWitness (fun t => Real.sqrt κ * B t ω) (γ ω) (G ω) (F ω))
+    (htrace : PublishedTraceGeneration (P.map (sourceDriverPath B hc)) κ (fun t p => p t))
+    (hcompact : PublishedHalfPlaneUnivalentCompactness)
+    (hboundary : PublishedFiniteLoewnerBoundaryExtension)
+    (hsupport : PublishedGeometricTubeSupport P γ)
+    (hplanar : PublishedPlanarDiskOpenness)
+    (hstraight : PublishedHalfPlaneCrosscutStraightening)
+    (hexit : PublishedHalfPlaneConformalExitLaw)
+    (hwiener : PublishedPlanarWienerUnitSupport)
+    (W : WienerLaw) (hW : IsWiener W) :
+    MainConclusion P (explicitGauge κ) γ :=
+  regular_driver_gauge_mainConclusion P κ hκ hκ8 B hB hBm hc hB0 γ G F hγm hw
+    htrace hcompact hboundary hsupport hplanar hstraight hexit hwiener W hW
+    (explicitGauge κ) (explicitGauge_isGauge hκ) (explicitGauge_small_formula κ)
+
+end SLEExactGauge
+
+end
+
+end OAI
diff --git a/lean/OAI/Probability/SLE/Geometry/ActualExplicitTransfer.lean b/lean/OAI/Probability/SLE/Geometry/ActualExplicitTransfer.lean
new file mode 100644
index 0000000000000000000000000000000000000000..3fe224dc6809fdaae954edee49d20003e1f3ae1d
--- /dev/null
+++ b/lean/OAI/Probability/SLE/Geometry/ActualExplicitTransfer.lean
@@ -0,0 +1,164 @@
+import OAI.Probability.SLE.Geometry.ActualExplicitMain
+
+namespace OAI
+
+/-! Passage from a regular presentation to an arbitrary ordinary SLE.
+The subtype restriction preserves the published geometric support input,
+and whole-trace expectations transfer through its measure-preserving map. -/
+
+noncomputable section
+open Set Filter MeasureTheory ProbabilityTheory Metric
+open scoped Topology NNReal ENNReal
+
+namespace SLEExactGauge
+open Target
+
+local instance explicitTransferDriverMeasurable : MeasurableSpace C(ℝ≥0, ℝ) := borel _
+local instance explicitTransferDriverBorel : BorelSpace C(ℝ≥0, ℝ) := ⟨rfl⟩
+
+/-- The same continuous Brownian path, retaining its pointwise zero start. -/
+def sourceBasedDriverPath {Ω : Type*} (B : ℝ≥0 → Ω → ℝ)
+    (hc : ∀ ω, Continuous (fun t => B t ω)) (h0 : ∀ ω, B 0 ω = 0)
+    (ω : Ω) : Driver where
+  toContinuousMap := sourceDriverPath B hc ω
+  map_zero' := h0 ω
+
+lemma sourceBasedDriverPath_measurable
+    {Ω : Type*} [MeasurableSpace Ω] (B : ℝ≥0 → Ω → ℝ)
+    (hm : ∀ t, Measurable (B t))
+    (hc : ∀ ω, Continuous (fun t => B t ω)) (h0 : ∀ ω, B 0 ω = 0) :
+    Measurable (sourceBasedDriverPath B hc h0) := by
+  apply ContinuousMapZero.isClosedEmbedding_toContinuousMap.measurableEmbedding.measurable_comp_iff.mp
+  exact source_path_measurable _ hm
+
+/-- An ordinary regular presentation supplies the based Wiener law needed
+by the two-dimensional Brownian support input. -/
+theorem sourceBasedDriverLaw_isWiener
+    {Ω : Type*} [MeasurableSpace Ω] {P : Measure Ω}
+    (B : ℝ≥0 → Ω → ℝ) (hB : IsBrownianReal B P)
+    (hm : ∀ t, Measurable (B t))
+    (hc : ∀ ω, Continuous (fun t => B t ω)) (h0 : ∀ ω, B 0 ω = 0) :
+    IsWiener (P.map (sourceBasedDriverPath B hc h0)) := by
+  have hbp := sourceBasedDriverPath_measurable B hm hc h0
+  refine ⟨⟨fun I => ?_⟩, Eventually.of_forall (fun b => map_continuous b)⟩
+  have hI : Measurable (fun b : Driver => I.restrict (fun t => b t)) :=
+    Measurable.of_eval (fun i => (continuous_eval_const (i : ℝ≥0)).measurable)
+  refine ⟨hI.aemeasurable, ?_⟩
+  rw [Measure.map_map hI hbp]
+  exact (hB.hasLaw I).map_eq
+
+theorem RegularSLEPresentation.geometric_support
+    {Ω : Type*} [MeasurableSpace Ω] {P : Measure Ω} {κ : ℝ}
+    {γ : Ω → ℝ≥0 → ℂ} (a : RegularSLEPresentation P κ γ)
+    (hsupport : PublishedGeometricTubeSupport P γ) :
+    PublishedGeometricTubeSupport (P.comap (Subtype.val : a.samples → Ω))
+      (fun ω => γ ω) := by
+  intro z p hp hpH N V hN hV hpN hzV
+  let E : Set Ω := {ω | ∃ T : ℝ≥0, 0 < T ∧ MapsTo (γ ω) (Icc 0 T) N ∧ γ ω T ∈ V}
+  have hemb : MeasurableEmbedding (Subtype.val : a.samples → Ω) :=
+    MeasurableEmbedding.subtype_coe a.measurable_samples
+  have he : (P.comap (Subtype.val : a.samples → Ω))
+      ((Subtype.val : a.samples → Ω) ⁻¹' E) = P E := by
+    rw [← hemb.map_apply, a.measurePreserving_val.map_eq]
+  change 0 < (P.comap (Subtype.val : a.samples → Ω))
+    ((Subtype.val : a.samples → Ω) ⁻¹' E)
+  rw [he]
+  exact hsupport z p hp hpH N V hN hV hpN hzV
+
+theorem ordinary_explicit_main_of_regular_presentation
+    {Ω : Type} [MeasurableSpace Ω] (P : Measure Ω) [IsProbabilityMeasure P]
+    (κ : ℝ) (hκ : 0 < κ) (hκ8 : κ < 8)
+    (γ : Ω → ℝ≥0 → ℂ) (hSLE : IsOrdinaryChordalSLE κ γ P)
+    (a : RegularSLEPresentation P κ γ)
+    (htrace : PublishedTraceGeneration
+      ((P.comap (Subtype.val : a.samples → Ω)).map (sourceDriverPath a.B a.continuous_B))
+      κ (fun t p => p t))
+    (hcompact : PublishedHalfPlaneUnivalentCompactness)
+    (hboundary : PublishedFiniteLoewnerBoundaryExtension)
+    (hsupport : PublishedGeometricTubeSupport P γ)
+    (hplanar : PublishedPlanarDiskOpenness)
+    (hstraight : PublishedHalfPlaneCrosscutStraightening)
+    (hexit : PublishedHalfPlaneConformalExitLaw)
+    (hwiener : PublishedPlanarWienerUnitSupport)
+    (W : WienerLaw) (hW : IsWiener W) :
+    MainConclusion P (explicitGauge κ) γ := by
+  let Q := P.comap (Subtype.val : a.samples → Ω)
+  let : IsProbabilityMeasure Q := a.probability
+  have hBm : Measurable (fun p : ℝ≥0 × a.samples => a.B p.1 p.2) :=
+    measurable_uncurry_of_continuous_of_measurable a.continuous_B a.measurable_B
+  have hmain := regular_driver_explicit_mainConclusion Q κ hκ hκ8 a.B a.brownian hBm
+    a.continuous_B a.zero_B (fun ω => γ ω) a.G a.F
+    (fun t => (hSLE.1 t).comp measurable_subtype_coe) a.witness htrace
+    hcompact hboundary (a.geometric_support hsupport) hplanar hstraight hexit hwiener W hW
+  apply (mainConclusion_iff_finiteExpectedWholeTrace P κ hκ hκ8 γ hSLE
+    (explicitGauge κ) (explicitGauge_isGauge hκ) (explicitGauge_small_formula κ)).mpr
+  intro R hR
+  have hb := finiteExpectedWholeTrace_of_mainConclusion Q (explicitGauge κ)
+    (fun ω => γ ω) hmain R hR
+  have hemb : MeasurableEmbedding (Subtype.val : a.samples → Ω) :=
+    MeasurableEmbedding.subtype_coe a.measurable_samples
+  have he := a.measurePreserving_val.lintegral_comp_emb hemb
+    (fun ω => hausdorffGauge (explicitGauge κ) (wholeTrace (γ ω) ∩ closedBall 0 R))
+  exact he.symm.trans_lt hb
+
+/-- A fixed choice is used only to state the precise canonical-driver law
+on which the Rohde--Schramm trace-generation input is needed. -/
+def ordinaryRegularPresentation
+    {Ω : Type} [MeasurableSpace Ω] {P : Measure Ω} {κ : ℝ}
+    {γ : Ω → ℝ≥0 → ℂ} (hSLE : IsOrdinaryChordalSLE κ γ P) :
+    RegularSLEPresentation P κ γ := Classical.choice (exists_regular_sle_presentation hSLE)
+
+def ordinaryRegularDriverLaw
+    {Ω : Type} [MeasurableSpace Ω] {P : Measure Ω} {κ : ℝ}
+    {γ : Ω → ℝ≥0 → ℂ} (hSLE : IsOrdinaryChordalSLE κ γ P) : Measure C(ℝ≥0, ℝ) :=
+  let a := ordinaryRegularPresentation hSLE
+  (P.comap (Subtype.val : a.samples → Ω)).map (sourceDriverPath a.B a.continuous_B)
+
+/-- The explicit exact-gauge main conclusion for any ordinary chordal SLE,
+conditional on the same eight published inputs as the regular theorem. -/
+theorem ordinary_explicit_mainConclusion
+    {Ω : Type} [MeasurableSpace Ω] (P : Measure Ω) [IsProbabilityMeasure P]
+    (κ : ℝ) (hκ : 0 < κ) (hκ8 : κ < 8)
+    (γ : Ω → ℝ≥0 → ℂ) (hSLE : IsOrdinaryChordalSLE κ γ P)
+    (htrace : PublishedTraceGeneration (ordinaryRegularDriverLaw hSLE) κ (fun t p => p t))
+    (hcompact : PublishedHalfPlaneUnivalentCompactness)
+    (hboundary : PublishedFiniteLoewnerBoundaryExtension)
+    (hsupport : PublishedGeometricTubeSupport P γ)
+    (hplanar : PublishedPlanarDiskOpenness)
+    (hstraight : PublishedHalfPlaneCrosscutStraightening)
+    (hexit : PublishedHalfPlaneConformalExitLaw)
+    (hwiener : PublishedPlanarWienerUnitSupport)
+    (W : WienerLaw) (hW : IsWiener W) :
+    MainConclusion P (explicitGauge κ) γ :=
+  ordinary_explicit_main_of_regular_presentation P κ hκ hκ8 γ hSLE
+    (ordinaryRegularPresentation hSLE) htrace hcompact hboundary hsupport hplanar hstraight
+    hexit hwiener W hW
+
+/-- The final ordinary-SLE theorem has no auxiliary Wiener-law assumption:
+that law is constructed from the chosen regular Brownian presentation. -/
+theorem ordinary_explicit_mainConclusion_of_published_inputs
+    {Ω : Type} [MeasurableSpace Ω] (P : Measure Ω) [IsProbabilityMeasure P]
+    (κ : ℝ) (hκ : 0 < κ) (hκ8 : κ < 8)
+    (γ : Ω → ℝ≥0 → ℂ) (hSLE : IsOrdinaryChordalSLE κ γ P)
+    (htrace : PublishedTraceGeneration (ordinaryRegularDriverLaw hSLE) κ (fun t p => p t))
+    (hcompact : PublishedHalfPlaneUnivalentCompactness)
+    (hboundary : PublishedFiniteLoewnerBoundaryExtension)
+    (hsupport : PublishedGeometricTubeSupport P γ)
+    (hplanar : PublishedPlanarDiskOpenness)
+    (hstraight : PublishedHalfPlaneCrosscutStraightening)
+    (hexit : PublishedHalfPlaneConformalExitLaw)
+    (hwiener : PublishedPlanarWienerUnitSupport) :
+    MainConclusion P (explicitGauge κ) γ := by
+  let a := ordinaryRegularPresentation hSLE
+  let W : WienerLaw := (P.comap (Subtype.val : a.samples → Ω)).map
+    (sourceBasedDriverPath a.B a.continuous_B a.zero_B)
+  have hW : IsWiener W := sourceBasedDriverLaw_isWiener a.B a.brownian
+    a.measurable_B a.continuous_B a.zero_B
+  exact ordinary_explicit_mainConclusion P κ hκ hκ8 γ hSLE htrace hcompact hboundary
+    hsupport hplanar hstraight hexit hwiener W hW
+
+end SLEExactGauge
+
+end
+
+end OAI
diff --git a/lean/OAI/Probability/SLE/Geometry/ActualFiniteBoundaryExtension.lean b/lean/OAI/Probability/SLE/Geometry/ActualFiniteBoundaryExtension.lean
new file mode 100644
index 0000000000000000000000000000000000000000..32d662ecba84838bd299ea79a9594304796b557c
--- /dev/null
+++ b/lean/OAI/Probability/SLE/Geometry/ActualFiniteBoundaryExtension.lean
@@ -0,0 +1,49 @@
+import OAI.Probability.SLE.Loewner.InverseBoundaryShrink
+import OAI.Probability.SLE.Geometry.HalfPlaneBoundaryExtension
+import OAI.Probability.SLE.Geometry.PublishedFiniteBoundaryExtension
+
+namespace OAI
+
+/-! The finite boundary extension required by the SLE application,
+proved from the capacity witness. Small inverse half-disks are Cauchy;
+completeness gives the boundary limits and the existing tip limit fixes
+the extension at the driver. -/
+noncomputable section
+open Set Filter Metric Function
+open scoped Topology NNReal
+
+namespace SLEExactGauge
+
+lemma IsCapacityTwoWitness.finite_real_boundary_limit
+    {U : ℝ≥0 → ℝ} {γ : ℝ≥0 → ℂ} {G F : ℝ≥0 → ℂ → ℂ}
+    (hw : IsCapacityTwoWitness U γ G F) (t : ℝ≥0) (x : ℝ) :
+    ∃ z : ℂ, Tendsto (F t) (𝓝[upperHalfPlane] (x:ℂ)) (𝓝 z) := by
+  have hx : (x:ℂ)∈closure upperHalfPlane :=
+    closedHalfPlane_subset_closure_upperHalfPlane (by simp)
+  have : NeBot (𝓝[upperHalfPlane] (x:ℂ)) := mem_closure_iff_nhdsWithin_neBot.mp hx
+  apply cauchy_map_iff_exists_tendsto.mp
+  apply Metric.cauchy_iff.mpr
+  refine ⟨inferInstance,fun ε hε => ?_⟩
+  obtain ⟨r,hr,z,hsmall⟩ := hw.small_boundary_halfdisk t x (ε/3) (by positivity)
+  refine ⟨F t '' (upperHalfPlane∩ball (x:ℂ) r),?_,?_⟩
+  · change (F t) ⁻¹' (F t '' (upperHalfPlane∩ball (x:ℂ) r))∈𝓝[upperHalfPlane] (x:ℂ)
+    filter_upwards [self_mem_nhdsWithin,
+      mem_nhdsWithin_of_mem_nhds (ball_mem_nhds (x:ℂ) hr)] with w hwH hwr
+    exact ⟨w,⟨hwH,hwr⟩,rfl⟩
+  · rintro a ⟨u,hu,rfl⟩ b ⟨v,hv,rfl⟩
+    have hsu := hsmall u hu.1 hu.2
+    have hsv := hsmall v hv.1 hv.2
+    have htri := dist_triangle (F t u) z (F t v)
+    rw [dist_comm z (F t v)] at htri
+    linarith
+
+/-- Continuous finite boundary extension of the inverse Loewner map. -/
+theorem actual_finiteLoewnerBoundaryExtension : PublishedFiniteLoewnerBoundaryExtension := by
+  intro U γ G F _hU hw t
+  exact hw.boundary_extension_of_real_limits t (hw.finite_real_boundary_limit t)
+
+end SLEExactGauge
+
+end
+
+end OAI
diff --git a/lean/OAI/Probability/SLE/Geometry/ActualFirstHeightSupport.lean b/lean/OAI/Probability/SLE/Geometry/ActualFirstHeightSupport.lean
new file mode 100644
index 0000000000000000000000000000000000000000..8dbe0bfe3e1f361684fc5d2eaf9e00cb3728f5aa
--- /dev/null
+++ b/lean/OAI/Probability/SLE/Geometry/ActualFirstHeightSupport.lean
@@ -0,0 +1,114 @@
+import OAI.Probability.SLE.Stochastic.BrownianFiniteSmallBall
+import OAI.Probability.SLE.Loewner.SmallDriverRise
+import OAI.Probability.SLE.Geometry.FirstHeightSupport
+
+namespace OAI
+
+/-! The narrow first-height support event is proved directly from the
+Brownian driver and the deterministic Loewner equation. -/
+noncomputable section
+open Set Filter _root_.MeasureTheory _root_.OAI.MeasureTheory ProbabilityTheory
+open scoped Topology NNReal ENNReal
+
+namespace SLEExactGauge
+open FirstHeightSupport
+
+theorem regular_strip_rise_positive
+    {Ω : Type*} [MeasurableSpace Ω] {P : Measure Ω} [IsProbabilityMeasure P]
+    {κ : ℝ} {γ : Ω → ℝ≥0 → ℂ} (a : RegularSLEPresentation P κ γ)
+    (hκ : 0 < κ) {A H : ℝ} (hA : 0 < A) (hH : 0 ≤ H) :
+    0 < (P.comap (Subtype.val : a.samples → Ω))
+      {ω | ∃ T : ℝ≥0, 0 < T ∧ MapsTo (γ ω) (Icc 0 T) {z : ℂ | |z.re| < A} ∧
+        H < (γ ω T).im} := by
+  let T : ℝ≥0 := ⟨(H+1)^2,sq_nonneg _⟩
+  have hT : 0 < T := by change 0 < (H+1)^2; positivity
+  have hHT : H < 2*Real.sqrt T := by
+    change H < 2*Real.sqrt ((H+1)^2)
+    rw [Real.sqrt_sq (by linarith : 0 ≤ H+1)]
+    linarith
+  obtain ⟨δ,hδ,hrise⟩ := exists_small_driver_rise T H hH hHT
+  let ε := min δ (A/2)
+  have hε : 0 < ε := lt_min hδ (by positivity)
+  have hroot : 0 < Real.sqrt κ := Real.sqrt_pos.mpr hκ
+  have hp := brownian_finite_smallBall_positive a.B a.brownian a.measurable_B
+    a.continuous_B a.zero_B T hT (div_pos hε hroot)
+  apply hp.trans_le (measure_mono ?_)
+  intro ω hω
+  have hu (t : ℝ≥0) (ht : t ∈ Icc 0 T) : |Real.sqrt κ*a.B t ω| < ε := by
+    rw [abs_mul,abs_of_pos hroot]
+    have hh := (lt_div_iff₀ hroot).mp (hω t ht)
+    nlinarith
+  obtain ⟨τ,hτ,hhigh⟩ := hrise (fun t => Real.sqrt κ*a.B t ω) (γ ω)
+    (a.G ω) (a.F ω) (a.witness ω) (fun t ht => (hu t ht).le.trans (min_le_left _ _))
+  have hτ0 : 0 < τ := by
+    by_contra hn
+    have he : τ=0 := le_antisymm (le_of_not_gt hn) zero_le
+    rw [he,(a.witness ω).2.1,Complex.zero_im] at hhigh
+    linarith
+  refine ⟨τ,hτ0,?_,hhigh⟩
+  intro t ht
+  have hb := (a.witness ω).trace_abs_re_le t (M := ε)
+    (fun s hs => (hu s ⟨zero_le,hs.2.trans (ht.2.trans hτ.2)⟩).le)
+  change |(γ ω t).re| < A
+  exact hb.trans_lt (lt_of_le_of_lt (min_le_right _ _) (by linarith))
+
+
+theorem regular_narrowRise_positive
+    {Ω : Type*} [MeasurableSpace Ω] {P : Measure Ω} [IsProbabilityMeasure P]
+    {κ : ℝ} {γ : Ω → ℝ≥0 → ℂ} (a : RegularSLEPresentation P κ γ)
+    (hκ : 0 < κ) {B : ℝ} (hB : 0 < B) :
+    0 < (P.comap (Subtype.val : a.samples → Ω))
+      {ω | ∃ T : ℝ≥0, 0 < T ∧ MapsTo (γ ω) (Icc 0 T) (narrowStrip B) ∧
+        γ ω T ∈ aboveQuarterHeight B} :=
+  regular_strip_rise_positive a hκ (by positivity : 0 < B/16) (by positivity : 0 ≤ B/4)
+
+theorem ordinary_strip_rise_positive
+    {Ω : Type*} [MeasurableSpace Ω] (P : Measure Ω) [IsProbabilityMeasure P]
+    (κ : ℝ) (hκ : 0 < κ) (γ : Ω → ℝ≥0 → ℂ)
+    (hSLE : IsOrdinaryChordalSLE κ γ P) {A H : ℝ} (hA : 0 < A) (hH : 0 ≤ H) :
+    0 < P {ω | ∃ T : ℝ≥0, 0 < T ∧ MapsTo (γ ω) (Icc 0 T) {z : ℂ | |z.re| < A} ∧
+      H < (γ ω T).im} := by
+  obtain ⟨a⟩ := exists_regular_sle_presentation hSLE
+  have hp := regular_strip_rise_positive a hκ hA hH
+  apply hp.trans_le
+  have hh := Measure.le_map_apply (μ := P.comap (Subtype.val : a.samples → Ω))
+    a.measurePreserving_val.measurable.aemeasurable
+    {ω | ∃ T : ℝ≥0, 0 < T ∧ MapsTo (γ ω) (Icc 0 T) {z : ℂ | |z.re| < A} ∧
+      H < (γ ω T).im}
+  rw [a.measurePreserving_val.map_eq] at hh
+  convert! hh using 1
+
+theorem ordinary_narrowRise_positive
+    {Ω : Type*} [MeasurableSpace Ω] (P : Measure Ω) [IsProbabilityMeasure P]
+    (κ : ℝ) (hκ : 0 < κ) (γ : Ω → ℝ≥0 → ℂ)
+    (hSLE : IsOrdinaryChordalSLE κ γ P) {B : ℝ} (hB : 0 < B) :
+    0 < P {ω | ∃ T : ℝ≥0, 0 < T ∧ MapsTo (γ ω) (Icc 0 T) (narrowStrip B) ∧
+      γ ω T ∈ aboveQuarterHeight B} := by
+  obtain ⟨a⟩ := exists_regular_sle_presentation hSLE
+  have hp := regular_narrowRise_positive a hκ hB
+  apply hp.trans_le
+  have hh := Measure.le_map_apply (μ := P.comap (Subtype.val : a.samples → Ω))
+    a.measurePreserving_val.measurable.aemeasurable
+    {ω | ∃ T : ℝ≥0, 0 < T ∧ MapsTo (γ ω) (Icc 0 T) (narrowStrip B) ∧
+      γ ω T ∈ aboveQuarterHeight B}
+  rw [a.measurePreserving_val.map_eq] at hh
+  convert! hh using 1
+
+theorem ordinary_narrowFirstHeight_positive
+    {Ω : Type*} [MeasurableSpace Ω] (P : Measure Ω) [IsProbabilityMeasure P]
+    (κ : ℝ) (hκ : 0 < κ) (γ : Ω → ℝ≥0 → ℂ)
+    (hSLE : IsOrdinaryChordalSLE κ γ P) {B : ℝ} (hB : 0 < B) :
+    0 < P {ω | NarrowFirstHeight B (γ ω)} := by
+  obtain ⟨_,_,htrace⟩ := hSLE.2
+  apply (ordinary_narrowRise_positive P κ hκ γ hSLE hB).trans_le
+  apply measure_mono_ae
+  filter_upwards [htrace] with ω hω
+  intro hrise
+  obtain ⟨G,F,hw⟩ := hω
+  exact narrowRiseEvent_gives_first_height hB ⟨γ ω,hw.1⟩ hw.2.1 hw.2.2.1 hrise
+
+end SLEExactGauge
+
+end
+
+end OAI
diff --git a/lean/OAI/Probability/SLE/Geometry/ActualGeometricTubeSupport.lean b/lean/OAI/Probability/SLE/Geometry/ActualGeometricTubeSupport.lean
new file mode 100644
index 0000000000000000000000000000000000000000..a8befd792ed0bdf38e10055b1763d025fa3e9098
--- /dev/null
+++ b/lean/OAI/Probability/SLE/Geometry/ActualGeometricTubeSupport.lean
@@ -0,0 +1,58 @@
+import OAI.Probability.SLE.Loewner.SlitRawCapacity
+import OAI.Probability.SLE.Loewner.SlitRealCharacteristics
+import OAI.Probability.SLE.Geometry.GeometricTubeSupport
+
+namespace OAI
+
+/-! The required open-tube support follows from the actual capacity
+driver of a prescribed simple arc, finite Brownian driver tubes, and
+deterministic trace stability. No geometric support input is assumed. -/
+noncomputable section
+open Set Filter Function Complex _root_.MeasureTheory _root_.OAI.MeasureTheory ProbabilityTheory
+open scoped Topology NNReal
+
+namespace SLEExactGauge
+
+theorem ordinary_geometricTubeSupport
+    {Ω : Type*} [MeasurableSpace Ω] (P : Measure Ω) [IsProbabilityMeasure P]
+    (κ : ℝ) (hκ : 0<κ) (γ : Ω → ℝ≥0 → ℂ)
+    (hSLE : IsOrdinaryChordalSLE κ γ P) : PublishedGeometricTubeSupport P γ := by
+  obtain ⟨a⟩ := exists_regular_sle_presentation hSLE
+  intro z p hi hH N V hN hV hpN hzV
+  let c := p.toContinuousMap
+  have hc0 : c 0=0 := p.source
+  have hcH : ∀ t : unitInterval, t≠0 → c t∈upperHalfPlane := hH
+  have hcl : (1:unitInterval)∈closure (Ioo (0:unitInterval) 1) := by
+    rw [closure_Ioo (by norm_num : (0:unitInterval)≠1)]
+    simp
+  have hnear : c ⁻¹' V∈𝓝 (1:unitInterval) := c.continuous.continuousAt.preimage_mem_nhds
+    (hV.mem_nhds (by change p 1∈V; rw [p.target]; exact hzV))
+  obtain ⟨T,hTV,hT0,hT⟩ := mem_closure_iff_nhds.mp hcl (c ⁻¹' V) hnear
+  let A := slitCapacityHorizon c hi hc0 hcH T
+  let b := slitCapacityDriver c hi hc0 hcH hT
+  let β := fun t : ℝ≥0 => Target.trace 1 b t
+  have hA : 0<A := div_pos (initialCapacity_pos c hi hc0 hcH (ne_of_gt hT0)) (by norm_num)
+  have hβA : β A=c T := by
+    change Target.trace 1 (slitCapacityDriver c hi hc0 hcH hT)
+      (slitCapacityHorizon c hi hc0 hcH T)=c T
+    rw [slitCapacity_raw_trace_eq c hi hc0 hcH hT le_rfl]
+    change c (slitCapacityTime c hi hc0 hcH T A)=c T
+    rw [slitCapacityTime_after c hi hc0 hcH T le_rfl]
+  have hsub : β '' Icc 0 A ⊆ N := by
+    change (fun t : ℝ≥0 => Target.trace 1 (slitCapacityDriver c hi hc0 hcH hT) t) '' Icc 0 A ⊆ N
+    rw [slitCapacity_raw_initial_range c hi hc0 hcH hT le_rfl,
+      slitCapacityCurve_initial_range c hi hc0 hcH T le_rfl,
+      slitCapacityTime_after c hi hc0 hcH T le_rfl]
+    exact (initialSubarc_range_subset c T).trans hpN
+  have hfree := (a.slitCapacity_raw_geometry hκ c hi hc0 hcH hT0 hT).2.2.2.2 A hA
+  exact ordinary_regular_slit_tube_positive P κ hκ γ hSLE b.toContinuousMap (map_zero b)
+    (a.slit_raw_capacity_witness hκ c hi hc0 hcH hT0 hT) A hA hfree
+    (slit_regularRealCharacteristics c hi hc0 hcH hT)
+    (by change 0<(β A).im; rw [hβA]; exact hcH T (ne_of_gt hT0))
+    N V hN hV hsub (by change β A∈V; rw [hβA]; exact hTV)
+
+end SLEExactGauge
+
+end
+
+end OAI
diff --git a/lean/OAI/Probability/SLE/Geometry/ActualGuideCompactness.lean b/lean/OAI/Probability/SLE/Geometry/ActualGuideCompactness.lean
new file mode 100644
index 0000000000000000000000000000000000000000..2138968b1ca7a91b7a23cc73261a3df318d494ec
--- /dev/null
+++ b/lean/OAI/Probability/SLE/Geometry/ActualGuideCompactness.lean
@@ -0,0 +1,207 @@
+import OAI.Probability.SLE.Geometry.NormalizedAccessGuide
+import OAI.Probability.SLE.Geometry.NormalizedLoewnerCharts
+import OAI.Probability.SLE.Geometry.GuideCompactness
+
+namespace OAI
+
+/-! Joint compactness for stopped capacity charts. Freshness, physical
+clearance and a waypoint angle bound give parameter-guide compactness
+and nondegenerate limits of the normalized analytic charts. -/
+
+noncomputable section
+open Set Filter MeasureTheory Metric
+open scoped Topology NNReal
+
+namespace SLEExactGauge
+
+theorem actual_guide_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))
+    (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) : ℂ)‖) :
+    ∃ (b : ℕ → ℝ) (φ : ℕ → ℕ) (F : ℂ → ℂ) (α β : ℝ → ℂ),
+      (∀ n, 0 < b n) ∧ 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) ∧
+      β 0 = 0 ∧ ContinuousOn β (Icc 0 2) ∧ InjOn β (Icc 0 2) ∧
+      MapsTo β (Ioc 0 2) upperHalfPlane ∧ EqOn (F ∘ β) α (Ioc 0 2) := by
+  have hguide n := normalized_actual_access_guide hboundary (hw n) (hU n) (T n) (hT n)
+    (hfresh n) (αₙ n) (by norm_num : (0 : ℝ) < 2)
+    (by norm_num : (1 / 2 : ℝ) ∈ Ioc 0 2) (hαL n).continuousOn
+    (PhysicalGuideCompactness.injective_of_lower_chord_bound hc (hchord n)) (hα0 n) (hαD n)
+  choose b hb Fb βₙ hbar hext hβc hβi hβ0 hβH hbarα hβnorm hβeq using hguide
+  let Fn := fun n => normalizedInverse (F₀ n (T n)) (U n (T n)) (b n)
+  let g := fun n => normalizedForward (G n (T n)) (U n (T n)) (b n)
+  let D := fun n => survivingDomain (γₙ n) (T n)
+  have hcharts n := normalized_capacity_charts (hw n) (T n) (b n) (hb n)
+  have hFn n : DifferentiableOn ℂ (Fn n) upperHalfPlane := (hcharts n).1
+  have hiFn n : InjOn (Fn n) upperHalfPlane := (hcharts n).2.1
+  have hg n : DifferentiableOn ℂ (g n) (D n) := (hcharts n).2.2.1
+  have hig n : InjOn (g n) (D n) := (hcharts n).2.2.2.1
+  have hFD n : MapsTo (Fn n) upperHalfPlane (D n) := (hcharts n).2.2.2.2.1
+  have hgH n : MapsTo (g n) (D n) upperHalfPlane := (hcharts n).2.2.2.2.2.1
+  have hgf n : ∀ z ∈ upperHalfPlane, g n (Fn n z) = z := (hcharts n).2.2.2.2.2.2.1
+  have hrelation n t (ht : t ∈ Ioc (0 : ℝ) 2) : Fn n (βₙ n t) = αₙ n t := by
+    apply OnePoint.coe_injective
+    exact (hext n _ (hβH n ht)).symm.trans (hbarα n t ⟨ht.1.le, ht.2⟩)
+  have hβHclosed n t (ht : t ∈ Icc (0 : ℝ) 2) : 0 ≤ (βₙ n t).im := by
+    by_cases ht0 : t = 0
+    · simp only [ht0, hβ0, Complex.zero_im, le_refl]
+    · exact (show 0 < (βₙ n t).im from hβH n ⟨lt_of_le_of_ne ht.1 (Ne.symm ht0), ht.2⟩).le
+  have hway n : ‖βₙ n (1 / 2)‖ = 1 ∧ s ≤ (βₙ n (1 / 2)).im := by
+    refine ⟨hβnorm n, ?_⟩
+    have hnorm := hβnorm n
+    rw [hβeq n _ (by norm_num : (1 / 2 : ℝ) ∈ Ioc 0 2), norm_div,
+      Complex.norm_real, Real.norm_eq_abs, abs_of_pos (hb n)] at hnorm
+    have he : b n = ‖G n (T n) (αₙ n (1 / 2)) - (U n (T n) : ℂ)‖ :=
+      ((div_eq_one_iff_eq (hb n).ne').mp hnorm).symm
+    rw [hβeq n _ (by norm_num : (1 / 2 : ℝ) ∈ Ioc 0 2), Complex.div_ofReal_im, he]
+    exact hangle n
+  have homit n : γₙ n (T n) ∉ Fn n '' upperHalfPlane := by
+    rintro ⟨z, hz, he⟩
+    have hh := hFD n hz
+    rw [he] at hh
+    exact hh.1.2 ⟨T n, ⟨bot_le, le_rfl⟩, rfl⟩
+  obtain ⟨ρ, hρ, hballs⟩ := hclear (1 / 2) (by norm_num) (by norm_num)
+  have hwayclear n : ball (αₙ n (1 / 2)) ρ ⊆ D n :=
+    hballs n _ (by norm_num)
+  obtain ⟨φ, F, α, β, hφ, hF, hiF, hFne, homitlim, hFconv, hαconv, _, _,
+      _, _, _, hβlim0, hβlimc, hβlimi, hβlimH, hlimrel⟩ :=
+    GuideCompactness.exists_joint_guide_limit_of_clearance P κ hκ hκ8 γ hSLE hcompact
+      Fn g D Fb αₙ βₙ (fun n => γₙ n (T n)) C
+      (by norm_num) (by norm_num) (by norm_num) hs hρ hc hC
+      (fun n => isOpen_survivingDomain (hw n).1 _) hFn hiFn hg hig hFD hgH hgf
+      hbar hext hαL hα0 haBound hchord hβc hβ0 hβHclosed hway hwayclear homit
+      hrelation hbarα (fun n t ht => hβeq n t ht) hclear
+  exact ⟨b, φ, F, α, β, hb, hφ, hF, hiF, hFne, homitlim, hFconv, hαconv,
+    hβlim0, hβlimc, hβlimi, hβlimH, hlimrel⟩
+
+/-- The same actual compactness extraction, retaining the chosen normalized
+boundary charts and parameter-guide family. Uniform convergence of that
+family supplies the fixed positive guide-time convergence needed by early
+trace localization. -/
+theorem actual_guide_joint_compactness_with_family
+    {Ω : 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))
+    (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) : ℂ)‖) :
+    ∃ (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) := by
+  have hguide n := normalized_actual_access_guide hboundary (hw n) (hU n) (T n) (hT n)
+    (hfresh n) (αₙ n) (by norm_num : (0 : ℝ) < 2)
+    (by norm_num : (1 / 2 : ℝ) ∈ Ioc 0 2) (hαL n).continuousOn
+    (PhysicalGuideCompactness.injective_of_lower_chord_bound hc (hchord n)) (hα0 n) (hαD n)
+  choose b hb Fb βₙ hbar hext hβc hβi hβ0 hβH hbarα hβnorm hβeq using hguide
+  let Fn := fun n => normalizedInverse (F₀ n (T n)) (U n (T n)) (b n)
+  let g := fun n => normalizedForward (G n (T n)) (U n (T n)) (b n)
+  let D := fun n => survivingDomain (γₙ n) (T n)
+  have hcharts n := normalized_capacity_charts (hw n) (T n) (b n) (hb n)
+  have hFn n : DifferentiableOn ℂ (Fn n) upperHalfPlane := (hcharts n).1
+  have hiFn n : InjOn (Fn n) upperHalfPlane := (hcharts n).2.1
+  have hg n : DifferentiableOn ℂ (g n) (D n) := (hcharts n).2.2.1
+  have hig n : InjOn (g n) (D n) := (hcharts n).2.2.2.1
+  have hFD n : MapsTo (Fn n) upperHalfPlane (D n) := (hcharts n).2.2.2.2.1
+  have hgH n : MapsTo (g n) (D n) upperHalfPlane := (hcharts n).2.2.2.2.2.1
+  have hgf n : ∀ z ∈ upperHalfPlane, g n (Fn n z) = z := (hcharts n).2.2.2.2.2.2.1
+  have hrelation n t (ht : t ∈ Ioc (0 : ℝ) 2) : Fn n (βₙ n t) = αₙ n t := by
+    apply OnePoint.coe_injective
+    exact (hext n _ (hβH n ht)).symm.trans (hbarα n t ⟨ht.1.le, ht.2⟩)
+  have hβHclosed n t (ht : t ∈ Icc (0 : ℝ) 2) : 0 ≤ (βₙ n t).im := by
+    by_cases ht0 : t = 0
+    · simp only [ht0, hβ0, Complex.zero_im, le_refl]
+    · exact (show 0 < (βₙ n t).im from hβH n ⟨lt_of_le_of_ne ht.1 (Ne.symm ht0), ht.2⟩).le
+  have hway n : ‖βₙ n (1 / 2)‖ = 1 ∧ s ≤ (βₙ n (1 / 2)).im := by
+    refine ⟨hβnorm n, ?_⟩
+    have hnorm := hβnorm n
+    rw [hβeq n _ (by norm_num : (1 / 2 : ℝ) ∈ Ioc 0 2), norm_div,
+      Complex.norm_real, Real.norm_eq_abs, abs_of_pos (hb n)] at hnorm
+    have he : b n = ‖G n (T n) (αₙ n (1 / 2)) - (U n (T n) : ℂ)‖ :=
+      ((div_eq_one_iff_eq (hb n).ne').mp hnorm).symm
+    rw [hβeq n _ (by norm_num : (1 / 2 : ℝ) ∈ Ioc 0 2), Complex.div_ofReal_im, he]
+    exact hangle n
+  have homit n : γₙ n (T n) ∉ Fn n '' upperHalfPlane := by
+    rintro ⟨z, hz, he⟩
+    have hh := hFD n hz
+    rw [he] at hh
+    exact hh.1.2 ⟨T n, ⟨bot_le, le_rfl⟩, rfl⟩
+  obtain ⟨ρ, hρ, hballs⟩ := hclear (1 / 2) (by norm_num) (by norm_num)
+  have hwayclear n : ball (αₙ n (1 / 2)) ρ ⊆ D n :=
+    hballs n _ (by norm_num)
+  obtain ⟨φ, F, α, β, 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⟩ :=
+    GuideCompactness.exists_joint_guide_limit_of_clearance P κ hκ hκ8 γ hSLE hcompact
+      Fn g D Fb αₙ βₙ (fun n => γₙ n (T n)) C
+      (by norm_num) (by norm_num) (by norm_num) hs hρ hc hC
+      (fun n => isOpen_survivingDomain (hw n).1 _) hFn hiFn hg hig hFD hgH hgf
+      hbar hext hαL hα0 haBound hchord hβc hβ0 hβHclosed hway hwayclear homit
+      hrelation hbarα (fun n t ht => hβeq n t ht) hclear
+  exact ⟨b, Fb, βₙ, φ, F, α, β, hb, hbar, hext, hβc, hβ0, hβHclosed, 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⟩
+
+end SLEExactGauge
+
+end
+
+end OAI
diff --git a/lean/OAI/Probability/SLE/Geometry/ActualMarkedCell.lean b/lean/OAI/Probability/SLE/Geometry/ActualMarkedCell.lean
new file mode 100644
index 0000000000000000000000000000000000000000..1f3982155b3978a1dded5baefd228fc775b0b5e1
--- /dev/null
+++ b/lean/OAI/Probability/SLE/Geometry/ActualMarkedCell.lean
@@ -0,0 +1,60 @@
+import OAI.Probability.SLE.Mass.CellMassComparison
+
+namespace OAI
+
+/-! The actual centered argument and modulus supply the marked disk
+coordinates in the physical cell comparison. -/
+
+noncomputable section
+open Set Filter _root_.MeasureTheory _root_.OAI.MeasureTheory Metric
+open scoped Topology NNReal ENNReal
+
+namespace SLEExactGauge
+open Multipoint
+
+lemma IsCapacityTwoWitness.live_marked_polar
+    {U : ℝ≥0 → ℝ} {γ : ℝ≥0 → ℂ} {G F : ℝ≥0 → ℂ → ℂ}
+    (hw : IsCapacityTwoWitness U γ G F) (t : ℝ≥0) (z : ℂ)
+    (hz : z ∈ survivingDomain γ t) :
+    let q := G t z-(U t:ℂ)
+    0 < ‖q‖₊ ∧ q.arg ∈ Ioo (0:ℝ) Real.pi ∧
+      G t z=(U t:ℂ)+(‖q‖₊:ℂ)*Complex.exp (q.arg*Complex.I) := by
+  let q := G t z-(U t:ℂ)
+  have hq : 0 < q.im := by
+    simpa only [q,Complex.sub_im,Complex.ofReal_im,sub_zero] using hw.imag_positive t z hz
+  have hn : q ≠ 0 := by intro h; simp only [h,Complex.zero_im,lt_self_iff_false] at hq
+  refine ⟨by exact_mod_cast norm_pos_iff.mpr hn,?_,?_⟩
+  · refine ⟨lt_of_le_of_ne (Complex.arg_nonneg_iff.mpr hq.le) ?_,
+      Complex.arg_lt_pi_iff.mpr (Or.inr hq.ne')⟩
+    intro h
+    exact hq.ne' (Complex.arg_eq_zero_iff.mp h.symm).2
+  · change G t z=(U t:ℂ)+(‖q‖:ℂ)*Complex.exp (q.arg*Complex.I)
+    rw [Complex.norm_mul_exp_arg_mul_I]
+    dsimp only [q]
+    ring
+
+lemma IsCapacityTwoWitness.cell_mass_comparison_at_marked_point
+    {U : ℝ≥0 → ℝ} {γ : ℝ≥0 → ℂ} {G F : ℝ≥0 → ℂ → ℂ}
+    (hw : IsCapacityTwoWitness U γ G F) (hgrowth : PublishedDiskUnivalentGrowth)
+    (κ : ℝ) (hκ : 0 < κ) (t : ℝ≥0) (z : ℂ) (hz : z ∈ survivingDomain γ t)
+    (r : ℝ) (hr : 0 < r) (hR : fullRadius G t z=(2048*Real.pi)*r)
+    (μ : Measure upperHalfPlane) [IsFiniteMeasureOnCompacts μ] :
+    ∃ (θ : ℝ) (hθ : θ ∈ Ioo (0:ℝ) Real.pi) (a : ℝ≥0) (ha : 0 < a),
+      θ=(G t z-(U t:ℂ)).arg ∧ a=‖G t z-(U t:ℂ)‖₊ ∧
+      let ν := weightedImageMass (fun w : upperHalfPlane => F t ((w:ℂ)+(U t:ℂ)))
+        (fun w : upperHalfPlane => ENNReal.ofReal
+          (‖deriv (F t) ((w:ℂ)+(U t:ℂ))‖^dimension κ)) (dilationMass κ a ha μ)
+      let L := ENNReal.ofReal (compactWeightedMass (Target.diskMassWeight κ θ hθ)
+        (Target.diskSourceHalfPlane θ) μ)
+      ENNReal.ofReal (((128*Real.pi)*r)^dimension κ)*L ≤
+          ν (closedBall z ((4096*Real.pi)*r)) ∧
+        ∀ A : Set ℂ, A ⊆ closedBall z (2*r) →
+          ν A ≤ ENNReal.ofReal (((32768*Real.pi)*r)^dimension κ)*L := by
+  obtain ⟨ha,hθ,he⟩ := hw.live_marked_polar t z hz
+  exact ⟨_,hθ,_,ha,rfl,rfl,hw.cell_mass_comparison hgrowth κ hκ _ hθ t z hz r hr hR _ ha he μ⟩
+
+end SLEExactGauge
+
+end
+
+end OAI
diff --git a/lean/OAI/Probability/SLE/Geometry/ActualMarkedStraightening.lean b/lean/OAI/Probability/SLE/Geometry/ActualMarkedStraightening.lean
new file mode 100644
index 0000000000000000000000000000000000000000..afd4365a916773b9defbaef8327842985eb4751d
--- /dev/null
+++ b/lean/OAI/Probability/SLE/Geometry/ActualMarkedStraightening.lean
@@ -0,0 +1,74 @@
+import OAI.Probability.SLE.Geometry.CompleteAccessGuide
+
+namespace OAI
+
+/-! Straighten the actual complete marked access guide. The local chart's
+zero set is identified with the explicit physical guide, including the
+exclusion of every nonlocal guide piece. -/
+
+noncomputable section
+open Set Filter Metric
+open scoped Topology NNReal
+
+namespace SLEExactGauge
+
+/-- An actual fresh-tip guide and its local marked-point chart give a
+straightening with an exact physical zero set. -/
+theorem actual_marked_access_straightening
+    (hpublished : PublishedHalfPlaneCrosscutStraightening)
+    {U : ℝ≥0 → ℝ} {γ : ℝ≥0 → ℂ} {G F : ℝ≥0 → ℂ → ℂ}
+    (hw : IsCapacityTwoWitness U γ G F) (hU : Continuous U)
+    (T : ℝ≥0) (hT : 0 < T)
+    (hfresh : ∀ s : ℝ≥0, s < T → γ T ∈ survivingDomain γ s)
+    (α : ℝ≥0 → ℂ) (hα : Continuous α) (hiα : Function.Injective α)
+    (hα0 : α 0 = γ T) (hαD : ∀ t : ℝ≥0, 0 < t → α t ∈ survivingDomain γ T)
+    (hescape : Tendsto α atTop (cocompact ℂ))
+    (Q : ℂ ≃ₜ ℂ) (r : ℝ)
+    (hQD : MapsTo Q (ball 0 r) (survivingDomain γ T))
+    (hlocus : ∀ z ∈ ball (0 : ℂ) r,
+      (∃ t : ℝ≥0, 0 < t ∧ α t = Q z) ↔ z.im = 0) :
+    ∃ h : ℂ ≃ₜ ℂ, (∀ x : ℝ, h (x : ℂ) = (x : ℂ)) ∧
+      MapsTo h upperHalfPlane upperHalfPlane ∧
+      (∀ z ∈ survivingDomain γ T,
+        (h (G T z - (U T : ℂ))).re = 0 ↔ ∃ t : ℝ≥0, 0 < t ∧ α t = z) ∧
+      ContinuousOn (fun z => h (G T (Q z) - (U T : ℂ))) (ball 0 r) ∧
+      InjOn (fun z => h (G T (Q z) - (U T : ℂ))) (ball 0 r) ∧
+      ∀ z ∈ ball (0 : ℂ) r, (h (G T (Q z) - (U T : ℂ))).re = 0 ↔ z.im = 0 := by
+  obtain ⟨β, hc, hi, hz, hH, hproper, heq⟩ :=
+    actual_complete_access_guide hw hU T hT hfresh α hα hiα hα0 hαD hescape
+  obtain ⟨h, hreal, hhalf, hstraight⟩ := hpublished β hc hi hz hH hproper
+  have hzero (z : ℂ) (hzD : z ∈ survivingDomain γ T) :
+      (h (G T z - (U T : ℂ))).re = 0 ↔ ∃ t : ℝ≥0, 0 < t ∧ α t = z := by
+    have hzH : G T z - (U T : ℂ) ∈ upperHalfPlane := by
+      simpa only [upperHalfPlane, mem_ofPred_eq, Complex.sub_im, Complex.ofReal_im, sub_zero]
+        using hw.imag_positive T z hzD
+    rw [CrosscutSides.straightened_real_zero_iff β h hhalf hstraight hzH]
+    constructor
+    · rintro ⟨t, ht, he⟩
+      rw [heq t ht] at he
+      have hg : G T (α t) = G T z := sub_left_inj.mp he
+      refine ⟨t, ht, ?_⟩
+      calc
+        α t = F T (G T (α t)) := (hw.2.2.2.2.2.2.2.1 T _ (hαD t ht)).symm
+        _ = F T (G T z) := congrArg (F T) hg
+        _ = z := hw.2.2.2.2.2.2.2.1 T _ hzD
+    · rintro ⟨t, ht, he⟩
+      exact ⟨t, ht, by rw [heq t ht, he]⟩
+  refine ⟨h, hreal, hhalf, hzero, ?_, ?_, ?_⟩
+  · exact h.continuous.comp_continuousOn
+      (((hw.2.2.2.1 T).continuousOn.comp Q.continuous.continuousOn hQD).sub continuousOn_const)
+  · intro z hz' w hw' he
+    have hg : G T (Q z) = G T (Q w) := sub_left_inj.mp (h.injective he)
+    apply Q.injective
+    calc
+      Q z = F T (G T (Q z)) := (hw.2.2.2.2.2.2.2.1 T _ (hQD hz')).symm
+      _ = F T (G T (Q w)) := congrArg (F T) hg
+      _ = Q w := hw.2.2.2.2.2.2.2.1 T _ (hQD hw')
+  · intro z hz'
+    exact (hzero (Q z) (hQD hz')).trans (hlocus z hz')
+
+end SLEExactGauge
+
+end
+
+end OAI
diff --git a/lean/OAI/Probability/SLE/Geometry/ActualStoppedTubeSupport.lean b/lean/OAI/Probability/SLE/Geometry/ActualStoppedTubeSupport.lean
new file mode 100644
index 0000000000000000000000000000000000000000..2fbd68411aef1504f4c9919f57e1416ac24f7108
--- /dev/null
+++ b/lean/OAI/Probability/SLE/Geometry/ActualStoppedTubeSupport.lean
@@ -0,0 +1,132 @@
+import OAI.Probability.SLE.Geometry.MeasurableBoundaryRestart
+import OAI.Probability.SLE.Loewner.FreshTipMapOut
+
+namespace OAI
+
+/-! Physical open-tube support after an actual finite first-height stop.
+Simple continuation routes are mapped out by the actual Loewner chart;
+their positive fresh-law probabilities transfer through the measurable
+boundary restart, including all parameter-boundary visits. -/
+
+noncomputable section
+open Set Filter MeasureTheory ProbabilityTheory
+open scoped Topology NNReal ENNReal
+
+namespace SLEExactGauge
+
+def stoppedPhysicalTube {Ω : Type*} (γ : Ω → ℝ≥0 → ℂ) (τ : Ω → ℝ≥0)
+    (O W : Set ℂ) : Set Ω :=
+  {ω | ∃ T : ℝ≥0, 0 < T ∧ MapsTo (fun t => γ ω (τ ω + t)) (Icc 0 T) O ∧
+    γ ω (τ ω + T) ∈ W}
+
+theorem measurableSet_stoppedPhysicalTube
+    {Ω : Type*} [MeasurableSpace Ω]
+    (γ : Ω → ℝ≥0 → ℂ) (hγ : ∀ ω, Continuous (γ ω))
+    (hγm : ∀ t, Measurable (fun ω => γ ω t))
+    (τ : Ω → ℝ≥0) (hτ : Measurable τ)
+    (O W : Set ℂ) (hO : IsOpen O) (hW : IsOpen W) :
+    MeasurableSet (stoppedPhysicalTube γ τ O W) := by
+  let p (ω : Ω) : C(ℝ≥0, ℂ) :=
+    ⟨fun t => γ ω (τ ω + t), (hγ ω).comp (continuous_const.add continuous_id)⟩
+  have hj : Measurable (fun x : ℝ≥0 × Ω => γ x.2 x.1) :=
+    measurable_uncurry_of_continuous_of_measurable hγ hγm
+  have hp : Measurable p := by
+    apply ContinuousMap.measurable_iff_eval.mpr
+    intro t
+    exact hj.comp ((hτ.add_const t).prodMk measurable_id)
+  exact (measurableSet_pathTubeEvent hO hW).preimage hp
+
+theorem conditional_stopped_physical_tube_positive
+    {Ω : 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 γ)
+    (τ : Ω → ℝ≥0)
+    (hτ : IsStoppingTime (Filtration.natural B (fun t => (hm t).stronglyMeasurable))
+      (fun ω => (τ ω : WithTop ℝ≥0)))
+    (O W : Set ℂ) (hO : IsOpen O) (hW : IsOpen W) (E : Set Ω)
+    (hfresh : ∀ ω ∈ E, 0 < τ ω ∧ 0 < (γ ω (τ ω)).im ∧
+      ∀ u : ℝ≥0, u < τ ω → (γ ω u).im < (γ ω (τ ω)).im)
+    (hroutes : ∀ ω ∈ E, ∃ w : ℂ, ∃ p : Path (γ ω (τ ω)) w,
+      Function.Injective p ∧
+      (∀ t, t ≠ 0 → p t ∈ survivingDomain (γ ω) (τ ω)) ∧
+      range p ⊆ O ∧ w ∈ W) :
+    ∀ᵐ ω ∂P, ω ∈ E →
+      0 < P⁻[(stoppedPhysicalTube γ τ O W).indicator (fun _ => 1) |
+        hτ.measurableSpace] ω := by
+  let : IsProbabilityMeasure P := hB.isGaussianProcess.isProbabilityMeasure
+  obtain ⟨Φ, Fb, hΦm, hΦ, hFbm, hFb, hFb0, hlaw, hfull⟩ :=
+    source_measurable_boundary_restart κ hκ hκ8 B hB hm hc γ G F hw hboundary τ hτ
+  let gp := sourceTracePath γ (fun ω => (hw ω).1)
+  let Y := fun ω => Φ (sourceRestartDriverPath B hc τ ω)
+  have hgm : Measurable gp := by
+    have he : gp = Φ ∘ sourceDriverPath B hc := funext fun ω => (hΦ ω).symm
+    rw [he]
+    exact hΦm.comp (source_path_measurable (sourceDriverPath B hc) hm)
+  have hYm : Measurable Y := hΦm.comp (source_path_measurable _ (fun t =>
+    (measurable_pi_apply t).comp (brownianRestart_measurable hm hc
+      (stopping_time_measurable_nnreal hτ))))
+  let O' : Set (OnePoint ℂ) := ((↑) : ℂ → OnePoint ℂ) '' O
+  let W' : Set (OnePoint ℂ) := ((↑) : ℂ → OnePoint ℂ) '' W
+  have hO' : IsOpen O' := OnePoint.isOpenEmbedding_coe.isOpenMap _ hO
+  have hW' : IsOpen W' := OnePoint.isOpenEmbedding_coe.isOpenMap _ hW
+  have hgeometry : ∀ ω ∈ E, ∃ z : ℂ, ∃ p : Path (0 : ℂ) z,
+      Function.Injective p ∧
+      ∃ hpH : ∀ t, t ≠ 0 → p t ∈ upperHalfPlane,
+        (∀ t, Fb ω ⟨p t, by
+          by_cases ht : t = 0
+          · simp [ht, closedHalfPlane]
+          · exact (show 0 < (p t).im from hpH t ht).le⟩ ∈ O') ∧
+        Fb ω ⟨z, by simpa using
+          (show 0 < (p 1).im from hpH 1 (by norm_num)).le⟩ ∈ W' := by
+    intro ω hω
+    obtain ⟨hτpos, hheight, hfirst⟩ := hfresh ω hω
+    obtain ⟨w, p, hp, hpD, hpO, hwW⟩ := hroutes ω hω
+    obtain ⟨q, hq, hqH, hqback⟩ := (hw ω).map_out_access_at_first_height
+      (continuous_const.mul (hc ω)) (τ ω) hτpos hheight hfirst w p hp hpD
+    refine ⟨_, q, hq, hqH, ?_, ?_⟩
+    · intro t
+      by_cases ht : t = 0
+      · subst t
+        simpa only [Path.source, hFb0] using
+          (mem_image_of_mem ((↑) : ℂ → OnePoint ℂ) (hpO (mem_range_self 0)))
+      · rw [hFb ω _ (hqH t ht), hqback t ht]
+        exact mem_image_of_mem ((↑) : ℂ → OnePoint ℂ) (hpO (mem_range_self t))
+    · rw [hFb ω _ (by simpa only [Path.target] using hqH 1 (by norm_num))]
+      have he := hqback 1 (by norm_num)
+      simp only [Path.target] at he
+      rw [he]
+      exact mem_image_of_mem ((↑) : ℂ → OnePoint ℂ) hwW
+  have hpositive := conditional_random_boundary_tube_positive P
+    hτ.measurableSpace hτ.measurableSpace_le Y gp hYm hgm hlaw
+    (fun ω => (hw ω).2.2.1) hsupport Fb hFbm O' W' hO' hW' E hgeometry
+  let C : Set Ω := {ω | (Fb ω).comp (liftClosedPath (Y ω)) ∈ pathTubeEventIn O' W'}
+  have hsubset : ∀ᵐ ω ∂P, ω ∈ C → ω ∈ stoppedPhysicalTube γ τ O W := by
+    filter_upwards [hfull] with ω hω hC
+    obtain ⟨T, hT, htrace, hend⟩ := hC
+    have hmap (t : ℝ≥0) {S : Set ℂ}
+        (ht : Fb ω (liftClosedPath (Y ω) t) ∈ ((↑) : ℂ → OnePoint ℂ) '' S) :
+        γ ω (τ ω + t) ∈ S := by
+      obtain ⟨z, hz, he⟩ := ht
+      have he' : z = γ ω (τ ω + t) := OnePoint.coe_injective (he.trans (hω t).symm)
+      exact he' ▸ hz
+    exact ⟨T, hT, fun t ht => hmap t (htrace ht), hmap T hend⟩
+  have hmono : C.indicator (fun _ => (1 : ℝ≥0∞)) ≤ᵐ[P]
+      (stoppedPhysicalTube γ τ O W).indicator (fun _ => 1) := by
+    filter_upwards [hsubset] with ω hω
+    by_cases hC : ω ∈ C
+    · simp only [indicator_of_mem hC, indicator_of_mem (hω hC), le_refl]
+    · simp only [indicator_of_notMem hC, zero_le]
+  filter_upwards [hpositive, condLExp_mono (mΩ := hτ.measurableSpace) hmono] with ω hp hm hω
+  exact (hp hω).trans_le hm
+
+end SLEExactGauge
+
+end
+
+end OAI
diff --git a/lean/OAI/Probability/SLE/Geometry/ActualWaypointAngle.lean b/lean/OAI/Probability/SLE/Geometry/ActualWaypointAngle.lean
new file mode 100644
index 0000000000000000000000000000000000000000..f81aff96de6524cfe40c42d22f69cf50ad7ff858
--- /dev/null
+++ b/lean/OAI/Probability/SLE/Geometry/ActualWaypointAngle.lean
@@ -0,0 +1,95 @@
+import OAI.Probability.SLE.Geometry.ActualWaypointStraightening
+import OAI.Probability.SLE.Mass.WaypointHarmonicMeasure
+import OAI.Probability.SLE.Geometry.NormalizedLoewnerCharts
+
+namespace OAI
+
+/-! The actual uniform ribbon waypoint angle.  Uniform Brownian route
+support, crosscut topology, and conformal Brownian exit bounds are the
+published inputs.  The positive ribbon angle is derived here. -/
+
+noncomputable section
+open Set Filter MeasureTheory Metric
+open scoped Topology NNReal ENNReal
+
+namespace SLEExactGauge.RibbonCoordinates
+open Target CrosscutSides
+
+theorem uniform_actual_ribbon_waypoint_angle
+    (hopen : PublishedPlanarDiskOpenness)
+    (hstraight : PublishedHalfPlaneCrosscutStraightening)
+    (hexit : PublishedHalfPlaneConformalExitLaw)
+    (hsupport : PublishedPlanarWienerUnitSupport)
+    (W : WienerLaw) (hW : IsWiener W)
+    (C K : ℝ≥0) (hK : 0 < (K : ℝ)) :
+    ∃ s : ℝ, 0 < s ∧ ∀ (U : ℝ≥0 → ℝ) (γ : ℝ≥0 → ℂ)
+      (G F : ℝ≥0 → ℂ → ℂ), IsCapacityTwoWitness U γ G F → Continuous U →
+      ∀ (P : ℂ → ℂ), ContinuousOn P closedRibbon → InjOn P closedRibbon →
+      (∀ z ∈ closedRibbon, 0 < z.re → P z ∈ upperHalfPlane) →
+      Tendsto (fun t : ℝ => ‖P (t : ℂ)‖) atTop atTop →
+      ∀ (k ε x : ℝ), 1 ≤ k → 0 < ε → ε ≤ 1 / 8 → |x| ≤ 1 / 16 →
+      LipschitzOnWith C P (crossingPatch k) →
+      (∀ u ∈ crossingPatch k, ∀ v ∈ crossingPatch k,
+        dist u v ≤ K * dist (P u) (P v)) →
+      ∀ (xp : ℝ≥0 → ℂ) (T : ℝ≥0), 0 < T → ContinuousOn xp (Icc 0 T) →
+      EqOn γ (P ∘ xp) (Icc 0 T) → (xp 0).re = 0 →
+      xp T = (k : ℂ) + (x : ℂ) * Complex.I →
+      MapsTo xp (Icc 0 T) closedRibbon →
+      (∀ t ∈ Icc 0 T, (xp t).re ≤ k ∧ |(xp t).im| ≤ ε) →
+      (∀ t : ℝ≥0, t < T → (xp t).re < k) →
+      s ≤ (G T (P ((k + 1 / 2 : ℝ) : ℂ)) - (U T : ℂ)).im /
+        ‖G T (P ((k + 1 / 2 : ℝ) : ℂ)) - (U T : ℂ)‖ := by
+  let : IsProbabilityMeasure W := hW.isGaussianProcess.isProbabilityMeasure
+  obtain ⟨q, hq, hprob⟩ := uniform_physical_waypoint_tube_probability
+    hsupport W hW C (div_pos (by norm_num : (0 : ℝ) < 1 / 32) hK)
+  have hqfin : q ≠ ⊤ := by
+    have hb := hprob (fun _ => (0 : ℂ)) 1 1 (by norm_num)
+      ((LipschitzWith.const (0 : ℂ)).weaken (show (0 : ℝ≥0) ≤ C from bot_le)).lipschitzOnWith
+    exact ne_top_of_le_ne_top (measure_ne_top _ _) hb
+  have hqreal : 0 < q.toReal := ENNReal.toReal_pos hq.ne' hqfin
+  refine ⟨2 * q.toReal, by positivity, ?_⟩
+  intro U γ G F hw hU P hP hiP hH hescape k ε x hk hε hεsmall hx hupper hlower
+    xp T hT hxp hγ hxp0 htip hcoords hcore hfront
+  have htipre : (xp T).re = k := by simp [htip]
+  have htipim : (xp T).im = x := by simp [htip]
+  have hxquarter : |x| ≤ 1 / 4 := hx.trans (by norm_num)
+  have hfresh := ribbon_front_tip_survives_prior P hP hiP 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))
+  have hpast : γ '' Icc 0 T ⊆ P '' {z ∈ closedRibbon | z.re ≤ k} := by
+    rintro z ⟨t, ht, rfl⟩
+    exact ⟨xp t, ⟨hcoords ht, (hcore t ht).1⟩, (hγ ht).symm⟩
+  have hunbounded := futureRibbon_unbounded_of_centerline_escape P k hescape
+  have hfuture : P '' futureRibbon k ⊆ survivingDomain γ T :=
+    futureRibbon_survives P hP hiP (by linarith) hH γ T hpast hunbounded
+  have hphysicalTip : P ((k : ℂ) + (x : ℂ) * Complex.I) = γ T := by
+    rw [← htip]
+    exact (hγ ⟨bot_le, le_rfl⟩).symm
+  obtain ⟨h, hreal, _, hcut, hloc, hloci, hlocz⟩ :=
+    actual_ribbon_waypoint_straightening hstraight hw hU T hT hfresh P hP hiP
+      (by linarith) hxquarter hphysicalTip hfuture hescape
+  let g := fun z => G T z - (U T : ℂ)
+  let f := fun z => F T ((U T : ℂ) + z)
+  have hcharts := normalized_capacity_charts hw T 1 (by norm_num)
+  have hgeq : normalizedForward (G T) (U T) 1 = g := by
+    funext z
+    simp [normalizedForward, g]
+  have hfeq : normalizedInverse (F T) (U T) 1 = f := by
+    funext z
+    simp [normalizedInverse, f]
+  rw [hgeq, hfeq] at hcharts
+  obtain ⟨hf, _, hg, _, hfD, hgH, hgf, hfg⟩ := hcharts
+  obtain ⟨hl, hr⟩ := ribbon_tube_harmonic_bounds hopen hexit W hW K hK P hP hiP hH
+    hk hε hεsmall hx hlower γ xp hw.1 T hT hxp hγ hxp0 htipre hcoords hcore hunbounded
+    g f hg hf hgH hfD hfg hgf h hreal hcut hloc hloci hlocz q
+    (fun side hs => hprob P k side (by rcases hs with rfl | rfl <;> norm_num) hupper)
+  have hwD : P ((k + 1 / 2 : ℝ) : ℂ) ∈ survivingDomain γ T := by
+    apply hfuture
+    exact ⟨((k + 1 / 2 : ℝ) : ℂ), ⟨by simp, by simp⟩, rfl⟩
+  exact (positive_angle_of_two_exit_probability_bounds hq (hgH hwD) hl hr).2
+
+end SLEExactGauge.RibbonCoordinates
+
+end
+
+end OAI
diff --git a/lean/OAI/Probability/SLE/Geometry/ActualWaypointStraightening.lean b/lean/OAI/Probability/SLE/Geometry/ActualWaypointStraightening.lean
new file mode 100644
index 0000000000000000000000000000000000000000..dd5784b46c517a0b761855f09b2c17fb9d6d991e
--- /dev/null
+++ b/lean/OAI/Probability/SLE/Geometry/ActualWaypointStraightening.lean
@@ -0,0 +1,253 @@
+import OAI.Probability.SLE.Geometry.CompleteAccessGuide
+import OAI.Probability.SLE.Geometry.WaypointCrosscutSides
+
+namespace OAI
+
+/-! The local straightening hypotheses at the actual ribbon waypoint.
+The complete access guide and the inverse identities exclude nonlocal
+pieces of the guide from the waypoint disk. -/
+
+noncomputable section
+open Set Filter Metric
+open scoped Topology NNReal
+
+namespace SLEExactGauge.RibbonCoordinates
+
+theorem waypoint_ball_coordinates {k : ℝ} {z : ℂ}
+    (hz : z ∈ ball ((k + 1 / 2 : ℝ) : ℂ) (1 / 4)) :
+    k + 1 / 4 < z.re ∧ z.re < k + 3 / 4 ∧ |z.im| < 1 / 4 := by
+  have hd : ‖z - ((k + 1 / 2 : ℝ) : ℂ)‖ < 1 / 4 := by
+    simpa only [mem_ball, dist_eq_norm] using hz
+  have hr := (Complex.abs_re_le_norm (z - ((k + 1 / 2 : ℝ) : ℂ))).trans_lt hd
+  have hi := (Complex.abs_im_le_norm (z - ((k + 1 / 2 : ℝ) : ℂ))).trans_lt hd
+  simp only [Complex.sub_re, Complex.ofReal_re] at hr
+  simp only [Complex.sub_im, Complex.ofReal_im, sub_zero] at hi
+  exact ⟨by linarith [(abs_lt.mp hr).1], by linarith [(abs_lt.mp hr).2], hi⟩
+
+theorem guideCoordinate_mem_future {k x : ℝ} (hx : |x| ≤ 1 / 4)
+    {t : ℝ} (ht : 0 < t) : guideCoordinate k x t ∈ futureRibbon k := by
+  exact ⟨by simp only [guideCoordinate_re]; linarith,
+    (guideCoordinate_im_bound ht.le).trans_lt (hx.trans_lt (by norm_num))⟩
+
+/-- The complete straightening detects the whole physical access guide,
+including points far outside the local coordinate disk. -/
+theorem actual_straightened_zero_lies_on_guide
+    {U : ℝ≥0 → ℝ} {γ : ℝ≥0 → ℂ} {G F : ℝ≥0 → ℂ → ℂ}
+    (hw : IsCapacityTwoWitness U γ G F) (T : ℝ≥0)
+    (P : ℂ → ℂ) {k x : ℝ} (hx : |x| ≤ 1 / 4)
+    (hfuture : P '' futureRibbon k ⊆ survivingDomain γ T)
+    (β : ℝ≥0 → ℂ)
+    (hβ : ∀ t : ℝ≥0, 0 < t →
+      β t = G T (P (guideCoordinate k x t)) - (U T : ℂ))
+    (h : ℂ ≃ₜ ℂ) (hH : MapsTo h upperHalfPlane upperHalfPlane)
+    (hstraight : ∀ t : ℝ≥0, h (β t) = (t : ℂ) * Complex.I)
+    {z : ℂ} (hz : z ∈ survivingDomain γ T)
+    (hzero : (h (G T z - (U T : ℂ))).re = 0) :
+    ∃ t : ℝ, 0 < t ∧ P (guideCoordinate k x t) = z := by
+  have hzH : G T z - (U T : ℂ) ∈ upperHalfPlane := by
+    simpa only [upperHalfPlane, mem_ofPred_eq, Complex.sub_im, Complex.ofReal_im,
+      sub_zero] using hw.imag_positive T z hz
+  obtain ⟨t, ht, he⟩ :=
+    (CrosscutSides.straightened_real_zero_iff β h hH hstraight hzH).mp hzero
+  have hD := hfuture (mem_image_of_mem P (guideCoordinate_mem_future hx (by exact_mod_cast ht)))
+  have hg : G T (P (guideCoordinate k x t)) = G T z := by
+    rw [hβ t ht] at he
+    exact sub_left_inj.mp he
+  refine ⟨t, by exact_mod_cast ht, ?_⟩
+  calc
+    P (guideCoordinate k x t) = F T (G T (P (guideCoordinate k x t))) :=
+      (hw.2.2.2.2.2.2.2.1 T _ hD).symm
+    _ = F T (G T z) := congrArg (F T) hg
+    _ = z := hw.2.2.2.2.2.2.2.1 T z hz
+
+theorem actual_waypoint_chart
+    {U : ℝ≥0 → ℝ} {γ : ℝ≥0 → ℂ} {G F : ℝ≥0 → ℂ → ℂ}
+    (hw : IsCapacityTwoWitness U γ G F) (T : ℝ≥0)
+    (P : ℂ → ℂ) (hP : ContinuousOn P closedRibbon) (hiP : InjOn P closedRibbon)
+    {k x : ℝ} (hk : 0 ≤ k) (hx : |x| ≤ 1 / 4)
+    (hfuture : P '' futureRibbon k ⊆ survivingDomain γ T)
+    (β : ℝ≥0 → ℂ)
+    (hβ : ∀ t : ℝ≥0, 0 < t →
+      β t = G T (P (guideCoordinate k x t)) - (U T : ℂ))
+    (h : ℂ ≃ₜ ℂ) (hH : MapsTo h upperHalfPlane upperHalfPlane)
+    (hstraight : ∀ t : ℝ≥0, h (β t) = (t : ℂ) * Complex.I) :
+    let f := fun z => h (G T (P z) - (U T : ℂ))
+    ContinuousOn f (ball ((k + 1 / 2 : ℝ) : ℂ) (1 / 4)) ∧
+      InjOn f (ball ((k + 1 / 2 : ℝ) : ℂ) (1 / 4)) ∧
+      ∀ z ∈ ball ((k + 1 / 2 : ℝ) : ℂ) (1 / 4), (f z).re = 0 ↔ z.im = 0 := by
+  dsimp only
+  let B := ball ((k + 1 / 2 : ℝ) : ℂ) (1 / 4)
+  have hBF : B ⊆ futureRibbon k := by
+    intro z hz
+    obtain ⟨hr, _, him⟩ := waypoint_ball_coordinates hz
+    exact ⟨by linarith, him.trans (by norm_num)⟩
+  have hBC := hBF.trans (futureRibbon_subset_closedRibbon hk)
+  have hBD : MapsTo P B (survivingDomain γ T) := by
+    intro z hz
+    exact hfuture (mem_image_of_mem P (hBF hz))
+  have hclosed (t : ℝ≥0) (ht : 0 < t) :
+      guideCoordinate k x t ∈ closedRibbon :=
+    futureRibbon_subset_closedRibbon hk (guideCoordinate_mem_future hx (by exact_mod_cast ht))
+  have hD (t : ℝ≥0) (ht : 0 < t) :
+      P (guideCoordinate k x t) ∈ survivingDomain γ T :=
+    hfuture (mem_image_of_mem P (guideCoordinate_mem_future hx (by exact_mod_cast ht)))
+  have hgInj : InjOn (G T) (survivingDomain γ T) := by
+    intro z hz w hw' he
+    calc
+      z = F T (G T z) := (hw.2.2.2.2.2.2.2.1 T z hz).symm
+      _ = F T (G T w) := congrArg (F T) he
+      _ = w := hw.2.2.2.2.2.2.2.1 T w hw'
+  refine ⟨h.continuous.continuousOn.comp
+    (((hw.2.2.2.1 T).continuousOn.comp (hP.mono hBC) hBD).sub continuousOn_const)
+    (fun _ _ => mem_univ _), ?_, ?_⟩
+  · intro z hz w hw' he
+    exact hiP (hBC hz) (hBC hw')
+      (hgInj (hBD hz) (hBD hw') (sub_left_inj.mp (h.injective he)))
+  · intro z hz
+    have hzH : G T (P z) - (U T : ℂ) ∈ upperHalfPlane := by
+      simpa only [upperHalfPlane, mem_ofPred_eq, Complex.sub_im, Complex.ofReal_im,
+        sub_zero] using hw.imag_positive T (P z) (hBD hz)
+    rw [CrosscutSides.straightened_real_zero_iff β h hH hstraight hzH]
+    constructor
+    · rintro ⟨t, ht, he⟩
+      rw [hβ t ht] at he
+      have hcoord : guideCoordinate k x t = z :=
+        hiP (hclosed t ht) (hBC hz) (hgInj (hD t ht) (hBD hz) (sub_left_inj.mp he))
+      have hre := congrArg Complex.re hcoord
+      simp only [guideCoordinate_re] at hre
+      have htquarter : 1 / 4 < (t : ℝ) := by
+        linarith [(waypoint_ball_coordinates hz).1]
+      rw [← hcoord, guideCoordinate_im, max_eq_right (by linarith), mul_zero]
+    · intro him
+      let t : ℝ≥0 := ⟨z.re - k, by linarith [(waypoint_ball_coordinates hz).1]⟩
+      have ht : 0 < t := by
+        change 0 < z.re - k
+        linarith [(waypoint_ball_coordinates hz).1]
+      have he : guideCoordinate k x t = z := by
+        apply Complex.ext
+        · rw [guideCoordinate_re]
+          change k + (z.re - k) = z.re
+          ring
+        · rw [guideCoordinate_im, max_eq_right, mul_zero, him]
+          change 1 - 4 * (z.re - k) ≤ 0
+          linarith [(waypoint_ball_coordinates hz).1]
+      exact ⟨t, ht, by rw [hβ t ht, he]⟩
+
+/-- The actual complete physical guide is proper because its tail is the
+centerline; no compactness or properness of a parameter guide is assumed. -/
+theorem actual_ribbon_complete_guide
+    {U : ℝ≥0 → ℝ} {γ : ℝ≥0 → ℂ} {G F : ℝ≥0 → ℂ → ℂ}
+    (hw : IsCapacityTwoWitness U γ G F) (hU : Continuous U)
+    (T : ℝ≥0) (hT : 0 < T)
+    (hfresh : ∀ s : ℝ≥0, s < T → γ T ∈ survivingDomain γ s)
+    (P : ℂ → ℂ) (hP : ContinuousOn P closedRibbon) (hiP : InjOn P closedRibbon)
+    {k x : ℝ} (hk : 0 ≤ k) (hx : |x| ≤ 1 / 4)
+    (htip : P ((k : ℂ) + (x : ℂ) * Complex.I) = γ T)
+    (hfuture : P '' futureRibbon k ⊆ survivingDomain γ T)
+    (hescape : Tendsto (fun s : ℝ => ‖P (s : ℂ)‖) atTop atTop) :
+    ∃ β : ℝ≥0 → ℂ, Continuous β ∧ Function.Injective β ∧ β 0 = 0 ∧
+      (∀ t : ℝ≥0, 0 < t → β t ∈ upperHalfPlane) ∧
+      Tendsto β atTop (cocompact ℂ) ∧
+      ∀ t : ℝ≥0, 0 < t → β t = G T (P (guideCoordinate k x t)) - (U T : ℂ) := by
+  let α : ℝ≥0 → ℂ := fun t => P (guideCoordinate k x t)
+  have hgc (t : ℝ≥0) : guideCoordinate k x t ∈ closedRibbon := by
+    exact ⟨by simp only [guideCoordinate_re]; positivity,
+      (guideCoordinate_im_bound t.coe_nonneg).trans (hx.trans (by norm_num))⟩
+  have hα : Continuous α :=
+    hP.comp_continuous ((guideCoordinate_continuous k x).comp NNReal.continuous_coe)
+      hgc
+  have hiα : Function.Injective α := by
+    intro s t he
+    have hh := congrArg Complex.re (hiP (hgc s) (hgc t) he)
+    simp only [guideCoordinate_re] at hh
+    apply NNReal.eq
+    linarith
+  have hα0 : α 0 = γ T := by simpa only [α, NNReal.coe_zero, guideCoordinate_zero] using htip
+  have hαD (t : ℝ≥0) (ht : 0 < t) : α t ∈ survivingDomain γ T :=
+    hfuture (mem_image_of_mem P (guideCoordinate_mem_future hx (by exact_mod_cast ht)))
+  have htend : Tendsto (fun t : ℝ≥0 => k + (t : ℝ)) atTop atTop :=
+    tendsto_atTop_add_const_left _ k (NNReal.tendsto_coe_atTop.mpr tendsto_id)
+  have hnorm : Tendsto (fun t => ‖α t‖) atTop atTop := by
+    apply (hescape.comp htend).congr'
+    filter_upwards [(NNReal.tendsto_coe_atTop.mpr tendsto_id).eventually_ge_atTop
+      (1 / 4 : ℝ)] with t ht
+    simp only [id_eq] at ht
+    change ‖P ((k + (t : ℝ) : ℝ) : ℂ)‖ = ‖P (guideCoordinate k x t)‖
+    apply congrArg (fun z : ℂ => ‖P z‖)
+    apply Complex.ext
+    · simp [guideCoordinate]
+    · simp only [guideCoordinate_im, Complex.ofReal_im]
+      rw [max_eq_right (by linarith), mul_zero]
+  have hproper : Tendsto α atTop (cocompact ℂ) := by
+    apply tendsto_cocompact_of_tendsto_dist_comp_atTop 0
+    simpa only [dist_zero_right] using hnorm
+  exact actual_complete_access_guide hw hU T hT hfresh α hα hiα hα0 hαD hproper
+
+theorem actual_ribbon_waypoint_straightening
+    (hpublished : PublishedHalfPlaneCrosscutStraightening)
+    {U : ℝ≥0 → ℝ} {γ : ℝ≥0 → ℂ} {G F : ℝ≥0 → ℂ → ℂ}
+    (hw : IsCapacityTwoWitness U γ G F) (hU : Continuous U)
+    (T : ℝ≥0) (hT : 0 < T)
+    (hfresh : ∀ s : ℝ≥0, s < T → γ T ∈ survivingDomain γ s)
+    (P : ℂ → ℂ) (hP : ContinuousOn P closedRibbon) (hiP : InjOn P closedRibbon)
+    {k x : ℝ} (hk : 0 ≤ k) (hx : |x| ≤ 1 / 4)
+    (htip : P ((k : ℂ) + (x : ℂ) * Complex.I) = γ T)
+    (hfuture : P '' futureRibbon k ⊆ survivingDomain γ T)
+    (hescape : Tendsto (fun s : ℝ => ‖P (s : ℂ)‖) atTop atTop) :
+    ∃ h : ℂ ≃ₜ ℂ, (∀ y : ℝ, h (y : ℂ) = (y : ℂ)) ∧
+      MapsTo h upperHalfPlane upperHalfPlane ∧
+      (∀ z ∈ survivingDomain γ T, (h (G T z - (U T : ℂ))).re = 0 →
+        ∃ u : ℝ, 0 ≤ u ∧ P (guideCoordinate k x u) = z) ∧
+      let f := fun z => h (G T (P z) - (U T : ℂ))
+      ContinuousOn f (ball ((k + 1 / 2 : ℝ) : ℂ) (1 / 4)) ∧
+        InjOn f (ball ((k + 1 / 2 : ℝ) : ℂ) (1 / 4)) ∧
+        ∀ z ∈ ball ((k + 1 / 2 : ℝ) : ℂ) (1 / 4), (f z).re = 0 ↔ z.im = 0 := by
+  obtain ⟨β, hc, hi, hz, hH, hproper, heq⟩ :=
+    actual_ribbon_complete_guide hw hU T hT hfresh P hP hiP hk hx htip hfuture hescape
+  obtain ⟨h, hreal, hhalf, hstraight⟩ := hpublished β hc hi hz hH hproper
+  refine ⟨h, hreal, hhalf, ?_, actual_waypoint_chart hw T P hP hiP hk hx hfuture β
+    heq h hhalf hstraight⟩
+  intro z hz hzero
+  obtain ⟨u, hu, he⟩ := actual_straightened_zero_lies_on_guide hw T P hx hfuture
+    β heq h hhalf hstraight hz hzero
+  exact ⟨u, hu.le, he⟩
+
+/-- Actual physical waypoint neighborhoods lie on opposite sides of the
+complete stopped access guide. The orientation is selected by the local
+chart and is shared by the whole pair of neighborhoods. -/
+theorem actual_physical_waypoint_tubes_opposite_sides
+    (hpublished : PublishedHalfPlaneCrosscutStraightening)
+    (hopen : PublishedPlanarDiskOpenness)
+    {U : ℝ≥0 → ℝ} {γ : ℝ≥0 → ℂ} {G F : ℝ≥0 → ℂ → ℂ}
+    (hw : IsCapacityTwoWitness U γ G F) (hU : Continuous U)
+    (T : ℝ≥0) (hT : 0 < T)
+    (hfresh : ∀ s : ℝ≥0, s < T → γ T ∈ survivingDomain γ s)
+    (P : ℂ → ℂ) (hP : ContinuousOn P closedRibbon) (hiP : InjOn P closedRibbon)
+    {k x : ℝ} (hk : 1 ≤ k) (hx : |x| ≤ 1 / 4)
+    (htip : P ((k : ℂ) + (x : ℂ) * Complex.I) = γ T)
+    (hfuture : P '' futureRibbon k ⊆ survivingDomain γ T)
+    (hescape : Tendsto (fun s : ℝ => ‖P (s : ℂ)‖) atTop atTop)
+    (K : ℝ≥0) (hK : 0 < (K : ℝ))
+    (hlower : ∀ v ∈ crossingPatch k, ∀ w ∈ crossingPatch k,
+      dist v w ≤ K * dist (P v) (P w)) :
+    ∃ (h : ℂ ≃ₜ ℂ) (side : ℝ),
+      (∀ y : ℝ, h (y : ℂ) = (y : ℂ)) ∧
+      MapsTo h upperHalfPlane upperHalfPlane ∧
+      (side = -1 ∨ side = 1) ∧
+      (∀ y : ℂ, dist y (P (waypointRoute k side (1 / 4))) < (1 / 32 : ℝ) / K →
+        0 < (h (G T y - (U T : ℂ))).re) ∧
+      (∀ y : ℂ, dist y (P (waypointRoute k (-side) (1 / 4))) < (1 / 32 : ℝ) / K →
+        (h (G T y - (U T : ℂ))).re < 0) := by
+  obtain ⟨h, hreal, hH, _, hc, hi, hzero⟩ := actual_ribbon_waypoint_straightening
+    hpublished hw hU T hT hfresh P hP hiP (by linarith) hx htip hfuture hescape
+  obtain ⟨side, hs, hp, hn⟩ := physical_waypoint_tubes_opposite_sides
+    hopen P hP hiP K hK hk hlower
+    (fun z => h (G T (P z) - (U T : ℂ)))
+    (fun y => (h (G T y - (U T : ℂ))).re) hc hi hzero (fun _ _ => rfl)
+  exact ⟨h, side, hreal, hH, hs, hp, hn⟩
+
+end SLEExactGauge.RibbonCoordinates
+
+end
+
+end OAI
diff --git a/lean/OAI/Probability/SLE/Geometry/ActualWienerSupport.lean b/lean/OAI/Probability/SLE/Geometry/ActualWienerSupport.lean
new file mode 100644
index 0000000000000000000000000000000000000000..a616317bc139795cec68b5b47983b971100b3d3c
--- /dev/null
+++ b/lean/OAI/Probability/SLE/Geometry/ActualWienerSupport.lean
@@ -0,0 +1,62 @@
+import OAI.Probability.SLE.Stochastic.WienerRealSupport
+
+namespace OAI
+
+/-! Finite-window planar Wiener support from finite Gaussian increments,
+independent interpolation residuals, and uniform continuity. -/
+noncomputable section
+open Set Filter MeasureTheory ProbabilityTheory Metric
+open scoped Topology NNReal ENNReal
+
+namespace SLEExactGauge
+
+def wienerUnitClamp (s : ℝ≥0) : unitInterval :=
+  ⟨min (s:ℝ) 1,le_min s.2 zero_le_one,min_le_right _ _⟩
+
+lemma continuous_wienerUnitClamp : Continuous wienerUnitClamp := by
+  unfold wienerUnitClamp
+  fun_prop
+
+@[simp] lemma wienerUnitClamp_unit (t : unitInterval) :
+    wienerUnitClamp ⟨t,t.2.1⟩ = t := by
+  apply Subtype.ext
+  exact min_eq_left t.2.2
+
+@[simp] lemma wienerUnitClamp_zero : wienerUnitClamp 0=0 := by
+  apply Subtype.ext
+  simp [wienerUnitClamp]
+
+/-- The planar Wiener law gives positive probability to each uniform tube
+about a continuous based path, as in Millet--Sanz-Sole (1994), Theorem 3.5. -/
+theorem actual_planarWienerUnitSupport : PublishedPlanarWienerUnitSupport := by
+  intro W hW f hf r hr
+  have : IsProbabilityMeasure W := hW.isGaussianProcess.isProbabilityMeasure
+  let fR : ℝ≥0 → ℝ := fun s => (f (wienerUnitClamp s)).re
+  let fI : ℝ≥0 → ℝ := fun s => (f (wienerUnitClamp s)).im
+  have hR : Continuous fR := Complex.continuous_re.comp (f.continuous.comp continuous_wienerUnitClamp)
+  have hI : Continuous fI := Complex.continuous_im.comp (f.continuous.comp continuous_wienerUnitClamp)
+  have hR0 : fR 0=0 := by simp [fR,hf]
+  have hI0 : fI 0=0 := by simp [fI,hf]
+  let A : Set Target.Driver := {b | ∀ t : unitInterval, |b ⟨t,t.2.1⟩-fR ⟨t,t.2.1⟩| < r/4}
+  let B : Set Target.Driver := {b | ∀ t : unitInterval, |b ⟨t,t.2.1⟩-fI ⟨t,t.2.1⟩| < r/4}
+  have hA : 0 < W A := wienerReal_uniform_tube_pos W hW fR hR hR0 (r/4) (by positivity)
+  have hB : 0 < W B := wienerReal_uniform_tube_pos W hW fI hI hI0 (r/4) (by positivity)
+  have hp : 0 < (W.prod W) (A ×ˢ B) := by
+    rw [Measure.prod_prod]
+    exact bot_lt_iff_ne_bot.mpr (mul_ne_zero hA.ne' hB.ne')
+  refine hp.trans_le (measure_mono ?_)
+  intro b hb
+  apply (BoundedContinuousFunction.dist_lt_iff_of_compact hr).mpr
+  intro t
+  rw [dist_eq_norm]
+  have hre : |(planarUnitPath b t-f t).re| < r/4 := by
+    simpa [planarUnitPath,fR] using hb.1 t
+  have him : |(planarUnitPath b t-f t).im| < r/4 := by
+    simpa [planarUnitPath,fI] using hb.2 t
+  exact (Complex.norm_le_abs_re_add_abs_im _).trans_lt (by linarith)
+
+end SLEExactGauge
+
+end
+
+end OAI
diff --git a/lean/OAI/Probability/SLE/Geometry/AnalyticCircleSquare.lean b/lean/OAI/Probability/SLE/Geometry/AnalyticCircleSquare.lean
new file mode 100644
index 0000000000000000000000000000000000000000..574ed5d8f4d97fb931f118a962dc1787df3d6e27
--- /dev/null
+++ b/lean/OAI/Probability/SLE/Geometry/AnalyticCircleSquare.lean
@@ -0,0 +1,57 @@
+import Mathlib
+
+namespace OAI
+
+/-! The square mean of a holomorphic function bounds its central value.
+This is the local energy estimate needed for the first exterior coefficient. -/
+noncomputable section
+open Set Filter Metric Function Complex MeasureTheory InnerProductSpace Real
+open scoped Topology
+
+namespace SLEExactGauge
+
+lemma circleAverage_norm_sq_ge {f : ℂ → ℂ} {c : ℂ} {r : ℝ}
+    (hf : ContinuousOn f (sphere c |r|)) :
+    ‖circleAverage f c r‖^2≤circleAverage (fun z => ‖f z‖^2) c r := by
+  let a := circleAverage f c r
+  let L : ℂ →L[ℝ] ℝ := innerSL ℝ a
+  have hL : ContinuousOn (fun z => L (f z)) (sphere c |r|) := L.continuous.comp_continuousOn hf
+  have hI := hf.circleIntegrable'
+  have hN := (hf.norm.pow 2).circleIntegrable'
+  have hLin : circleAverage (fun z => L (f z)) c r=‖a‖^2 := by
+    have hh := L.circleAverage_comp_comm hI
+    change circleAverage (fun z => L (f z)) c r=L a at hh
+    rw [hh]
+    exact real_inner_self_eq_norm_sq a
+  have hleft : circleAverage (fun z => (2:ℝ)*L (f z)-‖a‖^2) c r=‖a‖^2 := by
+    rw [circleAverage_fun_sub (hL.const_mul 2).circleIntegrable' (circleIntegrable_const (‖a‖^2) c r)]
+    have hmul : circleAverage (fun z => (2:ℝ)*L (f z)) c r=
+        2*circleAverage (fun z => L (f z)) c r := by
+      simpa only [smul_eq_mul] using (circleAverage_fun_smul (a := (2:ℝ)) (f := fun z => L (f z)) (c := c) (R := r))
+    rw [hmul,hLin,circleAverage_const]
+    ring
+  rw [←hleft]
+  apply circleAverage_mono ((hL.const_mul 2).sub continuousOn_const).circleIntegrable' hN
+  intro z _
+  have hn := norm_sub_sq_real (f z) a
+  have hp := sq_nonneg ‖f z-a‖
+  have hLa : L (f z)=inner ℝ (f z) a := by
+    change inner ℝ a (f z)=inner ℝ (f z) a
+    exact real_inner_comm _ _
+  dsimp only [Pi.sub_apply,Pi.pow_apply]
+  rw [hLa]
+  nlinarith
+
+lemma analytic_circleAverage_norm_sq_ge {f : ℂ → ℂ} {r : ℝ}
+    (hf : AnalyticOnNhd ℂ f (closedBall (0:ℂ) |r|)) :
+    ‖f 0‖^2≤circleAverage (fun z => ‖f z‖^2) 0 r := by
+  have hm : circleAverage f 0 r=f 0 :=
+    (show HarmonicOnNhd f (closedBall (0:ℂ) |r|) from fun z hz => (hf z hz).harmonicAt).circleAverage_eq
+  rw [←hm]
+  exact circleAverage_norm_sq_ge (hf.continuousOn.mono sphere_subset_closedBall)
+
+end SLEExactGauge
+
+end
+
+end OAI
diff --git a/lean/OAI/Probability/SLE/Geometry/AnalyticFluxEnergy.lean b/lean/OAI/Probability/SLE/Geometry/AnalyticFluxEnergy.lean
new file mode 100644
index 0000000000000000000000000000000000000000..1dec50c1d7ddc820b050ccc4554d4ec9a50d5794
--- /dev/null
+++ b/lean/OAI/Probability/SLE/Geometry/AnalyticFluxEnergy.lean
@@ -0,0 +1,54 @@
+import OAI.Probability.SLE.Geometry.InteriorFluxBound
+import OAI.Probability.SLE.Geometry.AnalyticCircleSquare
+import OAI.Probability.SLE.Geometry.ExteriorLaplacianTest
+
+namespace OAI
+
+/-! The first Taylor coefficient is bounded by the signed area of a
+holomorphic disk map. No injectivity of the disk map is needed. -/
+noncomputable section
+open Set Filter Metric Function Complex MeasureTheory InnerProductSpace Real
+open scoped Topology Laplacian
+
+namespace SLEExactGauge
+
+lemma analytic_norm_sq_laplacian {f : ℂ → ℂ} {z : ℂ} (hf : AnalyticAt ℂ f z) :
+    (Δ (fun w => ‖f w‖^2)) z=4*‖deriv f z‖^2 := by
+  have hh := laplacian_holomorphic_comp hf
+    ((contDiff_id.norm_sq ℝ : ContDiff ℝ 2 (fun w : ℂ => ‖w‖^2)).contDiffAt)
+  simpa only [Function.comp_def,id_eq,complex_laplacian_norm_sq,mul_comm] using hh
+
+lemma analytic_flux_ge_first_coefficient {f : ℂ → ℂ} {R : ℝ}
+    (hR : 0<R) (hf : AnalyticOnNhd ℂ f (closedBall (0:ℂ) R)) :
+    4*Real.pi*R^2*‖deriv f 0‖^2≤
+      ∫ θ in -Real.pi..Real.pi, radialLaplacianFlux (fun z => ‖f z‖^2) (R,θ) := by
+  have hu (z : ℂ) (hz : z∈closedBall (0:ℂ) R) :
+      ContDiffAt ℝ 2 (fun z => ‖f z‖^2) z :=
+    (hf z hz).contDiffAt.restrict_scalars ℝ |>.norm_sq ℝ
+  have hAvg (r : ℝ) (hr : r∈Icc 0 R) :
+      4*‖deriv f 0‖^2≤circleAverage (Δ (fun z => ‖f z‖^2)) 0 r := by
+    have hd : AnalyticOnNhd ℂ (deriv f) (closedBall (0:ℂ) |r|) :=
+      hf.deriv.mono (closedBall_subset_closedBall (by rw [abs_of_nonneg hr.1]; exact hr.2))
+    have hb := analytic_circleAverage_norm_sq_ge hd
+    have he : circleAverage (Δ (fun z => ‖f z‖^2)) 0 r=
+        circleAverage (fun z => (4:ℝ)*‖deriv f z‖^2) 0 r := by
+      apply circleAverage_congr_sphere
+      intro z hz
+      apply analytic_norm_sq_laplacian
+      exact hf z ((closedBall_subset_closedBall (by rw [abs_of_nonneg hr.1]; exact hr.2))
+        (sphere_subset_closedBall hz))
+    rw [he]
+    have hmul : circleAverage (fun z => (4:ℝ)*‖deriv f z‖^2) 0 r=
+        4*circleAverage (fun z => ‖deriv f z‖^2) 0 r := by
+      simpa only [smul_eq_mul] using (circleAverage_fun_smul (a := (4:ℝ))
+        (f := fun z => ‖deriv f z‖^2) (c := (0:ℂ)) (R := r))
+    rw [hmul]
+    exact mul_le_mul_of_nonneg_left hb (by norm_num)
+  have hh := radial_flux_ge_of_circle_laplacian hR hu hAvg
+  convert! hh using 1; ring
+
+end SLEExactGauge
+
+end
+
+end OAI
diff --git a/lean/OAI/Probability/SLE/Geometry/AnnulusPolarIntegral.lean b/lean/OAI/Probability/SLE/Geometry/AnnulusPolarIntegral.lean
new file mode 100644
index 0000000000000000000000000000000000000000..5a6b8811c9d81304ef3a8e326a13002546d52202
--- /dev/null
+++ b/lean/OAI/Probability/SLE/Geometry/AnnulusPolarIntegral.lean
@@ -0,0 +1,87 @@
+import OAI.Probability.SLE.AngularLaws
+import OAI.Probability.SLE.Geometry.PolarLaplacianFlux
+
+namespace OAI
+
+/-! Polar change of variables on a finite annulus. -/
+noncomputable section
+open Set Filter Metric Function Complex MeasureTheory InnerProductSpace
+open scoped Topology Laplacian
+
+namespace SLEExactGauge
+
+lemma annulus_integral_polar_rectangle (g : ℂ → ℝ) {a R : ℝ} (ha : 0<a) :
+    (∫ z in {z : ℂ | a<‖z‖ ∧ ‖z‖<R}, g z)=
+      ∫ p in Ioo a R ×ˢ Ioo (-Real.pi) Real.pi, p.1*g (polarPoint p.1 p.2) := by
+  let A := {z : ℂ | a<‖z‖ ∧ ‖z‖<R}
+  let T : Set (ℝ × ℝ) := Ioi 0 ×ˢ Ioo (-Real.pi) Real.pi
+  let S : Set (ℝ × ℝ) := Ioo a R ×ˢ Ioo (-Real.pi) Real.pi
+  have hA : MeasurableSet A :=
+    ((isOpen_lt continuous_const continuous_norm).inter
+      (isOpen_lt continuous_norm continuous_const)).measurableSet
+  have hT : MeasurableSet T := measurableSet_Ioi.prod measurableSet_Ioo
+  have hS : MeasurableSet S := measurableSet_Ioo.prod measurableSet_Ioo
+  have hST : S⊆T := prod_mono (fun r hr => ha.trans hr.1) subset_rfl
+  let f : ℂ → ℝ := A.indicator g
+  calc
+    _ = ∫ z, f z := (integral_indicator hA).symm
+    _ = ∫ p in T, p.1 • f (Complex.polarCoord.symm p) :=
+      (Complex.integral_comp_polarCoord_symm f).symm
+    _ = ∫ p in T, S.indicator (fun p : ℝ × ℝ => p.1*g (polarPoint p.1 p.2)) p := by
+      apply setIntegral_congr_fun hT
+      intro p hp
+      have hn : ‖Complex.polarCoord.symm p‖=p.1 := by
+        rw [Complex.norm_polarCoord_symm,abs_of_pos hp.1]
+      by_cases hr : p.1∈Ioo a R
+      · have hz : Complex.polarCoord.symm p∈A := by
+          change a<‖_‖ ∧ ‖_‖<R
+          rwa [hn]
+        have hs : p∈S := ⟨hr,hp.2⟩
+        simp only [f,indicator_of_mem hz,indicator_of_mem hs,smul_eq_mul,polarPoint_eq_polarCoord]
+      · have hz : Complex.polarCoord.symm p∉A := by
+          change ¬(a<‖_‖ ∧ ‖_‖<R)
+          simpa only [hn,mem_Ioo] using hr
+        have hs : p∉S := fun hs => hr hs.1
+        simp only [f,indicator_of_notMem hz,indicator_of_notMem hs,smul_zero]
+    _ = _ := by
+      rw [integral_indicator hS,Measure.restrict_restrict hS,inter_eq_left.mpr hST]
+
+lemma annulus_integral_polar (g : ℂ → ℝ) {a R : ℝ} (ha : 0<a) (haR : a≤R)
+    (hc : ∀ z : ℂ, a≤‖z‖ → ‖z‖≤R → ContinuousAt g z) :
+    (∫ z in {z : ℂ | a<‖z‖ ∧ ‖z‖<R}, g z)=
+      ∫ r in a..R, ∫ θ in -Real.pi..Real.pi, r*g (polarPoint r θ) := by
+  let G (p : ℝ × ℝ) := p.1*g (polarPoint p.1 p.2)
+  have hGc : ContinuousOn G (Icc a R ×ˢ Icc (-Real.pi) Real.pi) := by
+    intro p hp
+    have hn : ‖polarPoint p.1 p.2‖=p.1 := by
+      rw [polarPoint_norm,abs_of_pos (ha.trans_le hp.1.1)]
+    exact (continuousAt_fst.mul ((hc _ (by rw [hn]; exact hp.1.1)
+      (by rw [hn]; exact hp.1.2)).comp (f := fun p : ℝ × ℝ => polarPoint p.1 p.2)
+      polarPoint_contDiff.continuous.continuousAt)).continuousWithinAt
+  have hi : IntegrableOn G (Ioo a R ×ˢ Ioo (-Real.pi) Real.pi) :=
+    (hGc.integrableOn_compact (isCompact_Icc.prod isCompact_Icc)).mono_set
+      (prod_mono Ioo_subset_Icc_self Ioo_subset_Icc_self)
+  rw [annulus_integral_polar_rectangle g ha,Measure.volume_eq_prod]
+  rw [Measure.volume_eq_prod] at hi
+  rw [setIntegral_prod _ hi]
+  simp_rw [←integral_Ioc_eq_integral_Ioo]
+  rw [←intervalIntegral.integral_of_le haR]
+  congr 1
+  ext r
+  exact (intervalIntegral.integral_of_le (by linarith [Real.pi_pos] : -Real.pi≤Real.pi)).symm
+
+lemma annulus_integral_laplacian_flux {u : ℂ → ℝ} {a R : ℝ}
+    (ha : 0<a) (haR : a≤R)
+    (hu : ∀ z : ℂ, a≤‖z‖ → ‖z‖≤R → ContDiffAt ℝ 2 u z) :
+    (∫ z in {z : ℂ | a<‖z‖ ∧ ‖z‖<R}, (Δ u) z)=
+      (∫ θ in -Real.pi..Real.pi, radialLaplacianFlux u (R,θ))-
+      (∫ θ in -Real.pi..Real.pi, radialLaplacianFlux u (a,θ)) := by
+  rw [annulus_integral_polar _ ha haR
+    (fun z hz hzR => plane_laplacian_continuousAt (hu z hz hzR))]
+  exact annulus_laplacian_flux ha haR hu
+
+end SLEExactGauge
+
+end
+
+end OAI
diff --git a/lean/OAI/Probability/SLE/Geometry/ApproachIntervalEndpoint.lean b/lean/OAI/Probability/SLE/Geometry/ApproachIntervalEndpoint.lean
new file mode 100644
index 0000000000000000000000000000000000000000..24da392741604edade098fee0a5f4688b4593505
--- /dev/null
+++ b/lean/OAI/Probability/SLE/Geometry/ApproachIntervalEndpoint.lean
@@ -0,0 +1,54 @@
+import OAI.Probability.SLE.Loewner.SlitSegmentParameter
+
+namespace OAI
+
+/-! An explicit sequence approaching the terminal parameter from below,
+with every point still after the initial parameter. -/
+noncomputable section
+open Set Filter
+open scoped Topology
+
+namespace SLEExactGauge
+
+noncomputable def approachIntervalEndpoint {s t : unitInterval} (hst : s<t) (n : ℕ) :
+    unitInterval := by
+  let d : ℝ := (t:ℝ)-(s:ℝ)
+  have hd : 0<d := sub_pos.mpr hst
+  have hden : 0<(n:ℝ)+1 := by positivity
+  have he : d/((n:ℝ)+1)≤d := by
+    apply (div_le_iff₀ hden).mpr
+    nlinarith [Nat.cast_nonneg (α := ℝ) n]
+  refine ⟨(t:ℝ)-d/((n:ℝ)+1),?_,?_⟩
+  · dsimp only [d] at he ⊢
+    linarith [s.property.1]
+  · have hq := div_pos hd hden
+    linarith [t.property.2]
+
+lemma approachIntervalEndpoint_mem {s t : unitInterval} (hst : s<t) (n : ℕ) :
+    approachIntervalEndpoint hst n∈Ico s t := by
+  have hd : 0<(t:ℝ)-(s:ℝ) := sub_pos.mpr hst
+  have hden : 0<(n:ℝ)+1 := by positivity
+  have he : ((t:ℝ)-(s:ℝ))/((n:ℝ)+1)≤(t:ℝ)-(s:ℝ) := by
+    apply (div_le_iff₀ hden).mpr
+    nlinarith [Nat.cast_nonneg (α := ℝ) n]
+  constructor
+  · change (s:ℝ)≤(t:ℝ)-((t:ℝ)-(s:ℝ))/((n:ℝ)+1)
+    linarith
+  · change (t:ℝ)-((t:ℝ)-(s:ℝ))/((n:ℝ)+1)<(t:ℝ)
+    linarith [div_pos hd hden]
+
+lemma approachIntervalEndpoint_tendsto {s t : unitInterval} (hst : s<t) :
+    Tendsto (approachIntervalEndpoint hst) atTop (𝓝 t) := by
+  apply tendsto_subtype_rng.mpr
+  have hh := (tendsto_one_div_add_atTop_nhds_zero_nat.const_mul ((t:ℝ)-(s:ℝ))).const_sub (t:ℝ)
+  convert! hh using 1
+  · funext n
+    change (t:ℝ)-((t:ℝ)-(s:ℝ))/((n:ℝ)+1)=_
+    rw [mul_one_div]
+  · simp only [mul_zero,sub_zero]
+
+end SLEExactGauge
+
+end
+
+end OAI
diff --git a/lean/OAI/Probability/SLE/Geometry/ArbitraryDiskTail.lean b/lean/OAI/Probability/SLE/Geometry/ArbitraryDiskTail.lean
new file mode 100644
index 0000000000000000000000000000000000000000..14ff47748cf4f5a2deea399a3f604278bdae74e8
--- /dev/null
+++ b/lean/OAI/Probability/SLE/Geometry/ArbitraryDiskTail.lean
@@ -0,0 +1,62 @@
+import OAI.Probability.SLE.Loewner.RawDiskAngleTail
+import OAI.Probability.SLE.Gauge.CanonicalDiskMomentTails
+
+namespace OAI
+
+/-! Arbitrary finite radius levels are bounded by the same countable tail
+supremum already used in the prescribed-gauge budget. -/
+noncomputable section
+open Set Filter _root_.MeasureTheory _root_.OAI.MeasureTheory ProbabilityTheory
+open scoped Topology NNReal ENNReal
+
+namespace SLEExactGauge.Multipoint.CanonicalMass
+local instance arbitraryTailMeasurable : MeasurableSpace C(ℝ≥0,ℝ) := borel _
+local instance arbitraryTailBorel : BorelSpace C(ℝ≥0,ℝ) := ⟨rfl⟩
+
+variable {Ω : Type*} [MeasurableSpace Ω] {P : Measure Ω} [IsProbabilityMeasure P]
+  {κ : ℝ} {B : ℝ≥0 → Ω → ℝ} {hBm : Measurable (Function.uncurry B)}
+  {γ : Ω → ℝ≥0 → ℂ} {G : Ω → ℝ≥0 → ℂ → ℂ}
+  (C : CanonicalMass P κ B hBm γ G)
+
+lemma limitingDiskTail_le_one
+    (hB : IsBrownianReal B P) (hc : ∀ ω, Continuous (fun t => B t ω))
+    (hκ : 0<κ) (hκ8 : κ<8) (F : Ω → ℝ≥0 → ℂ → ℂ)
+    (hw : ∀ ω, IsCapacityTwoWitness (fun t => Real.sqrt κ*B t ω) (γ ω) (G ω) (F ω))
+    (b : ℝ) : C.limitingDiskTail hc b ≤ 1 := by
+  apply iSup_le
+  intro j
+  let := centeredDiskLaw_isProbability hB hBm hc hκ hκ8 γ G F hw
+    (4*(j:ℝ)/κ) (by positivity)
+  exact (measure_mono (subset_univ _)).trans_eq measure_univ
+
+lemma centeredDiskTail_le_limit
+    (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 ω))
+    (b v : ℝ) (hv : 0≤v) : C.centeredDiskTail hc b v ≤ C.limitingDiskTail hc b := by
+  obtain ⟨n,hn⟩ := exists_nat_ge (v*κ/4)
+  have hnV : v≤4*(n:ℝ)/κ := (le_div_iff₀ hκ).mpr (by linarith)
+  exact (C.centeredDiskTail_mono hB hc h0 hκ hκ8 F hw b hv
+    (show 0≤4*(n:ℝ)/κ from by positivity) hnV).trans (le_iSup (fun j : ℕ => C.centeredDiskTail hc b (4*(j:ℝ)/κ)) n)
+
+lemma raw_angle_tail_average_le_limit
+    (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 ω)
+    (b v : ℝ) (hv : 0≤v) :
+    (∫⁻ θ, R.angleDiskTail (P.map (sourceDriverPath B hc)) κ b v θ ∂Target.angleLaw κ) ≤
+      C.limitingDiskTail hc b := by
+  have hm (t : ℝ≥0) : Measurable (B t) := hBm.of_uncurry_left
+  let : IsProbabilityMeasure (P.map (sourceDriverPath B hc)) :=
+    (Measure.isProbabilityMeasure_map_iff (source_path_measurable _ hm).aemeasurable).mpr inferInstance
+  rw [R.angleDiskTail_average _ κ hκ b v,C.raw_centeredDiskTail_eq hc hκ F hw R he v b hv]
+  exact C.centeredDiskTail_le_limit hB hc h0 hκ hκ8 F hw b v hv
+
+end SLEExactGauge.Multipoint.CanonicalMass
+
+end
+
+end OAI
diff --git a/lean/OAI/Probability/SLE/Geometry/ArcBoundaryReplacement.lean b/lean/OAI/Probability/SLE/Geometry/ArcBoundaryReplacement.lean
new file mode 100644
index 0000000000000000000000000000000000000000..8b571bd14b03ecff94a2e8cc5272e3deaa379e91
--- /dev/null
+++ b/lean/OAI/Probability/SLE/Geometry/ArcBoundaryReplacement.lean
@@ -0,0 +1,66 @@
+import OAI.Probability.SLE.Geometry.ClosedComplexUnion
+
+namespace OAI
+
+/-! Replacing one compact arc in a Jordan boundary while fixing the
+other arc. The replacement retains the supplied interval parameter. -/
+noncomputable section
+open Set
+
+namespace SLEExactGauge
+
+def arcParameterHomeomorph (p : ℝ → ℂ) (hc : ContinuousOn p (Icc 0 1))
+    (hi : InjOn p (Icc 0 1)) : (Icc (0:ℝ) 1) ≃ₜ (p '' Icc 0 1) := by
+  let e := Equiv.Set.imageOfInjOn p (Icc 0 1) hi
+  have he : Continuous e := hc.mapsToRestrict (mapsTo_image p (Icc 0 1))
+  exact e.toHomeomorphOfContinuousClosed he he.isClosedMap
+
+@[simp] lemma arcParameterHomeomorph_apply
+    (p : ℝ → ℂ) (hc : ContinuousOn p (Icc 0 1)) (hi : InjOn p (Icc 0 1))
+    (s : Icc (0:ℝ) 1) : (arcParameterHomeomorph p hc hi s : ℂ)=p s := rfl
+
+def arcParameterReplacement (p q : ℝ → ℂ)
+    (hc : ContinuousOn p (Icc 0 1)) (hi : InjOn p (Icc 0 1))
+    (hqc : ContinuousOn q (Icc 0 1)) (hqi : InjOn q (Icc 0 1)) :
+    (p '' Icc 0 1) ≃ₜ (q '' Icc 0 1) :=
+  (arcParameterHomeomorph p hc hi).symm.trans (arcParameterHomeomorph q hqc hqi)
+
+lemma arcParameterReplacement_apply (p q : ℝ → ℂ)
+    (hc : ContinuousOn p (Icc 0 1)) (hi : InjOn p (Icc 0 1))
+    (hqc : ContinuousOn q (Icc 0 1)) (hqi : InjOn q (Icc 0 1))
+    (s : ℝ) (hs : s ∈ Icc 0 1) :
+    (arcParameterReplacement p q hc hi hqc hqi ⟨p s,mem_image_of_mem p hs⟩ : ℂ)=q s := by
+  have hh : arcParameterHomeomorph p hc hi ⟨s,hs⟩ = ⟨p s,mem_image_of_mem p hs⟩ := rfl
+  change (arcParameterHomeomorph q hqc hqi
+    ((arcParameterHomeomorph p hc hi).symm ⟨p s,mem_image_of_mem p hs⟩) : ℂ)=q s
+  rw [← hh,Homeomorph.symm_apply_apply]
+  rfl
+
+def fixedArcBoundaryReplacement (p q : ℝ → ℂ) (B : Set ℂ)
+    (hc : ContinuousOn p (Icc 0 1)) (hi : InjOn p (Icc 0 1))
+    (hqc : ContinuousOn q (Icc 0 1)) (hqi : InjOn q (Icc 0 1))
+    (hB : IsClosed B) (hzero : q 0=p 0) (hone : q 1=p 1)
+    (hpB : ∀ s ∈ Icc 0 1, p s ∈ B → s=0 ∨ s=1)
+    (hqB : ∀ s ∈ Icc 0 1, q s ∈ B → s=0 ∨ s=1) :
+    ↥(p '' Icc 0 1 ∪ B) ≃ₜ ↥(q '' Icc 0 1 ∪ B) := by
+  apply closedComplexUnionHomeomorph (isCompact_Icc.image_of_continuousOn hc).isClosed
+    (isCompact_Icc.image_of_continuousOn hqc).isClosed hB
+    (arcParameterReplacement p q hc hi hqc hqi)
+  · rintro ⟨z,⟨s,hs,rfl⟩⟩ hzB
+    rw [arcParameterReplacement_apply p q hc hi hqc hqi s hs]
+    rcases hpB s hs hzB with rfl | rfl
+    · exact hzero
+    · exact hone
+  · rintro ⟨z,⟨s,hs,rfl⟩⟩ hzB
+    change (arcParameterReplacement q p hqc hqi hc hi
+      ⟨q s,mem_image_of_mem q hs⟩ : ℂ)=q s
+    rw [arcParameterReplacement_apply q p hqc hqi hc hi s hs]
+    rcases hqB s hs hzB with rfl | rfl
+    · exact hzero.symm
+    · exact hone.symm
+
+end SLEExactGauge
+
+end
+
+end OAI
diff --git a/lean/OAI/Probability/SLE/Geometry/ArcHeightExtension.lean b/lean/OAI/Probability/SLE/Geometry/ArcHeightExtension.lean
new file mode 100644
index 0000000000000000000000000000000000000000..d74725888e0cc80c8a3234837c9636d9462c0b22
--- /dev/null
+++ b/lean/OAI/Probability/SLE/Geometry/ArcHeightExtension.lean
@@ -0,0 +1,65 @@
+import OAI.Probability.SLE.LoewnerCharts
+
+namespace OAI
+
+/-! Extending the time coordinate of a simple half-plane arc while fixing
+the real boundary at time zero. -/
+noncomputable section
+open Set Filter Function
+open scoped Topology
+
+namespace SLEExactGauge
+
+theorem simple_arc_height_extension (p : C(unitInterval,ℂ)) (hi : Injective p)
+    (hH : ∀ t : unitInterval, t ≠ 0 → p t ∈ upperHalfPlane) :
+    ∃ φ : C(ℂ,ℝ), (∀ z, φ z ∈ Icc (0 : ℝ) 1) ∧
+      (∀ t : unitInterval, φ (p t)=(t : ℝ)) ∧ (∀ x : ℝ, φ (x : ℂ)=0) := by
+  classical
+  let K : Set ℂ := range p
+  let A : Set ℂ := K ∪ {z : ℂ | z.im=0}
+  have hK : IsClosed K := p.continuous.isClosedEmbedding hi |>.isClosed_range
+  have hR : IsClosed {z : ℂ | z.im=0} := isClosed_eq Complex.continuous_im continuous_const
+  have hA : IsClosed A := hK.union hR
+  let t : C(unitInterval,ℝ) := ⟨fun t => t,continuous_subtype_val⟩
+  obtain ⟨g,hg⟩ := t.exists_extension' (p.continuous.isClosedEmbedding hi)
+  have hgp (t : unitInterval) : g (p t)=(t : ℝ) := congr_fun hg t
+  let f : ℂ → ℝ := K.piecewise g 0
+  have hfK : EqOn f g K := fun z hz => piecewise_eq_of_mem K g 0 hz
+  have hfR (z : ℂ) (hz : z.im=0) : f z=0 := by
+    by_cases hzK : z ∈ K
+    · obtain ⟨s,rfl⟩ := hzK
+      have hs : s=0 := by
+        by_contra hs
+        have hh := hH s hs
+        change 0 < (p s).im at hh
+        linarith
+      rw [hfK (mem_range_self s),hgp,hs]
+      rfl
+    · exact piecewise_eq_of_notMem K g 0 hzK
+  have hf : ContinuousOn f A :=
+    (g.continuous.continuousOn.congr hfK).union_of_isClosed
+      (continuousOn_const.congr (fun z hz => hfR z hz)) hK hR
+  let fA : C(A,ℝ) := ⟨fun z => f z,hf.domRestrict⟩
+  have hfA (z : A) : fA z ∈ Icc (0 : ℝ) 1 := by
+    rcases z.property with hz | hz
+    · obtain ⟨s,hs⟩ := hz
+      change f z ∈ Icc (0 : ℝ) 1
+      rw [hfK ⟨s,hs⟩,← hs,hgp]
+      exact s.property
+    · change f z ∈ Icc (0 : ℝ) 1
+      rw [hfR z hz]
+      exact ⟨le_rfl,zero_le_one⟩
+  obtain ⟨φ,hφ,hφf⟩ := fA.exists_restrict_eq_forall_mem_of_closed hfA
+    (nonempty_Icc.mpr zero_le_one) hA
+  have he (z : ℂ) (hz : z ∈ A) : φ z=f z := congr_fun (congrArg DFunLike.coe hφf) ⟨z,hz⟩
+  refine ⟨φ,hφ,?_,?_⟩
+  · intro s
+    rw [he _ (Or.inl (mem_range_self s)),hfK (mem_range_self s),hgp]
+  · intro x
+    rw [he _ (Or.inr (by simp)),hfR _ (by simp)]
+
+end SLEExactGauge
+
+end
+
+end OAI
diff --git a/lean/OAI/Probability/SLE/Geometry/ArcRealRetraction.lean b/lean/OAI/Probability/SLE/Geometry/ArcRealRetraction.lean
new file mode 100644
index 0000000000000000000000000000000000000000..fd07af3d3e465b358d39a964cf0e9f27d5b0f7d5
--- /dev/null
+++ b/lean/OAI/Probability/SLE/Geometry/ArcRealRetraction.lean
@@ -0,0 +1,77 @@
+import OAI.Probability.SLE.Geometry.ArcHeightExtension
+import OAI.Probability.SLE.Stochastic.PlanarRetractComplement
+
+namespace OAI
+
+/-! A simple arc attached to the real axis is a retract together with
+that axis. The explicit formula collapses the two coordinates onto the
+three branches of the attached arc and real line. -/
+noncomputable section
+open Set Filter Function
+open scoped Topology
+
+namespace SLEExactGauge
+
+theorem simple_arc_real_retraction (p : C(unitInterval,ℂ)) (hi : Injective p)
+    (h0 : p 0=0) (hH : ∀ t : unitInterval, t ≠ 0 → p t ∈ upperHalfPlane) :
+    ∃ r : C(ℂ,ℂ), (∀ z, r z ∈ range p ∪ {w : ℂ | w.im=0}) ∧
+      ∀ z ∈ range p ∪ {w : ℂ | w.im=0}, r z=z := by
+  obtain ⟨φ,hφ,hφp,hφR⟩ := simple_arc_height_extension p hi hH
+  let v (z : ℂ) : unitInterval := ⟨φ z,hφ z⟩
+  have hv : Continuous v := φ.continuous.subtype_mk _
+  let b (z : ℂ) : ℝ := z.re-(p (v z)).re
+  have hb : Continuous b := Complex.continuous_re.sub
+    (Complex.continuous_re.comp (p.continuous.comp hv))
+  let t (z : ℂ) : unitInterval := ⟨max (φ z-|b z|) 0,
+    le_max_right _ _,max_le (by linarith [(hφ z).2,abs_nonneg (b z)]) zero_le_one⟩
+  have ht : Continuous t := ((φ.continuous.sub hb.abs).max continuous_const).subtype_mk _
+  let x (z : ℂ) : ℝ := max (b z-φ z) 0-max (-b z-φ z) 0
+  have hx : Continuous x := ((hb.sub φ.continuous).max continuous_const).sub
+    ((hb.neg.sub φ.continuous).max continuous_const)
+  let r : C(ℂ,ℂ) := ⟨fun z => p (t z)+(x z : ℂ),
+    (p.continuous.comp ht).add (Complex.continuous_ofReal.comp hx)⟩
+  have ht0 (z : ℂ) (hz : φ z ≤ |b z|) : t z=0 := by
+    apply Subtype.ext
+    exact max_eq_right (sub_nonpos.mpr hz)
+  have hx0 (z : ℂ) (hz : |b z| ≤ φ z) : x z=0 := by
+    have hpos : b z-φ z ≤ 0 := sub_nonpos.mpr ((le_abs_self _).trans hz)
+    have hneg : -b z-φ z ≤ 0 := sub_nonpos.mpr ((neg_le_abs _).trans hz)
+    simp only [x,max_eq_right hpos,max_eq_right hneg,sub_self]
+  refine ⟨r,?_,?_⟩
+  · intro z
+    by_cases hz : |b z| ≤ φ z
+    · left
+      exact ⟨t z,by simp [r,hx0 z hz]⟩
+    · right
+      simp [r,ht0 z (le_of_not_ge hz),h0]
+  · intro z hz
+    rcases hz with ⟨s,rfl⟩ | hz
+    · have hvp : v (p s)=s := Subtype.ext (hφp s)
+      have hbp : b (p s)=0 := by simp [b,hvp]
+      have htp : t (p s)=s := by
+        apply Subtype.ext
+        simp only [t,hφp,hbp,abs_zero,sub_zero,max_eq_left s.property.1]
+      have hxp : x (p s)=0 := by
+        apply hx0
+        simp only [hbp,abs_zero,hφp]
+        exact s.property.1
+      simp [r,htp,hxp]
+    · change z.im=0 at hz
+      have hez : z=(z.re : ℂ) := by apply Complex.ext <;> simp [hz]
+      have hφz : φ z=0 := by rw [hez,hφR]
+      have hvz : v z=0 := Subtype.ext hφz
+      have hbz : b z=z.re := by simp [b,hvz,h0]
+      have htz : t z=0 := ht0 z (by rw [hφz]; exact abs_nonneg _)
+      have hxz : x z=z.re := by
+        change max (b z-φ z) 0-max (-b z-φ z) 0=z.re
+        rw [hbz,hφz,sub_zero,sub_zero]
+        rcases le_total 0 z.re with h | h
+        · rw [max_eq_left h,max_eq_right (neg_nonpos.mpr h),sub_zero]
+        · rw [max_eq_right h,max_eq_left (neg_nonneg.mpr h),zero_sub,neg_neg]
+      simpa only [r,ContinuousMap.coe_mk,htz,h0,zero_add,hxz] using hez.symm
+
+end SLEExactGauge
+
+end
+
+end OAI
diff --git a/lean/OAI/Probability/SLE/Geometry/BoundaryNull.lean b/lean/OAI/Probability/SLE/Geometry/BoundaryNull.lean
new file mode 100644
index 0000000000000000000000000000000000000000..b3d8b6663c0ae092071c5de6a361da8719b0206e
--- /dev/null
+++ b/lean/OAI/Probability/SLE/Geometry/BoundaryNull.lean
@@ -0,0 +1,85 @@
+import OAI.Probability.SLE.Gauge.GaugeCompletion
+
+namespace OAI
+
+/-! Real-boundary cleanup in the all-time upper Hausdorff estimate. -/
+
+noncomputable section
+open Set Filter MeasureTheory
+open scoped Topology ENNReal NNReal
+
+namespace SLEExactGauge
+
+/-- The log-log correction is smaller than every power lost from dimension. -/
+theorem hFormula_div_rpow_tendsto_zero {κ s : ℝ}
+    (hκ : 0 < κ) (hs : s < dimension κ) :
+    Tendsto (fun r => hFormula κ r / r ^ s) (𝓝[>] 0) (𝓝 0) := by
+  have hq : codimension κ / 2 ≤ 1 := by
+    dsimp [codimension, dimension]
+    linarith
+  have ht := (GaugeCompletion.tailProfile_tendsto_zero (sub_pos.mpr hs) hq).comp
+    GaugeCompletion.log_inv_tendsto_atTop
+  apply ht.congr'
+  filter_upwards [self_mem_nhdsWithin] with r hr
+  change GaugeCompletion.tailProfile (dimension κ - s) (codimension κ / 2)
+    (Real.log (1 / r)) = _
+  rw [GaugeCompletion.tailProfile_log_inv hr]
+  unfold hFormula
+  rw [Real.rpow_sub hr]
+  ring_nf
+
+/-- An eventual power bound compares the diameter-defined gauge measure with
+ordinary Hausdorff measure. -/
+theorem hausdorffGauge_le_hausdorffMeasure_of_power_bound
+    {h : ℝ → ℝ} (hh : IsGauge h) {s : ℝ} (hs : 0 ≤ s)
+    (hb : ∀ᶠ r in 𝓝[>] (0 : ℝ), h r ≤ r ^ s) :
+    hausdorffGauge h ≤ (Measure.hausdorffMeasure s : Measure ℂ) := by
+  obtain ⟨δ, hδ, hbound⟩ := mem_nhdsGT_iff_exists_Ioo_subset.mp hb
+  have ht : Tendsto ENNReal.toReal (𝓝 (0 : ℝ≥0∞)) (𝓝 (0 : ℝ)) := by
+    simpa using ENNReal.tendsto_toReal ENNReal.zero_ne_top
+  apply Measure.mkMetric_mono
+  filter_upwards [ht.eventually (gt_mem_nhds hδ)] with r hr
+  change ENNReal.ofReal (h r.toReal) ≤ r ^ s
+  by_cases hz : r.toReal = 0
+  · simp only [hz, hh.zero, ENNReal.ofReal_zero]
+    exact bot_le
+  · have hp : 0 < r.toReal := lt_of_le_of_ne ENNReal.toReal_nonneg (Ne.symm hz)
+    calc
+      ENNReal.ofReal (h r.toReal) ≤ ENNReal.ofReal (r.toReal ^ s) :=
+        ENNReal.ofReal_le_ofReal (hbound ⟨hp, hr⟩)
+      _ = (ENNReal.ofReal r.toReal) ^ s :=
+        (ENNReal.ofReal_rpow_of_nonneg ENNReal.toReal_nonneg hs).symm
+      _ ≤ r ^ s := ENNReal.rpow_le_rpow ENNReal.ofReal_toReal_le hs
+
+/-- Every continuous completion of the explicit gauge gives zero measure to
+the entire real axis, hence also to its trace points in any bounded disk. -/
+theorem explicit_gauge_real_axis_null {κ : ℝ} (hκ : 0 < κ)
+    {h : ℝ → ℝ} (hh : IsGauge h)
+    (hf : HasSmallRadiusFormula h (hFormula κ)) :
+    hausdorffGauge h (range ((↑) : ℝ → ℂ)) = 0 := by
+  let s : ℝ := (1 + dimension κ) / 2
+  have hd : 1 < dimension κ := by dsimp [dimension]; linarith
+  have hs1 : 1 < s := by dsimp [s]; linarith
+  have hsd : s < dimension κ := by dsimp [s]; linarith
+  have ht : Tendsto (fun r => h r / r ^ s) (𝓝[>] 0) (𝓝 0) := by
+    apply (hFormula_div_rpow_tendsto_zero hκ hsd).congr'
+    filter_upwards [hf] with r hr
+    rw [hr]
+  have hb : ∀ᶠ r in 𝓝[>] (0 : ℝ), h r ≤ r ^ s := by
+    filter_upwards [self_mem_nhdsWithin, ht.eventually (gt_mem_nhds zero_lt_one)] with r hr hb
+    exact ((div_lt_one (Real.rpow_pos_of_pos hr s)).mp hb).le
+  have hcomp := hausdorffGauge_le_hausdorffMeasure_of_power_bound hh
+    (zero_lt_one.trans hs1).le hb
+  apply le_antisymm _ bot_le
+  apply (hcomp _).trans
+  have he := Complex.isometry_ofReal.hausdorffMeasure_image
+    (Or.inl (zero_lt_one.trans hs1).le) (univ : Set ℝ)
+  rw [image_univ] at he
+  rw [he, Real.hausdorffMeasure_of_finrank_lt (by simpa using hs1)]
+  simp
+
+end SLEExactGauge
+
+end
+
+end OAI
diff --git a/lean/OAI/Probability/SLE/Geometry/BoundaryRadialDistance.lean b/lean/OAI/Probability/SLE/Geometry/BoundaryRadialDistance.lean
new file mode 100644
index 0000000000000000000000000000000000000000..a8935f3a75d1980d91be217b123d8c22c712b7ad
--- /dev/null
+++ b/lean/OAI/Probability/SLE/Geometry/BoundaryRadialDistance.lean
@@ -0,0 +1,91 @@
+import OAI.Probability.SLE.Loewner.ReverseConeContraction
+import OAI.Probability.SLE.Loewner.ReverseLongContraction
+
+namespace OAI
+
+/-! A boundary-start reverse trajectory is the uniform limit of the
+positive-height trajectories on each finite time interval. -/
+noncomputable section
+open Set Filter Complex
+open scoped Topology
+
+namespace SLEExactGauge
+
+theorem exists_boundary_radial_distance_constant {T a L : ℝ}
+    (ha : 0 < a) (haT : a ≤ T) (hL : 0 ≤ L) (hsmall : L^2*a ≤ 1)
+    (q : ℝ → ℂ) (u u' : ℝ → ℝ)
+    (hqc : ContinuousOn q (Icc 0 T))
+    (hq : ∀ t ∈ Ioc 0 T, HasDerivWithinAt q
+      (-2/(q t-(u t : ℂ))) (Ici t) t)
+    (hqp : ∀ t ∈ Ioc 0 T, 0 < (q t).im)
+    (hcone : ∀ t ∈ Icc 0 a, ((q t).re-u t)^2 ≤ t ∧ 3*t ≤ (q t).im^2)
+    (hu : ∀ t ∈ Icc 0 T, HasDerivWithinAt u (u' t) (Icc 0 T) t)
+    (hb : ∀ t ∈ Icc 0 T, |u' t| ≤ L) :
+    ∃ K : ℝ, 0 ≤ K ∧ ∀ r : ℝ → ℂ,
+      (∀ t ∈ Icc 0 T, HasDerivWithinAt r
+        (-2/(r t-(u t : ℂ))) (Ici 0) t) →
+      (∀ t ∈ Icc 0 T, 0 < (r t).im) → (r 0).re=u 0 →
+      dist (q T) (r T) ≤ dist (q 0) (r 0)*K := by
+  have hT : 0 ≤ T := ha.le.trans haT
+  have hpost : Icc a T ⊆ Icc 0 T := Icc_subset_Icc_left ha.le
+  obtain ⟨s,hs,hsm⟩ := isCompact_Icc.exists_isMinOn (nonempty_Icc.mpr haT)
+    (Complex.continuous_im.comp_continuousOn (hqc.mono hpost))
+  have hsp : s ∈ Ioc 0 T := ⟨ha.trans_le hs.1,hs.2⟩
+  let η : ℝ := min (q s).im (Real.sqrt a)
+  have hη : 0 < η := lt_min (hqp s hsp) (Real.sqrt_pos.mpr ha)
+  let K : ℝ := Real.exp ((4*η⁻¹^2)*(T-a))
+  refine ⟨K,(Real.exp_pos _).le,?_⟩
+  intro r hr hrp hr0
+  have hrd (t : ℝ) (ht : t ∈ Icc 0 T) : HasDerivWithinAt r
+      (-2/(r t-(u t : ℂ))) (Icc 0 T) t := (hr t ht).mono Icc_subset_Ici_self
+  have hrc : ContinuousOn r (Icc 0 T) := fun t ht => (hrd t ht).continuousWithinAt
+  have hsub : Icc 0 a ⊆ Icc 0 T := Icc_subset_Icc_right haT
+  have hrda (t : ℝ) (ht : t ∈ Icc 0 a) : HasDerivWithinAt r
+      (-2/(r t-(u t : ℂ))) (Icc 0 a) t := (hrd t (hsub ht)).mono hsub
+  have hua (t : ℝ) (ht : t ∈ Icc 0 a) : HasDerivWithinAt u
+      (u' t) (Icc 0 a) t := (hu t (hsub ht)).mono hsub
+  have hra := reverse_loewner_height_lower hL r u u' hrda hua
+    (fun t ht => hb t (hsub ht)) (fun t ht => hrp t (hsub ht)) hr0 hsmall
+  have hrx := (reverse_centered_coordinates hL r u u' hrda hua
+    (fun t ht => hb t (hsub ht)) (fun t ht => hrp t (hsub ht)) hr0).1
+  have hrcone (t : ℝ) (ht : t ∈ Ioc 0 a) : ((r t).re-u t)^2 ≤ t := by
+    have ht' : t ∈ Icc 0 a := Ioc_subset_Icc_self ht
+    have hxx := (sq_le_sq₀ (abs_nonneg ((r t).re-u t)) (mul_nonneg hL ht.1.le)).mpr (hrx t ht')
+    rw [sq_abs] at hxx
+    have hl := (mul_le_mul_of_nonneg_left ht.2 (sq_nonneg L)).trans hsmall
+    nlinarith [mul_le_mul_of_nonneg_right hl ht.1.le]
+  have hshort := reverse_trajectories_contract_in_cones ha.le q r u
+    (hqc.mono hsub) (hrc.mono hsub)
+    (fun t ht => hq t ⟨ht.1,ht.2.trans haT⟩)
+    (fun t ht => (hr t (hsub (Ioc_subset_Icc_self ht))).mono (Ici_subset_Ici.mpr ht.1.le))
+    (fun t ht => hqp t ⟨ht.1,ht.2.trans haT⟩)
+    (fun t ht => hrp t (hsub (Ioc_subset_Icc_self ht)))
+    (fun t ht => (hcone t (Ioc_subset_Icc_self ht)).1) hrcone
+    (fun t ht => by have hh := (hcone t (Ioc_subset_Icc_self ht)).2; linarith [ht.1])
+    (fun t ht => by have hh := hra t (Ioc_subset_Icc_self ht); linarith [ht.1])
+  have hQ (t : ℝ) (ht : t ∈ Icc a T) : η ≤ (q t).im :=
+    (min_le_left _ _).trans (hsm ht)
+  have hroot : Real.sqrt a ≤ (r a).im := by
+    have hh := hra a ⟨ha.le,le_rfl⟩
+    nlinarith [Real.sq_sqrt ha.le,Real.sqrt_nonneg a,hrp a ⟨ha.le,haT⟩]
+  have hrmono := reverse_height_monotone r u hrd hrp
+  have hR (t : ℝ) (ht : t ∈ Icc a T) : η ≤ (r t).im :=
+    (min_le_right _ _).trans (hroot.trans (hrmono ⟨ha.le,haT⟩ (hpost ht) ht.1))
+  have hdQ (t : ℝ) (ht : t ∈ Ico a T) : HasDerivWithinAt q
+      (reverseField η (u t) (q t)) (Ici t) t := by
+    rw [reverseField,reverseCenter_eq (hQ t (Ico_subset_Icc_self ht))]
+    simpa only [div_eq_mul_inv] using hq t ⟨ha.trans_le ht.1,ht.2.le⟩
+  have hdR (t : ℝ) (ht : t ∈ Ico a T) : HasDerivWithinAt r
+      (reverseField η (u t) (r t)) (Ici t) t := by
+    rw [reverseField,reverseCenter_eq (hR t (Ico_subset_Icc_self ht))]
+    simpa only [div_eq_mul_inv] using
+      (hr t (hpost (Ico_subset_Icc_self ht))).mono (Ici_subset_Ici.mpr (hpost (Ico_subset_Icc_self ht)).1)
+  exact dist_le_of_trajectories_ODE (fun t => reverseField_lipschitz hη (u t))
+    (hqc.mono hpost) hdQ (hrc.mono hpost) hdR
+    (hshort a ⟨ha.le,le_rfl⟩) T ⟨haT,le_rfl⟩
+
+end SLEExactGauge
+
+end
+
+end OAI
diff --git a/lean/OAI/Probability/SLE/Geometry/BoundaryScaleLaw.lean b/lean/OAI/Probability/SLE/Geometry/BoundaryScaleLaw.lean
new file mode 100644
index 0000000000000000000000000000000000000000..21a8f418d712c3002f7debb3a452c7a917fd3530
--- /dev/null
+++ b/lean/OAI/Probability/SLE/Geometry/BoundaryScaleLaw.lean
@@ -0,0 +1,194 @@
+import OAI.Probability.SLE.Geometry.PublishedFiniteBoundaryExtension
+import OAI.Probability.SLE.Geometry.FrontClockChange
+import OAI.Probability.SLE.Loewner.ScaleTraceLaw
+
+namespace OAI
+
+/-! Finite boundary charts commute with normalization. Capacity scaling
+changes only the clock of the physical image path, and therefore preserves
+the first-front success-and-sausage event. -/
+
+noncomputable section
+open Set Filter MeasureTheory
+open scoped Topology NNReal ENNReal
+
+namespace SLEExactGauge.BoundaryScaleLaw
+
+local instance : LocallyCompactSpace closedHalfPlane :=
+  isClosed_closedHalfPlane.locallyCompactSpace
+local instance boundaryScalePathMeasurable : MeasurableSpace C(ℝ≥0, ℂ) := borel _
+local instance boundaryScalePathBorel : BorelSpace C(ℝ≥0, ℂ) := ⟨rfl⟩
+
+theorem finite_boundary_ext (f g : C(closedHalfPlane, ℂ))
+    (heq : ∀ z : closedHalfPlane, z.1 ∈ upperHalfPlane → f z = g z) : f = g := by
+  ext z
+  let zₙ (n : ℕ) : closedHalfPlane :=
+    ⟨z + ((1 / ((n : ℝ) + 1) : ℝ) : ℂ) * Complex.I, by
+      change 0 ≤ (z.1 + ((1 / ((n : ℝ) + 1) : ℝ) : ℂ) * Complex.I).im
+      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]
+      exact add_nonneg z.2 (by positivity)⟩
+  have hH (n : ℕ) : (zₙ n).1 ∈ upperHalfPlane := by
+    change 0 < (z.1 + ((1 / ((n : ℝ) + 1) : ℝ) : ℂ) * Complex.I).im
+    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]
+    exact add_pos_of_nonneg_of_pos z.2 (by positivity)
+  have hz : Tendsto zₙ atTop (𝓝 z) := by
+    apply tendsto_subtype_rng.mpr
+    simpa only [Function.comp_def, Complex.ofReal_zero, zero_mul, add_zero] using
+      tendsto_const_nhds.add (((Complex.continuous_ofReal.tendsto 0).comp
+        (tendsto_one_div_add_atTop_nhds_zero_nat (𝕜 := ℝ))).mul_const Complex.I)
+  exact tendsto_nhds_unique ((f.continuous.tendsto z).comp hz)
+    (((g.continuous.tendsto z).comp hz).congr (fun n => (heq (zₙ n) (hH n)).symm))
+
+def scaleClosed (c : ℝ≥0) : C(closedHalfPlane, closedHalfPlane) :=
+  ⟨fun z => ⟨(c : ℂ) * z, by
+    change 0 ≤ ((c : ℂ) * (z : ℂ)).im
+    simpa only [Complex.mul_im, Complex.ofReal_re, Complex.ofReal_im, zero_mul,
+      add_zero] using mul_nonneg c.coe_nonneg z.2⟩,
+    (continuous_const.mul continuous_subtype_val).subtype_mk _⟩
+
+theorem normalized_boundary_eq
+    (F : ℂ → ℂ) (u : ℝ) (c : ℝ≥0) (hc : 0 < c)
+    (f₁ fc : C(closedHalfPlane, ℂ))
+    (h₁ : ∀ z : closedHalfPlane, z.1 ∈ upperHalfPlane → f₁ z = F ((u : ℂ) + z))
+    (hscaled : ∀ z : closedHalfPlane, z.1 ∈ upperHalfPlane →
+      fc z = F ((u : ℂ) + (c : ℂ) * z)) :
+    fc = f₁.comp (scaleClosed c) := by
+  apply finite_boundary_ext
+  intro z hz
+  change fc z = f₁ (scaleClosed c z)
+  rw [hscaled z hz, h₁]
+  · rfl
+  · change 0 < ((c : ℂ) * (z : ℂ)).im
+    simpa only [Complex.mul_im, Complex.ofReal_re, Complex.ofReal_im, zero_mul,
+      add_zero] using mul_pos (show 0 < (c : ℝ) by exact_mod_cast hc) hz
+
+def clockPath (e : ℝ≥0 ≃o ℝ≥0) (p : C(ℝ≥0, ℂ)) : C(ℝ≥0, ℂ) :=
+  ⟨fun t => p (e t), p.continuous.comp e.toHomeomorph.continuous⟩
+
+theorem measurable_clockPath (e : ℝ≥0 ≃o ℝ≥0) : Measurable (clockPath e) := by
+  apply ContinuousMap.measurable_iff_eval.mpr
+  intro t
+  change Measurable (fun p : C(ℝ≥0, ℂ) => p (e t))
+  exact (continuous_eval_const (e t)).measurable
+
+theorem boundary_scale_clock_identity
+    (c : ℝ≥0) (hc : 0 < c) (f : C(closedHalfPlane, ℂ))
+    (p : C(ℝ≥0, ℂ)) (hp : ClosedPathProperty p) :
+    finiteBoundaryPath (f.comp (scaleClosed c)) p =
+      clockPath (OrderIso.mulLeft₀ (c ^ 2) (pow_pos hc 2))
+        (finiteBoundaryPath f (ScaleTraceLaw.scalePath c p)) := by
+  have hpc : ClosedPathProperty (ScaleTraceLaw.scalePath c p) := by
+    intro t
+    change 0 ≤ ((c : ℂ) * p (sourceScaleTime c t)).im
+    simpa only [Complex.mul_im, Complex.ofReal_re, Complex.ofReal_im, zero_mul,
+      add_zero] using mul_nonneg c.coe_nonneg (hp _)
+  ext t
+  rw [finiteBoundaryPath_apply _ _ hp]
+  change f (scaleClosed c ⟨p t, hp t⟩) =
+    finiteBoundaryPath f (ScaleTraceLaw.scalePath c p) ((c ^ 2) * t)
+  rw [finiteBoundaryPath_apply _ _ hpc]
+  congr 1
+  apply Subtype.ext
+  change (c : ℂ) * p t = (c : ℂ) * p (sourceScaleTime c (c ^ 2 * t))
+  congr 2
+  unfold sourceScaleTime
+  field_simp
+
+/-- The normalized physical path has the same law as a deterministic
+capacity-clock change of the unnormalized physical path. -/
+theorem boundary_scale_path_law
+    {Ω : Type*} [MeasurableSpace Ω] (P : Measure Ω)
+    (p : Ω → C(ℝ≥0, ℂ)) (hp : Measurable p)
+    (hclosed : ∀ᵐ ω ∂P, ClosedPathProperty (p ω))
+    (c : ℝ≥0) (hc : 0 < c) (f : C(closedHalfPlane, ℂ))
+    (hlaw : P.map (fun ω => ScaleTraceLaw.scalePath c (p ω)) = P.map p) :
+    P.map (fun ω => finiteBoundaryPath (f.comp (scaleClosed c)) (p ω)) =
+      P.map (fun ω => clockPath (OrderIso.mulLeft₀ (c ^ 2) (pow_pos hc 2))
+        (finiteBoundaryPath f (p ω))) := by
+  let e := OrderIso.mulLeft₀ (c ^ 2) (pow_pos hc 2)
+  calc
+    _ = P.map (fun ω => clockPath e (finiteBoundaryPath f (ScaleTraceLaw.scalePath c (p ω)))) := by
+      apply Measure.map_congr
+      filter_upwards [hclosed] with ω hω
+      exact boundary_scale_clock_identity c hc f (p ω) hω
+    _ = (P.map (fun ω => ScaleTraceLaw.scalePath c (p ω))).map
+        (fun q => clockPath e (finiteBoundaryPath f q)) := by
+      exact (Measure.map_map ((measurable_clockPath e).comp (measurable_finiteBoundaryPath f))
+        ((ScaleTraceLaw.measurable_scalePath c).comp hp)).symm
+    _ = (P.map p).map (fun q => clockPath e (finiteBoundaryPath f q)) := by rw [hlaw]
+    _ = _ := by
+      exact Measure.map_map ((measurable_clockPath e).comp (measurable_finiteBoundaryPath f)) hp
+
+open FirstFrontPassage PassageSuccess
+
+def frontMassEvent (p : ℂ → ℝ) (V : Set ℂ) (a : ℂ) (ε κ v c : ℝ) (R : Set ℂ) :
+    Set C(ℝ≥0, ℂ) :=
+  {γ | γ ∈ FrontSuccess (fun _ (γ : C(ℝ≥0, ℂ)) => (γ : ℝ≥0 → ℂ)) (fun _ => p) (fun _ => 0)
+      (fun _ => V) (fun _ => a) ε 0 ∧
+    ENNReal.ofReal c ≤ segmentSausageCharge κ γ 0
+      (frontTime (fun t => p (γ t)) 1) v R}
+
+theorem measurableSet_frontMassEvent
+    (p : ℂ → ℝ) (V : Set ℂ) (a : ℂ) (ε κ v c : ℝ) (R K : Set ℂ)
+    (hK : IsClosed K) (hp : ContinuousOn p K) (hV : IsOpen V) (hVK : V ⊆ K) :
+    MeasurableSet (frontMassEvent p V a ε κ v c R) := by
+  let ℱ : Filtration ℝ≥0 (borel C(ℝ≥0, ℂ)) :=
+    Filtration.const ℝ≥0 (borel C(ℝ≥0, ℂ)) le_rfl
+  have ha : Adapted ℱ (fun t (γ : C(ℝ≥0, ℂ)) => γ t) := by
+    intro t
+    change @Measurable C(ℝ≥0, ℂ) ℂ (borel C(ℝ≥0, ℂ)) _ (fun γ => γ t)
+    exact (continuous_eval_const t).measurable
+  exact FrontSuccessMeasurability.measurableSet_frontSuccess_mass
+    ℱ
+    (fun _ (γ : C(ℝ≥0, ℂ)) => (γ : ℝ≥0 → ℂ)) (fun _ => p) (fun _ => 0)
+    (fun _ => V) (fun _ => a) ε 0
+    ha (fun γ => γ.continuous)
+    K hK hp measurable_const hV hVK κ v c R
+
+theorem mem_frontMassEvent_clock
+    (e : ℝ≥0 ≃o ℝ≥0) (p : ℂ → ℝ) (V : Set ℂ) (a : ℂ)
+    (ε κ v c : ℝ) (R : Set ℂ) (γ : C(ℝ≥0, ℂ)) :
+    clockPath e γ ∈ frontMassEvent p V a ε κ v c R ↔
+      γ ∈ frontMassEvent p V a ε κ v c R := by
+  have he := congrArg (fun S : Set C(ℝ≥0, ℂ) => γ ∈ S)
+    (FrontClockChange.frontSuccess_mass_clock e (fun γ : C(ℝ≥0, ℂ) => (γ : ℝ≥0 → ℂ)) p (fun _ => 0)
+      V a ε κ v c R)
+  have he0 : e.symm 0 = 0 := e.symm.map_bot
+  simpa only [he0, frontMassEvent, FrontSuccess, clockPath, ContinuousMap.coe_mk,
+    mem_ofPred_eq] using eq_iff_iff.mp he
+
+/-- Normalize the inverse chart without changing the physical first-front
+event probability. The scale law is the actual SLE path law. -/
+theorem frontMassEvent_boundary_scale_probability
+    {Ω : Type*} [MeasurableSpace Ω] (P : Measure Ω)
+    (γ : Ω → C(ℝ≥0, ℂ)) (hγ : Measurable γ)
+    (hclosed : ∀ᵐ ω ∂P, ClosedPathProperty (γ ω))
+    (ell : ℝ≥0) (hell : 0 < ell) (f : C(closedHalfPlane, ℂ))
+    (hlaw : P.map (fun ω => ScaleTraceLaw.scalePath ell (γ ω)) = P.map γ)
+    (p : ℂ → ℝ) (V : Set ℂ) (a : ℂ) (ε κ v c : ℝ) (R K : Set ℂ)
+    (hK : IsClosed K) (hp : ContinuousOn p K) (hV : IsOpen V) (hVK : V ⊆ K) :
+    P {ω | finiteBoundaryPath (f.comp (scaleClosed ell)) (γ ω) ∈ frontMassEvent p V a ε κ v c R} =
+      P {ω | finiteBoundaryPath f (γ ω) ∈ frontMassEvent p V a ε κ v c R} := by
+  let e := OrderIso.mulLeft₀ (ell ^ 2) (pow_pos hell 2)
+  let E := frontMassEvent p V a ε κ v c R
+  have hE : MeasurableSet E := measurableSet_frontMassEvent p V a ε κ v c R K hK hp hV hVK
+  have hn := (measurable_finiteBoundaryPath (f.comp (scaleClosed ell))).comp hγ
+  have hm := (measurable_clockPath e).comp ((measurable_finiteBoundaryPath f).comp hγ)
+  calc
+    _ = (P.map (fun ω => finiteBoundaryPath (f.comp (scaleClosed ell)) (γ ω))) E :=
+      (Measure.map_apply hn hE).symm
+    _ = (P.map (fun ω => clockPath e (finiteBoundaryPath f (γ ω)))) E := by
+      rw [boundary_scale_path_law P γ hγ hclosed ell hell f hlaw]
+    _ = P {ω | clockPath e (finiteBoundaryPath f (γ ω)) ∈ E} := Measure.map_apply hm hE
+    _ = _ := by
+      congr 1
+      ext ω
+      exact mem_frontMassEvent_clock e p V a ε κ v c R _
+
+end SLEExactGauge.BoundaryScaleLaw
+
+end
+
+end OAI
diff --git a/lean/OAI/Probability/SLE/Geometry/BoundarySeparationRectangle.lean b/lean/OAI/Probability/SLE/Geometry/BoundarySeparationRectangle.lean
new file mode 100644
index 0000000000000000000000000000000000000000..fa4e680f18247339f4ec6eee529715a4b073bd8f
--- /dev/null
+++ b/lean/OAI/Probability/SLE/Geometry/BoundarySeparationRectangle.lean
@@ -0,0 +1,53 @@
+import OAI.Probability.SLE.Geometry.ThinCrossingEnergy
+
+namespace OAI
+
+/-! A nonconstant continuous boundary value remains separated on a
+small upper rectangle. -/
+noncomputable section
+open Set Filter Function Complex Metric MeasureTheory
+open scoped Topology
+
+namespace SLEExactGauge
+
+lemma boundary_separation_rectangle {B F : ℂ → ℂ}
+    (hB : ContinuousOn B {z : ℂ | 0≤z.im})
+    (hBF : ∀ z∈upperHalfPlane, B z=F z)
+    {a b x : ℝ} (hx : x∈Ioo a b) {c : ℂ} (hne : B (x:ℂ)≠c) :
+    ∃ a' b' H δ : ℝ, a<a' ∧ a'<b' ∧ b'<b ∧ 0<H ∧ 0<δ ∧
+      ∀ u∈Icc a' b', ∀ y∈Ioc 0 H, 3*δ<‖F ((u:ℂ)+(y:ℂ)*I)-c‖ := by
+  let d := ‖B (x:ℂ)-c‖
+  have hd : 0<d := norm_pos_iff.mpr (sub_ne_zero.mpr hne)
+  obtain ⟨r,hr,hclose⟩ := Metric.continuousWithinAt_iff.mp
+    (hB (x:ℂ) (by simp)) (d/2) (half_pos hd)
+  let η := min (r/4) (min ((x-a)/2) ((b-x)/2))
+  have hη : 0<η := lt_min (by positivity) (lt_min (by linarith [hx.1]) (by linarith [hx.2]))
+  have hηr : η≤r/4 := min_le_left _ _
+  have hηa : η≤(x-a)/2 := (min_le_right _ _).trans (min_le_left _ _)
+  have hηb : η≤(b-x)/2 := (min_le_right _ _).trans (min_le_right _ _)
+  refine ⟨x-η,x+η,η,d/8,by linarith,by linarith,by linarith,hη,by positivity,?_⟩
+  intro u hu y hy
+  let z : ℂ := (u:ℂ)+(y:ℂ)*I
+  have hzH : z∈upperHalfPlane := by simpa [z,upperHalfPlane] using hy.1
+  have hzr : dist z (x:ℂ)<r := by
+    have hb := norm_le_abs_re_add_abs_im (z-(x:ℂ))
+    have hux : |u-x|≤η := abs_le.mpr ⟨by linarith [hu.1],by linarith [hu.2]⟩
+    have hre : (z-(x:ℂ)).re=u-x := by simp [z]
+    have him : (z-(x:ℂ)).im=y := by simp [z]
+    rw [hre,him,abs_of_pos hy.1] at hb
+    rw [dist_eq_norm]
+    linarith [hy.2]
+  have hzclosed : z∈{z : ℂ | 0≤z.im} := (show 0<z.im from hzH).le
+  have hc := hclose hzclosed hzr
+  rw [dist_eq_norm,hBF z hzH] at hc
+  have ht := norm_sub_le_norm_sub_add_norm_sub (B (x:ℂ)) (F z) c
+  rw [norm_sub_rev (B (x:ℂ)) (F z)] at ht
+  change 3*(d/8)<‖F z-c‖
+  change d≤_ at ht
+  linarith
+
+end SLEExactGauge
+
+end
+
+end OAI
diff --git a/lean/OAI/Probability/SLE/Geometry/BoundedSpliceProbability.lean b/lean/OAI/Probability/SLE/Geometry/BoundedSpliceProbability.lean
new file mode 100644
index 0000000000000000000000000000000000000000..136735e82063e6be3cbd4b6c1a52455428f1611e
--- /dev/null
+++ b/lean/OAI/Probability/SLE/Geometry/BoundedSpliceProbability.lean
@@ -0,0 +1,134 @@
+import OAI.Probability.SLE.Gauge.StoppedSplicePassage
+import OAI.Probability.SLE.Geometry.FirstHeightBounded
+
+namespace OAI
+
+/-! Passage from the actual bounded first-height event. The geometry of
+the stopped past is derived from the measurable certificate, rather than
+imposed separately on the stopped Loewner realization. -/
+
+noncomputable section
+open Set Filter MeasureTheory ProbabilityTheory Metric
+open scoped Topology NNReal ENNReal
+
+namespace SLEExactGauge
+
+theorem brownian_capacity_trace_adapted
+    {Ω : Type*} [m : MeasurableSpace Ω]
+    (B : ℝ≥0 → Ω → ℝ) (hm : ∀ t, Measurable (B t))
+    (hc : ∀ ω, Continuous (fun t => B t ω)) (κ : ℝ)
+    (γ : Ω → ℝ≥0 → ℂ) (G F : Ω → ℝ≥0 → ℂ → ℂ)
+    (hw : ∀ ω, IsCapacityTwoWitness (fun t => Real.sqrt κ * B t ω)
+      (γ ω) (G ω) (F ω)) :
+    Adapted (Filtration.natural B (fun t => (hm t).stronglyMeasurable))
+      (fun t ω => γ ω t) := by
+  apply capacity_trace_adapted _ (fun t ω => Real.sqrt κ * B t ω) _
+    (fun ω => continuous_const.mul (hc ω)) γ G F hw
+  intro t
+  exact measurable_const.mul
+    ((Filtration.stronglyAdapted_natural (fun t => (hm t).stronglyMeasurable)) t).measurable
+
+theorem bounded_firstHeight_splice_positive
+    {Ω : 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) :
+    let ℱ := Filtration.natural B₀ (fun t => (hm t).stronglyMeasurable)
+    let σ := fun ω => FirstHeightSupport.boundedFirstHeightTime (γ ω) B Tc
+    let hσ := FirstHeightSupport.boundedFirstHeightTime_isStoppingTime ℱ γ
+      (brownian_capacity_trace_adapted B₀ hm hc κ γ G F₀ hw) (fun ω => (hw ω).1) B Tc
+    ∀ᵐ ω ∂P, ω ∈ FirstHeightSupport.stoppedNarrowCertificate γ σ B Tc →
+      0 < P⁻[(stoppedPhysicalTube γ σ (parameterContinuationRegion F a r O) W).indicator
+        (fun _ => 1) | hσ.measurableSpace] ω := by
+  dsimp only
+  let ℱ := Filtration.natural B₀ (fun t => (hm t).stronglyMeasurable)
+  let σ := fun ω => FirstHeightSupport.boundedFirstHeightTime (γ ω) B Tc
+  have hσ := FirstHeightSupport.boundedFirstHeightTime_isStoppingTime ℱ γ
+    (brownian_capacity_trace_adapted B₀ hm hc κ γ G F₀ hw) (fun ω => (hw ω).1) B Tc
+  apply conditional_stopped_splice_positive κ hκ hκ8 B₀ hB₀ hm hc γ G F₀ hw
+    hboundary hsupport σ hσ B r hB hr
+    (FirstHeightSupport.stoppedNarrowCertificate γ σ B Tc) _
+    F hF a O W hO hW β tB T htB htBT hβ hi hβH hcross hafter hcircle hsector htail hend
+  intro ω hω
+  exact (FirstHeightSupport.bounded_certificate_geometry
+    (sourceTracePath γ (fun ω => (hw ω).1) ω)
+    (hw ω).2.1 (hw ω).2.2.1 hB Tc hω).2
+
+/-- Actual bounded-height splice support combined with varying early events
+produces one positive probability for the whole sequence of charts. -/
+theorem bounded_firstHeight_splice_varying_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) :
+    let ℱ := Filtration.natural B₀ (fun t => (hm t).stronglyMeasurable)
+    let σ := fun ω => FirstHeightSupport.boundedFirstHeightTime (γ ω) B Tc
+    let hσ := FirstHeightSupport.boundedFirstHeightTime_isStoppingTime ℱ γ
+      (brownian_capacity_trace_adapted B₀ hm hc κ γ G F₀ hw) (fun ω => (hw ω).1) B Tc
+    let E := FirstHeightSupport.stoppedNarrowCertificate γ σ B Tc
+    let C := stoppedPhysicalTube γ σ (parameterContinuationRegion F a r O) W
+    ∀ H : ℕ → Set Ω, (∀ n, MeasurableSet[hσ.measurableSpace] (H n)) →
+      0 < P E → (∀ n, P (E \ H n) ≤ P E / 2) →
+      ∃ q : ℝ≥0∞, 0 < q ∧ ∀ n, q ≤ P (E ∩ H n ∩ C) := by
+  dsimp only
+  let : IsProbabilityMeasure P := hB₀.isGaussianProcess.isProbabilityMeasure
+  let ℱ := Filtration.natural B₀ (fun t => (hm t).stronglyMeasurable)
+  let σ := fun ω => FirstHeightSupport.boundedFirstHeightTime (γ ω) B Tc
+  have ha := brownian_capacity_trace_adapted B₀ hm hc κ γ G F₀ hw
+  have hσ := FirstHeightSupport.boundedFirstHeightTime_isStoppingTime ℱ γ ha
+    (fun ω => (hw ω).1) B Tc
+  let E := FirstHeightSupport.stoppedNarrowCertificate γ σ B Tc
+  let C := stoppedPhysicalTube γ σ (parameterContinuationRegion F a r O) W
+  intro H hH hEpos hmissing
+  have hE : MeasurableSet[hσ.measurableSpace] E :=
+    FirstHeightSupport.boundedFirstHeight_certificate_measurable ℱ γ ha
+      (fun ω => (hw ω).1) B Tc
+  have hγm (t : ℝ≥0) : Measurable (fun ω => γ ω t) :=
+    (ha t).mono (ℱ.le t) le_rfl
+  have hC : MeasurableSet C := measurableSet_stoppedPhysicalTube γ
+    (fun ω => (hw ω).1) hγm σ (stopping_time_measurable_nnreal hσ)
+    (parameterContinuationRegion F a r O) W
+    (parameterContinuationRegion_isOpen hF a r hO) hW
+  have hpass := bounded_firstHeight_splice_positive κ 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
+  exact varying_passage_events_lower_bound P hσ.measurableSpace hσ.measurableSpace_le
+    E C H hE hC hH hEpos hpass hmissing
+
+end SLEExactGauge
+
+end
+
+end OAI
diff --git a/lean/OAI/Probability/SLE/Geometry/BoundedTerminalMean.lean b/lean/OAI/Probability/SLE/Geometry/BoundedTerminalMean.lean
new file mode 100644
index 0000000000000000000000000000000000000000..2036a37dda26e0f8de0be855a03d5f53551a7af3
--- /dev/null
+++ b/lean/OAI/Probability/SLE/Geometry/BoundedTerminalMean.lean
@@ -0,0 +1,60 @@
+import OAI.Probability.SLE.Mass.RationalCanonicalMass
+import OAI.Probability.SLE.SimpleTails
+
+namespace OAI
+
+/-! The canonical mass has finite expected mass on bounded physical sets,
+including sets that approach the real boundary. Compactness inside the
+half-plane is not needed for the upper-cover charge. -/
+noncomputable section
+open Set Filter MeasureTheory Metric
+open scoped ENNReal NNReal
+
+namespace SLEExactGauge.Multipoint
+
+lemma initialGreenMeasure_bounded_ball_lt_top {κ : ℝ} (hκ : 0<κ) (hκ8 : κ<8)
+    (R : ℝ) :
+    initialGreenMeasure κ (Subtype.val ⁻¹' closedBall (0:ℂ) R) < ∞ := by
+  let A : Set upperHalfPlane := Subtype.val ⁻¹' closedBall (0:ℂ) R
+  have hA : MeasurableSet A := isClosed_closedBall.measurableSet.preimage
+    continuous_subtype_val.measurable
+  have hI : MeasurableSet ((Subtype.val : upperHalfPlane → ℂ) '' A) :=
+    (MeasurableEmbedding.subtype_coe isOpen_upperHalfPlane.measurableSet).measurableSet_image.mpr hA
+  have hsub : (Subtype.val : upperHalfPlane → ℂ) '' A ⊆ closedBall 0 R := by
+    rintro _ ⟨z,hz,rfl⟩
+    exact hz
+  have hi : IntegrableOn (fun z : ℂ => (2:ℝ)^(-codimension κ)*|z.im|^(-codimension κ))
+      (closedBall 0 R) volume :=
+    (integrable_height_power_ball (codimension κ) R (codimension_lt_one κ hκ)).const_mul _
+  change initialGreenMeasure κ A < ∞
+  rw [initialGreenMeasure,comap_subtype_coe_apply isOpen_upperHalfPlane.measurableSet,
+    withDensity_apply _ hI]
+  refine lt_of_le_of_lt ?_ (lintegral_ofReal_lt_top_of_integrable hi)
+  calc
+    (∫⁻ z in (Subtype.val : upperHalfPlane → ℂ) '' A, ENNReal.ofReal (initialGreen κ z)) ≤
+        ∫⁻ z in (Subtype.val : upperHalfPlane → ℂ) '' A,
+          ENNReal.ofReal ((2:ℝ)^(-codimension κ)*|z.im|^(-codimension κ)) := by
+      apply setLIntegral_mono' hI
+      rintro z ⟨w,_,rfl⟩
+      apply ENNReal.ofReal_le_ofReal
+      simpa only [abs_of_pos (show 0<(w:ℂ).im from w.property)] using
+        initialGreen_le_height κ hκ hκ8 w w.property
+    _ ≤ _ := lintegral_mono' (Measure.restrict_mono hsub le_rfl) le_rfl
+
+lemma RationalCanonicalMass.terminal_bounded_mean_lt_top
+    {Ω : Type*} [MeasurableSpace Ω] {P : Measure Ω} {κ : ℝ}
+    {B : ℝ≥0 → Ω → ℝ} {hBm : Measurable (Function.uncurry B)}
+    {γ : Ω → ℝ≥0 → ℂ} {G : Ω → ℝ≥0 → ℂ → ℂ}
+    (C : RationalCanonicalMass P κ B hBm γ G) (hκ : 0<κ) (hκ8 : κ<8)
+    (R : ℝ) :
+    (∫⁻ ω, C.terminal ω (Subtype.val ⁻¹' closedBall (0:ℂ) R) ∂P) < ∞ := by
+  rw [← Measure.bind_apply
+    (isClosed_closedBall.measurableSet.preimage continuous_subtype_val.measurable)
+    C.terminal_measurable.aemeasurable,C.mean]
+  exact initialGreenMeasure_bounded_ball_lt_top hκ hκ8 R
+
+end SLEExactGauge.Multipoint
+
+end
+
+end OAI
diff --git a/lean/OAI/Probability/SLE/Geometry/CanonicalBoundaryLimit.lean b/lean/OAI/Probability/SLE/Geometry/CanonicalBoundaryLimit.lean
new file mode 100644
index 0000000000000000000000000000000000000000..7b2334bb659893e772bd9fe7dd2b682bf61e30aa
--- /dev/null
+++ b/lean/OAI/Probability/SLE/Geometry/CanonicalBoundaryLimit.lean
@@ -0,0 +1,72 @@
+import OAI.Probability.SLE.Loewner.CanonicalTraceCandidate
+import OAI.Probability.SLE.Loewner.TargetBoundaryLimit
+import OAI.Probability.SLE.Geometry.FiniteParameterProjection
+
+namespace OAI
+
+/-! A continuous canonical trace modification with the exact inverse-tip
+limit simultaneously at every time, obtained from an actual source witness. -/
+noncomputable section
+open Set Filter _root_.MeasureTheory _root_.OAI.MeasureTheory ProbabilityTheory
+open scoped Topology NNReal ENNReal
+
+namespace SLEExactGauge
+
+local instance boundaryRealMeasurable : MeasurableSpace C(ℝ≥0,ℝ) := borel _
+local instance boundaryRealBorel : BorelSpace C(ℝ≥0,ℝ) := ⟨rfl⟩
+local instance boundaryComplexMeasurable : MeasurableSpace C(ℝ≥0,ℂ) := borel _
+local instance boundaryComplexBorel : BorelSpace C(ℝ≥0,ℂ) := ⟨rfl⟩
+local instance boundaryDriverPolish : PolishSpace Target.Driver :=
+  ContinuousMapZero.isClosedEmbedding_toContinuousMap.polishSpace
+local instance boundaryDriverMetric : MetricSpace Target.Driver :=
+  TopologicalSpace.metrizableSpaceMetric Target.Driver
+
+theorem exists_canonical_all_time_boundary_limit
+    {Ω : 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 ω))
+    (h0 : ∀ ω, B 0 ω=0) (γ : Ω → ℝ≥0 → ℂ) (G F : Ω → ℝ≥0 → ℂ → ℂ)
+    (hw : ∀ ω, IsCapacityTwoWitness (fun t => Real.sqrt κ*B t ω) (γ ω) (G ω) (F ω))
+    (W : Target.WienerLaw) (hW : Target.IsWiener W) :
+    ∃ Ψ : Target.Driver → C(ℝ≥0,ℂ), Measurable Ψ ∧
+      (∀ ω, Ψ (Target.normalizedDriver κ B hc h0 ω)=sourceTracePath γ (fun ω => (hw ω).1) ω) ∧
+      ∀ᵐ b ∂W, Ψ b 0=0 ∧ (∀ T, 0 ≤ (Ψ b T).im) ∧
+        ∀ T, Tendsto (fun y => Target.rawTipAt κ T y b) (𝓝[>] 0) (𝓝 (Ψ b T)) := by
+  have : IsProbabilityMeasure W := hW.isGaussianProcess.isProbabilityMeasure
+  obtain ⟨Ψ,hΨ,hΨeq,_⟩ := exists_canonical_trace_candidate_modification
+    κ hκ hκ8 B hB hm hc h0 γ G F hw W hW
+  let p (T : ℝ≥0) (b : Target.Driver) : Prop :=
+    Ψ b 0=0 ∧ 0 ≤ (Ψ b T).im ∧
+      Tendsto (fun y => Target.rawTipAt κ T y b) (𝓝[>] 0) (𝓝 (Ψ b T))
+  have hEval : Measurable (fun q : ℝ≥0 × Target.Driver => Ψ q.2 q.1) :=
+    continuous_eval.measurable.comp ((hΨ.comp measurable_snd).prodMk measurable_fst)
+  have hEval0 : Measurable (fun q : ℝ≥0 × Target.Driver => Ψ q.2 0) :=
+    ((continuous_eval_const 0).measurable.comp hΨ).comp measurable_snd
+  have hp : MeasurableSet {q : ℝ≥0 × Target.Driver | p q.1 q.2} :=
+    (measurableSet_eq_fun hEval0 measurable_const).inter
+      ((measurableSet_le measurable_const hEval.im).inter
+        (Target.joint_measurableSet_rawTipAt_tendsto κ hκ _ hEval))
+  have hLaw := Target.normalizedDriver_law κ hκ B hB hm hc h0 W hW
+  have hsource : ∀ᵐ ω ∂P, ∀ T, p T (Target.normalizedDriver κ B hc h0 ω) := by
+    apply ae_of_all
+    intro ω T
+    have he (t : ℝ≥0) : Ψ (Target.normalizedDriver κ B hc h0 ω) t=γ ω t := by
+      have h := congrArg (fun e : C(ℝ≥0,ℂ) => e t) (hΨeq ω)
+      simpa only [sourceTracePath,ContinuousMap.coe_mk] using h
+    refine ⟨(he 0).trans (hw ω).2.1,?_,?_⟩
+    · rw [he]
+      exact (hw ω).2.2.1 T
+    · simpa only [he] using Target.rawTipAt_tendsto_witness κ hκ
+        (Target.normalizedDriver κ B hc h0 ω) (fun t => Real.sqrt κ*B t ω)
+        (γ ω) (G ω) (F ω) (hw ω) (Target.normalizedDriver_matches κ hκ B hc h0 ω) T
+  have hall := ae_forall_parameter_of_hasLaw hLaw p hp hsource
+  refine ⟨Ψ,hΨ,hΨeq,?_⟩
+  filter_upwards [hall] with b hb
+  exact ⟨(hb 0).1,fun T => (hb T).2.1,fun T => (hb T).2.2⟩
+
+end SLEExactGauge
+
+end
+
+end OAI
diff --git a/lean/OAI/Probability/SLE/Geometry/CanonicalCoefficientIntegrability.lean b/lean/OAI/Probability/SLE/Geometry/CanonicalCoefficientIntegrability.lean
new file mode 100644
index 0000000000000000000000000000000000000000..f466239e604f33b63b350ad1b896c6b83c9f30d2
--- /dev/null
+++ b/lean/OAI/Probability/SLE/Geometry/CanonicalCoefficientIntegrability.lean
@@ -0,0 +1,83 @@
+import OAI.Probability.SLE.Gauge.DensityWeightedMoments
+import OAI.Probability.SLE.Geometry.NormalizedStoppedDisk
+import OAI.Probability.SLE.Geometry.OuterCoefficientLimit
+import OAI.Probability.SLE.Gauge.MomentUnclipping
+
+namespace OAI
+
+/-! Integrability and removal of the exact coefficient's clipping,
+using the canonical terminal disk moment as a dominator. -/
+
+noncomputable section
+open Set Filter _root_.MeasureTheory _root_.OAI.MeasureTheory ProbabilityTheory
+open scoped NNReal ENNReal Topology
+
+namespace SLEExactGauge.Multipoint.CanonicalMass
+
+variable {Ω : Type*} [MeasurableSpace Ω] {P : Measure Ω} {κ : ℝ}
+  {B : ℝ≥0 → Ω → ℝ} {hBm : Measurable (Function.uncurry B)}
+  {γ : Ω → ℝ≥0 → ℂ} {G : Ω → ℝ≥0 → ℂ → ℂ}
+  (C : CanonicalMass P κ B hBm γ G)
+
+lemma density_disk_terminal_integrable
+    (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 ω))
+    (hgrowth : PublishedDiskUnivalentGrowth) (m : ℕ)
+    (θ : ℝ) (hθ : θ∈Ioo (0:ℝ) Real.pi) (ℓ : ℝ) (hℓ : 0≤ℓ) :
+    Integrable (fun ω => Target.levelDensity κ θ (Target.normalizedDriver κ B hc h0 ω) ℓ *
+      (C.diskTerminalScalar θ hθ ω)^m) P := by
+  obtain ⟨M,hM,hbound⟩ := C.uniform_density_disk_terminal_moments hB hc h0 hκ hκ8 F hw hgrowth m
+  have hb := Target.normalizedDriver_measurable κ B
+    (fun r => (hBm.comp (measurable_const.prodMk measurable_id) : Measurable (B r))) hc h0
+  have hwM := (Target.measurable_fixedLevelDensity κ θ ℓ).comp hb
+  have hzM : Measurable (C.diskTerminalScalar θ hθ) := (compactWeightedMass_measurable _ _ (Target.diskSourceHalfPlane_compact hθ).measurableSet).comp
+    C.rational.terminal_measurable
+  have hnonneg (ω) : 0≤Target.levelDensity κ θ (Target.normalizedDriver κ B hc h0 ω) ℓ *
+      (C.diskTerminalScalar θ hθ ω)^m :=
+    mul_nonneg (Target.levelDensity_nonneg_of_witness κ hκ _ _ ((hc ω).const_mul _)
+      (γ ω) (G ω) (F ω) (hw ω) (Target.normalizedDriver_matches κ hκ B hc h0 ω) θ hθ ℓ hℓ)
+      (pow_nonneg (compactWeightedMass_nonneg _ _ _) m)
+  apply (lintegral_ofReal_ne_top_iff_integrable (hwM.mul (hzM.pow_const m)).aestronglyMeasurable
+    (Eventually.of_forall hnonneg)).mp
+  exact ne_top_of_lt ((hbound θ hθ ℓ hℓ).trans_lt (ENNReal.mul_lt_top hM ENNReal.ofReal_lt_top))
+
+theorem clippedCoefficient_unclip_limit [IsProbabilityMeasure P]
+    (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 ω))
+    (hgrowth : PublishedDiskUnivalentGrowth) (W : Target.WienerLaw) (hW : Target.IsWiener W)
+    (θ : ℝ) (hθ : θ∈Ioo (0:ℝ) Real.pi) (ℓ : ℝ) (hℓ : 0≤ℓ) (m : ℕ) :
+    Tendsto (fun n : ℕ => Target.clippedCoefficient κ W ℓ n m θ) atTop
+      (𝓝 (∫ ω, Target.levelDensity κ θ (Target.normalizedDriver κ B hc h0 ω) ℓ *
+        (massAtExtendedTime (fun t => C.normalizedDiskScalar θ hθ t ω)
+          (C.diskTerminalScalar θ hθ ω)
+          (Target.levelTime κ θ (Target.normalizedDriver κ B hc h0 ω) ℓ))^m ∂P)) := by
+  let T := fun ω => Target.levelTime κ θ (Target.normalizedDriver κ B hc h0 ω) ℓ
+  let Y := fun ω => massAtExtendedTime (fun t => C.normalizedDiskScalar θ hθ t ω)
+    (C.diskTerminalScalar θ hθ ω) (T ω)
+  let w := fun ω => Target.levelDensity κ θ (Target.normalizedDriver κ B hc h0 ω) ℓ
+  have hT : Measurable T := normalized_levelTime_measurable (hBm:=hBm) hκ hc h0 F hw θ ℓ hℓ
+  have hY : Measurable Y := C.normalizedStoppedDisk_measurable θ hθ T hT
+  have hwM : Measurable w := (Target.measurable_fixedLevelDensity κ θ ℓ).comp
+    (Target.normalizedDriver_measurable κ B
+      (fun r => (hBm.comp (measurable_const.prodMk measurable_id) : Measurable (B r))) hc h0)
+  have hd : ∀ᵐ ω ∂P, 0≤w ω ∧ 0≤Y ω ∧ Y ω≤C.diskTerminalScalar θ hθ ω := by
+    filter_upwards [C.normalizedStoppedDisk_le_terminal hκ θ hθ T] with ω hω
+    exact ⟨Target.levelDensity_nonneg_of_witness κ hκ _ _ ((hc ω).const_mul _)
+      (γ ω) (G ω) (F ω) (hw ω) (Target.normalizedDriver_matches κ hκ B hc h0 ω) θ hθ ℓ hℓ,
+      C.normalizedStoppedDisk_nonneg θ hθ (T ω) ω,hω⟩
+  have ht := weighted_unclip_pow_tendsto P Y (C.diskTerminalScalar θ hθ) w
+    hY.aestronglyMeasurable hwM.aestronglyMeasurable hd m
+    (C.density_disk_terminal_integrable hB hc h0 hκ hκ8 F hw hgrowth m θ hθ ℓ hℓ)
+  apply ht.congr'
+  filter_upwards [] with n
+  exact (C.clippedCoefficient_eq_mass hB hκ hκ8 hc h0 F hw W hW θ hθ ℓ hℓ n (Nat.cast_nonneg n) m).symm
+
+end SLEExactGauge.Multipoint.CanonicalMass
+
+end
+
+end OAI
diff --git a/lean/OAI/Probability/SLE/Geometry/CanonicalCompactPotential.lean b/lean/OAI/Probability/SLE/Geometry/CanonicalCompactPotential.lean
new file mode 100644
index 0000000000000000000000000000000000000000..eb93378c1e4fbd4ab136b5317ce47c719158bbe9
--- /dev/null
+++ b/lean/OAI/Probability/SLE/Geometry/CanonicalCompactPotential.lean
@@ -0,0 +1,118 @@
+import OAI.Probability.SLE.Geometry.WeightedCompactKernel
+import OAI.Probability.SLE.Mass.CanonicalMassFirstVisit
+import OAI.Probability.SLE.Geometry.CanonicalGreenPast
+
+namespace OAI
+
+/-! The current Green potential of a compact weighted mass is the
+conditional expectation of its remaining terminal mass. -/
+
+noncomputable section
+open Set Filter _root_.MeasureTheory _root_.OAI.MeasureTheory ProbabilityTheory
+open scoped Topology NNReal ENNReal
+
+namespace SLEExactGauge.Multipoint
+
+local instance compactPotentialDriverMeasurable : MeasurableSpace C(ℝ≥0,ℝ) := borel _
+local instance compactPotentialDriverBorel : BorelSpace C(ℝ≥0,ℝ) := ⟨rfl⟩
+
+lemma compactWeightedMass_add
+    (w : C(upperHalfPlane,ℝ≥0)) (K : Set upperHalfPlane) (hK : IsCompact K)
+    (μ ν : Measure upperHalfPlane)
+    [IsFiniteMeasureOnCompacts μ] [IsFiniteMeasureOnCompacts ν] :
+    compactWeightedMass w K (μ+ν)=compactWeightedMass w K μ+compactWeightedMass w K ν := by
+  unfold compactWeightedMass
+  rw [Measure.restrict_add]
+  exact integral_add_measure (compact_weight_integrable w K hK μ)
+    (compact_weight_integrable w K hK ν)
+
+lemma halfPlaneGreenMeasure_measurable_past
+    {Ω : Type*} [mΩ : MeasurableSpace Ω] {B : ℝ≥0 → Ω → ℝ}
+    (hm : ∀ t, Measurable (B t)) (hc : ∀ ω, Continuous (fun t => B t ω))
+    (κ : ℝ) (γ : Ω → ℝ≥0 → ℂ) (G F : Ω → ℝ≥0 → ℂ → ℂ)
+    (hw : ∀ ω, IsCapacityTwoWitness (fun t => Real.sqrt κ*B t ω) (γ ω) (G ω) (F ω))
+    (t : ℝ≥0) :
+    Measurable[(Filtration.natural B (fun s => (hm s).stronglyMeasurable)) t]
+      (halfPlaneGreenMeasure κ B γ G t) := by
+  let ℱ := Filtration.natural B (fun s => (hm s).stronglyMeasurable)
+  have hp : Measurable[ℱ t,driverPathFiltration t] (sourceDriverPath B hc) :=
+    driverPath_measurable_past_of_adapted ℱ _
+      (fun s => (Filtration.stronglyAdapted_natural (fun s => (hm s).stronglyMeasurable) s).measurable) t
+  have h := (canonicalGreenMass_measurable_past κ t).comp hp
+  convert h using 1
+  funext ω
+  exact (canonicalGreenMass_eq κ (sourceDriverPath B hc ω) (hw ω) t).symm
+
+namespace CanonicalMass
+
+variable {Ω : Type*} [mΩ : MeasurableSpace Ω] {P : Measure Ω}
+  [IsProbabilityMeasure P] {κ : ℝ}
+  {B : ℝ≥0 → Ω → ℝ} {hBm : Measurable (Function.uncurry B)}
+  {γ : Ω → ℝ≥0 → ℂ} {G : Ω → ℝ≥0 → ℂ → ℂ}
+  (C : CanonicalMass P κ B hBm γ G)
+
+lemma compact_potential_condExp
+    (hc : ∀ ω, Continuous (fun t => B t ω)) (F : Ω → ℝ≥0 → ℂ → ℂ)
+    (hw : ∀ ω, IsCapacityTwoWitness (fun t => Real.sqrt κ*B t ω) (γ ω) (G ω) (F ω))
+    (w : C(upperHalfPlane,ℝ≥0)) (K : Set upperHalfPlane) (hK : IsCompact K)
+    (t : ℝ≥0) :
+    (fun ω => compactWeightedMass w K (halfPlaneGreenMeasure κ B γ G t ω)) =ᵐ[P]
+      P[(fun ω => compactWeightedMass w K (C.rational.terminal ω)-
+        compactWeightedMass w K (C.process t ω)) |
+          (Filtration.natural B (fun r =>
+            (hBm.comp (measurable_const.prodMk measurable_id) : Measurable (B r)).stronglyMeasurable)) t] := by
+  let ℱ := Filtration.natural B (fun r =>
+    (hBm.comp (measurable_const.prodMk measurable_id) : Measurable (B r)).stronglyMeasurable)
+  let V := halfPlaneGreenMeasure κ B γ G t
+  have hVp : Measurable[ℱ t] V := halfPlaneGreenMeasure_measurable_past
+    (fun r => hBm.comp (measurable_const.prodMk measurable_id)) hc κ γ G F hw t
+  have hVm : Measurable V := hVp.mono (ℱ.le t) le_rfl
+  have hk (E : Set Ω) (hE : MeasurableSet[ℱ t] E) :
+      (P.restrict E).bind C.rational.terminal =
+        (P.restrict E).bind (C.process t)+(P.restrict E).bind V := by
+    have hs := isStoppingTime_const ℱ t
+    have hES : MeasurableSet[hs.measurableSpace] E := by
+      rw [IsStoppingTime.measurableSpace_const]
+      exact hE
+    have h := C.kernel (fun _ => (t:WithTop ℝ≥0)) hs E hES
+    change (P.restrict E).bind C.rational.terminal =
+      (P.restrict E).bind (C.process t)+
+        (P.restrict E).bind (halfPlaneStoppingGreenMeasure κ B γ G (fun _ => (t:ℝ≥0∞))) at h
+    rwa [halfPlaneStoppingGreenMeasure_const] at h
+  have hVbound (E : Set Ω) (hE : MeasurableSet[ℱ t] E) :
+      (P.restrict E).bind V ≤ initialGreenMeasure κ := by
+    apply le_trans _ (C.uniqueness_terminal_mean_le E)
+    rw [hk E hE]
+    exact Measure.le_add_left le_rfl
+  have hVL := compactWeightedMass_kernel_integrable P κ V hVm
+    (by simpa only [Measure.restrict_univ] using hVbound univ MeasurableSet.univ) w K hK
+  have hNL := compactWeightedMass_kernel_integrable P κ (C.process t)
+    C.progressive.adapted.measurable
+    (by simpa only [Measure.restrict_univ] using C.uniqueness_process_mean_le t univ) w K hK
+  have hTL := compactWeightedMass_kernel_integrable P κ C.rational.terminal
+    C.rational.terminal_measurable (by rw [C.rational.mean]) w K hK
+  apply ae_eq_condExp_of_forall_setIntegral_eq (ℱ.le t) (hTL.1.sub hNL.1)
+    (fun E _ _ => hVL.1.integrableOn) ?_
+    (((compactWeightedMass_measurable w K hK.measurableSet).comp hVp).aestronglyMeasurable)
+  intro E hE _
+  have hVE := (compactWeightedMass_kernel_integrable (P.restrict E) κ V hVm (hVbound E hE) w K hK).2
+  have hNE := (compactWeightedMass_kernel_integrable (P.restrict E) κ (C.process t)
+    C.progressive.adapted.measurable (C.uniqueness_process_mean_le t E) w K hK).2
+  have hTE := (compactWeightedMass_kernel_integrable (P.restrict E) κ C.rational.terminal
+    C.rational.terminal_measurable (C.uniqueness_terminal_mean_le E) w K hK).2
+  let : IsFiniteMeasureOnCompacts (initialGreenMeasure κ) := initialGreenMeasure_finite_on_compacts κ
+  let : IsFiniteMeasureOnCompacts ((P.restrict E).bind (C.process t)) :=
+    ⟨fun A hA => lt_of_le_of_lt (C.uniqueness_process_mean_le t E A) hA.measure_lt_top⟩
+  let : IsFiniteMeasureOnCompacts ((P.restrict E).bind V) :=
+    ⟨fun A hA => lt_of_le_of_lt (hVbound E hE A) hA.measure_lt_top⟩
+  simp only [Pi.sub_apply]
+  rw [integral_sub hTL.1.integrableOn hNL.1.integrableOn,hVE,hTE,hNE,hk E hE,
+    compactWeightedMass_add w K hK]
+  ring
+
+end CanonicalMass
+end SLEExactGauge.Multipoint
+
+end
+
+end OAI
diff --git a/lean/OAI/Probability/SLE/Geometry/CanonicalDiskPositive.lean b/lean/OAI/Probability/SLE/Geometry/CanonicalDiskPositive.lean
new file mode 100644
index 0000000000000000000000000000000000000000..59f0621ec36179287750f4daafeb58b19436e0c3
--- /dev/null
+++ b/lean/OAI/Probability/SLE/Geometry/CanonicalDiskPositive.lean
@@ -0,0 +1,112 @@
+import OAI.Probability.SLE.Angle.TargetDiskVisit
+import OAI.Probability.SLE.Mass.PositiveTraceMass
+import OAI.Probability.SLE.Gauge.CenteredMomentJensen
+
+namespace OAI
+
+/-! Strict positivity of the exact finite-level disk coefficients. -/
+
+noncomputable section
+open Set Filter _root_.MeasureTheory _root_.OAI.MeasureTheory Metric ProbabilityTheory
+open scoped Topology NNReal ENNReal
+
+namespace SLEExactGauge.Multipoint
+
+lemma compactWeightedMass_pos (w : C(upperHalfPlane,ℝ≥0))
+    (hw : ∀ z, 0<w z) (K : Set upperHalfPlane) (hK : IsCompact K)
+    (μ : Measure upperHalfPlane) [IsFiniteMeasureOnCompacts μ] (hμ : 0<μ K) :
+    0<compactWeightedMass w K μ := by
+  rw [compactWeightedMass,integral_pos_iff_support_of_nonneg
+    (fun z => (w z).coe_nonneg) (compact_weight_integrable w K hK μ)]
+  have hs : Function.support (fun z => (w z:ℝ))=univ := by
+    ext z
+    simp only [Function.mem_support,mem_univ,iff_true]
+    exact ne_of_gt (show (0:ℝ)<w z from hw z)
+  rw [hs,Measure.restrict_apply_univ]
+  exact hμ
+
+namespace CanonicalMass
+
+variable {Ω : Type*} [mΩ : MeasurableSpace Ω] {P : Measure Ω} [IsProbabilityMeasure P]
+  {κ : ℝ} {B : ℝ≥0 → Ω → ℝ} {hBm : Measurable (Function.uncurry B)}
+  {γ : Ω → ℝ≥0 → ℂ} {G : Ω → ℝ≥0 → ℂ → ℂ}
+  (C : CanonicalMass P κ B hBm γ G)
+
+lemma centered_diskScalar_positive
+    (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 ω))
+    (hpublished : PublishedTraceGeneration (P.map (sourceDriverPath B hc)) κ (fun t p => p t))
+    (θ : ℝ) (hθ : θ∈Ioo (0:ℝ) Real.pi) (u : ℝ) (hu : 0≤u)
+    (hsmall : Real.exp (-u)<1/8) :
+    ∀ᵐ ω ∂finiteCenteredLaw P κ B γ G (Target.diskMapInv θ 0) u,
+      0<C.diskScalar θ hθ (radiusLevelTime (γ ω) (G ω) (Target.diskMapInv θ 0) u).toNNReal ω := by
+  let z := Target.diskMapInv θ 0
+  have hz : z∈upperHalfPlane := Target.diskMapInv_maps hθ (by simp)
+  have hl := finiteCenteredLaw_live_compact hB κ hκ hκ8 γ G F (Eventually.of_forall hw) z hz u hu
+  have hac : finiteCenteredLaw P κ B γ G z u ≪ P := withDensity_absolutelyContinuous P _
+  have hp := hac.ae_le
+    (C.positive_open_visited hB hc h0 hκ F hw hpublished)
+  filter_upwards [hl,hp] with ω hω hpω
+  obtain ⟨t,_,_,ht,_⟩ := hω
+  have hf : radiusLevelTime (γ ω) (G ω) z u≠∞ := by rw [ht]; exact ENNReal.coe_ne_top
+  obtain ⟨s,hs,hst,hvisit⟩ := Target.radius_level_visits_diskSource ((hc ω).const_mul _) (hw ω)
+    θ hθ u hsmall hf
+  have hpos := hpω (ball z (z.im/4)) isOpen_ball s
+    (radiusLevelTime (γ ω) (G ω) z u).toNNReal hs hst hvisit
+  have hmass : 0<C.process (radiusLevelTime (γ ω) (G ω) z u).toNNReal ω
+      (Target.diskSourceHalfPlane θ) :=
+    hpos.trans_le (measure_mono (preimage_mono (Target.marked_ball_subset_diskSource hθ)))
+  let := (C.radon (radiusLevelTime (γ ω) (G ω) z u).toNNReal ω).2
+  apply compactWeightedMass_pos _ _ _ (Target.diskSourceHalfPlane_compact hθ) _ hmass
+  intro v
+  apply NNReal.coe_pos.mp
+  rw [Target.diskMassWeight_coe]
+  exact Real.rpow_pos_of_pos (Target.diskMap_deriv_pos hθ v.property) _
+
+include C in
+lemma levelCoefficient_positive
+    (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 ω))
+    (hpublished : PublishedTraceGeneration (P.map (sourceDriverPath B hc)) κ (fun t p => p t))
+    (hgrowth : PublishedDiskUnivalentGrowth) (W : Target.WienerLaw) (hW : Target.IsWiener W)
+    (θ : ℝ) (hθ : θ∈Ioo (0:ℝ) Real.pi) (ℓ : ℝ) (hℓ : 0≤ℓ)
+    (hsmall : Real.exp (-(4*ℓ/κ))<1/8) :
+    0<Target.levelCoefficient κ W ℓ 1 θ := by
+  let z := Target.diskMapInv θ 0
+  let u := 4*ℓ/κ
+  have hu : 0≤u := div_nonneg (mul_nonneg (by norm_num) hℓ) hκ.le
+  let σ := fun ω => (radiusLevelTime (γ ω) (G ω) z u : WithTop ℝ≥0)
+  have hσ := actual_radiusLevelTime_stopping hB
+    (fun r => (hBm.comp (measurable_const.prodMk measurable_id) : Measurable (B r)))
+    hBm hc h0 κ hκ hκ8 γ G F hw z (Target.diskMapInv_maps hθ (by simp)) u hu
+  have heσ : ∀ᵐ ω ∂P, σ ω=radiusLevelTime (γ ω) (G ω) z u := Eventually.of_forall (fun _ => rfl)
+  let Q := finiteCenteredLaw P κ B γ G z u
+  let : IsProbabilityMeasure Q := finiteCenteredLaw_probability hB κ hκ hκ8 γ G F
+    (Eventually.of_forall hw) z (Target.diskMapInv_maps hθ (by simp)) u hu
+  obtain ⟨hi,he⟩ := C.centered_diskScalar_integrable_eq hB hc h0 hκ hκ8 F hw hgrowth W hW θ hθ ℓ hℓ 1 σ hσ heσ
+  rw [he]
+  simp only [pow_one] at hi ⊢
+  have hfinite := finiteCenteredLaw_earlier_stop_ae_finite hB hc κ hκ hκ8 γ G F
+    (Eventually.of_forall hw) z (Target.diskMapInv_maps hθ (by simp)) u u hu le_rfl σ
+    (Eventually.of_forall (fun _ => le_rfl))
+  have hp := C.centered_diskScalar_positive hB hc h0 hκ hκ8 F hw hpublished θ hθ u hu hsmall
+  have hpos : ∀ᵐ ω ∂Q, 0<finiteStoppedScalar (C.diskScalar θ hθ) σ ω := by
+    filter_upwards [hfinite,hp] with ω hf hpω
+    simpa only [finiteStoppedScalar,ite_eq_right hf,σ,ENNReal.toNNReal] using hpω
+  apply (integral_pos_iff_support_of_nonneg_ae (hpos.mono (fun _ h => h.le)) hi).2
+  have hevent : Q (Function.support (finiteStoppedScalar (C.diskScalar θ hθ) σ))=Q univ :=
+    measure_congr (hpos.mono (fun ω h => propext
+      (show finiteStoppedScalar (C.diskScalar θ hθ) σ ω≠0 ↔ True from iff_true_intro h.ne')))
+  rw [hevent,measure_univ]
+  exact zero_lt_one
+
+end CanonicalMass
+end SLEExactGauge.Multipoint
+
+end
+
+end OAI
diff --git a/lean/OAI/Probability/SLE/Geometry/CanonicalDiskPotential.lean b/lean/OAI/Probability/SLE/Geometry/CanonicalDiskPotential.lean
new file mode 100644
index 0000000000000000000000000000000000000000..eb7f27d2bba38524ac58dcfeed71744b0ade5d8f
--- /dev/null
+++ b/lean/OAI/Probability/SLE/Geometry/CanonicalDiskPotential.lean
@@ -0,0 +1,73 @@
+import OAI.Probability.SLE.Angle.TargetDiskMass
+import OAI.Probability.SLE.Geometry.CanonicalCompactPotential
+
+namespace OAI
+
+/-! The source-prescribed disk potential is the remaining canonical disk
+mass, with exactly the source's Brownian clock normalization. -/
+
+noncomputable section
+open Set Filter _root_.MeasureTheory _root_.OAI.MeasureTheory ProbabilityTheory
+open scoped Topology NNReal ENNReal
+
+namespace SLEExactGauge.Multipoint.CanonicalMass
+
+variable {Ω : Type*} [mΩ : MeasurableSpace Ω] {P : Measure Ω} {κ : ℝ}
+  {B : ℝ≥0 → Ω → ℝ} {hBm : Measurable (Function.uncurry B)}
+  {γ : Ω → ℝ≥0 → ℂ} {G : Ω → ℝ≥0 → ℂ → ℂ}
+  (C : CanonicalMass P κ B hBm γ G)
+
+def diskScalar (θ : ℝ) (hθ : θ ∈ Ioo (0:ℝ) Real.pi) (t : ℝ≥0) (ω : Ω) : ℝ :=
+  compactWeightedMass (Target.diskMassWeight κ θ hθ) (Target.diskSourceHalfPlane θ) (C.process t ω)
+
+def diskTerminalScalar (θ : ℝ) (hθ : θ ∈ Ioo (0:ℝ) Real.pi) (ω : Ω) : ℝ :=
+  compactWeightedMass (Target.diskMassWeight κ θ hθ) (Target.diskSourceHalfPlane θ)
+    (C.rational.terminal ω)
+
+theorem target_potential_condExp [IsProbabilityMeasure P]
+    (hκ : 0 < κ) (hc : ∀ ω, Continuous (fun t => B t ω))
+    (F : Ω → ℝ≥0 → ℂ → ℂ)
+    (hw : ∀ ω, IsCapacityTwoWitness (fun t => Real.sqrt κ*B t ω) (γ ω) (G ω) (F ω))
+    (b : Ω → Target.Driver)
+    (hU : ∀ ω (s : ℝ), 0 ≤ s → Real.sqrt κ*B s.toNNReal ω=Target.driverValue (b ω) (κ*s))
+    (θ : ℝ) (hθ : θ ∈ Ioo (0:ℝ) Real.pi) (t : ℝ≥0) :
+    (fun ω => (Target.potential κ θ (b ω) (κ*t)).toReal) =ᵐ[P]
+      P[C.diskTerminalScalar θ hθ-C.diskScalar θ hθ t |
+        (Filtration.natural B (fun r =>
+          (hBm.comp (measurable_const.prodMk measurable_id) : Measurable (B r)).stronglyMeasurable)) t] := by
+  have he (ω : Ω) : (Target.potential κ θ (b ω) (κ*t)).toReal =
+      compactWeightedMass (Target.diskMassWeight κ θ hθ) (Target.diskSourceHalfPlane θ)
+        (halfPlaneGreenMeasure κ B γ G t ω) := by
+    exact Target.potential_toReal_eq_compactWeightedMass κ hκ (b ω) _ ((hc ω).const_mul _)
+      (γ ω) (G ω) (F ω) (hw ω) (hU ω) θ hθ t
+  have heAE : (fun ω => (Target.potential κ θ (b ω) (κ*t)).toReal) =ᵐ[P]
+      (fun ω => compactWeightedMass (Target.diskMassWeight κ θ hθ)
+        (Target.diskSourceHalfPlane θ) (halfPlaneGreenMeasure κ B γ G t ω)) :=
+    Eventually.of_forall he
+  exact heAE.trans (C.compact_potential_condExp hc F hw _ _
+    (Target.diskSourceHalfPlane_compact hθ) t)
+
+include hBm in
+theorem target_potential_lintegral_ne_top
+    (hB : IsBrownianReal B P) (hκ : 0 < κ) (hκ8 : κ<8)
+    (hc : ∀ ω, Continuous (fun t => B t ω)) (h0 : ∀ ω, B 0 ω=0)
+    (F : Ω → ℝ≥0 → ℂ → ℂ)
+    (hw : ∀ ω, IsCapacityTwoWitness (fun t => Real.sqrt κ*B t ω) (γ ω) (G ω) (F ω))
+    (b : Ω → Target.Driver)
+    (hU : ∀ ω (s : ℝ), 0 ≤ s → Real.sqrt κ*B s.toNNReal ω=Target.driverValue (b ω) (κ*s))
+    (θ : ℝ) (hθ : θ ∈ Ioo (0:ℝ) Real.pi) (t : ℝ≥0) :
+    (∫⁻ ω, Target.potential κ θ (b ω) (κ*t) ∂P) ≠ ∞ := by
+  have he (ω : Ω) := Target.potential_eq_weighted_green κ hκ (b ω) _ ((hc ω).const_mul _)
+    (γ ω) (G ω) (F ω) (hw ω) (hU ω) θ hθ t
+  simp_rw [he]
+  apply compactWeightedMass_kernel_lintegral_ne_top P κ (halfPlaneGreenMeasure κ B γ G t)
+    (halfPlaneGreenMeasure_measurable hBm hc κ γ G F hw t)
+    (by simpa only [Measure.restrict_univ] using
+      halfPlaneGreenMeasure_mean_le hB hBm hc h0 hκ hκ8 γ G F hw t univ)
+    _ _ (Target.diskSourceHalfPlane_compact hθ)
+
+end SLEExactGauge.Multipoint.CanonicalMass
+
+end
+
+end OAI
diff --git a/lean/OAI/Probability/SLE/Geometry/CanonicalDiskTails.lean b/lean/OAI/Probability/SLE/Geometry/CanonicalDiskTails.lean
new file mode 100644
index 0000000000000000000000000000000000000000..4760fcb9ad97dec3dc49fa0a13a4b0a5a06cd2a5
--- /dev/null
+++ b/lean/OAI/Probability/SLE/Geometry/CanonicalDiskTails.lean
@@ -0,0 +1,112 @@
+import OAI.Probability.SLE.Geometry.CenteredDiskLaw
+import OAI.Probability.SLE.Geometry.CenteredStoppedTails
+
+namespace OAI
+
+/-! The tails of the actual finite centered disk laws increase with the
+radius level. Their supremum is sufficient; no infinite tilted path law
+is postulated. -/
+
+noncomputable section
+open Set Filter _root_.MeasureTheory _root_.OAI.MeasureTheory ProbabilityTheory
+open scoped Topology NNReal ENNReal
+attribute [local instance] Classical.propDecidable
+
+namespace SLEExactGauge
+
+lemma measure_joint_tail_of_lintegral {α β : Type*} [MeasurableSpace α] [MeasurableSpace β]
+    (ν : Measure (α × β)) (η : Measure α) (Q : α → Measure β)
+    (h : ∀ f : α × β → ℝ≥0∞, Measurable f →
+      (∫⁻ p, f p ∂ν) = ∫⁻ a, ∫⁻ b, f (a,b) ∂Q a ∂η)
+    (X : α × β → ℝ) (hX : Measurable X) (c : ℝ) :
+    ν {p | c ≤ X p} = ∫⁻ a, Q a {b | c ≤ X (a,b)} ∂η := by
+  have hA : MeasurableSet {p | c ≤ X p} := measurableSet_le measurable_const hX
+  let f : α × β → ℝ≥0∞ := {p | c ≤ X p}.indicator 1
+  have hf : Measurable f := (measurable_one : Measurable (1 : α × β → ℝ≥0∞)).indicator hA
+  calc
+    _ = ∫⁻ p, f p ∂ν := (lintegral_indicator_one hA).symm
+    _ = ∫⁻ a, ∫⁻ b, f (a,b) ∂Q a ∂η := h f hf
+    _ = _ := by
+      apply lintegral_congr
+      intro a
+      have hpair : Measurable (fun b : β => (a,b)) := measurable_const.prodMk measurable_id
+      have hAa : MeasurableSet {b | c ≤ X (a,b)} := hA.preimage hpair
+      change (∫⁻ b, {b | c ≤ X (a,b)}.indicator 1 b ∂Q a) = _
+      exact lintegral_indicator_one hAa
+
+end SLEExactGauge
+
+namespace SLEExactGauge.Multipoint.CanonicalMass
+
+variable {Ω : Type*} [MeasurableSpace Ω] {P : Measure Ω} [IsProbabilityMeasure P]
+  {κ : ℝ} {B : ℝ≥0 → Ω → ℝ} {hBm : Measurable (Function.uncurry B)}
+  {γ : Ω → ℝ≥0 → ℂ} {G : Ω → ℝ≥0 → ℂ → ℂ}
+  (C : CanonicalMass P κ B hBm γ G)
+
+def centeredDiskTail (hc : ∀ ω, Continuous (fun t => B t ω)) (b u : ℝ) : ℝ≥0∞ :=
+  centeredDiskLaw P κ B hc u {p | b ≤ C.diskAtRadius p.1 u p.2}
+
+lemma centeredDiskTail_eq_integral
+    (hc : ∀ ω, Continuous (fun t => B t ω))
+    (hκ : 0<κ) (F : Ω → ℝ≥0 → ℂ → ℂ)
+    (hw : ∀ ω, IsCapacityTwoWitness (fun t => Real.sqrt κ*B t ω) (γ ω) (G ω) (F ω))
+    (b u : ℝ) (hu : 0≤u) :
+    C.centeredDiskTail hc b u = ∫⁻ θ,
+      finiteCenteredLaw P κ B γ G (Target.diskMapInv θ 0) u
+        {ω | b ≤ C.diskAtRadius θ u ω} ∂Target.angleLaw κ := by
+  exact measure_joint_tail_of_lintegral (centeredDiskLaw P κ B hc u) (Target.angleLaw κ)
+    (fun θ => finiteCenteredLaw P κ B γ G (Target.diskMapInv θ 0) u)
+    (fun f hf => centeredDiskLaw_lintegral P κ hκ B
+      (fun t => hBm.comp (measurable_const.prodMk measurable_id)) hc γ G F hw u hu f hf)
+    (fun p => C.diskAtRadius p.1 u p.2) (C.diskAtRadius_joint_measurable hc F hw u hu) b
+
+lemma diskAtRadius_tail_mono
+    (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 ω))
+    (θ : ℝ) (hθ : θ∈Ioo (0:ℝ) Real.pi) (b v V : ℝ) (hv : 0≤v) (hvV : v≤V) :
+    finiteCenteredLaw P κ B γ G (Target.diskMapInv θ 0) v {ω | b ≤ C.diskAtRadius θ v ω} ≤
+      finiteCenteredLaw P κ B γ G (Target.diskMapInv θ 0) V {ω | b ≤ C.diskAtRadius θ V ω} := by
+  let z := Target.diskMapInv θ 0
+  have hz : z ∈ upperHalfPlane := Target.diskMapInv_maps hθ (by simp)
+  let σ := fun ω => radiusLevelTime (γ ω) (G ω) z v
+  let τ := fun ω => radiusLevelTime (γ ω) (G ω) z V
+  have hσ := actual_radiusLevelTime_stopping hB
+    (fun t => hBm.comp (measurable_const.prodMk measurable_id)) hBm hc h0 κ hκ hκ8 γ G F hw z hz v hv
+  have hf (w : ℝ) (hw0 : 0≤w) := finiteCenteredLaw_earlier_stop_ae_finite hB hc κ hκ hκ8 γ G F
+    (Eventually.of_forall hw) z hz w w hw0 le_rfl
+    (fun ω => radiusLevelTime (γ ω) (G ω) z w) (Eventually.of_forall (fun _ => le_rfl))
+  have he (w : ℝ) (hw0 : 0≤w) :
+      finiteCenteredLaw P κ B γ G z w {ω | b ≤ C.diskAtRadius θ w ω} =
+      finiteCenteredLaw P κ B γ G z w
+        {ω | b ≤ finiteStoppedScalar (C.diskScalar θ hθ)
+          (fun ω => radiusLevelTime (γ ω) (G ω) z w) ω} := by
+    apply measure_congr
+    filter_upwards [hf w hw0] with ω hω
+    rw [C.diskAtRadius_eq_finite θ hθ w
+      (fun ω => radiusLevelTime (γ ω) (G ω) z w) ω rfl hω]
+  rw [he v hv,he V (hv.trans hvV)]
+  exact finiteCenteredLaw_stoppedScalar_tail_mono hB hBm hc h0 κ hκ hκ8 γ G F
+    (Eventually.of_forall hw) z hz v V hv hvV (C.diskScalar θ hθ)
+    (C.diskScalar_progressive θ hθ)
+    ((C.compactWeightedMass_paths (Target.diskMassWeight κ θ hθ) (Target.diskSourceHalfPlane θ)
+      (Target.diskSourceHalfPlane_compact hθ)).mono (fun _ h => h.1))
+    σ τ hσ (Eventually.of_forall (fun _ => rfl)) (Eventually.of_forall (fun _ => rfl)) b
+
+lemma centeredDiskTail_mono
+    (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 ω))
+    (b : ℝ) : MonotoneOn (C.centeredDiskTail hc b) (Ici 0) := by
+  intro v hv V hV hvV
+  rw [C.centeredDiskTail_eq_integral hc hκ F hw b v hv,
+    C.centeredDiskTail_eq_integral hc hκ F hw b V hV]
+  apply lintegral_mono_ae
+  filter_upwards [Target.angleLaw_ae_mem κ] with θ hθ
+  exact C.diskAtRadius_tail_mono hB hc h0 hκ hκ8 F hw θ hθ b v V hv hvV
+
+end SLEExactGauge.Multipoint.CanonicalMass
+
+end
+
+end OAI
diff --git a/lean/OAI/Probability/SLE/Geometry/CanonicalGreenPast.lean b/lean/OAI/Probability/SLE/Geometry/CanonicalGreenPast.lean
new file mode 100644
index 0000000000000000000000000000000000000000..7deb081bd79b1768e8ac9ba1a9b004fee837d6a2
--- /dev/null
+++ b/lean/OAI/Probability/SLE/Geometry/CanonicalGreenPast.lean
@@ -0,0 +1,87 @@
+import OAI.Probability.SLE.Loewner.CanonicalRadiusKernel
+import OAI.Probability.SLE.Geometry.SpatialPastKernels
+import OAI.Probability.SLE.Stochastic.DriverPastFactorization
+import OAI.Probability.SLE.Mass.GreenMeasureSupport
+
+namespace OAI
+
+/-! The canonical Green measure at a deterministic time uses only the
+continuous driver prefix. This is a pathwise ODE fact, before any law is fixed. -/
+
+noncomputable section
+open Set Filter MeasureTheory ProbabilityTheory Classical
+open scoped NNReal ENNReal Topology
+
+namespace SLEExactGauge.Multipoint
+
+local instance greenPastDriverMeasurable : MeasurableSpace C(ℝ≥0,ℝ) := borel _
+local instance greenPastDriverBorel : BorelSpace C(ℝ≥0,ℝ) := ⟨rfl⟩
+
+lemma canonicalGreen_eq_of_agree (κ : ℝ) (T : ℝ≥0)
+    (p q : C(ℝ≥0,ℝ)) (hpq : ∀ s ≤ T, p s=q s) (z : ℂ) :
+    canonicalGreen κ (T,z,p)=canonicalGreen κ (T,z,q) := by
+  let c := canonicalRadiusFamily κ
+  have hQ (n : ℕ) : c.Q n T (z,p)=c.Q n T (z,q) := by
+    apply clipped_flow_eqOn_prefix (-(n:ℝ)) n _ T
+      (fun s hs => congrArg (fun x => Real.sqrt κ*x) (hpq s hs))
+      (c.derivative n z p) (c.derivative n z q)
+      (by rw [c.initial,c.initial])
+    exact ⟨T.coe_nonneg,le_rfl⟩
+  have hv (n : ℕ) : c.valid n T z p ↔ c.valid n T z q := by
+    simp only [SpatialClippedFamily.valid,hQ]
+  change c.jointGreen κ (fun s r => r s) (T,z,p) =
+    c.jointGreen κ (fun s r => r s) (T,z,q)
+  unfold SpatialClippedFamily.jointGreen
+  congr 1
+  funext n
+  simp only [SpatialClippedFamily.greenApprox,hv,hQ,hpq T le_rfl]
+
+def canonicalGreenMass (κ : ℝ) (t : ℝ≥0) (p : C(ℝ≥0,ℝ)) :
+    Measure upperHalfPlane :=
+  (volume.withDensity (fun z => ENNReal.ofReal (canonicalGreen κ (t,z,p)))).comap Subtype.val
+
+lemma canonicalGreenMass_measurable (κ : ℝ) (t : ℝ≥0) :
+    Measurable (canonicalGreenMass κ t) := by
+  apply Measure.measurable_of_measurable_coe
+  intro A hA
+  have hAI := (MeasurableEmbedding.subtype_coe isOpen_upperHalfPlane.measurableSet).measurableSet_image.mpr hA
+  simp only [canonicalGreenMass,comap_subtype_coe_apply isOpen_upperHalfPlane.measurableSet,
+    withDensity_apply _ hAI]
+  have hg : Measurable (fun x : C(ℝ≥0,ℝ) × ℂ => canonicalGreen κ (t,x.2,x.1)) :=
+    (canonicalGreen_measurable κ).comp
+      (measurable_const.prodMk (measurable_snd.prodMk measurable_fst))
+  exact hg.ennreal_ofReal.lintegral_prod_right'
+
+lemma canonicalGreenMass_eq_of_agree (κ : ℝ) (t : ℝ≥0)
+    (p q : C(ℝ≥0,ℝ)) (hpq : ∀ s ≤ t, p s=q s) :
+    canonicalGreenMass κ t p=canonicalGreenMass κ t q := by
+  unfold canonicalGreenMass
+  congr 2
+  funext z
+  rw [canonicalGreen_eq_of_agree κ t p q hpq z]
+
+lemma canonicalGreenMass_measurable_past (κ : ℝ) (t : ℝ≥0) :
+    Measurable[driverPathFiltration t] (canonicalGreenMass κ t) := by
+  have h := (canonicalGreenMass_measurable κ t).comp (driverPathStopped_measurable_past t)
+  convert h using 1
+  funext p
+  apply canonicalGreenMass_eq_of_agree
+  intro s hs
+  simp only [driverPathStopped,ContinuousMap.coe_mk,min_eq_left hs]
+
+lemma canonicalGreenMass_eq (κ : ℝ) (p : C(ℝ≥0,ℝ))
+    {γ : ℝ≥0 → ℂ} {G F : ℝ≥0 → ℂ → ℂ}
+    (hw : IsCapacityTwoWitness (fun t => Real.sqrt κ*p t) γ G F) (t : ℝ≥0) :
+    canonicalGreenMass κ t p =
+      (volume.withDensity (fun z => ENNReal.ofReal
+        (greenDensity κ (fun s => Real.sqrt κ*p s) γ G t z))).comap Subtype.val := by
+  unfold canonicalGreenMass
+  congr 2
+  funext z
+  rw [canonicalGreen_eq κ p hw t z]
+
+end SLEExactGauge.Multipoint
+
+end
+
+end OAI
diff --git a/lean/OAI/Probability/SLE/Geometry/CanonicalInteriorBound.lean b/lean/OAI/Probability/SLE/Geometry/CanonicalInteriorBound.lean
new file mode 100644
index 0000000000000000000000000000000000000000..714d09e8d92f535643d2b91639c8d39fc639ded1
--- /dev/null
+++ b/lean/OAI/Probability/SLE/Geometry/CanonicalInteriorBound.lean
@@ -0,0 +1,71 @@
+import OAI.Probability.SLE.Gauge.PrescribedCanonicalTransfer
+import OAI.Probability.SLE.Gauge.PrescribedUniformGeometry
+
+namespace OAI
+
+/-! The canonical finite-law failure estimate gives the exact uniform
+  interior bound used in the prescribed upper cover. -/
+noncomputable section
+open Set Filter _root_.MeasureTheory _root_.OAI.MeasureTheory ProbabilityTheory
+open scoped Topology NNReal ENNReal
+
+namespace SLEExactGauge.Multipoint.CanonicalMass
+
+variable {Ω : Type} [MeasurableSpace Ω] {P : Measure Ω} [IsProbabilityMeasure P]
+  {κ : ℝ} {B : ℝ≥0 → Ω → ℝ} {hBm : Measurable (Function.uncurry B)}
+  {γ : Ω → ℝ≥0 → ℂ} {G : Ω → ℝ≥0 → ℂ → ℂ}
+  (M : CanonicalMass P κ B hBm γ G)
+
+def prescribedCenteredFailure (W : Target.WienerLaw) (n : ℕ) {J : ℕ}
+    (e : Fin J → ℤ×ℕ) (C c : ℝ) (z : ℂ) : ℝ≥0∞ :=
+  finiteCenteredLaw P κ B γ G z (Target.entryPhysicalLevel κ W (n,none) (2048*Real.pi) z)
+    (M.prescribedTestFailures W n e C c z
+      (fun i ω => radiusLevelTime (γ ω) (G ω) z
+        (Target.entryPhysicalLevel κ W (n,some (e i)) (2048*Real.pi) z+
+          2*Target.a κ*(Target.batchLevel κ W n:ℝ))))
+
+theorem eventually_prescribed_interior_bound
+    (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 ω))
+    (hpublished : PublishedTraceGeneration (P.map (sourceDriverPath B hc)) κ (fun t p => p t))
+    (W : Target.WienerLaw) (hm1 : 0 < Target.moment κ W 1)
+    (hJ : ∀ n, 1≤n → Target.moment κ W 1^n ≤ Target.moment κ W n)
+    (J : ℕ → ℕ) (e : ∀ n, Fin (J n) → ℤ×ℕ)
+    (he : ∀ n i, (e n i).2 < Target.multiplicity κ W n (e n i).1)
+    (C c R : ℝ) (K : Set ℂ)
+    (hfailure : ∀ᶠ n in atTop, ∀ ij∈prescribedGridIndex R (Target.entryRadius κ W (n,none)) K,
+      Real.exp (-(n:ℝ)) ≤ (prescribedGridCenter (Target.entryRadius κ W (n,none)) ij).im →
+      M.prescribedCenteredFailure W n (e n) C c
+        (prescribedGridCenter (Target.entryRadius κ W (n,none)) ij) ≤
+        ENNReal.ofReal (Real.exp (-((2:ℝ)^n/16)))) :
+    ∀ᶠ n in atTop, ∀ ij∈prescribedGridIndex R (Target.entryRadius κ W (n,none)) K,
+      Real.exp (-(n:ℝ)) ≤ (prescribedGridCenter (Target.entryRadius κ W (n,none)) ij).im →
+      P {ω | ij∈prescribedMissedIndices κ W n (e n) C c R K (range (γ ω)∩K)
+        (M.rational.physicalTerminal ω)} ≤
+      ENNReal.ofReal ((uniformInverseAngleConstant κ 1*(2048*Real.pi)^codimension κ*
+        (2:ℝ)^(-codimension κ))*(Target.entryRadius κ W (n,none))^codimension κ*
+        (prescribedGridCenter (Target.entryRadius κ W (n,none)) ij).im^(-codimension κ)*
+        Real.exp (-((2:ℝ)^n/16))) := by
+  filter_upwards [hfailure,Target.eventually_prescribed_uniform_geometry hκ W hm1 hJ,
+    Target.eventually_entryPhysicalLevel_large hκ W (by positivity : 0<2048*Real.pi) 1]
+    with n hn hg hl
+  intro ij hij hy
+  let z := prescribedGridCenter (Target.entryRadius κ W (n,none)) ij
+  obtain ⟨hlevels,hsmall,hends⟩ := hg z hy
+  let V := Target.entryPhysicalLevel κ W (n,none) (2048*Real.pi) z
+  have hV : 1<V := hl none z hy
+  have hend (i : Fin (J n)) : Target.entryPhysicalLevel κ W (n,some (e n i)) (2048*Real.pi) z+
+      2*Target.a κ*(Target.batchLevel κ W n:ℝ) ≤ V-1 := by
+    have hh := hends (e n i).1 (e n i).2 (he n i)
+    dsimp only [V]
+    linarith
+  exact M.prescribed_missed_from_finite_failure hB hc h0 hκ hκ8 F hw hpublished W n (e n)
+    C c R K ij hij hlevels (V-1) (by linarith) (by linarith) hend hsmall
+    _ (Real.exp_pos _).le (hn ij hij hy)
+
+end SLEExactGauge.Multipoint.CanonicalMass
+
+end
+
+end OAI
diff --git a/lean/OAI/Probability/SLE/Geometry/CanonicalJointDisk.lean b/lean/OAI/Probability/SLE/Geometry/CanonicalJointDisk.lean
new file mode 100644
index 0000000000000000000000000000000000000000..cda8594a8176ee81cd33d25229e0a6833b9a5e0a
--- /dev/null
+++ b/lean/OAI/Probability/SLE/Geometry/CanonicalJointDisk.lean
@@ -0,0 +1,106 @@
+import OAI.Probability.SLE.Mass.JointDiskMass
+import OAI.Probability.SLE.Mass.CanonicalMassRemaining
+import OAI.Probability.SLE.Geometry.CenteredDiskCoefficient
+
+namespace OAI
+
+/-! Joint angle and sample measurability of actual canonical disk masses
+at radius stops. No angle-dependent exceptional set is selected. -/
+
+noncomputable section
+open Set Filter _root_.MeasureTheory _root_.OAI.MeasureTheory ProbabilityTheory
+open scoped Topology NNReal ENNReal
+
+namespace SLEExactGauge.Multipoint.CanonicalMass
+
+variable {Ω : Type*} [MeasurableSpace Ω] {P : Measure Ω} {κ : ℝ}
+  {B : ℝ≥0 → Ω → ℝ} {hBm : Measurable (Function.uncurry B)}
+  {γ : Ω → ℝ≥0 → ℂ} {G : Ω → ℝ≥0 → ℂ → ℂ}
+  (C : CanonicalMass P κ B hBm γ G)
+
+lemma disk_at_parameter_measurable
+    {Ξ : Type*} [MeasurableSpace Ξ] (θ : Ξ → ℝ) (hθ : Measurable θ)
+    (g : Ξ → Ω) (hg : Measurable g) (T : Ξ → ℝ≥0∞) (hT : Measurable T) :
+    Measurable (fun x => diskMassValue κ (θ x) (C.atTime (T x) (g x))) := by
+  apply diskMassValue_measurable κ θ hθ
+  · exact ((_root_.OAI.MeasureTheory.IsProgressive.parameter_time_measurable C.progressive g hg _ hT.ennreal_toNNReal).ite
+      (measurableSet_lt hT measurable_const) (C.rational.terminal_measurable.comp hg))
+  · intro x
+    exact (C.atTime_radon (T x) (g x)).2
+
+/-- The actual compact disk mass at the indicated logarithmic radius level.
+Infinite radius times use the already constructed terminal measure. -/
+def diskAtRadius (θ u : ℝ) (ω : Ω) : ℝ :=
+  (diskMassValue κ θ (C.atTime
+    (radiusLevelTime (γ ω) (G ω) (Target.diskMapInv θ 0) u) ω)).toReal
+
+lemma diskAtRadius_nonneg (θ u : ℝ) (ω : Ω) : 0 ≤ C.diskAtRadius θ u ω :=
+  ENNReal.toReal_nonneg
+
+lemma diskAtRadius_joint_measurable
+    (hc : ∀ ω, Continuous (fun t => B t ω))
+    (F : Ω → ℝ≥0 → ℂ → ℂ)
+    (hw : ∀ ω, IsCapacityTwoWitness (fun t => Real.sqrt κ*B t ω) (γ ω) (G ω) (F ω))
+    (u : ℝ) (hu : 0 ≤ u) :
+    Measurable (fun p : ℝ × Ω => C.diskAtRadius p.1 u p.2) := by
+  have hz : Measurable (fun p : ℝ × Ω => Target.diskMapInv p.1 0) := by
+    unfold Target.diskMapInv
+    fun_prop
+  have ht : Measurable (fun p : ℝ × Ω =>
+      radiusLevelTime (γ p.2) (G p.2) (Target.diskMapInv p.1 0) u) := by
+    have hj : Measurable (fun p : Ω × ℂ => radiusLevelTime (γ p.1) (G p.1) p.2 u) :=
+      actual_radiusLevel_joint_measurable
+        (fun t => hBm.comp (measurable_const.prodMk measurable_id)) hc κ u hu γ G F hw
+    exact @Measurable.comp (ℝ × Ω) (Ω × ℂ) ℝ≥0∞
+      inferInstance inferInstance inferInstance
+      (fun p => radiusLevelTime (γ p.1) (G p.1) p.2 u)
+      (fun p => (p.2,Target.diskMapInv p.1 0)) hj (measurable_snd.prodMk hz)
+  exact (C.disk_at_parameter_measurable _ measurable_fst _ measurable_snd _ ht).ennreal_toReal
+
+lemma diskAtRadius_eq_finite (θ : ℝ) (hθ : θ ∈ Ioo (0:ℝ) Real.pi)
+    (u : ℝ) (σ : Ω → WithTop ℝ≥0) (ω : Ω)
+    (he : σ ω=radiusLevelTime (γ ω) (G ω) (Target.diskMapInv θ 0) u)
+    (hf : σ ω≠⊤) :
+    C.diskAtRadius θ u ω = finiteStoppedScalar (C.diskScalar θ hθ) σ ω := by
+  rw [diskAtRadius,← he,diskMassValue_toReal_eq κ θ hθ]
+  have hfin : (σ ω : ℝ≥0∞) < ∞ := lt_top_iff_ne_top.mpr hf
+  simp only [atTime,extendedCanonicalMass,finiteStoppedScalar,hf,ite_false]
+  split_ifs with hs
+  · unfold diskScalar
+    lift σ ω to ℝ≥0 using hf with t
+    rfl
+  · exact False.elim (hs hfin)
+
+/-- The moment identity uses the same jointly measurable disk variable
+which enters tail events, with exactly the prescribed inner-clock scaling. -/
+lemma levelCoefficient_eq_diskAtRadius_moment [IsProbabilityMeasure P]
+    (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 ω))
+    (hgrowth : PublishedDiskUnivalentGrowth) (W : Target.WienerLaw) (hW : Target.IsWiener W)
+    (θ : ℝ) (hθ : θ∈Ioo (0:ℝ) Real.pi) (ℓ : ℝ) (hℓ : 0≤ℓ) (m : ℕ) :
+    ENNReal.ofReal (Target.levelCoefficient κ W ℓ m θ) =
+      ∫⁻ ω, ENNReal.ofReal (C.diskAtRadius θ (4*ℓ/κ) ω)^m
+        ∂finiteCenteredLaw P κ B γ G (Target.diskMapInv θ 0) (4*ℓ/κ) := by
+  let u := 4*ℓ/κ
+  have hu : 0 ≤ u := div_nonneg (mul_nonneg (by norm_num) hℓ) hκ.le
+  let σ := fun ω => radiusLevelTime (γ ω) (G ω) (Target.diskMapInv θ 0) u
+  have hz : Target.diskMapInv θ 0 ∈ upperHalfPlane := Target.diskMapInv_maps hθ (by simp)
+  have hσ := actual_radiusLevelTime_stopping hB
+    (fun t => hBm.comp (measurable_const.prodMk measurable_id)) hBm hc h0
+    κ hκ hκ8 γ G F hw (Target.diskMapInv θ 0) hz u hu
+  have hf := finiteCenteredLaw_earlier_stop_ae_finite hB hc κ hκ hκ8 γ G F
+    (Eventually.of_forall hw) (Target.diskMapInv θ 0) hz u u hu le_rfl σ
+    (Eventually.of_forall (fun _ => le_rfl))
+  rw [C.levelCoefficient_eq_centered_moment hB hc h0 hκ hκ8 F hw hgrowth W hW
+    θ hθ ℓ hℓ m σ hσ (Eventually.of_forall (fun _ => rfl))]
+  apply lintegral_congr_ae
+  filter_upwards [hf] with ω hω
+  rw [C.diskAtRadius_eq_finite θ hθ u σ ω rfl hω]
+
+end SLEExactGauge.Multipoint.CanonicalMass
+
+end
+
+end OAI
diff --git a/lean/OAI/Probability/SLE/Geometry/CanonicalLowerSegments.lean b/lean/OAI/Probability/SLE/Geometry/CanonicalLowerSegments.lean
new file mode 100644
index 0000000000000000000000000000000000000000..8b09038d7c963b74502af1ed7361c721c4ecc390
--- /dev/null
+++ b/lean/OAI/Probability/SLE/Geometry/CanonicalLowerSegments.lean
@@ -0,0 +1,88 @@
+import OAI.Probability.SLE.Gauge.CanonicalGridLower
+import OAI.Probability.SLE.Mass.PositiveTraceMass
+
+namespace OAI
+
+/-! Compact lower bounds give positivity simultaneously on every trace segment.
+Only a countable compact exhaustion is used before choosing the time interval. -/
+
+noncomputable section
+open Set Filter _root_.MeasureTheory _root_.OAI.MeasureTheory ProbabilityTheory Metric
+open scoped Topology NNReal ENNReal
+
+namespace SLEExactGauge.Multipoint
+
+local instance : LocallyCompactSpace upperHalfPlane := isOpen_upperHalfPlane.locallyCompactSpace
+
+lemma exists_compact_covering_positive_inter (μ : Measure upperHalfPlane)
+    (A : Set upperHalfPlane) (hA : 0 < μ A) :
+    ∃ n : ℕ, 0 < μ (compactCovering upperHalfPlane n ∩ A) := by
+  by_contra! hn
+  have he : (⋃ n : ℕ, compactCovering upperHalfPlane n ∩ A) = A := by
+    rw [← iUnion_inter,iUnion_compactCovering,univ_inter]
+  have hz : μ A = 0 := by
+    apply le_antisymm ?_ bot_le
+    rw [← he]
+    calc
+      _ ≤ ∑' n : ℕ, μ (compactCovering upperHalfPlane n ∩ A) := measure_iUnion_le _
+      _ = 0 := by simp only [fun n => le_zero_iff.mp (hn n),tsum_zero]
+  exact hA.ne' hz
+
+namespace CanonicalMass
+
+variable {Ω : Type*} [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 < κ) (F : Ω → ℝ≥0 → ℂ → ℂ)
+  (hw : ∀ ω, IsCapacityTwoWitness (fun t => Real.sqrt κ * B t ω) (γ ω) (G ω) (F ω))
+  (hpublished : PublishedTraceGeneration (P.map (sourceDriverPath B hc)) κ (fun t p => p t))
+
+include C hB hc h0 hκ F hw hpublished
+
+/-- A countable compact lower criterion and the proved positivity of every
+canonical increment imply the required simultaneous segment lower bound. -/
+theorem positive_all_segments_of_compact_lower (h : ℝ → ℝ)
+    (hlower : ∀ n : ℕ, ∀ᵐ ω ∂P, ∀ E : Set ℂ, MeasurableSet E →
+      0 < C.rational.terminal ω (compactCovering upperHalfPlane n ∩ Subtype.val ⁻¹' E) →
+      0 < Target.hausdorff h E) :
+    ∀ᵐ ω ∂P, ∀ s t : ℝ≥0, s < t →
+      0 < Target.hausdorff h (γ ω '' Icc s t) := by
+  have hp := C.positive_all_times hB hc h0 F hw
+  have hi := C.positive_increment_all_times hB hc hκ F hw hpublished hp
+  filter_upwards [ae_all_iff.mpr hlower,C.paths,hi] with ω hω hpath hinc
+  intro s t hst
+  let E := γ ω '' Icc s t
+  have hE : MeasurableSet E := (isCompact_Icc.image (hw ω).1).measurableSet
+  let A : Set upperHalfPlane := Subtype.val ⁻¹' E
+  have hA : MeasurableSet A := hE.preimage measurable_subtype_coe
+  have hsupp : (C.process t ω-C.process s ω) Aᶜ = 0 := by
+    have hh := hpath.increment_support s t hst.le
+    have he : (fun r : ℝ => γ ω r.toNNReal) '' Icc (s:ℝ) t = E := by
+      ext z
+      constructor
+      · rintro ⟨r,hr,rfl⟩
+        exact ⟨r.toNNReal,⟨by simpa using Real.toNNReal_mono hr.1,
+          by simpa using Real.toNNReal_mono hr.2⟩,rfl⟩
+      · rintro ⟨r,hr,rfl⟩
+        exact ⟨r,⟨by exact_mod_cast hr.1,by exact_mod_cast hr.2⟩,by simp⟩
+    change (C.process t ω-C.process s ω) {z : upperHalfPlane | (z:ℂ) ∉ E} = 0
+    rw [he] at hh
+    exact hh
+  have hpos : 0 < (C.process t ω-C.process s ω) A := by
+    have he := measure_add_measure_compl (μ := C.process t ω-C.process s ω) hA
+    rw [hsupp,add_zero] at he
+    rw [he]
+    exact Measure.measure_univ_pos.mpr (hinc s t hst)
+  have hterminal : 0 < C.rational.terminal ω A :=
+    hpos.trans_le ((Measure.sub_le.trans (hpath.dominated t)) A)
+  obtain ⟨n,hn⟩ := exists_compact_covering_positive_inter (C.rational.terminal ω) A hterminal
+  exact hω n E hE hn
+
+end CanonicalMass
+end SLEExactGauge.Multipoint
+
+end
+
+end OAI
diff --git a/lean/OAI/Probability/SLE/Geometry/CanonicalNormalizedPotential.lean b/lean/OAI/Probability/SLE/Geometry/CanonicalNormalizedPotential.lean
new file mode 100644
index 0000000000000000000000000000000000000000..0100468db5dd32905653f355f6b3eb1d8abffb41
--- /dev/null
+++ b/lean/OAI/Probability/SLE/Geometry/CanonicalNormalizedPotential.lean
@@ -0,0 +1,76 @@
+import OAI.Probability.SLE.Geometry.CanonicalDiskPotential
+import OAI.Probability.SLE.Angle.TargetNormalizedFiltration
+import OAI.Probability.SLE.Angle.TargetLevelTime
+
+namespace OAI
+
+/-! Canonical remaining mass in the exact clock and natural filtration
+of the source-prescribed Brownian driver. -/
+
+noncomputable section
+open Set Filter _root_.MeasureTheory _root_.OAI.MeasureTheory ProbabilityTheory
+open scoped Topology NNReal ENNReal
+
+namespace SLEExactGauge.Multipoint.CanonicalMass
+
+variable {Ω : Type*} [mΩ : MeasurableSpace Ω] {P : Measure Ω}
+  {κ : ℝ} {B : ℝ≥0 → Ω → ℝ} {hBm : Measurable (Function.uncurry B)}
+  {γ : Ω → ℝ≥0 → ℂ} {G : Ω → ℝ≥0 → ℂ → ℂ}
+  (C : CanonicalMass P κ B hBm γ G)
+
+theorem normalized_potential_condExp [IsProbabilityMeasure P]
+    (hκ : 0<κ) (hc : ∀ ω, Continuous (fun t => B t ω)) (h0 : ∀ ω, B 0 ω=0)
+    (F : Ω → ℝ≥0 → ℂ → ℂ)
+    (hw : ∀ ω, IsCapacityTwoWitness (fun t => Real.sqrt κ*B t ω) (γ ω) (G ω) (F ω))
+    (θ : ℝ) (hθ : θ ∈ Ioo (0:ℝ) Real.pi) (t : ℝ≥0) :
+    (fun ω => (Target.potential κ θ (Target.normalizedDriver κ B hc h0 ω) t).toReal) =ᵐ[P]
+      P[C.diskTerminalScalar θ hθ-C.diskScalar θ hθ (t/κ.toNNReal) |
+        Target.normalizedFiltration κ B
+          (fun r => (hBm.comp (measurable_const.prodMk measurable_id) : Measurable (B r))) hc h0 t] := by
+  have ht : κ*((t/κ.toNNReal:ℝ≥0):ℝ)=(t:ℝ) := by
+    rw [NNReal.coe_div,Real.coe_toNNReal _ hκ.le,mul_div_cancel₀ _ hκ.ne']
+  erw [Target.normalizedFiltration_at κ hκ B
+    (fun r => (hBm.comp (measurable_const.prodMk measurable_id) : Measurable (B r))) hc h0 t]
+  simpa only [ht] using C.target_potential_condExp hκ hc F hw
+    (Target.normalizedDriver κ B hc h0) (Target.normalizedDriver_matches κ hκ B hc h0)
+    θ hθ (t/κ.toNNReal)
+
+include hBm in
+theorem normalized_potential_lintegral_ne_top
+    (hB : IsBrownianReal B P) (hκ : 0<κ) (hκ8 : κ<8)
+    (hc : ∀ ω, Continuous (fun t => B t ω)) (h0 : ∀ ω, B 0 ω=0)
+    (F : Ω → ℝ≥0 → ℂ → ℂ)
+    (hw : ∀ ω, IsCapacityTwoWitness (fun t => Real.sqrt κ*B t ω) (γ ω) (G ω) (F ω))
+    (θ : ℝ) (hθ : θ ∈ Ioo (0:ℝ) Real.pi) (t : ℝ≥0) :
+    (∫⁻ ω, Target.potential κ θ (Target.normalizedDriver κ B hc h0 ω) t ∂P) ≠ ∞ := by
+  have ht : κ*((t/κ.toNNReal:ℝ≥0):ℝ)=(t:ℝ) := by
+    rw [NNReal.coe_div,Real.coe_toNNReal _ hκ.le,mul_div_cancel₀ _ hκ.ne']
+  simpa only [ht] using target_potential_lintegral_ne_top (hBm := hBm)
+    hB hκ hκ8 hc h0 F hw (Target.normalizedDriver κ B hc h0)
+    (Target.normalizedDriver_matches κ hκ B hc h0) θ hθ (t/κ.toNNReal)
+
+include hBm in
+theorem normalized_levelTime_measurable
+    (hκ : 0<κ) (hc : ∀ ω, Continuous (fun t => B t ω)) (h0 : ∀ ω, B 0 ω=0)
+    (F : Ω → ℝ≥0 → ℂ → ℂ)
+    (hw : ∀ ω, IsCapacityTwoWitness (fun t => Real.sqrt κ*B t ω) (γ ω) (G ω) (F ω))
+    (θ ℓ : ℝ) (hℓ : 0 ≤ ℓ) :
+    Measurable (fun ω => Target.levelTime κ θ (Target.normalizedDriver κ B hc h0 ω) ℓ) := by
+  apply Target.measurable_levelTime_of_radius_kernel κ hκ _ _
+    (fun ω => (hc ω).const_mul _) γ G F hw
+    (Target.normalizedDriver_matches κ hκ B hc h0) θ ℓ hℓ
+  have hu : 0 ≤ 4*ℓ/κ := div_nonneg (mul_nonneg (by norm_num) hℓ) hκ.le
+  have hm := measurable_canonicalRadiusLevel_random_state κ
+    (source_path_measurable (sourceDriverPath B hc)
+      (fun t => hBm.comp (measurable_const.prodMk measurable_id)))
+    (u := fun _ => 4*ℓ/κ) measurable_const
+    (z := fun _ => Target.diskMapInv θ 0) measurable_const
+  convert hm using 1
+  funext ω
+  exact (canonicalRadiusLevel_eq κ (sourceDriverPath B hc ω) (hw ω) _ hu _).symm
+
+end SLEExactGauge.Multipoint.CanonicalMass
+
+end
+
+end OAI
diff --git a/lean/OAI/Probability/SLE/Geometry/CanonicalRawMean.lean b/lean/OAI/Probability/SLE/Geometry/CanonicalRawMean.lean
new file mode 100644
index 0000000000000000000000000000000000000000..a6cf48bdb6d6ba34e75627eff59ea9c4a0fa7f28
--- /dev/null
+++ b/lean/OAI/Probability/SLE/Geometry/CanonicalRawMean.lean
@@ -0,0 +1,99 @@
+import OAI.Probability.SLE.Geometry.CanonicalRawTerminal
+import OAI.Probability.SLE.Mass.RestartRandomMassTesting
+
+namespace OAI
+
+/-! The fixed raw terminal functional has the exact Green mean under the
+driver law. Strong Markov then allows arbitrary stopped-past spatial weights
+in the fresh terminal mass. -/
+
+noncomputable section
+open Set Filter _root_.MeasureTheory _root_.OAI.MeasureTheory ProbabilityTheory Classical
+open scoped NNReal ENNReal Topology
+
+namespace SLEExactGauge.Multipoint
+
+local instance : MeasurableSpace C(ℝ≥0,ℝ) := borel _
+local instance : BorelSpace C(ℝ≥0,ℝ) := ⟨rfl⟩
+
+theorem CanonicalMass.raw_terminal_mean
+    {Ω : Type*} [MeasurableSpace Ω] {P : Measure Ω} {κ : ℝ}
+    {B : ℝ≥0 → Ω → ℝ} {hBm : Measurable (Function.uncurry B)}
+    {γ : Ω → ℝ≥0 → ℂ} {G : Ω → ℝ≥0 → ℂ → ℂ}
+    (C : CanonicalMass P κ B hBm γ G)
+    (hBc : ∀ ω, Continuous (fun t => B t ω)) (R : RawCanonicalMass)
+    (he : ∀ᵐ ω ∂P, R.terminal (sourceDriverPath B hBc ω) = C.rational.terminal ω) :
+    (P.map (sourceDriverPath B hBc)).bind R.terminal = initialGreenMeasure κ := by
+  have hp : Measurable (sourceDriverPath B hBc) := source_path_measurable _
+    (fun t => hBm.comp (measurable_const.prodMk measurable_id))
+  calc
+    _ = P.bind (fun ω => R.terminal (sourceDriverPath B hBc ω)) := by
+      unfold Measure.bind
+      rw [Measure.map_map R.terminal_measurable hp]
+      rfl
+    _ = P.bind C.rational.terminal := Measure.bind_congr_right he
+    _ = initialGreenMeasure κ := C.rational.mean
+
+theorem CanonicalMass.restarted_raw_terminal_mean
+    {Ω : Type*} [MeasurableSpace Ω] {P : Measure Ω} [IsProbabilityMeasure P]
+    {κ : ℝ} {B : ℝ≥0 → Ω → ℝ} {hBm : Measurable (Function.uncurry B)}
+    {γ : Ω → ℝ≥0 → ℂ} {G : Ω → ℝ≥0 → ℂ → ℂ}
+    (C : CanonicalMass P κ B hBm γ G)
+    (hB : IsBrownianReal B P) (hc : ∀ ω, Continuous (fun t => B t ω))
+    (R : RawCanonicalMass)
+    (he : ∀ᵐ ω ∂P, R.terminal (sourceDriverPath B hc ω)=C.rational.terminal ω)
+    (τ : Ω → ℝ≥0)
+    (hτ : IsStoppingTime (Filtration.natural B (fun t =>
+      (hBm.comp (measurable_const.prodMk measurable_id) : Measurable (B t)).stronglyMeasurable))
+      (fun ω => (τ ω:WithTop ℝ≥0))) :
+    P.bind (fun ω => R.terminal (sourceRestartDriverPath B hc τ ω))=initialGreenMeasure κ := by
+  have hm (t : ℝ≥0) : Measurable (B t) := hBm.comp (measurable_const.prodMk measurable_id)
+  have hY : Measurable (sourceRestartDriverPath B hc τ) := source_path_measurable _
+    (fun t => (measurable_pi_apply t).comp
+      (brownianRestart_measurable hm hc (stopping_time_measurable_nnreal hτ)))
+  have hlaw : P.map (sourceRestartDriverPath B hc τ)=P.map (sourceDriverPath B hc) := by
+    simpa only [Measure.restrict_univ,measure_univ,one_smul] using
+      source_restart_continuous_driver_law hB hm hc τ hτ (A := univ) MeasurableSet.univ
+  calc
+    _ = (P.map (sourceRestartDriverPath B hc τ)).bind R.terminal := by
+      unfold Measure.bind
+      rw [Measure.map_map R.terminal_measurable hY]
+      rfl
+    _ = initialGreenMeasure κ := by rw [hlaw,C.raw_terminal_mean hc R he]
+
+
+theorem CanonicalMass.fresh_terminal_random_test
+    {Ω : 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) (hBc : ∀ ω, Continuous (fun t => B t ω))
+    (R : RawCanonicalMass)
+    (he : ∀ᵐ ω ∂P, R.terminal (sourceDriverPath B hBc ω) = C.rational.terminal ω)
+    (τ : Ω → ℝ≥0)
+    (hτ : IsStoppingTime (Filtration.natural B (fun t =>
+      (hBm.comp (measurable_const.prodMk measurable_id) : Measurable (B t)).stronglyMeasurable))
+      (fun ω => (τ ω : WithTop ℝ≥0)))
+    (f : Ω × upperHalfPlane → ℝ≥0∞)
+    (hf : Measurable[hτ.measurableSpace.prod inferInstance] f) :
+    (∫⁻ ω, ∫⁻ z, f (ω,z) ∂(R.terminal (sourceRestartDriverPath B hBc τ ω)) ∂P) =
+      ∫⁻ ω, ∫⁻ z, f (ω,z) ∂initialGreenMeasure κ ∂P := by
+  have hm (t : ℝ≥0) : Measurable (B t) :=
+    hBm.comp (measurable_const.prodMk measurable_id)
+  have hp : Measurable (sourceDriverPath B hBc) := source_path_measurable _ hm
+  let : IsProbabilityMeasure (P.map (sourceDriverPath B hBc)) :=
+    (Measure.isProbabilityMeasure_map_iff hp.aemeasurable).mpr inferInstance
+  have hY : Measurable (sourceRestartDriverPath B hBc τ) :=
+    source_path_measurable _ (fun t => (measurable_pi_apply t).comp
+      (brownianRestart_measurable hm hBc (stopping_time_measurable_nnreal hτ)))
+  have h := restart_random_mass_test P (P.map (sourceDriverPath B hBc))
+    hτ.measurableSpace hτ.measurableSpace_le (sourceRestartDriverPath B hBc τ) hY
+    (fun A hA => source_restart_continuous_driver_law hB hm hBc τ hτ hA)
+    R.terminal R.terminal_measurable (fun p => (R.terminal_radon p).2) f hf
+  rwa [C.raw_terminal_mean hBc R he] at h
+
+end SLEExactGauge.Multipoint
+
+end
+
+end OAI
diff --git a/lean/OAI/Probability/SLE/Geometry/CanonicalRawTerminal.lean b/lean/OAI/Probability/SLE/Geometry/CanonicalRawTerminal.lean
new file mode 100644
index 0000000000000000000000000000000000000000..1c968e0aaa40f656142bc1f4bc64135442b02015
--- /dev/null
+++ b/lean/OAI/Probability/SLE/Geometry/CanonicalRawTerminal.lean
@@ -0,0 +1,86 @@
+import OAI.Probability.SLE.Mass.CanonicalRawMass
+import OAI.Probability.SLE.Mass.TerminalMassTestLimit
+
+namespace OAI
+
+/-! Terminal extension of the fixed raw canonical mass functional. Its
+integer-time vague limit agrees with the locally exhausted terminal mass. -/
+
+noncomputable section
+open Set Filter _root_.MeasureTheory _root_.OAI.MeasureTheory Classical
+open scoped NNReal ENNReal Topology CompactlySupported
+
+namespace SLEExactGauge.Multipoint
+
+local instance : MeasurableSpace C(ℝ≥0,ℝ) := borel _
+local instance : BorelSpace C(ℝ≥0,ℝ) := ⟨rfl⟩
+local instance : LocallyCompactSpace upperHalfPlane := isOpen_upperHalfPlane.locallyCompactSpace
+
+structure RawCanonicalMass where
+  process : ℝ≥0 → C(ℝ≥0,ℝ) → Measure upperHalfPlane
+  terminal : C(ℝ≥0,ℝ) → Measure upperHalfPlane
+  progressive : IsProgressive driverPathFiltration process
+  radon : ∀ t p, (process t p).Regular ∧ IsFiniteMeasureOnCompacts (process t p)
+  terminal_measurable : Measurable terminal
+  terminal_radon : ∀ p, (terminal p).Regular ∧ IsFiniteMeasureOnCompacts (terminal p)
+  nonanticipating : ∀ t p q, (∀ s ≤ t, p s=q s) → process t p=process t q
+
+def rawTerminalMass (R : ℝ≥0 → C(ℝ≥0,ℝ) → Measure upperHalfPlane)
+    (p : C(ℝ≥0,ℝ)) : Measure upperHalfPlane :=
+  canonicalRadonLimit (fun n : ℕ => R n p)
+
+lemma rawTerminalMass_measurable
+    (R : ℝ≥0 → C(ℝ≥0,ℝ) → Measure upperHalfPlane)
+    (hRp : IsProgressive driverPathFiltration R)
+    (hRr : ∀ t p, (R t p).Regular ∧ IsFiniteMeasureOnCompacts (R t p)) :
+    Measurable (rawTerminalMass R) := by
+  apply canonicalRadonLimit_measurable (fun n : ℕ => R n)
+    (fun n p => (hRr n p).2)
+  intro n f
+  exact measurable_halfPlane_compact_test_integral (R n)
+    (hRp.adapted.measurable (i := (n:ℝ≥0))) (fun p => (hRr n p).1) f
+
+lemma rawTerminalMass_radon
+    (R : ℝ≥0 → C(ℝ≥0,ℝ) → Measure upperHalfPlane) (p : C(ℝ≥0,ℝ)) :
+    (rawTerminalMass R p).Regular ∧ IsFiniteMeasureOnCompacts (rawTerminalMass R p) := by
+  have : (rawTerminalMass R p).Regular := canonicalRadonLimit_regular _
+  exact ⟨this,inferInstance⟩
+
+theorem CanonicalMass.rawTerminal_realizes
+    {Ω : Type*} [MeasurableSpace Ω] {P : Measure Ω} {κ : ℝ}
+    {B : ℝ≥0 → Ω → ℝ} {hBm : Measurable (Function.uncurry B)}
+    {γ : Ω → ℝ≥0 → ℂ} {G : Ω → ℝ≥0 → ℂ → ℂ}
+    (C : CanonicalMass P κ B hBm γ G)
+    (hBc : ∀ ω, Continuous (fun t => B t ω))
+    (R : ℝ≥0 → C(ℝ≥0,ℝ) → Measure upperHalfPlane)
+    (he : ∀ᵐ ω ∂P, ∀ t, R t (sourceDriverPath B hBc ω) = C.process t ω) :
+    ∀ᵐ ω ∂P, rawTerminalMass R (sourceDriverPath B hBc ω) = C.rational.terminal ω := by
+  filter_upwards [he,C.paths,C.exhaustion] with ω he hp hlim
+  apply canonicalRadonLimit_identified _ _
+  refine ⟨(C.rational.terminal_radon ω).1,?_⟩
+  intro f
+  let : (C.rational.terminal ω).Regular := (C.rational.terminal_radon ω).1
+  have ht := terminal_mass_test_tendsto (C.rational.terminal ω) (fun t => C.process t ω)
+    (fun t => (C.radon t ω).1) hp.dominated hlim f
+  simpa only [Function.comp_def,he] using ht.comp (tendsto_natCast_atTop_atTop (R := ℝ≥0))
+
+theorem CanonicalMass.exists_raw_canonical
+    {Ω : Type*} [MeasurableSpace Ω] {P : Measure Ω} {κ : ℝ}
+    {B : ℝ≥0 → Ω → ℝ} {hBm : Measurable (Function.uncurry B)}
+    {γ : Ω → ℝ≥0 → ℂ} {G : Ω → ℝ≥0 → ℂ → ℂ}
+    (C : CanonicalMass P κ B hBm γ G)
+    (hBc : ∀ ω, Continuous (fun t => B t ω)) :
+    ∃ R : RawCanonicalMass, ∀ᵐ ω ∂P,
+      (∀ t, R.process t (sourceDriverPath B hBc ω) = C.process t ω) ∧
+        R.terminal (sourceDriverPath B hBc ω) = C.rational.terminal ω := by
+  obtain ⟨R,hRp,hRr,hRn,he⟩ := C.exists_raw_nonanticipating_functional hBc
+  refine ⟨⟨R,rawTerminalMass R,hRp,hRr,rawTerminalMass_measurable R hRp hRr,
+    rawTerminalMass_radon R,hRn⟩,?_⟩
+  filter_upwards [he,C.rawTerminal_realizes hBc R he] with ω hf ht
+  exact ⟨hf,ht⟩
+
+end SLEExactGauge.Multipoint
+
+end
+
+end OAI
diff --git a/lean/OAI/Probability/SLE/Geometry/CanonicalRestartDischarge.lean b/lean/OAI/Probability/SLE/Geometry/CanonicalRestartDischarge.lean
new file mode 100644
index 0000000000000000000000000000000000000000..400721b87ff71c07a72c7b6ab5104c08381e9087
--- /dev/null
+++ b/lean/OAI/Probability/SLE/Geometry/CanonicalRestartDischarge.lean
@@ -0,0 +1,74 @@
+import OAI.Probability.SLE.Gauge.GaugeGrowthDischarge
+import OAI.Probability.SLE.Mass.CanonicalMassImageRestart
+
+namespace OAI
+
+/-! Finite and terminal stopping-time restart identities using a capacity
+trace witness for the canonical driver law. -/
+noncomputable section
+open Set Filter _root_.MeasureTheory _root_.OAI.MeasureTheory ProbabilityTheory Classical
+open scoped NNReal ENNReal Topology
+
+namespace SLEExactGauge.Multipoint
+
+local instance restartDischargeDriverMeasurable : MeasurableSpace C(ℝ≥0,ℝ) := borel _
+local instance restartDischargeDriverBorel : BorelSpace C(ℝ≥0,ℝ) := ⟨rfl⟩
+
+variable {Ω : Type*} [MeasurableSpace Ω] {P : Measure Ω} [IsProbabilityMeasure P]
+  {κ : ℝ} {B : ℝ≥0 → Ω → ℝ} {hBm : Measurable (Function.uncurry B)}
+  {γ : Ω → ℝ≥0 → ℂ} {G : Ω → ℝ≥0 → ℂ → ℂ}
+
+theorem CanonicalMass.exists_raw_all_stopping_restart_of_brownian_witness
+    (C : CanonicalMass P κ B hBm γ G) (hB : IsBrownianReal B P)
+    (hc : ∀ ω, Continuous (fun t => B t ω)) (hκ : 0 < κ)
+    (F : Ω → ℝ≥0 → ℂ → ℂ)
+    (hw : ∀ ω, IsCapacityTwoWitness (fun t => Real.sqrt κ*B t ω) (γ ω) (G ω) (F ω))
+    (hκ8 : κ < 8) (hB0 : ∀ ω, B 0 ω = 0) :
+    ∃ R : RawCanonicalMass,
+      (∀ᵐ ω ∂P, (∀ t, R.process t (sourceDriverPath B hc ω)=C.process t ω) ∧
+        R.terminal (sourceDriverPath B hc ω)=C.rational.terminal ω) ∧
+      ∀ (S : Ω → WithTop ℝ≥0)
+        (_hS : IsStoppingTime (Filtration.natural B (fun s =>
+          (hBm.comp (measurable_const.prodMk measurable_id) : Measurable (B s)).stronglyMeasurable)) S),
+        ∀ᵐ ω ∂P, S ω < ⊤ → ∀ u : ℝ≥0∞,
+          extendedCanonicalMass C.process C.rational.terminal
+              ((((S ω).untopD (0 : ℝ≥0) : ℝ≥0) : ℝ≥0∞)+u) ω-C.process ((S ω).untopD (0 : ℝ≥0)) ω =
+            weightedImageMass
+              (stoppedMassPoint B κ γ G F hw (fun ω => (S ω).untopD (0 : ℝ≥0)) ω)
+              (stoppedMassWeight B κ F (fun ω => (S ω).untopD (0 : ℝ≥0)) ω)
+              (extendedCanonicalMass R.process R.terminal u
+                (sourceRestartDriverPath B hc (fun ω => (S ω).untopD (0 : ℝ≥0)) ω)) := by
+  exact C.exists_raw_all_stopping_restart hB hc hκ F hw
+    (canonical_driver_trace_generation_of_witness κ hκ hκ8 B hB
+      (fun t => hBm.comp (measurable_const.prodMk measurable_id)) hc hB0 γ G F hw)
+
+theorem CanonicalMass.exists_raw_all_image_restart_of_brownian_witness
+    (C : CanonicalMass P κ B hBm γ G) (hB : IsBrownianReal B P)
+    (hc : ∀ ω, Continuous (fun t => B t ω)) (hκ : 0 < κ)
+    (F : Ω → ℝ≥0 → ℂ → ℂ)
+    (hw : ∀ ω, IsCapacityTwoWitness (fun t => Real.sqrt κ*B t ω) (γ ω) (G ω) (F ω))
+    (hκ8 : κ < 8) (hB0 : ∀ ω, B 0 ω = 0) :
+    ∃ R : RawCanonicalMass,
+      (∀ᵐ ω ∂P, (∀ t, R.process t (sourceDriverPath B hc ω)=C.process t ω) ∧
+        R.terminal (sourceDriverPath B hc ω)=C.rational.terminal ω) ∧
+      ∀ (S : Ω → WithTop ℝ≥0)
+        (_hS : IsStoppingTime (Filtration.natural B (fun s =>
+          (hBm.comp (measurable_const.prodMk measurable_id) : Measurable (B s)).stronglyMeasurable)) S),
+        ∀ᵐ ω ∂P, S ω < ⊤ → ∀ (D : Set ℂ) (J : upperHalfPlane ≃ₜ D)
+          (w : C(upperHalfPlane,ℝ≥0)) (u : ℝ≥0∞),
+          conformalMass J w (C.atTime ((((S ω).untopD (0:ℝ≥0):ℝ≥0):ℝ≥0∞)+u) ω)-
+              conformalMass J w (C.process ((S ω).untopD (0:ℝ≥0)) ω) =
+            conformalMass J w (weightedImageMass
+              (stoppedMassPoint B κ γ G F hw (fun ω => (S ω).untopD (0:ℝ≥0)) ω)
+              (stoppedMassWeight B κ F (fun ω => (S ω).untopD (0:ℝ≥0)) ω)
+              (extendedCanonicalMass R.process R.terminal u
+                (sourceRestartDriverPath B hc (fun ω => (S ω).untopD (0:ℝ≥0)) ω))) := by
+  exact C.exists_raw_all_image_restart hB hc hκ F hw
+    (canonical_driver_trace_generation_of_witness κ hκ hκ8 B hB
+      (fun t => hBm.comp (measurable_const.prodMk measurable_id)) hc hB0 γ G F hw)
+
+end SLEExactGauge.Multipoint
+
+end
+
+end OAI
diff --git a/lean/OAI/Probability/SLE/Geometry/CanonicalRestartWitness.lean b/lean/OAI/Probability/SLE/Geometry/CanonicalRestartWitness.lean
new file mode 100644
index 0000000000000000000000000000000000000000..f0f4c7d893493d576a8abfef5887caa6c4c780ba
--- /dev/null
+++ b/lean/OAI/Probability/SLE/Geometry/CanonicalRestartWitness.lean
@@ -0,0 +1,172 @@
+import OAI.Probability.SLE.Geometry.PublishedInputs
+import OAI.Probability.SLE.Loewner.TraceWitnessUniqueness
+import OAI.Probability.SLE.Geometry.FiniteBoundaryRestart
+
+namespace OAI
+
+/-! Actual capacity witnesses for the fresh driver path. The trace-generation
+input is Rohde--Schramm's existing input on the single canonical driver law.
+Deterministic uniqueness identifies the resulting measurable trace factor
+with the factor in the proved stopped trace law. -/
+
+noncomputable section
+open Set Filter MeasureTheory ProbabilityTheory
+open scoped Topology NNReal ENNReal
+
+namespace SLEExactGauge
+
+local instance canonicalDriverMeasurable : MeasurableSpace C(ℝ≥0, ℝ) := borel _
+local instance canonicalDriverBorel : BorelSpace C(ℝ≥0, ℝ) := ⟨rfl⟩
+local instance canonicalTraceMeasurable : MeasurableSpace C(ℝ≥0, ℂ) := borel _
+local instance canonicalTraceBorel : BorelSpace C(ℝ≥0, ℂ) := ⟨rfl⟩
+
+/-- Evaluation on the canonical continuous-driver law is the same Brownian
+motion law, so the trace-generation input below is applied to a Brownian driver. -/
+theorem canonical_driver_isBrownian
+    {Ω : Type*} [MeasurableSpace Ω] {P : Measure Ω}
+    (B : ℝ≥0 → Ω → ℝ) (hB : IsBrownianReal B P)
+    (hm : ∀ t, Measurable (B t)) (hc : ∀ ω, Continuous (fun t => B t ω)) :
+    IsBrownianReal (fun (t : ℝ≥0) (p : C(ℝ≥0, ℝ)) => p t)
+      (P.map (sourceDriverPath B hc)) := by
+  have hbp : Measurable (sourceDriverPath B hc) := source_path_measurable _ hm
+  refine ⟨⟨fun I => ?_⟩, Eventually.of_forall (fun p => p.continuous)⟩
+  have hI : Measurable (fun p : C(ℝ≥0, ℝ) => I.restrict (fun t => p t)) :=
+    Measurable.of_eval (fun i => (continuous_eval_const (i : ℝ≥0)).measurable)
+  refine ⟨hI.aemeasurable, ?_⟩
+  rw [Measure.map_map hI hbp]
+  exact (hB.hasLaw I).map_eq
+
+theorem exists_measurable_canonical_witness
+    (ν : Measure C(ℝ≥0, ℝ)) (κ : ℝ)
+    (hpublished : PublishedTraceGeneration ν κ (fun t p => p t)) :
+    ∃ (Φ : C(ℝ≥0, ℝ) → C(ℝ≥0, ℂ))
+      (Gc Fc : C(ℝ≥0, ℝ) → ℝ≥0 → ℂ → ℂ), Measurable Φ ∧
+      ∀ᵐ p ∂ν, IsCapacityTwoWitness (fun t => Real.sqrt κ * p t) (Φ p) (Gc p) (Fc p) := by
+  classical
+  obtain ⟨γ, hm, htrace⟩ := hpublished
+  obtain ⟨S, hSa, hSm, hS⟩ := htrace.exists_measurable_mem
+  choose G F hw using fun p : S => hS p p.property
+  let g : C(ℝ≥0, ℝ) → ℝ≥0 → ℂ := fun p t => if p ∈ S then γ p t else 0
+  have hg (p : C(ℝ≥0, ℝ)) : Continuous (g p) := by
+    by_cases hp : p ∈ S
+    · simpa only [g, ite_eq_left hp] using (hw ⟨p, hp⟩).1
+    · simpa only [g, ite_eq_right hp] using (continuous_const : Continuous (fun _ : ℝ≥0 => (0 : ℂ)))
+  let Φ : C(ℝ≥0, ℝ) → C(ℝ≥0, ℂ) := fun p => ⟨g p, hg p⟩
+  let Gc : C(ℝ≥0, ℝ) → ℝ≥0 → ℂ → ℂ := fun p =>
+    if hp : p ∈ S then G ⟨p, hp⟩ else fun _ _ => 0
+  let Fc : C(ℝ≥0, ℝ) → ℝ≥0 → ℂ → ℂ := fun p =>
+    if hp : p ∈ S then F ⟨p, hp⟩ else fun _ _ => 0
+  refine ⟨Φ, Gc, Fc, ?_, ?_⟩
+  · apply source_path_measurable
+    intro t
+    change Measurable (fun p => if p ∈ S then γ p t else 0)
+    exact Measurable.ite hSm (hm t) measurable_const
+  · filter_upwards [hSa] with p hp
+    change IsCapacityTwoWitness _ (g p) (Gc p) (Fc p)
+    simpa only [g, Gc, Fc, ite_eq_left hp, dite_eq_left hp] using hw ⟨p, hp⟩
+
+theorem canonical_witness_pullback
+    {ν : Measure C(ℝ≥0, ℝ)} {κ : ℝ}
+    {Φ : C(ℝ≥0, ℝ) → C(ℝ≥0, ℂ)}
+    {Gc Fc : C(ℝ≥0, ℝ) → ℝ≥0 → ℂ → ℂ}
+    (hw : ∀ᵐ p ∂ν, IsCapacityTwoWitness (fun t => Real.sqrt κ * p t) (Φ p) (Gc p) (Fc p))
+    {Ω : Type*} [MeasurableSpace Ω] {P : Measure Ω}
+    (Y : Ω → C(ℝ≥0, ℝ)) (hY : Measurable Y) (hlaw : P.map Y = ν) :
+    ∀ᵐ ω ∂P, IsCapacityTwoWitness (fun t => Real.sqrt κ * Y ω t)
+      (Φ (Y ω)) (Gc (Y ω)) (Fc (Y ω)) := by
+  apply ae_of_ae_map (p := fun p : C(ℝ≥0, ℝ) =>
+    IsCapacityTwoWitness (fun t => Real.sqrt κ * p t) (Φ p) (Gc p) (Fc p)) hY.aemeasurable
+  rwa [hlaw]
+
+theorem canonical_witness_original_trace
+    {Ω : Type*} [MeasurableSpace Ω] (P : Measure Ω) (κ : ℝ)
+    (B : ℝ≥0 → Ω → ℝ) (hm : ∀ t, Measurable (B t))
+    (hc : ∀ ω, Continuous (fun t => B t ω))
+    (γ : Ω → ℝ≥0 → ℂ) (G F : Ω → ℝ≥0 → ℂ → ℂ)
+    (hw : ∀ ω, IsCapacityTwoWitness (fun t => Real.sqrt κ * B t ω) (γ ω) (G ω) (F ω))
+    (hpublished : PublishedTraceGeneration (P.map (sourceDriverPath B hc)) κ (fun t p => p t)) :
+    ∃ (Φ : C(ℝ≥0, ℝ) → C(ℝ≥0, ℂ))
+      (Gc Fc : C(ℝ≥0, ℝ) → ℝ≥0 → ℂ → ℂ), Measurable Φ ∧
+      (∀ᵐ p ∂P.map (sourceDriverPath B hc),
+        IsCapacityTwoWitness (fun t => Real.sqrt κ * p t) (Φ p) (Gc p) (Fc p)) ∧
+      ∀ᵐ ω ∂P, Φ (sourceDriverPath B hc ω) = sourceTracePath γ (fun ω => (hw ω).1) ω := by
+  obtain ⟨Φ, Gc, Fc, hΦm, hΦw⟩ := exists_measurable_canonical_witness _ κ hpublished
+  refine ⟨Φ, Gc, Fc, hΦm, hΦw, ?_⟩
+  have hbp := source_path_measurable (sourceDriverPath B hc) hm
+  filter_upwards [ae_of_ae_map hbp.aemeasurable hΦw] with ω hω
+  have hω' : IsCapacityTwoWitness (fun t => Real.sqrt κ * B t ω)
+      (Φ (sourceDriverPath B hc ω)) (Gc (sourceDriverPath B hc ω)) (Fc (sourceDriverPath B hc ω)) := hω
+  have he := hω'.trace_unique (hw ω)
+  ext t
+  exact congrFun he t
+
+/-- The same fresh path has an actual capacity witness and realizes the
+all-time finite-boundary restart identity. The only new instance of trace
+generation is its explicit specialization to the original driver path law. -/
+theorem source_canonical_witness_boundary_restart
+    {Ω : Type*} [mΩ : 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 → ℂ) (G F : Ω → ℝ≥0 → ℂ → ℂ)
+    (hw : ∀ ω, IsCapacityTwoWitness (fun t => Real.sqrt κ * B t ω) (γ ω) (G ω) (F ω))
+    (hpublished : PublishedTraceGeneration (P.map (sourceDriverPath B hc)) κ (fun t p => p t))
+    (hboundary : PublishedFiniteLoewnerBoundaryExtension)
+    (τ : Ω → ℝ≥0)
+    (hτ : IsStoppingTime (Filtration.natural B (fun t => (hm t).stronglyMeasurable))
+      (fun ω => (τ ω : WithTop ℝ≥0))) :
+    ∃ (Φ : C(ℝ≥0, ℝ) → C(ℝ≥0, ℂ))
+      (Gc Fc : C(ℝ≥0, ℝ) → ℝ≥0 → ℂ → ℂ) (Fb : Ω → C(closedHalfPlane, ℂ)),
+      Measurable Φ ∧ Measurable[hτ.measurableSpace] Fb ∧
+      (∀ᵐ p ∂P.map (sourceDriverPath B hc),
+        IsCapacityTwoWitness (fun t => Real.sqrt κ * p t) (Φ p) (Gc p) (Fc p)) ∧
+      (∀ ω (z : closedHalfPlane), z.1 ∈ upperHalfPlane →
+        Fb ω z = F ω (τ ω) (z + (Real.sqrt κ * B (τ ω) ω : ℝ))) ∧
+      (∀ ω, Fb ω ⟨0, by simp [closedHalfPlane]⟩ = γ ω (τ ω)) ∧
+      (∀ A : Set Ω, MeasurableSet[hτ.measurableSpace] A →
+        (P.restrict A).map (fun ω => Φ (sourceRestartDriverPath B hc τ ω)) =
+          P A • P.map (sourceTracePath γ (fun ω => (hw ω).1))) ∧
+      ∀ᵐ ω ∂P,
+        IsCapacityTwoWitness (fun t => Real.sqrt κ * sourceRestartDriverPath B hc τ ω t)
+          (Φ (sourceRestartDriverPath B hc τ ω))
+          (Gc (sourceRestartDriverPath B hc τ ω)) (Fc (sourceRestartDriverPath B hc τ ω)) ∧
+        ∀ t : ℝ≥0, γ ω (τ ω + t) =
+          finiteBoundaryPath (Fb ω) (Φ (sourceRestartDriverPath B hc τ ω)) t := by
+  obtain ⟨Φ, Gc, Fc, hΦm, hΦw, hΦorig⟩ :=
+    canonical_witness_original_trace P κ B hm hc γ G F hw hpublished
+  obtain ⟨Ψ, Fb, hΨm, hΨorig, hFbm, hFb, hFb0, hΨlaw, hΨrestart⟩ :=
+    source_measurable_finite_boundary_restart κ hκ hκ8 B hB hm hc γ G F hw hboundary τ hτ
+  let bp := sourceDriverPath B hc
+  let rp := sourceRestartDriverPath B hc τ
+  have hbp : Measurable bp := source_path_measurable bp hm
+  have hrp : Measurable rp := source_path_measurable rp (fun t =>
+    (measurable_pi_apply t).comp (brownianRestart_measurable hm hc
+      (stopping_time_measurable_nnreal hτ)))
+  have heq : ∀ᵐ p ∂P.map bp, Φ p = Ψ p := by
+    apply (ae_map_iff hbp.aemeasurable (measurableSet_eq_fun hΦm hΨm)).mpr
+    filter_upwards [hΦorig] with ω hω
+    exact hω.trans (hΨorig ω).symm
+  have hlaw : P.map rp = P.map bp := by
+    simpa only [Measure.restrict_univ, measure_univ, one_smul] using
+      source_restart_continuous_driver_law hB hm hc τ hτ (A := univ) MeasurableSet.univ
+  have hrEq : ∀ᵐ ω ∂P, Φ (rp ω) = Ψ (rp ω) := by
+    apply ae_of_ae_map (p := fun p : C(ℝ≥0, ℝ) => Φ p = Ψ p) hrp.aemeasurable
+    rwa [hlaw]
+  refine ⟨Φ, Gc, Fc, Fb, hΦm, hFbm, hΦw, hFb, hFb0, ?_, ?_⟩
+  · intro A hA
+    calc
+      _ = (P.restrict A).map (fun ω => Ψ (rp ω)) :=
+        Measure.map_congr (hrEq.filter_mono (ae_mono Measure.restrict_le_self))
+      _ = _ := hΨlaw A hA
+  · have hrw := canonical_witness_pullback hΦw rp hrp hlaw
+    filter_upwards [hrw, hrEq, hΨrestart] with ω hω heω hrestart
+    refine ⟨hω, ?_⟩
+    intro t
+    rw [heω]
+    exact hrestart t
+
+end SLEExactGauge
+
+end
+
+end OAI
diff --git a/lean/OAI/Probability/SLE/Geometry/CenteredCellTail.lean b/lean/OAI/Probability/SLE/Geometry/CenteredCellTail.lean
new file mode 100644
index 0000000000000000000000000000000000000000..44000a8d6f253f8077c264df61581508f0420087
--- /dev/null
+++ b/lean/OAI/Probability/SLE/Geometry/CenteredCellTail.lean
@@ -0,0 +1,113 @@
+import OAI.Probability.SLE.Geometry.RadiusCellTail
+import OAI.Probability.SLE.Geometry.FinitePastCellTail
+import OAI.Probability.SLE.Angle.RadiusAngleBounds
+import OAI.Probability.SLE.Geometry.ArbitraryDiskTail
+
+namespace OAI
+
+/-! Actual centered cell tails, and finite strict-past tests, are bounded
+by the prescribed limiting disk tail after angular mixing at the start. -/
+noncomputable section
+open Set Filter _root_.MeasureTheory _root_.OAI.MeasureTheory ProbabilityTheory Metric
+open scoped Topology NNReal ENNReal
+
+namespace SLEExactGauge.Multipoint
+local instance centeredCellMeasurable : MeasurableSpace C(ℝ≥0,ℝ) := borel _
+local instance centeredCellBorel : BorelSpace C(ℝ≥0,ℝ) := ⟨rfl⟩
+
+theorem CanonicalMass.centered_cell_tail_of_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))
+    (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)
+    (K : Set ℂ) (hK : MeasurableSet K) (hKball : K⊆closedBall z (2*r))
+    (hangle : ∀ θ∈Ioo (0:ℝ) Real.pi,
+      canonicalAngleAverage (P.map (sourceDriverPath B hc)) κ u
+        (R.angleDiskTail (P.map (sourceDriverPath B hc)) κ b v) θ ≤
+      2*(∫⁻ φ, R.angleDiskTail (P.map (sourceDriverPath B hc)) κ b v φ ∂Target.angleLaw κ)) :
+    finiteCenteredLaw P κ B γ G z (u+v)
+      (C.finiteCellMassTest (fun ω => radiusLevelTime (γ ω) (G ω) z (u+v)) K
+        (ENNReal.ofReal (((32768*Real.pi)*r)^dimension κ)*ENNReal.ofReal b)) ≤
+      2*C.limitingDiskTail hc b := by
+  have hm (t : ℝ≥0) : Measurable (B t) := hBm.of_uncurry_left
+  let ν := P.map (sourceDriverPath B hc)
+  let : IsProbabilityMeasure ν :=
+    (Measure.isProbabilityMeasure_map_iff (source_path_measurable _ hm).aemeasurable).mpr inferInstance
+  let Q := finiteCenteredLaw P κ B γ G z (u+v)
+  let : IsProbabilityMeasure Q := finiteCenteredLaw_probability hB κ hκ hκ8 γ G F
+    (Eventually.of_forall hw) z hz (u+v) (by linarith)
+  let f := R.angleDiskTail ν κ b v
+  have hf : Measurable f := R.angleDiskTail_measurable ν κ b v
+  have hh := C.cell_mass_disk_tail_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.le hv hr hR K hK hKball univ MeasurableSet.univ
+  simp only [univ_inter,setLIntegral_univ] at hh
+  have hi := (radius_angle_average_bounds hB hBm hc h0 hκ hκ8 γ G F hw hpublished
+    z hz 0 u (u+v) (by norm_num) hu (by linarith) f hf 0
+    (2*(∫⁻ φ, f φ ∂Target.angleLaw κ)) (fun θ hθ => ⟨bot_le,hangle θ hθ⟩)
+    univ MeasurableSet.univ).2
+  simp only [zero_add,setLIntegral_univ,measure_univ,mul_one] at hi
+  exact hh.trans (hi.trans (mul_le_mul' le_rfl
+    (C.raw_angle_tail_average_le_limit hB hc h0 hκ hκ8 F hw R he b v hv.le)))
+
+theorem CanonicalMass.centered_strict_past_cell_tail_of_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))
+    (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)
+    (K : Set ℂ) (hK : MeasurableSet K) (hKball : K⊆closedBall z (2*r))
+    (hangle : ∀ θ∈Ioo (0:ℝ) Real.pi,
+      canonicalAngleAverage (P.map (sourceDriverPath B hc)) κ u
+        (R.angleDiskTail (P.map (sourceDriverPath B hc)) κ b v) θ ≤
+      2*(∫⁻ φ, R.angleDiskTail (P.map (sourceDriverPath B hc)) κ b v φ ∂Target.angleLaw κ)) (J : Finset ℝ≥0) :
+    finiteCenteredLaw P κ B γ G z (u+v)
+      (finiteStrictPastEvent J
+        (fun t => {ω | (((32768*Real.pi)*r)^dimension κ)*b <
+          (C.process t ω (Subtype.val ⁻¹' K)).toReal})
+        (fun ω => radiusLevelTime (γ ω) (G ω) z (u+v))) ≤
+      2*C.limitingDiskTail hc b := by
+  let Q := finiteCenteredLaw P κ B γ G z (u+v)
+  let T : Ω → WithTop ℝ≥0 := fun ω => radiusLevelTime (γ ω) (G ω) z (u+v)
+  have hfinite : ∀ᵐ ω ∂Q, T ω≠⊤ :=
+    finiteCenteredLaw_earlier_stop_ae_finite hB hc κ hκ hκ8 γ G F (Eventually.of_forall hw)
+      z hz (u+v) (u+v) (by linarith) le_rfl T (Eventually.of_forall fun _ => le_rfl)
+  have hh := C.finite_strict_past_le_cell_test Q (withDensity_absolutelyContinuous P _) T
+    hfinite J K ((((32768*Real.pi)*r)^dimension κ)*b)
+  rw [ENNReal.ofReal_mul (Real.rpow_nonneg (by positivity) _)] at hh
+  exact hh.trans (C.centered_cell_tail_of_angle_bound 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 K hK hKball hangle)
+
+end SLEExactGauge.Multipoint
+
+end
+
+end OAI
diff --git a/lean/OAI/Probability/SLE/Geometry/CenteredDiskCoefficient.lean b/lean/OAI/Probability/SLE/Geometry/CenteredDiskCoefficient.lean
new file mode 100644
index 0000000000000000000000000000000000000000..3413648506ea0135ba7288652f7e70b954c228ca
--- /dev/null
+++ b/lean/OAI/Probability/SLE/Geometry/CenteredDiskCoefficient.lean
@@ -0,0 +1,125 @@
+import OAI.Probability.SLE.Geometry.CenteredStoppedMonotonicity
+import OAI.Probability.SLE.Gauge.FiniteMomentBounds
+
+namespace OAI
+
+/-! The exact prescribed coefficient is a stopped canonical-mass moment
+under the finite centered law, including paths with an infinite level time. -/
+
+noncomputable section
+open Set Filter _root_.MeasureTheory _root_.OAI.MeasureTheory ProbabilityTheory
+open scoped NNReal ENNReal Topology
+
+namespace SLEExactGauge.Multipoint.CanonicalMass
+
+variable {Ω : Type*} [mΩ : MeasurableSpace Ω] {P : Measure Ω} [IsProbabilityMeasure P] {κ : ℝ}
+  {B : ℝ≥0 → Ω → ℝ} {hBm : Measurable (Function.uncurry B)}
+  {γ : Ω → ℝ≥0 → ℂ} {G : Ω → ℝ≥0 → ℂ → ℂ}
+  (C : CanonicalMass P κ B hBm γ G)
+
+omit [IsProbabilityMeasure P] in
+lemma diskScalar_progressive (θ : ℝ) (hθ : θ∈Ioo (0:ℝ) Real.pi) :
+    IsProgressive (Filtration.natural B
+      (fun r => (hBm.comp (measurable_const.prodMk measurable_id) : Measurable (B r)).stronglyMeasurable))
+      (C.diskScalar θ hθ) := by
+  intro t
+  exact (compactWeightedMass_measurable _ _
+    (Target.diskSourceHalfPlane_compact hθ).measurableSet).comp (C.progressive t)
+
+omit [IsProbabilityMeasure P] in
+lemma normalizedStoppedDisk_eq_finite
+    (hc : ∀ ω, Continuous (fun t => B t ω)) (h0 : ∀ ω, B 0 ω=0)
+    (hκ : 0<κ) (F : Ω → ℝ≥0 → ℂ → ℂ)
+    (hw : ∀ ω, IsCapacityTwoWitness (fun t => Real.sqrt κ*B t ω) (γ ω) (G ω) (F ω))
+    (θ : ℝ) (hθ : θ∈Ioo (0:ℝ) Real.pi) (ℓ : ℝ) (hℓ : 0≤ℓ)
+    (σ : Ω → WithTop ℝ≥0) (ω : Ω)
+    (hs : σ ω=radiusLevelTime (γ ω) (G ω) (Target.diskMapInv θ 0) (4*ℓ/κ))
+    (hf : σ ω≠⊤) :
+    massAtExtendedTime (fun t => C.normalizedDiskScalar θ hθ t ω)
+      (C.diskTerminalScalar θ hθ ω)
+      (Target.levelTime κ θ (Target.normalizedDriver κ B hc h0 ω) ℓ) =
+        finiteStoppedScalar (C.diskScalar θ hθ) σ ω := by
+  have he := Target.levelTime_eq_radiusLevelTime κ hκ _ _ ((hc ω).const_mul _)
+    (γ ω) (G ω) (F ω) (hw ω) (Target.normalizedDriver_matches κ hκ B hc h0 ω) θ ℓ hℓ
+  rw [← hs] at he
+  rw [he, massAtExtendedTime, ite_eq_right (ENNReal.mul_ne_top ENNReal.ofReal_ne_top hf),
+    finiteStoppedScalar, ite_eq_right hf, normalizedDiskScalar]
+  congr 1
+  lift σ ω to ℝ≥0 using hf with s hs'
+  simp only [ENNReal.ofReal, WithTop.untopD_coe]
+  exact mul_div_cancel_left₀ s (Real.toNNReal_pos.mpr hκ).ne'
+
+lemma levelCoefficient_eq_centered_moment
+    (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 ω))
+    (hgrowth : PublishedDiskUnivalentGrowth) (W : Target.WienerLaw) (hW : Target.IsWiener W)
+    (θ : ℝ) (hθ : θ∈Ioo (0:ℝ) Real.pi) (ℓ : ℝ) (hℓ : 0≤ℓ) (m : ℕ)
+    (σ : Ω → WithTop ℝ≥0)
+    (hσ : IsStoppingTime (Filtration.natural B
+      (fun r => (hBm.comp (measurable_const.prodMk measurable_id) : Measurable (B r)).stronglyMeasurable)) σ)
+    (heσ : ∀ᵐ ω ∂P, σ ω=radiusLevelTime (γ ω) (G ω) (Target.diskMapInv θ 0) (4*ℓ/κ)) :
+    ENNReal.ofReal (Target.levelCoefficient κ W ℓ m θ) =
+      ∫⁻ ω, ENNReal.ofReal (finiteStoppedScalar (C.diskScalar θ hθ) σ ω)^m
+        ∂finiteCenteredLaw P κ B γ G (Target.diskMapInv θ 0) (4*ℓ/κ) := by
+  let w := fun ω => Target.levelDensity κ θ (Target.normalizedDriver κ B hc h0 ω) ℓ
+  let T := fun ω => Target.levelTime κ θ (Target.normalizedDriver κ B hc h0 ω) ℓ
+  let Y := fun ω => massAtExtendedTime (fun t => C.normalizedDiskScalar θ hθ t ω)
+    (C.diskTerminalScalar θ hθ ω) (T ω)
+  have hwM : Measurable w := (Target.measurable_fixedLevelDensity κ θ ℓ).comp
+    (Target.normalizedDriver_measurable κ B
+      (fun r => (hBm.comp (measurable_const.prodMk measurable_id) : Measurable (B r))) hc h0)
+  have hY : Measurable Y := C.normalizedStoppedDisk_measurable θ hθ T
+    (normalized_levelTime_measurable (hBm:=hBm) hκ hc h0 F hw θ ℓ hℓ)
+  have hw0 (ω) : 0≤w ω := Target.levelDensity_nonneg_of_witness κ hκ _ _ ((hc ω).const_mul _)
+    (γ ω) (G ω) (F ω) (hw ω) (Target.normalizedDriver_matches κ hκ B hc h0 ω) θ hθ ℓ hℓ
+  have hY0 (ω) : 0≤Y ω := C.normalizedStoppedDisk_nonneg θ hθ (T ω) ω
+  have hi : Integrable (fun ω => w ω*(Y ω)^m) P := by
+    apply (C.density_disk_terminal_integrable hB hc h0 hκ hκ8 F hw hgrowth m θ hθ ℓ hℓ).mono'
+      (hwM.mul (hY.pow_const m)).aestronglyMeasurable
+    filter_upwards [C.normalizedStoppedDisk_le_terminal hκ θ hθ T] with ω hω
+    change ‖w ω*(Y ω)^m‖ ≤ _
+    rw [Real.norm_of_nonneg (mul_nonneg (hw0 ω) (pow_nonneg (hY0 ω) m))]
+    exact mul_le_mul_of_nonneg_left (pow_le_pow_left₀ (hY0 ω) hω m) (hw0 ω)
+  have hQ : finiteCenteredLaw P κ B γ G (Target.diskMapInv θ 0) (4*ℓ/κ) =
+      P.withDensity (fun ω => ENNReal.ofReal (w ω)) := by
+    unfold finiteCenteredLaw
+    congr 1
+    funext ω
+    dsimp only [w]
+    rw [Target.levelDensity_eq_stoppedGreen κ hκ _ _ ((hc ω).const_mul _)
+      (γ ω) (G ω) (F ω) (hw ω) (Target.normalizedDriver_matches κ hκ B hc h0 ω) θ hθ ℓ hℓ]
+  rw [C.levelCoefficient_eq_mass hB hc h0 hκ hκ8 F hw hgrowth W hW θ hθ ℓ hℓ m]
+  change ENNReal.ofReal (∫ ω, w ω*(Y ω)^m ∂P)=_
+  rw [ofReal_integral_eq_lintegral_ofReal hi
+    (Eventually.of_forall (fun ω => mul_nonneg (hw0 ω) (pow_nonneg (hY0 ω) m))),hQ,
+    lintegral_withDensity_eq_lintegral_mul P hwM.ennreal_ofReal
+      (((finiteStoppedScalar_measurable _ _ (C.diskScalar_progressive θ hθ) σ hσ).mono
+        hσ.measurableSpace_le le_rfl).ennreal_ofReal.pow_const m)]
+  apply lintegral_congr_ae
+  filter_upwards [heσ] with ω hs
+  rw [ENNReal.ofReal_mul (hw0 ω),ENNReal.ofReal_pow (hY0 ω)]
+  change ENNReal.ofReal (w ω)*ENNReal.ofReal (Y ω)^m =
+    ENNReal.ofReal (w ω)*ENNReal.ofReal (finiteStoppedScalar (C.diskScalar θ hθ) σ ω)^m
+  by_cases hf : σ ω=⊤
+  · have hT : T ω=∞ := by
+      dsimp only [T]
+      rw [Target.levelTime_eq_radiusLevelTime κ hκ _ _ ((hc ω).const_mul _)
+        (γ ω) (G ω) (F ω) (hw ω) (Target.normalizedDriver_matches κ hκ B hc h0 ω) θ ℓ hℓ,
+        ← hs,hf]
+      change ENNReal.ofReal κ*(⊤:ℝ≥0∞)=∞
+      exact ENNReal.mul_top (ENNReal.ofReal_pos.mpr hκ).ne'
+    have hwz : w ω=0 := by
+      change Target.levelDensity κ θ _ ℓ=0
+      have hT' : Target.levelTime κ θ (Target.normalizedDriver κ B hc h0 ω) ℓ=∞ := hT
+      simp only [Target.levelDensity,hT',lt_self_iff_false,ite_false]
+    simp only [hwz,ENNReal.ofReal_zero,zero_mul]
+  · dsimp only [Y,T]
+    rw [C.normalizedStoppedDisk_eq_finite hc h0 hκ F hw θ hθ ℓ hℓ σ ω hs hf]
+
+end SLEExactGauge.Multipoint.CanonicalMass
+
+end
+
+end OAI
diff --git a/lean/OAI/Probability/SLE/Geometry/CenteredDiskLaw.lean b/lean/OAI/Probability/SLE/Geometry/CenteredDiskLaw.lean
new file mode 100644
index 0000000000000000000000000000000000000000..a4e28b44df5218ad43e1076f2182f801348e9d9d
--- /dev/null
+++ b/lean/OAI/Probability/SLE/Geometry/CenteredDiskLaw.lean
@@ -0,0 +1,131 @@
+import OAI.Probability.SLE.Geometry.CanonicalJointDisk
+import OAI.Probability.SLE.Gauge.ExactMomentGauge
+
+namespace OAI
+
+/-! The actual finite centered law with the prescribed initial angle mixture.
+Its moments are exactly the finite coefficients in the gauge construction. -/
+
+noncomputable section
+open Set Filter _root_.MeasureTheory _root_.OAI.MeasureTheory ProbabilityTheory
+open scoped Topology NNReal ENNReal
+
+namespace SLEExactGauge
+
+local instance : MeasurableSpace C(ℝ≥0,ℝ) := borel _
+local instance : BorelSpace C(ℝ≥0,ℝ) := ⟨rfl⟩
+
+def centeredDiskDensity {Ω : Type*} (κ : ℝ) (B : ℝ≥0 → Ω → ℝ)
+    (hc : ∀ ω, Continuous (fun t => B t ω)) (u : ℝ) (p : ℝ × Ω) : ℝ≥0∞ :=
+  canonicalFiniteDensity κ (u,Target.diskMapInv p.1 0,sourceDriverPath B hc p.2)
+
+def centeredDiskLaw {Ω : Type*} [MeasurableSpace Ω] (P : Measure Ω) (κ : ℝ)
+    (B : ℝ≥0 → Ω → ℝ) (hc : ∀ ω, Continuous (fun t => B t ω)) (u : ℝ) :
+    Measure (ℝ × Ω) :=
+  ((Target.angleLaw κ).prod P).withDensity (centeredDiskDensity κ B hc u)
+
+lemma centeredDiskDensity_measurable {Ω : Type*} [MeasurableSpace Ω]
+    (κ : ℝ) (B : ℝ≥0 → Ω → ℝ)
+    (hm : ∀ t, Measurable (B t)) (hc : ∀ ω, Continuous (fun t => B t ω)) (u : ℝ) :
+    Measurable (centeredDiskDensity κ B hc u) := by
+  apply (canonicalFiniteDensity_measurable κ).comp
+  apply measurable_const.prodMk
+  apply Measurable.prodMk
+  · unfold Target.diskMapInv
+    fun_prop
+  · exact (source_path_measurable (sourceDriverPath B hc) hm).comp measurable_snd
+
+lemma centeredDiskLaw_lintegral {Ω : Type*} [MeasurableSpace Ω]
+    (P : Measure Ω) [SFinite P] (κ : ℝ) (hκ : 0 < κ)
+    (B : ℝ≥0 → Ω → ℝ) (hm : ∀ t, Measurable (B t))
+    (hc : ∀ ω, Continuous (fun t => B t ω))
+    (γ : Ω → ℝ≥0 → ℂ) (G F : Ω → ℝ≥0 → ℂ → ℂ)
+    (hw : ∀ ω, IsCapacityTwoWitness (fun t => Real.sqrt κ*B t ω) (γ ω) (G ω) (F ω))
+    (u : ℝ) (hu : 0 ≤ u) (f : ℝ × Ω → ℝ≥0∞) (hf : Measurable f) :
+    (∫⁻ p, f p ∂centeredDiskLaw P κ B hc u) =
+      ∫⁻ θ, ∫⁻ ω, f (θ,ω) ∂finiteCenteredLaw P κ B γ G (Target.diskMapInv θ 0) u
+        ∂Target.angleLaw κ := by
+  let : IsProbabilityMeasure (Target.angleLaw κ) := Target.angleLaw_isProbability hκ
+  have hd := centeredDiskDensity_measurable κ B hm hc u
+  rw [centeredDiskLaw,lintegral_withDensity_eq_lintegral_mul _ hd hf,
+    lintegral_prod _ (hd.mul hf).aemeasurable]
+  apply lintegral_congr
+  intro θ
+  have hdθ : Measurable (fun ω => ENNReal.ofReal
+      (stoppedGreen κ (fun t => Real.sqrt κ*B t ω) (γ ω) (G ω)
+        (Target.diskMapInv θ 0) u / initialGreen κ (Target.diskMapInv θ 0))) := by
+    have hmθ : Measurable (fun ω : Ω => (θ,ω)) := measurable_const.prodMk measurable_id
+    have h : Measurable (fun ω : Ω => centeredDiskDensity κ B hc u (θ,ω)) := hd.comp hmθ
+    convert h using 1
+    funext ω
+    exact (canonicalFiniteDensity_eq κ (sourceDriverPath B hc ω) (hw ω) u hu _).symm
+  have hfθ : Measurable (fun ω : Ω => f (θ,ω)) :=
+    hf.comp (measurable_const.prodMk measurable_id)
+  rw [finiteCenteredLaw,lintegral_withDensity_eq_lintegral_mul _ hdθ hfθ]
+  apply lintegral_congr
+  intro ω
+  change centeredDiskDensity κ B hc u (θ,ω) * f (θ,ω) = _
+  dsimp only [centeredDiskDensity]
+  rw [canonicalFiniteDensity_eq κ (sourceDriverPath B hc ω) (hw ω) u hu]
+  rfl
+
+lemma centeredDiskLaw_isProbability {Ω : Type*} [MeasurableSpace Ω]
+    {P : Measure Ω} [IsProbabilityMeasure P] {κ : ℝ}
+    {B : ℝ≥0 → Ω → ℝ} (hB : IsBrownianReal B P) (hBm : Measurable (Function.uncurry B))
+    (hc : ∀ ω, Continuous (fun t => B t ω))
+    (hκ : 0<κ) (hκ8 : κ<8) (γ : Ω → ℝ≥0 → ℂ) (G F : Ω → ℝ≥0 → ℂ → ℂ)
+    (hw : ∀ ω, IsCapacityTwoWitness (fun t => Real.sqrt κ*B t ω) (γ ω) (G ω) (F ω))
+    (u : ℝ) (hu : 0≤u) : IsProbabilityMeasure (centeredDiskLaw P κ B hc u) := by
+  let : IsProbabilityMeasure (Target.angleLaw κ) := Target.angleLaw_isProbability hκ
+  constructor
+  rw [← lintegral_one,centeredDiskLaw_lintegral P κ hκ B
+    (fun t => hBm.comp (measurable_const.prodMk measurable_id)) hc γ G F hw u hu
+    (fun _ => 1) measurable_const]
+  calc
+    _ = ∫⁻ _θ, (1 : ℝ≥0∞) ∂Target.angleLaw κ := by
+      apply lintegral_congr_ae
+      filter_upwards [Target.angleLaw_ae_mem κ] with θ hθ
+      let := finiteCenteredLaw_probability hB κ hκ hκ8 γ G F (Eventually.of_forall hw)
+        (Target.diskMapInv θ 0) (Target.diskMapInv_maps hθ (by simp)) u hu
+      simp
+    _ = 1 := by simp
+
+namespace Multipoint.CanonicalMass
+
+variable {Ω : Type*} [MeasurableSpace Ω] {P : Measure Ω} [IsProbabilityMeasure P]
+  {κ : ℝ} {B : ℝ≥0 → Ω → ℝ} {hBm : Measurable (Function.uncurry B)}
+  {γ : Ω → ℝ≥0 → ℂ} {G : Ω → ℝ≥0 → ℂ → ℂ}
+  (C : CanonicalMass P κ B hBm γ G)
+
+lemma centeredDiskLaw_moment
+    (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 ω))
+    (hgrowth : PublishedDiskUnivalentGrowth) (W : Target.WienerLaw) (hW : Target.IsWiener W)
+    (ℓ : ℝ) (hℓ : 0≤ℓ) (m : ℕ) :
+    (∫⁻ p, ENNReal.ofReal (C.diskAtRadius p.1 (4*ℓ/κ) p.2)^m
+      ∂centeredDiskLaw P κ B hc (4*ℓ/κ)) = ENNReal.ofReal (Target.finiteMoment κ W m ℓ) := by
+  have hu : 0 ≤ 4*ℓ/κ := div_nonneg (mul_nonneg (by norm_num) hℓ) hκ.le
+  rw [centeredDiskLaw_lintegral P κ hκ B
+    (fun t => hBm.comp (measurable_const.prodMk measurable_id)) hc γ G F hw _ hu _
+    ((C.diskAtRadius_joint_measurable hc F hw _ hu).ennreal_ofReal.pow_const m)]
+  calc
+    _ = ∫⁻ θ, ENNReal.ofReal (Target.levelCoefficient κ W ℓ m θ) ∂Target.angleLaw κ := by
+      apply lintegral_congr_ae
+      filter_upwards [Target.angleLaw_ae_mem κ] with θ hθ
+      exact (C.levelCoefficient_eq_diskAtRadius_moment hB hc h0 hκ hκ8 F hw hgrowth W hW
+        θ hθ ℓ hℓ m).symm
+    _ = _ := by
+      rw [C.finiteMoment_eq_levelCoefficientIntegral hB hc h0 hκ hκ8 F hw hgrowth W hW ℓ hℓ m]
+      symm
+      apply ofReal_integral_eq_lintegral_ofReal
+        (C.levelCoefficient_nonneg_integrable hB hc h0 hκ hκ8 F hw hgrowth W hW ℓ hℓ m).2
+      filter_upwards [Target.angleLaw_ae_mem κ] with θ hθ
+      exact (C.levelCoefficient_nonneg_integrable hB hc h0 hκ hκ8 F hw hgrowth W hW ℓ hℓ m).1 θ hθ
+
+end Multipoint.CanonicalMass
+end SLEExactGauge
+
+end
+
+end OAI
diff --git a/lean/OAI/Probability/SLE/Geometry/CenteredFutureSlit.lean b/lean/OAI/Probability/SLE/Geometry/CenteredFutureSlit.lean
new file mode 100644
index 0000000000000000000000000000000000000000..f18de79dc90246374c02cbabcd739261cb7054ea
--- /dev/null
+++ b/lean/OAI/Probability/SLE/Geometry/CenteredFutureSlit.lean
@@ -0,0 +1,59 @@
+import OAI.Probability.SLE.Loewner.MappedFutureSimple
+import OAI.Probability.SLE.Loewner.SlitSegmentParameter
+
+namespace OAI
+
+/-! Centering at the proved driving value makes every future segment an
+ordinary simple attached slit, to which the existing normalized chart
+theorem applies. -/
+noncomputable section
+open Set Filter Function Complex
+open scoped Topology
+
+namespace SLEExactGauge
+
+noncomputable def centeredFutureArc (p : C(unitInterval,ℂ)) (hi : Injective p)
+    (h0 : p 0=0) (hH : ∀ t : unitInterval, t≠0 → p t∈upperHalfPlane)
+    {s t : unitInterval} (hst : s<t) (ht : t<1) : C(unitInterval,ℂ) where
+  toFun u := mappedFutureArc p hi h0 hH hst ht u-
+    (initialDrivingValue p hi h0 hH s (hst.trans ht):ℂ)
+  continuous_toFun := (mappedFutureArc p hi h0 hH hst ht).continuous.sub continuous_const
+
+@[simp] lemma centeredFutureArc_zero (p : C(unitInterval,ℂ)) (hi : Injective p)
+    (h0 : p 0=0) (hH : ∀ t : unitInterval, t≠0 → p t∈upperHalfPlane)
+    {s t : unitInterval} (hst : s<t) (ht : t<1) :
+    centeredFutureArc p hi h0 hH hst ht 0=0 := by
+  change mappedFutureArc p hi h0 hH hst ht 0-_=0
+  rw [mappedFutureArc_zero,sub_self]
+
+lemma centeredFutureArc_injective (p : C(unitInterval,ℂ)) (hi : Injective p)
+    (h0 : p 0=0) (hH : ∀ t : unitInterval, t≠0 → p t∈upperHalfPlane)
+    {s t : unitInterval} (hst : s<t) (ht : t<1) :
+    Injective (centeredFutureArc p hi h0 hH hst ht) := by
+  intro u v he
+  exact mappedFutureArc_injective p hi h0 hH hst ht (sub_left_inj.mp he)
+
+lemma centeredFutureArc_upper (p : C(unitInterval,ℂ)) (hi : Injective p)
+    (h0 : p 0=0) (hH : ∀ t : unitInterval, t≠0 → p t∈upperHalfPlane)
+    {s t : unitInterval} (hst : s<t) (ht : t<1)
+    {u : unitInterval} (hu : u≠0) :
+    centeredFutureArc p hi h0 hH hst ht u∈upperHalfPlane := by
+  have hh := mappedFutureArc_upper p hi h0 hH hst ht hu
+  change 0<(mappedFutureArc p hi h0 hH hst ht u).im at hh
+  change 0<(_-(_ : ℂ)).im
+  simpa only [sub_im,ofReal_im,sub_zero] using hh
+
+noncomputable def futureSlitChart (p : C(unitInterval,ℂ)) (hi : Injective p)
+    (h0 : p 0=0) (hH : ∀ t : unitInterval, t≠0 → p t∈upperHalfPlane)
+    {s t : unitInterval} (hst : s<t) (ht : t<1) :
+    SimpleSlitChart (centeredFutureArc p hi h0 hH hst ht) :=
+  Classical.choice (exists_simpleSlitChart _
+    (centeredFutureArc_injective p hi h0 hH hst ht)
+    (centeredFutureArc_zero p hi h0 hH hst ht)
+    (fun _ hu => centeredFutureArc_upper p hi h0 hH hst ht hu))
+
+end SLEExactGauge
+
+end
+
+end OAI
diff --git a/lean/OAI/Probability/SLE/Geometry/CenteredStoppedMonotonicity.lean b/lean/OAI/Probability/SLE/Geometry/CenteredStoppedMonotonicity.lean
new file mode 100644
index 0000000000000000000000000000000000000000..5dbd2e8fbfd5fb7ce61086bb208048ec2fb00223
--- /dev/null
+++ b/lean/OAI/Probability/SLE/Geometry/CenteredStoppedMonotonicity.lean
@@ -0,0 +1,70 @@
+import OAI.Probability.SLE.Geometry.FiniteStoppedScalar
+import OAI.Probability.SLE.Geometry.FiniteCenteredConsistency
+
+namespace OAI
+
+/-! The moments of an increasing progressive mass, evaluated at radius
+stops, increase with the finite centered law's terminal level. -/
+
+noncomputable section
+open Set Filter _root_.MeasureTheory _root_.OAI.MeasureTheory ProbabilityTheory
+open scoped NNReal ENNReal Topology
+
+namespace SLEExactGauge
+
+theorem finiteCenteredLaw_stoppedScalar_moment_mono
+    {Ω : Type*} [mΩ : MeasurableSpace Ω] {P : Measure Ω} [IsProbabilityMeasure P]
+    {B : ℝ≥0 → Ω → ℝ} (hB : IsBrownianReal B P)
+    (hBm : Measurable (Function.uncurry B))
+    (hc : ∀ ω, Continuous (fun t => B t ω)) (h0 : ∀ ω, B 0 ω=0)
+    (κ : ℝ) (hκ : 0<κ) (hκ8 : κ<8)
+    (γ : Ω → ℝ≥0 → ℂ) (G F : Ω → ℝ≥0 → ℂ → ℂ)
+    (hw : ∀ᵐ ω ∂P, IsCapacityTwoWitness (fun t => Real.sqrt κ*B t ω) (γ ω) (G ω) (F ω))
+    (z : ℂ) (hz : z∈upperHalfPlane) (v V : ℝ) (hv : 0≤v) (hvV : v≤V)
+    (A : ℝ≥0 → Ω → ℝ)
+    (hA : IsProgressive (Filtration.natural B
+      (fun r => (hBm.comp (measurable_const.prodMk measurable_id) : Measurable (B r)).stronglyMeasurable)) A)
+    (hmono : ∀ᵐ ω ∂P, Monotone (fun t => A t ω))
+    (σ τ : Ω → WithTop ℝ≥0)
+    (hσ : IsStoppingTime (Filtration.natural B
+      (fun r => (hBm.comp (measurable_const.prodMk measurable_id) : Measurable (B r)).stronglyMeasurable)) σ)
+    (_hτ : IsStoppingTime (Filtration.natural B
+      (fun r => (hBm.comp (measurable_const.prodMk measurable_id) : Measurable (B r)).stronglyMeasurable)) τ)
+    (hσeq : ∀ᵐ ω ∂P, σ ω=radiusLevelTime (γ ω) (G ω) z v)
+    (hτeq : ∀ᵐ ω ∂P, τ ω=radiusLevelTime (γ ω) (G ω) z V) (m : ℕ) :
+    (∫⁻ ω, ENNReal.ofReal (finiteStoppedScalar A σ ω)^m ∂finiteCenteredLaw P κ B γ G z v) ≤
+      ∫⁻ ω, ENNReal.ofReal (finiteStoppedScalar A τ ω)^m ∂finiteCenteredLaw P κ B γ G z V := by
+  let Q := finiteCenteredLaw P κ B γ G z V
+  have hσf : ∀ᵐ ω ∂Q, σ ω≠⊤ :=
+    finiteCenteredLaw_earlier_stop_ae_finite hB hc κ hκ hκ8 γ G F hw z hz v V hv hvV σ
+      (hσeq.mono (fun _ h => h.le))
+  have hτf : ∀ᵐ ω ∂Q, τ ω≠⊤ :=
+    finiteCenteredLaw_earlier_stop_ae_finite hB hc κ hκ hκ8 γ G F hw z hz V V
+      (hv.trans hvV) le_rfl τ (hτeq.mono (fun _ h => h.le))
+  have horder : ∀ᵐ ω ∂P, σ ω≤τ ω := by
+    filter_upwards [hw,hσeq,hτeq] with ω hω hs ht
+    rw [hs,ht]
+    exact radiusLevelTime_mono ((hc ω).const_mul _) hω z hv hvV
+  have habs : Q.AbsolutelyContinuous P := withDensity_absolutelyContinuous P _
+  have heq : (∫⁻ ω, ENNReal.ofReal (finiteStoppedScalar A σ ω)^m ∂Q) =
+      ∫⁻ ω, ENNReal.ofReal (finiteStoppedScalar A σ ω)^m ∂finiteCenteredLaw P κ B γ G z v := by
+    apply lintegral_eq_of_stopped_events Q (finiteCenteredLaw P κ B γ G z v)
+      hσ.measurableSpace hσ.measurableSpace_le
+    · intro E hE
+      exact finiteCenteredLaw_consistent_at_radius_stop hB hBm hc h0 κ hκ hκ8 γ G F hw
+        z hz v V hv hvV σ hσ hσeq E hE
+    · exact ((finiteStoppedScalar_measurable _ A hA σ hσ).ennreal_ofReal).pow_const m
+  rw [← heq]
+  apply lintegral_mono_ae
+  filter_upwards [hσf,hτf,habs.ae_le horder,habs.ae_le hmono] with ω hs ht hst hm
+  apply pow_le_pow_left'
+  apply ENNReal.ofReal_le_ofReal
+  simp only [finiteStoppedScalar,hs,ht,ite_false]
+  apply hm
+  exact WithTop.untopD_mono ht hst
+
+end SLEExactGauge
+
+end
+
+end OAI
diff --git a/lean/OAI/Probability/SLE/Geometry/CenteredStoppedTails.lean b/lean/OAI/Probability/SLE/Geometry/CenteredStoppedTails.lean
new file mode 100644
index 0000000000000000000000000000000000000000..ea2b9498f80e032f5f64f625116b6b5f70e5b940
--- /dev/null
+++ b/lean/OAI/Probability/SLE/Geometry/CenteredStoppedTails.lean
@@ -0,0 +1,76 @@
+import OAI.Probability.SLE.Geometry.CenteredStoppedMonotonicity
+
+namespace OAI
+
+/-! Tail events of increasing canonical scalars under consistent finite laws.
+Only the stopped past is transported when the terminal level is increased. -/
+
+noncomputable section
+open Set Filter _root_.MeasureTheory _root_.OAI.MeasureTheory ProbabilityTheory
+open scoped NNReal ENNReal Topology
+
+namespace SLEExactGauge
+
+theorem finiteCenteredLaw_stoppedScalar_tail_mono
+    {Ω : Type*} [mΩ : MeasurableSpace Ω] {P : Measure Ω} [IsProbabilityMeasure P]
+    {B : ℝ≥0 → Ω → ℝ} (hB : IsBrownianReal B P)
+    (hBm : Measurable (Function.uncurry B))
+    (hc : ∀ ω, Continuous (fun t => B t ω)) (h0 : ∀ ω, B 0 ω=0)
+    (κ : ℝ) (hκ : 0<κ) (hκ8 : κ<8)
+    (γ : Ω → ℝ≥0 → ℂ) (G F : Ω → ℝ≥0 → ℂ → ℂ)
+    (hw : ∀ᵐ ω ∂P, IsCapacityTwoWitness (fun t => Real.sqrt κ*B t ω) (γ ω) (G ω) (F ω))
+    (z : ℂ) (hz : z∈upperHalfPlane) (v V : ℝ) (hv : 0≤v) (hvV : v≤V)
+    (A : ℝ≥0 → Ω → ℝ)
+    (hA : IsProgressive (Filtration.natural B
+      (fun r => (hBm.comp (measurable_const.prodMk measurable_id) : Measurable (B r)).stronglyMeasurable)) A)
+    (hmono : ∀ᵐ ω ∂P, Monotone (fun t => A t ω))
+    (σ τ : Ω → WithTop ℝ≥0)
+    (hσ : IsStoppingTime (Filtration.natural B
+      (fun r => (hBm.comp (measurable_const.prodMk measurable_id) : Measurable (B r)).stronglyMeasurable)) σ)
+    (hσeq : ∀ᵐ ω ∂P, σ ω=radiusLevelTime (γ ω) (G ω) z v)
+    (hτeq : ∀ᵐ ω ∂P, τ ω=radiusLevelTime (γ ω) (G ω) z V) (b : ℝ) :
+    finiteCenteredLaw P κ B γ G z v {ω | b ≤ finiteStoppedScalar A σ ω} ≤
+      finiteCenteredLaw P κ B γ G z V {ω | b ≤ finiteStoppedScalar A τ ω} := by
+  let Q := finiteCenteredLaw P κ B γ G z V
+  have hσf : ∀ᵐ ω ∂Q, σ ω≠⊤ :=
+    finiteCenteredLaw_earlier_stop_ae_finite hB hc κ hκ hκ8 γ G F hw z hz v V hv hvV σ
+      (hσeq.mono (fun _ h => h.le))
+  have hτf : ∀ᵐ ω ∂Q, τ ω≠⊤ :=
+    finiteCenteredLaw_earlier_stop_ae_finite hB hc κ hκ hκ8 γ G F hw z hz V V
+      (hv.trans hvV) le_rfl τ (hτeq.mono (fun _ h => h.le))
+  have horder : ∀ᵐ ω ∂P, σ ω≤τ ω := by
+    filter_upwards [hw,hσeq,hτeq] with ω hω hs ht
+    rw [hs,ht]
+    exact radiusLevelTime_mono ((hc ω).const_mul _) hω z hv hvV
+  have habs : Q.AbsolutelyContinuous P := withDensity_absolutelyContinuous P _
+  have he := finiteCenteredLaw_consistent_at_radius_stop hB hBm hc h0 κ hκ hκ8 γ G F hw
+    z hz v V hv hvV σ hσ hσeq {ω | b ≤ finiteStoppedScalar A σ ω}
+    (measurableSet_le measurable_const (finiteStoppedScalar_measurable _ A hA σ hσ))
+  rw [← he]
+  apply measure_mono_ae
+  filter_upwards [hσf,hτf,habs.ae_le horder,habs.ae_le hmono] with ω hs ht hst hm
+  intro hb
+  apply hb.trans
+  simp only [finiteStoppedScalar,hs,ht,ite_false]
+  exact hm (WithTop.untopD_mono ht hst)
+
+/-- A finite-law moment gives a tail bound without constructing an infinite
+centered path law. This form is convenient before taking the level supremum. -/
+lemma stoppedScalar_tail_moment_bound
+    {Ω : Type*} [MeasurableSpace Ω] (Q : Measure Ω)
+    (X : Ω → ℝ) (hX : Measurable X)
+    (b : ℝ) (hb : 0 ≤ b) (n : ℕ) :
+    ENNReal.ofReal (b^n)*Q {ω | b ≤ X ω} ≤ ∫⁻ ω, ENNReal.ofReal (X ω)^n ∂Q := by
+  have he : ENNReal.ofReal (b^n)=ENNReal.ofReal b^n := ENNReal.ofReal_pow hb n
+  rw [he]
+  apply le_trans ?_ (mul_meas_ge_le_lintegral (hX.ennreal_ofReal.pow_const n) (ENNReal.ofReal b^n))
+  apply mul_le_mul' le_rfl
+  apply measure_mono
+  intro ω hω
+  exact pow_le_pow_left' (ENNReal.ofReal_le_ofReal hω) n
+
+end SLEExactGauge
+
+end
+
+end OAI
diff --git a/lean/OAI/Probability/SLE/Geometry/CircleRadialFlux.lean b/lean/OAI/Probability/SLE/Geometry/CircleRadialFlux.lean
new file mode 100644
index 0000000000000000000000000000000000000000..6e6295faccc7e2c80bc30c73d7791bd3f61465c8
--- /dev/null
+++ b/lean/OAI/Probability/SLE/Geometry/CircleRadialFlux.lean
@@ -0,0 +1,64 @@
+import OAI.Probability.SLE.Geometry.PolarLaplacianFlux
+
+namespace OAI
+
+/-! The ordinary angular integral of radial flux is a circle average of
+the derivative applied to the position vector. -/
+noncomputable section
+open Set Filter Metric Function Complex MeasureTheory InnerProductSpace Real
+open scoped Topology Laplacian
+
+namespace SLEExactGauge
+
+lemma circleAverage_eq_neg_pi_integral {E : Type*} [NormedAddCommGroup E]
+    [NormedSpace ℝ E] (f : ℂ → E) (r : ℝ) :
+    circleAverage f 0 r=(2*Real.pi)⁻¹ • ∫ θ in -Real.pi..Real.pi, f (polarPoint r θ) := by
+  have h := circleAverage_eq_integral_add (f := f) (c := (0:ℂ)) (R := r) (-Real.pi)
+  have hs := intervalIntegral.integral_comp_add_right (fun θ => f (circleMap 0 r θ))
+    (a := (0:ℝ)) (b := 2*Real.pi) (-Real.pi)
+  rw [hs] at h
+  have hend : 2*Real.pi+ -Real.pi=Real.pi := by ring
+  simpa only [zero_add,hend,←polarPoint_eq_circleMap] using h
+
+lemma polar_integral_eq_circleAverage (g : ℂ → ℝ) (r : ℝ) :
+    (∫ θ in -Real.pi..Real.pi, r*g (polarPoint r θ))=
+      2*Real.pi*r*circleAverage g 0 r := by
+  rw [intervalIntegral.integral_const_mul,circleAverage_eq_neg_pi_integral,smul_eq_mul]
+  field_simp
+
+lemma radial_flux_eq_circleAverage (u : ℂ → ℝ) (r : ℝ) :
+    (∫ θ in -Real.pi..Real.pi, radialLaplacianFlux u (r,θ))=
+      2*Real.pi*circleAverage (fun z => fderiv ℝ u z z) 0 r := by
+  rw [circleAverage_eq_neg_pi_integral,smul_eq_mul]
+  have hpoint (θ : ℝ) : radialLaplacianFlux u (r,θ)=
+      fderiv ℝ u (polarPoint r θ) (polarPoint r θ) := by
+    unfold radialLaplacianFlux
+    conv_rhs => arg 2; rw [polarPoint]
+    simp only [map_smul,smul_eq_mul]
+  simp_rw [hpoint]
+  field_simp
+
+lemma radial_flux_continuousOn {u : ℂ → ℝ} {R : ℝ}
+    (hu : ∀ z∈closedBall (0:ℂ) R, ContDiffAt ℝ 2 u z) :
+    ContinuousOn (fun r => ∫ θ in -Real.pi..Real.pi, radialLaplacianFlux u (r,θ)) (Icc 0 R) := by
+  have hc : ContinuousOn (fun z => fderiv ℝ u z z)
+      {z : ℂ | ‖z-(0:ℂ)‖∈Icc 0 R} := by
+    intro z hz
+    have hzR : z∈closedBall (0:ℂ) R := by
+      rw [mem_closedBall,dist_eq_norm]
+      exact hz.2
+    have hh := ((hu z hzR).fderiv_right (m := 1) (by norm_num)).continuousAt
+    exact (hh.clm_apply continuousAt_id).continuousWithinAt
+  have hav := hc.circleAverage (fun r hr => hr.1)
+  simp_rw [radial_flux_eq_circleAverage]
+  exact hav.const_mul _
+
+@[simp] lemma radial_flux_zero (u : ℂ → ℝ) :
+    (∫ θ in -Real.pi..Real.pi, radialLaplacianFlux u (0,θ))=0 := by
+  simp [radialLaplacianFlux]
+
+end SLEExactGauge
+
+end
+
+end OAI
diff --git a/lean/OAI/Probability/SLE/Geometry/ClosedArcCrossing.lean b/lean/OAI/Probability/SLE/Geometry/ClosedArcCrossing.lean
new file mode 100644
index 0000000000000000000000000000000000000000..f3875bf73e99594b11aa9aa3c384dc46c5e5c100
--- /dev/null
+++ b/lean/OAI/Probability/SLE/Geometry/ClosedArcCrossing.lean
@@ -0,0 +1,75 @@
+import OAI.Probability.SLE.Geometry.TransverseCurveDifference
+
+namespace OAI
+
+/-! Closing an arc by a path outside the domain preserves its unique
+interior crossing. This connects the small-loop obstruction to inverse
+Loewner semicircles. -/
+noncomputable section
+open Set Filter Metric Function
+open scoped Topology
+
+namespace SLEExactGauge
+
+lemma path_trans_first_strict_deriv {a b d : ℂ} (c : Path a b) (q : Path b d)
+    {t : ℝ} (ht : t<1) {α : ℂ} (hc : HasStrictDerivAt c.extend α t) :
+    HasStrictDerivAt (c.trans q).extend ((2:ℝ) • α) (t/2) := by
+  have hd : HasStrictDerivAt (fun u : ℝ => 2*u) 2 (t/2) := by
+    simpa using (hasStrictDerivAt_id (t/2)).const_mul 2
+  have hcomp := hc.scomp_of_eq (t/2) hd (by ring)
+  apply hcomp.congr_of_eventuallyEq
+  filter_upwards [eventually_lt_nhds (show t/2<(1:ℝ)/2 by linarith)] with u hu
+  exact (Path.extend_trans_of_le_half c q hu.le).symm
+
+lemma small_closed_arc_no_transverse_crossing {D : Set ℂ} {a b y z : ℂ}
+    (c : Path a b) (q : Path b a) (p : Path y z)
+    (hpin : ∀ u, p u∈D) (hqout : ∀ u, q u∉D)
+    (w : ℂ) (r : ℝ) (hr : 0<r)
+    (hcball : ∀ u, c u∈ball w r) (hqball : ∀ u, q u∈ball w r)
+    (hy : y∉ball w r) (hz : z∉ball w r)
+    (s t : unitInterval) (hs : 0<(s:ℝ) ∧ (s:ℝ)<1) (ht : 0<(t:ℝ) ∧ (t:ℝ)<1)
+    (he : c t=p s) (hu : ∀ u v, c v=p u → u=s ∧ v=t)
+    (α β : ℂ) (hc : HasStrictDerivAt c.extend α t) (hp : HasStrictDerivAt p.extend β s)
+    (htrans : ∀ u v : ℝ, u • α-v • β=0 → u=0 ∧ v=0) : False := by
+  let l := c.trans q
+  let t' : unitInterval := ⟨(t:ℝ)/2,by constructor <;> linarith [t.property.1,t.property.2]⟩
+  have ht' : 0<(t':ℝ) ∧ (t':ℝ)<1 := ⟨half_pos ht.1,by dsimp [t']; linarith [ht.2]⟩
+  have hlball (u : unitInterval) : l u∈ball w r := by
+    have hmem : l u∈range l := mem_range_self u
+    rw [Path.trans_range] at hmem
+    rcases hmem with ⟨v,hv⟩ | ⟨v,hv⟩
+    · exact hv ▸ hcball v
+    · exact hv ▸ hqball v
+  have he' : l t'=p s := by
+    rw [Path.trans_apply,dite_eq_left (show (t':ℝ)≤1/2 by dsimp [t']; linarith [t.property.2])]
+    convert he using 1
+    congr 1
+    apply Subtype.ext
+    dsimp [t']
+    ring
+  have hu' (u v : unitInterval) (hev : l v=p u) : u=s ∧ v=t' := by
+    rw [Path.trans_apply] at hev
+    split_ifs at hev with hv
+    · obtain ⟨hu,hv'⟩ := hu _ _ hev
+      refine ⟨hu,Subtype.ext ?_⟩
+      have hvR := congrArg (fun a : unitInterval => (a:ℝ)) hv'
+      dsimp [t']
+      dsimp at hvR
+      linarith
+    · exact False.elim ((hqout _) (hev ▸ hpin u))
+  have htrans' (u v : ℝ) (heq : u • ((2:ℝ) • α)-v • β=0) : u=0 ∧ v=0 := by
+    have heq' : (2*u) • α-v • β=0 := by simpa only [smul_smul,mul_comm] using heq
+    obtain ⟨hu,hv⟩ := htrans _ _ heq'
+    exact ⟨by linarith,hv⟩
+  have hloc := transverse_difference_locally_injective
+    (path_trans_first_strict_deriv c q ht.2 hc) hp htrans'
+  apply small_loop_no_single_crossing (l : C(unitInterval,ℂ)) (p : C(unitInterval,ℂ))
+    w r hr hlball (by simpa using hy) (by simpa using hz) s t' hs ht' he' hu'
+  · exact hloc
+  · simp [l]
+
+end SLEExactGauge
+
+end
+
+end OAI
diff --git a/lean/OAI/Probability/SLE/Geometry/ClosedComplexPair.lean b/lean/OAI/Probability/SLE/Geometry/ClosedComplexPair.lean
new file mode 100644
index 0000000000000000000000000000000000000000..acff636faa895ef1f124232defc7cdf624867416
--- /dev/null
+++ b/lean/OAI/Probability/SLE/Geometry/ClosedComplexPair.lean
@@ -0,0 +1,84 @@
+import OAI.Probability.SLE.Geometry.ClosedComplexUnion
+
+namespace OAI
+
+/-! Gluing two prescribed homeomorphisms on closed pieces. -/
+noncomputable section
+open Set
+
+namespace SLEExactGauge
+
+def closedComplexPairHomeomorph {A A' B B' : Set ℂ}
+    (hA : IsClosed A) (hA' : IsClosed A') (hB : IsClosed B) (hB' : IsClosed B')
+    (e : A ≃ₜ A') (d : B ≃ₜ B')
+    (he : ∀ (x : A) (hx : (x:ℂ) ∈ B), (e x:ℂ)=d ⟨x,hx⟩)
+    (hi : ∀ (x : A') (hx : (x:ℂ) ∈ B'), (e.symm x:ℂ)=d.symm ⟨x,hx⟩) :
+    ↥(A ∪ B) ≃ₜ ↥(A' ∪ B') := by
+  classical
+  let f (x : ℂ) := if ha : x ∈ A then (e ⟨x,ha⟩:ℂ)
+    else if hb : x ∈ B then (d ⟨x,hb⟩:ℂ) else x
+  let g (x : ℂ) := if ha : x ∈ A' then (e.symm ⟨x,ha⟩:ℂ)
+    else if hb : x ∈ B' then (d.symm ⟨x,hb⟩:ℂ) else x
+  have hfA (x : A) : f x=(e x:ℂ) := by simp only [f,dite_eq_left x.property]
+  have hfB (x : B) : f x=(d x:ℂ) := by
+    dsimp [f]
+    by_cases ha : (x:ℂ) ∈ A
+    · rw [dite_eq_left ha]
+      exact he ⟨x,ha⟩ x.property
+    · rw [dite_eq_right ha,dite_eq_left x.property]
+  have hgA (x : A') : g x=(e.symm x:ℂ) := by simp only [g,dite_eq_left x.property]
+  have hgB (x : B') : g x=(d.symm x:ℂ) := by
+    dsimp [g]
+    by_cases ha : (x:ℂ) ∈ A'
+    · rw [dite_eq_left ha]
+      exact hi ⟨x,ha⟩ x.property
+    · rw [dite_eq_right ha,dite_eq_left x.property]
+  have hfAc : ContinuousOn f A := by
+    rw [continuousOn_iff_continuous_domRestrict]
+    exact (continuous_subtype_val.comp e.continuous).congr (fun x => (hfA x).symm)
+  have hfBc : ContinuousOn f B := by
+    rw [continuousOn_iff_continuous_domRestrict]
+    exact (continuous_subtype_val.comp d.continuous).congr (fun x => (hfB x).symm)
+  have hgAc : ContinuousOn g A' := by
+    rw [continuousOn_iff_continuous_domRestrict]
+    exact (continuous_subtype_val.comp e.symm.continuous).congr (fun x => (hgA x).symm)
+  have hgBc : ContinuousOn g B' := by
+    rw [continuousOn_iff_continuous_domRestrict]
+    exact (continuous_subtype_val.comp d.symm.continuous).congr (fun x => (hgB x).symm)
+  have hfm : MapsTo f (A ∪ B) (A' ∪ B') := by
+    intro x hx
+    rcases hx with hx|hx
+    · rw [hfA ⟨x,hx⟩]; exact Or.inl (e ⟨x,hx⟩).property
+    · rw [hfB ⟨x,hx⟩]; exact Or.inr (d ⟨x,hx⟩).property
+  have hgm : MapsTo g (A' ∪ B') (A ∪ B) := by
+    intro x hx
+    rcases hx with hx|hx
+    · rw [hgA ⟨x,hx⟩]; exact Or.inl (e.symm ⟨x,hx⟩).property
+    · rw [hgB ⟨x,hx⟩]; exact Or.inr (d.symm ⟨x,hx⟩).property
+  have hgf (x : ℂ) (hx : x ∈ A ∪ B) : g (f x)=x := by
+    rcases hx with hx|hx
+    · rw [hfA ⟨x,hx⟩,hgA (e ⟨x,hx⟩)]
+      exact congrArg Subtype.val (e.symm_apply_apply ⟨x,hx⟩)
+    · rw [hfB ⟨x,hx⟩,hgB (d ⟨x,hx⟩)]
+      exact congrArg Subtype.val (d.symm_apply_apply ⟨x,hx⟩)
+  have hfg (x : ℂ) (hx : x ∈ A' ∪ B') : f (g x)=x := by
+    rcases hx with hx|hx
+    · rw [hgA ⟨x,hx⟩,hfA (e.symm ⟨x,hx⟩)]
+      exact congrArg Subtype.val (e.apply_symm_apply ⟨x,hx⟩)
+    · rw [hgB ⟨x,hx⟩,hfB (d.symm ⟨x,hx⟩)]
+      exact congrArg Subtype.val (d.apply_symm_apply ⟨x,hx⟩)
+  exact
+    { toFun := fun x => ⟨f x,hfm x.property⟩
+      invFun := fun x => ⟨g x,hgm x.property⟩
+      left_inv := fun x => Subtype.ext (hgf x x.property)
+      right_inv := fun x => Subtype.ext (hfg x x.property)
+      continuous_toFun := ((hfAc.union_of_isClosed hfBc hA hB).comp_continuous
+        continuous_subtype_val (fun x => x.property)).subtype_mk _
+      continuous_invFun := ((hgAc.union_of_isClosed hgBc hA' hB').comp_continuous
+        continuous_subtype_val (fun x => x.property)).subtype_mk _ }
+
+end SLEExactGauge
+
+end
+
+end OAI
diff --git a/lean/OAI/Probability/SLE/Geometry/ClosedComplexUnion.lean b/lean/OAI/Probability/SLE/Geometry/ClosedComplexUnion.lean
new file mode 100644
index 0000000000000000000000000000000000000000..53ee338102cffad0900dd0938f08fe8aa47aa94f
--- /dev/null
+++ b/lean/OAI/Probability/SLE/Geometry/ClosedComplexUnion.lean
@@ -0,0 +1,97 @@
+import OAI.Probability.SLE.Geometry.ComplexJordanExtension
+
+namespace OAI
+
+/-! Glue a homeomorphism on one closed piece to the identity on a second
+closed piece, retaining the prescribed values on their intersection. -/
+noncomputable section
+open Set
+
+namespace SLEExactGauge
+
+def closedComplexUnionHomeomorph {A A' B : Set ℂ}
+    (hA : IsClosed A) (hA' : IsClosed A') (hB : IsClosed B)
+    (e : A ≃ₜ A')
+    (he : ∀ x : A, (x : ℂ) ∈ B → (e x : ℂ)=x)
+    (hi : ∀ x : A', (x : ℂ) ∈ B → (e.symm x : ℂ)=x) :
+    ↥(A ∪ B) ≃ₜ ↥(A' ∪ B) := by
+  classical
+  let f (x : ℂ) := if hx : x ∈ A then (e ⟨x,hx⟩ : ℂ) else x
+  let g (x : ℂ) := if hx : x ∈ A' then (e.symm ⟨x,hx⟩ : ℂ) else x
+  have hfA : ContinuousOn f A := by
+    rw [continuousOn_iff_continuous_domRestrict]
+    convert continuous_subtype_val.comp e.continuous using 1
+    funext x
+    exact dite_eq_left x.property
+  have hgA : ContinuousOn g A' := by
+    rw [continuousOn_iff_continuous_domRestrict]
+    convert continuous_subtype_val.comp e.symm.continuous using 1
+    funext x
+    exact dite_eq_left x.property
+  have hfB : ContinuousOn f B := by
+    apply continuousOn_id.congr
+    intro x hx
+    dsimp [f]
+    split_ifs with ha
+    · exact he ⟨x,ha⟩ hx
+    · rfl
+  have hgB : ContinuousOn g B := by
+    apply continuousOn_id.congr
+    intro x hx
+    dsimp [g]
+    split_ifs with ha
+    · exact hi ⟨x,ha⟩ hx
+    · rfl
+  have hf : ContinuousOn f (A ∪ B) := hfA.union_of_isClosed hfB hA hB
+  have hg : ContinuousOn g (A' ∪ B) := hgA.union_of_isClosed hgB hA' hB
+  have hfm : MapsTo f (A ∪ B) (A' ∪ B) := by
+    intro x hx
+    dsimp [f]
+    split_ifs with ha
+    · exact Or.inl (e ⟨x,ha⟩).property
+    · exact Or.inr (hx.resolve_left ha)
+  have hgm : MapsTo g (A' ∪ B) (A ∪ B) := by
+    intro x hx
+    dsimp [g]
+    split_ifs with ha
+    · exact Or.inl (e.symm ⟨x,ha⟩).property
+    · exact Or.inr (hx.resolve_left ha)
+  have hgf (x : ℂ) (hx : x ∈ A ∪ B) : g (f x)=x := by
+    by_cases ha : x ∈ A
+    · have hfa : f x=(e ⟨x,ha⟩ : ℂ) := dite_eq_left ha
+      rw [hfa]
+      dsimp [g]
+      rw [dite_eq_left (e ⟨x,ha⟩).property]
+      exact congrArg Subtype.val (e.symm_apply_apply ⟨x,ha⟩)
+    · rw [show f x=x from dite_eq_right ha]
+      dsimp [g]
+      split_ifs with ha'
+      · exact hi ⟨x,ha'⟩ (hx.resolve_left ha)
+      · rfl
+  have hfg (x : ℂ) (hx : x ∈ A' ∪ B) : f (g x)=x := by
+    by_cases ha : x ∈ A'
+    · have hga : g x=(e.symm ⟨x,ha⟩ : ℂ) := dite_eq_left ha
+      rw [hga]
+      dsimp [f]
+      rw [dite_eq_left (e.symm ⟨x,ha⟩).property]
+      exact congrArg Subtype.val (e.apply_symm_apply ⟨x,ha⟩)
+    · rw [show g x=x from dite_eq_right ha]
+      dsimp [f]
+      split_ifs with ha'
+      · exact he ⟨x,ha'⟩ (hx.resolve_left ha)
+      · rfl
+  exact
+    { toFun := fun x => ⟨f x,hfm x.property⟩
+      invFun := fun x => ⟨g x,hgm x.property⟩
+      left_inv := fun x => Subtype.ext (hgf x x.property)
+      right_inv := fun x => Subtype.ext (hfg x x.property)
+      continuous_toFun := (hf.comp_continuous continuous_subtype_val
+        (fun x => x.property)).subtype_mk _
+      continuous_invFun := (hg.comp_continuous continuous_subtype_val
+        (fun x => x.property)).subtype_mk _ }
+
+end SLEExactGauge
+
+end
+
+end OAI
diff --git a/lean/OAI/Probability/SLE/Geometry/ClosedHalfPlaneCayley.lean b/lean/OAI/Probability/SLE/Geometry/ClosedHalfPlaneCayley.lean
new file mode 100644
index 0000000000000000000000000000000000000000..f04a94c52a0e3c2fac3a1134638a7687d5d09cf6
--- /dev/null
+++ b/lean/OAI/Probability/SLE/Geometry/ClosedHalfPlaneCayley.lean
@@ -0,0 +1,28 @@
+import OAI.Probability.SLE.Geometry.HalfPlaneCayleyInverse
+
+namespace OAI
+
+/-! The fixed Cayley chart as a homeomorphism of the closed half-plane
+onto the closed disk with the point at infinity removed. -/
+noncomputable section
+open Set Complex
+
+namespace SLEExactGauge
+
+def closedHalfPlaneCayley :
+    {z : ℂ // 0 ≤ z.im} ≃ₜ {w : ℂ // ‖w‖ ≤ 1 ∧ w ≠ 1} where
+  toFun z := ⟨halfPlaneCayley z,halfPlaneCayley_norm_le z.property,
+    halfPlaneCayley_ne_one z.property⟩
+  invFun w := ⟨halfPlaneCayleyInv w,halfPlaneCayleyInv_closed w.property.1⟩
+  left_inv z := Subtype.ext (halfPlaneCayleyInv_cayley z.property)
+  right_inv w := Subtype.ext (halfPlaneCayley_cayleyInv w.property.2)
+  continuous_toFun := (halfPlaneCayley_continuousOn.comp_continuous continuous_subtype_val
+    (fun z => z.property)).subtype_mk _
+  continuous_invFun := (halfPlaneCayleyInv_continuousOn.comp_continuous continuous_subtype_val
+    (fun w => w.property.2)).subtype_mk _
+
+end SLEExactGauge
+
+end
+
+end OAI
diff --git a/lean/OAI/Probability/SLE/Geometry/ClosedHalfPlaneExtension.lean b/lean/OAI/Probability/SLE/Geometry/ClosedHalfPlaneExtension.lean
new file mode 100644
index 0000000000000000000000000000000000000000..c9919c916b82b74e92e64f530ab3cf5cf06cff40
--- /dev/null
+++ b/lean/OAI/Probability/SLE/Geometry/ClosedHalfPlaneExtension.lean
@@ -0,0 +1,60 @@
+import OAI.Probability.SLE.Geometry.ClosedComplexUnion
+
+namespace OAI
+
+/-! Extend a closed half-plane homeomorphism fixing its boundary by the
+identity on the other half-plane. -/
+noncomputable section
+open Set Complex
+
+namespace SLEExactGauge
+
+theorem closedHalfPlane_extension
+    (e : {z : ℂ // 0 ≤ z.im} ≃ₜ {z : ℂ // 0 ≤ z.im})
+    (he : ∀ (z : {z : ℂ // 0 ≤ z.im}), z.val.im=0 → (e z:ℂ)=z) :
+    ∃ F : ℂ ≃ₜ ℂ,
+      (∀ (z : ℂ) (hz : 0 ≤ z.im), F z=(e ⟨z,hz⟩:ℂ)) ∧
+      (∀ x : ℝ, F (x:ℂ)=(x:ℂ)) ∧
+      MapsTo F {z : ℂ | 0 < z.im} {z : ℂ | 0 < z.im} := by
+  classical
+  let A : Set ℂ := {z | 0 ≤ z.im}
+  let B : Set ℂ := {z | z.im ≤ 0}
+  have hA : IsClosed A := isClosed_le continuous_const Complex.continuous_im
+  have hB : IsClosed B := isClosed_le Complex.continuous_im continuous_const
+  have hfix (z : A) (hz : (z:ℂ) ∈ B) : (e z:ℂ)=z :=
+    he z (le_antisymm hz z.property)
+  have hfixi (z : A) (hz : (z:ℂ) ∈ B) : (e.symm z:ℂ)=z := by
+    have hh : e z=z := Subtype.ext (hfix z hz)
+    have hh' := congrArg e.symm hh
+    rw [e.symm_apply_apply] at hh'
+    exact congrArg Subtype.val hh'.symm
+  let E := closedComplexUnionHomeomorph hA hA hB e hfix hfixi
+  have hU : A ∪ B=univ := by
+    ext z
+    exact iff_true_intro (le_total 0 z.im)
+  let j : ℂ ≃ₜ ↥(A ∪ B) := (Homeomorph.Set.univ ℂ).symm.trans
+    (Homeomorph.setCongr hU.symm)
+  let F : ℂ ≃ₜ ℂ := (j.trans E).trans j.symm
+  have hF (z : ℂ) (hz : 0 ≤ z.im) : F z=(e ⟨z,hz⟩:ℂ) := by
+    change (if hx : z ∈ A then (e ⟨z,hx⟩:ℂ) else z)=_
+    rw [dite_eq_left (show z ∈ A from hz)]
+  have hFr (x : ℝ) : F (x:ℂ)=(x:ℂ) := by
+    rw [hF _ (by simp)]
+    exact he _ (by simp)
+  refine ⟨F,hF,hFr,?_⟩
+  intro z hz
+  have hn : 0 ≤ (F z).im := by
+    rw [hF z hz.le]
+    exact (e ⟨z,hz.le⟩).property
+  apply lt_of_le_of_ne hn
+  intro hzero
+  have hx : F z=((F z).re:ℂ) := Complex.ext rfl (by simpa using hzero.symm)
+  have hsame : z=((F z).re:ℂ) := F.injective (hx.trans (hFr _).symm)
+  have hz0 := congrArg Complex.im hsame
+  simpa only [Complex.ofReal_im] using hz.ne' hz0
+
+end SLEExactGauge
+
+end
+
+end OAI
diff --git a/lean/OAI/Probability/SLE/Geometry/CoefficientAngularBound.lean b/lean/OAI/Probability/SLE/Geometry/CoefficientAngularBound.lean
new file mode 100644
index 0000000000000000000000000000000000000000..8fe19777f5c31c61d712961b281d436771176484
--- /dev/null
+++ b/lean/OAI/Probability/SLE/Geometry/CoefficientAngularBound.lean
@@ -0,0 +1,70 @@
+import OAI.Probability.SLE.Geometry.CanonicalCoefficientIntegrability
+
+namespace OAI
+
+/-! One integrable angular majorant for every clipping and center level
+in the exact Wiener coefficient formula. -/
+
+noncomputable section
+open Set Filter _root_.MeasureTheory _root_.OAI.MeasureTheory ProbabilityTheory
+open scoped NNReal ENNReal Topology
+
+namespace SLEExactGauge.Multipoint.CanonicalMass
+
+variable {Ω : Type*} [MeasurableSpace Ω] {P : Measure Ω} [IsProbabilityMeasure P] {κ : ℝ}
+  {B : ℝ≥0 → Ω → ℝ} {hBm : Measurable (Function.uncurry B)}
+  {γ : Ω → ℝ≥0 → ℂ} {G : Ω → ℝ≥0 → ℂ → ℂ}
+  (C : CanonicalMass P κ B hBm γ G)
+
+include C in
+theorem uniform_clippedCoefficient_bound
+    (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 ω))
+    (hgrowth : PublishedDiskUnivalentGrowth) (W : Target.WienerLaw) (hW : Target.IsWiener W) (m : ℕ) :
+    ∃ M : ℝ, 0≤M ∧ ∀ θ∈Ioo (0:ℝ) Real.pi, ∀ ℓ : ℝ, 0≤ℓ → ∀ u : ℝ, 0≤u →
+      0≤Target.clippedCoefficient κ W ℓ u m θ ∧
+        Target.clippedCoefficient κ W ℓ u m θ≤M/(Real.sin θ)^greenExponent κ := by
+  obtain ⟨M,hM,hbound⟩ := C.uniform_density_disk_terminal_moments hB hc h0 hκ hκ8 F hw hgrowth m
+  refine ⟨M.toReal,ENNReal.toReal_nonneg,?_⟩
+  intro θ hθ ℓ hℓ u hu
+  let T := fun ω => Target.levelTime κ θ (Target.normalizedDriver κ B hc h0 ω) ℓ
+  let Y := fun ω => massAtExtendedTime (fun t => C.normalizedDiskScalar θ hθ t ω)
+    (C.diskTerminalScalar θ hθ ω) (T ω)
+  let w := fun ω => Target.levelDensity κ θ (Target.normalizedDriver κ B hc h0 ω) ℓ
+  have hT : Measurable T := normalized_levelTime_measurable (hBm:=hBm) hκ hc h0 F hw θ ℓ hℓ
+  have hY : Measurable Y := C.normalizedStoppedDisk_measurable θ hθ T hT
+  have hwM : Measurable w := (Target.measurable_fixedLevelDensity κ θ ℓ).comp
+    (Target.normalizedDriver_measurable κ B
+      (fun r => (hBm.comp (measurable_const.prodMk measurable_id) : Measurable (B r))) hc h0)
+  have hw0 (ω) : 0≤w ω := Target.levelDensity_nonneg_of_witness κ hκ _ _ ((hc ω).const_mul _)
+    (γ ω) (G ω) (F ω) (hw ω) (Target.normalizedDriver_matches κ hκ B hc h0 ω) θ hθ ℓ hℓ
+  have hd : ∀ᵐ ω ∂P, 0≤w ω ∧ 0≤Y ω ∧ Y ω≤C.diskTerminalScalar θ hθ ω := by
+    filter_upwards [C.normalizedStoppedDisk_le_terminal hκ θ hθ T] with ω hω
+    exact ⟨hw0 ω,C.normalizedStoppedDisk_nonneg θ hθ (T ω) ω,hω⟩
+  have hi := C.density_disk_terminal_integrable hB hc h0 hκ hκ8 F hw hgrowth m θ hθ ℓ hℓ
+  have hb := weighted_clip_integral_bound P Y (C.diskTerminalScalar θ hθ) w
+    hY.aestronglyMeasurable hwM.aestronglyMeasurable hd m hi u hu
+  rw [C.clippedCoefficient_eq_mass hB hκ hκ8 hc h0 F hw W hW θ hθ ℓ hℓ u hu m]
+  refine ⟨hb.1,hb.2.trans ?_⟩
+  have hs : 0<Real.sin θ := Real.sin_pos_of_pos_of_lt_pi hθ.1 hθ.2
+  have hI0 : 0≤(∫ ω, w ω*(C.diskTerminalScalar θ hθ ω)^m ∂P) := integral_nonneg
+    (fun ω => mul_nonneg (hw0 ω) (pow_nonneg (compactWeightedMass_nonneg _ _ _) m))
+  have hEn : ENNReal.ofReal (∫ ω, w ω*(C.diskTerminalScalar θ hθ ω)^m ∂P) ≤
+      M*ENNReal.ofReal (1/(Real.sin θ)^greenExponent κ) := by
+    rw [ofReal_integral_eq_lintegral_ofReal hi]
+    · exact hbound θ hθ ℓ hℓ
+    · exact Eventually.of_forall (fun ω => mul_nonneg (hw0 ω)
+        (pow_nonneg (compactWeightedMass_nonneg _ _ _) m))
+  have ht := ENNReal.toReal_mono
+    (ne_top_of_lt (ENNReal.mul_lt_top hM ENNReal.ofReal_lt_top)) hEn
+  rw [ENNReal.toReal_ofReal hI0,ENNReal.toReal_mul,ENNReal.toReal_ofReal
+    (one_div_nonneg.mpr (Real.rpow_nonneg hs.le _))] at ht
+  simpa only [div_eq_mul_inv,mul_one,one_mul] using ht
+
+end SLEExactGauge.Multipoint.CanonicalMass
+
+end
+
+end OAI
diff --git a/lean/OAI/Probability/SLE/Geometry/CompactCellTail.lean b/lean/OAI/Probability/SLE/Geometry/CompactCellTail.lean
new file mode 100644
index 0000000000000000000000000000000000000000..5e7858aefc34afc4d9783731d2c83075c93d5c66
--- /dev/null
+++ b/lean/OAI/Probability/SLE/Geometry/CompactCellTail.lean
@@ -0,0 +1,77 @@
+import OAI.Probability.SLE.Gauge.PrescribedCellNormalization
+import OAI.Probability.SLE.Mass.CompactEntryLevels
+import OAI.Probability.SLE.Gauge.CanonicalLateGridLower
+
+namespace OAI
+
+/-! The actual finite centered cell bounds, integrated over a compact
+spatial cell, supply the late-grid hypothesis for the prescribed gauge. -/
+noncomputable section
+open Set Filter _root_.MeasureTheory _root_.OAI.MeasureTheory ProbabilityTheory Metric
+open scoped Topology NNReal ENNReal
+
+namespace SLEExactGauge.Multipoint
+local instance compactCellTailMeasurable : MeasurableSpace C(ℝ≥0,ℝ) := borel _
+local instance compactCellTailBorel : BorelSpace C(ℝ≥0,ℝ) := ⟨rfl⟩
+
+theorem CanonicalMass.compact_cell_tail_of_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) (e : Target.GaugeIndex κ W)
+    (δ : ℝ) (hδ : 0<δ)
+    (hangle : ∀ v : ℝ, δ≤v → ∀ f : ℝ → ℝ≥0∞, Measurable f →
+      ∀ θ∈Ioo (0:ℝ) Real.pi, canonicalAngleAverage (P.map (sourceDriverPath B hc)) κ v f θ ≤
+        2*(∫⁻ φ, f φ ∂Target.angleLaw κ))
+    (K : Set upperHalfPlane) (hK : IsCompact K) (c : ℂ)
+    (hKball : (Subtype.val : upperHalfPlane → ℂ) '' K ⊆
+      closedBall c (2*Target.radii κ W e))
+    (V : ℝ)
+    (hbase : ∀ z∈K, δ≤Target.entryPhysicalLevel κ W e.val (4096*Real.pi) z)
+    (hV : ∀ z∈K, Target.entryPhysicalLevel κ W e.val (4096*Real.pi) z<V)
+    (J : Finset ℝ≥0) :
+    C.compactFinitePastTest K
+      ((16*(65536*Real.pi)^dimension κ)*Target.weights κ W e*(Target.radii κ W e)^Target.d κ)
+      J V ≤ (2*C.limitingDiskTail hc (16*Target.weights κ W e))*initialGreenMeasure κ K := by
+  let L : Set ℂ := (Subtype.val : upperHalfPlane → ℂ) '' K
+  have hL : MeasurableSet L := (hK.image continuous_subtype_val).measurableSet
+  have hpre : Subtype.val ⁻¹' L = K := Subtype.val_injective.preimage_image K
+  have ht : C.limitingDiskTail hc (16*Target.weights κ W e) ≠ ∞ :=
+    ne_top_of_le_ne_top (by norm_num) (C.limitingDiskTail_le_one hB hc hκ hκ8 F hw _)
+  rw [initialGreenMeasure,comap_subtype_coe_apply isOpen_upperHalfPlane.measurableSet,
+    withDensity_apply _ hL,← lintegral_const_mul' _ _ (ENNReal.mul_ne_top (by norm_num) ht)]
+  apply setLIntegral_mono' hL
+  rintro x ⟨z,hz,rfl⟩
+  let u := Target.entryPhysicalLevel κ W e.val (4096*Real.pi) (z:ℂ)
+  have hu : 0<u := hδ.trans_le (hbase z hz)
+  have hv : 0<V-u := sub_pos.mpr (hV z hz)
+  have hr := Target.radii_pos κ W e
+  have hball : L⊆closedBall (z:ℂ) (2*(2*Target.radii κ W e)) :=
+    cell_subset_ball_at_member hKball ⟨z,hz,rfl⟩
+  have hh := C.centered_strict_past_cell_tail_of_angle_bound hB hc h0 hκ hκ8 F hw
+    R he D hD hDf hDp hgrowth hpublished (z:ℂ) z.property u (V-u)
+    (2*Target.radii κ W e) (16*Target.weights κ W e) hu hv (by positivity)
+    (prescribed_lower_radius κ W e.val z.property) L hL hball
+    (hangle u (hbase z hz) _ (R.angleDiskTail_measurable _ _ _ _)) J
+  rw [show u+(V-u)=V by ring,hpre,
+    prescribed_lower_threshold κ (Target.radii κ W e) (Target.weights κ W e) hr] at hh
+  exact (mul_le_mul' le_rfl hh).trans_eq (mul_comm _ _)
+
+end SLEExactGauge.Multipoint
+
+end
+
+end OAI
diff --git a/lean/OAI/Probability/SLE/Geometry/CompactConnectedNeighborhoods.lean b/lean/OAI/Probability/SLE/Geometry/CompactConnectedNeighborhoods.lean
new file mode 100644
index 0000000000000000000000000000000000000000..c9a3ec5780b1cd4729f3d851b09a7bd453603571
--- /dev/null
+++ b/lean/OAI/Probability/SLE/Geometry/CompactConnectedNeighborhoods.lean
@@ -0,0 +1,63 @@
+import OAI.Probability.SLE.Geometry.FiniteTraceTopology
+
+namespace OAI
+
+/-! Uniform small connected neighborhoods on compact locally connected
+ metric spaces, specialized below to finite trace segments. -/
+noncomputable section
+open Set Filter Metric Function
+open scoped Topology NNReal
+
+namespace SLEExactGauge
+
+lemma compact_locallyConnected_uniform_connection {A : Type*} [MetricSpace A]
+    [CompactSpace A] [LocallyConnectedSpace A] (ε : ℝ) (hε : 0<ε) :
+    ∃ δ : ℝ, 0<δ ∧ ∀ x y : A, dist x y<δ →
+      ∃ V : Set A, IsPreconnected V ∧ x∈V ∧ y∈V ∧
+        ∀ u∈V, ∀ v∈V, dist u v<ε := by
+  classical
+  have hlocal (a : A) : ∃ V : Set A, V∈𝓝 a ∧ IsPreconnected V ∧
+      V⊆ball a (ε/2) :=
+    (locallyConnectedSpace_iff_connected_subsets.mp inferInstance) a _
+      (ball_mem_nhds a (half_pos hε))
+  choose V hV hc hs using hlocal
+  obtain ⟨δ,hδ,hcover⟩ := Metric.uniformity_basis_dist.lebesgue_number_lemma_nhds
+    (K := (univ : Set A)) isCompact_univ (fun a _ => hV a)
+  refine ⟨δ,hδ,fun x y hxy => ?_⟩
+  obtain ⟨a,ha⟩ := hcover x (mem_univ x)
+  have hsub : ball x δ⊆V a := by
+    intro z hz
+    apply ha
+    change dist x z<δ
+    simpa only [mem_ball,dist_comm] using hz
+  refine ⟨V a,hc a,hsub (mem_ball_self hδ),hsub (by simpa only [mem_ball,dist_comm] using hxy),?_⟩
+  intro u hu v hv
+  have hu' := mem_ball.mp (hs a hu)
+  have hv' := mem_ball.mp (hs a hv)
+  have := dist_triangle u a v
+  rw [dist_comm a v] at this
+  linarith
+
+lemma finiteTrace_uniform_connection {γ : ℝ≥0 → ℂ} (hγ : Continuous γ)
+    (T : ℝ≥0) (ε : ℝ) (hε : 0<ε) :
+    ∃ δ : ℝ, 0<δ ∧ ∀ x∈γ '' Icc 0 T, ∀ y∈γ '' Icc 0 T, dist x y<δ →
+      ∃ C : Set ℂ, C⊆γ '' Icc 0 T ∧ IsPreconnected C ∧ x∈C ∧ y∈C ∧
+        ∀ u∈C, ∀ v∈C, dist u v<ε := by
+  have : CompactSpace (γ '' Icc 0 T) := isCompact_iff_compactSpace.mp (finiteTrace_isCompact hγ T)
+  have : LocallyConnectedSpace (γ '' Icc 0 T) := finiteTrace_locallyConnected hγ T
+  obtain ⟨δ,hδ,hconn⟩ := compact_locallyConnected_uniform_connection
+    (A := γ '' Icc 0 T) ε hε
+  refine ⟨δ,hδ,fun x hx y hy hxy => ?_⟩
+  obtain ⟨V,hV,hxV,hyV,hd⟩ := hconn ⟨x,hx⟩ ⟨y,hy⟩ hxy
+  refine ⟨Subtype.val '' V,?_,hV.image _ continuous_subtype_val.continuousOn,
+    ⟨⟨x,hx⟩,hxV,rfl⟩,⟨⟨y,hy⟩,hyV,rfl⟩,?_⟩
+  · rintro _ ⟨z,_,rfl⟩
+    exact z.property
+  · rintro _ ⟨u,hu,rfl⟩ _ ⟨v,hv,rfl⟩
+    exact hd u hu v hv
+
+end SLEExactGauge
+
+end
+
+end OAI
diff --git a/lean/OAI/Probability/SLE/Geometry/CompactDerivativeIntegral.lean b/lean/OAI/Probability/SLE/Geometry/CompactDerivativeIntegral.lean
new file mode 100644
index 0000000000000000000000000000000000000000..6a3a5e8b54aeff4b7ff591e3955eaae24882f15c
--- /dev/null
+++ b/lean/OAI/Probability/SLE/Geometry/CompactDerivativeIntegral.lean
@@ -0,0 +1,57 @@
+import Mathlib
+
+namespace OAI
+
+/-! Compactly supported derivative integrals used in the exterior
+area calculation. -/
+noncomputable section
+open Set Filter Metric Function MeasureTheory
+open scoped Topology
+
+namespace SLEExactGauge
+
+lemma integral_deriv_compact_eq_zero {f : ℝ → ℝ}
+    (hf : ContDiff ℝ 1 f) (hs : HasCompactSupport f) : ∫ x, deriv f x=0 := by
+  have hi : Integrable (deriv f) := (hf.continuous_deriv le_rfl).integrable_of_hasCompactSupport hs.deriv
+  rw [←integral_add_compl measurableSet_Iic hi,compl_Iic,
+    hs.integral_Iic_deriv_eq hf 0,hs.integral_Ioi_deriv_eq hf 0]
+  ring
+
+lemma integral_complex_real_partial_eq_zero {f : ℂ → ℝ}
+    (hf : ContDiff ℝ 1 f) (hs : HasCompactSupport f) :
+    ∫ z, fderiv ℝ f z 1=0 := by
+  let D (z : ℂ) := fderiv ℝ f z 1
+  have hD : Continuous D := (hf.continuous_fderiv (by norm_num)).clm_apply continuous_const
+  have hDi : Integrable D := hD.integrable_of_hasCompactSupport (hs.fderiv_apply ℝ 1)
+  have hline (y : ℝ) : ∫ x : ℝ, D ((x:ℂ)+(y:ℂ)*Complex.I)=0 := by
+    let L (x : ℝ) := (x:ℂ)+(y:ℂ)*Complex.I
+    have hLc : ContDiff ℝ 1 L := Complex.ofRealCLM.contDiff.add contDiff_const
+    have hLi : Isometry L := by
+      apply isometry_iff_dist_eq.mpr
+      intro x x'
+      simpa only [L,dist_add_right] using Complex.isometry_ofReal.dist_eq x x'
+    have hcs : HasCompactSupport (f ∘ L) := hs.comp_isClosedEmbedding hLi.isClosedEmbedding
+    have he (x : ℝ) : deriv (f ∘ L) x=D (L x) := by
+      have hd := (hf.differentiable (by norm_num) (L x)).hasFDerivAt.comp_hasDerivAt x
+        ((Complex.ofRealCLM.hasDerivAt (x := x)).add_const ((y:ℂ)*Complex.I))
+      simpa only [Complex.ofRealCLM_apply,Complex.ofReal_one] using hd.deriv
+    simpa only [he] using integral_deriv_compact_eq_zero (hf.comp hLc) hcs
+  let e := Complex.measurableEquivRealProd.symm
+  have hp := Complex.volume_preserving_equiv_real_prod.symm
+  have hprod : Integrable (fun p : ℝ × ℝ => D (e p)) :=
+    (hp.integrable_comp_emb e.measurableEmbedding).mpr hDi
+  rw [←hp.integral_comp e.measurableEmbedding]
+  change (∫ p : ℝ × ℝ, D (e p))=0
+  rw [Measure.volume_eq_prod] at hprod ⊢
+  rw [integral_prod_symm _ hprod]
+  have he (y : ℝ) : (∫ x : ℝ, D (e (x,y)))=0 := by
+    have heq (x y : ℝ) : e (x,y)=(x:ℂ)+(y:ℂ)*Complex.I := by
+      apply Complex.ext <;> simp [e,Complex.measurableEquivRealProd_symm_apply]
+    simpa only [heq] using hline y
+  simp only [he,integral_zero]
+
+end SLEExactGauge
+
+end
+
+end OAI
diff --git a/lean/OAI/Probability/SLE/Geometry/CompactLaplacianIntegral.lean b/lean/OAI/Probability/SLE/Geometry/CompactLaplacianIntegral.lean
new file mode 100644
index 0000000000000000000000000000000000000000..07e44dc949cee7de17b978b1adc12822daa5d87b
--- /dev/null
+++ b/lean/OAI/Probability/SLE/Geometry/CompactLaplacianIntegral.lean
@@ -0,0 +1,82 @@
+import OAI.Probability.SLE.Geometry.CompactDerivativeIntegral
+import Mathlib.Analysis.InnerProductSpace.Laplacian
+
+namespace OAI
+
+/-! A compactly supported smooth planar test has zero total Laplacian.
+This lets its integral over a conformal image be evaluated on the
+compact omitted set instead. -/
+noncomputable section
+open Set Filter Metric Function MeasureTheory InnerProductSpace
+open scoped Topology Laplacian
+
+namespace SLEExactGauge
+
+lemma integral_complex_imag_partial_eq_zero {f : ℂ → ℝ}
+    (hf : ContDiff ℝ 1 f) (hs : HasCompactSupport f) :
+    ∫ z, fderiv ℝ f z Complex.I=0 := by
+  let D (z : ℂ) := fderiv ℝ f z Complex.I
+  have hD : Continuous D := (hf.continuous_fderiv (by norm_num)).clm_apply continuous_const
+  have hDi : Integrable D := hD.integrable_of_hasCompactSupport (hs.fderiv_apply ℝ Complex.I)
+  have hline (x : ℝ) : ∫ y : ℝ, D ((x:ℂ)+(y:ℂ)*Complex.I)=0 := by
+    let L (y : ℝ) := (x:ℂ)+(y:ℂ)*Complex.I
+    have hLc : ContDiff ℝ 1 L := contDiff_const.add (Complex.ofRealCLM.contDiff.mul contDiff_const)
+    have hLi : Isometry L := by
+      apply isometry_iff_dist_eq.mpr
+      intro y y'
+      rw [dist_eq_norm,show L y-L y'=((y-y':ℝ):ℂ)*Complex.I by dsimp [L]; push_cast; ring]
+      simp only [norm_mul,Complex.norm_I,mul_one,Complex.norm_real,dist_eq_norm]
+    have hcs : HasCompactSupport (f ∘ L) := hs.comp_isClosedEmbedding hLi.isClosedEmbedding
+    have he (y : ℝ) : deriv (f ∘ L) y=D (L y) := by
+      have hd := (hf.differentiable (by norm_num) (L y)).hasFDerivAt.comp_hasDerivAt y
+        (((Complex.ofRealCLM.hasDerivAt (x := y)).mul_const Complex.I).const_add (x:ℂ))
+      simpa only [Complex.ofRealCLM_apply,Complex.ofReal_one,one_mul] using hd.deriv
+    simpa only [he] using integral_deriv_compact_eq_zero (hf.comp hLc) hcs
+  let e := Complex.measurableEquivRealProd.symm
+  have hp := Complex.volume_preserving_equiv_real_prod.symm
+  have hprod : Integrable (fun p : ℝ × ℝ => D (e p)) :=
+    (hp.integrable_comp_emb e.measurableEmbedding).mpr hDi
+  rw [←hp.integral_comp e.measurableEmbedding]
+  change (∫ p : ℝ × ℝ, D (e p))=0
+  rw [Measure.volume_eq_prod] at hprod ⊢
+  rw [integral_prod _ hprod]
+  have he (x : ℝ) : (∫ y : ℝ, D (e (x,y)))=0 := by
+    have heq (x y : ℝ) : e (x,y)=(x:ℂ)+(y:ℂ)*Complex.I := by
+      apply Complex.ext <;> simp [e,Complex.measurableEquivRealProd_symm_apply]
+    simpa only [heq] using hline x
+  simp only [he,integral_zero]
+
+lemma integral_laplacian_compact_eq_zero {f : ℂ → ℝ}
+    (hf : ContDiff ℝ 2 f) (hs : HasCompactSupport f) : ∫ z, (Δ f) z=0 := by
+  let A (z : ℂ) := fderiv ℝ f z 1
+  let B (z : ℂ) := fderiv ℝ f z Complex.I
+  have hDf : ContDiff ℝ 1 (fderiv ℝ f) := hf.fderiv_right (by norm_num)
+  have hA : ContDiff ℝ 1 A := hDf.clm_apply contDiff_const
+  have hB : ContDiff ℝ 1 B := hDf.clm_apply contDiff_const
+  have hsA : HasCompactSupport A := hs.fderiv_apply ℝ 1
+  have hsB : HasCompactSupport B := hs.fderiv_apply ℝ Complex.I
+  have hAA (z : ℂ) : fderiv ℝ A z 1=fderiv ℝ (fderiv ℝ f) z 1 1 := by
+    have h := (hDf.differentiable (by norm_num) z).hasFDerivAt.clm_apply
+      (hasFDerivAt_const (1:ℂ) z)
+    rw [h.fderiv]
+    simp
+  have hBB (z : ℂ) : fderiv ℝ B z Complex.I=fderiv ℝ (fderiv ℝ f) z Complex.I Complex.I := by
+    have h := (hDf.differentiable (by norm_num) z).hasFDerivAt.clm_apply
+      (hasFDerivAt_const Complex.I z)
+    rw [h.fderiv]
+    simp
+  have hpoint (z : ℂ) : (Δ f) z=fderiv ℝ A z 1+fderiv ℝ B z Complex.I := by
+    rw [hAA,hBB,laplacian_eq_iteratedFDeriv_complexPlane]
+    simp only [iteratedFDeriv_two_apply,Fin.isValue,Matrix.cons_val_zero,
+      Matrix.cons_val_one,Matrix.cons_val_fin_one]
+  simp_rw [hpoint]
+  rw [integral_add
+    (((hA.continuous_fderiv (by norm_num)).clm_apply continuous_const).integrable_of_hasCompactSupport (hsA.fderiv_apply ℝ 1))
+    (((hB.continuous_fderiv (by norm_num)).clm_apply continuous_const).integrable_of_hasCompactSupport (hsB.fderiv_apply ℝ Complex.I)),
+    integral_complex_real_partial_eq_zero hA hsA,integral_complex_imag_partial_eq_zero hB hsB,add_zero]
+
+end SLEExactGauge
+
+end
+
+end OAI
diff --git a/lean/OAI/Probability/SLE/Geometry/CompactPathNeighborhoods.lean b/lean/OAI/Probability/SLE/Geometry/CompactPathNeighborhoods.lean
new file mode 100644
index 0000000000000000000000000000000000000000..cf717503938fbfc306e3d3a860d8efd9a8a85016
--- /dev/null
+++ b/lean/OAI/Probability/SLE/Geometry/CompactPathNeighborhoods.lean
@@ -0,0 +1,78 @@
+import OAI.Probability.SLE.Geometry.CompactConnectedNeighborhoods
+import Mathlib.Topology.Connected.LocallyPathConnected
+
+namespace OAI
+
+/-! Compact trace sets admit small paths, including after adjoining a
+compact interval of the real boundary. -/
+noncomputable section
+open Set Filter Metric Function
+open scoped Topology NNReal
+
+namespace SLEExactGauge
+
+lemma finiteTrace_locallyPathConnected {γ : ℝ≥0 → ℂ} (hγ : Continuous γ) (T : ℝ≥0) :
+    LocallyPathConnectedSpace (γ '' Icc 0 T) := by
+  have : LocallyPathConnectedSpace (Icc (0:ℝ) (T:ℝ)) :=
+    (isQuotientMap_projIcc (a := (0:ℝ)) (b := (T:ℝ)) (h := T.coe_nonneg)).locallyPathConnectedSpace
+  let p : Icc (0:ℝ) (T:ℝ) → γ '' Icc 0 T := fun t =>
+    ⟨γ t.1.toNNReal,⟨t.1.toNNReal,⟨by simp,(Real.toNNReal_le_iff_le_coe).mpr t.2.2⟩,rfl⟩⟩
+  have hp : Continuous p := (hγ.comp (continuous_real_toNNReal.comp continuous_subtype_val)).subtype_mk _
+  have hs : Surjective p := by
+    rintro ⟨z,t,ht,rfl⟩
+    refine ⟨⟨t,⟨t.coe_nonneg,by exact_mod_cast ht.2⟩⟩,?_⟩
+    apply Subtype.ext
+    simp [p]
+  exact (hp.isClosedMap.isQuotientMap hp hs).locallyPathConnectedSpace
+
+lemma compact_union_locallyPathConnected {X : Type*} [TopologicalSpace X] [T2Space X]
+    {A B : Set X} (hA : IsCompact A) (hB : IsCompact B)
+    [LocallyPathConnectedSpace A] [LocallyPathConnectedSpace B] :
+    LocallyPathConnectedSpace ↥(A∪B) := by
+  have : CompactSpace A := isCompact_iff_compactSpace.mp hA
+  have : CompactSpace B := isCompact_iff_compactSpace.mp hB
+  let p : A⊕B → ↥(A∪B) := Sum.elim
+    (fun a => ⟨a.1,Or.inl a.2⟩) (fun b => ⟨b.1,Or.inr b.2⟩)
+  have hp : Continuous p := continuous_sum_dom.mpr
+    ⟨continuous_subtype_val.subtype_mk _,continuous_subtype_val.subtype_mk _⟩
+  have hs : Surjective p := by
+    rintro ⟨x,hx⟩
+    rcases hx with hx | hx
+    · exact ⟨Sum.inl ⟨x,hx⟩,rfl⟩
+    · exact ⟨Sum.inr ⟨x,hx⟩,rfl⟩
+  exact (hp.isClosedMap.isQuotientMap hp hs).locallyPathConnectedSpace
+
+lemma compact_locallyPathConnected_uniform_path {A : Type*} [MetricSpace A]
+    [CompactSpace A] [LocallyPathConnectedSpace A] (ε : ℝ) (hε : 0<ε) :
+    ∃ δ : ℝ, 0<δ ∧ ∀ x y : A, dist x y<δ →
+      ∃ p : Path x y, ∀ t, dist (p t) x<ε := by
+  classical
+  have hlocal (a : A) : ∃ V : Set A, V∈𝓝 a ∧ IsPathConnected V ∧ V⊆ball a (ε/2) := by
+    obtain ⟨V,⟨hV,hpc⟩,hsub⟩ := (path_connected_basis a).mem_iff.mp
+      (ball_mem_nhds a (half_pos hε))
+    exact ⟨V,hV,hpc,hsub⟩
+  choose V hV hc hs using hlocal
+  obtain ⟨δ,hδ,hcover⟩ := Metric.uniformity_basis_dist.lebesgue_number_lemma_nhds
+    (K := (univ : Set A)) isCompact_univ (fun a _ => hV a)
+  refine ⟨δ,hδ,fun x y hxy => ?_⟩
+  obtain ⟨a,ha⟩ := hcover x (mem_univ x)
+  have hsub : ball x δ⊆V a := by
+    intro z hz
+    apply ha
+    change dist x z<δ
+    simpa only [mem_ball,dist_comm] using hz
+  have hx := hsub (mem_ball_self hδ)
+  have hy := hsub (by simpa only [mem_ball,dist_comm] using hxy)
+  obtain ⟨p,hp⟩ := hc a |>.joinedIn x hx y hy
+  refine ⟨p,fun t => ?_⟩
+  have ht := mem_ball.mp (hs a (hp t))
+  have hx' := mem_ball.mp (hs a hx)
+  have htri := dist_triangle (p t) a x
+  rw [dist_comm a x] at htri
+  linarith
+
+end SLEExactGauge
+
+end
+
+end OAI
diff --git a/lean/OAI/Probability/SLE/Geometry/CompactPlanarGaussian.lean b/lean/OAI/Probability/SLE/Geometry/CompactPlanarGaussian.lean
new file mode 100644
index 0000000000000000000000000000000000000000..3621c3bd8602684b714b933fddf302a60e0d96b2
--- /dev/null
+++ b/lean/OAI/Probability/SLE/Geometry/CompactPlanarGaussian.lean
@@ -0,0 +1,94 @@
+import OAI.Probability.SLE.Stochastic.PlanarGaussianMean
+import OAI.Probability.SLE.ClippedCoordinates
+
+namespace OAI
+
+/-! Compact smooth planar tests have one uniform Gaussian-generator
+error constant. These are the tests needed for Brownian localization. -/
+noncomputable section
+open Set Filter MeasureTheory ProbabilityTheory
+open scoped Topology NNReal ENNReal
+
+namespace SLEExactGauge
+
+lemma compact_planar_test_bounds
+    (f : ℝ × ℝ → ℝ) (hf : ContDiff ℝ (⊤ : ℕ∞) f) (hc : HasCompactSupport f) :
+    ∃ K : ℝ≥0,
+      (∀ a b j, j ≤ 3 → |iteratedDeriv j (fun x => f (x,b)) a| ≤ K) ∧
+      (∀ a b j, j ≤ 3 → |iteratedDeriv j (fun y => f (a,y)) b| ≤ K) ∧
+      ∀ a, LipschitzWith K (fun b => iteratedDeriv 2 (fun x => f (x,b)) a) := by
+  let g : ℝ × ℝ → ℝ := f ∘ Prod.swap
+  have hg : ContDiff ℝ (⊤ : ℕ∞) g := hf.comp (contDiff_snd.prodMk contDiff_fst)
+  have hgc : HasCompactSupport g := hc.comp_homeomorph (Homeomorph.prodComm ℝ ℝ)
+  have hx (j : ℕ) := compact_smooth_bounded_lipschitz (spatialPartial g j)
+    (spatialPartial_smooth g hg j) (spatialPartial_compact g hgc j)
+  have hy (j : ℕ) := compact_smooth_bounded_lipschitz (spatialPartial f j)
+    (spatialPartial_smooth f hf j) (spatialPartial_compact f hc j)
+  choose C hCb hCl using hx
+  choose D hDb hDl using hy
+  let K : ℝ≥0 := ∑ j ∈ Finset.range 4, (C j+D j)
+  have hC (j : ℕ) (hj : j ≤ 3) : C j ≤ K := by
+    have hle : C j ≤ C j+D j := le_add_of_nonneg_right (show 0 ≤ D j from zero_le)
+    exact hle.trans (Finset.single_le_sum (s := Finset.range 4) (f := fun i => C i+D i)
+      (fun i _ => (show 0 ≤ C i+D i from zero_le))
+      (Finset.mem_range.mpr (by omega)))
+  have hD (j : ℕ) (hj : j ≤ 3) : D j ≤ K := by
+    have hle : D j ≤ C j+D j := le_add_of_nonneg_left (show 0 ≤ C j from zero_le)
+    exact hle.trans (Finset.single_le_sum (s := Finset.range 4) (f := fun i => C i+D i)
+      (fun i _ => (show 0 ≤ C i+D i from zero_le))
+      (Finset.mem_range.mpr (by omega)))
+  refine ⟨K,?_,?_,?_⟩
+  · intro a b j hj
+    have hh := (hCb j (b,a)).trans (show (C j:ℝ)≤K by exact_mod_cast hC j hj)
+    simpa only [spatialPartial_eq_iteratedDeriv g hg, g, Function.comp_apply,
+      Prod.swap_prod_mk, Real.norm_eq_abs] using hh
+  · intro a b j hj
+    have hh := (hDb j (a,b)).trans (show (D j:ℝ)≤K by exact_mod_cast hD j hj)
+    simpa only [spatialPartial_eq_iteratedDeriv f hf, Real.norm_eq_abs] using hh
+  · intro a
+    apply LipschitzWith.of_dist_le_mul
+    intro b c
+    have hh := ((hCl 2).weaken (hC 2 (by decide))).dist_le_mul (b,a) (c,a)
+    simpa only [spatialPartial_eq_iteratedDeriv g hg, g, Function.comp_apply,
+      Prod.swap_prod_mk, Prod.dist_eq,dist_self,max_eq_left dist_nonneg] using hh
+
+def planarGenerator (f : ℝ × ℝ → ℝ) (z : ℝ × ℝ) : ℝ :=
+  (1/2:ℝ)*(iteratedDeriv 2 (fun x => f (x,z.2)) z.1+
+    iteratedDeriv 2 (fun y => f (z.1,y)) z.2)
+
+lemma compact_planar_gaussian_generator
+    (f : ℝ × ℝ → ℝ) (hf : ContDiff ℝ (⊤ : ℕ∞) f) (hc : HasCompactSupport f) :
+    ∃ C : ℝ≥0, ∀ (δ : ℝ≥0) (z : ℝ × ℝ),
+      |planarGaussianMean δ f z.1 z.2-f z-(δ:ℝ)*planarGenerator f z| ≤
+        (C:ℝ)*(δ:ℝ)*Real.sqrt δ := by
+  obtain ⟨K,hx,hy,hxy⟩ := compact_planar_test_bounds f hf hc
+  let M := 2*standardGaussianAbsMoment 3+(1/2:ℝ)*standardGaussianAbsMoment 1
+  have hM : 0≤M := by
+    dsimp [M]
+    have h3 := standardGaussianAbsMoment_nonneg 3
+    have h1 := standardGaussianAbsMoment_nonneg 1
+    positivity
+  refine ⟨K*⟨M,hM⟩,?_⟩
+  intro δ z
+  have h1 (b : ℝ) : ContDiff ℝ 3 (fun a => f (a,b)) :=
+    (hf.comp (contDiff_id.prodMk contDiff_const)).of_le (by simp)
+  have h2 (a : ℝ) : ContDiff ℝ 3 (fun b => f (a,b)) :=
+    (hf.comp (contDiff_const.prodMk contDiff_id)).of_le (by simp)
+  have h := planar_gaussian_generator_error f hf.continuous K h1 h2 hx hy hxy δ z.1 z.2
+  calc
+    _ = |planarGaussianMean δ f z.1 z.2-f z-(1/2:ℝ)*(δ:ℝ)*
+        (iteratedDeriv 2 (fun x => f (x,z.2)) z.1+
+          iteratedDeriv 2 (fun y => f (z.1,y)) z.2)| := by
+      congr 1
+      dsimp [planarGenerator]
+      ring
+    _ ≤ (K:ℝ)*(δ:ℝ)*Real.sqrt δ*M := h
+    _ = _ := by
+      change (K:ℝ)*(δ:ℝ)*Real.sqrt δ*M=(K:ℝ)*M*(δ:ℝ)*Real.sqrt δ
+      ring
+
+end SLEExactGauge
+
+end
+
+end OAI
diff --git a/lean/OAI/Probability/SLE/Geometry/CompactSmoothExtension.lean b/lean/OAI/Probability/SLE/Geometry/CompactSmoothExtension.lean
new file mode 100644
index 0000000000000000000000000000000000000000..1de159fe6044f53005c7d153fecd10a88b1a205e
--- /dev/null
+++ b/lean/OAI/Probability/SLE/Geometry/CompactSmoothExtension.lean
@@ -0,0 +1,61 @@
+import Mathlib
+
+namespace OAI
+
+/-! A compactly supported smooth extension agreeing near a prescribed
+compact subset of an open set. Its pointwise bound preserves bounded
+harmonic tests during Brownian localization. -/
+noncomputable section
+open Set Filter Function
+open scoped Topology
+
+namespace SLEExactGauge
+
+lemma exists_compact_smooth_extension
+    {E : Type*} [NormedAddCommGroup E] [NormedSpace ℝ E] [FiniteDimensional ℝ E]
+    (U K : Set E) (hU : IsOpen U) (hK : IsCompact K) (hKU : K ⊆ U)
+    (u : E → ℝ) (hu : ContDiffOn ℝ (⊤ : ℕ∞) u U) :
+    ∃ f : E → ℝ, ContDiff ℝ (⊤ : ℕ∞) f ∧ HasCompactSupport f ∧
+      tsupport f ⊆ U ∧ (∀ x∈K, f =ᶠ[𝓝 x] u) ∧
+      (∀ x, |f x|≤|u x|) ∧ ∀ x∉U, f x=0 := by
+  obtain ⟨V,hV,hKV,hVU,hVc⟩ := exists_open_between_and_isCompact_closure hK hU hKU
+  obtain ⟨O,hO,hVO,hOU,hOc⟩ := exists_open_between_and_isCompact_closure hVc hU hVU
+  obtain ⟨χ,hχ,hχrange,hχsupport,hχone⟩ :=
+    exists_contDiff_support_eq_eq_one_iff (n := (⊤ : ℕ∞)) hO isClosed_closure hVO
+  have hχc : HasCompactSupport χ := by
+    change IsCompact (closure (support χ))
+    rw [hχsupport]
+    exact hOc
+  have hχU : tsupport χ ⊆ U := by simpa only [tsupport,hχsupport] using hOU
+  have hχb (x) : 0≤χ x ∧ χ x≤1 := hχrange (mem_range_self x)
+  let f : E → ℝ := fun x => χ x*u x
+  have hf : ContDiff ℝ (⊤ : ℕ∞) f := by
+    apply contDiff_iff_contDiffAt.mpr
+    intro x
+    by_cases hx : x∈U
+    · exact hχ.contDiffAt.mul ((hu x hx).contDiffAt (hU.mem_nhds hx))
+    · have hn : x∉tsupport χ := fun h => hx (hχU h)
+      have he : f =ᶠ[𝓝 x] (fun _ => (0:ℝ)) := by
+        filter_upwards [(isClosed_tsupport χ).isOpen_compl.mem_nhds hn] with y hy
+        have hz : χ y=0 := notMem_support.mp (fun hs => hy ((subset_tsupport χ) hs))
+        simp only [f,hz,zero_mul]
+      exact contDiffAt_const.congr_of_eventuallyEq he
+  refine ⟨f,hf,hχc.mul_right,?_,?_,?_,?_⟩
+  · exact (tsupport_mul_subset_left (f := χ) (g := u)).trans hχU
+  · intro x hx
+    filter_upwards [hV.mem_nhds (hKV hx)] with y hy
+    have he : χ y=1 := (hχone y).mp (subset_closure hy)
+    simp only [f,he,one_mul]
+  · intro x
+    dsimp only [f]
+    rw [abs_mul,abs_of_nonneg (hχb x).1]
+    exact mul_le_of_le_one_left (abs_nonneg _) (hχb x).2
+  · intro x hx
+    have hz : χ x=0 := notMem_support.mp (fun hs => hx (hχU ((subset_tsupport χ) hs)))
+    simp only [f,hz,zero_mul]
+
+end SLEExactGauge
+
+end
+
+end OAI
diff --git a/lean/OAI/Probability/SLE/Geometry/CompactTubeProbability.lean b/lean/OAI/Probability/SLE/Geometry/CompactTubeProbability.lean
new file mode 100644
index 0000000000000000000000000000000000000000..a14126f349eb6ba965fe279ef74fafc7037c18ca
--- /dev/null
+++ b/lean/OAI/Probability/SLE/Geometry/CompactTubeProbability.lean
@@ -0,0 +1,98 @@
+import Mathlib
+import Mathlib.Topology.ContinuousMap.Bounded.ArzelaAscoli
+
+namespace OAI
+
+/-! A finite-cover argument makes individual tube probabilities uniform on
+a compact family of routes. No quantitative support estimate is assumed. -/
+
+noncomputable section
+open Set MeasureTheory Metric
+open scoped ENNReal NNReal BoundedContinuousFunction
+
+namespace SLEExactGauge
+
+theorem finite_positive_lower_bound {X : Type*} (S : Set X) (hS : S.Finite)
+    (f : X → ℝ≥0∞) (hf : ∀ x ∈ S, 0 < f x) :
+    ∃ q : ℝ≥0∞, 0 < q ∧ ∀ x ∈ S, q ≤ f x := by
+  classical
+  induction S, hS using Set.Finite.induction_on with
+  | empty => exact ⟨1, by norm_num, by simp⟩
+  | @insert x S hx hS ih =>
+    obtain ⟨q, hq, hbound⟩ := ih (fun y hy => hf y (mem_insert_of_mem x hy))
+    refine ⟨min (f x) q, lt_min (hf x (mem_insert x S)) hq, ?_⟩
+    intro y hy
+    rcases mem_insert_iff.mp hy with rfl | hy
+    · exact min_le_left _ _
+    · exact (min_le_right _ _).trans (hbound y hy)
+
+/-- Pointwise positivity on half-radius balls gives one positive lower
+bound for full-radius balls centered anywhere in a compact set. -/
+theorem compact_tube_probability_lower_bound
+    {X : Type*} [PseudoMetricSpace X] [MeasurableSpace X]
+    (P : Measure X) (K : Set X) (hK : IsCompact K) {ε : ℝ} (hε : 0 < ε)
+    (hpositive : ∀ x ∈ K, 0 < P (ball x (ε / 2))) :
+    ∃ q : ℝ≥0∞, 0 < q ∧ ∀ x ∈ K, q ≤ P (ball x ε) := by
+  obtain ⟨S, hSK, hS, hcover⟩ := hK.finite_cover_balls (half_pos hε)
+  obtain ⟨q, hq, hbound⟩ := finite_positive_lower_bound S hS
+    (fun x => P (ball x (ε / 2))) (fun x hx => hpositive x (hSK hx))
+  refine ⟨q, hq, ?_⟩
+  intro x hx
+  obtain ⟨y, hy, hxy⟩ := mem_iUnion₂.mp (hcover hx)
+  refine (hbound y hy).trans (measure_mono ?_)
+  intro z hz
+  have hd := dist_triangle z y x
+  have hxy' : dist y x < ε / 2 := by simpa only [mem_ball, dist_comm] using hxy
+  have hzy : dist z y < ε / 2 := hz
+  change dist z x < ε
+  linarith
+
+end SLEExactGauge
+
+namespace SLEExactGauge.CompactRouteTubes
+
+local instance compactRouteMeasurableSpace : MeasurableSpace (unitInterval →ᵇ ℂ) := borel _
+local instance compactRouteBorelSpace : BorelSpace (unitInterval →ᵇ ℂ) := ⟨rfl⟩
+
+/-- The usual pointwise full-support statement for continuous paths based
+at zero is enough for a uniform tube probability over all routes with a
+fixed speed bound. Arzela--Ascoli and a finite cover supply the uniformity. -/
+theorem uniform_tube_probability_of_based_support
+    (P : Measure (unitInterval →ᵇ ℂ)) (C : ℝ≥0) {ε : ℝ} (hε : 0 < ε)
+    (hsupport : ∀ f : unitInterval →ᵇ ℂ, f 0 = 0 → ∀ r : ℝ, 0 < r →
+      0 < P (ball f r)) :
+    ∃ q : ℝ≥0∞, 0 < q ∧ ∀ f : unitInterval →ᵇ ℂ,
+      LipschitzWith C f → f 0 = 0 →
+      q ≤ P {g | ∀ t : unitInterval, dist (g t) (f t) < ε} := by
+  let S : Set (unitInterval →ᵇ ℂ) := {f | LipschitzWith C f ∧ f 0 = 0}
+  have heq : Equicontinuous ((↑) : S → unitInterval → ℂ) := by
+    apply (LipschitzWith.uniformEquicontinuous _ C ?_).equicontinuous
+    intro f
+    exact f.property.1
+  have hbound : ∀ f ∈ S, ∀ t : unitInterval, f t ∈ closedBall (0 : ℂ) C := by
+    intro f hf t
+    have hh := hf.1.dist_le_mul t 0
+    have ht : dist t (0 : unitInterval) ≤ 1 := by
+      change |(t : ℝ) - 0| ≤ 1
+      simpa only [sub_zero, abs_of_nonneg t.property.1] using t.property.2
+    rw [hf.2] at hh
+    exact hh.trans (by simpa only [mul_one] using mul_le_mul_of_nonneg_left ht C.coe_nonneg)
+  have hcompact : IsCompact (closure S) := BoundedContinuousFunction.arzela_ascoli
+    (closedBall (0 : ℂ) C) (isCompact_closedBall _ _) S (fun f t hf => hbound f hf t) heq
+  have hbasedClosed : IsClosed {f : unitInterval →ᵇ ℂ | f 0 = 0} :=
+    isClosed_eq (BoundedContinuousFunction.lipschitz_eval_const 0).continuous continuous_const
+  have hbased : closure S ⊆ {f : unitInterval →ᵇ ℂ | f 0 = 0} :=
+    closure_minimal (fun _ hf => hf.2) hbasedClosed
+  obtain ⟨q, hq, hqbound⟩ := compact_tube_probability_lower_bound P (closure S) hcompact hε
+    (fun f hf => hsupport f (hbased hf) (ε / 2) (half_pos hε))
+  refine ⟨q, hq, ?_⟩
+  intro f hf hf0
+  refine (hqbound f (subset_closure ⟨hf, hf0⟩)).trans (measure_mono ?_)
+  intro g hg t
+  exact (BoundedContinuousFunction.dist_coe_le_dist t).trans_lt hg
+
+end SLEExactGauge.CompactRouteTubes
+
+end
+
+end OAI
diff --git a/lean/OAI/Probability/SLE/Geometry/CompactifiedCrosscut.lean b/lean/OAI/Probability/SLE/Geometry/CompactifiedCrosscut.lean
new file mode 100644
index 0000000000000000000000000000000000000000..8bf85a42d1a5e76c62a53a842bdcee8eb6805b0d
--- /dev/null
+++ b/lean/OAI/Probability/SLE/Geometry/CompactifiedCrosscut.lean
@@ -0,0 +1,120 @@
+import OAI.Probability.SLE.Geometry.HalfPlaneCayleyCompactification
+
+namespace OAI
+
+/-! A proper half-plane ray becomes an injective compact disk crosscut
+from `-1` to `1`. The endpoint at infinity is filled by the proved Cayley
+limit, preserving the prescribed ray parameter. -/
+noncomputable section
+open Set Filter Complex
+open scoped Topology NNReal
+
+namespace SLEExactGauge
+
+def crosscutParameter (s : ℝ) : ℝ≥0 := (s/(1-s)).toNNReal
+
+lemma crosscutParameter_injectiveOn : InjOn crosscutParameter (Ico 0 1) := by
+  intro s hs t ht he
+  have he' := congrArg (fun r : ℝ≥0 => (r : ℝ)) he
+  have hsval : (crosscutParameter s : ℝ)=s/(1-s) :=
+    Real.coe_toNNReal _ (div_nonneg hs.1 (sub_pos.mpr hs.2).le)
+  have htval : (crosscutParameter t : ℝ)=t/(1-t) :=
+    Real.coe_toNNReal _ (div_nonneg ht.1 (sub_pos.mpr ht.2).le)
+  rw [hsval,htval] at he'
+  have hh := (div_eq_div_iff (sub_pos.mpr hs.2).ne' (sub_pos.mpr ht.2).ne').mp he'
+  nlinarith
+
+lemma crosscutParameter_continuousOn : ContinuousOn crosscutParameter (Ico 0 1) := by
+  apply continuous_real_toNNReal.comp_continuousOn
+  exact continuousOn_id.div (continuousOn_const.sub continuousOn_id)
+    (fun _ hs => (sub_pos.mpr hs.2).ne')
+
+lemma crosscutParameter_tendsto : Tendsto crosscutParameter (𝓝[<] 1) atTop := by
+  have hid : Tendsto (fun s : ℝ => s) (𝓝[<] 1) (𝓝 1) :=
+    tendsto_id.mono_left nhdsWithin_le_nhds
+  have hsub : Tendsto (fun s : ℝ => 1-s) (𝓝[<] 1) (𝓝[>] 0) := by
+    apply tendsto_nhdsWithin_iff.mpr
+    refine ⟨?_,?_⟩
+    · simpa only [sub_self] using
+        (tendsto_const_nhds : Tendsto (fun _ : ℝ => (1:ℝ)) (𝓝[<] 1) (𝓝 1)).sub hid
+    · filter_upwards [self_mem_nhdsWithin] with s hs
+      change 0 < 1-s
+      exact sub_pos.mpr hs
+  have hh := hid.pos_mul_atTop zero_lt_one (tendsto_inv_nhdsGT_zero.comp hsub)
+  exact tendsto_real_toNNReal_atTop.comp
+    (by simpa only [div_eq_mul_inv,Function.comp_apply] using hh)
+
+def compactifiedCrosscut (β : ℝ≥0 → ℂ) : ℝ → ℂ :=
+  Function.update (fun s => halfPlaneCayley (β (crosscutParameter s))) 1 1
+
+lemma compactifiedCrosscut_one (β : ℝ≥0 → ℂ) : compactifiedCrosscut β 1=1 :=
+  Function.update_self ..
+
+lemma compactifiedCrosscut_eq (β : ℝ≥0 → ℂ) {s : ℝ} (hs : s < 1) :
+    compactifiedCrosscut β s=halfPlaneCayley (β (crosscutParameter s)) :=
+  Function.update_of_ne hs.ne _ _
+
+lemma compactifiedCrosscut_zero (β : ℝ≥0 → ℂ) (h0 : β 0=0) :
+    compactifiedCrosscut β 0 = -1 := by
+  rw [compactifiedCrosscut_eq β zero_lt_one]
+  simp only [crosscutParameter,zero_div,Real.toNNReal_zero,h0,halfPlaneCayley_zero]
+
+theorem compactifiedCrosscut_properties
+    (β : ℝ≥0 → ℂ) (hc : Continuous β) (hi : Function.Injective β) (h0 : β 0=0)
+    (hH : ∀ t : ℝ≥0, 0 < t → β t ∈ upperHalfPlane)
+    (hinfty : Tendsto β atTop (cocompact ℂ)) :
+    ContinuousOn (compactifiedCrosscut β) (Icc 0 1) ∧
+      InjOn (compactifiedCrosscut β) (Icc 0 1) ∧
+      ∀ s ∈ Ioo 0 1, ‖compactifiedCrosscut β s‖ < 1 := by
+  have hH' (t : ℝ≥0) : 0 ≤ (β t).im := by
+    by_cases ht : t=0
+    · simp [ht,h0]
+    · exact (hH t (pos_iff_ne_zero.mpr ht)).le
+  have hbase : ContinuousOn (fun s => halfPlaneCayley (β (crosscutParameter s)))
+      (Ico 0 1) := by
+    apply halfPlaneCayley_continuousOn.comp
+      (hc.comp_continuousOn crosscutParameter_continuousOn)
+    intro s _
+    exact hH' _
+  have hceq : Icc (0:ℝ) 1 \ {1} = Ico 0 1 := by
+    ext s
+    simp only [Set.mem_sdiff,mem_Icc,mem_singleton_iff,mem_Ico]
+    constructor
+    · rintro ⟨⟨hs,hs1⟩,hn⟩
+      exact ⟨hs,lt_of_le_of_ne hs1 hn⟩
+    · rintro ⟨hs,hs1⟩
+      exact ⟨⟨hs,hs1.le⟩,hs1.ne⟩
+  refine ⟨?_,?_,?_⟩
+  · apply continuousOn_update_iff.mpr
+    rw [hceq]
+    refine ⟨hbase,fun _ => ?_⟩
+    exact (halfPlaneCayley_tendsto_infinity.comp (hinfty.comp crosscutParameter_tendsto)).mono_left
+      (nhdsWithin_mono _ Ico_subset_Iio_self)
+  · intro s hs t ht he
+    by_cases hs1 : s=1
+    · subst s
+      by_contra ht1
+      rw [compactifiedCrosscut_one,
+        compactifiedCrosscut_eq β (lt_of_le_of_ne ht.2 (fun h => ht1 h.symm))] at he
+      exact halfPlaneCayley_ne_one (hH' _) he.symm
+    · by_cases ht1 : t=1
+      · subst t
+        rw [compactifiedCrosscut_one,compactifiedCrosscut_eq β (lt_of_le_of_ne hs.2 hs1)] at he
+        exact False.elim (halfPlaneCayley_ne_one (hH' _) he)
+      · have hslt := lt_of_le_of_ne hs.2 hs1
+        have htlt := lt_of_le_of_ne ht.2 ht1
+        rw [compactifiedCrosscut_eq β hslt,compactifiedCrosscut_eq β htlt] at he
+        exact crosscutParameter_injectiveOn ⟨hs.1,hslt⟩ ⟨ht.1,htlt⟩
+          (hi (halfPlaneCayley_injOn (hH' _) (hH' _) he))
+  · intro s hs
+    rw [compactifiedCrosscut_eq β hs.2]
+    apply halfPlaneCayley_norm_lt
+    apply hH
+    change 0 < (s/(1-s)).toNNReal
+    exact Real.toNNReal_pos.mpr (div_pos hs.1 (sub_pos.mpr hs.2))
+
+end SLEExactGauge
+
+end
+
+end OAI
diff --git a/lean/OAI/Probability/SLE/Geometry/CompleteAccessGuide.lean b/lean/OAI/Probability/SLE/Geometry/CompleteAccessGuide.lean
new file mode 100644
index 0000000000000000000000000000000000000000..d767c76e0f6fb28a93fef9366ee662d176099ac4
--- /dev/null
+++ b/lean/OAI/Probability/SLE/Geometry/CompleteAccessGuide.lean
@@ -0,0 +1,140 @@
+import OAI.Probability.SLE.Geometry.NormalizedAccessGuide
+import OAI.Probability.SLE.Geometry.PublishedCrosscutStraightening
+
+namespace OAI
+
+/-! The complete physical access guide maps to a proper half-plane
+crosscut based at the actual driving prime end. Properness at infinity
+is proved from the hydrodynamic normalization in the capacity witness. -/
+
+noncomputable section
+open Set Filter Metric
+open scoped Topology NNReal
+
+namespace SLEExactGauge
+
+theorem IsCapacityTwoWitness.centered_chart_escapes
+    {U : ℝ≥0 → ℝ} {γ : ℝ≥0 → ℂ} {G F : ℝ≥0 → ℂ → ℂ}
+    (hw : IsCapacityTwoWitness U γ G F) (T : ℝ≥0)
+    (α : ℝ≥0 → ℂ) (hαD : ∀ t : ℝ≥0, 0 < t → α t ∈ survivingDomain γ T)
+    (hescape : Tendsto α atTop (cocompact ℂ)) :
+    Tendsto (fun t => G T (α t) - (U T : ℂ)) atTop (cocompact ℂ) := by
+  have hnorm := hw
+  rcases hnorm with ⟨_, _, _, _, _, _, _, _, _, _, _, hnorm, _⟩
+  have hD : ∀ᶠ t in atTop, α t ∈ survivingDomain γ T := by
+    filter_upwards [eventually_gt_atTop (0 : ℝ≥0)] with t ht
+    exact hαD t ht
+  have hmap : Tendsto α atTop (cocompact ℂ ⊓ 𝓟 (survivingDomain γ T)) :=
+    by simpa only [inf_idem] using hescape.inf (tendsto_principal.mpr hD)
+  have hproduct := (hnorm T).comp hmap
+  have hinv : Tendsto (fun t => (α t)⁻¹) atTop (𝓝 (0 : ℂ)) :=
+    tendsto_inv₀_cobounded.comp (hescape.mono_right cobounded_eq_cocompact.ge)
+  have hprod0 := hproduct.mul hinv
+  have hαnorm : Tendsto (fun t => ‖α t‖) atTop atTop :=
+    tendsto_norm_cocompact_atTop.comp hescape
+  have hne : ∀ᶠ t in atTop, α t ≠ 0 := by
+    filter_upwards [hαnorm.eventually_gt_atTop 0] with t ht
+    exact norm_pos_iff.mp ht
+  have hdiff : Tendsto (fun t => G T (α t) - α t) atTop (𝓝 (0 : ℂ)) := by
+    have he : (fun t => (α t * (G T (α t) - α t)) * (α t)⁻¹) =ᶠ[atTop]
+        (fun t => G T (α t) - α t) := by
+      filter_upwards [hne] with t ht
+      field_simp
+    simpa only [mul_zero] using hprod0.congr' he
+  apply tendsto_cocompact_of_tendsto_dist_comp_atTop 0
+  simp only [dist_zero_right]
+  apply Filter.tendsto_atTop.mpr
+  intro R
+  have hsmall : ∀ᶠ t in atTop, ‖G T (α t) - α t‖ < 1 := by
+    simpa only [Metric.mem_ball, dist_zero_right] using hdiff.eventually (ball_mem_nhds 0 zero_lt_one)
+  filter_upwards [hαnorm.eventually_ge_atTop (R + |U T| + 1), hsmall] with t ht hs
+  have htri : ‖α t‖ ≤ ‖α t - (G T (α t) - (U T : ℂ))‖ +
+      ‖G T (α t) - (U T : ℂ)‖ := by
+    simpa only [add_comm] using norm_le_insert' (α t) (G T (α t) - (U T : ℂ))
+  have he : α t - (G T (α t) - (U T : ℂ)) =
+      -(G T (α t) - α t) + (U T : ℂ) := by ring
+  have hb : ‖α t - (G T (α t) - (U T : ℂ))‖ ≤
+      ‖G T (α t) - α t‖ + |U T| := by
+    rw [he]
+    simpa only [norm_neg, Complex.norm_real, Real.norm_eq_abs] using
+      norm_add_le (-(G T (α t) - α t)) (U T : ℂ)
+  linarith
+
+/-- The continuous complete parameter guide has the exact capacity-map
+formula at every positive time, including its asymptotic endpoint. -/
+theorem actual_complete_access_guide
+    {U : ℝ≥0 → ℝ} {γ : ℝ≥0 → ℂ} {G F : ℝ≥0 → ℂ → ℂ}
+    (hw : IsCapacityTwoWitness U γ G F) (hU : Continuous U)
+    (T : ℝ≥0) (hT : 0 < T)
+    (hfresh : ∀ s : ℝ≥0, s < T → γ T ∈ survivingDomain γ s)
+    (α : ℝ≥0 → ℂ) (hα : Continuous α) (hiα : Function.Injective α)
+    (hα0 : α 0 = γ T) (hαD : ∀ t : ℝ≥0, 0 < t → α t ∈ survivingDomain γ T)
+    (hescape : Tendsto α atTop (cocompact ℂ)) :
+    ∃ β : ℝ≥0 → ℂ, Continuous β ∧ Function.Injective β ∧ β 0 = 0 ∧
+      (∀ t : ℝ≥0, 0 < t → β t ∈ upperHalfPlane) ∧
+      Tendsto β atTop (cocompact ℂ) ∧
+      ∀ t : ℝ≥0, 0 < t → β t = G T (α t) - (U T : ℂ) := by
+  let D := survivingDomain γ T
+  have htip : γ T ∉ D := fun hh => hh.1.2 ⟨T, ⟨bot_le, le_rfl⟩, rfl⟩
+  let gb := Function.update (G T) (γ T) (U T : ℂ)
+  have hs : insert (γ T) D \ {γ T} = D := by
+    ext z
+    simp only [Set.mem_sdiff, mem_insert_iff, mem_singleton_iff]
+    constructor
+    · rintro ⟨rfl | hz, hn⟩
+      · exact False.elim (hn rfl)
+      · exact hz
+    · intro hz
+      exact ⟨Or.inr hz, fun he => htip (he ▸ hz)⟩
+  have hgb : ContinuousOn gb (insert (γ T) D) := by
+    rw [continuousOn_update_iff, hs]
+    exact ⟨(hw.2.2.2.1 T).continuousOn,
+      fun _ => hw.fresh_tip_chart_tendsto hU hT hfresh⟩
+  have hαS : MapsTo α univ (insert (γ T) D) := by
+    intro t _
+    by_cases ht : t = 0
+    · simpa only [ht, hα0] using mem_insert (γ T) D
+    · exact mem_insert_of_mem _ (hαD t (pos_iff_ne_zero.mpr ht))
+  let β : ℝ≥0 → ℂ := fun t => gb (α t) - (U T : ℂ)
+  have hβc : Continuous β :=
+    (hgb.comp_continuous hα (fun t => hαS (mem_univ t))).sub continuous_const
+  have hβ0 : β 0 = 0 := by simp [β, gb, hα0]
+  have hβeq (t : ℝ≥0) (ht : 0 < t) : β t = G T (α t) - (U T : ℂ) := by
+    have hn : α t ≠ γ T := fun he => htip (he ▸ hαD t ht)
+    exact congrArg (fun z : ℂ => z - (U T : ℂ)) (Function.update_of_ne hn _ _)
+  have hβH (t : ℝ≥0) (ht : 0 < t) : β t ∈ upperHalfPlane := by
+    rw [hβeq t ht]
+    simpa only [upperHalfPlane, mem_ofPred_eq, Complex.sub_im, Complex.ofReal_im, sub_zero]
+      using hw.imag_positive T (α t) (hαD t ht)
+  have hβi : Function.Injective β := by
+    intro s t he
+    by_cases hs0 : s = 0
+    · have ht0 : t = 0 := by
+        by_contra ht0
+        have hh : 0 < (β t).im := hβH t (pos_iff_ne_zero.mpr ht0)
+        rw [← he, hs0, hβ0, Complex.zero_im] at hh
+        exact (lt_irrefl 0) hh
+      exact hs0.trans ht0.symm
+    · by_cases ht0 : t = 0
+      · have hh : 0 < (β s).im := hβH s (pos_iff_ne_zero.mpr hs0)
+        rw [he, ht0, hβ0, Complex.zero_im] at hh
+        exact False.elim ((lt_irrefl 0) hh)
+      · apply hiα
+        rw [hβeq s (pos_iff_ne_zero.mpr hs0), hβeq t (pos_iff_ne_zero.mpr ht0)] at he
+        have hg : G T (α s) = G T (α t) := sub_left_inj.mp he
+        calc
+          α s = F T (G T (α s)) :=
+            (hw.2.2.2.2.2.2.2.1 T _ (hαD s (pos_iff_ne_zero.mpr hs0))).symm
+          _ = F T (G T (α t)) := congrArg (F T) hg
+          _ = α t := hw.2.2.2.2.2.2.2.1 T _ (hαD t (pos_iff_ne_zero.mpr ht0))
+  have hβescape : Tendsto β atTop (cocompact ℂ) := by
+    apply (hw.centered_chart_escapes T α hαD hescape).congr'
+    filter_upwards [eventually_gt_atTop (0 : ℝ≥0)] with t ht
+    exact (hβeq t ht).symm
+  exact ⟨β, hβc, hβi, hβ0, hβH, hβescape, hβeq⟩
+
+end SLEExactGauge
+
+end
+
+end OAI
diff --git a/lean/OAI/Probability/SLE/Geometry/ComplexAngularEnergy.lean b/lean/OAI/Probability/SLE/Geometry/ComplexAngularEnergy.lean
new file mode 100644
index 0000000000000000000000000000000000000000..a4a5c9ff8527d487a603dde2745527312f5cbe03
--- /dev/null
+++ b/lean/OAI/Probability/SLE/Geometry/ComplexAngularEnergy.lean
@@ -0,0 +1,61 @@
+import OAI.Probability.SLE.Geometry.SmallImageSemicircle
+
+namespace OAI
+
+/-! Complex-valued angular sections have small diameter when their
+one-dimensional derivative energy is small. -/
+noncomputable section
+open Set Filter Metric Function MeasureTheory
+open scoped Topology ENNReal
+
+namespace SLEExactGauge
+
+lemma complex_angular_oscillation {f : ℝ → ℂ} {x y : ℝ}
+    (hx : x∈Ioo 0 Real.pi) (hy : y∈Ioo 0 Real.pi)
+    (hf : ∀ θ∈uIcc x y, DifferentiableAt ℝ f θ)
+    (hd : MemLp (deriv f) 2 (volume.restrict (Ioo 0 Real.pi))) :
+    ‖f y-f x‖ ≤ Real.sqrt Real.pi *
+      Real.sqrt (∫ θ in Ioo 0 Real.pi, ‖deriv f θ‖^2) := by
+  have hsub : uIoc x y⊆Ioo 0 Real.pi := by
+    intro θ hθ
+    exact ordConnected_Ioo.uIcc_subset hx hy (uIoc_subset_uIcc hθ)
+  have hi : IntegrableOn (fun θ => ‖deriv f θ‖) (Ioo 0 Real.pi) :=
+    (hd.integrable (by norm_num)).norm
+  have hi' : IntegrableOn (deriv f) (Ioo 0 Real.pi) := hd.integrable (by norm_num)
+  have hid : IntervalIntegrable (deriv f) volume x y :=
+    intervalIntegrable_iff.mpr (hi'.mono_set hsub)
+  calc
+    ‖f y-f x‖ = ‖∫ θ in x..y, deriv f θ‖ :=
+      congrArg norm (intervalIntegral.integral_deriv_eq_sub hf hid).symm
+    _ ≤ ∫ θ in uIoc x y, ‖deriv f θ‖ := intervalIntegral.norm_integral_le_integral_norm_uIoc
+    _ ≤ ∫ θ in Ioo 0 Real.pi, ‖deriv f θ‖ :=
+      setIntegral_mono_set hi (ae_of_all _ (fun _ => norm_nonneg _)) hsub.eventuallySubset
+    _ ≤ _ := by
+      simpa only [abs_norm] using SmallImageSemicircle.integral_abs_le_angular_energy hd.norm
+
+lemma holomorphic_angular_section_absolutelyContinuous
+    {f : ℂ → ℂ} (hf : DifferentiableOn ℂ f {z | 0<z.im ∧ z.im<Real.pi})
+    (v : ℝ) {x y : ℝ} (hx : x∈Ioo 0 Real.pi) (hy : y∈Ioo 0 Real.pi) :
+    AbsolutelyContinuousOnInterval (fun θ : ℝ => f ((v:ℂ)+(θ:ℂ)*Complex.I)) x y := by
+  have hc : ContDiffOn ℝ 1 (fun θ : ℝ => f ((v:ℂ)+(θ:ℂ)*Complex.I)) (uIcc x y) := by
+    intro θ hθ
+    have hθ' := ordConnected_Ioo.uIcc_subset hx hy hθ
+    have hz : (v:ℂ)+(θ:ℂ)*Complex.I∈{z : ℂ | 0<z.im ∧ z.im<Real.pi} := by
+      simpa only [Set.mem_Ioo,Set.mem_ofPred_eq,Complex.add_im,Complex.ofReal_im,Complex.mul_im,
+        Complex.ofReal_re,Complex.I_im,Complex.I_re,mul_one,mul_zero,add_zero,zero_add] using hθ'
+    have ho : IsOpen {z : ℂ | 0<z.im ∧ z.im<Real.pi} :=
+      (isOpen_lt continuous_const Complex.continuous_im).inter
+        (isOpen_lt Complex.continuous_im continuous_const)
+    have ha : ContDiffAt ℝ 1 f ((v:ℂ)+(θ:ℂ)*Complex.I) :=
+      ((hf.analyticAt (ho.mem_nhds hz)).restrictScalars (𝕜 := ℝ)).contDiffAt
+    have hcast : ContDiffAt ℝ 1 (fun t : ℝ => (t:ℂ)) θ :=
+      Complex.ofRealCLM.contDiff.contDiffAt
+    exact (ha.comp θ (contDiffAt_const.add (hcast.mul contDiffAt_const))).contDiffWithinAt
+  obtain ⟨K,hK⟩ := hc.exists_lipschitzOnWith (by norm_num) (convex_uIcc x y) isCompact_uIcc
+  exact hK.absolutelyContinuousOnInterval
+
+end SLEExactGauge
+
+end
+
+end OAI
diff --git a/lean/OAI/Probability/SLE/Geometry/ComplexDirichletSlices.lean b/lean/OAI/Probability/SLE/Geometry/ComplexDirichletSlices.lean
new file mode 100644
index 0000000000000000000000000000000000000000..392fe98bf8041bf3250b3aac17aeccca1f09ca17
--- /dev/null
+++ b/lean/OAI/Probability/SLE/Geometry/ComplexDirichletSlices.lean
@@ -0,0 +1,58 @@
+import OAI.Probability.SLE.Geometry.ComplexAngularEnergy
+
+namespace OAI
+
+/-! Finite holomorphic energy gives square-integrable derivatives and
+low-energy angular sections in each unit logarithmic strip. -/
+noncomputable section
+open Set Filter Metric Function MeasureTheory
+open scoped Topology ENNReal
+
+namespace SLEExactGauge
+
+lemma deriv_memLp_two_of_energy {f : ℂ → ℂ} {S : Set ℂ} (hS : IsOpen S)
+    (hf : DifferentiableOn ℂ f S)
+    (he : (∫⁻ z in S, ENNReal.ofReal (‖deriv f z‖^2))<∞) :
+    MemLp (deriv f) 2 (volume.restrict S) := by
+  have hc : ContinuousOn (deriv f) S := (hf.deriv hS).continuousOn
+  have hm : AEStronglyMeasurable (deriv f) (volume.restrict S) :=
+    hc.aestronglyMeasurable hS.measurableSet
+  apply (memLp_two_iff_integrable_sq_norm hm).mpr
+  exact ⟨hm.norm.pow 2, (hasFiniteIntegral_iff_ofReal
+    (ae_of_all _ (fun _ => sq_nonneg _))).mpr he⟩
+
+lemma exists_complex_energy_section (g : ℝ × ℝ → ℂ) (q : ℝ)
+    (hg : MemLp g 2 ((volume.restrict (Ioo q (q+1))).prod
+      (volume.restrict (Ioo 0 Real.pi)))) :
+    ∃ v∈Ioo q (q+1), MemLp (fun θ => g (v,θ)) 2 (volume.restrict (Ioo 0 Real.pi)) ∧
+      (∫ θ in Ioo 0 Real.pi, ‖g (v,θ)‖^2) ≤
+        ∫ p, ‖g p‖^2 ∂((volume.restrict (Ioo q (q+1))).prod (volume.restrict (Ioo 0 Real.pi))) := by
+  let J := Ioo q (q+1)
+  let K := Ioo (0:ℝ) Real.pi
+  have hi := (memLp_two_iff_integrable_sq_norm hg.aestronglyMeasurable).mp hg
+  have hgood : ∀ᵐ v ∂volume.restrict J,
+      v∈J ∧ MemLp (fun θ => g (v,θ)) 2 (volume.restrict K) := by
+    filter_upwards [ae_restrict_mem measurableSet_Ioo,hi.prod_right_ae,
+      hg.aestronglyMeasurable.prodMk_left] with v hv hvi hvm
+    exact ⟨hv,(memLp_two_iff_integrable_sq_norm hvm).mpr hvi⟩
+  have : IsProbabilityMeasure (volume.restrict J) := by
+    constructor
+    simp [J,Real.volume_Ioo]
+  let energy := fun v => ∫ θ in K, ‖g (v,θ)‖^2
+  have hei : Integrable energy (volume.restrict J) := hi.integral_prod_left
+  let Good := fun v => v∈J ∧ MemLp (fun θ => g (v,θ)) 2 (volume.restrict K)
+  have hnull : (volume.restrict J) {v | ¬Good v}=0 := by
+    apply measure_eq_zero_iff_ae_notMem.mpr
+    filter_upwards [hgood] with v hv
+    exact fun h => h hv
+  obtain ⟨v,hv,hve⟩ := exists_notMem_null_le_integral hei hnull
+  have hv' : Good v := not_not.mp hv
+  refine ⟨v,hv'.1,hv'.2,?_⟩
+  rw [integral_prod _ hi]
+  exact hve
+
+end SLEExactGauge
+
+end
+
+end OAI
diff --git a/lean/OAI/Probability/SLE/Geometry/ComplexDissipation.lean b/lean/OAI/Probability/SLE/Geometry/ComplexDissipation.lean
new file mode 100644
index 0000000000000000000000000000000000000000..103612e825a17782f374c3bc11e1c63b2c2263e3
--- /dev/null
+++ b/lean/OAI/Probability/SLE/Geometry/ComplexDissipation.lean
@@ -0,0 +1,49 @@
+import OAI.Probability.SLE.Geometry.EndpointMonotonicity
+
+namespace OAI
+
+/-! A complex linear equation with nonpositive real coefficient contracts,
+including an initial endpoint where the coefficient may be singular. -/
+noncomputable section
+open Set Filter Complex
+open scoped Topology
+
+namespace SLEExactGauge
+
+lemma complex_normSq_hasDerivWithinAt {S : Set ℝ} {t : ℝ}
+    (f : ℝ → ℂ) (v : ℂ) (hf : HasDerivWithinAt f v S t) :
+    HasDerivWithinAt (fun s => Complex.normSq (f s))
+      (2*((f t).re*v.re+(f t).im*v.im)) S t := by
+  have hr := Complex.reCLM.hasFDerivAt.comp_hasDerivWithinAt t hf
+  have hi := Complex.imCLM.hasFDerivAt.comp_hasDerivWithinAt t hf
+  change HasDerivWithinAt (fun s => (f s).re) v.re S t at hr
+  change HasDerivWithinAt (fun s => (f s).im) v.im S t at hi
+  convert! (hr.pow 2).add (hi.pow 2) using 1
+  · funext s
+    simp only [Complex.normSq_apply,pow_two,Pi.add_apply,Pi.mul_apply]
+  · ring
+
+theorem complex_linear_endpoint_contraction {T : ℝ} (hT : 0 ≤ T)
+    (f c : ℝ → ℂ) (hc : ContinuousOn f (Icc 0 T))
+    (hd : ∀ t ∈ Ioc 0 T, HasDerivWithinAt f (c t*f t) (Ici t) t)
+    (hb : ∀ t ∈ Ioc 0 T, (c t).re ≤ 0) :
+    ∀ t ∈ Icc 0 T, ‖f t‖ ≤ ‖f 0‖ := by
+  have hsq := le_initial_of_deriv_nonpos_on_Ioc hT
+    (fun t => Complex.normSq (f t))
+    (fun t => 2*(c t).re*Complex.normSq (f t))
+    (Complex.continuous_normSq.comp_continuousOn hc) (fun t ht => ?_) (fun t ht => ?_)
+  · intro t ht
+    have hh := hsq t ht
+    rw [Complex.normSq_eq_norm_sq,Complex.normSq_eq_norm_sq] at hh
+    nlinarith [norm_nonneg (f t),norm_nonneg (f 0)]
+  · convert! complex_normSq_hasDerivWithinAt f (c t*f t) (hd t ht) using 1
+    simp only [Complex.mul_re,Complex.mul_im,Complex.normSq_apply]
+    ring
+  · exact mul_nonpos_of_nonpos_of_nonneg
+      (mul_nonpos_of_nonneg_of_nonpos (by norm_num) (hb t ht)) (Complex.normSq_nonneg _)
+
+end SLEExactGauge
+
+end
+
+end OAI
diff --git a/lean/OAI/Probability/SLE/Geometry/ComplexEndpointCluster.lean b/lean/OAI/Probability/SLE/Geometry/ComplexEndpointCluster.lean
new file mode 100644
index 0000000000000000000000000000000000000000..e66953d8b0e459949d5ec225751e1d0811e86332
--- /dev/null
+++ b/lean/OAI/Probability/SLE/Geometry/ComplexEndpointCluster.lean
@@ -0,0 +1,47 @@
+import OAI.Probability.SLE.Geometry.EndpointClusterLimit
+import Mathlib.Analysis.Complex.Basic
+
+namespace OAI
+
+/-! Lifting a real cluster value when the imaginary coordinate tends to
+zero. -/
+noncomputable section
+open Set Filter Metric Complex
+open scoped Topology
+
+namespace SLEExactGauge
+
+lemma complex_cluster_of_real_cluster {α : Type*} {l : Filter α} {f : α → ℂ} {a : ℝ}
+    (him : Tendsto (fun x => (f x).im) l (𝓝 0))
+    (ha : MapClusterPt a l (fun x => (f x).re)) : MapClusterPt (a:ℂ) l f := by
+  apply (Metric.nhds_basis_ball.mapClusterPt_iff_frequently).mpr
+  intro ε hε
+  have hre := ha.frequently (ball_mem_nhds a (half_pos hε))
+  have himsmall : ∀ᶠ x in l, |(f x).im|<ε/2 := by
+    have hh : Tendsto (fun x => |(f x).im|) l (𝓝 0) := by
+      simpa only [norm_zero,Real.norm_eq_abs] using him.norm
+    exact hh.eventually (gt_mem_nhds (half_pos hε))
+  apply (hre.and_eventually himsmall).mono
+  intro x hx
+  rw [mem_ball,dist_eq_norm]
+  have hr : |(f x).re-a|<ε/2 := by
+    simpa only [mem_ball,Real.dist_eq] using hx.1
+  calc
+    ‖f x-(a:ℂ)‖ ≤ |(f x).re-a|+|(f x).im| := by
+      simpa only [sub_re,ofReal_re,sub_im,ofReal_im,sub_zero] using
+        norm_le_abs_re_add_abs_im (f x-(a:ℂ))
+    _ < ε := by linarith [hx.2]
+
+lemma cluster_value_eq_limit {α X : Type*} [TopologicalSpace X] [T2Space X]
+    {l : Filter α} {f : α → X} {a b : X}
+    (ha : MapClusterPt a l f) (hb : Tendsto f l (𝓝 b)) : a=b := by
+  let : NeBot (𝓝 a ⊓ map f l) := ha
+  have h1 : Tendsto id (𝓝 a ⊓ map f l) (𝓝 a) := inf_le_left
+  have h2 : Tendsto id (𝓝 a ⊓ map f l) (𝓝 b) := inf_le_right.trans hb
+  exact tendsto_nhds_unique h1 h2
+
+end SLEExactGauge
+
+end
+
+end OAI
diff --git a/lean/OAI/Probability/SLE/Geometry/ComplexEndpointLimit.lean b/lean/OAI/Probability/SLE/Geometry/ComplexEndpointLimit.lean
new file mode 100644
index 0000000000000000000000000000000000000000..96f6f9ad545a0c1748b9bcba01842b8d4d0e69cd
--- /dev/null
+++ b/lean/OAI/Probability/SLE/Geometry/ComplexEndpointLimit.lean
@@ -0,0 +1,59 @@
+import OAI.Probability.SLE.Geometry.ComplexEndpointCluster
+
+namespace OAI
+
+/-! A bounded upper-half-plane path has a real endpoint limit when its
+continuous image has a limit and the corresponding boundary fiber has no
+interval. -/
+noncomputable section
+open Set Filter Metric Complex
+open scoped Topology
+
+namespace SLEExactGauge
+
+lemma real_cluster_in_boundary_fiber {α : Type*} {l : Filter α}
+    {f : α → ℂ} {B : ℂ → ℂ} {a : ℝ} {b : ℂ}
+    (hB : ContinuousOn B {z : ℂ | 0≤z.im})
+    (hmem : ∀ᶠ x in l, 0≤(f x).im)
+    (him : Tendsto (fun x => (f x).im) l (𝓝 0))
+    (himage : Tendsto (fun x => B (f x)) l (𝓝 b))
+    (ha : MapClusterPt a l (fun x => (f x).re)) : B (a:ℂ)=b := by
+  have hca := complex_cluster_of_real_cluster him ha
+  have hle : 𝓝 (a:ℂ) ⊓ map f l ≤ 𝓝[{z : ℂ | 0≤z.im}] (a:ℂ) :=
+    le_inf inf_le_left (inf_le_right.trans (tendsto_principal.mpr hmem))
+  have hcont : Tendsto B (𝓝[{z : ℂ | 0≤z.im}] (a:ℂ)) (𝓝 (B (a:ℂ))) := hB _ (by simp)
+  have hc := MapClusterPt.tendsto_comp' (hcont.mono_left hle) hca
+  exact cluster_value_eq_limit hc himage
+
+theorem exists_complex_endpoint_limit {f : ℝ → ℂ} {B : ℂ → ℂ} {b : ℂ} {D M : ℝ}
+    (hD : 0<D) (hf : ContinuousOn f (Ioo 0 D))
+    (hbound : ∀ᶠ t : ℝ in 𝓝[>] (0:ℝ), ‖f t‖≤M)
+    (hmem : ∀ᶠ t : ℝ in 𝓝[>] (0:ℝ), 0≤(f t).im)
+    (him : Tendsto (fun t => (f t).im) (𝓝[>] (0:ℝ)) (𝓝 0))
+    (hB : ContinuousOn B {z : ℂ | 0≤z.im})
+    (himage : Tendsto (fun t => B (f t)) (𝓝[>] (0:ℝ)) (𝓝 b))
+    (hno : ∀ a d : ℝ, a<d → ¬ ∀ c∈Ioo a d, B (c:ℂ)=b) :
+    ∃ a : ℝ, Tendsto f (𝓝[>] (0:ℝ)) (𝓝 (a:ℂ)) ∧ B (a:ℂ)=b := by
+  have hrbound : ∀ᶠ t : ℝ in 𝓝[>] (0:ℝ), (f t).re∈Icc (-M) M := by
+    filter_upwards [hbound] with t ht
+    exact abs_le.mp ((abs_re_le_norm (f t)).trans ht)
+  have hnoCluster : ∀ a d : ℝ, a<d →
+      ¬ ∀ c∈Ioo a d, MapClusterPt c (𝓝[>] (0:ℝ)) (fun t => (f t).re) := by
+    intro a d had hc
+    apply hno a d had
+    intro c hcd
+    exact real_cluster_in_boundary_fiber hB hmem him himage (hc c hcd)
+  obtain ⟨a,_,ha⟩ := exists_endpoint_limit_of_no_cluster_interval hD
+    (continuous_re.comp_continuousOn hf) isCompact_Icc hrbound hnoCluster
+  have hcomplex : Tendsto f (𝓝[>] (0:ℝ)) (𝓝 (a:ℂ)) := by
+    have hh := (continuous_ofReal.continuousAt.tendsto.comp ha).add
+      ((continuous_ofReal.continuousAt.tendsto.comp him).mul_const I)
+    simpa only [Function.comp_apply,ofReal_zero,zero_mul,add_zero,re_add_im] using hh
+  refine ⟨a,hcomplex,?_⟩
+  exact real_cluster_in_boundary_fiber hB hmem him himage ha.mapClusterPt
+
+end SLEExactGauge
+
+end
+
+end OAI
diff --git a/lean/OAI/Probability/SLE/Geometry/ComplexHarmonicGenerator.lean b/lean/OAI/Probability/SLE/Geometry/ComplexHarmonicGenerator.lean
new file mode 100644
index 0000000000000000000000000000000000000000..3cc345356a6eea5d38f6907118912f3e0577468c
--- /dev/null
+++ b/lean/OAI/Probability/SLE/Geometry/ComplexHarmonicGenerator.lean
@@ -0,0 +1,62 @@
+import OAI.Probability.SLE.Stochastic.PlanarHarmonicLocalization
+import OAI.Probability.SLE.Geometry.ConformalLaplacian
+
+namespace OAI
+
+/-! The planar Brownian generator of a complex-plane harmonic function is
+one half of its real Laplacian. -/
+noncomputable section
+open Set Filter MeasureTheory ProbabilityTheory Complex InnerProductSpace
+open scoped Topology NNReal ENNReal Laplacian
+
+namespace SLEExactGauge
+
+lemma second_derivative_constant_curve {u : ℂ → ℝ} {ψ : ℝ → ℂ} {a : ℝ} {v : ℂ}
+    (hu : ContDiffAt ℝ 2 u (ψ a)) (hψ : ∀ r, HasDerivAt ψ v r) :
+    iteratedDeriv 2 (fun r => u (ψ r)) a = fderiv ℝ (fderiv ℝ u) (ψ a) v v := by
+  have hu1 : ContDiffAt ℝ 1 u (ψ a) := hu.of_le (by norm_num)
+  have hevent : ∀ᶠ z in 𝓝 (ψ a), ContDiffAt ℝ 1 u z := hu1.eventually (by norm_num)
+  have he : deriv (fun r => u (ψ r)) =ᶠ[𝓝 a] (fun r => fderiv ℝ u (ψ r) v) := by
+    filter_upwards [(hψ a).continuousAt.tendsto.eventually hevent] with r hr
+    exact ((hr.differentiableAt (by norm_num)).hasFDerivAt.comp_hasDerivAt r (hψ r)).deriv
+  have hd := ((hu.fderiv_right (m := 1) (by norm_num)).differentiableAt (by norm_num)).hasFDerivAt
+  have hc := (hd.comp_hasDerivAt a (hψ a)).clm_apply (hasDerivAt_const a v)
+  have hv : deriv (fun r => fderiv ℝ u (ψ r) v) a=fderiv ℝ (fderiv ℝ u) (ψ a) v v := by
+    simpa only [Function.comp_apply,map_zero,add_zero] using hc.deriv
+  rw [show (2:ℕ)=1+1 from rfl,iteratedDeriv_succ,iteratedDeriv_one,he.deriv_eq,hv]
+
+lemma planarGenerator_complex_eq (u : ℂ → ℝ) (z : ℝ×ℝ)
+    (hu : ContDiffAt ℝ 2 u (Complex.equivRealProdCLM.symm z)) :
+    planarGenerator (u ∘ Complex.equivRealProdCLM.symm) z=
+      (1/2:ℝ)*(Δ u) (Complex.equivRealProdCLM.symm z) := by
+  have hx : ∀ r : ℝ, HasDerivAt (fun x : ℝ => (x:ℂ)+(z.2:ℂ)*I) 1 r := by
+    intro r
+    simpa only [Complex.ofRealCLM_apply,Complex.ofReal_one] using
+      (Complex.ofRealCLM.hasDerivAt (x := r)).add_const ((z.2:ℂ)*I)
+  have hy : ∀ r : ℝ, HasDerivAt (fun y : ℝ => (z.1:ℂ)+(y:ℂ)*I) I r := by
+    intro r
+    simpa only [Complex.ofRealCLM_apply,Complex.ofReal_one,one_mul] using
+      ((Complex.ofRealCLM.hasDerivAt (x := r)).mul_const I).const_add (z.1:ℂ)
+  have hu' : ContDiffAt ℝ 2 u ((z.1:ℂ)+(z.2:ℂ)*I) := by
+    simpa only [Complex.equivRealProdCLM_symm_apply] using hu
+  have hxr := second_derivative_constant_curve (ψ := fun x : ℝ => (x:ℂ)+(z.2:ℂ)*I)
+    (a := z.1) hu' hx
+  have hyr := second_derivative_constant_curve (ψ := fun y : ℝ => (z.1:ℂ)+(y:ℂ)*I)
+    (a := z.2) hu' hy
+  simp only [Function.comp_apply,Complex.equivRealProdCLM_symm_apply,planarGenerator]
+  rw [hxr,hyr]
+  congr 1
+  simp only [laplacian_eq_iteratedFDeriv_complexPlane,iteratedFDeriv_two_apply,
+    Fin.isValue,Matrix.cons_val_zero,Matrix.cons_val_one,Matrix.cons_val_fin_one]
+
+lemma planarGenerator_harmonicAt (u : ℂ → ℝ) (z : ℝ×ℝ)
+    (hu : HarmonicAt u (Complex.equivRealProdCLM.symm z)) :
+    planarGenerator (u ∘ Complex.equivRealProdCLM.symm) z=0 := by
+  rw [planarGenerator_complex_eq u z hu.1]
+  simp only [hu.2.self_of_nhds,Pi.zero_apply,mul_zero]
+
+end SLEExactGauge
+
+end
+
+end OAI
diff --git a/lean/OAI/Probability/SLE/Geometry/ComplexJordanExtension.lean b/lean/OAI/Probability/SLE/Geometry/ComplexJordanExtension.lean
new file mode 100644
index 0000000000000000000000000000000000000000..0a6b25cacd58c8757f2d8aa7141534004eeb9946
--- /dev/null
+++ b/lean/OAI/Probability/SLE/Geometry/ComplexJordanExtension.lean
@@ -0,0 +1,61 @@
+import Schoenflies.JordanSchoenflies
+
+namespace OAI
+
+/-! Complex-coordinate application of the relative Schönflies theorem.
+The prescribed boundary homeomorphism is retained pointwise. -/
+noncomputable section
+open Set
+
+namespace SLEExactGauge
+
+def complexPlaneCoordinates : ℂ ≃ₜ Schoenflies.Plane where
+  toFun z := !₂[z.re,z.im]
+  invFun v := ⟨v 0,v 1⟩
+  left_inv _ := rfl
+  right_inv v := by
+    ext i
+    fin_cases i <;> rfl
+  continuous_toFun := by
+    apply (PiLp.continuous_toLp _ _).comp
+    apply continuous_pi
+    intro i
+    fin_cases i
+    · exact Complex.continuous_re
+    · exact Complex.continuous_im
+  continuous_invFun := by
+    have hc : Continuous (fun v : Schoenflies.Plane =>
+        (v 0 : ℂ)+(v 1 : ℂ)*Complex.I) := by fun_prop
+    convert hc using 1
+    funext v
+    apply Complex.ext <;> simp
+
+lemma complexPlaneCoordinates_isArcBetween
+    (p : ℝ → ℂ) (hc : ContinuousOn p (Icc 0 1)) (hi : InjOn p (Icc 0 1)) :
+    Schoenflies.IsArcBetween (complexPlaneCoordinates '' (p '' Icc 0 1))
+      (complexPlaneCoordinates (p 0)) (complexPlaneCoordinates (p 1)) := by
+  refine ⟨complexPlaneCoordinates ∘ p,
+    complexPlaneCoordinates.continuous.comp_continuousOn hc,
+    (complexPlaneCoordinates.injective.injOn).comp hi (mapsTo_image p _),?_,rfl,rfl⟩
+  rw [image_image]
+  rfl
+
+theorem complex_jordan_extension {C D : Set ℂ}
+    (hC : Schoenflies.IsJordanCurve (complexPlaneCoordinates '' C))
+    (hD : Schoenflies.IsJordanCurve (complexPlaneCoordinates '' D))
+    (e : C ≃ₜ D) :
+    ∃ H : ℂ ≃ₜ ℂ, ∀ z : C, H z=e z := by
+  let ec := ((complexPlaneCoordinates.image C).symm.trans e).trans
+    (complexPlaneCoordinates.image D)
+  obtain ⟨F,hF⟩ := Schoenflies.jordan_schoenflies_of_homeomorph hC hD ec
+  refine ⟨(complexPlaneCoordinates.trans F).trans complexPlaneCoordinates.symm,?_⟩
+  intro z
+  apply complexPlaneCoordinates.injective
+  have hh := hF ((complexPlaneCoordinates.image C) z)
+  simpa [ec] using hh
+
+end SLEExactGauge
+
+end
+
+end OAI
diff --git a/lean/OAI/Probability/SLE/Geometry/ComplexJordanRegions.lean b/lean/OAI/Probability/SLE/Geometry/ComplexJordanRegions.lean
new file mode 100644
index 0000000000000000000000000000000000000000..bdfcd338ec622e108140f167f7ecbe6d491e8ab3
--- /dev/null
+++ b/lean/OAI/Probability/SLE/Geometry/ComplexJordanRegions.lean
@@ -0,0 +1,60 @@
+import OAI.Probability.SLE.Geometry.SchoenfliesInsideTransport
+
+namespace OAI
+
+/-! The bounded Jordan region in the complex coordinate chart. -/
+noncomputable section
+open Set
+
+namespace SLEExactGauge
+
+def complexInside (C : Set ℂ) : Set ℂ :=
+  complexPlaneCoordinates ⁻¹' Schoenflies.inside (complexPlaneCoordinates '' C)
+
+theorem complexInside_image (C : Set ℂ) :
+    complexPlaneCoordinates '' complexInside C =
+      Schoenflies.inside (complexPlaneCoordinates '' C) :=
+  image_preimage_eq _ complexPlaneCoordinates.surjective
+
+theorem complexInside_transport (h : ℂ ≃ₜ ℂ) (C : Set ℂ) :
+    h '' complexInside C=complexInside (h '' C) := by
+  let H := (complexPlaneCoordinates.symm.trans h).trans complexPlaneCoordinates
+  have he : H '' (complexPlaneCoordinates '' C)=complexPlaneCoordinates '' (h '' C) := by
+    ext x
+    simp [H]
+  apply complexPlaneCoordinates.injective.image_injective
+  rw [complexInside_image]
+  have hm : complexPlaneCoordinates '' (h '' complexInside C)=
+      H '' (complexPlaneCoordinates '' complexInside C) := by
+    ext x
+    simp [H]
+  rw [hm,complexInside_image,plane_homeomorph_inside,he]
+
+theorem complexInside_eq_open {C U : Set ℂ}
+    (hC : Schoenflies.IsJordanCurve (complexPlaneCoordinates '' C))
+    (hU : IsOpen U) (hconn : IsPreconnected U) (hne : U.Nonempty)
+    (hb : Bornology.IsBounded U) (hfront : frontier U=C) : complexInside C=U := by
+  apply complexPlaneCoordinates.injective.image_injective
+  rw [complexInside_image]
+  apply separating_inside_eq_open (Schoenflies.jordan_curve_theorem hC)
+    (complexPlaneCoordinates.isOpen_image.mpr hU)
+    (hconn.image _ complexPlaneCoordinates.continuous.continuousOn)
+    (hne.image _) ?_ ?_
+  · exact (hb.isCompact_closure.image complexPlaneCoordinates.continuous).isBounded.subset
+      (image_mono subset_closure)
+  · rw [← complexPlaneCoordinates.image_frontier,hfront]
+
+theorem complexInside_closure {C : Set ℂ}
+    (hC : Schoenflies.IsJordanCurve (complexPlaneCoordinates '' C)) :
+    closure (complexInside C)=complexInside C ∪ C := by
+  apply complexPlaneCoordinates.injective.image_injective
+  rw [complexPlaneCoordinates.image_closure,complexInside_image,image_union,
+    complexInside_image]
+  exact (Schoenflies.IsRegionOf.inside _).closure_eq
+    (Schoenflies.jordan_curve_theorem hC)
+
+end SLEExactGauge
+
+end
+
+end OAI
diff --git a/lean/OAI/Probability/SLE/Geometry/ComplexLipschitzExtension.lean b/lean/OAI/Probability/SLE/Geometry/ComplexLipschitzExtension.lean
new file mode 100644
index 0000000000000000000000000000000000000000..62e27cafb5cb439806a74de9efeee22e7f0a1c75
--- /dev/null
+++ b/lean/OAI/Probability/SLE/Geometry/ComplexLipschitzExtension.lean
@@ -0,0 +1,42 @@
+import Mathlib
+
+namespace OAI
+
+/-! A continuous extension of a complex Lipschitz map from a time set.
+The coordinatewise real extensions suffice for the raw flow endpoint. -/
+noncomputable section
+open Set Metric Complex
+open scoped Topology NNReal
+
+namespace SLEExactGauge
+
+lemma exists_continuous_complex_extension {S : Set ℝ} {K : ℝ≥0}
+    (f : ℝ → ℂ) (hf : LipschitzOnWith K f S) :
+    ∃ g : ℝ → ℂ, Continuous g ∧ EqOn g f S := by
+  have hre : LipschitzOnWith K (fun t => (f t).re) S := by
+    apply LipschitzOnWith.of_dist_le_mul
+    intro x hx y hy
+    calc
+      dist (f x).re (f y).re = |(f x-f y).re| := by simp [Real.dist_eq]
+      _ ≤ ‖f x-f y‖ := Complex.abs_re_le_norm _
+      _ ≤ K*dist x y := by simpa only [dist_eq_norm] using hf.dist_le_mul x hx y hy
+  have him : LipschitzOnWith K (fun t => (f t).im) S := by
+    apply LipschitzOnWith.of_dist_le_mul
+    intro x hx y hy
+    calc
+      dist (f x).im (f y).im = |(f x-f y).im| := by simp [Real.dist_eq]
+      _ ≤ ‖f x-f y‖ := Complex.abs_im_le_norm _
+      _ ≤ K*dist x y := by simpa only [dist_eq_norm] using hf.dist_le_mul x hx y hy
+  obtain ⟨r,hr,her⟩ := hre.extend_real
+  obtain ⟨i,hi,hei⟩ := him.extend_real
+  let g (t : ℝ) : ℂ := (r t : ℂ)+(i t : ℂ)*I
+  refine ⟨g,(Complex.continuous_ofReal.comp hr.continuous).add
+    ((Complex.continuous_ofReal.comp hi.continuous).mul continuous_const),?_⟩
+  intro t ht
+  apply Complex.ext <;> simp [g,← her ht,← hei ht]
+
+end SLEExactGauge
+
+end
+
+end OAI
diff --git a/lean/OAI/Probability/SLE/Geometry/ConcatenatedSlitGeometry.lean b/lean/OAI/Probability/SLE/Geometry/ConcatenatedSlitGeometry.lean
new file mode 100644
index 0000000000000000000000000000000000000000..c378d26eaf27b58e3f0157437bb9169906c9d8f8
--- /dev/null
+++ b/lean/OAI/Probability/SLE/Geometry/ConcatenatedSlitGeometry.lean
@@ -0,0 +1,104 @@
+import OAI.Probability.SLE.Geometry.FiniteSimpleSlit
+import OAI.Probability.SLE.Geometry.PublishedFiniteBoundaryExtension
+
+namespace OAI
+
+/-! Geometric concatenation of an old simple slit and a fresh simple slit
+through its inverse chart. The resulting curve has no extra filled components. -/
+noncomputable section
+open Set Filter Complex
+open scoped Topology NNReal
+
+namespace SLEExactGauge
+
+def concatenateSlit (T : ℝ≥0) (β η : ℝ≥0 → ℂ) (F : ℂ → ℂ) (u : ℝ)
+    (t : ℝ≥0) : ℂ := if t ≤ T then β t else F ((u:ℂ)+η (t-T))
+
+lemma continuous_concatenateSlit
+    (T : ℝ≥0) (β η : ℝ≥0 → ℂ) (F : ℂ → ℂ) (u : ℝ)
+    (hβ : Continuous β) (hη : Continuous η) (hη0 : η 0=0)
+    (hηH : ∀ t, 0 ≤ (η t).im) (hF : ContinuousOn F closedHalfPlane)
+    (hF0 : F (u:ℂ)=β T) : Continuous (concatenateSlit T β η F u) := by
+  have hc : Continuous (fun t : ℝ≥0 => F ((u:ℂ)+η (t-T))) := by
+    apply hF.comp_continuous (continuous_const.add (hη.comp (continuous_id.sub continuous_const)))
+    intro t
+    change 0 ≤ ((u:ℂ)+η (t-T)).im
+    simpa only [closedHalfPlane,mem_ofPred_eq,Complex.add_im,Complex.ofReal_im,zero_add] using hηH (t-T)
+  change Continuous ((Iic T).piecewise β (fun t => F ((u:ℂ)+η (t-T))))
+  apply Continuous.piecewise _ hβ hc
+  intro t ht
+  have he : t=T := by simpa only [frontier_Iic,mem_singleton_iff] using ht
+  simp only [he,tsub_self,hη0,add_zero,hF0]
+
+lemma concatenateSlit_injective
+    (T : ℝ≥0) (β η : ℝ≥0 → ℂ) (F : ℂ → ℂ) (u : ℝ)
+    (hβ : InjOn β (Icc 0 T)) (hη : Function.Injective η)
+    (hηH : ∀ t, 0 < t → η t ∈ upperHalfPlane)
+    (hF : InjOn F upperHalfPlane)
+    (himage : MapsTo F upperHalfPlane (survivingDomain β T)) :
+    Function.Injective (concatenateSlit T β η F u) := by
+  have hnew (t : ℝ≥0) (ht : T < t) : (u:ℂ)+η (t-T) ∈ upperHalfPlane := by
+    simpa only [upperHalfPlane,mem_ofPred_eq,Complex.add_im,Complex.ofReal_im,zero_add] using
+      hηH (t-T) (tsub_pos_iff_lt.mpr ht)
+  intro s t he
+  by_cases hs : s ≤ T
+  · by_cases ht : t ≤ T
+    · exact hβ ⟨zero_le,hs⟩ ⟨zero_le,ht⟩ (by simpa only [concatenateSlit,ite_eq_left hs,ite_eq_left ht] using he)
+    · have him := himage (hnew t (lt_of_not_ge ht))
+      apply False.elim
+      apply him.1.2
+      refine ⟨s,⟨zero_le,hs⟩,?_⟩
+      simpa only [concatenateSlit,ite_eq_left hs,ite_eq_right ht] using he
+  · by_cases ht : t ≤ T
+    · have him := himage (hnew s (lt_of_not_ge hs))
+      apply False.elim
+      apply him.1.2
+      refine ⟨t,⟨zero_le,ht⟩,?_⟩
+      simpa only [concatenateSlit,ite_eq_right hs,ite_eq_left ht] using he.symm
+    · have hst := hF (hnew s (lt_of_not_ge hs)) (hnew t (lt_of_not_ge ht))
+        (by simpa only [concatenateSlit,ite_eq_right hs,ite_eq_right ht] using he)
+      have heη := hη (add_left_cancel hst)
+      exact (tsub_left_inj (le_of_not_ge hs) (le_of_not_ge ht)).mp heη
+
+lemma concatenateSlit_positive
+    (T : ℝ≥0) (β η : ℝ≥0 → ℂ) (F : ℂ → ℂ) (u : ℝ)
+    (hβ : ∀ t, 0 < t → β t ∈ upperHalfPlane)
+    (hη : ∀ t, 0 < t → η t ∈ upperHalfPlane)
+    (hF : MapsTo F upperHalfPlane upperHalfPlane)
+    (t : ℝ≥0) (ht : 0 < t) : concatenateSlit T β η F u t ∈ upperHalfPlane := by
+  by_cases h : t ≤ T
+  · simpa only [concatenateSlit,ite_eq_left h] using hβ t ht
+  · rw [concatenateSlit,ite_eq_right h]
+    apply hF
+    simpa only [upperHalfPlane,mem_ofPred_eq,Complex.add_im,Complex.ofReal_im,zero_add] using
+      hη (t-T) (tsub_pos_iff_lt.mpr (lt_of_not_ge h))
+
+theorem concatenateSlit_free_complement
+    (T : ℝ≥0) (β η : ℝ≥0 → ℂ) (F : ℂ → ℂ) (u : ℝ)
+    (hβc : Continuous β) (hηc : Continuous η) (hβ0 : β 0=0) (hη0 : η 0=0)
+    (hβi : InjOn β (Icc 0 T)) (hηi : Function.Injective η)
+    (hβH : ∀ t, 0 < t → β t ∈ upperHalfPlane)
+    (hηH : ∀ t, 0 < t → η t ∈ upperHalfPlane)
+    (hFc : ContinuousOn F closedHalfPlane) (hF0 : F (u:ℂ)=β T)
+    (hFi : InjOn F upperHalfPlane)
+    (hFmap : MapsTo F upperHalfPlane (survivingDomain β T))
+    (S : ℝ≥0) (hS : 0 < S) :
+    upperHalfPlane \ ((concatenateSlit T β η F u) '' Icc 0 S) ⊆
+      survivingDomain (concatenateSlit T β η F u) S := by
+  have hηclosed (t : ℝ≥0) : 0 ≤ (η t).im := by
+    by_cases ht : t=0
+    · simp [ht,hη0]
+    · exact (hηH t (pos_iff_ne_zero.mpr ht)).le
+  apply finite_simple_slit_free _
+    (continuous_concatenateSlit T β η F u hβc hηc hη0 hηclosed hFc hF0)
+    (by simp only [concatenateSlit,ite_eq_left (show (0:ℝ≥0) ≤ T from zero_le),hβ0]) S hS
+    (concatenateSlit_injective T β η F u hβi hηi hηH hFi hFmap).injOn
+  intro t ht
+  exact concatenateSlit_positive T β η F u hβH hηH
+    (fun z hz => (hFmap hz).1.1) t ht.1
+
+end SLEExactGauge
+
+end
+
+end OAI
diff --git a/lean/OAI/Probability/SLE/Geometry/ConditionalStopExtension.lean b/lean/OAI/Probability/SLE/Geometry/ConditionalStopExtension.lean
new file mode 100644
index 0000000000000000000000000000000000000000..ddcd743282b194a36a9fa2b75d86e2318301d64e
--- /dev/null
+++ b/lean/OAI/Probability/SLE/Geometry/ConditionalStopExtension.lean
@@ -0,0 +1,63 @@
+import OAI.Probability.SLE.Gauge.ExtendedExperimentStop
+
+namespace OAI
+
+/-! A conditional estimate at finite stopping times extends unchanged to
+a stopping time finite almost surely on its admissible stopped-past event.
+The geometric state is evaluated only on that event. -/
+
+noncomputable section
+open Set Filter MeasureTheory ProbabilityTheory
+open scoped Topology NNReal ENNReal
+
+namespace SLEExactGauge
+
+theorem conditional_event_bound_at_extended_stop
+    {Ω : Type*} [mΩ : MeasurableSpace Ω] (Q : Measure Ω)
+    (ℱ : Filtration ℝ≥0 mΩ) (p : ℝ≥0∞) (S : Set Ω)
+    (state : Ω → ℝ≥0 → Prop)
+    (hfiniteStep : ∀ (τ : Ω → ℝ≥0)
+      (hτ : IsStoppingTime ℱ (fun ω => (τ ω : WithTop ℝ≥0)))
+      (E : Set Ω), MeasurableSet[hτ.measurableSpace] E →
+      (∀ ω ∈ E, state ω (τ ω)) → p * Q E ≤ Q (E ∩ S))
+    (σ : Ω → WithTop ℝ≥0) (hσ : IsStoppingTime ℱ σ)
+    (E : Set Ω) (hE : MeasurableSet[hσ.measurableSpace] E)
+    (hfinite : ∀ᵐ ω ∂Q, ω ∈ E → σ ω ≠ ⊤)
+    (hstate : ∀ ω ∈ E, state ω ((σ ω).untopD 0)) :
+    p * Q E ≤ Q (E ∩ S) := by
+  let Eₙ (n : ℕ) := E ∩ {ω | σ ω ≤ ((n : ℝ≥0) : WithTop ℝ≥0)}
+  have hmono : Monotone Eₙ := by
+    intro n k hnk ω hω
+    refine ⟨hω.1, ?_⟩
+    change σ ω ≤ ((k : ℝ≥0) : WithTop ℝ≥0)
+    exact hω.2.trans (WithTop.coe_le_coe.mpr (by exact_mod_cast hnk))
+  have hcover : E =ᵐ[Q] ⋃ n, Eₙ n := by
+    filter_upwards [hfinite] with ω hω
+    apply propext
+    constructor
+    · intro hωE
+      lift σ ω to ℝ≥0 using hω hωE with t ht
+      obtain ⟨n, hn⟩ := exists_nat_ge (t : ℝ)
+      exact mem_iUnion.mpr ⟨n, hωE, 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 hlocal (n : ℕ) : p * Q (Eₙ n) ≤ Q (E ∩ S) := by
+    have h := hfiniteStep (cutoffStop σ n) (cutoffStop_stopping ℱ σ hσ n) (Eₙ n)
+      (cutoffStop_success_measurable ℱ σ hσ n E hE) (fun ω hω => ?_)
+    · exact h.trans (measure_mono (inter_subset_inter inter_subset_left subset_rfl))
+    · rw [cutoffStop_eq_on_success σ n ω hω.2]
+      exact hstate ω hω.1
+  calc
+    _ = p * Q (⋃ n, Eₙ n) := by rw [measure_congr hcover]
+    _ = ⨆ n, p * Q (Eₙ n) := by rw [hmono.measure_iUnion, ENNReal.mul_iSup]
+    _ ≤ _ := iSup_le hlocal
+
+end SLEExactGauge
+
+end
+
+end OAI
diff --git a/lean/OAI/Probability/SLE/Geometry/ConformalDiskExit.lean b/lean/OAI/Probability/SLE/Geometry/ConformalDiskExit.lean
new file mode 100644
index 0000000000000000000000000000000000000000..9881525d4471afd5f82f0592fe25124874072475
--- /dev/null
+++ b/lean/OAI/Probability/SLE/Geometry/ConformalDiskExit.lean
@@ -0,0 +1,62 @@
+import OAI.Probability.SLE.Geometry.HolomorphicExitLimit
+
+namespace OAI
+
+/-! At a finite physical exit the limit of a conformal disk chart is on
+the unit circle. Only continuity of the inverse inside the disk is used. -/
+noncomputable section
+open Set Filter MeasureTheory ProbabilityTheory Metric
+open scoped Topology NNReal ENNReal
+
+namespace SLEExactGauge
+open Target
+
+lemma disk_exit_limit_norm {D : Set ℂ} {F H : ℂ → ℂ}
+    (hF : MapsTo F D (ball 0 1)) (hH : ContinuousOn H (ball 0 1))
+    (hHD : MapsTo H (ball 0 1) D) (hinv : ∀ z∈D, H (F z)=z)
+    (ζ : ℝ≥0 → ℂ) (hζ : Continuous ζ) (τ : ℝ≥0) (hτ : 0 < τ)
+    (hpath : ∀ t<τ, ζ t∈D) (hexit : ζ τ∉D) (c : ℂ)
+    (hc : Tendsto (fun t => F (ζ t)) (𝓝[<] τ) (𝓝 c)) : ‖c‖=1 := by
+  let : NeBot (𝓝[<] τ) := nhdsLT_neBot_of_exists_lt ⟨0,hτ⟩
+  have hmem : ∀ᶠ t in 𝓝[<] τ, ζ t∈D :=
+    (show ∀ᶠ t in 𝓝[<] τ, t<τ from self_mem_nhdsWithin).mono hpath
+  have hle : ‖c‖ ≤ 1 := le_of_tendsto hc.norm (hmem.mono fun t ht =>
+    (mem_ball_zero_iff.mp (hF ht)).le)
+  apply le_antisymm hle
+  apply not_lt.mp
+  intro hlt
+  have hcb : c∈ball (0:ℂ) 1 := mem_ball_zero_iff.mpr hlt
+  have hHlim := ((hH c hcb).continuousAt (isOpen_ball.mem_nhds hcb)).tendsto.comp hc
+  have hsame : Tendsto ζ (𝓝[<] τ) (𝓝 (H c)) :=
+    hHlim.congr' (hmem.mono fun t ht => hinv (ζ t) ht)
+  have hid : H c=ζ τ := tendsto_nhds_unique hsame
+    (hζ.continuousAt.tendsto.mono_left nhdsWithin_le_nhds)
+  exact hexit (hid ▸ hHD hcb)
+
+theorem conformal_disk_finite_exit_limit
+    (W : WienerLaw) (hW : IsWiener W) {D : Set ℂ} (hD : IsOpen D)
+    (w : ℂ) (hw : w∈D) {F H : ℂ → ℂ}
+    (hFhol : DifferentiableOn ℂ F D) (hF : MapsTo F D (ball 0 1))
+    (hH : ContinuousOn H (ball 0 1)) (hHD : MapsTo H (ball 0 1) D)
+    (hinv : ∀ z∈D, H (F z)=z) (T : ℝ≥0) :
+    ∀ᵐ b ∂W.prod W, ∀ τ : ℝ≥0, 0 < τ → τ ≤ T →
+      (∀ t<τ, w+Complex.equivRealProdCLM.symm (planarWiener t b)∈D) →
+      w+Complex.equivRealProdCLM.symm (planarWiener τ b)∉D →
+      ∃ c : ℂ, ‖c‖=1 ∧
+        Tendsto (fun t => F (w+Complex.equivRealProdCLM.symm (planarWiener t b)))
+          (𝓝[<] τ) (𝓝 c) := by
+  have hb := holomorphic_domain_exit_limit W hW hD w hw hFhol T 1
+    (fun z hz => (mem_ball_zero_iff.mp (hF hz)).le)
+  filter_upwards [hb] with b hb
+  intro τ hτ hτT hp hx
+  obtain ⟨c,hc⟩ := hb τ hτT hp hx
+  refine ⟨c,?_,hc⟩
+  exact disk_exit_limit_norm hF hH hHD hinv _
+    (continuous_const.add (Complex.equivRealProdCLM.symm.continuous.comp (planarWiener_continuous b)))
+    τ hτ hp hx c hc
+
+end SLEExactGauge
+
+end
+
+end OAI
diff --git a/lean/OAI/Probability/SLE/Geometry/ConformalLaplacian.lean b/lean/OAI/Probability/SLE/Geometry/ConformalLaplacian.lean
new file mode 100644
index 0000000000000000000000000000000000000000..46dab310903ebd7db5a248a8b1f6b6a5e50bda56
--- /dev/null
+++ b/lean/OAI/Probability/SLE/Geometry/ConformalLaplacian.lean
@@ -0,0 +1,66 @@
+import OAI.Probability.SLE.RadiusClocks
+import Mathlib.Analysis.InnerProductSpace.Harmonic.Constructions
+
+namespace OAI
+
+/-! The real Laplacian transforms by the squared complex derivative.
+This is the change-of-variables identity used for the exterior area proof. -/
+noncomputable section
+open Set Filter Metric Function Complex InnerProductSpace
+open scoped Topology Laplacian
+
+namespace SLEExactGauge
+
+lemma complex_composition_hessian {f : ℂ → ℂ} {u : ℂ → ℝ} {z : ℂ}
+    (hf : ContDiffAt ℝ 2 f z) (hu : ContDiffAt ℝ 2 u (f z)) (v : ℂ) :
+    fderiv ℝ (fderiv ℝ (u ∘ f)) z v v =
+      fderiv ℝ (fderiv ℝ u) (f z) (fderiv ℝ f z v) (fderiv ℝ f z v)+
+      fderiv ℝ u (f z) (fderiv ℝ (fderiv ℝ f) z v v) := by
+  have hf1 : DifferentiableAt ℝ f z := hf.differentiableAt (by norm_num)
+  have hf2 : DifferentiableAt ℝ (fderiv ℝ f) z := (hf.fderiv_right (m := 1) (by norm_num)).differentiableAt (by norm_num)
+  have hu2 : DifferentiableAt ℝ (fderiv ℝ u) (f z) := (hu.fderiv_right (m := 1) (by norm_num)).differentiableAt (by norm_num)
+  have hc := (hu2.hasFDerivAt.comp z hf1.hasFDerivAt).clm_comp hf2.hasFDerivAt
+  have he : fderiv ℝ (u ∘ f) =ᶠ[𝓝 z]
+      (fun a => (fderiv ℝ u (f a)).comp (fderiv ℝ f a)) := by
+    filter_upwards [hf.eventually (by norm_num),
+      hf1.continuousAt.tendsto.eventually (hu.eventually (by norm_num))] with a hfa hua
+    exact fderiv_comp a (hua.differentiableAt (by norm_num)) (hfa.differentiableAt (by norm_num))
+  have hd := hc.congr_of_eventuallyEq he
+  rw [hd.fderiv]
+  simp only [add_apply,ContinuousLinearMap.comp_apply,
+    ContinuousLinearMap.compL_apply,ContinuousLinearMap.flip_apply,Function.comp_apply]
+  ring
+
+lemma complex_fderiv_apply {f : ℂ → ℂ} {z : ℂ} (hf : DifferentiableAt ℂ f z) (v : ℂ) :
+    fderiv ℝ f z v=v*deriv f z := by
+  rw [hf.hasDerivAt.hasFDerivAt.restrictScalars ℝ |>.fderiv]
+  simp only [ContinuousLinearMap.coe_restrictScalars',ContinuousLinearMap.toSpanSingleton_apply,smul_eq_mul]
+
+lemma laplacian_holomorphic_comp {f : ℂ → ℂ} {u : ℂ → ℝ} {z : ℂ}
+    (hf : AnalyticAt ℂ f z) (hu : ContDiffAt ℝ 2 u (f z)) :
+    (Δ (u ∘ f)) z=‖deriv f z‖^2*(Δ u) (f z) := by
+  have hfR : ContDiffAt ℝ 2 f z := hf.contDiffAt.restrict_scalars ℝ
+  have he0 : fderiv ℝ (fderiv ℝ f) z 1 1+fderiv ℝ (fderiv ℝ f) z I I=0 := by
+    have hh := hf.harmonicAt.2.self_of_nhds
+    simpa only [laplacian_eq_iteratedFDeriv_complexPlane,iteratedFDeriv_two_apply,
+      Fin.isValue,Matrix.cons_val_zero,Matrix.cons_val_one,Matrix.cons_val_fin_one,Pi.zero_apply] using hh
+  have hh := complex_hessian_rotation (u := u) (f z) (deriv f z)
+  rw [laplacian_eq_iteratedFDeriv_complexPlane]
+  simp only [iteratedFDeriv_two_apply,Fin.isValue,Matrix.cons_val_zero,Matrix.cons_val_one,
+    Matrix.cons_val_fin_one]
+  rw [complex_composition_hessian hfR hu 1,complex_composition_hessian hfR hu I,
+    complex_fderiv_apply hf.differentiableAt,complex_fderiv_apply hf.differentiableAt,one_mul]
+  calc
+    _ = (fderiv ℝ (fderiv ℝ u) (f z) (deriv f z) (deriv f z)+
+        fderiv ℝ (fderiv ℝ u) (f z) (deriv f z*I) (deriv f z*I))+
+        fderiv ℝ u (f z) (fderiv ℝ (fderiv ℝ f) z 1 1+fderiv ℝ (fderiv ℝ f) z I I) := by
+      rw [map_add]
+      simp only [mul_comm I]
+      ring
+    _ = _ := by rw [he0,map_zero,add_zero,hh]
+
+end SLEExactGauge
+
+end
+
+end OAI
diff --git a/lean/OAI/Probability/SLE/Geometry/ConformalLaplacianIntegral.lean b/lean/OAI/Probability/SLE/Geometry/ConformalLaplacianIntegral.lean
new file mode 100644
index 0000000000000000000000000000000000000000..d723467ccf28b060167fd30293fc27272ca7468b
--- /dev/null
+++ b/lean/OAI/Probability/SLE/Geometry/ConformalLaplacianIntegral.lean
@@ -0,0 +1,61 @@
+import OAI.Probability.SLE.Geometry.ExteriorLaplacianTest
+import OAI.Probability.SLE.Gauge.ConformalSausageTransfer
+
+namespace OAI
+
+/-! Change of variables for the Laplacian of a smooth real test under
+an injective holomorphic map. -/
+noncomputable section
+open Set Filter Metric Function MeasureTheory InnerProductSpace
+open scoped Topology Laplacian
+
+namespace SLEExactGauge
+
+lemma integral_laplacian_holomorphic_image {D : Set ℂ} (hD : IsOpen D)
+    {f : ℂ → ℂ} (hf : DifferentiableOn ℂ f D) (hi : InjOn f D)
+    {u : ℂ → ℝ} (hu : ContDiff ℝ 2 u) :
+    (∫ z in f '' D, (Δ u) z)=(∫ z in D, (Δ (u ∘ f)) z) := by
+  have hd (z : ℂ) (hz : z∈D) : HasDerivAt f (deriv f z) z :=
+    (hf.differentiableAt (hD.mem_nhds hz)).hasDerivAt
+  rw [integral_image_eq_integral_abs_det_fderiv_smul volume hD.measurableSet
+    (fun z hz => ((hd z hz).hasFDerivAt.restrictScalars ℝ).hasFDerivWithinAt) hi]
+  apply setIntegral_congr_fun hD.measurableSet
+  intro z hz
+  dsimp only
+  rw [complex_derivative_real_det,abs_of_nonneg (sq_nonneg _),smul_eq_mul]
+  exact (laplacian_holomorphic_comp (hf.analyticAt (hD.mem_nhds hz)) hu.contDiffAt).symm
+
+lemma integrableOn_laplacian_holomorphic_comp {D : Set ℂ} (hD : IsOpen D)
+    {f : ℂ → ℂ} (hf : DifferentiableOn ℂ f D) (hi : InjOn f D)
+    {u : ℂ → ℝ} (hu : ContDiff ℝ 2 u) (hs : HasCompactSupport u) :
+    IntegrableOn (Δ (u ∘ f)) D := by
+  have hd (z : ℂ) (hz : z∈D) : HasDerivAt f (deriv f z) z :=
+    (hf.differentiableAt (hD.mem_nhds hz)).hasDerivAt
+  have hc : Continuous (Δ u) :=
+    continuous_iff_continuousAt.mpr (fun z => plane_laplacian_continuousAt (hu.contDiffAt (x := z)))
+  have hsu := hasCompactSupport_laplacian hs
+  have hint := (integrableOn_image_iff_integrableOn_abs_det_fderiv_smul volume hD.measurableSet
+    (fun z hz => ((hd z hz).hasFDerivAt.restrictScalars ℝ).hasFDerivWithinAt) hi (Δ u)).mp
+      ((hc.integrable_of_hasCompactSupport hsu).integrableOn)
+  apply hint.congr_fun _ hD.measurableSet
+  intro z hz
+  dsimp only
+  rw [complex_derivative_real_det,abs_of_nonneg (sq_nonneg _),smul_eq_mul]
+  exact (laplacian_holomorphic_comp (hf.analyticAt (hD.mem_nhds hz)) hu.contDiffAt).symm
+
+lemma exterior_compact_test_laplacian_nonpos {D : Set ℂ} (hD : IsOpen D)
+    {f : ℂ → ℂ} (hf : DifferentiableOn ℂ f D) (hi : InjOn f D)
+    (hK : IsCompact (f '' D)ᶜ) :
+    ∃ u : ℂ → ℝ, ContDiff ℝ 2 u ∧ HasCompactSupport u ∧
+      (∀ z∈(f '' D)ᶜ, u =ᶠ[𝓝 z] (fun w => ‖w‖^2)) ∧
+      IntegrableOn (Δ (u ∘ f)) D ∧ (∫ z in D, (Δ (u ∘ f)) z)≤0 := by
+  obtain ⟨u,hu,hs,he,hn⟩ := compact_quadratic_test_complement_integral _ hK
+  refine ⟨u,hu,hs,he,integrableOn_laplacian_holomorphic_comp hD hf hi hu hs,?_⟩
+  rw [←integral_laplacian_holomorphic_image hD hf hi hu]
+  simpa only [compl_compl] using hn
+
+end SLEExactGauge
+
+end
+
+end OAI
diff --git a/lean/OAI/Probability/SLE/Geometry/ConformalRestartTransport.lean b/lean/OAI/Probability/SLE/Geometry/ConformalRestartTransport.lean
new file mode 100644
index 0000000000000000000000000000000000000000..89265a7f2ea9adebca35a7c207cdcd365c9c2500
--- /dev/null
+++ b/lean/OAI/Probability/SLE/Geometry/ConformalRestartTransport.lean
@@ -0,0 +1,95 @@
+import OAI.Probability.SLE.Mass.CanonicalImageMass
+import OAI.Probability.SLE.Loewner.StoppedInversePaths
+
+namespace OAI
+
+/-! Fixed conformal changes of coordinates preserve restart increments.
+Composition combines the two density weights before pushing forward. -/
+
+noncomputable section
+open Set Filter _root_.MeasureTheory _root_.OAI.MeasureTheory
+open scoped NNReal ENNReal Topology CompactlySupported
+
+namespace SLEExactGauge
+
+local instance conformalRestartLocallyCompact : LocallyCompactSpace upperHalfPlane :=
+  isOpen_upperHalfPlane.locallyCompactSpace
+
+lemma weightedImageMass_comp
+    {X : Type*} [MeasurableSpace X]
+    (J : upperHalfPlane → X) (hJ : Measurable J)
+    (w : upperHalfPlane → ℝ≥0∞) (hw : Measurable w)
+    (F : upperHalfPlane → upperHalfPlane) (hF : Measurable F)
+    (v : upperHalfPlane → ℝ≥0∞) (hv : Measurable v)
+    (η : Measure upperHalfPlane) :
+    weightedImageMass J w (weightedImageMass F v η) =
+      weightedImageMass (J ∘ F) (fun z => v z*w (F z)) η := by
+  classical
+  apply Measure.ext
+  intro A hA
+  rw [weightedImageMass_apply J hJ w _ A hA,
+    weightedImageMass_lintegral F hF v hv η ((J ⁻¹' A).indicator w)
+      (hw.indicator (hJ hA)),
+    weightedImageMass_apply (J ∘ F) (hJ.comp hF) _ η A hA]
+  apply lintegral_congr
+  intro z
+  change v z * (if J (F z) ∈ A then w (F z) else 0) =
+    (if J (F z) ∈ A then v z*w (F z) else 0)
+  split_ifs <;> simp
+
+lemma derivative_dimension_weight_comp
+    (κ : ℝ) (J F : ℂ → ℂ) (z : ℂ)
+    (hJ : DifferentiableAt ℂ J (F z)) (hF : DifferentiableAt ℂ F z) :
+    ENNReal.ofReal (‖deriv F z‖ ^ dimension κ) *
+        ENNReal.ofReal (‖deriv J (F z)‖ ^ dimension κ) =
+      ENNReal.ofReal (‖deriv (J ∘ F) z‖ ^ dimension κ) := by
+  rw [deriv_comp z hJ hF,norm_mul,Real.mul_rpow (norm_nonneg _) (norm_nonneg _),
+    ENNReal.ofReal_mul (Real.rpow_nonneg (norm_nonneg _) _)]
+  exact mul_comm _ _
+
+namespace Multipoint
+
+variable {D : Set ℂ}
+
+lemma conformalMass_sub
+    (J : upperHalfPlane ≃ₜ D) (w : C(upperHalfPlane,ℝ≥0))
+    {μ ν : Measure upperHalfPlane} [IsFiniteMeasureOnCompacts ν] (hle : μ ≤ ν) :
+    conformalMass J w (ν-μ) = conformalMass J w ν-conformalMass J w μ := by
+  let : IsFiniteMeasureOnCompacts μ :=
+    ⟨fun K hK => lt_of_le_of_lt (hle K) hK.measure_lt_top⟩
+  let : IsLocallyFiniteMeasure (μ.withDensity (fun z => (w z : ℝ≥0∞))) :=
+    IsLocallyFiniteMeasure.withDensity_coe w.continuous
+  let : SigmaFinite (conformalMass J w μ) := J.measurableEmbedding.sigmaFinite_map
+  apply (Measure.add_left_inj (conformalMass J w μ) _ _).mp
+  calc
+    conformalMass J w (ν-μ)+conformalMass J w μ = conformalMass J w ν := by
+      rw [← conformalMass_add,sigmaFinite_sub_add_cancel_of_le hle]
+    _ = (conformalMass J w ν-conformalMass J w μ)+conformalMass J w μ :=
+      (sigmaFinite_sub_add_cancel_of_le (conformalMass_mono J w hle)).symm
+
+lemma conformalMass_weightedImageMass
+    (J : upperHalfPlane ≃ₜ D) (w : C(upperHalfPlane,ℝ≥0))
+    (F : upperHalfPlane → upperHalfPlane) (hF : Measurable F)
+    (v : upperHalfPlane → ℝ≥0∞) (hv : Measurable v) (η : Measure upperHalfPlane) :
+    conformalMass J w (weightedImageMass F v η) =
+      weightedImageMass (J ∘ F) (fun z => v z*(w (F z) : ℝ≥0∞)) η :=
+  weightedImageMass_comp J J.continuous.measurable _
+    w.continuous.measurable.coe_nnreal_ennreal F hF v hv η
+
+lemma conformalMass_increment_of_restart
+    (J : upperHalfPlane ≃ₜ D) (w : C(upperHalfPlane,ℝ≥0))
+    {μ ν : Measure upperHalfPlane} [IsFiniteMeasureOnCompacts ν] (hle : μ ≤ ν)
+    (F : upperHalfPlane → upperHalfPlane) (hF : Measurable F)
+    (v : upperHalfPlane → ℝ≥0∞) (hv : Measurable v) (η : Measure upperHalfPlane)
+    (hrestart : ν-μ = weightedImageMass F v η) :
+    conformalMass J w ν-conformalMass J w μ =
+      weightedImageMass (J ∘ F) (fun z => v z*(w (F z) : ℝ≥0∞)) η := by
+  rw [← conformalMass_sub J w hle,hrestart]
+  exact conformalMass_weightedImageMass J w F hF v hv η
+
+end Multipoint
+end SLEExactGauge
+
+end
+
+end OAI
diff --git a/lean/OAI/Probability/SLE/Geometry/ConjugateInversionChart.lean b/lean/OAI/Probability/SLE/Geometry/ConjugateInversionChart.lean
new file mode 100644
index 0000000000000000000000000000000000000000..321c3f600e476a46a3cb4447ea24f41370348217
--- /dev/null
+++ b/lean/OAI/Probability/SLE/Geometry/ConjugateInversionChart.lean
@@ -0,0 +1,51 @@
+import OAI.Probability.SLE.Geometry.ReflectedInvertedUpperConnected
+import OAI.Probability.SLE.Geometry.ExteriorJoukowski
+
+namespace OAI
+
+/-! Conjugate inversion identifies the upper half of the punctured disk
+with the upper exterior disk. -/
+noncomputable section
+open Set Complex Function Metric
+open scoped ComplexConjugate
+
+namespace SLEExactGauge
+
+@[simp] lemma norm_conjugateInversion (z : ℂ) : ‖conjugateInversion z‖=‖z‖⁻¹ := by
+  simp only [conjugateInversion,norm_inv,norm_conj]
+
+lemma conjugateInversion_injective : Injective conjugateInversion :=
+  Function.LeftInverse.injective conjugateInversion_involutive
+
+lemma conjugateInversion_disk_upper_bijOn :
+    BijOn conjugateInversion (ball (0:ℂ) 1 ∩ upperHalfPlane) exteriorUpperDisk := by
+  have hn : ∀ z ∈ upperHalfPlane, 0 < ‖z‖ := by
+    intro z hz
+    apply norm_pos_iff.mpr
+    intro he
+    simp only [upperHalfPlane,mem_ofPred_eq,he,zero_im,lt_self_iff_false] at hz
+  refine ⟨?_,conjugateInversion_injective.injOn,?_⟩
+  · intro z hz
+    refine ⟨?_,conjugateInversion_upper hz.2⟩
+    rw [norm_conjugateInversion,inv_eq_one_div,lt_div_iff₀ (hn z hz.2)]
+    simpa only [one_mul,mem_ball,dist_zero_right] using hz.1
+  · intro z hz
+    refine ⟨conjugateInversion z,⟨?_,conjugateInversion_upper hz.2⟩,
+      conjugateInversion_involutive z⟩
+    rw [mem_ball,dist_zero_right,norm_conjugateInversion,inv_eq_one_div,
+      div_lt_iff₀ (hn z hz.2)]
+    simpa only [one_mul] using hz.1
+
+lemma conjugateInversion_slit_bijOn
+    (p : C(unitInterval,ℂ)) (h0 : p 0=0)
+    (hH : ∀ t : unitInterval, t ≠ 0 → p t ∈ upperHalfPlane) :
+    BijOn conjugateInversion (upperHalfPlane \ range p)
+      (invertedExterior (reflectedArcSet p) ∩ upperHalfPlane) := by
+  rw [reflected_inverted_upper_image p h0 hH]
+  exact conjugateInversion_injective.injOn.bijOn_image
+
+end SLEExactGauge
+
+end
+
+end OAI
diff --git a/lean/OAI/Probability/SLE/Geometry/ContinuousRangeCompletion.lean b/lean/OAI/Probability/SLE/Geometry/ContinuousRangeCompletion.lean
new file mode 100644
index 0000000000000000000000000000000000000000..a802b9fc187f3586b596b9aeac9aeb9ccb595ef2
--- /dev/null
+++ b/lean/OAI/Probability/SLE/Geometry/ContinuousRangeCompletion.lean
@@ -0,0 +1,114 @@
+import Mathlib
+
+namespace OAI
+
+/-! Continuous images of Baire space are measurable in the completion of a
+finite measure. This supplies the uncountable-time projection step for SLE. -/
+noncomputable section
+open Set Filter MeasureTheory Function PiNat Metric
+open scoped Topology ENNReal
+
+namespace SLEExactGauge
+
+def prefixCylinder (s : List ℕ) : Set (ℕ → ℕ) :=
+  {b | res b s.length=s}
+
+lemma prefixCylinder_nil : prefixCylinder []=univ := by
+  ext b
+  simp [prefixCylinder]
+
+lemma prefixCylinder_children (s : List ℕ) :
+    prefixCylinder s=⋃ k : ℕ, prefixCylinder (k::s) := by
+  ext b
+  simp only [prefixCylinder,mem_ofPred_eq,mem_iUnion,List.length_cons,res_succ,List.cons.injEq]
+  constructor
+  · intro h
+    exact ⟨b s.length,rfl,h⟩
+  · rintro ⟨k,_,h⟩
+    exact h
+
+lemma prefixCylinder_res (b : ℕ → ℕ) (n : ℕ) :
+    prefixCylinder (res b n)=cylinder b n := by
+  rw [prefixCylinder,res_length,cylinder_eq_res]
+
+theorem nullMeasurableSet_continuous_baire_range
+    {X : Type*} [MetricSpace X] [MeasurableSpace X] [BorelSpace X]
+    (μ : Measure X) [IsFiniteMeasure μ]
+    (f : (ℕ → ℕ) → X) (hf : Continuous f) :
+    NullMeasurableSet (range f) μ := by
+  classical
+  let A (s : List ℕ) := f '' prefixCylinder s
+  let E (s : List ℕ) := toMeasurable μ (A s) ∩ closure (A s)
+  have hE (s : List ℕ) : MeasurableSet (E s) :=
+    (measurableSet_toMeasurable μ (A s)).inter isClosed_closure.measurableSet
+  have hAE (s : List ℕ) : A s ⊆ E s :=
+    fun _ h => ⟨subset_toMeasurable μ (A s) h,subset_closure h⟩
+  have hAchildren (s : List ℕ) : A s=⋃ k, A (k::s) := by
+    dsimp only [A]
+    rw [prefixCylinder_children,image_iUnion]
+  have hzero (s : List ℕ) : μ (E s \ ⋃ k, E (k::s))=0 := by
+    have hU : MeasurableSet (⋃ k, E (k::s)) := MeasurableSet.iUnion fun k => hE (k::s)
+    have hsub : A s ⊆ ⋃ k, E (k::s) := by
+      rw [hAchildren]
+      exact iUnion_mono fun k => hAE (k::s)
+    have hempty : A s ∩ (⋃ k, E (k::s))ᶜ=∅ := by
+      exact eq_empty_iff_forall_notMem.mpr (fun x hx => hx.2 (hsub hx.1))
+    apply measure_mono_null (show E s \ ⋃ k, E (k::s) ⊆
+      toMeasurable μ (A s) ∩ (⋃ k, E (k::s))ᶜ from fun _ h => ⟨h.1.1,h.2⟩)
+    rw [μ.measure_toMeasurable_inter hU.compl (measure_ne_top μ (A s)),hempty,measure_empty]
+  let N := ⋃ s : List ℕ, E s \ ⋃ k, E (k::s)
+  have hN : μ N=0 := measure_iUnion_null hzero
+  have hcover : range f ⊆ E [] := by
+    have h := hAE []
+    simpa only [A,prefixCylinder_nil,image_univ] using h
+  have hinside (x : X) (hx : x ∈ E []) (hxN : x ∉ N) : x ∈ range f := by
+    have hchild (s : List ℕ) (hs : x ∈ E s) : ∃ k, x ∈ E (k::s) := by
+      by_contra h
+      apply hxN
+      exact mem_iUnion.mpr ⟨s,hs,by simpa only [mem_iUnion,not_exists] using h⟩
+    let S := {s : List ℕ // x ∈ E s}
+    let F (s : S) : S := ⟨(hchild s.1 s.2).choose::s.1,(hchild s.1 s.2).choose_spec⟩
+    let p (n : ℕ) : S := F^[n] ⟨[],hx⟩
+    have hp (n : ℕ) : p (n+1)=F (p n) := by simp only [p,iterate_succ',comp_apply]
+    let b (n : ℕ) := (hchild (p n).1 (p n).2).choose
+    have hres (n : ℕ) : (p n).1=res b n := by
+      induction n with
+      | zero => rfl
+      | succ n ih =>
+        rw [hp]
+        change b n::(p n).1=res b (n+1)
+        rw [res_succ,ih]
+    have hclosure (n : ℕ) : x ∈ closure (f '' cylinder b n) := by
+      have h := (p n).2.2
+      simpa only [hres,A,prefixCylinder_res] using h
+    have heq : x=f b := by
+      apply eq_of_forall_dist_le
+      intro ε hε
+      obtain ⟨v,⟨c,n,rfl⟩,hb,hv⟩ :=
+        (isTopologicalBasis_cylinders (fun _ : ℕ => ℕ)).exists_subset_of_mem_open
+          (show b ∈ f ⁻¹' ball (f b) ε from mem_ball_self hε)
+          (isOpen_ball.preimage hf)
+      have hsub : f '' cylinder b n ⊆ closedBall (f b) ε := by
+        rw [← mem_cylinder_iff_eq.mp hb] at hv
+        exact (image_subset_iff.mpr hv).trans ball_subset_closedBall
+      have hc := closure_minimal hsub isClosed_closedBall (hclosure n)
+      exact hc
+    exact ⟨b,heq.symm⟩
+  apply (hE []).nullMeasurableSet.congr
+  filter_upwards [measure_eq_zero_iff_ae_notMem.mp hN] with x hxN
+  exact propext ⟨fun hx => hinside x hx hxN,fun hx => hcover hx⟩
+
+theorem nullMeasurableSet_of_analytic_finite
+    {X : Type*} [MetricSpace X] [MeasurableSpace X] [BorelSpace X]
+    (μ : Measure X) [IsFiniteMeasure μ] {s : Set X} (hs : AnalyticSet s) :
+    NullMeasurableSet s μ := by
+  rw [AnalyticSet] at hs
+  rcases hs with rfl | ⟨f,hf,rfl⟩
+  · exact MeasurableSet.empty.nullMeasurableSet
+  · exact nullMeasurableSet_continuous_baire_range μ f hf
+
+end SLEExactGauge
+
+end
+
+end OAI
diff --git a/lean/OAI/Probability/SLE/Geometry/CountableInteriorIntervals.lean b/lean/OAI/Probability/SLE/Geometry/CountableInteriorIntervals.lean
new file mode 100644
index 0000000000000000000000000000000000000000..dede935f7f327972c32451eb649b7b8deb242605
--- /dev/null
+++ b/lean/OAI/Probability/SLE/Geometry/CountableInteriorIntervals.lean
@@ -0,0 +1,95 @@
+import OAI.Probability.SLE.Gauge.CoverEvents
+import Mathlib.Topology.Compactness.SigmaCompact
+
+namespace OAI
+
+/-! The deterministic countable certificates for the retained middle-strip
+intervals. An actual open interior visit contains a nondegenerate rational
+time interval, whose image lies in one fixed countable compact exhaustion. -/
+
+noncomputable section
+open Set Filter MeasureTheory Metric
+open scoped Topology NNReal
+
+namespace SLEExactGauge
+
+theorem exists_countable_compact_exhaustion_open (O : Set ℂ) (hO : IsOpen O) :
+    ∃ K : ℕ → Set ℂ, (∀ n, IsCompact (K n)) ∧ (∀ n, K n ⊆ O) ∧
+      (∀ S : Set ℂ, IsCompact S → S ⊆ O → ∃ n, S ⊆ K n) := by
+  let : LocallyCompactSpace O := hO.locallyCompactSpace
+  let L := CompactExhaustion.choice O
+  refine ⟨fun n => Subtype.val '' L n, ?_, ?_, ?_⟩
+  · intro n
+    exact (L.isCompact n).image continuous_subtype_val
+  · rintro n z ⟨w, _, rfl⟩
+    exact w.property
+  · intro S hS hSO
+    have hpre : IsCompact ((Subtype.val : O → ℂ) ⁻¹' S) :=
+      Topology.IsEmbedding.subtypeVal.isInducing.isCompact_preimage'
+        hS (by simpa only [Subtype.range_coe] using hSO)
+    obtain ⟨n, hn⟩ := L.exists_superset_of_isCompact hpre
+    refine ⟨n, ?_⟩
+    intro z hz
+    exact ⟨⟨z, hSO hz⟩, hn hz, rfl⟩
+
+theorem exists_rational_interval_in_open_visit
+    (f : ℝ → ℂ) (hf : Continuous f) (O : Set ℂ) (hO : IsOpen O)
+    (a b : ℝ) (hvisit : ∃ u ∈ Ioo a b, f u ∈ O) :
+    ∃ s t : ℚ, a < (s : ℝ) ∧ (s : ℝ) < t ∧ (t : ℝ) < b ∧
+      MapsTo f (Icc (s : ℝ) t) O := by
+  have hU : IsOpen (Ioo a b ∩ f ⁻¹' O) := isOpen_Ioo.inter (hO.preimage hf)
+  have hUn : (Ioo a b ∩ f ⁻¹' O).Nonempty := by
+    obtain ⟨u, hu, hfu⟩ := hvisit
+    exact ⟨u, hu, hfu⟩
+  obtain ⟨l, r, hlr, hsub⟩ := hU.exists_Ioo_subset hUn
+  obtain ⟨s, hls, hsr⟩ := exists_rat_btwn hlr
+  obtain ⟨t, hst, htr⟩ := exists_rat_btwn hsr
+  refine ⟨s, t, (hsub ⟨hls, hsr⟩).1.1, hst,
+    (hsub ⟨hls.trans hst, htr⟩).1.2, ?_⟩
+  intro u hu
+  exact (hsub ⟨hls.trans_le hu.1, hu.2.trans_lt htr⟩).2
+
+/-- One countable compact family captures every open visit, at rational
+times strictly between the entry and the later crossing. -/
+theorem rational_interval_compact_certificate
+    (O : Set ℂ) (hO : IsOpen O) :
+    ∃ K : ℕ → Set ℂ, (∀ n, IsCompact (K n)) ∧ (∀ n, K n ⊆ O) ∧
+      ∀ (f : ℝ → ℂ), Continuous f → ∀ a b : ℝ,
+        (∃ u ∈ Ioo a b, f u ∈ O) →
+        ∃ (s t : ℚ) (n : ℕ), a < (s : ℝ) ∧ (s : ℝ) < t ∧
+          (t : ℝ) < b ∧ f '' Icc (s : ℝ) t ⊆ K n := by
+  obtain ⟨K, hK, hKO, hcap⟩ := exists_countable_compact_exhaustion_open O hO
+  refine ⟨K, hK, hKO, ?_⟩
+  intro f hf a b hvisit
+  obtain ⟨s, t, has, hst, htb, hmap⟩ :=
+    exists_rational_interval_in_open_visit f hf O hO a b hvisit
+  obtain ⟨n, hn⟩ := hcap (f '' Icc (s : ℝ) t)
+    (isCompact_Icc.image hf) hmap.image_subset
+  exact ⟨s, t, n, has, hst, htb, hn⟩
+
+local instance compactIntervalPathMeasurableSpace : MeasurableSpace C(ℝ≥0, ℂ) := borel _
+local instance compactIntervalPathBorelSpace : BorelSpace C(ℝ≥0, ℂ) := ⟨rfl⟩
+
+theorem isClosed_interval_compact_certificate (s t : ℝ≥0)
+    {K : Set ℂ} (hK : IsClosed K) :
+    IsClosed {f : C(ℝ≥0, ℂ) | MapsTo f (Icc s t) K} := by
+  have he : {f : C(ℝ≥0, ℂ) | MapsTo f (Icc s t) K} =
+      ⋂ u ∈ Icc s t, (fun f : C(ℝ≥0, ℂ) => f u) ⁻¹' K := by
+    ext f
+    simp only [mem_ofPred_eq, MapsTo, mem_iInter, mem_preimage]
+  rw [he]
+  exact isClosed_iInter (fun u => isClosed_iInter (fun _ =>
+    hK.preimage (continuous_eval_const u)))
+
+theorem measurableSet_interval_compact_certificate
+    {Ω : Type*} [MeasurableSpace Ω]
+    (f : Ω → C(ℝ≥0, ℂ)) (hf : Measurable f)
+    (s t : ℝ≥0) {K : Set ℂ} (hK : IsCompact K) :
+    MeasurableSet {ω | MapsTo (f ω) (Icc s t) K} :=
+  hf (isClosed_interval_compact_certificate s t hK.isClosed).measurableSet
+
+end SLEExactGauge
+
+end
+
+end OAI
diff --git a/lean/OAI/Probability/SLE/Geometry/CountablePastBound.lean b/lean/OAI/Probability/SLE/Geometry/CountablePastBound.lean
new file mode 100644
index 0000000000000000000000000000000000000000..d191d685fcc197fb3140775e097c472339da5df9
--- /dev/null
+++ b/lean/OAI/Probability/SLE/Geometry/CountablePastBound.lean
@@ -0,0 +1,106 @@
+import OAI.Probability.SLE.Gauge.StrictPastTilted
+import OAI.Probability.SLE.Gauge.ActualPastThreshold
+
+namespace OAI
+
+/-! Passing finite centered-law test bounds to countable detected mass. -/
+
+noncomputable section
+open Set Filter _root_.MeasureTheory _root_.OAI.MeasureTheory ProbabilityTheory
+open scoped Topology NNReal ENNReal
+attribute [local instance] Classical.propDecidable
+
+namespace SLEExactGauge.Multipoint
+
+lemma range_image_event_union {X : Type*} (q : ℕ → ℝ≥0) (A : ℝ≥0 → Set X) :
+    (⋃ n, ⋃ t∈(Finset.range n).image q, A t) = ⋃ n, A (q n) := by
+  ext x
+  constructor
+  · intro hx
+    obtain ⟨n,hx⟩ := mem_iUnion.mp hx
+    obtain ⟨t,ht,hxt⟩ := mem_iUnion₂.mp hx
+    obtain ⟨k,_,rfl⟩ := Finset.mem_image.mp ht
+    exact mem_iUnion.mpr ⟨k,hxt⟩
+  · intro hx
+    obtain ⟨n,hn⟩ := mem_iUnion.mp hx
+    exact mem_iUnion.mpr ⟨n+1,mem_iUnion₂.mpr ⟨q n,
+      Finset.mem_image.mpr ⟨n,Finset.mem_range.mpr (Nat.lt_succ_self n),rfl⟩,hn⟩⟩
+
+namespace CanonicalMass
+
+variable {Ω : Type*} [mΩ : MeasurableSpace Ω] {P : Measure Ω}
+  {κ : ℝ} {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 ω))
+
+include C hB hc h0 hκ hκ8 F hw
+
+lemma countable_strict_past_le_of_finite_bound
+    (u : ℕ → ℝ) (hu : ∀ n, 0 ≤ u n) (hmono : Monotone u)
+    (hlim : Tendsto u atTop atTop) (J : ℕ → Finset ℝ≥0) (hJ : Monotone J)
+    (E : ℝ≥0 → Set Ω)
+    (hE : ∀ t, MeasurableSet[(Filtration.natural B (fun s =>
+      (hBm.comp (measurable_const.prodMk measurable_id) : Measurable (B s)).stronglyMeasurable)) t] (E t))
+    (K : Set upperHalfPlane) (hK : IsCompact K) (A : ℝ≥0∞)
+    (hbound : ∀ j, ∀ᶠ n in atTop,
+      (∫⁻ z in (Subtype.val : upperHalfPlane → ℂ) '' K,
+        ENNReal.ofReal (initialGreen κ z) * finiteCenteredLaw P κ B γ G z (u n)
+          (finiteStrictPastEvent (J j) E (fun ω => radiusLevelTime (γ ω) (G ω) z (u n))) ∂volume) ≤ A) :
+    (∫⁻ ω, C.rational.terminal ω (K ∩ ⋃ n, ⋃ t∈J n,
+      if ω∈E t then {z : upperHalfPlane | (z:ℂ)∈γ ω '' Icc 0 t}ᶜ else ∅) ∂P) ≤ A := by
+  rw [C.countable_strict_past_expectation hB hc h0 hκ hκ8 F hw J hJ E hE K hK]
+  apply iSup_le
+  intro j
+  rw [← C.finite_strict_past_expectation hB hc h0 hκ hκ8 F hw (J j) E
+    (fun t _ => hE t) K hK]
+  exact le_of_tendsto (C.finite_strict_past_tilted_limit hB hBm hc h0 hκ hκ8 γ G F hw u hu hmono hlim
+    (J j) E (fun t _ => hE t) K hK) (hbound j)
+
+lemma bad_cell_mass_le_of_finite_bound
+    (u : ℕ → ℝ) (hu : ∀ n, 0 ≤ u n) (hmono : Monotone u)
+    (hlim : Tendsto u atTop atTop) (q : ℕ → ℝ≥0) (hq : DenseRange q)
+    (K : Set upperHalfPlane) (hK : IsCompact K) (H : ℝ) (hH : 0 < H) (A : ℝ≥0∞)
+    (hbound : ∀ j, ∀ᶠ n in atTop,
+      (∫⁻ z in (Subtype.val : upperHalfPlane → ℂ) '' K,
+        ENNReal.ofReal (initialGreen κ z) * finiteCenteredLaw P κ B γ G z (u n)
+          (finiteStrictPastEvent ((Finset.range j).image q)
+            (fun t => {ω | H < (C.process t ω K).toReal})
+            (fun ω => radiusLevelTime (γ ω) (G ω) z (u n))) ∂volume) ≤ A) :
+    (∫⁻ ω, {ω | ENNReal.ofReal (2*H) < C.rational.terminal ω K}.indicator
+      (fun ω => C.rational.terminal ω K) ω ∂P) ≤ 2*A := by
+  have hE (t : ℝ≥0) : MeasurableSet[(Filtration.natural B (fun s =>
+      (hBm.comp (measurable_const.prodMk measurable_id) : Measurable (B s)).stronglyMeasurable)) t]
+      {ω | H < (C.process t ω K).toReal} :=
+    measurableSet_lt measurable_const
+      (((Measure.measurable_coe hK.measurableSet).comp (C.progressive.adapted t)).ennreal_toReal)
+  let E (t : ℝ≥0) : Set Ω := {ω | H < (C.process t ω K).toReal}
+  let J (n : ℕ) := (Finset.range n).image q
+  let D (ω : Ω) := C.rational.terminal ω (K ∩ ⋃ n,
+    if H < (C.process (q n) ω K).toReal then
+      {z : upperHalfPlane | (z:ℂ)∈γ ω '' Icc 0 (q n)}ᶜ else ∅)
+  have hJ : Monotone J := fun n m hnm => Finset.image_subset_image (Finset.range_mono hnm)
+  have hD : (∫⁻ ω, D ω ∂P) ≤ A := by
+    have hh := C.countable_strict_past_le_of_finite_bound hB hc h0 hκ hκ8 F hw
+      u hu hmono hlim J hJ E hE K hK A hbound
+    simpa only [D, E, J, mem_ofPred_eq, range_image_event_union] using hh
+  calc
+    _ ≤ ∫⁻ ω, 2*D ω ∂P := by
+      apply lintegral_mono_ae
+      filter_upwards [C.past_threshold_detects_half_terminal hB hc h0 hκ hκ8 F hw q hq K hK H hH] with ω hω
+      by_cases hb : ENNReal.ofReal (2*H) < C.rational.terminal ω K
+      · rw [indicator_of_mem (show ω ∈ {ω | ENNReal.ofReal (2*H) < C.rational.terminal ω K} from hb)]
+        exact hω hb
+      · rw [indicator_of_notMem (show ω ∉ {ω | ENNReal.ofReal (2*H) < C.rational.terminal ω K} from hb)]
+        exact bot_le
+    _ = 2*(∫⁻ ω, D ω ∂P) := lintegral_const_mul' _ _ (by norm_num)
+    _ ≤ 2*A := mul_le_mul' le_rfl hD
+
+end CanonicalMass
+end SLEExactGauge.Multipoint
+
+end
+
+end OAI
diff --git a/lean/OAI/Probability/SLE/Geometry/CountableRemainderKernels.lean b/lean/OAI/Probability/SLE/Geometry/CountableRemainderKernels.lean
new file mode 100644
index 0000000000000000000000000000000000000000..d911f5435c267d46241cc3505ddda7496b49c913
--- /dev/null
+++ b/lean/OAI/Probability/SLE/Geometry/CountableRemainderKernels.lean
@@ -0,0 +1,76 @@
+import OAI.Probability.SLE.Mass.CountableLevelKernel
+import OAI.Probability.SLE.Geometry.RemainderKernelCancellation
+
+namespace OAI
+
+/-! Positive measurable remaining masses, with the exact Green kernel,
+for the actual common countable-time Radon construction. -/
+
+noncomputable section
+open Set Filter MeasureTheory ProbabilityTheory Classical
+open scoped NNReal ENNReal Topology CompactlySupported
+
+namespace SLEExactGauge.Multipoint
+
+local instance : LocallyCompactSpace upperHalfPlane := isOpen_upperHalfPlane.locallyCompactSpace
+
+theorem exists_countable_radon_remainder_kernels
+    {Ω : Type*} [MeasurableSpace Ω] {P : Measure Ω}
+    {B : ℝ≥0 → Ω → ℝ} (hB : IsBrownianReal B P)
+    (hm : ∀ t, Measurable (B t)) (hBm : Measurable (Function.uncurry B))
+    (hBc : ∀ ω, Continuous (fun t => B t ω)) (hB0 : ∀ ω, B 0 ω = 0)
+    {κ : ℝ} (hκ : 0 < κ) (hκ8 : κ < 8)
+    (γ : Ω → ℝ≥0 → ℂ) (G F : Ω → ℝ≥0 → ℂ → ℂ)
+    (hw : ∀ ω, IsCapacityTwoWitness (fun t => Real.sqrt κ * B t ω) (γ ω) (G ω) (F ω))
+    (hgrowth : PublishedDiskUnivalentGrowth) (t : ℕ → ℝ≥0) :
+    ∃ s : ℕ → Finset ℕ, ∃ w : ℕ → ℕ → ℝ,
+    ∃ ν η : ℕ → Ω → Measure upperHalfPlane,
+      (∀ n i, i ∈ s n → 0 ≤ w n i) ∧ (∀ n, ∑ i ∈ s n, w n i = 1) ∧
+      (∀ j, Measurable (ν j)) ∧
+      (∀ j ω, (ν j ω).Regular ∧ IsFiniteMeasureOnCompacts (ν j ω)) ∧
+      (∀ᵐ ω ∂P, ∀ j (f : C_c(upperHalfPlane,ℝ)),
+        Tendsto (fun n => ∫ z, f z ∂convexLevelMeasure κ B γ G (fun n => (n:ℝ)) s w n
+          (levelMassTimes t j) ω) atTop (𝓝 (∫ z, f z ∂ν j ω))) ∧
+      (∀ j, Measurable (η j)) ∧
+      (∀ j ω, (η j ω).Regular ∧ IsFiniteMeasureOnCompacts (η j ω)) ∧
+      (∀ᵐ ω ∂P, ∀ j, η j ω + ν (j+1) ω = ν 0 ω) ∧
+      P.bind (ν 0) = initialGreenMeasure κ ∧
+      ∀ j (E : Set Ω),
+        MeasurableSet[Filtration.natural B (fun r =>
+          (hBm.comp (measurable_const.prodMk measurable_id) : Measurable (B r)).stronglyMeasurable) (t j)] E →
+        (P.restrict E).bind (η j) = (P.restrict E).bind (halfPlaneGreenMeasure κ B γ G (t j)) := by
+  obtain ⟨s,w,ν,hw₀,hw₁,hνm,hν,hlim,hmean,hkernel⟩ :=
+    exists_countable_level_radon_kernels hB hm hBm hBc hB0 hκ hκ8 γ G F hw hgrowth t
+  have horder : ∀ᵐ ω ∂P, ∀ j, ν (j+1) ω ≤ ν 0 ω := by
+    filter_upwards [hlim] with ω hω
+    intro j
+    let (i : ℕ) : (ν i ω).Regular := (hν i ω).1
+    let (n i : ℕ) : IsFiniteMeasureOnCompacts
+        (convexLevelMeasure κ B γ G (fun n => (n:ℝ)) s w n (levelMassTimes t i) ω) :=
+      convexLevelMeasure_finite_on_compacts hκ hκ8 γ G F ω (hBc ω) (hw ω) _ s w n _
+    apply radon_limits_mono _ _ (ν (j+1) ω) (ν 0 ω) (hω (j+1)) (hω 0)
+    intro n
+    simpa only [levelMassTimes_zero,levelMassTimes_succ] using
+      convexLevelMeasure_mono κ B γ G (fun n => (n:ℝ)) s w n ω
+        (le_top : (t j : ℝ≥0∞) ≤ ∞)
+  have hex (j : ℕ) := exists_measurable_halfPlane_difference P (ν 0) (ν (j+1))
+    (hνm 0) (hνm (j+1)) (fun ω => (hν 0 ω).1) (fun ω => (hν (j+1) ω).1)
+    (horder.mono (fun _ hω => hω j))
+  choose η hηm hηr hηsum using hex
+  refine ⟨s,w,ν,η,hw₀,hw₁,hνm,hν,hlim,hηm,hηr,ae_all_iff.mpr hηsum,hmean,?_⟩
+  intro j E hE
+  let : IsFiniteMeasureOnCompacts (initialGreenMeasure κ) := initialGreenMeasure_finite_on_compacts κ
+  have hbound : (P.restrict E).bind (ν (j+1)) ≤ initialGreenMeasure κ := by
+    rw [← hmean]
+    exact restricted_bind_le_of_ae_le P (ν (j+1)) (ν 0) (hνm (j+1)) (hνm 0)
+      (horder.mono (fun _ hω => hω j)) E
+  let : IsFiniteMeasureOnCompacts ((P.restrict E).bind (ν (j+1))) :=
+    ⟨fun K hK => lt_of_le_of_lt (hbound K) hK.measure_lt_top⟩
+  exact bind_remainder_eq_of_sum (P.restrict E) (ν (j+1)) (ν 0) (η j)
+    (hνm (j+1)) (hνm 0) (hηm j) _ (ae_restrict_of_ae (hηsum j)) (hkernel j E hE)
+
+end SLEExactGauge.Multipoint
+
+end
+
+end OAI
diff --git a/lean/OAI/Probability/SLE/Geometry/CrosscutExitSides.lean b/lean/OAI/Probability/SLE/Geometry/CrosscutExitSides.lean
new file mode 100644
index 0000000000000000000000000000000000000000..98895de2890d973b2ad694a54f1f6c7f770cc3f2
--- /dev/null
+++ b/lean/OAI/Probability/SLE/Geometry/CrosscutExitSides.lean
@@ -0,0 +1,82 @@
+import OAI.Probability.SLE.Geometry.FirstDomainExit
+import OAI.Probability.SLE.Geometry.PublishedCrosscutStraightening
+import OAI.Probability.SLE.Geometry.PublishedConformalExitLaw
+
+namespace OAI
+
+/-! A nonzero real map-out limit has the sign selected before the first
+domain exit. This turns geometric guide avoidance into an actual exit-arc
+event, once the published conformal Brownian exit law is supplied. -/
+
+noncomputable section
+open Set Filter MeasureTheory
+open scoped Topology NNReal ENNReal
+
+namespace SLEExactGauge.CrosscutSides
+open RibbonCoordinates Target
+
+theorem real_exit_positive_of_straightened_prefix
+    (h : ℂ ≃ₜ ℂ) (hreal : ∀ x : ℝ, h (x : ℂ) = (x : ℂ))
+    (g : ℝ → ℂ) {a τ x : ℝ} (haτ : a < τ) (hx : x ≠ 0)
+    (hprefix : ∀ t ∈ Ico a τ, 0 < (h (g t)).re)
+    (hlim : Tendsto g (𝓝[<] τ) (𝓝 (x : ℂ))) : 0 < x := by
+  have hh := straightening_preserves_real_exit_limit h hreal g x hlim
+  have he : ∀ᶠ t in 𝓝[<] τ, 0 ≤ (h (g t)).re := by
+    filter_upwards [Ioo_mem_nhdsLT haτ] with t ht
+    exact (hprefix t ⟨ht.1.le, ht.2⟩).le
+  exact lt_of_le_of_ne (ge_of_tendsto hh he) (Ne.symm hx)
+
+theorem real_exit_negative_of_straightened_prefix
+    (h : ℂ ≃ₜ ℂ) (hreal : ∀ x : ℝ, h (x : ℂ) = (x : ℂ))
+    (g : ℝ → ℂ) {a τ x : ℝ} (haτ : a < τ) (hx : x ≠ 0)
+    (hprefix : ∀ t ∈ Ico a τ, (h (g t)).re < 0)
+    (hlim : Tendsto g (𝓝[<] τ) (𝓝 (x : ℂ))) : x < 0 := by
+  have hh := straightening_preserves_real_exit_limit h hreal g x hlim
+  have he : ∀ᶠ t in 𝓝[<] τ, (h (g t)).re ≤ 0 := by
+    filter_upwards [Ioo_mem_nhdsLT haτ] with t ht
+    exact (hprefix t ⟨ht.1.le, ht.2⟩).le
+  exact lt_of_le_of_ne (le_of_tendsto hh he) hx
+
+/-- The scalar straightened side coordinate has a fixed sign until exit
+because its zero set is precisely the complete guide. -/
+theorem positive_first_exit_belongs_to_arc
+    (D : Set ℂ) (g : ℂ → ℂ) (h : ℂ ≃ₜ ℂ)
+    (hreal : ∀ x : ℝ, h (x : ℂ) = (x : ℂ))
+    (hg : ContinuousOn g D) (ζ : ℝ → ℂ) (hc : Continuous ζ)
+    {τ : ℝ} (hτ : UnitWindowFirstExit D ζ τ)
+    (haτ : (1 / 4 : ℝ) < τ)
+    (hn : ∀ t ∈ Ico (1 / 4 : ℝ) τ, (h (g (ζ t))).re ≠ 0)
+    (hstart : 0 < (h (g (ζ (1 / 4)))).re)
+    (x : ℝ) (hx : x ≠ 0)
+    (hlim : Tendsto (fun t => g (ζ t)) (𝓝[<] τ) (𝓝 (x : ℂ))) : 0 < x := by
+  have hj : ContinuousOn (fun z => (h (g z)).re) D :=
+    Complex.continuous_re.comp_continuousOn (h.continuous.comp_continuousOn hg)
+  have hin : MapsTo ζ (Ico (1 / 4 : ℝ) τ) D :=
+    hτ.2.2.mono_left (Ico_subset_Ico_left (by norm_num))
+  exact real_exit_positive_of_straightened_prefix h hreal (fun t => g (ζ t)) haτ hx
+    (exit_prefix_positive (fun z => (h (g z)).re) hj ζ hc.continuousOn hin hn haτ hstart)
+    hlim
+
+theorem negative_first_exit_belongs_to_arc
+    (D : Set ℂ) (g : ℂ → ℂ) (h : ℂ ≃ₜ ℂ)
+    (hreal : ∀ x : ℝ, h (x : ℂ) = (x : ℂ))
+    (hg : ContinuousOn g D) (ζ : ℝ → ℂ) (hc : Continuous ζ)
+    {τ : ℝ} (hτ : UnitWindowFirstExit D ζ τ)
+    (haτ : (1 / 4 : ℝ) < τ)
+    (hn : ∀ t ∈ Ico (1 / 4 : ℝ) τ, (h (g (ζ t))).re ≠ 0)
+    (hstart : (h (g (ζ (1 / 4)))).re < 0)
+    (x : ℝ) (hx : x ≠ 0)
+    (hlim : Tendsto (fun t => g (ζ t)) (𝓝[<] τ) (𝓝 (x : ℂ))) : x < 0 := by
+  have hj : ContinuousOn (fun z => (h (g z)).re) D :=
+    Complex.continuous_re.comp_continuousOn (h.continuous.comp_continuousOn hg)
+  have hin : MapsTo ζ (Ico (1 / 4 : ℝ) τ) D :=
+    hτ.2.2.mono_left (Ico_subset_Ico_left (by norm_num))
+  exact real_exit_negative_of_straightened_prefix h hreal (fun t => g (ζ t)) haτ hx
+    (exit_prefix_negative (fun z => (h (g z)).re) hj ζ hc.continuousOn hin hn haτ hstart)
+    hlim
+
+end SLEExactGauge.CrosscutSides
+
+end
+
+end OAI
diff --git a/lean/OAI/Probability/SLE/Geometry/CrosscutParameterInverse.lean b/lean/OAI/Probability/SLE/Geometry/CrosscutParameterInverse.lean
new file mode 100644
index 0000000000000000000000000000000000000000..43b2fc8eaeb54807d6d6e19aa8ab7eb68dc0102a
--- /dev/null
+++ b/lean/OAI/Probability/SLE/Geometry/CrosscutParameterInverse.lean
@@ -0,0 +1,61 @@
+import OAI.Probability.SLE.Geometry.CompactifiedCrosscut
+import OAI.Probability.SLE.Geometry.DiskUpperStraightening
+import OAI.Probability.SLE.Geometry.HalfPlaneCayleyInverse
+
+namespace OAI
+
+/-! The compactification parameter exactly matches the prescribed vertical ray. -/
+noncomputable section
+open Set Complex
+open scoped NNReal
+
+namespace SLEExactGauge
+
+def rayDiskParameter (t : ℝ≥0) : ℝ := (t:ℝ)/(1+(t:ℝ))
+
+lemma rayDiskParameter_mem (t : ℝ≥0) : rayDiskParameter t ∈ Ico 0 1 := by
+  have hd : 0 < 1+(t:ℝ) := by positivity
+  refine ⟨div_nonneg t.property hd.le,?_⟩
+  exact (div_lt_one hd).mpr (by linarith)
+
+lemma crosscutParameter_rayDiskParameter (t : ℝ≥0) :
+    crosscutParameter (rayDiskParameter t)=t := by
+  apply NNReal.coe_injective
+  have hs := rayDiskParameter_mem t
+  have hval : (crosscutParameter (rayDiskParameter t) : ℝ) =
+      rayDiskParameter t / (1-rayDiskParameter t) :=
+    Real.coe_toNNReal _ (div_nonneg hs.1 (sub_pos.mpr hs.2).le)
+  rw [hval]
+  dsimp [rayDiskParameter]
+  have hd : (1+(t:ℝ)) ≠ 0 := by positivity
+  field_simp [hd]
+  ring
+
+lemma compactifiedCrosscut_rayDiskParameter (β : ℝ≥0 → ℂ) (t : ℝ≥0) :
+    compactifiedCrosscut β (rayDiskParameter t)=halfPlaneCayley (β t) := by
+  rw [compactifiedCrosscut_eq β (rayDiskParameter_mem t).2,
+    crosscutParameter_rayDiskParameter]
+
+lemma diskDiameter_rayDiskParameter (t : ℝ≥0) :
+    diskDiameter (rayDiskParameter t)=halfPlaneCayley ((t:ℂ)*I) := by
+  have hd : (1+(t:ℂ)) ≠ 0 := by
+    exact_mod_cast (show (1+(t:ℝ)) ≠ 0 by positivity)
+  have hi : (t:ℂ)*I+I ≠ 0 := by
+    have hh : (t:ℂ)*I+I=(1+(t:ℂ))*I := by ring
+    rw [hh]
+    exact mul_ne_zero hd Complex.I_ne_zero
+  have hr : 2*((t:ℝ)/(1+(t:ℝ)))-1=((t:ℝ)-1)/(1+(t:ℝ)) := by
+    have h : (1+(t:ℝ)) ≠ 0 := by positivity
+    field_simp
+    ring
+  unfold diskDiameter rayDiskParameter halfPlaneCayley
+  rw [hr]
+  push_cast
+  apply (div_eq_div_iff hd hi).mpr
+  ring
+
+end SLEExactGauge
+
+end
+
+end OAI
diff --git a/lean/OAI/Probability/SLE/Geometry/CurveJoin.lean b/lean/OAI/Probability/SLE/Geometry/CurveJoin.lean
new file mode 100644
index 0000000000000000000000000000000000000000..0030a8a5ace6224bd5dd74dcdb6ffb7999c73fda
--- /dev/null
+++ b/lean/OAI/Probability/SLE/Geometry/CurveJoin.lean
@@ -0,0 +1,104 @@
+import OAI.Probability.SLE.Gauge.NormalRibbonPatch
+
+namespace OAI
+
+/-! Joining the straight and circular pieces of the serpentine at matching
+positions and tangents. The joins preserve the actual derivative and the
+common tangent Lipschitz constant. -/
+
+noncomputable section
+open Set Filter Metric
+open scoped Topology NNReal
+
+namespace SLEExactGauge.Serpentine
+
+def curveJoin (c : ℝ) (f g : ℝ → ℂ) (t : ℝ) : ℂ := if t ≤ c then f t else g t
+
+@[simp] lemma curveJoin_of_le {c t : ℝ} (h : t ≤ c) (f g : ℝ → ℂ) :
+    curveJoin c f g t = f t := by simp only [curveJoin, ite_eq_left h]
+
+@[simp] lemma curveJoin_of_gt {c t : ℝ} (h : c < t) (f g : ℝ → ℂ) :
+    curveJoin c f g t = g t := by simp only [curveJoin, ite_eq_right (not_le_of_gt h)]
+
+theorem curveJoin_continuous (c : ℝ) (f g : ℝ → ℂ) (hf : Continuous f)
+    (hg : Continuous g) (he : f c = g c) : Continuous (curveJoin c f g) := by
+  classical
+  change Continuous ((Iic c).piecewise f g)
+  apply Continuous.piecewise ?_ hf hg
+  intro t ht
+  have ht' : t = c := by simpa only [frontier_Iic, mem_singleton_iff] using ht
+  simpa only [ht'] using he
+
+lemma curveJoin_lipschitz {c : ℝ} {f g : ℝ → ℂ} {K : ℝ≥0}
+    (hf : LipschitzWith K f) (hg : LipschitzWith K g) (he : f c = g c) :
+    LipschitzWith K (curveJoin c f g) := by
+  apply lipschitzWith_iff_dist_le_mul.mpr
+  intro u v
+  by_cases hu : u ≤ c
+  · by_cases hv : v ≤ c
+    · simpa only [curveJoin_of_le hu, curveJoin_of_le hv] using hf.dist_le_mul u v
+    · have hcv : c < v := lt_of_not_ge hv
+      rw [curveJoin_of_le hu, curveJoin_of_gt hcv]
+      calc
+        dist (f u) (g v) ≤ dist (f u) (f c) + dist (g c) (g v) := by
+          simpa only [he] using dist_triangle (f u) (f c) (g v)
+        _ ≤ K * dist u c + K * dist c v := add_le_add (hf.dist_le_mul _ _) (hg.dist_le_mul _ _)
+        _ = K * dist u v := by
+          rw [Real.dist_eq, Real.dist_eq, Real.dist_eq,
+            abs_of_nonpos (sub_nonpos.mpr hu), abs_of_neg (sub_neg.mpr hcv),
+            abs_of_neg (sub_neg.mpr (hu.trans_lt hcv))]
+          ring
+  · have hcu : c < u := lt_of_not_ge hu
+    by_cases hv : v ≤ c
+    · rw [curveJoin_of_gt hcu, curveJoin_of_le hv]
+      calc
+        dist (g u) (f v) ≤ dist (g u) (g c) + dist (f c) (f v) := by
+          simpa only [he] using dist_triangle (g u) (g c) (f v)
+        _ ≤ K * dist u c + K * dist c v := add_le_add (hg.dist_le_mul _ _) (hf.dist_le_mul _ _)
+        _ = K * dist u v := by
+          rw [Real.dist_eq, Real.dist_eq, Real.dist_eq,
+            abs_of_pos (sub_pos.mpr hcu), abs_of_nonneg (sub_nonneg.mpr hv),
+            abs_of_pos (sub_pos.mpr (hv.trans_lt hcu))]
+          ring
+    · simpa only [curveJoin_of_gt hcu, curveJoin_of_gt (lt_of_not_ge hv)] using hg.dist_le_mul u v
+
+theorem curveJoin_hasDerivAt (c : ℝ) (f g df dg : ℝ → ℂ)
+    (hf : ∀ t, HasDerivAt f (df t) t) (hg : ∀ t, HasDerivAt g (dg t) t)
+    (he : f c = g c) (hd : df c = dg c) (t : ℝ) :
+    HasDerivAt (curveJoin c f g) (curveJoin c df dg t) t := by
+  by_cases hlt : t < c
+  · have heq : curveJoin c f g =ᶠ[𝓝 t] f := by
+      filter_upwards [eventually_lt_nhds hlt] with u hu
+      exact curveJoin_of_le hu.le f g
+    rw [curveJoin_of_le hlt.le]
+    exact (hf t).congr_of_eventuallyEq heq
+  · by_cases hgt : c < t
+    · have heq : curveJoin c f g =ᶠ[𝓝 t] g := by
+        filter_upwards [eventually_gt_nhds hgt] with u hu
+        exact curveJoin_of_gt hu f g
+      rw [curveJoin_of_gt hgt]
+      exact (hg t).congr_of_eventuallyEq heq
+    · have ht : t = c := le_antisymm (le_of_not_gt hgt) (le_of_not_gt hlt)
+      subst t
+      have hl : HasDerivWithinAt (curveJoin c f g) (df c) (Iic c) c := by
+        apply (hf c).hasDerivWithinAt.congr
+        · intro u hu
+          exact curveJoin_of_le hu f g
+        · exact curveJoin_of_le le_rfl f g
+      have hr : HasDerivWithinAt (curveJoin c f g) (df c) (Ici c) c := by
+        rw [hd]
+        apply (hg c).hasDerivWithinAt.congr
+        · intro u hu
+          by_cases heq : u = c
+          · simpa only [heq, curveJoin_of_le le_rfl] using he
+          · exact curveJoin_of_gt (lt_of_le_of_ne hu (Ne.symm heq)) f g
+        · simpa only [curveJoin_of_le le_rfl] using he
+      have hh := hl.union hr
+      rw [Iic_union_Ici] at hh
+      simpa only [curveJoin_of_le le_rfl] using hh.hasDerivAt (by simp)
+
+end SLEExactGauge.Serpentine
+
+end
+
+end OAI
diff --git a/lean/OAI/Probability/SLE/Geometry/DiagonalComplexLimit.lean b/lean/OAI/Probability/SLE/Geometry/DiagonalComplexLimit.lean
new file mode 100644
index 0000000000000000000000000000000000000000..e25a9a56c2ef2ebf9790d8fd23d3e3b1ee84b935
--- /dev/null
+++ b/lean/OAI/Probability/SLE/Geometry/DiagonalComplexLimit.lean
@@ -0,0 +1,31 @@
+import OAI.Probability.SLE.Stochastic.DrivingEndpointUniqueness
+
+namespace OAI
+
+/-! A diagonal choice for the two limits used at a slit tip. -/
+noncomputable section
+open Set Filter Function Complex Metric
+open scoped Topology
+
+namespace SLEExactGauge
+
+lemma diagonal_complex_limit {f : ℕ → ℕ → ℂ} {g : ℕ → ℂ} {b : ℂ}
+    (hf : ∀ k, Tendsto (fun n => f n k) atTop (𝓝 (g k)))
+    (hg : Tendsto g atTop (𝓝 b)) :
+    ∃ φ : ℕ → ℕ, (∀ n, n≤φ n) ∧ Tendsto (fun n => f (φ n) n) atTop (𝓝 b) := by
+  have hN (k : ℕ) : ∃ N : ℕ, ∀ n≥N, dist (f n k) (g k)<1/((k:ℝ)+1) := by
+    exact eventually_atTop.mp ((Metric.tendsto_nhds.mp (hf k)) _ (by positivity))
+  choose N hN using hN
+  let φ := fun n => max n (N n)
+  refine ⟨φ,fun n => le_max_left _ _,Metric.tendsto_nhds.mpr ?_⟩
+  intro ε hε
+  filter_upwards [(Metric.tendsto_nhds.mp hg) (ε/2) (half_pos hε),
+    tendsto_one_div_add_atTop_nhds_zero_nat.eventually (gt_mem_nhds (half_pos hε))] with n hn he
+  have hd := hN n (φ n) (le_max_right _ _)
+  exact (dist_triangle _ (g n) b).trans_lt (by linarith)
+
+end SLEExactGauge
+
+end
+
+end OAI
diff --git a/lean/OAI/Probability/SLE/Geometry/DiskBoundaryRegion.lean b/lean/OAI/Probability/SLE/Geometry/DiskBoundaryRegion.lean
new file mode 100644
index 0000000000000000000000000000000000000000..b7e081a88b32247a7b51bb9a206fe18225e7012e
--- /dev/null
+++ b/lean/OAI/Probability/SLE/Geometry/DiskBoundaryRegion.lean
@@ -0,0 +1,128 @@
+import OAI.Probability.SLE.Geometry.HalfDiskGeometry
+
+namespace OAI
+
+/-! The full circle and its two half-disk Jordan regions. -/
+noncomputable section
+open Set Complex Metric
+open scoped ComplexConjugate
+
+namespace SLEExactGauge
+
+lemma diskLowerArc_continuous : Continuous diskLowerArc :=
+  Complex.continuous_conj.comp diskUpperArc_continuous
+
+lemma diskLowerArc_injOn : InjOn diskLowerArc (Icc 0 1) := by
+  intro s hs t ht he
+  exact diskUpperArc_injOn hs ht (Complex.conjCLE.injective he)
+
+lemma diskLowerArc_zero : diskLowerArc 0 = -1 := by
+  simp [diskLowerArc,diskUpperArc_zero]
+
+lemma diskLowerArc_one : diskLowerArc 1 = 1 := by
+  simp [diskLowerArc,diskUpperArc_one]
+
+theorem disk_circle_jordan :
+    Schoenflies.IsJordanCurve (complexPlaneCoordinates '' {z : ℂ | ‖z‖=1}) := by
+  rw [← disk_semicircle_union,image_union]
+  have hA := complexPlaneCoordinates_isArcBetween diskUpperArc
+    diskUpperArc_continuous.continuousOn diskUpperArc_injOn
+  have hB := complexPlaneCoordinates_isArcBetween diskLowerArc
+    diskLowerArc_continuous.continuousOn diskLowerArc_injOn
+  rw [diskLowerArc_zero,diskLowerArc_one,← diskUpperArc_zero,← diskUpperArc_one] at hB
+  apply Schoenflies.isJordanCurve_union hA hB
+  rintro _ ⟨a,ha,rfl⟩ ⟨b,hb,he⟩
+  have hab := complexPlaneCoordinates.injective he
+  have hz : a ∈ ({-1,1}:Set ℂ) := by
+    rw [← disk_semicircle_inter]
+    exact ⟨ha,hab ▸ hb⟩
+  rcases hz with hz|hz
+  · left
+    rw [hz,diskUpperArc_zero]
+  · right
+    rw [hz,diskUpperArc_one]
+
+theorem complexInside_unitDisk :
+    complexInside {z : ℂ | ‖z‖=1} = ball (0:ℂ) 1 := by
+  apply complexInside_eq_open disk_circle_jordan isOpen_ball
+    (convex_ball _ _).isPreconnected (nonempty_ball.mpr (by norm_num))
+    isBounded_ball
+  rw [frontier_ball _ (by norm_num : (1:ℝ)≠0)]
+  ext z
+  simp
+
+def openLowerDisk : Set ℂ := {z | ‖z‖ < 1 ∧ z.im < 0}
+def closedLowerDisk : Set ℂ := {z | ‖z‖ ≤ 1 ∧ z.im ≤ 0}
+
+lemma conj_image_openUpperDisk : conj '' openUpperDisk=openLowerDisk := by
+  ext z
+  constructor
+  · rintro ⟨w,hw,rfl⟩
+    simpa [openUpperDisk,openLowerDisk] using hw
+  · intro hz
+    refine ⟨conj z,?_,Complex.conj_conj z⟩
+    simpa [openUpperDisk,openLowerDisk] using hz
+
+lemma conj_image_closedUpperDisk : conj '' closedUpperDisk=closedLowerDisk := by
+  ext z
+  constructor
+  · rintro ⟨w,hw,rfl⟩
+    simpa [closedUpperDisk,closedLowerDisk] using hw
+  · intro hz
+    refine ⟨conj z,?_,Complex.conj_conj z⟩
+    simpa [closedUpperDisk,closedLowerDisk] using hz
+
+lemma openLowerDisk_closure : closure openLowerDisk=closedLowerDisk := by
+  have hh := Complex.conjCLE.toHomeomorph.image_closure openUpperDisk
+  change conj '' closure openUpperDisk=closure (conj '' openUpperDisk) at hh
+  rw [openUpperDisk_closure,conj_image_openUpperDisk,conj_image_closedUpperDisk] at hh
+  exact hh.symm
+
+lemma conj_image_diskDiameter : conj '' (diskDiameter '' Icc 0 1)=diskDiameter '' Icc 0 1 := by
+  ext z
+  constructor
+  · rintro ⟨_,⟨s,hs,rfl⟩,rfl⟩
+    simpa only [diskDiameter,Complex.conj_ofReal] using mem_image_of_mem diskDiameter hs
+  · rintro ⟨s,hs,rfl⟩
+    refine ⟨diskDiameter s,mem_image_of_mem _ hs,?_⟩
+    exact Complex.conj_ofReal _
+
+theorem complexInside_lowerDisk :
+    complexInside (diskDiameter '' Icc 0 1 ∪ diskLowerArc '' Icc 0 1)=openLowerDisk := by
+  have he : conj '' (diskUpperArc '' Icc 0 1)=diskLowerArc '' Icc 0 1 := by
+    rw [image_image]
+    rfl
+  have hh := complexInside_transport Complex.conjCLE.toHomeomorph
+    (diskDiameter '' Icc 0 1 ∪ diskUpperArc '' Icc 0 1)
+  change conj '' complexInside (diskDiameter '' Icc 0 1 ∪ diskUpperArc '' Icc 0 1)=
+    complexInside (conj '' (diskDiameter '' Icc 0 1 ∪ diskUpperArc '' Icc 0 1)) at hh
+  rw [image_union,conj_image_diskDiameter,he,complexInside_upperDisk,
+    conj_image_openUpperDisk] at hh
+  exact hh.symm
+
+lemma closed_halfDisks_union : closedUpperDisk ∪ closedLowerDisk=closedBall (0:ℂ) 1 := by
+  ext z
+  simp only [mem_union,closedUpperDisk,closedLowerDisk,mem_ofPred,mem_closedBall,dist_zero_right]
+  constructor
+  · rintro (h|h) <;> exact h.1
+  · intro hz
+    rcases le_total 0 z.im with hi|hi
+    · exact Or.inl ⟨hz,hi⟩
+    · exact Or.inr ⟨hz,hi⟩
+
+lemma closed_halfDisks_inter :
+    closedUpperDisk ∩ closedLowerDisk=diskDiameter '' Icc 0 1 := by
+  rw [diskDiameter_image]
+  ext z
+  simp only [closedUpperDisk,closedLowerDisk,mem_inter_iff,mem_ofPred]
+  constructor
+  · rintro ⟨hp,hm⟩
+    exact ⟨hp.1,le_antisymm hm.2 hp.2⟩
+  · rintro ⟨hn,hi⟩
+    exact ⟨⟨hn,hi.ge⟩,⟨hn,hi.le⟩⟩
+
+end SLEExactGauge
+
+end
+
+end OAI
diff --git a/lean/OAI/Probability/SLE/Geometry/DiskCrosscutBoundary.lean b/lean/OAI/Probability/SLE/Geometry/DiskCrosscutBoundary.lean
new file mode 100644
index 0000000000000000000000000000000000000000..d30c014ed3cbaa2608586dac47c46b574e6d9051
--- /dev/null
+++ b/lean/OAI/Probability/SLE/Geometry/DiskCrosscutBoundary.lean
@@ -0,0 +1,82 @@
+import OAI.Probability.SLE.Geometry.ComplexJordanExtension
+import OAI.Probability.SLE.Geometry.ArcBoundaryReplacement
+
+namespace OAI
+
+/-! The upper semicircle supplies the fixed boundary arc for the first
+relative Schoenflies extension of a compactified half-plane crosscut. -/
+noncomputable section
+open Set Complex
+
+namespace SLEExactGauge
+
+def diskUpperArc (s : ℝ) : ℂ :=
+  (-Real.cos (Real.pi*s) : ℂ)+(Real.sin (Real.pi*s) : ℂ)*I
+
+lemma diskUpperArc_continuous : Continuous diskUpperArc := by
+  unfold diskUpperArc
+  fun_prop
+
+lemma diskUpperArc_zero : diskUpperArc 0 = -1 := by simp [diskUpperArc]
+lemma diskUpperArc_one : diskUpperArc 1 = 1 := by simp [diskUpperArc]
+
+lemma diskUpperArc_re (s : ℝ) : (diskUpperArc s).re = -Real.cos (Real.pi*s) := by
+  simp only [diskUpperArc,Complex.add_re,Complex.neg_re,Complex.ofReal_re,
+    Complex.mul_re,Complex.ofReal_im,Complex.I_re,Complex.I_im,mul_zero,zero_mul,
+    sub_zero,add_zero]
+
+lemma diskUpperArc_im (s : ℝ) : (diskUpperArc s).im = Real.sin (Real.pi*s) := by
+  simp only [diskUpperArc,Complex.add_im,Complex.neg_im,Complex.ofReal_im,neg_zero,
+    Complex.mul_im,Complex.ofReal_re,Complex.I_im,Complex.I_re,mul_one,mul_zero,
+    add_zero,zero_add]
+
+lemma diskUpperArc_norm (s : ℝ) : ‖diskUpperArc s‖=1 := by
+  have hn : Complex.normSq (diskUpperArc s)=1 := by
+    rw [Complex.normSq_apply,diskUpperArc_re,diskUpperArc_im]
+    nlinarith [Real.sin_sq_add_cos_sq (Real.pi*s)]
+  rw [Complex.normSq_eq_norm_sq] at hn
+  nlinarith [norm_nonneg (diskUpperArc s)]
+
+lemma diskUpperArc_injOn : InjOn diskUpperArc (Icc 0 1) := by
+  intro s hs t ht he
+  have hr : -Real.cos (Real.pi*s) = -Real.cos (Real.pi*t) := by
+    simpa only [diskUpperArc_re] using congrArg Complex.re he
+  have heq : Real.pi*s=Real.pi*t := Real.strictAntiOn_cos.injOn
+    ⟨mul_nonneg Real.pi_pos.le hs.1,mul_le_of_le_one_right Real.pi_pos.le hs.2⟩
+    ⟨mul_nonneg Real.pi_pos.le ht.1,mul_le_of_le_one_right Real.pi_pos.le ht.2⟩ (by linarith)
+  exact mul_left_cancel₀ Real.pi_ne_zero heq
+
+lemma disk_crosscut_meets_upper_at_endpoints
+    (p : ℝ → ℂ) (hp : ∀ s ∈ Ioo 0 1, ‖p s‖ < 1)
+    (s : ℝ) (hs : s ∈ Icc 0 1) (hmem : p s ∈ diskUpperArc '' Icc 0 1) :
+    s=0 ∨ s=1 := by
+  by_contra hn
+  have hs0 : 0 < s := lt_of_le_of_ne hs.1 (by intro he; exact hn (Or.inl he.symm))
+  have hs1 : s < 1 := lt_of_le_of_ne hs.2 (by intro he; exact hn (Or.inr he))
+  obtain ⟨t,_ht,he⟩ := hmem
+  have hh := hp s ⟨hs0,hs1⟩
+  rw [← he,diskUpperArc_norm] at hh
+  exact lt_irrefl _ hh
+
+theorem disk_crosscut_upper_jordan
+    (p : ℝ → ℂ) (hc : ContinuousOn p (Icc 0 1)) (hi : InjOn p (Icc 0 1))
+    (h0 : p 0=-1) (h1 : p 1=1) (hp : ∀ s ∈ Ioo 0 1, ‖p s‖ < 1) :
+    Schoenflies.IsJordanCurve
+      (complexPlaneCoordinates '' (p '' Icc 0 1 ∪ diskUpperArc '' Icc 0 1)) := by
+  have hpArc := complexPlaneCoordinates_isArcBetween p hc hi
+  have haArc := complexPlaneCoordinates_isArcBetween diskUpperArc
+    diskUpperArc_continuous.continuousOn diskUpperArc_injOn
+  rw [diskUpperArc_zero,diskUpperArc_one,← h0,← h1] at haArc
+  rw [image_union]
+  apply Schoenflies.isJordanCurve_union hpArc haArc
+  rintro _ ⟨_,⟨s,hs,rfl⟩,rfl⟩ ⟨_,⟨t,ht,rfl⟩,he⟩
+  have het : diskUpperArc t=p s := complexPlaneCoordinates.injective he
+  rcases disk_crosscut_meets_upper_at_endpoints p hp s hs ⟨t,ht,het⟩ with rfl | rfl
+  · exact Or.inl rfl
+  · exact Or.inr rfl
+
+end SLEExactGauge
+
+end
+
+end OAI
diff --git a/lean/OAI/Probability/SLE/Geometry/DiskCrosscutClosedRegions.lean b/lean/OAI/Probability/SLE/Geometry/DiskCrosscutClosedRegions.lean
new file mode 100644
index 0000000000000000000000000000000000000000..76abab8e76638a7c857d8867b8fecb4423f98698
--- /dev/null
+++ b/lean/OAI/Probability/SLE/Geometry/DiskCrosscutClosedRegions.lean
@@ -0,0 +1,140 @@
+import OAI.Probability.SLE.Geometry.DiskCrosscutPartition
+
+namespace OAI
+
+/-! The closures of the two disk crosscut regions cover the closed disk
+and meet exactly along the crosscut. -/
+noncomputable section
+open Set Complex Metric
+open scoped ComplexConjugate
+
+namespace SLEExactGauge
+
+theorem disk_crosscut_lower_jordan
+    (p : ℝ → ℂ) (hc : ContinuousOn p (Icc 0 1)) (hi : InjOn p (Icc 0 1))
+    (h0 : p 0=-1) (h1 : p 1=1) (hp : ∀ s ∈ Ioo 0 1, ‖p s‖ < 1) :
+    Schoenflies.IsJordanCurve
+      (complexPlaneCoordinates '' (diskLowerArc '' Icc 0 1 ∪ p '' Icc 0 1)) := by
+  have hpArc := complexPlaneCoordinates_isArcBetween p hc hi
+  have haArc := complexPlaneCoordinates_isArcBetween diskLowerArc
+    diskLowerArc_continuous.continuousOn diskLowerArc_injOn
+  rw [diskLowerArc_zero,diskLowerArc_one,← h0,← h1] at haArc
+  rw [image_union]
+  apply Schoenflies.isJordanCurve_union haArc hpArc
+  rintro _ ⟨_,⟨t,ht,rfl⟩,rfl⟩ ⟨_,⟨s,hs,rfl⟩,he⟩
+  have heq : p s=diskLowerArc t := complexPlaneCoordinates.injective he
+  have hend : s=0 ∨ s=1 := by
+    by_contra hn
+    have hs0 : 0<s := lt_of_le_of_ne hs.1 (by intro he; exact hn (Or.inl he.symm))
+    have hs1 : s<1 := lt_of_le_of_ne hs.2 (by intro he; exact hn (Or.inr he))
+    have hh := hp s ⟨hs0,hs1⟩
+    rw [heq] at hh
+    have hn1 : ‖diskLowerArc t‖=1 := by simpa [diskLowerArc] using diskUpperArc_norm t
+    rw [hn1] at hh
+    exact lt_irrefl _ hh
+  rcases hend with rfl|rfl
+  · exact Or.inl (by rw [← heq,h0,← diskLowerArc_zero])
+  · exact Or.inr (by rw [← heq,h1,← diskLowerArc_one])
+
+lemma complexInside_not_mem {C : Set ℂ} {z : ℂ} (hz : z ∈ complexInside C) : z ∉ C := by
+  intro hc
+  exact hz.1 (mem_image_of_mem complexPlaneCoordinates hc)
+
+theorem disk_crosscut_closed_regions
+    (p : ℝ → ℂ) (hc : ContinuousOn p (Icc 0 1)) (hi : InjOn p (Icc 0 1))
+    (h0 : p 0=-1) (h1 : p 1=1) (hp : ∀ s ∈ Ioo 0 1, ‖p s‖ < 1) :
+    let U := complexInside (diskUpperArc '' Icc 0 1 ∪ p '' Icc 0 1)
+    let V := complexInside (diskLowerArc '' Icc 0 1 ∪ p '' Icc 0 1)
+    closure U ∪ closure V=closedBall (0:ℂ) 1 ∧
+      closure U ∩ closure V=p '' Icc 0 1 := by
+  dsimp only
+  let A := diskUpperArc '' Icc 0 1
+  let B := diskLowerArc '' Icc 0 1
+  let P := p '' Icc 0 1
+  let U := complexInside (A ∪ P)
+  let V := complexInside (B ∪ P)
+  have hJ : Schoenflies.IsJordanCurve (complexPlaneCoordinates '' (A ∪ P)) := by
+    simpa only [union_comm] using disk_crosscut_upper_jordan p hc hi h0 h1 hp
+  have hL := disk_crosscut_lower_jordan p hc hi h0 h1 hp
+  have hUc : closure U=U ∪ (A ∪ P) := complexInside_closure hJ
+  have hVc : closure V=V ∪ (B ∪ P) := complexInside_closure hL
+  obtain ⟨hpart,hdisj⟩ := disk_crosscut_partition p hc hi h0 h1 hp
+  change ball (0:ℂ) 1 \ P=U ∪ V at hpart
+  change Disjoint U V at hdisj
+  have hUV : U ∪ V ⊆ ball (0:ℂ) 1 := by rw [← hpart]; exact sdiff_subset
+  have hP : P ⊆ closedBall (0:ℂ) 1 := by
+    rintro z ⟨s,hs,rfl⟩
+    by_cases hs0 : s=0
+    · simp [hs0,h0]
+    by_cases hs1 : s=1
+    · simp [hs1,h1]
+    apply ball_subset_closedBall
+    simpa only [mem_ball,dist_zero_right] using hp s
+      ⟨lt_of_le_of_ne hs.1 (Ne.symm hs0),lt_of_le_of_ne hs.2 hs1⟩
+  have hAB : A ∪ B={z : ℂ | ‖z‖=1} := disk_semicircle_union
+  have hABn (z : ℂ) (hz : z ∈ A ∪ B) : z ∉ ball (0:ℂ) 1 := by
+    rw [hAB] at hz
+    change ‖z‖=1 at hz
+    simpa only [mem_ball,dist_zero_right,hz,lt_self_iff_false] using not_false
+  have hABP : A ∩ B ⊆ P := by
+    rw [disk_semicircle_inter]
+    intro z hz
+    rcases hz with hz|hz
+    · exact ⟨0,by norm_num,by simpa only [h0] using hz.symm⟩
+    · exact ⟨1,by norm_num,by simpa only [h1] using hz.symm⟩
+  rw [hUc,hVc]
+  constructor
+  · ext z
+    constructor
+    · rintro ((hz|hz)|(hz|hz))
+      · exact ball_subset_closedBall (hUV (Or.inl hz))
+      · rcases hz with hz|hz
+        · have hh : z ∈ A ∪ B := Or.inl hz
+          rw [hAB] at hh
+          change ‖z‖=1 at hh
+          simpa only [mem_closedBall,dist_zero_right,hh] using (le_refl (1:ℝ))
+        · exact hP hz
+      · exact ball_subset_closedBall (hUV (Or.inr hz))
+      · rcases hz with hz|hz
+        · have hh : z ∈ A ∪ B := Or.inr hz
+          rw [hAB] at hh
+          change ‖z‖=1 at hh
+          simpa only [mem_closedBall,dist_zero_right,hh] using (le_refl (1:ℝ))
+        · exact hP hz
+    · intro hz
+      by_cases hzP : z ∈ P
+      · exact Or.inl (Or.inr (Or.inr hzP))
+      have hn : ‖z‖ ≤ 1 := by simpa only [mem_closedBall,dist_zero_right] using hz
+      rcases lt_or_eq_of_le hn with hn|hn
+      · have hh : z ∈ U ∪ V := hpart ▸ ⟨by simpa only [mem_ball,dist_zero_right] using hn,hzP⟩
+        rcases hh with hh|hh
+        · exact Or.inl (Or.inl hh)
+        · exact Or.inr (Or.inl hh)
+      · have hh : z ∈ A ∪ B := hAB.symm ▸ hn
+        rcases hh with hh|hh
+        · exact Or.inl (Or.inr (Or.inl hh))
+        · exact Or.inr (Or.inr (Or.inl hh))
+  · ext z
+    constructor
+    · rintro ⟨hz,hz'⟩
+      rcases hz with hz|hz
+      · rcases hz' with hz'|hz'
+        · exact False.elim (Set.disjoint_left.mp hdisj hz hz')
+        · rcases hz' with hz'|hz'
+          · exact False.elim (hABn z (Or.inr hz') (hUV (Or.inl hz)))
+          · exact hz'
+      · rcases hz with hz|hz
+        · rcases hz' with hz'|hz'
+          · exact False.elim (hABn z (Or.inl hz) (hUV (Or.inr hz')))
+          · rcases hz' with hz'|hz'
+            · exact hABP ⟨hz,hz'⟩
+            · exact hz'
+        · exact hz
+    · intro hz
+      exact ⟨Or.inr (Or.inr hz),Or.inr (Or.inr hz)⟩
+
+end SLEExactGauge
+
+end
+
+end OAI
diff --git a/lean/OAI/Probability/SLE/Geometry/DiskCrosscutHomeomorph.lean b/lean/OAI/Probability/SLE/Geometry/DiskCrosscutHomeomorph.lean
new file mode 100644
index 0000000000000000000000000000000000000000..b5b4cc039a9bc63fd8863d51c1a9e467eae4c045
--- /dev/null
+++ b/lean/OAI/Probability/SLE/Geometry/DiskCrosscutHomeomorph.lean
@@ -0,0 +1,79 @@
+import OAI.Probability.SLE.Geometry.DiskSideRegionImages
+import OAI.Probability.SLE.Geometry.DiskTwoSideGlue
+
+namespace OAI
+
+/-! A parameter-preserving disk crosscut extension, fixing the whole circle. -/
+noncomputable section
+open Set Complex Metric
+
+namespace SLEExactGauge
+
+theorem disk_crosscut_homeomorph
+    (p : ℝ → ℂ) (hc : ContinuousOn p (Icc 0 1)) (hi : InjOn p (Icc 0 1))
+    (h0 : p 0=-1) (h1 : p 1=1) (hp : ∀ s ∈ Ioo 0 1, ‖p s‖ < 1) :
+    ∃ e : closedBall (0:ℂ) 1 ≃ₜ closedBall (0:ℂ) 1,
+      (∀ s ∈ Icc 0 1, ∀ hs : p s ∈ closedBall (0:ℂ) 1,
+        (e ⟨p s,hs⟩:ℂ)=diskDiameter s) ∧
+      ∀ z : closedBall (0:ℂ) 1, ‖(z:ℂ)‖=1 → (e z:ℂ)=z := by
+  classical
+  let A := closure (complexInside (diskUpperArc '' Icc 0 1 ∪ p '' Icc 0 1))
+  let B := closure (complexInside (diskLowerArc '' Icc 0 1 ∪ p '' Icc 0 1))
+  obtain ⟨hAB,hmeet⟩ := disk_crosscut_closed_regions p hc hi h0 h1 hp
+  change A ∪ B=closedBall (0:ℂ) 1 at hAB
+  change A ∩ B=p '' Icc 0 1 at hmeet
+  obtain ⟨H,hHP,hHA⟩ := disk_crosscut_upper_straightening p hc hi h0 h1 hp
+  obtain ⟨G,hGP,hGB⟩ := disk_crosscut_lower_straightening p hc hi h0 h1 hp
+  have hH := disk_upper_region_image p H hHP hHA
+  have hG := disk_lower_region_image p G hGP hGB
+  have he (z : ℂ) (hz : z ∈ A ∩ B) : H z=G z := by
+    rw [hmeet] at hz
+    obtain ⟨s,hs,rfl⟩ := hz
+    rw [hHP s hs,hGP s hs]
+  have hrev (z : ℂ) (hz : z ∈ closedUpperDisk ∩ closedLowerDisk) :
+      H.symm z=G.symm z := by
+    rw [closed_halfDisks_inter] at hz
+    obtain ⟨s,hs,rfl⟩ := hz
+    calc
+      H.symm (diskDiameter s)=p s := by rw [← hHP s hs,H.symm_apply_apply]
+      _=G.symm (diskDiameter s) := by rw [← hGP s hs,G.symm_apply_apply]
+  let e := closedDiskTwoSideHomeomorph (show IsClosed A from isClosed_closure)
+    (show IsClosed B from isClosed_closure) hAB H G hH hG he hrev
+  have heval (z : closedBall (0:ℂ) 1) : (e z:ℂ)=if z.val ∈ A then H z else G z :=
+    closedDiskTwoSideHomeomorph_apply _ _ hAB H G hH hG he hrev z
+  have hPA (s : ℝ) (hs : s ∈ Icc 0 1) : p s ∈ A := by
+    have hh : p s ∈ A ∩ B := by rw [hmeet]; exact ⟨s,hs,rfl⟩
+    exact hh.1
+  have hupper : Schoenflies.IsJordanCurve
+      (complexPlaneCoordinates '' (diskUpperArc '' Icc 0 1 ∪ p '' Icc 0 1)) := by
+    simpa only [union_comm] using disk_crosscut_upper_jordan p hc hi h0 h1 hp
+  have hlower := disk_crosscut_lower_jordan p hc hi h0 h1 hp
+  have hAc := complexInside_closure hupper
+  have hBc := complexInside_closure hlower
+  refine ⟨e,?_,?_⟩
+  · intro s hs hps
+    rw [heval,ite_eq_left (hPA s hs),hHP s hs]
+  · intro z hz
+    have hzAB : z.val ∈ diskUpperArc '' Icc 0 1 ∪ diskLowerArc '' Icc 0 1 := by
+      rw [disk_semicircle_union]
+      exact hz
+    rcases hzAB with hzA|hzB
+    · have hzAc : z.val ∈ A := by
+        change z.val ∈ closure (complexInside _)
+        rw [hAc]
+        exact Or.inr (Or.inl hzA)
+      rw [heval,ite_eq_left hzAc,hHA z hzA]
+    · have hzBc : z.val ∈ B := by
+        change z.val ∈ closure (complexInside _)
+        rw [hBc]
+        exact Or.inr (Or.inl hzB)
+      rw [heval]
+      split_ifs with hzAc
+      · rw [he z ⟨hzAc,hzBc⟩,hGB z hzB]
+      · exact hGB z hzB
+
+end SLEExactGauge
+
+end
+
+end OAI
diff --git a/lean/OAI/Probability/SLE/Geometry/DiskCrosscutPartition.lean b/lean/OAI/Probability/SLE/Geometry/DiskCrosscutPartition.lean
new file mode 100644
index 0000000000000000000000000000000000000000..70180f90c9f298eafdd72c6115bd303e2abd12b9
--- /dev/null
+++ b/lean/OAI/Probability/SLE/Geometry/DiskCrosscutPartition.lean
@@ -0,0 +1,105 @@
+import OAI.Probability.SLE.Geometry.DiskBoundaryRegion
+import OAI.Probability.SLE.Geometry.TransportCrosscutPartition
+
+namespace OAI
+
+/-! The two bounded regions of a compact disk crosscut exhaust its complement. -/
+noncomputable section
+open Set Complex Metric
+
+namespace SLEExactGauge
+
+lemma diskDiameter_plane_segment :
+    complexPlaneCoordinates '' (diskDiameter '' Icc 0 1)=
+      segment ℝ (complexPlaneCoordinates (-1)) (complexPlaneCoordinates 1) := by
+  rw [image_image,segment_eq_image_lineMap]
+  congr 1
+  funext s
+  rw [AffineMap.lineMap_apply_module]
+  change !₂[(diskDiameter s).re,(diskDiameter s).im]=
+    (1-s) • !₂[(-1:ℂ).re,(-1:ℂ).im] + s • !₂[(1:ℂ).re,(1:ℂ).im]
+  ext i
+  fin_cases i
+  · norm_num [diskDiameter]
+    ring
+  · norm_num [diskDiameter]
+
+theorem disk_crosscut_partition
+    (p : ℝ → ℂ) (hc : ContinuousOn p (Icc 0 1)) (hi : InjOn p (Icc 0 1))
+    (h0 : p 0=-1) (h1 : p 1=1) (hp : ∀ s ∈ Ioo 0 1, ‖p s‖ < 1) :
+    ball (0:ℂ) 1 \ (p '' Icc 0 1) =
+      complexInside (diskUpperArc '' Icc 0 1 ∪ p '' Icc 0 1) ∪
+      complexInside (diskLowerArc '' Icc 0 1 ∪ p '' Icc 0 1) ∧
+    Disjoint (complexInside (diskUpperArc '' Icc 0 1 ∪ p '' Icc 0 1))
+      (complexInside (diskLowerArc '' Icc 0 1 ∪ p '' Icc 0 1)) := by
+  let c := complexPlaneCoordinates
+  let C : Set ℂ := {z | ‖z‖=1}
+  let P := p '' Icc 0 1
+  let A := diskUpperArc '' Icc 0 1
+  let B := diskLowerArc '' Icc 0 1
+  obtain ⟨H,hHp,hHA⟩ := disk_crosscut_upper_straightening p hc hi h0 h1 hp
+  have hHP : H '' P=diskDiameter '' Icc 0 1 := by
+    ext z
+    constructor
+    · rintro ⟨_,⟨s,hs,rfl⟩,rfl⟩
+      exact ⟨s,hs,(hHp s hs).symm⟩
+    · rintro ⟨s,hs,rfl⟩
+      exact ⟨p s,mem_image_of_mem p hs,hHp s hs⟩
+  let G : Schoenflies.Plane ≃ₜ Schoenflies.Plane := (c.symm.trans H).trans c
+  have hGP : G '' (c '' P)=c '' (H '' P) := by
+    ext z
+    simp [G]
+  have hpoly : Schoenflies.IsPolygonal (G '' (c '' P)) := by
+    rw [hGP,hHP,diskDiameter_plane_segment]
+    exact Schoenflies.isPolygonal_segment _ _
+  have hcut : Schoenflies.IsCutPair (c '' C) (c (-1)) (c 1) (c '' A) (c '' B) := by
+    refine ⟨?_,?_,?_,?_⟩
+    · simpa only [diskUpperArc_zero,diskUpperArc_one] using
+        complexPlaneCoordinates_isArcBetween diskUpperArc
+          diskUpperArc_continuous.continuousOn diskUpperArc_injOn
+    · simpa only [diskLowerArc_zero,diskLowerArc_one] using
+        complexPlaneCoordinates_isArcBetween diskLowerArc
+          diskLowerArc_continuous.continuousOn diskLowerArc_injOn
+    · rw [← image_union]
+      exact congrArg (fun S => c '' S) disk_semicircle_union
+    · rw [← image_inter c.injective]
+      rw [disk_semicircle_inter,image_pair]
+  have hPin : c '' P \ {c (-1),c 1} ⊆ Schoenflies.inside (c '' C) := by
+    rintro z ⟨⟨_,⟨s,hs,rfl⟩,rfl⟩,hne⟩
+    have hs0 : s ≠ 0 := by
+      intro he
+      apply hne
+      simp [he,h0]
+    have hs1 : s ≠ 1 := by
+      intro he
+      apply hne
+      simp [he,h1]
+    have hball : p s ∈ ball (0:ℂ) 1 := by
+      simpa only [mem_ball,dist_zero_right] using
+        hp s ⟨lt_of_le_of_ne hs.1 (Ne.symm hs0),lt_of_le_of_ne hs.2 hs1⟩
+    have hin : p s ∈ complexInside C := by rwa [complexInside_unitDisk]
+    exact hin
+  have hP : Schoenflies.IsArcBetween (c '' P) (c (-1)) (c 1) := by
+    simpa only [h0,h1] using complexPlaneCoordinates_isArcBetween p hc hi
+  obtain ⟨he,hd⟩ := plane_crosscut_partition_of_straightening disk_circle_jordan hP hcut
+    (mem_image_of_mem c (by simp)) (mem_image_of_mem c (by simp)) hPin G hpoly
+  dsimp [c,C,P,A,B] at he hd
+  refine ⟨?_,?_⟩
+  · rw [← complexInside_unitDisk]
+    apply complexPlaneCoordinates.injective.image_injective
+    simpa only [image_sdiff complexPlaneCoordinates.injective,complexInside_image,image_union] using he
+  · rw [Set.disjoint_left] at hd ⊢
+    intro z hz hz'
+    apply hd (a := complexPlaneCoordinates z)
+    · have hh : complexPlaneCoordinates z ∈ Schoenflies.inside
+          (complexPlaneCoordinates '' (diskUpperArc '' Icc 0 1 ∪ p '' Icc 0 1)) := hz
+      simpa only [image_union] using hh
+    · have hh : complexPlaneCoordinates z ∈ Schoenflies.inside
+          (complexPlaneCoordinates '' (diskLowerArc '' Icc 0 1 ∪ p '' Icc 0 1)) := hz'
+      simpa only [image_union] using hh
+
+end SLEExactGauge
+
+end
+
+end OAI
diff --git a/lean/OAI/Probability/SLE/Geometry/DiskGrowthFromSecondCoefficient.lean b/lean/OAI/Probability/SLE/Geometry/DiskGrowthFromSecondCoefficient.lean
new file mode 100644
index 0000000000000000000000000000000000000000..e092c626d4fd5d22c04df9bdba54e7f4dc0ed6dc
--- /dev/null
+++ b/lean/OAI/Probability/SLE/Geometry/DiskGrowthFromSecondCoefficient.lean
@@ -0,0 +1,92 @@
+import OAI.Probability.SLE.Loewner.UnivalentRadialDerivative
+import OAI.Probability.SLE.Multipoint.MultipointGeometry
+
+namespace OAI
+
+/-! Integrating the sharp second-coefficient estimate gives the growth
+bounds for normalized univalent disk maps. -/
+noncomputable section
+open Set Filter Metric Function MeasureTheory
+open scoped Topology
+
+namespace SLEExactGauge
+
+theorem diskGrowth_of_secondDerivative
+    (hsecond : ∀ f : ℂ → ℂ, DifferentiableOn ℂ f (ball 0 1) →
+      InjOn f (ball 0 1) → ‖deriv (deriv f) 0‖≤4*‖deriv f 0‖) :
+    PublishedDiskUnivalentGrowth := by
+  intro f hf hi z hz
+  by_cases hz0 : z=0
+  · simp [hz0]
+  let r := ‖z‖
+  have hrp : 0<r := norm_pos_iff.mpr hz0
+  have hr1 : r<1 := mem_ball_zero_iff.mp hz
+  let u := z/(r:ℂ)
+  have hu : ‖u‖=1 := by
+    dsimp [u,r]
+    simp only [norm_div,Complex.norm_real,Real.norm_eq_abs,abs_norm]
+    exact div_self (norm_ne_zero_iff.mpr hz0)
+  have hru : (r:ℂ)*u=z := by
+    dsimp [u]
+    field_simp [Complex.ofReal_ne_zero.mpr hrp.ne']
+  have hpre := fun (a : ℂ) (ha : ‖a‖<1) =>
+    univalent_preSchwarzian_of_second_derivative hsecond hf hi (a := a) ha
+  let v (t : ℝ) := f ((t:ℂ)*u)
+  let v' (t : ℝ) := u*deriv f ((t:ℂ)*u)
+  let g (t : ℝ) := ‖deriv f 0‖*(1+t)/(1-t)^3
+  let G (t : ℝ) := ‖deriv f 0‖*t/(1-t)^2
+  have hat (t : ℝ) (ht : t∈Icc 0 r) : (t:ℂ)*u∈ball 0 1 := by
+    rw [mem_ball_zero_iff,norm_mul,hu,mul_one,Complex.norm_real,Real.norm_eq_abs,abs_of_nonneg ht.1]
+    exact ht.2.trans_lt hr1
+  have hv' (t : ℝ) (ht : t∈Icc 0 r) : HasDerivAt v (v' t) t := by
+    have hd := ((hf.differentiableAt (isOpen_ball.mem_nhds (hat t ht))).hasDerivAt.hasFDerivAt.restrictScalars ℝ).comp_hasDerivAt t
+      ((Complex.ofRealCLM.hasDerivAt (x := t)).mul_const u)
+    simpa only [ContinuousLinearMap.coe_restrictScalars',ContinuousLinearMap.toSpanSingleton_apply,
+      smul_eq_mul,Complex.ofRealCLM_apply,Complex.ofReal_one,one_mul,Function.comp_def,v,v'] using hd
+  have hv'c : ContinuousOn v' (Icc 0 r) := by
+    apply continuousOn_const.mul
+    intro t ht
+    have houter : ContinuousAt (deriv f) ((t:ℂ)*u) :=
+      (hf.analyticAt (isOpen_ball.mem_nhds (hat t ht))).deriv.continuousAt
+    exact (ContinuousAt.comp (g := deriv f) (f := fun s : ℝ => (s:ℂ)*u)
+      houter (by fun_prop)).continuousWithinAt
+  have hgc : ContinuousOn g (Icc 0 r) := by
+    apply ContinuousOn.div (by fun_prop) (by fun_prop)
+    intro t ht
+    exact pow_ne_zero _ (by linarith [ht.2,hr1])
+  have hG (t : ℝ) (ht : t∈Icc 0 r) : HasDerivAt G (g t) t := by
+    have hm : 1-t≠0 := by linarith [ht.2,hr1]
+    have h := ((hasDerivAt_id t).const_mul ‖deriv f 0‖).div
+      (((hasDerivAt_id t).const_sub 1).pow 2) (pow_ne_zero _ hm)
+    change HasDerivAt G _ t at h
+    convert h using 1
+    dsimp [g]
+    field_simp
+    ring
+  have hvint : ∫ t in (0:ℝ)..r, v' t=f z-f 0 := by
+    have h := intervalIntegral.integral_eq_sub_of_hasDerivAt (a := 0) (b := r)
+      (fun t ht => hv' t (by simpa only [uIcc_of_le hrp.le] using ht))
+      (hv'c.intervalIntegrable_of_Icc hrp.le)
+    simpa only [v,hru,Complex.ofReal_zero,zero_mul] using h
+  have hgint : ∫ t in (0:ℝ)..r, g t=G r := by
+    have h := intervalIntegral.integral_eq_sub_of_hasDerivAt (a := 0) (b := r)
+      (fun t ht => hG t (by simpa only [uIcc_of_le hrp.le] using ht))
+      (hgc.intervalIntegrable_of_Icc hrp.le)
+    simpa [G] using h
+  calc
+    ‖f z-f 0‖ = ‖∫ t in (0:ℝ)..r, v' t‖ := congrArg norm hvint.symm
+    _ ≤ ∫ t in (0:ℝ)..r, ‖v' t‖ := intervalIntegral.norm_integral_le_integral_norm hrp.le
+    _ ≤ ∫ t in (0:ℝ)..r, g t := by
+      apply intervalIntegral.integral_mono_on hrp.le
+        (hv'c.norm.intervalIntegrable_of_Icc hrp.le) (hgc.intervalIntegrable_of_Icc hrp.le)
+      intro t ht
+      dsimp only [v']
+      rw [norm_mul,hu,one_mul]
+      exact univalent_radial_derivative_bound hf hi hpre u hu t ⟨ht.1,ht.2.trans_lt hr1⟩
+    _ = ‖deriv f 0‖*‖z‖/(1-‖z‖)^2 := hgint
+
+end SLEExactGauge
+
+end
+
+end OAI
diff --git a/lean/OAI/Probability/SLE/Geometry/DiskKernelRemainder.lean b/lean/OAI/Probability/SLE/Geometry/DiskKernelRemainder.lean
new file mode 100644
index 0000000000000000000000000000000000000000..27a87f6065763b8909b91b0c93f0ae493259b274
--- /dev/null
+++ b/lean/OAI/Probability/SLE/Geometry/DiskKernelRemainder.lean
@@ -0,0 +1,60 @@
+import OAI.Probability.SLE.Geometry.PositiveRealDiskEstimate
+
+namespace OAI
+
+/-! A quantitative first-order kernel estimate for the inverted
+positive-real function of a small slit. -/
+noncomputable section
+open Set Filter Function Metric Complex
+open scoped Topology
+
+namespace SLEExactGauge
+
+lemma disk_kernel_remainder {v w : ℂ} {m : ℝ} (hm : 0<m) (hw : ‖w‖≤1/2)
+    (hv : ‖v-(m:ℂ)‖≤4*m*‖w‖) :
+    ‖w*v/(1-w^2)-(m:ℂ)*w‖≤10*m*‖w‖^2 := by
+  have hr : 0≤‖w‖ := norm_nonneg _
+  have hr1 : ‖w‖≤1 := by linarith
+  have hd : 1/2≤‖(1:ℂ)-w^2‖ := by
+    have hn := norm_sub_norm_le (1:ℂ) (w^2)
+    rw [norm_one,norm_pow] at hn
+    nlinarith
+  have hdp : 0<‖(1:ℂ)-w^2‖ := by linarith
+  have hd0 : (1:ℂ)-w^2≠0 := norm_pos_iff.mp hdp
+  have he : w*v/(1-w^2)-(m:ℂ)*w=
+      w*((v-(m:ℂ))+(m:ℂ)*w^2)/(1-w^2) := by
+    field_simp [hd0]
+    ring
+  have hv' : ‖(v-(m:ℂ))+(m:ℂ)*w^2‖≤5*m*‖w‖ := by
+    calc
+      ‖(v-(m:ℂ))+(m:ℂ)*w^2‖ ≤ ‖v-(m:ℂ)‖+‖(m:ℂ)*w^2‖ := norm_add_le _ _
+      _ ≤ 4*m*‖w‖+m*‖w‖^2 := by
+        rw [norm_mul,norm_pow,Complex.norm_real,Real.norm_eq_abs,abs_of_pos hm]
+        exact add_le_add hv le_rfl
+      _ ≤ 5*m*‖w‖ := by nlinarith [mul_nonneg hm.le (mul_nonneg hr (sub_nonneg.mpr hr1))]
+  rw [he,norm_div,norm_mul]
+  calc
+    ‖w‖*‖(v-(m:ℂ))+(m:ℂ)*w^2‖/‖(1:ℂ)-w^2‖ ≤
+        ‖w‖*(5*m*‖w‖)/‖(1:ℂ)-w^2‖ :=
+      div_le_div_of_nonneg_right (mul_le_mul_of_nonneg_left hv' hr) hdp.le
+    _ ≤ ‖w‖*(5*m*‖w‖)/(1/2) :=
+      div_le_div_of_nonneg_left (by positivity) (by norm_num) hd
+    _ = 10*m*‖w‖^2 := by ring
+
+theorem positive_real_disk_kernel_remainder {H : ℂ → ℂ} {m : ℝ} (hm : 0<m)
+    (hH : DifferentiableOn ℂ H (ball 0 1)) (h0 : H 0=(m:ℂ))
+    (hpos : ∀ z∈ball (0:ℂ) 1, 0≤(H z).re)
+    {w : ℂ} (hw : ‖w‖≤1/2) :
+    ‖w*H w/(1-w^2)-(m:ℂ)*w‖≤10*m*‖w‖^2 := by
+  apply disk_kernel_remainder hm hw
+  have hr : ‖w‖<1 := by linarith
+  have hb := positive_real_disk_deviation hm hH h0 hpos (mem_ball_zero_iff.mpr hr)
+  apply hb.trans
+  apply (div_le_iff₀ (sub_pos.mpr hr)).mpr
+  nlinarith [norm_nonneg w, mul_nonneg hm.le (norm_nonneg w)]
+
+end SLEExactGauge
+
+end
+
+end OAI
diff --git a/lean/OAI/Probability/SLE/Geometry/DiskLowerStraightening.lean b/lean/OAI/Probability/SLE/Geometry/DiskLowerStraightening.lean
new file mode 100644
index 0000000000000000000000000000000000000000..ea01438fea47f34e5bfc08055d3766f322122e06
--- /dev/null
+++ b/lean/OAI/Probability/SLE/Geometry/DiskLowerStraightening.lean
@@ -0,0 +1,44 @@
+import OAI.Probability.SLE.Geometry.DiskUpperStraightening
+
+namespace OAI
+
+/-! Reflection gives the second prescribed boundary extension. -/
+noncomputable section
+open Set Complex
+open scoped ComplexConjugate
+
+namespace SLEExactGauge
+
+def diskLowerArc (s : ℝ) : ℂ := conj (diskUpperArc s)
+
+theorem disk_crosscut_lower_straightening
+    (p : ℝ → ℂ) (hc : ContinuousOn p (Icc 0 1)) (hi : InjOn p (Icc 0 1))
+    (h0 : p 0=-1) (h1 : p 1=1) (hp : ∀ s ∈ Ioo 0 1, ‖p s‖ < 1) :
+    ∃ H : ℂ ≃ₜ ℂ,
+      (∀ s ∈ Icc 0 1, H (p s)=diskDiameter s) ∧
+      ∀ z ∈ diskLowerArc '' Icc 0 1, H z=z := by
+  let q (s : ℝ) := conj (p s)
+  have hqc : ContinuousOn q (Icc 0 1) := Complex.continuous_conj.comp_continuousOn hc
+  have hqi : InjOn q (Icc 0 1) := by
+    intro s hs t ht he
+    exact hi hs ht (Complex.conjCLE.injective he)
+  have hq0 : q 0=-1 := by simp [q,h0]
+  have hq1 : q 1=1 := by simp [q,h1]
+  have hqp (s : ℝ) (hs : s ∈ Ioo 0 1) : ‖q s‖ < 1 := by simpa [q] using hp s hs
+  obtain ⟨H,hHp,hHa⟩ := disk_crosscut_upper_straightening q hqc hqi hq0 hq1 hqp
+  let C : ℂ ≃ₜ ℂ := Complex.conjCLE.toHomeomorph
+  refine ⟨(C.trans H).trans C,?_,?_⟩
+  · intro s hs
+    change conj (H (q s))=diskDiameter s
+    rw [hHp s hs]
+    exact Complex.conj_ofReal _
+  · rintro z ⟨s,hs,rfl⟩
+    change conj (H (conj (diskLowerArc s)))=diskLowerArc s
+    simp only [diskLowerArc,Complex.conj_conj]
+    rw [hHa _ (mem_image_of_mem diskUpperArc hs)]
+
+end SLEExactGauge
+
+end
+
+end OAI
diff --git a/lean/OAI/Probability/SLE/Geometry/DiskPoissonPeaks.lean b/lean/OAI/Probability/SLE/Geometry/DiskPoissonPeaks.lean
new file mode 100644
index 0000000000000000000000000000000000000000..a2fa2258748141af2d6878a17022c1af777a562a
--- /dev/null
+++ b/lean/OAI/Probability/SLE/Geometry/DiskPoissonPeaks.lean
@@ -0,0 +1,78 @@
+import OAI.Probability.SLE.Geometry.ConformalDiskExit
+import Mathlib.Analysis.Complex.Poisson
+
+namespace OAI
+
+/-! Bounded positive holomorphic peak tests for excluding atoms at the
+two exceptional points of the half-plane disk chart. -/
+noncomputable section
+open Set Filter MeasureTheory ProbabilityTheory Metric Complex
+open scoped Topology NNReal ENNReal
+
+namespace SLEExactGauge
+
+def diskPeak (a : ℂ) (r : ℝ) (z : ℂ) : ℂ := (a+(r:ℂ)*z)/(a-(r:ℂ)*z)
+
+lemma diskPeak_denominator {a : ℂ} (ha : ‖a‖=1) {r : ℝ} (hr : 0 ≤ r) (hr1 : r<1)
+    {z : ℂ} (hz : ‖z‖ ≤ 1) : a-(r:ℂ)*z ≠ 0 := by
+  have hb : ‖(r:ℂ)*z‖ ≤ r := by
+    rw [norm_mul,Complex.norm_real,Real.norm_eq_abs,abs_of_nonneg hr]
+    nlinarith
+  have hnorm := norm_sub_norm_le a ((r:ℂ)*z)
+  rw [ha] at hnorm
+  exact norm_pos_iff.mp (by linarith)
+
+lemma diskPeak_norm_bound {a : ℂ} (ha : ‖a‖=1) {r : ℝ} (hr : 0 ≤ r) (hr1 : r<1)
+    {z : ℂ} (hz : ‖z‖ ≤ 1) : ‖diskPeak a r z‖ ≤ (1+r)/(1-r) := by
+  have hb : ‖(r:ℂ)*z‖ ≤ r := by
+    rw [norm_mul,Complex.norm_real,Real.norm_eq_abs,abs_of_nonneg hr]
+    nlinarith
+  have hd : 1-r ≤ ‖a-(r:ℂ)*z‖ := by
+    have hh := norm_sub_norm_le a ((r:ℂ)*z)
+    rw [ha] at hh
+    linarith
+  have hn : ‖a+(r:ℂ)*z‖ ≤ 1+r := (norm_add_le _ _).trans (by rw [ha]; linarith)
+  rw [diskPeak,norm_div]
+  exact div_le_div₀ (by positivity) hn (by linarith) hd
+
+lemma diskPeak_re_nonnegative {a : ℂ} (ha : ‖a‖=1) {r : ℝ} (hr : 0 ≤ r) (hr1 : r<1)
+    {z : ℂ} (hz : ‖z‖ ≤ 1) : 0 ≤ (diskPeak a r z).re := by
+  have hb : ‖(r:ℂ)*z‖ < 1 := by
+    rw [norm_mul,Complex.norm_real,Real.norm_eq_abs,abs_of_nonneg hr]
+    nlinarith
+  have he := congrFun (poissonKernel_eq_re_herglotzRieszKernel (c := 0) (w := (r:ℂ)*z)) a
+  have he' : (diskPeak a r z).re=(1-‖(r:ℂ)*z‖^2)/‖a-(r:ℂ)*z‖^2 := by
+    simpa only [poissonKernel,herglotzRieszKernel,Function.comp_apply,sub_zero,ha,one_pow,diskPeak] using he.symm
+  rw [he']
+  exact div_nonneg (by nlinarith [norm_nonneg ((r:ℂ)*z)]) (sq_nonneg _)
+
+lemma diskPeak_differentiable {a : ℂ} (ha : ‖a‖=1) {r : ℝ} (hr : 0 ≤ r) (hr1 : r<1) :
+    DifferentiableOn ℂ (diskPeak a r) (ball 0 1) := by
+  apply ((differentiableOn_id.const_mul (r:ℂ)).const_add a).div
+    ((differentiableOn_id.const_mul (r:ℂ)).const_sub a)
+  intro z hz
+  exact diskPeak_denominator ha hr hr1 (mem_ball_zero_iff.mp hz).le
+
+lemma diskPeak_continuousAt_boundary {a z : ℂ} (ha : ‖a‖=1) {r : ℝ}
+    (hr : 0 ≤ r) (hr1 : r<1) (hz : ‖z‖ ≤ 1) : ContinuousAt (diskPeak a r) z :=
+  (continuousAt_const.add (continuousAt_const.mul continuousAt_id)).div
+    (continuousAt_const.sub (continuousAt_const.mul continuousAt_id))
+    (diskPeak_denominator ha hr hr1 hz)
+
+lemma diskPeak_zero {a : ℂ} (ha : ‖a‖=1) (r : ℝ) : diskPeak a r 0=1 := by
+  have ha0 : a≠0 := norm_ne_zero_iff.mp (ha ▸ one_ne_zero)
+  simp [diskPeak,ha0]
+
+lemma diskPeak_at_peak {a : ℂ} (ha : ‖a‖=1) (r : ℝ) :
+    diskPeak a r a=(((1+r)/(1-r):ℝ):ℂ) := by
+  have ha0 : a≠0 := norm_ne_zero_iff.mp (ha ▸ one_ne_zero)
+  rw [diskPeak,show a+(r:ℂ)*a=a*(1+r) by ring,
+    show a-(r:ℂ)*a=a*(1-r) by ring,mul_div_mul_left _ _ ha0]
+  push_cast
+  rfl
+
+end SLEExactGauge
+
+end
+
+end OAI
diff --git a/lean/OAI/Probability/SLE/Geometry/DiskQuarterDistortion.lean b/lean/OAI/Probability/SLE/Geometry/DiskQuarterDistortion.lean
new file mode 100644
index 0000000000000000000000000000000000000000..4168424bacb8996faa394359c999f727a1703e95
--- /dev/null
+++ b/lean/OAI/Probability/SLE/Geometry/DiskQuarterDistortion.lean
@@ -0,0 +1,75 @@
+import OAI.Probability.SLE.Geometry.DiskRecentering
+import OAI.Probability.SLE.Geometry.PhysicalCellDisk
+
+namespace OAI
+
+/-! Two-sided derivative comparison on the fixed quarter disk. -/
+
+noncomputable section
+open Set Filter Metric Complex
+open scoped Topology NNReal
+
+namespace SLEExactGauge
+
+lemma univalent_quarter_derivative_lower (hgrowth : PublishedDiskUnivalentGrowth)
+    {f : ℂ → ℂ} (hd : DifferentiableOn ℂ f (ball 0 1))
+    (hi : InjOn f (ball 0 1)) {w : ℂ} (hw : ‖w‖ ≤ 1/4) :
+    ‖deriv f 0‖ / 16 ≤ ‖deriv f w‖ := by
+  have hw1 : ‖w‖ < 1 := by linarith
+  let g := f ∘ diskRecenter w
+  have hgd : DifferentiableOn ℂ g (ball 0 1) :=
+    hd.comp (diskRecenter_differentiable hw1) (diskRecenter_maps hw1)
+  have hgi : InjOn g (ball 0 1) := hi.comp (diskRecenter_injOn hw1) (diskRecenter_maps hw1)
+  have hnorm (z : ℂ) (hz : z ∈ ball 0 1) :
+      ‖deriv g z‖ = ‖deriv f (diskRecenter w z)‖ * ‖deriv (diskRecenter w) z‖ := by
+    have hf := hd.differentiableAt (isOpen_ball.mem_nhds (diskRecenter_maps hw1 hz))
+    have hg := (diskRecenter_hasDerivAt hw1 (mem_ball_zero_iff.mp hz)).differentiableAt
+    change ‖deriv (f ∘ diskRecenter w) z‖ = _
+    rw [deriv_comp z hf hg,norm_mul]
+  have hzero := hnorm 0 (mem_ball_self (by norm_num : (0:ℝ)<1))
+  simp only [diskRecenter_zero,diskRecenter_deriv_zero hw1] at hzero
+  have hneg := hnorm (-w) (mem_ball_zero_iff.mpr (by simpa only [norm_neg] using hw1))
+  simp only [diskRecenter_neg,diskRecenter_deriv_neg hw1] at hneg
+  have hh := univalent_quarter_derivative_upper hgrowth hgd hgi
+    (show ‖-w‖ ≤ 1/4 by simpa only [norm_neg] using hw)
+  rw [hzero,hneg] at hh
+  let δ : ℝ := 1-‖w‖^2
+  have hδ : 0 < δ := (diskRecenter_det hw1).2
+  have hδ1 : δ ≤ 1 := by dsimp [δ]; nlinarith [sq_nonneg ‖w‖]
+  change ‖deriv f 0‖ * δ⁻¹ ≤ 16 * (‖deriv f w‖ * δ) at hh
+  have hbound : ‖deriv f 0‖ ≤ 16*‖deriv f w‖*δ^2 := by
+    calc
+      _ = (‖deriv f 0‖*δ⁻¹)*δ := by field_simp
+      _ ≤ (16*(‖deriv f w‖*δ))*δ := mul_le_mul_of_nonneg_right hh hδ.le
+      _ = _ := by ring
+  have hsq : δ^2 ≤ 1 := by nlinarith
+  have hlast := hbound.trans (mul_le_of_le_one_right
+    (mul_nonneg (by norm_num : (0:ℝ)≤16) (norm_nonneg _)) hsq)
+  linarith
+
+lemma univalent_quarter_derivative_bounds (hgrowth : PublishedDiskUnivalentGrowth)
+    {f : ℂ → ℂ} (hd : DifferentiableOn ℂ f (ball 0 1))
+    (hi : InjOn f (ball 0 1)) {w : ℂ} (hw : ‖w‖ ≤ 1/4) :
+    ‖deriv f 0‖ / 16 ≤ ‖deriv f w‖ ∧ ‖deriv f w‖ ≤ 16*‖deriv f 0‖ :=
+  ⟨univalent_quarter_derivative_lower hgrowth hd hi hw,
+    univalent_quarter_derivative_upper hgrowth hd hi hw⟩
+
+lemma IsCapacityTwoWitness.quarter_disk_derivative_bounds
+    {U : ℝ≥0 → ℝ} {γ : ℝ≥0 → ℂ} {G F : ℝ≥0 → ℂ → ℂ}
+    (hw : IsCapacityTwoWitness U γ G F) (hgrowth : PublishedDiskUnivalentGrowth)
+    (t : ℝ≥0) (z : ℂ) (hz : z ∈ survivingDomain γ t)
+    (w : ℂ) (hw' : w ∈ closedBall 0 (1/4)) :
+    fullRadius G t z / 16 ≤ ‖deriv (physicalDiskChart id F G t z) w‖ ∧
+      ‖deriv (physicalDiskChart id F G t z) w‖ ≤ 16*fullRadius G t z := by
+  obtain ⟨hd,hi,_,hder,_⟩ := hw.physical_disk_chart id differentiableOn_id
+    (fun _ _ _ _ h => h) t z hz
+  have hr : ‖deriv (physicalDiskChart id F G t z) 0‖ = fullRadius G t z := by
+    simpa [physicalConformalRadius] using hder
+  have hn : ‖w‖ ≤ 1/4 := by simpa only [mem_closedBall,dist_zero_right] using hw'
+  simpa only [hr] using univalent_quarter_derivative_bounds hgrowth hd hi hn
+
+end SLEExactGauge
+
+end
+
+end OAI
diff --git a/lean/OAI/Probability/SLE/Geometry/DiskQuarterGeometry.lean b/lean/OAI/Probability/SLE/Geometry/DiskQuarterGeometry.lean
new file mode 100644
index 0000000000000000000000000000000000000000..db1a25aad321d52f175c575b3dd7a75deff2b895
--- /dev/null
+++ b/lean/OAI/Probability/SLE/Geometry/DiskQuarterGeometry.lean
@@ -0,0 +1,99 @@
+import OAI.Probability.SLE.Multipoint.MultipointGeometry
+import OAI.Probability.SLE.AngularLaws
+
+namespace OAI
+
+/-! Compact disk-chart bounds used to compare physical cell mass with
+canonical disk mass. Coarse universal constants suffice for the gauge bounds. -/
+
+noncomputable section
+open Set Filter Metric Complex
+open scoped Topology NNReal
+
+namespace SLEExactGauge
+
+lemma univalent_ball_subset_image
+    {f : ℂ → ℂ} {r : ℝ} (hr : 0 < r)
+    (hd : DifferentiableOn ℂ f (ball 0 r)) (hi : InjOn f (ball 0 r)) :
+    ball (f 0) (r * ‖deriv f 0‖ / (128 * Real.pi)) ⊆ f '' ball 0 r := by
+  intro z hz
+  by_contra hn
+  have h := univalent_omitted_value_bound_ball hr hd hi z hn
+  have hp : 0 < 128 * Real.pi := mul_pos (by norm_num) Real.pi_pos
+  have hz' : dist z (f 0) < r * ‖deriv f 0‖ / (128 * Real.pi) := hz
+  have hh := (lt_div_iff₀ hp).mp hz'
+  rw [dist_eq_norm, norm_sub_rev] at hh
+  nlinarith
+
+lemma univalent_half_growth_bound (hgrowth : PublishedDiskUnivalentGrowth)
+    {f : ℂ → ℂ} (hd : DifferentiableOn ℂ f (ball 0 1))
+    (hi : InjOn f (ball 0 1)) {z : ℂ} (hz : ‖z‖ ≤ 1/2) :
+    ‖f z - f 0‖ ≤ 2 * ‖deriv f 0‖ := by
+  have hz1 : ‖z‖ < 1 := by linarith
+  have hh := hgrowth f hd hi z (mem_ball_zero_iff.mpr hz1)
+  apply hh.trans
+  have hp : 0 < (1-‖z‖)^2 := sq_pos_of_pos (by linarith)
+  apply (div_le_iff₀ hp).mpr
+  have hsq : (1/4:ℝ) ≤ (1-‖z‖)^2 := by nlinarith [norm_nonneg z]
+  have hprod := mul_le_mul_of_nonneg_left hsq (norm_nonneg (deriv f 0))
+  have hnorm := mul_le_mul_of_nonneg_left hz (norm_nonneg (deriv f 0))
+  nlinarith
+
+lemma univalent_quarter_derivative_upper (hgrowth : PublishedDiskUnivalentGrowth)
+    {f : ℂ → ℂ} (hd : DifferentiableOn ℂ f (ball 0 1))
+    (hi : InjOn f (ball 0 1)) {z : ℂ} (hz : ‖z‖ ≤ 1/4) :
+    ‖deriv f z‖ ≤ 16 * ‖deriv f 0‖ := by
+  have hsub : ball z (1/4) ⊆ ball (0:ℂ) 1 := by
+    intro w hw
+    have hdist : ‖w-z‖ < 1/4 := by simpa only [mem_ball,dist_eq_norm] using hw
+    have hnorm : ‖w‖ ≤ ‖w-z‖+‖z‖ := by simpa only [norm_sub_rev, add_comm] using norm_le_insert z w
+    apply mem_ball_zero_iff.mpr
+    linarith
+  have hmaps : MapsTo f (ball z (1/4)) (closedBall (f z) (4*‖deriv f 0‖)) := by
+    intro w hw
+    have hdist : ‖w-z‖ < 1/4 := by simpa only [mem_ball,dist_eq_norm] using hw
+    have hnorm : ‖w‖ ≤ ‖w-z‖+‖z‖ := by simpa only [norm_sub_rev, add_comm] using norm_le_insert z w
+    have hw2 : ‖w‖ ≤ 1/2 := by linarith
+    have hz2 : ‖z‖ ≤ 1/2 := by linarith
+    have hb₁ := univalent_half_growth_bound hgrowth hd hi hw2
+    have hb₂ := univalent_half_growth_bound hgrowth hd hi hz2
+    have htri : ‖f w-f z‖ ≤ ‖f w-f 0‖+‖f z-f 0‖ := by
+      simpa only [norm_sub_rev] using norm_sub_le_norm_sub_add_norm_sub (f w) (f 0) (f z)
+    change dist (f w) (f z) ≤ 4*‖deriv f 0‖
+    rw [dist_eq_norm]
+    linarith
+  have hh := Complex.norm_deriv_le_div_of_mapsTo_ball (hd.mono hsub) hmaps (by norm_num : (0:ℝ)<1/4)
+  norm_num at hh ⊢
+  linarith
+
+lemma univalent_quarter_closed_image_contains
+    {f : ℂ → ℂ} (hd : DifferentiableOn ℂ f (ball 0 1))
+    (hi : InjOn f (ball 0 1)) (hder : 0 < ‖deriv f 0‖) :
+    closedBall (f 0) (‖deriv f 0‖ / (1024 * Real.pi)) ⊆
+      f '' closedBall 0 (1/4) := by
+  have hsub : ball (0:ℂ) (1/4) ⊆ ball 0 1 := ball_subset_ball (by norm_num)
+  have h := univalent_ball_subset_image (by norm_num : (0:ℝ)<1/4) (hd.mono hsub) (hi.mono hsub)
+  intro z hz
+  apply (image_mono ball_subset_closedBall)
+  apply h
+  have hp : 0 < Real.pi := Real.pi_pos
+  have hstrict : ‖deriv f 0‖ / (1024 * Real.pi) < (1/4)*‖deriv f 0‖ / (128 * Real.pi) := by
+    apply (div_lt_div_iff₀ (by positivity) (by positivity)).mpr
+    nlinarith
+  exact lt_of_le_of_lt hz hstrict
+
+lemma univalent_quarter_closed_image_bound (hgrowth : PublishedDiskUnivalentGrowth)
+    {f : ℂ → ℂ} (hd : DifferentiableOn ℂ f (ball 0 1))
+    (hi : InjOn f (ball 0 1)) :
+    f '' closedBall 0 (1/4) ⊆ closedBall (f 0) (2*‖deriv f 0‖) := by
+  rintro z ⟨w,hw,rfl⟩
+  have hw' : ‖w‖ ≤ 1/2 := by
+    have hh : ‖w‖ ≤ 1/4 := by simpa only [mem_closedBall,dist_zero_right] using hw
+    linarith
+  simpa only [mem_closedBall,dist_eq_norm] using univalent_half_growth_bound hgrowth hd hi hw'
+
+end SLEExactGauge
+
+end
+
+end OAI
diff --git a/lean/OAI/Probability/SLE/Geometry/DiskRecentering.lean b/lean/OAI/Probability/SLE/Geometry/DiskRecentering.lean
new file mode 100644
index 0000000000000000000000000000000000000000..421a1e514d7ad39dd78451ce2b38b6fe12817693
--- /dev/null
+++ b/lean/OAI/Probability/SLE/Geometry/DiskRecentering.lean
@@ -0,0 +1,99 @@
+import OAI.Probability.SLE.Geometry.DiskQuarterGeometry
+
+namespace OAI
+
+/-! The elementary disk automorphism needed to compare derivatives on the
+quarter disk. -/
+
+noncomputable section
+open Set Filter Metric Complex
+open scoped Topology NNReal
+
+namespace SLEExactGauge
+
+def diskRecenter (w z : ℂ) : ℂ := (w+z)/(1+star w*z)
+
+lemma diskRecenter_den_ne {w z : ℂ} (hw : ‖w‖ < 1) (hz : ‖z‖ < 1) :
+    1+star w*z ≠ 0 := by
+  intro h
+  have hh : star w*z = -1 := by linear_combination h
+  have hn := congrArg norm hh
+  simp only [norm_mul,norm_star,norm_neg,norm_one] at hn
+  nlinarith [norm_nonneg w,norm_nonneg z]
+
+lemma diskRecenter_det {w : ℂ} (hw : ‖w‖ < 1) :
+    1-star w*w = ((1-‖w‖^2:ℝ):ℂ) ∧ 0 < 1-‖w‖^2 := by
+  constructor
+  · simp only [Complex.star_def,Complex.conj_mul',Complex.ofReal_sub,Complex.ofReal_one,Complex.ofReal_pow]
+  · nlinarith [norm_nonneg w]
+
+lemma diskRecenter_maps {w : ℂ} (hw : ‖w‖ < 1) :
+    MapsTo (diskRecenter w) (ball 0 1) (ball 0 1) := by
+  intro z hz
+  have hz' : ‖z‖ < 1 := mem_ball_zero_iff.mp hz
+  have hd := diskRecenter_den_ne hw hz'
+  have hg : Complex.normSq (1+star w*z)-Complex.normSq (w+z) =
+      (1-Complex.normSq w)*(1-Complex.normSq z) := by
+    simp only [Complex.normSq_apply,Complex.add_re,Complex.add_im,Complex.one_re,Complex.one_im,
+      Complex.mul_re,Complex.mul_im,Complex.star_def,Complex.conj_re,Complex.conj_im]
+    ring
+  have hp : 0 < (1-Complex.normSq w)*(1-Complex.normSq z) := by
+    rw [Complex.normSq_eq_norm_sq,Complex.normSq_eq_norm_sq]
+    exact mul_pos (diskRecenter_det hw).2 (diskRecenter_det hz').2
+  rw [mem_ball_zero_iff,diskRecenter,norm_div]
+  apply (div_lt_one (norm_pos_iff.mpr hd)).mpr
+  simp only [Complex.normSq_eq_norm_sq] at hg hp
+  nlinarith [norm_nonneg (w+z),norm_nonneg (1+star w*z)]
+
+lemma diskRecenter_injOn {w : ℂ} (hw : ‖w‖ < 1) :
+    InjOn (diskRecenter w) (ball 0 1) := by
+  intro x hx y hy hxy
+  have hx' := diskRecenter_den_ne hw (mem_ball_zero_iff.mp hx)
+  have hy' := diskRecenter_den_ne hw (mem_ball_zero_iff.mp hy)
+  have hh := (div_eq_div_iff hx' hy').mp hxy
+  have he : (1-star w*w)*(x-y)=0 := by linear_combination hh
+  have hn : 1-star w*w ≠ 0 := by
+    rw [(diskRecenter_det hw).1]
+    exact_mod_cast (diskRecenter_det hw).2.ne'
+  exact sub_eq_zero.mp ((mul_eq_zero.mp he).resolve_left hn)
+
+lemma diskRecenter_hasDerivAt {w z : ℂ} (hw : ‖w‖ < 1) (hz : ‖z‖ < 1) :
+    HasDerivAt (diskRecenter w) ((1-star w*w)/(1+star w*z)^2) z := by
+  have hh := ((hasDerivAt_id z).const_add w).div
+    (((hasDerivAt_id z).const_mul (star w)).const_add 1) (diskRecenter_den_ne hw hz)
+  convert hh using 1 <;> first | rfl | (dsimp; ring)
+
+lemma diskRecenter_differentiable {w : ℂ} (hw : ‖w‖ < 1) :
+    DifferentiableOn ℂ (diskRecenter w) (ball 0 1) := by
+  intro z hz
+  exact (diskRecenter_hasDerivAt hw (mem_ball_zero_iff.mp hz)).differentiableAt.differentiableWithinAt
+
+@[simp] lemma diskRecenter_zero (w : ℂ) : diskRecenter w 0=w := by simp [diskRecenter]
+@[simp] lemma diskRecenter_neg (w : ℂ) : diskRecenter w (-w)=0 := by simp [diskRecenter]
+
+lemma diskRecenter_deriv_zero {w : ℂ} (hw : ‖w‖ < 1) :
+    ‖deriv (diskRecenter w) 0‖=1-‖w‖^2 := by
+  rw [(diskRecenter_hasDerivAt hw (by simp)).deriv]
+  simp only [mul_zero,add_zero,one_pow,div_one,(diskRecenter_det hw).1]
+  exact Complex.norm_of_nonneg (diskRecenter_det hw).2.le
+
+lemma diskRecenter_deriv_neg {w : ℂ} (hw : ‖w‖ < 1) :
+    ‖deriv (diskRecenter w) (-w)‖=(1-‖w‖^2)⁻¹ := by
+  have hz : ‖-w‖ < 1 := by simpa only [norm_neg] using hw
+  rw [(diskRecenter_hasDerivAt hw hz).deriv]
+  have he : 1+star w*(-w)=1-star w*w := by ring
+  rw [he]
+  have hn : 1-star w*w ≠ 0 := by
+    rw [(diskRecenter_det hw).1]
+    exact_mod_cast (diskRecenter_det hw).2.ne'
+  have hquot : (1-star w*w)/(1-star w*w)^2=(1-star w*w)⁻¹ := by
+    field_simp [hn]
+  rw [hquot]
+  simp only [norm_inv,(diskRecenter_det hw).1,
+    Complex.norm_of_nonneg (diskRecenter_det hw).2.le]
+
+end SLEExactGauge
+
+end
+
+end OAI
diff --git a/lean/OAI/Probability/SLE/Geometry/DiskSemicircleGeometry.lean b/lean/OAI/Probability/SLE/Geometry/DiskSemicircleGeometry.lean
new file mode 100644
index 0000000000000000000000000000000000000000..b36f2379184dd5f80ca0057e5eb5859d2bbee9d3
--- /dev/null
+++ b/lean/OAI/Probability/SLE/Geometry/DiskSemicircleGeometry.lean
@@ -0,0 +1,118 @@
+import OAI.Probability.SLE.Geometry.DiskLowerStraightening
+
+namespace OAI
+
+/-! Concrete boundary sets used in the relative disk extension. -/
+noncomputable section
+open Set Complex
+open scoped ComplexConjugate
+
+namespace SLEExactGauge
+
+lemma diskUpperArc_im_nonneg {s : ℝ} (hs : s ∈ Icc 0 1) :
+    0 ≤ (diskUpperArc s).im := by
+  rw [diskUpperArc_im]
+  exact Real.sin_nonneg_of_mem_Icc
+    ⟨mul_nonneg Real.pi_pos.le hs.1,mul_le_of_le_one_right Real.pi_pos.le hs.2⟩
+
+theorem diskUpperArc_image :
+    diskUpperArc '' Icc 0 1 = {z : ℂ | ‖z‖=1 ∧ 0 ≤ z.im} := by
+  ext z
+  constructor
+  · rintro ⟨s,hs,rfl⟩
+    exact ⟨diskUpperArc_norm s,diskUpperArc_im_nonneg hs⟩
+  · rintro ⟨hn,hi⟩
+    have hr : |z.re| ≤ 1 := by simpa only [hn] using abs_re_le_norm z
+    have ha := abs_le.mp hr
+    let s := Real.arccos (-z.re)/Real.pi
+    have hs : s ∈ Icc 0 1 := by
+      constructor
+      · exact div_nonneg (Real.arccos_nonneg _) Real.pi_pos.le
+      · exact (div_le_one Real.pi_pos).mpr (Real.arccos_le_pi _)
+    refine ⟨s,hs,?_⟩
+    have hps : Real.pi*s=Real.arccos (-z.re) := by dsimp [s]; field_simp
+    have hc : Real.cos (Real.pi*s) = -z.re := by
+      rw [hps]
+      exact Real.cos_arccos (by linarith [ha.2]) (by linarith [ha.1])
+    have hsin := diskUpperArc_im_nonneg hs
+    have hsq : z.re^2+z.im^2=1 := by
+      have he := Complex.normSq_eq_norm_sq z
+      rw [Complex.normSq_apply,hn] at he
+      nlinarith
+    apply Complex.ext
+    · rw [diskUpperArc_re]
+      rw [hc]; ring
+    · rw [diskUpperArc_im]
+      rw [diskUpperArc_im] at hsin
+      nlinarith [Real.sin_sq_add_cos_sq (Real.pi*s)]
+
+theorem diskLowerArc_image :
+    diskLowerArc '' Icc 0 1 = {z : ℂ | ‖z‖=1 ∧ z.im ≤ 0} := by
+  ext z
+  constructor
+  · rintro ⟨s,hs,rfl⟩
+    have hh : diskUpperArc s ∈ diskUpperArc '' Icc 0 1 := mem_image_of_mem _ hs
+    rw [diskUpperArc_image] at hh
+    simpa [diskLowerArc] using hh
+  · rintro ⟨hn,hi⟩
+    have hc : conj z ∈ diskUpperArc '' Icc 0 1 := by
+      rw [diskUpperArc_image]
+      simpa using And.intro hn hi
+    obtain ⟨s,hs,he⟩ := hc
+    refine ⟨s,hs,?_⟩
+    dsimp [diskLowerArc]
+    rw [he,Complex.conj_conj]
+
+theorem disk_semicircle_union :
+    diskUpperArc '' Icc 0 1 ∪ diskLowerArc '' Icc 0 1 = {z : ℂ | ‖z‖=1} := by
+  rw [diskUpperArc_image,diskLowerArc_image]
+  ext z
+  simp only [mem_union,mem_ofPred]
+  constructor
+  · rintro (h|h) <;> exact h.1
+  · intro h
+    rcases le_total 0 z.im with hi|hi
+    · exact Or.inl ⟨h,hi⟩
+    · exact Or.inr ⟨h,hi⟩
+
+theorem disk_semicircle_inter :
+    diskUpperArc '' Icc 0 1 ∩ diskLowerArc '' Icc 0 1 = ({-1,1} : Set ℂ) := by
+  rw [diskUpperArc_image,diskLowerArc_image]
+  ext z
+  constructor
+  · rintro ⟨⟨hn,hp⟩,⟨_,hm⟩⟩
+    have hi : z.im=0 := le_antisymm hm hp
+    have hz : z=(z.re : ℂ) := Complex.ext rfl hi
+    rw [hz,Complex.norm_real,Real.norm_eq_abs] at hn
+    rcases (abs_eq (by norm_num : (0:ℝ) ≤ 1)).mp hn with he|he
+    · right
+      rw [hz,he]
+      norm_num
+    · left
+      rw [hz,he]
+      norm_num
+  · intro hz
+    rcases hz with hz|hz <;> simp_all
+
+theorem diskDiameter_image :
+    diskDiameter '' Icc 0 1 = {z : ℂ | ‖z‖ ≤ 1 ∧ z.im=0} := by
+  ext z
+  constructor
+  · rintro ⟨s,hs,rfl⟩
+    change ‖((2*s-1:ℝ):ℂ)‖ ≤ 1 ∧ _
+    rw [Complex.norm_real,Real.norm_eq_abs]
+    exact ⟨abs_le.mpr ⟨by linarith [hs.1],by linarith [hs.2]⟩,rfl⟩
+  · rintro ⟨hn,hi⟩
+    have hr := (abs_re_le_norm z).trans hn
+    have ha := abs_le.mp hr
+    refine ⟨(z.re+1)/2,⟨by linarith [ha.1],by linarith [ha.2]⟩,?_⟩
+    apply Complex.ext
+    · change 2*((z.re+1)/2)-1=z.re
+      ring
+    · exact hi.symm
+
+end SLEExactGauge
+
+end
+
+end OAI
diff --git a/lean/OAI/Probability/SLE/Geometry/DiskSideRegionImages.lean b/lean/OAI/Probability/SLE/Geometry/DiskSideRegionImages.lean
new file mode 100644
index 0000000000000000000000000000000000000000..67fff132c20cd9f8eaf3663cec4c87701df02107
--- /dev/null
+++ b/lean/OAI/Probability/SLE/Geometry/DiskSideRegionImages.lean
@@ -0,0 +1,51 @@
+import OAI.Probability.SLE.Geometry.DiskCrosscutClosedRegions
+
+namespace OAI
+
+/-! Each prescribed side extension transports the corresponding closed region. -/
+noncomputable section
+open Set Complex
+
+namespace SLEExactGauge
+
+lemma image_interval_of_agree (H : ℂ ≃ₜ ℂ) (p q : ℝ → ℂ)
+    (h : ∀ s ∈ Icc 0 1, H (p s)=q s) : H '' (p '' Icc 0 1)=q '' Icc 0 1 := by
+  ext z
+  constructor
+  · rintro ⟨_,⟨s,hs,rfl⟩,rfl⟩
+    exact ⟨s,hs,(h s hs).symm⟩
+  · rintro ⟨s,hs,rfl⟩
+    exact ⟨p s,mem_image_of_mem p hs,h s hs⟩
+
+lemma image_eq_self_of_fixed (H : ℂ ≃ₜ ℂ) (A : Set ℂ)
+    (h : ∀ z ∈ A, H z=z) : H '' A=A := by
+  ext z
+  constructor
+  · rintro ⟨w,hw,rfl⟩
+    rwa [h w hw]
+  · intro hz
+    exact ⟨z,hz,h z hz⟩
+
+theorem disk_upper_region_image (p : ℝ → ℂ) (H : ℂ ≃ₜ ℂ)
+    (hP : ∀ s ∈ Icc 0 1, H (p s)=diskDiameter s)
+    (hA : ∀ z ∈ diskUpperArc '' Icc 0 1, H z=z) :
+    H '' closure (complexInside (diskUpperArc '' Icc 0 1 ∪ p '' Icc 0 1))=
+      closedUpperDisk := by
+  rw [H.image_closure,complexInside_transport,image_union,
+    image_interval_of_agree H p diskDiameter hP,
+    image_eq_self_of_fixed H _ hA,union_comm,complexInside_upperDisk,openUpperDisk_closure]
+
+theorem disk_lower_region_image (p : ℝ → ℂ) (H : ℂ ≃ₜ ℂ)
+    (hP : ∀ s ∈ Icc 0 1, H (p s)=diskDiameter s)
+    (hA : ∀ z ∈ diskLowerArc '' Icc 0 1, H z=z) :
+    H '' closure (complexInside (diskLowerArc '' Icc 0 1 ∪ p '' Icc 0 1))=
+      closedLowerDisk := by
+  rw [H.image_closure,complexInside_transport,image_union,
+    image_interval_of_agree H p diskDiameter hP,
+    image_eq_self_of_fixed H _ hA,union_comm,complexInside_lowerDisk,openLowerDisk_closure]
+
+end SLEExactGauge
+
+end
+
+end OAI
diff --git a/lean/OAI/Probability/SLE/Geometry/DiskTwoSideGlue.lean b/lean/OAI/Probability/SLE/Geometry/DiskTwoSideGlue.lean
new file mode 100644
index 0000000000000000000000000000000000000000..e50243fcdf95c437607a7f40e9bec5c9a4e05381
--- /dev/null
+++ b/lean/OAI/Probability/SLE/Geometry/DiskTwoSideGlue.lean
@@ -0,0 +1,55 @@
+import OAI.Probability.SLE.Geometry.DiskBoundaryRegion
+import OAI.Probability.SLE.Geometry.ClosedComplexPair
+
+namespace OAI
+
+/-! Assemble two compatible side maps into a homeomorphism of the closed disk. -/
+noncomputable section
+open Set Complex Metric
+attribute [local instance] Classical.propDecidable
+
+namespace SLEExactGauge
+
+lemma closedLowerDisk_isClosed : IsClosed closedLowerDisk :=
+  (isClosed_le continuous_norm continuous_const).inter
+    (isClosed_le Complex.continuous_im continuous_const)
+
+def closedDiskTwoSideHomeomorph {A B : Set ℂ}
+    (hA : IsClosed A) (hB : IsClosed B)
+    (hAB : A ∪ B=closedBall (0:ℂ) 1)
+    (H G : ℂ ≃ₜ ℂ)
+    (hH : H '' A=closedUpperDisk) (hG : G '' B=closedLowerDisk)
+    (he : ∀ z ∈ A ∩ B, H z=G z)
+    (hi : ∀ z ∈ closedUpperDisk ∩ closedLowerDisk, H.symm z=G.symm z) :
+    closedBall (0:ℂ) 1 ≃ₜ closedBall (0:ℂ) 1 := by
+  let e : A ≃ₜ closedUpperDisk := (H.image A).trans (Homeomorph.setCongr hH)
+  let d : B ≃ₜ closedLowerDisk := (G.image B).trans (Homeomorph.setCongr hG)
+  let F := closedComplexPairHomeomorph hA closedUpperDisk_isClosed hB
+    closedLowerDisk_isClosed e d (fun x hx => he x ⟨x.property,hx⟩)
+    (fun x hx => hi x ⟨x.property,hx⟩)
+  exact ((Homeomorph.setCongr hAB.symm).trans F).trans
+    (Homeomorph.setCongr closed_halfDisks_union)
+
+lemma closedDiskTwoSideHomeomorph_apply {A B : Set ℂ}
+    (hA : IsClosed A) (hB : IsClosed B)
+    (hAB : A ∪ B=closedBall (0:ℂ) 1)
+    (H G : ℂ ≃ₜ ℂ)
+    (hH : H '' A=closedUpperDisk) (hG : G '' B=closedLowerDisk)
+    (he : ∀ z ∈ A ∩ B, H z=G z)
+    (hi : ∀ z ∈ closedUpperDisk ∩ closedLowerDisk, H.symm z=G.symm z)
+    (z : closedBall (0:ℂ) 1) :
+    (closedDiskTwoSideHomeomorph hA hB hAB H G hH hG he hi z : ℂ)=
+      if z.val ∈ A then H z else G z := by
+  classical
+  change (if ha : z.val ∈ A then H z else
+    if hb : z.val ∈ B then G z else z.val)=_
+  by_cases ha : z.val ∈ A
+  · rw [dite_eq_left ha,ite_eq_left ha]
+  · have hb : z.val ∈ B := ((hAB.symm ▸ z.property) : z.val ∈ A ∪ B).resolve_left ha
+    rw [dite_eq_right ha,dite_eq_left hb,ite_eq_right ha]
+
+end SLEExactGauge
+
+end
+
+end OAI
diff --git a/lean/OAI/Probability/SLE/Geometry/DiskUpperStraightening.lean b/lean/OAI/Probability/SLE/Geometry/DiskUpperStraightening.lean
new file mode 100644
index 0000000000000000000000000000000000000000..ed61f85e3225be4d29c6d4da1b83a596c6033999
--- /dev/null
+++ b/lean/OAI/Probability/SLE/Geometry/DiskUpperStraightening.lean
@@ -0,0 +1,76 @@
+import OAI.Probability.SLE.Geometry.DiskCrosscutBoundary
+
+namespace OAI
+
+/-! Straighten the disk crosscut with its exact parameter, while fixing
+the upper semicircle. The second side is handled separately. -/
+noncomputable section
+open Set Complex
+
+namespace SLEExactGauge
+
+def diskDiameter (s : ℝ) : ℂ := ((2*s-1 : ℝ) : ℂ)
+
+lemma diskDiameter_continuous : Continuous diskDiameter := by
+  unfold diskDiameter
+  fun_prop
+
+lemma diskDiameter_injOn : InjOn diskDiameter (Icc 0 1) := by
+  intro s _ t _ he
+  have hh := Complex.ofReal_inj.mp he
+  linarith
+
+lemma diskDiameter_interior (s : ℝ) (hs : s ∈ Ioo 0 1) : ‖diskDiameter s‖ < 1 := by
+  change ‖((2*s-1 : ℝ) : ℂ)‖ < 1
+  rw [Complex.norm_real,Real.norm_eq_abs]
+  exact abs_lt.mpr ⟨by linarith [hs.1],by linarith [hs.2]⟩
+
+theorem disk_crosscut_upper_straightening
+    (p : ℝ → ℂ) (hc : ContinuousOn p (Icc 0 1)) (hi : InjOn p (Icc 0 1))
+    (h0 : p 0=-1) (h1 : p 1=1) (hp : ∀ s ∈ Ioo 0 1, ‖p s‖ < 1) :
+    ∃ H : ℂ ≃ₜ ℂ,
+      (∀ s ∈ Icc 0 1, H (p s)=diskDiameter s) ∧
+      ∀ z ∈ diskUpperArc '' Icc 0 1, H z=z := by
+  classical
+  let B : Set ℂ := diskUpperArc '' Icc 0 1
+  have hB : IsClosed B := (isCompact_Icc.image diskUpperArc_continuous).isClosed
+  have hq0 : diskDiameter 0=p 0 := by simp [diskDiameter,h0]
+  have hq1 : diskDiameter 1=p 1 := by norm_num [diskDiameter,h1]
+  let e := fixedArcBoundaryReplacement p diskDiameter B hc hi
+    diskDiameter_continuous.continuousOn diskDiameter_injOn hB hq0 hq1
+    (disk_crosscut_meets_upper_at_endpoints p hp)
+    (disk_crosscut_meets_upper_at_endpoints diskDiameter diskDiameter_interior)
+  obtain ⟨H,hH⟩ := complex_jordan_extension (disk_crosscut_upper_jordan p hc hi h0 h1 hp)
+    (disk_crosscut_upper_jordan diskDiameter diskDiameter_continuous.continuousOn
+      diskDiameter_injOn (by norm_num [diskDiameter]) (by norm_num [diskDiameter])
+      diskDiameter_interior) e
+  refine ⟨H,?_,?_⟩
+  · intro s hs
+    have hh := hH ⟨p s,Or.inl (mem_image_of_mem p hs)⟩
+    apply hh.trans
+    change (if hx : p s ∈ p '' Icc 0 1 then
+      (arcParameterReplacement p diskDiameter hc hi diskDiameter_continuous.continuousOn
+        diskDiameter_injOn ⟨p s,hx⟩ : ℂ) else p s)=diskDiameter s
+    rw [dite_eq_left (mem_image_of_mem p hs)]
+    exact arcParameterReplacement_apply p diskDiameter hc hi
+      diskDiameter_continuous.continuousOn diskDiameter_injOn s hs
+  · intro z hz
+    have hh := hH ⟨z,Or.inr hz⟩
+    apply hh.trans
+    change (if hx : z ∈ p '' Icc 0 1 then
+      (arcParameterReplacement p diskDiameter hc hi diskDiameter_continuous.continuousOn
+        diskDiameter_injOn ⟨z,hx⟩ : ℂ) else z)=z
+    split_ifs with hx
+    · obtain ⟨s,hs,rfl⟩ := hx
+      rw [arcParameterReplacement_apply p diskDiameter hc hi
+        diskDiameter_continuous.continuousOn diskDiameter_injOn s hs]
+      rcases disk_crosscut_meets_upper_at_endpoints p hp s hs hz with rfl | rfl
+      · exact hq0
+      · exact hq1
+    · rfl
+
+end SLEExactGauge
+
+end
+
+end OAI
diff --git a/lean/OAI/Probability/SLE/Geometry/EndpointClusterInterval.lean b/lean/OAI/Probability/SLE/Geometry/EndpointClusterInterval.lean
new file mode 100644
index 0000000000000000000000000000000000000000..4fd09531c13a09917351a6bd7ea74782d914cf52
--- /dev/null
+++ b/lean/OAI/Probability/SLE/Geometry/EndpointClusterInterval.lean
@@ -0,0 +1,52 @@
+import Mathlib.Topology.Order.IntermediateValue
+import Mathlib.Topology.MetricSpace.Pseudo.Defs
+import Mathlib.Topology.ClusterPt
+import Mathlib.Topology.Instances.Real.Lemmas
+
+namespace OAI
+
+/-! The real cluster values of a continuous path at a one-sided endpoint
+contain every value between two of them. -/
+noncomputable section
+open Set Filter Metric
+open scoped Topology
+
+namespace SLEExactGauge
+
+lemma endpoint_intermediate_level {f : ℝ → ℝ} {D a b c : ℝ}
+    (hD : 0<D) (hC : ContinuousOn f (Ioo 0 D))
+    (ha : MapClusterPt a (𝓝[>] (0:ℝ)) f) (hb : MapClusterPt b (𝓝[>] (0:ℝ)) f)
+    (hac : a<c) (hcb : c<b) {δ : ℝ} (hδ : 0<δ) :
+    ∃ t∈Ioo 0 δ, f t=c := by
+  let ε := min δ D
+  have hε : 0<ε := lt_min hδ hD
+  have hsmall : ∀ᶠ t : ℝ in 𝓝[>] (0:ℝ), t∈Ioo 0 ε := by
+    filter_upwards [self_mem_nhdsWithin,
+      mem_nhdsWithin_of_mem_nhds (Iio_mem_nhds hε)] with t ht htε
+    exact ⟨ht,htε⟩
+  obtain ⟨u,hu,huε⟩ := ((ha.frequently (Iio_mem_nhds hac)).and_eventually hsmall).exists
+  obtain ⟨v,hv,hvε⟩ := ((hb.frequently (Ioi_mem_nhds hcb)).and_eventually hsmall).exists
+  have hcε : ContinuousOn f (Ioo 0 ε) := hC.mono (Ioo_subset_Ioo le_rfl (min_le_right δ D))
+  obtain ⟨t,ht,he⟩ := isPreconnected_Ioo.intermediate_value huε hvε hcε ⟨hu.le,hv.le⟩
+  exact ⟨t,⟨ht.1,ht.2.trans_le (min_le_left δ D)⟩,he⟩
+
+theorem endpoint_cluster_interval {f : ℝ → ℝ} {D a b : ℝ}
+    (hD : 0<D) (hC : ContinuousOn f (Ioo 0 D))
+    (ha : MapClusterPt a (𝓝[>] (0:ℝ)) f) (hb : MapClusterPt b (𝓝[>] (0:ℝ)) f) :
+    ∀ c∈Ioo a b, MapClusterPt c (𝓝[>] (0:ℝ)) f := by
+  intro c hc
+  apply clusterPt_iff_nonempty.mpr
+  intro W hW V hV
+  have hpre : f ⁻¹' V∈𝓝[>] (0:ℝ) := hV
+  obtain ⟨δ,hδ,hsub⟩ := Metric.mem_nhdsWithin_iff.mp hpre
+  obtain ⟨t,ht,he⟩ := endpoint_intermediate_level hD hC ha hb hc.1 hc.2 hδ
+  have htB : t∈ball (0:ℝ) δ := by
+    simpa only [mem_ball,Real.dist_eq,sub_zero,abs_of_pos ht.1] using ht.2
+  have hfV : f t∈V := hsub ⟨htB,ht.1⟩
+  exact ⟨c,mem_of_mem_nhds hW,he ▸ hfV⟩
+
+end SLEExactGauge
+
+end
+
+end OAI
diff --git a/lean/OAI/Probability/SLE/Geometry/EndpointClusterLimit.lean b/lean/OAI/Probability/SLE/Geometry/EndpointClusterLimit.lean
new file mode 100644
index 0000000000000000000000000000000000000000..1f05ac457a1248a7590f97dd588c62ee68006212
--- /dev/null
+++ b/lean/OAI/Probability/SLE/Geometry/EndpointClusterLimit.lean
@@ -0,0 +1,31 @@
+import OAI.Probability.SLE.Geometry.EndpointClusterInterval
+import Mathlib.Topology.Compactness.Compact
+
+namespace OAI
+
+/-! A bounded continuous real path has an endpoint limit when its cluster
+values contain no nontrivial interval. -/
+noncomputable section
+open Set Filter
+open scoped Topology
+
+namespace SLEExactGauge
+
+theorem exists_endpoint_limit_of_no_cluster_interval {f : ℝ → ℝ} {D : ℝ}
+    (hD : 0<D) (hC : ContinuousOn f (Ioo 0 D)) {K : Set ℝ} (hK : IsCompact K)
+    (hmem : ∀ᶠ t : ℝ in 𝓝[>] (0:ℝ), f t∈K)
+    (hno : ∀ a b : ℝ, a<b → ¬ ∀ c∈Ioo a b, MapClusterPt c (𝓝[>] (0:ℝ)) f) :
+    ∃ a∈K, Tendsto f (𝓝[>] (0:ℝ)) (𝓝 a) := by
+  obtain ⟨a,haK,ha⟩ := hK.exists_mapClusterPt (tendsto_principal.mpr hmem)
+  refine ⟨a,haK,hK.tendsto_nhds_of_unique_mapClusterPt hmem ?_⟩
+  intro b _ hb
+  by_contra hba
+  rcases lt_or_gt_of_ne hba with hlt | hgt
+  · exact hno b a hlt (endpoint_cluster_interval hD hC hb ha)
+  · exact hno a b hgt (endpoint_cluster_interval hD hC ha hb)
+
+end SLEExactGauge
+
+end
+
+end OAI
diff --git a/lean/OAI/Probability/SLE/Geometry/EndpointDerivativeBound.lean b/lean/OAI/Probability/SLE/Geometry/EndpointDerivativeBound.lean
new file mode 100644
index 0000000000000000000000000000000000000000..fcc79cb89981c78294f53160334f427a750fdeec
--- /dev/null
+++ b/lean/OAI/Probability/SLE/Geometry/EndpointDerivativeBound.lean
@@ -0,0 +1,52 @@
+import Mathlib
+
+namespace OAI
+
+/-! A derivative bound on positive times extends to the endpoint when
+the function is continuous there. Used for squared reverse coordinates. -/
+noncomputable section
+open Set Filter
+open scoped Topology
+
+namespace SLEExactGauge
+
+lemma norm_sub_initial_le_of_deriv_on_Ioc
+    {E : Type*} [NormedAddCommGroup E] [NormedSpace ℝ E]
+    {T C : ℝ} (hT : 0 ≤ T) (f f' : ℝ → E)
+    (hc : ContinuousOn f (Icc 0 T))
+    (hd : ∀ t ∈ Ioc 0 T, HasDerivWithinAt f (f' t) (Ici t) t)
+    (hb : ∀ t ∈ Ioc 0 T, ‖f' t‖ ≤ C) :
+    ∀ t ∈ Icc 0 T, ‖f t-f 0‖ ≤ C*t := by
+  intro t ht
+  by_cases ht0 : t=0
+  · subst t; simp
+  have htp : 0 < t := lt_of_le_of_ne ht.1 (Ne.symm ht0)
+  let x (n : ℕ) : ℝ := t/((n : ℝ)+1)
+  have hx (n : ℕ) : 0 < x n := by dsimp [x]; positivity
+  have hxt (n : ℕ) : x n ≤ t := by
+    apply (div_le_iff₀ (by positivity : 0 < (n : ℝ)+1)).mpr
+    nlinarith [Nat.cast_nonneg (α := ℝ) n]
+  have hx0 : Tendsto x atTop (𝓝 (0 : ℝ)) := by
+    have h := tendsto_one_div_add_atTop_nhds_zero_nat.const_mul t
+    simpa only [x,mul_one_div,mul_zero] using h
+  have hxin : Tendsto x atTop (𝓝[Icc 0 T] 0) := tendsto_nhdsWithin_iff.mpr
+    ⟨hx0,Eventually.of_forall (fun n => ⟨(hx n).le,(hxt n).trans ht.2⟩)⟩
+  have hfx := (hc 0 ⟨le_rfl,hT⟩).tendsto.comp hxin
+  have hleft : Tendsto (fun n => ‖f t-f (x n)‖) atTop (𝓝 ‖f t-f 0‖) :=
+    (hfx.const_sub (f t)).norm
+  have hright : Tendsto (fun n => C*(t-x n)) atTop (𝓝 (C*t)) := by
+    simpa only [sub_zero] using (hx0.const_sub t).const_mul C
+  apply le_of_tendsto_of_tendsto hleft hright
+  apply Eventually.of_forall
+  intro n
+  have hsub : Icc (x n) t ⊆ Icc 0 T := Icc_subset_Icc (hx n).le ht.2
+  apply norm_image_sub_le_of_norm_deriv_right_le_segment (hc.mono hsub)
+    (fun s hs => hd s ⟨(hx n).trans_le hs.1,hs.2.le.trans ht.2⟩)
+    (fun s hs => hb s ⟨(hx n).trans_le hs.1,hs.2.le.trans ht.2⟩)
+    t ⟨hxt n,le_rfl⟩
+
+end SLEExactGauge
+
+end
+
+end OAI
diff --git a/lean/OAI/Probability/SLE/Geometry/EndpointMonotonicity.lean b/lean/OAI/Probability/SLE/Geometry/EndpointMonotonicity.lean
new file mode 100644
index 0000000000000000000000000000000000000000..e01eef2e2acb4f20b0a30a700efff75dabe602f7
--- /dev/null
+++ b/lean/OAI/Probability/SLE/Geometry/EndpointMonotonicity.lean
@@ -0,0 +1,46 @@
+import OAI.Probability.SLE.Geometry.EndpointDerivativeBound
+
+namespace OAI
+
+/-! One-sided derivative comparisons remain valid at a continuous endpoint,
+even when the derivative at that endpoint is singular. -/
+noncomputable section
+open Set Filter
+open scoped Topology
+
+namespace SLEExactGauge
+
+lemma le_initial_of_deriv_nonpos_on_Ioc {T : ℝ} (hT : 0 ≤ T)
+    (f f' : ℝ → ℝ) (hc : ContinuousOn f (Icc 0 T))
+    (hd : ∀ t ∈ Ioc 0 T, HasDerivWithinAt f (f' t) (Ici t) t)
+    (hb : ∀ t ∈ Ioc 0 T, f' t ≤ 0) :
+    ∀ t ∈ Icc 0 T, f t ≤ f 0 := by
+  intro t ht
+  by_cases ht0 : t=0
+  · subst t; exact le_rfl
+  have htp : 0 < t := lt_of_le_of_ne ht.1 (Ne.symm ht0)
+  let x (n : ℕ) : ℝ := t/((n : ℝ)+1)
+  have hx (n : ℕ) : 0 < x n := by dsimp [x]; positivity
+  have hxt (n : ℕ) : x n ≤ t := by
+    apply (div_le_iff₀ (by positivity : 0 < (n : ℝ)+1)).mpr
+    nlinarith [Nat.cast_nonneg (α := ℝ) n]
+  have hx0 : Tendsto x atTop (𝓝 (0 : ℝ)) := by
+    have h := tendsto_one_div_add_atTop_nhds_zero_nat.const_mul t
+    simpa only [x,mul_one_div,mul_zero] using h
+  have hxin : Tendsto x atTop (𝓝[Icc 0 T] 0) := tendsto_nhdsWithin_iff.mpr
+    ⟨hx0,Eventually.of_forall (fun n => ⟨(hx n).le,(hxt n).trans ht.2⟩)⟩
+  apply ge_of_tendsto ((hc 0 ⟨le_rfl,hT⟩).tendsto.comp hxin)
+  apply Eventually.of_forall
+  intro n
+  have hsub : Icc (x n) t ⊆ Icc 0 T := Icc_subset_Icc (hx n).le ht.2
+  exact image_le_of_deriv_right_le_deriv_boundary (hc.mono hsub)
+    (fun s hs => hd s ⟨(hx n).trans_le hs.1,hs.2.le.trans ht.2⟩)
+    (B := fun _ => f (x n)) (B' := fun _ => 0) le_rfl continuousOn_const
+    (fun s _ => hasDerivWithinAt_const s (Ici s) (f (x n)))
+    (fun s hs => hb s ⟨(hx n).trans_le hs.1,hs.2.le.trans ht.2⟩) ⟨hxt n,le_rfl⟩
+
+end SLEExactGauge
+
+end
+
+end OAI
diff --git a/lean/OAI/Probability/SLE/Geometry/ExplicitInputDischarge.lean b/lean/OAI/Probability/SLE/Geometry/ExplicitInputDischarge.lean
new file mode 100644
index 0000000000000000000000000000000000000000..157d63241e41cbfbfce8de331a706509f6eb6b98
--- /dev/null
+++ b/lean/OAI/Probability/SLE/Geometry/ExplicitInputDischarge.lean
@@ -0,0 +1,36 @@
+import OAI.Probability.SLE.Geometry.ActualExplicitTransfer
+import OAI.Probability.SLE.Geometry.ActualWienerSupport
+
+namespace OAI
+
+/-! The explicit exact-gauge theorem using planar Wiener support
+derived from the Brownian law. -/
+noncomputable section
+open Set MeasureTheory ProbabilityTheory
+open scoped Topology NNReal ENNReal
+
+namespace SLEExactGauge
+
+local instance explicitDischargeMeasurable : MeasurableSpace C(ℝ≥0,ℝ) := borel _
+local instance explicitDischargeBorel : BorelSpace C(ℝ≥0,ℝ) := ⟨rfl⟩
+
+theorem ordinary_explicit_mainConclusion_of_remaining_inputs
+    {Ω : Type} [MeasurableSpace Ω] (P : Measure Ω) [IsProbabilityMeasure P]
+    (κ : ℝ) (hκ : 0 < κ) (hκ8 : κ < 8)
+    (γ : Ω → ℝ≥0 → ℂ) (hSLE : IsOrdinaryChordalSLE κ γ P)
+    (htrace : PublishedTraceGeneration (ordinaryRegularDriverLaw hSLE) κ (fun t p => p t))
+    (hcompact : PublishedHalfPlaneUnivalentCompactness)
+    (hboundary : PublishedFiniteLoewnerBoundaryExtension)
+    (hsupport : PublishedGeometricTubeSupport P γ)
+    (hplanar : PublishedPlanarDiskOpenness)
+    (hstraight : PublishedHalfPlaneCrosscutStraightening)
+    (hexit : PublishedHalfPlaneConformalExitLaw) :
+    MainConclusion P (explicitGauge κ) γ :=
+  ordinary_explicit_mainConclusion_of_published_inputs P κ hκ hκ8 γ hSLE
+    htrace hcompact hboundary hsupport hplanar hstraight hexit actual_planarWienerUnitSupport
+
+end SLEExactGauge
+
+end
+
+end OAI
diff --git a/lean/OAI/Probability/SLE/Geometry/ExplicitPublishedMain.lean b/lean/OAI/Probability/SLE/Geometry/ExplicitPublishedMain.lean
new file mode 100644
index 0000000000000000000000000000000000000000..760e94982b831b289e620721e745b0d5137d1350
--- /dev/null
+++ b/lean/OAI/Probability/SLE/Geometry/ExplicitPublishedMain.lean
@@ -0,0 +1,25 @@
+import OAI.Probability.SLE.Gauge.GaugeCrosscutDischarge
+import OAI.Probability.SLE.Geometry.ActualGeometricTubeSupport
+
+namespace OAI
+
+/-! The explicit exact Hausdorff gauge theorem for ordinary chordal SLE. -/
+noncomputable section
+open Set _root_.MeasureTheory _root_.OAI.MeasureTheory ProbabilityTheory
+open scoped Topology NNReal ENNReal
+
+namespace SLEExactGauge
+
+theorem ordinary_explicit_mainConclusion_unconditional
+    {Ω : Type} [MeasurableSpace Ω] (P : Measure Ω) [IsProbabilityMeasure P]
+    (κ : ℝ) (hκ : 0<κ) (hκ8 : κ<8) (γ : Ω → ℝ≥0 → ℂ)
+    (hSLE : IsOrdinaryChordalSLE κ γ P) :
+    MainConclusion P (explicitGauge κ) γ :=
+  ordinary_explicit_mainConclusion_of_support P κ hκ hκ8 γ hSLE
+    (ordinary_geometricTubeSupport P κ hκ γ hSLE)
+
+end SLEExactGauge
+
+end
+
+end OAI
diff --git a/lean/OAI/Probability/SLE/Geometry/ExtendedDiskAngle.lean b/lean/OAI/Probability/SLE/Geometry/ExtendedDiskAngle.lean
new file mode 100644
index 0000000000000000000000000000000000000000..53b633baf62e0e5ff144f29b04c06896ab70c779
--- /dev/null
+++ b/lean/OAI/Probability/SLE/Geometry/ExtendedDiskAngle.lean
@@ -0,0 +1,69 @@
+import OAI.Probability.SLE.Geometry.ExtendedMarkedAngle
+import OAI.Probability.SLE.Geometry.FiniteStoppedScalar
+
+namespace OAI
+
+/-! The full marked angle at a possibly infinite stopping time is
+measurable in its stopped past, with value zero on the infinite event. -/
+noncomputable section
+open Set Filter _root_.MeasureTheory _root_.OAI.MeasureTheory ProbabilityTheory
+open scoped Topology NNReal ENNReal
+
+namespace SLEExactGauge
+
+def extendedMarkedAngle {Ω : Type*} (κ : ℝ) (B : ℝ≥0 → Ω → ℝ)
+    (γ : Ω → ℝ≥0 → ℂ) (G : Ω → ℝ≥0 → ℂ → ℂ)
+    (σ : Ω → WithTop ℝ≥0) (z : ℂ) (ω : Ω) : ℝ :=
+  if σ ω=⊤ then 0 else
+    (stoppedMarkedCenter κ B γ G (fun ω => (σ ω).untopD 0) z ω).arg
+
+lemma stoppedMarkedCenter_time_congr {Ω : Type*}
+    (κ : ℝ) (B : ℝ≥0 → Ω → ℝ) (γ : Ω → ℝ≥0 → ℂ) (G : Ω → ℝ≥0 → ℂ → ℂ)
+    (σ τ : Ω → ℝ≥0) (z : ℂ) (ω : Ω) (h : σ ω=τ ω) :
+    stoppedMarkedCenter κ B γ G σ z ω=stoppedMarkedCenter κ B γ G τ z ω := by
+  classical
+  exact congrArg (fun t => (if z∈survivingDomain (γ ω) t then G ω t z else 0)-
+    ((Real.sqrt κ*B t ω:ℝ):ℂ)) h
+
+lemma extendedMarkedAngle_measurable
+    {Ω : Type*} [mΩ : MeasurableSpace Ω]
+    (B : ℝ≥0 → Ω → ℝ) (hm : ∀ t, Measurable (B t))
+    (hc : ∀ ω, Continuous (fun t => B t ω))
+    (κ : ℝ) (γ : Ω → ℝ≥0 → ℂ) (G F : Ω → ℝ≥0 → ℂ → ℂ)
+    (hw : ∀ ω, IsCapacityTwoWitness (fun t => Real.sqrt κ*B t ω) (γ ω) (G ω) (F ω))
+    (σ : Ω → WithTop ℝ≥0)
+    (hσ : IsStoppingTime (Filtration.natural B (fun t => (hm t).stronglyMeasurable)) σ)
+    (z : ℂ) :
+    Measurable[hσ.measurableSpace] (extendedMarkedAngle κ B γ G σ z) := by
+  let X := fun n : ℕ => (finiteStopEvent σ n).indicator (fun ω =>
+    (stoppedMarkedCenter κ B γ G (cutoffStop σ n) z ω).arg)
+  have hX (n : ℕ) : Measurable[hσ.measurableSpace] (X n) := by
+    have hcut := cutoffStop_stopping _ σ hσ (n:ℝ≥0)
+    have hp := (source_stoppedMarkedCenter_measurable B hm hc κ γ G F hw
+      (cutoffStop σ n) hcut z).carg
+    exact (hp.mono (cutoffStop_past_le _ σ hσ n) le_rfl).indicator
+      (finiteStopEvent_measurable _ σ hσ n)
+  apply @measurable_of_tendsto_metrizable Ω ℝ hσ.measurableSpace _ _ _ _ X
+    (extendedMarkedAngle κ B γ G σ z) hX
+  apply tendsto_pi_nhds.mpr
+  intro ω
+  by_cases hs : σ ω=⊤
+  · have he (n : ℕ) : X n ω=0 := by simp [X,finiteStopEvent,hs]
+    simpa only [he,extendedMarkedAngle,hs,ite_true] using
+      (tendsto_const_nhds : Tendsto (fun _ : ℕ => (0:ℝ)) atTop (𝓝 0))
+  · have hf : σ ω<⊤ := lt_top_iff_ne_top.mpr hs
+    have hmem : ω∈⋃ n, finiteStopEvent σ n := by rw [iUnion_finiteStopEvent]; exact hf
+    obtain ⟨n,hn⟩ := mem_iUnion.mp hmem
+    apply tendsto_const_nhds.congr'
+    filter_upwards [eventually_ge_atTop n,cutoffStop_eventually_eq σ ω hf] with k hk he
+    dsimp only [X]
+    rw [indicator_of_mem (finiteStopEvent_mono σ hk hn),
+      stoppedMarkedCenter_time_congr κ B γ G (cutoffStop σ k)
+        (fun ω => (σ ω).untopD 0) z ω he]
+    exact ite_eq_right hs
+
+end SLEExactGauge
+
+end
+
+end OAI
diff --git a/lean/OAI/Probability/SLE/Geometry/ExtendedMarkedAngle.lean b/lean/OAI/Probability/SLE/Geometry/ExtendedMarkedAngle.lean
new file mode 100644
index 0000000000000000000000000000000000000000..5ed19ee48becdcb6c8f60569b0542f90d218aab3
--- /dev/null
+++ b/lean/OAI/Probability/SLE/Geometry/ExtendedMarkedAngle.lean
@@ -0,0 +1,168 @@
+import OAI.Probability.SLE.Loewner.ActualRadiusStopsRegular
+import OAI.Probability.SLE.Angle.ActualAngleWarmup
+
+namespace OAI
+
+/-! The good-angle event at an actual radius level belongs to that literal
+stopping time's past. Infinite stopping times are excluded explicitly.
+Measurability follows by finite cutoff exhaustion of the stopped chart. -/
+
+noncomputable section
+open Set Filter MeasureTheory ProbabilityTheory
+open scoped Topology NNReal ENNReal
+
+namespace SLEExactGauge
+
+/-- The stopped marked state at a finite extended stopping time. -/
+def extendedMarkedGood {Ω : Type*} (κ : ℝ) (B : ℝ≥0 → Ω → ℝ)
+    (γ : Ω → ℝ≥0 → ℂ) (G : Ω → ℝ≥0 → ℂ → ℂ)
+    (σ : Ω → WithTop ℝ≥0) (z : ℂ) (s : ℝ) : Set Ω :=
+  {ω | σ ω ≠ ⊤ ∧ ω ∈ stoppedMarkedGood κ B γ G (fun ω => (σ ω).untopD 0) z s}
+
+lemma stoppedMarkedGood_time_congr
+    {Ω : Type*} (κ : ℝ) (B : ℝ≥0 → Ω → ℝ)
+    (γ : Ω → ℝ≥0 → ℂ) (G : Ω → ℝ≥0 → ℂ → ℂ)
+    (τ₁ τ₂ : Ω → ℝ≥0) (z : ℂ) (s : ℝ) (ω : Ω) (he : τ₁ ω = τ₂ ω) :
+    ω ∈ stoppedMarkedGood κ B γ G τ₁ z s ↔
+      ω ∈ stoppedMarkedGood κ B γ G τ₂ z s := by
+  classical
+  exact Iff.of_eq (congrArg (fun t : ℝ≥0 => z ∈ survivingDomain (γ ω) t ∧
+    s ≤ (unitMarkedState ((if z ∈ survivingDomain (γ ω) t then G ω t z else 0) -
+      (Real.sqrt κ * B t ω : ℝ))).im) he)
+
+lemma extendedMarkedGood_measurable
+    {Ω : Type*} [mΩ : MeasurableSpace Ω]
+    (B : ℝ≥0 → Ω → ℝ) (hm : ∀ t, Measurable (B t))
+    (hc : ∀ ω, Continuous (fun t => B t ω))
+    (κ : ℝ) (γ : Ω → ℝ≥0 → ℂ) (G F : Ω → ℝ≥0 → ℂ → ℂ)
+    (hw : ∀ ω, IsCapacityTwoWitness (fun t => Real.sqrt κ * B t ω) (γ ω) (G ω) (F ω))
+    (σ : Ω → WithTop ℝ≥0)
+    (hσ : IsStoppingTime (Filtration.natural B (fun t => (hm t).stronglyMeasurable)) σ)
+    (z : ℂ) (s : ℝ) :
+    MeasurableSet[hσ.measurableSpace] (extendedMarkedGood κ B γ G σ z s) := by
+  let E (n : ℕ) := stoppedMarkedGood κ B γ G (cutoffStop σ (n : ℝ≥0)) z s ∩
+    {ω | σ ω ≤ ((n : ℝ≥0) : WithTop ℝ≥0)}
+  have hE (n : ℕ) : MeasurableSet[hσ.measurableSpace] (E n) := by
+    have hcut := cutoffStop_stopping _ σ hσ (n : ℝ≥0)
+    have hpast := hcut.measurableSpace_mono hσ (fun ω =>
+      (le_of_eq (cutoffStop_coe σ (n : ℝ≥0) ω)).trans (min_le_left _ _))
+    exact (hpast _ (source_stoppedMarkedGood_measurable B hm hc κ γ G F hw
+      (cutoffStop σ (n : ℝ≥0)) hcut z s)).inter (hσ.measurableSet_le' (n : ℝ≥0))
+  have he : extendedMarkedGood κ B γ G σ z s = ⋃ n, E n := by
+    ext ω
+    constructor
+    · rintro ⟨hf, hg⟩
+      lift σ ω to ℝ≥0 using hf with t ht
+      obtain ⟨n, hn⟩ := exists_nat_ge (t : ℝ)
+      have hle : σ ω ≤ ((n : ℝ≥0) : WithTop ℝ≥0) := by
+        rw [← ht]
+        exact WithTop.coe_le_coe.mpr (by exact_mod_cast hn)
+      apply mem_iUnion.mpr
+      refine ⟨n, ?_, hle⟩
+      exact (stoppedMarkedGood_time_congr κ B γ G (cutoffStop σ (n : ℝ≥0))
+        (fun ω => (σ ω).untopD 0) z s ω (cutoffStop_eq_on_success σ _ ω hle)).mpr hg
+    · intro hg
+      obtain ⟨n, hn, hle⟩ := mem_iUnion.mp hg
+      refine ⟨ne_top_of_le_ne_top WithTop.coe_ne_top hle, ?_⟩
+      exact (stoppedMarkedGood_time_congr κ B γ G (cutoffStop σ (n : ℝ≥0))
+        (fun ω => (σ ω).untopD 0) z s ω (cutoffStop_eq_on_success σ _ ω hle)).mp hn
+  rw [he]
+  exact MeasurableSet.iUnion hE
+
+lemma extendedMarkedGood_eq_actual_angle
+    {Ω : Type*} (κ : ℝ) (B : ℝ≥0 → Ω → ℝ)
+    (γ : Ω → ℝ≥0 → ℂ) (G : Ω → ℝ≥0 → ℂ → ℂ)
+    (σ : Ω → WithTop ℝ≥0) (z : ℂ) (s : ℝ) :
+    extendedMarkedGood κ B γ G σ z s =
+      {ω | σ ω ≠ ⊤ ∧ z ∈ survivingDomain (γ ω) ((σ ω).untopD 0) ∧
+        s ≤ Real.sin (Complex.arg (G ω ((σ ω).untopD 0) z -
+          (Real.sqrt κ * B ((σ ω).untopD 0) ω : ℝ)))} := by
+  ext ω
+  change (σ ω ≠ ⊤ ∧ z ∈ survivingDomain (γ ω) ((σ ω).untopD 0) ∧ _) ↔ _
+  simp only [mem_ofPred_eq]
+  by_cases hl : z ∈ survivingDomain (γ ω) ((σ ω).untopD 0)
+  · rw [stoppedMarkedUnit_im_on_live B κ γ G (fun ω => (σ ω).untopD 0) z ω hl]
+  · simp only [hl, false_and, and_false]
+
+lemma canonical_good_angle_eq_extendedMarkedGood
+    {Ω : Type*} (κ : ℝ) (B : ℝ≥0 → Ω → ℝ)
+    (hc : ∀ ω, Continuous (fun t => B t ω))
+    (γ : Ω → ℝ≥0 → ℂ) (G F : Ω → ℝ≥0 → ℂ → ℂ)
+    (hw : ∀ ω, IsCapacityTwoWitness (fun t => Real.sqrt κ * B t ω) (γ ω) (G ω) (F ω))
+    (z : ℂ) (u s : ℝ) (hu : 0 ≤ u) :
+    {ω | canonicalRadiusLevel κ (u, z, sourceDriverPath B hc ω) < ∞ ∧
+      s ≤ canonicalStoppedSine κ (u, z, sourceDriverPath B hc ω)} =
+      extendedMarkedGood κ B γ G
+        (fun ω => (radiusLevelTime (γ ω) (G ω) z u : WithTop ℝ≥0)) z s := by
+  rw [canonical_good_angle_source_eq κ B hc γ G F hw z u s hu]
+  rw [extendedMarkedGood_eq_actual_angle κ B γ G
+    (fun ω => (radiusLevelTime (γ ω) (G ω) z u : WithTop ℝ≥0)) z s]
+  ext ω
+  simp only [mem_ofPred_eq]
+  by_cases hf : radiusLevelTime (γ ω) (G ω) z u < ∞
+  · obtain ⟨T, hT, hR⟩ := exists_live_level_of_radiusLevelTime_lt_top (γ ω) (G ω) z u hf
+    have he := radiusLevelTime_eq_of_live_level ((hc ω).const_mul _) (hw ω) z u T hT hR
+    rw [he]
+    change ((T : ℝ≥0∞) < ∞ ∧
+      s ≤ Real.sin (Complex.arg (G ω (T : ℝ≥0∞).toNNReal z -
+        (Real.sqrt κ * B (T : ℝ≥0∞).toNNReal ω : ℝ)))) ↔
+      ((T : WithTop ℝ≥0) ≠ ⊤ ∧ z ∈ survivingDomain (γ ω) ((T : WithTop ℝ≥0).untopD 0) ∧
+        s ≤ Real.sin (Complex.arg (G ω ((T : WithTop ℝ≥0).untopD 0) z -
+          (Real.sqrt κ * B ((T : WithTop ℝ≥0).untopD 0) ω : ℝ))))
+    simp only [ENNReal.coe_lt_top, ENNReal.toNNReal_coe,
+      WithTop.untopD_coe, hT, true_and]
+    constructor
+    · intro hs
+      exact ⟨WithTop.coe_ne_top, hs⟩
+    · exact fun h => h.2
+  · have he : radiusLevelTime (γ ω) (G ω) z u = ∞ := not_lt_top_iff.mp hf
+    simp only [he, lt_self_iff_false, false_and]
+    constructor
+    · exact False.elim
+    · intro h
+      exact h.1 rfl
+
+/-- The jointly measurable canonical angle event also belongs to the
+literal actual radius stop's past. -/
+theorem canonical_good_angle_measurable_at_radius
+    {Ω : Type*} [mΩ : MeasurableSpace Ω] {P : Measure Ω}
+    {B : ℝ≥0 → Ω → ℝ} (hB : IsBrownianReal B P)
+    (hm : ∀ t, Measurable (B t))
+    (hBm : Measurable (fun p : ℝ≥0 × Ω => B p.1 p.2))
+    (hc : ∀ ω, Continuous (fun t => B t ω)) (hB0 : ∀ ω, B 0 ω = 0)
+    (κ : ℝ) (hκ : 0 < κ) (hκ8 : κ < 8)
+    (γ : Ω → ℝ≥0 → ℂ) (G F : Ω → ℝ≥0 → ℂ → ℂ)
+    (hw : ∀ ω, IsCapacityTwoWitness (fun t => Real.sqrt κ * B t ω) (γ ω) (G ω) (F ω))
+    (z : ℂ) (hz : z ∈ upperHalfPlane) (u s : ℝ) (hu : 0 ≤ u) :
+    MeasurableSet[(actual_radiusLevelTime_stopping hB hm hBm hc hB0 κ hκ hκ8
+      γ G F hw z hz u hu).measurableSpace]
+      {ω | canonicalRadiusLevel κ (u, z, sourceDriverPath B hc ω) < ∞ ∧
+        s ≤ canonicalStoppedSine κ (u, z, sourceDriverPath B hc ω)} := by
+  rw [canonical_good_angle_eq_extendedMarkedGood κ B hc γ G F hw z u s hu]
+  exact extendedMarkedGood_measurable B hm hc κ γ G F hw _
+    (actual_radiusLevelTime_stopping hB hm hBm hc hB0 κ hκ hκ8 γ G F hw z hz u hu) z s
+
+/-- The same stopped-past measurability for the literal geometric angle. -/
+theorem actual_good_angle_measurable_at_radius
+    {Ω : Type*} [mΩ : MeasurableSpace Ω] {P : Measure Ω}
+    {B : ℝ≥0 → Ω → ℝ} (hB : IsBrownianReal B P)
+    (hm : ∀ t, Measurable (B t))
+    (hBm : Measurable (fun p : ℝ≥0 × Ω => B p.1 p.2))
+    (hc : ∀ ω, Continuous (fun t => B t ω)) (hB0 : ∀ ω, B 0 ω = 0)
+    (κ : ℝ) (hκ : 0 < κ) (hκ8 : κ < 8)
+    (γ : Ω → ℝ≥0 → ℂ) (G F : Ω → ℝ≥0 → ℂ → ℂ)
+    (hw : ∀ ω, IsCapacityTwoWitness (fun t => Real.sqrt κ * B t ω) (γ ω) (G ω) (F ω))
+    (z : ℂ) (hz : z ∈ upperHalfPlane) (u s : ℝ) (hu : 0 ≤ u) :
+    MeasurableSet[(actual_radiusLevelTime_stopping hB hm hBm hc hB0 κ hκ hκ8
+      γ G F hw z hz u hu).measurableSpace]
+      {ω | radiusLevelTime (γ ω) (G ω) z u < ∞ ∧
+        s ≤ Real.sin (Complex.arg (G ω (radiusLevelTime (γ ω) (G ω) z u).toNNReal z -
+          (Real.sqrt κ * B (radiusLevelTime (γ ω) (G ω) z u).toNNReal ω : ℝ)))} := by
+  rw [← canonical_good_angle_source_eq κ B hc γ G F hw z u s hu]
+  exact canonical_good_angle_measurable_at_radius hB hm hBm hc hB0 κ hκ hκ8 γ G F hw z hz u s hu
+
+end SLEExactGauge
+
+end
+
+end OAI
diff --git a/lean/OAI/Probability/SLE/Geometry/ExtendedStopLocalization.lean b/lean/OAI/Probability/SLE/Geometry/ExtendedStopLocalization.lean
new file mode 100644
index 0000000000000000000000000000000000000000..e727c863d4567db6e2f4af47aad4fa016dc3bf76
--- /dev/null
+++ b/lean/OAI/Probability/SLE/Geometry/ExtendedStopLocalization.lean
@@ -0,0 +1,123 @@
+import OAI.Probability.SLE.Gauge.ExtendedExperimentStop
+
+namespace OAI
+
+/-! Finite localization of a possibly infinite stopping time. The value
+`S.untopD 0` is used only on the event where `S` is finite; it is not asserted
+to be a stopping time on the whole sample space. -/
+
+noncomputable section
+open Set Filter MeasureTheory ProbabilityTheory
+open scoped NNReal ENNReal Topology
+
+namespace SLEExactGauge
+
+variable {Ω : Type*}
+
+def finiteStopEvent (S : Ω → WithTop ℝ≥0) (n : ℕ) : Set Ω :=
+  {ω | S ω ≤ ((n : ℝ≥0) : WithTop ℝ≥0)}
+
+lemma cutoffStop_le_horizon (S : Ω → WithTop ℝ≥0) (H : ℝ≥0) (ω : Ω) :
+    cutoffStop S H ω ≤ H := by
+  exact WithTop.coe_le_coe.mp ((cutoffStop_coe S H ω).trans_le (min_le_right _ _))
+
+lemma cutoffStop_le_stop (S : Ω → WithTop ℝ≥0) (H : ℝ≥0) (ω : Ω) :
+    (cutoffStop S H ω : WithTop ℝ≥0) ≤ S ω := by
+  rw [cutoffStop_coe]
+  exact min_le_left _ _
+
+lemma cutoffStop_monotone (S : Ω → WithTop ℝ≥0) (ω : Ω) :
+    Monotone (fun H : ℝ≥0 => cutoffStop S H ω) := by
+  intro H K hHK
+  apply WithTop.coe_le_coe.mp
+  rw [cutoffStop_coe,cutoffStop_coe]
+  exact min_le_min_left _ (WithTop.coe_le_coe.mpr hHK)
+
+lemma finiteStopEvent_mono (S : Ω → WithTop ℝ≥0) : Monotone (finiteStopEvent S) := by
+  intro n k hnk ω hω
+  change S ω ≤ ((n : ℝ≥0) : WithTop ℝ≥0) at hω
+  change S ω ≤ ((k : ℝ≥0) : WithTop ℝ≥0)
+  exact hω.trans (WithTop.coe_le_coe.mpr (by exact_mod_cast hnk))
+
+lemma iUnion_finiteStopEvent (S : Ω → WithTop ℝ≥0) :
+    (⋃ n, finiteStopEvent S n) = {ω | S ω < ⊤} := by
+  ext ω
+  simp only [mem_iUnion,finiteStopEvent,mem_ofPred_eq]
+  constructor
+  · rintro ⟨n,hn⟩
+    exact hn.trans_lt (WithTop.coe_lt_top _)
+  · intro hω
+    lift S ω to ℝ≥0 using hω.ne with t ht
+    obtain ⟨n,hn⟩ := exists_nat_ge (t : ℝ)
+    refine ⟨n,?_⟩
+    exact WithTop.coe_le_coe.mpr (by exact_mod_cast hn)
+
+lemma cutoffStop_eqOn_finiteStopEvent (S : Ω → WithTop ℝ≥0) (n : ℕ) :
+    EqOn (cutoffStop S n) (fun ω => (S ω).untopD 0) (finiteStopEvent S n) := by
+  intro ω hω
+  exact cutoffStop_eq_on_success S n ω hω
+
+lemma cutoffStop_eventually_eq (S : Ω → WithTop ℝ≥0) (ω : Ω) (hω : S ω < ⊤) :
+    ∀ᶠ n : ℕ in atTop, cutoffStop S n ω = (S ω).untopD 0 := by
+  have hmem : ω ∈ ⋃ n, finiteStopEvent S n := by
+    rw [iUnion_finiteStopEvent S]
+    exact hω
+  obtain ⟨n,hn⟩ := mem_iUnion.mp hmem
+  filter_upwards [eventually_ge_atTop n] with k hk
+  exact cutoffStop_eqOn_finiteStopEvent S k (finiteStopEvent_mono S hk hn)
+
+section Measurable
+
+variable [mΩ : MeasurableSpace Ω] (ℱ : Filtration ℝ≥0 mΩ)
+  (S : Ω → WithTop ℝ≥0) (hS : IsStoppingTime ℱ S)
+
+lemma finiteStopEvent_measurable (n : ℕ) :
+    MeasurableSet[hS.measurableSpace] (finiteStopEvent S n) :=
+  hS.measurableSet_le' n
+
+lemma finiteStopEvent_measurable_cutoff (n : ℕ) :
+    MeasurableSet[(cutoffStop_stopping ℱ S hS n).measurableSpace] (finiteStopEvent S n) := by
+  simpa only [Set.univ_inter,finiteStopEvent] using
+    cutoffStop_success_measurable ℱ S hS n Set.univ MeasurableSet.univ
+
+lemma finiteStopEvent_inter_measurable_cutoff (n : ℕ) (E : Set Ω)
+    (hE : MeasurableSet[hS.measurableSpace] E) :
+    MeasurableSet[(cutoffStop_stopping ℱ S hS n).measurableSpace] (E ∩ finiteStopEvent S n) :=
+  cutoffStop_success_measurable ℱ S hS n E hE
+
+lemma finiteStopEvent_all_measurable :
+    MeasurableSet[hS.measurableSpace] {ω | S ω < ⊤} := by
+  rw [← iUnion_finiteStopEvent S]
+  exact MeasurableSet.iUnion (finiteStopEvent_measurable ℱ S hS)
+
+lemma cutoffStop_past_le (n : ℕ) :
+    (cutoffStop_stopping ℱ S hS n).measurableSpace ≤ hS.measurableSpace :=
+  IsStoppingTime.measurableSpace_mono _ hS (cutoffStop_le_stop S n)
+
+lemma ae_of_cutoffStop (P : Measure Ω) (Q : Ω → ℝ≥0 → Prop)
+    (hQ : ∀ n : ℕ, ∀ᵐ ω ∂P, Q ω (cutoffStop S n ω)) :
+    ∀ᵐ ω ∂P, S ω < ⊤ → Q ω ((S ω).untopD 0) := by
+  filter_upwards [ae_all_iff.mpr hQ] with ω hω hfinite
+  have hmem : ω ∈ ⋃ n, finiteStopEvent S n := by
+    rw [iUnion_finiteStopEvent S]
+    exact hfinite
+  obtain ⟨n,hn⟩ := mem_iUnion.mp hmem
+  simpa only [cutoffStop_eqOn_finiteStopEvent S n hn] using hω n
+
+end Measurable
+
+lemma sourceRestartDriverPath_eq_on_finiteStopEvent
+    (B : ℝ≥0 → Ω → ℝ) (hc : ∀ ω, Continuous (fun t => B t ω))
+    (S : Ω → WithTop ℝ≥0) (n : ℕ) (ω : Ω) (hω : ω ∈ finiteStopEvent S n) :
+    sourceRestartDriverPath B hc (cutoffStop S n) ω =
+      sourceRestartDriverPath B hc (fun ω => (S ω).untopD 0) ω := by
+  ext t
+  change B (cutoffStop S n ω+t) ω-B (cutoffStop S n ω) ω =
+    B ((S ω).untopD 0+t) ω-B ((S ω).untopD 0) ω
+  rw [cutoffStop_eqOn_finiteStopEvent S n hω]
+
+end SLEExactGauge
+
+end
+
+end OAI
diff --git a/lean/OAI/Probability/SLE/Geometry/ExteriorCapacityRemainder.lean b/lean/OAI/Probability/SLE/Geometry/ExteriorCapacityRemainder.lean
new file mode 100644
index 0000000000000000000000000000000000000000..8e17a0c68390007eb89c6d8373acb6478b09dd66
--- /dev/null
+++ b/lean/OAI/Probability/SLE/Geometry/ExteriorCapacityRemainder.lean
@@ -0,0 +1,61 @@
+import OAI.Probability.SLE.Geometry.ExteriorHerglotzPositive
+import OAI.Probability.SLE.Geometry.DiskKernelRemainder
+
+namespace OAI
+
+/-! Capacity-relative remainder for a hydrodynamically normalized
+reflected slit contained in a small disk. -/
+noncomputable section
+open Set Filter Function Complex Metric
+open scoped Topology
+
+namespace SLEExactGauge
+
+theorem exterior_capacity_remainder {G : ℂ → ℂ} {R c : ℝ}
+    (hR : 0<R) (hc0 : 0<c)
+    (hG : ∀ z : ℂ, R≤‖z‖ → DifferentiableAt ℂ G z)
+    (hc : Tendsto (fun z : ℂ => z*(G z-z)) (cocompact ℂ) (𝓝 (c:ℂ)))
+    (hs : ∀ z : ℂ, R≤‖z‖ → z.im*(G z-z).im≤0)
+    {z : ℂ} (hz : 2*R≤‖z‖) :
+    ‖G z-z-(c:ℂ)/z‖≤10*c*R/‖z‖^2 := by
+  have hn : 0<‖z‖ := lt_of_lt_of_le (by linarith : 0<2*R) hz
+  have hz0 : z≠0 := norm_pos_iff.mp hn
+  have hR0 : (R:ℂ)≠0 := ofReal_ne_zero.mpr hR.ne'
+  let w : ℂ := (R:ℂ)/z
+  have hw0 : w≠0 := div_ne_zero hR0 hz0
+  have hwn : ‖w‖=R/‖z‖ := by
+    simp only [w,norm_div,Complex.norm_real,Real.norm_eq_abs,abs_of_pos hR]
+  have hw : ‖w‖≤1/2 := by rw [hwn]; apply (div_le_iff₀ hn).mpr; linarith
+  have hH := exteriorHerglotzTransform_differentiableOn hR hG hc
+  have hpos := exteriorHerglotzTransform_nonneg hR hG hc hs
+  have hb := positive_real_disk_kernel_remainder (div_pos hc0 hR)
+    (hH.mono ball_subset_closedBall) (by simp only [exteriorHerglotzTransform_zero,ofReal_div])
+    (fun v hv => hpos v (ball_subset_closedBall hv)) hw
+  have hw2 : (1:ℂ)-w^2≠0 := by
+    have hlt : ‖w^2‖<1 := by rw [norm_pow]; nlinarith [norm_nonneg w]
+    intro he
+    have he' : w^2=1 := (sub_eq_zero.mp he).symm
+    rw [he',norm_one] at hlt
+    exact lt_irrefl _ hlt
+  have hinv : (R:ℂ)/w=z := by dsimp only [w]; field_simp
+  have he : w*exteriorHerglotzTransform G R c w/(1-w^2)-(c/R:ℝ)*w=
+      G z-z-(c:ℂ)/z := by
+    have hm : (c/R:ℝ)*w=(c:ℂ)/z := by
+      dsimp only [w]
+      rw [ofReal_div]
+      field_simp [hR0]
+    rw [hm,exteriorHerglotzTransform_eq_raw hw0]
+    unfold exteriorHerglotzRaw
+    rw [hinv]
+    congr 1
+    field_simp [hw0,hw2]
+  rw [he,hwn] at hb
+  have hbR : 10*(c/R)*(R/‖z‖)^2=10*c*R/‖z‖^2 := by
+    field_simp [hR.ne',hn.ne']
+  rwa [hbR] at hb
+
+end SLEExactGauge
+
+end
+
+end OAI
diff --git a/lean/OAI/Probability/SLE/Geometry/ExteriorCompactFlux.lean b/lean/OAI/Probability/SLE/Geometry/ExteriorCompactFlux.lean
new file mode 100644
index 0000000000000000000000000000000000000000..44db8d9f7700516be59a70f67c07e1ac62ec7dd3
--- /dev/null
+++ b/lean/OAI/Probability/SLE/Geometry/ExteriorCompactFlux.lean
@@ -0,0 +1,50 @@
+import OAI.Probability.SLE.Geometry.AnnulusPolarIntegral
+
+namespace OAI
+
+/-! A compactly supported test with nonpositive exterior Laplacian
+integral has nonnegative inward boundary flux. -/
+noncomputable section
+open Set Filter Metric Function Complex MeasureTheory InnerProductSpace
+open scoped Topology Laplacian
+
+namespace SLEExactGauge
+
+lemma exterior_compact_flux_nonneg {v : ℂ → ℝ} {a : ℝ} (ha : 0<a)
+    (hv : ∀ z : ℂ, a≤‖z‖ → ContDiffAt ℝ 2 v z)
+    (hs : HasCompactSupport v)
+    (hneg : (∫ z in {z : ℂ | a<‖z‖}, (Δ v) z)≤0) :
+    0≤∫ θ in -Real.pi..Real.pi, radialLaplacianFlux v (a,θ) := by
+  obtain ⟨M,hM,hMs⟩ := hs.isBounded.exists_pos_norm_lt
+  let R := max a M+1
+  have haR : a≤R := by dsimp [R]; linarith [le_max_left a M]
+  have hMR : M<R := by dsimp [R]; linarith [le_max_right a M]
+  have hnot (z : ℂ) (hz : R≤‖z‖) : z∉tsupport v := by
+    intro hs'
+    exact (hMs z hs').not_ge (hMR.le.trans hz)
+  have hzero (z : ℂ) (hz : R≤‖z‖) : (Δ v) z=0 := by
+    have hh := (laplacian_congr_nhds (notMem_tsupport_iff_eventuallyEq.mp (hnot z hz))).self_of_nhds
+    simpa only [Pi.zero_def,laplacian_const,Pi.zero_apply] using hh
+  have hrestrict : (∫ z in {z : ℂ | a<‖z‖}, (Δ v) z)=
+      ∫ z in {z : ℂ | a<‖z‖ ∧ ‖z‖<R}, (Δ v) z := by
+    apply setIntegral_eq_of_subset_of_forall_sdiff_eq_zero
+      (isOpen_lt continuous_const continuous_norm).measurableSet
+      (fun z hz => hz.1)
+    intro z hz
+    apply hzero z
+    exact le_of_not_gt (fun h => hz.2 ⟨hz.1,h⟩)
+  have hrzero (θ : ℝ) : radialLaplacianFlux v (R,θ)=0 := by
+    have hn : R≤‖polarPoint R θ‖ := by
+      rw [polarPoint_norm,abs_of_pos (ha.trans_le haR)]
+    simp only [radialLaplacianFlux,fderiv_of_notMem_tsupport ℝ (hnot _ hn),
+      zero_apply,mul_zero]
+  have he := annulus_integral_laplacian_flux ha haR (fun z hz _ => hv z hz)
+  rw [hrestrict,he] at hneg
+  simp only [hrzero,intervalIntegral.integral_zero,zero_sub] at hneg
+  linarith
+
+end SLEExactGauge
+
+end
+
+end OAI
diff --git a/lean/OAI/Probability/SLE/Geometry/ExteriorFirstCoefficient.lean b/lean/OAI/Probability/SLE/Geometry/ExteriorFirstCoefficient.lean
new file mode 100644
index 0000000000000000000000000000000000000000..d203acf6bffc461803e79479965301c23eec1fb9
--- /dev/null
+++ b/lean/OAI/Probability/SLE/Geometry/ExteriorFirstCoefficient.lean
@@ -0,0 +1,87 @@
+import OAI.Probability.SLE.Geometry.HolomorphicAreaAverage
+import OAI.Probability.SLE.Geometry.AnalyticFluxEnergy
+
+namespace OAI
+
+/-! The first inverse-radius coefficient of a univalent exterior map is
+bounded by its nonnegative signed boundary area. -/
+noncomputable section
+open Set Filter Metric Function Complex MeasureTheory InnerProductSpace Real
+open scoped Topology Laplacian ComplexConjugate
+
+namespace SLEExactGauge
+
+lemma exterior_first_coefficient_le_one {f C : ℂ → ℂ}
+    (hf : DifferentiableOn ℂ f {z : ℂ | 1<‖z‖})
+    (hC : DifferentiableOn ℂ C (ball 0 1))
+    (he : ∀ z : ℂ, 1<‖z‖ → f z=z+C z⁻¹)
+    (hflux : ∀ r : ℝ, 1<r → 0≤∫ θ in -Real.pi..Real.pi,
+      radialLaplacianFlux (fun z => ‖f z‖^2) (r,θ)) :
+    ‖deriv C 0‖≤1 := by
+  have hbound (r : ℝ) (hr : 1<r) : ‖deriv C 0‖≤r^2 := by
+    have hr0 : 0<r := zero_lt_one.trans hr
+    have hri : 0<r⁻¹ := inv_pos.mpr hr0
+    have hri1 : r⁻¹<1 := inv_lt_one_of_one_lt₀ hr
+    have hCa : AnalyticOnNhd ℂ C (closedBall (0:ℂ) r⁻¹) := by
+      intro z hz
+      apply hC.analyticAt
+      apply isOpen_ball.mem_nhds
+      exact (closedBall_subset_ball hri1) hz
+    have hfa : AnalyticOnNhd ℂ f (sphere (0:ℂ) |r|) := by
+      intro z hz
+      apply hf.analyticAt
+      apply (isOpen_lt continuous_const continuous_norm).mem_nhds
+      have hzr : ‖z‖=r := by simpa only [mem_sphere,dist_zero_right,abs_of_pos hr0] using hz
+      change 1<‖z‖
+      rwa [hzr]
+    have hval (z : ℂ) (hz : z∈sphere (0:ℂ) r) : f z=z+C z⁻¹ := by
+      apply he z
+      rwa [show ‖z‖=r by simpa only [mem_sphere,dist_zero_right] using hz]
+    have hder (z : ℂ) (hz : z∈sphere (0:ℂ) r) :
+        deriv f z=1-z⁻¹^2*deriv C z⁻¹ := by
+      have hzr : ‖z‖=r := by simpa only [mem_sphere,dist_zero_right] using hz
+      have hz0 : z≠0 := (norm_ne_zero_iff (a := z)).mp (by rw [hzr]; exact hr0.ne')
+      have hzi : z⁻¹∈ball (0:ℂ) 1 := by
+        rw [mem_ball_zero_iff,norm_inv,hzr]
+        exact hri1
+      have hdC := (hC.differentiableAt (isOpen_ball.mem_nhds hzi)).hasDerivAt
+      have hd := (hasDerivAt_id z).add (hdC.comp z (hasDerivAt_inv hz0))
+      have heloc : f =ᶠ[𝓝 z] (fun z => z+C z⁻¹) := by
+        filter_upwards [(isOpen_lt continuous_const continuous_norm).mem_nhds
+          (show 1<‖z‖ by rwa [hzr])] with w hw
+        exact he w hw
+      have hh := (hd.congr_of_eventuallyEq heloc).deriv
+      convert! hh using 1
+      ring
+    have harea := inverse_chart_area_average hr0 hCa hval hder
+    have hfp := hflux r hr
+    rw [holomorphic_flux_eq_area_average hfa,harea] at hfp
+    have hcp := analytic_flux_ge_first_coefficient hri hCa
+    rw [holomorphic_flux_eq_area_average (hCa.mono (by
+      rw [abs_of_pos hri]; exact sphere_subset_closedBall))] at hcp
+    have hs : r⁻¹^2*‖deriv C 0‖^2≤r^2 := by
+      apply (mul_le_mul_iff_right₀ (show 0<4*Real.pi by positivity)).mp
+      nlinarith only [hfp,hcp]
+    have hrnorm : r⁻¹*‖deriv C 0‖≤r := by
+      apply (sq_le_sq₀ (mul_nonneg hri.le (norm_nonneg _)) hr0.le).mp
+      nlinarith only [hs]
+    have hh : ‖deriv C 0‖≤r*r := by
+      apply (div_le_iff₀ hr0).mp
+      simpa only [div_eq_mul_inv,mul_comm] using hrnorm
+    simpa only [pow_two] using hh
+  let r (n : ℕ) := 1+1/((n:ℝ)+1)
+  have hr (n : ℕ) : 1<r n := by
+    dsimp [r]
+    have : 0 < 1 / ((n:ℝ)+1) := by positivity
+    linarith
+  have ht : Tendsto r atTop (𝓝 1) := by
+    simpa only [r,add_zero] using
+      (tendsto_one_div_add_atTop_nhds_zero_nat (𝕜 := ℝ)).const_add 1
+  have ht2 : Tendsto (fun n => (r n)^2) atTop (𝓝 (1:ℝ)) := by simpa using ht.pow 2
+  exact ge_of_tendsto ht2 (Eventually.of_forall (fun n => hbound (r n) (hr n)))
+
+end SLEExactGauge
+
+end
+
+end OAI
diff --git a/lean/OAI/Probability/SLE/Geometry/ExteriorHerglotzAnalytic.lean b/lean/OAI/Probability/SLE/Geometry/ExteriorHerglotzAnalytic.lean
new file mode 100644
index 0000000000000000000000000000000000000000..41690acdf7fbcc69bdc0149196ad43855fe96fba
--- /dev/null
+++ b/lean/OAI/Probability/SLE/Geometry/ExteriorHerglotzAnalytic.lean
@@ -0,0 +1,56 @@
+import OAI.Probability.SLE.Geometry.ExteriorHerglotzTransform
+
+namespace OAI
+
+/-! The hydrodynamic singularity of the inverted transform is removable.
+Only analyticity outside the chosen circle is required. -/
+noncomputable section
+open Set Filter Function Complex Metric
+open scoped Topology
+
+namespace SLEExactGauge
+
+lemma exteriorHerglotzTransform_eq_raw {G : ℂ → ℂ} {R c : ℝ} {w : ℂ}
+    (hw : w≠0) : exteriorHerglotzTransform G R c w=exteriorHerglotzRaw G R w :=
+  Function.update_of_ne hw _ _
+
+lemma exteriorHerglotzTransform_differentiableAt_ne_zero {G : ℂ → ℂ} {R c : ℝ}
+    (hR : 0<R) (hG : ∀ z : ℂ, R≤‖z‖ → DifferentiableAt ℂ G z)
+    {w : ℂ} (hw : w≠0) (hw1 : ‖w‖≤1) :
+    DifferentiableAt ℂ (exteriorHerglotzTransform G R c) w := by
+  have hn : 0<‖w‖ := norm_pos_iff.mpr hw
+  have hz : R≤‖(R:ℂ)/w‖ := by
+    rw [norm_div,Complex.norm_real,Real.norm_eq_abs,abs_of_pos hR]
+    exact (le_div_iff₀ hn).mpr (mul_le_of_le_one_right hR.le hw1)
+  have hi : DifferentiableAt ℂ (fun v : ℂ => (R:ℂ)/v) w :=
+    (differentiableAt_const (R:ℂ)).div differentiableAt_id hw
+  have hd : DifferentiableAt ℂ (exteriorHerglotzRaw G R) w :=
+    ((((differentiableAt_const (1:ℂ)).sub (differentiableAt_id.pow 2)).div
+      differentiableAt_id hw).mul (((hG _ hz).comp w hi).sub hi))
+  apply hd.congr_of_eventuallyEq
+  filter_upwards [isOpen_ne.mem_nhds hw] with v hv
+  exact exteriorHerglotzTransform_eq_raw hv
+
+theorem exteriorHerglotzTransform_differentiableOn {G : ℂ → ℂ} {R c : ℝ}
+    (hR : 0<R) (hG : ∀ z : ℂ, R≤‖z‖ → DifferentiableAt ℂ G z)
+    (hc : Tendsto (fun z : ℂ => z*(G z-z)) (cocompact ℂ) (𝓝 (c:ℂ))) :
+    DifferentiableOn ℂ (exteriorHerglotzTransform G R c) (closedBall 0 1) := by
+  have hzero : DifferentiableAt ℂ (exteriorHerglotzTransform G R c) 0 := by
+    apply (Complex.analyticAt_of_differentiable_on_punctured_nhds_of_continuousAt ?_
+      (exteriorHerglotzTransform_continuousAt_zero hR.ne' hc)).differentiableAt
+    have hb : ∀ᶠ w : ℂ in 𝓝[≠] (0:ℂ), w∈ball 0 1 :=
+      Filter.Eventually.filter_mono inf_le_left (ball_mem_nhds (0:ℂ) zero_lt_one)
+    filter_upwards [self_mem_nhdsWithin,hb] with w hw hw1
+    exact exteriorHerglotzTransform_differentiableAt_ne_zero hR hG hw
+      (mem_ball_zero_iff.mp hw1).le
+  intro w hw
+  rcases eq_or_ne w 0 with rfl|hne
+  · exact hzero.differentiableWithinAt
+  · exact (exteriorHerglotzTransform_differentiableAt_ne_zero hR hG hne
+      (mem_closedBall_zero_iff.mp hw)).differentiableWithinAt
+
+end SLEExactGauge
+
+end
+
+end OAI
diff --git a/lean/OAI/Probability/SLE/Geometry/ExteriorHerglotzPositive.lean b/lean/OAI/Probability/SLE/Geometry/ExteriorHerglotzPositive.lean
new file mode 100644
index 0000000000000000000000000000000000000000..bf381b97c6a404f573d4b06fbf5e4ac07d504bd8
--- /dev/null
+++ b/lean/OAI/Probability/SLE/Geometry/ExteriorHerglotzPositive.lean
@@ -0,0 +1,51 @@
+import OAI.Probability.SLE.Geometry.ExteriorHerglotzAnalytic
+import OAI.Probability.SLE.Geometry.PositiveRealDiskEstimate
+
+namespace OAI
+
+/-! The normalized height inequality becomes positivity of the real
+part after inversion. -/
+noncomputable section
+open Set Filter Function Complex Metric
+open scoped Topology ComplexConjugate
+
+namespace SLEExactGauge
+
+lemma exteriorHerglotzTransform_sphere_re {G : ℂ → ℂ} {R c : ℝ}
+    {w : ℂ} (hw : ‖w‖=1) :
+    (exteriorHerglotzTransform G R c w).re=
+      2*w.im*(G ((R:ℂ)/w)-(R:ℂ)/w).im := by
+  have hw0 : w≠0 := by intro he; simp [he] at hw
+  have he : ((1:ℂ)-w^2)/w=conj w-w := by
+    rw [← Complex.inv_eq_conj hw]
+    field_simp [hw0]
+  rw [exteriorHerglotzTransform_eq_raw hw0]
+  simp only [exteriorHerglotzRaw,he,mul_re,sub_re,sub_im,conj_re,conj_im]
+  ring
+
+theorem exteriorHerglotzTransform_nonneg {G : ℂ → ℂ} {R c : ℝ}
+    (hR : 0<R) (hG : ∀ z : ℂ, R≤‖z‖ → DifferentiableAt ℂ G z)
+    (hc : Tendsto (fun z : ℂ => z*(G z-z)) (cocompact ℂ) (𝓝 (c:ℂ)))
+    (hs : ∀ z : ℂ, R≤‖z‖ → z.im*(G z-z).im≤0) :
+    ∀ w∈closedBall (0:ℂ) 1, 0≤(exteriorHerglotzTransform G R c w).re := by
+  apply real_nonneg_of_sphere_nonneg zero_lt_one
+    (exteriorHerglotzTransform_differentiableOn hR hG hc)
+  intro w hw
+  have hwn : ‖w‖=1 := by simpa only [mem_sphere,dist_zero_right] using hw
+  have hz : ‖(R:ℂ)/w‖=R := by
+    rw [norm_div,Complex.norm_real,Real.norm_eq_abs,abs_of_pos hR,hwn,div_one]
+  have him : ((R:ℂ)/w).im= -R*w.im := by
+    rw [div_eq_mul_inv,Complex.inv_eq_conj hwn]
+    simp only [mul_im,ofReal_re,ofReal_im,conj_im,zero_mul,add_zero]
+    ring
+  have hh := hs ((R:ℂ)/w) hz.ge
+  rw [him] at hh
+  rw [exteriorHerglotzTransform_sphere_re hwn]
+  have hp : 0≤w.im*(G ((R:ℂ)/w)-(R:ℂ)/w).im := by nlinarith
+  nlinarith
+
+end SLEExactGauge
+
+end
+
+end OAI
diff --git a/lean/OAI/Probability/SLE/Geometry/ExteriorHerglotzTransform.lean b/lean/OAI/Probability/SLE/Geometry/ExteriorHerglotzTransform.lean
new file mode 100644
index 0000000000000000000000000000000000000000..4d8b42668016a5fcb7b0e99c6549c2d98e6429de
--- /dev/null
+++ b/lean/OAI/Probability/SLE/Geometry/ExteriorHerglotzTransform.lean
@@ -0,0 +1,60 @@
+import OAI.Probability.SLE.Loewner.ReflectedExteriorAnalytic
+import Mathlib.Analysis.Complex.RemovableSingularity
+
+namespace OAI
+
+/-! Inversion converts the vanishing exterior hydrodynamic displacement
+into a disk function whose value at zero is exactly capacity/radius. -/
+noncomputable section
+open Set Filter Function Complex Metric
+open scoped Topology
+
+namespace SLEExactGauge
+
+def exteriorHerglotzRaw (G : ℂ → ℂ) (R : ℝ) (w : ℂ) : ℂ :=
+  (1-w^2)/w*(G ((R:ℂ)/w)-(R:ℂ)/w)
+
+noncomputable def exteriorHerglotzTransform (G : ℂ → ℂ) (R c : ℝ) : ℂ → ℂ :=
+  Function.update (exteriorHerglotzRaw G R) 0 ((c:ℂ)/(R:ℂ))
+
+@[simp] lemma exteriorHerglotzTransform_zero (G : ℂ → ℂ) (R c : ℝ) :
+    exteriorHerglotzTransform G R c 0=(c:ℂ)/(R:ℂ) := Function.update_self _ _ _
+
+lemma exteriorHerglotzRaw_identity (G : ℂ → ℂ) {R : ℝ} (hR : R≠0)
+    {w : ℂ} (hw : w≠0) :
+    exteriorHerglotzRaw G R w=(1-w^2)/(R:ℂ)*
+      (((R:ℂ)/w)*(G ((R:ℂ)/w)-(R:ℂ)/w)) := by
+  unfold exteriorHerglotzRaw
+  field_simp [ofReal_ne_zero.mpr hR,hw]
+
+lemma scaled_inverse_tendsto_cocompact {R : ℝ} (hR : R≠0) :
+    Tendsto (fun w : ℂ => (R:ℂ)/w) (𝓝[≠] (0:ℂ)) (cocompact ℂ) := by
+  have hi : Tendsto (fun w : ℂ => w⁻¹) (𝓝[≠] (0:ℂ)) (cocompact ℂ) := by
+    simpa only [Metric.cobounded_eq_cocompact] using
+      (tendsto_inv₀_nhdsNE_zero : Tendsto (Inv.inv : ℂ → ℂ) (𝓝[≠] (0:ℂ)) (Bornology.cobounded ℂ))
+  have hh :=
+    (Homeomorph.mulLeft₀ (R:ℂ) (ofReal_ne_zero.mpr hR)).isClosedEmbedding.tendsto_cocompact.comp hi
+  change Tendsto (fun w : ℂ => (R:ℂ)*w⁻¹) (𝓝[≠] (0:ℂ)) (cocompact ℂ) at hh
+  simpa only [div_eq_mul_inv] using hh
+
+theorem exteriorHerglotzTransform_continuousAt_zero {G : ℂ → ℂ} {R c : ℝ} (hR : R≠0)
+    (hc : Tendsto (fun z : ℂ => z*(G z-z)) (cocompact ℂ) (𝓝 (c:ℂ))) :
+    ContinuousAt (exteriorHerglotzTransform G R c) 0 := by
+  apply continuousAt_update_same.mpr
+  have hsmall : Tendsto (fun w : ℂ => (1-w^2)/(R:ℂ)) (𝓝[≠] (0:ℂ)) (𝓝 (1/(R:ℂ))) := by
+    have hh : Continuous (fun w : ℂ => (1-w^2)/(R:ℂ)) :=
+      (continuous_const.sub (continuous_id.pow 2)).div_const _
+    have ht := (hh.tendsto 0).mono_left (show 𝓝[≠] (0:ℂ)≤𝓝 (0:ℂ) from inf_le_left)
+    simpa only [zero_pow two_ne_zero,sub_zero] using ht
+  have ht := hsmall.mul (hc.comp (scaled_inverse_tendsto_cocompact hR))
+  have he : (1/(R:ℂ))*(c:ℂ)=(c:ℂ)/(R:ℂ) := by ring
+  rw [he] at ht
+  apply ht.congr'
+  filter_upwards [self_mem_nhdsWithin] with w hw
+  exact (exteriorHerglotzRaw_identity G hR hw).symm
+
+end SLEExactGauge
+
+end
+
+end OAI
diff --git a/lean/OAI/Probability/SLE/Geometry/ExteriorJoukowski.lean b/lean/OAI/Probability/SLE/Geometry/ExteriorJoukowski.lean
new file mode 100644
index 0000000000000000000000000000000000000000..17cfbfdc57be466e2c385d089131fe4d78267be1
--- /dev/null
+++ b/lean/OAI/Probability/SLE/Geometry/ExteriorJoukowski.lean
@@ -0,0 +1,116 @@
+import OAI.Probability.SLE.LoewnerCharts
+import Mathlib.Analysis.Complex.Polynomial.Basic
+
+namespace OAI
+
+/-! The Joukowski chart from the upper half of the exterior disk to the
+half-plane. This is the final elementary chart in exterior slit normalization. -/
+noncomputable section
+open Set Complex
+
+namespace SLEExactGauge
+
+def exteriorUpperDisk : Set ℂ := {w | 1 < ‖w‖ ∧ 0 < w.im}
+
+def exteriorJoukowski (w : ℂ) : ℂ := w+w⁻¹
+
+lemma exteriorJoukowski_im (w : ℂ) :
+    (exteriorJoukowski w).im=w.im-w.im/‖w‖^2 := by
+  simp only [exteriorJoukowski,add_im,inv_im,normSq_eq_norm_sq,neg_div,sub_eq_add_neg]
+
+lemma exteriorJoukowski_im_mul {w : ℂ} (hw : w ≠ 0) :
+    (exteriorJoukowski w).im*‖w‖^2=w.im*(‖w‖^2-1) := by
+  rw [exteriorJoukowski_im]
+  have hn : ‖w‖^2 ≠ 0 := pow_ne_zero _ (norm_ne_zero_iff.mpr hw)
+  field_simp
+
+lemma exteriorJoukowski_mapsTo : MapsTo exteriorJoukowski exteriorUpperDisk upperHalfPlane := by
+  intro w hw
+  change 1 < ‖w‖ ∧ 0 < w.im at hw
+  have hwn : 0 < ‖w‖ := zero_lt_one.trans hw.1
+  have hw0 : w ≠ 0 := norm_ne_zero_iff.mp hwn.ne'
+  have hsq : 1 < ‖w‖^2 := by nlinarith
+  have he := exteriorJoukowski_im_mul hw0
+  change 0 < (exteriorJoukowski w).im
+  nlinarith [mul_pos hw.2 (sub_pos.mpr hsq),sq_nonneg ‖w‖]
+
+lemma exteriorJoukowski_injOn : InjOn exteriorJoukowski {w : ℂ | 1 < ‖w‖} := by
+  intro u hu v hv he
+  change 1 < ‖u‖ at hu
+  change 1 < ‖v‖ at hv
+  have hu0 : u ≠ 0 := norm_ne_zero_iff.mp (zero_lt_one.trans hu).ne'
+  have hv0 : v ≠ 0 := norm_ne_zero_iff.mp (zero_lt_one.trans hv).ne'
+  have hf : (u-v)*(u*v-1)=0 := by
+    calc
+      (u-v)*(u*v-1)=(exteriorJoukowski u-exteriorJoukowski v)*(u*v) := by
+        dsimp only [exteriorJoukowski]
+        field_simp [hu0,hv0]
+        ring
+      _ = 0 := by rw [he,sub_self,zero_mul]
+  rcases mul_eq_zero.mp hf with h|h
+  · exact sub_eq_zero.mp h
+  · have hnorm : ‖u‖*‖v‖=1 := by
+      simpa only [norm_mul,norm_one] using congrArg norm (sub_eq_zero.mp h)
+    have hmul := mul_lt_mul_of_pos_left hv (zero_lt_one.trans hu)
+    have hp : 1 < ‖u‖*‖v‖ := hu.trans (by simpa only [mul_one] using hmul)
+    linarith
+
+lemma exteriorJoukowski_surjOn : SurjOn exteriorJoukowski exteriorUpperDisk upperHalfPlane := by
+  intro z hz
+  obtain ⟨s,hs⟩ := IsAlgClosed.exists_pow_nat_eq (z^2-4) (by decide : 0 < (2:ℕ))
+  let u : ℂ := (z+s)/2
+  let v : ℂ := (z-s)/2
+  have hsum : u+v=z := by dsimp [u,v]; ring
+  have hprod : u*v=1 := by
+    dsimp only [u,v]
+    linear_combination -hs/4
+  have hu0 : u ≠ 0 := by intro he; rw [he,zero_mul] at hprod; exact zero_ne_one hprod
+  have hv0 : v ≠ 0 := by intro he; rw [he,mul_zero] at hprod; exact zero_ne_one hprod
+  have huinv : u⁻¹=v := by
+    apply (mul_left_cancel₀ hu0)
+    rw [mul_inv_cancel₀ hu0,hprod]
+  have hvinv : v⁻¹=u := by rw [← huinv,inv_inv]
+  have huJ : exteriorJoukowski u=z := by rw [exteriorJoukowski,huinv,hsum]
+  have hvJ : exteriorJoukowski v=z := by rw [exteriorJoukowski,hvinv,add_comm,hsum]
+  have hunit (w : ℂ) (hw0 : w ≠ 0) (hwJ : exteriorJoukowski w=z) : ‖w‖ ≠ 1 := by
+    intro h
+    have he := exteriorJoukowski_im_mul hw0
+    rw [hwJ,h] at he
+    norm_num at he
+    exact hz.ne' he
+  have hex : ∃ w : ℂ, 1 < ‖w‖ ∧ exteriorJoukowski w=z := by
+    by_cases hu : 1 < ‖u‖
+    · exact ⟨u,hu,huJ⟩
+    · have hvnorm : ‖u‖*‖v‖=1 := by
+        simpa only [norm_mul,norm_one] using congrArg norm hprod
+      have hult : ‖u‖ < 1 := lt_of_le_of_ne (le_of_not_gt hu) (hunit u hu0 huJ)
+      have hvn : 0 ≤ ‖v‖ := norm_nonneg _
+      have hup : 0 < ‖u‖ := norm_pos_iff.mpr hu0
+      have hvp : 0 < ‖v‖ := norm_pos_iff.mpr hv0
+      have hh := mul_lt_mul_of_pos_right hult hvp
+      exact ⟨v,by nlinarith, hvJ⟩
+  obtain ⟨w,hwn,hwJ⟩ := hex
+  have hw0 : w ≠ 0 := norm_ne_zero_iff.mp (zero_lt_one.trans hwn).ne'
+  have hi : 0 < w.im := by
+    have he := exteriorJoukowski_im_mul hw0
+    rw [hwJ] at he
+    have hsq : 1 < ‖w‖^2 := by nlinarith
+    have hh : 0 < z.im*‖w‖^2 := mul_pos hz (sq_pos_of_pos (zero_lt_one.trans hwn))
+    nlinarith
+  exact ⟨w,⟨hwn,hi⟩,hwJ⟩
+
+theorem exteriorJoukowski_bijOn : BijOn exteriorJoukowski exteriorUpperDisk upperHalfPlane :=
+  ⟨exteriorJoukowski_mapsTo,exteriorJoukowski_injOn.mono (fun _ h => h.1),
+    exteriorJoukowski_surjOn⟩
+
+theorem exteriorJoukowski_differentiableOn :
+    DifferentiableOn ℂ exteriorJoukowski exteriorUpperDisk := by
+  intro w hw
+  exact (differentiableAt_id.add (differentiableAt_id.inv
+    (norm_ne_zero_iff.mp (zero_lt_one.trans hw.1).ne'))).differentiableWithinAt
+
+end SLEExactGauge
+
+end
+
+end OAI
diff --git a/lean/OAI/Probability/SLE/Geometry/ExteriorLaplacianTest.lean b/lean/OAI/Probability/SLE/Geometry/ExteriorLaplacianTest.lean
new file mode 100644
index 0000000000000000000000000000000000000000..ea986f1461ff053c367a9ea0a0bea3ba1f221224
--- /dev/null
+++ b/lean/OAI/Probability/SLE/Geometry/ExteriorLaplacianTest.lean
@@ -0,0 +1,70 @@
+import OAI.Probability.SLE.Geometry.CompactLaplacianIntegral
+import OAI.Probability.SLE.Geometry.ConformalLaplacian
+
+namespace OAI
+
+/-! A compactly supported quadratic test near the omitted set of an
+exterior conformal map. Its Laplacian has nonpositive integral over the
+image domain. -/
+noncomputable section
+open Set Filter Metric Function MeasureTheory InnerProductSpace
+open scoped Topology Laplacian
+
+namespace SLEExactGauge
+
+lemma complex_laplacian_norm_sq (z : ℂ) : (Δ (fun w : ℂ => ‖w‖^2)) z=4 := by
+  let L : ℂ →L[ℝ] (ℂ →L[ℝ] ℝ) := 2 • innerSL ℝ
+  have hd : fderiv ℝ (fun w : ℂ => ‖w‖^2)=L := fderiv_norm_sq
+  rw [laplacian_eq_iteratedFDeriv_complexPlane]
+  simp only [iteratedFDeriv_two_apply,Fin.isValue,Matrix.cons_val_zero,
+    Matrix.cons_val_one,Matrix.cons_val_fin_one,hd,L.fderiv]
+  simp only [L,two_smul,add_apply]
+  change (inner ℝ (1:ℂ) 1+inner ℝ (1:ℂ) 1)+(inner ℝ Complex.I Complex.I+inner ℝ Complex.I Complex.I)=4
+  simp only [real_inner_self_eq_norm_sq,norm_one,Complex.norm_I]
+  norm_num
+
+lemma exists_compact_quadratic_test (K : Set ℂ) (hK : IsCompact K) :
+    ∃ u : ℂ → ℝ, ContDiff ℝ 2 u ∧ HasCompactSupport u ∧
+      (∀ z∈K, u =ᶠ[𝓝 z] (fun w => ‖w‖^2)) ∧
+      (∀ z∈K, (Δ u) z=4) := by
+  obtain ⟨R,hR,hRK⟩ := hK.isBounded.exists_pos_norm_lt
+  let b : ContDiffBump (0:ℂ) := ⟨R,R+1,hR,by linarith⟩
+  let u (z : ℂ) := b z*‖z‖^2
+  have hu : ContDiff ℝ 2 u := b.contDiff.mul (contDiff_id.norm_sq ℝ)
+  have hs : HasCompactSupport u := b.hasCompactSupport.mul_right
+  have he (z : ℂ) (hz : z∈K) : u =ᶠ[𝓝 z] (fun w => ‖w‖^2) := by
+    have hb := b.eventuallyEq_one_of_mem_ball (show z∈ball (0:ℂ) b.rIn by
+      simpa only [mem_ball_zero_iff] using hRK z hz)
+    filter_upwards [hb] with w hw
+    simp only [u,hw,Pi.one_apply,one_mul]
+  exact ⟨u,hu,hs,he,fun z hz => (laplacian_congr_nhds (he z hz)).self_of_nhds.trans (complex_laplacian_norm_sq z)⟩
+
+lemma hasCompactSupport_laplacian {u : ℂ → ℝ} (hs : HasCompactSupport u) :
+    HasCompactSupport (Δ u) := by
+  have h := (hs.fderiv ℝ |>.fderiv ℝ).comp_left
+    (g := fun L : ℂ →L[ℝ] (ℂ →L[ℝ] ℝ) => L 1 1+L Complex.I Complex.I) (by simp)
+  simpa only [Function.comp_def,laplacian_eq_iteratedFDeriv_complexPlane,
+    iteratedFDeriv_two_apply,Fin.isValue,Matrix.cons_val_zero,
+    Matrix.cons_val_one,Matrix.cons_val_fin_one] using h
+
+lemma compact_quadratic_test_complement_integral
+    (K : Set ℂ) (hK : IsCompact K) :
+    ∃ u : ℂ → ℝ, ContDiff ℝ 2 u ∧ HasCompactSupport u ∧
+      (∀ z∈K, u =ᶠ[𝓝 z] (fun w => ‖w‖^2)) ∧
+      (∫ z in Kᶜ, (Δ u) z)≤0 := by
+  obtain ⟨u,hu,hs,he,hΔ⟩ := exists_compact_quadratic_test K hK
+  have hcont : Continuous (Δ u) := by
+    exact continuous_iff_continuousAt.mpr (fun z => plane_laplacian_continuousAt (hu.contDiffAt (x := z)))
+  have hsupport := hasCompactSupport_laplacian hs
+  have hi : Integrable (Δ u) := hcont.integrable_of_hasCompactSupport hsupport
+  have hzero := integral_laplacian_compact_eq_zero hu hs
+  have hsum := integral_add_compl hK.measurableSet hi
+  have hpos : 0≤∫ z in K, (Δ u) z := setIntegral_nonneg hK.measurableSet (fun z hz => by rw [hΔ z hz]; norm_num)
+  refine ⟨u,hu,hs,he,?_⟩
+  linarith
+
+end SLEExactGauge
+
+end
+
+end OAI
diff --git a/lean/OAI/Probability/SLE/Geometry/ExteriorLaurent.lean b/lean/OAI/Probability/SLE/Geometry/ExteriorLaurent.lean
new file mode 100644
index 0000000000000000000000000000000000000000..b37275b87a970c0ffe314170c45f673474888e11
--- /dev/null
+++ b/lean/OAI/Probability/SLE/Geometry/ExteriorLaurent.lean
@@ -0,0 +1,91 @@
+import OAI.Probability.SLE.Loewner.SlitExteriorChart
+import OAI.Probability.SLE.Geometry.SymmetricSlope
+
+namespace OAI
+
+/-! Removing the pole of the exterior slit chart at infinity gives its
+first two Laurent coefficients without choosing a power-series expansion. -/
+noncomputable section
+open Set Filter Complex Function Metric
+open scoped Topology ComplexConjugate
+
+namespace SLEExactGauge
+
+def slitInfinityFactor (f : ℂ → ℂ) (a : ℝ) (w : ℂ) : ℂ :=
+  (a:ℂ) * ((dslope f 0 w)⁻¹+w^2*dslope f 0 w)
+
+lemma slitInfinityFactor_zero {f : ℂ → ℂ} {a : ℝ}
+    (ha : a ≠ 0) (hd : deriv f 0=(a:ℂ)) : slitInfinityFactor f a 0=1 := by
+  simp only [slitInfinityFactor,dslope_same,hd,zero_pow two_ne_zero,zero_mul,add_zero]
+  exact mul_inv_cancel₀ (Complex.ofReal_ne_zero.mpr ha)
+
+lemma slitInfinityFactor_analyticAt {f : ℂ → ℂ} {a : ℝ}
+    (hf : AnalyticAt ℂ f 0) (ha : a ≠ 0) (hd : deriv f 0=(a:ℂ)) :
+    AnalyticAt ℂ (slitInfinityFactor f a) 0 := by
+  have hq := analyticAt_dslope_zero hf
+  have hq0 : dslope f 0 0 ≠ 0 := by
+    rw [dslope_same,hd]
+    exact Complex.ofReal_ne_zero.mpr ha
+  exact analyticAt_const.mul ((hq.inv hq0).add ((analyticAt_id.pow 2).mul hq))
+
+lemma slitInfinityFactor_reflection {D : Set ℂ} (hD : D ∈ 𝓝 (0:ℂ))
+    {f : ℂ → ℂ} (hs : ∀ z ∈ D, f (conj z)=conj (f z)) (a : ℝ) :
+    ∀ z ∈ D, slitInfinityFactor f a (conj z)=conj (slitInfinityFactor f a z) := by
+  intro z hz
+  simp only [slitInfinityFactor,dslope_reflection hD hs z hz,map_mul,map_add,map_inv₀,
+    map_pow,conj_ofReal]
+
+lemma slitInfinityFactor_identity {f : ℂ → ℂ} (hf0 : f 0=0) (a : ℝ)
+    {z : ℂ} (hz : z ≠ 0) :
+    z*slitInfinityFactor f a z⁻¹=(a:ℂ)*exteriorJoukowski (slitExteriorMap f z) := by
+  have hq : dslope f 0 z⁻¹=z*f z⁻¹ := by
+    simp only [dslope_of_ne _ (inv_ne_zero hz),slope,vsub_eq_sub,sub_zero,hf0,inv_inv,smul_eq_mul]
+  simp only [slitInfinityFactor,hq,exteriorJoukowski,slitExteriorMap,inv_inv,mul_inv_rev]
+  field_simp
+
+lemma slitInfinityFactor_remainder {f : ℂ → ℂ} {a : ℝ}
+    (hf0 : f 0=0) (ha : a ≠ 0) (hd : deriv f 0=(a:ℂ)) {z : ℂ} (hz : z ≠ 0) :
+    z*((a:ℂ)*exteriorJoukowski (slitExteriorMap f z)-
+        deriv (slitInfinityFactor f a) 0-z)=
+      dslope (dslope (slitInfinityFactor f a) 0) 0 z⁻¹ := by
+  have h0 := slitInfinityFactor_zero ha hd
+  have h1 := sub_smul_dslope (slitInfinityFactor f a) (0:ℂ) z⁻¹
+  have h2 := sub_smul_dslope (dslope (slitInfinityFactor f a) 0) (0:ℂ) z⁻¹
+  simp only [sub_zero,smul_eq_mul,dslope_same,h0] at h1 h2
+  have hmul : (a:ℂ)*exteriorJoukowski (slitExteriorMap f z)=
+      z*slitInfinityFactor f a z⁻¹ := (slitInfinityFactor_identity hf0 a hz).symm
+  rw [hmul]
+  have hz1 : z*z⁻¹=1 := mul_inv_cancel₀ hz
+  calc
+    z*(z*slitInfinityFactor f a z⁻¹-deriv (slitInfinityFactor f a) 0-z) =
+      z*(z*(z⁻¹*dslope (slitInfinityFactor f a) 0 z⁻¹+1)-
+        deriv (slitInfinityFactor f a) 0-z) := by rw [h1]; ring
+    _ = z*(dslope (slitInfinityFactor f a) 0 z⁻¹-deriv (slitInfinityFactor f a) 0) := by
+      rw [mul_add,← mul_assoc,hz1,one_mul,mul_one]
+      ring
+    _ = z*(z⁻¹*dslope (dslope (slitInfinityFactor f a) 0) 0 z⁻¹) := by rw [h2]
+    _ = _ := by rw [← mul_assoc,hz1,one_mul]
+
+lemma slitExteriorMap_laurent_limit {f : ℂ → ℂ} {a : ℝ}
+    (hf : AnalyticAt ℂ f 0) (hf0 : f 0=0) (ha : a ≠ 0)
+    (hd : deriv f 0=(a:ℂ)) :
+    Tendsto (fun z : ℂ => z*((a:ℂ)*exteriorJoukowski (slitExteriorMap f z)-
+        deriv (slitInfinityFactor f a) 0-z)) (cocompact ℂ)
+      (𝓝 (deriv (dslope (slitInfinityFactor f a) 0) 0)) := by
+  have hH := slitInfinityFactor_analyticAt hf ha hd
+  have hq := analyticAt_dslope_zero hH
+  have hr := analyticAt_dslope_zero hq
+  have hinv : Tendsto (fun z : ℂ => z⁻¹) (cocompact ℂ) (𝓝 0) := by
+    simpa only [Metric.cobounded_eq_cocompact] using
+      (tendsto_inv₀_cobounded : Tendsto (fun z : ℂ => z⁻¹) (Bornology.cobounded ℂ) (𝓝 0))
+  have ht := hr.continuousAt.tendsto.comp hinv
+  simp only [dslope_same] at ht
+  apply ht.congr'
+  filter_upwards [(isCompact_singleton (x := (0:ℂ))).compl_mem_cocompact] with z hz
+  exact (slitInfinityFactor_remainder hf0 ha hd hz).symm
+
+end SLEExactGauge
+
+end
+
+end OAI
diff --git a/lean/OAI/Probability/SLE/Geometry/FiniteBoundaryRestart.lean b/lean/OAI/Probability/SLE/Geometry/FiniteBoundaryRestart.lean
new file mode 100644
index 0000000000000000000000000000000000000000..6caa929bfa5e998e6abe5c2db680a25059dbab2c
--- /dev/null
+++ b/lean/OAI/Probability/SLE/Geometry/FiniteBoundaryRestart.lean
@@ -0,0 +1,141 @@
+import OAI.Probability.SLE.Geometry.PublishedFiniteBoundaryExtension
+import OAI.Probability.SLE.Geometry.MeasurableBoundaryRestart
+
+namespace OAI
+
+/-! Finite-valued boundary charts introduce no measurable selection into
+an actual stopped restart: their boundary evaluations are determined by the
+interior map. The same past-measurable family realizes all future times. -/
+
+noncomputable section
+open Set Filter MeasureTheory ProbabilityTheory
+open scoped Topology NNReal ENNReal
+
+namespace SLEExactGauge
+
+local instance : LocallyCompactSpace closedHalfPlane :=
+  isClosed_closedHalfPlane.locallyCompactSpace
+local instance finiteRestartPathMeasurable : MeasurableSpace C(ℝ≥0, ℂ) := borel _
+local instance finiteRestartPathBorel : BorelSpace C(ℝ≥0, ℂ) := ⟨rfl⟩
+local instance finiteRestartDriverMeasurable : MeasurableSpace C(ℝ≥0, ℝ) := borel _
+local instance finiteRestartDriverBorel : BorelSpace C(ℝ≥0, ℝ) := ⟨rfl⟩
+
+lemma closed_halfplane_map_ext {Y : Type*} [TopologicalSpace Y] [T2Space Y]
+    (f g : C(closedHalfPlane, Y))
+    (heq : ∀ z : closedHalfPlane, z.1 ∈ upperHalfPlane → f z = g z) : f = g := by
+  ext z
+  let zₙ (n : ℕ) : closedHalfPlane :=
+    ⟨z + ((1 / ((n : ℝ) + 1) : ℝ) : ℂ) * Complex.I, by
+      change 0 ≤ (z.1 + ((1 / ((n : ℝ) + 1) : ℝ) : ℂ) * Complex.I).im
+      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]
+      exact add_nonneg z.2 (by positivity)⟩
+  have hH (n : ℕ) : (zₙ n).1 ∈ upperHalfPlane := by
+    change 0 < (z.1 + ((1 / ((n : ℝ) + 1) : ℝ) : ℂ) * Complex.I).im
+    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]
+    exact add_pos_of_nonneg_of_pos z.2 (by positivity)
+  have hz : Tendsto zₙ atTop (𝓝 z) := by
+    apply tendsto_subtype_rng.mpr
+    simpa only [Function.comp_def, Complex.ofReal_zero, zero_mul, add_zero] using
+      tendsto_const_nhds.add (((Complex.continuous_ofReal.tendsto 0).comp
+        (tendsto_one_div_add_atTop_nhds_zero_nat (𝕜 := ℝ))).mul_const Complex.I)
+  exact tendsto_nhds_unique ((f.continuous.tendsto z).comp hz)
+    (((g.continuous.tendsto z).comp hz).congr (fun n => (heq (zₙ n) (hH n)).symm))
+
+lemma finite_boundary_extension_family_measurable
+    {Ω : Type*} [MeasurableSpace Ω]
+    (f : Ω → ℂ → ℂ) (Fb : Ω → C(closedHalfPlane, ℂ))
+    (hf : ∀ z ∈ upperHalfPlane, Measurable (fun ω => f ω z))
+    (hext : ∀ ω (z : closedHalfPlane), z.1 ∈ upperHalfPlane → Fb ω z = f ω z) :
+    Measurable Fb := by
+  let Fc : Ω → C(closedHalfPlane, OnePoint ℂ) := fun ω =>
+    ⟨fun z => (Fb ω z : OnePoint ℂ), OnePoint.continuous_coe.comp (Fb ω).continuous⟩
+  apply ContinuousMap.measurable_iff_eval.mpr
+  intro z
+  have hc := boundary_extension_eval_measurable f Fc hf
+    (fun ω w hw => congrArg (fun v : ℂ => (v : OnePoint ℂ)) (hext ω w hw)) z
+  exact OnePoint.isOpenEmbedding_coe.measurableEmbedding.measurable_comp_iff.mp hc
+
+/-- Finite boundary evaluations are determined by the stopping-time past. -/
+theorem source_stopped_finiteBoundaryPath_measurable
+    (hpublished : PublishedFiniteLoewnerBoundaryExtension)
+    {Ω : Type*} [mΩ : MeasurableSpace Ω] (B : ℝ≥0 → Ω → ℝ)
+    (hm : ∀ t, Measurable (B t)) (hc : ∀ ω, Continuous (fun t => B t ω))
+    (κ : ℝ) (γ : Ω → ℝ≥0 → ℂ) (G F : Ω → ℝ≥0 → ℂ → ℂ)
+    (hw : ∀ ω, IsCapacityTwoWitness (fun t => Real.sqrt κ * B t ω)
+      (γ ω) (G ω) (F ω))
+    (τ : Ω → ℝ≥0)
+    (hτ : IsStoppingTime (Filtration.natural B (fun t => (hm t).stronglyMeasurable))
+      (fun ω => (τ ω : WithTop ℝ≥0))) :
+    ∃ Fb : Ω → C(closedHalfPlane, ℂ),
+      Measurable[hτ.measurableSpace] Fb ∧
+      (∀ ω (z : closedHalfPlane), z.1 ∈ upperHalfPlane →
+        Fb ω z = F ω (τ ω) (z + (Real.sqrt κ * B (τ ω) ω : ℝ))) ∧
+      ∀ ω, Fb ω ⟨0, by simp [closedHalfPlane]⟩ = γ ω (τ ω) := by
+  choose Fb hext htip using fun ω =>
+    normalized_finite_capacity_inverse_boundary_extension hpublished
+      (continuous_const.mul (hc ω)) (hw ω) (τ ω) 1 zero_lt_one
+  have he (ω : Ω) (z : closedHalfPlane) (hz : z.1 ∈ upperHalfPlane) :
+      Fb ω z = F ω (τ ω) (z + (Real.sqrt κ * B (τ ω) ω : ℝ)) := by
+    simpa only [Complex.ofReal_one, one_mul, add_comm, Pi.mul_apply] using hext ω z hz
+  refine ⟨Fb, ?_, he, htip⟩
+  apply @finite_boundary_extension_family_measurable Ω hτ.measurableSpace
+    (fun ω z => F ω (τ ω) (z + (Real.sqrt κ * B (τ ω) ω : ℝ))) Fb _ he
+  intro z hz
+  exact (continuous_eval_const (⟨z, hz⟩ : upperHalfPlane)).measurable.comp
+    (source_stopped_inversePath_measurable B hm hc κ γ G F hw τ hτ)
+
+/-- The actual future trace is the finite boundary image of the fresh
+trace, using a chart measurable in precisely the same stopped past. -/
+theorem source_measurable_finite_boundary_restart
+    {Ω : 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 ω))
+    (hpublished : PublishedFiniteLoewnerBoundaryExtension)
+    (τ : Ω → ℝ≥0)
+    (hτ : IsStoppingTime (Filtration.natural B (fun t => (hm t).stronglyMeasurable))
+      (fun ω => (τ ω : WithTop ℝ≥0))) :
+    ∃ Φ : C(ℝ≥0, ℝ) → C(ℝ≥0, ℂ), ∃ Fb : Ω → C(closedHalfPlane, ℂ),
+      Measurable Φ ∧
+      (∀ ω, Φ (sourceDriverPath B hc ω) = sourceTracePath γ (fun ω => (hw ω).1) ω) ∧
+      Measurable[hτ.measurableSpace] Fb ∧
+      (∀ ω (z : closedHalfPlane), z.1 ∈ upperHalfPlane →
+        Fb ω z = F ω (τ ω) (z + (Real.sqrt κ * B (τ ω) ω : ℝ))) ∧
+      (∀ ω, Fb ω ⟨0, by simp [closedHalfPlane]⟩ = γ ω (τ ω)) ∧
+      (∀ A : Set Ω, MeasurableSet[hτ.measurableSpace] A →
+        (P.restrict A).map (fun ω => Φ (sourceRestartDriverPath B hc τ ω)) =
+          P A • P.map (sourceTracePath γ (fun ω => (hw ω).1))) ∧
+      ∀ᵐ ω ∂P, ∀ t : ℝ≥0,
+        γ ω (τ ω + t) =
+          finiteBoundaryPath (Fb ω) (Φ (sourceRestartDriverPath B hc τ ω)) t := by
+  obtain ⟨Φ, Fc, hΦm, hΦ, _, hFc, _, hlaw, hrestart⟩ :=
+    source_measurable_boundary_restart κ hκ hκ8 B hB hm hc γ G F hw
+      hpublished.to_onePoint τ hτ
+  obtain ⟨Fb, hFbm, hFb, hFb0⟩ := source_stopped_finiteBoundaryPath_measurable
+    hpublished B hm hc κ γ G F hw τ hτ
+  have he (ω : Ω) :
+      (⟨fun z => (Fb ω z : OnePoint ℂ),
+        OnePoint.continuous_coe.comp (Fb ω).continuous⟩ :
+        C(closedHalfPlane, OnePoint ℂ)) = Fc ω := by
+    apply closed_halfplane_map_ext
+    intro z hz
+    exact (congrArg (fun w : ℂ => (w : OnePoint ℂ)) (hFb ω z hz)).trans
+      (hFc ω z hz).symm
+  refine ⟨Φ, Fb, hΦm, hΦ, hFbm, hFb, hFb0, hlaw, ?_⟩
+  filter_upwards [hrestart] with ω hω
+  intro t
+  apply OnePoint.coe_injective
+  rw [hω t]
+  exact (congrArg (fun f : C(closedHalfPlane, OnePoint ℂ) =>
+    f (liftClosedPath (Φ (sourceRestartDriverPath B hc τ ω)) t)) (he ω)).symm
+
+end SLEExactGauge
+
+end
+
+end OAI
diff --git a/lean/OAI/Probability/SLE/Geometry/FiniteCellTailKernel.lean b/lean/OAI/Probability/SLE/Geometry/FiniteCellTailKernel.lean
new file mode 100644
index 0000000000000000000000000000000000000000..e6f973f378b196a8894820d46e87737c440dae5f
--- /dev/null
+++ b/lean/OAI/Probability/SLE/Geometry/FiniteCellTailKernel.lean
@@ -0,0 +1,212 @@
+import OAI.Probability.SLE.Gauge.PrescribedDiskTestKernel
+import OAI.Probability.SLE.Gauge.PrescribedDiskConditional
+
+namespace OAI
+
+/-! The upper physical cell comparison gives the reverse test inequality:
+a large canonical cell mass forces a large normalized finite disk mass. -/
+noncomputable section
+open Set Filter _root_.MeasureTheory _root_.OAI.MeasureTheory ProbabilityTheory Metric
+open scoped Topology NNReal ENNReal
+
+namespace SLEExactGauge.Multipoint
+local instance cellKernelMeasurable : MeasurableSpace C(ℝ≥0,ℝ) := borel _
+local instance cellKernelBorel : BorelSpace C(ℝ≥0,ℝ) := ⟨rfl⟩
+
+def CanonicalMass.finiteCellMassTest
+    {Ω : Type*} [MeasurableSpace Ω] {P : Measure Ω} {κ : ℝ}
+    {B : ℝ≥0 → Ω → ℝ} {hBm : Measurable (Function.uncurry B)}
+    {γ : Ω → ℝ≥0 → ℂ} {G : Ω → ℝ≥0 → ℂ → ℂ}
+    (C : CanonicalMass P κ B hBm γ G) (S : Ω → WithTop ℝ≥0)
+    (K : Set ℂ) (b : ℝ≥0∞) : Set Ω :=
+  finiteStoppedThreshold (fun t ω => C.process t ω (Subtype.val ⁻¹' K)) S b
+
+lemma CanonicalMass.finiteCellMassTest_measurable
+    {Ω : Type*} [mΩ : MeasurableSpace Ω] {P : Measure Ω} {κ : ℝ}
+    {B : ℝ≥0 → Ω → ℝ} {hBm : Measurable (Function.uncurry B)}
+    {γ : Ω → ℝ≥0 → ℂ} {G : Ω → ℝ≥0 → ℂ → ℂ}
+    (C : CanonicalMass P κ B hBm γ G) (S : Ω → WithTop ℝ≥0)
+    (hS : IsStoppingTime (Filtration.natural B (fun t =>
+      (hBm.of_uncurry_left : Measurable (B t)).stronglyMeasurable)) S)
+    (K : Set ℂ) (hK : MeasurableSet K) (b : ℝ≥0∞) :
+    MeasurableSet[hS.measurableSpace] (C.finiteCellMassTest S K b) := by
+  apply finiteStoppedThreshold_measurable _ _ S hS b
+  intro t
+  exact (Measure.measurable_coe (hK.preimage measurable_subtype_coe)).comp (C.progressive t)
+
+lemma cell_ball_live_of_radius
+    {U : ℝ≥0 → ℝ} {γ : ℝ≥0 → ℂ} {G F : ℝ≥0 → ℂ → ℂ}
+    (hw : IsCapacityTwoWitness U γ G F) (hgrowth : PublishedDiskUnivalentGrowth)
+    (t : ℝ≥0) (z : ℂ) (hz : z∈survivingDomain γ t) (r : ℝ) (hr : 0<r)
+    (hR : fullRadius G t z=(2048*Real.pi)*r) :
+    closedBall z (2*r) ⊆ survivingDomain γ t := by
+  have hpos : 0<fullRadius G t z := by rw [hR]; positivity
+  obtain ⟨_,hinner,_,hlive,_⟩ := hw.quarter_disk_chart_bounds hgrowth t z hz hpos
+  have heq : fullRadius G t z/(1024*Real.pi)=2*r := by
+    rw [hR]
+    field_simp
+    ring
+  rw [heq] at hinner
+  exact hinner.trans hlive
+
+theorem CanonicalMass.finite_cell_mass_disk_tail
+    {Ω : 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))
+    (τ : Ω → ℝ≥0)
+    (hτ : IsStoppingTime (Filtration.natural B (fun t =>
+      (hBm.of_uncurry_left : Measurable (B t)).stronglyMeasurable))
+      (fun ω => (τ ω:WithTop ℝ≥0)))
+    (z : ℂ) (hz : z∈upperHalfPlane) (u v r b : ℝ)
+    (hu : 0≤u) (hv : 0<v) (hr : 0<r)
+    (E : Set Ω) (hE : MeasurableSet[hτ.measurableSpace] E)
+    (hlive : ∀ ω∈E, z∈survivingDomain (γ ω) (τ ω))
+    (hbase : ∀ ω∈E, fullRadius (G ω) (τ ω) z=(2*z.im)*Real.exp (-u))
+    (hR : ∀ ω∈E, fullRadius (G ω) (τ ω) z=(2048*Real.pi)*r)
+    (K : Set ℂ) (hK : MeasurableSet K) (hKball : K⊆closedBall z (2*r)) :
+    ∀ A : Set Ω, MeasurableSet[hτ.measurableSpace] A →
+      finiteCenteredLaw P κ B γ G z (u+v)
+        (A∩E∩C.finiteCellMassTest (fun ω => radiusLevelTime (γ ω) (G ω) z (u+v)) K
+          (ENNReal.ofReal (((32768*Real.pi)*r)^dimension κ)*ENNReal.ofReal b)) ≤
+      ∫⁻ ω in A∩E, R.angleDiskTail (P.map (sourceDriverPath B hc)) κ b v
+        (stoppedMarkedCenter κ B γ G τ z ω).arg
+        ∂finiteCenteredLaw P κ B γ G z (u+v) := by
+  classical
+  have hm (t : ℝ≥0) : Measurable (B t) := hBm.of_uncurry_left
+  let ν := P.map (sourceDriverPath B hc)
+  let : IsProbabilityMeasure ν :=
+    (Measure.isProbabilityMeasure_map_iff (source_path_measurable _ hm).aemeasurable).mpr inferInstance
+  let a := stoppedMarkedScale κ B γ G τ z
+  let θ := fun ω => (stoppedMarkedCenter κ B γ G τ z ω).arg
+  let Y := normalizedRestartDriverPath B hc τ a
+  have ham : Measurable[hτ.measurableSpace] a :=
+    source_stoppedMarkedScale_measurable B hm hc κ γ G F hw τ hτ z
+  have ha : ∀ ω, 0<a ω := stoppedMarkedScale_pos κ B γ G τ z
+  have hθm : Measurable[hτ.measurableSpace] θ :=
+    (source_stoppedMarkedCenter_measurable B hm hc κ γ G F hw τ hτ z).carg
+  have hY : Measurable Y := measurable_scaleDriverPath.comp
+    ((ham.mono hτ.measurableSpace_le le_rfl).inv.prodMk
+      (sourceRestartDriverPath_measurable B hm hc τ hτ))
+  have hYlaw (A : Set Ω) (hA : MeasurableSet[hτ.measurableSpace] A) :
+      (P.restrict A).map Y=P A • ν :=
+    source_restart_random_scale_driver_law B hB hm hc τ hτ
+      (fun ω => (a ω)⁻¹) ham.inv (fun ω => inv_pos.mpr (ha ω)) A hA
+  have hpolar (ω : Ω) (hω : ω∈E) :
+      θ ω∈Ioo (0:ℝ) Real.pi ∧ G ω (τ ω) z=
+        (Real.sqrt κ*B (τ ω) ω:ℝ)+(a ω:ℂ)*Complex.exp (θ ω*Complex.I) := by
+    have hh := (hw ω).live_marked_polar (τ ω) z (hlive ω hω)
+    simpa only [θ,a,stoppedMarkedCenter_eq κ B γ G τ z ω (hlive ω hω),
+      stoppedMarkedScale_eq_on_live B κ γ G F hw τ z ω (hlive ω hω)] using hh.2
+  obtain ⟨M,hM,hMf,hMactual,hMpast⟩ := exists_finiteDensity_at_radius_state
+    hB hBm hc h0 κ hκ hκ8 γ G F hw τ hτ z hz u v hu hv E hE hlive hbase
+  intro A hA
+  let T : Ω → WithTop ℝ≥0 := fun ω => radiusLevelTime (γ ω) (G ω) z (u+v)
+  let q := fun ω => R.angleDiskTail ν κ b v (θ ω)
+  let test := C.finiteCellMassTest T K
+    (ENNReal.ofReal (((32768*Real.pi)*r)^dimension κ)*ENNReal.ofReal b)
+  let S := E∩test
+  let Z := fun ω => ENNReal.ofReal (stoppedGreen κ (fun t => Real.sqrt κ*B t ω)
+    (γ ω) (G ω) z (u+v)/initialGreen κ z)
+  let H : Set (Ω × C(ℝ≥0,ℝ)) := {x | x.1∈E ∧ b≤R.diskAtRadius κ (θ x.1) v x.2}
+  let Dens : Ω × C(ℝ≥0,ℝ) → ℝ≥0∞ := fun x =>
+    M x.1*canonicalFiniteDensity κ (v,Target.diskMapInv (θ x.1) 0,x.2)
+  have hH : @MeasurableSet _ (hτ.measurableSpace.prod (borel _)) H :=
+    (hE.preimage measurable_fst).inter (measurableSet_le measurable_const
+      (@RawCanonicalMass.diskAtRadius_measurable (Ω × C(ℝ≥0,ℝ))
+        (hτ.measurableSpace.prod (borel _)) R κ _ _ (hθm.comp measurable_fst)
+        measurable_const Prod.snd measurable_snd))
+  have hzm : Measurable[hτ.measurableSpace] (fun ω => Target.diskMapInv (θ ω) 0) := by
+    unfold Target.diskMapInv
+    fun_prop
+  have hDens : @Measurable _ _ (hτ.measurableSpace.prod (borel _)) _ Dens :=
+    (hM.comp measurable_fst).mul ((canonicalFiniteDensity_measurable κ).comp
+      (measurable_const.prodMk ((hzm.comp measurable_fst).prodMk measurable_snd)))
+  have hT := actual_radiusLevelTime_stopping hB hm hBm hc h0 κ hκ hκ8 γ G F hw z hz
+    (u+v) (by linarith)
+  have htest : MeasurableSet test := hT.measurableSpace_le _
+    (C.finiteCellMassTest_measurable T hT K hK _)
+  have hS : MeasurableSet S := (hτ.measurableSpace_le _ hE).inter htest
+  have hsec (ω : Ω) : (∫⁻ p, H.indicator Dens (ω,p) ∂ν)=
+      E.indicator (fun ω => M ω*q ω) ω := by
+    by_cases hω : ω∈E
+    · let V := {p | b≤R.diskAtRadius κ (θ ω) v p}
+      have hV : MeasurableSet V := measurableSet_le measurable_const
+        (R.diskAtRadius_measurable κ (fun _ => θ ω) (fun _ => v)
+          measurable_const measurable_const id measurable_id)
+      have hid : (fun p => H.indicator Dens (ω,p)) =
+          (fun p => M ω*V.indicator (fun p => canonicalFiniteDensity κ
+            (v,Target.diskMapInv (θ ω) 0,p)) p) := by
+        funext p
+        by_cases hp : p∈V
+        · rw [indicator_of_mem (show (ω,p)∈H from ⟨hω,hp⟩),indicator_of_mem hp]
+        · rw [indicator_of_notMem (show (ω,p)∉H from fun h => hp h.2),
+            indicator_of_notMem hp,mul_zero]
+      rw [hid,lintegral_const_mul' _ _ (hMf ω),lintegral_indicator hV,
+        ← withDensity_apply _ hV,indicator_of_mem hω]
+      rfl
+    · have hn (p : C(ℝ≥0,ℝ)) : (ω,p)∉H := fun h => hω h.1
+      simp only [indicator_of_notMem hω]
+      simp_rw [indicator_of_notMem (hn _)]
+      exact lintegral_zero
+  have hden := normalized_restart_disk_density hB hm hc γ G F hw hpublished τ hτ a ham ha
+  have hcell := C.normalized_cell_bounds_at_radius hB hc hκ F hw R he D hD hDf hDp
+    hgrowth hpublished τ hτ a ham ha
+  have hactual : ∀ᵐ ω ∂P, S.indicator Z ω≤H.indicator Dens (ω,Y ω) := by
+    filter_upwards [hden,hcell,hMactual] with ω hd hb hMω
+    by_cases hSω : ω∈S
+    · obtain ⟨hωE,ht⟩ := hSω
+      have hpol := hpolar ω hωE
+      have hmass := (hb (θ ω) hpol.1 z (hlive ω hωE) r hr (hR ω hωE)
+        hpol.2 u hu (hbase ω hωE) v hv ht.1).2 K hK hKball (hKball.trans (cell_ball_live_of_radius (hw ω) hgrowth (τ ω) z (hlive ω hωE) r hr (hR ω hωE)))
+      have heval : extendedCanonicalMass C.process C.rational.terminal (T ω) ω=
+          C.process ((T ω).untopD 0) ω := by
+        change (if T ω<⊤ then C.process ((T ω).untopD 0) ω else C.rational.terminal ω)=_
+        exact ite_eq_left ht.1
+      rw [heval] at hmass
+      have hfpos : 0<ENNReal.ofReal (((32768*Real.pi)*r)^dimension κ) := by
+        apply ENNReal.ofReal_pos.mpr
+        exact Real.rpow_pos_of_pos (by positivity) _
+      have hval : b≤R.diskAtRadius κ (θ ω) v (Y ω) :=
+        (ENNReal.ofReal_le_ofReal_iff (R.diskAtRadius_nonneg _ _ _ _)).mp
+          ((ENNReal.mul_le_mul_iff_right hfpos.ne' ENNReal.ofReal_ne_top).mp (ht.2.trans hmass))
+      have hDZ : Dens (ω,Y ω)=Z ω := by
+        change M ω*canonicalFiniteDensity κ (v,Target.diskMapInv (θ ω) 0,Y ω)=Z ω
+        rw [hMω hωE]
+        exact (hd _ hpol.1 z (hlive ω hωE) hz hpol.2 u v hu hv (hbase ω hωE)).symm
+      rw [indicator_of_mem (show (ω,Y ω)∈H from ⟨hωE,hval⟩),indicator_of_mem (show ω∈S from ⟨hωE,ht⟩),hDZ]
+    · rw [indicator_of_notMem hSω]
+      exact bot_le
+  calc
+    _ = ∫⁻ ω in A, S.indicator Z ω ∂P := by
+      rw [setLIntegral_indicator hS,inter_comm S A,← inter_assoc]
+      exact withDensity_apply _
+        (((hτ.measurableSpace_le _ hA).inter (hτ.measurableSpace_le _ hE)).inter htest)
+    _ ≤ ∫⁻ ω in A, H.indicator Dens (ω,Y ω) ∂P :=
+      lintegral_mono_ae (ae_restrict_of_ae hactual)
+    _ = ∫⁻ ω in A, ∫⁻ p, H.indicator Dens (ω,p) ∂ν ∂P :=
+      restart_setLIntegral_random_test P ν hτ.measurableSpace hτ.measurableSpace_le
+        Y hY hYlaw (H.indicator Dens) (hDens.indicator hH) A hA
+    _ = ∫⁻ ω in A∩E, M ω*q ω ∂P := by
+      simp_rw [hsec]
+      rw [setLIntegral_indicator (hτ.measurableSpace_le _ hE),inter_comm E A]
+    _ = _ := past_density_test_integral P _ hτ.measurableSpace hτ.measurableSpace_le
+      M hM E hE hMpast q ((R.angleDiskTail_measurable ν κ b v).comp hθm) A hA
+
+end SLEExactGauge.Multipoint
+
+end
+
+end OAI
diff --git a/lean/OAI/Probability/SLE/Geometry/FiniteCenteredAngleKernel.lean b/lean/OAI/Probability/SLE/Geometry/FiniteCenteredAngleKernel.lean
new file mode 100644
index 0000000000000000000000000000000000000000..66107f47115c4b0041586a544bcdc6d2769a8fc7
--- /dev/null
+++ b/lean/OAI/Probability/SLE/Geometry/FiniteCenteredAngleKernel.lean
@@ -0,0 +1,150 @@
+import OAI.Probability.SLE.Angle.CanonicalAngleKernel
+import OAI.Probability.SLE.Geometry.ActualMarkedCell
+import OAI.Probability.SLE.Geometry.PastDensityIntegral
+import OAI.Probability.SLE.Geometry.FiniteDensityAtRadiusState
+import OAI.Probability.SLE.Geometry.RestartWeightedKernel
+
+namespace OAI
+
+/-! Actual finite-centered angle transitions at a finite stopped radius
+state. This identifies the transition before applying any mixing bound. -/
+noncomputable section
+open Set Filter _root_.MeasureTheory _root_.OAI.MeasureTheory ProbabilityTheory
+open scoped Topology NNReal ENNReal
+
+namespace SLEExactGauge
+local instance centeredAngleMeasurable : MeasurableSpace C(ℝ≥0,ℝ) := borel _
+local instance centeredAngleBorel : BorelSpace C(ℝ≥0,ℝ) := ⟨rfl⟩
+
+theorem finite_centered_angle_kernel
+    {Ω : Type*} [mΩ : MeasurableSpace Ω] {P : Measure Ω} [IsProbabilityMeasure P]
+    {κ : ℝ} {B : ℝ≥0 → Ω → ℝ} (hB : IsBrownianReal B P)
+    (hBm : Measurable (Function.uncurry B))
+    (hc : ∀ ω, Continuous (fun t => B t ω)) (h0 : ∀ ω, B 0 ω=0)
+    (hκ : 0 < κ) (hκ8 : κ < 8)
+    (γ : Ω → ℝ≥0 → ℂ) (G F : Ω → ℝ≥0 → ℂ → ℂ)
+    (hw : ∀ ω, IsCapacityTwoWitness (fun t => Real.sqrt κ*B t ω) (γ ω) (G ω) (F ω))
+    (hpublished : PublishedTraceGeneration (P.map (sourceDriverPath B hc)) κ (fun t p => p t))
+    (τ : Ω → ℝ≥0)
+    (hτ : IsStoppingTime (Filtration.natural B (fun t =>
+      (hBm.of_uncurry_left : Measurable (B t)).stronglyMeasurable))
+      (fun ω => (τ ω:WithTop ℝ≥0)))
+    (z : ℂ) (hz : z∈upperHalfPlane) (u v : ℝ) (hu : 0 ≤ u) (hv : 0 < v)
+    (E : Set Ω) (hE : MeasurableSet[hτ.measurableSpace] E)
+    (hlive : ∀ ω∈E, z∈survivingDomain (γ ω) (τ ω))
+    (hbase : ∀ ω∈E, fullRadius (G ω) (τ ω) z=(2*z.im)*Real.exp (-u))
+    (f : ℝ → ℝ≥0∞) (hf : Measurable f)
+    (A : Set Ω) (hA : MeasurableSet[hτ.measurableSpace] A) :
+    (∫⁻ ω in A∩E, canonicalAngleAverage (P.map (sourceDriverPath B hc)) κ v f
+      (stoppedMarkedCenter κ B γ G τ z ω).arg ∂finiteCenteredLaw P κ B γ G z (u+v)) =
+    ∫⁻ ω in A∩E, f (extendedMarkedAngle κ B γ G
+      (fun ω => radiusLevelTime (γ ω) (G ω) z (u+v)) z ω)
+      ∂finiteCenteredLaw P κ B γ G z (u+v) := by
+  classical
+  have hm (t : ℝ≥0) : Measurable (B t) := hBm.of_uncurry_left
+  let ν := P.map (sourceDriverPath B hc)
+  let : IsProbabilityMeasure ν :=
+    (Measure.isProbabilityMeasure_map_iff (source_path_measurable _ hm).aemeasurable).mpr inferInstance
+  let a := stoppedMarkedScale κ B γ G τ z
+  let θ := fun ω => (stoppedMarkedCenter κ B γ G τ z ω).arg
+  let Y := normalizedRestartDriverPath B hc τ a
+  have ham : Measurable[hτ.measurableSpace] a :=
+    source_stoppedMarkedScale_measurable B hm hc κ γ G F hw τ hτ z
+  have ha : ∀ ω, 0<a ω := stoppedMarkedScale_pos κ B γ G τ z
+  have hθm : Measurable[hτ.measurableSpace] θ :=
+    (source_stoppedMarkedCenter_measurable B hm hc κ γ G F hw τ hτ z).carg
+  have hY : Measurable Y := measurable_scaleDriverPath.comp
+    ((ham.mono hτ.measurableSpace_le le_rfl).inv.prodMk
+      (sourceRestartDriverPath_measurable B hm hc τ hτ))
+  have hYlaw (D : Set Ω) (hD : MeasurableSet[hτ.measurableSpace] D) :
+      (P.restrict D).map Y=P D • ν :=
+    source_restart_random_scale_driver_law B hB hm hc τ hτ
+      (fun ω => (a ω)⁻¹) ham.inv (fun ω => inv_pos.mpr (ha ω)) D hD
+  have hYlaw0 : P.map Y=ν := by
+    simpa only [Measure.restrict_univ,measure_univ,one_smul] using hYlaw univ MeasurableSet.univ
+  obtain ⟨Φ,Gc,Fc,_hΦ,hW⟩ := exists_measurable_canonical_witness _ κ hpublished
+  have hYw := canonical_witness_pullback hW Y hY hYlaw0
+  have hpolar (ω : Ω) (hω : ω∈E) :
+      θ ω∈Ioo (0:ℝ) Real.pi ∧ G ω (τ ω) z=
+        (Real.sqrt κ*B (τ ω) ω:ℝ)+(a ω:ℂ)*Complex.exp (θ ω*Complex.I) := by
+    have hh := (hw ω).live_marked_polar (τ ω) z (hlive ω hω)
+    simpa only [θ,a,stoppedMarkedCenter_eq κ B γ G τ z ω (hlive ω hω),
+      stoppedMarkedScale_eq_on_live B κ γ G F hw τ z ω (hlive ω hω)] using hh.2
+  obtain ⟨M,hM,hMf,hMactual,hMpast⟩ := exists_finiteDensity_at_radius_state
+    hB hBm hc h0 κ hκ hκ8 γ G F hw τ hτ z hz u v hu hv E hE hlive hbase
+  let q := fun ω => canonicalAngleAverage ν κ v f (θ ω)
+  have hq : Measurable[hτ.measurableSpace] q :=
+    (canonicalAngleAverage_measurable ν κ v f hf).comp hθm
+  let K : Ω × C(ℝ≥0,ℝ) → ℝ≥0∞ := fun x =>
+    M x.1*canonicalFiniteDensity κ (v,Target.diskMapInv (θ x.1) 0,x.2)*
+      f (canonicalStoppedAngle κ (v,Target.diskMapInv (θ x.1) 0,x.2))
+  have hzM : Measurable[hτ.measurableSpace] (fun ω => Target.diskMapInv (θ ω) 0) := by
+    unfold Target.diskMapInv
+    fun_prop
+  have hpM : @Measurable (Ω × C(ℝ≥0,ℝ)) _ (hτ.measurableSpace.prod (borel _)) _
+      (fun x => (v,Target.diskMapInv (θ x.1) 0,x.2)) :=
+    measurable_const.prodMk ((hzM.comp measurable_fst).prodMk measurable_snd)
+  have hK : @Measurable _ _ (hτ.measurableSpace.prod (borel _)) _ K :=
+    ((hM.comp measurable_fst).mul ((canonicalFiniteDensity_measurable κ).comp hpM)).mul
+      (hf.comp ((canonicalStoppedAngle_measurable κ).comp hpM))
+  have hsec (ω : Ω) : (∫⁻ p, K (ω,p) ∂ν)=M ω*q ω := by
+    simp only [K,mul_assoc]
+    rw [lintegral_const_mul' _ _ (hMf ω)]
+    congr 1
+    symm
+    exact lintegral_withDensity_eq_lintegral_mul _
+      ((canonicalFiniteDensity_measurable κ).comp
+        (measurable_const.prodMk (measurable_const.prodMk measurable_id)))
+      (hf.comp ((canonicalStoppedAngle_measurable κ).comp
+        (measurable_const.prodMk (measurable_const.prodMk measurable_id))))
+  let Z : Ω → ℝ≥0∞ := fun ω => ENNReal.ofReal (stoppedGreen κ
+    (fun t => Real.sqrt κ*B t ω) (γ ω) (G ω) z (u+v)/initialGreen κ z)
+  let g := fun ω => f (extendedMarkedAngle κ B γ G
+    (fun ω => radiusLevelTime (γ ω) (G ω) z (u+v)) z ω)
+  have hT := actual_radiusLevelTime_stopping hB hm hBm hc h0 κ hκ hκ8 γ G F hw z hz
+    (u+v) (by linarith)
+  have hg : Measurable g := (hf.comp (extendedMarkedAngle_measurable B hm hc κ γ G F hw
+    _ hT z)).mono hT.measurableSpace_le le_rfl
+  have hZ : Measurable Z := by
+    convert (canonicalFiniteDensity_measurable κ).comp
+      (measurable_const.prodMk (measurable_const.prodMk (source_path_measurable (sourceDriverPath B hc) hm))) using 1
+    funext ω
+    exact (canonicalFiniteDensity_eq κ (sourceDriverPath B hc ω) (hw ω) (u+v)
+      (by linarith) z).symm
+  have hactual : ∀ᵐ ω ∂P, ω∈E → K (ω,Y ω)=Z ω*g ω := by
+    filter_upwards [hYw,hMactual] with ω hwY hMω hωE
+    have hp := hpolar ω hωE
+    change M ω*canonicalFiniteDensity κ (v,Target.diskMapInv (θ ω) 0,Y ω)*
+      f (canonicalStoppedAngle κ (v,Target.diskMapInv (θ ω) 0,Y ω))=Z ω*g ω
+    rw [hMω hωE]
+    have hn := (hw ω).normalized_disk_angle_test ((hc ω).const_mul _) κ (τ ω) (a ω)
+      (ha ω) (Y ω) hwY (normalizedRestartDriverPath_driver κ B hc τ a ω)
+      (θ ω) hp.1 z (hlive ω hωE) hz hp.2 u v hu hv (hbase ω hωE) f
+    rw [hn]
+    by_cases ht : radiusLevelTime (γ ω) (G ω) z (u+v)<∞
+    · rw [show g ω=f ((G ω (radiusLevelTime (γ ω) (G ω) z (u+v)).toNNReal z-
+          ((Real.sqrt κ*B (radiusLevelTime (γ ω) (G ω) z (u+v)).toNNReal ω:ℝ):ℂ)).arg) from
+        congrArg f (extendedMarkedAngle_at_finite_radius κ B hc γ G F hw z (u+v) ω ht)]
+    · simp only [Z,stoppedGreen,ite_eq_right ht,zero_div,ENNReal.ofReal_zero,zero_mul]
+  have hAm : MeasurableSet (A∩E) := hτ.measurableSpace_le _ (hA.inter hE)
+  calc
+    (∫⁻ ω in A∩E, q ω ∂finiteCenteredLaw P κ B γ G z (u+v)) =
+        ∫⁻ ω in A∩E, M ω*q ω ∂P :=
+      (past_density_test_integral P _ hτ.measurableSpace hτ.measurableSpace_le M hM
+        E hE hMpast q hq A hA).symm
+    _ = ∫⁻ ω in A∩E, ∫⁻ p, K (ω,p) ∂ν ∂P := by simp only [hsec]
+    _ = ∫⁻ ω in A∩E, K (ω,Y ω) ∂P :=
+      (restart_setLIntegral_random_test P ν hτ.measurableSpace hτ.measurableSpace_le
+        Y hY hYlaw K hK (A∩E) (hA.inter hE)).symm
+    _ = ∫⁻ ω in A∩E, Z ω*g ω ∂P := by
+      apply setLIntegral_congr_fun_ae hAm
+      filter_upwards [hactual] with ω hω hωAE
+      exact hω hωAE.2
+    _ = ∫⁻ ω in A∩E, g ω ∂P.withDensity Z :=
+      (setLIntegral_withDensity_eq_setLIntegral_mul _ hZ hg hAm).symm
+
+end SLEExactGauge
+
+end
+
+end OAI
diff --git a/lean/OAI/Probability/SLE/Geometry/FiniteCenteredConsistency.lean b/lean/OAI/Probability/SLE/Geometry/FiniteCenteredConsistency.lean
new file mode 100644
index 0000000000000000000000000000000000000000..0f88cd28da6f89b060d5c5aad4b18f3379eca806
--- /dev/null
+++ b/lean/OAI/Probability/SLE/Geometry/FiniteCenteredConsistency.lean
@@ -0,0 +1,199 @@
+import OAI.Probability.SLE.Geometry.FiniteDensityAtPast
+import OAI.Probability.SLE.Loewner.ActualRadiusStops
+import OAI.Probability.SLE.Gauge.ExtendedExperimentStop
+
+namespace OAI
+
+/-! Exact consistency of the finite centered laws on the past of an
+earlier conformal-radius stop. Extended stopping times are exhausted
+through finite cutoffs; the finite centered laws give the earlier stop
+finite time almost surely. -/
+
+noncomputable section
+open Set Filter MeasureTheory ProbabilityTheory
+open scoped Topology NNReal ENNReal
+
+namespace SLEExactGauge
+
+lemma IsCapacityTwoWitness.physicalStoppedGreen_at_or_before
+    {U : ℝ≥0 → ℝ} {γ : ℝ≥0 → ℂ} {G F : ℝ≥0 → ℂ → ℂ}
+    (hw : IsCapacityTwoWitness U γ G F) (hU : Continuous U)
+    (κ : ℝ) (z : ℂ) (u : ℝ) (t : ℝ≥0)
+    (ht : (t : ℝ≥0∞) ≤ radiusLevelTime γ G z u) :
+    physicalStoppedGreen κ U γ G z u t = greenDensity κ U γ G t z := by
+  by_cases hstop : radiusLevelTime γ G z u ≤ (t : ℝ≥0∞)
+  · have he : radiusLevelTime γ G z u = (t : ℝ≥0∞) := le_antisymm hstop ht
+    have hf : radiusLevelTime γ G z u < ∞ := by rw [he]; exact ENNReal.coe_lt_top
+    obtain ⟨T, hT, hR⟩ := exists_live_level_of_radiusLevelTime_lt_top γ G z u hf
+    have hTt : T = t := by
+      exact_mod_cast (radiusLevelTime_eq_of_live_level hU hw z u T hT hR).symm.trans he
+    subst T
+    rw [physicalStoppedGreen, ite_eq_left hstop,
+      stoppedGreen_eq_of_live_level hU hw κ z u t hT hR]
+  · exact ite_eq_right hstop
+
+/-- Finite-stop consistency holds on the entire earlier stopped past,
+including events on which the later radius level is never reached. -/
+theorem finiteCenteredLaw_consistent_at_finite_stop
+    {Ω : Type*} [mΩ : MeasurableSpace Ω] {P : Measure Ω} [IsProbabilityMeasure P]
+    {B : ℝ≥0 → Ω → ℝ} (hB : IsBrownianReal B P)
+    (hBm : Measurable (fun p : ℝ≥0 × Ω => B p.1 p.2))
+    (hc : ∀ ω, Continuous (fun t => B t ω)) (hB0 : ∀ ω, B 0 ω = 0)
+    (κ : ℝ) (hκ : 0 < κ) (hκ8 : κ < 8)
+    (γ : Ω → ℝ≥0 → ℂ) (G F : Ω → ℝ≥0 → ℂ → ℂ)
+    (hw : ∀ᵐ ω ∂P, IsCapacityTwoWitness
+      (fun t => Real.sqrt κ * B t ω) (γ ω) (G ω) (F ω))
+    (z : ℂ) (hz : z ∈ upperHalfPlane) (v V : ℝ) (hv : 0 ≤ v) (hvV : v ≤ V)
+    (σ : Ω → ℝ≥0)
+    (hσ : IsStoppingTime (Filtration.natural B
+      (fun _t => (hBm.comp (measurable_const.prodMk measurable_id)).stronglyMeasurable))
+      (fun ω => (σ ω : WithTop ℝ≥0)))
+    (hbefore : ∀ᵐ ω ∂P, (σ ω : ℝ≥0∞) ≤ radiusLevelTime (γ ω) (G ω) z v)
+    (A : Set Ω) (hA : MeasurableSet[hσ.measurableSpace] A) :
+    finiteCenteredLaw P κ B γ G z V A = finiteCenteredLaw P κ B γ G z v A := by
+  obtain ⟨Mv, Zv, _, hZvi, _, hZvn, _, hvstop, hvsrc, _⟩ :=
+    exists_physical_green_stopping_regular hB hBm hc hB0 κ hκ hκ8 γ G F hw z hz v hv
+  obtain ⟨MV, ZV, _, hZVi, _, hZVn, _, hVstop, hVsrc, _⟩ :=
+    exists_physical_green_stopping_regular hB hBm hc hB0 κ hκ hκ8 γ G F hw z hz V (hv.trans hvV)
+  have hvmeasure : P.withDensity (fun ω => ENNReal.ofReal (Zv ω / initialGreen κ z)) =
+      finiteCenteredLaw P κ B γ G z v := by
+    apply withDensity_congr_ae
+    filter_upwards [hvsrc] with ω hω
+    rw [hω.2]
+  have hVmeasure : P.withDensity (fun ω => ENNReal.ofReal (ZV ω / initialGreen κ z)) =
+      finiteCenteredLaw P κ B γ G z V := by
+    apply withDensity_congr_ae
+    filter_upwards [hVsrc] with ω hω
+    rw [hω.2]
+  have hev := normalizedDensity_measure_at_past P hσ.measurableSpace hσ.measurableSpace_le
+    Zv (fun ω => Mv (σ ω) ω) hZvi (Eventually.of_forall (fun ω => (hZvn ω).1))
+    (hvstop σ hσ) (initialGreen κ z) (initialGreen_pos κ z hz) A hA
+  have heV := normalizedDensity_measure_at_past P hσ.measurableSpace hσ.measurableSpace_le
+    ZV (fun ω => MV (σ ω) ω) hZVi (Eventually.of_forall (fun ω => (hZVn ω).1))
+    (hVstop σ hσ) (initialGreen κ z) (initialGreen_pos κ z hz) A hA
+  rw [hvmeasure] at hev
+  rw [hVmeasure] at heV
+  refine heV.trans ((lintegral_congr_ae ?_).trans hev.symm)
+  filter_upwards [ae_restrict_of_ae hw, ae_restrict_of_ae hbefore,
+    ae_restrict_of_ae hvsrc, ae_restrict_of_ae hVsrc] with ω hω hbef hvs hVs
+  rw [hvs.1 (σ ω), hVs.1 (σ ω),
+    hω.physicalStoppedGreen_at_or_before ((hc ω).const_mul _) κ z v (σ ω) hbef,
+    hω.physicalStoppedGreen_at_or_before ((hc ω).const_mul _) κ z V (σ ω)
+      (hbef.trans (radiusLevelTime_mono ((hc ω).const_mul _) hω z hv hvV))]
+
+lemma stopped_past_cover_of_ae_finite
+    {Ω : Type*} [MeasurableSpace Ω] (Q : Measure Ω)
+    (σ : Ω → WithTop ℝ≥0) (hfinite : ∀ᵐ ω ∂Q, σ ω ≠ ⊤) (A : Set Ω) :
+    A =ᵐ[Q] ⋃ n : ℕ, A ∩ {ω | σ ω ≤ ((n : ℝ≥0) : WithTop ℝ≥0)} := by
+  filter_upwards [hfinite] with ω hω
+  simp only [mem_iUnion]
+  apply propext
+  constructor
+  · intro hωA
+    lift σ ω to ℝ≥0 using hω with t ht
+    obtain ⟨n, hn⟩ := exists_nat_ge (t : ℝ)
+    refine ⟨n, hωA, ?_⟩
+    change σ ω ≤ ((n : ℝ≥0) : WithTop ℝ≥0)
+    rw [← ht]
+    exact WithTop.coe_le_coe.mpr (by exact_mod_cast hn)
+  · rintro ⟨n, hn⟩
+    exact hn.1
+
+/-- Every earlier stop is finite under a later finite centered law, even
+when it is infinite on a set of positive original probability. -/
+theorem finiteCenteredLaw_earlier_stop_ae_finite
+    {Ω : Type*} [MeasurableSpace Ω] {P : Measure Ω} [IsProbabilityMeasure P]
+    {B : ℝ≥0 → Ω → ℝ} (hB : IsBrownianReal B P)
+    (hc : ∀ ω, Continuous (fun t => B t ω))
+    (κ : ℝ) (hκ : 0 < κ) (hκ8 : κ < 8)
+    (γ : Ω → ℝ≥0 → ℂ) (G F : Ω → ℝ≥0 → ℂ → ℂ)
+    (hw : ∀ᵐ ω ∂P, IsCapacityTwoWitness
+      (fun t => Real.sqrt κ * B t ω) (γ ω) (G ω) (F ω))
+    (z : ℂ) (hz : z ∈ upperHalfPlane) (v V : ℝ) (hv : 0 ≤ v) (hvV : v ≤ V)
+    (σ : Ω → WithTop ℝ≥0)
+    (hbefore : ∀ᵐ ω ∂P, σ ω ≤ radiusLevelTime (γ ω) (G ω) z v) :
+    ∀ᵐ ω ∂finiteCenteredLaw P κ B γ G z V, σ ω ≠ ⊤ := by
+  have hl := finiteCenteredLaw_live_compact hB κ hκ hκ8 γ G F hw z hz V (hv.trans hvV)
+  filter_upwards [hl, (withDensity_absolutelyContinuous P _).ae_le hbefore,
+    (withDensity_absolutelyContinuous P _).ae_le hw] with ω hω hb hW
+  obtain ⟨t, _, _, ht, _⟩ := hω
+  have hlt : σ ω < ⊤ :=
+    (hb.trans (radiusLevelTime_mono ((hc ω).const_mul _) hW z hv hvV)).trans_lt
+      (by rw [ht]; exact ENNReal.coe_lt_top)
+  exact hlt.ne
+
+/-- Extended-stop consistency. The sole geometric requirement is that
+this stop occur no later than the earlier conformal-radius level almost
+surely under the original law. -/
+theorem finiteCenteredLaw_consistent_at_extended_stop
+    {Ω : Type*} [mΩ : MeasurableSpace Ω] {P : Measure Ω} [IsProbabilityMeasure P]
+    {B : ℝ≥0 → Ω → ℝ} (hB : IsBrownianReal B P)
+    (hBm : Measurable (fun p : ℝ≥0 × Ω => B p.1 p.2))
+    (hc : ∀ ω, Continuous (fun t => B t ω)) (hB0 : ∀ ω, B 0 ω = 0)
+    (κ : ℝ) (hκ : 0 < κ) (hκ8 : κ < 8)
+    (γ : Ω → ℝ≥0 → ℂ) (G F : Ω → ℝ≥0 → ℂ → ℂ)
+    (hw : ∀ᵐ ω ∂P, IsCapacityTwoWitness
+      (fun t => Real.sqrt κ * B t ω) (γ ω) (G ω) (F ω))
+    (z : ℂ) (hz : z ∈ upperHalfPlane) (v V : ℝ) (hv : 0 ≤ v) (hvV : v ≤ V)
+    (σ : Ω → WithTop ℝ≥0)
+    (hσ : IsStoppingTime (Filtration.natural B
+      (fun _t => (hBm.comp (measurable_const.prodMk measurable_id)).stronglyMeasurable)) σ)
+    (hbefore : ∀ᵐ ω ∂P, σ ω ≤ radiusLevelTime (γ ω) (G ω) z v)
+    (A : Set Ω) (hA : MeasurableSet[hσ.measurableSpace] A) :
+    finiteCenteredLaw P κ B γ G z V A = finiteCenteredLaw P κ B γ G z v A := by
+  let Qv := finiteCenteredLaw P κ B γ G z v
+  let QV := finiteCenteredLaw P κ B γ G z V
+  have hvfinite : ∀ᵐ ω ∂Qv, σ ω ≠ ⊤ :=
+    finiteCenteredLaw_earlier_stop_ae_finite hB hc κ hκ hκ8 γ G F hw
+      z hz v v hv le_rfl σ hbefore
+  have hVfinite : ∀ᵐ ω ∂QV, σ ω ≠ ⊤ :=
+    finiteCenteredLaw_earlier_stop_ae_finite hB hc κ hκ hκ8 γ G F hw
+      z hz v V hv hvV σ hbefore
+  let An (n : ℕ) := A ∩ {ω | σ ω ≤ ((n : ℝ≥0) : WithTop ℝ≥0)}
+  have hmono : Monotone An := by
+    intro n m hnm ω hω
+    refine ⟨hω.1, ?_⟩
+    change σ ω ≤ ((m : ℝ≥0) : WithTop ℝ≥0)
+    exact hω.2.trans (WithTop.coe_le_coe.mpr (by exact_mod_cast hnm))
+  have hlocal (n : ℕ) : QV (An n) = Qv (An n) := by
+    let τ := cutoffStop σ (n : ℝ≥0)
+    have hτ := cutoffStop_stopping _ σ hσ (n : ℝ≥0)
+    apply finiteCenteredLaw_consistent_at_finite_stop hB hBm hc hB0 κ hκ hκ8
+      γ G F hw z hz v V hv hvV τ hτ _ (An n)
+      (cutoffStop_success_measurable _ σ hσ _ A hA)
+    filter_upwards [hbefore] with ω hω
+    exact (le_of_eq (cutoffStop_coe σ (n : ℝ≥0) ω)).trans ((min_le_left _ _).trans hω)
+  calc
+    QV A = QV (⋃ n, An n) := measure_congr (stopped_past_cover_of_ae_finite QV σ hVfinite A)
+    _ = ⨆ n, QV (An n) := hmono.measure_iUnion
+    _ = ⨆ n, Qv (An n) := by congr 1; funext n; exact hlocal n
+    _ = Qv (⋃ n, An n) := hmono.measure_iUnion.symm
+    _ = Qv A := (measure_congr (stopped_past_cover_of_ae_finite Qv σ hvfinite A)).symm
+
+/-- The cover application: any stopping-time version of the actual
+radius-v time has exactly the same stopped-past law under every later
+finite centered measure. -/
+theorem finiteCenteredLaw_consistent_at_radius_stop
+    {Ω : Type*} [mΩ : MeasurableSpace Ω] {P : Measure Ω} [IsProbabilityMeasure P]
+    {B : ℝ≥0 → Ω → ℝ} (hB : IsBrownianReal B P)
+    (hBm : Measurable (fun p : ℝ≥0 × Ω => B p.1 p.2))
+    (hc : ∀ ω, Continuous (fun t => B t ω)) (hB0 : ∀ ω, B 0 ω = 0)
+    (κ : ℝ) (hκ : 0 < κ) (hκ8 : κ < 8)
+    (γ : Ω → ℝ≥0 → ℂ) (G F : Ω → ℝ≥0 → ℂ → ℂ)
+    (hw : ∀ᵐ ω ∂P, IsCapacityTwoWitness
+      (fun t => Real.sqrt κ * B t ω) (γ ω) (G ω) (F ω))
+    (z : ℂ) (hz : z ∈ upperHalfPlane) (v V : ℝ) (hv : 0 ≤ v) (hvV : v ≤ V)
+    (σ : Ω → WithTop ℝ≥0)
+    (hσ : IsStoppingTime (Filtration.natural B
+      (fun _t => (hBm.comp (measurable_const.prodMk measurable_id)).stronglyMeasurable)) σ)
+    (hactual : ∀ᵐ ω ∂P, σ ω = radiusLevelTime (γ ω) (G ω) z v)
+    (A : Set Ω) (hA : MeasurableSet[hσ.measurableSpace] A) :
+    finiteCenteredLaw P κ B γ G z V A = finiteCenteredLaw P κ B γ G z v A :=
+  finiteCenteredLaw_consistent_at_extended_stop hB hBm hc hB0 κ hκ hκ8 γ G F hw
+    z hz v V hv hvV σ hσ (hactual.mono fun _ h => h.le) A hA
+
+end SLEExactGauge
+
+end
+
+end OAI
diff --git a/lean/OAI/Probability/SLE/Geometry/FiniteCenteredPast.lean b/lean/OAI/Probability/SLE/Geometry/FiniteCenteredPast.lean
new file mode 100644
index 0000000000000000000000000000000000000000..f671a5101920a0a7fe37f74b902db9895a3ddf7d
--- /dev/null
+++ b/lean/OAI/Probability/SLE/Geometry/FiniteCenteredPast.lean
@@ -0,0 +1,90 @@
+import OAI.Probability.SLE.Mass.LevelCurrentLimit
+import OAI.Probability.SLE.Gauge.CoverChangeOfLaw
+
+namespace OAI
+
+/-! Strict past tests of the finite centered laws and their increasing-level limit.
+The event remains strictly before the marked radius level. -/
+
+noncomputable section
+open Set Filter MeasureTheory ProbabilityTheory
+open scoped Topology NNReal ENNReal
+attribute [local instance] Classical.propDecidable
+
+namespace SLEExactGauge.Multipoint
+
+variable {Ω : Type*} [mΩ : MeasurableSpace Ω] {P : Measure Ω}
+  {κ : ℝ} {B : ℝ≥0 → Ω → ℝ}
+  (hB : IsBrownianReal B P) (hBm : Measurable (Function.uncurry B))
+  (hc : ∀ ω, Continuous (fun t => B t ω)) (h0 : ∀ ω, B 0 ω = 0)
+  (hκ : 0 < κ) (hκ8 : κ < 8)
+  (γ : Ω → ℝ≥0 → ℂ) (G F : Ω → ℝ≥0 → ℂ → ℂ)
+  (hw : ∀ ω, IsCapacityTwoWitness (fun t => Real.sqrt κ * B t ω) (γ ω) (G ω) (F ω))
+
+include hB hBm hc h0 hκ hκ8 γ G F hw
+
+lemma finiteCenteredLaw_strict_past (z : ℂ) (hz : z ∈ upperHalfPlane)
+    (u : ℝ) (hu : 0 ≤ u) (t : ℝ≥0) (E : Set Ω)
+    (hE : MeasurableSet[(Filtration.natural B (fun s =>
+      (hBm.comp (measurable_const.prodMk measurable_id) : Measurable (B s)).stronglyMeasurable)) t] E) :
+    ENNReal.ofReal (initialGreen κ z) * finiteCenteredLaw P κ B γ G z u
+      (E ∩ {ω | (t : ℝ≥0∞) < radiusLevelTime (γ ω) (G ω) z u}) =
+      ∫⁻ ω in E, ENNReal.ofReal (levelCurrentGreen κ B γ G u t z ω) ∂P := by
+  let ℱ := Filtration.natural B (fun s =>
+    (hBm.comp (measurable_const.prodMk measurable_id) : Measurable (B s)).stronglyMeasurable)
+  let A : Set Ω := {ω | (t : ℝ≥0∞) < radiusLevelTime (γ ω) (G ω) z u}
+  have hA : MeasurableSet A := by
+    have hm (s : ℝ≥0) : Measurable (B s) := hBm.comp (measurable_const.prodMk measurable_id)
+    have hj := actual_radiusLevel_joint_measurable hm hc κ u hu γ G F hw
+    have hp : Measurable (fun ω : Ω => (ω,z)) := measurable_id.prodMk measurable_const
+    have htt := hj.comp hp
+    have ht : Measurable (fun ω => radiusLevelTime (γ ω) (G ω) z u) := by
+      simpa only [Function.comp_def] using htt
+    exact measurableSet_lt (measurable_const : Measurable (fun _ : Ω => (t : ℝ≥0∞))) ht
+  have hEg : MeasurableSet E := (ℱ.le t) _ hE
+  calc
+    _ = ∫⁻ ω in E ∩ A, ENNReal.ofReal
+        (stoppedGreen κ (fun s => Real.sqrt κ * B s ω) (γ ω) (G ω) z u) ∂P :=
+      (finiteCenteredLaw_event_identity P κ B γ G z hz u (hEg.inter hA)).symm
+    _ = ∫⁻ ω in E, ENNReal.ofReal (levelRemainderGreen κ B γ G u t z ω) ∂P := by
+      rw [inter_comm E A, ← setLIntegral_indicator hA]
+      apply lintegral_congr
+      intro ω
+      by_cases ha : ω ∈ A
+      · have hh : (t : ℝ≥0∞) < radiusLevelTime (γ ω) (G ω) z u := ha
+        rw [indicator_of_mem ha, levelRemainderGreen, ite_eq_left hh]
+      · have hh : ¬ (t : ℝ≥0∞) < radiusLevelTime (γ ω) (G ω) z u := ha
+        rw [indicator_of_notMem ha, levelRemainderGreen, ite_eq_right hh, ENNReal.ofReal_zero]
+    _ = _ := levelRemainderGreen_setLIntegral hB hBm hc h0 hκ hκ8 γ G F
+      (ae_of_all _ hw) z hz u hu t E hE
+
+lemma finiteCenteredLaw_strict_past_tendsto
+    (z : ℂ) (hz : z ∈ upperHalfPlane)
+    (u : ℕ → ℝ) (hu : ∀ n, 0 ≤ u n) (hmono : Monotone u)
+    (hlim : Tendsto u atTop atTop) (t : ℝ≥0) (E : Set Ω)
+    (hE : MeasurableSet[(Filtration.natural B (fun s =>
+      (hBm.comp (measurable_const.prodMk measurable_id) : Measurable (B s)).stronglyMeasurable)) t] E) :
+    Tendsto (fun n => ENNReal.ofReal (initialGreen κ z) *
+      finiteCenteredLaw P κ B γ G z (u n)
+        (E ∩ {ω | (t : ℝ≥0∞) < radiusLevelTime (γ ω) (G ω) z (u n)})) atTop
+      (𝓝 (∫⁻ ω in E, ENNReal.ofReal
+        (greenDensity κ (fun s => Real.sqrt κ * B s ω) (γ ω) (G ω) t z) ∂P)) := by
+  simp_rw [finiteCenteredLaw_strict_past hB hBm hc h0 hκ hκ8 γ G F hw z hz _ (hu _) t E hE]
+  apply lintegral_tendsto_of_tendsto_of_monotone
+  · intro n
+    have hp : Measurable (fun ω : Ω => (ω,z)) := measurable_id.prodMk measurable_const
+    have hh := (levelCurrentGreen_joint_measurable hBm hc κ (u n) (hu n) γ G F hw t).comp hp
+    have hh' : Measurable (fun ω => levelCurrentGreen κ B γ G (u n) t z ω) := by
+      simpa only [Function.comp_def] using hh
+    exact hh'.ennreal_ofReal.aemeasurable
+  · exact ae_of_all _ (fun ω n m hnm => ENNReal.ofReal_le_ofReal
+      (levelCurrentGreen_mono ω (hc ω) (hw ω) z t (hu n) (hmono hnm)))
+  · exact ae_of_all _ (fun ω => tendsto_const_nhds.congr'
+      ((levelCurrentGreen_eventually_eq ω (hc ω) (hw ω) z t u hu hlim).mono
+        (fun n hn => congrArg ENNReal.ofReal hn.symm)))
+
+end SLEExactGauge.Multipoint
+
+end
+
+end OAI
diff --git a/lean/OAI/Probability/SLE/Geometry/FiniteDensityAtPast.lean b/lean/OAI/Probability/SLE/Geometry/FiniteDensityAtPast.lean
new file mode 100644
index 0000000000000000000000000000000000000000..31e74e2dd2e2aa9949099e9493a16b45077125b2
--- /dev/null
+++ b/lean/OAI/Probability/SLE/Geometry/FiniteDensityAtPast.lean
@@ -0,0 +1,47 @@
+import OAI.Probability.SLE.Gauge.RandomPassageBounds
+
+namespace OAI
+
+/-! The finite tilted law on a stopped-past event is the integral of its
+conditional density there. -/
+
+noncomputable section
+open Set Filter MeasureTheory
+open scoped ENNReal
+
+namespace SLEExactGauge
+
+theorem normalizedDensity_measure_at_past
+    {Ω : Type*} [mΩ : MeasurableSpace Ω] (P : Measure Ω) [IsFiniteMeasure P]
+    (m : MeasurableSpace Ω) (hm : m ≤ mΩ)
+    (Z M : Ω → ℝ) (hZi : Integrable Z P) (hZn : 0 ≤ᵐ[P] Z)
+    (hM : M =ᵐ[P] P[Z | m]) (a : ℝ) (ha : 0 < a)
+    (E : Set Ω) (hE : MeasurableSet[m] E) :
+    P.withDensity (fun ω => ENNReal.ofReal (Z ω / a)) E =
+      ∫⁻ ω in E, ENNReal.ofReal (M ω / a) ∂P := by
+  let : MeasurableSpace Ω := mΩ
+  have hcond := condLExp_ofReal m hZi hZn
+  have he : (∫⁻ ω in E, ENNReal.ofReal (M ω) ∂P) =
+      ∫⁻ ω in E, ENNReal.ofReal (Z ω) ∂P := by
+    calc
+      _ = ∫⁻ ω in E, P⁻[(fun ω => ENNReal.ofReal (Z ω)) | m] ω ∂P := by
+        apply lintegral_congr_ae
+        filter_upwards [ae_restrict_of_ae hM, ae_restrict_of_ae hcond] with ω hMω hcω
+        rw [hcω, ← hMω]
+      _ = _ := setLIntegral_condLExp hm P _ hE
+  rw [setLIntegral_eq_mul_normalizedDensity P Z ha (hm E hE),
+    setLIntegral_eq_mul_normalizedDensity P M ha (hm E hE)] at he
+  have he' :
+      P.withDensity (fun ω => ENNReal.ofReal (M ω / a)) E * ENNReal.ofReal a =
+      P.withDensity (fun ω => ENNReal.ofReal (Z ω / a)) E * ENNReal.ofReal a :=
+    (mul_comm _ _).trans (he.trans (mul_comm _ _))
+  have hcancel := (ENNReal.mul_left_inj (ENNReal.ofReal_ne_zero_iff.mpr ha)
+    ENNReal.ofReal_ne_top).mp he'
+  rw [withDensity_apply _ (hm E hE)] at hcancel
+  exact hcancel.symm
+
+end SLEExactGauge
+
+end
+
+end OAI
diff --git a/lean/OAI/Probability/SLE/Geometry/FiniteDensityAtRadiusState.lean b/lean/OAI/Probability/SLE/Geometry/FiniteDensityAtRadiusState.lean
new file mode 100644
index 0000000000000000000000000000000000000000..3b8732f8811d6f442c59fcd139358367450e52cf
--- /dev/null
+++ b/lean/OAI/Probability/SLE/Geometry/FiniteDensityAtRadiusState.lean
@@ -0,0 +1,68 @@
+import OAI.Probability.SLE.Geometry.FiniteDensityAtPast
+import OAI.Probability.SLE.Gauge.DenseRadiusGap
+import OAI.Probability.SLE.InverseMoments
+
+namespace OAI
+
+/-! The exact density on a finite stopped past at a live radius state.
+The deeper finite-centered law has the original Green density there. -/
+
+noncomputable section
+open Set Filter MeasureTheory ProbabilityTheory
+open scoped Topology NNReal ENNReal
+
+namespace SLEExactGauge
+
+theorem exists_finiteDensity_at_radius_state
+    {Ω : Type*} [MeasurableSpace Ω] {P : Measure Ω} [IsProbabilityMeasure P]
+    {B : ℝ≥0 → Ω → ℝ} (hB : IsBrownianReal B P)
+    (hBm : Measurable (fun p : ℝ≥0 × Ω => B p.1 p.2))
+    (hc : ∀ ω, Continuous (fun t => B t ω)) (hB0 : ∀ ω, B 0 ω = 0)
+    (κ : ℝ) (hκ : 0 < κ) (hκ8 : κ < 8)
+    (γ : Ω → ℝ≥0 → ℂ) (G F : Ω → ℝ≥0 → ℂ → ℂ)
+    (hw : ∀ ω, IsCapacityTwoWitness (fun t => Real.sqrt κ * B t ω) (γ ω) (G ω) (F ω))
+    (τ : Ω → ℝ≥0)
+    (hτ : IsStoppingTime (Filtration.natural B
+      (fun _t => (hBm.comp (measurable_const.prodMk measurable_id)).stronglyMeasurable))
+      (fun ω => (τ ω : WithTop ℝ≥0)))
+    (z : ℂ) (hz : z ∈ upperHalfPlane) (u q : ℝ) (hu : 0 ≤ u) (hq : 0 < q)
+    (E : Set Ω) (hE : MeasurableSet[hτ.measurableSpace] E)
+    (hlive : ∀ ω ∈ E, z ∈ survivingDomain (γ ω) (τ ω))
+    (hbase : ∀ ω ∈ E, fullRadius (G ω) (τ ω) z = (2 * z.im) * Real.exp (-u)) :
+    ∃ M : Ω → ℝ≥0∞, Measurable[hτ.measurableSpace] M ∧
+      (∀ ω, M ω ≠ ∞) ∧
+      (∀ᵐ ω ∂P, ω ∈ E → M ω = ENNReal.ofReal
+        (greenDensity κ (fun t => Real.sqrt κ * B t ω) (γ ω) (G ω) (τ ω) z /
+          initialGreen κ z)) ∧
+      ∀ A : Set Ω, MeasurableSet[hτ.measurableSpace] A →
+        (∫⁻ ω in A ∩ E, M ω ∂P) = finiteCenteredLaw P κ B γ G z (u + q) (A ∩ E) := by
+  obtain ⟨V, Z, _, hZi, _, hZb, _, hVstop, hsource, _⟩ :=
+    exists_physical_green_stopping_regular hB hBm hc hB0 κ hκ hκ8 γ G F
+      (Eventually.of_forall hw) z hz (u + q) (by linarith)
+  let C : Ω → ℝ := P[Z | hτ.measurableSpace]
+  let M : Ω → ℝ≥0∞ := fun ω => ENNReal.ofReal (C ω / initialGreen κ z)
+  have hCm : Measurable[hτ.measurableSpace] C := stronglyMeasurable_condExp.measurable
+  have he : P.withDensity (fun ω => ENNReal.ofReal (Z ω / initialGreen κ z)) =
+      finiteCenteredLaw P κ B γ G z (u + q) := by
+    apply withDensity_congr_ae
+    filter_upwards [hsource] with ω hω
+    rw [hω.2]
+  refine ⟨M, ENNReal.measurable_ofReal.comp (hCm.div_const _),
+    fun _ => ENNReal.ofReal_ne_top, ?_, ?_⟩
+  · filter_upwards [hVstop τ hτ, hsource] with ω hVω hsrc hωE
+    have hbefore := (hw ω).before_deeper_radius_level ((hc ω).const_mul _) z u q hu hq
+      (τ ω) (hlive ω hωE) (hbase ω hωE)
+    change ENNReal.ofReal (C ω / _) = _
+    rw [show C ω = V (τ ω) ω from hVω.symm, hsrc.1 (τ ω), physicalStoppedGreen,
+      ite_eq_right (not_le.mpr hbefore)]
+  · intro A hA
+    rw [← he]
+    exact (normalizedDensity_measure_at_past P hτ.measurableSpace hτ.measurableSpace_le
+      Z C hZi (Eventually.of_forall (fun ω => (hZb ω).1)) Filter.EventuallyEq.rfl
+      (initialGreen κ z) (initialGreen_pos κ z hz) (A ∩ E) (hA.inter hE)).symm
+
+end SLEExactGauge
+
+end
+
+end OAI
diff --git a/lean/OAI/Probability/SLE/Geometry/FiniteEnergyArcExtension.lean b/lean/OAI/Probability/SLE/Geometry/FiniteEnergyArcExtension.lean
new file mode 100644
index 0000000000000000000000000000000000000000..de97456914c6fb2c678eebc7bed911045412e7b3
--- /dev/null
+++ b/lean/OAI/Probability/SLE/Geometry/FiniteEnergyArcExtension.lean
@@ -0,0 +1,52 @@
+import OAI.Probability.SLE.Geometry.ComplexAngularEnergy
+
+namespace OAI
+
+/-! An angular section with finite derivative energy has a continuous
+extension to both endpoints. The construction is its actual integral primitive. -/
+noncomputable section
+open Set Filter Metric Function MeasureTheory
+open scoped Topology ENNReal
+
+namespace SLEExactGauge
+
+lemma finite_energy_angular_extension {f : ℝ → ℂ}
+    (hf : ∀ θ∈Ioo 0 Real.pi, DifferentiableAt ℝ f θ)
+    (hd : MemLp (deriv f) 2 (volume.restrict (Ioo 0 Real.pi))) :
+    ∃ F : ℝ → ℂ, Continuous F ∧ EqOn F f (Ioo 0 Real.pi) := by
+  let a := Real.pi/2
+  have ha : a∈Ioo 0 Real.pi := ⟨half_pos Real.pi_pos,by dsimp [a]; linarith [Real.pi_pos]⟩
+  let g := (Ioo 0 Real.pi).indicator (deriv f)
+  have hi : Integrable g volume := (integrable_indicator_iff measurableSet_Ioo).mpr
+    (hd.integrable (by norm_num))
+  refine ⟨fun θ => f a + ∫ s in a..θ, g s,
+    continuous_const.add (hi.continuous_primitive a),?_⟩
+  intro θ hθ
+  have hs : uIcc a θ⊆Ioo 0 Real.pi := ordConnected_Ioo.uIcc_subset ha hθ
+  have hi' : IntegrableOn (deriv f) (Ioo 0 Real.pi) := hd.integrable (by norm_num)
+  have hid : IntervalIntegrable (deriv f) volume a θ := intervalIntegrable_iff.mpr
+    (hi'.mono_set (uIoc_subset_uIcc.trans hs))
+  have he : (∫ s in a..θ, g s)=∫ s in a..θ, deriv f s :=
+    intervalIntegral.integral_congr (fun s hs' => indicator_of_mem (hs hs') _)
+  change f a + (∫ s in a..θ, g s)=f θ
+  rw [he,intervalIntegral.integral_deriv_eq_sub (fun s hs' => hf s (hs hs')) hid]
+  exact add_sub_cancel _ _
+
+lemma continuous_angular_oscillation_on_endpoints {F : ℝ → ℂ}
+    (hF : Continuous F) (ε : ℝ)
+    (hsmall : ∀ θ∈Ioo 0 Real.pi, ∀ φ∈Ioo 0 Real.pi, ‖F θ-F φ‖≤ε) :
+    ∀ θ∈Icc 0 Real.pi, ∀ φ∈Icc 0 Real.pi, ‖F θ-F φ‖≤ε := by
+  have hc : IsClosed {p : ℝ×ℝ | ‖F p.1-F p.2‖≤ε} :=
+    isClosed_le ((hF.comp continuous_fst).sub (hF.comp continuous_snd)).norm continuous_const
+  have hs : (Ioo (0:ℝ) Real.pi) ×ˢ (Ioo (0:ℝ) Real.pi)⊆
+      {p : ℝ×ℝ | ‖F p.1-F p.2‖≤ε} := fun p hp => hsmall p.1 hp.1 p.2 hp.2
+  have hcl := hc.closure_subset_iff.mpr hs
+  rw [closure_prod_eq,closure_Ioo (ne_of_lt Real.pi_pos)] at hcl
+  intro θ hθ φ hφ
+  exact hcl (show (θ,φ)∈(Icc 0 Real.pi) ×ˢ (Icc 0 Real.pi) from ⟨hθ,hφ⟩)
+
+end SLEExactGauge
+
+end
+
+end OAI
diff --git a/lean/OAI/Probability/SLE/Geometry/FiniteExitArcAt.lean b/lean/OAI/Probability/SLE/Geometry/FiniteExitArcAt.lean
new file mode 100644
index 0000000000000000000000000000000000000000..9cc519237a1124e02726d6cd9cc9e6f7fda775e1
--- /dev/null
+++ b/lean/OAI/Probability/SLE/Geometry/FiniteExitArcAt.lean
@@ -0,0 +1,55 @@
+import OAI.Probability.SLE.Mass.WaypointHarmonicMeasure
+
+namespace OAI
+
+/-! Identify exit arcs from any strictly positive local departure time.
+This permits a short initial departure inside a marked corner chart. -/
+
+noncomputable section
+open Set Filter MeasureTheory
+open scoped Topology NNReal ENNReal
+
+namespace SLEExactGauge.RibbonCoordinates
+open Target CrosscutSides
+
+theorem finite_exit_event_measure_le_arc_at
+    (μ : Measure (Driver × Driver)) (D : Set ℂ) (g : ℂ → ℂ) (w : ℂ)
+    (h : ℂ ≃ₜ ℂ) (hreal : ∀ x : ℝ, h (x : ℂ) = (x : ℂ))
+    (hg : ContinuousOn g D) (E : Set (Driver × Driver)) {dir a : ℝ}
+    (hdir : dir = -1 ∨ dir = 1) (ha : 0 ≤ a)
+    (hexit : ∀ᵐ b ∂μ, ∀ τ : ℝ, UnitWindowFirstExit D (physicalUnitBrownianPath w b) τ →
+      ∃ x : ℝ, x ≠ 0 ∧ Tendsto (fun t => g (physicalUnitBrownianPath w b t))
+        (𝓝[<] τ) (𝓝 (x : ℂ)))
+    (hgeom : ∀ b ∈ E, ∃ τ : ℝ,
+      UnitWindowFirstExit D (physicalUnitBrownianPath w b) τ ∧ a < τ ∧
+      ∀ t ∈ Ico a τ, (h (g (physicalUnitBrownianPath w b t))).re ≠ 0)
+    (hstart : ∀ b ∈ E, 0 < dir * (h (g (physicalUnitBrownianPath w b a))).re) :
+    μ E ≤ μ (unitWindowExitArc D g w dir) := by
+  apply measure_mono_ae
+  filter_upwards [hexit] with b hb
+  intro he
+  obtain ⟨τ, hτ, haτ, hn⟩ := hgeom b he
+  obtain ⟨x, hx, hlim⟩ := hb τ hτ
+  refine ⟨τ, hτ, x, ?_, hlim⟩
+  let ζ := physicalUnitBrownianPath w b
+  have hj : ContinuousOn (fun z => (h (g z)).re) D :=
+    Complex.continuous_re.comp_continuousOn (h.continuous.comp_continuousOn hg)
+  have hin : MapsTo ζ (Ico a τ) D := hτ.2.2.mono_left (Ico_subset_Ico_left ha)
+  have hs := hstart b he
+  rcases hdir with rfl | rfl
+  · have hp := exit_prefix_negative (fun z => (h (g z)).re) hj ζ
+      (physicalUnitBrownianPath_continuous w b).continuousOn hin hn haτ (by nlinarith)
+    have hxneg := real_exit_negative_of_straightened_prefix h hreal
+      (fun t => g (ζ t)) haτ hx hp hlim
+    nlinarith
+  · have hp := exit_prefix_positive (fun z => (h (g z)).re) hj ζ
+      (physicalUnitBrownianPath_continuous w b).continuousOn hin hn haτ (by simpa using hs)
+    have hxpos := real_exit_positive_of_straightened_prefix h hreal
+      (fun t => g (ζ t)) haτ hx hp hlim
+    simpa using hxpos
+
+end SLEExactGauge.RibbonCoordinates
+
+end
+
+end OAI
diff --git a/lean/OAI/Probability/SLE/Geometry/FiniteLawTailBounds.lean b/lean/OAI/Probability/SLE/Geometry/FiniteLawTailBounds.lean
new file mode 100644
index 0000000000000000000000000000000000000000..f8645dcef3042e5be1b5c83bd8ef29ce0e892de6
--- /dev/null
+++ b/lean/OAI/Probability/SLE/Geometry/FiniteLawTailBounds.lean
@@ -0,0 +1,75 @@
+import OAI.Probability.SLE.Gauge.MomentBatches
+
+namespace OAI
+
+/-! The batch estimates need only upper moment bounds on finite laws.
+Increasing finite-law tails can be passed to their supremum before summing. -/
+
+noncomputable section
+open Set Filter MeasureTheory
+open scoped Topology ENNReal NNReal
+
+namespace SLEExactGauge.MomentBatches
+
+lemma upper_finite_batch_bound {Ω : Type*} [MeasurableSpace Ω]
+    (P : Measure Ω) [IsFiniteMeasure P] (X : Ω → ℝ) (hX : Measurable X)
+    (hX0 : ∀ ω, 0 ≤ X ω) {n : ℕ} (hn : 1 ≤ n)
+    {m T : ℝ} (hm : 0 < m) (hi : Integrable (fun ω => X ω^n) P)
+    (hMoment : (∫ ω, X ω^n ∂P) ≤ m) (S : Finset ℤ) :
+    (∑ k ∈ S, (copies n m T k : ℝ)*P.real {ω | 16*dyadic k ≤ X ω}) ≤
+      (4:ℝ)^n/16^n/(1-(1/2:ℝ)^n) := by
+  let C := (4:ℝ)^n/(m*16^n*(1-(1/2:ℝ)^n))
+  have hden : 0 < 1-(1/2:ℝ)^n := denominator_pos hn
+  have hC : 0 ≤ C := by dsimp only [C]; positivity
+  have hset (k : ℤ) : MeasurableSet {ω | 16*dyadic k ≤ X ω} :=
+    measurableSet_le measurable_const hX
+  have hInt (k : ℤ) : Integrable
+      (fun ω => if 16*dyadic k ≤ X ω then (copies n m T k : ℝ) else 0) P :=
+    (integrable_const _).indicator (hset k)
+  calc
+    _ = ∫ ω, ∑ k ∈ S, if 16*dyadic k ≤ X ω then (copies n m T k : ℝ) else 0 ∂P :=
+      (integral_hit_count P X hX n m T 16 S).symm
+    _ ≤ ∫ ω, C*X ω^n ∂P := integral_mono
+      (integrable_finsetSum S (fun k _ => hInt k)) (hi.const_mul C)
+      (fun ω => hit_count_upper hn hm (hX0 ω) S)
+    _ = C*(∫ ω, X ω^n ∂P) := integral_const_mul _ _
+    _ ≤ C*m := mul_le_mul_of_nonneg_left hMoment hC
+    _ = _ := by dsimp only [C]; field_simp
+
+lemma cleanup_finite_tail_bound {Ω : Type*} [MeasurableSpace Ω]
+    (P : Measure Ω) [IsFiniteMeasure P] (X : Ω → ℝ) (hX : Measurable X)
+    (hX0 : ∀ ω, 0 ≤ X ω) (hi : Integrable X P) (S : Finset ℕ) :
+    (∑ n ∈ S, P.real {ω | 16*((n:ℝ)+1) ≤ X ω}) ≤ (∫ ω, X ω ∂P)/16 := by
+  classical
+  have hset (n : ℕ) : MeasurableSet {ω | 16*((n:ℝ)+1) ≤ X ω} :=
+    measurableSet_le measurable_const hX
+  have hInt (n : ℕ) : Integrable
+      (fun ω => if 16*((n:ℝ)+1) ≤ X ω then (1:ℝ) else 0) P :=
+    (integrable_const _).indicator (hset n)
+  calc
+    _ = ∫ ω, ∑ n ∈ S, if 16*((n:ℝ)+1) ≤ X ω then (1:ℝ) else 0 ∂P := by
+      rw [integral_finsetSum S (fun n _ => hInt n)]
+      apply Finset.sum_congr rfl
+      intro n _
+      simpa only [Set.indicator,Set.mem_ofPred_eq,smul_eq_mul,mul_one] using
+        (integral_indicator_const (μ := P) (1:ℝ) (hset n)).symm
+    _ ≤ ∫ ω, X ω/16 ∂P := integral_mono
+      (integrable_finsetSum S (fun n _ => hInt n)) (hi.div_const 16)
+      (fun ω => cleanup_count_le (hX0 ω) S)
+    _ = _ := integral_div _ _
+
+lemma finite_monotone_tail_sum_bound {ι : Type*} (S : Finset ι)
+    (c : ι → ℝ≥0∞) (p : ℕ → ι → ℝ≥0∞)
+    (hp : ∀ i, Monotone (fun n => p n i)) (A : ℝ≥0∞)
+    (hbound : ∀ n, (∑ i ∈ S, c i*p n i) ≤ A) :
+    (∑ i ∈ S, c i*(⨆ n, p n i)) ≤ A := by
+  simp_rw [ENNReal.mul_iSup]
+  rw [ENNReal.finsetSum_iSup_of_monotone (s := S) (f := fun i n => c i*p n i)
+    (fun i => fun n m hnm => mul_le_mul' le_rfl (hp i hnm))]
+  exact iSup_le hbound
+
+end SLEExactGauge.MomentBatches
+
+end
+
+end OAI
diff --git a/lean/OAI/Probability/SLE/Geometry/FiniteLawTailENN.lean b/lean/OAI/Probability/SLE/Geometry/FiniteLawTailENN.lean
new file mode 100644
index 0000000000000000000000000000000000000000..cc10fe672d3a723253ec60cbc411f17c34b78732
--- /dev/null
+++ b/lean/OAI/Probability/SLE/Geometry/FiniteLawTailENN.lean
@@ -0,0 +1,82 @@
+import OAI.Probability.SLE.Geometry.FiniteLawTailBounds
+
+namespace OAI
+
+/-! Summable dyadic and cleanup tails from increasing finite laws.
+No limiting probability measure or future-dependent density is required. -/
+
+noncomputable section
+open Set Filter MeasureTheory
+open scoped Topology ENNReal NNReal
+
+namespace SLEExactGauge.MomentBatches
+
+lemma finite_probability_sum_eq {Ω ι : Type*} [MeasurableSpace Ω]
+    (Q : Measure Ω) [IsFiniteMeasure Q] (S : Finset ι)
+    (c : ι → ℕ) (E : ι → Set Ω) :
+    (∑ i ∈ S, (c i : ℝ≥0∞)*Q (E i)) =
+      ENNReal.ofReal (∑ i ∈ S, (c i : ℝ)*Q.real (E i)) := by
+  symm
+  rw [ENNReal.ofReal_sum_of_nonneg (fun i _ => mul_nonneg (Nat.cast_nonneg _) measureReal_nonneg)]
+  apply Finset.sum_congr rfl
+  intro i _
+  rw [ENNReal.ofReal_mul (Nat.cast_nonneg _),ENNReal.ofReal_natCast,ofReal_measureReal]
+
+lemma upper_finite_batch_bound_enn {Ω : Type*} [MeasurableSpace Ω]
+    (Q : Measure Ω) [IsFiniteMeasure Q] (X : Ω → ℝ) (hX : Measurable X)
+    (hX0 : ∀ ω, 0 ≤ X ω) {n : ℕ} (hn : 1 ≤ n)
+    {m T : ℝ} (hm : 0 < m) (hi : Integrable (fun ω => X ω^n) Q)
+    (hMoment : (∫ ω, X ω^n ∂Q) ≤ m) (S : Finset ℤ) :
+    (∑ k ∈ S, (copies n m T k : ℝ≥0∞)*Q {ω | 16*dyadic k ≤ X ω}) ≤
+      ENNReal.ofReal ((4:ℝ)^n/16^n/(1-(1/2:ℝ)^n)) := by
+  rw [finite_probability_sum_eq]
+  exact ENNReal.ofReal_le_ofReal (upper_finite_batch_bound Q X hX hX0 hn hm hi hMoment S)
+
+lemma limiting_upper_batch_bound {Ω : Type*} [MeasurableSpace Ω]
+    (Q : ℕ → Measure Ω) (hfin : ∀ j, IsFiniteMeasure (Q j))
+    (X : ℕ → Ω → ℝ) (hX : ∀ j, Measurable (X j)) (hX0 : ∀ j ω, 0 ≤ X j ω)
+    (hmono : ∀ b, Monotone (fun j => Q j {ω | b ≤ X j ω}))
+    {n : ℕ} (hn : 1 ≤ n) {m T : ℝ} (hm : 0 < m)
+    (hi : ∀ j, Integrable (fun ω => X j ω^n) (Q j))
+    (hMoment : ∀ j, (∫ ω, X j ω^n ∂Q j) ≤ m) :
+    (∑' k : ℤ, (copies n m T k : ℝ≥0∞)*
+      (⨆ j, Q j {ω | 16*dyadic k ≤ X j ω})) ≤
+        ENNReal.ofReal ((4:ℝ)^n/16^n/(1-(1/2:ℝ)^n)) := by
+  rw [ENNReal.tsum_eq_iSup_sum]
+  apply iSup_le
+  intro S
+  apply finite_monotone_tail_sum_bound S (fun k => (copies n m T k : ℝ≥0∞))
+    (fun j k => Q j {ω | 16*dyadic k ≤ X j ω}) (fun k => hmono _) _
+  intro j
+  let := hfin j
+  exact upper_finite_batch_bound_enn (Q j) (X j) (hX j) (hX0 j) hn hm (hi j) (hMoment j) S
+
+lemma limiting_cleanup_tail_bound {Ω : Type*} [MeasurableSpace Ω]
+    (Q : ℕ → Measure Ω) (hfin : ∀ j, IsFiniteMeasure (Q j))
+    (X : ℕ → Ω → ℝ) (hX : ∀ j, Measurable (X j)) (hX0 : ∀ j ω, 0 ≤ X j ω)
+    (hmono : ∀ b, Monotone (fun j => Q j {ω | b ≤ X j ω}))
+    (hi : ∀ j, Integrable (X j) (Q j)) (m : ℝ)
+    (hMoment : ∀ j, (∫ ω, X j ω ∂Q j) ≤ m) :
+    (∑' n : ℕ, ⨆ j, Q j {ω | 16*((n:ℝ)+1) ≤ X j ω}) ≤ ENNReal.ofReal (m/16) := by
+  rw [ENNReal.tsum_eq_iSup_sum]
+  apply iSup_le
+  intro S
+  have hs := finite_monotone_tail_sum_bound S (fun _ => (1:ℝ≥0∞))
+    (fun j n => Q j {ω | 16*((n:ℝ)+1) ≤ X j ω}) (fun n => hmono _) (ENNReal.ofReal (m/16))
+  simp only [one_mul] at hs
+  apply hs
+  intro j
+  let := hfin j
+  have he := finite_probability_sum_eq (Q j) S (fun _ => 1)
+    (fun n => {ω | 16*((n:ℝ)+1) ≤ X j ω})
+  simp only [Nat.cast_one,one_mul] at he
+  rw [he]
+  apply ENNReal.ofReal_le_ofReal
+  exact (cleanup_finite_tail_bound (Q j) (X j) (hX j) (hX0 j) (hi j) S).trans
+    (div_le_div_of_nonneg_right (hMoment j) (by norm_num))
+
+end SLEExactGauge.MomentBatches
+
+end
+
+end OAI
diff --git a/lean/OAI/Probability/SLE/Geometry/FiniteParameterProjection.lean b/lean/OAI/Probability/SLE/Geometry/FiniteParameterProjection.lean
new file mode 100644
index 0000000000000000000000000000000000000000..ca1fac7e2ddcdcbd0191af6ed2568ba8b48571a7
--- /dev/null
+++ b/lean/OAI/Probability/SLE/Geometry/FiniteParameterProjection.lean
@@ -0,0 +1,56 @@
+import OAI.Probability.SLE.Geometry.ContinuousRangeCompletion
+
+namespace OAI
+
+/-! Transfer of Borel parameter families under a finite path law, with one
+exceptional set for all parameters. -/
+noncomputable section
+open Set Filter MeasureTheory ProbabilityTheory
+open scoped Topology ENNReal
+
+namespace SLEExactGauge
+
+lemma nullMeasurableSet_forall_parameter
+    {X T : Type*} [MetricSpace X] [SecondCountableTopology X]
+    [MeasurableSpace X] [BorelSpace X] [StandardBorelSpace X]
+    [MeasurableSpace T] [StandardBorelSpace T]
+    (μ : Measure X) [IsFiniteMeasure μ] (p : T → X → Prop)
+    (hp : MeasurableSet {q : T × X | p q.1 q.2}) :
+    NullMeasurableSet {x | ∀ t, p t x} μ := by
+  have hbad : AnalyticSet (Prod.snd '' {q : T × X | ¬p q.1 q.2}) :=
+    hp.compl.analyticSet_image measurable_snd
+  have heq : {x | ∀ t, p t x}=(Prod.snd '' {q : T × X | ¬p q.1 q.2})ᶜ := by
+    ext x
+    simp only [mem_compl_iff,mem_image,mem_ofPred_eq,Prod.exists,
+      exists_eq_right,not_exists,not_not]
+  rw [heq]
+  exact (nullMeasurableSet_of_analytic_finite μ hbad).compl
+
+lemma ae_map_iff_nullMeasurableSet
+    {Ω X : Type*} [MeasurableSpace Ω] [MeasurableSpace X]
+    {P : Measure Ω} {f : Ω → X} (hf : AEMeasurable f P) {p : X → Prop}
+    (hp : NullMeasurableSet {x | p x} (P.map f)) :
+    (∀ᵐ x ∂P.map f, p x) ↔ ∀ᵐ ω ∂P, p (f ω) := by
+  have hn : NullMeasurableSet {x | ¬p x} (P.map f) := hp.compl
+  rw [ae_iff,Measure.map_apply₀ hf hn]
+  rfl
+
+lemma ae_forall_parameter_of_hasLaw
+    {Ω X T : Type*} [MeasurableSpace Ω]
+    [MetricSpace X] [SecondCountableTopology X]
+    [MeasurableSpace X] [BorelSpace X] [StandardBorelSpace X]
+    [MeasurableSpace T] [StandardBorelSpace T]
+    {P : Measure Ω} {μ : Measure X} [IsFiniteMeasure μ]
+    {f : Ω → X} (hf : HasLaw f μ P) (p : T → X → Prop)
+    (hp : MeasurableSet {q : T × X | p q.1 q.2})
+    (h : ∀ᵐ ω ∂P, ∀ t, p t (f ω)) :
+    ∀ᵐ x ∂μ, ∀ t, p t x := by
+  have hn := nullMeasurableSet_forall_parameter μ p hp
+  rw [← hf.map_eq] at hn ⊢
+  exact (ae_map_iff_nullMeasurableSet hf.aemeasurable hn).mpr h
+
+end SLEExactGauge
+
+end
+
+end OAI
diff --git a/lean/OAI/Probability/SLE/Geometry/FinitePastCellTail.lean b/lean/OAI/Probability/SLE/Geometry/FinitePastCellTail.lean
new file mode 100644
index 0000000000000000000000000000000000000000..c445056106bc89115cd85a88dfe129a1e95ac8ed
--- /dev/null
+++ b/lean/OAI/Probability/SLE/Geometry/FinitePastCellTail.lean
@@ -0,0 +1,41 @@
+import OAI.Probability.SLE.Geometry.FiniteCellTailKernel
+import OAI.Probability.SLE.Geometry.FinitePastEvents
+
+namespace OAI
+
+/-! A positive mass test strictly before a finite radius frontier forces
+the corresponding canonical cell mass test at the frontier. -/
+noncomputable section
+open Set Filter _root_.MeasureTheory _root_.OAI.MeasureTheory ProbabilityTheory
+open scoped Topology NNReal ENNReal
+
+namespace SLEExactGauge.Multipoint
+
+lemma CanonicalMass.finite_strict_past_le_cell_test
+    {Ω : Type*} [MeasurableSpace Ω] {P : Measure Ω} {κ : ℝ}
+    {B : ℝ≥0 → Ω → ℝ} {hBm : Measurable (Function.uncurry B)}
+    {γ : Ω → ℝ≥0 → ℂ} {G : Ω → ℝ≥0 → ℂ → ℂ}
+    (C : CanonicalMass P κ B hBm γ G) (Q : Measure Ω) (hQP : Q.AbsolutelyContinuous P)
+    (T : Ω → WithTop ℝ≥0) (hT : ∀ᵐ ω ∂Q, T ω≠⊤)
+    (J : Finset ℝ≥0) (K : Set ℂ) (H : ℝ) :
+    Q (finiteStrictPastEvent J (fun t => {ω | H<(C.process t ω (Subtype.val ⁻¹' K)).toReal}) T) ≤
+      Q (C.finiteCellMassTest T K (ENNReal.ofReal H)) := by
+  apply measure_mono_ae
+  filter_upwards [hQP.ae_le C.paths,hT] with ω hp hf hω
+  obtain ⟨t,_ht,hval,hbefore⟩ := mem_iUnion₂.mp hω
+  have hf' := hf
+  lift T ω to ℝ≥0 using hf with s hs
+  have hts : t ≤ s := by
+    apply WithTop.coe_le_coe.mp
+    simpa only [hs] using hbefore.le
+  have hmass := hp.monotone hts (Subtype.val ⁻¹' K)
+  refine ⟨lt_top_iff_ne_top.mpr (hs ▸ hf'),?_⟩
+  have htime : (T ω).untopD 0=s := by rw [← hs,WithTop.untopD_coe]
+  rw [htime]
+  exact (ENNReal.ofReal_le_ofReal hval.le).trans (ENNReal.ofReal_toReal_le.trans hmass)
+
+end SLEExactGauge.Multipoint
+
+end
+
+end OAI
diff --git a/lean/OAI/Probability/SLE/Geometry/FinitePastEvents.lean b/lean/OAI/Probability/SLE/Geometry/FinitePastEvents.lean
new file mode 100644
index 0000000000000000000000000000000000000000..b28d077e300dc1431b5499aa43931975bbc7185b
--- /dev/null
+++ b/lean/OAI/Probability/SLE/Geometry/FinitePastEvents.lean
@@ -0,0 +1,65 @@
+import OAI.Probability.SLE.Geometry.FirstSuccessfulPast
+
+namespace OAI
+
+/-! First-success partition for finite tests strictly before an extended time. -/
+
+noncomputable section
+open Set Filter _root_.MeasureTheory _root_.OAI.MeasureTheory ProbabilityTheory
+open scoped Topology NNReal ENNReal
+attribute [local instance] Classical.propDecidable
+
+namespace SLEExactGauge.Multipoint
+
+variable {Ω : Type*}
+
+def finiteStrictPastEvent (I : Finset ℝ≥0) (E : ℝ≥0 → Set Ω)
+    (T : Ω → ℝ≥0∞) : Set Ω :=
+  ⋃ t∈I, E t ∩ {ω | (t : ℝ≥0∞) < T ω}
+
+lemma finiteStrictPastEvent_first (I : Finset ℝ≥0) (E : ℝ≥0 → Set Ω)
+    (T : Ω → ℝ≥0∞) :
+    finiteStrictPastEvent I E T =
+      ⋃ t∈I, firstPastSuccess I E t ∩ {ω | (t : ℝ≥0∞) < T ω} := by
+  ext ω
+  constructor
+  · intro h
+    obtain ⟨t,ht,hEt,hT⟩ := mem_iUnion₂.mp h
+    obtain ⟨s,hs,hEs,hst⟩ := exists_firstPastSuccess I E ω ⟨t,ht,hEt⟩
+    exact mem_iUnion₂.mpr ⟨s,hs,hEs,(ENNReal.coe_le_coe.mpr (hst t ht hEt)).trans_lt hT⟩
+  · intro h
+    obtain ⟨t,ht,hEt,hT⟩ := mem_iUnion₂.mp h
+    exact mem_iUnion₂.mpr ⟨t,ht,((mem_firstPastSuccess_iff I E t ω).mp hEt).1,hT⟩
+
+lemma finiteStrictPastEvent_mono (I : Finset ℝ≥0) (E : ℝ≥0 → Set Ω)
+    {S T : Ω → ℝ≥0∞} (h : S ≤ T) :
+    finiteStrictPastEvent I E S ⊆ finiteStrictPastEvent I E T := by
+  intro ω hω
+  obtain ⟨t,ht,hEt,hT⟩ := mem_iUnion₂.mp hω
+  exact mem_iUnion₂.mpr ⟨t,ht,hEt,hT.trans_le (h ω)⟩
+
+lemma finiteStrictPastEvent_measurable [MeasurableSpace Ω]
+    (I : Finset ℝ≥0) (E : ℝ≥0 → Set Ω) (hE : ∀ t∈I, MeasurableSet (E t))
+    (T : Ω → ℝ≥0∞) (hT : Measurable T) : MeasurableSet (finiteStrictPastEvent I E T) :=
+  Finset.measurableSet_biUnion I (fun t ht => (hE t ht).inter
+    (measurableSet_lt measurable_const hT))
+
+lemma finiteStrictPastEvent_measure [mΩ : MeasurableSpace Ω]
+    (Q : Measure Ω) (ℱ : Filtration ℝ≥0 mΩ) (I : Finset ℝ≥0) (E : ℝ≥0 → Set Ω)
+    (hE : ∀ t∈I, MeasurableSet[ℱ t] (E t))
+    (T : Ω → ℝ≥0∞) (hT : Measurable T) :
+    Q (finiteStrictPastEvent I E T) =
+      ∑ t∈I, Q (firstPastSuccess I E t ∩ {ω | (t : ℝ≥0∞) < T ω}) := by
+  rw [finiteStrictPastEvent_first]
+  apply measure_biUnion_finset
+  · intro s hs t ht hne
+    exact (firstPastSuccess_disjoint I E hs ht hne).mono inter_subset_left inter_subset_left
+  · intro t ht
+    exact ((ℱ.le t) _ (firstPastSuccess_measurable ℱ I E hE ht)).inter
+      (measurableSet_lt measurable_const hT)
+
+end SLEExactGauge.Multipoint
+
+end
+
+end OAI
diff --git a/lean/OAI/Probability/SLE/Geometry/FinitePastKernel.lean b/lean/OAI/Probability/SLE/Geometry/FinitePastKernel.lean
new file mode 100644
index 0000000000000000000000000000000000000000..dd71cc0368af7a8e1bb81d3e32b5573818a2d806
--- /dev/null
+++ b/lean/OAI/Probability/SLE/Geometry/FinitePastKernel.lean
@@ -0,0 +1,74 @@
+import OAI.Probability.SLE.Geometry.FiniteCenteredPast
+import OAI.Probability.SLE.Geometry.FinitePastEvents
+
+namespace OAI
+
+/-! Finite strict past events under a single finite centered law. -/
+
+noncomputable section
+open Set Filter _root_.MeasureTheory _root_.OAI.MeasureTheory ProbabilityTheory
+open scoped Topology NNReal ENNReal
+attribute [local instance] Classical.propDecidable
+
+namespace SLEExactGauge.Multipoint
+
+variable {Ω : Type*} [mΩ : MeasurableSpace Ω] {P : Measure Ω}
+  {κ : ℝ} {B : ℝ≥0 → Ω → ℝ}
+  (hB : IsBrownianReal B P) (hBm : Measurable (Function.uncurry B))
+  (hc : ∀ ω, Continuous (fun t => B t ω)) (h0 : ∀ ω, B 0 ω = 0)
+  (hκ : 0 < κ) (hκ8 : κ < 8)
+  (γ : Ω → ℝ≥0 → ℂ) (G F : Ω → ℝ≥0 → ℂ → ℂ)
+  (hw : ∀ ω, IsCapacityTwoWitness (fun t => Real.sqrt κ * B t ω) (γ ω) (G ω) (F ω))
+
+include hB hBm hc h0 hκ hκ8 γ G F hw
+
+lemma finiteCenteredLaw_tests (z : ℂ) (hz : z ∈ upperHalfPlane)
+    (u : ℝ) (hu : 0 ≤ u) (I : Finset ℝ≥0) (E : ℝ≥0 → Set Ω)
+    (hE : ∀ t∈I, MeasurableSet[(Filtration.natural B (fun s =>
+      (hBm.comp (measurable_const.prodMk measurable_id) : Measurable (B s)).stronglyMeasurable)) t] (E t)) :
+    ENNReal.ofReal (initialGreen κ z) * finiteCenteredLaw P κ B γ G z u
+      (finiteStrictPastEvent I E (fun ω => radiusLevelTime (γ ω) (G ω) z u)) =
+      ∑ t∈I, ∫⁻ ω in firstPastSuccess I E t,
+        ENNReal.ofReal (levelCurrentGreen κ B γ G u t z ω) ∂P := by
+  let ℱ := Filtration.natural B (fun s =>
+    (hBm.comp (measurable_const.prodMk measurable_id) : Measurable (B s)).stronglyMeasurable)
+  have hm (s : ℝ≥0) : Measurable (B s) := hBm.comp (measurable_const.prodMk measurable_id)
+  have hp : Measurable (fun ω : Ω => (ω,z)) := measurable_id.prodMk measurable_const
+  have hj := (actual_radiusLevel_joint_measurable hm hc κ u hu γ G F hw).comp hp
+  have hT : Measurable (fun ω => radiusLevelTime (γ ω) (G ω) z u) := by
+    simpa only [Function.comp_def] using hj
+  rw [finiteStrictPastEvent_measure _ ℱ I E hE _ hT, Finset.mul_sum]
+  apply Finset.sum_congr rfl
+  intro t ht
+  exact finiteCenteredLaw_strict_past hB hBm hc h0 hκ hκ8 γ G F hw z hz u hu t _
+    (firstPastSuccess_measurable ℱ I E hE ht)
+
+lemma finiteCenteredLaw_tests_tendsto (z : ℂ) (hz : z ∈ upperHalfPlane)
+    (u : ℕ → ℝ) (hu : ∀ n, 0 ≤ u n) (hmono : Monotone u)
+    (hlim : Tendsto u atTop atTop) (I : Finset ℝ≥0) (E : ℝ≥0 → Set Ω)
+    (hE : ∀ t∈I, MeasurableSet[(Filtration.natural B (fun s =>
+      (hBm.comp (measurable_const.prodMk measurable_id) : Measurable (B s)).stronglyMeasurable)) t] (E t)) :
+    Tendsto (fun n => ENNReal.ofReal (initialGreen κ z) *
+      finiteCenteredLaw P κ B γ G z (u n)
+        (finiteStrictPastEvent I E (fun ω => radiusLevelTime (γ ω) (G ω) z (u n)))) atTop
+      (𝓝 (∑ t∈I, ∫⁻ ω in firstPastSuccess I E t,
+        ENNReal.ofReal (greenDensity κ (fun s => Real.sqrt κ * B s ω) (γ ω) (G ω) t z) ∂P)) := by
+  let ℱ := Filtration.natural B (fun s =>
+    (hBm.comp (measurable_const.prodMk measurable_id) : Measurable (B s)).stronglyMeasurable)
+  have h := tendsto_finsetSum I (fun t ht =>
+    finiteCenteredLaw_strict_past_tendsto hB hBm hc h0 hκ hκ8 γ G F hw z hz u hu hmono hlim t
+      (firstPastSuccess I E t) (firstPastSuccess_measurable ℱ I E hE ht))
+  simp only [← Finset.mul_sum] at h
+  apply h.congr'
+  filter_upwards [] with n
+  rw [finiteStrictPastEvent_measure _ ℱ I E hE]
+  have hm (s : ℝ≥0) : Measurable (B s) := hBm.comp (measurable_const.prodMk measurable_id)
+  have hp : Measurable (fun ω : Ω => (ω,z)) := measurable_id.prodMk measurable_const
+  have hj := (actual_radiusLevel_joint_measurable hm hc κ (u n) (hu n) γ G F hw).comp hp
+  simpa only [Function.comp_def] using hj
+
+end SLEExactGauge.Multipoint
+
+end
+
+end OAI
diff --git a/lean/OAI/Probability/SLE/Geometry/FinitePastTrivialBound.lean b/lean/OAI/Probability/SLE/Geometry/FinitePastTrivialBound.lean
new file mode 100644
index 0000000000000000000000000000000000000000..2834e4b16a8434e6605b4b48b1c07504c1811cee
--- /dev/null
+++ b/lean/OAI/Probability/SLE/Geometry/FinitePastTrivialBound.lean
@@ -0,0 +1,48 @@
+import OAI.Probability.SLE.Gauge.CanonicalGridLower
+
+namespace OAI
+
+/-! The finite centered laws give the unit bound for every early cell test. -/
+
+noncomputable section
+open Set Filter _root_.MeasureTheory _root_.OAI.MeasureTheory ProbabilityTheory
+open scoped Topology NNReal ENNReal
+
+namespace SLEExactGauge.Multipoint.CanonicalMass
+
+variable {Ω : Type*} [MeasurableSpace Ω] {P : Measure Ω} [IsProbabilityMeasure P]
+  {κ : ℝ} {B : ℝ≥0 → Ω → ℝ} {hBm : Measurable (Function.uncurry B)}
+  {γ : Ω → ℝ≥0 → ℂ} {G : Ω → ℝ≥0 → ℂ → ℂ}
+  (C : CanonicalMass P κ B hBm γ G)
+
+def compactFinitePastTest (K : Set upperHalfPlane) (H : ℝ) (J : Finset ℝ≥0) (u : ℝ) : ℝ≥0∞ :=
+  ∫⁻ x in (Subtype.val : upperHalfPlane → ℂ) '' K,
+    ENNReal.ofReal (initialGreen κ x) * finiteCenteredLaw P κ B γ G x u
+      (finiteStrictPastEvent J (fun t => {ω | H < (C.process t ω K).toReal})
+        (fun ω => radiusLevelTime (γ ω) (G ω) x u)) ∂volume
+
+lemma compactFinitePastTest_le_initial
+    (hB : IsBrownianReal B P) (hκ : 0<κ) (hκ8 : κ<8) (F : Ω → ℝ≥0 → ℂ → ℂ)
+    (hw : ∀ ω, IsCapacityTwoWitness (fun t => Real.sqrt κ*B t ω) (γ ω) (G ω) (F ω))
+    (K : Set upperHalfPlane) (hK : IsCompact K) (H : ℝ) (J : Finset ℝ≥0)
+    (u : ℝ) (hu : 0≤u) : C.compactFinitePastTest K H J u ≤ initialGreenMeasure κ K := by
+  have hKI := (hK.image continuous_subtype_val).measurableSet
+  rw [initialGreenMeasure,comap_subtype_coe_apply isOpen_upperHalfPlane.measurableSet,
+    withDensity_apply _ hKI]
+  apply setLIntegral_mono' hKI
+  rintro x ⟨z,_,rfl⟩
+  let := finiteCenteredLaw_probability hB κ hκ hκ8 γ G F (Eventually.of_forall hw)
+    (z:ℂ) z.property u hu
+  have hQ : finiteCenteredLaw P κ B γ G (z:ℂ) u
+      (finiteStrictPastEvent J (fun t => {ω | H < (C.process t ω K).toReal})
+        (fun ω => radiusLevelTime (γ ω) (G ω) (z:ℂ) u)) ≤ 1 := by
+    calc
+      _ ≤ finiteCenteredLaw P κ B γ G (z:ℂ) u univ := measure_mono (subset_univ _)
+      _ = 1 := measure_univ
+  simpa only [mul_one] using mul_le_mul' (le_refl (ENNReal.ofReal (initialGreen κ z))) hQ
+
+end SLEExactGauge.Multipoint.CanonicalMass
+
+end
+
+end OAI
diff --git a/lean/OAI/Probability/SLE/Geometry/FiniteSimpleSlit.lean b/lean/OAI/Probability/SLE/Geometry/FiniteSimpleSlit.lean
new file mode 100644
index 0000000000000000000000000000000000000000..adc4d3c4abb31ef9f983df32c6741460cd124758
--- /dev/null
+++ b/lean/OAI/Probability/SLE/Geometry/FiniteSimpleSlit.lean
@@ -0,0 +1,57 @@
+import OAI.Probability.SLE.Geometry.SimpleArcComplement
+
+namespace OAI
+
+/-! The finite trace of a simple interior slit has no swallowed points
+away from the slit itself. -/
+noncomputable section
+open Set Filter Function
+open scoped Topology NNReal
+
+namespace SLEExactGauge
+
+theorem finite_simple_slit_free
+    (γ : ℝ≥0 → ℂ) (hc : Continuous γ) (h0 : γ 0=0)
+    (T : ℝ≥0) (hT : 0 < T) (hi : InjOn γ (Icc 0 T))
+    (hH : ∀ t ∈ Ioc 0 T, γ t ∈ upperHalfPlane) :
+    upperHalfPlane \ (γ '' Icc 0 T) ⊆ survivingDomain γ T := by
+  let v (u : unitInterval) : ℝ≥0 := ⟨u,u.property.1⟩
+  have hv : Continuous v := continuous_subtype_val.subtype_mk _
+  let p : C(unitInterval,ℂ) := ⟨fun u => γ (T*v u),hc.comp (continuous_const.mul hv)⟩
+  have hv1 (u : unitInterval) : v u ≤ 1 := u.property.2
+  have ht (u : unitInterval) : T*v u ∈ Icc 0 T :=
+    ⟨zero_le,by simpa only [mul_one] using mul_le_mul_of_nonneg_left (hv1 u) zero_le⟩
+  have hp : Injective p := by
+    intro u w he
+    have heq := hi (ht u) (ht w) he
+    have heq' := mul_left_cancel₀ hT.ne' heq
+    apply Subtype.ext
+    exact congrArg (fun x : ℝ≥0 => (x : ℝ)) heq'
+  have hv0 : v 0=0 := Subtype.ext rfl
+  have hp0 : p 0=0 := by change γ (T*v 0)=0; rw [hv0,mul_zero,h0]
+  have hpH (u : unitInterval) (hu : u ≠ 0) : p u ∈ upperHalfPlane := by
+    apply hH _ ⟨mul_pos hT ?_,(ht u).2⟩
+    change 0 < (u : ℝ)
+    exact lt_of_le_of_ne u.property.1 (fun he => hu (Subtype.ext he.symm))
+  have hrange : range p=γ '' Icc 0 T := by
+    apply Subset.antisymm
+    · rintro _ ⟨u,rfl⟩
+      exact ⟨T*v u,ht u,rfl⟩
+    · rintro _ ⟨t,ht',rfl⟩
+      let u : unitInterval := ⟨(t/T : ℝ≥0),
+        (t/T).coe_nonneg,by exact_mod_cast (div_le_one hT).mpr ht'.2⟩
+      refine ⟨u,?_⟩
+      change γ (T*v u)=γ t
+      congr 1
+      change T*(t/T)=t
+      exact mul_div_cancel₀ _ hT.ne'
+  intro z hz
+  refine ⟨hz,?_⟩
+  rw [← hrange]
+  exact simple_arc_halfPlane_component_unbounded p hp hp0 hpH (hrange.symm ▸ hz)
+
+end SLEExactGauge
+
+end
+
+end OAI
diff --git a/lean/OAI/Probability/SLE/Geometry/FiniteStopSorting.lean b/lean/OAI/Probability/SLE/Geometry/FiniteStopSorting.lean
new file mode 100644
index 0000000000000000000000000000000000000000..db480a4802696d75ca92501b4c041d6c75952935
--- /dev/null
+++ b/lean/OAI/Probability/SLE/Geometry/FiniteStopSorting.lean
@@ -0,0 +1,210 @@
+import Mathlib
+
+namespace OAI
+
+/-! A finite min/max sorting network for bounded stopping times. Unlike
+sorting sampled values by a sample-dependent permutation, every output
+is directly a stopping time. Ties and simultaneous switches are kept. -/
+
+noncomputable section
+open Set MeasureTheory
+open scoped NNReal
+
+namespace SLEExactGauge.Multipoint
+
+def insertStop {Ω : Type*} (σ : Ω → ℝ≥0) : List (Ω → ℝ≥0) → List (Ω → ℝ≥0)
+  | [] => [σ]
+  | τ :: l => (fun ω => min (σ ω) (τ ω)) ::
+      insertStop (fun ω => max (σ ω) (τ ω)) l
+
+def sortStops {Ω : Type*} : List (Ω → ℝ≥0) → List (Ω → ℝ≥0)
+  | [] => []
+  | σ :: l => insertStop σ (sortStops l)
+
+@[simp] lemma insertStop_length {Ω : Type*} (σ : Ω → ℝ≥0) (l : List (Ω → ℝ≥0)) :
+    (insertStop σ l).length = l.length + 1 := by
+  induction l generalizing σ with
+  | nil => simp [insertStop]
+  | cons τ l ih => simp [insertStop, ih]
+
+@[simp] lemma sortStops_length {Ω : Type*} (l : List (Ω → ℝ≥0)) :
+    (sortStops l).length = l.length := by
+  induction l with
+  | nil => rfl
+  | cons σ l ih => simp [sortStops, ih]
+
+lemma insertStop_lower_bound {Ω : Type*} (l : List (Ω → ℝ≥0)) (ω : Ω)
+    (a : ℝ≥0) (σ : Ω → ℝ≥0) (hσ : a ≤ σ ω)
+    (hl : ∀ τ ∈ l, a ≤ τ ω) : ∀ τ ∈ insertStop σ l, a ≤ τ ω := by
+  induction l generalizing σ with
+  | nil =>
+    intro τ hτ
+    have he : τ = σ := List.mem_singleton.mp hτ
+    subst τ
+    exact hσ
+  | cons ρ l ih =>
+    intro τ hτ
+    rcases List.mem_cons.mp hτ with rfl | hτ
+    · exact le_min hσ (hl ρ (List.mem_cons_self ..))
+    · exact ih _ (hσ.trans (le_max_left _ _))
+        (fun η hη => hl η (List.mem_cons_of_mem _ hη)) τ hτ
+
+lemma insertStop_ordered {Ω : Type*} (l : List (Ω → ℝ≥0)) (ω : Ω)
+    (hl : l.Pairwise (fun σ τ => σ ω ≤ τ ω)) (σ : Ω → ℝ≥0) :
+    (insertStop σ l).Pairwise (fun σ τ => σ ω ≤ τ ω) := by
+  induction l generalizing σ with
+  | nil => simp [insertStop]
+  | cons ρ l ih =>
+    obtain ⟨hρ, hl⟩ := List.pairwise_cons.mp hl
+    apply List.pairwise_cons.mpr
+    refine ⟨?_, ih hl _⟩
+    exact insertStop_lower_bound l ω (min (σ ω) (ρ ω)) _
+      ((min_le_left _ _).trans (le_max_left _ _))
+      (fun η hη => (min_le_right _ _).trans (hρ η hη))
+
+theorem sortStops_ordered {Ω : Type*} (l : List (Ω → ℝ≥0)) (ω : Ω) :
+    (sortStops l).Pairwise (fun σ τ => σ ω ≤ τ ω) := by
+  induction l with
+  | nil => simp [sortStops]
+  | cons σ l ih => exact insertStop_ordered (sortStops l) ω ih σ
+
+lemma insertStop_permutation {Ω : Type*} (l : List (Ω → ℝ≥0)) (ω : Ω)
+    (σ : Ω → ℝ≥0) :
+    ((insertStop σ l).map (fun τ => τ ω)).Perm (σ ω :: l.map (fun τ => τ ω)) := by
+  induction l generalizing σ with
+  | nil => simp [insertStop]
+  | cons ρ l ih =>
+    change (min (σ ω) (ρ ω) ::
+      (insertStop (fun ω => max (σ ω) (ρ ω)) l).map (fun τ => τ ω)).Perm _
+    apply ((ih (fun ω => max (σ ω) (ρ ω))).cons (min (σ ω) (ρ ω))).trans
+    rcases le_total (σ ω) (ρ ω) with h | h
+    · simp only [min_eq_left h, max_eq_right h, List.map_cons]
+      exact List.Perm.refl _
+    · simp only [min_eq_right h, max_eq_left h, List.map_cons]
+      exact List.Perm.swap _ _ _
+
+theorem sortStops_permutation {Ω : Type*} (l : List (Ω → ℝ≥0)) (ω : Ω) :
+    ((sortStops l).map (fun τ => τ ω)).Perm (l.map (fun τ => τ ω)) := by
+  induction l with
+  | nil => simp [sortStops]
+  | cons σ l ih =>
+    exact (insertStop_permutation (sortStops l) ω σ).trans (ih.cons (σ ω))
+
+lemma insertStop_bounded {Ω : Type*} (l : List (Ω → ℝ≥0)) (H : ℝ≥0)
+    (σ : Ω → ℝ≥0) (hσ : ∀ ω, σ ω ≤ H)
+    (hl : ∀ τ ∈ l, ∀ ω, τ ω ≤ H) : ∀ τ ∈ insertStop σ l, ∀ ω, τ ω ≤ H := by
+  induction l generalizing σ with
+  | nil =>
+    intro τ hτ
+    have he : τ = σ := List.mem_singleton.mp hτ
+    subst τ
+    exact hσ
+  | cons ρ l ih =>
+    intro τ hτ ω
+    rcases List.mem_cons.mp hτ with rfl | hτ
+    · exact (min_le_left _ _).trans (hσ ω)
+    · exact ih _ (fun ω => max_le (hσ ω) (hl ρ (List.mem_cons_self ..) ω))
+        (fun η hη => hl η (List.mem_cons_of_mem _ hη)) τ hτ ω
+
+theorem sortStops_bounded {Ω : Type*} (l : List (Ω → ℝ≥0)) (H : ℝ≥0)
+    (hl : ∀ τ ∈ l, ∀ ω, τ ω ≤ H) : ∀ τ ∈ sortStops l, ∀ ω, τ ω ≤ H := by
+  induction l with
+  | nil => simp [sortStops]
+  | cons σ l ih =>
+    apply insertStop_bounded (sortStops l) H σ (hl σ (List.mem_cons_self ..))
+    exact ih (fun τ hτ => hl τ (List.mem_cons_of_mem _ hτ))
+
+lemma insertStop_stopping {Ω : Type*} [mΩ : MeasurableSpace Ω]
+    (ℱ : Filtration ℝ≥0 mΩ) (l : List (Ω → ℝ≥0)) (σ : Ω → ℝ≥0)
+    (hσ : IsStoppingTime ℱ (fun ω => (σ ω : WithTop ℝ≥0)))
+    (hl : ∀ τ ∈ l, IsStoppingTime ℱ (fun ω => (τ ω : WithTop ℝ≥0))) :
+    ∀ τ ∈ insertStop σ l, IsStoppingTime ℱ (fun ω => (τ ω : WithTop ℝ≥0)) := by
+  induction l generalizing σ with
+  | nil =>
+    intro τ hτ
+    have he : τ = σ := List.mem_singleton.mp hτ
+    subst τ
+    exact hσ
+  | cons ρ l ih =>
+    intro τ hτ
+    have hρ := hl ρ (List.mem_cons_self ..)
+    rcases List.mem_cons.mp hτ with rfl | hτ
+    · simpa only [WithTop.coe_min] using hσ.min hρ
+    · apply ih _ _ (fun η hη => hl η (List.mem_cons_of_mem _ hη)) τ hτ
+      simpa only [WithTop.coe_max] using hσ.max hρ
+
+theorem sortStops_stopping {Ω : Type*} [mΩ : MeasurableSpace Ω]
+    (ℱ : Filtration ℝ≥0 mΩ) (l : List (Ω → ℝ≥0))
+    (hl : ∀ τ ∈ l, IsStoppingTime ℱ (fun ω => (τ ω : WithTop ℝ≥0))) :
+    ∀ τ ∈ sortStops l, IsStoppingTime ℱ (fun ω => (τ ω : WithTop ℝ≥0)) := by
+  induction l with
+  | nil => simp [sortStops]
+  | cons σ l ih =>
+    apply insertStop_stopping ℱ (sortStops l) σ (hl σ (List.mem_cons_self ..))
+    exact ih (fun τ hτ => hl τ (List.mem_cons_of_mem _ hτ))
+
+def sortedStopAt {Ω : Type*} (l : List (Ω → ℝ≥0)) (H : ℝ≥0) (n : ℕ) : Ω → ℝ≥0 :=
+  (sortStops l).getD n (fun _ => H)
+
+theorem sortedStopAt_stopping {Ω : Type*} [mΩ : MeasurableSpace Ω]
+    (ℱ : Filtration ℝ≥0 mΩ) (l : List (Ω → ℝ≥0))
+    (hl : ∀ τ ∈ l, IsStoppingTime ℱ (fun ω => (τ ω : WithTop ℝ≥0)))
+    (H : ℝ≥0) (n : ℕ) : IsStoppingTime ℱ (fun ω => (sortedStopAt l H n ω : WithTop ℝ≥0)) := by
+  by_cases hn : n < (sortStops l).length
+  · rw [sortedStopAt, List.getD_eq_getElem _ _ hn]
+    exact sortStops_stopping ℱ l hl _ (List.getElem_mem hn)
+  · rw [sortedStopAt, List.getD_eq_default _ _ (Nat.le_of_not_gt hn)]
+    exact isStoppingTime_const ℱ H
+
+theorem sortedStopAt_bounded {Ω : Type*} (l : List (Ω → ℝ≥0)) (H : ℝ≥0)
+    (hl : ∀ τ ∈ l, ∀ ω, τ ω ≤ H) (n : ℕ) (ω : Ω) : sortedStopAt l H n ω ≤ H := by
+  by_cases hn : n < (sortStops l).length
+  · rw [sortedStopAt, List.getD_eq_getElem _ _ hn]
+    exact sortStops_bounded l H hl _ (List.getElem_mem hn) ω
+  · rw [sortedStopAt, List.getD_eq_default _ _ (Nat.le_of_not_gt hn)]
+
+theorem sortedStopAt_monotone {Ω : Type*} (l : List (Ω → ℝ≥0)) (H : ℝ≥0)
+    (hl : ∀ τ ∈ l, ∀ ω, τ ω ≤ H) (ω : Ω) : Monotone (fun n => sortedStopAt l H n ω) := by
+  intro i j hij
+  by_cases hj : j < (sortStops l).length
+  · have hi : i < (sortStops l).length := hij.trans_lt hj
+    rcases eq_or_lt_of_le hij with rfl | hij
+    · exact le_rfl
+    · have h := (sortStops_ordered l ω).rel_get_of_lt
+        (a := ⟨i, hi⟩) (b := ⟨j, hj⟩) hij
+      simpa only [sortedStopAt, List.getD_eq_get _ _ ⟨i, hi⟩,
+        List.getD_eq_get _ _ ⟨j, hj⟩] using h
+  · have he : sortedStopAt l H j = fun _ => H :=
+      List.getD_eq_default _ _ (Nat.le_of_not_gt hj)
+    change sortedStopAt l H i ω ≤ sortedStopAt l H j ω
+    rw [he]
+    exact sortedStopAt_bounded l H hl i ω
+
+@[simp] theorem sortedStopAt_length {Ω : Type*} (l : List (Ω → ℝ≥0)) (H : ℝ≥0) :
+    sortedStopAt l H l.length = fun _ => H := by
+  exact List.getD_eq_default _ _ (by simp)
+
+/-- Every original switch occurs in the sorted sequence, including ties. -/
+theorem sortedStopAt_covers {Ω : Type*} (l : List (Ω → ℝ≥0)) (H : ℝ≥0)
+    (σ : Ω → ℝ≥0) (hσ : σ ∈ l) (ω : Ω) :
+    ∃ n < l.length, sortedStopAt l H n ω = σ ω := by
+  have hmem : σ ω ∈ (sortStops l).map (fun τ => τ ω) :=
+    (sortStops_permutation l ω).mem_iff.mpr (List.mem_map_of_mem hσ)
+  obtain ⟨τ, hτ, he⟩ := List.mem_map.mp hmem
+  obtain ⟨i, hi⟩ := List.mem_iff_get.mp hτ
+  refine ⟨i, by simpa only [sortStops_length] using i.isLt, ?_⟩
+  rw [sortedStopAt, List.getD_eq_get _ _ i, hi, he]
+
+theorem sortedStopAt_zero {Ω : Type*} (l : List (Ω → ℝ≥0)) (H : ℝ≥0)
+    (hl : ∀ τ ∈ l, ∀ ω, τ ω ≤ H) (hzero : (fun _ : Ω => (0 : ℝ≥0)) ∈ l)
+    (ω : Ω) : sortedStopAt l H 0 ω = 0 := by
+  obtain ⟨n, _, hn⟩ := sortedStopAt_covers l H (fun _ => 0) hzero ω
+  apply le_antisymm _ (show 0 ≤ sortedStopAt l H 0 ω from bot_le)
+  have h := sortedStopAt_monotone l H hl ω (Nat.zero_le n)
+  exact h.trans_eq hn
+
+end SLEExactGauge.Multipoint
+
+end
+
+end OAI
diff --git a/lean/OAI/Probability/SLE/Geometry/FiniteStoppedScalar.lean b/lean/OAI/Probability/SLE/Geometry/FiniteStoppedScalar.lean
new file mode 100644
index 0000000000000000000000000000000000000000..5c117e51a631ffe15ca69112768af0d4067173b4
--- /dev/null
+++ b/lean/OAI/Probability/SLE/Geometry/FiniteStoppedScalar.lean
@@ -0,0 +1,79 @@
+import OAI.Probability.SLE.Stochastic.ProgressiveStoppedTime
+import OAI.Probability.SLE.Geometry.ExtendedStopLocalization
+
+namespace OAI
+
+/-! A progressive scalar evaluated at a possibly infinite stop, with zero
+on the infinite event, is measurable in the original stopped past. -/
+
+noncomputable section
+open Set Filter _root_.MeasureTheory _root_.OAI.MeasureTheory
+open scoped NNReal ENNReal Topology
+
+namespace SLEExactGauge
+
+def finiteStoppedScalar {Ω : Type*} (A : ℝ≥0 → Ω → ℝ)
+    (S : Ω → WithTop ℝ≥0) (ω : Ω) : ℝ :=
+  if S ω=⊤ then 0 else A ((S ω).untopD 0) ω
+
+lemma finiteStoppedScalar_measurable
+    {Ω : Type*} [mΩ : MeasurableSpace Ω]
+    (ℱ : Filtration ℝ≥0 mΩ) (A : ℝ≥0 → Ω → ℝ) (hA : IsProgressive ℱ A)
+    (S : Ω → WithTop ℝ≥0) (hS : IsStoppingTime ℱ S) :
+    Measurable[hS.measurableSpace] (finiteStoppedScalar A S) := by
+  let X := fun n : ℕ => (finiteStopEvent S n).indicator (fun ω => A (cutoffStop S n ω) ω)
+  have hm (n : ℕ) : Measurable[hS.measurableSpace] (X n) := by
+    have hh := _root_.OAI.MeasureTheory.IsProgressive.stopped_time_measurable hA (cutoffStop S n) (cutoffStop_stopping ℱ S hS n)
+    exact (hh.mono (cutoffStop_past_le ℱ S hS n) le_rfl).indicator
+      (finiteStopEvent_measurable ℱ S hS n)
+  apply @measurable_of_tendsto_metrizable Ω ℝ hS.measurableSpace _ _ _ _ X (finiteStoppedScalar A S) hm
+  apply tendsto_pi_nhds.mpr
+  intro ω
+  by_cases hs : S ω=⊤
+  · have he (n : ℕ) : X n ω=0 := by simp [X,finiteStopEvent,hs]
+    simpa only [he,finiteStoppedScalar,hs,ite_true] using
+      (tendsto_const_nhds : Tendsto (fun _ : ℕ => (0:ℝ)) atTop (𝓝 0))
+  · have hf : S ω<⊤ := lt_top_iff_ne_top.mpr hs
+    have hmemb : ω∈⋃ n, finiteStopEvent S n := by rw [iUnion_finiteStopEvent]; exact hf
+    obtain ⟨n,hn⟩ := mem_iUnion.mp hmemb
+    apply tendsto_const_nhds.congr'
+    filter_upwards [eventually_ge_atTop n,cutoffStop_eventually_eq S ω hf] with k hk he
+    simp only [finiteStoppedScalar,hs,ite_false,X,
+      indicator_of_mem (finiteStopEvent_mono S hk hn),he]
+
+lemma integral_eq_of_stopped_events
+    {Ω : Type*} [mΩ : MeasurableSpace Ω]
+    (P Q : Measure Ω) (m : MeasurableSpace Ω) (hm : m ≤ mΩ)
+    (he : ∀ E, MeasurableSet[m] E → P E=Q E)
+    (X : Ω → ℝ) (hX : Measurable[m] X) :
+    (∫ ω, X ω ∂P)=(∫ ω, X ω ∂Q) := by
+  have htrim : P.trim hm=Q.trim hm := by
+    ext E hE
+    rw [trim_measurableSet_eq hm hE,trim_measurableSet_eq hm hE]
+    exact he E hE
+  calc
+    (∫ ω, X ω ∂P) = (∫ ω, X ω ∂P.trim hm) :=
+      integral_trim hm hX.stronglyMeasurable
+    _ = (∫ ω, X ω ∂Q.trim hm) := by rw [htrim]
+    _ = _ := (integral_trim hm hX.stronglyMeasurable).symm
+
+lemma lintegral_eq_of_stopped_events
+    {Ω : Type*} [mΩ : MeasurableSpace Ω]
+    (P Q : Measure Ω) (m : MeasurableSpace Ω) (hm : m ≤ mΩ)
+    (he : ∀ E, MeasurableSet[m] E → P E=Q E)
+    (X : Ω → ℝ≥0∞) (hX : Measurable[m] X) :
+    (∫⁻ ω, X ω ∂P)=(∫⁻ ω, X ω ∂Q) := by
+  have htrim : P.trim hm=Q.trim hm := by
+    ext E hE
+    rw [trim_measurableSet_eq hm hE,trim_measurableSet_eq hm hE]
+    exact he E hE
+  calc
+    (∫⁻ ω, X ω ∂P) = (∫⁻ ω, X ω ∂P.trim hm) := (lintegral_trim hm hX).symm
+    _ = (∫⁻ ω, X ω ∂Q.trim hm) := by rw [htrim]
+    _ = _ := lintegral_trim hm hX
+
+end SLEExactGauge
+
+end
+
+end OAI
diff --git a/lean/OAI/Probability/SLE/Geometry/FiniteTraceTopology.lean b/lean/OAI/Probability/SLE/Geometry/FiniteTraceTopology.lean
new file mode 100644
index 0000000000000000000000000000000000000000..e77f63976f7744890074f2ad27e550e1cf58ea8f
--- /dev/null
+++ b/lean/OAI/Probability/SLE/Geometry/FiniteTraceTopology.lean
@@ -0,0 +1,48 @@
+import OAI.Probability.SLE.LoewnerCharts
+import Mathlib.Topology.Order.ProjIcc
+
+namespace OAI
+
+/-! The finite trace is a locally connected compact continuum, supplying
+ the boundary geometry needed for continuous inverse extensions. -/
+noncomputable section
+open Set Filter Metric Function
+open scoped Topology NNReal
+
+namespace SLEExactGauge
+
+lemma finiteTrace_locallyConnected {γ : ℝ≥0 → ℂ} (hγ : Continuous γ) (T : ℝ≥0) :
+    LocallyConnectedSpace (γ '' Icc 0 T) := by
+  have : LocallyConnectedSpace (Icc (0:ℝ) (T:ℝ)) :=
+    (isQuotientMap_projIcc (a := (0:ℝ)) (b := (T:ℝ)) (h := T.coe_nonneg)).isCoinducing.locallyConnectedSpace
+  let p : Icc (0:ℝ) (T:ℝ) → γ '' Icc 0 T := fun t =>
+    ⟨γ t.1.toNNReal,⟨t.1.toNNReal,⟨by simp,(Real.toNNReal_le_iff_le_coe).mpr t.2.2⟩,rfl⟩⟩
+  have hp : Continuous p := (hγ.comp (continuous_real_toNNReal.comp continuous_subtype_val)).subtype_mk _
+  have hs : Surjective p := by
+    rintro ⟨z,t,ht,rfl⟩
+    refine ⟨⟨t,⟨t.coe_nonneg,by exact_mod_cast ht.2⟩⟩,?_⟩
+    apply Subtype.ext
+    simp [p]
+  exact (hp.isClosedMap.isQuotientMap hp hs).isCoinducing.locallyConnectedSpace
+
+lemma finiteTrace_isCompact {γ : ℝ≥0 → ℂ} (hγ : Continuous γ) (T : ℝ≥0) :
+    IsCompact (γ '' Icc 0 T) := isCompact_Icc.image hγ
+
+lemma finiteTrace_isConnected {γ : ℝ≥0 → ℂ} (hγ : Continuous γ) (T : ℝ≥0) :
+    IsConnected (γ '' Icc 0 T) :=
+  (isConnected_Icc (show (0:ℝ≥0)≤T from bot_le)).image γ hγ.continuousOn
+
+lemma finiteTrace_small_connected_neighborhood {γ : ℝ≥0 → ℂ} (hγ : Continuous γ)
+    (T : ℝ≥0) (z : γ '' Icc 0 T) (ε : ℝ) (hε : 0<ε) :
+    ∃ V : Set (γ '' Icc 0 T), V ∈ 𝓝 z ∧ IsPreconnected V ∧
+      ∀ w∈V, dist (w:ℂ) (z:ℂ)<ε := by
+  have := finiteTrace_locallyConnected hγ T
+  obtain ⟨V,hV,hconn,hsub⟩ := (locallyConnectedSpace_iff_connected_subsets.mp this)
+    z (ball z ε) (ball_mem_nhds z hε)
+  exact ⟨V,hV,hconn,fun w hw => mem_ball.mp (hsub hw)⟩
+
+end SLEExactGauge
+
+end
+
+end OAI
diff --git a/lean/OAI/Probability/SLE/Geometry/FirstDomainExit.lean b/lean/OAI/Probability/SLE/Geometry/FirstDomainExit.lean
new file mode 100644
index 0000000000000000000000000000000000000000..d87c9a9865b811284094d80f48971b0346c1da3f
--- /dev/null
+++ b/lean/OAI/Probability/SLE/Geometry/FirstDomainExit.lean
@@ -0,0 +1,85 @@
+import OAI.Probability.SLE.Geometry.LocalCrosscutSides
+import OAI.Probability.SLE.LoewnerCharts
+
+namespace OAI
+
+/-! Actual first exits forced by the waypoint route.  Compactness of the
+finite time window gives an attained first exit, strictly after the early
+surviving prefix. No stopping-time or exit-location assumption is used. -/
+
+noncomputable section
+open Set Filter Metric
+open scoped Topology NNReal
+
+namespace SLEExactGauge.CrosscutSides
+
+theorem exists_first_domain_exit
+    {X : Type*} [TopologicalSpace X] (D : Set X) (hD : IsOpen D)
+    (ζ : ℝ → X) {a L : ℝ}
+    (hc : ContinuousOn ζ (Icc 0 L)) (hearly : MapsTo ζ (Icc 0 a) D)
+    (hhit : ∃ t ∈ Icc (0 : ℝ) L, ζ t ∉ D) :
+    ∃ τ ∈ Ioc a L, ζ τ ∉ D ∧ MapsTo ζ (Ico 0 τ) D := by
+  let K := Icc (0 : ℝ) L ∩ ζ ⁻¹' Dᶜ
+  have hKc : IsClosed K := hc.preimage_isClosed_of_isClosed isClosed_Icc hD.isClosed_compl
+  have hK : IsCompact K := isCompact_Icc.of_isClosed_subset hKc inter_subset_left
+  have hKn : K.Nonempty := by
+    obtain ⟨t, ht, hh⟩ := hhit
+    exact ⟨t, ht, hh⟩
+  obtain ⟨τ, hτ, hmin⟩ := hK.exists_isLeast hKn
+  have haτ : a < τ := by
+    by_contra hh
+    exact hτ.2 (hearly ⟨hτ.1.1, le_of_not_gt hh⟩)
+  refine ⟨τ, ⟨haτ, hτ.1.2⟩, hτ.2, ?_⟩
+  intro t ht
+  by_contra hh
+  exact (not_le_of_gt ht.2) (hmin ⟨⟨ht.1, ht.2.le.trans hτ.1.2⟩, hh⟩)
+
+theorem first_domain_exit_unique
+    {X : Type*} (D : Set X) (ζ : ℝ → X) {τ σ : ℝ}
+    (hτ : 0 ≤ τ) (hσ : 0 ≤ σ)
+    (hτout : ζ τ ∉ D) (hσout : ζ σ ∉ D)
+    (hτin : MapsTo ζ (Ico 0 τ) D) (hσin : MapsTo ζ (Ico 0 σ) D) : τ = σ := by
+  apply le_antisymm
+  · by_contra hh
+    exact hσout (hτin ⟨hσ, lt_of_not_ge hh⟩)
+  · by_contra hh
+    exact hτout (hσin ⟨hτ, lt_of_not_ge hh⟩)
+
+theorem waypoint_first_exit_after_early_prefix
+    (γ : ℝ≥0 → ℂ) (hγ : Continuous γ) (T : ℝ≥0)
+    (ζ : ℝ → ℂ) (hc : ContinuousOn ζ (Icc 0 3))
+    (hearly : MapsTo ζ (Icc 0 2) (survivingDomain γ T))
+    (hhit : ∃ s ∈ Icc 0 T, ∃ t ∈ Icc (0 : ℝ) 3, γ s = ζ t) :
+    ∃ τ ∈ Ioc (2 : ℝ) 3, ζ τ ∉ survivingDomain γ T ∧
+      MapsTo ζ (Ico 0 τ) (survivingDomain γ T) := by
+  apply exists_first_domain_exit (survivingDomain γ T) (isOpen_survivingDomain hγ T)
+    ζ hc hearly
+  obtain ⟨s, hs, t, ht, he⟩ := hhit
+  refine ⟨t, ht, ?_⟩
+  intro hh
+  exact hh.1.2 ⟨s, hs, he⟩
+
+/-- A continuous nonzero side-coordinate cannot change sign before exit. -/
+theorem exit_prefix_positive
+    {X : Type*} [TopologicalSpace X] {D : Set X} (j : X → ℝ)
+    (hj : ContinuousOn j D) (ζ : ℝ → X) {a τ : ℝ}
+    (hc : ContinuousOn ζ (Ico a τ)) (hin : MapsTo ζ (Ico a τ) D)
+    (hn : ∀ t ∈ Ico a τ, j (ζ t) ≠ 0) (haτ : a < τ)
+    (hstart : 0 < j (ζ a)) : ∀ t ∈ Ico a τ, 0 < j (ζ t) :=
+  positive_on_preconnected_of_nonzero isPreconnected_Ico (hj.comp hc hin)
+    hn ⟨le_rfl, haτ⟩ hstart
+
+theorem exit_prefix_negative
+    {X : Type*} [TopologicalSpace X] {D : Set X} (j : X → ℝ)
+    (hj : ContinuousOn j D) (ζ : ℝ → X) {a τ : ℝ}
+    (hc : ContinuousOn ζ (Ico a τ)) (hin : MapsTo ζ (Ico a τ) D)
+    (hn : ∀ t ∈ Ico a τ, j (ζ t) ≠ 0) (haτ : a < τ)
+    (hstart : j (ζ a) < 0) : ∀ t ∈ Ico a τ, j (ζ t) < 0 :=
+  negative_on_preconnected_of_nonzero isPreconnected_Ico (hj.comp hc hin)
+    hn ⟨le_rfl, haτ⟩ hstart
+
+end SLEExactGauge.CrosscutSides
+
+end
+
+end OAI
diff --git a/lean/OAI/Probability/SLE/Geometry/FirstHeightBounded.lean b/lean/OAI/Probability/SLE/Geometry/FirstHeightBounded.lean
new file mode 100644
index 0000000000000000000000000000000000000000..78d232f13fc6a8e562cefeec174ad92f461fd78c
--- /dev/null
+++ b/lean/OAI/Probability/SLE/Geometry/FirstHeightBounded.lean
@@ -0,0 +1,370 @@
+import OAI.Probability.SLE.Geometry.FirstHeightScaling
+
+namespace OAI
+
+/-! A bounded narrow first-height event, its probability uniformly over spatial
+scales, and measurability of the corresponding stopped-past certificate. -/
+
+noncomputable section
+open Set Filter MeasureTheory ProbabilityTheory
+open scoped Topology NNReal ENNReal
+
+namespace SLEExactGauge.FirstHeightSupport
+
+local instance : MeasurableSpace C(ℝ≥0, ℂ) := borel _
+local instance : BorelSpace C(ℝ≥0, ℂ) := ⟨rfl⟩
+
+def narrowRiseBy (B : ℝ) (T : ℝ≥0) : Set C(ℝ≥0, ℂ) :=
+  {p | ∃ S : ℝ≥0, 0 < S ∧ S ≤ T ∧ MapsTo p (Icc 0 S) (narrowStrip B) ∧
+    p S ∈ aboveQuarterHeight B}
+
+theorem isOpen_narrowRiseBy (B : ℝ) (T : ℝ≥0) : IsOpen (narrowRiseBy B T) := by
+  have he : narrowRiseBy B T = ⋃ S : ℝ≥0, ⋃ (_ : 0 < S), ⋃ (_ : S ≤ T),
+      {p : C(ℝ≥0, ℂ) | MapsTo p (Icc 0 S) (narrowStrip B)} ∩
+      (fun p : C(ℝ≥0, ℂ) => p S) ⁻¹' aboveQuarterHeight B := by
+    ext p
+    simp only [narrowRiseBy, mem_ofPred_eq, mem_iUnion, mem_inter_iff, mem_preimage]
+    constructor <;> rintro ⟨S, hS, hST, hN, hV⟩ <;> exact ⟨S, hS, hST, hN, hV⟩
+  rw [he]
+  exact isOpen_iUnion fun S => isOpen_iUnion fun _ => isOpen_iUnion fun _ =>
+    (ContinuousMap.isOpen_setOfPred_mapsTo isCompact_Icc
+      (isOpen_lt Complex.continuous_re.abs continuous_const)).inter
+      ((isOpen_lt continuous_const Complex.continuous_im).preimage (continuous_eval_const S))
+
+theorem measurableSet_narrowRiseBy (B : ℝ) (T : ℝ≥0) : MeasurableSet (narrowRiseBy B T) :=
+  (isOpen_narrowRiseBy B T).measurableSet
+
+theorem narrowRiseEvent_eq_iUnion (B : ℝ) :
+    narrowRiseEvent B = ⋃ n : ℕ, narrowRiseBy B (n + 1) := by
+  ext p
+  constructor
+  · rintro ⟨T, hT, hN, hV⟩
+    obtain ⟨n, hn⟩ := exists_nat_gt T
+    exact mem_iUnion.mpr ⟨n, T, hT, hn.le.trans (by simp), hN, hV⟩
+  · intro hp
+    obtain ⟨n, T, hT, _, hN, hV⟩ := mem_iUnion.mp hp
+    exact ⟨T, hT, hN, hV⟩
+
+theorem scalePath_narrowRiseBy_iff
+    (p : C(ℝ≥0, ℂ)) (c : ℝ≥0) (hc : 0 < c) (B : ℝ) (T : ℝ≥0) :
+    ScaleTraceLaw.scalePath c p ∈ narrowRiseBy ((c : ℝ) * B) (T * c ^ 2) ↔
+      p ∈ narrowRiseBy B T := by
+  have hcR : 0 < (c : ℝ) := hc
+  have hc2 : 0 < c ^ 2 := pow_pos hc 2
+  have hre (t : ℝ≥0) : |(ScaleTraceLaw.scalePath c p t).re| =
+      (c : ℝ) * |(p (sourceScaleTime c t)).re| := by
+    change |((c : ℂ) * p (sourceScaleTime c t)).re| = _
+    simp [Complex.mul_re, abs_mul, abs_of_nonneg c.coe_nonneg]
+  have him (t : ℝ≥0) : (ScaleTraceLaw.scalePath c p t).im =
+      (c : ℝ) * (p (sourceScaleTime c t)).im := by
+    change ((c : ℂ) * p (sourceScaleTime c t)).im = _
+    simp [Complex.mul_im]
+  constructor
+  · rintro ⟨S, hS, hST, hN, hV⟩
+    refine ⟨sourceScaleTime c S, div_pos hS hc2, (div_le_iff₀ hc2).mpr hST, ?_, ?_⟩
+    · intro t ht
+      have hv : t * c ^ 2 ∈ Icc (0 : ℝ≥0) S :=
+        ⟨bot_le, (le_div_iff₀ hc2).mp ht.2⟩
+      have hh : |(ScaleTraceLaw.scalePath c p (t * c ^ 2)).re| < (c : ℝ) * B / 16 := hN hv
+      rw [hre] at hh
+      simp only [sourceScaleTime, mul_div_cancel_right₀ _ (ne_of_gt hc2)] at hh
+      apply (mul_lt_mul_iff_right₀ hcR).mp
+      nlinarith
+    · have hh : (c : ℝ) * B / 4 < (ScaleTraceLaw.scalePath c p S).im := hV
+      rw [him] at hh
+      apply (mul_lt_mul_iff_right₀ hcR).mp
+      nlinarith
+  · rintro ⟨S, hS, hST, hN, hV⟩
+    refine ⟨S * c ^ 2, mul_pos hS hc2, mul_le_mul_of_nonneg_right hST hc2.le, ?_, ?_⟩
+    · intro t ht
+      have hu : sourceScaleTime c t ∈ Icc (0 : ℝ≥0) S :=
+        ⟨bot_le, (div_le_iff₀ hc2).mpr ht.2⟩
+      change |(ScaleTraceLaw.scalePath c p t).re| < (c : ℝ) * B / 16
+      rw [hre]
+      have hh : |(p (sourceScaleTime c t)).re| < B / 16 := hN hu
+      nlinarith
+    · change (c : ℝ) * B / 4 < (ScaleTraceLaw.scalePath c p (S * c ^ 2)).im
+      rw [him]
+      simp only [sourceScaleTime, mul_div_cancel_right₀ _ (ne_of_gt hc2)]
+      have hh : B / 4 < (p S).im := hV
+      nlinarith
+
+theorem narrowRiseBy_probability_scaling
+    {Ω : 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 ω))
+    (c : ℝ≥0) (hcpos : 0 < c) (B : ℝ) (T : ℝ≥0) :
+    P {ω | sourceTracePath γ (fun ω => (hw ω).1) ω ∈
+      narrowRiseBy ((c : ℝ) * B) (T * c ^ 2)} =
+    P {ω | sourceTracePath γ (fun ω => (hw ω).1) ω ∈ narrowRiseBy B T} := by
+  let gp := sourceTracePath γ (fun ω => (hw ω).1)
+  obtain ⟨Φ, hΦm, hΦ, _⟩ := sourceStoppedTraceLaw κ hκ hκ8 B₀ hB₀ hm hc γ G F hw
+  have hgm : Measurable gp := by
+    have he : gp = Φ ∘ sourceDriverPath B₀ hc := funext fun ω => (hΦ ω).symm
+    rw [he]
+    exact hΦm.comp (source_path_measurable _ hm)
+  have he := congrArg (fun μ : Measure C(ℝ≥0, ℂ) =>
+      μ (narrowRiseBy ((c : ℝ) * B) (T * c ^ 2)))
+    (ScaleTraceLaw.scaled_trace_path_law κ hκ hκ8 B₀ hB₀ hm hc γ G F hw c hcpos)
+  change (P.map (ScaleTraceLaw.scalePath c ∘ gp)) _ = (P.map gp) _ at he
+  rw [Measure.map_apply ((ScaleTraceLaw.measurable_scalePath c).comp hgm)
+      (measurableSet_narrowRiseBy _ _),
+    Measure.map_apply hgm (measurableSet_narrowRiseBy _ _)] at he
+  have hset : {ω | ScaleTraceLaw.scalePath c (gp ω) ∈
+      narrowRiseBy ((c : ℝ) * B) (T * c ^ 2)} = {ω | gp ω ∈ narrowRiseBy B T} := by
+    ext ω
+    exact scalePath_narrowRiseBy_iff (gp ω) c hcpos B T
+  change P {ω | ScaleTraceLaw.scalePath c (gp ω) ∈
+      narrowRiseBy ((c : ℝ) * B) (T * c ^ 2)} =
+      P {ω | gp ω ∈ narrowRiseBy ((c : ℝ) * B) (T * c ^ 2)} at he
+  rw [hset] at he
+  exact he.symm
+
+/-- The uniform probability can be realized before a deterministic multiple
+of the square of the spatial scale. -/
+theorem uniform_bounded_narrowRise_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 ω))
+    (hpublished : PublishedGeometricTubeSupport P γ) :
+    ∃ T₀ : ℝ≥0, 0 < T₀ ∧ ∃ q : ℝ≥0∞, 0 < q ∧ ∀ c : ℝ≥0, 0 < c →
+      q ≤ P {ω | sourceTracePath γ (fun ω => (hw ω).1) ω ∈
+        narrowRiseBy (c : ℝ) (T₀ * c ^ 2)} := by
+  let gp := sourceTracePath γ (fun ω => (hw ω).1)
+  have hpos : 0 < P {ω | gp ω ∈ narrowRiseEvent 1} :=
+    narrowRiseEvent_positive P γ hpublished zero_lt_one
+  have hex : ∃ n : ℕ, 0 < P {ω | gp ω ∈ narrowRiseBy 1 (n + 1)} := by
+    by_contra! hn
+    have he : {ω | gp ω ∈ narrowRiseEvent 1} =
+        ⋃ n : ℕ, {ω | gp ω ∈ narrowRiseBy 1 (n + 1)} := by
+      ext ω
+      simp only [narrowRiseEvent_eq_iUnion, mem_ofPred_eq, mem_iUnion]
+    rw [he, measure_iUnion_null (fun n => le_antisymm (hn n) bot_le)] at hpos
+    exact (lt_irrefl _) hpos
+  obtain ⟨n, hn⟩ := hex
+  refine ⟨n + 1, by positivity, P {ω | gp ω ∈ narrowRiseBy 1 (n + 1)}, hn, ?_⟩
+  intro c hcpos
+  have he := narrowRiseBy_probability_scaling κ hκ hκ8 B₀ hB₀ hm hc γ G F hw c hcpos 1 (n + 1)
+  simpa only [mul_one] using he.symm.le
+
+/-- Stop a continuous trace at a finite stopping time, retaining a continuous
+path on the common nonnegative-time domain. -/
+def stoppedTracePath {Ω : Type*} (γ : Ω → ℝ≥0 → ℂ) (hc : ∀ ω, Continuous (γ ω))
+    (σ : Ω → ℝ≥0) (ω : Ω) : C(ℝ≥0, ℂ) :=
+  ⟨fun t => γ ω (min t (σ ω)), (hc ω).comp (continuous_id.min continuous_const)⟩
+
+/-- Every coordinate of this path is already measurable in the stopped past. -/
+theorem stoppedTracePath_measurable
+    {Ω : Type*} [m : MeasurableSpace Ω] (ℱ : Filtration ℝ≥0 m)
+    (γ : Ω → ℝ≥0 → ℂ) (ha : Adapted ℱ (fun t ω => γ ω t))
+    (hc : ∀ ω, Continuous (γ ω)) (σ : Ω → ℝ≥0)
+    (hσ : IsStoppingTime ℱ (fun ω => (σ ω : WithTop ℝ≥0))) :
+    Measurable[hσ.measurableSpace] (stoppedTracePath γ hc σ) := by
+  have hp := ha.stronglyAdapted.isStronglyProgressive_of_continuous hc
+  let : MeasurableSpace Ω := hσ.measurableSpace
+  apply source_path_measurable
+  intro t
+  have hm := measurable_stoppedValue hp (hσ.min_const t)
+  have hm' := hm.mono (IsStoppingTime.measurableSpace_mono (hσ.min_const t) hσ
+    (fun _ => min_le_left _ _)) le_rfl
+  change Measurable[hσ.measurableSpace]
+    (fun ω => γ ω ((min (σ ω : WithTop ℝ≥0) (t : WithTop ℝ≥0)).untopA)) at hm'
+  change Measurable[hσ.measurableSpace] (fun ω => γ ω (min t (σ ω)))
+  simpa only [← WithTop.coe_min, WithTop.untopA, WithTop.untopD_coe, min_comm] using hm'
+
+/-- This concrete certificate depends only on the stopped trace. Its height
+and horizontal-strip conditions can therefore be tested in the stopped past. -/
+def stoppedNarrowCertificate {Ω : Type*} (γ : Ω → ℝ≥0 → ℂ) (σ : Ω → ℝ≥0)
+    (B : ℝ) (T : ℝ≥0) : Set Ω :=
+  {ω | 0 < σ ω ∧ (γ ω (σ ω)).im = B / 4 ∧
+    MapsTo (fun t => γ ω (min t (σ ω))) (Icc 0 T) (narrowStrip B)}
+
+theorem stoppedNarrowCertificate_measurable
+    {Ω : Type*} [m : MeasurableSpace Ω] (ℱ : Filtration ℝ≥0 m)
+    (γ : Ω → ℝ≥0 → ℂ) (ha : Adapted ℱ (fun t ω => γ ω t))
+    (hc : ∀ ω, Continuous (γ ω)) (σ : Ω → ℝ≥0)
+    (hσ : IsStoppingTime ℱ (fun ω => (σ ω : WithTop ℝ≥0))) (B : ℝ) (T : ℝ≥0) :
+    MeasurableSet[hσ.measurableSpace] (stoppedNarrowCertificate γ σ B T) := by
+  have hp := ha.stronglyAdapted.isStronglyProgressive_of_continuous hc
+  have hv : Measurable[hσ.measurableSpace] (fun ω => γ ω (σ ω)) := by
+    have hm := measurable_stoppedValue hp hσ
+    change Measurable[hσ.measurableSpace]
+      (fun ω => γ ω ((σ ω : WithTop ℝ≥0).untopA)) at hm
+    simpa only [WithTop.untopA, WithTop.untopD_coe] using hm
+  have hs : Measurable[hσ.measurableSpace] σ := by
+    simpa only [WithTop.untopA, WithTop.untopD_coe] using hσ.measurable.untopA
+  have hpath := stoppedTracePath_measurable ℱ γ ha hc σ hσ
+  exact (measurableSet_lt measurable_const hs).inter
+    ((measurableSet_eq_fun (Complex.continuous_im.measurable.comp hv) measurable_const).inter
+      ((ContinuousMap.isOpen_setOfPred_mapsTo isCompact_Icc
+        (isOpen_lt Complex.continuous_re.abs continuous_const)).measurableSet.preimage hpath))
+
+/-- Finite first-height clock, stopped at the prescribed deterministic bound. -/
+def boundedFirstHeightTime (γ : ℝ≥0 → ℂ) (B : ℝ) (T : ℝ≥0) : ℝ≥0 :=
+  (min (firstHeightTime γ (B / 4)) (T : WithTop ℝ≥0)).untopD 0
+
+@[simp] theorem boundedFirstHeightTime_coe (γ : ℝ≥0 → ℂ) (B : ℝ) (T : ℝ≥0) :
+    (boundedFirstHeightTime γ B T : WithTop ℝ≥0) =
+      min (firstHeightTime γ (B / 4)) (T : WithTop ℝ≥0) := by
+  cases he : firstHeightTime γ (B / 4) with
+  | top =>
+    simp only [boundedFirstHeightTime, he, min_eq_right le_top, WithTop.untopD_coe]
+  | coe r =>
+    simp only [boundedFirstHeightTime, he, ← WithTop.coe_min, WithTop.untopD_coe]
+
+theorem boundedFirstHeightTime_le (γ : ℝ≥0 → ℂ) (B : ℝ) (T : ℝ≥0) :
+    boundedFirstHeightTime γ B T ≤ T := by
+  apply WithTop.coe_le_coe.mp
+  rw [boundedFirstHeightTime_coe]
+  exact min_le_right _ _
+
+theorem boundedFirstHeightTime_isStoppingTime
+    {Ω : Type*} [m : MeasurableSpace Ω] (ℱ : Filtration ℝ≥0 m)
+    (γ : Ω → ℝ≥0 → ℂ) (ha : Adapted ℱ (fun t ω => γ ω t))
+    (hc : ∀ ω, Continuous (γ ω)) (B : ℝ) (T : ℝ≥0) :
+    IsStoppingTime ℱ (fun ω => (boundedFirstHeightTime (γ ω) B T : WithTop ℝ≥0)) := by
+  simpa only [boundedFirstHeightTime_coe] using
+    (firstHeightTime_isStoppingTime ℱ γ ha hc (B / 4)).min_const T
+
+/-- A bounded supported rise supplies a narrow certificate at the actual
+first-height clock. -/
+theorem narrowRiseBy_gives_bounded_certificate
+    {B : ℝ} (hB : 0 < B) (p : C(ℝ≥0, ℂ)) (hp0 : p 0 = 0)
+    {T : ℝ≥0} (hp : p ∈ narrowRiseBy B T) :
+    let σ := boundedFirstHeightTime p B T
+    0 < σ ∧ (p σ).im = B / 4 ∧
+      MapsTo (fun t => p (min t σ)) (Icc 0 T) (narrowStrip B) := by
+  obtain ⟨S, _, hST, hstrip, habove⟩ := hp
+  obtain ⟨τ, htime, hτ, hτS, hhit, _⟩ :=
+    exists_first_height p p.continuous hp0 (by positivity : 0 < B / 4) habove
+  have hσ : boundedFirstHeightTime p B T = τ := by
+    apply WithTop.coe_injective
+    rw [boundedFirstHeightTime_coe, htime, min_eq_left (WithTop.coe_le_coe.mpr (hτS.le.trans hST))]
+  dsimp only
+  rw [hσ]
+  refine ⟨hτ, hhit, ?_⟩
+  intro t _
+  exact hstrip ⟨bot_le, (min_le_right t τ).trans hτS.le⟩
+
+/-- Every measurable bounded certificate gives the full first-height
+geometry, including strict freshness and rectangle containment. -/
+theorem bounded_certificate_geometry
+    (p : C(ℝ≥0, ℂ)) (hp0 : p 0 = 0) (hpH : ∀ t, 0 ≤ (p t).im)
+    {B : ℝ} (hB : 0 < B) (T : ℝ≥0)
+    (hcert : let σ := boundedFirstHeightTime p B T
+      0 < σ ∧ (p σ).im = B / 4 ∧
+        MapsTo (fun t => p (min t σ)) (Icc 0 T) (narrowStrip B)) :
+    let σ := boundedFirstHeightTime p B T
+    firstHeightTime p (B / 4) = (σ : WithTop ℝ≥0) ∧ 0 < σ ∧
+      (p σ).im = B / 4 ∧ |(p σ).re| < B / 16 ∧
+      (∀ u : ℝ≥0, u < σ → (p u).im < (p σ).im) ∧
+      p '' Icc 0 σ ⊆ GuideSplice.closedInitialRectangle B := by
+  let σ := boundedFirstHeightTime p B T
+  obtain ⟨hσpos, hhit, hstrip⟩ := hcert
+  change (p σ).im = B / 4 at hhit
+  change MapsTo (fun t => p (min t σ)) (Icc 0 T) (narrowStrip B) at hstrip
+  have hσT : σ ≤ T := boundedFirstHeightTime_le p B T
+  have hfirstle : firstHeightTime p (B / 4) ≤ (σ : WithTop ℝ≥0) := by
+    apply hittingAfter_le_of_mem (show (0 : ℝ≥0) ≤ σ from bot_le)
+    change (p σ).im - B / 4 = 0
+    rw [hhit, sub_self]
+  have htime : firstHeightTime p (B / 4) = (σ : WithTop ℝ≥0) := by
+    apply le_antisymm hfirstle
+    exact (boundedFirstHeightTime_coe p B T).trans_le (min_le_left _ _)
+  have hprior (u : ℝ≥0) (hu : u < σ) : (p u).im < B / 4 := by
+    by_contra hn
+    obtain ⟨v, hv, he⟩ := intermediate_value_Icc (show (0 : ℝ≥0) ≤ u from bot_le)
+      (Complex.continuous_im.comp p.continuous).continuousOn
+      (show B / 4 ∈ Icc (p 0).im (p u).im by
+        rw [hp0, Complex.zero_im]
+        exact ⟨by positivity, le_of_not_gt hn⟩)
+    have hh : firstHeightTime p (B / 4) ≤ (v : WithTop ℝ≥0) := by
+      apply hittingAfter_le_of_mem (show (0 : ℝ≥0) ≤ v from bot_le)
+      change (p v).im - B / 4 = 0
+      rw [show (p v).im = B / 4 from he, sub_self]
+    rw [htime, WithTop.coe_le_coe] at hh
+    exact (not_le_of_gt hu) (hh.trans hv.2)
+  have hσstrip : |(p σ).re| < B / 16 := by
+    simpa only [min_self, narrowStrip, mem_ofPred_eq] using hstrip ⟨bot_le, hσT⟩
+  refine ⟨htime, hσpos, hhit, hσstrip, ?_, ?_⟩
+  · intro u hu
+    rw [hhit]
+    exact hprior u hu
+  · rintro z ⟨u, hu, rfl⟩
+    have hs : |(p u).re| < B / 16 := by
+      have hh := hstrip ⟨bot_le, hu.2.trans hσT⟩
+      change |(p (min u σ)).re| < B / 16 at hh
+      rw [min_eq_left (show u ≤ σ from hu.2)] at hh
+      exact hh
+    refine ⟨hs.le, hpH u, ?_⟩
+    rcases eq_or_lt_of_le hu.2 with rfl | huσ
+    · exact hhit.le
+    · exact (hprior u huσ).le
+
+theorem bounded_certificate_gives_first_height
+    (p : C(ℝ≥0, ℂ)) (hp0 : p 0 = 0) (hpH : ∀ t, 0 ≤ (p t).im)
+    {B : ℝ} (hB : 0 < B) (T : ℝ≥0)
+    (hcert : let σ := boundedFirstHeightTime p B T
+      0 < σ ∧ (p σ).im = B / 4 ∧
+        MapsTo (fun t => p (min t σ)) (Icc 0 T) (narrowStrip B)) :
+    NarrowFirstHeight B p :=
+  ⟨boundedFirstHeightTime p B T, bounded_certificate_geometry p hp0 hpH hB T hcert⟩
+
+/-- Uniform bounded first-height probability in the form of a concrete
+stopped-past event. -/
+theorem uniform_boundedFirstHeight_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 ω))
+    (hpublished : PublishedGeometricTubeSupport P γ) :
+    ∃ T₀ : ℝ≥0, 0 < T₀ ∧ ∃ q : ℝ≥0∞, 0 < q ∧ ∀ c : ℝ≥0, 0 < c →
+      q ≤ P (stoppedNarrowCertificate γ
+        (fun ω => boundedFirstHeightTime (γ ω) c (T₀ * c ^ 2)) c (T₀ * c ^ 2)) := by
+  obtain ⟨T₀, hT₀, q, hq, hprob⟩ := uniform_bounded_narrowRise_probability
+    κ hκ hκ8 B₀ hB₀ hm hc γ G F hw hpublished
+  refine ⟨T₀, hT₀, q, hq, fun c hcpos => (hprob c hcpos).trans ?_⟩
+  apply measure_mono
+  intro ω hω
+  exact narrowRiseBy_gives_bounded_certificate hcpos
+    (sourceTracePath γ (fun ω => (hw ω).1) ω) (hw ω).2.1 hω
+
+/-- The event in the uniform probability theorem is measurable at its
+bounded first-height stopping time. -/
+theorem boundedFirstHeight_certificate_measurable
+    {Ω : Type*} [m : MeasurableSpace Ω] (ℱ : Filtration ℝ≥0 m)
+    (γ : Ω → ℝ≥0 → ℂ) (ha : Adapted ℱ (fun t ω => γ ω t))
+    (hc : ∀ ω, Continuous (γ ω)) (B : ℝ) (T : ℝ≥0) :
+    MeasurableSet[(boundedFirstHeightTime_isStoppingTime ℱ γ ha hc B T).measurableSpace]
+      (stoppedNarrowCertificate γ (fun ω => boundedFirstHeightTime (γ ω) B T) B T) :=
+  stoppedNarrowCertificate_measurable ℱ γ ha hc
+    (fun ω => boundedFirstHeightTime (γ ω) B T)
+    (boundedFirstHeightTime_isStoppingTime ℱ γ ha hc B T) B T
+
+/-- The same event is measurable in the full first-height past, as used in
+the manuscript's conditional continuation argument. -/
+theorem boundedFirstHeight_certificate_measurable_at_first
+    {Ω : Type*} [m : MeasurableSpace Ω] (ℱ : Filtration ℝ≥0 m)
+    (γ : Ω → ℝ≥0 → ℂ) (ha : Adapted ℱ (fun t ω => γ ω t))
+    (hc : ∀ ω, Continuous (γ ω)) (B : ℝ) (T : ℝ≥0) :
+    MeasurableSet[(firstHeightTime_isStoppingTime ℱ γ ha hc (B / 4)).measurableSpace]
+      (stoppedNarrowCertificate γ (fun ω => boundedFirstHeightTime (γ ω) B T) B T) := by
+  have hle := IsStoppingTime.measurableSpace_mono
+    (boundedFirstHeightTime_isStoppingTime ℱ γ ha hc B T)
+    (firstHeightTime_isStoppingTime ℱ γ ha hc (B / 4))
+    (fun ω => (boundedFirstHeightTime_coe (γ ω) B T).trans_le (min_le_left _ _))
+  exact hle _ (boundedFirstHeight_certificate_measurable ℱ γ ha hc B T)
+
+end SLEExactGauge.FirstHeightSupport
+
+end
+
+end OAI
diff --git a/lean/OAI/Probability/SLE/Geometry/FirstHeightScaling.lean b/lean/OAI/Probability/SLE/Geometry/FirstHeightScaling.lean
new file mode 100644
index 0000000000000000000000000000000000000000..fe83e8602f66ba2997c4194235f8abe2d749cdc8
--- /dev/null
+++ b/lean/OAI/Probability/SLE/Geometry/FirstHeightScaling.lean
@@ -0,0 +1,129 @@
+import OAI.Probability.SLE.Geometry.FirstHeightSupport
+import OAI.Probability.SLE.Loewner.ScaleTraceLaw
+
+namespace OAI
+
+/-! The scale-independent narrow first-height probability follows from the
+proved equality of actual scaled trace laws and an exact tube-event scaling
+identity. -/
+
+noncomputable section
+open Set Filter MeasureTheory ProbabilityTheory
+open scoped Topology NNReal ENNReal
+
+namespace SLEExactGauge.FirstHeightSupport
+
+local instance : MeasurableSpace C(ℝ≥0, ℂ) := borel _
+local instance : BorelSpace C(ℝ≥0, ℂ) := ⟨rfl⟩
+
+/-- Capacity scaling sends a narrow-rise event to exactly the correspondingly
+scaled narrow-rise event, including its finite time witness. -/
+theorem scalePath_narrowRiseEvent_iff
+    (p : C(ℝ≥0, ℂ)) (c : ℝ≥0) (hc : 0 < c) (B : ℝ) :
+    ScaleTraceLaw.scalePath c p ∈ narrowRiseEvent ((c : ℝ) * B) ↔ p ∈ narrowRiseEvent B := by
+  have hcR : 0 < (c : ℝ) := hc
+  have hc2 : 0 < c ^ 2 := pow_pos hc 2
+  have hre (t : ℝ≥0) : |(ScaleTraceLaw.scalePath c p t).re| =
+      (c : ℝ) * |(p (sourceScaleTime c t)).re| := by
+    change |((c : ℂ) * p (sourceScaleTime c t)).re| = _
+    simp [Complex.mul_re, abs_mul, abs_of_nonneg c.coe_nonneg]
+  have him (t : ℝ≥0) : (ScaleTraceLaw.scalePath c p t).im =
+      (c : ℝ) * (p (sourceScaleTime c t)).im := by
+    change ((c : ℂ) * p (sourceScaleTime c t)).im = _
+    simp [Complex.mul_im]
+  constructor
+  · rintro ⟨S, hS, hN, hV⟩
+    refine ⟨sourceScaleTime c S, div_pos hS hc2, ?_, ?_⟩
+    · intro t ht
+      have hv : t * c ^ 2 ∈ Icc (0 : ℝ≥0) S :=
+        ⟨bot_le, (le_div_iff₀ hc2).mp ht.2⟩
+      have hh : |(ScaleTraceLaw.scalePath c p (t * c ^ 2)).re| < (c : ℝ) * B / 16 := hN hv
+      rw [hre] at hh
+      simp only [sourceScaleTime, mul_div_cancel_right₀ _ (ne_of_gt hc2)] at hh
+      apply (mul_lt_mul_iff_right₀ hcR).mp
+      nlinarith
+    · have hh : (c : ℝ) * B / 4 < (ScaleTraceLaw.scalePath c p S).im := hV
+      rw [him] at hh
+      apply (mul_lt_mul_iff_right₀ hcR).mp
+      nlinarith
+  · rintro ⟨T, hT, hN, hV⟩
+    refine ⟨T * c ^ 2, mul_pos hT hc2, ?_, ?_⟩
+    · intro t ht
+      have hu : sourceScaleTime c t ∈ Icc (0 : ℝ≥0) T :=
+        ⟨bot_le, (div_le_iff₀ hc2).mpr ht.2⟩
+      change |(ScaleTraceLaw.scalePath c p t).re| < (c : ℝ) * B / 16
+      rw [hre]
+      have hh : |(p (sourceScaleTime c t)).re| < B / 16 := hN hu
+      nlinarith
+    · change (c : ℝ) * B / 4 < (ScaleTraceLaw.scalePath c p (T * c ^ 2)).im
+      rw [him]
+      simp only [sourceScaleTime, mul_div_cancel_right₀ _ (ne_of_gt hc2)]
+      have hh : B / 4 < (p T).im := hV
+      nlinarith
+
+/-- Narrow-rise probabilities for actual chordal SLE are invariant under
+simultaneous spatial and capacity-time scaling. -/
+theorem narrowRise_probability_scaling
+    {Ω : 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 ω))
+    (c : ℝ≥0) (hcpos : 0 < c) (B : ℝ) :
+    P {ω | sourceTracePath γ (fun ω => (hw ω).1) ω ∈ narrowRiseEvent ((c : ℝ) * B)} =
+      P {ω | sourceTracePath γ (fun ω => (hw ω).1) ω ∈ narrowRiseEvent B} := by
+  let gp := sourceTracePath γ (fun ω => (hw ω).1)
+  obtain ⟨Φ, hΦm, hΦ, _⟩ := sourceStoppedTraceLaw κ hκ hκ8 B₀ hB₀ hm hc γ G F hw
+  have hgm : Measurable gp := by
+    have he : gp = Φ ∘ sourceDriverPath B₀ hc := funext fun ω => (hΦ ω).symm
+    rw [he]
+    exact hΦm.comp (source_path_measurable _ hm)
+  have he := congrArg (fun μ : Measure C(ℝ≥0, ℂ) => μ (narrowRiseEvent ((c : ℝ) * B)))
+    (ScaleTraceLaw.scaled_trace_path_law κ hκ hκ8 B₀ hB₀ hm hc γ G F hw c hcpos)
+  change (P.map (ScaleTraceLaw.scalePath c ∘ gp)) (narrowRiseEvent ((c : ℝ) * B)) =
+    (P.map gp) (narrowRiseEvent ((c : ℝ) * B)) at he
+  rw [Measure.map_apply ((ScaleTraceLaw.measurable_scalePath c).comp hgm)
+      (measurableSet_narrowRiseEvent _),
+    Measure.map_apply hgm (measurableSet_narrowRiseEvent _)] at he
+  have hset : {ω | ScaleTraceLaw.scalePath c (gp ω) ∈ narrowRiseEvent ((c : ℝ) * B)} =
+      {ω | gp ω ∈ narrowRiseEvent B} := by
+    ext ω
+    exact scalePath_narrowRiseEvent_iff (gp ω) c hcpos B
+  change P {ω | ScaleTraceLaw.scalePath c (gp ω) ∈ narrowRiseEvent ((c : ℝ) * B)} =
+    P {ω | gp ω ∈ narrowRiseEvent ((c : ℝ) * B)} at he
+  rw [hset] at he
+  exact he.symm
+
+/-- One fixed positive probability works for the narrow first-height event
+at every spatial scale. Its equality of laws has been proved above. -/
+theorem uniform_narrowFirstHeight_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 ω))
+    (hpublished : PublishedGeometricTubeSupport P γ) :
+    ∃ q : ℝ≥0∞, 0 < q ∧ ∀ B : ℝ, 0 < B → q ≤ P {ω | NarrowFirstHeight B (γ ω)} := by
+  let gp := sourceTracePath γ (fun ω => (hw ω).1)
+  let q := P {ω | gp ω ∈ narrowRiseEvent 1}
+  have hq : 0 < q := narrowRiseEvent_positive P γ hpublished zero_lt_one
+  refine ⟨q, hq, ?_⟩
+  intro B hB
+  let c : ℝ≥0 := ⟨B, hB.le⟩
+  have he := narrowRise_probability_scaling κ hκ hκ8 B₀ hB₀ hm hc γ G F hw c hB 1
+  have he' : P {ω | gp ω ∈ narrowRiseEvent B} = q := by
+    have hcval : (c : ℝ) = B := rfl
+    change P {ω | gp ω ∈ narrowRiseEvent ((c : ℝ) * 1)} = q at he
+    simpa only [hcval, mul_one] using he
+  rw [← he']
+  apply measure_mono
+  intro ω hω
+  exact narrowRiseEvent_gives_first_height hB (gp ω) (hw ω).2.1 (hw ω).2.2.1 hω
+
+end SLEExactGauge.FirstHeightSupport
+
+end
+
+end OAI
diff --git a/lean/OAI/Probability/SLE/Geometry/FirstHeightSupport.lean b/lean/OAI/Probability/SLE/Geometry/FirstHeightSupport.lean
new file mode 100644
index 0000000000000000000000000000000000000000..637fe8ae1a7fee817fdca299ce1ddd030dca7f7d
--- /dev/null
+++ b/lean/OAI/Probability/SLE/Geometry/FirstHeightSupport.lean
@@ -0,0 +1,191 @@
+import OAI.Probability.SLE.Geometry.GeometricTubeSupport
+import OAI.Probability.SLE.Gauge.RibbonSurvival
+import OAI.Probability.SLE.RadiusClocks
+
+namespace OAI
+
+/-!
+Positive probability of a narrow first-height crossing. The deterministic
+first crossing is finite, positive, fresh, and its entire past lies in the
+initial rectangle. A vertical supported path supplies the positive-probability
+event at each fixed spatial scale.
+-/
+
+noncomputable section
+open Set Filter MeasureTheory ProbabilityTheory Metric
+open scoped Topology NNReal ENNReal unitInterval
+
+namespace SLEExactGauge.FirstHeightSupport
+
+/-- The first capacity time at which the trace reaches the specified height. -/
+def firstHeightTime (γ : ℝ≥0 → ℂ) (h : ℝ) : WithTop ℝ≥0 :=
+  hittingAfter (fun t (_ : Unit) => (γ t).im - h) {0} 0 ()
+
+/-- The actual first-height time is a stopping time for an adapted
+continuous trace. -/
+theorem firstHeightTime_isStoppingTime
+    {Ω : Type*} [m : MeasurableSpace Ω] (ℱ : Filtration ℝ≥0 m)
+    (γ : Ω → ℝ≥0 → ℂ) (hγa : Adapted ℱ (fun t ω => γ ω t))
+    (hγc : ∀ ω, Continuous (γ ω)) (h : ℝ) :
+    IsStoppingTime ℱ (fun ω => firstHeightTime (γ ω) h) := by
+  have hs := continuous_zero_hit_stopping ℱ (fun t ω => (γ ω t).im - h)
+    (fun t => (Complex.continuous_im.measurable.comp (hγa t)).sub_const h)
+    (fun ω => (Complex.continuous_im.comp (hγc ω)).sub continuous_const) 0
+  change IsStoppingTime ℱ (hittingAfter (fun t ω => (γ ω t).im - h) {0} 0)
+  exact hs
+
+/-- A continuous trace which rises above a positive height has a genuine
+first crossing. Every earlier point has strictly smaller height. -/
+theorem exists_first_height
+    (γ : ℝ≥0 → ℂ) (hγ : Continuous γ) (hγ0 : γ 0 = 0)
+    {h : ℝ} (hh : 0 < h) {T : ℝ≥0} (hT : h < (γ T).im) :
+    ∃ τ : ℝ≥0, firstHeightTime γ h = (τ : WithTop ℝ≥0) ∧ 0 < τ ∧ τ < T ∧
+      (γ τ).im = h ∧ ∀ u : ℝ≥0, u < τ → (γ u).im < h := by
+  have hcont : Continuous (fun t => (γ t).im) := Complex.continuous_im.comp hγ
+  let K := Icc (0 : ℝ≥0) T ∩ (fun t => (γ t).im) ⁻¹' {h}
+  have hK : IsCompact K := isCompact_Icc.inter_right
+    (isClosed_singleton.preimage hcont)
+  have hKn : K.Nonempty := by
+    obtain ⟨t, ht, he⟩ := intermediate_value_Icc (show (0 : ℝ≥0) ≤ T from bot_le)
+      hcont.continuousOn (show h ∈ Icc (γ 0).im (γ T).im by simpa [hγ0] using ⟨hh.le, hT.le⟩)
+    exact ⟨t, ht, he⟩
+  obtain ⟨τ, hτK, hmin⟩ := hK.exists_isLeast hKn
+  have hhit : (γ τ).im = h := hτK.2
+  have hτpos : 0 < τ := by
+    by_contra hn
+    have he : τ = 0 := le_antisymm (le_of_not_gt hn) bot_le
+    rw [he, hγ0, Complex.zero_im] at hhit
+    exact hh.ne' hhit.symm
+  have hτT : τ < T := lt_of_le_of_ne hτK.1.2 (by
+    intro he
+    rw [he] at hhit
+    exact (ne_of_gt hT) hhit)
+  have hprior (u : ℝ≥0) (hu : u < τ) : (γ u).im < h := by
+    by_contra hn
+    have huT : u ≤ T := hu.le.trans hτK.1.2
+    obtain ⟨v, hv, he⟩ := intermediate_value_Icc (show (0 : ℝ≥0) ≤ u from bot_le)
+      hcont.continuousOn
+      (show h ∈ Icc (γ 0).im (γ u).im by simpa [hγ0] using ⟨hh.le, le_of_not_gt hn⟩)
+    have hvK : v ∈ K := ⟨⟨bot_le, hv.2.trans huT⟩, he⟩
+    exact (not_le_of_gt hu) ((hmin hvK).trans hv.2)
+  have hleast : IsLeast {t : ℝ≥0 | 0 ≤ t ∧ (γ t).im - h ∈ ({0} : Set ℝ)} τ := by
+    refine ⟨⟨bot_le, by simp only [mem_singleton_iff, hhit, sub_self]⟩, ?_⟩
+    intro t ht
+    by_contra hn
+    have hl := hprior t (lt_of_not_ge hn)
+    have he : (γ t).im = h := sub_eq_zero.mp ht.2
+    exact (ne_of_lt hl) he
+  have htime : firstHeightTime γ h = (τ : WithTop ℝ≥0) := by
+    unfold firstHeightTime hittingAfter
+    rw [ite_eq_left ⟨τ, hleast.1⟩, hleast.csInf_eq]
+  exact ⟨τ, htime, hτpos, hτT, hhit, hprior⟩
+
+def narrowStrip (B : ℝ) : Set ℂ := {z | |z.re| < B / 16}
+
+def aboveQuarterHeight (B : ℝ) : Set ℂ := {z | B / 4 < z.im}
+
+/-- The measurable supported event used to obtain the narrow first crossing. -/
+def narrowRiseEvent (B : ℝ) : Set C(ℝ≥0, ℂ) :=
+  pathTubeEvent (narrowStrip B) (aboveQuarterHeight B)
+
+theorem isOpen_narrowRiseEvent (B : ℝ) : IsOpen (narrowRiseEvent B) :=
+  isOpen_pathTubeEvent (isOpen_lt Complex.continuous_re.abs continuous_const)
+    (isOpen_lt continuous_const Complex.continuous_im)
+
+local instance : MeasurableSpace C(ℝ≥0, ℂ) := borel _
+local instance : BorelSpace C(ℝ≥0, ℂ) := ⟨rfl⟩
+
+theorem measurableSet_narrowRiseEvent (B : ℝ) : MeasurableSet (narrowRiseEvent B) :=
+  (isOpen_narrowRiseEvent B).measurableSet
+
+def NarrowFirstHeight (B : ℝ) (γ : ℝ≥0 → ℂ) : Prop :=
+  ∃ τ : ℝ≥0, firstHeightTime γ (B / 4) = (τ : WithTop ℝ≥0) ∧ 0 < τ ∧
+    (γ τ).im = B / 4 ∧ |(γ τ).re| < B / 16 ∧
+    (∀ u : ℝ≥0, u < τ → (γ u).im < (γ τ).im) ∧
+    γ '' Icc 0 τ ⊆ GuideSplice.closedInitialRectangle B
+
+theorem narrowRiseEvent_gives_first_height
+    {B : ℝ} (hB : 0 < B) (p : C(ℝ≥0, ℂ)) (hp0 : p 0 = 0)
+    (hpH : ∀ t, 0 ≤ (p t).im) (hp : p ∈ narrowRiseEvent B) :
+    NarrowFirstHeight B p := by
+  obtain ⟨T, _, hstrip, habove⟩ := hp
+  obtain ⟨τ, htime, hτ, hτT, hhit, hprior⟩ :=
+    exists_first_height p p.continuous hp0 (by positivity : 0 < B / 4) habove
+  have hτstrip : |(p τ).re| < B / 16 := hstrip ⟨bot_le, hτT.le⟩
+  refine ⟨τ, htime, hτ, hhit, hτstrip, ?_, ?_⟩
+  · intro u hu
+    rw [hhit]
+    exact hprior u hu
+  · rintro z ⟨u, hu, rfl⟩
+    refine ⟨(hstrip ⟨bot_le, hu.2.trans hτT.le⟩).le, hpH u, ?_⟩
+    rcases eq_or_lt_of_le hu.2 with rfl | huτ
+    · exact hhit.le
+    · exact (hprior u huτ).le
+
+/-- A vertical reference path for the fixed-scale support event. -/
+def verticalPath (B : ℝ) : Path (0 : ℂ) (((B / 2 : ℝ) : ℂ) * Complex.I) where
+  toFun t := (((t : ℝ) * (B / 2) : ℝ) : ℂ) * Complex.I
+  continuous_toFun := (Complex.continuous_ofReal.comp
+    (continuous_subtype_val.mul continuous_const)).mul continuous_const
+  source' := by simp
+  target' := by simp
+
+@[simp] theorem verticalPath_apply (B : ℝ) (t : unitInterval) :
+    verticalPath B t = (((t : ℝ) * (B / 2) : ℝ) : ℂ) * Complex.I := rfl
+
+theorem verticalPath_injective {B : ℝ} (hB : 0 < B) : Function.Injective (verticalPath B) := by
+  intro s t he
+  have hi := congrArg Complex.im he
+  simp only [verticalPath_apply, Complex.mul_im, Complex.ofReal_re,
+    Complex.I_im, mul_one, Complex.ofReal_im, Complex.I_re, mul_zero, add_zero] at hi
+  apply Subtype.ext
+  nlinarith
+
+theorem narrowRiseEvent_positive
+    {Ω : Type*} [MeasurableSpace Ω] (P : Measure Ω)
+    (γ : Ω → ℝ≥0 → ℂ) (hpublished : PublishedGeometricTubeSupport P γ)
+    {B : ℝ} (hB : 0 < B) :
+    0 < P {ω | ∃ T : ℝ≥0, 0 < T ∧ MapsTo (γ ω) (Icc 0 T) (narrowStrip B) ∧
+      γ ω T ∈ aboveQuarterHeight B} := by
+  apply hpublished _ (verticalPath B) (verticalPath_injective hB)
+  · intro t ht
+    change 0 < (verticalPath B t).im
+    simp only [verticalPath_apply, Complex.mul_im, Complex.ofReal_re,
+      Complex.I_im, mul_one, Complex.ofReal_im, Complex.I_re, mul_zero, add_zero]
+    have ht0 : 0 < (t : ℝ) := by
+      by_contra hn
+      have he : (t : ℝ) = 0 := le_antisymm (le_of_not_gt hn) t.property.1
+      exact ht (Subtype.ext he)
+    exact mul_pos ht0 (by positivity)
+  · exact isOpen_lt (Complex.continuous_re.abs) continuous_const
+  · exact isOpen_lt continuous_const Complex.continuous_im
+  · rintro z ⟨t, rfl⟩
+    change |(verticalPath B t).re| < B / 16
+    simpa only [verticalPath_apply, Complex.mul_re, Complex.ofReal_re, Complex.I_re,
+      Complex.ofReal_im, Complex.I_im, mul_zero, zero_mul, sub_zero, abs_zero] using
+      (show (0 : ℝ) < B / 16 by positivity)
+  · change B / 4 < (((B / 2 : ℝ) : ℂ) * Complex.I).im
+    simpa only [Complex.mul_im, Complex.ofReal_re, Complex.I_im, mul_one,
+      Complex.ofReal_im, Complex.I_re, mul_zero, add_zero] using
+      (show B / 4 < B / 2 by linarith)
+
+/-- Ordinary SLE has positive probability of a finite positive first-height
+crossing with fresh tip and rectangle-contained past, at each fixed scale. -/
+theorem narrowFirstHeight_positive
+    {Ω : Type*} [MeasurableSpace Ω] (P : Measure Ω)
+    (κ : ℝ) (γ : Ω → ℝ≥0 → ℂ) (hSLE : IsOrdinaryChordalSLE κ γ P)
+    (hpublished : PublishedGeometricTubeSupport P γ) {B : ℝ} (hB : 0 < B) :
+    0 < P {ω | NarrowFirstHeight B (γ ω)} := by
+  obtain ⟨_, _, htrace⟩ := hSLE.2
+  have hpos := narrowRiseEvent_positive P γ hpublished hB
+  refine hpos.trans_le (measure_mono_ae ?_)
+  filter_upwards [htrace] with ω hω
+  intro hωrise
+  obtain ⟨G, F, hw⟩ := hω
+  exact narrowRiseEvent_gives_first_height hB ⟨γ ω, hw.1⟩ hw.2.1 hw.2.2.1 hωrise
+
+end SLEExactGauge.FirstHeightSupport
+
+end
+
+end OAI
diff --git a/lean/OAI/Probability/SLE/Geometry/FirstSuccessfulPast.lean b/lean/OAI/Probability/SLE/Geometry/FirstSuccessfulPast.lean
new file mode 100644
index 0000000000000000000000000000000000000000..28bd6146d63250611707c5da704b11e445bd0f58
--- /dev/null
+++ b/lean/OAI/Probability/SLE/Geometry/FirstSuccessfulPast.lean
@@ -0,0 +1,138 @@
+import OAI.Probability.SLE.Mass.StrictPastMass
+
+namespace OAI
+
+/-! The finite first-success partition in the strict past-mass identity.
+A later successful test outside the visited trace is detected by its first
+successful predecessor, whose entire event is already in that earlier past. -/
+
+noncomputable section
+open Set Filter _root_.MeasureTheory _root_.OAI.MeasureTheory ProbabilityTheory
+open scoped Topology NNReal ENNReal
+attribute [local instance] Classical.propDecidable
+
+namespace SLEExactGauge.Multipoint
+
+variable {Ω : Type*}
+
+def firstPastSuccess (I : Finset ℝ≥0) (E : ℝ≥0 → Set Ω) (t : ℝ≥0) : Set Ω :=
+  E t \ ⋃ s ∈ I.filter (fun s => s < t), E s
+
+lemma mem_firstPastSuccess_iff (I : Finset ℝ≥0) (E : ℝ≥0 → Set Ω) (t : ℝ≥0) (ω : Ω) :
+    ω∈firstPastSuccess I E t ↔ ω∈E t ∧ ∀ s∈I, s < t → ω∉E s := by
+  simp [firstPastSuccess]
+
+lemma exists_firstPastSuccess (I : Finset ℝ≥0) (E : ℝ≥0 → Set Ω) (ω : Ω)
+    (h : ∃ t∈I, ω∈E t) :
+    ∃ t∈I, ω∈firstPastSuccess I E t ∧ ∀ s∈I, ω∈E s → t ≤ s := by
+  classical
+  let J := I.filter (fun t => ω∈E t)
+  have hJ : J.Nonempty := by
+    obtain ⟨t,ht,hE⟩ := h
+    exact ⟨t,Finset.mem_filter.mpr ⟨ht,hE⟩⟩
+  let t := J.min' hJ
+  have ht : t∈J := Finset.min'_mem J hJ
+  refine ⟨t,(Finset.mem_filter.mp ht).1,?_,?_⟩
+  · rw [mem_firstPastSuccess_iff]
+    refine ⟨(Finset.mem_filter.mp ht).2,?_⟩
+    intro s hs hst hEs
+    exact (not_le_of_gt hst) (Finset.min'_le J s (Finset.mem_filter.mpr ⟨hs,hEs⟩))
+  · intro s hs hEs
+    exact Finset.min'_le J s (Finset.mem_filter.mpr ⟨hs,hEs⟩)
+
+lemma firstPastSuccess_disjoint (I : Finset ℝ≥0) (E : ℝ≥0 → Set Ω)
+    {s t : ℝ≥0} (hs : s∈I) (ht : t∈I) (hne : s≠t) :
+    Disjoint (firstPastSuccess I E s) (firstPastSuccess I E t) := by
+  rw [Set.disjoint_left]
+  intro ω hωs hωt
+  rw [mem_firstPastSuccess_iff] at hωs hωt
+  rcases lt_or_gt_of_ne hne with hst | hts
+  · exact hωt.2 s hs hst hωs.1
+  · exact hωs.2 t ht hts hωt.1
+
+lemma firstPastSuccess_measurable [mΩ : MeasurableSpace Ω]
+    (ℱ : Filtration ℝ≥0 mΩ) (I : Finset ℝ≥0) (E : ℝ≥0 → Set Ω)
+    (hE : ∀ t∈I, MeasurableSet[ℱ t] (E t)) {t : ℝ≥0} (ht : t∈I) :
+    MeasurableSet[ℱ t] (firstPastSuccess I E t) := by
+  classical
+  apply (hE t ht).diff
+  apply Finset.measurableSet_biUnion
+  intro s hs
+  obtain ⟨hs,hst⟩ := Finset.mem_filter.mp hs
+  exact (ℱ.mono hst.le) _ (hE s hs)
+
+lemma firstPastSuccess_future_union {X : Type*}
+    (I : Finset ℝ≥0) (E : ℝ≥0 → Set Ω) (A : ℝ≥0 → Set X) (hA : Monotone A) (ω : Ω) :
+    (⋃ t∈I, if ω∈E t then (A t)ᶜ else ∅)=
+      ⋃ t∈I, if ω∈firstPastSuccess I E t then (A t)ᶜ else ∅ := by
+  classical
+  ext z
+  constructor
+  · intro hz
+    obtain ⟨t,ht,hz⟩ := mem_iUnion₂.mp hz
+    split_ifs at hz with hEt
+    · obtain ⟨s,hs,hEs,hst⟩ := exists_firstPastSuccess I E ω ⟨t,ht,hEt⟩
+      apply mem_iUnion₂.mpr
+      refine ⟨s,hs,?_⟩
+      rw [ite_eq_left hEs]
+      exact fun hzs => hz (hA (hst t ht hEt) hzs)
+    · exact False.elim (notMem_empty z hz)
+  · intro hz
+    obtain ⟨t,ht,hz⟩ := mem_iUnion₂.mp hz
+    split_ifs at hz with hEt
+    · apply mem_iUnion₂.mpr
+      refine ⟨t,ht,?_⟩
+      rw [ite_eq_left ((mem_firstPastSuccess_iff I E t ω).mp hEt).1]
+      exact hz
+    · exact False.elim (notMem_empty z hz)
+
+lemma firstPastSuccess_unique (I : Finset ℝ≥0) (E : ℝ≥0 → Set Ω) (ω : Ω)
+    {s t : ℝ≥0} (hs : s∈I) (ht : t∈I)
+    (hωs : ω∈firstPastSuccess I E s) (hωt : ω∈firstPastSuccess I E t) : s=t := by
+  by_contra hne
+  exact Set.disjoint_left.mp (firstPastSuccess_disjoint I E hs ht hne) hωs hωt
+
+lemma firstPastSuccess_future_mass {X : Type*} [MeasurableSpace X]
+    (μ : Measure X) (K : Set X) (I : Finset ℝ≥0) (E : ℝ≥0 → Set Ω)
+    (A : ℝ≥0 → Set X) (hA : Monotone A) (ω : Ω) :
+    μ (K ∩ ⋃ t∈I, if ω∈E t then (A t)ᶜ else ∅)=
+      ∑ t∈I, if ω∈firstPastSuccess I E t then μ (K \ A t) else 0 := by
+  classical
+  rw [firstPastSuccess_future_union I E A hA ω]
+  by_cases hex : ∃ t∈I, ω∈E t
+  · obtain ⟨s,hs,hωs,_⟩ := exists_firstPastSuccess I E ω hex
+    have he : (⋃ t∈I, if ω∈firstPastSuccess I E t then (A t)ᶜ else ∅)=(A s)ᶜ := by
+      ext z
+      constructor
+      · intro hz
+        obtain ⟨t,ht,hz⟩ := mem_iUnion₂.mp hz
+        split_ifs at hz with hωt
+        · have hts := firstPastSuccess_unique I E ω ht hs hωt hωs
+          simpa only [hts] using hz
+        · exact False.elim (notMem_empty z hz)
+      · intro hz
+        exact mem_iUnion₂.mpr ⟨s,hs,by simpa only [ite_eq_left hωs] using hz⟩
+    rw [he]
+    symm
+    rw [Finset.sum_eq_single s]
+    · simp only [ite_eq_left hωs,sdiff_eq_compl_inter,inter_comm]
+    · intro t ht hts
+      have hnot : ω∉firstPastSuccess I E t := fun h => hts (firstPastSuccess_unique I E ω ht hs h hωs)
+      simp only [ite_eq_right hnot]
+    · exact fun h => False.elim (h hs)
+  · have hn (t) (ht : t∈I) : ω∉firstPastSuccess I E t :=
+      fun h => hex ⟨t,ht,((mem_firstPastSuccess_iff I E t ω).mp h).1⟩
+    have he : (⋃ t∈I, if ω∈firstPastSuccess I E t then (A t)ᶜ else ∅)=∅ := by
+      apply eq_empty_iff_forall_notMem.mpr
+      intro z hz
+      obtain ⟨t,ht,hz⟩ := mem_iUnion₂.mp hz
+      simp only [ite_eq_right (hn t ht),notMem_empty] at hz
+    rw [he,inter_empty,measure_empty]
+    symm
+    exact Finset.sum_eq_zero (fun t ht => by simp only [ite_eq_right (hn t ht)])
+
+end SLEExactGauge.Multipoint
+
+end
+
+end OAI
diff --git a/lean/OAI/Probability/SLE/Geometry/FixedCanonicalRestart.lean b/lean/OAI/Probability/SLE/Geometry/FixedCanonicalRestart.lean
new file mode 100644
index 0000000000000000000000000000000000000000..4e602489fa51da9080ebb2423b5e633f6fe34838
--- /dev/null
+++ b/lean/OAI/Probability/SLE/Geometry/FixedCanonicalRestart.lean
@@ -0,0 +1,93 @@
+import OAI.Probability.SLE.Geometry.NormalizedCanonicalRestart
+
+namespace OAI
+
+/-! Normalized restarting with a single fixed canonical trace factor.
+The factor and hence its dense-experiment constants are chosen before the
+stopping time and the stopped-past normalization scale. -/
+
+noncomputable section
+open Set Filter MeasureTheory ProbabilityTheory
+open scoped Topology NNReal ENNReal
+
+namespace SLEExactGauge
+
+local instance fixedCanonicalDriverMeasurable : MeasurableSpace C(ℝ≥0, ℝ) := borel _
+local instance fixedCanonicalDriverBorel : BorelSpace C(ℝ≥0, ℝ) := ⟨rfl⟩
+local instance fixedCanonicalPathMeasurable : MeasurableSpace C(ℝ≥0, ℂ) := borel _
+local instance fixedCanonicalPathBorel : BorelSpace C(ℝ≥0, ℂ) := ⟨rfl⟩
+
+theorem source_normalized_restart_with_factor
+    {Ω : Type*} [mΩ : 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 → ℂ) (G F : Ω → ℝ≥0 → ℂ → ℂ)
+    (hw : ∀ ω, IsCapacityTwoWitness (fun t => Real.sqrt κ * B t ω) (γ ω) (G ω) (F ω))
+    (Φ : C(ℝ≥0, ℝ) → C(ℝ≥0, ℂ)) (hΦ : Measurable Φ)
+    (Gc Fc : C(ℝ≥0, ℝ) → ℝ≥0 → ℂ → ℂ)
+    (hW : ∀ᵐ p ∂P.map (sourceDriverPath B hc),
+      IsCapacityTwoWitness (fun t => Real.sqrt κ * p t) (Φ p) (Gc p) (Fc p))
+    (hboundary : PublishedFiniteLoewnerBoundaryExtension)
+    (τ : Ω → ℝ≥0)
+    (hτ : IsStoppingTime (Filtration.natural B (fun t => (hm t).stronglyMeasurable))
+      (fun ω => (τ ω : WithTop ℝ≥0)))
+    (a : Ω → ℝ≥0) (ham : Measurable[hτ.measurableSpace] a) (ha : ∀ ω, 0 < a ω) :
+    ∃ Fb : Ω → C(closedHalfPlane, ℂ),
+      Measurable[hτ.measurableSpace] Fb ∧
+      Measurable (normalizedRestartDriverPath B hc τ a) ∧
+      (∀ᵐ ω ∂P, Φ (sourceDriverPath B hc ω) = sourceTracePath γ (fun ω => (hw ω).1) ω) ∧
+      (∀ ω (z : closedHalfPlane), z.1 ∈ upperHalfPlane →
+        Fb ω z = F ω (τ ω) ((a ω : ℂ) * z + (Real.sqrt κ * B (τ ω) ω : ℝ))) ∧
+      (∀ ω, Fb ω ⟨0, by simp [closedHalfPlane]⟩ = γ ω (τ ω)) ∧
+      (∀ A : Set Ω, MeasurableSet[hτ.measurableSpace] A →
+        (P.restrict A).map (normalizedRestartDriverPath B hc τ a) =
+          P A • P.map (sourceDriverPath B hc)) ∧
+      ∀ᵐ ω ∂P,
+        IsCapacityTwoWitness
+          (normalizedRestartDriver (fun t => Real.sqrt κ * B t ω) (τ ω) (a ω))
+          (Φ (normalizedRestartDriverPath B hc τ a ω))
+          (Gc (normalizedRestartDriverPath B hc τ a ω))
+          (Fc (normalizedRestartDriverPath B hc τ a ω)) ∧
+        ∀ t : ℝ≥0, γ ω (τ ω + (a ω) ^ 2 * t) =
+          finiteBoundaryPath (Fb ω) (Φ (normalizedRestartDriverPath B hc τ a ω)) t := by
+  have hpublished : PublishedTraceGeneration (P.map (sourceDriverPath B hc)) κ
+      (fun t p => p t) := by
+    refine ⟨fun p t => Φ p t, fun t => (continuous_eval_const t).measurable.comp hΦ, ?_⟩
+    filter_upwards [hW] with p hp
+    exact ⟨Gc p, Fc p, hp⟩
+  obtain ⟨Ψ, GΨ, FΨ, Fb, hΨ, hFb, hYm, hΨorig, hΨW, hFbEq, hFb0, hYlaw, hΨrestart⟩ :=
+    source_normalized_canonical_witness_boundary_restart κ hκ hκ8 B hB hm hc γ G F hw
+      hpublished hboundary τ hτ a ham ha
+  let bp := sourceDriverPath B hc
+  let Y := normalizedRestartDriverPath B hc τ a
+  have hbp : Measurable bp := source_path_measurable bp hm
+  have heq : ∀ᵐ p ∂P.map bp, Φ p = Ψ p := by
+    filter_upwards [hW, hΨW] with p hp hΨp
+    ext t
+    exact congrFun (hp.trace_unique hΨp) t
+  have heqBp : ∀ᵐ ω ∂P, Φ (bp ω) = Ψ (bp ω) :=
+    ae_of_ae_map (p := fun p => Φ p = Ψ p) hbp.aemeasurable heq
+  have hYlaw₀ : P.map Y = P.map bp := by
+    simpa only [Measure.restrict_univ, measure_univ, one_smul] using
+      hYlaw univ MeasurableSet.univ
+  have heqY : ∀ᵐ ω ∂P, Φ (Y ω) = Ψ (Y ω) := by
+    apply ae_of_ae_map (p := fun p => Φ p = Ψ p) hYm.aemeasurable
+    rwa [hYlaw₀]
+  have hYw := canonical_witness_pullback hW Y hYm hYlaw₀
+  refine ⟨Fb, hFb, hYm, ?_, hFbEq, hFb0, hYlaw, ?_⟩
+  · filter_upwards [heqBp, hΨorig] with ω hω hΨω
+    exact hω.trans hΨω
+  · filter_upwards [hYw, heqY, hΨrestart] with ω hω heω hrestart
+    refine ⟨?_, ?_⟩
+    · rw [← normalizedRestartDriverPath_driver κ B hc τ a ω]
+      exact hω
+    · intro t
+      rw [heω]
+      exact hrestart.2 t
+
+end SLEExactGauge
+
+end
+
+end OAI
diff --git a/lean/OAI/Probability/SLE/Geometry/FrontClockChange.lean b/lean/OAI/Probability/SLE/Geometry/FrontClockChange.lean
new file mode 100644
index 0000000000000000000000000000000000000000..e02294cc2ac6378022ad8030634813bc19522508
--- /dev/null
+++ b/lean/OAI/Probability/SLE/Geometry/FrontClockChange.lean
@@ -0,0 +1,131 @@
+import OAI.Probability.SLE.Gauge.UniformFrontPassage
+
+namespace OAI
+
+/-! The exact change of capacity clock in a first-front passage. Ordered
+time changes preserve the stopped trace segment and its sausage, including
+the attained first front and terminal offset. This applies to the positive
+linear clocks arising from normalized Loewner charts. -/
+
+noncomputable section
+open Set Filter MeasureTheory
+open scoped Topology NNReal ENNReal
+
+namespace SLEExactGauge.FrontClockChange
+open FirstFrontPassage PassageSuccess
+
+theorem firstFrontTime_of_clock_hit
+    (e : ℝ≥0 ≃o ℝ≥0) (x : ℝ≥0 → ℝ) (q : ℝ) (τ : ℝ≥0)
+    (hfirst : firstFrontTime (fun t => x (e t)) q = (τ : WithTop ℝ≥0))
+    (hhit : x (e τ) = q) :
+    firstFrontTime x q = (e τ : WithTop ℝ≥0) := by
+  have hleast : IsLeast {t : ℝ≥0 | 0 ≤ t ∧ x t - q ∈ ({0} : Set ℝ)} (e τ) := by
+    refine ⟨⟨bot_le, by simp only [hhit, sub_self, mem_singleton_iff]⟩, ?_⟩
+    intro t ht
+    have hh := hittingAfter_le_of_mem
+      (u := fun s (_ : Unit) => x (e s) - q) (ω := ())
+      (show (0 : ℝ≥0) ≤ e.symm t from bot_le)
+      (show x (e (e.symm t)) - q ∈ ({0} : Set ℝ) by simpa only [e.apply_symm_apply] using ht.2)
+    change firstFrontTime (fun s => x (e s)) q ≤ (e.symm t : WithTop ℝ≥0) at hh
+    rw [hfirst, WithTop.coe_le_coe] at hh
+    simpa only [e.apply_symm_apply] using e.monotone hh
+  unfold firstFrontTime hittingAfter
+  rw [ite_eq_left ⟨e τ, hleast.1⟩, hleast.csInf_eq]
+
+theorem sourceSausageSet_clock
+    (e : ℝ≥0 ≃o ℝ≥0) (γ : ℝ≥0 → ℂ) (s t : ℝ≥0) (v : ℝ) :
+    sourceSausageSet (fun u => γ (e u)) s t v = sourceSausageSet γ (e s) (e t) v := by
+  ext z
+  constructor
+  · rintro ⟨u, hu, hd⟩
+    exact ⟨e u, ⟨e.monotone hu.1, e.monotone hu.2⟩, hd⟩
+  · rintro ⟨u, hu, hd⟩
+    refine ⟨e.symm u, ⟨?_, ?_⟩, ?_⟩
+    · exact (e.le_iff_le).mp (by simpa only [e.apply_symm_apply] using hu.1)
+    · exact (e.le_iff_le).mp (by simpa only [e.apply_symm_apply] using hu.2)
+    · simpa only [e.apply_symm_apply] using hd
+
+theorem segmentSausageCharge_clock
+    (e : ℝ≥0 ≃o ℝ≥0) (κ : ℝ) (γ : ℝ≥0 → ℂ)
+    (s t : ℝ≥0) (v : ℝ) (R : Set ℂ) :
+    segmentSausageCharge κ (fun u => γ (e u)) s t v R =
+      segmentSausageCharge κ γ (e s) (e t) v R := by
+  simp only [segmentSausageCharge, sourceSausageSet_clock]
+
+theorem frontSuccess_clock_transport
+    {Ω : Type*} (e : ℝ≥0 ≃o ℝ≥0) (η : Ω → ℝ≥0 → ℂ)
+    (p : ℂ → ℝ) (σ : Ω → ℝ≥0) (V : Set ℂ) (a : ℂ) (ε : ℝ)
+    (ω : Ω)
+    (hω : ω ∈ FrontSuccess (fun _ ω t => η ω (e t)) (fun _ => p) σ
+      (fun _ => V) (fun _ => a) ε 0) :
+    ω ∈ FrontSuccess (fun _ => η) (fun _ => p) (fun ω => e (σ ω))
+      (fun _ => V) (fun _ => a) ε 0 ∧
+      frontTime (fun t => p (η ω t)) 1 =
+        e (frontTime (fun t => p (η ω (e t))) 1) := by
+  obtain ⟨hf, hh, hs, hpath, hend⟩ := hω
+  let τ := frontTime (fun t => p (η ω (e t))) 1
+  have hf' := firstFrontTime_of_clock_hit e (fun t => p (η ω t)) 1 τ hf hh
+  have ht : frontTime (fun t => p (η ω t)) 1 = e τ := by
+    simp only [frontTime, hf', WithTop.untopD_coe]
+  refine ⟨?_, ht⟩
+  change _ ∧ _ ∧ _ ∧ _ ∧ _
+  rw [ht]
+  refine ⟨hf', hh, e.strictMono hs, ?_, hend⟩
+  intro t ht'
+  have hmem : e.symm t ∈ Icc 0 τ := by
+    refine ⟨bot_le, ?_⟩
+    exact (e.le_iff_le).mp (by simpa only [e.apply_symm_apply] using ht'.2)
+  simpa only [e.apply_symm_apply] using hpath hmem
+
+theorem frontSuccess_clock_iff
+    {Ω : Type*} (e : ℝ≥0 ≃o ℝ≥0) (η : Ω → ℝ≥0 → ℂ)
+    (p : ℂ → ℝ) (σ : Ω → ℝ≥0) (V : Set ℂ) (a : ℂ) (ε : ℝ) (ω : Ω) :
+    ω ∈ FrontSuccess (fun _ ω t => η ω (e t)) (fun _ => p)
+        (fun ω => e.symm (σ ω)) (fun _ => V) (fun _ => a) ε 0 ↔
+      ω ∈ FrontSuccess (fun _ => η) (fun _ => p) σ (fun _ => V) (fun _ => a) ε 0 := by
+  constructor
+  · intro h
+    simpa only [e.apply_symm_apply] using
+      (frontSuccess_clock_transport e η p (fun ω => e.symm (σ ω)) V a ε ω h).1
+  · intro h
+    have hh : ω ∈ FrontSuccess
+        (fun _ ω t => (fun u => η ω (e u)) (e.symm t))
+        (fun _ => p) σ (fun _ => V) (fun _ => a) ε 0 := by
+      simpa only [e.apply_symm_apply] using h
+    exact (frontSuccess_clock_transport e.symm (fun ω t => η ω (e t)) p σ V a ε ω hh).1
+
+/-- The full success-and-mass event is unchanged by capacity-clock
+normalization. It is an exact event identity, before taking probabilities. -/
+theorem frontSuccess_mass_clock
+    {Ω : Type*} (e : ℝ≥0 ≃o ℝ≥0) (η : Ω → ℝ≥0 → ℂ)
+    (p : ℂ → ℝ) (σ : Ω → ℝ≥0) (V : Set ℂ) (a : ℂ) (ε κ v c : ℝ) (R : Set ℂ) :
+    {ω | ω ∈ FrontSuccess (fun _ ω t => η ω (e t)) (fun _ => p)
+        (fun ω => e.symm (σ ω)) (fun _ => V) (fun _ => a) ε 0 ∧
+      ENNReal.ofReal c ≤ segmentSausageCharge κ (fun t => η ω (e t))
+        (e.symm (σ ω)) (frontTime (fun t => p (η ω (e t))) 1) v R} =
+    {ω | ω ∈ FrontSuccess (fun _ => η) (fun _ => p) σ
+        (fun _ => V) (fun _ => a) ε 0 ∧
+      ENNReal.ofReal c ≤ segmentSausageCharge κ (η ω) (σ ω)
+        (frontTime (fun t => p (η ω t)) 1) v R} := by
+  ext ω
+  constructor
+  · rintro ⟨hs, hm⟩
+    obtain ⟨hs', ht⟩ := frontSuccess_clock_transport e η p (fun ω => e.symm (σ ω))
+      V a ε ω hs
+    simp only [e.apply_symm_apply] at hs'
+    refine ⟨hs', ?_⟩
+    rw [segmentSausageCharge_clock, e.apply_symm_apply, ← ht] at hm
+    exact hm
+  · rintro ⟨hs, hm⟩
+    have hs' := (frontSuccess_clock_iff e η p σ V a ε ω).mpr hs
+    have ht := (frontSuccess_clock_transport e η p (fun ω => e.symm (σ ω))
+      V a ε ω hs').2
+    refine ⟨hs', ?_⟩
+    rw [segmentSausageCharge_clock, e.apply_symm_apply, ← ht]
+    exact hm
+
+end SLEExactGauge.FrontClockChange
+
+end
+
+end OAI
diff --git a/lean/OAI/Probability/SLE/Geometry/FrontSuccessMeasurability.lean b/lean/OAI/Probability/SLE/Geometry/FrontSuccessMeasurability.lean
new file mode 100644
index 0000000000000000000000000000000000000000..4ea4c1a97f12af6afc5b9e9972ba9454e4c2889c
--- /dev/null
+++ b/lean/OAI/Probability/SLE/Geometry/FrontSuccessMeasurability.lean
@@ -0,0 +1,259 @@
+import OAI.Probability.SLE.Gauge.PassageSuccess
+import Mathlib.Topology.TietzeExtension
+
+namespace OAI
+
+/-! Measurable actual front passages. Local ribbon coordinates are extended
+from their closed patch only to construct an adapted stopping time; on every
+successful passage this stopping time is exactly the original first front. -/
+
+noncomputable section
+open Set Filter MeasureTheory ProbabilityTheory Metric
+open scoped Topology NNReal ENNReal
+
+namespace SLEExactGauge.FrontSuccessMeasurability
+open FirstFrontPassage PassageSuccess
+
+local instance frontSuccessPathMeasurable : MeasurableSpace C(ℝ≥0, ℂ) := borel _
+local instance frontSuccessPathBorel : BorelSpace C(ℝ≥0, ℂ) := ⟨rfl⟩
+
+/-- Freeze a continuous path outside a finite time interval. -/
+def clampedPath (f : C(ℝ≥0, ℂ)) (s t : ℝ≥0) : C(ℝ≥0, ℂ) :=
+  f.comp ⟨fun u => max s (min u t), continuous_const.max (continuous_id.min continuous_const)⟩
+
+theorem measurable_clampedPath
+    {Ω : Type*} [MeasurableSpace Ω] (f : Ω → C(ℝ≥0, ℂ)) (hf : Measurable f)
+    (s t : Ω → ℝ≥0) (hs : Measurable s) (ht : Measurable t) :
+    Measurable (fun ω => clampedPath (f ω) (s ω) (t ω)) := by
+  apply source_path_measurable
+  intro u
+  exact continuous_eval.measurable.comp
+    (hf.prodMk (hs.max (measurable_const.min ht)))
+
+theorem sourceSausageSet_eq_clamped
+    (f : C(ℝ≥0, ℂ)) (s t : ℝ≥0) (hst : s ≤ t) (v : ℝ) :
+    sourceSausageSet f s t v = wholeSausageSet (clampedPath f s t) v := by
+  ext z
+  constructor
+  · rintro ⟨u, hu, hv⟩
+    refine ⟨u, ?_⟩
+    simpa only [clampedPath, ContinuousMap.comp_apply, ContinuousMap.coe_mk,
+      min_eq_left hu.2, max_eq_right hu.1, dist_comm] using hv
+  · rintro ⟨u, hv⟩
+    exact ⟨max s (min u t), ⟨le_max_left _ _, max_le hst (min_le_right _ _)⟩,
+      by simpa only [clampedPath, ContinuousMap.comp_apply, ContinuousMap.coe_mk, dist_comm] using hv⟩
+
+/-- Variable finite endpoints cause no measurability loss in the physical
+sausage charge. No stopping-time assumption on these endpoints is needed. -/
+theorem segmentSausageCharge_measurable
+    {Ω : Type*} [MeasurableSpace Ω] (f : Ω → C(ℝ≥0, ℂ)) (hf : Measurable f)
+    (s t : Ω → ℝ≥0) (hs : Measurable s) (ht : Measurable t)
+    (κ v : ℝ) (R : Set ℂ) :
+    Measurable (fun ω => segmentSausageCharge κ (f ω) (s ω) (t ω) v R) := by
+  have hm := (wholeSausageCharge_measurable κ v R).comp (measurable_clampedPath f hf s t hs ht)
+  have he (ω : Ω) : segmentSausageCharge κ (f ω) (s ω) (t ω) v R =
+      if s ω ≤ t ω then wholeSausageCharge κ (clampedPath (f ω) (s ω) (t ω)) v R else 0 := by
+    split_ifs with hst
+    · simp only [segmentSausageCharge, wholeSausageCharge, sourceSausageSet_eq_clamped _ _ _ hst]
+    · have hempty : sourceSausageSet (f ω) (s ω) (t ω) v = ∅ := by
+        apply Set.eq_empty_iff_forall_notMem.mpr
+        rintro z ⟨u, hu, _⟩
+        exact hst (hu.1.trans hu.2)
+      simp only [segmentSausageCharge, hempty, inter_empty, measure_empty, mul_zero]
+  simp_rw [he]
+  exact Measurable.ite (measurableSet_le hs ht) hm measurable_const
+
+/-- An open target and a measurable finite endpoint give a measurable
+whole-prefix containment event. -/
+theorem measurableSet_prefix_mapsTo
+    {Ω : Type*} [MeasurableSpace Ω] (f : Ω → C(ℝ≥0, ℂ)) (hf : Measurable f)
+    (t : Ω → ℝ≥0) (ht : Measurable t) (V : Set ℂ) (hV : IsOpen V) :
+    MeasurableSet {ω | MapsTo (f ω) (Icc 0 (t ω)) V} := by
+  let g := fun ω => clampedPath (f ω) 0 (t ω)
+  have hgm : Measurable g := measurable_clampedPath f hf (fun _ => 0) t measurable_const ht
+  have he : {ω | MapsTo (f ω) (Icc 0 (t ω)) V} =
+      ⋂ n : ℕ, {ω | MapsTo (g ω) (Icc 0 (n : ℝ≥0)) V} := by
+    ext ω
+    constructor
+    · intro h
+      apply mem_iInter.mpr
+      intro n u hu
+      exact h ⟨bot_le, by simp only [ContinuousMap.coe_mk, zero_le, max_eq_right, min_le_right]⟩
+    · intro h u hu
+      obtain ⟨n, hn⟩ := exists_nat_ge (u : ℝ)
+      have hnn : u ≤ (n : ℝ≥0) := by exact_mod_cast hn
+      have hh := (mem_iInter.mp h n) ⟨bot_le, hnn⟩
+      simpa only [g, clampedPath, ContinuousMap.comp_apply, ContinuousMap.coe_mk,
+        min_eq_left hu.2, max_eq_right (show (0 : ℝ≥0) ≤ u from bot_le)] using hh
+  rw [he]
+  exact MeasurableSet.iInter fun n =>
+    (ContinuousMap.isOpen_setOfPred_mapsTo isCompact_Icc hV).measurableSet.preimage hgm
+
+/-- Agreement through an attained first hit identifies the first hitting
+time, regardless of how the two coordinates are defined later. -/
+theorem firstFrontTime_eq_of_prefix
+    (x y : ℝ≥0 → ℝ) (q : ℝ) (τ : ℝ≥0)
+    (hx : firstFrontTime x q = (τ : WithTop ℝ≥0)) (hattain : x τ = q)
+    (hxy : EqOn x y (Icc 0 τ)) :
+    firstFrontTime y q = (τ : WithTop ℝ≥0) := by
+  have hleast : IsLeast {t : ℝ≥0 | 0 ≤ t ∧ y t - q ∈ ({0} : Set ℝ)} τ := by
+    refine ⟨⟨bot_le, ?_⟩, ?_⟩
+    · rw [← hxy ⟨bot_le, le_rfl⟩, hattain, sub_self]
+      exact mem_singleton 0
+    · intro t ht
+      by_contra hbad
+      have hlt : t < τ := lt_of_not_ge hbad
+      have hy : y t = q := sub_eq_zero.mp ht.2
+      have hxhit : x t - q ∈ ({0} : Set ℝ) := by
+        rw [hxy ⟨bot_le, hlt.le⟩, hy, sub_self]
+        exact mem_singleton 0
+      have hh := hittingAfter_le_of_mem (u := fun t (_ : Unit) => x t - q)
+        (ω := ()) (show (0 : ℝ≥0) ≤ t from bot_le) hxhit
+      change firstFrontTime x q ≤ (t : WithTop ℝ≥0) at hh
+      rw [hx, WithTop.coe_le_coe] at hh
+      exact (not_le_of_gt hlt) hh
+  unfold firstFrontTime hittingAfter
+  rw [ite_eq_left ⟨τ, hleast.1⟩, hleast.csInf_eq]
+
+/-- The concrete success event depends only on the coordinate inside its
+allowed region; the attained front equation makes this exact. -/
+theorem frontSuccess_eq_of_eqOn
+    {Ω : Type*} (η : ℕ → Ω → ℝ≥0 → ℂ) (p p' : ℕ → ℂ → ℝ)
+    (σ : Ω → ℝ≥0) (V : ℕ → Set ℂ) (a : ℕ → ℂ) (ε : ℝ) (n : ℕ)
+    (hpeq : EqOn (p n) (p' n) (V n)) :
+    FrontSuccess η p σ V a ε n = FrontSuccess η p' σ V a ε n := by
+  suffices hsub : ∀ (q q' : ℕ → ℂ → ℝ), EqOn (q n) (q' n) (V n) →
+      FrontSuccess η q σ V a ε n ⊆ FrontSuccess η q' σ V a ε n from
+    Subset.antisymm (hsub p p' hpeq) (hsub p' p hpeq.symm)
+  intro q q' hqq ω hω
+  let τ := frontTime (fun t => q n (η n ω t)) 1
+  obtain ⟨hfirst, hhit, hσ, hpath, hoffset⟩ := hω
+  have heq : EqOn (fun t => q n (η n ω t)) (fun t => q' n (η n ω t)) (Icc 0 τ) :=
+    fun t ht => hqq (hpath ht)
+  have hfirst' := firstFrontTime_eq_of_prefix _ _ 1 τ hfirst hhit heq
+  have ht : frontTime (fun t => q' n (η n ω t)) 1 = τ := by
+    simp only [frontTime, hfirst', WithTop.untopD_coe]
+  change firstFrontTime (fun t => q' n (η n ω t)) 1 = _ ∧ _
+  rw [ht]
+  exact ⟨hfirst', (heq ⟨bot_le, le_rfl⟩).symm.trans hhit, hσ, hpath, hoffset⟩
+
+/-- A globally continuous progress coordinate gives the actual adapted
+front stopping time, including the possibility of no hit. -/
+theorem firstFrontTime_stopping
+    {Ω : Type*} [m : MeasurableSpace Ω] (ℱ : Filtration ℝ≥0 m)
+    (η : Ω → ℝ≥0 → ℂ) (ha : Adapted ℱ (fun t ω => η ω t))
+    (hc : ∀ ω, Continuous (η ω)) (p : ℂ → ℝ) (hp : Continuous p) :
+    IsStoppingTime ℱ (fun ω => firstFrontTime (fun t => p (η ω t)) 1) :=
+  firstFrontTime_isStoppingTime ℱ (fun t ω => p (η ω t))
+    (fun t => hp.measurable.comp (ha t)) (fun ω => hp.comp (hc ω)) 1
+
+/-- Success is measurable when the progress coordinate is globally
+continuous; the next theorem removes this unnecessary global requirement. -/
+theorem measurableSet_frontSuccess_of_continuous
+    {Ω : Type*} [m : MeasurableSpace Ω] (ℱ : Filtration ℝ≥0 m)
+    (η : ℕ → Ω → ℝ≥0 → ℂ) (p : ℕ → ℂ → ℝ) (σ : Ω → ℝ≥0)
+    (V : ℕ → Set ℂ) (a : ℕ → ℂ) (ε : ℝ) (n : ℕ)
+    (ha : Adapted ℱ (fun t ω => η n ω t)) (hc : ∀ ω, Continuous (η n ω))
+    (hp : Continuous (p n)) (hσ : Measurable σ) (hV : IsOpen (V n)) :
+    MeasurableSet (FrontSuccess η p σ V a ε n) := by
+  let f := sourceTracePath (η n) hc
+  have hfm : Measurable f := source_path_measurable f
+    (fun t => (ha t).mono (ℱ.le t) le_rfl)
+  let τ := fun ω => frontTime (fun t => p n (η n ω t)) 1
+  have hfirst := firstFrontTime_stopping ℱ (η n) ha hc (p n) hp
+  have hτ : Measurable τ := hfirst.measurable'.untopD 0
+  have heval : Measurable (fun ω => η n ω (τ ω)) :=
+    continuous_eval.measurable.comp (hfm.prodMk hτ)
+  have hprefix := measurableSet_prefix_mapsTo f hfm τ hτ (V n) hV
+  have hset : MeasurableSet {ω |
+      firstFrontTime (fun t => p n (η n ω t)) 1 = (τ ω : WithTop ℝ≥0) ∧
+      p n (η n ω (τ ω)) = 1 ∧ σ ω < τ ω ∧
+      MapsTo (η n ω) (Icc 0 (τ ω)) (V n) ∧ ‖η n ω (τ ω) - a n‖ < ε / 4} :=
+    (measurableSet_eq_fun hfirst.measurable'
+      (WithTop.continuous_coe.measurable.comp hτ)).inter
+      ((measurableSet_eq_fun (hp.measurable.comp heval) measurable_const).inter
+        ((measurableSet_lt hσ hτ).inter
+          (hprefix.inter (measurableSet_lt (heval.sub_const _).norm measurable_const))))
+  exact hset
+
+/-- A closed physical ribbon patch supplies a continuous progress extension
+by the proved Tietze theorem. -/
+theorem exists_continuous_progress_extension
+    (p : ℂ → ℝ) (K : Set ℂ) (hK : IsClosed K) (hp : ContinuousOn p K) :
+    ∃ g : C(ℂ, ℝ), EqOn p g K := by
+  let f : C(K, ℝ) := ⟨fun z => p z, hp.domRestrict⟩
+  obtain ⟨g, hg⟩ := f.exists_restrict_eq hK
+  refine ⟨g, ?_⟩
+  intro z hz
+  have hh := congrArg (fun F : C(K, ℝ) => F ⟨z, hz⟩) hg
+  exact hh.symm
+
+/-- The original local front event is measurable, and agrees there with an
+adapted front stopping time obtained by extending the ribbon coordinate. -/
+theorem measurableSet_frontSuccess_of_continuousOn
+    {Ω : Type*} [m : MeasurableSpace Ω] (ℱ : Filtration ℝ≥0 m)
+    (η : ℕ → Ω → ℝ≥0 → ℂ) (p : ℕ → ℂ → ℝ) (σ : Ω → ℝ≥0)
+    (V : ℕ → Set ℂ) (a : ℕ → ℂ) (ε : ℝ) (n : ℕ)
+    (ha : Adapted ℱ (fun t ω => η n ω t)) (hc : ∀ ω, Continuous (η n ω))
+    (K : Set ℂ) (hK : IsClosed K) (hp : ContinuousOn (p n) K)
+    (hσ : Measurable σ) (hV : IsOpen (V n)) (hVK : V n ⊆ K) :
+    MeasurableSet (FrontSuccess η p σ V a ε n) ∧
+      ∃ ρ : Ω → WithTop ℝ≥0, IsStoppingTime ℱ ρ ∧
+        ∀ ω ∈ FrontSuccess η p σ V a ε n,
+          ρ ω = firstFrontTime (fun t => p n (η n ω t)) 1 := by
+  obtain ⟨g, hg⟩ := exists_continuous_progress_extension (p n) K hK hp
+  let p' : ℕ → ℂ → ℝ := fun _ => g
+  have heq := frontSuccess_eq_of_eqOn η p p' σ V a ε n (hg.mono hVK)
+  have hmeas := measurableSet_frontSuccess_of_continuous ℱ η p' σ V a ε n
+    ha hc g.continuous hσ hV
+  refine ⟨heq.symm ▸ hmeas, (fun ω => firstFrontTime (fun t => g (η n ω t)) 1),
+    firstFrontTime_stopping ℱ (η n) ha hc g g.continuous, ?_⟩
+  intro ω hω
+  obtain ⟨hfirst, hhit, _, hpath, _⟩ := hω
+  exact (firstFrontTime_eq_of_prefix _ _ 1 _ hfirst hhit
+    (fun t ht => hg (hVK (hpath ht)))).trans hfirst.symm
+
+/-- The full local-coordinate success-and-mass event is measurable. This is
+the concrete event used by the repeated ribbon passage argument. -/
+theorem measurableSet_frontSuccess_mass
+    {Ω : Type*} [m : MeasurableSpace Ω] (ℱ : Filtration ℝ≥0 m)
+    (η : ℕ → Ω → ℝ≥0 → ℂ) (p : ℕ → ℂ → ℝ) (σ : Ω → ℝ≥0)
+    (V : ℕ → Set ℂ) (a : ℕ → ℂ) (ε : ℝ) (n : ℕ)
+    (ha : Adapted ℱ (fun t ω => η n ω t)) (hc : ∀ ω, Continuous (η n ω))
+    (K : Set ℂ) (hK : IsClosed K) (hp : ContinuousOn (p n) K)
+    (hσ : Measurable σ) (hV : IsOpen (V n)) (hVK : V n ⊆ K)
+    (κ v c : ℝ) (R : Set ℂ) :
+    MeasurableSet {ω | ω ∈ FrontSuccess η p σ V a ε n ∧ ENNReal.ofReal c ≤
+      segmentSausageCharge κ (η n ω) (σ ω)
+        (frontTime (fun t => p n (η n ω t)) 1) v R} := by
+  obtain ⟨g, hg⟩ := exists_continuous_progress_extension (p n) K hK hp
+  let p' : ℕ → ℂ → ℝ := fun _ => g
+  have heq := frontSuccess_eq_of_eqOn η p p' σ V a ε n (hg.mono hVK)
+  let τ := fun ω => frontTime (fun t => g (η n ω t)) 1
+  have hτ : Measurable τ := (firstFrontTime_stopping ℱ (η n) ha hc g g.continuous).measurable'.untopD 0
+  let f := sourceTracePath (η n) hc
+  have hfm : Measurable f := source_path_measurable f
+    (fun t => (ha t).mono (ℱ.le t) le_rfl)
+  have hmass := segmentSausageCharge_measurable f hfm σ τ hσ hτ κ v R
+  have hm := (measurableSet_frontSuccess_of_continuous ℱ η p' σ V a ε n
+    ha hc g.continuous hσ hV).inter (measurableSet_le (measurable_const : Measurable (fun _ : Ω => ENNReal.ofReal c)) hmass)
+  convert hm using 1
+  ext ω
+  by_cases hω : ω ∈ FrontSuccess η p σ V a ε n
+  · have hω' : ω ∈ FrontSuccess η p' σ V a ε n := heq ▸ hω
+    have hωsave := hω
+    obtain ⟨hfirst, hhit, _, hpath, _⟩ := hω
+    have hfirst' := firstFrontTime_eq_of_prefix _ _ 1 _ hfirst hhit
+      (fun t ht => hg (hVK (hpath ht)))
+    have ht : τ ω = frontTime (fun t => p n (η n ω t)) 1 := by
+      simp only [τ, frontTime, hfirst', WithTop.untopD_coe]
+    simp only [mem_ofPred_eq, mem_inter_iff, hωsave, hω', true_and, ht]
+    rfl
+  · have hω' : ω ∉ FrontSuccess η p' σ V a ε n := by simpa only [← heq] using hω
+    simp only [mem_ofPred_eq, mem_inter_iff, hω, hω', false_and]
+
+end SLEExactGauge.FrontSuccessMeasurability
+
+end
+
+end OAI
diff --git a/lean/OAI/Probability/SLE/Geometry/FrontSuccessStopped.lean b/lean/OAI/Probability/SLE/Geometry/FrontSuccessStopped.lean
new file mode 100644
index 0000000000000000000000000000000000000000..c9dafa635799beb00595dc6e5d83b61c21d7d580
--- /dev/null
+++ b/lean/OAI/Probability/SLE/Geometry/FrontSuccessStopped.lean
@@ -0,0 +1,259 @@
+import OAI.Probability.SLE.Geometry.FrontSuccessMeasurability
+
+namespace OAI
+
+/-! The front success-and-mass event is measurable in the actual extended
+front past, not merely in the full path sigma algebra. -/
+
+noncomputable section
+open Set Filter MeasureTheory ProbabilityTheory Metric
+open scoped Topology NNReal ENNReal
+
+namespace SLEExactGauge.FrontSuccessMeasurability
+open FirstFrontPassage PassageSuccess
+
+local instance stoppedFrontPathMeasurable : MeasurableSpace C(ℝ≥0, ℂ) := borel _
+local instance stoppedFrontPathBorel : BorelSpace C(ℝ≥0, ℂ) := ⟨rfl⟩
+
+/-- Stop at a possibly infinite time, leaving the path running if no front
+is ever reached. -/
+def stoppedAtPath (f : C(ℝ≥0, ℂ)) (ρ : WithTop ℝ≥0) : C(ℝ≥0, ℂ) :=
+  if ρ = ⊤ then f else clampedPath f 0 (ρ.untopD 0)
+
+theorem stoppedAtPath_apply (f : C(ℝ≥0, ℂ)) (ρ : WithTop ℝ≥0) (t : ℝ≥0) :
+    stoppedAtPath f ρ t = f (min ρ (t : WithTop ℝ≥0)).untopA := by
+  cases ρ with
+  | top => simp only [stoppedAtPath, ite_true, min_top_left, WithTop.untopA, WithTop.untopD_coe]
+  | coe ρ => simp only [stoppedAtPath, WithTop.coe_ne_top, ite_false, WithTop.untopD_coe,
+      clampedPath, ContinuousMap.comp_apply, ContinuousMap.coe_mk, zero_le, max_eq_right,
+      ← WithTop.coe_min, WithTop.untopA, WithTop.untopD_coe, min_comm]
+
+/-- The whole stopped path is measurable in its stopping-time past even
+when that stopping time can be infinite. -/
+theorem stoppedAtPath_measurable
+    {Ω : Type*} [m : MeasurableSpace Ω] (ℱ : Filtration ℝ≥0 m)
+    (η : Ω → ℝ≥0 → ℂ) (ha : Adapted ℱ (fun t ω => η ω t))
+    (hc : ∀ ω, Continuous (η ω)) (ρ : Ω → WithTop ℝ≥0) (hρ : IsStoppingTime ℱ ρ) :
+    Measurable[hρ.measurableSpace]
+      (fun ω => stoppedAtPath (sourceTracePath η hc ω) (ρ ω)) := by
+  have hp := ha.stronglyAdapted.isStronglyProgressive_of_continuous hc
+  let : MeasurableSpace Ω := hρ.measurableSpace
+  apply source_path_measurable
+  intro t
+  have hm := measurable_stoppedValue hp (hρ.min_const t)
+  have hm' := hm.mono (IsStoppingTime.measurableSpace_mono (hρ.min_const t) hρ
+    (fun _ => min_le_left _ _)) le_rfl
+  change Measurable (fun ω => η ω (min (ρ ω) (t : WithTop ℝ≥0)).untopA) at hm'
+  simpa only [stoppedAtPath_apply, sourceTracePath, ContinuousMap.coe_mk] using hm'
+
+/-- A finite original stopping time truncated at the front is measurable
+in the front past. -/
+theorem truncated_start_measurable
+    {Ω : Type*} [m : MeasurableSpace Ω] (ℱ : Filtration ℝ≥0 m)
+    (σ : Ω → ℝ≥0) (hσ : IsStoppingTime ℱ (fun ω => (σ ω : WithTop ℝ≥0)))
+    (ρ : Ω → WithTop ℝ≥0) (hρ : IsStoppingTime ℱ ρ) :
+    Measurable[hρ.measurableSpace]
+      (fun ω => (min (σ ω : WithTop ℝ≥0) (ρ ω)).untopD 0) := by
+  exact ((hσ.min hρ).measurable.mono
+    (IsStoppingTime.measurableSpace_mono (hσ.min hρ) hρ (fun _ => min_le_right _ _)) le_rfl).untopD 0
+
+/-- A finite first front for a continuous coordinate is attained. -/
+theorem firstFrontTime_attained
+    (x : ℝ≥0 → ℝ) (hx : Continuous x) (q : ℝ) (τ : ℝ≥0)
+    (hτ : firstFrontTime x q = (τ : WithTop ℝ≥0)) : x τ = q := by
+  have hh : hittingAfter (fun t (_ : Unit) => x t - q) {0} 0 () ≤ (τ : WithTop ℝ≥0) := hτ.le
+  obtain ⟨u, hu, hxu⟩ := (hittingAfter_zero_le_iff (fun t (_ : Unit) => x t - q)
+    (fun _ => hx.sub continuous_const) 0 τ ()).mp hh
+  have hlu := hittingAfter_le_of_mem (u := fun t (_ : Unit) => x t - q)
+    (ω := ()) hu.1 (show x u - q ∈ ({0} : Set ℝ) from hxu)
+  change firstFrontTime x q ≤ (u : WithTop ℝ≥0) at hlu
+  rw [hτ, WithTop.coe_le_coe] at hlu
+  have he : u = τ := le_antisymm hu.2 hlu
+  exact he ▸ sub_eq_zero.mp hxu
+
+/-- Stopping the path and truncating the earlier time at the front does not
+change the concrete success event. -/
+theorem frontSuccess_stopped_eq
+    {Ω : Type*} (η : ℕ → Ω → ℝ≥0 → ℂ) (p : ℕ → ℂ → ℝ)
+    (σ : Ω → ℝ≥0) (V : ℕ → Set ℂ) (a : ℕ → ℂ) (ε : ℝ) (n : ℕ)
+    (hc : ∀ ω, Continuous (η n ω)) (hp : Continuous (p n)) :
+    let ρ := fun ω => firstFrontTime (fun t => p n (η n ω t)) 1
+    let η' := fun (_ : ℕ) ω => (stoppedAtPath (sourceTracePath (η n) hc ω) (ρ ω) : ℝ≥0 → ℂ)
+    let σ' := fun ω => (min (σ ω : WithTop ℝ≥0) (ρ ω)).untopD 0
+    FrontSuccess η p σ V a ε n = FrontSuccess η' p σ' V a ε n := by
+  dsimp only
+  ext ω
+  let ρ := firstFrontTime (fun t => p n (η n ω t)) 1
+  cases hρ : ρ with
+  | top =>
+    have hfirst : firstFrontTime (fun t => p n (η n ω t)) 1 = ⊤ := hρ
+    simp only [FrontSuccess, hfirst, WithTop.top_ne_coe, false_and, mem_ofPred_eq,
+      stoppedAtPath, ite_true, min_top_right, WithTop.untopD_coe,
+      sourceTracePath, ContinuousMap.coe_mk]
+  | coe τ =>
+    have hfirst : firstFrontTime (fun t => p n (η n ω t)) 1 = (τ : WithTop ℝ≥0) := hρ
+    have hhit := firstFrontTime_attained _ (hp.comp (hc ω)) 1 τ hfirst
+    have hpath : EqOn
+        (fun t => stoppedAtPath (sourceTracePath (η n) hc ω) (ρ) t) (η n ω) (Icc 0 τ) := by
+      intro t ht
+      simp only [hρ, stoppedAtPath, WithTop.coe_ne_top, ite_false, WithTop.untopD_coe,
+        clampedPath, ContinuousMap.comp_apply, ContinuousMap.coe_mk,
+        min_eq_left ht.2, max_eq_right ht.1]
+      rfl
+    have hfirst' := firstFrontTime_eq_of_prefix
+      (fun t => p n (η n ω t)) (fun t => p n (stoppedAtPath (sourceTracePath (η n) hc ω) ρ t))
+      1 τ hfirst hhit (fun t ht => congrArg (p n) (hpath ht).symm)
+    have ht : frontTime (fun t => p n (η n ω t)) 1 = τ := by
+      simp only [frontTime, hfirst, WithTop.untopD_coe]
+    have ht' : frontTime
+        (fun t => p n (stoppedAtPath (sourceTracePath (η n) hc ω) ρ t)) 1 = τ := by
+      simp only [frontTime, hfirst', WithTop.untopD_coe]
+    have hmaps : MapsTo (fun t => stoppedAtPath (sourceTracePath (η n) hc ω) ρ t)
+        (Icc 0 τ) (V n) ↔ MapsTo (η n ω) (Icc 0 τ) (V n) := by
+      constructor <;> intro h t ht
+      · simpa only [hpath ht] using h ht
+      · simpa only [hpath ht] using h ht
+    have hsig : (min (σ ω : WithTop ℝ≥0) ρ).untopD 0 = min (σ ω) τ := by
+      simp only [hρ, ← WithTop.coe_min, WithTop.untopD_coe]
+    have hendpoint := hpath ⟨bot_le, le_rfl⟩
+    rw [hρ] at hfirst' ht' hmaps hsig hendpoint
+    change (_ : Prop) ↔ (_ : Prop)
+    simp only [FrontSuccess, mem_ofPred_eq, ht, ht', hfirst, hfirst', hsig,
+      hendpoint, hmaps, min_lt_iff, lt_self_iff_false, or_false, true_and]
+
+/-- The mass on a successful passage is also unchanged by stopping at the
+front, including the earlier endpoint. -/
+theorem frontSuccess_mass_stopped_eq
+    {Ω : Type*} (η : ℕ → Ω → ℝ≥0 → ℂ) (p : ℕ → ℂ → ℝ)
+    (σ : Ω → ℝ≥0) (V : ℕ → Set ℂ) (a : ℕ → ℂ) (ε : ℝ) (n : ℕ)
+    (hc : ∀ ω, Continuous (η n ω)) (hp : Continuous (p n)) (κ v c : ℝ) (R : Set ℂ) :
+    let ρ := fun ω => firstFrontTime (fun t => p n (η n ω t)) 1
+    let η' := fun (_ : ℕ) ω => (stoppedAtPath (sourceTracePath (η n) hc ω) (ρ ω) : ℝ≥0 → ℂ)
+    let σ' := fun ω => (min (σ ω : WithTop ℝ≥0) (ρ ω)).untopD 0
+    {ω | ω ∈ FrontSuccess η p σ V a ε n ∧ ENNReal.ofReal c ≤
+      segmentSausageCharge κ (η n ω) (σ ω) (frontTime (fun t => p n (η n ω t)) 1) v R} =
+    {ω | ω ∈ FrontSuccess η' p σ' V a ε n ∧ ENNReal.ofReal c ≤
+      segmentSausageCharge κ (η' n ω) (σ' ω) (frontTime (fun t => p n (η' n ω t)) 1) v R} := by
+  dsimp only
+  have hsuccess := frontSuccess_stopped_eq η p σ V a ε n hc hp
+  ext ω
+  by_cases hω : ω ∈ FrontSuccess η p σ V a ε n
+  · have hω' := hsuccess ▸ hω
+    have hωsave := hω
+    obtain ⟨hfirst, _, hστ, _, _⟩ := hω
+    let τ := frontTime (fun t => p n (η n ω t)) 1
+    have heval (t : ℝ≥0) (ht : t ≤ τ) :
+        stoppedAtPath (sourceTracePath (η n) hc ω)
+          (firstFrontTime (fun t => p n (η n ω t)) 1) t = η n ω t := by
+      change t ≤ frontTime (fun t => p n (η n ω t)) 1 at ht
+      simp only [hfirst, stoppedAtPath, WithTop.coe_ne_top, ite_false, WithTop.untopD_coe,
+        clampedPath, ContinuousMap.comp_apply, ContinuousMap.coe_mk,
+        min_eq_left ht, max_eq_right (show (0 : ℝ≥0) ≤ t from bot_le)]
+      rfl
+    have hfirst' := firstFrontTime_eq_of_prefix
+      (fun t => p n (η n ω t))
+      (fun t => p n (stoppedAtPath (sourceTracePath (η n) hc ω)
+        (firstFrontTime (fun u => p n (η n ω u)) 1) t))
+      1 τ hfirst (by exact hωsave.2.1)
+      (fun t ht => congrArg (p n) (heval t ht.2).symm)
+    have ht' : frontTime (fun t => p n (stoppedAtPath (sourceTracePath (η n) hc ω)
+        (firstFrontTime (fun u => p n (η n ω u)) 1) t)) 1 = τ := by
+      simp only [frontTime, hfirst', WithTop.untopD_coe]
+    have hσ' : (min (σ ω : WithTop ℝ≥0)
+        (firstFrontTime (fun t => p n (η n ω t)) 1)).untopD 0 = σ ω := by
+      rw [hfirst, ← WithTop.coe_min, WithTop.untopD_coe, min_eq_left hστ.le]
+    have hsausage := sourceSausageSet_congr_interval
+      (s := σ ω) (t := τ) (fun t ht => heval t ht.2) v
+    simp only [mem_ofPred_eq, hωsave, hω', true_and, hσ', ht', segmentSausageCharge, hsausage]
+    rfl
+  · have hω' : ω ∉ FrontSuccess
+        (fun (_ : ℕ) ω => (stoppedAtPath (sourceTracePath (η n) hc ω)
+          (firstFrontTime (fun t => p n (η n ω t)) 1) : ℝ≥0 → ℂ)) p
+        (fun ω => (min (σ ω : WithTop ℝ≥0)
+          (firstFrontTime (fun t => p n (η n ω t)) 1)).untopD 0) V a ε n := by
+      simpa only [← hsuccess] using hω
+    simp only [mem_ofPred_eq, hω, hω', false_and]
+
+/-- The full success-and-mass event belongs to the front past. -/
+theorem frontSuccess_mass_measurable_at_front
+    {Ω : Type*} [m : MeasurableSpace Ω] (ℱ : Filtration ℝ≥0 m)
+    (η : ℕ → Ω → ℝ≥0 → ℂ) (p : ℕ → ℂ → ℝ) (σ : Ω → ℝ≥0)
+    (V : ℕ → Set ℂ) (a : ℕ → ℂ) (ε : ℝ) (n : ℕ)
+    (ha : Adapted ℱ (fun t ω => η n ω t)) (hc : ∀ ω, Continuous (η n ω))
+    (hp : Continuous (p n)) (hσ : IsStoppingTime ℱ (fun ω => (σ ω : WithTop ℝ≥0)))
+    (hV : IsOpen (V n)) (κ v c : ℝ) (R : Set ℂ) :
+    let hρ := firstFrontTime_stopping ℱ (η n) ha hc (p n) hp
+    MeasurableSet[hρ.measurableSpace] {ω | ω ∈ FrontSuccess η p σ V a ε n ∧ ENNReal.ofReal c ≤
+      segmentSausageCharge κ (η n ω) (σ ω) (frontTime (fun t => p n (η n ω t)) 1) v R} := by
+  dsimp only
+  let ρ := fun ω => firstFrontTime (fun t => p n (η n ω t)) 1
+  have hρ := firstFrontTime_stopping ℱ (η n) ha hc (p n) hp
+  let f := fun ω => stoppedAtPath (sourceTracePath (η n) hc ω) (ρ ω)
+  have hfm : Measurable[hρ.measurableSpace] f := stoppedAtPath_measurable ℱ (η n) ha hc ρ hρ
+  let η' : ℕ → Ω → ℝ≥0 → ℂ := fun _ ω => f ω
+  let σ' := fun ω => (min (σ ω : WithTop ℝ≥0) (ρ ω)).untopD 0
+  have hσ' : Measurable[hρ.measurableSpace] σ' := truncated_start_measurable ℱ σ hσ ρ hρ
+  rw [frontSuccess_mass_stopped_eq η p σ V a ε n hc hp κ v c R]
+  let : MeasurableSpace Ω := hρ.measurableSpace
+  let ℱ' : Filtration ℝ≥0 hρ.measurableSpace := Filtration.const ℝ≥0 hρ.measurableSpace le_rfl
+  apply measurableSet_frontSuccess_mass ℱ' η' p σ' V a ε n
+    (fun t => (continuous_eval_const t).measurable.comp hfm) (fun ω => (f ω).continuous)
+    univ isClosed_univ hp.continuousOn hσ' hV (subset_univ _) κ v c R
+
+/-- Local physical ribbon coordinates suffice for an actual stopping time
+whose past contains the full success-and-mass event. -/
+theorem local_frontSuccess_mass_measurable_at_front
+    {Ω : Type*} [m : MeasurableSpace Ω] (ℱ : Filtration ℝ≥0 m)
+    (η : ℕ → Ω → ℝ≥0 → ℂ) (p : ℕ → ℂ → ℝ) (σ : Ω → ℝ≥0)
+    (V : ℕ → Set ℂ) (a : ℕ → ℂ) (ε : ℝ) (n : ℕ)
+    (ha : Adapted ℱ (fun t ω => η n ω t)) (hc : ∀ ω, Continuous (η n ω))
+    (K : Set ℂ) (hK : IsClosed K) (hp : ContinuousOn (p n) K)
+    (hσ : IsStoppingTime ℱ (fun ω => (σ ω : WithTop ℝ≥0)))
+    (hV : IsOpen (V n)) (hVK : V n ⊆ K) (κ v c : ℝ) (R : Set ℂ) :
+    ∃ ρ : Ω → WithTop ℝ≥0, ∃ hρ : IsStoppingTime ℱ ρ,
+      MeasurableSet[hρ.measurableSpace] (FrontSuccess η p σ V a ε n) ∧
+      MeasurableSet[hρ.measurableSpace] {ω | ω ∈ FrontSuccess η p σ V a ε n ∧ ENNReal.ofReal c ≤
+        segmentSausageCharge κ (η n ω) (σ ω)
+          (frontTime (fun t => p n (η n ω t)) 1) v R} ∧
+      ∀ ω ∈ FrontSuccess η p σ V a ε n,
+        ρ ω = firstFrontTime (fun t => p n (η n ω t)) 1 := by
+  obtain ⟨g, hg⟩ := exists_continuous_progress_extension (p n) K hK hp
+  let p' : ℕ → ℂ → ℝ := fun _ => g
+  let ρ := fun ω => firstFrontTime (fun t => g (η n ω t)) 1
+  have hρ := firstFrontTime_stopping ℱ (η n) ha hc g g.continuous
+  have heq := frontSuccess_eq_of_eqOn η p p' σ V a ε n (hg.mono hVK)
+  have htime (ω : Ω) (hω : ω ∈ FrontSuccess η p σ V a ε n) :
+      ρ ω = firstFrontTime (fun t => p n (η n ω t)) 1 := by
+    obtain ⟨hfirst, hhit, _, hpath, _⟩ := hω
+    exact (firstFrontTime_eq_of_prefix _ _ 1 _ hfirst hhit
+      (fun t ht => hg (hVK (hpath ht)))).trans hfirst.symm
+  have hmassEq (b : ℝ) :
+      {ω | ω ∈ FrontSuccess η p σ V a ε n ∧ ENNReal.ofReal b ≤
+        segmentSausageCharge κ (η n ω) (σ ω)
+          (frontTime (fun t => p n (η n ω t)) 1) v R} =
+      {ω | ω ∈ FrontSuccess η p' σ V a ε n ∧ ENNReal.ofReal b ≤
+        segmentSausageCharge κ (η n ω) (σ ω)
+          (frontTime (fun t => p' n (η n ω t)) 1) v R} := by
+    ext ω
+    by_cases hω : ω ∈ FrontSuccess η p σ V a ε n
+    · have hω' := heq ▸ hω
+      have ht : frontTime (fun t => p' n (η n ω t)) 1 =
+          frontTime (fun t => p n (η n ω t)) 1 :=
+        congrArg (fun z : WithTop ℝ≥0 => z.untopD 0) (htime ω hω)
+      simp only [mem_ofPred_eq, hω, hω', true_and, ht]
+    · have hω' : ω ∉ FrontSuccess η p' σ V a ε n := by simpa only [← heq] using hω
+      simp only [mem_ofPred_eq, hω, hω', false_and]
+  have hmass (b : ℝ) := frontSuccess_mass_measurable_at_front ℱ η p' σ V a ε n
+    ha hc g.continuous hσ hV κ v b R
+  refine ⟨ρ, hρ, ?_, ?_, htime⟩
+  · have hz := hmass 0
+    rw [← hmassEq 0] at hz
+    simpa only [ENNReal.ofReal_zero, zero_le, and_true, ofPred_mem_eq] using hz
+  · rw [hmassEq c]
+    exact hmass c
+
+end SLEExactGauge.FrontSuccessMeasurability
+
+end
+
+end OAI
diff --git a/lean/OAI/Probability/SLE/Geometry/GeometricTubeSupport.lean b/lean/OAI/Probability/SLE/Geometry/GeometricTubeSupport.lean
new file mode 100644
index 0000000000000000000000000000000000000000..c3b09d5f8fd73ec0e73d96522478d7771d2e1aa9
--- /dev/null
+++ b/lean/OAI/Probability/SLE/Geometry/GeometricTubeSupport.lean
@@ -0,0 +1,69 @@
+import OAI.Probability.SLE.Loewner.SlitSupport
+import Mathlib.Topology.CompactOpen
+
+namespace OAI
+
+/-! The clock-free open-tube specialization of the published support input.
+
+Tran–Yuan (2020), *A support theorem for SLE curves*, Corollary 1.2
+(strong topology, i.e. modulo increasing reparameterization). Its
+simple-curve inclusion, with the usual capacity normalization/dilation,
+gives the specialization below for a geometric simple path. Only positivity
+for each fixed tube is assumed; no uniformity over tubes or pasts is assumed.
+-/
+
+noncomputable section
+open Set Filter MeasureTheory Metric
+open scoped Topology ENNReal NNReal
+
+namespace SLEExactGauge
+
+local instance geometricTubePathMeasurableSpace : MeasurableSpace C(ℝ≥0, ℂ) := borel _
+local instance geometricTubePathBorelSpace : BorelSpace C(ℝ≥0, ℂ) := ⟨rfl⟩
+
+def pathTubeEvent (N V : Set ℂ) : Set C(ℝ≥0, ℂ) :=
+  {f | ∃ T : ℝ≥0, 0 < T ∧ MapsTo f (Icc 0 T) N ∧ f T ∈ V}
+
+theorem isOpen_pathTubeEvent {N V : Set ℂ} (hN : IsOpen N) (hV : IsOpen V) :
+    IsOpen (pathTubeEvent N V) := by
+  have he : pathTubeEvent N V = ⋃ T : ℝ≥0, ⋃ (_ : 0 < T),
+      {f : C(ℝ≥0, ℂ) | MapsTo f (Icc 0 T) N} ∩
+        (fun f : C(ℝ≥0, ℂ) => f T) ⁻¹' V := by
+    ext f
+    simp only [pathTubeEvent, mem_ofPred_eq, mem_iUnion, mem_inter_iff, mem_preimage]
+    constructor <;> rintro ⟨T, hT, hN, hV⟩ <;> exact ⟨T, hT, hN, hV⟩
+  rw [he]
+  exact isOpen_iUnion (fun T => isOpen_iUnion (fun _ =>
+    (ContinuousMap.isOpen_setOfPred_mapsTo isCompact_Icc hN).inter
+      (hV.preimage (continuous_eval_const T))))
+
+theorem measurableSet_pathTubeEvent {N V : Set ℂ} (hN : IsOpen N) (hV : IsOpen V) :
+    MeasurableSet (pathTubeEvent N V) := (isOpen_pathTubeEvent hN hV).measurableSet
+
+/-- A precise small consequence of the simple-curve inclusion in Tran–Yuan,
+Corollary 1.2, suited to the actual geometric continuation route. -/
+def PublishedGeometricTubeSupport {Ω : Type*} [MeasurableSpace Ω]
+    (P : Measure Ω) (γ : Ω → ℝ≥0 → ℂ) : Prop :=
+  ∀ (z : ℂ) (p : Path (0 : ℂ) z), Function.Injective p →
+    (∀ t, t ≠ 0 → p t ∈ upperHalfPlane) →
+    ∀ N V : Set ℂ, IsOpen N → IsOpen V → range p ⊆ N → z ∈ V →
+      0 < P {ω | ∃ T : ℝ≥0, 0 < T ∧ MapsTo (γ ω) (Icc 0 T) N ∧ γ ω T ∈ V}
+
+/-- The geometrically stated published input applies directly to the Borel
+passage event on continuous-path space. -/
+theorem geometric_tube_passage_of_published_support
+    {Ω : Type*} [MeasurableSpace Ω] (P : Measure Ω)
+    (f : Ω → C(ℝ≥0, ℂ))
+    (hpublished : PublishedGeometricTubeSupport P (fun ω => f ω))
+    (z : ℂ) (p : Path (0 : ℂ) z) (hp : Function.Injective p)
+    (hpH : ∀ t, t ≠ 0 → p t ∈ upperHalfPlane)
+    (N V : Set ℂ) (hN : IsOpen N) (hV : IsOpen V)
+    (hpN : range p ⊆ N) (hzV : z ∈ V) :
+    0 < P (f ⁻¹' pathTubeEvent N V) :=
+  hpublished z p hp hpH N V hN hV hpN hzV
+
+end SLEExactGauge
+
+end
+
+end OAI
diff --git a/lean/OAI/Probability/SLE/Geometry/GoodPrefixCoordinates.lean b/lean/OAI/Probability/SLE/Geometry/GoodPrefixCoordinates.lean
new file mode 100644
index 0000000000000000000000000000000000000000..e44558d8f9da84a893fd09deae3050604bbb73cc
--- /dev/null
+++ b/lean/OAI/Probability/SLE/Geometry/GoodPrefixCoordinates.lean
@@ -0,0 +1,81 @@
+import OAI.Probability.SLE.Gauge.RibbonGoodPrefix
+
+namespace OAI
+
+/-! Recover the actual continuous ribbon coordinates at a successful
+first front without adding any chart distortion assumptions. -/
+
+noncomputable section
+open Set Filter Metric
+open scoped Topology NNReal ENNReal
+
+namespace SLEExactGauge
+open RibbonCoordinates FirstFrontPassage
+
+theorem goodRibbonPrefix_coordinates
+    (γ : ℝ≥0 → ℂ) (hc : Continuous γ) (P : ℂ → ℂ)
+    (hemb : Topology.IsClosedEmbedding (fun z : closedRibbon => P z))
+    (hi : InjOn P closedRibbon) (g : C(ℂ, ℝ))
+    (hg : ∀ z ∈ closedRibbon, g (P z) = z.re) (hg0 : g (γ 0) = 0)
+    {k ε : ℝ} (hk : 0 < k)
+    (hpref : () ∈ GoodRibbonPrefix (fun _ : Unit => γ)
+      (fun _ => firstFrontTime (fun t => g (γ t)) k) P ε) :
+    ∃ (T : ℝ≥0) (x : ℝ) (xp : ℝ≥0 → ℂ),
+      firstFrontTime (fun t => g (γ t)) k = (T : WithTop ℝ≥0) ∧ 0 < T ∧ |x| ≤ ε / 4 ∧
+      ContinuousOn xp (Icc 0 T) ∧ EqOn γ (P ∘ xp) (Icc 0 T) ∧
+      (xp 0).re = 0 ∧ xp T = (k : ℂ) + (x : ℂ) * Complex.I ∧
+      MapsTo xp (Icc 0 T) closedRibbon ∧
+      (∀ t ∈ Icc 0 T, (xp t).re ≤ k ∧ |(xp t).im| ≤ ε) ∧
+      ∀ t : ℝ≥0, t < T → (xp t).re < k := by
+  cases hτ : firstFrontTime (fun t => g (γ t)) k with
+  | top => exact False.elim (hpref.1 hτ)
+  | coe T =>
+    have hpast : MapsTo γ (Icc 0 T) (ribbonCore P ε) := by
+      simpa only [hτ, WithTop.untopD_coe] using hpref.2.1
+    have hend : γ T ∈ ribbonCore P (ε / 4) := by
+      simpa only [hτ, WithTop.untopD_coe] using hpref.2.2
+    let xp := fun t => coordinateInverse P closedRibbon (γ t)
+    have hmap : MapsTo γ (Icc 0 T) (P '' closedRibbon) :=
+      fun _ ht => image_mono inter_subset_left (hpast ht)
+    have hcoords : MapsTo xp (Icc 0 T) closedRibbon := fun _ ht => coordinateInverse_mem (hmap ht)
+    have hxpc : ContinuousOn xp (Icc 0 T) :=
+      (coordinateInverse_continuousOn_of_embedding P hemb.isEmbedding).comp hc.continuousOn hmap
+    have hγeq : EqOn γ (P ∘ xp) (Icc 0 T) := fun _ ht => (coordinateInverse_right (hmap ht)).symm
+    have hgt (t : ℝ≥0) (ht : t ∈ Icc 0 T) : g (γ t) = (xp t).re := by
+      rw [hγeq ht]
+      exact hg _ (hcoords ht)
+    have hhit : g (γ T) = k := FrontSuccessMeasurability.firstFrontTime_attained _ (g.continuous.comp hc) k T hτ
+    have hT : 0 < T := by
+      apply lt_of_le_of_ne bot_le
+      intro he
+      rw [← he] at hhit
+      change g (γ 0) = k at hhit
+      rw [hg0] at hhit
+      exact hk.ne' hhit.symm
+    have hxre : (xp T).re = k := (hgt T ⟨bot_le, le_rfl⟩).symm.trans hhit
+    have htip : xp T = (k : ℂ) + ((xp T).im : ℂ) * Complex.I := by
+      apply Complex.ext <;> simp [hxre]
+    have hx : |(xp T).im| ≤ ε / 4 := by
+      obtain ⟨z, ⟨hz, hiε⟩, he⟩ := hend
+      simpa only [xp, ← he, coordinateInverse_left hi hz] using hiε
+    have hstrict : ∀ t : ℝ≥0, t < T → (xp t).re < k := by
+      have hh := strict_before_attained_front (fun t => g (γ t)) k T
+        (g.continuous.comp hc).continuousOn (by rw [hg0]; exact hk) hτ
+      intro t ht
+      rw [← hgt t ⟨bot_le, ht.le⟩]
+      exact hh t ht
+    refine ⟨T, (xp T).im, xp, rfl, hT, hx, hxpc, hγeq,
+      by rw [← hgt 0 ⟨bot_le, bot_le⟩, hg0], htip, hcoords, ?_, hstrict⟩
+    intro t ht
+    refine ⟨?_, ?_⟩
+    · rcases ht.2.eq_or_lt with rfl | hlt
+      · exact hxre.le
+      · exact (hstrict t hlt).le
+    · obtain ⟨z, ⟨hz, hiε⟩, he⟩ := hpast ht
+      simpa only [xp, ← he, coordinateInverse_left hi hz] using hiε
+
+end SLEExactGauge
+
+end
+
+end OAI
diff --git a/lean/OAI/Probability/SLE/Geometry/GreenCompactDecay.lean b/lean/OAI/Probability/SLE/Geometry/GreenCompactDecay.lean
new file mode 100644
index 0000000000000000000000000000000000000000..90e900b1705ce197779174e5530cb7425532093b
--- /dev/null
+++ b/lean/OAI/Probability/SLE/Geometry/GreenCompactDecay.lean
@@ -0,0 +1,81 @@
+import OAI.Probability.SLE.Geometry.GreenMeanDecay
+import OAI.Probability.SLE.Mass.LevelCurrentLimit
+import Mathlib.MeasureTheory.Integral.Lebesgue.DominatedConvergence
+
+namespace OAI
+
+/-! Spatially tested Green decay on interior compacts. This is the input
+for exhaustion of the canonical terminal measure by finite times. -/
+
+noncomputable section
+open Set Filter MeasureTheory ProbabilityTheory Classical
+open scoped NNReal ENNReal Topology
+
+namespace SLEExactGauge.Multipoint
+
+local instance : LocallyCompactSpace upperHalfPlane := isOpen_upperHalfPlane.locallyCompactSpace
+
+lemma halfPlaneGreenMeasure_mean_apply
+    {Ω : Type*} [MeasurableSpace Ω] (P : Measure Ω) [SFinite P]
+    {B : ℝ≥0 → Ω → ℝ} (hBm : Measurable (Function.uncurry B))
+    (hBc : ∀ ω, Continuous (fun s => B s ω)) (κ : ℝ)
+    (γ : Ω → ℝ≥0 → ℂ) (G F : Ω → ℝ≥0 → ℂ → ℂ)
+    (hw : ∀ ω, IsCapacityTwoWitness (fun s => Real.sqrt κ * B s ω) (γ ω) (G ω) (F ω))
+    (t : ℝ≥0) (K : Set upperHalfPlane) (hK : MeasurableSet K) :
+    P.bind (halfPlaneGreenMeasure κ B γ G t) K =
+      ∫⁻ z in (Subtype.val : upperHalfPlane → ℂ) '' K,
+        (∫⁻ ω, ENNReal.ofReal (greenDensity κ (fun s => Real.sqrt κ * B s ω)
+          (γ ω) (G ω) t z) ∂P) ∂volume := by
+  have hL := (MeasurableEmbedding.subtype_coe isOpen_upperHalfPlane.measurableSet).measurableSet_image.mpr hK
+  rw [Measure.bind_apply hK (halfPlaneGreenMeasure_measurable hBm hBc κ γ G F hw t).aemeasurable]
+  have he (ω : Ω) : halfPlaneGreenMeasure κ B γ G t ω K =
+      ∫⁻ z in (Subtype.val : upperHalfPlane → ℂ) '' K,
+        ENNReal.ofReal (greenDensity κ (fun s => Real.sqrt κ * B s ω)
+          (γ ω) (G ω) t z) ∂volume := by
+    rw [halfPlaneGreenMeasure,comap_subtype_coe_apply isOpen_upperHalfPlane.measurableSet,
+      withDensity_apply _ hL]
+  simp_rw [he]
+  exact lintegral_lintegral_swap
+    ((actual_greenDensity_joint_measurable hBm hBc κ γ G F hw t).ennreal_ofReal.aemeasurable)
+
+theorem halfPlaneGreenMeasure_compact_mean_tendsto_zero
+    {Ω : Type*} [MeasurableSpace Ω] {P : Measure Ω}
+    {B : ℝ≥0 → Ω → ℝ} (hB : IsBrownianReal B P)
+    (hBm : Measurable (Function.uncurry B)) (hBc : ∀ ω, Continuous (fun s => B s ω))
+    (hB0 : ∀ ω, B 0 ω = 0) {κ : ℝ} (hκ : 0 < κ) (hκ8 : κ < 8)
+    (γ : Ω → ℝ≥0 → ℂ) (G F : Ω → ℝ≥0 → ℂ → ℂ)
+    (hw : ∀ ω, IsCapacityTwoWitness (fun s => Real.sqrt κ * B s ω) (γ ω) (G ω) (F ω))
+    (K : Set upperHalfPlane) (hK : IsCompact K) :
+    Tendsto (fun n : ℕ => P.bind (halfPlaneGreenMeasure κ B γ G n) K) atTop (𝓝 0) := by
+  let : IsProbabilityMeasure P := hB.isGaussianProcess.isProbabilityMeasure
+  let : IsFiniteMeasureOnCompacts (initialGreenMeasure κ) := initialGreenMeasure_finite_on_compacts κ
+  let L := (Subtype.val : upperHalfPlane → ℂ) '' K
+  have hL : IsCompact L := hK.image continuous_subtype_val
+  have hLH : L ⊆ upperHalfPlane := by rintro _ ⟨z,_,rfl⟩; exact z.property
+  have hfin : (∫⁻ z in L, ENNReal.ofReal (initialGreen κ z) ∂volume) ≠ ∞ := by
+    have h := hK.measure_lt_top (μ := initialGreenMeasure κ)
+    rw [initialGreenMeasure,comap_subtype_coe_apply isOpen_upperHalfPlane.measurableSet,
+      withDensity_apply _ hL.measurableSet] at h
+    exact h.ne
+  have hm (n : ℕ) : Measurable (fun z => ∫⁻ ω, ENNReal.ofReal
+      (greenDensity κ (fun s => Real.sqrt κ * B s ω) (γ ω) (G ω) n z) ∂P) :=
+    (actual_greenDensity_joint_measurable hBm hBc κ γ G F hw n).ennreal_ofReal.lintegral_prod_left
+  have hb (n : ℕ) : (fun z => ∫⁻ ω, ENNReal.ofReal
+      (greenDensity κ (fun s => Real.sqrt κ * B s ω) (γ ω) (G ω) n z) ∂P)
+      ≤ᵐ[volume.restrict L] (fun z => ENNReal.ofReal (initialGreen κ z)) := by
+    filter_upwards [ae_restrict_mem hL.measurableSet] with z hz
+    exact greenDensity_mean_le hB hBm hBc hB0 hκ hκ8 γ G F hw z (hLH hz) n
+  have hl : ∀ᵐ z ∂volume.restrict L, Tendsto (fun n : ℕ => ∫⁻ ω, ENNReal.ofReal
+      (greenDensity κ (fun s => Real.sqrt κ * B s ω) (γ ω) (G ω) n z) ∂P) atTop (𝓝 0) := by
+    filter_upwards [ae_restrict_mem hL.measurableSet] with z hz
+    exact (greenDensity_mean_tendsto_zero hB hBm hBc hB0 hκ hκ8 γ G F hw z (hLH hz)).comp
+      (tendsto_natCast_atTop_atTop : Tendsto (fun n : ℕ => (n:ℝ≥0)) atTop atTop)
+  have hlim := tendsto_lintegral_of_dominated_convergence _ hm hb hfin hl
+  simp only [lintegral_zero] at hlim
+  simpa only [halfPlaneGreenMeasure_mean_apply P hBm hBc κ γ G F hw _ K hK.measurableSet] using hlim
+
+end SLEExactGauge.Multipoint
+
+end
+
+end OAI
diff --git a/lean/OAI/Probability/SLE/Geometry/GreenMeanDecay.lean b/lean/OAI/Probability/SLE/Geometry/GreenMeanDecay.lean
new file mode 100644
index 0000000000000000000000000000000000000000..0500ec032ba5426d253ee72a240786a959690752
--- /dev/null
+++ b/lean/OAI/Probability/SLE/Geometry/GreenMeanDecay.lean
@@ -0,0 +1,143 @@
+import OAI.Probability.SLE.Mass.LevelGreenLimit
+import OAI.Probability.SLE.FiniteMass
+
+namespace OAI
+
+/-! Finite centered clock tightness implies decay of the ordinary killed
+Green potential. No infinite centered probability space is needed. -/
+
+noncomputable section
+open Set Filter MeasureTheory ProbabilityTheory Classical
+open scoped NNReal ENNReal Topology
+
+namespace SLEExactGauge.Multipoint
+
+lemma ofReal_mul_integral_div {Ω : Type*} [MeasurableSpace Ω]
+    (P : Measure Ω) (Y : Ω → ℝ) (hY : Integrable Y P)
+    (hYn : ∀ᵐ ω ∂P, 0 ≤ Y ω) (g : ℝ) (hg : 0 < g) :
+    ENNReal.ofReal g * ENNReal.ofReal ((∫ ω, Y ω ∂P) / g) =
+      ∫⁻ ω, ENNReal.ofReal (Y ω) ∂P := by
+  rw [← ENNReal.ofReal_mul hg.le,← ofReal_integral_eq_lintegral_ofReal hY hYn]
+  congr 1
+  field_simp
+
+lemma actual_radius_tail_measurable
+    {Ω : Type*} [MeasurableSpace Ω] {B : ℝ≥0 → Ω → ℝ}
+    (hm : ∀ t, Measurable (B t)) (hBc : ∀ ω, Continuous (fun s => B s ω))
+    (κ u : ℝ) (hu : 0 ≤ u) (γ : Ω → ℝ≥0 → ℂ) (G F : Ω → ℝ≥0 → ℂ → ℂ)
+    (hw : ∀ ω, IsCapacityTwoWitness (fun s => Real.sqrt κ * B s ω) (γ ω) (G ω) (F ω))
+    (z : ℂ) (t : ℝ≥0) :
+    MeasurableSet {ω | (t : ℝ≥0∞) < radiusLevelTime (γ ω) (G ω) z u} := by
+  have hτ := actual_radiusLevel_joint_measurable hm hBc κ u hu γ G F hw
+  have hlt := measurableSet_lt (measurable_const (a := (t : ℝ≥0∞))) hτ
+  have hpre := hlt.preimage (measurable_id.prodMk (measurable_const (a := z)))
+  exact hpre
+
+
+lemma levelCurrentGreen_mean_eq_centered_tail
+    {Ω : Type*} [MeasurableSpace Ω] {P : Measure Ω}
+    {B : ℝ≥0 → Ω → ℝ} (hB : IsBrownianReal B P)
+    (hBm : Measurable (Function.uncurry B)) (hBc : ∀ ω, Continuous (fun s => B s ω))
+    (hB0 : ∀ ω, B 0 ω = 0) {κ : ℝ} (hκ : 0 < κ) (hκ8 : κ < 8)
+    (γ : Ω → ℝ≥0 → ℂ) (G F : Ω → ℝ≥0 → ℂ → ℂ)
+    (hw : ∀ ω, IsCapacityTwoWitness (fun s => Real.sqrt κ * B s ω) (γ ω) (G ω) (F ω))
+    (z : ℂ) (hz : z ∈ upperHalfPlane) (u : ℝ) (hu : 0 ≤ u) (t : ℝ≥0) :
+    (∫⁻ ω, ENNReal.ofReal (levelCurrentGreen κ B γ G u t z ω) ∂P) =
+      ENNReal.ofReal (initialGreen κ z) * finiteCenteredLaw P κ B γ G z u
+        {ω | (t : ℝ≥0∞) < radiusLevelTime (γ ω) (G ω) z u} := by
+  let : IsProbabilityMeasure P := hB.isGaussianProcess.isProbabilityMeasure
+  let A := {ω | (t : ℝ≥0∞) < radiusLevelTime (γ ω) (G ω) z u}
+  have hA : MeasurableSet A := actual_radius_tail_measurable
+    (fun r => hBm.comp (measurable_const.prodMk measurable_id)) hBc κ u hu γ G F hw z t
+  have hi := (finite_stopped_green_regular hB hBm hBc hB0 κ hκ hκ8 γ G F
+    (Eventually.of_forall hw) z hz u hu).1
+  have he := levelRemainderGreen_setLIntegral hB hBm hBc hB0 hκ hκ8 γ G F
+    (Eventually.of_forall hw) z hz u hu t univ MeasurableSet.univ
+  simp only [Measure.restrict_univ] at he
+  rw [← he]
+  change (∫⁻ ω, ENNReal.ofReal (if ω ∈ A then
+    stoppedGreen κ (fun s => Real.sqrt κ * B s ω) (γ ω) (G ω) z u else 0) ∂P) = _
+  trans (∫⁻ ω in A, ENNReal.ofReal
+    (stoppedGreen κ (fun s => Real.sqrt κ * B s ω) (γ ω) (G ω) z u) ∂P)
+  · rw [← lintegral_indicator hA]
+    apply lintegral_congr
+    intro ω
+    by_cases hω : ω ∈ A
+    · rw [ite_eq_left hω,indicator_of_mem hω]
+    · rw [ite_eq_right hω,indicator_of_notMem hω,ENNReal.ofReal_zero]
+  · rw [finiteCenteredLaw_apply hB κ hκ hκ8 γ G F (Eventually.of_forall hw) z hz u hu A hA]
+    exact (ofReal_mul_integral_div (P.restrict A) _ hi.integrableOn
+      (Eventually.of_forall (fun ω => stoppedGreen_nonneg (hw ω) κ z u)) _
+        (initialGreen_pos κ z hz)).symm
+
+
+lemma greenDensity_mean_le_of_level_bound
+    {Ω : Type*} [MeasurableSpace Ω] {P : Measure Ω}
+    {B : ℝ≥0 → Ω → ℝ} (hBm : Measurable (Function.uncurry B))
+    (hBc : ∀ ω, Continuous (fun s => B s ω)) {κ : ℝ}
+    (γ : Ω → ℝ≥0 → ℂ) (G F : Ω → ℝ≥0 → ℂ → ℂ)
+    (hw : ∀ ω, IsCapacityTwoWitness (fun s => Real.sqrt κ * B s ω) (γ ω) (G ω) (F ω))
+    (z : ℂ) (t : ℝ≥0) (C : ℝ≥0∞)
+    (hbound : ∀ n : ℕ, (∫⁻ ω, ENNReal.ofReal
+      (levelCurrentGreen κ B γ G n t z ω) ∂P) ≤ C) :
+    (∫⁻ ω, ENNReal.ofReal (greenDensity κ (fun s => Real.sqrt κ * B s ω)
+      (γ ω) (G ω) t z) ∂P) ≤ C := by
+  have hm (n : ℕ) : Measurable (fun ω => ENNReal.ofReal (levelCurrentGreen κ B γ G n t z ω)) :=
+    ((levelCurrentGreen_joint_measurable hBm hBc κ n (Nat.cast_nonneg n) γ G F hw t).comp
+      (measurable_id.prodMk measurable_const)).ennreal_ofReal
+  have hmono : ∀ᵐ ω ∂P, Monotone (fun n : ℕ => ENNReal.ofReal (levelCurrentGreen κ B γ G n t z ω)) := by
+    filter_upwards [] with ω
+    intro m n hmn
+    exact ENNReal.ofReal_le_ofReal (levelCurrentGreen_mono ω (hBc ω) (hw ω) z t
+      (Nat.cast_nonneg m) (Nat.cast_le.mpr hmn))
+  have hlim : ∀ᵐ ω ∂P, Tendsto (fun n : ℕ => ENNReal.ofReal (levelCurrentGreen κ B γ G n t z ω))
+      atTop (𝓝 (ENNReal.ofReal (greenDensity κ (fun s => Real.sqrt κ * B s ω)
+        (γ ω) (G ω) t z))) := by
+    filter_upwards [] with ω
+    apply tendsto_const_nhds.congr'
+    exact (levelCurrentGreen_eventually_eq ω (hBc ω) (hw ω) z t (fun n : ℕ => (n:ℝ))
+      (fun n => Nat.cast_nonneg n) tendsto_natCast_atTop_atTop).mono
+      (fun _ h => congrArg ENNReal.ofReal h.symm)
+  exact le_of_tendsto (lintegral_tendsto_of_tendsto_of_monotone (fun n => (hm n).aemeasurable)
+    hmono hlim) (Eventually.of_forall hbound)
+
+theorem greenDensity_mean_tendsto_zero
+    {Ω : Type*} [MeasurableSpace Ω] {P : Measure Ω}
+    {B : ℝ≥0 → Ω → ℝ} (hB : IsBrownianReal B P)
+    (hBm : Measurable (Function.uncurry B)) (hBc : ∀ ω, Continuous (fun s => B s ω))
+    (hB0 : ∀ ω, B 0 ω = 0) {κ : ℝ} (hκ : 0 < κ) (hκ8 : κ < 8)
+    (γ : Ω → ℝ≥0 → ℂ) (G F : Ω → ℝ≥0 → ℂ → ℂ)
+    (hw : ∀ ω, IsCapacityTwoWitness (fun s => Real.sqrt κ * B s ω) (γ ω) (G ω) (F ω))
+    (z : ℂ) (hz : z ∈ upperHalfPlane) :
+    Tendsto (fun t : ℝ≥0 => ∫⁻ ω, ENNReal.ofReal
+      (greenDensity κ (fun s => Real.sqrt κ * B s ω) (γ ω) (G ω) t z) ∂P)
+      atTop (𝓝 0) := by
+  let : IsProbabilityMeasure P := hB.isGaussianProcess.isProbabilityMeasure
+  apply ENNReal.tendsto_atTop_zero.mpr
+  intro ε hε
+  by_cases he : ε = ∞
+  · exact ⟨0,fun _ _ => he ▸ le_top⟩
+  let δ := ε.toReal / initialGreen κ z
+  have hδ : 0 < δ := div_pos (ENNReal.toReal_pos hε.ne' he) (initialGreen_pos κ z hz)
+  obtain ⟨T,_,hT⟩ := finite_physical_clock_tight hB κ hκ hκ8 γ G F
+    (Eventually.of_forall hw) z hz δ hδ
+  refine ⟨T,fun t ht => ?_⟩
+  apply greenDensity_mean_le_of_level_bound hBm hBc γ G F hw z t ε
+  intro n
+  rw [levelCurrentGreen_mean_eq_centered_tail hB hBm hBc hB0 hκ hκ8 γ G F hw z hz
+    n (Nat.cast_nonneg n) t]
+  have htail : finiteCenteredLaw P κ B γ G z n
+      {ω | (t:ℝ≥0∞) < radiusLevelTime (γ ω) (G ω) z n} ≤ ENNReal.ofReal δ :=
+    (measure_mono (fun ω hω => (ENNReal.coe_le_coe.mpr ht).trans_lt hω)).trans (hT n)
+  apply (mul_le_mul' le_rfl htail).trans_eq
+  rw [← ENNReal.ofReal_mul (initialGreen_pos κ z hz).le]
+  have hc : initialGreen κ z * δ = ε.toReal := by
+    dsimp only [δ]
+    exact mul_div_cancel₀ _ (initialGreen_pos κ z hz).ne'
+  rw [hc,ENNReal.ofReal_toReal he]
+
+end SLEExactGauge.Multipoint
+
+end
+
+end OAI
diff --git a/lean/OAI/Probability/SLE/Geometry/GuideCompactness.lean b/lean/OAI/Probability/SLE/Geometry/GuideCompactness.lean
new file mode 100644
index 0000000000000000000000000000000000000000..e2f252672e57bcdd3306abc325043614687af88d
--- /dev/null
+++ b/lean/OAI/Probability/SLE/Geometry/GuideCompactness.lean
@@ -0,0 +1,263 @@
+import OAI.Probability.SLE.Geometry.WaypointDerivativeBounds
+import OAI.Probability.SLE.Geometry.LipschitzGuideConfinement
+import OAI.Probability.SLE.Geometry.UniformGuideCompactness
+import OAI.Probability.SLE.Geometry.PhysicalGuideCompactness
+import Mathlib.Analysis.Complex.LocallyUniformLimit
+
+namespace OAI
+
+/-!
+Joint compactness of conformal charts and physical/parameter access guides.
+The sole published input is the explicitly stated normalized univalent
+normal-family theorem. Normalization and guide identification use proved
+clearance, tip-collapse, and compact-inverse estimates.
+-/
+
+noncomputable section
+open Set Filter MeasureTheory Metric
+open scoped Topology NNReal
+
+namespace SLEExactGauge.GuideCompactness
+
+/-- The weak omitted-value derivative estimate proves that a nondegenerate
+locally uniform conformal limit still omits the limiting omitted value. -/
+theorem limit_omits_tip
+    (Fₙ : ℕ → ℂ → ℂ) (F : ℂ → ℂ) (aₙ : ℕ → ℂ) (a : ℂ)
+    (hFn : ∀ n, DifferentiableOn ℂ (Fₙ n) upperHalfPlane)
+    (hinj : ∀ n, InjOn (Fₙ n) upperHalfPlane)
+    (hconv : TendstoLocallyUniformlyOn Fₙ F atTop upperHalfPlane)
+    (ha : Tendsto aₙ atTop (𝓝 a))
+    (homit : ∀ n, aₙ n ∉ Fₙ n '' upperHalfPlane)
+    (hne : ∀ z ∈ upperHalfPlane, deriv F z ≠ 0) :
+    a ∉ F '' upperHalfPlane := by
+  rintro ⟨z, hz, he⟩
+  have hr : 0 < z.im := hz
+  have hball : ball z z.im ⊆ upperHalfPlane := ball_subset_upperHalfPlane le_rfl
+  have hbound n : z.im * ‖deriv (Fₙ n) z‖ ≤
+      (128 * Real.pi) * ‖Fₙ n z - aₙ n‖ :=
+    univalent_omitted_value_bound_ball hr ((hFn n).mono hball)
+      ((hinj n).mono hball) (aₙ n) (fun hh => homit n (image_mono hball hh))
+  have hd := ((hconv.deriv (Eventually.of_forall hFn) isOpen_upperHalfPlane).tendsto_at hz).norm
+  have hv := ((hconv.tendsto_at hz).sub ha).norm
+  have hb : z.im * ‖deriv F z‖ ≤ (128 * Real.pi) * ‖F z - a‖ :=
+    le_of_tendsto_of_tendsto (tendsto_const_nhds.mul hd)
+      (tendsto_const_nhds.mul hv) (Eventually.of_forall hbound)
+  rw [he, sub_self, norm_zero, mul_zero] at hb
+  have hp : 0 < z.im * ‖deriv F z‖ := mul_pos hr (norm_pos_iff.mpr (hne z hz))
+  exact (not_le_of_gt hp) hb
+
+/-- Reindexing a locally uniform limit along a subsequence. -/
+theorem locallyUniform_subsequence
+    {Fₙ : ℕ → ℂ → ℂ} {F : ℂ → ℂ} {S : Set ℂ}
+    (h : TendstoLocallyUniformlyOn Fₙ F atTop S)
+    {φ : ℕ → ℕ} (hφ : StrictMono φ) :
+    TendstoLocallyUniformlyOn (fun n => Fₙ (φ n)) F atTop S := by
+  intro U hU z hz
+  obtain ⟨V, hV, he⟩ := h U hU z hz
+  exact ⟨V, hV, hφ.tendsto_atTop.eventually he⟩
+
+/-- The unit-semicircle waypoint normalization survives uniform guide
+convergence on the closed time interval. -/
+theorem normalized_waypoint_of_uniform_limit
+    {βₙ : ℕ → ℝ → ℂ} {β : ℝ → ℂ} {I : Set ℝ} {tw s : ℝ}
+    (hu : TendstoUniformlyOn βₙ β atTop I) (htw : tw ∈ I)
+    (hway : ∀ n, ‖βₙ n tw‖ = 1 ∧ s ≤ (βₙ n tw).im) :
+    ‖β tw‖ = 1 ∧ s ≤ (β tw).im := by
+  have hn := (hu.tendsto_at htw).norm
+  have hn' : Tendsto (fun n : ℕ => ‖βₙ n tw‖) atTop (𝓝 (1 : ℝ)) := by
+    have he : (fun n : ℕ => ‖βₙ n tw‖) = fun _ => (1 : ℝ) :=
+      funext (fun n => (hway n).1)
+    rw [he]
+    exact tendsto_const_nhds
+  exact ⟨tendsto_nhds_unique hn hn',
+    ge_of_tendsto (Complex.continuous_im.continuousAt.tendsto.comp (hu.tendsto_at htw))
+      (Eventually.of_forall fun n => (hway n).2)⟩
+
+/-- Physical clearance on every interval away from zero gives the compact
+parameter confinement required to identify the inverse-guide limit. -/
+theorem compact_parameter_family_of_clearance
+    (g : ℕ → ℂ → ℂ) (D : ℕ → Set ℂ) (αₙ βₙ : ℕ → ℝ → ℂ)
+    {T tw s : ℝ} (C : ℝ≥0) (htw : 0 < tw) (htwT : tw ≤ T) (hs : 0 < s)
+    (hαL : ∀ n, LipschitzOnWith C (αₙ n) (Icc 0 T))
+    (hg : ∀ n, DifferentiableOn ℂ (g n) (D n)) (hig : ∀ n, InjOn (g n) (D n))
+    (hgH : ∀ n, MapsTo (g n) (D n) upperHalfPlane)
+    (hway : ∀ n, ‖βₙ n tw‖ = 1 ∧ s ≤ (βₙ n tw).im)
+    (hβeq : ∀ n t, t ∈ Ioc 0 T → βₙ n t = g n (αₙ n t))
+    (hclear : ∀ δ : ℝ, 0 < δ → δ ≤ T → ∃ r : ℝ, 0 < r ∧
+      ∀ n t, t ∈ Icc δ T → ball (αₙ n t) r ⊆ D n) :
+    ∀ δ : ℝ, 0 < δ → δ ≤ T →
+      ∃ Q : Set ℂ, IsCompact Q ∧ Q ⊆ upperHalfPlane ∧
+        ∀ n, MapsTo (βₙ n) (Icc δ T) Q := by
+  intro δ hδ hδT
+  let δ' := min δ tw
+  have hδ' : 0 < δ' := lt_min hδ htw
+  have hδ'T : δ' ≤ T := (min_le_left _ _).trans hδT
+  have htw' : tw ∈ Icc δ' T := ⟨min_le_right _ _, htwT⟩
+  have hsub : Icc δ' T ⊆ Icc 0 T := Icc_subset_Icc hδ'.le le_rfl
+  obtain ⟨r, hr, hballs⟩ := hclear δ' hδ' hδ'T
+  obtain ⟨Q, hQ, hQH, hmap, _⟩ :=
+    LipschitzGuideConfinement.family_compact_containment g αₙ hr C hs htw'
+      (fun n => (hαL n).mono hsub)
+      (fun n t ht => (hg n).mono (hballs n t ht))
+      (fun n t ht => (hig n).mono (hballs n t ht))
+      (fun n t ht => (hgH n).mono_left (hballs n t ht))
+      (fun n => by rw [← hβeq n tw ⟨htw, htwT⟩]; exact (hway n).1)
+      (fun n => by rw [← hβeq n tw ⟨htw, htwT⟩]; exact (hway n).2)
+  refine ⟨Q, hQ, hQH, ?_⟩
+  intro n t ht
+  rw [hβeq n t ⟨hδ.trans_le ht.1, ht.2⟩]
+  exact hmap n ⟨(min_le_left δ tw).trans ht.1, ht.2⟩
+
+/-- Actual inverse charts with a common physical clearance at the waypoint,
+bi-Lipschitz physical guides, and compact parameter confinement have one
+joint subsequential limit. The inverse guide remains continuous and simple
+through its initial boundary point. -/
+theorem exists_joint_guide_limit
+    {Ω : Type} [MeasurableSpace Ω] (P : Measure Ω) [IsProbabilityMeasure P]
+    (κ : ℝ) (hκ : 0 < κ) (hκ8 : κ < 8)
+    (γ : Ω → ℝ≥0 → ℂ) (hSLE : IsOrdinaryChordalSLE κ γ P)
+    (hpublished : PublishedHalfPlaneUnivalentCompactness)
+    (Fₙ g : ℕ → ℂ → ℂ) (D : ℕ → Set ℂ) (Fbar : ℕ → ℂ → OnePoint ℂ)
+    (αₙ βₙ : ℕ → ℝ → ℂ) (aₙ : ℕ → ℂ)
+    {T tw s ρ A c : ℝ} (C : ℝ≥0)
+    (hT : 0 < T) (htw : 0 < tw) (htwT : tw ≤ T)
+    (hs : 0 < s) (hρ : 0 < ρ) (hc : 0 < c) (hC : 0 < (C : ℝ))
+    (hD : ∀ n, IsOpen (D n))
+    (hFn : ∀ n, DifferentiableOn ℂ (Fₙ n) upperHalfPlane)
+    (hiFn : ∀ n, InjOn (Fₙ n) upperHalfPlane)
+    (hg : ∀ n, DifferentiableOn ℂ (g n) (D n)) (hig : ∀ n, InjOn (g n) (D n))
+    (hFD : ∀ n, MapsTo (Fₙ n) upperHalfPlane (D n))
+    (hgH : ∀ n, MapsTo (g n) (D n) upperHalfPlane)
+    (hgf : ∀ n z, z ∈ upperHalfPlane → g n (Fₙ n z) = z)
+    (hbar : ∀ n, ContinuousOn (Fbar n) {z : ℂ | 0 ≤ z.im})
+    (hext : ∀ n z, z ∈ upperHalfPlane → Fbar n z = (Fₙ n z : OnePoint ℂ))
+    (hαL : ∀ n, LipschitzOnWith C (αₙ n) (Icc 0 T))
+    (hα0 : ∀ n, αₙ n 0 = aₙ n) (haBound : ∀ n, ‖aₙ n‖ ≤ A)
+    (hchord : ∀ n u, u ∈ Icc 0 T → ∀ v, v ∈ Icc 0 T →
+      c * |u - v| ≤ dist (αₙ n u) (αₙ n v))
+    (hβ : ∀ n, ContinuousOn (βₙ n) (Icc 0 T)) (hβ0 : ∀ n, βₙ n 0 = 0)
+    (hβH : ∀ n t, t ∈ Icc 0 T → 0 ≤ (βₙ n t).im)
+    (hway : ∀ n, ‖βₙ n tw‖ = 1 ∧ s ≤ (βₙ n tw).im)
+    (hclear : ∀ n, ball (αₙ n tw) ρ ⊆ D n)
+    (homit : ∀ n, aₙ n ∉ Fₙ n '' upperHalfPlane)
+    (hrelation : ∀ n t, t ∈ Ioc 0 T → Fₙ n (βₙ n t) = αₙ n t)
+    (hbarRelation : ∀ n t, t ∈ Icc 0 T → Fbar n (βₙ n t) = (αₙ n t : OnePoint ℂ))
+    (hcompact : ∀ δ : ℝ, 0 < δ → δ ≤ T →
+      ∃ Q : Set ℂ, IsCompact Q ∧ Q ⊆ upperHalfPlane ∧
+        ∀ n, MapsTo (βₙ n) (Icc δ T) Q) :
+    ∃ (φ : ℕ → ℕ) (F : ℂ → ℂ) (α β : ℝ → ℂ), StrictMono φ ∧
+      DifferentiableOn ℂ F upperHalfPlane ∧ InjOn F upperHalfPlane ∧
+      (∀ z ∈ upperHalfPlane, deriv F z ≠ 0) ∧ α 0 ∉ F '' upperHalfPlane ∧
+      TendstoLocallyUniformlyOn (fun n => Fₙ (φ n)) F atTop upperHalfPlane ∧
+      TendstoUniformlyOn (fun n => αₙ (φ n)) α atTop (Icc 0 T) ∧
+      TendstoUniformlyOn (fun n => βₙ (φ n)) β atTop (Icc 0 T) ∧
+      Tendsto (fun n => aₙ (φ n)) atTop (𝓝 (α 0)) ∧
+      LipschitzOnWith C α (Icc 0 T) ∧ ContinuousOn α (Icc 0 T) ∧ InjOn α (Icc 0 T) ∧
+      β 0 = 0 ∧ ContinuousOn β (Icc 0 T) ∧ InjOn β (Icc 0 T) ∧
+      MapsTo β (Ioc 0 T) upperHalfPlane ∧ EqOn (F ∘ β) α (Ioc 0 T) := by
+  have htwi : tw ∈ Icc (0 : ℝ) T := ⟨htw.le, htwT⟩
+  have hnear n : ‖Fₙ n (βₙ n tw) - aₙ n‖ ≤ (C : ℝ) * tw := by
+    rw [hrelation n tw ⟨htw, htwT⟩, ← hα0 n, ← dist_eq_norm]
+    have hh := (hαL n).dist_le_mul tw htwi 0 ⟨le_rfl, hT.le⟩
+    simpa only [Real.dist_eq, sub_zero, abs_of_pos htw] using hh
+  obtain ⟨m, M, hm, hvalue, hder, hatip⟩ := waypoint_family_normalization_of_clearance
+    Fₙ g D hD hFn hiFn hg hig hFD hgH hgf (fun n => βₙ n tw) aₙ s ρ
+    ((C : ℝ) * tw) A hs hρ hway
+    (fun n => by rw [hrelation n tw ⟨htw, htwT⟩]; exact hclear n) homit hnear haBound
+  have himage n t (ht : t ∈ Icc 0 T) : ∃ w : ℂ,
+      Fbar n (βₙ n t) = (w : OnePoint ℂ) ∧ ‖w - aₙ n‖ ≤ (C : ℝ) * t := by
+    refine ⟨αₙ n t, hbarRelation n t ht, ?_⟩
+    rw [← hα0 n, ← dist_eq_norm]
+    have hh := (hαL n).dist_le_mul t ht 0 ⟨le_rfl, hT.le⟩
+    simpa only [Real.dist_eq, sub_zero, abs_of_nonneg ht.1] using hh
+  have htip := uniform_tip_collapse_of_published_compactness P κ hκ hκ8 γ hSLE
+    hpublished Fₙ Fbar hFn hiFn hbar hext (fun n => βₙ n tw) aₙ s m M hs hm
+    hway hvalue hder hatip βₙ T C hT hC hβ hβ0 hβH himage
+  obtain ⟨φ₀, F, hφ₀, hF, hiF, hFne, hFconv⟩ :=
+    hpublished Fₙ (fun n => βₙ n tw) s m M hs hm hFn hiFn hway hvalue hder
+  obtain ⟨α, ψ, hψ, hαconv, hαLip, hαcont, _, _, hαinj⟩ :=
+    PhysicalGuideCompactness.exists_simple_uniform_subsequence (fun n => αₙ (φ₀ n))
+      hT.le C hc (fun n => hαL _) (fun n => by rw [hα0]; exact haBound _)
+      (fun n => hchord _)
+  let φ : ℕ → ℕ := φ₀ ∘ ψ
+  have hφ : StrictMono φ := hφ₀.comp hψ
+  have hFconv' : TendstoLocallyUniformlyOn (fun n => Fₙ (φ n)) F atTop upperHalfPlane :=
+    locallyUniform_subsequence hFconv hψ
+  have hαconv' : TendstoUniformlyOn (fun n => αₙ (φ n)) α atTop (Icc 0 T) := hαconv
+  have halim : Tendsto (fun n => aₙ (φ n)) atTop (𝓝 (α 0)) := by
+    simpa only [hα0] using hαconv'.tendsto_at (show 0 ∈ Icc (0 : ℝ) T from ⟨le_rfl, hT.le⟩)
+  have hlimomit : α 0 ∉ F '' upperHalfPlane := limit_omits_tip
+    (fun n => Fₙ (φ n)) F (fun n => aₙ (φ n)) (α 0)
+    (fun n => hFn _) (fun n => hiFn _) hFconv' halim (fun n => homit _) hFne
+  obtain ⟨β, hβlim0, hβlimH, hβrel, hβcont, hβconv⟩ :=
+    GuideLimitIdentification.exists_continuous_guide_limit
+      (fun n => Fₙ (φ n)) F (fun n => βₙ (φ n)) (fun n => αₙ (φ n)) α
+      hF.continuousOn hiF hFconv' hαconv' (fun n => hβ _)
+      (fun δ hδ hδT => by
+        obtain ⟨Q, hQ, hQH, hβQ⟩ := hcompact δ hδ hδT
+        exact ⟨Q, hQ, hQH, fun n => hβQ _⟩)
+      (fun n => hrelation _)
+      (fun ε hε => by
+        obtain ⟨h, hh, hhT, hb⟩ := htip ε hε
+        exact ⟨h, hh, hhT, fun n => hb _⟩)
+  have hβinj := GuideLimitIdentification.inverse_guide_injective_with_tip
+    hβlim0 hβlimH hβrel (hαinj.mono Ioc_subset_Icc_self)
+  exact ⟨φ, F, α, β, hφ, hF, hiF, hFne, hlimomit, hFconv', hαconv', hβconv,
+    halim, hαLip, hαcont, hαinj, hβlim0, hβcont, hβinj, hβlimH, hβrel⟩
+
+/-- Joint guide compactness with compact containment discharged by the
+actual inverse charts and positive physical clearance away from the tip. -/
+theorem exists_joint_guide_limit_of_clearance
+    {Ω : Type} [MeasurableSpace Ω] (P : Measure Ω) [IsProbabilityMeasure P]
+    (κ : ℝ) (hκ : 0 < κ) (hκ8 : κ < 8)
+    (γ : Ω → ℝ≥0 → ℂ) (hSLE : IsOrdinaryChordalSLE κ γ P)
+    (hpublished : PublishedHalfPlaneUnivalentCompactness)
+    (Fₙ g : ℕ → ℂ → ℂ) (D : ℕ → Set ℂ) (Fbar : ℕ → ℂ → OnePoint ℂ)
+    (αₙ βₙ : ℕ → ℝ → ℂ) (aₙ : ℕ → ℂ)
+    {T tw s ρ A c : ℝ} (C : ℝ≥0)
+    (hT : 0 < T) (htw : 0 < tw) (htwT : tw ≤ T)
+    (hs : 0 < s) (hρ : 0 < ρ) (hc : 0 < c) (hC : 0 < (C : ℝ))
+    (hD : ∀ n, IsOpen (D n))
+    (hFn : ∀ n, DifferentiableOn ℂ (Fₙ n) upperHalfPlane)
+    (hiFn : ∀ n, InjOn (Fₙ n) upperHalfPlane)
+    (hg : ∀ n, DifferentiableOn ℂ (g n) (D n)) (hig : ∀ n, InjOn (g n) (D n))
+    (hFD : ∀ n, MapsTo (Fₙ n) upperHalfPlane (D n))
+    (hgH : ∀ n, MapsTo (g n) (D n) upperHalfPlane)
+    (hgf : ∀ n z, z ∈ upperHalfPlane → g n (Fₙ n z) = z)
+    (hbar : ∀ n, ContinuousOn (Fbar n) {z : ℂ | 0 ≤ z.im})
+    (hext : ∀ n z, z ∈ upperHalfPlane → Fbar n z = (Fₙ n z : OnePoint ℂ))
+    (hαL : ∀ n, LipschitzOnWith C (αₙ n) (Icc 0 T))
+    (hα0 : ∀ n, αₙ n 0 = aₙ n) (haBound : ∀ n, ‖aₙ n‖ ≤ A)
+    (hchord : ∀ n u, u ∈ Icc 0 T → ∀ v, v ∈ Icc 0 T →
+      c * |u - v| ≤ dist (αₙ n u) (αₙ n v))
+    (hβ : ∀ n, ContinuousOn (βₙ n) (Icc 0 T)) (hβ0 : ∀ n, βₙ n 0 = 0)
+    (hβH : ∀ n t, t ∈ Icc 0 T → 0 ≤ (βₙ n t).im)
+    (hway : ∀ n, ‖βₙ n tw‖ = 1 ∧ s ≤ (βₙ n tw).im)
+    (hclear : ∀ n, ball (αₙ n tw) ρ ⊆ D n)
+    (homit : ∀ n, aₙ n ∉ Fₙ n '' upperHalfPlane)
+    (hrelation : ∀ n t, t ∈ Ioc 0 T → Fₙ n (βₙ n t) = αₙ n t)
+    (hbarRelation : ∀ n t, t ∈ Icc 0 T → Fbar n (βₙ n t) = (αₙ n t : OnePoint ℂ))
+    (hβeq : ∀ n t, t ∈ Ioc 0 T → βₙ n t = g n (αₙ n t))
+    (hclearAway : ∀ δ : ℝ, 0 < δ → δ ≤ T → ∃ r : ℝ, 0 < r ∧
+      ∀ n t, t ∈ Icc δ T → ball (αₙ n t) r ⊆ D n) :
+    ∃ (φ : ℕ → ℕ) (F : ℂ → ℂ) (α β : ℝ → ℂ), StrictMono φ ∧
+      DifferentiableOn ℂ F upperHalfPlane ∧ InjOn F upperHalfPlane ∧
+      (∀ z ∈ upperHalfPlane, deriv F z ≠ 0) ∧ α 0 ∉ F '' upperHalfPlane ∧
+      TendstoLocallyUniformlyOn (fun n => Fₙ (φ n)) F atTop upperHalfPlane ∧
+      TendstoUniformlyOn (fun n => αₙ (φ n)) α atTop (Icc 0 T) ∧
+      TendstoUniformlyOn (fun n => βₙ (φ n)) β atTop (Icc 0 T) ∧
+      Tendsto (fun n => aₙ (φ n)) atTop (𝓝 (α 0)) ∧
+      LipschitzOnWith C α (Icc 0 T) ∧ ContinuousOn α (Icc 0 T) ∧ InjOn α (Icc 0 T) ∧
+      β 0 = 0 ∧ ContinuousOn β (Icc 0 T) ∧ InjOn β (Icc 0 T) ∧
+      MapsTo β (Ioc 0 T) upperHalfPlane ∧ EqOn (F ∘ β) α (Ioc 0 T) := by
+  have hcompact := compact_parameter_family_of_clearance g D αₙ βₙ C htw htwT hs
+    hαL hg hig hgH hway hβeq hclearAway
+  exact exists_joint_guide_limit P κ hκ hκ8 γ hSLE hpublished Fₙ g D Fbar αₙ βₙ aₙ C
+    hT htw htwT hs hρ hc hC hD hFn hiFn hg hig hFD hgH hgf hbar hext hαL hα0 haBound
+    hchord hβ hβ0 hβH hway hclear homit hrelation hbarRelation hcompact
+
+end SLEExactGauge.GuideCompactness
+
+end
+
+end OAI
diff --git a/lean/OAI/Probability/SLE/Geometry/GuideInteriorSeparation.lean b/lean/OAI/Probability/SLE/Geometry/GuideInteriorSeparation.lean
new file mode 100644
index 0000000000000000000000000000000000000000..650710e558c1e36abebc72da25abc2c780f9c936
--- /dev/null
+++ b/lean/OAI/Probability/SLE/Geometry/GuideInteriorSeparation.lean
@@ -0,0 +1,64 @@
+import OAI.Probability.SLE.LoewnerCharts
+
+namespace OAI
+
+/-!
+A fixed interior ball separated from the moving tip images in the guide
+compactness argument. Only local uniform convergence and continuity of
+the limit are used.
+-/
+
+noncomputable section
+open Set Filter Metric
+open scoped Topology
+
+namespace SLEExactGauge
+
+/-- A non-tip interior value of the limiting map supplies a fixed closed
+ball whose images stay uniformly away from the moving tip values. -/
+theorem exists_interior_ball_eventually_separated
+    (Fₙ : ℕ → ℂ → ℂ) (F : ℂ → ℂ) (aₙ : ℕ → ℂ) (a z₀ : ℂ)
+    (hconv : TendstoLocallyUniformlyOn Fₙ F atTop upperHalfPlane)
+    (ha : Tendsto aₙ atTop (𝓝 a)) (hF : ContinuousOn F upperHalfPlane)
+    (hz₀ : z₀ ∈ upperHalfPlane) (hne : F z₀ ≠ a) :
+    ∃ ρ r₀ : ℝ, 0 < ρ ∧ 0 < r₀ ∧ closedBall z₀ ρ ⊆ upperHalfPlane ∧
+      ∀ᶠ n in atTop, ∀ z ∈ closedBall z₀ ρ, r₀ ≤ ‖Fₙ n z - aₙ n‖ := by
+  let D : ℝ := ‖F z₀ - a‖
+  have hD : 0 < D := norm_pos_iff.mpr (sub_ne_zero.mpr hne)
+  have hcont : ContinuousAt (fun z => ‖F z - a‖) z₀ :=
+    ((hF.continuousAt (isOpen_upperHalfPlane.mem_nhds hz₀)).sub_const a).norm
+  have hsep : {z : ℂ | D / 2 < ‖F z - a‖} ∈ 𝓝 z₀ :=
+    hcont.preimage_mem_nhds (Ioi_mem_nhds (by dsimp only [D] at hD ⊢; linarith))
+  obtain ⟨ρ, hρ, hball⟩ := Metric.nhds_basis_closedBall.mem_iff.mp
+    (inter_mem (isOpen_upperHalfPlane.mem_nhds hz₀) hsep)
+  have hballH : closedBall z₀ ρ ⊆ upperHalfPlane := fun z hz => (hball hz).1
+  have hu : TendstoUniformlyOn Fₙ F atTop (closedBall z₀ ρ) :=
+    (tendstoLocallyUniformlyOn_iff_tendstoUniformlyOn_of_compact
+      (isCompact_closedBall z₀ ρ)).mp (hconv.mono hballH)
+  have herror : ∀ᶠ n in atTop, ∀ z ∈ closedBall z₀ ρ,
+      dist (F z) (Fₙ n z) < D / 8 :=
+    hu _ (Metric.dist_mem_uniformity (by positivity : 0 < D / 8))
+  have haerror : ∀ᶠ n in atTop, dist (aₙ n) a < D / 8 :=
+    Metric.tendsto_nhds.mp ha (D / 8) (by positivity)
+  refine ⟨ρ, D / 4, hρ, by positivity, hballH, ?_⟩
+  filter_upwards [herror, haerror] with n hn han
+  intro z hz
+  have hseparated : D / 2 < dist (F z) a := by
+    rw [dist_eq_norm]
+    exact (hball hz).2
+  have htriangle : dist (F z) a ≤
+      dist (F z) (Fₙ n z) + dist (Fₙ n z) (aₙ n) + dist (aₙ n) a := by
+    calc
+      _ ≤ dist (F z) (Fₙ n z) + dist (Fₙ n z) a := dist_triangle _ _ _
+      _ ≤ dist (F z) (Fₙ n z) + (dist (Fₙ n z) (aₙ n) + dist (aₙ n) a) :=
+        by linarith [dist_triangle (Fₙ n z) (aₙ n) a]
+      _ = _ := by ring
+  have he := hn z hz
+  rw [← dist_eq_norm]
+  linarith
+
+end SLEExactGauge
+
+end
+
+end OAI
diff --git a/lean/OAI/Probability/SLE/Geometry/GuideLimitIdentification.lean b/lean/OAI/Probability/SLE/Geometry/GuideLimitIdentification.lean
new file mode 100644
index 0000000000000000000000000000000000000000..9e4335a602186f2661ebff0ac867b3276fc0f8e6
--- /dev/null
+++ b/lean/OAI/Probability/SLE/Geometry/GuideLimitIdentification.lean
@@ -0,0 +1,277 @@
+import OAI.Probability.SLE.Geometry.HyperbolicGuideCompactness
+import OAI.Probability.SLE.Geometry.GuideTipCollapse
+
+namespace OAI
+
+/-!
+Identification of parameter-guide limits. Compact containment and injectivity
+give a uniform inverse modulus for the limiting conformal map, so the whole
+sequence converges once the physical guides do.
+-/
+
+noncomputable section
+open Set Filter MeasureTheory Metric
+open scoped Topology
+
+namespace SLEExactGauge.GuideLimitIdentification
+
+/-- An injective continuous map on a compact set has a uniform inverse
+modulus, stated directly in the ambient complex plane. -/
+theorem compact_inverse_modulus
+    {F : ℂ → ℂ} {Q : Set ℂ} (hQ : IsCompact Q)
+    (hF : ContinuousOn F Q) (hi : InjOn F Q) :
+    ∀ ε : ℝ, 0 < ε → ∃ η : ℝ, 0 < η ∧
+      ∀ x ∈ Q, ∀ y ∈ Q, dist (F x) (F y) < η → dist x y < ε := by
+  intro ε hε
+  let D := (Q ×ˢ Q) ∩ {p : ℂ × ℂ | ε ≤ dist p.1 p.2}
+  have hD : IsCompact D := (hQ.prod hQ).inter_right
+    (isClosed_le continuous_const (continuous_fst.dist continuous_snd))
+  have hc₁ : ContinuousOn (fun p : ℂ × ℂ => F p.1) D :=
+    hF.comp continuous_fst.continuousOn (fun _ hp => hp.1.1)
+  have hc₂ : ContinuousOn (fun p : ℂ × ℂ => F p.2) D :=
+    hF.comp continuous_snd.continuousOn (fun _ hp => hp.1.2)
+  have hc : ContinuousOn (fun p : ℂ × ℂ => dist (F p.1) (F p.2)) D :=
+    continuous_dist.comp_continuousOn (hc₁.prodMk hc₂)
+  by_cases hne : D.Nonempty
+  · obtain ⟨p, hp, hmin⟩ := hD.exists_isMinOn hne hc
+    have hxy : p.1 ≠ p.2 := by
+      intro he
+      have hh : ε ≤ dist p.1 p.2 := hp.2
+      rw [he, dist_self] at hh
+      linarith
+    have hpF : F p.1 ≠ F p.2 := fun he => hxy (hi hp.1.1 hp.1.2 he)
+    refine ⟨dist (F p.1) (F p.2), dist_pos.mpr hpF, ?_⟩
+    intro x hx y hy hdist
+    by_contra hn
+    have hxyD : (x, y) ∈ D := ⟨⟨hx, hy⟩, le_of_not_gt hn⟩
+    exact (not_le_of_gt hdist) (hmin hxyD)
+  · refine ⟨1, zero_lt_one, ?_⟩
+    intro x hx y hy _
+    by_contra hn
+    exact hne ⟨(x, y), ⟨⟨hx, hy⟩, le_of_not_gt hn⟩⟩
+
+/-- Uniform convergence of the physical curves and of the conformal maps on
+the common compact set gives uniform convergence after applying the limiting
+map to the parameter curves. -/
+theorem limiting_map_composition_tendsto
+    (Fₙ : ℕ → ℂ → ℂ) (F : ℂ → ℂ) (βₙ αₙ : ℕ → ℝ → ℂ) (α : ℝ → ℂ)
+    {Q : Set ℂ} {I : Set ℝ}
+    (hF : TendstoUniformlyOn Fₙ F atTop Q)
+    (hα : TendstoUniformlyOn αₙ α atTop I)
+    (hQ : ∀ n, MapsTo (βₙ n) I Q)
+    (hrelation : ∀ n t, t ∈ I → Fₙ n (βₙ n t) = αₙ n t) :
+    TendstoUniformlyOn (fun n t => F (βₙ n t)) α atTop I := by
+  apply Metric.tendstoUniformlyOn_iff.mpr
+  intro ε hε
+  have hFe := Metric.tendstoUniformlyOn_iff.mp hF (ε / 2) (by positivity)
+  have hαe := Metric.tendstoUniformlyOn_iff.mp hα (ε / 2) (by positivity)
+  filter_upwards [hFe, hαe] with n hnF hnα
+  intro t ht
+  have heF := hnF (βₙ n t) (hQ n ht)
+  have heα := hnα t ht
+  have heF' : dist (αₙ n t) (F (βₙ n t)) < ε / 2 := by
+    rw [← hrelation n t ht, dist_comm]
+    exact heF
+  exact (dist_triangle (α t) (αₙ n t) (F (βₙ n t))).trans_lt
+    (by linarith)
+
+/-- The unique inverse guide is the uniform limit on a fixed interval.
+The compact set can be supplied by `inverse_guide_family_compactness`. -/
+theorem exists_unique_uniform_guide_limit
+    (Fₙ : ℕ → ℂ → ℂ) (F : ℂ → ℂ) (βₙ αₙ : ℕ → ℝ → ℂ) (α : ℝ → ℂ)
+    {Q : Set ℂ} {I : Set ℝ} (hQ : IsCompact Q)
+    (hFcont : ContinuousOn F Q) (hi : InjOn F Q)
+    (hF : TendstoUniformlyOn Fₙ F atTop Q)
+    (hα : TendstoUniformlyOn αₙ α atTop I)
+    (hβQ : ∀ n, MapsTo (βₙ n) I Q)
+    (hβcont : ∀ n, ContinuousOn (βₙ n) I)
+    (hrelation : ∀ n t, t ∈ I → Fₙ n (βₙ n t) = αₙ n t) :
+    ∃ β : ℝ → ℂ, MapsTo β I Q ∧ EqOn (F ∘ β) α I ∧ ContinuousOn β I ∧
+      TendstoUniformlyOn βₙ β atTop I ∧
+      ∀ β' : ℝ → ℂ, MapsTo β' I Q → EqOn (F ∘ β') α I → EqOn β' β I := by
+  classical
+  have hc := limiting_map_composition_tendsto Fₙ F βₙ αₙ α hF hα hβQ hrelation
+  have hFQ : IsClosed (F '' Q) := (hQ.image_of_continuousOn hFcont).isClosed
+  have hex : ∀ t ∈ I, ∃ z ∈ Q, F z = α t := by
+    intro t ht
+    have hlim := hc.tendsto_at ht
+    have hm : α t ∈ F '' Q := hFQ.mem_of_tendsto hlim
+      (Eventually.of_forall (fun n => mem_image_of_mem F (hβQ n ht)))
+    exact hm
+  choose b hbQ hbF using hex
+  let β : ℝ → ℂ := fun t => if ht : t ∈ I then b t ht else 0
+  have hβm : MapsTo β I Q := by
+    intro t ht
+    simpa only [β, dite_eq_left ht] using hbQ t ht
+  have hβF : EqOn (F ∘ β) α I := by
+    intro t ht
+    simpa only [Function.comp_apply, β, dite_eq_left ht] using hbF t ht
+  have hu : TendstoUniformlyOn βₙ β atTop I := by
+    apply Metric.tendstoUniformlyOn_iff.mpr
+    intro ε hε
+    obtain ⟨η, hη, hinv⟩ := compact_inverse_modulus hQ hFcont hi ε hε
+    filter_upwards [Metric.tendstoUniformlyOn_iff.mp hc η hη] with n hn
+    intro t ht
+    apply hinv (β t) (hβm ht) (βₙ n t) (hβQ n ht)
+    have hβFt : F (β t) = α t := hβF ht
+    rw [hβFt]
+    exact hn t ht
+  refine ⟨β, hβm, hβF, hu.continuousOn (Frequently.of_forall hβcont), hu, ?_⟩
+  intro β' hβ'm hβ'F t ht
+  apply hi (hβ'm ht) (hβm ht)
+  exact (hβ'F ht).trans (hβF ht).symm
+
+theorem inverse_guide_injective
+    {β α : ℝ → ℂ} {G : ℂ → ℂ} {I : Set ℝ}
+    (hrelation : EqOn (G ∘ β) α I) (hα : InjOn α I) : InjOn β I := by
+  intro s hs t ht he
+  apply hα hs ht
+  rw [← hrelation hs, ← hrelation ht]
+  exact congrArg G he
+
+/-- The upper-half-plane condition separates every positive-time point
+from the starting point; injectivity of the physical guide separates the rest. -/
+theorem inverse_guide_injective_with_tip
+    {β α : ℝ → ℂ} {F : ℂ → ℂ} {T : ℝ}
+    (hzero : β 0 = 0) (hH : MapsTo β (Ioc 0 T) upperHalfPlane)
+    (hrelation : EqOn (F ∘ β) α (Ioc 0 T)) (hα : InjOn α (Ioc 0 T)) :
+    InjOn β (Icc 0 T) := by
+  have hnz : ∀ t ∈ Ioc 0 T, β t ≠ 0 := by
+    intro t ht he
+    have hh : 0 < (β t).im := hH ht
+    simp only [he, Complex.zero_im, lt_self_iff_false] at hh
+  intro s hs t ht he
+  by_cases hs0 : s = 0
+  · subst s
+    by_contra ht0
+    have htp : 0 < t := by rcases eq_or_lt_of_le ht.1 with he | he; exact False.elim (ht0 he); exact he
+    exact hnz t ⟨htp, ht.2⟩ (he.symm.trans hzero)
+  by_cases ht0 : t = 0
+  · subst t
+    have hsp : 0 < s := by rcases eq_or_lt_of_le hs.1 with he | he; exact False.elim (hs0 he.symm); exact he
+    exact False.elim (hnz s ⟨hsp, hs.2⟩ (he.trans hzero))
+  have hsp : 0 < s := by rcases eq_or_lt_of_le hs.1 with he | he; exact False.elim (hs0 he.symm); exact he
+  have htp : 0 < t := by rcases eq_or_lt_of_le ht.1 with he | he; exact False.elim (ht0 he.symm); exact he
+  exact inverse_guide_injective hrelation hα ⟨hsp, hs.2⟩ ⟨htp, ht.2⟩ he
+
+/-- The fixed-interval inverse limit supplied by the actual normalized
+hyperbolic-speed estimates. -/
+theorem normalized_guide_limit
+    (Fₙ : ℕ → ℂ → ℂ) (F : ℂ → ℂ) (βₙ αₙ : ℕ → ℝ → ℂ) (α : ℝ → ℂ)
+    {δ T tw K s : ℝ} (hK : 0 ≤ K) (hs : 0 < s) (htw : tw ∈ Icc δ T)
+    (hD : ∀ n t, t ∈ Icc δ T → DifferentiableAt ℝ (βₙ n) t)
+    (hH : ∀ n t, t ∈ Icc δ T → 0 < (βₙ n t).im)
+    (hv : ∀ n t, t ∈ Icc δ T → ‖deriv (βₙ n) t‖ ≤ K * (βₙ n t).im)
+    (hway : ∀ n, ‖βₙ n tw‖ = 1) (hangle : ∀ n, s ≤ (βₙ n tw).im)
+    (hFcont : ContinuousOn F upperHalfPlane) (hi : InjOn F upperHalfPlane)
+    (hF : TendstoLocallyUniformlyOn Fₙ F atTop upperHalfPlane)
+    (hα : TendstoUniformlyOn αₙ α atTop (Icc δ T))
+    (hrelation : ∀ n t, t ∈ Icc δ T → Fₙ n (βₙ n t) = αₙ n t) :
+    ∃ β : ℝ → ℂ, MapsTo β (Icc δ T) upperHalfPlane ∧
+      EqOn (F ∘ β) α (Icc δ T) ∧ ContinuousOn β (Icc δ T) ∧
+      TendstoUniformlyOn βₙ β atTop (Icc δ T) := by
+  obtain ⟨hQ, hQH, hβQ, _⟩ :=
+    HyperbolicGuideCompactness.family_compact_containment_equicontinuity
+      βₙ hK hs htw hD hH hv hway hangle
+  have hFH := (tendstoLocallyUniformlyOn_iff_tendstoUniformlyOn_of_compact hQ).mp
+    (hF.mono hQH)
+  obtain ⟨β, hβ, hβF, hc, hu, _⟩ := exists_unique_uniform_guide_limit
+    Fₙ F βₙ αₙ α hQ (hFcont.mono hQH) (hi.mono hQH) hFH hα hβQ
+    (fun n => fun t ht => (hD n t ht).continuousAt.continuousWithinAt) hrelation
+  exact ⟨β, fun t ht => hQH (hβ ht), hβF, hc, hu⟩
+
+/-- A common tip modulus upgrades uniform convergence away from the tip to
+uniform convergence on the closed time interval, including continuity at zero. -/
+theorem uniform_limit_of_away_and_common_tip_modulus
+    (βₙ : ℕ → ℝ → ℂ) (β : ℝ → ℂ) {T : ℝ}
+    (hcont : ∀ n, ContinuousOn (βₙ n) (Icc 0 T)) (hzero : β 0 = 0)
+    (haway : ∀ δ : ℝ, 0 < δ → δ ≤ T →
+      TendstoUniformlyOn βₙ β atTop (Icc δ T))
+    (htip : ∀ ε : ℝ, 0 < ε → ∃ h : ℝ, 0 < h ∧ h ≤ T ∧
+      ∀ n t, t ∈ Icc 0 h → ‖βₙ n t‖ < ε) :
+    TendstoUniformlyOn βₙ β atTop (Icc 0 T) ∧ ContinuousOn β (Icc 0 T) := by
+  have hu : TendstoUniformlyOn βₙ β atTop (Icc 0 T) := by
+    apply Metric.tendstoUniformlyOn_iff.mpr
+    intro ε hε
+    obtain ⟨h, hh, hhT, hsmall⟩ := htip (ε / 3) (by positivity)
+    have hβsmall : ∀ t ∈ Icc 0 h, ‖β t‖ ≤ ε / 3 := by
+      intro t ht
+      rcases eq_or_lt_of_le ht.1 with ht0 | ht0
+      · subst t
+        simpa only [hzero, norm_zero] using (show (0 : ℝ) ≤ ε / 3 by positivity)
+      · exact le_of_tendsto ((haway t ht0 (ht.2.trans hhT)).tendsto_at
+          (show t ∈ Icc t T from ⟨le_rfl, ht.2.trans hhT⟩)).norm
+          (Eventually.of_forall fun n => (hsmall n t ht).le)
+    filter_upwards [Metric.tendstoUniformlyOn_iff.mp (haway h hh hhT) ε hε] with n hn
+    intro t ht
+    by_cases hth : h ≤ t
+    · exact hn t ⟨hth, ht.2⟩
+    · have ht' : t ∈ Icc 0 h := ⟨ht.1, (lt_of_not_ge hth).le⟩
+      calc
+        dist (β t) (βₙ n t) ≤ ‖β t‖ + ‖βₙ n t‖ := dist_le_norm_add_norm _ _
+        _ < ε := by linarith [hβsmall t ht', hsmall n t ht']
+  exact ⟨hu, hu.continuousOn (Frequently.of_forall hcont)⟩
+
+/-- Compatible inverse limits on all positive compact time intervals give one
+continuous guide starting at zero. The compact sets are the actual confinement
+sets proved by `HyperbolicGuideCompactness`. -/
+theorem exists_continuous_guide_limit
+    (Fₙ : ℕ → ℂ → ℂ) (F : ℂ → ℂ) (βₙ αₙ : ℕ → ℝ → ℂ) (α : ℝ → ℂ)
+    {T : ℝ}
+    (hFcont : ContinuousOn F upperHalfPlane) (hi : InjOn F upperHalfPlane)
+    (hF : TendstoLocallyUniformlyOn Fₙ F atTop upperHalfPlane)
+    (hα : TendstoUniformlyOn αₙ α atTop (Icc 0 T))
+    (hcont : ∀ n, ContinuousOn (βₙ n) (Icc 0 T))
+    (hcompact : ∀ δ : ℝ, 0 < δ → δ ≤ T →
+      ∃ Q : Set ℂ, IsCompact Q ∧ Q ⊆ upperHalfPlane ∧
+        ∀ n, MapsTo (βₙ n) (Icc δ T) Q)
+    (hrelation : ∀ n t, t ∈ Ioc 0 T → Fₙ n (βₙ n t) = αₙ n t)
+    (htip : ∀ ε : ℝ, 0 < ε → ∃ h : ℝ, 0 < h ∧ h ≤ T ∧
+      ∀ n t, t ∈ Icc 0 h → ‖βₙ n t‖ < ε) :
+    ∃ β : ℝ → ℂ, β 0 = 0 ∧ MapsTo β (Ioc 0 T) upperHalfPlane ∧
+      EqOn (F ∘ β) α (Ioc 0 T) ∧ ContinuousOn β (Icc 0 T) ∧
+      TendstoUniformlyOn βₙ β atTop (Icc 0 T) := by
+  classical
+  have hlocal (δ : ℝ) (hδ : 0 < δ) (hδT : δ ≤ T) :
+      ∃ β : ℝ → ℂ, MapsTo β (Icc δ T) upperHalfPlane ∧
+        EqOn (F ∘ β) α (Icc δ T) ∧ ContinuousOn β (Icc δ T) ∧
+        TendstoUniformlyOn βₙ β atTop (Icc δ T) := by
+    obtain ⟨Q, hQ, hQH, hβQ⟩ := hcompact δ hδ hδT
+    have hsub : Icc δ T ⊆ Icc 0 T := Icc_subset_Icc hδ.le le_rfl
+    obtain ⟨β, hβ, hβF, hc, hu, _⟩ := exists_unique_uniform_guide_limit
+      Fₙ F βₙ αₙ α hQ (hFcont.mono hQH) (hi.mono hQH)
+      ((tendstoLocallyUniformlyOn_iff_tendstoUniformlyOn_of_compact hQ).mp (hF.mono hQH))
+      (hα.mono hsub) hβQ (fun n => (hcont n).mono hsub)
+      (fun n t ht => hrelation n t ⟨hδ.trans_le ht.1, ht.2⟩)
+    exact ⟨β, fun t ht => hQH (hβ ht), hβF, hc, hu⟩
+  have hex : ∀ t ∈ Ioc 0 T, ∃ z ∈ upperHalfPlane, F z = α t := by
+    intro t ht
+    obtain ⟨b, hb, hbF, _, _⟩ := hlocal t ht.1 ht.2
+    exact ⟨b t, hb ⟨le_rfl, ht.2⟩, hbF ⟨le_rfl, ht.2⟩⟩
+  choose b hbH hbF using hex
+  let β : ℝ → ℂ := fun t => if ht : t ∈ Ioc 0 T then b t ht else 0
+  have hβ0 : β 0 = 0 := by simp [β]
+  have hβH : MapsTo β (Ioc 0 T) upperHalfPlane := by
+    intro t ht
+    simpa only [β, dite_eq_left ht] using hbH t ht
+  have hβF : EqOn (F ∘ β) α (Ioc 0 T) := by
+    intro t ht
+    simpa only [Function.comp_apply, β, dite_eq_left ht] using hbF t ht
+  have haway (δ : ℝ) (hδ : 0 < δ) (hδT : δ ≤ T) :
+      TendstoUniformlyOn βₙ β atTop (Icc δ T) := by
+    obtain ⟨b', hb', hb'F, _, hu⟩ := hlocal δ hδ hδT
+    have heq : EqOn b' β (Icc δ T) := by
+      intro t ht
+      have ht' : t ∈ Ioc 0 T := ⟨hδ.trans_le ht.1, ht.2⟩
+      apply hi (hb' ht) (hβH ht')
+      exact (hb'F ht).trans (hβF ht').symm
+    exact hu.congr_right heq
+  obtain ⟨hu, hc⟩ := uniform_limit_of_away_and_common_tip_modulus
+    βₙ β hcont hβ0 haway htip
+  exact ⟨β, hβ0, hβH, hβF, hc, hu⟩
+
+end SLEExactGauge.GuideLimitIdentification
+
+end
+
+end OAI
diff --git a/lean/OAI/Probability/SLE/Geometry/GuideSplice.lean b/lean/OAI/Probability/SLE/Geometry/GuideSplice.lean
new file mode 100644
index 0000000000000000000000000000000000000000..b377722e39bcf0f4ea2bbb895dcea95d5d740e8a
--- /dev/null
+++ b/lean/OAI/Probability/SLE/Geometry/GuideSplice.lean
@@ -0,0 +1,491 @@
+import OAI.Probability.SLE.Geometry.SmallImageSector
+
+namespace OAI
+
+/-!
+The deterministic last-crossing and connector geometry following
+`es:good-semicircle`. All sets below are actual subsets of the complex plane.
+-/
+
+noncomputable section
+open Set Filter MeasureTheory Metric
+open scoped Topology
+open scoped unitInterval
+
+namespace SLEExactGauge.GuideSplice
+
+/-- The final crossing of a small circle occurs before the specified positive
+time; the remainder of the guide lies strictly outside that circle. -/
+theorem exists_last_circle_crossing
+    {β : ℝ → ℂ} {B δ T : ℝ} (hB : 0 < B) (hδ : 0 < δ) (hδT : δ ≤ T)
+    (hβ : ContinuousOn β (Icc 0 T)) (hβ₀ : β 0 = 0)
+    (hlate : ∀ t ∈ Icc δ T, B < ‖β t‖) :
+    ∃ tB ∈ Ioo 0 δ, ‖β tB‖ = B ∧
+      ∀ t ∈ Ioc tB T, B < ‖β t‖ := by
+  have hT : 0 < T := hδ.trans_le hδT
+  have hBT := hlate T ⟨hδT, le_rfl⟩
+  let K := Icc 0 T ∩ (fun t => ‖β t‖) ⁻¹' {B}
+  have hKclosed : IsClosed K :=
+    hβ.norm.preimage_isClosed_of_isClosed isClosed_Icc isClosed_singleton
+  have hKcompact : IsCompact K := isCompact_Icc.of_isClosed_subset hKclosed inter_subset_left
+  have hKnonempty : K.Nonempty := by
+    obtain ⟨t, ht, he⟩ := intermediate_value_Icc hT.le hβ.norm
+      (show B ∈ Icc ‖β 0‖ ‖β T‖ by simpa [hβ₀] using And.intro hB.le hBT.le)
+    exact ⟨t, ht, he⟩
+  obtain ⟨tB, htB, hmax⟩ := hKcompact.exists_isGreatest hKnonempty
+  have heB : ‖β tB‖ = B := htB.2
+  have htBpos : 0 < tB := by
+    by_contra hn
+    have he : tB = 0 := le_antisymm (le_of_not_gt hn) htB.1.1
+    rw [he, hβ₀, norm_zero] at heB
+    exact hB.ne' heB.symm
+  have htBδ : tB < δ := by
+    by_contra hn
+    have hh := hlate tB ⟨le_of_not_gt hn, htB.1.2⟩
+    exact (ne_of_gt hh) heB
+  refine ⟨tB, ⟨htBpos, htBδ⟩, heB, ?_⟩
+  intro t ht
+  by_contra hn
+  have htlow : ‖β t‖ ≤ B := le_of_not_gt hn
+  have hct : ContinuousOn (fun s => ‖β s‖) (Icc t T) :=
+    hβ.norm.mono (Icc_subset_Icc_left (htB.1.1.trans ht.1.le))
+  obtain ⟨s, hs, hse⟩ := intermediate_value_Icc ht.2 hct ⟨htlow, hBT.le⟩
+  have hsK : s ∈ K := ⟨⟨htB.1.1.trans (ht.1.le.trans hs.1), hs.2⟩, hse⟩
+  exact (not_le_of_gt (ht.1.trans_le hs.1)) (hmax hsK)
+
+def connectorTop (B x : ℝ) : ℂ := (x : ℂ) + (Real.sqrt (B ^ 2 - x ^ 2) : ℂ) * Complex.I
+
+def verticalConnector (B x : ℝ) : Set ℂ :=
+  {z | z.re = x ∧ B / 4 ≤ z.im ∧ z.im ≤ Real.sqrt (B ^ 2 - x ^ 2)}
+
+def initialRectangle (B : ℝ) : Set ℂ :=
+  {z | |z.re| < B / 16 ∧ 0 ≤ z.im ∧ z.im ≤ B / 4}
+
+lemma circle_height_pos {B x : ℝ} (hB : 0 < B) (hx : |x| < B / 16) :
+    0 < B ^ 2 - x ^ 2 := by
+  have hs : x ^ 2 < (B / 16) ^ 2 := by
+    simpa only [sq_abs] using (sq_lt_sq₀ (abs_nonneg x) (by positivity)).mpr hx
+  nlinarith
+
+lemma connectorTop_norm {B x : ℝ} (hB : 0 < B) (hx : |x| < B / 16) :
+    ‖connectorTop B x‖ = B := by
+  have hs := Real.sq_sqrt (circle_height_pos hB hx).le
+  have hn := Complex.sq_norm (connectorTop B x)
+  simp [connectorTop, Complex.normSq_apply] at hn
+  change ‖connectorTop B x‖ ^ 2 = x * x +
+    Real.sqrt (B ^ 2 - x ^ 2) * Real.sqrt (B ^ 2 - x ^ 2) at hn
+  nlinarith [norm_nonneg (connectorTop B x)]
+
+/-- The entire vertical connector lies in the central sector controlled by
+the small-image estimate, including its lower endpoint. -/
+theorem verticalConnector_subset_sector {B x : ℝ}
+    (hB : 0 < B) (hx : |x| < B / 16) :
+    verticalConnector B x ⊆
+      {z | B / 8 ≤ ‖z‖ ∧ ‖z‖ ≤ B ∧ ‖z‖ / 2 ≤ z.im} := by
+  intro z hz
+  obtain ⟨hzx, hzlow, hzup⟩ := hz
+  have hs := Real.sq_sqrt (circle_height_pos hB hx).le
+  have hn := Complex.sq_norm z
+  rw [Complex.normSq_apply, hzx] at hn
+  have hzpos : 0 < z.im := (by positivity : 0 < B / 4).trans_le hzlow
+  have hsx : x ^ 2 < (B / 16) ^ 2 := by
+    simpa only [sq_abs] using (sq_lt_sq₀ (abs_nonneg x) (by positivity)).mpr hx
+  have hsy : z.im ^ 2 ≤ (Real.sqrt (B ^ 2 - x ^ 2)) ^ 2 :=
+    (sq_le_sq₀ hzpos.le (Real.sqrt_nonneg _)).mpr hzup
+  have hly : (B / 4) ^ 2 ≤ z.im ^ 2 :=
+    (sq_le_sq₀ (by positivity) hzpos.le).mpr hzlow
+  have hnim : z.im ≤ ‖z‖ := Complex.im_le_norm z
+  refine ⟨by linarith, ?_, ?_⟩
+  · nlinarith [norm_nonneg z]
+  · nlinarith [norm_nonneg z]
+
+lemma initialRectangle_subset_smallBall {B : ℝ} (hB : 0 < B) :
+    initialRectangle B ⊆ ball (0 : ℂ) (B / 2) := by
+  intro z hz
+  obtain ⟨hxr, hy0, hyr⟩ := hz
+  have hsx : z.re ^ 2 < (B / 16) ^ 2 := by
+    simpa only [sq_abs] using (sq_lt_sq₀ (abs_nonneg _) (by positivity)).mpr hxr
+  have hsy : z.im ^ 2 ≤ (B / 4) ^ 2 := (sq_le_sq₀ hy0 (by positivity)).mpr hyr
+  have hn := Complex.sq_norm z
+  rw [Complex.normSq_apply] at hn
+  rw [mem_ball_zero_iff]
+  nlinarith [norm_nonneg z]
+
+/-- Above its first point, the vertical connector is disjoint from every
+initial hull contained in the specified rectangle. -/
+lemma verticalConnector_meets_rectangle_only_at_start {B x : ℝ}
+    {z : ℂ} (hz : z ∈ verticalConnector B x) (hrect : z ∈ initialRectangle B) :
+    z = (x : ℂ) + ((B / 4 : ℝ) : ℂ) * Complex.I := by
+  apply Complex.ext
+  · simpa using hz.1
+  · simpa using le_antisymm hrect.2.2 hz.2.1
+
+lemma circle_and_outerGuide_avoid_initialRectangle {B : ℝ} (hB : 0 < B)
+    {z : ℂ} (hz : B ≤ ‖z‖) : z ∉ initialRectangle B := by
+  intro hrect
+  have hh := mem_ball_zero_iff.mp (initialRectangle_subset_smallBall hB hrect)
+  linarith
+
+def semicircleArc (B α ω : ℝ) : Set ℂ :=
+  (fun θ : ℝ => (B : ℂ) * Complex.exp ((θ : ℂ) * Complex.I)) '' uIcc α ω
+
+lemma semicircleArc_compact (B α ω : ℝ) : IsCompact (semicircleArc B α ω) := by
+  apply isCompact_uIcc.image
+  exact continuous_const.mul ((Complex.continuous_ofReal.mul continuous_const).cexp)
+
+lemma semicircleArc_norm {B α ω : ℝ} (hB : 0 < B) {z : ℂ}
+    (hz : z ∈ semicircleArc B α ω) : ‖z‖ = B := by
+  obtain ⟨θ, _, rfl⟩ := hz
+  simp [Complex.norm_real, abs_of_pos hB, Complex.norm_exp]
+
+lemma semicircleArc_subset_halfPlane {B α ω : ℝ} (hB : 0 < B)
+    (hα : α ∈ Ioo 0 Real.pi) (hω : ω ∈ Ioo 0 Real.pi) :
+    semicircleArc B α ω ⊆ {z : ℂ | 0 < z.im} := by
+  rintro z ⟨θ, hθ, rfl⟩
+  have hθ' := ordConnected_Ioo.uIcc_subset hα hω hθ
+  change 0 < ((B : ℂ) * Complex.exp ((θ : ℂ) * Complex.I)).im
+  simpa [Complex.exp_im] using mul_pos hB (Real.sin_pos_of_pos_of_lt_pi hθ'.1 hθ'.2)
+
+lemma verticalConnector_eq_image (B x : ℝ) : verticalConnector B x =
+    (fun y : ℝ => (x : ℂ) + (y : ℂ) * Complex.I) ''
+      Icc (B / 4) (Real.sqrt (B ^ 2 - x ^ 2)) := by
+  ext z
+  constructor
+  · rintro ⟨hx, hlo, hup⟩
+    refine ⟨z.im, ⟨hlo, hup⟩, ?_⟩
+    apply Complex.ext <;> simp [← hx]
+  · rintro ⟨y, hy, rfl⟩
+    simpa [verticalConnector] using And.intro (rfl : x = x) hy
+
+lemma verticalConnector_compact (B x : ℝ) : IsCompact (verticalConnector B x) := by
+  rw [verticalConnector_eq_image]
+  apply isCompact_Icc.image
+  exact continuous_const.add (Complex.continuous_ofReal.mul continuous_const)
+
+lemma verticalConnector_subset_halfPlane {B x : ℝ} (hB : 0 < B) :
+    verticalConnector B x ⊆ {z : ℂ | 0 < z.im} := by
+  intro z hz
+  exact lt_of_lt_of_le (by positivity : 0 < B / 4) hz.2.1
+
+/-- The actual compact set traced by the vertical piece, the circular piece,
+and the remainder of the guide. -/
+def continuationRoute (B x α ω : ℝ) (β : ℝ → ℂ) (tB T : ℝ) : Set ℂ :=
+  verticalConnector B x ∪ semicircleArc B α ω ∪ β '' Icc tB T
+
+theorem continuationRoute_compact
+    {B x α ω tB T : ℝ} {β : ℝ → ℂ}
+    (hβ : ContinuousOn β (Icc 0 T)) (htB : 0 ≤ tB) :
+    IsCompact (continuationRoute B x α ω β tB T) := by
+  exact ((verticalConnector_compact B x).union (semicircleArc_compact B α ω)).union
+    (isCompact_Icc.image_of_continuousOn (hβ.mono (Icc_subset_Icc_left htB)))
+
+theorem continuationRoute_subset_halfPlane
+    {B x α ω tB T : ℝ} {β : ℝ → ℂ} (hB : 0 < B)
+    (hα : α ∈ Ioo 0 Real.pi) (hω : ω ∈ Ioo 0 Real.pi) (htB : 0 < tB)
+    (hβH : ∀ t ∈ Ioc 0 T, 0 < (β t).im) :
+    continuationRoute B x α ω β tB T ⊆ {z : ℂ | 0 < z.im} := by
+  intro z hz
+  rcases hz with (hz | hz) | ⟨t, ht, rfl⟩
+  · exact verticalConnector_subset_halfPlane hB hz
+  · exact semicircleArc_subset_halfPlane hB hα hω hz
+  · exact hβH t ⟨htB.trans_le ht.1, ht.2⟩
+
+/-- The continuation route avoids an arbitrary hull in the source rectangle,
+except at its initial tip. -/
+theorem continuationRoute_meets_rectangle_only_at_start
+    {B x α ω tB T : ℝ} {β : ℝ → ℂ} (hB : 0 < B)
+    (hcross : ‖β tB‖ = B) (hafter : ∀ t ∈ Ioc tB T, B < ‖β t‖)
+    {z : ℂ} (hz : z ∈ continuationRoute B x α ω β tB T)
+    (hrect : z ∈ initialRectangle B) :
+    z = (x : ℂ) + ((B / 4 : ℝ) : ℂ) * Complex.I := by
+  rcases hz with (hz | hz) | ⟨t, ht, rfl⟩
+  · exact verticalConnector_meets_rectangle_only_at_start hz hrect
+  · exact False.elim (circle_and_outerGuide_avoid_initialRectangle hB
+      (semicircleArc_norm hB hz).ge hrect)
+  · have hnorm : B ≤ ‖β t‖ := by
+      rcases eq_or_lt_of_le ht.1 with he | he
+      · simpa only [← he, hcross] using (le_rfl : B ≤ B)
+      · exact (hafter t ⟨he, ht.2⟩).le
+    exact False.elim (circle_and_outerGuide_avoid_initialRectangle hB hnorm hrect)
+
+/-- The vertical connector reaches the radius-`B` circle only at its top. -/
+lemma verticalConnector_meets_circle_only_at_top {B x : ℝ}
+    (hB : 0 < B) (hx : |x| < B / 16) {z : ℂ}
+    (hz : z ∈ verticalConnector B x) (hcircle : ‖z‖ = B) :
+    z = connectorTop B x := by
+  have hs := Real.sq_sqrt (circle_height_pos hB hx).le
+  have hn := Complex.sq_norm z
+  rw [Complex.normSq_apply, hz.1, hcircle] at hn
+  have hzim : 0 < z.im := (by positivity : 0 < B / 4).trans_le hz.2.1
+  apply Complex.ext
+  · simpa [connectorTop] using hz.1
+  · simp only [connectorTop, Complex.add_im, Complex.ofReal_im, Complex.mul_im,
+      Complex.ofReal_re, Complex.I_im, Complex.I_re, mul_one, mul_zero, add_zero, zero_add]
+    nlinarith [Real.sqrt_nonneg (B ^ 2 - x ^ 2)]
+
+/-- The tail meets the selected circle only at the last-crossing point. -/
+lemma tail_meets_circle_only_at_start {β : ℝ → ℂ} {B tB T : ℝ}
+    (hafter : ∀ t ∈ Ioc tB T, B < ‖β t‖) {z : ℂ}
+    (hz : z ∈ β '' Icc tB T) (hcircle : ‖z‖ = B) : z = β tB := by
+  obtain ⟨t, ht, rfl⟩ := hz
+  rcases eq_or_lt_of_le ht.1 with he | he
+  · rw [← he]
+  · exact False.elim ((ne_of_gt (hafter t ⟨he, ht.2⟩)) hcircle)
+
+lemma verticalConnector_inter_semicircleArc {B x α ω : ℝ}
+    (hB : 0 < B) (hx : |x| < B / 16) :
+    verticalConnector B x ∩ semicircleArc B α ω ⊆ {connectorTop B x} := by
+  intro z hz
+  exact verticalConnector_meets_circle_only_at_top hB hx hz.1 (semicircleArc_norm hB hz.2)
+
+lemma semicircleArc_inter_tail {β : ℝ → ℂ} {B α ω tB T : ℝ}
+    (hB : 0 < B) (hafter : ∀ t ∈ Ioc tB T, B < ‖β t‖) :
+    semicircleArc B α ω ∩ β '' Icc tB T ⊆ {β tB} := by
+  intro z hz
+  exact tail_meets_circle_only_at_start hafter hz.2 (semicircleArc_norm hB hz.1)
+
+lemma verticalConnector_inter_tail {β : ℝ → ℂ} {B x tB T : ℝ}
+    (hB : 0 < B) (hx : |x| < B / 16)
+    (hcross : ‖β tB‖ = B) (hafter : ∀ t ∈ Ioc tB T, B < ‖β t‖) :
+    verticalConnector B x ∩ β '' Icc tB T ⊆ {connectorTop B x} ∩ {β tB} := by
+  rintro z ⟨hz, t, ht, rfl⟩
+  have hle := (verticalConnector_subset_sector hB hx hz).2.1
+  have hteq : tB = t := by
+    rcases eq_or_lt_of_le ht.1 with he | he
+    · exact he
+    · exact False.elim (not_lt_of_ge hle (hafter t ⟨he, ht.2⟩))
+  have hcircle : ‖β t‖ = B := by rwa [← hteq]
+  exact ⟨verticalConnector_meets_circle_only_at_top hB hx hz hcircle, by simp [← hteq]⟩
+
+lemma path_trans_injective {x y z : ℂ} {p : Path x y} {q : Path y z}
+    (hp : Function.Injective p) (hq : Function.Injective q)
+    (hmeet : ∀ s t : unitInterval, p s = q t → s = 1 ∧ t = 0) :
+    Function.Injective (p.trans q) := by
+  intro s t he
+  apply Subtype.ext
+  by_cases hs : (s : ℝ) ≤ 1 / 2
+  · by_cases ht : (t : ℝ) ≤ 1 / 2
+    · simp only [Path.trans_apply, dite_eq_left hs, dite_eq_left ht] at he
+      have hv := congrArg (fun v : unitInterval => (v : ℝ)) (hp he)
+      dsimp only at hv
+      linarith
+    · simp only [Path.trans_apply, dite_eq_left hs, dite_eq_right ht] at he
+      obtain ⟨hv, hw⟩ := hmeet _ _ he
+      have hv' := congrArg (fun v : unitInterval => (v : ℝ)) hv
+      have hw' := congrArg (fun v : unitInterval => (v : ℝ)) hw
+      change 2 * (s : ℝ) = 1 at hv'
+      change 2 * (t : ℝ) - 1 = 0 at hw'
+      linarith
+  · by_cases ht : (t : ℝ) ≤ 1 / 2
+    · simp only [Path.trans_apply, dite_eq_right hs, dite_eq_left ht] at he
+      obtain ⟨hv, hw⟩ := hmeet _ _ he.symm
+      have hv' := congrArg (fun v : unitInterval => (v : ℝ)) hv
+      have hw' := congrArg (fun v : unitInterval => (v : ℝ)) hw
+      change 2 * (t : ℝ) = 1 at hv'
+      change 2 * (s : ℝ) - 1 = 0 at hw'
+      linarith
+    · simp only [Path.trans_apply, dite_eq_right hs, dite_eq_right ht] at he
+      have hv := congrArg (fun v : unitInterval => (v : ℝ)) (hq he)
+      dsimp only at hv
+      linarith
+
+def circlePoint (B θ : ℝ) : ℂ := (B : ℂ) * Complex.exp ((θ : ℂ) * Complex.I)
+
+def circularPath (B α ω : ℝ) : Path (circlePoint B α) (circlePoint B ω) :=
+  (Path.segment α ω).map
+    (show Continuous (circlePoint B) from
+      continuous_const.mul ((Complex.continuous_ofReal.mul continuous_const).cexp))
+
+lemma circularPath_range (B α ω : ℝ) :
+    range (circularPath B α ω) = semicircleArc B α ω := by
+  rw [circularPath, Path.map_coe, range_comp, Path.range_segment, segment_eq_uIcc]
+  rfl
+
+lemma circularPath_injective {B α ω : ℝ} (hB : 0 < B)
+    (hα : α ∈ Ioo 0 Real.pi) (hω : ω ∈ Ioo 0 Real.pi) (hne : α ≠ ω) :
+    Function.Injective (circularPath B α ω) := by
+  intro s t he
+  have hs : (Path.segment α ω) s ∈ Ioo 0 Real.pi :=
+    ordConnected_Ioo.uIcc_subset hα hω (by
+      rw [← segment_eq_uIcc, ← Path.range_segment]; exact mem_range_self s)
+  have ht : (Path.segment α ω) t ∈ Ioo 0 Real.pi :=
+    ordConnected_Ioo.uIcc_subset hα hω (by
+      rw [← segment_eq_uIcc, ← Path.range_segment]; exact mem_range_self t)
+  change circlePoint B ((Path.segment α ω) s) = circlePoint B ((Path.segment α ω) t) at he
+  have heexp := mul_left_cancel₀ (show (B : ℂ) ≠ 0 by exact_mod_cast hB.ne') he
+  have hearg := exp_injective_strip
+    (SmallImageSemicircle.stripPoint_mem (v := 0) hs)
+    (SmallImageSemicircle.stripPoint_mem (v := 0) ht)
+    (by simpa only [SmallImageSemicircle.stripPoint, Complex.ofReal_zero, zero_add] using heexp)
+  have hangle := congrArg Complex.im hearg
+  simp only [SmallImageSemicircle.stripPoint, Complex.add_im, Complex.ofReal_im,
+    Complex.mul_im, Complex.ofReal_re, Complex.I_im, Complex.I_re,
+    mul_one, mul_zero, add_zero, zero_add] at hangle
+  exact Path.segment_injective_of_ne hne hangle
+
+lemma path_trans_injective_of_inter {x y z : ℂ} {p : Path x y} {q : Path y z}
+    (hp : Function.Injective p) (hq : Function.Injective q)
+    (hmeet : range p ∩ range q ⊆ {y}) : Function.Injective (p.trans q) := by
+  apply path_trans_injective hp hq
+  intro s t he
+  have hy : p s = y := hmeet ⟨mem_range_self s, ⟨t, he.symm⟩⟩
+  exact ⟨hp (hy.trans p.target.symm), hq ((he.symm.trans hy).trans q.source.symm)⟩
+
+lemma circle_height_gt_quarter {B x : ℝ} (hB : 0 < B) (hx : |x| < B / 16) :
+    B / 4 < Real.sqrt (B ^ 2 - x ^ 2) := by
+  have hs := Real.sq_sqrt (circle_height_pos hB hx).le
+  have hsx : x ^ 2 < (B / 16) ^ 2 := by
+    simpa only [sq_abs] using (sq_lt_sq₀ (abs_nonneg x) (by positivity)).mpr hx
+  nlinarith [Real.sqrt_nonneg (B ^ 2 - x ^ 2)]
+
+def verticalPath (B x : ℝ) :
+    Path ((x : ℂ) + ((B / 4 : ℝ) : ℂ) * Complex.I) (connectorTop B x) :=
+  (Path.segment (B / 4) (Real.sqrt (B ^ 2 - x ^ 2))).map
+    (f := fun y : ℝ => (x : ℂ) + (y : ℂ) * Complex.I)
+    (continuous_const.add (Complex.continuous_ofReal.mul continuous_const))
+
+lemma verticalPath_range {B x : ℝ} (hB : 0 < B) (hx : |x| < B / 16) :
+    range (verticalPath B x) = verticalConnector B x := by
+  change range ((fun y : ℝ => (x : ℂ) + (y : ℂ) * Complex.I) ∘
+    (Path.segment (B / 4) (Real.sqrt (B ^ 2 - x ^ 2)))) = _
+  rw [range_comp, Path.range_segment,
+    segment_eq_Icc (circle_height_gt_quarter hB hx).le, verticalConnector_eq_image]
+
+lemma verticalPath_injective {B x : ℝ} (hB : 0 < B) (hx : |x| < B / 16) :
+    Function.Injective (verticalPath B x) := by
+  intro s t he
+  have hh := congrArg Complex.im he
+  change ((x : ℂ) + ((Path.segment (B / 4) (Real.sqrt (B ^ 2 - x ^ 2))) s : ℂ) * Complex.I).im =
+    ((x : ℂ) + ((Path.segment (B / 4) (Real.sqrt (B ^ 2 - x ^ 2))) t : ℂ) * Complex.I).im at hh
+  simp only [Complex.add_im, Complex.ofReal_im, Complex.mul_im, Complex.ofReal_re,
+    Complex.I_im, Complex.I_re, mul_one, mul_zero, add_zero, zero_add] at hh
+  exact Path.segment_injective_of_ne (ne_of_lt (circle_height_gt_quarter hB hx)) hh
+
+def tailPath {β : ℝ → ℂ} {tB T : ℝ} (ht : tB ≤ T)
+    (hβ : ContinuousOn β (Icc tB T)) : Path (β tB) (β T) :=
+  (Path.segment tB T).map' (f := β) (by
+    rw [Path.range_segment, segment_eq_Icc ht]
+    exact hβ)
+
+lemma tailPath_range {β : ℝ → ℂ} {tB T : ℝ} (ht : tB ≤ T)
+    (hβ : ContinuousOn β (Icc tB T)) : range (tailPath ht hβ) = β '' Icc tB T := by
+  change range (β ∘ Path.segment tB T) = _
+  rw [range_comp, Path.range_segment, segment_eq_Icc ht]
+
+lemma tailPath_injective {β : ℝ → ℂ} {tB T : ℝ} (ht : tB < T)
+    (hβ : ContinuousOn β (Icc tB T)) (hi : InjOn β (Icc tB T)) :
+    Function.Injective (tailPath ht.le hβ) := by
+  intro s t he
+  change β ((Path.segment tB T) s) = β ((Path.segment tB T) t) at he
+  have hs : (Path.segment tB T) s ∈ Icc tB T := by
+    rw [← segment_eq_Icc ht.le, ← Path.range_segment]; exact mem_range_self s
+  have ht' : (Path.segment tB T) t ∈ Icc tB T := by
+    rw [← segment_eq_Icc ht.le, ← Path.range_segment]; exact mem_range_self t
+  exact Path.segment_injective_of_ne ht.ne (hi hs ht' he)
+
+/-- The three source pieces form an actual simple continuation path. When
+the circular arc degenerates, it is omitted from the parametrization. -/
+theorem exists_simple_continuation_path
+    {B x α ω tB T : ℝ} {β : ℝ → ℂ}
+    (hB : 0 < B) (hx : |x| < B / 16)
+    (hα : α ∈ Ioo 0 Real.pi) (hω : ω ∈ Ioo 0 Real.pi)
+    (htB : tB < T) (hβ : ContinuousOn β (Icc tB T)) (hi : InjOn β (Icc tB T))
+    (hstart : connectorTop B x = circlePoint B α) (hend : β tB = circlePoint B ω)
+    (hcross : ‖β tB‖ = B) (hafter : ∀ t ∈ Ioc tB T, B < ‖β t‖) :
+    ∃ p : Path ((x : ℂ) + ((B / 4 : ℝ) : ℂ) * Complex.I) (β T),
+      Function.Injective p ∧ range p = continuationRoute B x α ω β tB T := by
+  let v := verticalPath B x
+  let q := tailPath htB.le hβ
+  have hv : Function.Injective v := verticalPath_injective hB hx
+  have hq : Function.Injective q := tailPath_injective htB hβ hi
+  have hvr : range v = verticalConnector B x := verticalPath_range hB hx
+  have hqr : range q = β '' Icc tB T := tailPath_range htB.le hβ
+  by_cases heq : α = ω
+  · have htop : connectorTop B x = β tB :=
+      hstart.trans ((congrArg (circlePoint B) heq).trans hend.symm)
+    let v' := v.cast rfl htop.symm
+    have hv' : Function.Injective v' := hv
+    have hvr' : range v' = verticalConnector B x := hvr
+    have hmeet : range v' ∩ range q ⊆ {β tB} := by
+      rw [hvr', hqr]
+      exact (verticalConnector_inter_tail hB hx hcross hafter).trans inter_subset_right
+    refine ⟨v'.trans q, path_trans_injective_of_inter hv' hq hmeet, ?_⟩
+    have hArc : semicircleArc B α ω ⊆ verticalConnector B x := by
+      intro z hz
+      obtain ⟨θ, hθ, rfl⟩ := hz
+      have hθα : θ = α := by simpa only [← heq, uIcc_self, mem_singleton_iff] using hθ
+      rw [hθα]
+      change circlePoint B α ∈ verticalConnector B x
+      rw [← hstart, ← hvr]
+      exact ⟨1, v.target⟩
+    rw [Path.trans_range, hvr', hqr]
+    unfold continuationRoute
+    rw [union_eq_left.mpr hArc]
+  · let c := (circularPath B α ω).cast hstart hend
+    have hc : Function.Injective c := circularPath_injective hB hα hω heq
+    have hcr : range c = semicircleArc B α ω := circularPath_range B α ω
+    have hmeet : range v ∩ range c ⊆ {connectorTop B x} := by
+      rw [hvr, hcr]
+      exact verticalConnector_inter_semicircleArc hB hx
+    have hvc : Function.Injective (v.trans c) := path_trans_injective_of_inter hv hc hmeet
+    have hmeetq : range (v.trans c) ∩ range q ⊆ {β tB} := by
+      rw [Path.trans_range, hvr, hcr, hqr]
+      rintro z ⟨hz | hz, hzt⟩
+      · exact (verticalConnector_inter_tail hB hx hcross hafter ⟨hz, hzt⟩).2
+      · exact semicircleArc_inter_tail hB hafter ⟨hz, hzt⟩
+    refine ⟨(v.trans c).trans q, path_trans_injective_of_inter hvc hq hmeetq, ?_⟩
+    rw [Path.trans_range, Path.trans_range, hvr, hcr, hqr]
+    rfl
+
+lemma arg_mem_upper_interval {z : ℂ} (hz : 0 < z.im) : z.arg ∈ Ioo 0 Real.pi := by
+  refine ⟨lt_of_le_of_ne (Complex.arg_nonneg_iff.mpr hz.le) ?_,
+    Complex.arg_lt_pi_iff.mpr (Or.inr hz.ne')⟩
+  intro heq
+  exact hz.ne' (Complex.arg_eq_zero_iff.mp heq.symm).2
+
+/-- The source splice as an injective path in a compact subset of the upper
+half-plane. It meets any initial hull in the prescribed rectangle only at
+the starting tip. -/
+theorem exists_simple_splice_path
+    {B x tB T : ℝ} {β : ℝ → ℂ} (hB : 0 < B) (hx : |x| < B / 16)
+    (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‖) :
+    ∃ p : Path ((x : ℂ) + ((B / 4 : ℝ) : ℂ) * Complex.I) (β T),
+      Function.Injective p ∧ IsCompact (range p) ∧
+      range p ⊆ {z : ℂ | 0 < z.im} ∧
+      (∀ z ∈ range p, z ∈ initialRectangle B →
+        z = (x : ℂ) + ((B / 4 : ℝ) : ℂ) * Complex.I) ∧
+      range p = continuationRoute B x (connectorTop B x).arg (β tB).arg β tB T := by
+  have htopH : 0 < (connectorTop B x).im := by
+    simpa [connectorTop] using Real.sqrt_pos.mpr (circle_height_pos hB hx)
+  have htH := hβH tB ⟨htB₀, htBT.le⟩
+  have hα := arg_mem_upper_interval htopH
+  have hω := arg_mem_upper_interval htH
+  have hstart : connectorTop B x = circlePoint B (connectorTop B x).arg := by
+    calc
+      _ = (‖connectorTop B x‖ : ℂ) * Complex.exp (((connectorTop B x).arg : ℂ) * Complex.I) :=
+        (Complex.norm_mul_exp_arg_mul_I _).symm
+      _ = _ := by rw [connectorTop_norm hB hx]; rfl
+  have hend : β tB = circlePoint B (β tB).arg := by
+    calc
+      _ = (‖β tB‖ : ℂ) * Complex.exp (((β tB).arg : ℂ) * Complex.I) :=
+        (Complex.norm_mul_exp_arg_mul_I _).symm
+      _ = _ := by rw [hcross]; rfl
+  obtain ⟨p, hp, hpr⟩ := exists_simple_continuation_path hB hx hα hω htBT
+    (hβ.mono (Icc_subset_Icc_left htB₀.le)) (hi.mono (Icc_subset_Icc_left htB₀.le))
+    hstart hend hcross hafter
+  have hpc : IsCompact (range p) := by
+    simpa only [image_univ] using isCompact_univ.image p.continuous
+  refine ⟨p, hp, hpc, ?_, ?_, hpr⟩
+  · rw [hpr]
+    exact continuationRoute_subset_halfPlane hB hα hω htB₀ hβH
+  · intro z hz hr
+    exact continuationRoute_meets_rectangle_only_at_start hB hcross hafter (hpr ▸ hz) hr
+
+end SLEExactGauge.GuideSplice
+
+end
+
+end OAI
diff --git a/lean/OAI/Probability/SLE/Geometry/GuideTipCollapse.lean b/lean/OAI/Probability/SLE/Geometry/GuideTipCollapse.lean
new file mode 100644
index 0000000000000000000000000000000000000000..a86540a49ebf4b6d65c916ef4b1f105af6db1430
--- /dev/null
+++ b/lean/OAI/Probability/SLE/Geometry/GuideTipCollapse.lean
@@ -0,0 +1,237 @@
+import OAI.Probability.SLE.Geometry.InteriorVisit
+import OAI.Probability.SLE.Geometry.GuideInteriorSeparation
+
+namespace OAI
+
+/-! Uniform collapse at the initial tip of access guides. The local uniform
+limit is assumed here; the boundary collapse itself is proved using the
+existing SLE localization estimate and a positive sausage seed. -/
+
+noncomputable section
+open Set Filter MeasureTheory Metric
+open scoped Topology ENNReal NNReal
+
+namespace SLEExactGauge
+
+/-- Finitely many initial continuous guides can be absorbed into a common
+modulus once the tail has one. -/
+theorem uniform_tip_modulus_of_eventually_uniform
+    (β : ℕ → ℝ → ℂ) (T : ℝ) (hT : 0 < T)
+    (hβ : ∀ n, ContinuousOn (β n) (Icc 0 T)) (hβ0 : ∀ n, β n 0 = 0)
+    (htail : ∀ ε : ℝ, 0 < ε → ∃ h : ℝ, 0 < h ∧ h ≤ T ∧
+      ∀ᶠ n in atTop, ∀ t ∈ Icc 0 h, ‖β n t‖ < ε) :
+    ∀ ε : ℝ, 0 < ε → ∃ h : ℝ, 0 < h ∧ h ≤ T ∧
+      ∀ n t, t ∈ Icc 0 h → ‖β n t‖ < ε := by
+  intro ε hε
+  obtain ⟨h, hh, hhT, htail⟩ := htail ε hε
+  obtain ⟨N, hN⟩ := eventually_atTop.mp htail
+  have hfinite : ∀ᶠ t in 𝓝[Icc 0 T] 0, ∀ n ∈ Finset.range N, ‖β n t‖ < ε := by
+    apply (Finset.eventually_all _).mpr
+    intro n _
+    have hc := ((hβ n) 0 (mem_Icc.mpr ⟨le_rfl, hT.le⟩)).norm
+    have hv : ‖β n 0‖ < ε := by simpa only [hβ0 n, norm_zero] using hε
+    exact hc.eventually (Iio_mem_nhds hv)
+  obtain ⟨δ, hδ, hδbound⟩ := Metric.mem_nhdsWithin_iff.mp hfinite
+  let h' := min h (δ / 2)
+  have hh' : 0 < h' := lt_min hh (by positivity)
+  have hh'h : h' ≤ h := min_le_left _ _
+  refine ⟨h', hh', hh'h.trans hhT, ?_⟩
+  intro n t ht
+  by_cases hn : N ≤ n
+  · exact hN n hn t ⟨ht.1, ht.2.trans hh'h⟩
+  · apply hδbound
+    · refine ⟨?_, ht.1, ht.2.trans (hh'h.trans hhT)⟩
+      rw [mem_ball, Real.dist_eq, sub_zero, abs_of_nonneg ht.1]
+      exact (ht.2.trans (min_le_right _ _)).trans_lt (by linarith)
+    · exact Finset.mem_range.mpr (lt_of_not_ge hn)
+
+lemma seed_ball_subset_halfPlane {z : ℂ} (hz : 2 < z.im) :
+    closedBall z 2 ⊆ upperHalfPlane := by
+  intro w hw
+  have hh := Complex.im_le_norm (z - w)
+  have hd := mem_closedBall.mp hw
+  rw [Complex.sub_im, ← dist_eq_norm, dist_comm] at hh
+  change 0 < w.im
+  linarith
+
+/-- Of two disjoint interior seed balls, at least one omits a given value
+under an injective map. Compactness then gives a positive separation. -/
+theorem exists_separated_seed_ball
+    (F : ℂ → ℂ) (a : ℂ) (hF : ContinuousOn F upperHalfPlane)
+    (hinj : InjOn F upperHalfPlane) :
+    ∃ z : ℂ, 2 < z.im ∧ ∃ r₀ : ℝ, 0 < r₀ ∧
+      ∀ w ∈ closedBall z 2, r₀ ≤ ‖F w - a‖ := by
+  let z₁ : ℂ := 3 * Complex.I
+  let z₂ : ℂ := 8 * Complex.I
+  have hz₁ : 2 < z₁.im := by norm_num [z₁]
+  have hz₂ : 2 < z₂.im := by norm_num [z₂]
+  have hdisjoint : Disjoint (closedBall z₁ 2) (closedBall z₂ 2) := by
+    apply Set.disjoint_left.mpr
+    intro w hw₁ hw₂
+    have hd := dist_triangle z₁ w z₂
+    have h₁ : dist z₁ w ≤ 2 := by simpa only [dist_comm] using mem_closedBall.mp hw₁
+    have h₂ := mem_closedBall.mp hw₂
+    have he : dist z₁ z₂ = 5 := by
+      rw [dist_eq_norm]
+      norm_num [z₁, z₂, ← sub_mul, Complex.norm_mul]
+    linarith
+  have hex : ∃ z : ℂ, 2 < z.im ∧ ∀ w ∈ closedBall z 2, F w ≠ a := by
+    by_cases h₁ : ∀ w ∈ closedBall z₁ 2, F w ≠ a
+    · exact ⟨z₁, hz₁, h₁⟩
+    · push Not at h₁
+      obtain ⟨w₁, hw₁, hFw₁⟩ := h₁
+      refine ⟨z₂, hz₂, ?_⟩
+      intro w₂ hw₂ hFw₂
+      have he := hinj (seed_ball_subset_halfPlane hz₁ hw₁)
+        (seed_ball_subset_halfPlane hz₂ hw₂) (hFw₁.trans hFw₂.symm)
+      exact Set.disjoint_left.mp hdisjoint hw₁ (he ▸ hw₂)
+  obtain ⟨z, hz, hne⟩ := hex
+  have hc : ContinuousOn (fun w => ‖F w - a‖) (closedBall z 2) :=
+    ((hF.mono (seed_ball_subset_halfPlane hz)).sub continuousOn_const).norm
+  obtain ⟨w, hw, hmin⟩ := (isCompact_closedBall z 2).exists_isMinOn
+    (nonempty_closedBall.mpr (by norm_num)) hc
+  exact ⟨z, hz, ‖F w - a‖, norm_pos_iff.mpr (sub_ne_zero.mpr (hne w hw)), hmin⟩
+
+theorem seed_ball_eventually_separated
+    (Fₙ : ℕ → ℂ → ℂ) (F : ℂ → ℂ) (aₙ : ℕ → ℂ) (a : ℂ)
+    (hconv : TendstoLocallyUniformlyOn Fₙ F atTop upperHalfPlane)
+    (ha : Tendsto aₙ atTop (𝓝 a)) (hF : ContinuousOn F upperHalfPlane)
+    (hinj : InjOn F upperHalfPlane) :
+    ∃ z : ℂ, 2 < z.im ∧ ∃ r₀ : ℝ, 0 < r₀ ∧
+      ∀ᶠ n in atTop, ∀ w ∈ closedBall z 2, r₀ ≤ ‖Fₙ n w - aₙ n‖ := by
+  obtain ⟨z, hz, r₀, hr₀, hsep⟩ := exists_separated_seed_ball F a hF hinj
+  have hu : TendstoUniformlyOn Fₙ F atTop (closedBall z 2) :=
+    (tendstoLocallyUniformlyOn_iff_tendstoUniformlyOn_of_compact
+      (isCompact_closedBall z 2)).mp (hconv.mono (seed_ball_subset_halfPlane hz))
+  have herror : ∀ᶠ n in atTop, ∀ w ∈ closedBall z 2,
+      dist (F w) (Fₙ n w) < r₀ / 4 :=
+    hu _ (Metric.dist_mem_uniformity (by positivity : 0 < r₀ / 4))
+  have haerror : ∀ᶠ n in atTop, dist (aₙ n) a < r₀ / 4 :=
+    Metric.tendsto_nhds.mp ha (r₀ / 4) (by positivity)
+  refine ⟨z, hz, r₀ / 2, by positivity, ?_⟩
+  filter_upwards [herror, haerror] with n hn han
+  intro w hw
+  have hh : dist (F w) a ≤ dist (F w) (Fₙ n w) +
+      dist (Fₙ n w) (aₙ n) + dist (aₙ n) a := by
+    calc
+      _ ≤ dist (F w) (Fₙ n w) + dist (Fₙ n w) a := dist_triangle _ _ _
+      _ ≤ dist (F w) (Fₙ n w) + (dist (Fₙ n w) (aₙ n) + dist (aₙ n) a) :=
+        by linarith [dist_triangle (Fₙ n w) (aₙ n) a]
+      _ = _ := by ring
+  have hs := hsep w hw
+  have he := hn w hw
+  rw [← dist_eq_norm] at hs ⊢
+  linarith
+
+/-- A locally convergent conformal family has a common tip
+modulus. The physical guides have only a Lipschitz bound at their initial
+point; no boundary modulus of continuity for the maps is assumed. -/
+theorem uniform_tip_collapse
+    {Ω : Type} [MeasurableSpace Ω] (P : Measure Ω) [IsProbabilityMeasure P]
+    (κ : ℝ) (hκ : 0 < κ) (hκ8 : κ < 8)
+    (γ : Ω → ℝ≥0 → ℂ) (hSLE : IsOrdinaryChordalSLE κ γ P)
+    (Fₙ : ℕ → ℂ → ℂ) (Fbar : ℕ → ℂ → OnePoint ℂ) (F : ℂ → ℂ)
+    (hFn : ∀ n, DifferentiableOn ℂ (Fₙ n) upperHalfPlane)
+    (hinjn : ∀ n, InjOn (Fₙ n) upperHalfPlane)
+    (hbar : ∀ n, ContinuousOn (Fbar n) {z : ℂ | 0 ≤ z.im})
+    (hext : ∀ n z, z ∈ upperHalfPlane → Fbar n z = (Fₙ n z : OnePoint ℂ))
+    (hconv : TendstoLocallyUniformlyOn Fₙ F atTop upperHalfPlane)
+    (hF : ContinuousOn F upperHalfPlane) (hinj : InjOn F upperHalfPlane)
+    (aₙ : ℕ → ℂ) (a : ℂ) (ha : Tendsto aₙ atTop (𝓝 a))
+    (β : ℕ → ℝ → ℂ) (T C : ℝ) (hT : 0 < T) (hC : 0 < C)
+    (hβ : ∀ n, ContinuousOn (β n) (Icc 0 T)) (hβ0 : ∀ n, β n 0 = 0)
+    (hβH : ∀ n t, t ∈ Icc 0 T → 0 ≤ (β n t).im)
+    (himage : ∀ n t, t ∈ Icc 0 T → ∃ w : ℂ,
+      Fbar n (β n t) = (w : OnePoint ℂ) ∧ ‖w - aₙ n‖ ≤ C * t) :
+    ∀ ε : ℝ, 0 < ε → ∃ h : ℝ, 0 < h ∧ h ≤ T ∧
+      ∀ n t, t ∈ Icc 0 h → ‖β n t‖ < ε := by
+  apply uniform_tip_modulus_of_eventually_uniform β T hT hβ hβ0
+  intro ε hε
+  let scale : ℂ → ℂ := fun z => (ε : ℂ) * z
+  have hscaleH : MapsTo scale upperHalfPlane upperHalfPlane := by
+    intro z hz
+    change 0 < ((ε : ℂ) * z).im
+    simpa only [Complex.mul_im, Complex.ofReal_re, Complex.ofReal_im,
+      zero_mul, add_zero] using mul_pos hε hz
+  have hscaleC : Continuous scale := continuous_const.mul continuous_id
+  have hscaleinj : Function.Injective scale := mul_right_injective₀ (by exact_mod_cast hε.ne')
+  have hscaledconv := hconv.comp scale hscaleH hscaleC.continuousOn
+  have hscaledF := hF.comp hscaleC.continuousOn hscaleH
+  have hscaledinj : InjOn (F ∘ scale) upperHalfPlane :=
+    fun x hx y hy hxy => hscaleinj (hinj (hscaleH hx) (hscaleH hy) hxy)
+  obtain ⟨z, hz, r₀, hr₀, hsep⟩ := seed_ball_eventually_separated
+    (fun n => Fₙ n ∘ scale) (F ∘ scale) aₙ a hscaledconv ha hscaledF hscaledinj
+  let pres := Classical.choice (exists_regular_sle_presentation hSLE)
+  let Q := P.comap (Subtype.val : pres.samples → Ω)
+  have hsampleSLE : IsOrdinaryChordalSLE κ (fun ω : pres.samples => γ ω) Q :=
+    ⟨fun t => (hSLE.1 t).comp measurable_subtype_coe, pres.B, pres.brownian,
+      ae_of_all _ (fun ω => ⟨pres.G ω, pres.F ω, pres.witness ω⟩)⟩
+  obtain ⟨Tvisit, R, _, _, hvisit⟩ := pres.positive_bounded_interior_visit hκ hκ8 z hz
+  obtain ⟨rmin, hrmin, hbound⟩ := uniform_access_radius_lower_bound_of_interior_visit
+    Q κ hκ hκ8 (fun ω : pres.samples => γ ω) hsampleSLE Tvisit R
+    (closedBall z 2) (seed_ball_subset_halfPlane hz) hvisit r₀ hr₀
+  let h : ℝ := min T (rmin / (2 * C))
+  have hh : 0 < h := lt_min hT (div_pos hrmin (by positivity))
+  have hhT : h ≤ T := min_le_left _ _
+  have hCh : C * h < rmin := by
+    have hb : h ≤ rmin / (2 * C) := min_le_right _ _
+    have hb' := (le_div_iff₀ (by positivity : 0 < 2 * C)).mp hb
+    nlinarith
+  refine ⟨h, hh, hhT, ?_⟩
+  filter_upwards [hsep] with n hn
+  intro t ht
+  by_contra! hlarge
+  have htT : Icc 0 t ⊆ Icc 0 T := Icc_subset_Icc_right (ht.2.trans hhT)
+  have hnorm : ContinuousOn (fun s => ‖β n s‖) (Icc 0 t) :=
+    (hβ n).norm.mono htT
+  have hεmem : ε ∈ Icc ‖β n 0‖ ‖β n t‖ := by
+    rw [hβ0 n, norm_zero]
+    exact ⟨hε.le, hlarge⟩
+  obtain ⟨S, hS, hnormS⟩ := intermediate_value_Icc ht.1 hnorm hεmem
+  have hSpos : 0 < S := by
+    by_contra hs
+    have he : S = 0 := le_antisymm (le_of_not_gt hs) hS.1
+    have hzero : (0 : ℝ) = ε := by simpa only [he, hβ0 n, norm_zero] using hnormS
+    exact hε.ne' hzero.symm
+  let η : ℝ → ℂ := fun s => (ε : ℂ)⁻¹ * β n s
+  have hη : ContinuousOn η (Icc 0 S) :=
+    continuousOn_const.mul ((hβ n).mono (Icc_subset_Icc_right (hS.2.trans (ht.2.trans hhT))))
+  have hη0 : η 0 = 0 := by simp [η, hβ0 n]
+  have hηS : ‖η S‖ = 1 := by
+    simp only [η, norm_mul, norm_inv, Complex.norm_real, Real.norm_eq_abs,
+      abs_of_pos hε, hnormS, inv_mul_cancel₀ hε.ne']
+  have hηH : ∀ s ∈ Icc 0 S, 0 ≤ (η s).im := by
+    intro s hs
+    have hsT : s ∈ Icc 0 T := ⟨hs.1, hs.2.trans (hS.2.trans (ht.2.trans hhT))⟩
+    simpa only [η, ← Complex.ofReal_inv, Complex.mul_im, Complex.ofReal_re,
+      Complex.ofReal_im, zero_mul, add_zero] using mul_nonneg (inv_nonneg.mpr hε.le) (hβH n s hsT)
+  have hscaledbar : ContinuousOn (Fbar n ∘ scale) {z : ℂ | 0 ≤ z.im} := by
+    apply (hbar n).comp hscaleC.continuousOn
+    intro z hz
+    change 0 ≤ ((ε : ℂ) * z).im
+    simpa only [Complex.mul_im, Complex.ofReal_re, Complex.ofReal_im,
+      zero_mul, add_zero] using mul_nonneg hε.le hz
+  have hηimage : ∀ s ∈ Icc 0 S, ∃ w : ℂ,
+      (Fbar n ∘ scale) (η s) = (w : OnePoint ℂ) ∧ ‖w - aₙ n‖ ≤ C * h := by
+    intro s hs
+    have hsT : s ∈ Icc 0 T := ⟨hs.1, hs.2.trans (hS.2.trans (ht.2.trans hhT))⟩
+    obtain ⟨w, hw, hwd⟩ := himage n s hsT
+    refine ⟨w, ?_, hwd.trans (mul_le_mul_of_nonneg_left (hs.2.trans (hS.2.trans ht.2)) hC.le)⟩
+    simpa only [Function.comp_apply, scale, η, ← mul_assoc,
+      mul_inv_cancel₀ (show (ε : ℂ) ≠ 0 by exact_mod_cast hε.ne'), one_mul] using hw
+  have hscaledFn : DifferentiableOn ℂ (Fₙ n ∘ scale) upperHalfPlane :=
+    (hFn n).comp (((differentiable_const (ε : ℂ)).mul differentiable_id).differentiableOn) hscaleH
+  have hscaledInjn : InjOn (Fₙ n ∘ scale) upperHalfPlane :=
+    fun x hx y hy hxy => hscaleinj (hinjn n (hscaleH hx) (hscaleH hy) hxy)
+  have hscaledExt : ∀ w ∈ upperHalfPlane,
+      (Fbar n ∘ scale) w = ((Fₙ n ∘ scale) w : OnePoint ℂ) :=
+    fun w hw => hext n _ (hscaleH hw)
+  exact (not_lt_of_ge (hbound (Fₙ n ∘ scale) (Fbar n ∘ scale) hscaledFn
+    hscaledInjn hscaledbar hscaledExt (aₙ n) (C * h) (mul_pos hC hh) hn
+    η S hSpos hη hη0 hηS hηH hηimage)) hCh
+
+end SLEExactGauge
+
+end
+
+end OAI
diff --git a/lean/OAI/Probability/SLE/Geometry/GuideTube.lean b/lean/OAI/Probability/SLE/Geometry/GuideTube.lean
new file mode 100644
index 0000000000000000000000000000000000000000..bcee96b3b2ce3558e4c4f3432ef06765c1a347cc
--- /dev/null
+++ b/lean/OAI/Probability/SLE/Geometry/GuideTube.lean
@@ -0,0 +1,229 @@
+import OAI.Probability.SLE.Geometry.GuideSplice
+import OAI.Probability.SLE.Gauge.ConformalCompactSausage
+
+namespace OAI
+
+/-!
+Open continuation tubes for the geometric splice. The initial tip is a
+boundary point of the tube; every positive-time route point lies in the tube.
+This is the version compatible with avoiding the initial containing rectangle.
+-/
+
+noncomputable section
+open Set Filter MeasureTheory Metric
+open scoped Topology unitInterval
+
+namespace SLEExactGauge.GuideSplice
+
+def closedInitialRectangle (B : ℝ) : Set ℂ :=
+  {z | |z.re| ≤ B / 16 ∧ 0 ≤ z.im ∧ z.im ≤ B / 4}
+
+lemma closedInitialRectangle_isClosed (B : ℝ) : IsClosed (closedInitialRectangle B) :=
+  (isClosed_le Complex.continuous_re.abs continuous_const).inter
+    ((isClosed_le continuous_const Complex.continuous_im).inter
+      (isClosed_le Complex.continuous_im continuous_const))
+
+lemma initialRectangle_subset_closed (B : ℝ) :
+    initialRectangle B ⊆ closedInitialRectangle B :=
+  fun _ hz => ⟨hz.1.le, hz.2⟩
+
+lemma closedInitialRectangle_subset_smallBall {B : ℝ} (hB : 0 < B) :
+    closedInitialRectangle B ⊆ ball (0 : ℂ) (B / 2) := by
+  intro z hz
+  obtain ⟨hxr, hy0, hyr⟩ := hz
+  have hsx : z.re ^ 2 ≤ (B / 16) ^ 2 := by
+    simpa only [sq_abs] using (sq_le_sq₀ (abs_nonneg _) (by positivity)).mpr hxr
+  have hsy : z.im ^ 2 ≤ (B / 4) ^ 2 := (sq_le_sq₀ hy0 (by positivity)).mpr hyr
+  have hn := Complex.sq_norm z
+  rw [Complex.normSq_apply] at hn
+  rw [mem_ball_zero_iff]
+  nlinarith [norm_nonneg z]
+
+lemma outer_circle_avoids_closedInitialRectangle {B : ℝ} (hB : 0 < B)
+    {z : ℂ} (hz : B ≤ ‖z‖) : z ∉ closedInitialRectangle B := by
+  intro hrect
+  have hh := mem_ball_zero_iff.mp (closedInitialRectangle_subset_smallBall hB hrect)
+  linarith
+
+lemma continuationRoute_meets_closed_rectangle_only_at_start
+    {B x α ω tB T : ℝ} {β : ℝ → ℂ} (hB : 0 < B)
+    (hcross : ‖β tB‖ = B) (hafter : ∀ t ∈ Ioc tB T, B < ‖β t‖)
+    {z : ℂ} (hz : z ∈ continuationRoute B x α ω β tB T)
+    (hrect : z ∈ closedInitialRectangle B) :
+    z = (x : ℂ) + ((B / 4 : ℝ) : ℂ) * Complex.I := by
+  rcases hz with (hz | hz) | ⟨t, ht, rfl⟩
+  · apply Complex.ext
+    · simpa using hz.1
+    · simpa using le_antisymm hrect.2.2 hz.2.1
+  · exact False.elim (outer_circle_avoids_closedInitialRectangle hB
+      (semicircleArc_norm hB hz).ge hrect)
+  · have hnorm : B ≤ ‖β t‖ := by
+      rcases eq_or_lt_of_le ht.1 with he | he
+      · simpa only [← he, hcross] using (le_rfl : B ≤ B)
+      · exact (hafter t ⟨he, ht.2⟩).le
+    exact False.elim (outer_circle_avoids_closedInitialRectangle hB hnorm hrect)
+
+/-- The image bound for the actual initial vertical and circular pieces. -/
+theorem initial_splice_image_subset_quarter_ball
+    {F : ℂ → ℂ} {a : ℂ} {B x α ω r : ℝ}
+    (hB : 0 < B) (hx : |x| < B / 16)
+    (hα : α ∈ Ioo 0 Real.pi) (hω : ω ∈ Ioo 0 Real.pi)
+    (hcircle : ∀ θ ∈ Ioo 0 Real.pi, ‖F (circlePoint B θ) - a‖ < r / 4)
+    (hsector : ∀ z : ℂ, B / 8 ≤ ‖z‖ → ‖z‖ ≤ B → ‖z‖ / 2 ≤ z.im →
+      ‖F z - a‖ < r / 4) :
+    F '' (verticalConnector B x ∪ semicircleArc B α ω) ⊆ ball a (r / 4) := by
+  rintro _ ⟨z, hz, rfl⟩
+  rw [mem_ball, dist_eq_norm]
+  rcases hz with hz | ⟨θ, hθ, rfl⟩
+  · obtain ⟨hlo, hup, him⟩ := verticalConnector_subset_sector hB hx hz
+    exact hsector z hlo hup him
+  · exact hcircle θ (ordConnected_Ioo.uIcc_subset hα hω hθ)
+
+def continuationTube (F : ℂ → ℂ) (a : ℂ) (r B : ℝ) (O : Set ℂ) : Set ℂ :=
+  (upperHalfPlane ∩ F ⁻¹' (ball a (r / 2) ∪ O)) \ closedInitialRectangle B
+
+lemma continuationTube_isOpen {F : ℂ → ℂ} (hF : ContinuousOn F upperHalfPlane)
+    (a : ℂ) (r B : ℝ) {O : Set ℂ} (hO : IsOpen O) :
+    IsOpen (continuationTube F a r B O) :=
+  (hF.isOpen_inter_preimage isOpen_upperHalfPlane (isOpen_ball.union hO)).sdiff
+    (closedInitialRectangle_isClosed B)
+
+lemma continuationTube_subset_halfPlane (F : ℂ → ℂ) (a : ℂ) (r B : ℝ) (O : Set ℂ) :
+    continuationTube F a r B O ⊆ upperHalfPlane := fun _ hz => hz.1.1
+
+lemma continuationTube_disjoint_rectangle (F : ℂ → ℂ) (a : ℂ) (r B : ℝ) (O : Set ℂ) :
+    Disjoint (continuationTube F a r B O) (closedInitialRectangle B) :=
+  disjoint_sdiff_left
+
+lemma continuationTube_image_subset (F : ℂ → ℂ) (a : ℂ) (r B : ℝ) (O : Set ℂ) :
+    F '' continuationTube F a r B O ⊆ ball a (r / 2) ∪ O := by
+  rintro _ ⟨z, hz, rfl⟩
+  exact hz.1.2
+
+/-- An open tube avoids the entire initial rectangle while retaining every
+continuation point other than the initial tip. Its physical image lies in the
+half-radius ball or in the prescribed open region for the compact tail. -/
+theorem continuationRoute_rest_subset_tube
+    {F : ℂ → ℂ} {a : ℂ} {B x α ω r tB T : ℝ} {β : ℝ → ℂ} {O : Set ℂ}
+    (hr : 0 < r) (hB : 0 < B) (hx : |x| < B / 16)
+    (hα : α ∈ Ioo 0 Real.pi) (hω : ω ∈ Ioo 0 Real.pi) (htB : 0 < tB)
+    (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 (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) :
+    continuationRoute B x α ω β tB T \
+        {(x : ℂ) + ((B / 4 : ℝ) : ℂ) * Complex.I} ⊆ continuationTube F a r B O := by
+  intro z hz
+  refine ⟨⟨continuationRoute_subset_halfPlane hB hα hω htB hβH hz.1, ?_⟩, ?_⟩
+  · rcases hz.1 with (hz | hz) | hz
+    · left
+      have hh := initial_splice_image_subset_quarter_ball hB hx hα hω hcircle hsector
+        (mem_image_of_mem F (Or.inl hz))
+      exact ball_subset_ball (by linarith) hh
+    · left
+      have hh := initial_splice_image_subset_quarter_ball hB hx hα hω hcircle hsector
+        (mem_image_of_mem F (Or.inr hz))
+      exact ball_subset_ball (by linarith) hh
+    · exact Or.inr (htail (mem_image_of_mem F hz))
+  · intro hrect
+    exact hz.2 (continuationRoute_meets_closed_rectangle_only_at_start hB hcross hafter hz.1 hrect)
+
+lemma initial_tip_mem_closure_of_connector_rest
+    {B x : ℝ} (hB : 0 < B) (hx : |x| < B / 16) {N : Set ℂ}
+    (hsub : verticalConnector B x \
+      {(x : ℂ) + ((B / 4 : ℝ) : ℂ) * Complex.I} ⊆ N) :
+    (x : ℂ) + ((B / 4 : ℝ) : ℂ) * Complex.I ∈ closure N := by
+  rw [Metric.mem_closure_iff]
+  intro ε hε
+  let d := min (ε / 2) ((Real.sqrt (B ^ 2 - x ^ 2) - B / 4) / 2)
+  have hd : 0 < d := lt_min (by positivity) (by
+    have hh := circle_height_gt_quarter hB hx
+    positivity)
+  let z : ℂ := (x : ℂ) + (((B / 4 + d : ℝ)) : ℂ) * Complex.I
+  have hzV : z ∈ verticalConnector B x := by
+    have hu := min_le_right (ε / 2) ((Real.sqrt (B ^ 2 - x ^ 2) - B / 4) / 2)
+    simp only [z, verticalConnector, mem_ofPred_eq, Complex.add_re, Complex.ofReal_re,
+      Complex.mul_re, Complex.I_re, Complex.ofReal_im, Complex.I_im,
+      mul_zero, sub_self, add_zero, Complex.add_im, Complex.mul_im,
+      mul_one, zero_add]
+    dsimp only [d] at hd
+    exact ⟨trivial, by dsimp only [d]; linarith, by dsimp only [d]; linarith⟩
+  have hzne : z ≠ (x : ℂ) + ((B / 4 : ℝ) : ℂ) * Complex.I := by
+    intro he
+    have hh := congrArg Complex.im he
+    simp [z] at hh
+    exact hd.ne' hh
+  refine ⟨z, hsub ⟨hzV, hzne⟩, ?_⟩
+  have hdε : d < ε := (min_le_left _ _).trans_lt (by linarith)
+  have he : z - ((x : ℂ) + ((B / 4 : ℝ) : ℂ) * Complex.I) = (d : ℂ) * Complex.I := by
+    dsimp only [z]
+    push_cast
+    ring
+  rw [dist_comm, dist_eq_norm, he, norm_mul, Complex.norm_real, Real.norm_eq_abs,
+    abs_of_pos hd, Complex.norm_I, mul_one]
+  exact hdε
+
+lemma initial_tip_mem_closure_of_route_rest
+    {B x α ω tB T : ℝ} {β : ℝ → ℂ} (hB : 0 < B) (hx : |x| < B / 16)
+    {N : Set ℂ} (hsub : continuationRoute B x α ω β tB T \
+      {(x : ℂ) + ((B / 4 : ℝ) : ℂ) * Complex.I} ⊆ N) :
+    (x : ℂ) + ((B / 4 : ℝ) : ℂ) * Complex.I ∈ closure N :=
+  initial_tip_mem_closure_of_connector_rest hB hx
+    (fun _ hz => hsub ⟨Or.inl (Or.inl hz.1), hz.2⟩)
+
+/-- Compact parts of the initial splice have a tube lying entirely in the
+physical half-radius ball, as well as outside the old containing rectangle. -/
+theorem compact_initial_splice_has_small_image_tube
+    {F : ℂ → ℂ} (hF : ContinuousOn F upperHalfPlane) {a : ℂ}
+    {B x α ω r : ℝ} (hr : 0 < r) (hB : 0 < B) (hx : |x| < B / 16)
+    (hα : α ∈ Ioo 0 Real.pi) (hω : ω ∈ Ioo 0 Real.pi)
+    (hcircle : ∀ θ ∈ Ioo 0 Real.pi, ‖F (circlePoint B θ) - a‖ < r / 4)
+    (hsector : ∀ z : ℂ, B / 8 ≤ ‖z‖ → ‖z‖ ≤ B → ‖z‖ / 2 ≤ z.im →
+      ‖F z - a‖ < r / 4)
+    (K : Set ℂ) (hK : IsCompact K)
+    (hsub : K ⊆ (verticalConnector B x ∪ semicircleArc B α ω) \
+      {(x : ℂ) + ((B / 4 : ℝ) : ℂ) * Complex.I}) :
+    ∃ ε : ℝ, 0 < ε ∧ thickening ε K ⊆ continuationTube F a r B ∅ := by
+  apply hK.exists_thickening_subset_open
+    (continuationTube_isOpen hF a r B isOpen_empty)
+  intro z hz
+  have hz' := hsub hz
+  refine ⟨⟨?_, Or.inl ?_⟩, ?_⟩
+  · rcases hz'.1 with hv | hc
+    · exact verticalConnector_subset_halfPlane hB hv
+    · exact semicircleArc_subset_halfPlane hB hα hω hc
+  · exact ball_subset_ball (by linarith)
+      (initial_splice_image_subset_quarter_ball hB hx hα hω hcircle hsector
+        (mem_image_of_mem F hz'.1))
+  · intro hrect
+    rcases hz'.1 with hv | hc
+    · apply hz'.2
+      apply Complex.ext
+      · simpa using hv.1
+      · simpa using le_antisymm hrect.2.2 hv.2.1
+    · exact outer_circle_avoids_closedInitialRectangle hB (semicircleArc_norm hB hc).ge hrect
+
+/-- Every compact positive-time piece of a simple route has a uniform tube
+radius; the radius is allowed to shrink towards the initial tip. -/
+theorem positive_subpath_has_uniform_tube
+    {z₀ z₁ : ℂ} (p : Path z₀ z₁) (hp : Function.Injective p)
+    {N : Set ℂ} (hN : IsOpen N) (hsub : range p \ {z₀} ⊆ N)
+    (δ : unitInterval) (hδ : 0 < (δ : ℝ)) :
+    ∃ ε : ℝ, 0 < ε ∧ thickening ε (p '' Icc δ 1) ⊆ N := by
+  apply (isCompact_Icc.image p.continuous).exists_thickening_subset_open hN
+  rintro _ ⟨t, ht, rfl⟩
+  apply hsub
+  refine ⟨mem_range_self t, ?_⟩
+  intro he
+  have ht0 := hp (he.trans p.source.symm)
+  have hh : (δ : ℝ) ≤ (t : ℝ) := ht.1
+  have htzero : (t : ℝ) = 0 := congrArg (fun u : unitInterval => (u : ℝ)) ht0
+  linarith
+
+end SLEExactGauge.GuideSplice
+
+end
+
+end OAI
diff --git a/lean/OAI/Probability/SLE/Geometry/HalfDiskGeometry.lean b/lean/OAI/Probability/SLE/Geometry/HalfDiskGeometry.lean
new file mode 100644
index 0000000000000000000000000000000000000000..e974f916c38cb27834b188ed51e6dee27636012a
--- /dev/null
+++ b/lean/OAI/Probability/SLE/Geometry/HalfDiskGeometry.lean
@@ -0,0 +1,85 @@
+import OAI.Probability.SLE.Geometry.DiskSemicircleGeometry
+import OAI.Probability.SLE.Geometry.ComplexJordanRegions
+import Mathlib.Analysis.Normed.Operator.Banach
+
+namespace OAI
+
+/-! The two standard closed half disks and their bounded Jordan interiors. -/
+noncomputable section
+open Set Complex Metric
+
+namespace SLEExactGauge
+
+def closedUpperDisk : Set ℂ := {z | ‖z‖ ≤ 1 ∧ 0 ≤ z.im}
+def openUpperDisk : Set ℂ := {z | ‖z‖ < 1 ∧ 0 < z.im}
+
+lemma closedUpperDisk_eq :
+    closedUpperDisk=closedBall (0:ℂ) 1 ∩ Complex.imCLM ⁻¹' Ici 0 := by
+  ext z
+  simp [closedUpperDisk,mem_closedBall,dist_zero_right]
+
+lemma closedUpperDisk_isClosed : IsClosed closedUpperDisk :=
+  (isClosed_le continuous_norm continuous_const).inter
+    (isClosed_le continuous_const Complex.continuous_im)
+
+lemma closedUpperDisk_convex : Convex ℝ closedUpperDisk := by
+  rw [closedUpperDisk_eq]
+  exact (convex_closedBall _ _).inter ((convex_Ici (0:ℝ)).linear_preimage _)
+
+lemma closedUpperDisk_interior : interior closedUpperDisk=openUpperDisk := by
+  rw [closedUpperDisk_eq,interior_inter,interior_closedBall _ (by norm_num : (1:ℝ)≠0)]
+  rw [Complex.imCLM.interior_preimage (fun x => ⟨x*I,by simp⟩),interior_Ici]
+  ext z
+  simp [openUpperDisk,mem_ball,dist_zero_right]
+
+lemma openUpperDisk_nonempty : openUpperDisk.Nonempty := by
+  refine ⟨I/2,?_,?_⟩
+  · norm_num
+  · norm_num
+
+lemma openUpperDisk_isOpen : IsOpen openUpperDisk :=
+  (isOpen_lt continuous_norm continuous_const).inter
+    (isOpen_lt continuous_const Complex.continuous_im)
+
+lemma openUpperDisk_convex : Convex ℝ openUpperDisk := by
+  rw [← closedUpperDisk_interior]
+  exact closedUpperDisk_convex.interior
+
+lemma openUpperDisk_closure : closure openUpperDisk=closedUpperDisk := by
+  rw [← closedUpperDisk_interior,
+    closedUpperDisk_convex.closure_interior_eq_closure_of_nonempty_interior
+      (by rw [closedUpperDisk_interior]; exact openUpperDisk_nonempty),
+    closedUpperDisk_isClosed.closure_eq]
+
+lemma openUpperDisk_frontier :
+    frontier openUpperDisk=diskDiameter '' Icc 0 1 ∪ diskUpperArc '' Icc 0 1 := by
+  rw [openUpperDisk_isOpen.frontier_eq,openUpperDisk_closure,
+    diskDiameter_image,diskUpperArc_image]
+  ext z
+  simp only [mem_sdiff,closedUpperDisk,openUpperDisk,mem_ofPred,mem_union]
+  constructor
+  · rintro ⟨⟨hn,hi⟩,he⟩
+    by_cases hz : z.im=0
+    · exact Or.inl ⟨hn,hz⟩
+    · exact Or.inr ⟨le_antisymm hn (le_of_not_gt (fun h => he ⟨h,lt_of_le_of_ne hi
+        (Ne.symm hz)⟩)),hi⟩
+  · rintro (⟨hn,hi⟩|⟨hn,hi⟩)
+    · exact ⟨⟨hn,hi.ge⟩,fun h => by simpa only [hi,lt_self_iff_false] using h.2⟩
+    · exact ⟨⟨hn.le,hi⟩,fun h => (not_lt_of_ge hn.ge) h.1⟩
+
+theorem complexInside_upperDisk :
+    complexInside (diskDiameter '' Icc 0 1 ∪ diskUpperArc '' Icc 0 1)=openUpperDisk := by
+  apply complexInside_eq_open
+    (disk_crosscut_upper_jordan diskDiameter diskDiameter_continuous.continuousOn
+      diskDiameter_injOn (by norm_num [diskDiameter]) (by norm_num [diskDiameter])
+      diskDiameter_interior)
+    openUpperDisk_isOpen openUpperDisk_convex.isPreconnected openUpperDisk_nonempty
+    ?_ openUpperDisk_frontier
+  exact (isBounded_ball (x := (0:ℂ)) (r := 1)).subset (fun z hz => by
+    simpa only [mem_ball,dist_zero_right] using hz.1)
+
+end SLEExactGauge
+
+end
+
+end OAI
diff --git a/lean/OAI/Probability/SLE/Geometry/HalfPlaneBoundaryDerivative.lean b/lean/OAI/Probability/SLE/Geometry/HalfPlaneBoundaryDerivative.lean
new file mode 100644
index 0000000000000000000000000000000000000000..50236c55becb35ed788dd88ea9530cf8df4632b4
--- /dev/null
+++ b/lean/OAI/Probability/SLE/Geometry/HalfPlaneBoundaryDerivative.lean
@@ -0,0 +1,89 @@
+import OAI.Probability.SLE.Geometry.ActualFiniteBoundaryExtension
+import Mathlib.Analysis.Complex.Schwarz
+
+namespace OAI
+
+/-! A finite continuous boundary value makes the inverse derivative small
+after multiplication by the height. -/
+noncomputable section
+open Set Filter Metric
+open scoped Topology NNReal
+
+namespace SLEExactGauge
+
+lemma vertical_approach_halfPlane (x : ℝ) :
+    Tendsto (fun y : ℝ => (x : ℂ)+(y : ℂ)*Complex.I)
+      (𝓝[>] 0) (𝓝[upperHalfPlane] (x : ℂ)) := by
+  apply tendsto_nhdsWithin_iff.mpr
+  refine ⟨?_,?_⟩
+  · have hc : Continuous (fun y : ℝ => (x : ℂ)+(y : ℂ)*Complex.I) := by fun_prop
+    simpa using (hc.tendsto 0).mono_left nhdsWithin_le_nhds
+  · filter_upwards [self_mem_nhdsWithin] with y hy
+    simpa [upperHalfPlane] using hy
+
+lemma IsCapacityTwoWitness.inverse_tip_limit
+    {U : ℝ≥0 → ℝ} {γ : ℝ≥0 → ℂ} {G F : ℝ≥0 → ℂ → ℂ}
+    (h : IsCapacityTwoWitness U γ G F) (T : ℝ≥0) :
+    Tendsto (F T) (𝓝[upperHalfPlane] (U T : ℂ)) (𝓝 (γ T)) := by
+  obtain ⟨q,hq⟩ := h.finite_real_boundary_limit T (U T)
+  have he : q=γ T := tendsto_nhds_unique
+    (hq.comp (vertical_approach_halfPlane (U T))) (h.2.2.2.2.2.2.2.2.2.2.2.2 T)
+  simpa only [he] using hq
+
+theorem halfPlane_boundary_derivative_vanishes
+    {f : ℂ → ℂ} (hf : DifferentiableOn ℂ f upperHalfPlane)
+    {x : ℝ} {q : ℂ} (hl : Tendsto f (𝓝[upperHalfPlane] (x : ℂ)) (𝓝 q)) :
+    Tendsto (fun y : ℝ => y*‖deriv f ((x : ℂ)+(y : ℂ)*Complex.I)‖)
+      (𝓝[>] 0) (𝓝 0) := by
+  apply Metric.tendsto_nhdsWithin_nhds.mpr
+  intro ε hε
+  obtain ⟨δ,hδ,hclose⟩ := Metric.tendsto_nhdsWithin_nhds.mp hl (ε/8) (by positivity)
+  refine ⟨δ/2,by positivity,?_⟩
+  intro y hy hyd
+  have hy0 : 0 < y := hy
+  have hyδ : y < δ/2 := by simpa only [Real.dist_eq,sub_zero,abs_of_pos hy0] using hyd
+  let w : ℂ := (x : ℂ)+(y : ℂ)*Complex.I
+  have hw : w ∈ upperHalfPlane := by simpa [w,upperHalfPlane] using hy0
+  have hdw : dist w (x : ℂ)=y := by
+    simp [w,dist_eq_norm,Complex.norm_real,abs_of_pos hy0]
+  have hball : ball w (y/2) ⊆ upperHalfPlane := by
+    intro z hz
+    have hd : ‖z-w‖ < y/2 := by simpa only [mem_ball,dist_eq_norm] using hz
+    have hi := (abs_lt.mp ((Complex.abs_im_le_norm (z-w)).trans_lt hd)).1
+    simp only [Complex.sub_im] at hi
+    change 0 < z.im
+    have hwi : w.im=y := by simp [w]
+    linarith
+  have hc (z : ℂ) (hz : z ∈ ball w (y/2)) : dist (f z) q < ε/8 := by
+    apply hclose (hball hz)
+    have ht := dist_triangle z w (x : ℂ)
+    rw [hdw] at ht
+    have hzdist := mem_ball.mp hz
+    linarith
+  have hcw : dist (f w) q < ε/8 := hc w (mem_ball_self (by positivity))
+  have hm : MapsTo f (ball w (y/2)) (closedBall (f w) (ε/4)) := by
+    intro z hz
+    rw [mem_closedBall]
+    have ht := dist_triangle (f z) q (f w)
+    rw [dist_comm q (f w)] at ht
+    linarith [hc z hz]
+  have hd := Complex.norm_deriv_le_div_of_mapsTo_ball (hf.mono hball) hm (by positivity)
+  have hb : y*‖deriv f w‖ ≤ ε/2 := by
+    have hh := (le_div_iff₀ (by positivity : 0 < y/2)).mp hd
+    nlinarith
+  change dist (y*‖deriv f w‖) 0 < ε
+  rw [Real.dist_eq,sub_zero,abs_of_nonneg (mul_nonneg hy0.le (norm_nonneg _))]
+  linarith
+
+lemma IsCapacityTwoWitness.inverse_tip_derivative_vanishes
+    {U : ℝ≥0 → ℝ} {γ : ℝ≥0 → ℂ} {G F : ℝ≥0 → ℂ → ℂ}
+    (h : IsCapacityTwoWitness U γ G F) (T : ℝ≥0) :
+    Tendsto (fun y : ℝ => y*‖deriv (F T) ((U T : ℂ)+(y : ℂ)*Complex.I)‖)
+      (𝓝[>] 0) (𝓝 0) :=
+  halfPlane_boundary_derivative_vanishes (h.2.2.2.2.1 T) (h.inverse_tip_limit T)
+
+end SLEExactGauge
+
+end
+
+end OAI
diff --git a/lean/OAI/Probability/SLE/Geometry/HalfPlaneBoundaryExtension.lean b/lean/OAI/Probability/SLE/Geometry/HalfPlaneBoundaryExtension.lean
new file mode 100644
index 0000000000000000000000000000000000000000..56e838fa4d6eb19b8c0de62b15ef54139a0b8cc0
--- /dev/null
+++ b/lean/OAI/Probability/SLE/Geometry/HalfPlaneBoundaryExtension.lean
@@ -0,0 +1,82 @@
+import OAI.Probability.SLE.LoewnerCharts
+import Mathlib.Topology.ExtendFrom
+
+namespace OAI
+
+/-! Once finite limits at the real boundary are proved, the continuous
+closed-half-plane extension and the prescribed Loewner tip follow. -/
+noncomputable section
+open Set Filter Metric Function
+open scoped Topology NNReal
+
+namespace SLEExactGauge
+
+lemma closedHalfPlane_subset_closure_upperHalfPlane :
+    {z : ℂ | 0≤z.im} ⊆ closure upperHalfPlane := by
+  intro z hz
+  change 0≤z.im at hz
+  apply Metric.mem_closure_iff.mpr
+  intro ε hε
+  refine ⟨z+((ε/2:ℝ):ℂ)*Complex.I,?_,?_⟩
+  · change 0<(z+((ε/2:ℝ):ℂ)*Complex.I).im
+    simp only [Complex.add_im,Complex.mul_im,Complex.ofReal_re,Complex.ofReal_im,
+      Complex.I_im,Complex.I_re,mul_one,mul_zero,add_zero]
+    linarith
+  · rw [dist_eq_norm,norm_sub_rev]
+    simp only [add_sub_cancel_left,norm_mul,Complex.norm_real,Real.norm_eq_abs,Complex.norm_I,
+      mul_one,abs_of_pos (half_pos hε)]
+    linarith
+
+lemma exists_halfPlane_boundary_extension {f : ℂ → ℂ}
+    (hf : ContinuousOn f upperHalfPlane)
+    (hreal : ∀ x : ℝ, ∃ z : ℂ, Tendsto f (𝓝[upperHalfPlane] (x:ℂ)) (𝓝 z)) :
+    ∃ F : ℂ → ℂ, ContinuousOn F {z : ℂ | 0≤z.im} ∧
+      ∀ z∈upperHalfPlane, F z=f z := by
+  refine ⟨extendFrom upperHalfPlane f,?_,extendFrom_extends hf⟩
+  apply continuousOn_extendFrom closedHalfPlane_subset_closure_upperHalfPlane
+  intro z hz
+  by_cases hp : 0<z.im
+  · exact ⟨f z,hf z hp⟩
+  · have him : z.im=0 := le_antisymm (le_of_not_gt hp) hz
+    have he : z=(z.re:ℂ) := by apply Complex.ext <;> simp [him]
+    rw [he]
+    exact hreal z.re
+
+lemma IsCapacityTwoWitness.boundary_extension_of_real_limits
+    {U : ℝ≥0 → ℝ} {γ : ℝ≥0 → ℂ} {G F : ℝ≥0 → ℂ → ℂ}
+    (hw : IsCapacityTwoWitness U γ G F) (t : ℝ≥0)
+    (hreal : ∀ x : ℝ, ∃ z : ℂ, Tendsto (F t) (𝓝[upperHalfPlane] (x:ℂ)) (𝓝 z)) :
+    ∃ Fbar : ℂ → ℂ, ContinuousOn Fbar {z : ℂ | 0≤z.im} ∧
+      (∀ z∈upperHalfPlane, Fbar z=F t z) ∧ Fbar (U t:ℂ)=γ t := by
+  let Fbar := extendFrom upperHalfPlane (F t)
+  have hFc := (hw.2.2.2.2.1 t).continuousOn
+  have hext : ∀ z∈upperHalfPlane, Fbar z=F t z := extendFrom_extends hFc
+  have hcont : ContinuousOn Fbar {z : ℂ | 0≤z.im} := by
+    apply continuousOn_extendFrom closedHalfPlane_subset_closure_upperHalfPlane
+    intro z hz
+    by_cases hp : 0<z.im
+    · exact ⟨F t z,hFc z hp⟩
+    · have him : z.im=0 := le_antisymm (le_of_not_gt hp) hz
+      have he : z=(z.re:ℂ) := by apply Complex.ext <;> simp [him]
+      rw [he]
+      exact hreal z.re
+  obtain ⟨p,hp⟩ := hreal (U t)
+  have hv : Tendsto (fun y : ℝ => (U t:ℂ)+(y:ℂ)*Complex.I)
+      (𝓝[>] 0) (𝓝[upperHalfPlane] (U t:ℂ)) := by
+    apply tendsto_nhdsWithin_iff.mpr
+    constructor
+    · have hc : Continuous (fun y : ℝ => (U t:ℂ)+(y:ℂ)*Complex.I) := by fun_prop
+      simpa only [Complex.ofReal_zero,zero_mul,add_zero] using
+        (hc.tendsto 0).mono_left nhdsWithin_le_nhds
+    · filter_upwards [self_mem_nhdsWithin] with y hy
+      change 0<((U t:ℂ)+(y:ℂ)*Complex.I).im
+      simpa using hy
+  have hpγ : p=γ t := tendsto_nhds_unique (hp.comp hv) (hw.2.2.2.2.2.2.2.2.2.2.2.2 t)
+  refine ⟨Fbar,hcont,hext,?_⟩
+  exact (extendFrom_eq (closedHalfPlane_subset_closure_upperHalfPlane (by simp)) hp).trans hpγ
+
+end SLEExactGauge
+
+end
+
+end OAI
diff --git a/lean/OAI/Probability/SLE/Geometry/HalfPlaneBoundaryIdentity.lean b/lean/OAI/Probability/SLE/Geometry/HalfPlaneBoundaryIdentity.lean
new file mode 100644
index 0000000000000000000000000000000000000000..6e55cfaeb58c23baa88ecf86369a622092f29395
--- /dev/null
+++ b/lean/OAI/Probability/SLE/Geometry/HalfPlaneBoundaryIdentity.lean
@@ -0,0 +1,62 @@
+import OAI.Probability.SLE.Geometry.HolomorphicAcrossReal
+import OAI.Probability.SLE.Geometry.HalfPlaneBoundaryExtension
+import Mathlib.Topology.Piecewise
+
+namespace OAI
+
+/-! A holomorphic upper-half-plane function continuous at a real interval
+and constant there is constant on an adjacent upper half disk. -/
+noncomputable section
+open Complex Set Filter Metric
+open scoped Topology
+
+namespace SLEExactGauge
+
+theorem halfPlane_boundary_identity {f : ℂ → ℂ}
+    (hC : ContinuousOn f {z : ℂ | 0≤z.im})
+    (hf : DifferentiableOn ℂ f upperHalfPlane) (x : ℝ) {r : ℝ} (hr : 0<r) (c : ℂ)
+    (hb : ∀ z∈ball (x:ℂ) r, z.im=0 → f z=c) :
+    ∀ z∈ball (x:ℂ) r, 0<z.im → f z=c := by
+  let g : ℂ → ℂ := fun z => if 0≤z.im then f z-c else 0
+  have hclosed : IsClosed {z : ℂ | 0≤z.im} := isClosed_le continuous_const continuous_im
+  have hgC : ContinuousOn g (ball (x:ℂ) r) := by
+    apply ContinuousOn.if
+    · intro z hz
+      have he : z.im=0 := (frontier_le_subset_eq continuous_const continuous_im hz.2).symm
+      exact sub_eq_zero.mpr (hb z hz.1 he)
+    · exact (hC.sub continuousOn_const).mono (fun _ hz => hclosed.closure_eq ▸ hz.2)
+    · exact continuousOn_const
+  have hgD : DifferentiableOn ℂ g (ball (x:ℂ) r) := by
+    apply differentiableOn_of_continuousOn_off_real isOpen_ball hgC
+    intro z _ hz
+    rcases lt_or_gt_of_ne hz with hn | hp
+    · apply (differentiableAt_const (c := (0:ℂ))).congr_of_eventuallyEq
+      filter_upwards [continuous_im.isOpen_preimage _ isOpen_Iio |>.mem_nhds hn] with w hw
+      simp only [g,ite_eq_right (not_le_of_gt (show w.im<0 from hw))]
+    · apply ((hf.differentiableAt (isOpen_upperHalfPlane.mem_nhds hp)).sub_const c).congr_of_eventuallyEq
+      filter_upwards [isOpen_upperHalfPlane.mem_nhds hp] with w hw
+      simp only [g,ite_eq_left (show 0<w.im from hw).le]
+  let a : ℂ := (x:ℂ)-((r/2:ℝ):ℂ)*I
+  have ha : a∈ball (x:ℂ) r := by
+    rw [mem_ball,dist_eq_norm]
+    have he : a-(x:ℂ)=-(((r/2:ℝ):ℂ)*I) := by dsimp [a]; ring
+    rw [he,norm_neg,norm_mul,norm_I,mul_one,norm_real,Real.norm_eq_abs,abs_of_pos (half_pos hr)]
+    linarith
+  have haim : a.im<0 := by
+    dsimp [a]
+    simp only [ofReal_im,mul_im,ofReal_re,I_im,mul_one,I_re,mul_zero,add_zero,zero_sub]
+    linarith
+  have hga : g =ᶠ[𝓝 a] 0 := by
+    filter_upwards [continuous_im.isOpen_preimage _ isOpen_Iio |>.mem_nhds haim] with w hw
+    simp only [g,ite_eq_right (not_le_of_gt (show w.im<0 from hw)),Pi.zero_apply]
+  have hzero := (hgD.analyticOnNhd isOpen_ball).eqOn_zero_of_preconnected_of_eventuallyEq_zero
+    (convex_ball (x:ℂ) r).isPreconnected ha hga
+  intro z hz hp
+  have he := hzero hz
+  simpa only [g,ite_eq_left hp.le,Pi.zero_apply,sub_eq_zero] using he
+
+end SLEExactGauge
+
+end
+
+end OAI
diff --git a/lean/OAI/Probability/SLE/Geometry/HalfPlaneCayleyCompactification.lean b/lean/OAI/Probability/SLE/Geometry/HalfPlaneCayleyCompactification.lean
new file mode 100644
index 0000000000000000000000000000000000000000..486e658bd5522f0c5e1e6c661dcee293cc3f186c
--- /dev/null
+++ b/lean/OAI/Probability/SLE/Geometry/HalfPlaneCayleyCompactification.lean
@@ -0,0 +1,91 @@
+import OAI.Probability.SLE.LoewnerCharts
+
+namespace OAI
+
+/-! The fixed Cayley chart compactifies the closed upper half-plane by
+sending infinity to `1`. It retains the real boundary pointwise as a
+parameterized unit circle, for the relative crosscut construction. -/
+noncomputable section
+open Set Filter Complex
+open scoped Topology
+
+namespace SLEExactGauge
+
+def halfPlaneCayley (z : ℂ) : ℂ := (z-I)/(z+I)
+
+lemma halfPlaneCayley_den_ne {z : ℂ} (hz : 0 ≤ z.im) : z+I ≠ 0 := by
+  intro he
+  have hh := congrArg Complex.im he
+  simp only [Complex.add_im,Complex.I_im,Complex.zero_im] at hh
+  linarith
+
+lemma halfPlaneCayley_continuousOn :
+    ContinuousOn halfPlaneCayley {z : ℂ | 0 ≤ z.im} :=
+  (continuousOn_id.sub continuousOn_const).div
+    (continuousOn_id.add continuousOn_const) (fun _ hz => halfPlaneCayley_den_ne hz)
+
+lemma halfPlaneCayley_injOn : InjOn halfPlaneCayley {z : ℂ | 0 ≤ z.im} := by
+  intro z hz w hw he
+  have hh := (div_eq_div_iff (halfPlaneCayley_den_ne hz) (halfPlaneCayley_den_ne hw)).mp he
+  have hzero : (z-w)*(2*I)=0 := by linear_combination hh
+  exact sub_eq_zero.mp ((mul_eq_zero.mp hzero).resolve_right (by norm_num))
+
+lemma halfPlaneCayley_norm_le {z : ℂ} (hz : 0 ≤ z.im) : ‖halfPlaneCayley z‖ ≤ 1 := by
+  rw [halfPlaneCayley,norm_div]
+  apply (div_le_one (norm_pos_iff.mpr (halfPlaneCayley_den_ne hz))).mpr
+  apply (sq_le_sq₀ (norm_nonneg _) (norm_nonneg _)).mp
+  rw [← Complex.normSq_eq_norm_sq,← Complex.normSq_eq_norm_sq]
+  simp only [Complex.normSq_apply,Complex.sub_re,Complex.I_re,sub_zero,
+    Complex.sub_im,Complex.I_im,Complex.add_re,add_zero,Complex.add_im]
+  nlinarith
+
+lemma halfPlaneCayley_norm_lt {z : ℂ} (hz : 0 < z.im) : ‖halfPlaneCayley z‖ < 1 := by
+  rw [halfPlaneCayley,norm_div]
+  apply (div_lt_one (norm_pos_iff.mpr (halfPlaneCayley_den_ne hz.le))).mpr
+  apply (sq_lt_sq₀ (norm_nonneg _) (norm_nonneg _)).mp
+  rw [← Complex.normSq_eq_norm_sq,← Complex.normSq_eq_norm_sq]
+  simp only [Complex.normSq_apply,Complex.sub_re,Complex.I_re,sub_zero,
+    Complex.sub_im,Complex.I_im,Complex.add_re,add_zero,Complex.add_im]
+  nlinarith
+
+lemma halfPlaneCayley_real_norm (x : ℝ) : ‖halfPlaneCayley (x : ℂ)‖ = 1 := by
+  rw [halfPlaneCayley,norm_div]
+  have he : ‖(x : ℂ)-I‖ = ‖(x : ℂ)+I‖ := by
+    apply (sq_eq_sq₀ (norm_nonneg _) (norm_nonneg _)).mp
+    rw [← Complex.normSq_eq_norm_sq,← Complex.normSq_eq_norm_sq]
+    simp [Complex.normSq_apply]
+  rw [he,div_self (norm_ne_zero_iff.mpr (halfPlaneCayley_den_ne (by simp)))]
+
+lemma halfPlaneCayley_ne_one {z : ℂ} (hz : 0 ≤ z.im) : halfPlaneCayley z ≠ 1 := by
+  intro he
+  have hh := (div_eq_one_iff_eq (halfPlaneCayley_den_ne hz)).mp he
+  have hi := congrArg Complex.im hh
+  simp only [Complex.sub_im,Complex.add_im,Complex.I_im] at hi
+  linarith
+
+lemma halfPlaneCayley_zero : halfPlaneCayley 0 = -1 := by
+  norm_num [halfPlaneCayley]
+
+theorem halfPlaneCayley_tendsto_infinity :
+    Tendsto halfPlaneCayley (cocompact ℂ) (𝓝 1) := by
+  have hadd : Tendsto (fun z : ℂ => z+I) (cocompact ℂ) (cocompact ℂ) :=
+    le_of_eq (Homeomorph.addRight I).map_cocompact
+  have hinv : Tendsto (fun z : ℂ => (z+I)⁻¹) (cocompact ℂ) (𝓝 0) :=
+    tendsto_inv₀_cobounded.comp (hadd.mono_right Metric.cobounded_eq_cocompact.ge)
+  have hn : ∀ᶠ z : ℂ in cocompact ℂ, z+I ≠ 0 := by
+    filter_upwards [(tendsto_norm_cocompact_atTop.comp hadd).eventually_gt_atTop 0] with z hz
+    exact norm_pos_iff.mp hz
+  have he : halfPlaneCayley =ᶠ[cocompact ℂ] (fun z => 1-(2*I)*(z+I)⁻¹) := by
+    filter_upwards [hn] with z hz
+    dsimp [halfPlaneCayley]
+    field_simp
+    ring
+  have hh := (tendsto_const_nhds : Tendsto (fun _ : ℂ => (1:ℂ))
+    (cocompact ℂ) (𝓝 1)).sub (hinv.const_mul (2*I))
+  simpa only [mul_zero,sub_zero] using hh.congr' he.symm
+
+end SLEExactGauge
+
+end
+
+end OAI
diff --git a/lean/OAI/Probability/SLE/Geometry/HalfPlaneCayleyInverse.lean b/lean/OAI/Probability/SLE/Geometry/HalfPlaneCayleyInverse.lean
new file mode 100644
index 0000000000000000000000000000000000000000..572897156632c9ee3f5abee2da03b7445b6e3aa1
--- /dev/null
+++ b/lean/OAI/Probability/SLE/Geometry/HalfPlaneCayleyInverse.lean
@@ -0,0 +1,84 @@
+import OAI.Probability.SLE.Geometry.HalfPlaneCayleyCompactification
+import OAI.Probability.SLE.DiskHalfPlane
+
+namespace OAI
+
+/-! The inverse Cayley chart on the compact disk with the point at
+infinity removed. -/
+noncomputable section
+open Set Filter Complex
+open scoped Topology
+
+namespace SLEExactGauge
+
+def halfPlaneCayleyInv (w : ℂ) : ℂ := I*(1+w)/(1-w)
+
+lemma halfPlaneCayleyInv_eq (w : ℂ) : halfPlaneCayleyInv w=diskToHalfPlane I w := by
+  unfold halfPlaneCayleyInv diskToHalfPlane
+  simp only [Complex.star_def,Complex.conj_I]
+  congr 1
+  ring
+
+lemma halfPlaneCayleyInv_im (w : ℂ) :
+    (halfPlaneCayleyInv w).im=(1-Complex.normSq w)/Complex.normSq (1-w) := by
+  rw [halfPlaneCayleyInv_eq,diskToHalfPlane_im]
+  simp
+
+lemma halfPlaneCayleyInv_continuousOn :
+    ContinuousOn halfPlaneCayleyInv {w : ℂ | w ≠ 1} := by
+  apply (continuousOn_const.mul (continuousOn_const.add continuousOn_id)).div
+    (continuousOn_const.sub continuousOn_id)
+  intro w hw
+  exact sub_ne_zero.mpr hw.symm
+
+lemma halfPlaneCayleyInv_closed {w : ℂ} (hw : ‖w‖ ≤ 1) :
+    0 ≤ (halfPlaneCayleyInv w).im := by
+  rw [halfPlaneCayleyInv_im]
+  have hs : Complex.normSq w ≤ 1 := by
+    rw [Complex.normSq_eq_norm_sq]
+    nlinarith [norm_nonneg w]
+  exact div_nonneg (sub_nonneg.mpr hs) (Complex.normSq_nonneg _)
+
+lemma halfPlaneCayleyInv_open {w : ℂ} (hw : ‖w‖ < 1) :
+    0 < (halfPlaneCayleyInv w).im := by
+  rw [halfPlaneCayleyInv_im]
+  have hs : Complex.normSq w < 1 := by
+    rw [Complex.normSq_eq_norm_sq]
+    nlinarith [norm_nonneg w]
+  have hn : 1-w ≠ 0 := by
+    intro he
+    have hwe : w=1 := (sub_eq_zero.mp he).symm
+    simp only [hwe,norm_one,lt_self_iff_false] at hw
+  exact div_pos (sub_pos.mpr hs) (Complex.normSq_pos.mpr hn)
+
+lemma halfPlaneCayleyInv_cayley {z : ℂ} (hz : 0 ≤ z.im) :
+    halfPlaneCayleyInv (halfPlaneCayley z)=z := by
+  have hd := halfPlaneCayley_den_ne hz
+  have hn : 1-halfPlaneCayley z ≠ 0 := sub_ne_zero.mpr (halfPlaneCayley_ne_one hz).symm
+  unfold halfPlaneCayleyInv
+  apply (div_eq_iff hn).mpr
+  unfold halfPlaneCayley
+  field_simp
+  ring
+
+lemma halfPlaneCayley_cayleyInv {w : ℂ} (hw : w ≠ 1) :
+    halfPlaneCayley (halfPlaneCayleyInv w)=w := by
+  have hd : 1-w ≠ 0 := sub_ne_zero.mpr hw.symm
+  have hn : halfPlaneCayleyInv w+I ≠ 0 := by
+    intro he
+    have hh : I*(1+w)+I*(1-w)=0 := by
+      have hx := congrArg (fun z : ℂ => z*(1-w)) he
+      simpa only [halfPlaneCayleyInv,add_mul,div_mul_cancel₀ _ hd,zero_mul] using hx
+    have hi : (2:ℂ)*I=0 := by linear_combination hh
+    norm_num at hi
+  unfold halfPlaneCayley
+  apply (div_eq_iff hn).mpr
+  unfold halfPlaneCayleyInv
+  field_simp
+  ring
+
+end SLEExactGauge
+
+end
+
+end OAI
diff --git a/lean/OAI/Probability/SLE/Geometry/HalfPlaneChartBoundary.lean b/lean/OAI/Probability/SLE/Geometry/HalfPlaneChartBoundary.lean
new file mode 100644
index 0000000000000000000000000000000000000000..ede1237f7cbd68098e23c85a5eb5a64cdf3e2f52
--- /dev/null
+++ b/lean/OAI/Probability/SLE/Geometry/HalfPlaneChartBoundary.lean
@@ -0,0 +1,40 @@
+import OAI.Probability.SLE.KernelConsistency
+
+namespace OAI
+
+/-! The two exceptional circle values of the centered half-plane chart. -/
+noncomputable section
+open Set Filter Metric
+open scoped Topology
+
+namespace SLEExactGauge
+
+lemma halfPlaneToDisk_zero_norm {v : ℂ} (hv : 0 < v.im) : ‖halfPlaneToDisk v 0‖=1 := by
+  have hv0 : v≠0 := by intro h; simp [h] at hv
+  simp only [halfPlaneToDisk,zero_sub,norm_div,norm_neg,norm_star]
+  exact div_self (norm_ne_zero_iff.mpr hv0)
+
+lemma diskToHalfPlane_continuousAt {v c : ℂ} (hc : c≠1) :
+    ContinuousAt (diskToHalfPlane v) c :=
+  (continuousAt_const.sub (continuousAt_const.mul continuousAt_id)).div
+    (continuousAt_const.sub continuousAt_id) (sub_ne_zero.mpr hc.symm)
+
+lemma diskToHalfPlane_boundary_im {v c : ℂ} (hc : ‖c‖=1) :
+    (diskToHalfPlane v c).im=0 := by
+  rw [diskToHalfPlane_im,Complex.normSq_eq_norm_sq,hc,one_pow,sub_self,mul_zero,zero_div]
+
+lemma diskToHalfPlane_boundary_ne_zero {v c : ℂ} (hv : 0 < v.im)
+    (hc1 : c≠1) (hc0 : c≠halfPlaneToDisk v 0) : diskToHalfPlane v c≠0 := by
+  have hv0 : v≠0 := by intro h; simp [h] at hv
+  have hstar : star v≠0 := by simpa using hv0
+  intro hz
+  have hn : v-star v*c=0 := (div_eq_zero_iff.mp hz).resolve_right (sub_ne_zero.mpr hc1.symm)
+  have he : c=v/star v := (eq_div_iff hstar).mpr (by linear_combination -hn)
+  apply hc0
+  simpa only [halfPlaneToDisk,zero_sub,neg_div_neg_eq] using he
+
+end SLEExactGauge
+
+end
+
+end OAI
diff --git a/lean/OAI/Probability/SLE/Geometry/HalfPlaneCompactnessBloch.lean b/lean/OAI/Probability/SLE/Geometry/HalfPlaneCompactnessBloch.lean
new file mode 100644
index 0000000000000000000000000000000000000000..8daa26b12214bf78d1a594b63510a1a6b46202e1
--- /dev/null
+++ b/lean/OAI/Probability/SLE/Geometry/HalfPlaneCompactnessBloch.lean
@@ -0,0 +1,74 @@
+import OAI.Probability.SLE.Loewner.UnivalentMovingNormalization
+import OAI.Probability.SLE.Geometry.HolomorphicFamilyCompactness
+import OAI.Probability.SLE.Loewner.UnivalentLocallyUniformLimit
+import OAI.Probability.SLE.Geometry.PublishedConformalCompactness
+
+namespace OAI
+
+/-! The precise half-plane compactness input, proved using the coarse Bloch
+bound, local propagation, and compact-open sequential compactness. -/
+noncomputable section
+open Set Filter Metric Function
+open scoped Topology
+
+namespace SLEExactGauge
+
+local instance compactnessFromBlochLocallyCompact : LocallyCompactSpace upperHalfPlane :=
+  isOpen_upperHalfPlane.locallyCompactSpace
+
+theorem actual_halfPlaneUnivalentCompactness : PublishedHalfPlaneUnivalentCompactness := by
+  classical
+  intro f z s m M hs hm hf hi hz hv hd
+  let K : Set ℂ := sphere 0 1 ∩ {w | s≤w.im}
+  have hK : IsCompact K := (isCompact_sphere (0:ℂ) 1).inter_right
+    (isClosed_le continuous_const Complex.continuous_im)
+  have hKH : K⊆upperHalfPlane := fun w hw => hs.trans_le hw.2
+  have hzK (n : ℕ) : z n∈K := by
+    exact ⟨by simpa only [mem_sphere,dist_zero_right] using (hz n).1,(hz n).2⟩
+  obtain ⟨σ,hσ,hb⟩ := univalent_moving_normalization_subsequence f z s M hs hf hi hz hv
+    (fun n => (hd n).2)
+  obtain ⟨g,τ,hτ,hconv⟩ := holomorphic_halfPlane_family_subsequence
+    (fun n => f (σ n)) (fun n => hf (σ n)) hb
+  let φ : ℕ → ℕ := σ ∘ τ
+  have hφ : StrictMono φ := hσ.comp hτ
+  let F : ℂ → ℂ := fun w => if hw : w∈upperHalfPlane then g ⟨w,hw⟩ else 0
+  have hlim : TendstoLocallyUniformlyOn (fun n => f (φ n)) F atTop upperHalfPlane := by
+    rw [tendstoLocallyUniformlyOn_iff_tendstoLocallyUniformly_comp_coe]
+    apply tendstoLocallyUniformly_iff_forall_isCompact.mpr
+    intro L hL
+    have h := ContinuousMap.tendsto_iff_forall_isCompact_tendstoUniformlyOn.mp hconv L hL
+    change TendstoUniformlyOn (fun n (w : upperHalfPlane) => f (φ n) w) g atTop L at h
+    change TendstoUniformlyOn (fun n (w : upperHalfPlane) => f (φ n) w)
+      (fun w : upperHalfPlane => F w) atTop L
+    have he : (fun w : upperHalfPlane => F w)=(g : upperHalfPlane → ℂ) := by
+      funext w
+      exact dite_eq_left w.property
+    rwa [he]
+  have hF := hlim.differentiableOn (Eventually.of_forall fun n => hf (φ n)) isOpen_upperHalfPlane
+  have hnon : ¬∃ c, ∀ w∈upperHalfPlane, F w=c := by
+    rintro ⟨c,hc⟩
+    have hzero (w : ℂ) (hw : w∈upperHalfPlane) : deriv F w=0 := by
+      have he : F =ᶠ[𝓝 w] (fun _ => c) := by
+        filter_upwards [isOpen_upperHalfPlane.mem_nhds hw] with v hv
+        exact hc v hv
+      rw [he.deriv_eq,deriv_const]
+    have hdl := hlim.deriv (Eventually.of_forall fun n => hf (φ n)) isOpen_upperHalfPlane
+    have hdu := (tendstoLocallyUniformlyOn_iff_forall_isCompact isOpen_upperHalfPlane).mp
+      hdl K hKH hK
+    obtain ⟨n,hn⟩ := ((Metric.tendstoUniformlyOn_iff.mp hdu) (m/2) (by positivity)).exists
+    have hsmall := hn (z (φ n)) (hzK (φ n))
+    have hlower := (hd (φ n)).1
+    rw [hzero _ (hKH (hzK (φ n)))] at hsmall
+    simp only [Function.comp_apply,dist_zero_left] at hsmall
+    linarith
+  have hconn : IsPreconnected upperHalfPlane :=
+    (convex_halfSpace_im_gt (0:ℝ)).isPreconnected
+  have hFi := tendstoLocallyUniformlyOn_injOn isOpen_upperHalfPlane hconn
+    (fun n => hf (φ n)) (fun n => hi (φ n)) hlim hnon
+  exact ⟨φ,F,hφ,hF,hFi,fun w hw => univalent_deriv_ne_zero isOpen_upperHalfPlane hF hFi hw,hlim⟩
+
+end SLEExactGauge
+
+end
+
+end OAI
diff --git a/lean/OAI/Probability/SLE/Geometry/HalfPlaneCompactnessFromGrowth.lean b/lean/OAI/Probability/SLE/Geometry/HalfPlaneCompactnessFromGrowth.lean
new file mode 100644
index 0000000000000000000000000000000000000000..1694d979447c0721630db01dc1b1a3e63cc59b94
--- /dev/null
+++ b/lean/OAI/Probability/SLE/Geometry/HalfPlaneCompactnessFromGrowth.lean
@@ -0,0 +1,75 @@
+import OAI.Probability.SLE.Geometry.HalfPlaneUnivalentBounds
+import OAI.Probability.SLE.Geometry.HolomorphicFamilyCompactness
+import OAI.Probability.SLE.Loewner.UnivalentLocallyUniformLimit
+import OAI.Probability.SLE.Geometry.PublishedConformalCompactness
+
+namespace OAI
+
+/-! The half-plane compactness input follows from the disk growth input.
+Moving normalization points stay on the prescribed compact semicircle. -/
+noncomputable section
+open Set Filter Metric Function
+open scoped Topology
+
+namespace SLEExactGauge
+
+local instance compactnessFromGrowthLocallyCompact : LocallyCompactSpace upperHalfPlane :=
+  isOpen_upperHalfPlane.locallyCompactSpace
+
+theorem halfPlaneUnivalentCompactness_of_diskGrowth
+    (hgrowth : PublishedDiskUnivalentGrowth) : PublishedHalfPlaneUnivalentCompactness := by
+  classical
+  intro f z s m M hs hm hf hi hz hv hd
+  let K : Set ℂ := sphere 0 1 ∩ {w | s≤w.im}
+  have hK : IsCompact K := (isCompact_sphere (0:ℂ) 1).inter_right
+    (isClosed_le continuous_const Complex.continuous_im)
+  have hKH : K⊆upperHalfPlane := fun w hw => hs.trans_le hw.2
+  have hzK (n : ℕ) : z n∈K := by
+    exact ⟨by simpa only [mem_sphere,dist_zero_right] using (hz n).1,(hz n).2⟩
+  have hb : ∀ L : Set ℂ, IsCompact L → L⊆upperHalfPlane →
+      ∃ C : ℝ, ∀ n, ∀ w∈L, ‖f n w‖≤C := by
+    intro L hL hLH
+    exact univalent_compact_family_bound hgrowth f z K L M hK hL hKH hLH hzK hf hi hv
+      (fun n => (hd n).2)
+  obtain ⟨g,φ,hφ,hconv⟩ := holomorphic_halfPlane_family_subsequence f hf hb
+  let F : ℂ → ℂ := fun w => if hw : w∈upperHalfPlane then g ⟨w,hw⟩ else 0
+  have hlim : TendstoLocallyUniformlyOn (fun n => f (φ n)) F atTop upperHalfPlane := by
+    rw [tendstoLocallyUniformlyOn_iff_tendstoLocallyUniformly_comp_coe]
+    apply tendstoLocallyUniformly_iff_forall_isCompact.mpr
+    intro L hL
+    have h := ContinuousMap.tendsto_iff_forall_isCompact_tendstoUniformlyOn.mp hconv L hL
+    change TendstoUniformlyOn (fun n (w : upperHalfPlane) => f (φ n) w) g atTop L at h
+    change TendstoUniformlyOn (fun n (w : upperHalfPlane) => f (φ n) w)
+      (fun w : upperHalfPlane => F w) atTop L
+    have he : (fun w : upperHalfPlane => F w)=(g : upperHalfPlane → ℂ) := by
+      funext w
+      exact dite_eq_left w.property
+    rwa [he]
+  have hF := hlim.differentiableOn (Eventually.of_forall fun n => hf (φ n)) isOpen_upperHalfPlane
+  have hnon : ¬∃ c, ∀ w∈upperHalfPlane, F w=c := by
+    rintro ⟨c,hc⟩
+    have hzero (w : ℂ) (hw : w∈upperHalfPlane) : deriv F w=0 := by
+      have he : F =ᶠ[𝓝 w] (fun _ => c) := by
+        filter_upwards [isOpen_upperHalfPlane.mem_nhds hw] with v hv
+        exact hc v hv
+      rw [he.deriv_eq,deriv_const]
+    have hdl := hlim.deriv (Eventually.of_forall fun n => hf (φ n)) isOpen_upperHalfPlane
+    have hdu := (tendstoLocallyUniformlyOn_iff_forall_isCompact isOpen_upperHalfPlane).mp
+      hdl K hKH hK
+    obtain ⟨n,hn⟩ := ((Metric.tendstoUniformlyOn_iff.mp hdu) (m/2) (by positivity)).exists
+    have hsmall := hn (z (φ n)) (hzK (φ n))
+    have hlower := (hd (φ n)).1
+    rw [hzero _ (hKH (hzK (φ n)))] at hsmall
+    simp only [Function.comp_apply,dist_zero_left] at hsmall
+    linarith
+  have hconn : IsPreconnected upperHalfPlane :=
+    (convex_halfSpace_im_gt (0:ℝ)).isPreconnected
+  have hFi := tendstoLocallyUniformlyOn_injOn isOpen_upperHalfPlane hconn
+    (fun n => hf (φ n)) (fun n => hi (φ n)) hlim hnon
+  exact ⟨φ,F,hφ,hF,hFi,fun w hw => univalent_deriv_ne_zero isOpen_upperHalfPlane hF hFi hw,hlim⟩
+
+end SLEExactGauge
+
+end
+
+end OAI
diff --git a/lean/OAI/Probability/SLE/Geometry/HalfPlaneDiskTransport.lean b/lean/OAI/Probability/SLE/Geometry/HalfPlaneDiskTransport.lean
new file mode 100644
index 0000000000000000000000000000000000000000..1ac59a5370856e43db426e951d0f4fb9b6205284
--- /dev/null
+++ b/lean/OAI/Probability/SLE/Geometry/HalfPlaneDiskTransport.lean
@@ -0,0 +1,45 @@
+import OAI.Probability.SLE.Geometry.ClosedHalfPlaneCayley
+import OAI.Probability.SLE.Geometry.PuncturedDiskHomeomorph
+
+namespace OAI
+
+/-! Transport a boundary-fixing disk homeomorphism through the fixed Cayley chart. -/
+noncomputable section
+open Set Complex Metric
+
+namespace SLEExactGauge
+
+def halfPlaneDiskTransport
+    (e : closedBall (0:ℂ) 1 ≃ₜ closedBall (0:ℂ) 1)
+    (h1 : e ⟨1,by norm_num⟩=⟨1,by norm_num⟩) :
+    {z : ℂ // 0 ≤ z.im} ≃ₜ {z : ℂ // 0 ≤ z.im} :=
+  (closedHalfPlaneCayley.trans (puncturedDiskHomeomorph e h1)).trans
+    closedHalfPlaneCayley.symm
+
+lemma halfPlaneDiskTransport_apply
+    (e : closedBall (0:ℂ) 1 ≃ₜ closedBall (0:ℂ) 1)
+    (h1 : e ⟨1,by norm_num⟩=⟨1,by norm_num⟩)
+    (z : {z : ℂ // 0 ≤ z.im}) :
+    (halfPlaneDiskTransport e h1 z : ℂ)=
+      halfPlaneCayleyInv (e ⟨halfPlaneCayley z,by
+        simpa only [mem_closedBall,dist_zero_right] using halfPlaneCayley_norm_le z.property⟩) := rfl
+
+lemma halfPlaneDiskTransport_boundary
+    (e : closedBall (0:ℂ) 1 ≃ₜ closedBall (0:ℂ) 1)
+    (h1 : e ⟨1,by norm_num⟩=⟨1,by norm_num⟩)
+    (hfix : ∀ z : closedBall (0:ℂ) 1, ‖(z:ℂ)‖=1 → (e z:ℂ)=z)
+    (z : {z : ℂ // 0 ≤ z.im}) (hz : z.val.im=0) :
+    (halfPlaneDiskTransport e h1 z : ℂ)=z := by
+  rw [halfPlaneDiskTransport_apply]
+  have hreal : (z:ℂ)=(z.val.re:ℂ) := Complex.ext rfl hz
+  have hn : ‖halfPlaneCayley (z:ℂ)‖=1 := by
+    rw [hreal]
+    exact halfPlaneCayley_real_norm _
+  rw [hfix _ hn]
+  exact halfPlaneCayleyInv_cayley z.property
+
+end SLEExactGauge
+
+end
+
+end OAI
diff --git a/lean/OAI/Probability/SLE/Geometry/HalfPlaneExteriorConnected.lean b/lean/OAI/Probability/SLE/Geometry/HalfPlaneExteriorConnected.lean
new file mode 100644
index 0000000000000000000000000000000000000000..4437eff27284e3a302fc15641f86ca73bb07badc
--- /dev/null
+++ b/lean/OAI/Probability/SLE/Geometry/HalfPlaneExteriorConnected.lean
@@ -0,0 +1,111 @@
+import OAI.Probability.SLE.Geometry.SimpleArcComplement
+import Mathlib.Analysis.Convex.Topology
+
+namespace OAI
+
+/-! A common connected exterior for every bounded half-plane obstacle.
+This lets unbounded complementary components be identified without any
+boundary regularity or choice of a conformal map. -/
+noncomputable section
+open Set Complex Metric
+
+namespace SLEExactGauge
+
+def halfPlaneRectangleExterior (R : ℝ) : Set ℂ :=
+  {z | 0 < z.im ∧ (R < |z.re| ∨ R < z.im)}
+
+lemma halfPlaneRectangleExterior_connected {R : ℝ} (hR : 0 ≤ R) :
+    IsConnected (halfPlaneRectangleExterior R) := by
+  let L : Set ℂ := {z | z.re < -R ∧ 0 < z.im}
+  let U : Set ℂ := {z | R < z.im}
+  let V : Set ℂ := {z | R < z.re ∧ 0 < z.im}
+  have hL : Convex ℝ L :=
+    (convex_halfSpace_re_lt (-R)).inter (convex_halfSpace_im_gt 0)
+  have hU : Convex ℝ U := convex_halfSpace_im_gt R
+  have hV : Convex ℝ V :=
+    (convex_halfSpace_re_gt R).inter (convex_halfSpace_im_gt 0)
+  have hLU : (L ∩ U).Nonempty := by
+    refine ⟨((-R-1 : ℝ) : ℂ)+((R+1:ℝ):ℂ)*I,?_,?_⟩
+    all_goals norm_num [L,U]
+    all_goals linarith
+  have hUV : ((L ∪ U) ∩ V).Nonempty := by
+    refine ⟨((R+1 : ℝ) : ℂ)+((R+1:ℝ):ℂ)*I,Or.inr ?_,?_⟩
+    all_goals norm_num [U,V]
+    all_goals linarith
+  have hpre := (hL.isPreconnected.union' hLU hU.isPreconnected).union' hUV hV.isPreconnected
+  have he : halfPlaneRectangleExterior R = (L ∪ U) ∪ V := by
+    ext z
+    simp only [halfPlaneRectangleExterior,L,U,V,mem_ofPred_eq,mem_union]
+    rw [lt_abs]
+    constructor
+    · rintro ⟨hi,(hr|hiR)⟩
+      · rcases hr with hr|hr
+        · exact Or.inr ⟨hr,hi⟩
+        · exact Or.inl (Or.inl ⟨by linarith,hi⟩)
+      · exact Or.inl (Or.inr hiR)
+    · rintro ((⟨hr,hi⟩|hi)|⟨hr,hi⟩)
+      · exact ⟨hi,Or.inl (Or.inr (by linarith))⟩
+      · exact ⟨lt_of_le_of_lt hR hi,Or.inr hi⟩
+      · exact ⟨hi,Or.inl (Or.inl hr)⟩
+  rw [he]
+  exact ⟨⟨hLU.choose,Or.inl (Or.inl hLU.choose_spec.1)⟩,hpre⟩
+
+lemma mem_halfPlaneRectangleExterior_of_norm_lt {R : ℝ} {z : ℂ}
+    (hz : 0 < z.im) (hn : 2*R < ‖z‖) :
+    z ∈ halfPlaneRectangleExterior R := by
+  refine ⟨hz,?_⟩
+  by_contra h
+  push Not at h
+  have hb := norm_le_abs_re_add_abs_im z
+  rw [abs_of_pos hz] at hb
+  linarith
+
+lemma halfPlaneRectangleExterior_disjoint_bounded {K : Set ℂ} {R : ℝ}
+    (hK : ∀ z ∈ K, ‖z‖ ≤ R) :
+    halfPlaneRectangleExterior R ⊆ upperHalfPlane \ K := by
+  intro z hz
+  refine ⟨hz.1,?_⟩
+  intro hzK
+  rcases hz.2 with hr|hi
+  · exact (hK z hzK).not_gt (hr.trans_le (abs_re_le_norm z))
+  · exact (hK z hzK).not_gt (hi.trans_le ((le_abs_self z.im).trans (abs_im_le_norm z)))
+
+theorem halfPlane_complement_connected_of_unbounded_components
+    {K : Set ℂ} (hK : Bornology.IsBounded K)
+    (hcomp : ∀ z ∈ upperHalfPlane \ K,
+      ¬ Bornology.IsBounded (connectedComponentIn (upperHalfPlane \ K) z)) :
+    IsConnected (upperHalfPlane \ K) := by
+  obtain ⟨R,hR,hbound⟩ := hK.subset_ball_lt 0 (0:ℂ)
+  have hKR : ∀ z ∈ K, ‖z‖ ≤ R := by
+    intro z hz
+    exact (show ‖z‖ < R by simpa only [mem_ball,dist_zero_right] using hbound hz).le
+  let E := halfPlaneRectangleExterior R
+  have hE : IsConnected E := halfPlaneRectangleExterior_connected hR.le
+  have hED : E ⊆ upperHalfPlane \ K := halfPlaneRectangleExterior_disjoint_bounded hKR
+  obtain ⟨w,hw⟩ := hE.nonempty
+  have heq : upperHalfPlane \ K = connectedComponentIn (upperHalfPlane \ K) w := by
+    apply Subset.antisymm _ (connectedComponentIn_subset _ _)
+    intro z hz
+    have hn := hcomp z hz
+    have hexc : ∃ v ∈ connectedComponentIn (upperHalfPlane \ K) z, 2*R < ‖v‖ := by
+      by_contra he
+      push Not at he
+      apply hn
+      apply (isBounded_closedBall (x := (0:ℂ)) (r := 2*R)).subset
+      intro v hv
+      simpa only [mem_closedBall,dist_zero_right] using he v hv
+    obtain ⟨v,hv,hvR⟩ := hexc
+    have hvE : v ∈ E := mem_halfPlaneRectangleExterior_of_norm_lt
+      (connectedComponentIn_subset _ _ hv).1 hvR
+    have hwC := hE.isPreconnected.subset_connectedComponentIn hvE hED hw
+    rw [← connectedComponentIn_eq hv] at hwC
+    rw [← connectedComponentIn_eq hwC]
+    exact mem_connectedComponentIn hz
+  rw [heq]
+  exact isConnected_connectedComponentIn_iff.mpr (hED hw)
+
+end SLEExactGauge
+
+end
+
+end OAI
diff --git a/lean/OAI/Probability/SLE/Geometry/HalfPlaneJulia.lean b/lean/OAI/Probability/SLE/Geometry/HalfPlaneJulia.lean
new file mode 100644
index 0000000000000000000000000000000000000000..06a1edff821debde282b247e074cb54e5ab6d791
--- /dev/null
+++ b/lean/OAI/Probability/SLE/Geometry/HalfPlaneJulia.lean
@@ -0,0 +1,62 @@
+import OAI.Probability.SLE.Geometry.HalfPlaneSchwarzPick
+
+namespace OAI
+
+/-! The boundary Schwarz–Pick limit at infinity. Only a normalized
+sequence tending vertically to infinity is needed for slit comparisons. -/
+noncomputable section
+open Set Filter Complex Function Metric
+open scoped Topology ComplexConjugate
+
+namespace SLEExactGauge
+
+lemma normSq_div_real (z : ℂ) (y : ℝ) : normSq (z/(y:ℂ))=normSq z/y^2 := by
+  simp [normSq_apply,pow_two]
+
+lemma halfPlane_schwarz_pick_scaled {f : ℂ → ℂ}
+    (hf : DifferentiableOn ℂ f upperHalfPlane) (hm : MapsTo f upperHalfPlane upperHalfPlane)
+    {z : ℂ} (hz : z ∈ upperHalfPlane) {y : ℝ} (hy : 0<y) :
+    z.im*normSq (f z/(y:ℂ)-conj (f ((y:ℂ)*I)/(y:ℂ))) ≤
+      (f z).im*(f ((y:ℂ)*I)/(y:ℂ)).im*normSq (z/(y:ℂ)+I) := by
+  have hw : (y:ℂ)*I ∈ upperHalfPlane := by simpa [upperHalfPlane] using hy
+  have hh := halfPlane_schwarz_pick_kernel hf hm hz hw
+  have h1 : f z/(y:ℂ)-conj (f ((y:ℂ)*I)/(y:ℂ)) =
+      (f z-conj (f ((y:ℂ)*I)))/(y:ℂ) := by
+    rw [map_div₀,conj_ofReal,sub_div]
+  have h2 : z/(y:ℂ)+I = (z-conj ((y:ℂ)*I))/(y:ℂ) := by
+    simp only [map_mul,conj_ofReal,conj_I]
+    field_simp [Complex.ofReal_ne_zero.mpr hy.ne']
+    ring
+  rw [h1,h2,normSq_div_real,normSq_div_real,div_ofReal_im]
+  have hi : ((y:ℂ)*I).im=y := by simp
+  rw [hi] at hh
+  have hp : 0<y^3 := pow_pos hy 3
+  apply (mul_le_mul_iff_of_pos_right hp).mp
+  field_simp
+  nlinarith [hh]
+
+theorem halfPlane_julia_at_infinity {f : ℂ → ℂ}
+    (hf : DifferentiableOn ℂ f upperHalfPlane) (hm : MapsTo f upperHalfPlane upperHalfPlane)
+    (y : ℕ → ℝ) (hy : ∀ n, 0<y n)
+    (hinv : Tendsto (fun n => (y n)⁻¹) atTop (𝓝 0))
+    (hfn : Tendsto (fun n => f ((y n:ℂ)*I)/(y n:ℂ)) atTop (𝓝 I))
+    {z : ℂ} (hz : z ∈ upperHalfPlane) : z.im ≤ (f z).im := by
+  have hzero (w : ℂ) : Tendsto (fun n => w/(y n:ℂ)) atTop (𝓝 0) := by
+    have hh := (tendsto_const_nhds (x := w) (f := atTop)).mul (Complex.continuous_ofReal.continuousAt.tendsto.comp hinv)
+    simpa only [Function.comp_def,ofReal_zero,mul_zero,ofReal_inv,div_eq_mul_inv] using hh
+  have hL := (hzero (f z)).sub (Complex.continuous_conj.tendsto I |>.comp hfn)
+  have hR := (hzero z).add_const I
+  have hIm := Complex.continuous_im.tendsto I |>.comp hfn
+  have hnL := (continuous_normSq.tendsto ((0:ℂ)-conj I)).comp hL
+  have hnR := (continuous_normSq.tendsto ((0:ℂ)+I)).comp hR
+  have hl := (tendsto_const_nhds (x := z.im) (f := atTop)).mul hnL
+  have hr := ((tendsto_const_nhds (x := (f z).im) (f := atTop)).mul hIm).mul hnR
+  have hh := le_of_tendsto_of_tendsto hl hr
+    (Eventually.of_forall (fun n => halfPlane_schwarz_pick_scaled hf hm hz (hy n)))
+  simpa only [conj_I,zero_sub,neg_neg,zero_add,normSq_I,I_im,mul_one] using hh
+
+end SLEExactGauge
+
+end
+
+end OAI
diff --git a/lean/OAI/Probability/SLE/Geometry/HalfPlaneNormalizedUniqueness.lean b/lean/OAI/Probability/SLE/Geometry/HalfPlaneNormalizedUniqueness.lean
new file mode 100644
index 0000000000000000000000000000000000000000..b267658a886642b4cb659558c8f8b3ed53f1c4be
--- /dev/null
+++ b/lean/OAI/Probability/SLE/Geometry/HalfPlaneNormalizedUniqueness.lean
@@ -0,0 +1,46 @@
+import OAI.Probability.SLE.Loewner.HydrodynamicHeight
+import Mathlib.Analysis.Complex.OpenMapping
+
+namespace OAI
+
+/-! A normalized half-plane map with a normalized holomorphic inverse is
+the identity. The height comparison fixes its imaginary part, and the
+normalization removes the remaining real translation. -/
+noncomputable section
+open Set Filter Complex Function Metric
+open scoped Topology
+
+namespace SLEExactGauge
+
+theorem normalized_halfPlane_left_inverse_eq_id {G F : ℂ → ℂ}
+    (hG : DifferentiableOn ℂ G upperHalfPlane) (hF : DifferentiableOn ℂ F upperHalfPlane)
+    (hGm : MapsTo G upperHalfPlane upperHalfPlane) (hFm : MapsTo F upperHalfPlane upperHalfPlane)
+    (hFG : ∀ z ∈ upperHalfPlane, F (G z)=z)
+    (hGn : Tendsto (fun z : ℂ => G z/z) (cocompact ℂ ⊓ 𝓟 upperHalfPlane) (𝓝 1))
+    (hFn : Tendsto (fun z : ℂ => F z/z) (cocompact ℂ ⊓ 𝓟 upperHalfPlane) (𝓝 1))
+    (hG0 : Tendsto (fun z : ℂ => G z-z) (cocompact ℂ ⊓ 𝓟 upperHalfPlane) (𝓝 0)) :
+    EqOn G id upperHalfPlane := by
+  have him (z : ℂ) (hz : z ∈ upperHalfPlane) : (G z-z).im=0 := by
+    have h1 := normalized_halfPlane_height hG hGm hGn hz
+    have h2 := normalized_halfPlane_height hF hFm hFn (hGm hz)
+    rw [hFG z hz] at h2
+    simp only [sub_im]
+    linarith
+  have hc : IsConnected upperHalfPlane :=
+    ⟨⟨I,by simp [upperHalfPlane]⟩,(convex_halfSpace_im_gt (0:ℝ)).isPreconnected⟩
+  have ha : AnalyticOnNhd ℂ (fun z => G z-z) upperHalfPlane :=
+    (hG.sub differentiableOn_id).analyticOnNhd isOpen_upperHalfPlane
+  obtain ⟨c,hc⟩ := ha.eq_const_of_im_eq_const him isOpen_upperHalfPlane hc
+  have ht : Tendsto (fun _ : ℕ => c) atTop (𝓝 0) := by
+    apply (hG0.comp verticalInfinity_tendsto).congr
+    intro n
+    exact hc _ (verticalInfinity_mem n)
+  have hc0 : c=0 := tendsto_nhds_unique tendsto_const_nhds ht
+  intro z hz
+  exact sub_eq_zero.mp ((hc z hz).trans hc0)
+
+end SLEExactGauge
+
+end
+
+end OAI
diff --git a/lean/OAI/Probability/SLE/Geometry/HalfPlaneSchwarzPick.lean b/lean/OAI/Probability/SLE/Geometry/HalfPlaneSchwarzPick.lean
new file mode 100644
index 0000000000000000000000000000000000000000..e52d2010bf303182b13db0010a25fd312610554b
--- /dev/null
+++ b/lean/OAI/Probability/SLE/Geometry/HalfPlaneSchwarzPick.lean
@@ -0,0 +1,60 @@
+import OAI.Probability.SLE.KernelConsistency
+import Mathlib.Analysis.Complex.Schwarz
+
+namespace OAI
+
+/-! The half-plane Schwarz–Pick inequality in the form needed to compare
+hydrodynamically normalized slit maps. -/
+noncomputable section
+open Set Filter Complex Function Metric
+open scoped Topology ComplexConjugate
+
+namespace SLEExactGauge
+
+lemma halfPlane_schwarz_pick {f : ℂ → ℂ}
+    (hf : DifferentiableOn ℂ f upperHalfPlane) (hm : MapsTo f upperHalfPlane upperHalfPlane)
+    {z w : ℂ} (hz : z ∈ upperHalfPlane) (hw : w ∈ upperHalfPlane) :
+    ‖halfPlaneToDisk (f w) (f z)‖ ≤ ‖halfPlaneToDisk w z‖ := by
+  let g := halfPlaneToDisk (f w) ∘ f ∘ diskToHalfPlane w
+  have hg : DifferentiableOn ℂ g (ball 0 1) :=
+    (halfPlaneToDisk_differentiable (hm hw)).comp
+      (hf.comp (diskToHalfPlane_differentiable w) (diskToHalfPlane_maps hw))
+      (hm.comp (diskToHalfPlane_maps hw))
+  have hgm : MapsTo g (ball 0 1) (closedBall 0 1) :=
+    ((halfPlaneToDisk_maps (hm hw)).comp (hm.comp (diskToHalfPlane_maps hw))).mono_right
+      ball_subset_closedBall
+  have hg0 : g 0=0 := by simp [g,halfPlaneToDisk]
+  have hh := Complex.norm_le_norm_of_mapsTo_ball hg hgm hg0
+    (mem_ball_zero_iff.mp (halfPlaneToDisk_maps hw hz))
+  simpa only [g,Function.comp_apply,diskToHalfPlane_halfPlaneToDisk hw hz] using hh
+
+lemma halfPlane_normSq_difference (z w : ℂ) :
+    normSq (z-conj w)-normSq (z-w)=4*z.im*w.im := by
+  simp only [normSq_apply,sub_re,sub_im,conj_re,conj_im]
+  ring
+
+lemma halfPlane_schwarz_pick_kernel {f : ℂ → ℂ}
+    (hf : DifferentiableOn ℂ f upperHalfPlane) (hm : MapsTo f upperHalfPlane upperHalfPlane)
+    {z w : ℂ} (hz : z ∈ upperHalfPlane) (hw : w ∈ upperHalfPlane) :
+    z.im*w.im*normSq (f z-conj (f w)) ≤
+      (f z).im*(f w).im*normSq (z-conj w) := by
+  have h := halfPlane_schwarz_pick hf hm hz hw
+  have hd : 0 < normSq (z-conj w) :=
+    normSq_pos.mpr (halfPlane_denominator_ne hw hz)
+  have hdf : 0 < normSq (f z-conj (f w)) :=
+    normSq_pos.mpr (halfPlane_denominator_ne (hm hw) (hm hz))
+  have hsq : normSq (halfPlaneToDisk (f w) (f z)) ≤
+      normSq (halfPlaneToDisk w z) := by
+    rw [normSq_eq_norm_sq,normSq_eq_norm_sq]
+    nlinarith [norm_nonneg (halfPlaneToDisk (f w) (f z)),norm_nonneg (halfPlaneToDisk w z)]
+  simp only [halfPlaneToDisk,star_def,normSq_div] at hsq
+  have he := (div_le_div_iff₀ hdf hd).mp hsq
+  have h1 := halfPlane_normSq_difference z w
+  have h2 := halfPlane_normSq_difference (f z) (f w)
+  nlinarith
+
+end SLEExactGauge
+
+end
+
+end OAI
diff --git a/lean/OAI/Probability/SLE/Geometry/HalfPlaneUnivalentBounds.lean b/lean/OAI/Probability/SLE/Geometry/HalfPlaneUnivalentBounds.lean
new file mode 100644
index 0000000000000000000000000000000000000000..ce05365083cc254cf0479088b74dffec7718f0ad
--- /dev/null
+++ b/lean/OAI/Probability/SLE/Geometry/HalfPlaneUnivalentBounds.lean
@@ -0,0 +1,85 @@
+import OAI.Probability.SLE.Multipoint.MultipointGeometry
+import OAI.Probability.SLE.KernelConsistency
+
+namespace OAI
+
+/-! The disk growth estimate controls half-plane maps with moving
+normalizations on a fixed compact set. -/
+noncomputable section
+open Set Filter Metric Complex
+open scoped Topology
+
+namespace SLEExactGauge
+
+def halfPlaneGrowthCost (z w : ℂ) : ℝ :=
+  2*z.im*‖halfPlaneToDisk z w‖/(1-‖halfPlaneToDisk z w‖)^2
+
+lemma halfPlaneGrowthCost_nonneg {z w : ℂ} (hz : z∈upperHalfPlane) :
+    0≤halfPlaneGrowthCost z w := by
+  exact div_nonneg (mul_nonneg (mul_nonneg (by norm_num) hz.le) (norm_nonneg _)) (sq_nonneg _)
+
+lemma univalent_halfPlane_growth (hgrowth : PublishedDiskUnivalentGrowth)
+    {f : ℂ → ℂ} (hf : DifferentiableOn ℂ f upperHalfPlane) (hi : InjOn f upperHalfPlane)
+    {z w : ℂ} (hz : z∈upperHalfPlane) (hw : w∈upperHalfPlane) :
+    ‖f w-f z‖ ≤ ‖deriv f z‖*halfPlaneGrowthCost z w := by
+  have hdf : DifferentiableOn ℂ (f ∘ diskToHalfPlane z) (ball 0 1) :=
+    hf.comp (diskToHalfPlane_differentiable z) (diskToHalfPlane_maps hz)
+  have hinj : InjOn (f ∘ diskToHalfPlane z) (ball 0 1) :=
+    hi.comp (diskToHalfPlane_injOn hz) (diskToHalfPlane_maps hz)
+  have hdfz : HasDerivAt f (deriv f z) (diskToHalfPlane z 0) := by
+    simpa only [diskToHalfPlane_zero] using
+      (hf.differentiableAt (isOpen_upperHalfPlane.mem_nhds hz)).hasDerivAt
+  have hder : deriv (f ∘ diskToHalfPlane z) 0=deriv f z*(z-star z) :=
+    (hdfz.comp 0 (diskToHalfPlane_deriv_zero z)).deriv
+  have h := hgrowth (f ∘ diskToHalfPlane z) hdf hinj (halfPlaneToDisk z w)
+    (halfPlaneToDisk_maps hz hw)
+  simp only [Function.comp_apply,diskToHalfPlane_zero,diskToHalfPlane_halfPlaneToDisk hz hw,
+    hder,norm_mul,norm_sub_conj_of_im_pos hz] at h
+  convert h using 1
+  simp only [halfPlaneGrowthCost]
+  ring
+
+lemma continuousOn_halfPlaneGrowthCost :
+    ContinuousOn (fun q : ℂ × ℂ => halfPlaneGrowthCost q.1 q.2)
+      (upperHalfPlane ×ˢ upperHalfPlane) := by
+  have hq : ContinuousOn (fun q : ℂ × ℂ => halfPlaneToDisk q.1 q.2)
+      (upperHalfPlane ×ˢ upperHalfPlane) := by
+    exact (continuous_snd.sub continuous_fst).continuousOn.div
+      (continuous_snd.sub (Complex.continuous_conj.comp continuous_fst)).continuousOn
+      (fun q hq => halfPlane_denominator_ne hq.1 hq.2)
+  exact ((continuous_const.mul (Complex.continuous_im.comp continuous_fst)).continuousOn.mul
+    hq.norm).div (continuousOn_const.sub hq.norm |>.pow 2) (fun q hq' => by
+      apply pow_ne_zero
+      exact sub_ne_zero.mpr (ne_of_gt (mem_ball_zero_iff.mp (halfPlaneToDisk_maps hq'.1 hq'.2))))
+
+lemma univalent_compact_family_bound (hgrowth : PublishedDiskUnivalentGrowth)
+    (f : ℕ → ℂ → ℂ) (z : ℕ → ℂ) (K L : Set ℂ) (M : ℝ)
+    (hK : IsCompact K) (hL : IsCompact L) (hKH : K⊆upperHalfPlane) (hLH : L⊆upperHalfPlane)
+    (hz : ∀ n, z n∈K) (hf : ∀ n, DifferentiableOn ℂ (f n) upperHalfPlane)
+    (hi : ∀ n, InjOn (f n) upperHalfPlane)
+    (hv : ∀ n, ‖f n (z n)‖≤M) (hd : ∀ n, ‖deriv (f n) (z n)‖≤M) :
+    ∃ C : ℝ, ∀ n, ∀ w∈L, ‖f n w‖≤C := by
+  have hc := continuousOn_halfPlaneGrowthCost.mono (Set.prod_mono hKH hLH)
+  obtain ⟨R,hR⟩ := (hK.prod hL).bddAbove_image hc
+  let A : ℝ := max M 0
+  let B : ℝ := max R 0
+  have hA : 0≤A := le_max_right _ _
+  have hB : 0≤B := le_max_right _ _
+  refine ⟨A*B+A,fun n w hw => ?_⟩
+  have hcost : halfPlaneGrowthCost (z n) w≤B := by
+    apply le_trans _ (le_max_left R 0)
+    exact hR ⟨(z n,w),⟨hz n,hw⟩,rfl⟩
+  calc
+    ‖f n w‖ ≤ ‖f n w-f n (z n)‖+‖f n (z n)‖ := norm_le_norm_sub_add _ _
+    _ ≤ ‖deriv (f n) (z n)‖*halfPlaneGrowthCost (z n) w+A :=
+      add_le_add (univalent_halfPlane_growth hgrowth (hf n) (hi n) (hKH (hz n)) (hLH hw))
+        ((hv n).trans (le_max_left _ _))
+    _ ≤ A*B+A := add_le_add
+      (mul_le_mul ((hd n).trans (le_max_left _ _)) hcost
+        (halfPlaneGrowthCost_nonneg (hKH (hz n))) hA) le_rfl
+
+end SLEExactGauge
+
+end
+
+end OAI
diff --git a/lean/OAI/Probability/SLE/Geometry/HarmonicExitLimit.lean b/lean/OAI/Probability/SLE/Geometry/HarmonicExitLimit.lean
new file mode 100644
index 0000000000000000000000000000000000000000..b949a855e71ee338c8c622fd4ff8b92283e43e0a
--- /dev/null
+++ b/lean/OAI/Probability/SLE/Geometry/HarmonicExitLimit.lean
@@ -0,0 +1,56 @@
+import OAI.Probability.SLE.Geometry.HarmonicUniformTails
+
+namespace OAI
+
+/-! Bounded harmonic observables have actual left limits at every finite
+domain exit, simultaneously on the original planar Wiener space. -/
+noncomputable section
+open Set Filter MeasureTheory ProbabilityTheory
+open scoped Topology NNReal ENNReal
+
+namespace SLEExactGauge
+open Target
+namespace SmoothDomainExhaustion
+variable {U : Set (ℝ×ℝ)} (e : SmoothDomainExhaustion U 0)
+
+include e in
+theorem harmonic_exit_limit
+    (W : WienerLaw) (hW : IsWiener W) (T : ℝ≥0) (hU : IsOpen U)
+    (u : ℝ×ℝ → ℝ) (hu : ContDiffOn ℝ (⊤ : ℕ∞) u U)
+    (hhar : ∀ z∈U, planarGenerator u z=0)
+    (C : ℝ≥0) (huC : ∀ z∈U, |u z|≤C) :
+    ∃ Y : Driver×Driver → ℝ, Measurable Y ∧ (∀ b, |Y b|≤C) ∧
+      (∫ b, Y b ∂W.prod W)=u 0 ∧
+      (∀ᵐ b ∂W.prod W, Tendsto (fun n => u (planarWiener (e.stop T n b) b)) atTop (𝓝 (Y b))) ∧
+      (∀ᵐ b ∂W.prod W, ∀ τ : ℝ≥0, τ ≤ T →
+        (∀ t<τ, planarWiener t b∈U) → planarWiener τ b∉U →
+          Tendsto (fun t => u (planarWiener t b)) (𝓝[<] τ) (𝓝 (Y b))) := by
+  let : IsProbabilityMeasure W := hW.isGaussianProcess.isProbabilityMeasure
+  obtain ⟨Y,hYm,hYb,hY,hE⟩ := SmoothDomainExhaustion.harmonic_limit_data e W hW T hU u hu hhar C huC
+  obtain ⟨N,hN,hgood⟩ := e.harmonic_uniform_tails W hW T hU u hu hhar C huC Y hY hE
+  have hI : Tendsto (fun n => ∫ b, u (planarWiener (e.stop T n b) b) ∂W.prod W) atTop
+      (𝓝 (∫ b, Y b ∂W.prod W)) := by
+    have hM := e.harmonic_stopped_martingale W hW T hU u hu hhar C huC
+    apply tendsto_integral_of_dominated_convergence (fun _ => (C:ℝ))
+      (fun n => ((hM.1 n).mono ((e.stopFiltration T).le n)).aestronglyMeasurable) (integrable_const _)
+    · intro n
+      exact Eventually.of_forall fun b => by
+        simpa only [Real.norm_eq_abs] using huC _ (e.stop_mem_domain T n b _ le_rfl)
+    · exact hY
+  have hIn (n) : (∫ b, u (planarWiener (e.stop T n b) b) ∂W.prod W)=u 0 := by
+    have hh := planar_local_harmonic_optional W hW U (tsupport (e.cutoff n)) hU
+      (e.compact n) (e.supported n) u hu hhar (e.stop T n) (e.stop_stopping T n)
+      T (e.stop_le T n) (e.stop_mem_support T n)
+    simpa only [planarWiener_zero,integral_const,probReal_univ,one_smul] using hh
+  refine ⟨Y,hYm,hYb,?_,hY,?_⟩
+  · exact tendsto_nhds_unique hI (by simpa only [hIn] using (tendsto_const_nhds (x := u 0)))
+  · filter_upwards [hY,hgood] with b hb hg
+    intro τ hτ hp hx
+    exact e.boundary_limit_of_uniform_tail T u b (Y b) N hN hb hg τ hτ hp hx
+
+end SmoothDomainExhaustion
+end SLEExactGauge
+
+end
+
+end OAI
diff --git a/lean/OAI/Probability/SLE/Geometry/HarmonicExitProbability.lean b/lean/OAI/Probability/SLE/Geometry/HarmonicExitProbability.lean
new file mode 100644
index 0000000000000000000000000000000000000000..0170a23eadaa87dcd1f4ef630c057730eb0a0e27
--- /dev/null
+++ b/lean/OAI/Probability/SLE/Geometry/HarmonicExitProbability.lean
@@ -0,0 +1,61 @@
+import OAI.Probability.SLE.Geometry.HarmonicExitLimit
+
+namespace OAI
+
+/-! Positive bounded harmonic terminal tests control finite-exit events
+without requiring measurability of the event's existential description. -/
+noncomputable section
+open Set Filter MeasureTheory ProbabilityTheory
+open scoped Topology NNReal ENNReal
+
+namespace SLEExactGauge
+open Target
+
+lemma terminal_threshold_measure_le {Ω : Type*} [MeasurableSpace Ω]
+    (P : Measure Ω) [IsFiniteMeasure P] (Y : Ω → ℝ) (hY : Integrable Y P)
+    (hpos : ∀ᵐ b ∂P, 0 ≤ Y b) (E : Set Ω) (a : ℝ) (ha : 0 ≤ a)
+    (hE : ∀ᵐ b ∂P, b∈E → a ≤ Y b) :
+    ENNReal.ofReal a*P E ≤ ENNReal.ofReal (∫ b, Y b ∂P) := by
+  have hh := mul_meas_ge_le_integral_of_nonneg hpos hY a
+  have hmarkov : ENNReal.ofReal a*P {b | a ≤ Y b} ≤ ENNReal.ofReal (∫ b, Y b ∂P) := by
+    have h := ENNReal.ofReal_le_ofReal hh
+    simpa only [ENNReal.ofReal_mul ha,measureReal_def,ENNReal.ofReal_toReal (measure_ne_top _ _)] using h
+  exact (mul_le_mul' le_rfl (measure_mono_ae hE)).trans hmarkov
+
+namespace SmoothDomainExhaustion
+variable {U : Set (ℝ×ℝ)} (e : SmoothDomainExhaustion U 0)
+
+include e in
+theorem nonnegative_harmonic_exit_bound
+    (W : WienerLaw) (hW : IsWiener W) (T : ℝ≥0) (hU : IsOpen U)
+    (u : ℝ×ℝ → ℝ) (hu : ContDiffOn ℝ (⊤ : ℕ∞) u U)
+    (hhar : ∀ z∈U, planarGenerator u z=0)
+    (C : ℝ≥0) (huC : ∀ z∈U, |u z|≤C) (hpos : ∀ z∈U, 0 ≤ u z)
+    (E : Set (Driver×Driver)) (a : ℝ) (ha : 0 ≤ a)
+    (hE : ∀ b∈E, ∃ τ : ℝ≥0, 0 < τ ∧ τ ≤ T ∧
+      (∀ t<τ, planarWiener t b∈U) ∧ planarWiener τ b∉U ∧
+      Tendsto (fun t => u (planarWiener t b)) (𝓝[<] τ) (𝓝 a)) :
+    ENNReal.ofReal a*(W.prod W) E ≤ ENNReal.ofReal (u 0) := by
+  let : IsProbabilityMeasure W := hW.isGaussianProcess.isProbabilityMeasure
+  obtain ⟨Y,hYm,hYb,hmean,hYconv,hYexit⟩ := e.harmonic_exit_limit W hW T hU u hu hhar C huC
+  have hYi : Integrable Y (W.prod W) := Integrable.of_bound hYm.aestronglyMeasurable C
+    (Eventually.of_forall fun b => by simpa only [Real.norm_eq_abs] using hYb b)
+  have hYpos : ∀ᵐ b ∂W.prod W, 0 ≤ Y b := by
+    filter_upwards [hYconv] with b hb
+    exact ge_of_tendsto hb (Eventually.of_forall fun n =>
+      hpos _ (e.stop_mem_domain T n b _ le_rfl))
+  have hevent : ∀ᵐ b ∂W.prod W, b∈E → a ≤ Y b := by
+    filter_upwards [hYexit] with b hb
+    intro hbe
+    obtain ⟨τ,hτ,hτT,hp,hx,hl⟩ := hE b hbe
+    let : NeBot (𝓝[<] τ) := nhdsLT_neBot_of_exists_lt ⟨0,hτ⟩
+    exact (tendsto_nhds_unique (hb τ hτT hp hx) hl).symm.le
+  simpa only [hmean] using terminal_threshold_measure_le (W.prod W) Y hYi hYpos E a ha hevent
+
+end SmoothDomainExhaustion
+
+end SLEExactGauge
+
+end
+
+end OAI
diff --git a/lean/OAI/Probability/SLE/Geometry/HarmonicLimitData.lean b/lean/OAI/Probability/SLE/Geometry/HarmonicLimitData.lean
new file mode 100644
index 0000000000000000000000000000000000000000..38a1565dcd720b3cb5dfc8850b0a59fd9f4728d6
--- /dev/null
+++ b/lean/OAI/Probability/SLE/Geometry/HarmonicLimitData.lean
@@ -0,0 +1,70 @@
+import OAI.Probability.SLE.Geometry.HarmonicPathMaximum
+
+namespace OAI
+
+/-! A bounded measurable terminal variable for each localized harmonic
+test, with the L1 error required in the full-path maximal estimate. -/
+noncomputable section
+open Set Filter MeasureTheory ProbabilityTheory
+open scoped Topology NNReal ENNReal
+
+namespace SLEExactGauge
+open Target
+namespace SmoothDomainExhaustion
+variable {U : Set (ℝ×ℝ)} (e : SmoothDomainExhaustion U 0)
+
+theorem harmonic_limit_data
+    (W : WienerLaw) (hW : IsWiener W) (T : ℝ≥0) (hU : IsOpen U)
+    (u : ℝ×ℝ → ℝ) (hu : ContDiffOn ℝ (⊤ : ℕ∞) u U)
+    (hhar : ∀ z∈U, planarGenerator u z=0)
+    (C : ℝ≥0) (huC : ∀ z∈U, |u z|≤C) :
+    ∃ Y : Driver×Driver → ℝ, Measurable Y ∧ (∀ b, |Y b|≤C) ∧
+      (∀ᵐ b ∂W.prod W, Tendsto (fun n => u (planarWiener (e.stop T n b) b)) atTop (𝓝 (Y b))) ∧
+      Tendsto (fun n => ∫ b, |u (planarWiener (e.stop T n b) b)-Y b| ∂W.prod W) atTop (𝓝 0) := by
+  let : IsProbabilityMeasure W := hW.isGaussianProcess.isProbabilityMeasure
+  let X (n : ℕ) (b : Driver×Driver) := u (planarWiener (e.stop T n b) b)
+  have hM := e.harmonic_stopped_martingale W hW T hU u hu hhar C huC
+  have hXb (n b) : |X n b|≤C := huC _ (e.stop_mem_domain T n b _ le_rfl)
+  have hXm (n) : Measurable (X n) := ((hM.1 n).mono ((e.stopFiltration T).le n)).measurable
+  have hLp (n) : eLpNorm (X n) 1 (W.prod W) ≤ C := by
+    have hb : ∀ᵐ b ∂W.prod W, ‖X n b‖≤C :=
+      Eventually.of_forall fun b => by simpa only [Real.norm_eq_abs] using hXb n b
+    simpa using eLpNorm_le_of_ae_bound (p := 1) (hXm n).aestronglyMeasurable hb
+  let L := (e.stopFiltration T).limitProcess X (W.prod W)
+  have hLm : Measurable L := Filtration.stronglyMeasurable_limit_process'.measurable
+  have hlim : ∀ᵐ b ∂W.prod W, Tendsto (fun n => X n b) atTop (𝓝 (L b)) :=
+    hM.submartingale.ae_tendsto_limitProcess hLp
+  let clip (v : ℝ) := max (-(C:ℝ)) (min (C:ℝ) v)
+  have hclip (n b) : clip (X n b)=X n b := by
+    dsimp only [clip]
+    rw [min_eq_right (abs_le.mp (hXb n b)).2,max_eq_right (abs_le.mp (hXb n b)).1]
+  let Y (b : Driver×Driver) := clip (L b)
+  have hYm : Measurable Y := measurable_const.max (measurable_const.min hLm)
+  have hYb (b) : |Y b|≤C := by
+    apply abs_le.mpr
+    exact ⟨le_max_left _ _,max_le (by linarith [C.coe_nonneg]) (min_le_left _ _)⟩
+  have hconv : ∀ᵐ b ∂W.prod W, Tendsto (fun n => X n b) atTop (𝓝 (Y b)) := by
+    filter_upwards [hlim] with b hb
+    have hclipcont : Continuous clip := continuous_const.max (continuous_const.min continuous_id)
+    have hh := hclipcont.continuousAt.tendsto.comp hb
+    change Tendsto (fun n => clip (X n b)) atTop (𝓝 (Y b)) at hh
+    simpa only [hclip] using hh
+  refine ⟨Y,hYm,hYb,hconv,?_⟩
+  have hh : Tendsto (fun n => ∫ b, |X n b-Y b| ∂W.prod W) atTop
+      (𝓝 (∫ _b : Driver×Driver, (0:ℝ) ∂W.prod W)) := by
+    apply tendsto_integral_of_dominated_convergence (fun _ => (2:ℝ)*C)
+      (fun n => ((hXm n).sub hYm).abs.aestronglyMeasurable) (integrable_const _)
+    · intro n
+      exact Eventually.of_forall fun b => by
+        rw [Real.norm_eq_abs,abs_abs]
+        exact (abs_sub _ _).trans (by linarith [hXb n b,hYb b])
+    · filter_upwards [hconv] with b hb
+      simpa only [Pi.sub_apply,sub_self,abs_zero] using (hb.sub_const (Y b)).abs
+  simpa only [integral_zero] using hh
+
+end SmoothDomainExhaustion
+end SLEExactGauge
+
+end
+
+end OAI
diff --git a/lean/OAI/Probability/SLE/Geometry/HarmonicMaximal.lean b/lean/OAI/Probability/SLE/Geometry/HarmonicMaximal.lean
new file mode 100644
index 0000000000000000000000000000000000000000..967e559896f1a62298a1ab5f6a04361135c7be31
--- /dev/null
+++ b/lean/OAI/Probability/SLE/Geometry/HarmonicMaximal.lean
@@ -0,0 +1,47 @@
+import OAI.Probability.SLE.Stochastic.PlanarHarmonicSampling
+
+namespace OAI
+
+/-! The finite maximal estimate used to control a harmonic test between
+two of the actual domain-localization stops. -/
+noncomputable section
+open Set Filter MeasureTheory ProbabilityTheory
+open scoped Topology NNReal ENNReal
+
+namespace SLEExactGauge
+
+lemma martingale_abs_sub_initial {Ω : Type*} [mΩ : MeasurableSpace Ω]
+    {μ : Measure Ω} [IsFiniteMeasure μ] {ℱ : Filtration ℕ mΩ}
+    {X : ℕ → Ω → ℝ} (hX : Martingale X ℱ μ) :
+    Submartingale (fun n b => |X n b-X 0 b|) ℱ μ := by
+  have hM : Martingale (fun n b => X n b-X 0 b) ℱ μ :=
+    hX.sub (martingale_const_fun ℱ μ (hX.1 0) (hX.integrable 0))
+  refine ⟨fun n => by simpa only [Real.norm_eq_abs] using (hM.1 n).norm,
+    fun i j hij => ?_, fun n => (hM.integrable n).abs⟩
+  filter_upwards [hM.2 i j hij,
+    abs_condExp_ae_le_condExp_abs (μ := μ) (m := ℱ i) (fun b => X j b-X 0 b)]
+    with b hb hle
+  change |μ[(fun b => X j b-X 0 b) | ℱ i] b| ≤
+    μ[(fun b => |X j b-X 0 b|) | ℱ i] b at hle
+  rwa [hb] at hle
+
+lemma martingale_finite_maximal {Ω : Type*} [mΩ : MeasurableSpace Ω]
+    {μ : Measure Ω} [IsFiniteMeasure μ] {ℱ : Filtration ℕ mΩ}
+    {X : ℕ → Ω → ℝ} (hX : Martingale X ℱ μ) (ε : ℝ≥0) (N : ℕ) :
+    ε * μ {b | ∃ k ≤ N, (ε:ℝ) ≤ |X k b-X 0 b|} ≤
+      ENNReal.ofReal (∫ b, |X N b-X 0 b| ∂μ) := by
+  have hm := martingale_abs_sub_initial hX
+  have hh := maximal_ineq hm (fun n b => abs_nonneg _) (ε := ε) N
+  have he : {b | (ε:ℝ) ≤ (Finset.range (N+1)).sup' Finset.nonempty_range_add_one
+      (fun k => |X k b-X 0 b|)}={b | ∃ k ≤ N, (ε:ℝ) ≤ |X k b-X 0 b|} := by
+    ext b
+    simp only [mem_ofPred_eq,Finset.le_sup'_iff,Finset.mem_range,Nat.lt_succ_iff]
+  rw [he] at hh
+  exact hh.trans (ENNReal.ofReal_le_ofReal (setIntegral_le_integral
+    (hm.integrable N) (Eventually.of_forall fun b => abs_nonneg _)))
+
+end SLEExactGauge
+
+end
+
+end OAI
diff --git a/lean/OAI/Probability/SLE/Geometry/HarmonicPathMaximum.lean b/lean/OAI/Probability/SLE/Geometry/HarmonicPathMaximum.lean
new file mode 100644
index 0000000000000000000000000000000000000000..a892dd88267e3f0626cb76d9ea3b23b9fe9152fd
--- /dev/null
+++ b/lean/OAI/Probability/SLE/Geometry/HarmonicPathMaximum.lean
@@ -0,0 +1,79 @@
+import OAI.Probability.SLE.Geometry.HarmonicStopSamples
+
+namespace OAI
+
+/-! Passing the finite mesh maximal estimate to all times between two
+compact localization stops. -/
+noncomputable section
+open Set Filter MeasureTheory ProbabilityTheory
+open scoped Topology NNReal ENNReal
+
+namespace SLEExactGauge
+open Target
+
+lemma mul_measure_le_of_eventually_mem {Ω : Type*} [MeasurableSpace Ω]
+    (μ : Measure Ω) (E : Set Ω) (A : ℕ → Set Ω) (c C : ℝ≥0∞)
+    (hEA : ∀ b∈E, ∀ᶠ n in atTop, b∈A n) (hA : ∀ n, c*μ (A n) ≤ C) :
+    c*μ E ≤ C := by
+  let B (n : ℕ) := {b | ∀ k, n ≤ k → b∈A k}
+  have hmono : Monotone B := fun i j hij b hb k hjk => hb k (hij.trans hjk)
+  have hsub : E ⊆ ⋃ n, B n := by
+    intro b hb
+    obtain ⟨n,hn⟩ := eventually_atTop.mp (hEA b hb)
+    exact mem_iUnion.mpr ⟨n,hn⟩
+  calc
+    c*μ E ≤ c*μ (⋃ n, B n) := by gcongr
+    _ = ⨆ n, c*μ (B n) := by rw [hmono.measure_iUnion,ENNReal.mul_iSup]
+    _ ≤ C := iSup_le fun n => le_trans (by
+      gcongr
+      exact fun b (hb : b∈B n) => hb n le_rfl) (hA n)
+
+theorem harmonic_path_maximal
+    (W : WienerLaw) (hW : IsWiener W) (U K : Set (ℝ×ℝ))
+    (hU : IsOpen U) (hK : IsCompact K) (hKU : K ⊆ U)
+    (u : ℝ×ℝ → ℝ) (hu : ContDiffOn ℝ (⊤ : ℕ∞) u U)
+    (hhar : ∀ z∈U, planarGenerator u z=0)
+    (σ τ : Driver×Driver → ℝ≥0)
+    (hσ : IsStoppingTime planarWienerFiltration (fun b => (σ b : WithTop ℝ≥0)))
+    (hτ : IsStoppingTime planarWienerFiltration (fun b => (τ b : WithTop ℝ≥0)))
+    (hστ : ∀ b, σ b ≤ τ b) (T : ℝ≥0) (hb : ∀ b, τ b ≤ T)
+    (hpath : ∀ b t, t ≤ τ b → planarWiener t b∈K) (ε : ℝ≥0) :
+    ε * (W.prod W) {b | ∃ t∈Icc (σ b) (τ b),
+      (ε:ℝ) < |u (planarWiener t b)-u (planarWiener (σ b) b)|} ≤
+      ENNReal.ofReal (∫ b, |u (planarWiener (τ b) b)-u (planarWiener (σ b) b)| ∂W.prod W) := by
+  obtain ⟨f,hf,_,_,he,_,_⟩ := exists_compact_smooth_extension U K hU hK hKU u hu
+  let A (n : ℕ) := {b | ∃ k ≤ stopGridIndex n T,
+    (ε:ℝ) ≤ |u (planarWiener (max (σ b) (min (stopGridTime n k) (τ b))) b)-
+      u (planarWiener (σ b) b)|}
+  apply mul_measure_le_of_eventually_mem (W.prod W) _ A ε _
+  · rintro b ⟨t,ht,hε⟩
+    let H (v : ℝ≥0) := f (planarWiener (max (σ b) (min v (τ b))) b)
+    have hH : Continuous H := hf.continuous.comp ((planarWiener_continuous b).comp
+      (continuous_const.max (continuous_id.min continuous_const)))
+    have heval (v : ℝ≥0) : H v=
+        u (planarWiener (max (σ b) (min v (τ b))) b) :=
+      (he _ (hpath b _ (max_le (hστ b) (min_le_right _ _)))).self_of_nhds
+    have hbase : H (σ b)=u (planarWiener (σ b) b) := by
+      rw [heval,min_eq_left (hστ b),max_self]
+    have htval : H t=u (planarWiener t b) := by
+      rw [heval,min_eq_left ht.2,max_eq_right ht.1]
+    have hlim := ((hH.continuousAt.tendsto.comp (stopGrid_tendsto t)).sub_const
+      (H (σ b))).abs
+    have hev : ∀ᶠ n in atTop, (ε:ℝ) < |H (stopGrid n t)-H (σ b)| :=
+      hlim.eventually (eventually_gt_nhds (by simpa only [htval,hbase] using hε))
+    filter_upwards [hev] with n hn
+    refine ⟨stopGridIndex n t,?_,?_⟩
+    · exact (stopGridIndex_le n _ _).mpr
+        ((ht.2.trans (hb b)).trans (stopGrid_bounds n T).1)
+    · rw [hbase,heval] at hn
+      simpa only [stopGrid] using hn.le
+  · intro n
+    exact harmonic_clipped_grid_maximal W hW U K hU hK hKU u hu hhar σ τ hσ hτ hστ
+      T hb hpath (stopGridTime n) (monotone_stopGridTime n)
+      (by simp [stopGridTime]) (stopGridIndex n T) (stopGrid_bounds n T).1 ε
+
+end SLEExactGauge
+
+end
+
+end OAI
diff --git a/lean/OAI/Probability/SLE/Geometry/HarmonicStopSamples.lean b/lean/OAI/Probability/SLE/Geometry/HarmonicStopSamples.lean
new file mode 100644
index 0000000000000000000000000000000000000000..0cf0d578a64718d49664c3f90b9c5e48498656a4
--- /dev/null
+++ b/lean/OAI/Probability/SLE/Geometry/HarmonicStopSamples.lean
@@ -0,0 +1,97 @@
+import OAI.Probability.SLE.Geometry.HarmonicMaximal
+
+namespace OAI
+
+/-! Ordered samples between compact domain stops retain their full stopped
+past. The resulting finite maximal bound controls all mesh observations. -/
+noncomputable section
+open Set Filter MeasureTheory ProbabilityTheory
+open scoped Topology NNReal ENNReal
+
+namespace SLEExactGauge
+open Target
+
+def orderedStopFiltration (ρ : ℕ → Driver×Driver → ℝ≥0)
+    (hρ : ∀ n, IsStoppingTime planarWienerFiltration (fun b => (ρ n b : WithTop ℝ≥0)))
+    (hmono : ∀ b, Monotone (fun n => ρ n b)) :
+    Filtration ℕ (inferInstance : MeasurableSpace (Driver×Driver)) where
+  seq n := (hρ n).measurableSpace
+  mono' := fun n m hnm => (hρ n).measurableSpace_mono (hρ m)
+    (fun b => WithTop.coe_le_coe.mpr (hmono b hnm))
+  le' n := (hρ n).measurableSpace_le
+
+theorem planar_local_harmonic_sampled_martingale
+    (W : WienerLaw) (hW : IsWiener W) (U K : Set (ℝ×ℝ))
+    (hU : IsOpen U) (hK : IsCompact K) (hKU : K ⊆ U)
+    (u : ℝ×ℝ → ℝ) (hu : ContDiffOn ℝ (⊤ : ℕ∞) u U)
+    (hhar : ∀ z∈U, planarGenerator u z=0)
+    (ρ : ℕ → Driver×Driver → ℝ≥0)
+    (hρ : ∀ n, IsStoppingTime planarWienerFiltration (fun b => (ρ n b : WithTop ℝ≥0)))
+    (hmono : ∀ b, Monotone (fun n => ρ n b))
+    (T : ℝ≥0) (hb : ∀ n b, ρ n b ≤ T)
+    (hpath : ∀ n b t, t ≤ ρ n b → planarWiener t b∈K) :
+    Martingale (fun n b => u (planarWiener (ρ n b) b))
+      (orderedStopFiltration ρ hρ hmono) (W.prod W) := by
+  let : IsProbabilityMeasure W := hW.isGaussianProcess.isProbabilityMeasure
+  obtain ⟨f,hf,hfc,_,he,_,_⟩ := exists_compact_smooth_extension U K hU hK hKU u hu
+  have hp := (Filtration.stronglyAdapted_natural (fun t =>
+    (measurable_planarWiener t).stronglyMeasurable)).isStronglyProgressive_of_continuous
+      planarWiener_continuous
+  have heq (n b) : f (planarWiener (ρ n b) b)=u (planarWiener (ρ n b) b) :=
+    (he _ (hpath n b _ le_rfl)).self_of_nhds
+  have ha : StronglyAdapted (orderedStopFiltration ρ hρ hmono)
+      (fun n b => u (planarWiener (ρ n b) b)) := by
+    intro n
+    have hm := hf.continuous.measurable.comp (measurable_stoppedValue hp (hρ n))
+    change Measurable[(orderedStopFiltration ρ hρ hmono) n]
+      (fun b => f (planarWiener (ρ n b) b)) at hm
+    simpa only [heq] using hm.stronglyMeasurable
+  obtain ⟨C,hC,_⟩ := compact_smooth_bounded_lipschitz f hf hfc
+  apply martingale_of_setIntegral_eq_succ ha
+  · intro n
+    apply Integrable.of_bound ((ha n).mono ((orderedStopFiltration ρ hρ hmono).le n)).aestronglyMeasurable C
+    exact Eventually.of_forall fun b => by
+      change ‖u (planarWiener (ρ n b) b)‖ ≤ C
+      rw [← heq n b]
+      exact hC _
+  · intro n A hA
+    exact planar_local_harmonic_optional_between W hW U K hU hK hKU u hu hhar
+      (ρ n) (ρ (n+1)) (hρ n) (hρ (n+1)) (fun b => hmono b (Nat.le_succ n))
+      T (hb (n+1)) A hA (hpath (n+1))
+
+theorem harmonic_clipped_grid_maximal
+    (W : WienerLaw) (hW : IsWiener W) (U K : Set (ℝ×ℝ))
+    (hU : IsOpen U) (hK : IsCompact K) (hKU : K ⊆ U)
+    (u : ℝ×ℝ → ℝ) (hu : ContDiffOn ℝ (⊤ : ℕ∞) u U)
+    (hhar : ∀ z∈U, planarGenerator u z=0)
+    (σ τ : Driver×Driver → ℝ≥0)
+    (hσ : IsStoppingTime planarWienerFiltration (fun b => (σ b : WithTop ℝ≥0)))
+    (hτ : IsStoppingTime planarWienerFiltration (fun b => (τ b : WithTop ℝ≥0)))
+    (hστ : ∀ b, σ b ≤ τ b) (T : ℝ≥0) (hb : ∀ b, τ b ≤ T)
+    (hpath : ∀ b t, t ≤ τ b → planarWiener t b∈K)
+    (q : ℕ → ℝ≥0) (hq : Monotone q) (hq0 : q 0=0)
+    (N : ℕ) (hqN : T ≤ q N) (ε : ℝ≥0) :
+    ε * (W.prod W) {b | ∃ k ≤ N,
+      (ε:ℝ) ≤ |u (planarWiener (max (σ b) (min (q k) (τ b))) b)-
+        u (planarWiener (σ b) b)|} ≤
+      ENNReal.ofReal (∫ b, |u (planarWiener (τ b) b)-u (planarWiener (σ b) b)| ∂W.prod W) := by
+  let : IsProbabilityMeasure W := hW.isGaussianProcess.isProbabilityMeasure
+  let ρ (n : ℕ) (b : Driver×Driver) := max (σ b) (min (τ b) (q n))
+  have hρ (n) : IsStoppingTime planarWienerFiltration (fun b => (ρ n b : WithTop ℝ≥0)) := by
+    simpa only [ρ,WithTop.coe_max,WithTop.coe_min] using hσ.max (hτ.min_const (q n))
+  have hm (b) : Monotone (fun n => ρ n b) :=
+    fun i j hij => max_le_max_left _ (min_le_min_left _ (hq hij))
+  have hle (n b) : ρ n b ≤ τ b := max_le (hστ b) (min_le_left _ _)
+  have hM := planar_local_harmonic_sampled_martingale W hW U K hU hK hKU u hu hhar
+    ρ hρ hm T (fun n b => (hle n b).trans (hb b))
+    (fun n b t ht => hpath b t (ht.trans (hle n b)))
+  have h0 (b) : ρ 0 b=σ b := by simp [ρ,hq0]
+  have hN (b) : ρ N b=τ b := by
+    simp only [ρ,min_eq_left ((hb b).trans hqN),max_eq_right (hστ b)]
+  simpa only [h0,hN,ρ,min_comm] using martingale_finite_maximal hM ε N
+
+end SLEExactGauge
+
+end
+
+end OAI
diff --git a/lean/OAI/Probability/SLE/Geometry/HarmonicTailMaximum.lean b/lean/OAI/Probability/SLE/Geometry/HarmonicTailMaximum.lean
new file mode 100644
index 0000000000000000000000000000000000000000..95725f0711fc6d41cf3d90ed67df02f379143458
--- /dev/null
+++ b/lean/OAI/Probability/SLE/Geometry/HarmonicTailMaximum.lean
@@ -0,0 +1,74 @@
+import OAI.Probability.SLE.Geometry.HarmonicLimitData
+
+namespace OAI
+
+/-! The maximal error after a compact localization stop is bounded by
+the L1 error to the bounded harmonic terminal variable. -/
+noncomputable section
+open Set Filter MeasureTheory ProbabilityTheory
+open scoped Topology NNReal ENNReal
+
+namespace SLEExactGauge
+open Target
+namespace SmoothDomainExhaustion
+variable {U : Set (ℝ×ℝ)} (e : SmoothDomainExhaustion U 0)
+
+def harmonicTailEvent (T : ℝ≥0) (u : ℝ×ℝ → ℝ) (n : ℕ) (ε : ℝ≥0) : Set (Driver×Driver) :=
+  {b | ∃ m : ℕ, ∃ t∈Icc (e.stop T n b) (e.stop T (n+m) b),
+    (ε:ℝ) < |u (planarWiener t b)-u (planarWiener (e.stop T n b) b)|}
+
+theorem harmonic_tail_maximal
+    (W : WienerLaw) (hW : IsWiener W) (T : ℝ≥0) (hU : IsOpen U)
+    (u : ℝ×ℝ → ℝ) (hu : ContDiffOn ℝ (⊤ : ℕ∞) u U)
+    (hhar : ∀ z∈U, planarGenerator u z=0)
+    (C : ℝ≥0) (huC : ∀ z∈U, |u z|≤C)
+    (Y : Driver×Driver → ℝ)
+    (hY : ∀ᵐ b ∂W.prod W,
+      Tendsto (fun n => u (planarWiener (e.stop T n b) b)) atTop (𝓝 (Y b)))
+    (n : ℕ) (ε : ℝ≥0) :
+    ε*(W.prod W) (e.harmonicTailEvent T u n ε) ≤
+      ENNReal.ofReal (∫ b, |Y b-u (planarWiener (e.stop T n b) b)| ∂W.prod W) := by
+  let : IsProbabilityMeasure W := hW.isGaussianProcess.isProbabilityMeasure
+  let X (j : ℕ) (b : Driver×Driver) := u (planarWiener (e.stop T j b) b)
+  have hM := e.harmonic_stopped_martingale W hW T hU u hu hhar C huC
+  have hXm (j) : Measurable (X j) := ((hM.1 j).mono ((e.stopFiltration T).le j)).measurable
+  have hXb (j b) : |X j b|≤C := huC _ (e.stop_mem_domain T j b _ le_rfl)
+  let A (m : ℕ) : Set (Driver×Driver) :=
+    {b | ∃ t∈Icc (e.stop T n b) (e.stop T (n+m) b), (ε:ℝ) < |u (planarWiener t b)-X n b|}
+  have hAm : Monotone A := by
+    intro i j hij b hb
+    obtain ⟨t,ht,hε⟩ := hb
+    exact ⟨t,⟨ht.1,ht.2.trans (e.stop_monotone T b (Nat.add_le_add_left hij n))⟩,hε⟩
+  have he : e.harmonicTailEvent T u n ε=⋃ m, A m := by
+    ext b
+    simp only [harmonicTailEvent,A,X,mem_iUnion,mem_ofPred_eq]
+  have hbound (m) : ε*(W.prod W) (A m) ≤
+      ENNReal.ofReal (∫ b, |X (n+m) b-X n b| ∂W.prod W) :=
+    harmonic_path_maximal W hW U (tsupport (e.cutoff (n+m))) hU
+      (e.compact (n+m)) (e.supported (n+m)) u hu hhar
+      (e.stop T n) (e.stop T (n+m)) (e.stop_stopping T n) (e.stop_stopping T (n+m))
+      (fun b => e.stop_monotone T b (Nat.le_add_right n m))
+      T (e.stop_le T (n+m)) (e.stop_mem_support T (n+m)) ε
+  have hright : Tendsto (fun m => ∫ b, |X (n+m) b-X n b| ∂W.prod W) atTop
+      (𝓝 (∫ b, |Y b-X n b| ∂W.prod W)) := by
+    apply tendsto_integral_of_dominated_convergence (fun _ => (2:ℝ)*C)
+      (fun m => ((hXm (n+m)).sub (hXm n)).abs.aestronglyMeasurable) (integrable_const _)
+    · intro m
+      exact Eventually.of_forall fun b => by
+        rw [Real.norm_eq_abs,abs_abs]
+        exact (abs_sub _ _).trans (by linarith [hXb (n+m) b,hXb n b])
+    · filter_upwards [hY] with b hb
+      have hh := hb.comp (tendsto_add_atTop_nat n)
+      simpa only [Function.comp_apply,Pi.sub_apply,X,Nat.add_comm] using (hh.sub_const (X n b)).abs
+  have hleft := (ENNReal.continuous_const_mul (ENNReal.coe_ne_top (r := ε))).continuousAt.tendsto.comp
+    (tendsto_measure_iUnion_atTop (μ := W.prod W) hAm)
+  rw [he]
+  exact le_of_tendsto_of_tendsto hleft (ENNReal.continuous_ofReal.continuousAt.tendsto.comp hright)
+    (Eventually.of_forall hbound)
+
+end SmoothDomainExhaustion
+end SLEExactGauge
+
+end
+
+end OAI
diff --git a/lean/OAI/Probability/SLE/Geometry/HarmonicUniformTails.lean b/lean/OAI/Probability/SLE/Geometry/HarmonicUniformTails.lean
new file mode 100644
index 0000000000000000000000000000000000000000..595953373124dd07a8463a9499a897ef6dbbae95
--- /dev/null
+++ b/lean/OAI/Probability/SLE/Geometry/HarmonicUniformTails.lean
@@ -0,0 +1,96 @@
+import OAI.Probability.SLE.Geometry.HarmonicTailMaximum
+
+namespace OAI
+
+/-! A single deterministic subsequence makes the harmonic oscillation
+uniform over every later compact localization interval. -/
+noncomputable section
+open Set Filter MeasureTheory ProbabilityTheory
+open scoped Topology NNReal ENNReal
+
+namespace SLEExactGauge
+open Target
+namespace SmoothDomainExhaustion
+variable {U : Set (ℝ×ℝ)} (e : SmoothDomainExhaustion U 0)
+
+theorem harmonic_uniform_tails
+    (W : WienerLaw) (hW : IsWiener W) (T : ℝ≥0) (hU : IsOpen U)
+    (u : ℝ×ℝ → ℝ) (hu : ContDiffOn ℝ (⊤ : ℕ∞) u U)
+    (hhar : ∀ z∈U, planarGenerator u z=0)
+    (C : ℝ≥0) (huC : ∀ z∈U, |u z|≤C)
+    (Y : Driver×Driver → ℝ)
+    (hY : ∀ᵐ b ∂W.prod W,
+      Tendsto (fun n => u (planarWiener (e.stop T n b) b)) atTop (𝓝 (Y b)))
+    (hE : Tendsto (fun n => ∫ b, |u (planarWiener (e.stop T n b) b)-Y b| ∂W.prod W)
+      atTop (𝓝 0)) :
+    ∃ N : ℕ → ℕ, (∀ j, j ≤ N j) ∧
+      ∀ᵐ b ∂W.prod W, ∀ᶠ j in atTop,
+        b∉e.harmonicTailEvent T u (N j) ((1/2:ℝ≥0)^j) := by
+  let ε (j : ℕ) : ℝ≥0 := (1/2)^j
+  have hε (j) : 0 < ε j := pow_pos (by norm_num) j
+  have hchoose (j : ℕ) : ∃ k : ℕ, j ≤ k ∧
+      (∫ b, |u (planarWiener (e.stop T k b) b)-Y b| ∂W.prod W) ≤ (ε j:ℝ)^2 := by
+    have hp : (0:ℝ) < (ε j:ℝ)^2 := sq_pos_of_pos (hε j)
+    obtain ⟨M,hM⟩ := eventually_atTop.mp (hE.eventually (eventually_lt_nhds hp))
+    exact ⟨max j M,le_max_left _ _,(hM _ (le_max_right _ _)).le⟩
+  choose N hNj hNE using hchoose
+  refine ⟨N,hNj,?_⟩
+  have hprob (j) : (W.prod W) (e.harmonicTailEvent T u (N j) (ε j)) ≤ (ε j:ℝ≥0∞) := by
+    have hh := e.harmonic_tail_maximal W hW T hU u hu hhar C huC Y hY (N j) (ε j)
+    have herr : (∫ b, |Y b-u (planarWiener (e.stop T (N j) b) b)| ∂W.prod W) ≤ (ε j:ℝ)^2 := by
+      simpa only [abs_sub_comm] using hNE j
+    have hmul : (ε j:ℝ≥0∞)*(W.prod W) (e.harmonicTailEvent T u (N j) (ε j)) ≤
+        (ε j:ℝ≥0∞)*(ε j:ℝ≥0∞) := by
+      calc
+        _ ≤ ENNReal.ofReal ((ε j:ℝ)^2) := hh.trans (ENNReal.ofReal_le_ofReal herr)
+        _ = _ := by rw [pow_two,ENNReal.ofReal_mul (ε j).coe_nonneg]; simp
+    exact (ENNReal.mul_le_mul_iff_right (ENNReal.coe_ne_zero.mpr (hε j).ne') ENNReal.coe_ne_top).mp hmul
+  have hsum : (∑' j, (ε j:ℝ≥0∞)) ≠ ∞ := by
+    simpa [ε,ENNReal.ofReal_pow] using summable_geometric_two.tsum_ofReal_ne_top
+  exact ae_eventually_notMem (ne_top_of_le_ne_top hsum (ENNReal.tsum_le_tsum hprob))
+
+theorem boundary_limit_of_uniform_tail
+    (T : ℝ≥0) (u : ℝ×ℝ → ℝ) (b : Driver×Driver) (Y : ℝ)
+    (N : ℕ → ℕ) (hN : ∀ j, j ≤ N j)
+    (hconv : Tendsto (fun n => u (planarWiener (e.stop T n b) b)) atTop (𝓝 Y))
+    (hgood : ∀ᶠ j in atTop, b∉e.harmonicTailEvent T u (N j) ((1/2:ℝ≥0)^j))
+    (τ : ℝ≥0) (hτT : τ ≤ T) (hpath : ∀ t<τ, planarWiener t b∈U)
+    (hexit : planarWiener τ b∉U) :
+    Tendsto (fun t => u (planarWiener t b)) (𝓝[<] τ) (𝓝 Y) := by
+  have hNt : Tendsto N atTop atTop := tendsto_atTop.2 fun a =>
+    eventually_atTop.2 ⟨a,fun j hj => hj.trans (hN j)⟩
+  have hsub := hconv.comp hNt
+  have hstop := e.stop_tendsto_finite_exit T τ hτT b hpath hexit
+  have hlt (n) : e.stop T n b < τ := by
+    have hle : e.stop T n b ≤ τ := ge_of_tendsto hstop (by
+      filter_upwards [eventually_ge_atTop n] with m hm
+      exact e.stop_monotone T b hm)
+    exact lt_of_le_of_ne hle (fun heq => hexit (heq ▸ e.stop_mem_domain T n b _ le_rfl))
+  have hε : Tendsto (fun j : ℕ => ((1/2:ℝ≥0)^j:ℝ)) atTop (𝓝 0) := by
+    simpa only [NNReal.coe_pow,NNReal.coe_div,NNReal.coe_one,NNReal.coe_ofNat] using
+      (tendsto_pow_atTop_nhds_zero_of_lt_one (by norm_num : (0:ℝ) ≤ 1/2) (by norm_num : (1/2:ℝ)<1))
+  apply Metric.tendsto_nhds.2
+  intro δ hδ
+  obtain ⟨j,hjg,hje,hjx⟩ := (hgood.and ((hε.eventually (eventually_lt_nhds (half_pos hδ))).and
+    (hsub.eventually (Metric.ball_mem_nhds Y (half_pos hδ))))).exists
+  have hjx' : |u (planarWiener (e.stop T (N j) b) b)-Y| < δ/2 := by
+    simpa only [Metric.mem_ball,Real.dist_eq,Function.comp_apply] using hjx
+  filter_upwards [self_mem_nhdsWithin,
+    nhdsWithin_le_nhds (Ioi_mem_nhds (hlt (N j)))] with t htτ htN
+  have ht : t < τ := htτ
+  obtain ⟨k,hk,hkt⟩ := ((eventually_ge_atTop (N j)).and
+    (hstop.eventually (eventually_gt_nhds ht))).exists
+  obtain ⟨m,rfl⟩ := Nat.exists_eq_add_of_le hk
+  have hsmall : |u (planarWiener t b)-u (planarWiener (e.stop T (N j) b) b)| ≤ ((1/2:ℝ≥0)^j:ℝ) := by
+    apply not_lt.mp
+    intro hbad
+    exact hjg ⟨m,t,⟨htN.le,hkt.le⟩,hbad⟩
+  rw [Real.dist_eq]
+  exact (abs_sub_le _ _ _).trans_lt (by linarith)
+
+end SmoothDomainExhaustion
+end SLEExactGauge
+
+end
+
+end OAI
diff --git a/lean/OAI/Probability/SLE/Geometry/HolomorphicAcrossReal.lean b/lean/OAI/Probability/SLE/Geometry/HolomorphicAcrossReal.lean
new file mode 100644
index 0000000000000000000000000000000000000000..a539a3eb434c32b360e93d6eb004e81543bd43a5
--- /dev/null
+++ b/lean/OAI/Probability/SLE/Geometry/HolomorphicAcrossReal.lean
@@ -0,0 +1,89 @@
+import OAI.Probability.SLE.Geometry.RectangleCauchyBoundary
+
+namespace OAI
+
+/-! A continuous function holomorphic on both sides of the real line is
+holomorphic across it, by splitting rectangular Cauchy integrals. -/
+noncomputable section
+open Complex Set
+open scoped Topology Interval
+
+namespace SLEExactGauge
+
+lemma rectangle_differentiable_off_real {U : Set ℂ} {f : ℂ → ℂ} {z w : ℂ}
+    (hf : ∀ a∈U, a.im≠0 → DifferentiableAt ℂ f a)
+    (hzw : Rectangle z w⊆U)
+    (hside : 0≤min z.im w.im ∨ max z.im w.im≤0) :
+    DifferentiableOn ℂ f
+      (Ioo (min z.re w.re) (max z.re w.re) ×ℂ Ioo (min z.im w.im) (max z.im w.im)) := by
+  intro a ha
+  have hac : a∈Rectangle z w := by
+    change a.re∈Icc (min z.re w.re) (max z.re w.re) ∧
+      a.im∈Icc (min z.im w.im) (max z.im w.im)
+    exact ⟨⟨ha.1.1.le,ha.1.2.le⟩,⟨ha.2.1.le,ha.2.2.le⟩⟩
+  have hane : a.im≠0 := by
+    rcases hside with h | h
+    · exact ne_of_gt (h.trans_lt ha.2.1)
+    · exact ne_of_lt (ha.2.2.trans_le h)
+  exact (hf a (hzw hac) hane).differentiableWithinAt
+
+lemma rectangle_wedge_zero_one_side {U : Set ℂ} {f : ℂ → ℂ}
+    (hC : ContinuousOn f U) (hf : ∀ a∈U, a.im≠0 → DifferentiableAt ℂ f a)
+    {z w : ℂ} (hzw : Rectangle z w⊆U)
+    (hside : 0≤min z.im w.im ∨ max z.im w.im≤0) :
+    wedgeIntegral z w f+wedgeIntegral w z f=0 :=
+  rectangle_wedge_eq_zero (hC.mono hzw) (rectangle_differentiable_off_real hf hzw hside)
+
+theorem differentiableOn_of_continuousOn_off_real {U : Set ℂ} {f : ℂ → ℂ}
+    (hU : IsOpen U) (hC : ContinuousOn f U)
+    (hf : ∀ a∈U, a.im≠0 → DifferentiableAt ℂ f a) : DifferentiableOn ℂ f U := by
+  apply (isConservativeOn_and_continuousOn_iff_isDifferentiableOn hU).mp
+  refine ⟨?_,hC⟩
+  have hord (z w : ℂ) (hzw : Rectangle z w⊆U) (hle : z.im≤w.im) :
+      wedgeIntegral z w f+wedgeIntegral w z f=0 := by
+    by_cases hz : 0≤z.im
+    · exact rectangle_wedge_zero_one_side hC hf hzw (Or.inl (by rwa [min_eq_left hle]))
+    by_cases hw : w.im≤0
+    · exact rectangle_wedge_zero_one_side hC hf hzw (Or.inr (by rwa [max_eq_right hle]))
+    have hzn : z.im≤0 := (lt_of_not_ge hz).le
+    have hwp : 0≤w.im := (lt_of_not_ge hw).le
+    let zc : ℂ := ⟨z.re,0⟩
+    let wc : ℂ := ⟨w.re,0⟩
+    have hlow : Rectangle z wc⊆Rectangle z w := by
+      intro a ha
+      change a.re∈uIcc z.re w.re ∧ a.im∈uIcc z.im 0 at ha
+      change a.re∈uIcc z.re w.re ∧ a.im∈uIcc z.im w.im
+      rw [uIcc_of_le hzn] at ha
+      rw [uIcc_of_le hle]
+      exact ⟨ha.1,⟨ha.2.1,ha.2.2.trans hwp⟩⟩
+    have hupp : Rectangle zc w⊆Rectangle z w := by
+      intro a ha
+      change a.re∈uIcc z.re w.re ∧ a.im∈uIcc 0 w.im at ha
+      change a.re∈uIcc z.re w.re ∧ a.im∈uIcc z.im w.im
+      rw [uIcc_of_le hwp] at ha
+      rw [uIcc_of_le hle]
+      exact ⟨ha.1,⟨hzn.trans ha.2.1,ha.2.2⟩⟩
+    have hl := rectangle_wedge_zero_one_side hC hf (hlow.trans hzw)
+      (Or.inr (show max z.im wc.im≤0 from by simpa only [wc,max_le_iff] using And.intro hzn le_rfl))
+    have hu := rectangle_wedge_zero_one_side hC hf (hupp.trans hzw)
+      (Or.inl (show 0≤min zc.im w.im from by simpa only [zc,le_min_iff] using And.intro le_rfl hwp))
+    have hcut : (0:ℝ)∈uIcc z.im w.im := by rw [uIcc_of_le hle]; exact ⟨hzn,hwp⟩
+    rw [rectangle_wedge_split_of_continuous (hC.mono hzw) hcut]
+    rw [hl,hu,add_zero]
+  intro z w hzw
+  rw [← add_eq_zero_iff_eq_neg]
+  by_cases hle : z.im≤w.im
+  · exact hord z w hzw hle
+  · have hrev : Rectangle w z⊆U := by
+      intro a ha
+      apply hzw
+      change a.re∈uIcc z.re w.re ∧ a.im∈uIcc z.im w.im
+      change a.re∈uIcc w.re z.re ∧ a.im∈uIcc w.im z.im at ha
+      simpa only [uIcc_comm] using ha
+    simpa only [add_comm] using hord w z hrev (le_of_not_ge hle)
+
+end SLEExactGauge
+
+end
+
+end OAI
diff --git a/lean/OAI/Probability/SLE/Geometry/HolomorphicAreaAverage.lean b/lean/OAI/Probability/SLE/Geometry/HolomorphicAreaAverage.lean
new file mode 100644
index 0000000000000000000000000000000000000000..661ee69dc9c9de7bdb5e91c068c1039da0cb4b28
--- /dev/null
+++ b/lean/OAI/Probability/SLE/Geometry/HolomorphicAreaAverage.lean
@@ -0,0 +1,86 @@
+import OAI.Probability.SLE.Loewner.InverseCircleArea
+import OAI.Probability.SLE.Geometry.AnalyticCircleSquare
+
+namespace OAI
+
+/-! Circle averages of signed holomorphic area densities. -/
+noncomputable section
+open Set Filter Metric Function Complex MeasureTheory InnerProductSpace Real
+open scoped Topology Laplacian ComplexConjugate
+
+namespace SLEExactGauge
+
+def holomorphicAreaDensity (f : ℂ → ℂ) (z : ℂ) : ℝ :=
+  2*(z*deriv f z*conj (f z)).re
+
+lemma holomorphic_flux_eq_area_average {f : ℂ → ℂ} {r : ℝ}
+    (hf : AnalyticOnNhd ℂ f (sphere (0:ℂ) |r|)) :
+    (∫ θ in -Real.pi..Real.pi, radialLaplacianFlux (fun z => ‖f z‖^2) (r,θ))=
+      2*Real.pi*circleAverage (holomorphicAreaDensity f) 0 r := by
+  rw [circleAverage_eq_neg_pi_integral,smul_eq_mul]
+  have hpoint (θ : ℝ) : radialLaplacianFlux (fun z => ‖f z‖^2) (r,θ)=
+      holomorphicAreaDensity f (polarPoint r θ) :=
+    holomorphic_radial_flux (hf _ (by
+      rw [polarPoint_eq_circleMap]; exact circleMap_mem_sphere' 0 r θ))
+  simp_rw [hpoint]
+  field_simp
+
+lemma inverse_chart_area_average {f C : ℂ → ℂ} {r : ℝ} (hr : 0<r)
+    (hC : AnalyticOnNhd ℂ C (closedBall (0:ℂ) r⁻¹))
+    (he : ∀ z∈sphere (0:ℂ) r, f z=z+C z⁻¹)
+    (hd : ∀ z∈sphere (0:ℂ) r, deriv f z=1-z⁻¹^2*deriv C z⁻¹) :
+    circleAverage (holomorphicAreaDensity f) 0 r=
+      2*r^2-circleAverage (holomorphicAreaDensity C) 0 r⁻¹ := by
+  let A (w : ℂ) := w*C w-w^2*deriv C w
+  let H (w : ℂ) := 2*r^2+2*r^2*(A w).re-holomorphicAreaDensity C w
+  have hCA : AnalyticOnNhd ℂ A (closedBall (0:ℂ) r⁻¹) :=
+    (analyticOnNhd_id.mul hC).sub ((analyticOnNhd_id.pow 2).mul hC.deriv)
+  have hAmean : circleAverage A 0 r⁻¹=0 := by
+    have hh := (show HarmonicOnNhd A (closedBall (0:ℂ) |r⁻¹|) from
+      fun z hz => (hCA z (by simpa only [abs_of_pos (inv_pos.mpr hr)] using hz)).harmonicAt).circleAverage_eq
+    simpa [A] using hh
+  have hAr : ContinuousOn (fun w => (A w).re) (sphere (0:ℂ) |r⁻¹|) :=
+    (Complex.continuous_re.comp_continuousOn hCA.continuousOn).mono
+      (by rw [abs_of_pos (inv_pos.mpr hr)]; exact sphere_subset_closedBall)
+  have hD : ContinuousOn (holomorphicAreaDensity C) (sphere (0:ℂ) |r⁻¹|) := by
+    have hc := hC.continuousOn.mono (sphere_subset_closedBall (x := (0:ℂ)) (ε := r⁻¹))
+    have hdc := hC.deriv.continuousOn.mono (sphere_subset_closedBall (x := (0:ℂ)) (ε := r⁻¹))
+    rw [abs_of_pos (inv_pos.mpr hr)]
+    exact (Complex.continuous_re.comp_continuousOn
+      ((continuousOn_id.mul hdc).mul (Complex.continuous_conj.comp_continuousOn hc))).const_mul 2
+  have hReA : circleAverage (fun w => (A w).re) 0 r⁻¹=0 := by
+    have hh := Complex.reCLM.circleAverage_comp_comm
+      ((hCA.continuousOn.mono (by rw [abs_of_pos (inv_pos.mpr hr)]; exact sphere_subset_closedBall)).circleIntegrable')
+    simpa only [Function.comp_def,Complex.reCLM_apply,hAmean,Complex.zero_re] using hh
+  calc
+    _ = circleAverage (fun z => H z⁻¹) 0 r := by
+      apply circleAverage_congr_sphere
+      intro z hz
+      have hzr : ‖z‖=r := by simpa only [abs_of_pos hr,mem_sphere,dist_zero_right] using hz
+      have hz' : z∈sphere (0:ℂ) r := by simpa only [abs_of_pos hr] using hz
+      have hz0 : z≠0 := norm_ne_zero_iff.mp (by rw [hzr]; exact hr.ne')
+      dsimp only [holomorphicAreaDensity]
+      rw [he z hz',hd z hz']
+      have halg : z*(1-z⁻¹^2*deriv C z⁻¹)=z-z⁻¹*deriv C z⁻¹ := by
+        field_simp
+      rw [halg,inverse_area_density_identity z (C z⁻¹) (deriv C z⁻¹) hz0,hzr]
+      rfl
+    _ = circleAverage H 0 r⁻¹ := circleAverage_inv_radius H r
+    _ = _ := by
+      dsimp only [H]
+      rw [circleAverage_fun_sub (f₁ := fun w => 2*r^2+2*r^2*(A w).re)
+        (f₂ := holomorphicAreaDensity C)
+        ((continuousOn_const.add (hAr.const_mul (2*r^2))).circleIntegrable') hD.circleIntegrable',
+        circleAverage_fun_add (f₁ := fun _ => 2*r^2) (f₂ := fun w => 2*r^2*(A w).re)
+          (circleIntegrable_const (2*r^2) 0 r⁻¹) (hAr.const_mul (2*r^2)).circleIntegrable']
+      have hm : circleAverage (fun w => 2*r^2*(A w).re) 0 r⁻¹=
+          2*r^2*circleAverage (fun w => (A w).re) 0 r⁻¹ := by
+        simpa only [smul_eq_mul] using (circleAverage_fun_smul (a := (2*r^2 : ℝ))
+          (f := fun w => (A w).re) (c := (0:ℂ)) (R := r⁻¹))
+      rw [circleAverage_const,hm,hReA,mul_zero,add_zero]
+
+end SLEExactGauge
+
+end
+
+end OAI
diff --git a/lean/OAI/Probability/SLE/Geometry/HolomorphicBoundaryAtoms.lean b/lean/OAI/Probability/SLE/Geometry/HolomorphicBoundaryAtoms.lean
new file mode 100644
index 0000000000000000000000000000000000000000..ea877fce25a3727d9139b2192241f769ee9927b7
--- /dev/null
+++ b/lean/OAI/Probability/SLE/Geometry/HolomorphicBoundaryAtoms.lean
@@ -0,0 +1,57 @@
+import OAI.Probability.SLE.Geometry.DiskPoissonPeaks
+import OAI.Probability.SLE.Geometry.HarmonicExitProbability
+
+namespace OAI
+
+/-! Positive harmonic peaks bound the probability that a finite domain
+exit maps to a prescribed point on the unit circle. -/
+noncomputable section
+open Set Filter MeasureTheory ProbabilityTheory Metric
+open scoped Topology NNReal ENNReal
+
+namespace SLEExactGauge
+open Target
+
+def planarDiskExitAtom (D : Set ℂ) (F : ℂ → ℂ) (w a : ℂ) (T : ℝ≥0) : Set (Driver×Driver) :=
+  {b | ∃ τ : ℝ≥0, 0 < τ ∧ τ ≤ T ∧
+    (∀ t<τ, w+Complex.equivRealProdCLM.symm (planarWiener t b)∈D) ∧
+    w+Complex.equivRealProdCLM.symm (planarWiener τ b)∉D ∧
+    Tendsto (fun t => F (w+Complex.equivRealProdCLM.symm (planarWiener t b))) (𝓝[<] τ) (𝓝 a)}
+
+theorem planarDiskExitAtom_peak_bound
+    (W : WienerLaw) (hW : IsWiener W) {D : Set ℂ} (hD : IsOpen D)
+    (w : ℂ) (hw : w∈D) {F : ℂ → ℂ} (hF : DifferentiableOn ℂ F D)
+    (hFD : MapsTo F D (ball 0 1)) (hF0 : F w=0)
+    (a : ℂ) (ha : ‖a‖=1) (T : ℝ≥0) (r : ℝ) (hr : 0 ≤ r) (hr1 : r<1) :
+    ENNReal.ofReal ((1+r)/(1-r))*(W.prod W) (planarDiskExitAtom D F w a T) ≤ 1 := by
+  let G := diskPeak a r ∘ F
+  have hG : DifferentiableOn ℂ G D := (diskPeak_differentiable ha hr hr1).comp hF hFD
+  have hU := planarTranslatedDomain_open hD w
+  have h0 : (0:ℝ×ℝ)∈planarTranslatedDomain D w := by simpa [planarTranslatedDomain] using hw
+  let e := Classical.choice (exists_smoothDomainExhaustion _ hU 0 h0)
+  obtain ⟨⟨hu,hhar⟩,_⟩ := holomorphic_planar_components hD hG w
+  let u (z : ℝ×ℝ) := (G (w+Complex.equivRealProdCLM.symm z)).re
+  have hC : 0 ≤ (1+r)/(1-r) := by positivity
+  let C : ℝ≥0 := ⟨(1+r)/(1-r),hC⟩
+  have hub (z) (hz : z∈planarTranslatedDomain D w) : |u z|≤C :=
+    (Complex.abs_re_le_norm _).trans
+      (diskPeak_norm_bound ha hr hr1 (mem_ball_zero_iff.mp (hFD hz)).le)
+  have hup (z) (hz : z∈planarTranslatedDomain D w) : 0 ≤ u z :=
+    diskPeak_re_nonnegative ha hr hr1 (mem_ball_zero_iff.mp (hFD hz)).le
+  have hh := e.nonnegative_harmonic_exit_bound W hW T hU u hu hhar C hub hup
+    (planarDiskExitAtom D F w a T) ((1+r)/(1-r)) hC (by
+      rintro b ⟨τ,hτ,hτT,hp,hx,hl⟩
+      refine ⟨τ,hτ,hτT,hp,hx,?_⟩
+      have hpeak := (diskPeak_continuousAt_boundary ha hr hr1 ha.le).tendsto.comp hl
+      have hreal := Complex.continuous_re.continuousAt.tendsto.comp hpeak
+      change Tendsto (fun t => (diskPeak a r (F (w+Complex.equivRealProdCLM.symm
+        (planarWiener t b)))).re) (𝓝[<] τ) (𝓝 (diskPeak a r a).re) at hreal
+      simpa only [u,G,Function.comp_apply,diskPeak_at_peak ha,Complex.ofReal_re] using hreal)
+  have hu0 : u 0=1 := by simp [u,G,hF0,diskPeak_zero ha]
+  simpa only [hu0,ENNReal.ofReal_one] using hh
+
+end SLEExactGauge
+
+end
+
+end OAI
diff --git a/lean/OAI/Probability/SLE/Geometry/HolomorphicDiskInterior.lean b/lean/OAI/Probability/SLE/Geometry/HolomorphicDiskInterior.lean
new file mode 100644
index 0000000000000000000000000000000000000000..985f3120cdda136d4b8e8a0c82afce27bceb5491
--- /dev/null
+++ b/lean/OAI/Probability/SLE/Geometry/HolomorphicDiskInterior.lean
@@ -0,0 +1,32 @@
+import Mathlib.Analysis.Complex.AbsMax
+
+namespace OAI
+
+/-! A bounded holomorphic disk-valued limit is interior everywhere once it
+is interior at one point of the connected domain. -/
+noncomputable section
+open Set Function
+
+namespace SLEExactGauge
+
+lemma holomorphic_disk_strict_of_point {D : Set ℂ} (hD : IsOpen D)
+    (hconn : IsPreconnected D) {F : ℂ → ℂ} (hF : DifferentiableOn ℂ F D)
+    (hbound : ∀ z∈D, ‖F z‖≤1) {a : ℂ} (ha : a∈D) (hFa : ‖F a‖<1) :
+    ∀ z∈D, ‖F z‖<1 := by
+  intro z hz
+  by_contra hnot
+  have he : ‖F z‖=1 := le_antisymm (hbound z hz) (le_of_not_gt hnot)
+  have hmax : IsMaxOn (norm ∘ F) D z := by
+    intro w hw
+    change ‖F w‖≤‖F z‖
+    rw [he]
+    exact hbound w hw
+  have hh := Complex.norm_eqOn_of_isPreconnected_of_isMaxOn hconn hD hF hz hmax ha
+  have hnorm : ‖F a‖=‖F z‖ := hh
+  exact hFa.ne (hnorm.trans he)
+
+end SLEExactGauge
+
+end
+
+end OAI
diff --git a/lean/OAI/Probability/SLE/Geometry/HolomorphicExitLimit.lean b/lean/OAI/Probability/SLE/Geometry/HolomorphicExitLimit.lean
new file mode 100644
index 0000000000000000000000000000000000000000..1ab85bcc86aa270dedd041ab04237124c28985c1
--- /dev/null
+++ b/lean/OAI/Probability/SLE/Geometry/HolomorphicExitLimit.lean
@@ -0,0 +1,49 @@
+import OAI.Probability.SLE.Geometry.HarmonicExitLimit
+import OAI.Probability.SLE.Stochastic.PlanarHolomorphicTests
+
+namespace OAI
+
+/-! A bounded holomorphic map has a genuine left limit at each finite
+exit of the original planar Wiener path from its open domain. -/
+noncomputable section
+open Set Filter MeasureTheory ProbabilityTheory
+open scoped Topology NNReal ENNReal
+
+namespace SLEExactGauge
+open Target
+
+theorem holomorphic_domain_exit_limit
+    (W : WienerLaw) (hW : IsWiener W) {D : Set ℂ} (hD : IsOpen D)
+    (w : ℂ) (hw : w∈D) {F : ℂ → ℂ} (hF : DifferentiableOn ℂ F D)
+    (T : ℝ≥0) (C : ℝ≥0) (hC : ∀ z∈D, ‖F z‖ ≤ C) :
+    ∀ᵐ b ∂W.prod W, ∀ τ : ℝ≥0, τ ≤ T →
+      (∀ t<τ, w+Complex.equivRealProdCLM.symm (planarWiener t b)∈D) →
+      w+Complex.equivRealProdCLM.symm (planarWiener τ b)∉D →
+      ∃ c : ℂ, Tendsto (fun t => F (w+Complex.equivRealProdCLM.symm (planarWiener t b)))
+        (𝓝[<] τ) (𝓝 c) := by
+  have hU := planarTranslatedDomain_open hD w
+  have h0 : (0:ℝ×ℝ)∈planarTranslatedDomain D w := by simpa [planarTranslatedDomain] using hw
+  let e := Classical.choice (exists_smoothDomainExhaustion _ hU 0 h0)
+  obtain ⟨⟨hr,hr0⟩,⟨hi,hi0⟩⟩ := holomorphic_planar_components hD hF w
+  obtain ⟨Yr,_,_,_,_,hYr⟩ := e.harmonic_exit_limit W hW T hU _ hr hr0 C
+    (fun z hz => (Complex.abs_re_le_norm _).trans (hC _ hz))
+  obtain ⟨Yi,_,_,_,_,hYi⟩ := e.harmonic_exit_limit W hW T hU _ hi hi0 C
+    (fun z hz => (Complex.abs_im_le_norm _).trans (hC _ hz))
+  filter_upwards [hYr,hYi] with b hb hi
+  intro τ hτ hp hx
+  have hrl := hb τ hτ hp hx
+  have hil := hi τ hτ hp hx
+  refine ⟨Complex.equivRealProdCLM.symm (Yr b,Yi b),?_⟩
+  have hh := Complex.equivRealProdCLM.symm.continuous.continuousAt.tendsto.comp
+    (hrl.prodMk_nhds hil)
+  change Tendsto (fun t => Complex.equivRealProdCLM.symm
+    ((F (w+Complex.equivRealProdCLM.symm (planarWiener t b))).re,
+     (F (w+Complex.equivRealProdCLM.symm (planarWiener t b))).im))
+    (𝓝[<] τ) (𝓝 (Complex.equivRealProdCLM.symm (Yr b,Yi b))) at hh
+  simpa only [Complex.equivRealProdCLM_symm_apply,Complex.re_add_im] using hh
+
+end SLEExactGauge
+
+end
+
+end OAI
diff --git a/lean/OAI/Probability/SLE/Geometry/HolomorphicFamilyCompactness.lean b/lean/OAI/Probability/SLE/Geometry/HolomorphicFamilyCompactness.lean
new file mode 100644
index 0000000000000000000000000000000000000000..509bc0892795ed1c0266d6fb991599fe3319f11a
--- /dev/null
+++ b/lean/OAI/Probability/SLE/Geometry/HolomorphicFamilyCompactness.lean
@@ -0,0 +1,63 @@
+import OAI.Probability.SLE.Geometry.HolomorphicFamilyEquicontinuity
+
+namespace OAI
+
+/-! Sequential compactness of locally bounded holomorphic half-plane
+families, with the ordinary compact-open topology. -/
+noncomputable section
+open Set Filter Metric Function
+open scoped Topology
+
+namespace SLEExactGauge
+
+local instance halfPlaneFamilyLocallyCompact : LocallyCompactSpace upperHalfPlane :=
+  isOpen_upperHalfPlane.locallyCompactSpace
+
+local instance halfPlaneUniformOnT2 :
+    T2Space (UniformOnFun upperHalfPlane ℂ {K | IsCompact K}) :=
+  UniformOnFun.t2Space_of_covering (by
+    apply eq_univ_iff_forall.mpr
+    intro z
+    exact mem_sUnion.mpr ⟨{z},isCompact_singleton,mem_singleton z⟩)
+
+lemma holomorphic_halfPlane_family_subsequence
+    (f : ℕ → ℂ → ℂ) (hf : ∀ n, DifferentiableOn ℂ (f n) upperHalfPlane)
+    (hb : ∀ K : Set ℂ, IsCompact K → K⊆upperHalfPlane →
+      ∃ C : ℝ, ∀ n, ∀ z∈K, ‖f n z‖≤C) :
+    ∃ (g : C(upperHalfPlane,ℂ)) (φ : ℕ → ℕ), StrictMono φ ∧
+      Tendsto (fun n => (⟨fun z => f (φ n) z,(hf (φ n)).continuousOn.domRestrict⟩ :
+        C(upperHalfPlane,ℂ))) atTop (𝓝 g) := by
+  let F : ℕ → C(upperHalfPlane,ℂ) :=
+    fun n => ⟨fun z => f n z,(hf n).continuousOn.domRestrict⟩
+  have hEq := holomorphic_halfPlane_family_equicontinuous f hf hb
+  have hES : Equicontinuous (fun (q : range F) (z : upperHalfPlane) => q.1 z) := by
+    intro z
+    apply Metric.equicontinuousAt_iff_right.mpr
+    intro ε hε
+    filter_upwards [Metric.equicontinuousAt_iff_right.mp (hEq z) ε hε] with w hw q
+    obtain ⟨n,hn⟩ := q.property
+    rw [← hn]
+    change dist (f n z.1) (f n w.1)<ε
+    exact hw n
+  have hcompact : IsCompact (closure (range F)) := by
+    apply ArzelaAscoli.isCompact_closure_of_isClosedEmbedding
+      (F := fun q : C(upperHalfPlane,ℂ) => (q : upperHalfPlane → ℂ))
+      (𝔖 := {K : Set upperHalfPlane | IsCompact K})
+      (fun _ h => h) ContinuousMap.isUniformEmbedding_toUniformOnFunIsCompact.isClosedEmbedding
+    · intro K _
+      exact hES.equicontinuousOn K
+    · intro K _ z _
+      obtain ⟨C,hC⟩ := hb {z.1} isCompact_singleton (singleton_subset_iff.mpr z.property)
+      refine ⟨closedBall (0:ℂ) (max C 0),isCompact_closedBall _ _,?_⟩
+      rintro _ ⟨n,rfl⟩
+      rw [mem_closedBall,dist_zero_right]
+      change ‖f n z.1‖ ≤ max C 0
+      exact (hC n z.1 (mem_singleton z.1)).trans (le_max_left _ _)
+  obtain ⟨g,_,φ,hφ,hconv⟩ := hcompact.tendsto_subseq (fun n => subset_closure (mem_range_self n))
+  exact ⟨g,φ,hφ,hconv⟩
+
+end SLEExactGauge
+
+end
+
+end OAI
diff --git a/lean/OAI/Probability/SLE/Geometry/HolomorphicFamilyEquicontinuity.lean b/lean/OAI/Probability/SLE/Geometry/HolomorphicFamilyEquicontinuity.lean
new file mode 100644
index 0000000000000000000000000000000000000000..19acca62a088b1b88f400d3c790bedbd8b9102fc
--- /dev/null
+++ b/lean/OAI/Probability/SLE/Geometry/HolomorphicFamilyEquicontinuity.lean
@@ -0,0 +1,57 @@
+import OAI.Probability.SLE.LoewnerCharts
+
+namespace OAI
+
+/-! Local compact bounds give a common continuity modulus for the
+holomorphic half-plane families used in the normal-family argument. -/
+noncomputable section
+open Set Filter Metric
+open scoped Topology
+
+namespace SLEExactGauge
+
+lemma holomorphic_halfPlane_family_equicontinuous
+    (f : ℕ → ℂ → ℂ) (hf : ∀ n, DifferentiableOn ℂ (f n) upperHalfPlane)
+    (hb : ∀ K : Set ℂ, IsCompact K → K⊆upperHalfPlane →
+      ∃ C : ℝ, ∀ n, ∀ z∈K, ‖f n z‖≤C) :
+    Equicontinuous (fun n (z : upperHalfPlane) => f n z) := by
+  intro x
+  obtain ⟨R,hR,hRH⟩ := Metric.nhds_basis_ball.mem_iff.mp (isOpen_upperHalfPlane.mem_nhds x.property)
+  let r := R/3
+  have hr : 0<r := by dsimp [r]; positivity
+  have hKH : closedBall x.1 (2*r) ⊆ upperHalfPlane := by
+    intro z hz
+    apply hRH
+    rw [mem_ball]
+    have hzr := mem_closedBall.mp hz
+    dsimp [r] at hzr
+    linarith
+  obtain ⟨C,hC⟩ := hb (closedBall x.1 (2*r)) (isCompact_closedBall _ _) hKH
+  have hder (n : ℕ) (z : ℂ) (hz : z∈ball x.1 r) : ‖deriv (f n) z‖≤C/r := by
+    have hball : closedBall z r ⊆ closedBall x.1 (2*r) := by
+      intro w hw
+      rw [mem_closedBall] at hw ⊢
+      have hzx := mem_ball.mp hz
+      have htri := dist_triangle w z x.1
+      linarith
+    rw [← Complex.cderiv_eq_deriv isOpen_upperHalfPlane (hf n) hr (hball.trans hKH)]
+    exact Complex.norm_cderiv_le hr (fun w hw => hC n w (hball (sphere_subset_closedBall hw)))
+  apply Metric.equicontinuousAt_of_continuity_modulus
+    (fun y : upperHalfPlane => (C/r)*dist x.1 y.1)
+  · have hc : Continuous (fun y : upperHalfPlane => (C/r)*dist x.1 y.1) := by fun_prop
+    simpa using hc.tendsto x
+  · have hn : {y : upperHalfPlane | y.1∈ball x.1 r} ∈ 𝓝 x :=
+      continuous_subtype_val.continuousAt.preimage_mem_nhds (ball_mem_nhds x.1 hr)
+    filter_upwards [hn] with y hy n
+    have hrH : ball x.1 r ⊆ upperHalfPlane :=
+      (ball_subset_ball (show r≤2*r by linarith)).trans (ball_subset_closedBall.trans hKH)
+    have h := (convex_ball x.1 r).norm_image_sub_le_of_norm_deriv_le
+      (fun z hz => (hf n).differentiableAt (isOpen_upperHalfPlane.mem_nhds (hrH hz)))
+      (hder n) (mem_ball_self hr) hy
+    simpa only [dist_eq_norm,norm_sub_rev] using h
+
+end SLEExactGauge
+
+end
+
+end OAI
diff --git a/lean/OAI/Probability/SLE/Geometry/HolomorphicRadialFlux.lean b/lean/OAI/Probability/SLE/Geometry/HolomorphicRadialFlux.lean
new file mode 100644
index 0000000000000000000000000000000000000000..13073e2ad7aee15269faf6c736a52ce7990f4730
--- /dev/null
+++ b/lean/OAI/Probability/SLE/Geometry/HolomorphicRadialFlux.lean
@@ -0,0 +1,37 @@
+import OAI.Probability.SLE.Geometry.CircleRadialFlux
+import OAI.Probability.SLE.Geometry.ConformalLaplacian
+
+namespace OAI
+
+/-! Complex-coordinate expression for the radial flux of a squared
+holomorphic norm. -/
+noncomputable section
+open Set Filter Metric Function Complex MeasureTheory InnerProductSpace Real
+open scoped Topology Laplacian ComplexConjugate
+
+namespace SLEExactGauge
+
+lemma holomorphic_radial_flux {f : ℂ → ℂ} {r θ : ℝ}
+    (hf : AnalyticAt ℂ f (polarPoint r θ)) :
+    radialLaplacianFlux (fun z => ‖f z‖^2) (r,θ)=
+      2*(polarPoint r θ*deriv f (polarPoint r θ)*conj (f (polarPoint r θ))).re := by
+  have hd : HasDerivAt (fun s => f (polarPoint s θ))
+      (circleMap 0 1 θ*deriv f (polarPoint r θ)) r := by
+    have hh := (hf.differentiableAt.restrictScalars ℝ).hasFDerivAt.comp_hasDerivAt r
+      (polarPoint_radial_hasDeriv r θ)
+    rwa [complex_fderiv_apply hf.differentiableAt] at hh
+  have hu : ContDiffAt ℝ 2 (fun z => ‖f z‖^2) (polarPoint r θ) :=
+    hf.contDiffAt.restrict_scalars ℝ |>.norm_sq ℝ
+  have he := (radial_partial_hasDeriv hu).unique hd.norm_sq
+  rw [radialLaplacianFlux,he,Complex.inner]
+  have hmul : (polarPoint r θ*deriv f (polarPoint r θ)*conj (f (polarPoint r θ))).re=
+      r*(circleMap 0 1 θ*deriv f (polarPoint r θ)*conj (f (polarPoint r θ))).re := by
+    simp only [polarPoint,smul_mul_assoc,Complex.smul_re,smul_eq_mul]
+  rw [hmul]
+  ring
+
+end SLEExactGauge
+
+end
+
+end OAI
diff --git a/lean/OAI/Probability/SLE/Geometry/HolomorphicStripSections.lean b/lean/OAI/Probability/SLE/Geometry/HolomorphicStripSections.lean
new file mode 100644
index 0000000000000000000000000000000000000000..9eb348fe4c95449989e41fdb94a9f989bb443c89
--- /dev/null
+++ b/lean/OAI/Probability/SLE/Geometry/HolomorphicStripSections.lean
@@ -0,0 +1,82 @@
+import OAI.Probability.SLE.Geometry.ComplexDirichletSlices
+
+namespace OAI
+
+/-! Low-energy angular sections of a holomorphic map on a logarithmic strip. -/
+noncomputable section
+open Set Filter Metric Function MeasureTheory
+open scoped Topology ENNReal
+
+namespace SLEExactGauge
+
+lemma holomorphic_angular_deriv_norm {f : ℂ → ℂ} {v θ : ℝ}
+    (hf : DifferentiableAt ℂ f ((v:ℂ)+(θ:ℂ)*Complex.I)) :
+    ‖deriv (fun s : ℝ => f ((v:ℂ)+(s:ℂ)*Complex.I)) θ‖ =
+      ‖deriv f ((v:ℂ)+(θ:ℂ)*Complex.I)‖ := by
+  have hp : HasDerivAt (fun s : ℝ => (v:ℂ)+(s:ℂ)*Complex.I) Complex.I θ := by
+    simpa using ((Complex.ofRealCLM.hasDerivAt (x := θ)).mul_const Complex.I).const_add (v:ℂ)
+  have hd := (hf.hasDerivAt.hasFDerivAt.restrictScalars ℝ).comp_hasDerivAt θ hp
+  change ‖deriv (f ∘ fun s : ℝ => (v:ℂ)+(s:ℂ)*Complex.I) θ‖ = _
+  rw [hd.deriv]
+  simp [ContinuousLinearMap.toSpanSingleton_apply]
+
+lemma exists_holomorphic_energy_section {f : ℂ → ℂ}
+    (hf : DifferentiableOn ℂ f {z | 0<z.im ∧ z.im<Real.pi}) (q : ℝ)
+    (he : (∫⁻ z in {z : ℂ | q<z.re ∧ z.re<q+1 ∧ 0<z.im ∧ z.im<Real.pi},
+      ENNReal.ofReal (‖deriv f z‖^2))<∞) :
+    ∃ v∈Ioo q (q+1),
+      MemLp (deriv (fun θ : ℝ => f ((v:ℂ)+(θ:ℂ)*Complex.I))) 2
+        (volume.restrict (Ioo 0 Real.pi)) ∧
+      (∫ θ in Ioo 0 Real.pi, ‖deriv (fun s : ℝ => f ((v:ℂ)+(s:ℂ)*Complex.I)) θ‖^2) ≤
+        ∫ z in {z : ℂ | q<z.re ∧ z.re<q+1 ∧ 0<z.im ∧ z.im<Real.pi}, ‖deriv f z‖^2 := by
+  let S : Set ℂ := {z | 0<z.im ∧ z.im<Real.pi}
+  let T : Set ℂ := {z | q<z.re ∧ z.re<q+1 ∧ 0<z.im ∧ z.im<Real.pi}
+  let J := Ioo q (q+1)
+  let K := Ioo (0:ℝ) Real.pi
+  let e := Complex.measurableEquivRealProd.symm
+  have hS : IsOpen S := (isOpen_lt continuous_const Complex.continuous_im).inter
+    (isOpen_lt Complex.continuous_im continuous_const)
+  have hT : IsOpen T := (isOpen_lt continuous_const Complex.continuous_re).inter
+    ((isOpen_lt Complex.continuous_re continuous_const).inter hS)
+  have hTS : T⊆S := fun _ hz => hz.2.2
+  have hpre : e ⁻¹' T=J ×ˢ K := by ext z; simp [e,T,J,K,and_assoc]
+  have hmp : MeasurePreserving e volume volume := Complex.volume_preserving_equiv_real_prod.symm _
+  have hgT := deriv_memLp_two_of_energy hT (hf.mono hTS) he
+  have hiT : IntegrableOn (fun z => ‖deriv f z‖^2) T := hgT.norm.integrable_sq
+  have hip : Integrable (fun p : ℝ×ℝ => ‖deriv f (e p)‖^2)
+      ((volume.restrict J).prod (volume.restrict K)) := by
+    rw [Measure.prod_restrict]
+    exact hpre ▸ (hmp.integrableOn_comp_preimage e.measurableEmbedding).mpr hiT
+  have hgm : AEStronglyMeasurable (fun p : ℝ×ℝ => deriv f (e p))
+      ((volume.restrict J).prod (volume.restrict K)) := by
+    rw [Measure.prod_restrict, ← hpre]
+    exact hgT.aestronglyMeasurable.comp_quasiMeasurePreserving
+      (hmp.quasiMeasurePreserving.restrict (fun _ hz => hz))
+  have hgp := (memLp_two_iff_integrable_sq_norm hgm).mpr hip
+  obtain ⟨v,hv,hvm,hve⟩ := exists_complex_energy_section (fun p => deriv f (e p)) q hgp
+  have hd (θ : ℝ) (hθ : θ∈K) : DifferentiableAt ℂ f ((v:ℂ)+(θ:ℂ)*Complex.I) := by
+    apply hf.differentiableAt (hS.mem_nhds ?_)
+    simpa [S,K] using hθ
+  have hnorm (θ : ℝ) (hθ : θ∈K) :
+      ‖deriv (fun s : ℝ => f ((v:ℂ)+(s:ℂ)*Complex.I)) θ‖ = ‖deriv f (e (v,θ))‖ := by
+    convert holomorphic_angular_deriv_norm (hd θ hθ) using 1
+    congr 2
+    apply Complex.ext <;> simp [e]
+  have hae : ∀ᵐ θ ∂volume.restrict K,
+      ‖deriv (fun s : ℝ => f ((v:ℂ)+(s:ℂ)*Complex.I)) θ‖ = ‖deriv f (e (v,θ))‖ :=
+    (ae_restrict_mem measurableSet_Ioo).mono (fun θ hθ => hnorm θ hθ)
+  refine ⟨v,hv,?_,?_⟩
+  · exact hvm.of_le (aestronglyMeasurable_deriv _ _) (hae.mono fun _ h => h.le)
+  · calc
+      _ = ∫ θ in K, ‖deriv f (e (v,θ))‖^2 := integral_congr_ae (hae.mono fun _ h => congrArg (·^2) h)
+      _ ≤ ∫ p, ‖deriv f (e p)‖^2 ∂((volume.restrict J).prod (volume.restrict K)) := hve
+      _ = ∫ z in T, ‖deriv f z‖^2 := by
+        rw [Measure.prod_restrict, ← hpre]
+        simpa only [Measure.volume_eq_prod] using
+          hmp.setIntegral_preimage_emb e.measurableEmbedding (fun z => ‖deriv f z‖^2) T
+
+end SLEExactGauge
+
+end
+
+end OAI
diff --git a/lean/OAI/Probability/SLE/Geometry/HyperbolicGuideCompactness.lean b/lean/OAI/Probability/SLE/Geometry/HyperbolicGuideCompactness.lean
new file mode 100644
index 0000000000000000000000000000000000000000..d5b1c6827bbf2d5760db9c1c072208fb1033ca37
--- /dev/null
+++ b/lean/OAI/Probability/SLE/Geometry/HyperbolicGuideCompactness.lean
@@ -0,0 +1,237 @@
+import Mathlib
+import OAI.Probability.SLE.AngularLaws
+
+namespace OAI
+
+/-!
+The hyperbolic confinement step in `es:guide-compactness`. A bound on the
+actual velocity divided by height controls the logarithm of height. A single
+normalized waypoint then gives compact containment and a common Euclidean
+Lipschitz bound on each fixed interval away from the tip.
+-/
+
+noncomputable section
+open Set Filter MeasureTheory Metric
+open scoped Topology NNReal
+
+namespace SLEExactGauge.HyperbolicGuideCompactness
+
+theorem log_height_lipschitz
+    {β : ℝ → ℂ} {δ T K : ℝ} (hK : 0 ≤ K)
+    (hD : ∀ t ∈ Icc δ T, DifferentiableAt ℝ β t)
+    (hH : ∀ t ∈ Icc δ T, 0 < (β t).im)
+    (hv : ∀ t ∈ Icc δ T, ‖deriv β t‖ ≤ K * (β t).im) :
+    LipschitzOnWith ⟨K, hK⟩ (fun t => Real.log (β t).im) (Icc δ T) := by
+  have hd (t : ℝ) (ht : t ∈ Icc δ T) :
+      HasDerivAt (fun u => Real.log (β u).im) ((deriv β t).im / (β t).im) t := by
+    have hh := Complex.imCLM.hasFDerivAt.comp_hasDerivAt t (hD t ht).hasDerivAt
+    have hi : HasDerivAt (fun u => (β u).im) (deriv β t).im t := by
+      simpa only [Function.comp_def, Complex.imCLM_apply] using hh
+    exact hi.log (hH t ht).ne'
+  apply Convex.lipschitzOnWith_of_nnnorm_hasDerivWithin_le (convex_Icc δ T)
+    (fun t ht => (hd t ht).hasDerivWithinAt)
+  intro t ht
+  change ‖(deriv β t).im / (β t).im‖ ≤ K
+  rw [Real.norm_eq_abs, abs_div, abs_of_pos (hH t ht)]
+  exact (div_le_iff₀ (hH t ht)).mpr ((Complex.abs_im_le_norm _).trans (hv t ht))
+
+lemma interval_dist_le_width {δ T s t : ℝ} (hs : s ∈ Icc δ T) (ht : t ∈ Icc δ T) :
+    dist s t ≤ T - δ := by
+  rw [Real.dist_eq]
+  exact abs_le.mpr ⟨by linarith [hs.1, hs.2, ht.1, ht.2],
+    by linarith [hs.1, hs.2, ht.1, ht.2]⟩
+
+/-- Exponential upper and lower height bounds follow directly from the
+log-height derivative estimate, without assuming a geometric confinement
+result. -/
+theorem height_bounds_from_waypoint
+    {β : ℝ → ℂ} {δ T tw K s : ℝ} (hK : 0 ≤ K) (hs : 0 < s)
+    (htw : tw ∈ Icc δ T)
+    (hD : ∀ t ∈ Icc δ T, DifferentiableAt ℝ β t)
+    (hH : ∀ t ∈ Icc δ T, 0 < (β t).im)
+    (hv : ∀ t ∈ Icc δ T, ‖deriv β t‖ ≤ K * (β t).im)
+    (hway : ‖β tw‖ = 1) (hangle : s ≤ (β tw).im) :
+    ∀ t ∈ Icc δ T,
+      s * Real.exp (-K * (T - δ)) ≤ (β t).im ∧
+      (β t).im ≤ Real.exp (K * (T - δ)) := by
+  have hL := log_height_lipschitz hK hD hH hv
+  have hlogway : Real.log (β tw).im ≤ 0 :=
+    Real.log_nonpos (hH tw htw).le ((Complex.im_le_norm _).trans_eq hway)
+  have hlogs : Real.log s ≤ Real.log (β tw).im := Real.log_le_log hs hangle
+  intro t ht
+  have hdist := interval_dist_le_width ht htw
+  have hh := hL.dist_le_mul t ht tw htw
+  change dist (Real.log (β t).im) (Real.log (β tw).im) ≤ K * dist t tw at hh
+  have hh' := hh.trans (mul_le_mul_of_nonneg_left hdist hK)
+  rw [Real.dist_eq] at hh'
+  have hlo : Real.log s + (-K * (T - δ)) ≤ Real.log (β t).im := by
+    have hab := (abs_le.mp hh').1
+    nlinarith
+  have hup : Real.log (β t).im ≤ K * (T - δ) := by
+    have hab := (abs_le.mp hh').2
+    linarith
+  constructor
+  · calc
+      s * Real.exp (-K * (T - δ)) = Real.exp (Real.log s + (-K * (T - δ))) := by
+        rw [Real.exp_add, Real.exp_log hs]
+      _ ≤ Real.exp (Real.log (β t).im) := Real.exp_le_exp.mpr hlo
+      _ = (β t).im := Real.exp_log (hH t ht)
+  · simpa only [Real.exp_log (hH t ht)] using Real.exp_le_exp.mpr hup
+
+def speedBound (K δ T : ℝ) : ℝ := K * Real.exp (K * (T - δ))
+
+def radiusBound (K δ T : ℝ) : ℝ := 1 + speedBound K δ T * (T - δ)
+
+theorem euclidean_lipschitz_from_waypoint
+    {β : ℝ → ℂ} {δ T tw K s : ℝ} (hK : 0 ≤ K) (hs : 0 < s)
+    (htw : tw ∈ Icc δ T)
+    (hD : ∀ t ∈ Icc δ T, DifferentiableAt ℝ β t)
+    (hH : ∀ t ∈ Icc δ T, 0 < (β t).im)
+    (hv : ∀ t ∈ Icc δ T, ‖deriv β t‖ ≤ K * (β t).im)
+    (hway : ‖β tw‖ = 1) (hangle : s ≤ (β tw).im) :
+    LipschitzOnWith ⟨speedBound K δ T, mul_nonneg hK (Real.exp_pos _).le⟩
+      β (Icc δ T) := by
+  have hheight := height_bounds_from_waypoint hK hs htw hD hH hv hway hangle
+  apply Convex.lipschitzOnWith_of_nnnorm_deriv_le hD _ (convex_Icc δ T)
+  intro t ht
+  change ‖deriv β t‖ ≤ speedBound K δ T
+  exact (hv t ht).trans (mul_le_mul_of_nonneg_left (hheight t ht).2 hK)
+
+theorem norm_bound_from_waypoint
+    {β : ℝ → ℂ} {δ T tw K s : ℝ} (hK : 0 ≤ K) (hs : 0 < s)
+    (htw : tw ∈ Icc δ T)
+    (hD : ∀ t ∈ Icc δ T, DifferentiableAt ℝ β t)
+    (hH : ∀ t ∈ Icc δ T, 0 < (β t).im)
+    (hv : ∀ t ∈ Icc δ T, ‖deriv β t‖ ≤ K * (β t).im)
+    (hway : ‖β tw‖ = 1) (hangle : s ≤ (β tw).im) :
+    ∀ t ∈ Icc δ T, ‖β t‖ ≤ radiusBound K δ T := by
+  have hL := euclidean_lipschitz_from_waypoint hK hs htw hD hH hv hway hangle
+  intro t ht
+  have hh := hL.dist_le_mul t ht tw htw
+  have hsB : 0 ≤ speedBound K δ T := mul_nonneg hK (Real.exp_pos _).le
+  have hdist := hh.trans (mul_le_mul_of_nonneg_left (interval_dist_le_width ht htw) hsB)
+  rw [dist_eq_norm] at hdist
+  change ‖β t - β tw‖ ≤ speedBound K δ T * (T - δ) at hdist
+  have hn := norm_le_insert' (β t) (β tw)
+  rw [hway] at hn
+  exact hn.trans (by dsimp [radiusBound]; linarith)
+
+/-- The common compact set obtained from the actual derivative estimates. -/
+def confinementSet (K s δ T : ℝ) : Set ℂ :=
+  closedBall 0 (radiusBound K δ T) ∩ {z | s * Real.exp (-K * (T - δ)) ≤ z.im}
+
+theorem confinementSet_compact (K s δ T : ℝ) : IsCompact (confinementSet K s δ T) :=
+  (isCompact_closedBall _ _).inter_right (isClosed_le continuous_const Complex.continuous_im)
+
+theorem confinementSet_subset_halfPlane {K s δ T : ℝ} (hs : 0 < s) :
+    confinementSet K s δ T ⊆ {z : ℂ | 0 < z.im} := by
+  intro z hz
+  exact (mul_pos hs (Real.exp_pos _)).trans_le hz.2
+
+/-- A normalized family with a common hyperbolic-speed bound is uniformly
+equicontinuous and remains in one compact subset of the upper half-plane. -/
+theorem family_compact_containment_equicontinuity
+    (β : ℕ → ℝ → ℂ) {δ T tw K s : ℝ} (hK : 0 ≤ K) (hs : 0 < s)
+    (htw : tw ∈ Icc δ T)
+    (hD : ∀ n t, t ∈ Icc δ T → DifferentiableAt ℝ (β n) t)
+    (hH : ∀ n t, t ∈ Icc δ T → 0 < (β n t).im)
+    (hv : ∀ n t, t ∈ Icc δ T → ‖deriv (β n) t‖ ≤ K * (β n t).im)
+    (hway : ∀ n, ‖β n tw‖ = 1) (hangle : ∀ n, s ≤ (β n tw).im) :
+    IsCompact (confinementSet K s δ T) ∧
+    confinementSet K s δ T ⊆ {z : ℂ | 0 < z.im} ∧
+    (∀ n, MapsTo (β n) (Icc δ T) (confinementSet K s δ T)) ∧
+    UniformEquicontinuousOn β (Icc δ T) := by
+  have hL (n : ℕ) := euclidean_lipschitz_from_waypoint hK hs htw
+    (hD n) (hH n) (hv n) (hway n) (hangle n)
+  refine ⟨confinementSet_compact K s δ T, confinementSet_subset_halfPlane hs, ?_,
+    LipschitzOnWith.uniformEquicontinuousOn β _ hL⟩
+  intro n t ht
+  refine ⟨?_, (height_bounds_from_waypoint hK hs htw
+    (hD n) (hH n) (hv n) (hway n) (hangle n) t ht).1⟩
+  simpa only [mem_closedBall, dist_zero_right] using
+    norm_bound_from_waypoint hK hs htw (hD n) (hH n) (hv n) (hway n) (hangle n) t ht
+
+/-- A univalent inverse chart on a physical clearance ball has derivative
+bounded by its height. The omitted point is the real part of its center value. -/
+theorem inverse_chart_derivative_bound
+    {g : ℂ → ℂ} {z : ℂ} {r : ℝ} (hr : 0 < r)
+    (hd : DifferentiableOn ℂ g (ball z r)) (hi : InjOn g (ball z r))
+    (hH : MapsTo g (ball z r) {w : ℂ | 0 < w.im}) :
+    ‖deriv g z‖ ≤ ((128 * Real.pi) / r) * (g z).im := by
+  have hzH : 0 < (g z).im := hH (mem_ball_self hr)
+  have hnot : ((g z).re : ℂ) ∉ g '' ball z r := by
+    rintro ⟨w, hw, he⟩
+    have hh : 0 < (g w).im := hH hw
+    rw [he] at hh
+    simp only [Complex.ofReal_im, lt_self_iff_false] at hh
+  have hh := univalent_omitted_value_bound_ball hr hd hi ((g z).re : ℂ) hnot
+  have hvalue : g z - ((g z).re : ℂ) = ((g z).im : ℂ) * Complex.I := by
+    apply Complex.ext <;> simp
+  have hn : ‖g z - ((g z).re : ℂ)‖ = (g z).im := by
+    rw [hvalue, norm_mul, Complex.norm_real, Real.norm_eq_abs, abs_of_pos hzH,
+      Complex.norm_I, mul_one]
+  rw [hn] at hh
+  calc
+    ‖deriv g z‖ ≤ ((128 * Real.pi) * (g z).im) / r :=
+      (le_div_iff₀ hr).mpr (by simpa only [mul_comm] using hh)
+    _ = _ := by ring
+
+/-- Actual composition with a physical guide converts clearance and bounded
+physical speed into the hyperbolic-speed estimate used above. -/
+theorem inverse_guide_composition_bound
+    {g : ℂ → ℂ} {α : ℝ → ℂ} {t r V : ℝ} (hr : 0 < r)
+    (hg : DifferentiableOn ℂ g (ball (α t) r)) (hgi : InjOn g (ball (α t) r))
+    (hgH : MapsTo g (ball (α t) r) {w : ℂ | 0 < w.im})
+    (hα : DifferentiableAt ℝ α t) (hv : ‖deriv α t‖ ≤ V) :
+    DifferentiableAt ℝ (g ∘ α) t ∧
+      ‖deriv (g ∘ α) t‖ ≤ ((128 * Real.pi * V) / r) * (g (α t)).im := by
+  have hgd : DifferentiableAt ℂ g (α t) :=
+    hg.differentiableAt (isOpen_ball.mem_nhds (mem_ball_self hr))
+  have hcomp := (hgd.restrictScalars ℝ).hasFDerivAt.comp_hasDerivAt t hα.hasDerivAt
+  refine ⟨hcomp.differentiableAt, ?_⟩
+  have hval : (fderiv ℝ g (α t)) (deriv α t) = deriv α t * deriv g (α t) := by
+    rw [hgd.fderiv_restrictScalars (𝕜 := ℝ)]
+    change (fderiv ℂ g (α t)) (deriv α t) = _
+    rw [fderiv_eq_smul_deriv, smul_eq_mul]
+  have hnorm : ‖deriv (g ∘ α) t‖ = ‖deriv g (α t)‖ * ‖deriv α t‖ := by
+    rw [hcomp.deriv, hval, norm_mul, mul_comm]
+  have hh := inverse_chart_derivative_bound hr hg hgi hgH
+  have hheight : 0 < (g (α t)).im := hgH (mem_ball_self hr)
+  rw [hnorm]
+  calc
+    ‖deriv g (α t)‖ * ‖deriv α t‖ ≤
+        (((128 * Real.pi) / r) * (g (α t)).im) * V :=
+      mul_le_mul hh hv (norm_nonneg _) (by positivity)
+    _ = _ := by ring
+
+/-- The family compactness conclusion with its hyperbolic-speed hypothesis
+fully discharged by actual inverse charts and physical clearance balls. -/
+theorem inverse_guide_family_compactness
+    (g : ℕ → ℂ → ℂ) (α : ℕ → ℝ → ℂ) {δ T tw r V s : ℝ}
+    (hr : 0 < r) (hV : 0 ≤ V) (hs : 0 < s) (htw : tw ∈ Icc δ T)
+    (hg : ∀ n t, t ∈ Icc δ T → DifferentiableOn ℂ (g n) (ball (α n t) r))
+    (hgi : ∀ n t, t ∈ Icc δ T → InjOn (g n) (ball (α n t) r))
+    (hgH : ∀ n t, t ∈ Icc δ T → MapsTo (g n) (ball (α n t) r) {w : ℂ | 0 < w.im})
+    (hα : ∀ n t, t ∈ Icc δ T → DifferentiableAt ℝ (α n) t)
+    (hv : ∀ n t, t ∈ Icc δ T → ‖deriv (α n) t‖ ≤ V)
+    (hway : ∀ n, ‖g n (α n tw)‖ = 1)
+    (hangle : ∀ n, s ≤ (g n (α n tw)).im) :
+    ∃ Q : Set ℂ, IsCompact Q ∧ Q ⊆ {z : ℂ | 0 < z.im} ∧
+      (∀ n, MapsTo (g n ∘ α n) (Icc δ T) Q) ∧
+      UniformEquicontinuousOn (fun n => g n ∘ α n) (Icc δ T) := by
+  let K := (128 * Real.pi * V) / r
+  have hK : 0 ≤ K := by dsimp [K]; positivity
+  have hcomp n t (ht : t ∈ Icc δ T) :=
+    inverse_guide_composition_bound hr (hg n t ht) (hgi n t ht) (hgH n t ht)
+      (hα n t ht) (hv n t ht)
+  have hheight n t (ht : t ∈ Icc δ T) : 0 < ((g n ∘ α n) t).im :=
+    hgH n t ht (mem_ball_self hr)
+  exact ⟨confinementSet K s δ T,
+    family_compact_containment_equicontinuity (fun n => g n ∘ α n) hK hs htw
+      (fun n t ht => (hcomp n t ht).1) hheight (fun n t ht => (hcomp n t ht).2) hway hangle⟩
+
+end SLEExactGauge.HyperbolicGuideCompactness
+
+end
+
+end OAI
diff --git a/lean/OAI/Probability/SLE/Geometry/InteriorFluxBound.lean b/lean/OAI/Probability/SLE/Geometry/InteriorFluxBound.lean
new file mode 100644
index 0000000000000000000000000000000000000000..2f0367ff04ca40e5d1fef95eaf5d0838c7c26d89
--- /dev/null
+++ b/lean/OAI/Probability/SLE/Geometry/InteriorFluxBound.lean
@@ -0,0 +1,77 @@
+import OAI.Probability.SLE.Geometry.CircleRadialFlux
+import OAI.Probability.SLE.Geometry.AnnulusPolarIntegral
+
+namespace OAI
+
+/-! A lower bound on circle averages of a Laplacian integrates to a
+quadratic lower bound on boundary flux. -/
+noncomputable section
+open Set Filter Metric Function Complex MeasureTheory InnerProductSpace Real
+open scoped Topology Laplacian
+
+namespace SLEExactGauge
+
+lemma radial_flux_ge_of_circle_laplacian {u : ℂ → ℝ} {R C : ℝ} (hR : 0<R)
+    (hu : ∀ z∈closedBall (0:ℂ) R, ContDiffAt ℝ 2 u z)
+    (havg : ∀ r∈Icc 0 R, C≤circleAverage (Δ u) 0 r) :
+    Real.pi*C*R^2≤∫ θ in -Real.pi..Real.pi, radialLaplacianFlux u (R,θ) := by
+  let F (r : ℝ) := ∫ θ in -Real.pi..Real.pi, radialLaplacianFlux u (r,θ)
+  let G (r : ℝ) := ∫ θ in -Real.pi..Real.pi, r*(Δ u) (polarPoint r θ)
+  have hGc : ContinuousOn G (Icc 0 R) := by
+    have hc : ContinuousOn (Δ u) {z : ℂ | ‖z-(0:ℂ)‖∈Icc 0 R} := by
+      intro z hz
+      exact (plane_laplacian_continuousAt (hu z (by
+        rw [mem_closedBall,dist_eq_norm]; exact hz.2))).continuousWithinAt
+    have hh := hc.circleAverage (fun r hr => hr.1)
+    apply ((continuousOn_const.mul continuousOn_id).mul hh).congr
+    intro r _
+    exact polar_integral_eq_circleAverage (Δ u) r
+  have hlower {a : ℝ} (ha : 0<a) (haR : a≤R) :
+      Real.pi*C*(R^2-a^2)≤F R-F a := by
+    have hiG : IntervalIntegrable G volume a R :=
+      (hGc.mono (Icc_subset_Icc ha.le le_rfl)).intervalIntegrable_of_Icc haR
+    have hil : IntervalIntegrable (fun r : ℝ => 2*Real.pi*C*r) volume a R := by
+      exact (continuous_const.mul continuous_id).intervalIntegrable _ _
+    have hib := intervalIntegral.integral_mono_on haR hil hiG (fun r hr => by
+      dsimp only [G]
+      rw [polar_integral_eq_circleAverage]
+      have hh := mul_le_mul_of_nonneg_left (havg r ⟨ha.le.trans hr.1,hr.2⟩)
+        (mul_nonneg (by positivity : 0≤2*Real.pi) (ha.le.trans hr.1))
+      nlinarith only [hh])
+    have hprimitive (r : ℝ) :
+        HasDerivAt (fun r : ℝ => Real.pi*C*r^2) (2*Real.pi*C*r) r := by
+      convert! (hasDerivAt_pow 2 r).const_mul (Real.pi*C) using 1; ring
+    have heil : (∫ r in a..R, 2*Real.pi*C*r)=Real.pi*C*(R^2-a^2) := by
+      rw [intervalIntegral.integral_eq_sub_of_hasDerivAt (fun r _ => hprimitive r) hil]
+      ring
+    have heig : (∫ r in a..R, G r)=F R-F a :=
+      annulus_laplacian_flux ha haR (fun z _ hzR => hu z (by
+        rw [mem_closedBall,dist_zero_right]; exact hzR))
+    rwa [heil,heig] at hib
+  let a (n : ℕ) := R*greenInner n
+  have han (n : ℕ) : a n∈Ioc 0 R := by
+    constructor
+    · exact mul_pos hR (greenInner_pos n)
+    · have hh := mul_le_mul_of_nonneg_left (greenInner_le_half n) hR.le
+      dsimp only [a]
+      linarith
+  have hat : Tendsto a atTop (𝓝 0) := by
+    simpa only [a,mul_zero] using greenInner_tendsto.const_mul R
+  have haT : Tendsto a atTop (𝓝[Icc 0 R] 0) :=
+    tendsto_nhdsWithin_iff.mpr ⟨hat,Eventually.of_forall (fun n => ⟨(han n).1.le,(han n).2⟩)⟩
+  have hFt : Tendsto (fun n => F (a n)) atTop (𝓝 0) := by
+    have hh := (radial_flux_continuousOn hu 0 ⟨le_rfl,hR.le⟩).tendsto.comp haT
+    simpa only [F,Function.comp_def,radial_flux_zero] using hh
+  have hlim : Tendsto (fun n => F (a n)+Real.pi*C*(R^2-(a n)^2)) atTop
+      (𝓝 (Real.pi*C*R^2)) := by
+    simpa only [zero_pow (by norm_num : (2:ℕ)≠0),sub_zero,zero_add] using
+      hFt.add ((tendsto_const_nhds.sub (hat.pow 2)).const_mul (Real.pi*C))
+  exact le_of_tendsto hlim (Eventually.of_forall (fun n => by
+    have hh := hlower (han n).1 (han n).2
+    linarith))
+
+end SLEExactGauge
+
+end
+
+end OAI
diff --git a/lean/OAI/Probability/SLE/Geometry/InteriorVisit.lean b/lean/OAI/Probability/SLE/Geometry/InteriorVisit.lean
new file mode 100644
index 0000000000000000000000000000000000000000..7a026c4dec199da06ebab0e58f6a838d1aabc585
--- /dev/null
+++ b/lean/OAI/Probability/SLE/Geometry/InteriorVisit.lean
@@ -0,0 +1,138 @@
+import OAI.Probability.SLE.SausageSeedAll
+import OAI.Probability.SLE.Geometry.AccessGuideCollapse
+
+namespace OAI
+
+/-! A positive bounded interior visit, obtained from the already proved
+sausage seed. This supplies the nondegeneracy event in the access-guide
+argument without a uniform support assumption. -/
+
+noncomputable section
+open Set Filter MeasureTheory Metric
+open scoped Topology ENNReal NNReal
+
+namespace SLEExactGauge
+
+theorem RegularSLEPresentation.positive_bounded_interior_visit
+    {Ω : Type} [MeasurableSpace Ω] {P : Measure Ω} [IsProbabilityMeasure P]
+    {κ : ℝ} {γ : Ω → ℝ≥0 → ℂ} (a : RegularSLEPresentation P κ γ)
+    (hκ : 0 < κ) (hκ8 : κ < 8) (z : ℂ) (hz : 2 < z.im) :
+    ∃ (T : ℝ≥0) (R : ℝ), 0 < T ∧ 0 < R ∧
+      0 < (P.comap (Subtype.val : a.samples → Ω))
+        {ω | (∀ t ∈ Icc 0 T, ‖γ ω t‖ < R) ∧
+          ∃ t ∈ Icc 0 T, γ ω t ∈ closedBall z 2} := by
+  obtain ⟨T, p, b, e₀, hT, hp, hb, he₀, hseed⟩ :=
+    a.source_positive_probability_initial_sausage_all hκ hκ8 z hz
+  let e : ℝ := min (e₀ / 2) (1 / 2)
+  have he : 0 < e := lt_min (by positivity) (by norm_num)
+  have hee₀ : e < e₀ := (min_le_left _ _).trans_lt (by linarith)
+  have hehalf : e ≤ 1 / 2 := min_le_right _ _
+  let Q := P.comap (Subtype.val : a.samples → Ω)
+  let A : Set a.samples := {ω | ENNReal.ofReal b ≤ ENNReal.ofReal
+    (e ^ (-codimension κ)) * volume (closedBall z 1 ∩ sourceSausageSet (γ ω) 0 T e)}
+  let E : ℕ → Set a.samples := fun n =>
+    {ω | (∀ t ∈ Icc 0 T, ‖γ ω t‖ < (n : ℝ)) ∧
+      ∃ t ∈ Icc 0 T, γ ω t ∈ closedBall z 2}
+  have hApos : 0 < Q A := (ENNReal.ofReal_pos.mpr hp).trans_le (hseed e he hee₀)
+  have hsub : A ⊆ ⋃ n : ℕ, E n := by
+    intro ω hω
+    have hnonempty : (closedBall z 1 ∩ sourceSausageSet (γ ω) 0 T e).Nonempty := by
+      by_contra hn
+      have hempty := Set.not_nonempty_iff_eq_empty.mp hn
+      have hh := hω
+      change ENNReal.ofReal b ≤ ENNReal.ofReal (e ^ (-codimension κ)) *
+        volume (closedBall z 1 ∩ sourceSausageSet (γ ω) 0 T e) at hh
+      rw [hempty, measure_empty, mul_zero] at hh
+      exact (not_le_of_gt (ENNReal.ofReal_pos.mpr hb)) hh
+    obtain ⟨w, hwball, u, hu, hdist⟩ := hnonempty
+    have huQ : γ ω u ∈ closedBall z 2 := by
+      apply mem_closedBall.mpr
+      have hh := dist_triangle (γ ω u) w z
+      have hw := mem_closedBall.mp hwball
+      have hd : dist (γ ω u) w < e := by simpa only [dist_comm] using hdist
+      linarith
+    have hbounded : Bornology.IsBounded (γ ω '' Icc 0 T) :=
+      (isCompact_Icc.image (a.trace_continuous ω)).isBounded
+    obtain ⟨M, hM, hbound⟩ := hbounded.exists_pos_norm_lt
+    obtain ⟨n, hn⟩ := exists_nat_gt M
+    apply mem_iUnion.mpr
+    refine ⟨n, ?_, u, hu, huQ⟩
+    intro t ht
+    exact (hbound _ (mem_image_of_mem (γ ω) ht)).trans hn
+  have hex : ∃ n : ℕ, 0 < Q (E n) := by
+    by_contra! hnone
+    have hnull : ∀ n, Q (E n) = 0 := fun n => le_antisymm (hnone n) bot_le
+    have hu : Q (⋃ n : ℕ, E n) = 0 := measure_iUnion_null_iff.mpr hnull
+    exact (not_le_of_gt hApos) ((measure_mono hsub).trans_eq hu)
+  obtain ⟨n, hn⟩ := hex
+  have hnpos : 0 < (n : ℝ) := by
+    by_contra h
+    have hE : E n = ∅ := by
+      apply Set.eq_empty_iff_forall_notMem.mpr
+      intro ω hω
+      have hh := hω.1 0 (mem_Icc.mpr ⟨le_rfl, zero_le⟩)
+      exact (not_lt_of_ge ((le_of_not_gt h).trans (norm_nonneg _))) hh
+    rw [hE, measure_empty] at hn
+    exact (lt_irrefl 0) hn
+  exact ⟨T, n, hT, hnpos, hn⟩
+
+/-- Localization only needs an interior visit before the bounded time,
+not a visit at a predetermined terminal time. -/
+theorem uniform_access_radius_lower_bound_of_interior_visit
+    {Ω : Type*} [MeasurableSpace Ω] (P : Measure Ω) [IsProbabilityMeasure P]
+    (κ : ℝ) (hκ : 0 < κ) (hκ8 : κ < 8)
+    (γ : Ω → ℝ≥0 → ℂ) (hSLE : IsOrdinaryChordalSLE κ γ P)
+    (T : ℝ≥0) (R : ℝ) (Q : Set ℂ) (hQ : Q ⊆ upperHalfPlane)
+    (hvisit : 0 < P {ω | (∀ t ∈ Icc 0 T, ‖γ ω t‖ < R) ∧
+      ∃ t ∈ Icc 0 T, γ ω t ∈ Q})
+    (r₀ : ℝ) (hr₀ : 0 < r₀) :
+    ∃ rmin : ℝ, 0 < rmin ∧
+      ∀ (F : ℂ → ℂ) (Fbar : ℂ → OnePoint ℂ),
+      DifferentiableOn ℂ F upperHalfPlane → InjOn F upperHalfPlane →
+      ContinuousOn Fbar {z : ℂ | 0 ≤ z.im} →
+      (∀ z ∈ upperHalfPlane, Fbar z = (F z : OnePoint ℂ)) →
+      ∀ (a : ℂ) (r : ℝ), 0 < r →
+      (∀ z ∈ Q, r₀ ≤ ‖F z - a‖) →
+      ∀ (η : ℝ → ℂ) (S : ℝ), 0 < S → ContinuousOn η (Icc 0 S) →
+      η 0 = 0 → ‖η S‖ = 1 → (∀ t ∈ Icc 0 S, 0 ≤ (η t).im) →
+      (∀ t ∈ Icc 0 S, ∃ w : ℂ,
+        Fbar (η t) = (w : OnePoint ℂ) ∧ ‖w - a‖ ≤ r) → rmin ≤ r := by
+  obtain ⟨b, C, c, L₀, hb, _, hc, hL₀, hloc⟩ :=
+    sourceUniformConformalLocalization κ hκ hκ8
+  let E : Set Ω := {ω | (∀ t ∈ Icc 0 T, ‖γ ω t‖ < R) ∧
+    ∃ t ∈ Icc 0 T, γ ω t ∈ Q}
+  have ht : Tendsto (fun L : ℝ => ENNReal.ofReal (C * L ^ (-c))) atTop (𝓝 0) := by
+    simpa only [Function.comp_def, mul_zero, ENNReal.ofReal_zero] using
+      ENNReal.continuous_ofReal.continuousAt.tendsto.comp
+        ((tendsto_rpow_neg_atTop hc).const_mul C)
+  obtain ⟨L, hL, hLR, hLprob⟩ := ((eventually_ge_atTop L₀).and
+    (((tendsto_rpow_atTop hb).eventually_gt_atTop R).and
+      (ht.eventually (gt_mem_nhds hvisit)))).exists
+  have hLp : 0 < L := (zero_lt_one.trans hL₀).trans_le hL
+  refine ⟨r₀ / L, div_pos hr₀ hLp, ?_⟩
+  intro F Fbar hF hinj hbar hext a r hr hsep η S hS hη hη0 hηS hupper himage
+  by_contra! hsmall
+  have hLr : L * r < r₀ := by
+    simpa only [mul_comm] using (lt_div_iff₀ hLp).mp hsmall
+  have hbound := hloc Ω inferInstance P inferInstance γ hSLE F Fbar hF hinj
+    hbar hext a r hr η S hS hη hη0 hηS hupper himage L hL
+  have hsub : E ⊆ {ω | ∃ t : ℝ≥0, BeforeFirstModulus (γ ω) (L ^ b) t ∧
+      Fbar (γ ω t) ∉ (fun z : ℂ => (z : OnePoint ℂ)) '' ball a (L * r)} := by
+    rintro ω ⟨hω, t, ht, hωQ⟩
+    refine ⟨t, ?_, ?_⟩
+    · intro s hs
+      exact (hω s ⟨zero_le, hs.le.trans ht.2⟩).trans hLR
+    · rintro ⟨w, hw, he⟩
+      have heq : w = F (γ ω t) :=
+        OnePoint.coe_injective (he.trans (hext _ (hQ hωQ)))
+      subst w
+      have hh : ‖F (γ ω t) - a‖ < L * r := by
+        simpa only [mem_ball, dist_eq_norm] using hw
+      exact (not_lt_of_ge (hsep _ hωQ)) (hh.trans hLr)
+  exact (not_lt_of_ge ((measure_mono hsub).trans hbound)) hLprob
+
+end SLEExactGauge
+
+end
+
+end OAI
diff --git a/lean/OAI/Probability/SLE/Geometry/InvertedArcComponents.lean b/lean/OAI/Probability/SLE/Geometry/InvertedArcComponents.lean
new file mode 100644
index 0000000000000000000000000000000000000000..31ae3bd7d877b855d250235cab0564873e3a0a59
--- /dev/null
+++ b/lean/OAI/Probability/SLE/Geometry/InvertedArcComponents.lean
@@ -0,0 +1,93 @@
+import OAI.Probability.SLE.Geometry.InvertedExterior
+import OAI.Probability.SLE.Geometry.ReflectedSimpleArc
+
+namespace OAI
+
+/-! The two sides of an inverted reflected slit run to infinity.
+Consequently its complementary components cannot be bounded. -/
+noncomputable section
+open Set Complex Metric Filter Function
+open scoped Topology ComplexConjugate
+
+namespace SLEExactGauge
+
+def invertedArcImage (p : C(unitInterval,ℂ)) : Set ℂ :=
+  (fun t => (p t)⁻¹) '' Ioi (0:unitInterval)
+
+lemma invertedArcImage_preconnected (p : C(unitInterval,ℂ))
+    (hn : ∀ t : unitInterval, 0 < t → p t ≠ 0) :
+    IsPreconnected (invertedArcImage p) := by
+  apply isPreconnected_Ioi.image
+  intro t ht
+  exact (p.continuous.continuousAt.inv₀ (hn t ht)).continuousWithinAt
+
+lemma invertedArcImage_unbounded (p : C(unitInterval,ℂ)) (h0 : p 0=0)
+    (hn : ∀ t : unitInterval, 0 < t → p t ≠ 0) :
+    ¬ Bornology.IsBounded (invertedArcImage p) := by
+  intro hb
+  obtain ⟨R,hR,hbound⟩ := hb.subset_ball_lt 0 (0:ℂ)
+  have : NeBot (𝓝[>] (0:unitInterval)) :=
+    nhdsWithin_Ioi_neBot' ⟨1,by norm_num⟩ le_rfl
+  have hlim : Tendsto p (𝓝[>] (0:unitInterval)) (𝓝 (0:ℂ)) := by
+    simpa only [h0] using (p.continuous.tendsto (0:unitInterval)).mono_left nhdsWithin_le_nhds
+  have hnear := hlim.eventually (ball_mem_nhds (0:ℂ) (by positivity : 0 < 1/(R+1)))
+  have hpos : ∀ᶠ t : unitInterval in 𝓝[>] (0:unitInterval), 0 < t := self_mem_nhdsWithin
+  obtain ⟨t,ht,hsmall⟩ := (hpos.and hnear).exists
+  have hnpt : 0 < ‖p t‖ := norm_pos_iff.mpr (hn t ht)
+  have hsize : ‖p t‖ < 1/(R+1) := by
+    simpa only [mem_ball,dist_zero_right] using hsmall
+  have hbig : R+1 < ‖p t‖⁻¹ := by
+    rw [← one_div,lt_div_iff₀ hnpt]
+    nlinarith [(lt_div_iff₀ (by linarith : 0 < R+1)).mp hsize]
+  have hless : ‖p t‖⁻¹ < R := by
+    simpa only [mem_ball,dist_zero_right,norm_inv] using hbound ⟨t,ht,rfl⟩
+  linarith
+
+lemma invertedExterior_two_arcs_complement
+    (p q : C(unitInterval,ℂ)) (hp0 : p 0=0) (hq0 : q 0=0)
+    (hp : ∀ t : unitInterval, 0 < t → p t ≠ 0)
+    (hq : ∀ t : unitInterval, 0 < t → q t ≠ 0) :
+    (invertedExterior (range p ∪ range q))ᶜ = invertedArcImage p ∪ invertedArcImage q := by
+  have himage (r : C(unitInterval,ℂ)) (hr0 : r 0=0) (z : ℂ) (hz : z ≠ 0) :
+      z⁻¹ ∈ range r ↔ z ∈ invertedArcImage r := by
+    constructor
+    · rintro ⟨t,ht⟩
+      have ht0 : t ≠ 0 := by intro h; rw [h,hr0] at ht; exact (inv_ne_zero hz) ht.symm
+      exact ⟨t,pos_iff_ne_zero.mpr ht0,by change (r t)⁻¹=z; rw [ht,inv_inv]⟩
+    · rintro ⟨t,ht,rfl⟩
+      exact ⟨t,by rw [inv_inv]⟩
+  ext z
+  by_cases hz : z=0
+  · subst z
+    have hn (r : C(unitInterval,ℂ)) (hr : ∀ t : unitInterval, 0 < t → r t ≠ 0) :
+        (0:ℂ) ∉ invertedArcImage r := by
+      rintro ⟨t,ht,he⟩
+      exact inv_ne_zero (hr t ht) he
+    simp only [mem_compl_iff,zero_mem_invertedExterior,not_true_eq_false,
+      mem_union,hn p hp,hn q hq,false_or]
+  · change (¬ (z=0 ∨ z⁻¹ ∉ range p ∪ range q)) ↔
+      z ∈ invertedArcImage p ∪ invertedArcImage q
+    simp only [hz,false_or,not_not,mem_union,himage p hp0 z hz,himage q hq0 z hz]
+
+theorem invertedExterior_two_arcs_components_unbounded
+    (p q : C(unitInterval,ℂ)) (hp0 : p 0=0) (hq0 : q 0=0)
+    (hp : ∀ t : unitInterval, 0 < t → p t ≠ 0)
+    (hq : ∀ t : unitInterval, 0 < t → q t ≠ 0)
+    {z : ℂ} (hz : z ∉ invertedExterior (range p ∪ range q)) :
+    ¬ Bornology.IsBounded
+      (connectedComponentIn (invertedExterior (range p ∪ range q))ᶜ z) := by
+  change z ∈ (invertedExterior (range p ∪ range q))ᶜ at hz
+  rw [invertedExterior_two_arcs_complement p q hp0 hq0 hp hq] at hz ⊢
+  rcases hz with hz|hz
+  · have hsub := (invertedArcImage_preconnected p hp).subset_connectedComponentIn hz
+      (subset_union_left : invertedArcImage p ⊆ invertedArcImage p ∪ invertedArcImage q)
+    exact fun hb => invertedArcImage_unbounded p hp0 hp (hb.subset hsub)
+  · have hsub := (invertedArcImage_preconnected q hq).subset_connectedComponentIn hz
+      (subset_union_right : invertedArcImage q ⊆ invertedArcImage p ∪ invertedArcImage q)
+    exact fun hb => invertedArcImage_unbounded q hq0 hq (hb.subset hsub)
+
+end SLEExactGauge
+
+end
+
+end OAI
diff --git a/lean/OAI/Probability/SLE/Geometry/InvertedExterior.lean b/lean/OAI/Probability/SLE/Geometry/InvertedExterior.lean
new file mode 100644
index 0000000000000000000000000000000000000000..016adec4f434c9a050b02066f6daeb87fb0cc6ac
--- /dev/null
+++ b/lean/OAI/Probability/SLE/Geometry/InvertedExterior.lean
@@ -0,0 +1,96 @@
+import OAI.Probability.SLE.Geometry.SimpleArcPlaneComplement
+import Mathlib.Analysis.Normed.Field.Lemmas
+
+namespace OAI
+
+/-! Inverting a bounded obstacle and adding the point at infinity at
+zero. This is the domain used for conformal normalization at infinity. -/
+noncomputable section
+open Set Complex Metric Filter
+open scoped Topology
+
+namespace SLEExactGauge
+
+def invertedExterior (K : Set ℂ) : Set ℂ := {z | z=0 ∨ z⁻¹ ∉ K}
+
+lemma invertedExterior_eq_insert (K : Set ℂ) :
+    invertedExterior K=insert 0 (Inv.inv '' Kᶜ) := by
+  ext z
+  change (z=0 ∨ z⁻¹ ∉ K) ↔ z=0 ∨ ∃ w ∈ Kᶜ, w⁻¹=z
+  constructor
+  · rintro (rfl|hz)
+    · exact Or.inl rfl
+    · exact Or.inr ⟨z⁻¹,hz,inv_inv z⟩
+  · rintro (rfl|⟨w,hw,rfl⟩)
+    · exact Or.inl rfl
+    · exact Or.inr (by rw [inv_inv]; exact hw)
+
+lemma zero_mem_invertedExterior (K : Set ℂ) : (0:ℂ) ∈ invertedExterior K := Or.inl rfl
+
+lemma invertedExterior_isOpen {K : Set ℂ} (hK : IsCompact K) :
+    IsOpen (invertedExterior K) := by
+  obtain ⟨R,hR,hbound⟩ := hK.isBounded.subset_ball_lt 0 (0:ℂ)
+  apply isOpen_iff_mem_nhds.mpr
+  intro z hz
+  by_cases hz0 : z=0
+  · subst z
+    apply mem_of_superset (ball_mem_nhds 0 (by positivity : 0 < 1/(R+1)))
+    intro w hw
+    by_cases hw0 : w=0
+    · exact Or.inl hw0
+    right
+    intro hwK
+    have hsmall : ‖w‖ < 1/(R+1) := by simpa only [mem_ball,dist_zero_right] using hw
+    have hn : 0 < ‖w‖ := norm_pos_iff.mpr hw0
+    have hlarge : R+1 < ‖w‖⁻¹ := by
+      rw [← one_div,lt_div_iff₀ hn]
+      nlinarith [(lt_div_iff₀ (by linarith : 0 < R+1)).mp hsmall]
+    have hb : ‖w‖⁻¹ < R := by
+      simpa only [mem_ball,dist_zero_right,norm_inv] using hbound hwK
+    linarith
+  · have hinv : z⁻¹ ∈ Kᶜ := hz.resolve_left hz0
+    have hpre := (continuousAt_inv₀ hz0).preimage_mem_nhds
+      (hK.isClosed.isOpen_compl.mem_nhds hinv)
+    exact mem_of_superset hpre (fun _ h => Or.inr h)
+
+lemma zero_mem_closure_inverted_complement {K : Set ℂ} (hK : Bornology.IsBounded K) :
+    (0:ℂ) ∈ closure (Inv.inv '' Kᶜ) := by
+  obtain ⟨R,hR,hbound⟩ := hK.subset_ball_lt 0 (0:ℂ)
+  apply Metric.mem_closure_iff.mpr
+  intro ε hε
+  let M := R+1+1/ε
+  have hM : 0 < M := by dsimp [M]; positivity
+  have hMR : R < M := by dsimp [M]; linarith [one_div_pos.mpr hε]
+  have hMe : 1/ε < M := by dsimp [M]; linarith
+  have hnot : (M:ℂ) ∈ Kᶜ := by
+    intro hh
+    have hb := hbound hh
+    have he : ‖(M:ℂ)‖=M := by simp only [Complex.norm_real,Real.norm_eq_abs,abs_of_pos hM]
+    rw [mem_ball,dist_zero_right,he] at hb
+    linarith
+  refine ⟨(M:ℂ)⁻¹,⟨(M:ℂ),hnot,rfl⟩,?_⟩
+  have hsmall : M⁻¹ < ε := by
+    rw [← one_div,div_lt_iff₀ hM]
+    nlinarith [(div_lt_iff₀ hε).mp hMe]
+  simpa only [dist_eq_norm,zero_sub,norm_neg,norm_inv,Complex.norm_real,
+    Real.norm_eq_abs,abs_of_pos hM] using hsmall
+
+theorem invertedExterior_connected {K : Set ℂ} (hb : Bornology.IsBounded K)
+    (h0 : (0:ℂ) ∈ K) (hc : IsConnected Kᶜ) : IsConnected (invertedExterior K) := by
+  have hi : ContinuousOn (Inv.inv : ℂ → ℂ) Kᶜ := by
+    intro z hz
+    have hn : z ≠ (0:ℂ) := fun he => hz (he.symm ▸ h0)
+    exact (continuousAt_inv₀ hn).continuousWithinAt
+  have himage := hc.image Inv.inv hi
+  rw [invertedExterior_eq_insert K]
+  apply himage.subset_closure (subset_insert 0 _)
+  intro z hz
+  rcases hz with rfl|hz
+  · exact zero_mem_closure_inverted_complement hb
+  · exact subset_closure hz
+
+end SLEExactGauge
+
+end
+
+end OAI
diff --git a/lean/OAI/Probability/SLE/Geometry/JointRadiusKernel.lean b/lean/OAI/Probability/SLE/Geometry/JointRadiusKernel.lean
new file mode 100644
index 0000000000000000000000000000000000000000..0cdf99a3caba7bcce6fd646a867fb041ded86631
--- /dev/null
+++ b/lean/OAI/Probability/SLE/Geometry/JointRadiusKernel.lean
@@ -0,0 +1,211 @@
+import OAI.Probability.SLE.Loewner.ActualRadiusStops
+import OAI.Probability.SLE.ChartMeasurability
+import OAI.Probability.SLE.InverseMoments
+
+namespace OAI
+
+/-! Jointly measurable geometric radius and radius-level kernels, constructed
+from the clipped Loewner equations. Agreement holds simultaneously at every
+marked point and nonnegative radius level on each actual capacity witness. -/
+
+noncomputable section
+open Set Filter MeasureTheory ProbabilityTheory TopologicalSpace Classical
+open scoped Topology NNReal ENNReal
+
+namespace SLEExactGauge
+
+lemma fullRadius_strictAnti_on_live
+    {U : ℝ≥0 → ℝ} {γ : ℝ≥0 → ℂ} {G F : ℝ≥0 → ℂ → ℂ}
+    (hU : Continuous U) (hw : IsCapacityTwoWitness U γ G F)
+    (z : ℂ) {s t : ℝ≥0} (hst : s < t)
+    (ht : z ∈ survivingDomain γ t) :
+    fullRadius G t z < fullRadius G s z := by
+  have hs := survivingDomain_antitone γ hst.le ht
+  have hc := hw.radius_clock_strictMonoOn hU z t ht
+    (show (s : ℝ) ∈ Icc 0 (t : ℝ) from ⟨s.coe_nonneg, by exact_mod_cast hst.le⟩)
+    (show (t : ℝ) ∈ Icc 0 (t : ℝ) from ⟨t.coe_nonneg, le_rfl⟩)
+    (by exact_mod_cast hst)
+  simp only [Real.toNNReal_coe] at hc
+  rw [fullRadius_eq_logClock hU hw z t ht, fullRadius_eq_logClock hU hw z s hs,
+    logRadiusClock_logCoordinates hU hw z t ht,
+    logRadiusClock_logCoordinates hU hw z s hs]
+  exact mul_lt_mul_of_pos_left (Real.exp_lt_exp.mpr (neg_lt_neg hc))
+    (mul_pos (by norm_num) ht.1.1)
+
+lemma radiusLevelTime_lt_of_live_radius_lt
+    {U : ℝ≥0 → ℝ} {γ : ℝ≥0 → ℂ} {G F : ℝ≥0 → ℂ → ℂ}
+    (hU : Continuous U) (hw : IsCapacityTwoWitness U γ G F)
+    (z : ℂ) (u : ℝ) (hu : 0 ≤ u) (t : ℝ≥0)
+    (ht : z ∈ survivingDomain γ t)
+    (hR : fullRadius G t z < (2 * z.im) * Real.exp (-u)) :
+    radiusLevelTime γ G z u < (t : ℝ≥0∞) := by
+  obtain ⟨s, hs, hsR⟩ := exists_live_level_of_radiusLevelTime_lt_top γ G z u
+    (radiusLevelTime_finite_of_live_radius_lt hU hw z u hu t ht hR)
+  have hst : s < t := by
+    by_contra hn
+    have hts := le_of_not_gt hn
+    rcases hts.eq_or_lt with he | he
+    · subst s
+      exact (lt_irrefl _ (hsR ▸ hR))
+    · have hh := fullRadius_strictAnti_on_live hU hw z he hs
+      rw [hsR] at hh
+      exact (not_lt_of_ge hh.le) hR
+  rw [radiusLevelTime_eq_of_live_level hU hw z u s hs hsR]
+  exact_mod_cast hst
+
+/-- A radius level is before `x` exactly when a time in one fixed countable
+dense set is before `x`, still live, and strictly beyond that radius level. -/
+lemma radiusLevelTime_lt_iff_dense
+    {U : ℝ≥0 → ℝ} {γ : ℝ≥0 → ℂ} {G F : ℝ≥0 → ℂ → ℂ}
+    (hU : Continuous U) (hw : IsCapacityTwoWitness U γ G F)
+    (z : ℂ) (u : ℝ) (hu : 0 ≤ u) (x : ℝ≥0∞) :
+    radiusLevelTime γ G z u < x ↔ ∃ n : ℕ,
+      (denseSeq ℝ≥0 n : ℝ≥0∞) < x ∧
+      z ∈ survivingDomain γ (denseSeq ℝ≥0 n) ∧
+      fullRadius G (denseSeq ℝ≥0 n) z < (2 * z.im) * Real.exp (-u) := by
+  constructor
+  · intro hx
+    obtain ⟨T, hT, hTR⟩ := exists_live_level_of_radiusLevelTime_lt_top γ G z u
+      (hx.trans_le le_top)
+    have hTx : (T : ℝ≥0∞) < x := by
+      rwa [radiusLevelTime_eq_of_live_level hU hw z u T hT hTR] at hx
+    let V : Set ℝ≥0 := {q | z ∈ survivingDomain γ q ∧ (q : ℝ≥0∞) < x}
+    have hVo : IsOpen V := by
+      have hLive : IsOpen {q : ℝ≥0 | z ∈ survivingDomain γ q} :=
+        source_survival_open.preimage
+        (((continuous_const : Continuous (fun _ : ℝ≥0 =>
+          (⟨γ, hw.1⟩ : C(ℝ≥0, ℂ)))).prodMk continuous_id).prodMk continuous_const)
+      exact hLive.inter (isOpen_lt ENNReal.continuous_coe continuous_const)
+    obtain ⟨b, hTb, hb⟩ := exists_Ico_subset_of_mem_nhds
+      (hVo.mem_nhds (show T ∈ V from ⟨hT, hTx⟩)) (exists_gt T)
+    obtain ⟨n, hn⟩ := (denseRange_denseSeq ℝ≥0).exists_mem_open isOpen_Ioo
+      (nonempty_Ioo.mpr hTb)
+    have hV := hb (show denseSeq ℝ≥0 n ∈ Ico T b from ⟨hn.1.le, hn.2⟩)
+    refine ⟨n, hV.2, hV.1, ?_⟩
+    have hr := fullRadius_strictAnti_on_live hU hw z hn.1 hV.1
+    rwa [hTR] at hr
+  · rintro ⟨n, hnx, hn, hnR⟩
+    exact (radiusLevelTime_lt_of_live_radius_lt hU hw z u hu _ hn hnR).trans hnx
+
+namespace SpatialClippedFamily
+variable {Ω : Type*} [MeasurableSpace Ω] {U : ℝ≥0 → Ω → ℝ}
+  (c : SpatialClippedFamily U)
+
+def jointLive (p : ℝ≥0 × (ℂ × Ω)) : Prop := ∃ n : ℕ, c.valid n p.1 p.2.1 p.2.2
+
+lemma jointLive_measurable : MeasurableSet {p | c.jointLive p} := by
+  simpa only [jointLive, ofPred_exists] using
+    MeasurableSet.iUnion (fun n => c.valid_measurable n)
+
+lemma jointLive_iff {γ : ℝ≥0 → ℂ} {G F : ℝ≥0 → ℂ → ℂ}
+    (ω : Ω) (hUc : Continuous (fun t => U t ω))
+    (hw : IsCapacityTwoWitness (fun t => U t ω) γ G F) (t : ℝ≥0) (z : ℂ) :
+    c.jointLive (t, z, ω) ↔ z ∈ survivingDomain γ t := by
+  constructor
+  · rintro ⟨n, hn⟩
+    exact c.live_of_valid ω hUc hw n t z hn
+  · intro hz
+    obtain ⟨n, hn⟩ := (c.eventually_valid_agrees ω hUc hw t z hz).exists
+    exact ⟨n, hn.1⟩
+
+def radiusApprox (n : ℕ) (p : ℝ≥0 × (ℂ × Ω)) : ℝ :=
+  if c.valid n p.1 p.2.1 p.2.2 then
+    (2 * p.2.1.im) * Real.exp (-logRadiusClock (Real.log p.2.1.im) (c.Q n p.1 p.2))
+  else 0
+
+lemma radiusApprox_measurable (n : ℕ) : Measurable (c.radiusApprox n) := by
+  have hz : Measurable (fun p : ℝ≥0 × (ℂ × Ω) => p.2.1.im) :=
+    Complex.measurable_im.comp (measurable_fst.comp measurable_snd)
+  have hQ := (c.measurable n).comp
+    ((NNReal.continuous_coe.measurable.comp measurable_fst).prodMk measurable_snd)
+  apply Measurable.ite (c.valid_measurable n) _ measurable_const
+  exact (hz.const_mul 2).mul (Real.continuous_exp.measurable.comp
+    (((Real.measurable_log.comp hz).sub (Complex.measurable_im.comp hQ.fst)).add hQ.snd).neg)
+
+def jointRadius (p : ℝ≥0 × (ℂ × Ω)) : ℝ :=
+  limUnder atTop (fun n => c.radiusApprox n p)
+
+lemma jointRadius_measurable : Measurable c.jointRadius :=
+  (StronglyMeasurable.limUnder (fun n =>
+    (c.radiusApprox_measurable n).stronglyMeasurable)).measurable
+
+lemma jointRadius_eq {γ : ℝ≥0 → ℂ} {G F : ℝ≥0 → ℂ → ℂ}
+    (ω : Ω) (hUc : Continuous (fun t => U t ω))
+    (hw : IsCapacityTwoWitness (fun t => U t ω) γ G F) (t : ℝ≥0) (z : ℂ) :
+    c.jointRadius (t, z, ω) =
+      if z ∈ survivingDomain γ t then fullRadius G t z else 0 := by
+  apply Filter.Tendsto.limUnder_eq
+  apply tendsto_nhds_of_eventually_eq
+  by_cases hz : z ∈ survivingDomain γ t
+  · filter_upwards [c.eventually_valid_agrees ω hUc hw t z hz] with n hn
+    rw [radiusApprox, ite_eq_left hn.1, hn.2, ite_eq_left hz]
+    exact (fullRadius_eq_logClock hUc hw z t hz).symm
+  · filter_upwards [] with n
+    have hn : ¬ c.valid n t z ω := fun hv => hz (c.live_of_valid ω hUc hw n t z hv)
+    simp only [radiusApprox, ite_eq_right hn, ite_eq_right hz]
+
+def jointRadiusLevel (p : ℝ × (ℂ × Ω)) : ℝ≥0∞ :=
+  ⨅ n : ℕ, if c.jointLive (denseSeq ℝ≥0 n, p.2) ∧
+    c.jointRadius (denseSeq ℝ≥0 n, p.2) < (2 * p.2.1.im) * Real.exp (-p.1)
+    then (denseSeq ℝ≥0 n : ℝ≥0∞) else ∞
+
+lemma jointRadiusLevel_measurable : Measurable c.jointRadiusLevel := by
+  apply Measurable.iInf
+  intro n
+  have hp : Measurable (fun p : ℝ × (ℂ × Ω) => (denseSeq ℝ≥0 n, p.2)) :=
+    measurable_const.prodMk measurable_snd
+  have hz : Measurable (fun p : ℝ × (ℂ × Ω) => p.2.1.im) :=
+    Complex.measurable_im.comp (measurable_fst.comp measurable_snd)
+  exact Measurable.ite ((c.jointLive_measurable.preimage hp).inter
+    (measurableSet_lt (c.jointRadius_measurable.comp hp)
+      ((hz.const_mul 2).mul (Real.continuous_exp.measurable.comp measurable_fst.neg))))
+    measurable_const measurable_const
+
+lemma jointRadiusLevel_eq {γ : ℝ≥0 → ℂ} {G F : ℝ≥0 → ℂ → ℂ}
+    (ω : Ω) (hUc : Continuous (fun t => U t ω))
+    (hw : IsCapacityTwoWitness (fun t => U t ω) γ G F)
+    (u : ℝ) (hu : 0 ≤ u) (z : ℂ) :
+    c.jointRadiusLevel (u, z, ω) = radiusLevelTime γ G z u := by
+  apply eq_of_forall_gt_iff
+  intro x
+  rw [jointRadiusLevel, iInf_lt_iff, radiusLevelTime_lt_iff_dense hUc hw z u hu x]
+  apply exists_congr
+  intro n
+  have hLive := c.jointLive_iff ω hUc hw (denseSeq ℝ≥0 n) z
+  have hRad := c.jointRadius_eq ω hUc hw (denseSeq ℝ≥0 n) z
+  by_cases hz : z ∈ survivingDomain γ (denseSeq ℝ≥0 n)
+  · rw [ite_eq_left hz] at hRad
+    by_cases hr : fullRadius G (denseSeq ℝ≥0 n) z < (2 * z.im) * Real.exp (-u)
+    · simp [hLive, hz, hRad, hr]
+    · simp [hLive, hz, hRad, hr]
+  · simp [hLive, hz]
+
+end SpatialClippedFamily
+
+/-- The kernels agree on one probability-one set simultaneously for all
+points, all times, and every nonnegative radius level. Consequently random
+measurable marked states may be substituted without changing that null set. -/
+theorem exists_joint_radius_and_level
+    {Ω : Type*} [MeasurableSpace Ω] {P : Measure Ω}
+    (U : ℝ≥0 → Ω → ℝ)
+    (hUm : Measurable (fun p : ℝ≥0 × Ω => U p.1 p.2))
+    (hUc : ∀ ω, Continuous (fun t => U t ω))
+    (γ : Ω → ℝ≥0 → ℂ) (G F : Ω → ℝ≥0 → ℂ → ℂ)
+    (hw : ∀ᵐ ω ∂P, IsCapacityTwoWitness (fun t => U t ω) (γ ω) (G ω) (F ω)) :
+    ∃ R : ℝ≥0 × (ℂ × Ω) → ℝ, ∃ τ : ℝ × (ℂ × Ω) → ℝ≥0∞,
+      Measurable R ∧ Measurable τ ∧ ∀ᵐ ω ∂P,
+        (∀ t z, R (t, z, ω) =
+          if z ∈ survivingDomain (γ ω) t then fullRadius (G ω) t z else 0) ∧
+        (∀ u, 0 ≤ u → ∀ z, τ (u, z, ω) = radiusLevelTime (γ ω) (G ω) z u) := by
+  let c := spatialClippedFamily U hUm hUc
+  refine ⟨c.jointRadius, c.jointRadiusLevel, c.jointRadius_measurable,
+    c.jointRadiusLevel_measurable, ?_⟩
+  filter_upwards [hw] with ω hω
+  exact ⟨fun t z => c.jointRadius_eq ω (hUc ω) hω t z,
+    fun u hu z => c.jointRadiusLevel_eq ω (hUc ω) hω u hu z⟩
+
+end SLEExactGauge
+
+end
+
+end OAI
diff --git a/lean/OAI/Probability/SLE/Geometry/LipschitzGuideConfinement.lean b/lean/OAI/Probability/SLE/Geometry/LipschitzGuideConfinement.lean
new file mode 100644
index 0000000000000000000000000000000000000000..ad3c689dcda2c920adf06b5baa05b3dce0844cb7
--- /dev/null
+++ b/lean/OAI/Probability/SLE/Geometry/LipschitzGuideConfinement.lean
@@ -0,0 +1,295 @@
+import OAI.Probability.SLE.Geometry.HyperbolicGuideCompactness
+
+namespace OAI
+
+/-! Compact confinement for the actual Lipschitz access guides. Local
+conformal derivative bounds are integrated by continuous induction, so no
+differentiability of the physical guide is required. -/
+
+noncomputable section
+open Set Filter Metric
+open scoped Topology NNReal
+
+namespace SLEExactGauge.LipschitzGuideConfinement
+
+/-- A common local distance bound on a real interval is a global bound.
+The proof uses continuous induction and applies to arbitrary metric targets. -/
+theorem lipschitzOn_of_local_bound
+    {E : Type*} [PseudoMetricSpace E] {f : ℝ → E} {a b K : ℝ}
+    (hK : 0 ≤ K) (hf : ContinuousOn f (Icc a b))
+    (hloc : ∀ t ∈ Icc a b, ∃ ε : ℝ, 0 < ε ∧
+      ∀ u ∈ Icc a b, dist u t < ε → dist (f u) (f t) ≤ K * dist u t) :
+    LipschitzOnWith ⟨K, hK⟩ f (Icc a b) := by
+  have hsegment {s t : ℝ} (hs : s ∈ Icc a b) (ht : t ∈ Icc a b) (hst : s ≤ t) :
+      dist (f t) (f s) ≤ K * (t - s) := by
+    let S : Set ℝ := {x | dist (f x) (f s) ≤ K * (x - s)}
+    have hsub : Icc s t ⊆ Icc a b := Icc_subset_Icc hs.1 ht.2
+    have hc : ContinuousOn (fun x => (dist (f x) (f s), K * (x - s))) (Icc s t) :=
+      (continuous_dist.comp_continuousOn ((hf.mono hsub).prodMk continuousOn_const)).prodMk
+        (continuousOn_const.mul (continuousOn_id.sub continuousOn_const))
+    have hclosed : IsClosed (S ∩ Icc s t) := by
+      rw [inter_comm]
+      exact hc.preimage_isClosed_of_isClosed isClosed_Icc
+        OrderClosedTopology.isClosed_le'
+    have hmem : Icc s t ⊆ S := hclosed.Icc_subset_of_forall_exists_gt
+      (by change dist (f s) (f s) ≤ K * (s - s); simp) (by
+        intro x hx y hy
+        obtain ⟨ε, hε, hεbound⟩ := hloc x (hsub (Ico_subset_Icc_self hx.2))
+        let z := min t (min y (x + ε / 2))
+        have hxz : x < z := lt_min hx.2.2 (lt_min hy (by linarith))
+        have hzt : z ≤ t := min_le_left _ _
+        have hzy : z ≤ y := (min_le_right _ _).trans (min_le_left _ _)
+        have hzx : z ≤ x + ε / 2 := (min_le_right _ _).trans (min_le_right _ _)
+        have hz : z ∈ Icc s t := ⟨hx.2.1.trans hxz.le, hzt⟩
+        have hdist : dist z x < ε := by
+          rw [Real.dist_eq, abs_of_pos (sub_pos.mpr hxz)]
+          linarith
+        have hlocal := hεbound z (hsub hz) hdist
+        rw [Real.dist_eq, abs_of_pos (sub_pos.mpr hxz)] at hlocal
+        refine ⟨z, ?_, hxz, hzy⟩
+        change dist (f z) (f s) ≤ K * (z - s)
+        calc
+          dist (f z) (f s) ≤ dist (f z) (f x) + dist (f x) (f s) := dist_triangle _ _ _
+          _ ≤ K * (z - x) + K * (x - s) := add_le_add hlocal hx.1
+          _ = K * (z - s) := by ring)
+    exact hmem ⟨hst, le_rfl⟩
+  apply lipschitzOnWith_iff_dist_le_mul.mpr
+  intro s hs t ht
+  rcases le_total s t with hst | hts
+  · rw [dist_comm (f s), Real.dist_eq, abs_sub_comm, abs_of_nonneg (sub_nonneg.mpr hst)]
+    exact hsegment hs ht hst
+  · rw [Real.dist_eq, abs_of_nonneg (sub_nonneg.mpr hts)]
+    exact hsegment ht hs hts
+
+theorem log_im_fderiv_bound
+    {g : ℂ → ℂ} {z : ℂ} {r : ℝ} (hr : 0 < r)
+    (hg : DifferentiableOn ℂ g (ball z r)) (hi : InjOn g (ball z r))
+    (hH : MapsTo g (ball z r) upperHalfPlane) :
+    DifferentiableAt ℝ (fun w => Real.log (g w).im) z ∧
+      ‖fderiv ℝ (fun w => Real.log (g w).im) z‖ ≤ (128 * Real.pi) / r := by
+  have hgd : DifferentiableAt ℂ g z := hg.differentiableAt
+    (isOpen_ball.mem_nhds (mem_ball_self hr))
+  have hzH : 0 < (g z).im := hH (mem_ball_self hr)
+  have hd : HasFDerivAt (fun w => Real.log (g w).im)
+      ((g z).im⁻¹ • Complex.imCLM.comp (fderiv ℝ g z)) z := by
+    simpa only [Function.comp_apply, Complex.imCLM_apply] using
+      (Complex.imCLM.hasFDerivAt.comp z (hgd.restrictScalars ℝ).hasFDerivAt).log hzH.ne'
+  have hnorm : ‖fderiv ℝ g z‖ = ‖deriv g z‖ := by
+    rw [hgd.fderiv_restrictScalars (𝕜 := ℝ), ContinuousLinearMap.norm_restrictScalars,
+      ← norm_deriv_eq_norm_fderiv (𝕜 := ℂ)]
+  have hb := HyperbolicGuideCompactness.inverse_chart_derivative_bound hr hg hi hH
+  refine ⟨hd.differentiableAt, ?_⟩
+  rw [hd.fderiv, norm_smul, Real.norm_eq_abs, abs_inv, abs_of_pos hzH]
+  calc
+    (g z).im⁻¹ * ‖Complex.imCLM.comp (fderiv ℝ g z)‖ ≤
+        (g z).im⁻¹ * (‖Complex.imCLM‖ * ‖fderiv ℝ g z‖) :=
+      mul_le_mul_of_nonneg_left (ContinuousLinearMap.opNorm_comp_le _ _) (by positivity)
+    _ = (g z).im⁻¹ * ‖deriv g z‖ := by rw [Complex.imCLM_norm, one_mul, hnorm]
+    _ ≤ (g z).im⁻¹ * (((128 * Real.pi) / r) * (g z).im) :=
+      mul_le_mul_of_nonneg_left hb (by positivity)
+    _ = (128 * Real.pi) / r := by field_simp
+
+/-- The logarithm of the inverse-map height has bounded gradient on each
+physical clearance ball. -/
+theorem log_im_lipschitz_on_half_ball
+    {g : ℂ → ℂ} {z : ℂ} {r : ℝ} (hr : 0 < r)
+    (hg : DifferentiableOn ℂ g (ball z r)) (hi : InjOn g (ball z r))
+    (hH : MapsTo g (ball z r) upperHalfPlane) :
+    LipschitzOnWith ⟨(256 * Real.pi) / r, by positivity⟩
+      (fun w => Real.log (g w).im) (ball z (r / 2)) := by
+  have hbound (w : ℂ) (hw : w ∈ ball z (r / 2)) :
+      DifferentiableAt ℝ (fun w => Real.log (g w).im) w ∧
+        ‖fderiv ℝ (fun w => Real.log (g w).im) w‖ ≤ (256 * Real.pi) / r := by
+    have hsub : ball w (r / 2) ⊆ ball z r := by
+      intro u hu
+      apply mem_ball.mpr
+      have hh := (dist_triangle u w z).trans_lt (add_lt_add (mem_ball.mp hu) (mem_ball.mp hw))
+      linarith
+    have hh := log_im_fderiv_bound (by positivity : 0 < r / 2)
+      (hg.mono hsub) (hi.mono hsub) (hH.mono_left hsub)
+    refine ⟨hh.1, ?_⟩
+    convert hh.2 using 1
+    ring
+  apply Convex.lipschitzOnWith_of_nnnorm_fderiv_le (fun w hw => (hbound w hw).1) _
+    (convex_ball _ _)
+  intro w hw
+  exact_mod_cast (hbound w hw).2
+
+/-- Lipschitz guides have a uniformly Lipschitz logarithmic inverse height,
+even at their corners. -/
+theorem log_height_lipschitz
+    {g : ℂ → ℂ} {α : ℝ → ℂ} {δ T r : ℝ} (hr : 0 < r) (C : ℝ≥0)
+    (hL : LipschitzOnWith C α (Icc δ T))
+    (hg : ∀ t ∈ Icc δ T, DifferentiableOn ℂ g (ball (α t) r))
+    (hi : ∀ t ∈ Icc δ T, InjOn g (ball (α t) r))
+    (hH : ∀ t ∈ Icc δ T, MapsTo g (ball (α t) r) upperHalfPlane) :
+    LipschitzOnWith ⟨(256 * Real.pi * C) / r, by positivity⟩
+      (fun t => Real.log (g (α t)).im) (Icc δ T) := by
+  have hc : ContinuousOn (fun t => Real.log (g (α t)).im) (Icc δ T) := by
+    intro t ht
+    have hh := log_im_fderiv_bound hr (hg t ht) (hi t ht) (hH t ht)
+    exact hh.1.continuousAt.comp_continuousWithinAt (hL.continuousOn t ht)
+  apply lipschitzOn_of_local_bound (by positivity) hc
+  intro t ht
+  refine ⟨r / (4 * (C + 1)), by positivity, ?_⟩
+  intro u hu hdist
+  have hαdist : dist (α u) (α t) < r / 2 := by
+    have hb := hL.dist_le_mul u hu t ht
+    have hm := (mul_lt_mul_of_pos_left hdist (show (0 : ℝ) < 4 * (C + 1) by positivity))
+    have hm' : (4 * (C + 1)) * dist u t < r := by
+      simpa only [mul_div_cancel₀ _ (ne_of_gt (show (0 : ℝ) < 4 * (C + 1) by positivity))] using hm
+    have hd := dist_nonneg (x := u) (y := t)
+    nlinarith
+  have hlog := log_im_lipschitz_on_half_ball hr (hg t ht) (hi t ht) (hH t ht)
+  have hb := hlog.dist_le_mul (α u) (mem_ball.mpr hαdist)
+    (α t) (mem_ball_self (by positivity : 0 < r / 2))
+  exact hb.trans (by
+    change (256 * Real.pi / r) * dist (α u) (α t) ≤ _
+    calc
+      _ ≤ (256 * Real.pi / r) * (C * dist u t) :=
+        mul_le_mul_of_nonneg_left (hL.dist_le_mul u hu t ht) (by positivity)
+      _ = _ := by ring)
+
+/-- A holomorphic derivative bounds the distance quotient from its center
+in some neighborhood; no regularity of a curve composed with it is needed. -/
+theorem holomorphic_local_distance_bound
+    {g : ℂ → ℂ} {z : ℂ} (hg : DifferentiableAt ℂ g z) :
+    ∃ ε : ℝ, 0 < ε ∧ ∀ w, dist w z < ε →
+      dist (g w) (g z) ≤ (‖deriv g z‖ + 1) * dist w z := by
+  have he := hg.hasFDerivAt.isLittleO.bound (show (0 : ℝ) < 1 by norm_num)
+  obtain ⟨ε, hε, hball⟩ := Metric.mem_nhds_iff.mp he
+  refine ⟨ε, hε, ?_⟩
+  intro w hw
+  have hh := hball (mem_ball.mpr hw)
+  change ‖g w - g z - (fderiv ℂ g z) (w - z)‖ ≤ 1 * ‖w - z‖ at hh
+  have hlin : ‖(fderiv ℂ g z) (w - z)‖ = ‖deriv g z‖ * ‖w - z‖ := by
+    rw [fderiv_eq_smul_deriv, smul_eq_mul, norm_mul, mul_comm]
+  rw [dist_eq_norm, dist_eq_norm]
+  calc
+    ‖g w - g z‖ ≤ ‖g w - g z - (fderiv ℂ g z) (w - z)‖ +
+        ‖(fderiv ℂ g z) (w - z)‖ := by
+      simpa only [add_comm] using norm_le_insert' (g w - g z) ((fderiv ℂ g z) (w - z))
+    _ ≤ 1 * ‖w - z‖ + ‖deriv g z‖ * ‖w - z‖ := by
+      rw [hlin]
+      exact add_le_add hh le_rfl
+    _ = (‖deriv g z‖ + 1) * ‖w - z‖ := by ring
+
+theorem height_bounds_from_waypoint
+    {g : ℂ → ℂ} {α : ℝ → ℂ} {δ T tw r s : ℝ}
+    (hr : 0 < r) (C : ℝ≥0) (hs : 0 < s) (htw : tw ∈ Icc δ T)
+    (hL : LipschitzOnWith C α (Icc δ T))
+    (hg : ∀ t ∈ Icc δ T, DifferentiableOn ℂ g (ball (α t) r))
+    (hi : ∀ t ∈ Icc δ T, InjOn g (ball (α t) r))
+    (hH : ∀ t ∈ Icc δ T, MapsTo g (ball (α t) r) upperHalfPlane)
+    (hway : ‖g (α tw)‖ = 1) (hangle : s ≤ (g (α tw)).im) :
+    ∀ t ∈ Icc δ T,
+      s * Real.exp (-((256 * Real.pi * C) / r) * (T - δ)) ≤ (g (α t)).im ∧
+      (g (α t)).im ≤ Real.exp (((256 * Real.pi * C) / r) * (T - δ)) := by
+  let K := (256 * Real.pi * C) / r
+  have hK : 0 ≤ K := by dsimp [K]; positivity
+  have hlog := log_height_lipschitz hr C hL hg hi hH
+  have hpos (t : ℝ) (ht : t ∈ Icc δ T) : 0 < (g (α t)).im :=
+    hH t ht (mem_ball_self hr)
+  have hlogway : Real.log (g (α tw)).im ≤ 0 :=
+    Real.log_nonpos (hpos tw htw).le ((Complex.im_le_norm _).trans_eq hway)
+  have hlogs : Real.log s ≤ Real.log (g (α tw)).im := Real.log_le_log hs hangle
+  intro t ht
+  have hd := HyperbolicGuideCompactness.interval_dist_le_width ht htw
+  have hh := hlog.dist_le_mul t ht tw htw
+  change dist (Real.log (g (α t)).im) (Real.log (g (α tw)).im) ≤ K * dist t tw at hh
+  have hh' := hh.trans (mul_le_mul_of_nonneg_left hd hK)
+  rw [Real.dist_eq] at hh'
+  have hlo : Real.log s + (-K * (T - δ)) ≤ Real.log (g (α t)).im := by
+    linarith [(abs_le.mp hh').1]
+  have hup : Real.log (g (α t)).im ≤ K * (T - δ) := by
+    linarith [(abs_le.mp hh').2]
+  constructor
+  · calc
+      s * Real.exp (-K * (T - δ)) = Real.exp (Real.log s + (-K * (T - δ))) := by
+        rw [Real.exp_add, Real.exp_log hs]
+      _ ≤ Real.exp (Real.log (g (α t)).im) := Real.exp_le_exp.mpr hlo
+      _ = (g (α t)).im := Real.exp_log (hpos t ht)
+  · simpa only [Real.exp_log (hpos t ht)] using Real.exp_le_exp.mpr hup
+
+def euclideanSpeed (C r δ T : ℝ) : ℝ :=
+  ((128 * Real.pi / r) * Real.exp (((256 * Real.pi * C) / r) * (T - δ)) + 1) * C
+
+/-- Common clearance and a waypoint control the full inverse guide's speed
+for Lipschitz physical guides, including guides with corners. -/
+theorem inverse_guide_lipschitz
+    {g : ℂ → ℂ} {α : ℝ → ℂ} {δ T tw r s : ℝ}
+    (hr : 0 < r) (C : ℝ≥0) (hs : 0 < s) (htw : tw ∈ Icc δ T)
+    (hL : LipschitzOnWith C α (Icc δ T))
+    (hg : ∀ t ∈ Icc δ T, DifferentiableOn ℂ g (ball (α t) r))
+    (hi : ∀ t ∈ Icc δ T, InjOn g (ball (α t) r))
+    (hH : ∀ t ∈ Icc δ T, MapsTo g (ball (α t) r) upperHalfPlane)
+    (hway : ‖g (α tw)‖ = 1) (hangle : s ≤ (g (α tw)).im) :
+    LipschitzOnWith ⟨euclideanSpeed C r δ T, by dsimp [euclideanSpeed]; positivity⟩
+      (g ∘ α) (Icc δ T) := by
+  let M := (128 * Real.pi / r) * Real.exp (((256 * Real.pi * C) / r) * (T - δ)) + 1
+  have hM : 0 < M := by dsimp [M]; positivity
+  have hheight := height_bounds_from_waypoint hr C hs htw hL hg hi hH hway hangle
+  have hgd t (ht : t ∈ Icc δ T) : DifferentiableAt ℂ g (α t) :=
+    (hg t ht).differentiableAt (isOpen_ball.mem_nhds (mem_ball_self hr))
+  have hc : ContinuousOn (g ∘ α) (Icc δ T) := fun t ht =>
+    (hgd t ht).continuousAt.comp_continuousWithinAt (hL.continuousOn t ht)
+  apply lipschitzOn_of_local_bound (by dsimp [euclideanSpeed]; positivity) hc
+  intro t ht
+  obtain ⟨ε, hε, hlocal⟩ := holomorphic_local_distance_bound (hgd t ht)
+  refine ⟨ε / (C + 1), by positivity, ?_⟩
+  intro u hu hdist
+  have hαdist : dist (α u) (α t) < ε := by
+    have hm := (mul_lt_mul_of_pos_left hdist (show (0 : ℝ) < C + 1 by positivity))
+    have hm' : (C + 1) * dist u t < ε := by
+      simpa only [mul_div_cancel₀ _ (ne_of_gt (show (0 : ℝ) < C + 1 by positivity))] using hm
+    have hb := hL.dist_le_mul u hu t ht
+    nlinarith [dist_nonneg (x := u) (y := t)]
+  have hder := HyperbolicGuideCompactness.inverse_chart_derivative_bound hr (hg t ht) (hi t ht) (hH t ht)
+  have hderM : ‖deriv g (α t)‖ + 1 ≤ M := by
+    dsimp [M]
+    exact add_le_add (hder.trans (mul_le_mul_of_nonneg_left (hheight t ht).2 (by positivity))) le_rfl
+  change dist (g (α u)) (g (α t)) ≤ _
+  calc
+    _ ≤ (‖deriv g (α t)‖ + 1) * dist (α u) (α t) := hlocal _ hαdist
+    _ ≤ M * (C * dist u t) := mul_le_mul hderM (hL.dist_le_mul u hu t ht)
+      (dist_nonneg) hM.le
+    _ = euclideanSpeed C r δ T * dist u t := by simp only [euclideanSpeed, M, mul_assoc]
+
+def confinementSet (C r s δ T : ℝ) : Set ℂ :=
+  closedBall 0 (1 + euclideanSpeed C r δ T * (T - δ)) ∩
+    {z | s * Real.exp (-((256 * Real.pi * C) / r) * (T - δ)) ≤ z.im}
+
+theorem family_compact_containment
+    (g : ℕ → ℂ → ℂ) (α : ℕ → ℝ → ℂ) {δ T tw r s : ℝ}
+    (hr : 0 < r) (C : ℝ≥0) (hs : 0 < s) (htw : tw ∈ Icc δ T)
+    (hL : ∀ n, LipschitzOnWith C (α n) (Icc δ T))
+    (hg : ∀ n t, t ∈ Icc δ T → DifferentiableOn ℂ (g n) (ball (α n t) r))
+    (hi : ∀ n t, t ∈ Icc δ T → InjOn (g n) (ball (α n t) r))
+    (hH : ∀ n t, t ∈ Icc δ T → MapsTo (g n) (ball (α n t) r) upperHalfPlane)
+    (hway : ∀ n, ‖g n (α n tw)‖ = 1) (hangle : ∀ n, s ≤ (g n (α n tw)).im) :
+    ∃ Q : Set ℂ, IsCompact Q ∧ Q ⊆ upperHalfPlane ∧
+      (∀ n, MapsTo (g n ∘ α n) (Icc δ T) Q) ∧
+      UniformEquicontinuousOn (fun n => g n ∘ α n) (Icc δ T) := by
+  have hLip n := inverse_guide_lipschitz hr C hs htw (hL n) (hg n) (hi n) (hH n)
+    (hway n) (hangle n)
+  refine ⟨confinementSet C r s δ T,
+    (isCompact_closedBall _ _).inter_right (isClosed_le continuous_const Complex.continuous_im),
+    ?_, ?_, LipschitzOnWith.uniformEquicontinuousOn _ _ hLip⟩
+  · intro z hz
+    exact (mul_pos hs (Real.exp_pos _)).trans_le hz.2
+  · intro n t ht
+    refine ⟨?_, (height_bounds_from_waypoint hr C hs htw (hL n) (hg n) (hi n) (hH n)
+      (hway n) (hangle n) t ht).1⟩
+    have hd := (hLip n).dist_le_mul t ht tw htw
+    have hwidth := HyperbolicGuideCompactness.interval_dist_le_width ht htw
+    have hspeed : 0 ≤ euclideanSpeed C r δ T := by dsimp [euclideanSpeed]; positivity
+    have hh := hd.trans (mul_le_mul_of_nonneg_left hwidth hspeed)
+    change dist (g n (α n t)) (g n (α n tw)) ≤ euclideanSpeed C r δ T * (T - δ) at hh
+    have hn := norm_le_norm_add_const_of_dist_le hh
+    simpa only [mem_closedBall, dist_zero_right, Function.comp_apply, hway n] using hn
+
+end SLEExactGauge.LipschitzGuideConfinement
+
+end
+
+end OAI
diff --git a/lean/OAI/Probability/SLE/Geometry/LocalCrosscutSides.lean b/lean/OAI/Probability/SLE/Geometry/LocalCrosscutSides.lean
new file mode 100644
index 0000000000000000000000000000000000000000..45157d737f1140675f3fc5b064a5c29992a8e714
--- /dev/null
+++ b/lean/OAI/Probability/SLE/Geometry/LocalCrosscutSides.lean
@@ -0,0 +1,101 @@
+import OAI.Probability.SLE.Geometry.PublishedPlanarDiskOpenness
+
+namespace OAI
+
+/-! Opposite local sides of a straightened crosscut.  This is a deterministic
+consequence of disk-image openness and the intermediate value theorem.  It
+does not assume any classification of ribbon exits or harmonic measures. -/
+
+noncomputable section
+open Set Metric
+open scoped Topology
+
+namespace SLEExactGauge.CrosscutSides
+
+theorem positive_on_preconnected_of_nonzero
+    {X : Type*} [TopologicalSpace X] {S : Set X} (hS : IsPreconnected S)
+    {f : X → ℝ} (hf : ContinuousOn f S) (hn : ∀ z ∈ S, f z ≠ 0)
+    {a : X} (ha : a ∈ S) (hfa : 0 < f a) : ∀ z ∈ S, 0 < f z := by
+  intro z hz
+  by_contra hh
+  have hzneg : f z < 0 := lt_of_le_of_ne (le_of_not_gt hh) (hn z hz)
+  obtain ⟨w, hw, he⟩ := hS.intermediate_value hz ha hf ⟨hzneg.le, hfa.le⟩
+  exact hn w hw he
+
+theorem negative_on_preconnected_of_nonzero
+    {X : Type*} [TopologicalSpace X] {S : Set X} (hS : IsPreconnected S)
+    {f : X → ℝ} (hf : ContinuousOn f S) (hn : ∀ z ∈ S, f z ≠ 0)
+    {a : X} (ha : a ∈ S) (hfa : f a < 0) : ∀ z ∈ S, f z < 0 := by
+  have hh := positive_on_preconnected_of_nonzero hS hf.neg
+    (fun z hz => neg_ne_zero.mpr (hn z hz)) ha (neg_pos.mpr hfa)
+  intro z hz
+  exact neg_pos.mp (hh z hz)
+
+/-- An open image of a disk cannot send both sides of its horizontal
+diameter into the same side of the vertical axis.  The zero-set assumption
+is exactly the assertion that this diameter is the local crosscut. -/
+theorem opposite_half_disk_signs
+    (f : ℂ → ℂ) (x : ℂ) {r : ℝ} (hr : 0 < r)
+    (hf : ContinuousOn f (ball x r)) (ho : IsOpen (f '' ball x r))
+    (hfx : (f x).re = 0)
+    (hz : ∀ z ∈ ball x r, (f z).re = 0 ↔ z.im = 0) :
+    ((∀ z ∈ ball x r, 0 < z.im → 0 < (f z).re) ∧
+      (∀ z ∈ ball x r, z.im < 0 → (f z).re < 0)) ∨
+    ((∀ z ∈ ball x r, 0 < z.im → (f z).re < 0) ∧
+      (∀ z ∈ ball x r, z.im < 0 → 0 < (f z).re)) := by
+  let U := ball x r ∩ {z : ℂ | 0 < z.im}
+  let V := ball x r ∩ {z : ℂ | z.im < 0}
+  have hU : IsPreconnected U :=
+    ((convex_ball x r : Convex ℝ (ball x r)).inter
+      (convex_halfSpace_gt Complex.imLm.isLinear 0)).isPreconnected
+  have hV : IsPreconnected V :=
+    ((convex_ball x r : Convex ℝ (ball x r)).inter
+      (convex_halfSpace_lt Complex.imLm.isLinear 0)).isPreconnected
+  have hc := Complex.continuous_re.comp_continuousOn hf
+  have hnU : ∀ z ∈ U, (f z).re ≠ 0 :=
+    fun z hz' he => (ne_of_gt hz'.2) ((hz z hz'.1).mp he)
+  have hnV : ∀ z ∈ V, (f z).re ≠ 0 :=
+    fun z hz' he => (ne_of_lt hz'.2) ((hz z hz'.1).mp he)
+  obtain ⟨δ, hδ, hδsub⟩ := Metric.isOpen_iff.mp ho (f x)
+    (mem_image_of_mem f (mem_ball_self hr))
+  have hplus : f x + (δ / 2 : ℝ) ∈ ball (f x) δ := by
+    rw [mem_ball, dist_eq_norm, add_sub_cancel_left, Complex.norm_real,
+      Real.norm_eq_abs, abs_of_pos (by positivity : 0 < δ / 2)]
+    linarith
+  have hminus : f x - (δ / 2 : ℝ) ∈ ball (f x) δ := by
+    rw [mem_ball, dist_eq_norm, sub_sub_cancel_left, norm_neg, Complex.norm_real,
+      Real.norm_eq_abs, abs_of_pos (by positivity : 0 < δ / 2)]
+    linarith
+  obtain ⟨a, ha, hea⟩ := hδsub hplus
+  obtain ⟨b, hb, heb⟩ := hδsub hminus
+  have hapos : 0 < (f a).re := by rw [hea, Complex.add_re, Complex.ofReal_re, hfx]; positivity
+  have hbneg : (f b).re < 0 := by rw [heb, Complex.sub_re, Complex.ofReal_re, hfx]; linarith
+  have hai : a.im ≠ 0 := fun he => (ne_of_gt hapos) ((hz a ha).mpr he)
+  have hbi : b.im ≠ 0 := fun he => (ne_of_lt hbneg) ((hz b hb).mpr he)
+  rcases lt_or_gt_of_ne hai with han | hap
+  · have hVon := positive_on_preconnected_of_nonzero hV (hc.mono inter_subset_left)
+      hnV ⟨ha, han⟩ hapos
+    have hbp : 0 < b.im := by
+      rcases lt_or_gt_of_ne hbi with hbn | hbp
+      · exact False.elim ((not_lt_of_gt (hVon b ⟨hb, hbn⟩)) hbneg)
+      · exact hbp
+    have hUon := negative_on_preconnected_of_nonzero hU (hc.mono inter_subset_left)
+      hnU ⟨hb, hbp⟩ hbneg
+    exact Or.inr ⟨fun z hz' hi => hUon z ⟨hz', hi⟩,
+      fun z hz' hi => hVon z ⟨hz', hi⟩⟩
+  · have hUon := positive_on_preconnected_of_nonzero hU (hc.mono inter_subset_left)
+      hnU ⟨ha, hap⟩ hapos
+    have hbn : b.im < 0 := by
+      rcases lt_or_gt_of_ne hbi with hbn | hbp
+      · exact hbn
+      · exact False.elim ((not_lt_of_gt (hUon b ⟨hb, hbp⟩)) hbneg)
+    have hVon := negative_on_preconnected_of_nonzero hV (hc.mono inter_subset_left)
+      hnV ⟨hb, hbn⟩ hbneg
+    exact Or.inl ⟨fun z hz' hi => hUon z ⟨hz', hi⟩,
+      fun z hz' hi => hVon z ⟨hz', hi⟩⟩
+
+end SLEExactGauge.CrosscutSides
+
+end
+
+end OAI
diff --git a/lean/OAI/Probability/SLE/Geometry/LocalLogObstruction.lean b/lean/OAI/Probability/SLE/Geometry/LocalLogObstruction.lean
new file mode 100644
index 0000000000000000000000000000000000000000..abb8d9c21666b6b7d9ab13d26b9630af6731fe48
--- /dev/null
+++ b/lean/OAI/Probability/SLE/Geometry/LocalLogObstruction.lean
@@ -0,0 +1,104 @@
+import OAI.Probability.SLE.Stochastic.PlanarLogLifting
+
+namespace OAI
+
+/-! A locally injective isolated zero has nontrivial boundary monodromy.
+This is the local obstruction used for separating the sides of a crosscut. -/
+noncomputable section
+open Set Filter Metric Function
+open scoped Topology
+
+namespace SLEExactGauge
+
+lemma univalent_boundary_no_continuous_log (f : ℂ → ℂ) (r : ℝ) (hr : 0<r)
+    (hf : ContinuousOn f (closedBall 0 r)) (hi : InjOn f (closedBall 0 r))
+    (L : C(sphere (0:ℂ) r,ℂ)) (hL : ∀ z, Complex.exp (L z)=f z-f 0) : False := by
+  let S := sphere (0:ℂ) r
+  have : PreconnectedSpace S := isPreconnected_iff_preconnectedSpace.mp
+    (isPreconnected_sphere (by simp) 0 r)
+  have hn (z : S) : ‖(z:ℂ)‖=r := by simpa only [S,mem_sphere,dist_zero_right] using z.property
+  have hc : Continuous (fun z : S => f z) :=
+    hf.comp_continuous continuous_subtype_val (fun z => sphere_subset_closedBall z.property)
+  have hns (q : unitInterval × S) : -((q.1:ℂ)*(q.2:ℂ))∈closedBall (0:ℂ) r := by
+    rw [mem_closedBall,dist_zero_right,norm_neg,norm_mul,Complex.norm_real,Real.norm_eq_abs,
+      abs_of_nonneg q.1.property.1,hn]
+    simpa only [one_mul] using mul_le_mul_of_nonneg_right q.1.property.2 hr.le
+  let H : C(unitInterval × S,ℂ) := ⟨fun q => f q.2-f (-((q.1:ℂ)*(q.2:ℂ))),
+    (hc.comp continuous_snd).sub (hf.comp_continuous (by fun_prop) hns)⟩
+  have hH (q : unitInterval × S) : H q≠0 := by
+    intro he
+    have heq := hi (sphere_subset_closedBall q.2.property) (hns q) (sub_eq_zero.mp he)
+    have hz : (q.2:ℂ)≠0 := by
+      intro hz
+      have := hn q.2
+      rw [hz,norm_zero] at this
+      exact hr.ne' this.symm
+    have hp : (1+(q.1:ℂ))*(q.2:ℂ)=0 := by linear_combination heq
+    have hp0 := (mul_eq_zero.mp hp).resolve_right hz
+    have hpR : (1:ℝ)+(q.1:ℝ)=0 := by exact_mod_cast hp0
+    linarith [q.1.property.1]
+  obtain ⟨M,hM⟩ := continuous_log_at_end_of_homotopy H hH L (by intro z; simpa [H] using hL z)
+  let J : S → S := fun z => ⟨-z,by simpa only [S,mem_sphere,dist_zero_right,norm_neg] using z.property⟩
+  have hJ : Continuous J := continuous_subtype_val.neg.subtype_mk _
+  let F : C(S,ℂ) := ⟨fun z => f z-f (-z),hc.sub (hf.comp_continuous
+    continuous_subtype_val.neg (fun z => by
+      simpa only [mem_closedBall,dist_zero_right,norm_neg] using sphere_subset_closedBall z.property))⟩
+  apply no_continuous_log_of_odd_involution J hJ (fun z => Subtype.ext (neg_neg z.1)) F M
+    (fun z => by simpa [F,H] using hH (1,z))
+    (fun z => by dsimp [F,J]; rw [neg_neg]; ring)
+    (fun z => by simpa [F,H] using hM z)
+    ⟨r,by simp [S,abs_of_pos hr]⟩
+
+lemma isolated_zero_no_continuous_boundary_log (f : ℂ → ℂ) (r ρ : ℝ)
+    (hr : 0<r) (hρ : 0<ρ) (hρr : ρ≤r)
+    (hf : ContinuousOn f (closedBall 0 r))
+    (hz : ∀ z∈closedBall 0 r, f z=f 0 → z=0)
+    (hi : InjOn f (closedBall 0 ρ))
+    (L : C(sphere (0:ℂ) r,ℂ)) (hL : ∀ z, Complex.exp (L z)=f z-f 0) : False := by
+  let S := sphere (0:ℂ) r
+  let s (t : unitInterval) : ℝ := 1-(t:ℝ)+(t:ℝ)*(ρ/r)
+  have hs (t : unitInterval) : 0<s t ∧ s t≤1 := by
+    have hd : 0<ρ/r := div_pos hρ hr
+    have hle : ρ/r≤1 := (div_le_one hr).mpr hρr
+    constructor
+    · dsimp [s]
+      by_cases ht : (t:ℝ)=1
+      · simp [ht,hd]
+      · have hlt : (t:ℝ)<1 := lt_of_le_of_ne t.property.2 ht
+        nlinarith [mul_nonneg t.property.1 hd.le]
+    · dsimp [s]
+      nlinarith [mul_le_mul_of_nonneg_left hle t.property.1]
+  have hn (z : S) : ‖(z:ℂ)‖=r := by simpa only [S,mem_sphere,dist_zero_right] using z.property
+  have hscale (q : unitInterval × S) : (s q.1:ℂ)*(q.2:ℂ)∈closedBall (0:ℂ) r := by
+    rw [mem_closedBall,dist_zero_right,norm_mul,Complex.norm_real,Real.norm_eq_abs,
+      abs_of_pos (hs q.1).1,hn]
+    simpa only [one_mul] using mul_le_mul_of_nonneg_right (hs q.1).2 hr.le
+  let H : C(unitInterval × S,ℂ) := ⟨fun q => f ((s q.1:ℂ)*(q.2:ℂ))-f 0,
+    (hf.comp_continuous (by dsimp [s]; fun_prop) hscale).sub continuous_const⟩
+  have hH (q : unitInterval × S) : H q≠0 := by
+    intro he
+    have he0 := hz _ (hscale q) (sub_eq_zero.mp he)
+    have heq := congrArg norm he0
+    rw [norm_mul,Complex.norm_real,Real.norm_eq_abs,abs_of_pos (hs q.1).1,hn,norm_zero] at heq
+    exact (mul_pos (hs q.1).1 hr).ne' heq
+  obtain ⟨M,hM⟩ := continuous_log_at_end_of_homotopy H hH L (by intro z; simpa [H,s] using hL z)
+  let e : sphere (0:ℂ) ρ → S := fun z => ⟨((r/ρ:ℝ):ℂ)*(z:ℂ),by
+    rw [mem_sphere,dist_zero_right,norm_mul,Complex.norm_real,Real.norm_eq_abs,
+      abs_of_pos (div_pos hr hρ)]
+    have hnz : ‖(z:ℂ)‖=ρ := by simpa only [mem_sphere,dist_zero_right] using z.property
+    rw [hnz,div_mul_cancel₀ _ hρ.ne']⟩
+  have hec : Continuous e := (continuous_const.mul continuous_subtype_val).subtype_mk _
+  apply univalent_boundary_no_continuous_log f ρ hρ
+    (hf.mono (closedBall_subset_closedBall hρr)) hi (M.comp ⟨e,hec⟩)
+  intro z
+  have harg : ((ρ/r:ℝ):ℂ)*(((r/ρ:ℝ):ℂ)*(z:ℂ))=(z:ℂ) := by
+    push_cast
+    field_simp [hr.ne',hρ.ne']
+  simpa only [ContinuousMap.comp_apply,H,ContinuousMap.coe_mk,s,
+    Set.Icc.coe_one,sub_self,zero_add,one_mul,e,harg] using hM (e z)
+
+end SLEExactGauge
+
+end
+
+end OAI
diff --git a/lean/OAI/Probability/SLE/Geometry/LocallyUniformEvaluation.lean b/lean/OAI/Probability/SLE/Geometry/LocallyUniformEvaluation.lean
new file mode 100644
index 0000000000000000000000000000000000000000..7b986660b25f49ea483a9023be587d0b3c5e9fcb
--- /dev/null
+++ b/lean/OAI/Probability/SLE/Geometry/LocallyUniformEvaluation.lean
@@ -0,0 +1,43 @@
+import Mathlib.Topology.UniformSpace.LocallyUniformConvergence
+import Mathlib.Analysis.Complex.Basic
+
+namespace OAI
+
+/-! Evaluation at moving interior points of locally uniformly convergent complex maps. -/
+noncomputable section
+open Set Filter Metric
+open scoped Topology
+
+namespace SLEExactGauge
+
+lemma locallyUniform_evaluation_tendsto {D : Set ℂ} (hD : IsOpen D)
+    {f : ℕ → ℂ → ℂ} {F : ℂ → ℂ} (hF : ContinuousOn F D)
+    (hf : TendstoLocallyUniformlyOn f F atTop D)
+    {z : ℕ → ℂ} {a : ℂ} (ha : a∈D) (hz : Tendsto z atTop (𝓝 a)) :
+    Tendsto (fun n => f n (z n)) atTop (𝓝 (F a)) := by
+  have hFa : Tendsto (fun n => F (z n)) atTop (𝓝 (F a)) :=
+    (hF a ha).continuousAt (hD.mem_nhds ha) |>.tendsto.comp hz
+  apply Metric.tendsto_nhds.mpr
+  intro ε hε
+  obtain ⟨V,hV,hsmall⟩ := hf _ (dist_mem_uniformity (half_pos hε)) a ha
+  rw [hD.nhdsWithin_eq ha] at hV
+  filter_upwards [hsmall,hz.eventually hV,
+    Metric.tendsto_nhds.mp hFa (ε/2) (half_pos hε)] with n hn hzV hnF
+  have hh : dist (F (z n)) (f n (z n))<ε/2 := hn _ hzV
+  have htri := dist_triangle (f n (z n)) (F (z n)) (F a)
+  rw [dist_comm (f n (z n)) (F (z n))] at htri
+  linarith
+
+lemma locallyUniform_reindex {D : Set ℂ} {f : ℕ → ℂ → ℂ} {F : ℂ → ℂ}
+    (hf : TendstoLocallyUniformlyOn f F atTop D) {φ : ℕ → ℕ}
+    (hφ : Tendsto φ atTop atTop) :
+    TendstoLocallyUniformlyOn (fun n => f (φ n)) F atTop D := by
+  intro U hU z hz
+  obtain ⟨V,hV,hN⟩ := hf U hU z hz
+  exact ⟨V,hV,hφ.eventually hN⟩
+
+end SLEExactGauge
+
+end
+
+end OAI
diff --git a/lean/OAI/Probability/SLE/Geometry/LongitudinalCrossing.lean b/lean/OAI/Probability/SLE/Geometry/LongitudinalCrossing.lean
new file mode 100644
index 0000000000000000000000000000000000000000..e3fa4829ff4e17837269a410a6d63dbc0de9397a
--- /dev/null
+++ b/lean/OAI/Probability/SLE/Geometry/LongitudinalCrossing.lean
@@ -0,0 +1,96 @@
+import OAI.Probability.SLE.Geometry.RectangleCrossing
+import OAI.Probability.SLE.Gauge.PassageRetention
+
+namespace OAI
+
+/-! The last-rear/first-front portion of an arbitrary continuous past is a
+longitudinal rectangle crossing. Together with RectangleCrossing this
+proves the separation assertion used in the ribbon waypoint argument. -/
+
+noncomputable section
+open Set
+open scoped Topology
+
+namespace SLEExactGauge.RectangleCrossing
+
+theorem last_rear_before_first_front
+    (x : ℝ → ℝ) {T a b : ℝ} (hT : 0 < T) (hab : a < b)
+    (hx : ContinuousOn x (Icc 0 T)) (hstart : x 0 < a) (hend : b < x T) :
+    ∃ u v : ℝ, 0 ≤ u ∧ u < v ∧ v < T ∧ x u = a ∧ x v = b ∧
+      ∀ t ∈ Icc u v, x t ∈ Icc a b := by
+  obtain ⟨v, hv, hxv, hprior⟩ := PassageRetention.first_progress_crossing x hT hx
+    (hstart.trans hab) hend
+  let K := Icc (0 : ℝ) v ∩ x ⁻¹' {a}
+  have hKc : IsClosed K := (hx.mono (Icc_subset_Icc_right hv.2.le)).preimage_isClosed_of_isClosed
+    isClosed_Icc isClosed_singleton
+  have hK : IsCompact K := isCompact_Icc.of_isClosed_subset hKc inter_subset_left
+  have hKn : K.Nonempty := by
+    obtain ⟨t, ht, he⟩ := intermediate_value_Icc hv.1.le
+      (hx.mono (Icc_subset_Icc_right hv.2.le))
+      (show a ∈ Icc (x 0) (x v) by rw [hxv]; exact ⟨hstart.le, hab.le⟩)
+    exact ⟨t, ht, he⟩
+  obtain ⟨u, hu, hmax⟩ := hK.exists_isGreatest hKn
+  have hxu : x u = a := hu.2
+  have huv : u < v := lt_of_le_of_ne hu.1.2 (by
+    intro he
+    have hh := he ▸ hxu
+    rw [hxv] at hh
+    exact (ne_of_gt hab) hh)
+  refine ⟨u, v, hu.1.1, huv, hv.2, hxu, hxv, ?_⟩
+  intro t ht
+  refine ⟨?_, ?_⟩
+  · by_contra hn
+    have htx : x t < a := lt_of_not_ge hn
+    obtain ⟨s, hs, hxs⟩ := intermediate_value_Icc ht.2
+      (hx.mono (Icc_subset_Icc (hu.1.1.trans ht.1) hv.2.le))
+      (show a ∈ Icc (x t) (x v) by rw [hxv]; exact ⟨htx.le, hab.le⟩)
+    have hsK : s ∈ K := ⟨⟨(hu.1.1.trans ht.1).trans hs.1, hs.2⟩, hxs⟩
+    have hsu : s ≤ u := hmax hsK
+    have htu : t = u := le_antisymm (hs.1.trans hsu) ht.1
+    rw [htu, hxu] at htx
+    exact (lt_irrefl a) htx
+  · by_cases htv : t = v
+    · rw [htv, hxv]
+    · exact (hprior t ⟨hu.1.1.trans ht.1, lt_of_le_of_ne ht.2 htv⟩).le
+
+def intervalParam (u v t : ℝ) : ℝ := u + (v - u) * t
+
+theorem intervalParam_mem {u v t : ℝ} (huv : u ≤ v) (ht : t ∈ Icc (0 : ℝ) 1) :
+    intervalParam u v t ∈ Icc u v := by
+  have hp := mul_nonneg (sub_nonneg.mpr huv) ht.1
+  have hq := mul_le_mul_of_nonneg_left ht.2 (sub_nonneg.mpr huv)
+  dsimp [intervalParam]
+  constructor <;> linarith
+
+/-- The continuous past need not be simple. Its transverse separation
+comes from a compact crossing portion, whose endpoints are selected in
+the prescribed last-rear/first-front order. -/
+theorem transverse_crossing_hits_past
+    (p q : ℝ → ℂ) {T a b c d : ℝ} (hT : 0 < T) (hab : a < b) (hcd : c < d)
+    (hp : ContinuousOn p (Icc 0 T)) (hq : ContinuousOn q (Icc 0 1))
+    (hp0 : (p 0).re < a) (hpT : b < (p T).re)
+    (hpim : ∀ t ∈ Icc (0 : ℝ) T, (p t).im ∈ Icc c d)
+    (hqr : ∀ t ∈ Icc (0 : ℝ) 1, (q t).re ∈ Icc a b ∧ (q t).im ∈ Icc c d)
+    (hq0 : (q 0).im = c) (hq1 : (q 1).im = d) :
+    ∃ s ∈ Icc (0 : ℝ) T, ∃ t ∈ Icc (0 : ℝ) 1, p s = q t := by
+  have hx : ContinuousOn (fun t => (p t).re) (Icc 0 T) :=
+    Complex.continuous_re.comp_continuousOn hp
+  obtain ⟨u, v, hu, huv, hvT, hpu, hpv, hrect⟩ :=
+    last_rear_before_first_front (fun t => (p t).re) hT hab hx hp0 hpT
+  have hmap : MapsTo (intervalParam u v) (Icc (0 : ℝ) 1) (Icc 0 T) := by
+    intro t ht
+    exact (Icc_subset_Icc hu hvT.le) (intervalParam_mem huv.le ht)
+  have hparam : Continuous (intervalParam u v) := by unfold intervalParam; fun_prop
+  have hcomp : ContinuousOn (fun t => p (intervalParam u v t)) (Icc 0 1) :=
+    hp.comp hparam.continuousOn hmap
+  obtain ⟨s, hs, t, ht, he⟩ := paths_intersect_rectangle
+    (fun t => p (intervalParam u v t)) q a b c d hab hcd hcomp hq
+    (fun t ht => ⟨hrect _ (intervalParam_mem huv.le ht), hpim _ (hmap ht)⟩) hqr
+    (by simpa [intervalParam] using hpu) (by simpa [intervalParam] using hpv) hq0 hq1
+  exact ⟨intervalParam u v s, hmap hs, t, ht, he⟩
+
+end SLEExactGauge.RectangleCrossing
+
+end
+
+end OAI
diff --git a/lean/OAI/Probability/SLE/Geometry/MarkedAccessAngle.lean b/lean/OAI/Probability/SLE/Geometry/MarkedAccessAngle.lean
new file mode 100644
index 0000000000000000000000000000000000000000..1751300483d8ccd8eb67f1b4ffa28808ee66029a
--- /dev/null
+++ b/lean/OAI/Probability/SLE/Geometry/MarkedAccessAngle.lean
@@ -0,0 +1,97 @@
+import OAI.Probability.SLE.Geometry.ActualMarkedStraightening
+import OAI.Probability.SLE.Mass.MarkedTubeHarmonicMeasure
+import OAI.Probability.SLE.Geometry.MarkedSurvivingBall
+import OAI.Probability.SLE.Geometry.MarkedWindowEarly
+import OAI.Probability.SLE.Geometry.NormalizedLoewnerCharts
+
+namespace OAI
+
+/-! The marked-point angle follows from the actual complete access guide,
+two uniformly supported Brownian routes and the cited conformal exit law.
+This isolates explicit physical geometry for the serpentine application. -/
+
+noncomputable section
+open Set Filter MeasureTheory Metric
+open scoped Topology NNReal ENNReal
+
+namespace SLEExactGauge.Serpentine
+open RibbonCoordinates CrosscutSides Target
+
+theorem uniform_marked_access_angle
+    (hopen : PublishedPlanarDiskOpenness)
+    (hstraight : PublishedHalfPlaneCrosscutStraightening)
+    (hexit : PublishedHalfPlaneConformalExitLaw)
+    (hsupport : PublishedPlanarWienerUnitSupport) (W : WienerLaw) (hW : IsWiener W)
+    {a : ℝ} (ha : 0 < a) (ha1 : a ≤ 1) :
+    ∃ s₀ : ℝ, 0 < s₀ ∧ ∀ (U : ℝ≥0 → ℝ) (γ : ℝ≥0 → ℂ)
+      (G F : ℝ≥0 → ℂ → ℂ), IsCapacityTwoWitness U γ G F → Continuous U →
+      ∀ T : ℝ≥0, 0 < T →
+      (∀ S : ℝ≥0, S < T → γ T ∈ survivingDomain γ S) →
+      ∀ w : ℂ, ‖w‖ ≤ 1 → 2 * a < w.im →
+      (∀ q ∈ γ '' Icc 0 T, q.im ≤ w.im - 2 * a ∨ w.re + 2 * a ≤ q.re) →
+      ∀ α : ℝ≥0 → ℂ, Continuous α → Function.Injective α → α 0 = γ T →
+      (∀ u : ℝ≥0, 0 < u → α u ∈ survivingDomain γ T) →
+      Tendsto α atTop (cocompact ℂ) →
+      (∀ z ∈ ball (0 : ℂ) (a / 12),
+        (∃ u : ℝ≥0, 0 < u ∧ α u = markedCornerChart w z) ↔ z.im = 0) →
+      (∀ (right : Bool) (t : ℝ), t ∈ Icc (1 / 64 : ℝ) 3 → ∀ u : ℝ≥0, 0 < u →
+        a / 1000 ≤ dist (markedWindowRoute right w a t) (α u)) →
+      s₀ ≤ (G T w - (U T : ℂ)).im / ‖G T w - (U T : ℂ)‖ := by
+  let : IsProbabilityMeasure W := hW.isGaussianProcess.isProbabilityMeasure
+  obtain ⟨q, hq, hprob⟩ := uniform_marked_window_tube_probability hsupport W hW ha ha1
+  have hqfin : q ≠ ⊤ := ne_top_of_le_ne_top (measure_ne_top _ _)
+    (hprob false 0 (by simp))
+  have hqr : 0 < q.toReal := ENNReal.toReal_pos hq.ne' hqfin
+  refine ⟨2 * q.toReal, by positivity, ?_⟩
+  intro U γ G F hw hU T hT hfresh w hwn hwa hpast α hα hiα hα0 hαD hescape hlocus hclear
+  have hQD := marked_corner_ball_survives γ T w ha hwa hpast
+  obtain ⟨h, hreal, _, hzero, hloc, hloci, hlocz⟩ := actual_marked_access_straightening
+    hstraight hw hU T hT hfresh α hα hiα hα0 hαD hescape (markedCornerChart w) (a / 12) hQD hlocus
+  let g := fun z => G T z - (U T : ℂ)
+  let f := fun z => F T ((U T : ℂ) + z)
+  have hcharts := normalized_capacity_charts hw T 1 (by norm_num)
+  have hgeq : normalizedForward (G T) (U T) 1 = g := by funext z; simp [normalizedForward, g]
+  have hfeq : normalizedInverse (F T) (U T) 1 = f := by funext z; simp [normalizedInverse, f]
+  rw [hgeq, hfeq] at hcharts
+  obtain ⟨hf, _, hg, _, hfD, hgH, hgf, hfg⟩ := hcharts
+  have hwD : w ∈ survivingDomain γ T := marked_ball_survives γ T w ha hwa hpast (mem_ball_self ha)
+  have hgeom (right : Bool) (b : Driver × Driver)
+      (hb : ∀ t ∈ Icc (0 : ℝ) 3,
+        dist (physicalUnitBrownianPath w b t) (markedWindowRoute right w a t) < a / 10000) :
+      ∃ τ : ℝ, UnitWindowFirstExit (survivingDomain γ T) (physicalUnitBrownianPath w b) τ ∧
+        (1 / 64 : ℝ) < τ ∧ ∀ t ∈ Ico (1 / 64 : ℝ) τ,
+          (h (g (physicalUnitBrownianPath w b t))).re ≠ 0 := by
+    apply marked_tube_first_exit_geometry _ (isOpen_survivingDomain hw.1 T) g h α
+      (fun z hz he => (hzero z hz).mp he) _ (physicalUnitBrownianPath_continuous w b)
+    · intro t ht
+      apply marked_ball_survives γ T w ha hwa hpast
+      have hn := hb t ⟨ht.1, ht.2.trans (by norm_num)⟩
+      have hd := (dist_triangle (physicalUnitBrownianPath w b t)
+        (markedWindowRoute right w a t) w).trans_lt
+        (add_lt_add_of_lt_of_le hn (markedWindowRoute_early_dist right w ha.le ht))
+      change dist _ w < a
+      linarith
+    · intro hz
+      have hn := hb 3 (by norm_num)
+      have hi := (Complex.abs_im_le_norm
+        (physicalUnitBrownianPath w b 3 - markedWindowRoute right w a 3)).trans_lt
+        (show ‖physicalUnitBrownianPath w b 3 - markedWindowRoute right w a 3‖ < a / 10000 by
+          simpa only [dist_eq_norm] using hn)
+      rw [Complex.sub_im, markedWindowRoute_final] at hi
+      have him : 0 < (physicalUnitBrownianPath w b 3).im := hz.1.1
+      linarith [(abs_lt.mp hi).2]
+    · intro t ht u hu he
+      have hn := hb t ⟨by linarith [ht.1], ht.2⟩
+      rw [he, dist_comm] at hn
+      have hc := hclear right t ht u hu
+      linarith
+  obtain ⟨hl, hr⟩ := marked_tubes_harmonic_bounds hopen hexit W hW _
+    (isOpen_survivingDomain hw.1 T) (fun z hz => hz.1.1) g f hg hf hgH hfD hfg hgf w hwD ha
+    h hreal hloc hloci hlocz q (fun right => hprob right w hwn) hgeom
+  exact (positive_angle_of_two_exit_probability_bounds hq (hgH hwD) hl hr).2
+
+end SLEExactGauge.Serpentine
+
+end
+
+end OAI
diff --git a/lean/OAI/Probability/SLE/Geometry/MarkedAccessHook.lean b/lean/OAI/Probability/SLE/Geometry/MarkedAccessHook.lean
new file mode 100644
index 0000000000000000000000000000000000000000..ea872c9e2fa329eb00e9d86ad0561c40936b1192
--- /dev/null
+++ b/lean/OAI/Probability/SLE/Geometry/MarkedAccessHook.lean
@@ -0,0 +1,236 @@
+import OAI.Probability.SLE.Geometry.CurveJoin
+import OAI.Probability.SLE.Gauge.SerpentineExperimentGeometry
+
+namespace OAI
+
+/-! A proper polygonal continuation from the high right-hand tail of
+the serpentine through the marked point and then to infinity on its left. -/
+
+noncomputable section
+open Set Filter Metric
+open scoped Topology NNReal
+
+namespace SLEExactGauge.Serpentine
+
+def hookTop (_w : ℂ) (R H t : ℝ) : ℂ := ((R - t : ℝ) : ℂ) + (H : ℂ) * Complex.I
+
+def hookDown (w : ℂ) (R H t : ℝ) : ℂ :=
+  (w.re : ℂ) + ((H - (t - (R - w.re)) : ℝ) : ℂ) * Complex.I
+
+def hookLeft (w : ℂ) (R H t : ℝ) : ℂ :=
+  ((w.re - (t - ((R - w.re) + (H - w.im))) : ℝ) : ℂ) + (w.im : ℂ) * Complex.I
+
+def hookUp (w : ℂ) (R H a t : ℝ) : ℂ :=
+  ((w.re - a : ℝ) : ℂ) + ((w.im + t - ((R - w.re) + (H - w.im) + a) : ℝ) : ℂ) * Complex.I
+
+def markedHook (w : ℂ) (R H a : ℝ) : ℝ → ℂ :=
+  curveJoin (R - w.re) (hookTop w R H)
+    (curveJoin ((R - w.re) + (H - w.im)) (hookDown w R H)
+      (curveJoin ((R - w.re) + (H - w.im) + a) (hookLeft w R H) (hookUp w R H a)))
+
+lemma markedHook_zero (w : ℂ) {R H a : ℝ} (hR : w.re < R) :
+    markedHook w R H a 0 = (R : ℂ) + (H : ℂ) * Complex.I := by
+  simp only [markedHook, curveJoin_of_le (show (0 : ℝ) ≤ R - w.re by linarith), hookTop,
+    sub_zero]
+
+lemma markedHook_continuous (w : ℂ) (R : ℝ) {H a : ℝ} (hH : w.im < H) (ha : 0 < a) :
+    Continuous (markedHook w R H a) := by
+  have htop : Continuous (hookTop w R H) := by unfold hookTop; fun_prop
+  have hdown : Continuous (hookDown w R H) := by unfold hookDown; fun_prop
+  have hleft : Continuous (hookLeft w R H) := by unfold hookLeft; fun_prop
+  have hup : Continuous (hookUp w R H a) := by unfold hookUp; fun_prop
+  have h1 : hookTop w R H (R - w.re) = hookDown w R H (R - w.re) := by
+    unfold hookTop hookDown
+    push_cast
+    ring
+  have h2 : hookDown w R H ((R - w.re) + (H - w.im)) =
+      hookLeft w R H ((R - w.re) + (H - w.im)) := by
+    unfold hookDown hookLeft
+    push_cast
+    ring
+  have h3 : hookLeft w R H ((R - w.re) + (H - w.im) + a) =
+      hookUp w R H a ((R - w.re) + (H - w.im) + a) := by
+    unfold hookLeft hookUp
+    push_cast
+    ring
+  unfold markedHook
+  apply curveJoin_continuous _ _ _ htop
+  · exact curveJoin_continuous _ _ _ hdown (curveJoin_continuous _ _ _ hleft hup h3) (by
+      rw [curveJoin_of_le (show (R - w.re) + (H - w.im) ≤ (R - w.re) + (H - w.im) + a by linarith)]
+      exact h2)
+  · rw [curveJoin_of_le (show R - w.re ≤ (R - w.re) + (H - w.im) by linarith)]
+    exact h1
+
+lemma markedHook_pieces (w : ℂ) {R H a t : ℝ} (_hR : w.re < R) (_hH : w.im < H)
+    (_ha : 0 < a) (ht : 0 ≤ t) :
+    (t ∈ Icc 0 (R - w.re) ∧ markedHook w R H a t = hookTop w R H t) ∨
+    (t ∈ Icc (R - w.re) ((R - w.re) + (H - w.im)) ∧
+      markedHook w R H a t = hookDown w R H t) ∨
+    (t ∈ Icc ((R - w.re) + (H - w.im)) ((R - w.re) + (H - w.im) + a) ∧
+      markedHook w R H a t = hookLeft w R H t) ∨
+    ((R - w.re) + (H - w.im) + a ≤ t ∧ markedHook w R H a t = hookUp w R H a t) := by
+  by_cases h1 : t ≤ R - w.re
+  · exact Or.inl ⟨⟨ht, h1⟩, by unfold markedHook; rw [curveJoin_of_le h1]⟩
+  · right
+    by_cases h2 : t ≤ (R - w.re) + (H - w.im)
+    · exact Or.inl ⟨⟨by linarith, h2⟩, by simp only [markedHook,
+        curveJoin_of_gt (lt_of_not_ge h1), curveJoin_of_le h2]⟩
+    · right
+      by_cases h3 : t ≤ (R - w.re) + (H - w.im) + a
+      · exact Or.inl ⟨⟨by linarith, h3⟩, by simp only [markedHook,
+          curveJoin_of_gt (lt_of_not_ge h1), curveJoin_of_gt (lt_of_not_ge h2), curveJoin_of_le h3]⟩
+      · exact Or.inr ⟨by linarith, by simp only [markedHook,
+          curveJoin_of_gt (lt_of_not_ge h1), curveJoin_of_gt (lt_of_not_ge h2),
+          curveJoin_of_gt (lt_of_not_ge h3)]⟩
+
+lemma markedHook_injective (w : ℂ) {R H a : ℝ} (hR : w.re < R) (hH : w.im < H)
+    (ha : 0 < a) : InjOn (markedHook w R H a) (Ici 0) := by
+  intro s hs t ht he
+  rcases markedHook_pieces w hR hH ha hs with ⟨hs, hse⟩ | ⟨hs, hse⟩ | ⟨hs, hse⟩ | ⟨hs, hse⟩ <;>
+    rcases markedHook_pieces w hR hH ha ht with ⟨ht, hte⟩ | ⟨ht, hte⟩ | ⟨ht, hte⟩ | ⟨ht, hte⟩
+  all_goals
+    rw [hse, hte] at he
+    have hre := congrArg Complex.re he
+    have him := congrArg Complex.im he
+    simp only [hookTop, hookDown, hookLeft, hookUp, Complex.add_re, Complex.add_im,
+      Complex.mul_re, Complex.mul_im, Complex.ofReal_re, Complex.ofReal_im,
+      Complex.I_re, Complex.I_im, mul_zero, mul_one, sub_zero, add_zero, zero_add] at hre him
+    try simp only [mem_Icc] at hs ht
+    linarith [hs, ht]
+
+lemma markedHook_passes_marked (w : ℂ) {R H a : ℝ} (hH : w.im < H) :
+    markedHook w R H a ((R - w.re) + (H - w.im)) = w := by
+  have h1 : R - w.re < (R - w.re) + (H - w.im) := by linarith
+  simp only [markedHook, curveJoin_of_gt h1, curveJoin_of_le le_rfl, hookDown]
+  convert Complex.re_add_im w using 1
+  push_cast
+  ring
+
+lemma markedHook_tail_region (w : ℂ) {R H a t : ℝ} (hR : w.re < R) (hH : w.im < H)
+    (ha : 0 < a) (ht : 0 ≤ t) :
+    (markedHook w R H a t).im = H ∨
+      ((markedHook w R H a t).re ≤ w.re ∧ w.im ≤ (markedHook w R H a t).im) := by
+  rcases markedHook_pieces w hR hH ha ht with ⟨_, he⟩ | ⟨ht, he⟩ | ⟨ht, he⟩ | ⟨ht, he⟩
+  · left
+    rw [he]
+    simp [hookTop]
+  all_goals
+    right
+    rw [he]
+    simp only [hookDown, hookLeft, hookUp, Complex.add_re, Complex.add_im,
+      Complex.mul_re, Complex.mul_im, Complex.ofReal_re, Complex.ofReal_im,
+      Complex.I_re, Complex.I_im, mul_zero, mul_one, sub_zero, add_zero, zero_add]
+    try simp only [mem_Icc] at ht
+    constructor <;> linarith [ht]
+
+lemma markedHook_disjoint_prefix (w : ℂ) {R H a : ℝ} (hR : w.re < R) (hH : w.im < H)
+    (ha : 0 < a) (z : ℂ) (hzH : z.im < H) (hz : z.im < w.im ∨ w.re < z.re)
+    {t : ℝ} (ht : 0 ≤ t) : z ≠ markedHook w R H a t := by
+  intro he
+  rw [he] at hzH hz
+  rcases markedHook_tail_region w hR hH ha ht with hh | hh
+  · linarith
+  · rcases hz with hz | hz <;> linarith [hh.1, hh.2]
+
+lemma markedHook_tail (w : ℂ) {R H a t : ℝ} (hH : w.im < H) (ha : 0 < a)
+    (ht : (R - w.re) + (H - w.im) + a < t) :
+    markedHook w R H a t = hookUp w R H a t := by
+  simp only [markedHook,
+    curveJoin_of_gt (show R - w.re < t by linarith),
+    curveJoin_of_gt (show (R - w.re) + (H - w.im) < t by linarith), curveJoin_of_gt ht]
+
+lemma markedHook_unbounded (w : ℂ) {R H a : ℝ} (hR : w.re < R) (hH : w.im < H)
+    (ha : 0 < a) : ¬ Bornology.IsBounded (range (fun t : ℝ≥0 => markedHook w R H a t)) := by
+  intro hb
+  obtain ⟨B, hB, hbound⟩ := hb.exists_pos_norm_lt
+  let t : ℝ≥0 := ⟨(R - w.re) + (H - w.im) + a + B + |w.im| + 1, by positivity⟩
+  have htval : (t : ℝ) = (R - w.re) + (H - w.im) + a + B + |w.im| + 1 := rfl
+  have ht : (R - w.re) + (H - w.im) + a < (t : ℝ) := by
+    rw [htval]
+    linarith [abs_nonneg w.im]
+  have hn := hbound (markedHook w R H a t) (mem_range_self t)
+  have hi := Complex.im_le_norm (markedHook w R H a t)
+  rw [markedHook_tail w hH ha ht] at hi hn
+  simp only [hookUp, Complex.add_im, Complex.ofReal_im, Complex.mul_im,
+    Complex.ofReal_re, Complex.I_re, Complex.I_im, mul_zero, mul_one, add_zero, zero_add] at hi
+  rw [htval] at hi hn
+  dsimp only [hookUp] at hn
+  linarith [neg_le_abs w.im]
+
+theorem markedHook_survives
+    (γ : ℝ≥0 → ℂ) (T : ℝ≥0) (w : ℂ) (hw : 0 < w.im)
+    {R H a : ℝ} (hR : w.re < R) (hH : w.im < H) (ha : 0 < a)
+    (hpast : ∀ z ∈ γ '' Icc 0 T, z.im < H ∧ (z.im < w.im ∨ w.re < z.re)) :
+    range (fun t : ℝ≥0 => markedHook w R H a t) ⊆ survivingDomain γ T := by
+  apply survives_of_unbounded_free_curve γ T _
+    ((markedHook_continuous w R hH ha).comp NNReal.continuous_coe) ?_
+    (markedHook_unbounded w hR hH ha)
+  rintro z ⟨t, rfl⟩
+  have hregion := markedHook_tail_region w hR hH ha t.coe_nonneg
+  refine ⟨?_, ?_⟩
+  · change 0 < (markedHook w R H a t).im
+    rcases hregion with he | hh <;> linarith
+  · intro hp
+    exact markedHook_disjoint_prefix w hR hH ha _ (hpast _ hp).1 (hpast _ hp).2 t.coe_nonneg rfl
+
+def appendMarkedHook (α : ℝ → ℂ) (T : ℝ) (w : ℂ) (R H a : ℝ) : ℝ → ℂ :=
+  curveJoin T α (fun t => markedHook w R H a (t - T))
+
+lemma appendMarkedHook_continuous (α : ℝ → ℂ) (hα : Continuous α) (T : ℝ)
+    (w : ℂ) {R H a : ℝ} (hR : w.re < R) (hH : w.im < H) (ha : 0 < a)
+    (hαT : α T = (R : ℂ) + (H : ℂ) * Complex.I) :
+    Continuous (appendMarkedHook α T w R H a) := by
+  apply curveJoin_continuous _ _ _ hα
+  · exact (markedHook_continuous w R hH ha).comp (continuous_id.sub continuous_const)
+  · simpa only [sub_self, markedHook_zero w hR] using hαT
+
+lemma appendMarkedHook_injective (α : ℝ → ℂ) {T : ℝ} (_hT : 0 ≤ T)
+    (hαinj : InjOn α (Icc 0 T)) (w : ℂ) {R H a : ℝ}
+    (hR : w.re < R) (hH : w.im < H) (ha : 0 < a)
+    (hαT : α T = (R : ℂ) + (H : ℂ) * Complex.I)
+    (hregion : ∀ t ∈ Ico 0 T, (α t).im < H ∧ ((α t).im < w.im ∨ w.re < (α t).re)) :
+    InjOn (appendMarkedHook α T w R H a) (Ici 0) := by
+  intro s hs t ht he
+  have hzero : (0 : ℝ) ∈ Ici (0 : ℝ) := show (0 : ℝ) ≤ 0 from le_rfl
+  by_cases hsT : s ≤ T
+  · by_cases htT : t ≤ T
+    · apply hαinj ⟨hs, hsT⟩ ⟨ht, htT⟩
+      simpa only [appendMarkedHook, curveJoin_of_le hsT, curveJoin_of_le htT] using he
+    · have htT' : T < t := lt_of_not_ge htT
+      simp only [appendMarkedHook, curveJoin_of_le hsT, curveJoin_of_gt htT'] at he
+      rcases eq_or_lt_of_le hsT with hsEq | hsT'
+      · rw [hsEq, hαT, ← markedHook_zero w (a := a) hR] at he
+        have hx := markedHook_injective w hR hH ha hzero
+          (show t - T ∈ Ici (0 : ℝ) by change 0 ≤ t - T; linarith) he
+        linarith
+      · exact (markedHook_disjoint_prefix w hR hH ha (α s)
+          (hregion s ⟨hs, hsT'⟩).1 (hregion s ⟨hs, hsT'⟩).2 (by linarith) he).elim
+  · have hsT' : T < s := lt_of_not_ge hsT
+    by_cases htT : t ≤ T
+    · simp only [appendMarkedHook, curveJoin_of_gt hsT', curveJoin_of_le htT] at he
+      rcases eq_or_lt_of_le htT with htEq | htT'
+      · rw [htEq, hαT, ← markedHook_zero w (a := a) hR] at he
+        have hx := markedHook_injective w hR hH ha
+          (show s - T ∈ Ici (0 : ℝ) by change 0 ≤ s - T; linarith) hzero he
+        linarith
+      · exact (markedHook_disjoint_prefix w hR hH ha (α t)
+          (hregion t ⟨ht, htT'⟩).1 (hregion t ⟨ht, htT'⟩).2 (by linarith) he.symm).elim
+    · have htT' : T < t := lt_of_not_ge htT
+      simp only [appendMarkedHook, curveJoin_of_gt hsT', curveJoin_of_gt htT'] at he
+      have hx := markedHook_injective w hR hH ha
+        (show s - T ∈ Ici 0 by change 0 ≤ s - T; linarith)
+        (show t - T ∈ Ici 0 by change 0 ≤ t - T; linarith) he
+      linarith
+
+lemma appendMarkedHook_passes_marked (α : ℝ → ℂ) (T : ℝ) (w : ℂ) {R H a : ℝ}
+    (hR : w.re < R) (hH : w.im < H) :
+    appendMarkedHook α T w R H a (T + ((R - w.re) + (H - w.im))) = w := by
+  have hT : T < T + ((R - w.re) + (H - w.im)) := by linarith
+  simp only [appendMarkedHook, curveJoin_of_gt hT, add_sub_cancel_left]
+  exact markedHook_passes_marked w hH
+
+end SLEExactGauge.Serpentine
+
+end
+
+end OAI
diff --git a/lean/OAI/Probability/SLE/Geometry/MarkedCornerBounds.lean b/lean/OAI/Probability/SLE/Geometry/MarkedCornerBounds.lean
new file mode 100644
index 0000000000000000000000000000000000000000..927cbbd1b6307fedc3d602d9a747436f6db048aa
--- /dev/null
+++ b/lean/OAI/Probability/SLE/Geometry/MarkedCornerBounds.lean
@@ -0,0 +1,119 @@
+import OAI.Probability.SLE.Geometry.MarkedCornerChart
+
+namespace OAI
+
+/-! Quantitative local chart bounds for the marked corner. -/
+
+noncomputable section
+open Set Metric
+
+namespace SLEExactGauge.Serpentine
+
+private lemma abs_max_diff_add_abs_min_diff (x y : ℝ) :
+    |max x 0 - max y 0| + |min x 0 - min y 0| = |x - y| := by
+  have hx := max_add_min x (0 : ℝ)
+  have hy := max_add_min y (0 : ℝ)
+  by_cases h : y ≤ x
+  · rw [abs_of_nonneg (sub_nonneg.mpr (max_le_max h le_rfl)),
+      abs_of_nonneg (sub_nonneg.mpr (min_le_min h le_rfl)),
+      abs_of_nonneg (sub_nonneg.mpr h)]
+    linarith
+  · have h' : x ≤ y := le_of_not_ge h
+    rw [abs_of_nonpos (sub_nonpos.mpr (max_le_max h' le_rfl)),
+      abs_of_nonpos (sub_nonpos.mpr (min_le_min h' le_rfl)),
+      abs_of_nonpos (sub_nonpos.mpr h')]
+    linarith
+
+lemma cornerMap_lipschitz : LipschitzWith 3 cornerMap := by
+  apply LipschitzWith.of_dist_le_mul
+  intro z w
+  have hre : |(cornerMap z - cornerMap w).re| ≤
+      |max z.re 0 - max w.re 0| + |z.im - w.im| := by
+    have he : (cornerMap z - cornerMap w).re =
+        -(max z.re 0 - max w.re 0) + (z.im - w.im) := by
+      simp [cornerMap]
+      ring
+    rw [he]
+    simpa only [abs_neg] using abs_add_le (-(max z.re 0 - max w.re 0)) (z.im - w.im)
+  have him : |(cornerMap z - cornerMap w).im| ≤
+      |min z.re 0 - min w.re 0| + |z.im - w.im| := by
+    have he : (cornerMap z - cornerMap w).im =
+        -(min z.re 0 - min w.re 0) - (z.im - w.im) := by
+      simp [cornerMap]
+      ring
+    rw [he]
+    simpa only [abs_neg] using abs_sub (-(min z.re 0 - min w.re 0)) (z.im - w.im)
+  have hpart := abs_max_diff_add_abs_min_diff z.re w.re
+  have hr := Complex.abs_re_le_norm (z - w)
+  have hi := Complex.abs_im_le_norm (z - w)
+  simp only [Complex.sub_re, Complex.sub_im] at hr hi
+  have hb := Complex.norm_le_abs_re_add_abs_im (cornerMap z - cornerMap w)
+  rw [dist_eq_norm, dist_eq_norm]
+  norm_num only [NNReal.coe_ofNat]
+  linarith
+
+private lemma cornerInv_im (z : ℂ) : (cornerInv z).im = max z.re (-z.im) := by
+  simp only [cornerInv, Complex.add_im, Complex.ofReal_im, Complex.mul_im,
+    Complex.ofReal_re, Complex.I_im, Complex.I_re, mul_one, mul_zero, add_zero, zero_add]
+  by_cases h : 0 ≤ -z.re - z.im
+  · rw [max_eq_left h, max_eq_right (by linarith : z.re ≤ -z.im)]
+    ring
+  · rw [max_eq_right (le_of_not_ge h), max_eq_left (by linarith : -z.im ≤ z.re)]
+    ring
+
+lemma markedCornerChart_symm_im (w z : ℂ) :
+    ((markedCornerChart w).symm z).im = max (z.re - w.re) (w.im - z.im) := by
+  change (cornerInv (z - w)).im = _
+  rw [cornerInv_im]
+  simp only [Complex.sub_re, Complex.sub_im, neg_sub]
+
+lemma cornerInv_lipschitz : LipschitzWith 3 cornerInv := by
+  apply LipschitzWith.of_dist_le_mul
+  intro z w
+  have hr := Complex.abs_re_le_norm (z - w)
+  have hi := Complex.abs_im_le_norm (z - w)
+  simp only [Complex.sub_re, Complex.sub_im] at hr hi
+  have hre : |(cornerInv z - cornerInv w).re| ≤ |z.re - w.re| + |z.im - w.im| := by
+    have he : (cornerInv z - cornerInv w).re = -((z.re - w.re) + (z.im - w.im)) := by
+      simp [cornerInv]
+      ring
+    rw [he, abs_neg]
+    exact abs_add_le (z.re - w.re) (z.im - w.im)
+  have him : |(cornerInv z - cornerInv w).im| ≤ ‖z - w‖ := by
+    rw [Complex.sub_im, cornerInv_im, cornerInv_im]
+    apply (abs_max_sub_max_le_max _ _ _ _).trans
+    exact max_le hr (by simpa only [neg_sub_neg, abs_sub_comm] using hi)
+  have hb := Complex.norm_le_abs_re_add_abs_im (cornerInv z - cornerInv w)
+  rw [dist_eq_norm, dist_eq_norm]
+  norm_num only [NNReal.coe_ofNat]
+  linarith
+
+lemma markedCornerChart_lipschitz (w : ℂ) : LipschitzWith 3 (markedCornerChart w) := by
+  apply LipschitzWith.of_dist_le_mul
+  intro z z'
+  change dist (w + cornerMap z) (w + cornerMap z') ≤ _
+  simpa only [dist_add_left] using cornerMap_lipschitz.dist_le_mul z z'
+
+lemma markedCornerChart_inverse_lipschitz (w : ℂ) :
+    LipschitzWith 3 (markedCornerChart w).symm := by
+  apply LipschitzWith.of_dist_le_mul
+  intro z z'
+  change dist (cornerInv (z - w)) (cornerInv (z' - w)) ≤ _
+  simpa only [dist_sub_right] using cornerInv_lipschitz.dist_le_mul (z - w) (z' - w)
+
+lemma markedCornerChart_norm (w z : ℂ) : dist (markedCornerChart w z) w ≤ 3 * ‖z‖ := by
+  have h := (markedCornerChart_lipschitz w).dist_le_mul z 0
+  simpa only [markedCornerChart_zero, dist_zero_right, NNReal.coe_ofNat] using h
+
+lemma markedCornerChart_norm_lower (w z : ℂ) : ‖z‖ ≤ 3 * dist (markedCornerChart w z) w := by
+  have h := (markedCornerChart_inverse_lipschitz w).dist_le_mul (markedCornerChart w z) w
+  have hw : (markedCornerChart w).symm w = 0 := by
+    apply (markedCornerChart w).injective
+    simp only [Homeomorph.apply_symm_apply, markedCornerChart_zero]
+  simpa only [Homeomorph.symm_apply_apply, hw, dist_zero_right, NNReal.coe_ofNat] using h
+
+end SLEExactGauge.Serpentine
+
+end
+
+end OAI
diff --git a/lean/OAI/Probability/SLE/Geometry/MarkedCornerChart.lean b/lean/OAI/Probability/SLE/Geometry/MarkedCornerChart.lean
new file mode 100644
index 0000000000000000000000000000000000000000..4622c13d4461cb33f39d8027ddd36f7ac60e0da6
--- /dev/null
+++ b/lean/OAI/Probability/SLE/Geometry/MarkedCornerChart.lean
@@ -0,0 +1,91 @@
+import OAI.Probability.SLE.Geometry.MarkedAccessHook
+
+namespace OAI
+
+/-! An explicit plane homeomorphism takes the real axis to the two
+legs of the marked access hook. It permits the same local crosscut
+argument as a smooth waypoint chart without smoothing the corner. -/
+
+noncomputable section
+open Set Metric
+
+namespace SLEExactGauge.Serpentine
+
+def cornerMap (z : ℂ) : ℂ :=
+  ((-max z.re 0 + z.im : ℝ) : ℂ) + ((-min z.re 0 - z.im : ℝ) : ℂ) * Complex.I
+
+def cornerInv (z : ℂ) : ℂ :=
+  ((-z.re - z.im : ℝ) : ℂ) + ((z.re + max (-z.re - z.im) 0 : ℝ) : ℂ) * Complex.I
+
+lemma cornerInv_cornerMap (z : ℂ) : cornerInv (cornerMap z) = z := by
+  have he := max_add_min z.re (0 : ℝ)
+  apply Complex.ext <;>
+    simp only [cornerInv, cornerMap, Complex.add_re, Complex.add_im,
+      Complex.mul_re, Complex.mul_im, Complex.ofReal_re, Complex.ofReal_im,
+      Complex.I_re, Complex.I_im, mul_zero, mul_one, sub_zero, add_zero, zero_add]
+  · linarith
+  · have hu : -(-max z.re 0 + z.im) - (-min z.re 0 - z.im) = z.re := by linarith
+    rw [hu]
+    ring
+
+lemma cornerMap_cornerInv (z : ℂ) : cornerMap (cornerInv z) = z := by
+  have he := max_add_min (-z.re - z.im) (0 : ℝ)
+  apply Complex.ext <;>
+    simp only [cornerInv, cornerMap, Complex.add_re, Complex.add_im,
+      Complex.mul_re, Complex.mul_im, Complex.ofReal_re, Complex.ofReal_im,
+      Complex.I_re, Complex.I_im, mul_zero, mul_one, sub_zero, add_zero, zero_add] <;>
+    linarith
+
+def markedCornerChart (w : ℂ) : ℂ ≃ₜ ℂ where
+  toFun z := w + cornerMap z
+  invFun z := cornerInv (z - w)
+  left_inv z := by
+    change cornerInv ((w + cornerMap z) - w) = z
+    rw [add_sub_cancel_left, cornerInv_cornerMap]
+  right_inv z := by
+    change w + cornerMap (cornerInv (z - w)) = z
+    rw [cornerMap_cornerInv]
+    abel
+  continuous_toFun := by unfold cornerMap; fun_prop
+  continuous_invFun := by unfold cornerInv; fun_prop
+
+lemma markedCornerChart_zero (w : ℂ) : markedCornerChart w 0 = w := by
+  simp [markedCornerChart, cornerMap]
+
+lemma markedCornerChart_real_nonneg (w : ℂ) {u : ℝ} (hu : 0 ≤ u) :
+    markedCornerChart w (u : ℂ) = w - (u : ℂ) := by
+  simp [markedCornerChart, cornerMap, max_eq_left hu, min_eq_right hu, sub_eq_add_neg]
+
+lemma markedCornerChart_real_nonpos (w : ℂ) {u : ℝ} (hu : u ≤ 0) :
+    markedCornerChart w (u : ℂ) = w + ((-u : ℝ) : ℂ) * Complex.I := by
+  simp [markedCornerChart, cornerMap, max_eq_right hu, min_eq_left hu]
+
+theorem markedCornerChart_real_image (w z : ℂ) :
+    (∃ u : ℝ, markedCornerChart w (u : ℂ) = z) ↔
+      (z.re = w.re ∧ w.im ≤ z.im) ∨ (z.im = w.im ∧ z.re ≤ w.re) := by
+  constructor
+  · rintro ⟨u, rfl⟩
+    by_cases hu : 0 ≤ u
+    · right
+      rw [markedCornerChart_real_nonneg w hu]
+      simp only [Complex.sub_im, Complex.sub_re, Complex.ofReal_re, Complex.ofReal_im, sub_zero]
+      exact ⟨trivial, by linarith⟩
+    · left
+      rw [markedCornerChart_real_nonpos w (le_of_not_ge hu)]
+      simp only [Complex.add_im, Complex.add_re, Complex.mul_im, Complex.mul_re,
+        Complex.ofReal_re, Complex.ofReal_im, Complex.I_re, Complex.I_im,
+        mul_zero, mul_one, sub_zero, add_zero]
+      exact ⟨trivial, by linarith⟩
+  · rintro (⟨hre, him⟩ | ⟨him, hre⟩)
+    · refine ⟨w.im - z.im, ?_⟩
+      rw [markedCornerChart_real_nonpos w (by linarith)]
+      apply Complex.ext <;> simp [hre]
+    · refine ⟨w.re - z.re, ?_⟩
+      rw [markedCornerChart_real_nonneg w (by linarith)]
+      apply Complex.ext <;> simp [him]
+
+end SLEExactGauge.Serpentine
+
+end
+
+end OAI
diff --git a/lean/OAI/Probability/SLE/Geometry/MarkedHookLocal.lean b/lean/OAI/Probability/SLE/Geometry/MarkedHookLocal.lean
new file mode 100644
index 0000000000000000000000000000000000000000..497f3e223a86e23f4951585d5ee985a50f55cdb2
--- /dev/null
+++ b/lean/OAI/Probability/SLE/Geometry/MarkedHookLocal.lean
@@ -0,0 +1,109 @@
+import OAI.Probability.SLE.Geometry.MarkedCornerBounds
+
+namespace OAI
+
+/-! The complete marked hook has exactly its two adjacent legs in a
+small corner-chart neighbourhood. A separated preceding guide contributes
+no other local intersection. -/
+
+noncomputable section
+open Set Metric
+
+namespace SLEExactGauge.Serpentine
+
+lemma markedCornerChart_real_iff (w z : ℂ) :
+    ((markedCornerChart w z).re = w.re ∧ w.im ≤ (markedCornerChart w z).im) ∨
+      ((markedCornerChart w z).im = w.im ∧ (markedCornerChart w z).re ≤ w.re) ↔
+    z.im = 0 := by
+  rw [← markedCornerChart_real_image]
+  constructor
+  · rintro ⟨u, hu⟩
+    have h := (markedCornerChart w).injective hu
+    simpa only [Complex.ofReal_im] using congrArg Complex.im h.symm
+  · intro hz
+    refine ⟨z.re, ?_⟩
+    congr 1
+    apply Complex.ext <;> simp [hz]
+
+lemma markedHook_in_small_corner {w z : ℂ} {R H a δ t : ℝ}
+    (hR : w.re < R) (hH : w.im < H) (ha : 0 < a)
+    (hδH : 3 * δ < H - w.im) (hδa : 3 * δ < a)
+    (hz : ‖z‖ < δ) (ht : 0 ≤ t)
+    (he : markedHook w R H a t = markedCornerChart w z) : z.im = 0 := by
+  have hd : dist (markedCornerChart w z) w < 3 * δ :=
+    (markedCornerChart_norm w z).trans_lt (by linarith)
+  have hy := Complex.abs_im_le_norm (markedCornerChart w z - w)
+  have hx := Complex.abs_re_le_norm (markedCornerChart w z - w)
+  rw [Complex.sub_im] at hy
+  rw [Complex.sub_re] at hx
+  rw [← dist_eq_norm] at hy hx
+  apply (markedCornerChart_real_iff w z).mp
+  rcases markedHook_pieces w hR hH ha ht with ⟨_, hh⟩ | ⟨ht, hh⟩ |
+      ⟨ht, hh⟩ | ⟨_, hh⟩
+  · have him : (markedCornerChart w z).im = H := by
+      rw [← he, hh]
+      simp [hookTop]
+    rw [him] at hy
+    linarith [le_abs_self (H - w.im)]
+  · left
+    rw [← he, hh]
+    simp only [hookDown, Complex.add_re, Complex.add_im, Complex.mul_re, Complex.mul_im,
+      Complex.ofReal_re, Complex.ofReal_im, Complex.I_re, Complex.I_im,
+      mul_zero, mul_one, sub_zero, add_zero, zero_add]
+    exact ⟨trivial, by linarith [ht.2]⟩
+  · right
+    rw [← he, hh]
+    simp only [hookLeft, Complex.add_re, Complex.add_im, Complex.mul_re, Complex.mul_im,
+      Complex.ofReal_re, Complex.ofReal_im, Complex.I_re, Complex.I_im,
+      mul_zero, mul_one, sub_zero, add_zero, zero_add]
+    exact ⟨trivial, by linarith [ht.1]⟩
+  · have hre : (markedCornerChart w z).re = w.re - a := by
+      rw [← he, hh]
+      simp [hookUp]
+    rw [hre] at hx
+    linarith [neg_le_abs (w.re - a - w.re)]
+
+lemma markedHook_contains_small_real {w z : ℂ} {R H a δ : ℝ}
+    (hR : w.re < R) (hδH : δ < H - w.im) (hδa : δ < a)
+    (hz : ‖z‖ < δ) (him : z.im = 0) :
+    ∃ t : ℝ, 0 ≤ t ∧ markedHook w R H a t = markedCornerChart w z := by
+  have hu : |z.re| < δ := (Complex.abs_re_le_norm z).trans_lt hz
+  have hez : z = (z.re : ℂ) := by apply Complex.ext <;> simp [him]
+  rw [hez]
+  by_cases hp : 0 < z.re
+  · refine ⟨(R - w.re) + (H - w.im) + z.re, ?_, ?_⟩
+    · linarith [le_abs_self z.re, neg_le_abs z.re]
+    · rw [markedHook, curveJoin_of_gt (by linarith [neg_le_abs z.re]),
+        curveJoin_of_gt (by linarith), curveJoin_of_le (by linarith [le_abs_self z.re]),
+        markedCornerChart_real_nonneg w hp.le]
+      apply Complex.ext <;> simp [hookLeft]
+  · have hn : z.re ≤ 0 := le_of_not_gt hp
+    refine ⟨(R - w.re) + (H - w.im) + z.re, ?_, ?_⟩
+    · linarith [neg_le_abs z.re]
+    · rw [markedHook, curveJoin_of_gt (by linarith [neg_le_abs z.re]),
+        curveJoin_of_le (by linarith), markedCornerChart_real_nonpos w hn]
+      apply Complex.ext <;> simp [hookDown]; ring
+
+/-- The local intersection statement needed to straighten the complete guide. -/
+theorem markedHook_small_corner_iff {w z : ℂ} {R H a δ : ℝ}
+    (hR : w.re < R) (hH : w.im < H) (ha : 0 < a) (hδ : 0 < δ)
+    (hδH : 3 * δ < H - w.im) (hδa : 3 * δ < a) (hz : ‖z‖ < δ) :
+    (∃ t : ℝ, 0 ≤ t ∧ markedHook w R H a t = markedCornerChart w z) ↔ z.im = 0 := by
+  constructor
+  · rintro ⟨t, ht, he⟩
+    exact markedHook_in_small_corner hR hH ha hδH hδa hz ht he
+  · exact markedHook_contains_small_real hR (by linarith) (by linarith) hz
+
+lemma separated_prefix_outside_corner {w z p : ℂ} {δ d : ℝ}
+    (hd : d ≤ dist p w) (hδ : 3 * δ < d) (hz : ‖z‖ < δ) :
+    p ≠ markedCornerChart w z := by
+  intro he
+  have hb := markedCornerChart_norm w z
+  rw [← he] at hb
+  linarith
+
+end SLEExactGauge.Serpentine
+
+end
+
+end OAI
diff --git a/lean/OAI/Probability/SLE/Geometry/MarkedRouteClearance.lean b/lean/OAI/Probability/SLE/Geometry/MarkedRouteClearance.lean
new file mode 100644
index 0000000000000000000000000000000000000000..822d8ceb40382de69a792edc53c576ffd4eddfd5
--- /dev/null
+++ b/lean/OAI/Probability/SLE/Geometry/MarkedRouteClearance.lean
@@ -0,0 +1,226 @@
+import OAI.Probability.SLE.Geometry.MarkedRoutes
+
+namespace OAI
+
+/-! Fixed positive clearance of both marked-point routes from the past
+and from the complete polygonal hook, away from their common initial point. -/
+
+noncomputable section
+open Set Metric
+
+namespace SLEExactGauge.Serpentine
+open RibbonCoordinates
+
+lemma markedHook_re_bounds {w : ℂ} {R a t : ℝ} (hR : w.re < R)
+    (hw : w.im < 2) (ha : 0 < a) (ht : 0 ≤ t) :
+    w.re - a ≤ (markedHook w R 2 a t).re ∧ (markedHook w R 2 a t).re ≤ R := by
+  rcases markedHook_pieces w hR hw ha ht with ⟨ht, he⟩ | ⟨ht, he⟩ |
+    ⟨ht, he⟩ | ⟨ht, he⟩
+  all_goals
+    rw [he]
+    simp only [hookTop, hookDown, hookLeft, hookUp, Complex.add_re, Complex.mul_re,
+      Complex.ofReal_re, Complex.ofReal_im, Complex.I_re, Complex.I_im,
+      mul_zero, mul_one, sub_zero, add_zero]
+    try simp only [mem_Icc] at ht
+    constructor <;> linarith
+
+lemma markedHook_im_lower {w : ℂ} {R a t : ℝ} (hR : w.re < R)
+    (hw : w.im < 2) (ha : 0 < a) (ht : 0 ≤ t) :
+    w.im ≤ (markedHook w R 2 a t).im := by
+  rcases markedHook_pieces w hR hw ha ht with ⟨ht, he⟩ | ⟨ht, he⟩ |
+    ⟨ht, he⟩ | ⟨ht, he⟩
+  all_goals
+    rw [he]
+    simp only [hookTop, hookDown, hookLeft, hookUp, Complex.add_im, Complex.mul_im,
+      Complex.ofReal_re, Complex.ofReal_im, Complex.I_re, Complex.I_im,
+      mul_zero, mul_one, add_zero, zero_add]
+    try simp only [mem_Icc] at ht
+    linarith
+
+lemma markedLeftRoute_before_two {w : ℂ} {a t : ℝ} (ha : 0 ≤ a) (hw : -3 ≤ w.re) (ht : t ≤ 2) :
+    (markedLeftRoute w a t).re ≤ w.re ∧
+      w.im - a ≤ (markedLeftRoute w a t).im := by
+  rw [markedLeftRoute_re, markedLeftRoute_im,
+    unitClip_of_nonpos (by linarith : t - 2 ≤ 0), mul_zero, add_zero]
+  have hc1 := unitClip_le_one t
+  constructor
+  · have h := unitClip_nonneg (t - 1)
+    nlinarith
+  · nlinarith
+
+lemma markedLeftRoute_after_two (w : ℂ) (a : ℝ) {t : ℝ} (ht : 2 ≤ t) :
+    (markedLeftRoute w a t).re = -3 := by
+  rw [markedLeftRoute_re, unitClip_of_one_le (by linarith : 1 ≤ t - 1)]
+  ring
+
+lemma markedRightRoute_before_two {w : ℂ} {a t : ℝ}
+    (hw : w.im ≤ 1) (ha : 0 ≤ a) (ht : t ≤ 2) :
+    (markedRightRoute w a t).re ≤ w.re ∧ w.im ≤ (markedRightRoute w a t).im := by
+  rw [markedRightRoute_re, markedRightRoute_im,
+    unitClip_of_nonpos (by linarith : t - 2 ≤ 0),
+    unitClip_of_nonpos (by linarith : t - 3 ≤ 0)]
+  have h0 := unitClip_nonneg t
+  have h1 := unitClip_nonneg (t - 1)
+  constructor <;> nlinarith
+
+lemma markedRightRoute_middle {w : ℂ} {a t : ℝ}
+    (hw : w.re ≤ 1) (ha : 0 ≤ a) (ht : t ∈ Icc (2 : ℝ) 3) :
+    w.re - a / 2 ≤ (markedRightRoute w a t).re ∧
+      (markedRightRoute w a t).im = 2 + a := by
+  rw [markedRightRoute_re, markedRightRoute_im,
+    unitClip_of_one_le (by linarith [ht.1] : 1 ≤ t),
+    unitClip_of_one_le (by linarith [ht.1] : 1 ≤ t - 1),
+    unitClip_of_nonpos (by linarith [ht.2] : t - 3 ≤ 0)]
+  have h := unitClip_nonneg (t - 2)
+  constructor <;> nlinarith
+
+lemma markedRightRoute_after_three (w : ℂ) (a : ℝ) {t : ℝ} (ht : 3 ≤ t) :
+    (markedRightRoute w a t).re = 3 := by
+  rw [markedRightRoute_re, unitClip_of_one_le (by linarith : 1 ≤ t),
+    unitClip_of_one_le (by linarith : 1 ≤ t - 2)]
+  ring
+
+/-- The explicit routes are uniformly separated from every admissible
+past point, including before the local departure from the marked point. -/
+theorem markedRoutes_past_clearance {w q : ℂ} {a t : ℝ}
+    (hwr : -3 ≤ w.re) (hwr1 : w.re ≤ 1) (hwi1 : w.im ≤ 1)
+    (ha : 0 ≤ a) (ha1 : a ≤ 1)
+    (hqre : -2 ≤ q.re ∧ q.re ≤ 2) (hqim : q.im ≤ 2)
+    (hq : q.im ≤ w.im - 2 * a ∨ w.re + 2 * a ≤ q.re) :
+    a ≤ dist (markedLeftRoute w a t) q ∧ a ≤ dist (markedRightRoute w a t) q := by
+  have hlr := Complex.abs_re_le_norm (markedLeftRoute w a t - q)
+  have hli := Complex.abs_im_le_norm (markedLeftRoute w a t - q)
+  have hrr := Complex.abs_re_le_norm (markedRightRoute w a t - q)
+  have hri := Complex.abs_im_le_norm (markedRightRoute w a t - q)
+  simp only [Complex.sub_re, Complex.sub_im, ← dist_eq_norm] at hlr hli hrr hri
+  constructor
+  · by_cases ht : t ≤ 2
+    · have hb := markedLeftRoute_before_two ha hwr ht
+      rcases hq with hq | hq
+      · linarith [le_abs_self ((markedLeftRoute w a t).im - q.im)]
+      · linarith [neg_le_abs ((markedLeftRoute w a t).re - q.re)]
+    · rw [markedLeftRoute_after_two w a (le_of_not_ge ht)] at hlr
+      linarith [neg_le_abs (-3 - q.re), hqre.1]
+  · by_cases ht : t ≤ 2
+    · have hb := markedRightRoute_before_two hwi1 ha ht
+      rcases hq with hq | hq
+      · linarith [le_abs_self ((markedRightRoute w a t).im - q.im)]
+      · linarith [neg_le_abs ((markedRightRoute w a t).re - q.re)]
+    · by_cases ht3 : t ≤ 3
+      · have hb := markedRightRoute_middle hwr1 ha ⟨le_of_not_ge ht, ht3⟩
+        rw [hb.2] at hri
+        linarith [le_abs_self (2 + a - q.im)]
+      · rw [markedRightRoute_after_three w a (le_of_not_ge ht3)] at hrr
+        linarith [le_abs_self (3 - q.re), hqre.2]
+
+lemma markedLeftRoute_early_below {w : ℂ} {a t : ℝ} (ha : 0 ≤ a)
+    (ht : t ∈ Icc (1 / 4 : ℝ) 2) :
+    (markedLeftRoute w a t).im ≤ w.im - a / 4 := by
+  rw [markedLeftRoute_im, unitClip_of_nonpos (by linarith [ht.2] : t - 2 ≤ 0)]
+  have hc : 1 / 4 ≤ unitClip t :=
+    (show 1 / 4 ≤ min 1 t from le_min (by norm_num) ht.1).trans (le_max_right _ _)
+  nlinarith
+
+/-- The lower route avoids the complete hook after time 1/4. -/
+theorem markedLeftRoute_hook_clearance {w : ℂ} {R a t u : ℝ}
+    (hwr : 0 ≤ w.re) (hwi : w.im < 2) (hR : w.re < R)
+    (ha : 0 < a) (ha1 : a ≤ 1) (ht : 1 / 4 ≤ t) (hu : 0 ≤ u) :
+    a / 4 ≤ dist (markedLeftRoute w a t) (markedHook w R 2 a u) := by
+  have hr := Complex.abs_re_le_norm (markedLeftRoute w a t - markedHook w R 2 a u)
+  have hi := Complex.abs_im_le_norm (markedLeftRoute w a t - markedHook w R 2 a u)
+  simp only [Complex.sub_re, Complex.sub_im, ← dist_eq_norm] at hr hi
+  by_cases ht2 : t ≤ 2
+  · have h := markedLeftRoute_early_below (w := w) ha.le ⟨ht, ht2⟩
+    have h' := markedHook_im_lower hR hwi ha hu
+    linarith [neg_le_abs ((markedLeftRoute w a t).im - (markedHook w R 2 a u).im)]
+  · rw [markedLeftRoute_after_two w a (le_of_not_ge ht2)] at hr
+    have h := (markedHook_re_bounds hR hwi ha hu).1
+    linarith [neg_le_abs (-3 - (markedHook w R 2 a u).re)]
+
+lemma markedRightRoute_first {w : ℂ} {a t : ℝ} (ha : 0 ≤ a)
+    (ht : t ∈ Icc (1 / 4 : ℝ) 1) :
+    w.re - a / 2 ≤ (markedRightRoute w a t).re ∧
+    (markedRightRoute w a t).re ≤ w.re - a / 8 ∧
+    w.im + a / 8 ≤ (markedRightRoute w a t).im ∧
+    (markedRightRoute w a t).im ≤ w.im + a / 2 := by
+  rw [markedRightRoute_re, markedRightRoute_im, unitClip_of_mem ⟨by linarith [ht.1], ht.2⟩,
+    unitClip_of_nonpos (by linarith [ht.2] : t - 1 ≤ 0),
+    unitClip_of_nonpos (by linarith [ht.2] : t - 2 ≤ 0),
+    unitClip_of_nonpos (by linarith [ht.2] : t - 3 ≤ 0)]
+  constructor
+  · nlinarith [ht.2]
+  constructor
+  · nlinarith [ht.1]
+  constructor <;> nlinarith [ht.1, ht.2]
+
+lemma markedRightRoute_second {w : ℂ} {a t : ℝ} (hw : w.im ≤ 1) (ha : 0 ≤ a)
+    (ht : t ∈ Icc (1 : ℝ) 2) :
+    (markedRightRoute w a t).re = w.re - a / 2 ∧
+    w.im + a / 2 ≤ (markedRightRoute w a t).im := by
+  rw [markedRightRoute_re, markedRightRoute_im, unitClip_of_one_le ht.1,
+    unitClip_of_nonpos (by linarith [ht.2] : t - 2 ≤ 0),
+    unitClip_of_nonpos (by linarith [ht.2] : t - 3 ≤ 0)]
+  have h := unitClip_nonneg (t - 1)
+  constructor
+  · ring
+  · nlinarith
+
+/-- The upper route runs in the gap between the two vertical legs,
+then above the horizontal top, and finally along the exterior line. -/
+theorem markedRightRoute_hook_clearance {w : ℂ} {R a t u : ℝ}
+    (hwr1 : w.re ≤ 1) (hwi : w.im ≤ 1) (hR : w.re < R) (hR2 : R ≤ 2)
+    (ha : 0 < a) (ha1 : a ≤ 1) (ht : 1 / 4 ≤ t) (hu : 0 ≤ u) :
+    a / 8 ≤ dist (markedRightRoute w a t) (markedHook w R 2 a u) := by
+  have hr := Complex.abs_re_le_norm (markedRightRoute w a t - markedHook w R 2 a u)
+  have hi := Complex.abs_im_le_norm (markedRightRoute w a t - markedHook w R 2 a u)
+  simp only [Complex.sub_re, Complex.sub_im, ← dist_eq_norm] at hr hi
+  have hrp := le_abs_self ((markedRightRoute w a t).re - (markedHook w R 2 a u).re)
+  have hrn := neg_le_abs ((markedRightRoute w a t).re - (markedHook w R 2 a u).re)
+  have hip := le_abs_self ((markedRightRoute w a t).im - (markedHook w R 2 a u).im)
+  have hin := neg_le_abs ((markedRightRoute w a t).im - (markedHook w R 2 a u).im)
+  by_cases ht3 : 3 ≤ t
+  · have hq := (markedHook_re_bounds hR (by linarith) ha hu).2
+    rw [markedRightRoute_after_three w a ht3] at hr hrp
+    linarith
+  have hwi2 : w.im < 2 := by linarith
+  by_cases ht1 : t ≤ 1
+  · obtain ⟨hx0, hx1, hy0, hy1⟩ := markedRightRoute_first (w := w) ha.le ⟨ht, ht1⟩
+    rcases markedHook_pieces w hR hwi2 ha hu with ⟨hq, he⟩ | ⟨hq, he⟩ |
+      ⟨hq, he⟩ | ⟨hq, he⟩
+    all_goals
+      rw [he] at hr hi hrp hrn hip hin ⊢
+      simp only [hookTop, hookDown, hookLeft, hookUp, Complex.add_re, Complex.add_im,
+        Complex.mul_re, Complex.mul_im, Complex.ofReal_re, Complex.ofReal_im,
+        Complex.I_re, Complex.I_im, mul_zero, mul_one, sub_zero, add_zero, zero_add]
+        at hr hi hrp hrn hip hin ⊢
+      try simp only [mem_Icc] at hq
+      linarith
+  · by_cases ht2 : t ≤ 2
+    · obtain ⟨hx, hy⟩ := markedRightRoute_second hwi ha.le ⟨le_of_not_ge ht1, ht2⟩
+      rcases markedHook_pieces w hR hwi2 ha hu with ⟨hq, he⟩ | ⟨hq, he⟩ |
+        ⟨hq, he⟩ | ⟨hq, he⟩
+      all_goals
+        rw [he] at hr hi hrp hrn hip hin ⊢
+        simp only [hookTop, hookDown, hookLeft, hookUp, Complex.add_re, Complex.add_im,
+          Complex.mul_re, Complex.mul_im, Complex.ofReal_re, Complex.ofReal_im,
+          Complex.I_re, Complex.I_im, mul_zero, mul_one, sub_zero, add_zero, zero_add]
+          at hr hi hrp hrn hip hin ⊢
+        try simp only [mem_Icc] at hq
+        linarith
+    · obtain ⟨hx, hy⟩ := markedRightRoute_middle hwr1 ha.le ⟨le_of_not_ge ht2, le_of_not_ge ht3⟩
+      rcases markedHook_pieces w hR hwi2 ha hu with ⟨hq, he⟩ | ⟨hq, he⟩ |
+        ⟨hq, he⟩ | ⟨hq, he⟩
+      all_goals
+        rw [he] at hr hi hrp hrn hip hin ⊢
+        simp only [hookTop, hookDown, hookLeft, hookUp, Complex.add_re, Complex.add_im,
+          Complex.mul_re, Complex.mul_im, Complex.ofReal_re, Complex.ofReal_im,
+          Complex.I_re, Complex.I_im, mul_zero, mul_one, sub_zero, add_zero, zero_add]
+          at hr hi hrp hrn hip hin ⊢
+        try simp only [mem_Icc] at hq
+        linarith
+
+end SLEExactGauge.Serpentine
+
+end
+
+end OAI
diff --git a/lean/OAI/Probability/SLE/Geometry/MarkedRouteEarlyClearance.lean b/lean/OAI/Probability/SLE/Geometry/MarkedRouteEarlyClearance.lean
new file mode 100644
index 0000000000000000000000000000000000000000..410f9fab4d5551e9225c993ddf847a53461a2148
--- /dev/null
+++ b/lean/OAI/Probability/SLE/Geometry/MarkedRouteEarlyClearance.lean
@@ -0,0 +1,86 @@
+import OAI.Probability.SLE.Geometry.MarkedRouteClearance
+
+namespace OAI
+
+/-! Uniform hook separation already at the early local-side test time. -/
+
+noncomputable section
+open Set Metric
+
+namespace SLEExactGauge.Serpentine
+open RibbonCoordinates
+
+private lemma right_early_box {w : ℂ} {a t : ℝ} (ha : 0 ≤ a)
+    (ht : t ∈ Icc (1 / 64 : ℝ) (1 / 4)) :
+    w.re - a / 8 ≤ (markedRightRoute w a t).re ∧
+    (markedRightRoute w a t).re ≤ w.re - a / 128 ∧
+    w.im + a / 128 ≤ (markedRightRoute w a t).im ∧
+    (markedRightRoute w a t).im ≤ w.im + a / 8 := by
+  rw [markedRightRoute_re, markedRightRoute_im,
+    unitClip_of_mem ⟨by linarith [ht.1], by linarith [ht.2]⟩,
+    unitClip_of_nonpos (by linarith [ht.2] : t - 1 ≤ 0),
+    unitClip_of_nonpos (by linarith [ht.2] : t - 2 ≤ 0),
+    unitClip_of_nonpos (by linarith [ht.2] : t - 3 ≤ 0)]
+  constructor
+  · nlinarith [ht.2]
+  constructor
+  · nlinarith [ht.1]
+  constructor <;> nlinarith [ht.1, ht.2]
+
+private lemma left_very_early_clearance {w : ℂ} {R a t u : ℝ}
+    (hwi : w.im < 2) (hR : w.re < R) (ha : 0 < a)
+    (ht : t ∈ Icc (1 / 64 : ℝ) (1 / 4)) (hu : 0 ≤ u) :
+    a / 512 ≤ dist (markedLeftRoute w a t) (markedHook w R 2 a u) := by
+  have hbelow : (markedLeftRoute w a t).im ≤ w.im - a / 64 := by
+    rw [markedLeftRoute_im, unitClip_of_mem ⟨by linarith [ht.1], by linarith [ht.2]⟩,
+      unitClip_of_nonpos (by linarith [ht.2] : t - 2 ≤ 0)]
+    nlinarith [ht.1]
+  have hq := markedHook_im_lower hR hwi ha hu
+  have hi := Complex.abs_im_le_norm (markedLeftRoute w a t - markedHook w R 2 a u)
+  rw [Complex.sub_im, ← dist_eq_norm] at hi
+  linarith [neg_le_abs ((markedLeftRoute w a t).im - (markedHook w R 2 a u).im)]
+
+private lemma right_very_early_clearance {w : ℂ} {R a t u : ℝ}
+    (hwi : w.im ≤ 1) (hR : w.re < R) (ha : 0 < a) (ha1 : a ≤ 1)
+    (ht : t ∈ Icc (1 / 64 : ℝ) (1 / 4)) (hu : 0 ≤ u) :
+    a / 512 ≤ dist (markedRightRoute w a t) (markedHook w R 2 a u) := by
+  obtain ⟨hx0, hx1, hy0, hy1⟩ := right_early_box (w := w) ha.le ht
+  have hr := Complex.abs_re_le_norm (markedRightRoute w a t - markedHook w R 2 a u)
+  have hi := Complex.abs_im_le_norm (markedRightRoute w a t - markedHook w R 2 a u)
+  simp only [Complex.sub_re, Complex.sub_im, ← dist_eq_norm] at hr hi
+  have hrp := le_abs_self ((markedRightRoute w a t).re - (markedHook w R 2 a u).re)
+  have hrn := neg_le_abs ((markedRightRoute w a t).re - (markedHook w R 2 a u).re)
+  have hip := le_abs_self ((markedRightRoute w a t).im - (markedHook w R 2 a u).im)
+  have hin := neg_le_abs ((markedRightRoute w a t).im - (markedHook w R 2 a u).im)
+  rcases markedHook_pieces w hR (show w.im < 2 by linarith) ha hu with ⟨hq, he⟩ | ⟨hq, he⟩ |
+      ⟨hq, he⟩ | ⟨hq, he⟩
+  all_goals
+    rw [he] at hr hi hrp hrn hip hin ⊢
+    simp only [hookTop, hookDown, hookLeft, hookUp, Complex.add_re, Complex.add_im,
+      Complex.mul_re, Complex.mul_im, Complex.ofReal_re, Complex.ofReal_im,
+      Complex.I_re, Complex.I_im, mul_zero, mul_one, sub_zero, add_zero, zero_add]
+      at hr hi hrp hrn hip hin ⊢
+    try simp only [mem_Icc] at hq
+    linarith
+
+/-- A common margin for both routes from the local-side test onward. -/
+theorem markedRoutes_hook_clearance_early {w : ℂ} {R a t u : ℝ}
+    (hwr : 0 ≤ w.re) (hwr1 : w.re ≤ 1) (hwi : w.im ≤ 1)
+    (hR : w.re < R) (hR2 : R ≤ 2) (ha : 0 < a) (ha1 : a ≤ 1)
+    (ht : 1 / 64 ≤ t) (hu : 0 ≤ u) :
+    a / 512 ≤ dist (markedLeftRoute w a t) (markedHook w R 2 a u) ∧
+    a / 512 ≤ dist (markedRightRoute w a t) (markedHook w R 2 a u) := by
+  by_cases ht' : 1 / 4 ≤ t
+  · constructor
+    · exact (by linarith : a / 512 ≤ a / 4).trans
+        (markedLeftRoute_hook_clearance hwr (by linarith) hR ha ha1 ht' hu)
+    · exact (by linarith : a / 512 ≤ a / 8).trans
+        (markedRightRoute_hook_clearance hwr1 hwi hR hR2 ha ha1 ht' hu)
+  · exact ⟨left_very_early_clearance (by linarith) hR ha ⟨ht, le_of_not_ge ht'⟩ hu,
+      right_very_early_clearance hwi hR ha ha1 ⟨ht, le_of_not_ge ht'⟩ hu⟩
+
+end SLEExactGauge.Serpentine
+
+end
+
+end OAI
diff --git a/lean/OAI/Probability/SLE/Geometry/MarkedRouteSides.lean b/lean/OAI/Probability/SLE/Geometry/MarkedRouteSides.lean
new file mode 100644
index 0000000000000000000000000000000000000000..282fcc55148e2997d3d219dc0ccf6a52b3b56d58
--- /dev/null
+++ b/lean/OAI/Probability/SLE/Geometry/MarkedRouteSides.lean
@@ -0,0 +1,42 @@
+import OAI.Probability.SLE.Geometry.MarkedRouteClearance
+import OAI.Probability.SLE.Geometry.MarkedCornerBounds
+
+namespace OAI
+
+/-! The initial portions of the two physical routes lie on opposite
+sides of the explicit local corner chart. -/
+
+noncomputable section
+open Set Metric
+
+namespace SLEExactGauge.Serpentine
+open RibbonCoordinates
+
+lemma markedLeftRoute_corner_side {w : ℂ} {a t : ℝ}
+    (ha : 0 < a) (ht : t ∈ Ioc (0 : ℝ) 1) :
+    0 < ((markedCornerChart w).symm (markedLeftRoute w a t)).im := by
+  rw [markedCornerChart_symm_im, markedLeftRoute_re, markedLeftRoute_im,
+    unitClip_of_mem ⟨ht.1.le, ht.2⟩,
+    unitClip_of_nonpos (by linarith [ht.2] : t - 1 ≤ 0),
+    unitClip_of_nonpos (by linarith [ht.2] : t - 2 ≤ 0)]
+  have hp : 0 < a * t := mul_pos ha ht.1
+  apply lt_of_lt_of_le hp
+  apply le_trans _ (le_max_right _ _)
+  linarith
+
+lemma markedRightRoute_corner_side {w : ℂ} {a t : ℝ}
+    (ha : 0 < a) (ht : t ∈ Ioc (0 : ℝ) 1) :
+    ((markedCornerChart w).symm (markedRightRoute w a t)).im < 0 := by
+  rw [markedCornerChart_symm_im, markedRightRoute_re, markedRightRoute_im,
+    unitClip_of_mem ⟨ht.1.le, ht.2⟩,
+    unitClip_of_nonpos (by linarith [ht.2] : t - 1 ≤ 0),
+    unitClip_of_nonpos (by linarith [ht.2] : t - 2 ≤ 0),
+    unitClip_of_nonpos (by linarith [ht.2] : t - 3 ≤ 0), max_lt_iff]
+  have hp : 0 < a * t := mul_pos ha ht.1
+  constructor <;> nlinarith
+
+end SLEExactGauge.Serpentine
+
+end
+
+end OAI
diff --git a/lean/OAI/Probability/SLE/Geometry/MarkedRoutes.lean b/lean/OAI/Probability/SLE/Geometry/MarkedRoutes.lean
new file mode 100644
index 0000000000000000000000000000000000000000..344a45d31dc0fb730ac512ac3b043706039449d7
--- /dev/null
+++ b/lean/OAI/Probability/SLE/Geometry/MarkedRoutes.lean
@@ -0,0 +1,141 @@
+import OAI.Probability.SLE.Geometry.WaypointRoutes
+import OAI.Probability.SLE.Geometry.MarkedAccessHook
+
+namespace OAI
+
+/-! Two explicit finite routes from the marked point to the exterior
+real boundary. One goes below the marked hook and exits on the left;
+the other passes between its legs, above its top, and exits on the right. -/
+
+noncomputable section
+open Set Metric
+open scoped Topology NNReal
+
+namespace SLEExactGauge.Serpentine
+open RibbonCoordinates
+
+private def clippedVector (v : ℂ) (c t : ℝ) : ℂ :=
+  (unitClip (t - c) : ℂ) * v
+
+private lemma clippedVector_lipschitz {v : ℂ} (hv : ‖v‖ ≤ 6) (c : ℝ) :
+    LipschitzWith 6 (clippedVector v c) := by
+  apply LipschitzWith.of_dist_le_mul
+  intro t u
+  have hc := unitClip_lipschitz.dist_le_mul (t - c) (u - c)
+  simp only [NNReal.coe_one, one_mul, Real.dist_eq, sub_sub_sub_cancel_right] at hc
+  rw [clippedVector, clippedVector, dist_eq_norm, ← sub_mul, ← Complex.ofReal_sub,
+    norm_mul, Complex.norm_real, Real.norm_eq_abs]
+  norm_num only [NNReal.coe_ofNat]
+  calc
+    |unitClip (t - c) - unitClip (u - c)| * ‖v‖ ≤ |t - u| * 6 :=
+      mul_le_mul hc hv (norm_nonneg _) (abs_nonneg _)
+    _ = 6 * dist t u := by rw [Real.dist_eq]; ring
+
+private lemma clippedVector_shift_lipschitz (w : ℂ) {v : ℂ} (hv : ‖v‖ ≤ 6) (c : ℝ) :
+    LipschitzWith 6 (fun t => w + clippedVector v c t) := by
+  apply LipschitzWith.of_dist_le_mul
+  intro t u
+  simpa only [dist_add_left] using (clippedVector_lipschitz hv c).dist_le_mul t u
+
+def markedLeftRoute (w : ℂ) (a : ℝ) (t : ℝ) : ℂ :=
+  w + clippedVector (-(a : ℂ) * Complex.I) 0 t +
+    clippedVector ((-3 - w.re : ℝ) : ℂ) 1 t +
+    clippedVector ((-1 - w.im + a : ℝ) * Complex.I) 2 t
+
+def markedRightRoute (w : ℂ) (a : ℝ) (t : ℝ) : ℂ :=
+  w + clippedVector ((-a / 2 : ℝ) + (a / 2 : ℝ) * Complex.I) 0 t +
+    clippedVector ((2 + a / 2 - w.im : ℝ) * Complex.I) 1 t +
+    clippedVector ((3 - w.re + a / 2 : ℝ) : ℂ) 2 t +
+    clippedVector ((-3 - a : ℝ) * Complex.I) 3 t
+
+@[simp] lemma markedLeftRoute_re (w : ℂ) (a t : ℝ) :
+    (markedLeftRoute w a t).re = w.re + (-3 - w.re) * unitClip (t - 1) := by
+  simp [markedLeftRoute, clippedVector]
+  ring
+
+@[simp] lemma markedLeftRoute_im (w : ℂ) (a t : ℝ) :
+    (markedLeftRoute w a t).im = w.im - a * unitClip t +
+      (-1 - w.im + a) * unitClip (t - 2) := by
+  simp [markedLeftRoute, clippedVector]
+  ring
+
+@[simp] lemma markedRightRoute_re (w : ℂ) (a t : ℝ) :
+    (markedRightRoute w a t).re = w.re - a / 2 * unitClip t +
+      (3 - w.re + a / 2) * unitClip (t - 2) := by
+  simp [markedRightRoute, clippedVector]
+  ring
+
+@[simp] lemma markedRightRoute_im (w : ℂ) (a t : ℝ) :
+    (markedRightRoute w a t).im = w.im + a / 2 * unitClip t +
+      (2 + a / 2 - w.im) * unitClip (t - 1) + (-3 - a) * unitClip (t - 3) := by
+  simp [markedRightRoute, clippedVector]
+  ring
+
+lemma markedLeftRoute_zero (w : ℂ) (a : ℝ) : markedLeftRoute w a 0 = w := by
+  apply Complex.ext <;> norm_num [unitClip]
+
+lemma markedRightRoute_zero (w : ℂ) (a : ℝ) : markedRightRoute w a 0 = w := by
+  apply Complex.ext <;> norm_num [unitClip]
+
+lemma markedLeftRoute_final (w : ℂ) (a : ℝ) :
+    markedLeftRoute w a 3 = (-3 : ℂ) - Complex.I := by
+  apply Complex.ext <;> norm_num [unitClip]
+
+lemma markedLeftRoute_four (w : ℂ) (a : ℝ) :
+    markedLeftRoute w a 4 = (-3 : ℂ) - Complex.I := by
+  apply Complex.ext <;> norm_num [unitClip]
+
+lemma markedRightRoute_final (w : ℂ) (a : ℝ) :
+    markedRightRoute w a 4 = (3 : ℂ) - Complex.I := by
+  apply Complex.ext <;> norm_num [unitClip]; ring
+
+lemma markedLeftRoute_continuous (w : ℂ) (a : ℝ) : Continuous (markedLeftRoute w a) := by
+  have hc := unitClip_lipschitz.continuous
+  unfold markedLeftRoute clippedVector
+  fun_prop
+
+lemma markedRightRoute_continuous (w : ℂ) (a : ℝ) : Continuous (markedRightRoute w a) := by
+  have hc := unitClip_lipschitz.continuous
+  unfold markedRightRoute clippedVector
+  fun_prop
+
+lemma markedLeftRoute_lipschitz {w : ℂ} (hw : ‖w‖ ≤ 1) {a : ℝ}
+    (ha : 0 ≤ a) (ha1 : a ≤ 1) : LipschitzWith 24 (markedLeftRoute w a) := by
+  have hr := (Complex.abs_re_le_norm w).trans hw
+  have hi := (Complex.abs_im_le_norm w).trans hw
+  have h0 : ‖-(a : ℂ) * Complex.I‖ ≤ 6 := by simpa [norm_mul, abs_of_nonneg ha] using (show a ≤ 6 by linarith)
+  have h1 : ‖((-3 - w.re : ℝ) : ℂ)‖ ≤ 6 := by
+    simpa only [Complex.norm_real, Real.norm_eq_abs] using
+      (show |-3 - w.re| ≤ 6 from abs_le.mpr ⟨by linarith [(abs_le.mp hr).2], by linarith [(abs_le.mp hr).1]⟩)
+  have h2 : ‖((-1 - w.im + a : ℝ) : ℂ) * Complex.I‖ ≤ 6 := by
+    simp only [norm_mul, Complex.norm_real, Real.norm_eq_abs, Complex.norm_I, mul_one]
+    exact abs_le.mpr ⟨by linarith [(abs_le.mp hi).2], by linarith [(abs_le.mp hi).1]⟩
+  exact ((clippedVector_shift_lipschitz w h0 0).add
+    (clippedVector_lipschitz h1 1) |>.add (clippedVector_lipschitz h2 2)).weaken (by norm_num)
+
+lemma markedRightRoute_lipschitz {w : ℂ} (hw : ‖w‖ ≤ 1) {a : ℝ}
+    (ha : 0 ≤ a) (ha1 : a ≤ 1) : LipschitzWith 24 (markedRightRoute w a) := by
+  have hr := (Complex.abs_re_le_norm w).trans hw
+  have hi := (Complex.abs_im_le_norm w).trans hw
+  have h0 : ‖((-a / 2 : ℝ) : ℂ) + ((a / 2 : ℝ) : ℂ) * Complex.I‖ ≤ 6 := by
+    calc
+      _ ≤ |(-a / 2 : ℝ)| + |a / 2| := by simpa using Complex.norm_le_abs_re_add_abs_im (((-a / 2 : ℝ) : ℂ) + ((a / 2 : ℝ) : ℂ) * Complex.I)
+      _ ≤ 6 := by rw [abs_of_nonpos (by linarith), abs_of_nonneg (by linarith)]; linarith
+  have h1 : ‖((2 + a / 2 - w.im : ℝ) : ℂ) * Complex.I‖ ≤ 6 := by
+    simp only [norm_mul, Complex.norm_real, Real.norm_eq_abs, Complex.norm_I, mul_one]
+    exact abs_le.mpr ⟨by linarith [(abs_le.mp hi).2], by linarith [(abs_le.mp hi).1]⟩
+  have h2 : ‖((3 - w.re + a / 2 : ℝ) : ℂ)‖ ≤ 6 := by
+    simp only [Complex.norm_real, Real.norm_eq_abs]
+    exact abs_le.mpr ⟨by linarith [(abs_le.mp hr).2], by linarith [(abs_le.mp hr).1]⟩
+  have h3 : ‖((-3 - a : ℝ) : ℂ) * Complex.I‖ ≤ 6 := by
+    simp only [norm_mul, Complex.norm_real, Real.norm_eq_abs, Complex.norm_I, mul_one]
+    exact abs_le.mpr ⟨by linarith, by linarith⟩
+  exact ((clippedVector_shift_lipschitz w h0 0).add
+    (clippedVector_lipschitz h1 1) |>.add (clippedVector_lipschitz h2 2) |>.add
+    (clippedVector_lipschitz h3 3)).weaken (by norm_num)
+
+end SLEExactGauge.Serpentine
+
+end
+
+end OAI
diff --git a/lean/OAI/Probability/SLE/Geometry/MarkedSurvivingBall.lean b/lean/OAI/Probability/SLE/Geometry/MarkedSurvivingBall.lean
new file mode 100644
index 0000000000000000000000000000000000000000..f7ae255124de1eb3963b1e3214bd720eaacbc226
--- /dev/null
+++ b/lean/OAI/Probability/SLE/Geometry/MarkedSurvivingBall.lean
@@ -0,0 +1,57 @@
+import OAI.Probability.SLE.Geometry.MarkedCornerBounds
+import OAI.Probability.SLE.Gauge.RibbonSurvival
+
+namespace OAI
+
+/-! The marked corner lies in a quantitative free ball of the actual
+surviving component. This follows from the physical low-or-right geometry
+of the completed trace, with no filled-hull containment assumption. -/
+
+noncomputable section
+open Set Filter Metric
+open scoped Topology NNReal
+
+namespace SLEExactGauge.Serpentine
+
+theorem marked_ball_survives
+    (γ : ℝ≥0 → ℂ) (T : ℝ≥0) (w : ℂ) {a : ℝ} (ha : 0 < a) (hw : 2 * a < w.im)
+    (hpast : ∀ q ∈ γ '' Icc 0 T, q.im ≤ w.im - 2 * a ∨ w.re + 2 * a ≤ q.re) :
+    ball w a ⊆ survivingDomain γ T := by
+  intro z hz
+  have hd : ‖z - w‖ < a := by simpa only [mem_ball, dist_eq_norm] using hz
+  have hr := (Complex.abs_re_le_norm (z - w)).trans_lt hd
+  have hi := (Complex.abs_im_le_norm (z - w)).trans_lt hd
+  rw [Complex.sub_re] at hr
+  rw [Complex.sub_im] at hi
+  have hfree : range (upwardRay z) ⊆ upperHalfPlane \ (γ '' Icc 0 T) := by
+    rintro q ⟨u, rfl⟩
+    have hre : (upwardRay z u).re = z.re := by simp [upwardRay]
+    have him : (upwardRay z u).im = z.im + (u : ℝ) := by simp [upwardRay]
+    refine ⟨?_, ?_⟩
+    · change 0 < (upwardRay z u).im
+      rw [him]
+      linarith [(abs_lt.mp hi).1, u.coe_nonneg]
+    · intro hq
+      rcases hpast _ hq with hq | hq
+      · rw [him] at hq
+        linarith [(abs_lt.mp hi).1, u.coe_nonneg]
+      · rw [hre] at hq
+        linarith [(abs_lt.mp hr).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
+
+lemma marked_corner_ball_survives
+    (γ : ℝ≥0 → ℂ) (T : ℝ≥0) (w : ℂ) {a : ℝ} (ha : 0 < a) (hw : 2 * a < w.im)
+    (hpast : ∀ q ∈ γ '' Icc 0 T, q.im ≤ w.im - 2 * a ∨ w.re + 2 * a ≤ q.re) :
+    MapsTo (markedCornerChart w) (ball (0 : ℂ) (a / 12)) (survivingDomain γ T) := by
+  intro z hz
+  apply marked_ball_survives γ T w ha hw hpast
+  have hn : ‖z‖ < a / 12 := by simpa only [mem_ball, dist_zero_right] using hz
+  exact (markedCornerChart_norm w z).trans_lt (by linarith)
+
+end SLEExactGauge.Serpentine
+
+end
+
+end OAI
diff --git a/lean/OAI/Probability/SLE/Geometry/MarkedTubeLocalSides.lean b/lean/OAI/Probability/SLE/Geometry/MarkedTubeLocalSides.lean
new file mode 100644
index 0000000000000000000000000000000000000000..c43360cfd62c0a9f9cf4aeb591f3984ebd5d11bf
--- /dev/null
+++ b/lean/OAI/Probability/SLE/Geometry/MarkedTubeLocalSides.lean
@@ -0,0 +1,129 @@
+import OAI.Probability.SLE.Geometry.MarkedRouteSides
+import OAI.Probability.SLE.Geometry.LocalCrosscutSides
+
+namespace OAI
+
+/-! Uniform small physical tube neighbourhoods depart on opposite local
+sides of the marked corner. Openness determines either orientation of the
+actual conformal map-out; no boundary-order assertion is assumed. -/
+
+noncomputable section
+open Set Metric
+open scoped Topology
+
+namespace SLEExactGauge.Serpentine
+open RibbonCoordinates CrosscutSides
+
+lemma markedLeftRoute_small_time (w : ℂ) (a : ℝ) :
+    markedLeftRoute w a (1 / 48) = w - (a / 48 : ℝ) * Complex.I := by
+  apply Complex.ext <;> norm_num [unitClip]; ring
+
+lemma markedRightRoute_small_time (w : ℂ) (a : ℝ) :
+    markedRightRoute w a (1 / 48) =
+      w + ((-a / 96 : ℝ) : ℂ) + (a / 96 : ℝ) * Complex.I := by
+  apply Complex.ext <;> norm_num [unitClip] <;> ring
+
+lemma marked_small_route_dist (w : ℂ) {a : ℝ} (ha : 0 ≤ a) :
+    dist (markedLeftRoute w a (1 / 48)) w ≤ a / 48 ∧
+      dist (markedRightRoute w a (1 / 48)) w ≤ a / 48 := by
+  constructor
+  · rw [markedLeftRoute_small_time, dist_eq_norm, sub_sub_cancel_left,
+      norm_neg, norm_mul, Complex.norm_real, Real.norm_eq_abs, Complex.norm_I,
+      mul_one, abs_of_nonneg (by positivity : 0 ≤ a / 48)]
+  · rw [markedRightRoute_small_time, dist_eq_norm]
+    have he : w + ((-a / 96 : ℝ) : ℂ) + (a / 96 : ℝ) * Complex.I - w =
+        ((-a / 96 : ℝ) : ℂ) + (a / 96 : ℝ) * Complex.I := by ring
+    rw [he]
+    calc
+      _ ≤ |(-a / 96 : ℝ)| + |a / 96| := by
+        simpa using Complex.norm_le_abs_re_add_abs_im
+          (((-a / 96 : ℝ) : ℂ) + (a / 96 : ℝ) * Complex.I)
+      _ = a / 48 := by rw [abs_of_nonpos (by linarith), abs_of_nonneg (by positivity)]; ring
+
+lemma marked_small_tube_coordinate {w y : ℂ} {a : ℝ} (ha : 0 < a)
+    (hnear : dist y (markedLeftRoute w a (1 / 48)) < a / 10000 ∨
+      dist y (markedRightRoute w a (1 / 48)) < a / 10000) :
+    (markedCornerChart w).symm y ∈ ball (0 : ℂ) (a / 12) := by
+  have hd : dist y w < a / 10000 + a / 48 := by
+    rcases hnear with hn | hn
+    · exact (dist_triangle y _ w).trans_lt (add_lt_add_of_lt_of_le hn (marked_small_route_dist w ha.le).1)
+    · exact (dist_triangle y _ w).trans_lt (add_lt_add_of_lt_of_le hn (marked_small_route_dist w ha.le).2)
+  have hb := markedCornerChart_norm_lower w ((markedCornerChart w).symm y)
+  rw [Homeomorph.apply_symm_apply] at hb
+  rw [mem_ball, dist_zero_right]
+  linarith
+
+lemma marked_small_tube_positive {w y : ℂ} {a : ℝ} (ha : 0 < a)
+    (hn : dist y (markedLeftRoute w a (1 / 48)) < a / 10000) :
+    0 < ((markedCornerChart w).symm y).im := by
+  have hi := (Complex.abs_im_le_norm (y - markedLeftRoute w a (1 / 48))).trans_lt
+    (show ‖y - markedLeftRoute w a (1 / 48)‖ < a / 10000 by simpa only [dist_eq_norm] using hn)
+  rw [Complex.sub_im, markedLeftRoute_small_time] at hi
+  simp only [Complex.sub_im, Complex.mul_im, Complex.ofReal_re, Complex.ofReal_im,
+    Complex.I_re, Complex.I_im, mul_one, mul_zero, add_zero] at hi
+  rw [markedCornerChart_symm_im]
+  exact lt_of_lt_of_le (by linarith [(abs_lt.mp hi).2] : 0 < w.im - y.im) (le_max_right _ _)
+
+lemma marked_small_tube_negative {w y : ℂ} {a : ℝ} (ha : 0 < a)
+    (hn : dist y (markedRightRoute w a (1 / 48)) < a / 10000) :
+    ((markedCornerChart w).symm y).im < 0 := by
+  have hd : ‖y - markedRightRoute w a (1 / 48)‖ < a / 10000 := by simpa only [dist_eq_norm] using hn
+  have hi := (Complex.abs_im_le_norm _).trans_lt hd
+  have hr := (Complex.abs_re_le_norm _).trans_lt hd
+  rw [Complex.sub_im, markedRightRoute_small_time] at hi
+  rw [Complex.sub_re, markedRightRoute_small_time] at hr
+  simp only [Complex.add_im, Complex.mul_im, Complex.ofReal_re, Complex.ofReal_im,
+    Complex.I_re, Complex.I_im, mul_one, mul_zero, add_zero] at hi
+  simp only [Complex.add_re, Complex.mul_re, Complex.ofReal_re, Complex.ofReal_im,
+    Complex.I_re, Complex.I_im, mul_zero] at hr
+  rw [markedCornerChart_symm_im, max_lt_iff]
+  constructor <;> linarith [(abs_lt.mp hi).1, (abs_lt.mp hr).2]
+
+theorem marked_physical_tubes_opposite_sides
+    (hopen : PublishedPlanarDiskOpenness) (w : ℂ) {a : ℝ} (ha : 0 < a)
+    (f : ℂ → ℂ) (j : ℂ → ℝ)
+    (hf : ContinuousOn f (ball (0 : ℂ) (a / 12)))
+    (hfi : InjOn f (ball (0 : ℂ) (a / 12)))
+    (hzero : ∀ z ∈ ball (0 : ℂ) (a / 12), (f z).re = 0 ↔ z.im = 0)
+    (hrel : ∀ z ∈ ball (0 : ℂ) (a / 12), j (markedCornerChart w z) = (f z).re) :
+    ((∀ y : ℂ, dist y (markedLeftRoute w a (1 / 48)) < a / 10000 → 0 < j y) ∧
+      (∀ y : ℂ, dist y (markedRightRoute w a (1 / 48)) < a / 10000 → j y < 0)) ∨
+    ((∀ y : ℂ, dist y (markedLeftRoute w a (1 / 48)) < a / 10000 → j y < 0) ∧
+      (∀ y : ℂ, dist y (markedRightRoute w a (1 / 48)) < a / 10000 → 0 < j y)) := by
+  have ha12 : 0 < a / 12 := by positivity
+  have hz := (hzero 0 (mem_ball_self ha12)).mpr (by simp)
+  obtain h | h := opposite_half_disk_signs f 0 ha12 hf (hopen f 0 _ ha12 hf hfi) hz hzero
+  · left
+    constructor
+    · intro y hy
+      have hb := marked_small_tube_coordinate ha (Or.inl hy)
+      have he := hrel _ hb
+      rw [Homeomorph.apply_symm_apply] at he
+      rw [he]
+      exact h.1 _ hb (marked_small_tube_positive ha hy)
+    · intro y hy
+      have hb := marked_small_tube_coordinate ha (Or.inr hy)
+      have he := hrel _ hb
+      rw [Homeomorph.apply_symm_apply] at he
+      rw [he]
+      exact h.2 _ hb (marked_small_tube_negative ha hy)
+  · right
+    constructor
+    · intro y hy
+      have hb := marked_small_tube_coordinate ha (Or.inl hy)
+      have he := hrel _ hb
+      rw [Homeomorph.apply_symm_apply] at he
+      rw [he]
+      exact h.1 _ hb (marked_small_tube_positive ha hy)
+    · intro y hy
+      have hb := marked_small_tube_coordinate ha (Or.inr hy)
+      have he := hrel _ hb
+      rw [Homeomorph.apply_symm_apply] at he
+      rw [he]
+      exact h.2 _ hb (marked_small_tube_negative ha hy)
+
+end SLEExactGauge.Serpentine
+
+end
+
+end OAI
diff --git a/lean/OAI/Probability/SLE/Geometry/MarkedWindowEarly.lean b/lean/OAI/Probability/SLE/Geometry/MarkedWindowEarly.lean
new file mode 100644
index 0000000000000000000000000000000000000000..8a305e2246070f112e7ebd999ac9f3742416a291
--- /dev/null
+++ b/lean/OAI/Probability/SLE/Geometry/MarkedWindowEarly.lean
@@ -0,0 +1,68 @@
+import OAI.Probability.SLE.Geometry.MarkedWindowRoutes
+
+namespace OAI
+
+/-! A short initial part of either marked route stays in the free marked
+ball, including the entire uniform Brownian tube around that part. -/
+
+noncomputable section
+open Set Metric
+open scoped Topology
+
+namespace SLEExactGauge.Serpentine
+open RibbonCoordinates
+
+lemma markedRoute_initial_dist {w : ℂ} {a u : ℝ} (ha : 0 ≤ a)
+    (hu : u ∈ Icc (0 : ℝ) (1 / 48)) :
+    dist (markedLeftRoute w a u) w ≤ a / 48 ∧
+      dist (markedRightRoute w a u) w ≤ a / 48 := by
+  have hleft : markedLeftRoute w a u = w - ((a * u : ℝ) : ℂ) * Complex.I := by
+    apply Complex.ext <;>
+      simp only [markedLeftRoute_re, markedLeftRoute_im,
+        unitClip_of_mem ⟨hu.1, hu.2.trans (by norm_num)⟩,
+        unitClip_of_nonpos (by linarith [hu.2] : u - 1 ≤ 0),
+        unitClip_of_nonpos (by linarith [hu.2] : u - 2 ≤ 0),
+        Complex.sub_re, Complex.sub_im, Complex.mul_re, Complex.mul_im,
+        Complex.ofReal_re, Complex.ofReal_im, Complex.I_re, Complex.I_im,
+        mul_zero, mul_one, add_zero, sub_zero]
+  have hright : markedRightRoute w a u = w + ((-a * u / 2 : ℝ) : ℂ) +
+      ((a * u / 2 : ℝ) : ℂ) * Complex.I := by
+    apply Complex.ext <;>
+      simp only [markedRightRoute_re, markedRightRoute_im,
+        unitClip_of_mem ⟨hu.1, hu.2.trans (by norm_num)⟩,
+        unitClip_of_nonpos (by linarith [hu.2] : u - 1 ≤ 0),
+        unitClip_of_nonpos (by linarith [hu.2] : u - 2 ≤ 0),
+        unitClip_of_nonpos (by linarith [hu.2] : u - 3 ≤ 0),
+        Complex.add_re, Complex.add_im, Complex.mul_re, Complex.mul_im,
+        Complex.ofReal_re, Complex.ofReal_im, Complex.I_re, Complex.I_im,
+        mul_zero, mul_one, add_zero, sub_zero] <;> ring
+  have hprod : 0 ≤ a * u := mul_nonneg ha hu.1
+  have hbound : a * u ≤ a / 48 := by nlinarith [hu.2]
+  constructor
+  · rw [hleft, dist_eq_norm, sub_sub_cancel_left, norm_neg, norm_mul,
+      Complex.norm_real, Real.norm_eq_abs, Complex.norm_I, mul_one, abs_of_nonneg hprod]
+    exact hbound
+  · rw [hright, dist_eq_norm]
+    have he : w + ((-a * u / 2 : ℝ) : ℂ) + ((a * u / 2 : ℝ) : ℂ) * Complex.I - w =
+        ((-a * u / 2 : ℝ) : ℂ) + ((a * u / 2 : ℝ) : ℂ) * Complex.I := by ring
+    rw [he]
+    calc
+      _ ≤ |(-a * u / 2 : ℝ)| + |a * u / 2| := by
+        simpa using Complex.norm_le_abs_re_add_abs_im
+          (((-a * u / 2 : ℝ) : ℂ) + ((a * u / 2 : ℝ) : ℂ) * Complex.I)
+      _ = a * u := by rw [abs_of_nonpos (by nlinarith), abs_of_nonneg (by positivity)]; ring
+      _ ≤ a / 48 := hbound
+
+lemma markedWindowRoute_early_dist (right : Bool) (w : ℂ) {a : ℝ} (ha : 0 ≤ a)
+    {t : ℝ} (ht : t ∈ Icc (0 : ℝ) (1 / 64)) :
+    dist (markedWindowRoute right w a t) w ≤ a / 48 := by
+  have hu : 4 / 3 * t ∈ Icc (0 : ℝ) (1 / 48) := ⟨by linarith [ht.1], by linarith [ht.2]⟩
+  cases right
+  · exact (markedRoute_initial_dist ha hu).1
+  · exact (markedRoute_initial_dist ha hu).2
+
+end SLEExactGauge.Serpentine
+
+end
+
+end OAI
diff --git a/lean/OAI/Probability/SLE/Geometry/MarkedWindowRoutes.lean b/lean/OAI/Probability/SLE/Geometry/MarkedWindowRoutes.lean
new file mode 100644
index 0000000000000000000000000000000000000000..c19d5943ac1f8e49d4f10a6076bb9cd139a74379
--- /dev/null
+++ b/lean/OAI/Probability/SLE/Geometry/MarkedWindowRoutes.lean
@@ -0,0 +1,66 @@
+import OAI.Probability.SLE.Geometry.MarkedTubeLocalSides
+import OAI.Probability.SLE.Geometry.PhysicalRouteProbability
+
+namespace OAI
+
+/-! Compress the four-leg marked routes into the finite Brownian exit
+window used by the published conformal exit law. -/
+
+noncomputable section
+open Set Metric MeasureTheory
+open scoped Topology NNReal ENNReal
+
+namespace SLEExactGauge.Serpentine
+open RibbonCoordinates Target
+
+def markedWindowRoute (right : Bool) (w : ℂ) (a t : ℝ) : ℂ :=
+  if right then markedRightRoute w a (4 / 3 * t) else markedLeftRoute w a (4 / 3 * t)
+
+lemma markedWindowRoute_zero (right : Bool) (w : ℂ) (a : ℝ) :
+    markedWindowRoute right w a 0 = w := by
+  cases right <;> simp only [markedWindowRoute, Bool.false_eq_true, ↓reduceIte, mul_zero,
+    markedLeftRoute_zero, markedRightRoute_zero]
+
+lemma markedWindowRoute_small (right : Bool) (w : ℂ) (a : ℝ) :
+    markedWindowRoute right w a (1 / 64) =
+      if right then markedRightRoute w a (1 / 48) else markedLeftRoute w a (1 / 48) := by
+  norm_num only [markedWindowRoute]
+
+lemma markedWindowRoute_final (right : Bool) (w : ℂ) (a : ℝ) :
+    (markedWindowRoute right w a 3).im = -1 := by
+  cases right <;> norm_num [markedWindowRoute, markedLeftRoute_four, markedRightRoute_final]
+
+lemma markedWindowRoute_lipschitz (right : Bool) {w : ℂ} (hw : ‖w‖ ≤ 1)
+    {a : ℝ} (ha : 0 ≤ a) (ha1 : a ≤ 1) : LipschitzWith 32 (markedWindowRoute right w a) := by
+  have hroute : LipschitzWith 24
+      (fun t => if right then markedRightRoute w a t else markedLeftRoute w a t) := by
+    cases right
+    · exact markedLeftRoute_lipschitz hw ha ha1
+    · exact markedRightRoute_lipschitz hw ha ha1
+  apply LipschitzWith.of_dist_le_mul
+  intro t u
+  have hh := hroute.dist_le_mul (4 / 3 * t) (4 / 3 * u)
+  have hd : dist (4 / 3 * t) (4 / 3 * u) = (4 / 3 : ℝ) * dist t u := by
+    rw [Real.dist_eq, Real.dist_eq, ← mul_sub, abs_mul]
+    norm_num
+  rw [hd] at hh
+  change dist (markedWindowRoute right w a t) (markedWindowRoute right w a u) ≤ _
+  convert hh using 1 <;> norm_num [markedWindowRoute]; ring
+
+theorem uniform_marked_window_tube_probability
+    (hpublished : PublishedPlanarWienerUnitSupport) (W : WienerLaw) (hW : IsWiener W)
+    {a : ℝ} (ha : 0 < a) (ha1 : a ≤ 1) :
+    ∃ q : ℝ≥0∞, 0 < q ∧ ∀ (right : Bool) (w : ℂ), ‖w‖ ≤ 1 →
+      q ≤ (W.prod W) {b | ∀ t ∈ Icc (0 : ℝ) 3,
+        dist (physicalUnitBrownianPath w b t) (markedWindowRoute right w a t) < a / 10000} := by
+  obtain ⟨q, hq, hprob⟩ := uniform_physical_route_tube_probability hpublished W hW 32
+    (by positivity : 0 < a / 10000)
+  refine ⟨q, hq, fun right w hw => ?_⟩
+  simpa only [markedWindowRoute_zero] using
+    hprob (markedWindowRoute right w a) (markedWindowRoute_lipschitz right hw ha.le ha1)
+
+end SLEExactGauge.Serpentine
+
+end
+
+end OAI
diff --git a/lean/OAI/Probability/SLE/Geometry/MarkedWitnessReflection.lean b/lean/OAI/Probability/SLE/Geometry/MarkedWitnessReflection.lean
new file mode 100644
index 0000000000000000000000000000000000000000..2c05c1149d8a4c69fe89aec7c63a5822f946720e
--- /dev/null
+++ b/lean/OAI/Probability/SLE/Geometry/MarkedWitnessReflection.lean
@@ -0,0 +1,72 @@
+import OAI.Probability.SLE.Gauge.SerpentineMarkedReflection
+import OAI.Probability.SLE.BrownianStrongMarkov
+
+namespace OAI
+
+/-! The actual capacity witness and marked sine angle transform exactly
+under reflection; no law comparison is needed for the geometric angle bound. -/
+
+noncomputable section
+open Set Metric
+open scoped Topology NNReal
+
+namespace SLEExactGauge.Serpentine
+
+lemma mirrored_centered_value (z : ℂ) (u : ℝ) :
+    loewnerMirror z - ((-u : ℝ) : ℂ) = loewnerMirror (z - (u : ℂ)) := by
+  apply Complex.ext <;> simp [sub_eq_add_neg, add_comm]
+
+lemma mirrored_centered_sine (z : ℂ) (u : ℝ) :
+    (loewnerMirror z - ((-u : ℝ) : ℂ)).im / ‖loewnerMirror z - ((-u : ℝ) : ℂ)‖ =
+      (z - (u : ℂ)).im / ‖z - (u : ℂ)‖ := by
+  rw [mirrored_centered_value, loewnerMirror_im, loewnerMirror_norm]
+
+lemma mirrored_marked_sine (G : ℝ≥0 → ℂ → ℂ) (U : ℝ≥0 → ℝ) (T : ℝ≥0) (w : ℂ) :
+    (loewnerMirror (G T (loewnerMirror (loewnerMirror w))) - ((-U T : ℝ) : ℂ)).im /
+      ‖loewnerMirror (G T (loewnerMirror (loewnerMirror w))) - ((-U T : ℝ) : ℂ)‖ =
+      (G T w - (U T : ℂ)).im / ‖G T w - (U T : ℂ)‖ := by
+  rw [loewnerMirror_twice, mirrored_centered_sine]
+
+lemma mirrored_front_freshness (γ : ℝ≥0 → ℂ) (T : ℝ≥0)
+    (hfresh : ∀ S : ℝ≥0, S < T → γ T ∈ survivingDomain γ S) :
+    ∀ S : ℝ≥0, S < T → (loewnerMirror ∘ γ) T ∈ survivingDomain (loewnerMirror ∘ γ) S := by
+  intro S hS
+  exact (loewnerMirror_surviving γ S (γ T)).mpr (hfresh S hS)
+
+lemma mirrored_ball_surviving_iff (γ : ℝ≥0 → ℂ) (T : ℝ≥0) (w : ℂ) (r : ℝ) :
+    ball (loewnerMirror w) r ⊆ survivingDomain (loewnerMirror ∘ γ) T ↔
+      ball w r ⊆ survivingDomain γ T := by
+  constructor
+  · intro h z hz
+    exact (loewnerMirror_surviving γ T z).mp
+      (h (by simpa only [mem_ball, loewnerMirror_dist] using hz))
+  · intro h z hz
+    have hz' : loewnerMirror z ∈ ball w r := by
+      change dist (loewnerMirror z) w < r
+      have hd := loewnerMirror_dist z (loewnerMirror w)
+      rw [loewnerMirror_twice] at hd
+      exact hd.trans_lt hz
+    have hh := (loewnerMirror_surviving γ T (loewnerMirror z)).mpr (h hz')
+    simpa only [loewnerMirror_twice] using hh
+
+/-- Every item required by the marked-angle application is reflected
+with the same capacity time and the negated continuous driver. -/
+theorem marked_witness_reflection
+    {U : ℝ≥0 → ℝ} {γ : ℝ≥0 → ℂ} {G F : ℝ≥0 → ℂ → ℂ}
+    (hw : IsCapacityTwoWitness U γ G F) (hU : Continuous U) (T : ℝ≥0)
+    (hfresh : ∀ S : ℝ≥0, S < T → γ T ∈ survivingDomain γ S) (w : ℂ) :
+    IsCapacityTwoWitness (fun t => -U t) (loewnerMirror ∘ γ)
+      (fun t z => loewnerMirror (G t (loewnerMirror z)))
+      (fun t z => loewnerMirror (F t (loewnerMirror z))) ∧
+    Continuous (fun t => -U t) ∧
+    (∀ S : ℝ≥0, S < T → (loewnerMirror ∘ γ) T ∈ survivingDomain (loewnerMirror ∘ γ) S) ∧
+    (loewnerMirror (G T (loewnerMirror (loewnerMirror w))) - ((-U T : ℝ) : ℂ)).im /
+      ‖loewnerMirror (G T (loewnerMirror (loewnerMirror w))) - ((-U T : ℝ) : ℂ)‖ =
+      (G T w - (U T : ℂ)).im / ‖G T w - (U T : ℂ)‖ :=
+  ⟨hw.mirror, hU.neg, mirrored_front_freshness γ T hfresh, mirrored_marked_sine G U T w⟩
+
+end SLEExactGauge.Serpentine
+
+end
+
+end OAI
diff --git a/lean/OAI/Probability/SLE/Geometry/MeasurableBoundaryRestart.lean b/lean/OAI/Probability/SLE/Geometry/MeasurableBoundaryRestart.lean
new file mode 100644
index 0000000000000000000000000000000000000000..ff0918cb69eddcec32c706da115a489bb4ee80b0
--- /dev/null
+++ b/lean/OAI/Probability/SLE/Geometry/MeasurableBoundaryRestart.lean
@@ -0,0 +1,100 @@
+import OAI.Probability.SLE.Geometry.RandomBoundaryTubes
+import OAI.Probability.SLE.Geometry.StoppedBoundaryRestart
+
+namespace OAI
+
+/-! The actual stopped trace law with a past-measurable boundary chart.
+The identity holds at all future times, including boundary visits, for the
+same chart family used in random continuation events. -/
+
+noncomputable section
+open Set Filter MeasureTheory ProbabilityTheory
+open scoped Topology NNReal ENNReal
+
+namespace SLEExactGauge
+
+theorem source_measurable_boundary_restart
+    {Ω : 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 ω))
+    (hpublished : PublishedLoewnerBoundaryExtension)
+    (τ : Ω → ℝ≥0)
+    (hτ : IsStoppingTime (Filtration.natural B (fun t => (hm t).stronglyMeasurable))
+      (fun ω => (τ ω : WithTop ℝ≥0))) :
+    ∃ Φ : C(ℝ≥0, ℝ) → C(ℝ≥0, ℂ), ∃ Fb : Ω → C(closedHalfPlane, OnePoint ℂ),
+      Measurable Φ ∧
+      (∀ ω, Φ (sourceDriverPath B hc ω) = sourceTracePath γ (fun ω => (hw ω).1) ω) ∧
+      Measurable[hτ.measurableSpace] Fb ∧
+      (∀ ω (z : closedHalfPlane), z.1 ∈ upperHalfPlane →
+        Fb ω z = (F ω (τ ω) (z + (Real.sqrt κ * B (τ ω) ω : ℝ)) : OnePoint ℂ)) ∧
+      (∀ ω, Fb ω ⟨0, by simp [closedHalfPlane]⟩ = (γ ω (τ ω) : OnePoint ℂ)) ∧
+      (∀ A : Set Ω, MeasurableSet[hτ.measurableSpace] A →
+        (P.restrict A).map (fun ω => Φ (sourceRestartDriverPath B hc τ ω)) =
+          P A • P.map (sourceTracePath γ (fun ω => (hw ω).1))) ∧
+      ∀ᵐ ω ∂P, ∀ t : ℝ≥0,
+        (γ ω (τ ω + t) : OnePoint ℂ) =
+          Fb ω (liftClosedPath (Φ (sourceRestartDriverPath B hc τ ω)) t) := by
+  let : IsProbabilityMeasure P := hB.isGaussianProcess.isProbabilityMeasure
+  obtain ⟨Φ, hΦm, hΦ, hlaw⟩ := sourceStoppedTraceLaw κ hκ hκ8 B hB hm hc γ G F hw
+  obtain ⟨Fb, hFbm, hFb, hFb0⟩ := source_stopped_boundaryPath_measurable
+    hpublished B hm hc κ γ G F hw τ hτ
+  let gp := sourceTracePath γ (fun ω => (hw ω).1)
+  have hgm : Measurable gp := by
+    have he : gp = fun ω => Φ (sourceDriverPath B hc ω) := funext fun ω => (hΦ ω).symm
+    rw [he]
+    exact hΦm.comp (source_path_measurable (sourceDriverPath B hc) hm)
+  have hSLE : IsOrdinaryChordalSLE κ γ P := by
+    refine ⟨fun t => (continuous_eval_const t).measurable.comp hgm, B, hB, ?_⟩
+    exact Eventually.of_forall fun ω => ⟨G ω, F ω, hw ω⟩
+  have hgood := StoppedBoundaryRestart.ordinarySLE_ae_goodBoundaryPath
+    hκ hκ8 γ (fun ω => (hw ω).1) hSLE
+  have hgoodLaw : ∀ᵐ p ∂P.map gp, StoppedBoundaryRestart.GoodBoundaryPath p :=
+    (ae_map_iff hgm.aemeasurable StoppedBoundaryRestart.measurableSet_goodBoundaryPath).mpr hgood
+  let rp := sourceRestartDriverPath B hc τ
+  have hrm : Measurable rp := source_path_measurable rp (fun t =>
+    (measurable_pi_apply t).comp (brownianRestart_measurable hm hc
+      (stopping_time_measurable_nnreal hτ)))
+  have hrestartLaw : P.map (fun ω => Φ (rp ω)) = P.map gp := by
+    simpa only [Measure.restrict_univ, measure_univ, one_smul] using
+      (hlaw τ hτ).1 univ MeasurableSet.univ
+  have hgoodRestart : ∀ᵐ ω ∂P, StoppedBoundaryRestart.GoodBoundaryPath (Φ (rp ω)) := by
+    rw [← hrestartLaw] at hgoodLaw
+    exact (ae_map_iff (hΦm.comp hrm).aemeasurable
+      StoppedBoundaryRestart.measurableSet_goodBoundaryPath).mp hgoodLaw
+  refine ⟨Φ, Fb, hΦm, hΦ, hFbm, hFb, hFb0, (hlaw τ hτ).1, ?_⟩
+  filter_upwards [hgoodRestart, (hlaw τ hτ).2] with ω hgoodω heq
+  let Fext : ℂ → OnePoint ℂ := fun z =>
+    if hz : z ∈ closedHalfPlane then Fb ω ⟨z, hz⟩ else OnePoint.infty
+  have hFc : ContinuousOn Fext closedHalfPlane := by
+    rw [continuousOn_iff_continuous_domRestrict]
+    convert (Fb ω).continuous using 1
+    funext z
+    change Fext z = Fb ω z
+    dsimp only [Fext]
+    rw [dite_eq_left z.2]
+  have hfull : ∀ t : ℝ≥0, (γ ω (τ ω + t) : OnePoint ℂ) = Fext (Φ (rp ω) t) := by
+    apply StoppedBoundaryRestart.extend_restart_identity (Φ (rp ω))
+      (fun t => γ ω (τ ω + t)) ((hw ω).1.comp (continuous_const.add continuous_id))
+      Fext hFc hgoodω
+    intro t ht
+    have hz : Φ (rp ω) t ∈ closedHalfPlane :=
+      (show 0 < (Φ (rp ω) t).im from ht).le
+    simp only [Fext, dite_eq_left hz]
+    rw [hFb ω ⟨Φ (rp ω) t, hz⟩ ht, heq t ht]
+  intro t
+  rw [hfull t]
+  have hz : Φ (rp ω) t ∈ closedHalfPlane := hgoodω.2 t
+  simp only [Fext, dite_eq_left hz]
+  congr 1
+  apply Subtype.ext
+  exact (liftClosedPath_apply _ hgoodω.2 t).symm
+
+end SLEExactGauge
+
+end
+
+end OAI
diff --git a/lean/OAI/Probability/SLE/Geometry/MonotoneRationalLimit.lean b/lean/OAI/Probability/SLE/Geometry/MonotoneRationalLimit.lean
new file mode 100644
index 0000000000000000000000000000000000000000..4b14829d7f90af20f63b9c1c4c450c9a029d99c9
--- /dev/null
+++ b/lean/OAI/Probability/SLE/Geometry/MonotoneRationalLimit.lean
@@ -0,0 +1,48 @@
+import Mathlib.Topology.Instances.Rat
+import Mathlib.Topology.Order.Basic
+import Mathlib.Tactic.Linarith
+
+namespace OAI
+
+/-! A continuous limit on rational times determines the limit at every
+time for a sequence of increasing functions. -/
+
+noncomputable section
+open Set Filter
+open scoped Topology
+
+namespace SLEExactGauge
+
+theorem tendsto_of_monotone_rational_limits
+    (A : ℕ → ℝ → ℝ) (a : ℝ → ℝ)
+    (hA : ∀ n, Monotone (A n)) (ha : Continuous a)
+    (hrat : ∀ q : ℚ, Tendsto (fun n => A n q) atTop (𝓝 (a q)))
+    (x : ℝ) : Tendsto (fun n => A n x) atTop (𝓝 (a x)) := by
+  apply tendsto_order.mpr
+  constructor
+  · intro b hb
+    have hn : {y | b < a y} ∈ 𝓝 x :=
+      (isOpen_lt continuous_const ha).mem_nhds hb
+    obtain ⟨ε,hε,he⟩ := Metric.mem_nhds_iff.mp hn
+    obtain ⟨q,hq,hqx⟩ := exists_rat_btwn (sub_lt_self x hε)
+    have hqb : b < a q := he (by
+      rw [Metric.mem_ball,Real.dist_eq,abs_of_neg (sub_neg.mpr hqx)]
+      linarith)
+    filter_upwards [(tendsto_order.mp (hrat q)).1 b hqb] with n hn
+    exact hn.trans_le (hA n hqx.le)
+  · intro b hb
+    have hn : {y | a y < b} ∈ 𝓝 x :=
+      (isOpen_lt ha continuous_const).mem_nhds hb
+    obtain ⟨ε,hε,he⟩ := Metric.mem_nhds_iff.mp hn
+    obtain ⟨q,hxq,hq⟩ := exists_rat_btwn (lt_add_of_pos_right x hε)
+    have hqb : a q < b := he (by
+      rw [Metric.mem_ball,Real.dist_eq,abs_of_pos (sub_pos.mpr hxq)]
+      linarith)
+    filter_upwards [(tendsto_order.mp (hrat q)).2 b hqb] with n hn
+    exact (hA n hxq.le).trans_lt hn
+
+end SLEExactGauge
+
+end
+
+end OAI
diff --git a/lean/OAI/Probability/SLE/Geometry/NoBoundaryAtoms.lean b/lean/OAI/Probability/SLE/Geometry/NoBoundaryAtoms.lean
new file mode 100644
index 0000000000000000000000000000000000000000..deef198b109d3c7348f84ce3ace889d7cd43f36c
--- /dev/null
+++ b/lean/OAI/Probability/SLE/Geometry/NoBoundaryAtoms.lean
@@ -0,0 +1,47 @@
+import OAI.Probability.SLE.Geometry.HolomorphicBoundaryAtoms
+
+namespace OAI
+
+/-! A centered conformal disk chart has no atom at any prescribed
+boundary point on finite physical exits. -/
+noncomputable section
+open Set Filter MeasureTheory ProbabilityTheory Metric
+open scoped Topology NNReal ENNReal
+
+namespace SLEExactGauge
+open Target
+
+theorem planarDiskExitAtom_null
+    (W : WienerLaw) (hW : IsWiener W) {D : Set ℂ} (hD : IsOpen D)
+    (w : ℂ) (hw : w∈D) {F : ℂ → ℂ} (hF : DifferentiableOn ℂ F D)
+    (hFD : MapsTo F D (ball 0 1)) (hF0 : F w=0)
+    (a : ℂ) (ha : ‖a‖=1) (T : ℝ≥0) :
+    (W.prod W) (planarDiskExitAtom D F w a T)=0 := by
+  let : IsProbabilityMeasure W := hW.isGaussianProcess.isProbabilityMeasure
+  let p := (W.prod W) (planarDiskExitAtom D F w a T)
+  have hpn : p ≠ ∞ := measure_ne_top _ _
+  have hbound (n : ℕ) : p.toReal ≤ 1/((n:ℝ)+1) := by
+    let r : ℝ := n/((n:ℝ)+1)
+    have hr : 0 ≤ r := by dsimp only [r]; positivity
+    have hr1 : r<1 := (div_lt_one (by positivity)).mpr (by norm_num)
+    have hh := planarDiskExitAtom_peak_bound W hW hD w hw hF hFD hF0 a ha T r hr hr1
+    have hcoef : (1+r)/(1-r)=2*(n:ℝ)+1 := by
+      dsimp only [r]
+      field_simp
+      ring
+    rw [hcoef] at hh
+    have hhR : (2*(n:ℝ)+1)*p.toReal ≤ 1 := by
+      simpa only [ENNReal.toReal_mul,ENNReal.toReal_ofReal (by positivity : 0 ≤ 2*(n:ℝ)+1),
+        ENNReal.toReal_one] using ENNReal.toReal_mono (by simp) hh
+    apply (le_div_iff₀ (by positivity : (0:ℝ)<n+1)).mpr
+    nlinarith [ENNReal.toReal_nonneg (a := p)]
+  have hp0 : p.toReal=0 := le_antisymm
+    (ge_of_tendsto (tendsto_one_div_add_atTop_nhds_zero_nat (𝕜 := ℝ))
+      (Eventually.of_forall hbound)) ENNReal.toReal_nonneg
+  exact ((ENNReal.toReal_eq_zero_iff p).mp hp0).resolve_right hpn
+
+end SLEExactGauge
+
+end
+
+end OAI
diff --git a/lean/OAI/Probability/SLE/Geometry/NormalizedAccessGuide.lean b/lean/OAI/Probability/SLE/Geometry/NormalizedAccessGuide.lean
new file mode 100644
index 0000000000000000000000000000000000000000..b73916c584c032f4161c2b65f936a74af0f1ca7c
--- /dev/null
+++ b/lean/OAI/Probability/SLE/Geometry/NormalizedAccessGuide.lean
@@ -0,0 +1,107 @@
+import OAI.Probability.SLE.Gauge.RibbonFrontFreshness
+import OAI.Probability.SLE.Geometry.PublishedBoundaryExtension
+
+namespace OAI
+
+/-! Continuous normalized parameter guides from actual fresh Loewner tips.
+The boundary value, inverse identity, simplicity and unit-waypoint
+normalization are derived, rather than imposed on an abstract map family. -/
+
+noncomputable section
+open Set Filter Metric
+open scoped Topology NNReal
+
+namespace SLEExactGauge
+
+theorem normalized_actual_access_guide
+    (hpublished : PublishedLoewnerBoundaryExtension)
+    {U : ℝ≥0 → ℝ} {γ : ℝ≥0 → ℂ} {G F : ℝ≥0 → ℂ → ℂ}
+    (hw : IsCapacityTwoWitness U γ G F) (hU : Continuous U)
+    (T : ℝ≥0) (hT : 0 < T)
+    (hfresh : ∀ s : ℝ≥0, s < T → γ T ∈ survivingDomain γ s)
+    (α : ℝ → ℂ) {A tw : ℝ} (_hA : 0 < A) (htw : tw ∈ Ioc (0 : ℝ) A)
+    (hα : ContinuousOn α (Icc 0 A)) (hiα : InjOn α (Icc 0 A))
+    (hα0 : α 0 = γ T) (hαD : MapsTo α (Ioc 0 A) (survivingDomain γ T)) :
+    ∃ c : ℝ, 0 < c ∧ ∃ (Fbar : ℂ → OnePoint ℂ) (β : ℝ → ℂ),
+      ContinuousOn Fbar {z : ℂ | 0 ≤ z.im} ∧
+      (∀ z ∈ upperHalfPlane, Fbar z = (F T ((U T : ℂ) + (c : ℂ) * z) : OnePoint ℂ)) ∧
+      ContinuousOn β (Icc 0 A) ∧ InjOn β (Icc 0 A) ∧ β 0 = 0 ∧
+      MapsTo β (Ioc 0 A) upperHalfPlane ∧
+      (∀ t ∈ Icc 0 A, Fbar (β t) = (α t : OnePoint ℂ)) ∧
+      ‖β tw‖ = 1 ∧
+      (∀ t ∈ Ioc 0 A, β t = (G T (α t) - (U T : ℂ)) / (c : ℂ)) := by
+  let D := survivingDomain γ T
+  have htip : γ T ∉ D := by
+    intro hh
+    exact hh.1.2 ⟨T, ⟨bot_le, le_rfl⟩, rfl⟩
+  have hlim := hw.fresh_tip_chart_tendsto hU hT hfresh
+  let gb := Function.update (G T) (γ T) (U T : ℂ)
+  have hs : insert (γ T) D \ {γ T} = D := by
+    ext z
+    simp only [Set.mem_sdiff, mem_insert_iff, mem_singleton_iff]
+    constructor
+    · rintro ⟨rfl | hz, hn⟩
+      · exact False.elim (hn rfl)
+      · exact hz
+    · intro hz
+      exact ⟨Or.inr hz, fun he => htip (he ▸ hz)⟩
+  have hgb : ContinuousOn gb (insert (γ T) D) := by
+    rw [continuousOn_update_iff, hs]
+    exact ⟨(hw.2.2.2.1 T).continuousOn, fun _ => hlim⟩
+  have hαS : MapsTo α (Icc 0 A) (insert (γ T) D) := by
+    intro t ht
+    by_cases ht0 : t = 0
+    · simpa only [ht0, hα0] using mem_insert (γ T) D
+    · exact mem_insert_of_mem _ (hαD ⟨lt_of_le_of_ne ht.1 (Ne.symm ht0), ht.2⟩)
+  have heval (t : ℝ) (ht : t ∈ Ioc 0 A) : gb (α t) = G T (α t) := by
+    have hne : α t ≠ γ T := fun he => htip (he ▸ hαD ht)
+    exact Function.update_of_ne hne _ _
+  have hwayH : G T (α tw) - (U T : ℂ) ∈ upperHalfPlane := by
+    have hh := hw.2.2.2.2.2.1 T (hαD htw)
+    simpa only [upperHalfPlane, mem_ofPred_eq, Complex.sub_im, Complex.ofReal_im, sub_zero] using hh
+  let c := ‖G T (α tw) - (U T : ℂ)‖
+  have hc : 0 < c := norm_pos_iff.mpr (by
+    intro he
+    have hh : 0 < (G T (α tw) - (U T : ℂ)).im := hwayH
+    rw [he] at hh
+    exact (lt_irrefl 0) hh)
+  let β : ℝ → ℂ := fun t => (gb (α t) - (U T : ℂ)) / (c : ℂ)
+  have hβ : ContinuousOn β (Icc 0 A) :=
+    ((hgb.comp hα hαS).sub continuousOn_const).div_const _
+  have hβ0 : β 0 = 0 := by simp [β, gb, hα0]
+  have hβeq (t : ℝ) (ht : t ∈ Ioc 0 A) :
+      β t = (G T (α t) - (U T : ℂ)) / (c : ℂ) := by
+    dsimp only [β]
+    rw [heval t ht]
+  have hβH : MapsTo β (Ioc 0 A) upperHalfPlane := by
+    intro t ht
+    rw [hβeq t ht]
+    change 0 < ((G T (α t) - (U T : ℂ)) / (c : ℂ)).im
+    rw [Complex.div_ofReal_im, Complex.sub_im, Complex.ofReal_im, sub_zero]
+    exact div_pos (hw.2.2.2.2.2.1 T (hαD ht)) hc
+  obtain ⟨Fbar, hbar, hext, hbar0⟩ :=
+    normalized_capacity_inverse_boundary_extension hpublished hU hw T c hc
+  have hbarα (t : ℝ) (ht : t ∈ Icc 0 A) : Fbar (β t) = (α t : OnePoint ℂ) := by
+    by_cases ht0 : t = 0
+    · simpa only [ht0, hβ0, hα0] using hbar0
+    · have ht' : t ∈ Ioc 0 A := ⟨lt_of_le_of_ne ht.1 (Ne.symm ht0), ht.2⟩
+      rw [hext _ (hβH ht'), hβeq t ht']
+      have hcC : (c : ℂ) ≠ 0 := Complex.ofReal_ne_zero.mpr hc.ne'
+      have he : (U T : ℂ) + (c : ℂ) * ((G T (α t) - (U T : ℂ)) / (c : ℂ)) =
+          G T (α t) := by field_simp; ring
+      rw [he, hw.2.2.2.2.2.2.2.1 T (α t) (hαD ht')]
+  have hβi : InjOn β (Icc 0 A) := by
+    intro s hs t ht he
+    apply hiα hs ht
+    apply OnePoint.coe_injective
+    rw [← hbarα s hs, ← hbarα t ht, he]
+  have hβnorm : ‖β tw‖ = 1 := by
+    rw [hβeq tw htw, norm_div, Complex.norm_real, Real.norm_eq_abs, abs_of_pos hc]
+    exact div_self hc.ne'
+  exact ⟨c, hc, Fbar, β, hbar, hext, hβ, hβi, hβ0, hβH, hbarα, hβnorm, hβeq⟩
+
+end SLEExactGauge
+
+end
+
+end OAI
diff --git a/lean/OAI/Probability/SLE/Geometry/NormalizedCanonicalRestart.lean b/lean/OAI/Probability/SLE/Geometry/NormalizedCanonicalRestart.lean
new file mode 100644
index 0000000000000000000000000000000000000000..8e9006e8d3c25f2a73df032844bc4f4db6d9d262
--- /dev/null
+++ b/lean/OAI/Probability/SLE/Geometry/NormalizedCanonicalRestart.lean
@@ -0,0 +1,165 @@
+import OAI.Probability.SLE.Geometry.CanonicalRestartWitness
+import OAI.Probability.SLE.Loewner.RestartDriverScaling
+import OAI.Probability.SLE.Geometry.NormalizedRestartKernel
+import OAI.Probability.SLE.Geometry.BoundaryScaleLaw
+
+namespace OAI
+
+/-! Canonical capacity witnesses and finite boundary charts for the actual
+restart normalized by a positive scale measurable in the stopped past. -/
+
+noncomputable section
+open Set Filter MeasureTheory ProbabilityTheory Classical
+open scoped Topology NNReal ENNReal
+
+namespace SLEExactGauge
+open BoundaryScaleLaw
+
+local instance normalizedCanonicalDriverMeasurable : MeasurableSpace C(ℝ≥0, ℝ) := borel _
+local instance normalizedCanonicalDriverBorel : BorelSpace C(ℝ≥0, ℝ) := ⟨rfl⟩
+local instance normalizedCanonicalPathMeasurable : MeasurableSpace C(ℝ≥0, ℂ) := borel _
+local instance normalizedCanonicalPathBorel : BorelSpace C(ℝ≥0, ℂ) := ⟨rfl⟩
+local instance : LocallyCompactSpace closedHalfPlane :=
+  isClosed_closedHalfPlane.locallyCompactSpace
+
+def normalizedRestartDriverPath
+    {Ω : Type*} (B : ℝ≥0 → Ω → ℝ)
+    (hc : ∀ ω, Continuous (fun t => B t ω)) (τ a : Ω → ℝ≥0) (ω : Ω) : C(ℝ≥0, ℝ) :=
+  scaleDriverPath ((a ω)⁻¹) (sourceRestartDriverPath B hc τ ω)
+
+lemma normalizedRestartDriverPath_driver
+    {Ω : Type*} (κ : ℝ) (B : ℝ≥0 → Ω → ℝ)
+    (hc : ∀ ω, Continuous (fun t => B t ω)) (τ a : Ω → ℝ≥0) (ω : Ω) :
+    (fun t => Real.sqrt κ * normalizedRestartDriverPath B hc τ a ω t) =
+      normalizedRestartDriver (fun t => Real.sqrt κ * B t ω) (τ ω) (a ω) := by
+  funext t
+  have htime : sourceScaleTime ((a ω)⁻¹) t = (a ω) ^ 2 * t := by
+    simp only [sourceScaleTime, div_eq_mul_inv, inv_pow, inv_inv, mul_comm]
+  change Real.sqrt κ * (((a ω)⁻¹ : ℝ≥0) *
+      (B (τ ω + sourceScaleTime ((a ω)⁻¹) t) ω - B (τ ω) ω)) = _
+  rw [htime]
+  simp only [normalizedRestartDriver, NNReal.coe_inv, div_eq_mul_inv]
+  ring
+
+lemma measurable_boundary_scale_family
+    {X : Type*} [MeasurableSpace X]
+    (Fb : X → C(closedHalfPlane, ℂ)) (hFb : Measurable Fb)
+    (a : X → ℝ≥0) (ha : Measurable a) :
+    Measurable (fun x => (Fb x).comp (scaleClosed (a x))) := by
+  apply ContinuousMap.measurable_iff_eval.mpr
+  intro z
+  have hz : Measurable (fun x => scaleClosed (a x) z) := by
+    apply Measurable.subtype_mk
+    exact (Complex.measurable_ofReal.comp (NNReal.continuous_coe.measurable.comp ha)).mul_const
+      (z : ℂ)
+  exact continuous_eval.measurable.comp (hFb.prodMk hz)
+
+/-- The same canonical trace factor realizes every positive, past-measurable
+normalization of the restart, with its actual capacity witness and an
+all-time identity through the corresponding finite boundary chart. -/
+theorem source_normalized_canonical_witness_boundary_restart
+    {Ω : Type*} [mΩ : 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 → ℂ) (G F : Ω → ℝ≥0 → ℂ → ℂ)
+    (hw : ∀ ω, IsCapacityTwoWitness (fun t => Real.sqrt κ * B t ω) (γ ω) (G ω) (F ω))
+    (hpublished : PublishedTraceGeneration (P.map (sourceDriverPath B hc)) κ (fun t p => p t))
+    (hboundary : PublishedFiniteLoewnerBoundaryExtension)
+    (τ : Ω → ℝ≥0)
+    (hτ : IsStoppingTime (Filtration.natural B (fun t => (hm t).stronglyMeasurable))
+      (fun ω => (τ ω : WithTop ℝ≥0)))
+    (a : Ω → ℝ≥0) (ham : Measurable[hτ.measurableSpace] a) (ha : ∀ ω, 0 < a ω) :
+    ∃ (Φ : C(ℝ≥0, ℝ) → C(ℝ≥0, ℂ))
+      (Gc Fc : C(ℝ≥0, ℝ) → ℝ≥0 → ℂ → ℂ) (Fb : Ω → C(closedHalfPlane, ℂ)),
+      Measurable Φ ∧ Measurable[hτ.measurableSpace] Fb ∧
+      Measurable (normalizedRestartDriverPath B hc τ a) ∧
+      (∀ᵐ ω ∂P, Φ (sourceDriverPath B hc ω) = sourceTracePath γ (fun ω => (hw ω).1) ω) ∧
+      (∀ᵐ p ∂P.map (sourceDriverPath B hc),
+        IsCapacityTwoWitness (fun t => Real.sqrt κ * p t) (Φ p) (Gc p) (Fc p)) ∧
+      (∀ ω (z : closedHalfPlane), z.1 ∈ upperHalfPlane →
+        Fb ω z = F ω (τ ω) ((a ω : ℂ) * z + (Real.sqrt κ * B (τ ω) ω : ℝ))) ∧
+      (∀ ω, Fb ω ⟨0, by simp [closedHalfPlane]⟩ = γ ω (τ ω)) ∧
+      (∀ A : Set Ω, MeasurableSet[hτ.measurableSpace] A →
+        (P.restrict A).map (normalizedRestartDriverPath B hc τ a) =
+          P A • P.map (sourceDriverPath B hc)) ∧
+      ∀ᵐ ω ∂P,
+        IsCapacityTwoWitness
+          (normalizedRestartDriver (fun t => Real.sqrt κ * B t ω) (τ ω) (a ω))
+          (Φ (normalizedRestartDriverPath B hc τ a ω))
+          (Gc (normalizedRestartDriverPath B hc τ a ω))
+          (Fc (normalizedRestartDriverPath B hc τ a ω)) ∧
+        ∀ t : ℝ≥0, γ ω (τ ω + (a ω) ^ 2 * t) =
+          finiteBoundaryPath (Fb ω) (Φ (normalizedRestartDriverPath B hc τ a ω)) t := by
+  obtain ⟨Φ, Gc, Fc, Fb₀, hΦ, hFb₀, hW, hFb₀eq, hFb₀zero, _htraceLaw, hrestart⟩ :=
+    source_canonical_witness_boundary_restart κ hκ hκ8 B hB hm hc γ G F hw
+      hpublished hboundary τ hτ
+  let bp := sourceDriverPath B hc
+  let rp := sourceRestartDriverPath B hc τ
+  let Y := normalizedRestartDriverPath B hc τ a
+  let Fb : Ω → C(closedHalfPlane, ℂ) := fun ω => (Fb₀ ω).comp (scaleClosed (a ω))
+  have hbp : Measurable bp := source_path_measurable bp hm
+  have hrp : Measurable rp := source_path_measurable rp (fun t =>
+    (measurable_pi_apply t).comp (brownianRestart_measurable hm hc
+      (stopping_time_measurable_nnreal hτ)))
+  have haAmbient : Measurable a := ham.mono hτ.measurableSpace_le le_rfl
+  have hY : Measurable Y :=
+    measurable_scaleDriverPath.comp (haAmbient.inv.prodMk hrp)
+  have hYlaw (A : Set Ω) (hA : MeasurableSet[hτ.measurableSpace] A) :
+      (P.restrict A).map Y = P A • P.map bp :=
+    source_restart_random_scale_driver_law B hB hm hc τ hτ (fun ω => (a ω)⁻¹)
+      ham.inv (fun ω => inv_pos.mpr (ha ω)) A hA
+  have hYlaw₀ : P.map Y = P.map bp := by
+    simpa only [Measure.restrict_univ, measure_univ, one_smul] using hYlaw univ MeasurableSet.univ
+  have hYw := canonical_witness_pullback hW Y hY hYlaw₀
+  have hbpw := canonical_witness_pullback hW bp hbp rfl
+  have hΦorig : ∀ᵐ ω ∂P, Φ (bp ω) = sourceTracePath γ (fun ω => (hw ω).1) ω := by
+    filter_upwards [hbpw] with ω hω
+    ext t
+    exact congrFun (hω.trace_unique (hw ω)) t
+  have hFb : Measurable[hτ.measurableSpace] Fb :=
+    @measurable_boundary_scale_family Ω hτ.measurableSpace Fb₀ hFb₀ a ham
+  refine ⟨Φ, Gc, Fc, Fb, hΦ, hFb, hY, hΦorig, hW, ?_, ?_, hYlaw, ?_⟩
+  · intro ω z hz
+    have hscaled : (scaleClosed (a ω) z : ℂ) ∈ upperHalfPlane := by
+      change 0 < ((a ω : ℂ) * z).im
+      simpa only [Complex.mul_im, Complex.ofReal_re, Complex.ofReal_im, zero_mul, add_zero]
+        using mul_pos (show 0 < (a ω : ℝ) from ha ω) hz
+    exact hFb₀eq ω (scaleClosed (a ω) z) hscaled
+  · intro ω
+    change Fb₀ ω ⟨(a ω : ℂ) * 0, _⟩ = γ ω (τ ω)
+    simpa only [mul_zero] using hFb₀zero ω
+  · filter_upwards [hYw, hrestart] with ω hω hωrestart
+    have hactual : IsCapacityTwoWitness
+        (normalizedRestartDriver (fun t => Real.sqrt κ * B t ω) (τ ω) (a ω))
+        (Φ (Y ω)) (Gc (Y ω)) (Fc (Y ω)) := by
+      rw [← normalizedRestartDriverPath_driver κ B hc τ a ω]
+      exact hω
+    have hup : IsCapacityTwoWitness (fun t => Real.sqrt κ * rp ω t)
+        (sourceScaleTrace (a ω) (Φ (Y ω)))
+        (sourceScaleChart (a ω) (Gc (Y ω)))
+        (sourceScaleChart (a ω) (Fc (Y ω))) := by
+      convert normalized_restart_witness (τ ω) (a ω) (ha ω) hactual using 1
+      funext t
+      change Real.sqrt κ * (B (τ ω + t) ω - B (τ ω) ω) =
+        Real.sqrt κ * B (τ ω + t) ω - Real.sqrt κ * B (τ ω) ω
+      ring
+    have heq : Φ (rp ω) = ScaleTraceLaw.scalePath (a ω) (Φ (Y ω)) := by
+      ext t
+      exact (congrFun (hup.trace_unique hωrestart.1) t).symm
+    refine ⟨hactual, ?_⟩
+    intro t
+    have hclosed : ClosedPathProperty (Φ (Y ω)) := fun t => hω.2.2.1 t
+    have hclock := congrArg (fun p : C(ℝ≥0, ℂ) => p t)
+      (boundary_scale_clock_identity (a ω) (ha ω) (Fb₀ ω) (Φ (Y ω)) hclosed)
+    change finiteBoundaryPath (Fb ω) (Φ (Y ω)) t =
+      finiteBoundaryPath (Fb₀ ω) (ScaleTraceLaw.scalePath (a ω) (Φ (Y ω))) ((a ω) ^ 2 * t)
+      at hclock
+    rw [← heq] at hclock
+    exact (hωrestart.2 ((a ω) ^ 2 * t)).trans hclock.symm
+
+end SLEExactGauge
+
+end
+
+end OAI
diff --git a/lean/OAI/Probability/SLE/Geometry/NormalizedCellAllTimes.lean b/lean/OAI/Probability/SLE/Geometry/NormalizedCellAllTimes.lean
new file mode 100644
index 0000000000000000000000000000000000000000..1db143ef68fae13453a409869747731cf3dc089a
--- /dev/null
+++ b/lean/OAI/Probability/SLE/Geometry/NormalizedCellAllTimes.lean
@@ -0,0 +1,68 @@
+import OAI.Probability.SLE.Geometry.NormalizedRawAllTimes
+import OAI.Probability.SLE.Geometry.RestartCellBounds
+
+namespace OAI
+
+/-! Canonical physical cell mass versus the same raw normalized disk mass,
+simultaneously at every finite horizon, including a future random one. -/
+noncomputable section
+open Set Filter _root_.MeasureTheory _root_.OAI.MeasureTheory ProbabilityTheory Metric
+open scoped Topology NNReal ENNReal
+
+namespace SLEExactGauge.Multipoint
+local instance normalizedCellAllTimesMeasurable : MeasurableSpace C(ℝ≥0,ℝ) := borel _
+local instance normalizedCellAllTimesBorel : BorelSpace C(ℝ≥0,ℝ) := ⟨rfl⟩
+
+lemma CanonicalMass.normalized_cell_bounds_all_times
+    {Ω : Type*} [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 ω)) (hκ : 0 < κ)
+    (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 ω)
+    (E : Set C(ℝ≥0,ℝ)) (hE : MeasurableSet E)
+    (hEf : ∀ᵐ p ∂P.map (sourceDriverPath B hc), p∈E)
+    (hEp : ∀ p∈E, PositiveMassPaths (fun t => R.process t p) (R.terminal p))
+    (hgrowth : PublishedDiskUnivalentGrowth)
+    (hpublished : PublishedTraceGeneration (P.map (sourceDriverPath B hc)) κ (fun t p => p t))
+    (τ : Ω → ℝ≥0)
+    (hτ : IsStoppingTime (Filtration.natural B (fun s =>
+      (hBm.comp (measurable_const.prodMk measurable_id) : Measurable (B s)).stronglyMeasurable))
+      (fun ω => (τ ω:WithTop ℝ≥0)))
+    (a : Ω → ℝ≥0) (haM : Measurable[hτ.measurableSpace] a) (ha : ∀ ω, 0 < a ω) :
+    ∀ᵐ ω ∂P, ∀ (T : ℝ≥0) (θ : ℝ) (hθ : θ ∈ Ioo (0:ℝ) Real.pi)
+      (z : ℂ) (_hz : z ∈ survivingDomain (γ ω) (τ ω))
+      (r : ℝ) (_hr : 0 < r)
+      (_hR : fullRadius (G ω) (τ ω) z=(2048*Real.pi)*r)
+      (_hpolar : G ω (τ ω) z=(Real.sqrt κ*B (τ ω) ω:ℝ)+
+        (a ω:ℂ)*Complex.exp (θ*Complex.I)),
+      let L := ENNReal.ofReal (compactWeightedMass (Target.diskMassWeight κ θ hθ)
+        (Target.diskSourceHalfPlane θ)
+        (R.process T (scaleDriverPath (a ω)⁻¹ (sourceRestartDriverPath B hc τ ω))))
+      ENNReal.ofReal (((128*Real.pi)*r)^dimension κ)*L ≤
+          C.process (τ ω+(a ω)^2*T) ω
+            (Subtype.val ⁻¹' closedBall z ((4096*Real.pi)*r)) ∧
+        ∀ A : Set ℂ, MeasurableSet A → A ⊆ closedBall z (2*r) →
+          A ⊆ survivingDomain (γ ω) (τ ω) →
+          C.process (τ ω+(a ω)^2*T) ω (Subtype.val ⁻¹' A) ≤
+            ENNReal.ofReal (((32768*Real.pi)*r)^dimension κ)*L := by
+  filter_upwards [C.paths,C.normalized_raw_restart_all_times hB hc F hw R he E hE hEf hEp
+    τ hτ a haM ha hκ hpublished] with ω hp hrst
+  intro T θ hθ z hz r hr hR hpolar
+  let := (C.radon (τ ω) ω).2
+  let := (R.radon T (scaleDriverPath (a ω)⁻¹ (sourceRestartDriverPath B hc τ ω))).2
+  exact (hw ω).restarted_cell_mass_bounds hgrowth κ hκ (τ ω) (τ ω+(a ω)^2*T)
+    (le_add_of_nonneg_right (by positivity)) (fun t => C.process t ω) hp.monotone
+    (fun A hA => hp.zero_on_surviving_subset (τ ω) A hA) θ hθ (a ω) (ha ω)
+    (R.process T (scaleDriverPath (a ω)⁻¹ (sourceRestartDriverPath B hc τ ω)))
+    (hrst T) z hz hpolar r hr hR
+
+end SLEExactGauge.Multipoint
+
+end
+
+end OAI
diff --git a/lean/OAI/Probability/SLE/Geometry/NormalizedCoefficientLimit.lean b/lean/OAI/Probability/SLE/Geometry/NormalizedCoefficientLimit.lean
new file mode 100644
index 0000000000000000000000000000000000000000..38e2351b6083ccc3dc27d7a47190e935a9f19cd1
--- /dev/null
+++ b/lean/OAI/Probability/SLE/Geometry/NormalizedCoefficientLimit.lean
@@ -0,0 +1,80 @@
+import OAI.Probability.SLE.Geometry.NormalizedPotentialIncrement
+import OAI.Probability.SLE.Angle.TargetLevelDensity
+
+namespace OAI
+
+/-! The inner mesh limit in the prescribed coefficient is the clipped
+moment of the actual canonical disk mass at the prescribed level. -/
+
+noncomputable section
+open Set Filter _root_.MeasureTheory _root_.OAI.MeasureTheory ProbabilityTheory
+open scoped Topology NNReal ENNReal
+
+namespace SLEExactGauge.Target
+
+lemma measurable_potentialDifference (κ θ : ℝ) (W : WienerLaw) [SFinite W] (n i : ℕ) :
+    Measurable (fun b => potentialDifference κ θ W b n i) := by
+  have hv := measurable_potential κ θ (compensatorMeshTime n i)
+  have hw := measurable_continuationMean W (compensatorMeshTime n i)
+    (fun b => potential κ θ b (compensatorMeshTime n (i+1)))
+    (measurable_potential κ θ (compensatorMeshTime n (i+1)))
+  have hn : ((i:ℝ)+1)*mesh n=(compensatorMeshTime n (i+1):ℝ) := by
+    simpa only [Nat.cast_add,Nat.cast_one] using mesh_eq_compensatorMeshTime n (i+1)
+  simp only [potentialDifference,mesh_eq_compensatorMeshTime,hn]
+  exact (hv.ennreal_toReal.sub hw.ennreal_toReal).ite
+    ((measurableSet_lt hv measurable_const).inter (measurableSet_lt hw measurable_const))
+    measurable_const
+
+lemma discreteMass_comp_measurable
+    {Ω : Type*} [MeasurableSpace Ω] (κ θ : ℝ) (W : WienerLaw) [SFinite W]
+    (b : Ω → Driver) (hb : Measurable b) (ℓ : ℝ)
+    (hT : Measurable (fun ω => levelTime κ θ (b ω) ℓ)) (n : ℕ) :
+    Measurable (fun ω => discreteMass κ θ W (b ω) ℓ n) := by
+  unfold discreteMass
+  apply Finset.measurable_sum
+  intro i _
+  exact ((measurable_potentialDifference κ θ W n i).comp hb).ite
+    (measurableSet_le measurable_const hT) measurable_const
+
+end SLEExactGauge.Target
+
+namespace SLEExactGauge.Multipoint.CanonicalMass
+
+variable {Ω : Type*} [mΩ : MeasurableSpace Ω] {P : Measure Ω}
+  [IsProbabilityMeasure P] {κ : ℝ}
+  {B : ℝ≥0 → Ω → ℝ} {hBm : Measurable (Function.uncurry B)}
+  {γ : Ω → ℝ≥0 → ℂ} {G : Ω → ℝ≥0 → ℂ → ℂ}
+  (C : CanonicalMass P κ B hBm γ G)
+
+theorem normalized_clipped_coefficient_limit
+    (hB : IsBrownianReal B P) (hκ : 0<κ) (hκ8 : κ<8)
+    (hc : ∀ ω, Continuous (fun t => B t ω)) (h0 : ∀ ω, B 0 ω=0)
+    (F : Ω → ℝ≥0 → ℂ → ℂ)
+    (hw : ∀ ω, IsCapacityTwoWitness (fun t => Real.sqrt κ*B t ω) (γ ω) (G ω) (F ω))
+    (W : Target.WienerLaw) (hW : Target.IsWiener W)
+    (θ : ℝ) (hθ : θ ∈ Ioo (0:ℝ) Real.pi) (ℓ : ℝ) (hℓ : 0 ≤ ℓ)
+    (u : ℝ) (hu : 0 ≤ u) (k : ℕ) :
+    Tendsto (fun n => ∫ ω, Target.levelDensity κ θ (Target.normalizedDriver κ B hc h0 ω) ℓ *
+      (Target.clip u (Target.discreteMass κ θ W (Target.normalizedDriver κ B hc h0 ω) ℓ n))^k ∂P)
+      atTop (𝓝 (∫ ω, Target.levelDensity κ θ (Target.normalizedDriver κ B hc h0 ω) ℓ *
+        (Target.clip u (massAtExtendedTime (fun t => C.normalizedDiskScalar θ hθ t ω)
+          (C.diskTerminalScalar θ hθ ω)
+          (Target.levelTime κ θ (Target.normalizedDriver κ B hc h0 ω) ℓ)))^k ∂P)) := by
+  let : IsProbabilityMeasure W := hW.isGaussianProcess.isProbabilityMeasure
+  apply weighted_clip_pow_integral_tendsto P _ _ _ _ _
+    (C.normalized_discreteMass_tendstoInMeasure hB hκ hκ8 hc h0 F hw W hW θ hθ ℓ hℓ)
+    u hu k
+  · intro n
+    exact (Target.discreteMass_comp_measurable κ θ W _
+      (Target.normalizedDriver_measurable κ B
+        (fun r => (hBm.comp (measurable_const.prodMk measurable_id) : Measurable (B r))) hc h0) ℓ
+      (normalized_levelTime_measurable (hBm := hBm) hκ hc h0 F hw θ ℓ hℓ) n).aestronglyMeasurable
+  · exact (Target.levelDensity_integrable_mean κ hκ hκ8 B hB
+      (Target.normalizedDriver κ B hc h0) γ G F (Eventually.of_forall hw)
+      (Eventually.of_forall (Target.normalizedDriver_matches κ hκ B hc h0)) θ hθ ℓ hℓ).1
+
+end SLEExactGauge.Multipoint.CanonicalMass
+
+end
+
+end OAI
diff --git a/lean/OAI/Probability/SLE/Geometry/NormalizedConformalBounds.lean b/lean/OAI/Probability/SLE/Geometry/NormalizedConformalBounds.lean
new file mode 100644
index 0000000000000000000000000000000000000000..2bd5c14ccac67d074b0280ce748cda0f0a628535
--- /dev/null
+++ b/lean/OAI/Probability/SLE/Geometry/NormalizedConformalBounds.lean
@@ -0,0 +1,142 @@
+import OAI.Probability.SLE.Geometry.PublishedConformalCompactness
+import OAI.Probability.SLE.Gauge.ConformalCompactSausage
+
+namespace OAI
+
+/-! Interior derivative bounds for the normalized inverse maps used to
+transport the dense experiment. The only input is the existing published
+compactness consequence for the schlicht class. -/
+
+noncomputable section
+open Set Filter Metric
+open scoped Topology
+
+namespace SLEExactGauge
+
+def normalizedInteriorCompact (s : ℝ) : Set ℂ :=
+  {z | ‖z‖ ≤ 2 ∧ s / 2 ≤ z.im}
+
+lemma normalizedInteriorCompact_isCompact (s : ℝ) :
+    IsCompact (normalizedInteriorCompact s) := by
+  have he : normalizedInteriorCompact s =
+      closedBall (0 : ℂ) 2 ∩ {z : ℂ | s / 2 ≤ z.im} := by
+    ext z
+    simp only [normalizedInteriorCompact, mem_ofPred_eq, mem_inter_iff,
+      mem_closedBall, dist_zero_right]
+  rw [he]
+  exact (isCompact_closedBall _ _).inter_right
+    (isClosed_le continuous_const Complex.continuous_im)
+
+lemma normalizedInteriorCompact_nonempty {s : ℝ} (hs : s ≤ 1) :
+    (normalizedInteriorCompact s).Nonempty := by
+  refine ⟨Complex.I, ?_⟩
+  change ‖Complex.I‖ ≤ 2 ∧ s / 2 ≤ Complex.I.im
+  simp only [Complex.norm_I, Complex.I_im]
+  constructor <;> linarith
+
+lemma normalizedInteriorCompact_subset_halfPlane {s : ℝ} (hs : 0 < s) :
+    normalizedInteriorCompact s ⊆ upperHalfPlane := by
+  intro z hz
+  change 0 < z.im
+  exact (half_pos hs).trans_le hz.2
+
+/-- The interior normalization fixes the value and the derivative norm
+at a unit semicircle waypoint. -/
+structure IsNormalizedHalfPlaneMap (s : ℝ) (F : ℂ → ℂ) (w : ℂ) : Prop where
+  differentiable : DifferentiableOn ℂ F upperHalfPlane
+  injective : InjOn F upperHalfPlane
+  waypoint_norm : ‖w‖ = 1
+  waypoint_height : s ≤ w.im
+  value : F w = 0
+  derivative_norm : ‖deriv F w‖ = 1
+
+theorem uniform_normalized_derivative_bounds
+    (hcompact : PublishedHalfPlaneUnivalentCompactness)
+    {s : ℝ} (hs : 0 < s) (hs1 : s ≤ 1) :
+    ∃ c C : ℝ, 0 < c ∧ 0 < C ∧
+      ∀ (F : ℂ → ℂ) (w : ℂ), IsNormalizedHalfPlaneMap s F w →
+        ∀ z ∈ normalizedInteriorCompact s,
+          c ≤ ‖deriv F z‖ ∧ ‖deriv F z‖ ≤ C := by
+  classical
+  by_contra hnone
+  push Not at hnone
+  have hfail (n : ℕ) : ∃ (F : ℂ → ℂ) (w : ℂ),
+      IsNormalizedHalfPlaneMap s F w ∧
+      ∃ z ∈ normalizedInteriorCompact s,
+        ‖deriv F z‖ < 1 / ((n : ℝ) + 1) ∨ (n : ℝ) + 1 < ‖deriv F z‖ := by
+    obtain ⟨F, w, hF, z, hz, hbad⟩ :=
+      hnone (1 / ((n : ℝ) + 1)) ((n : ℝ) + 1) (by positivity) (by positivity)
+    refine ⟨F, w, hF, z, hz, ?_⟩
+    by_cases hlo : ‖deriv F z‖ < 1 / ((n : ℝ) + 1)
+    · exact Or.inl hlo
+    · exact Or.inr (hbad (le_of_not_gt hlo))
+  choose F w hF z hz hbad using hfail
+  obtain ⟨φ, G, hφ, hG, _hi, hne, hconv⟩ := hcompact F w s 1 1 hs zero_lt_one
+    (fun n => (hF n).differentiable) (fun n => (hF n).injective)
+    (fun n => ⟨(hF n).waypoint_norm, (hF n).waypoint_height⟩)
+    (fun n => by rw [(hF n).value]; simp)
+    (fun n => by rw [(hF n).derivative_norm]; exact ⟨le_rfl, le_rfl⟩)
+  obtain ⟨c, C, hc, _hC, hb⟩ := eventually_derivative_norm_bounds_on_compact
+    (fun n => F (φ n)) G (fun n => (hF (φ n)).differentiable) hG hconv
+    (normalizedInteriorCompact s) (normalizedInteriorCompact_isCompact s)
+    (normalizedInteriorCompact_nonempty hs1) (normalizedInteriorCompact_subset_halfPlane hs)
+    (fun z hz => hne z (normalizedInteriorCompact_subset_halfPlane hs hz))
+  have hsmall : ∀ᶠ n in atTop, 1 / ((φ n : ℝ) + 1) < c :=
+    (tendsto_one_div_add_atTop_nhds_zero_nat.comp hφ.tendsto_atTop).eventually (gt_mem_nhds hc)
+  have hlarge : ∀ᶠ n in atTop, C < (φ n : ℝ) :=
+    (tendsto_natCast_atTop_atTop.comp hφ.tendsto_atTop).eventually_gt_atTop C
+  obtain ⟨n, hbn, hsn, hln⟩ := (hb.and (hsmall.and hlarge)).exists
+  have hbounds := hbn (z (φ n)) (hz (φ n))
+  rcases hbad (φ n) with hlo | hhi
+  · exact (not_lt_of_ge hbounds.1) (hlo.trans hsn)
+  · exact (not_lt_of_ge hbounds.2) (lt_trans (by linarith) hhi)
+
+/-- The same bounds with the normalization hypotheses exposed individually. -/
+theorem uniform_normalized_derivative_bounds_explicit
+    (hcompact : PublishedHalfPlaneUnivalentCompactness)
+    {s : ℝ} (hs : 0 < s) (hs1 : s ≤ 1) :
+    ∃ c C : ℝ, 0 < c ∧ 0 < C ∧
+      ∀ (F : ℂ → ℂ) (w : ℂ), DifferentiableOn ℂ F upperHalfPlane →
+        InjOn F upperHalfPlane → ‖w‖ = 1 → s ≤ w.im → F w = 0 →
+        ‖deriv F w‖ = 1 → ∀ z : ℂ, ‖z‖ ≤ 2 → s / 2 ≤ z.im →
+          c ≤ ‖deriv F z‖ ∧ ‖deriv F z‖ ≤ C := by
+  obtain ⟨c, C, hc, hC, hbound⟩ := uniform_normalized_derivative_bounds hcompact hs hs1
+  refine ⟨c, C, hc, hC, ?_⟩
+  intro F w hd hi hwn hwh hw0 hwd z hzn hzh
+  exact hbound F w ⟨hd, hi, hwn, hwh, hw0, hwd⟩ z ⟨hzn, hzh⟩
+
+/-- Centering and dividing by the waypoint derivative gives the relative
+bounds used for an arbitrary inverse chart. -/
+theorem uniform_waypoint_derivative_ratios
+    (hcompact : PublishedHalfPlaneUnivalentCompactness)
+    {s : ℝ} (hs : 0 < s) (hs1 : s ≤ 1) :
+    ∃ c C : ℝ, 0 < c ∧ 0 < C ∧
+      ∀ (F : ℂ → ℂ) (w : ℂ), DifferentiableOn ℂ F upperHalfPlane →
+        InjOn F upperHalfPlane → ‖w‖ = 1 → s ≤ w.im → deriv F w ≠ 0 →
+        ∀ z : ℂ, ‖z‖ ≤ 2 → s / 2 ≤ z.im →
+          c * ‖deriv F w‖ ≤ ‖deriv F z‖ ∧ ‖deriv F z‖ ≤ C * ‖deriv F w‖ := by
+  obtain ⟨c, C, hc, hC, hbound⟩ := uniform_normalized_derivative_bounds hcompact hs hs1
+  refine ⟨c, C, hc, hC, ?_⟩
+  intro F w hd hi hwn hwh hne z hzn hzh
+  have hscale : 0 < ‖deriv F w‖ := norm_pos_iff.mpr hne
+  have hden : (‖deriv F w‖ : ℂ) ≠ 0 := by exact_mod_cast hscale.ne'
+  let A : ℂ → ℂ := fun u => (F u - F w) / (‖deriv F w‖ : ℂ)
+  have hAder (u : ℂ) : deriv A u = deriv F u / (‖deriv F w‖ : ℂ) := by
+    simp only [A, deriv_div_const, deriv_sub_const]
+  have hAn : IsNormalizedHalfPlaneMap s A w := by
+    refine ⟨(hd.sub_const _).div_const _, ?_, hwn, hwh, ?_, ?_⟩
+    · intro u hu v hv he
+      apply hi hu hv
+      have he' : F u - F w = F v - F w := (div_left_inj' hden).mp he
+      exact sub_left_injective he'
+    · simp only [A, sub_self, zero_div]
+    · rw [hAder, norm_div, Complex.norm_of_nonneg (norm_nonneg _), div_self hscale.ne']
+  have hh := hbound A w hAn z ⟨hzn, hzh⟩
+  rw [hAder, norm_div, Complex.norm_of_nonneg (norm_nonneg _)] at hh
+  exact ⟨(le_div_iff₀ hscale).mp hh.1, (div_le_iff₀ hscale).mp hh.2⟩
+
+end SLEExactGauge
+
+end
+
+end OAI
diff --git a/lean/OAI/Probability/SLE/Geometry/NormalizedDiskAngle.lean b/lean/OAI/Probability/SLE/Geometry/NormalizedDiskAngle.lean
new file mode 100644
index 0000000000000000000000000000000000000000..e8ea032fde4a04a81901a13465746a415fee7cbd
--- /dev/null
+++ b/lean/OAI/Probability/SLE/Geometry/NormalizedDiskAngle.lean
@@ -0,0 +1,131 @@
+import OAI.Probability.SLE.Angle.ActualAngleWarmup
+import OAI.Probability.SLE.Geometry.ExtendedDiskAngle
+import OAI.Probability.SLE.Geometry.NormalizedDiskDensity
+
+namespace OAI
+
+/-! Normalization preserves the full stopped argument, which is the state
+variable needed by the finite-centered transition kernel. -/
+noncomputable section
+open Set Filter _root_.MeasureTheory _root_.OAI.MeasureTheory ProbabilityTheory
+open scoped Topology NNReal ENNReal
+
+namespace SLEExactGauge
+
+lemma IsCapacityTwoWitness.normalized_restart_stopped_arg
+    {U : ℝ≥0 → ℝ} {γ β : ℝ≥0 → ℂ} {G F G' F' : ℝ≥0 → ℂ → ℂ}
+    (hw : IsCapacityTwoWitness U γ G F) (hU : Continuous U) (T a : ℝ≥0) (ha : 0 < a)
+    (hb : IsCapacityTwoWitness (normalizedRestartDriver U T a) β G' F')
+    (w : ℂ) (u v : ℝ)
+    (hbase : fullRadius G T (F T ((a : ℂ) * w + (U T : ℂ))) =
+      (2 * (F T ((a : ℂ) * w + (U T : ℂ))).im) * Real.exp (-u))
+    (hfinite : radiusLevelTime β G' w v < ∞) :
+    radiusLevelTime γ G (F T ((a : ℂ) * w + (U T : ℂ))) (u + v) < ∞ ∧
+    Complex.arg (G (radiusLevelTime γ G
+        (F T ((a : ℂ) * w + (U T : ℂ))) (u + v)).toNNReal
+        (F T ((a : ℂ) * w + (U T : ℂ))) -
+      (U (radiusLevelTime γ G (F T ((a : ℂ) * w + (U T : ℂ)))
+        (u + v)).toNNReal : ℂ)) =
+    Complex.arg (G' (radiusLevelTime β G' w v).toNNReal w -
+      (normalizedRestartDriver U T a (radiusLevelTime β G' w v).toNNReal : ℂ)) := by
+  have hV : Continuous (normalizedRestartDriver U T a) := by
+    unfold normalizedRestartDriver
+    fun_prop
+  obtain ⟨t, ht, hR⟩ := exists_live_level_of_radiusLevelTime_lt_top β G' w v hfinite
+  have hs := radiusLevelTime_eq_of_live_level hV hb w v t ht hR
+  have hp := (hw.normalized_restart_level_of_live_source hU T a ha hb w u v hbase t ht hR).2
+  refine ⟨by rw [hp]; exact ENNReal.coe_lt_top, ?_⟩
+  rw [hp, hs, ENNReal.toNNReal_coe, ENNReal.toNNReal_coe]
+  have hbup := normalized_restart_witness T a ha hb
+  have haC : (a : ℂ) ≠ 0 := by exact_mod_cast ha.ne'
+  have htu : (a : ℂ) * w ∈ survivingDomain (sourceScaleTrace a β) (a ^ 2 * t) := by
+    rw [source_scale_domain_iff a _ ha β, source_scale_time_mul_sq a t ha,
+      mul_div_cancel_left₀ w haC]
+    exact ht
+  have hc := hw.restart_centered_value T hbup (a ^ 2 * t) ((a : ℂ) * w) htu
+  rw [sourceScaleChart, source_scale_time_mul_sq a t ha,
+    mul_div_cancel_left₀ w haC] at hc
+  have hscale : (a : ℂ) * G' t w - ((U (T + a ^ 2 * t) - U T : ℝ) : ℂ) =
+      (a : ℂ) * (G' t w - (normalizedRestartDriver U T a t : ℂ)) := by
+    rw [normalizedRestartDriver, Complex.ofReal_div]
+    field_simp
+  rw [hc, hscale]
+  exact Complex.arg_real_mul _ (show (0:ℝ)<(a:ℝ) from ha)
+
+def canonicalStoppedAngle (κ : ℝ) (q : ℝ × (ℂ × C(ℝ≥0,ℝ))) : ℝ :=
+  if canonicalRadiusLevel κ q < ∞ then (canonicalStoppedCenter κ q).arg else 0
+
+lemma canonicalStoppedAngle_measurable (κ : ℝ) : Measurable (canonicalStoppedAngle κ) :=
+  Measurable.ite (measurableSet_lt (canonicalRadiusLevel_measurable κ) measurable_const)
+    (canonicalStoppedCenter_measurable κ).carg measurable_const
+
+lemma canonicalStoppedAngle_eq (κ : ℝ) (p : C(ℝ≥0,ℝ))
+    {γ : ℝ≥0 → ℂ} {G F : ℝ≥0 → ℂ → ℂ}
+    (hw : IsCapacityTwoWitness (fun t => Real.sqrt κ*p t) γ G F)
+    (u : ℝ) (hu : 0 ≤ u) (z : ℂ) (hfinite : radiusLevelTime γ G z u < ∞) :
+    canonicalStoppedAngle κ (u,z,p)=
+      (G (radiusLevelTime γ G z u).toNNReal z-
+        ((Real.sqrt κ*p (radiusLevelTime γ G z u).toNNReal:ℝ):ℂ)).arg := by
+  rw [canonicalStoppedAngle,canonicalRadiusLevel_eq κ p hw u hu z,ite_eq_left hfinite,
+    canonicalStoppedCenter_eq κ p hw u hu z hfinite]
+
+
+lemma extendedMarkedAngle_at_finite_radius {Ω : Type*}
+    (κ : ℝ) (B : ℝ≥0 → Ω → ℝ) (hc : ∀ ω, Continuous (fun t => B t ω))
+    (γ : Ω → ℝ≥0 → ℂ) (G F : Ω → ℝ≥0 → ℂ → ℂ)
+    (hw : ∀ ω, IsCapacityTwoWitness (fun t => Real.sqrt κ*B t ω) (γ ω) (G ω) (F ω))
+    (z : ℂ) (u : ℝ) (ω : Ω) (hf : radiusLevelTime (γ ω) (G ω) z u<∞) :
+    extendedMarkedAngle κ B γ G (fun ω => radiusLevelTime (γ ω) (G ω) z u) z ω =
+      (G ω (radiusLevelTime (γ ω) (G ω) z u).toNNReal z-
+        ((Real.sqrt κ*B (radiusLevelTime (γ ω) (G ω) z u).toNNReal ω:ℝ):ℂ)).arg := by
+  obtain ⟨t,ht,hR⟩ := exists_live_level_of_radiusLevelTime_lt_top (γ ω) (G ω) z u hf
+  have he := radiusLevelTime_eq_of_live_level ((hc ω).const_mul _) (hw ω) z u t ht hR
+  have htime : WithTop.untopD 0 (radiusLevelTime (γ ω) (G ω) z u)=t := by
+    change (radiusLevelTime (γ ω) (G ω) z u).toNNReal=t
+    rw [he,ENNReal.toNNReal_coe]
+  let σ : Ω → WithTop ℝ≥0 := fun ω => radiusLevelTime (γ ω) (G ω) z u
+  change extendedMarkedAngle κ B γ G σ z ω = _
+  dsimp only [extendedMarkedAngle]
+  rw [ite_eq_right (show σ ω≠⊤ from ne_of_lt hf),
+    stoppedMarkedCenter_time_congr κ B γ G _ (fun _ => t) z ω htime,
+    stoppedMarkedCenter_eq κ B γ G (fun _ => t) z ω ht,he,ENNReal.toNNReal_coe]
+
+lemma IsCapacityTwoWitness.normalized_disk_stopped_arg
+    {U : ℝ≥0 → ℝ} {γ : ℝ≥0 → ℂ} {G F : ℝ≥0 → ℂ → ℂ}
+    (hw : IsCapacityTwoWitness U γ G F) (hU : Continuous U)
+    (κ : ℝ) (T a : ℝ≥0) (ha : 0 < a) (p : C(ℝ≥0,ℝ))
+    {β : ℝ≥0 → ℂ} {G' F' : ℝ≥0 → ℂ → ℂ}
+    (hb : IsCapacityTwoWitness (fun t => Real.sqrt κ*p t) β G' F')
+    (hdriver : (fun t => Real.sqrt κ*p t)=normalizedRestartDriver U T a)
+    (θ : ℝ) (hθ : θ ∈ Ioo (0:ℝ) Real.pi) (z : ℂ)
+    (hz : z ∈ survivingDomain γ T)
+    (hpolar : G T z=(U T:ℂ)+(a:ℂ)*Complex.exp (θ*Complex.I))
+    (u v : ℝ) (hu : 0 ≤ u) (hv : 0 < v)
+    (hbase : fullRadius G T z=(2*z.im)*Real.exp (-u))
+    (hfinite : radiusLevelTime γ G z (u+v)<∞) :
+    (G (radiusLevelTime γ G z (u+v)).toNNReal z-
+      (U (radiusLevelTime γ G z (u+v)).toNNReal:ℂ)).arg =
+        canonicalStoppedAngle κ (v,Target.diskMapInv θ 0,p) := by
+  have hb' : IsCapacityTwoWitness (normalizedRestartDriver U T a) β G' F' := by
+    rwa [hdriver] at hb
+  have hF : F T ((a:ℂ)*Target.diskMapInv θ 0+(U T:ℂ))=z := by
+    rw [Target.diskMapInv_zero,add_comm,← hpolar]
+    exact hw.2.2.2.2.2.2.2.1 T z hz
+  have hbase' : fullRadius G T (F T ((a:ℂ)*Target.diskMapInv θ 0+(U T:ℂ)))=
+      (2*(F T ((a:ℂ)*Target.diskMapInv θ 0+(U T:ℂ))).im)*Real.exp (-u) := by
+    simpa only [hF] using hbase
+  have hf := (hw.normalized_restart_radius_finite_iff hU T a ha hb'
+    (Target.diskMapInv θ 0) (Target.diskMapInv_maps hθ (by simp)) u v hu hv hbase').mp
+      (by simpa only [hF] using hfinite)
+  have he := (hw.normalized_restart_stopped_arg hU T a ha hb'
+    (Target.diskMapInv θ 0) u v hbase' hf).2
+  rw [hF] at he
+  rw [canonicalStoppedAngle_eq κ p hb v hv.le _ hf,
+    congrFun hdriver (radiusLevelTime β G' (Target.diskMapInv θ 0) v).toNNReal]
+  exact he
+
+end SLEExactGauge
+
+end
+
+end OAI
diff --git a/lean/OAI/Probability/SLE/Geometry/NormalizedDiskDensity.lean b/lean/OAI/Probability/SLE/Geometry/NormalizedDiskDensity.lean
new file mode 100644
index 0000000000000000000000000000000000000000..f4f3d9c532bb8f0f4e625183708dbb289e101190
--- /dev/null
+++ b/lean/OAI/Probability/SLE/Geometry/NormalizedDiskDensity.lean
@@ -0,0 +1,91 @@
+import OAI.Probability.SLE.Geometry.NormalizedRestartDensity
+import OAI.Probability.SLE.Geometry.NormalizedCanonicalRestart
+import OAI.Probability.SLE.Loewner.RawDiskRadiusLaw
+
+namespace OAI
+
+/-! Exact finite centered density in the disk coordinates used by the
+prescribed tests. This includes paths which never reach the later level. -/
+noncomputable section
+open Set Filter _root_.MeasureTheory _root_.OAI.MeasureTheory ProbabilityTheory
+open scoped Topology NNReal ENNReal
+
+namespace SLEExactGauge
+local instance diskDensityMeasurable : MeasurableSpace C(ℝ≥0,ℝ) := borel _
+local instance diskDensityBorel : BorelSpace C(ℝ≥0,ℝ) := ⟨rfl⟩
+
+lemma IsCapacityTwoWitness.normalized_disk_density
+    {U : ℝ≥0 → ℝ} {γ : ℝ≥0 → ℂ} {G F : ℝ≥0 → ℂ → ℂ}
+    (hw : IsCapacityTwoWitness U γ G F) (hU : Continuous U)
+    (κ : ℝ) (T a : ℝ≥0) (ha : 0 < a) (p : C(ℝ≥0,ℝ))
+    {β : ℝ≥0 → ℂ} {G' F' : ℝ≥0 → ℂ → ℂ}
+    (hb : IsCapacityTwoWitness (fun t => Real.sqrt κ*p t) β G' F')
+    (hdriver : (fun t => Real.sqrt κ*p t)=normalizedRestartDriver U T a)
+    (θ : ℝ) (hθ : θ ∈ Ioo (0:ℝ) Real.pi) (z : ℂ)
+    (hz : z ∈ survivingDomain γ T) (hzH : z ∈ upperHalfPlane)
+    (hpolar : G T z=(U T:ℂ)+(a:ℂ)*Complex.exp (θ*Complex.I))
+    (u v : ℝ) (hu : 0 ≤ u) (hv : 0 < v)
+    (hbase : fullRadius G T z=(2*z.im)*Real.exp (-u)) :
+    ENNReal.ofReal (stoppedGreen κ U γ G z (u+v)/initialGreen κ z) =
+      ENNReal.ofReal (greenDensity κ U γ G T z/initialGreen κ z)*
+        canonicalFiniteDensity κ (v,Target.diskMapInv θ 0,p) := by
+  have hb' : IsCapacityTwoWitness (normalizedRestartDriver U T a) β G' F' := by
+    rwa [hdriver] at hb
+  have hF : F T ((a:ℂ)*Target.diskMapInv θ 0+(U T:ℂ))=z := by
+    rw [Target.diskMapInv_zero,add_comm,← hpolar]
+    exact hw.2.2.2.2.2.2.2.1 T z hz
+  have heq := hw.normalized_restart_stopped_green_eq hU T a ha hb' κ
+    (Target.diskMapInv θ 0) (Target.diskMapInv_maps hθ (by simp))
+    u v hu hv (by simpa only [hF] using hbase)
+  rw [hF] at heq
+  rw [canonicalFiniteDensity_eq κ p hb v hv.le,hdriver,
+    ← ENNReal.ofReal_mul (div_nonneg (greenDensity_nonneg hw κ T z)
+      (initialGreen_pos κ z hzH).le),← heq]
+  congr 1
+  ring
+
+theorem normalized_restart_disk_density
+    {Ω : Type*} [MeasurableSpace Ω] {P : Measure Ω} [IsProbabilityMeasure P]
+    {κ : ℝ} {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 ω))
+    (hpublished : PublishedTraceGeneration (P.map (sourceDriverPath B hc)) κ (fun t p => p t))
+    (τ : Ω → ℝ≥0)
+    (hτ : IsStoppingTime (Filtration.natural B (fun t => (hm t).stronglyMeasurable))
+      (fun ω => (τ ω:WithTop ℝ≥0)))
+    (a : Ω → ℝ≥0) (haM : Measurable[hτ.measurableSpace] a) (ha : ∀ ω, 0 < a ω) :
+    ∀ᵐ ω ∂P, ∀ (θ : ℝ) (_hθ : θ ∈ Ioo (0:ℝ) Real.pi) (z : ℂ)
+      (_hz : z ∈ survivingDomain (γ ω) (τ ω)) (_hzH : z ∈ upperHalfPlane)
+      (_hpolar : G ω (τ ω) z=(Real.sqrt κ*B (τ ω) ω:ℝ)+
+        (a ω:ℂ)*Complex.exp (θ*Complex.I))
+      (u v : ℝ) (_hu : 0 ≤ u) (_hv : 0 < v)
+      (_hbase : fullRadius (G ω) (τ ω) z=(2*z.im)*Real.exp (-u)),
+      ENNReal.ofReal (stoppedGreen κ (fun t => Real.sqrt κ*B t ω) (γ ω) (G ω) z
+        (u+v)/initialGreen κ z) =
+      ENNReal.ofReal (greenDensity κ (fun t => Real.sqrt κ*B t ω) (γ ω) (G ω)
+        (τ ω) z/initialGreen κ z)*canonicalFiniteDensity κ
+          (v,Target.diskMapInv θ 0,normalizedRestartDriverPath B hc τ a ω) := by
+  obtain ⟨Φ,Gc,Fc,_hΦ,hW⟩ := exists_measurable_canonical_witness _ κ hpublished
+  let Y := normalizedRestartDriverPath B hc τ a
+  have hY : Measurable Y := measurable_scaleDriverPath.comp
+    ((haM.mono hτ.measurableSpace_le le_rfl).inv.prodMk
+      (sourceRestartDriverPath_measurable B hm hc τ hτ))
+  have hYlaw : P.map Y=P.map (sourceDriverPath B hc) := by
+    change P.map (fun ω => scaleDriverPath (a ω)⁻¹
+      (sourceRestartDriverPath B hc τ ω))=P.map (sourceDriverPath B hc)
+    simpa only [Measure.restrict_univ,measure_univ,one_smul] using
+      source_restart_random_scale_driver_law B hB hm hc τ hτ
+        (fun ω => (a ω)⁻¹) haM.inv (fun ω => inv_pos.mpr (ha ω))
+        univ MeasurableSet.univ
+  filter_upwards [canonical_witness_pullback hW Y hY hYlaw] with ω hb
+  intro θ hθ z hz hzH hpolar u v hu hv hbase
+  exact (hw ω).normalized_disk_density ((hc ω).const_mul _) κ (τ ω) (a ω) (ha ω)
+    (Y ω) hb (normalizedRestartDriverPath_driver κ B hc τ a ω)
+    θ hθ z hz hzH hpolar u v hu hv hbase
+
+end SLEExactGauge
+
+end
+
+end OAI
diff --git a/lean/OAI/Probability/SLE/Geometry/NormalizedLoewnerCharts.lean b/lean/OAI/Probability/SLE/Geometry/NormalizedLoewnerCharts.lean
new file mode 100644
index 0000000000000000000000000000000000000000..c6f55327713681bec33aa45881aa950e1d679ac6
--- /dev/null
+++ b/lean/OAI/Probability/SLE/Geometry/NormalizedLoewnerCharts.lean
@@ -0,0 +1,85 @@
+import OAI.Probability.SLE.LoewnerCharts
+
+namespace OAI
+
+/-! The actual inverse/forward capacity charts after translating the driver
+to zero and applying the positive waypoint dilation. These supply all
+analytic chart hypotheses in the joint guide compactness argument. -/
+
+noncomputable section
+open Set
+open scoped Topology NNReal
+
+namespace SLEExactGauge
+
+def normalizedForward (G : ℂ → ℂ) (u c : ℝ) (z : ℂ) : ℂ :=
+  (G z - (u : ℂ)) / (c : ℂ)
+
+def normalizedInverse (F : ℂ → ℂ) (u c : ℝ) (z : ℂ) : ℂ :=
+  F ((u : ℂ) + (c : ℂ) * z)
+
+theorem normalized_capacity_charts
+    {U : ℝ≥0 → ℝ} {γ : ℝ≥0 → ℂ} {G F : ℝ≥0 → ℂ → ℂ}
+    (hw : IsCapacityTwoWitness U γ G F) (T : ℝ≥0) (c : ℝ) (hc : 0 < c) :
+    let g := normalizedForward (G T) (U T) c
+    let f := normalizedInverse (F T) (U T) c
+    let D := survivingDomain γ T
+    DifferentiableOn ℂ f upperHalfPlane ∧ InjOn f upperHalfPlane ∧
+      DifferentiableOn ℂ g D ∧ InjOn g D ∧
+      MapsTo f upperHalfPlane D ∧ MapsTo g D upperHalfPlane ∧
+      (∀ z ∈ upperHalfPlane, g (f z) = z) ∧ (∀ z ∈ D, f (g z) = z) := by
+  dsimp only
+  let A : ℂ → ℂ := fun z => (U T : ℂ) + (c : ℂ) * z
+  have hAH : MapsTo A upperHalfPlane upperHalfPlane := by
+    intro z hz
+    change 0 < (A z).im
+    simpa only [A, Complex.add_im, Complex.ofReal_im, Complex.mul_im, Complex.ofReal_re,
+      zero_mul, add_zero, zero_add] using mul_pos hc hz
+  have hAD : Differentiable ℂ A := by dsimp [A]; fun_prop
+  have hf : DifferentiableOn ℂ (normalizedInverse (F T) (U T) c) upperHalfPlane :=
+    (hw.2.2.2.2.1 T).comp hAD.differentiableOn hAH
+  have hg : DifferentiableOn ℂ (normalizedForward (G T) (U T) c) (survivingDomain γ T) :=
+    ((hw.2.2.2.1 T).sub_const _).div_const _
+  have hfD : MapsTo (normalizedInverse (F T) (U T) c) upperHalfPlane (survivingDomain γ T) :=
+    (hw.2.2.2.2.2.2.1 T).comp hAH
+  have hgH : MapsTo (normalizedForward (G T) (U T) c) (survivingDomain γ T) upperHalfPlane := by
+    intro z hz
+    change 0 < ((G T z - (U T : ℂ)) / (c : ℂ)).im
+    rw [Complex.div_ofReal_im, Complex.sub_im, Complex.ofReal_im, sub_zero]
+    exact div_pos (hw.2.2.2.2.2.1 T hz) hc
+  have hcC : (c : ℂ) ≠ 0 := Complex.ofReal_ne_zero.mpr hc.ne'
+  have hgf : ∀ z ∈ upperHalfPlane,
+      normalizedForward (G T) (U T) c (normalizedInverse (F T) (U T) c z) = z := by
+    intro z hz
+    dsimp only [normalizedForward, normalizedInverse]
+    rw [hw.2.2.2.2.2.2.2.2.1 T (A z) (hAH hz)]
+    dsimp only [A]
+    field_simp
+    ring
+  have hfg : ∀ z ∈ survivingDomain γ T,
+      normalizedInverse (F T) (U T) c (normalizedForward (G T) (U T) c z) = z := by
+    intro z hz
+    dsimp only [normalizedInverse, normalizedForward]
+    have he : (U T : ℂ) + (c : ℂ) * ((G T z - (U T : ℂ)) / (c : ℂ)) = G T z := by
+      field_simp
+      ring
+    rw [he, hw.2.2.2.2.2.2.2.1 T z hz]
+  have hfi : InjOn (normalizedInverse (F T) (U T) c) upperHalfPlane := by
+    intro z hz w hw he
+    calc
+      z = normalizedForward (G T) (U T) c (normalizedInverse (F T) (U T) c z) := (hgf z hz).symm
+      _ = normalizedForward (G T) (U T) c (normalizedInverse (F T) (U T) c w) := congrArg _ he
+      _ = w := hgf w hw
+  have hgi : InjOn (normalizedForward (G T) (U T) c) (survivingDomain γ T) := by
+    intro z hz w hw he
+    calc
+      z = normalizedInverse (F T) (U T) c (normalizedForward (G T) (U T) c z) := (hfg z hz).symm
+      _ = normalizedInverse (F T) (U T) c (normalizedForward (G T) (U T) c w) := congrArg _ he
+      _ = w := hfg w hw
+  exact ⟨hf, hfi, hg, hgi, hfD, hgH, hgf, hfg⟩
+
+end SLEExactGauge
+
+end
+
+end OAI
diff --git a/lean/OAI/Probability/SLE/Geometry/NormalizedMarkedState.lean b/lean/OAI/Probability/SLE/Geometry/NormalizedMarkedState.lean
new file mode 100644
index 0000000000000000000000000000000000000000..96daa35c6f57bcb517d20533b7b31a1042bfece4
--- /dev/null
+++ b/lean/OAI/Probability/SLE/Geometry/NormalizedMarkedState.lean
@@ -0,0 +1,113 @@
+import OAI.Probability.SLE.Geometry.NormalizedLoewnerCharts
+import OAI.Probability.SLE.DiskHalfPlane
+
+namespace OAI
+
+/-! The actual marked point in a unit-modulus restarted chart. Its physical
+scale is exactly the original conformal radius, including the inverse-map
+derivative factor used in the dense experiment. -/
+
+noncomputable section
+open Set Filter
+open scoped Topology NNReal
+
+namespace SLEExactGauge
+
+def unitMarkedState (q : ℂ) : ℂ := q / (‖q‖ : ℂ)
+
+lemma unitMarkedState_norm {q : ℂ} (hq : q ≠ 0) : ‖unitMarkedState q‖ = 1 := by
+  rw [unitMarkedState, norm_div, Complex.norm_real, Real.norm_eq_abs,
+    abs_of_nonneg (norm_nonneg _), div_self (norm_pos_iff.mpr hq).ne']
+
+lemma unitMarkedState_im (q : ℂ) : (unitMarkedState q).im = Real.sin (Complex.arg q) := by
+  rw [unitMarkedState, Complex.div_ofReal_im, Complex.sin_arg]
+
+lemma IsCapacityTwoWitness.inverse_derivative_identity
+    {U : ℝ≥0 → ℝ} {γ : ℝ≥0 → ℂ} {G F : ℝ≥0 → ℂ → ℂ}
+    (hw : IsCapacityTwoWitness U γ G F) (t : ℝ≥0) (z : ℂ)
+    (hz : z ∈ survivingDomain γ t) :
+    deriv (F t) (G t z) * deriv (G t) z = 1 := by
+  have hFd := ((hw.2.2.2.2.1 t).differentiableAt
+    (isOpen_upperHalfPlane.mem_nhds (hw.2.2.2.2.2.1 t hz))).hasDerivAt
+  have hGd := ((hw.2.2.2.1 t).differentiableAt
+    ((isOpen_survivingDomain hw.1 t).mem_nhds hz)).hasDerivAt
+  have he : (fun w => F t (G t w)) =ᶠ[𝓝 z] (fun w => w) := by
+    filter_upwards [(isOpen_survivingDomain hw.1 t).mem_nhds hz] with w hwl
+    exact hw.2.2.2.2.2.2.2.1 t w hwl
+  exact ((hFd.comp z hGd).congr_of_eventuallyEq he.symm).unique (hasDerivAt_id z)
+
+lemma normalizedInverse_derivative
+    (F : ℂ → ℂ) (u a : ℝ) (w : ℂ)
+    (hF : DifferentiableAt ℂ F ((u : ℂ) + (a : ℂ) * w)) :
+    deriv (normalizedInverse F u a) w = deriv F ((u : ℂ) + (a : ℂ) * w) * (a : ℂ) := by
+  have hA := (hasDerivAt_const w (u : ℂ)).add ((hasDerivAt_id w).const_mul (a : ℂ))
+  change deriv (fun x => F ((u : ℂ) + (a : ℂ) * x)) w = _
+  simpa only [Function.comp_def, Pi.add_apply, Pi.mul_apply, id_eq, zero_add, mul_one] using
+    (hF.hasDerivAt.comp w hA).deriv
+
+/-- All hypotheses of the uniform conformal dense experiment are supplied
+by the actual live marked state and its normalized inverse chart. -/
+theorem IsCapacityTwoWitness.normalized_marked_state
+    {U : ℝ≥0 → ℝ} {γ : ℝ≥0 → ℂ} {G F : ℝ≥0 → ℂ → ℂ}
+    (hw : IsCapacityTwoWitness U γ G F) (hU : Continuous U)
+    (T : ℝ≥0) (z : ℂ) (hz : z ∈ survivingDomain γ T) :
+    let q := G T z - (U T : ℂ)
+    let w := unitMarkedState q
+    let f := normalizedInverse (F T) (U T) ‖q‖
+    ‖w‖ = 1 ∧ 0 < w.im ∧ f w = z ∧
+      DifferentiableOn ℂ f upperHalfPlane ∧ InjOn f upperHalfPlane ∧
+      deriv f w ≠ 0 ∧ 2 * w.im * ‖deriv f w‖ = fullRadius G T z := by
+  dsimp only
+  let q := G T z - (U T : ℂ)
+  let w := unitMarkedState q
+  let f := normalizedInverse (F T) (U T) ‖q‖
+  have hq : q ≠ 0 := hw.centered_ne_zero T z hz
+  have ha : 0 < ‖q‖ := norm_pos_iff.mpr hq
+  have hqim : 0 < q.im := by
+    simpa only [q, Complex.sub_im, Complex.ofReal_im, sub_zero] using hw.imag_positive T z hz
+  have hwim : 0 < w.im := by
+    dsimp only [w, unitMarkedState]
+    rw [Complex.div_ofReal_im]
+    exact div_pos hqim ha
+  have heval : (U T : ℂ) + (‖q‖ : ℂ) * w = G T z := by
+    dsimp only [w, unitMarkedState]
+    rw [mul_div_cancel₀ _ (Complex.ofReal_ne_zero.mpr ha.ne')]
+    dsimp only [q]
+    ring
+  have hcharts := normalized_capacity_charts hw T ‖q‖ ha
+  have hFdiff : DifferentiableAt ℂ (F T) ((U T : ℂ) + (‖q‖ : ℂ) * w) := by
+    rw [heval]
+    exact (hw.2.2.2.2.1 T).differentiableAt
+      (isOpen_upperHalfPlane.mem_nhds (hw.imag_positive T z hz))
+  have hdf : deriv f w = deriv (F T) (G T z) * (‖q‖ : ℂ) := by
+    dsimp only [f]
+    rw [normalizedInverse_derivative _ _ _ _ hFdiff, heval]
+  have hidentity := hw.inverse_derivative_identity T z hz
+  have hFne : deriv (F T) (G T z) ≠ 0 := by
+    intro he
+    rw [he, zero_mul] at hidentity
+    exact zero_ne_one hidentity
+  have hnorm : ‖deriv f w‖ = ‖deriv (F T) (G T z)‖ * ‖q‖ := by
+    rw [hdf, norm_mul, Complex.norm_real, Real.norm_eq_abs, abs_of_nonneg (norm_nonneg _)]
+  have hnidentity : ‖deriv (F T) (G T z)‖ * ‖deriv (G T) z‖ = 1 := by
+    simpa only [norm_mul, norm_one] using congrArg norm hidentity
+  have hGpos := hw.derivative_norm_positive hU T z hz
+  refine ⟨unitMarkedState_norm hq, hwim, ?_, hcharts.1, hcharts.2.1,
+    by rw [hdf]; exact mul_ne_zero hFne (Complex.ofReal_ne_zero.mpr ha.ne'), ?_⟩
+  · change F T ((U T : ℂ) + (‖q‖ : ℂ) * w) = z
+    rw [heval, hw.2.2.2.2.2.2.2.1 T z hz]
+  · rw [fullRadius, hnorm]
+    change 2 * (q / (‖q‖ : ℂ)).im *
+      (‖deriv (F T) (G T z)‖ * ‖q‖) = 2 * (G T z).im / ‖deriv (G T) z‖
+    rw [Complex.div_ofReal_im]
+    have hqi : q.im = (G T z).im := by simp only [q, Complex.sub_im, Complex.ofReal_im, sub_zero]
+    rw [hqi]
+    apply (eq_div_iff hGpos.ne').mpr
+    field_simp
+    nlinarith [hnidentity]
+
+end SLEExactGauge
+
+end
+
+end OAI
diff --git a/lean/OAI/Probability/SLE/Geometry/NormalizedPotentialIncrement.lean b/lean/OAI/Probability/SLE/Geometry/NormalizedPotentialIncrement.lean
new file mode 100644
index 0000000000000000000000000000000000000000..a7d3e6a787fab66650f9b5a4ee3042e175bb675f
--- /dev/null
+++ b/lean/OAI/Probability/SLE/Geometry/NormalizedPotentialIncrement.lean
@@ -0,0 +1,86 @@
+import OAI.Probability.SLE.Loewner.TargetContinuationPullback
+import OAI.Probability.SLE.Mass.NormalizedDiskCompensator
+import OAI.Probability.SLE.Angle.TargetPotentialMeasurability
+import OAI.Probability.SLE.Mass.TargetDiscreteMassRecovery
+
+namespace OAI
+
+/-! The exact prescribed potential increments are the predictable
+increments of the actual canonical disk mass on the normalized clock. -/
+
+noncomputable section
+open Set Filter _root_.MeasureTheory _root_.OAI.MeasureTheory ProbabilityTheory
+open scoped Topology NNReal ENNReal
+
+namespace SLEExactGauge.Multipoint.CanonicalMass
+
+variable {Ω : Type*} [mΩ : MeasurableSpace Ω] {P : Measure Ω}
+  [IsProbabilityMeasure P] {κ : ℝ}
+  {B : ℝ≥0 → Ω → ℝ} {hBm : Measurable (Function.uncurry B)}
+  {γ : Ω → ℝ≥0 → ℂ} {G : Ω → ℝ≥0 → ℂ → ℂ}
+  (C : CanonicalMass P κ B hBm γ G)
+
+theorem normalized_potentialDifference_eq_increment
+    (hB : IsBrownianReal B P) (hκ : 0<κ) (hκ8 : κ<8)
+    (hc : ∀ ω, Continuous (fun t => B t ω)) (h0 : ∀ ω, B 0 ω=0)
+    (F : Ω → ℝ≥0 → ℂ → ℂ)
+    (hw : ∀ ω, IsCapacityTwoWitness (fun t => Real.sqrt κ*B t ω) (γ ω) (G ω) (F ω))
+    (W : Target.WienerLaw) (hW : Target.IsWiener W)
+    (θ : ℝ) (hθ : θ ∈ Ioo (0:ℝ) Real.pi) (n i : ℕ) :
+    (fun ω => Target.potentialDifference κ θ W (Target.normalizedDriver κ B hc h0 ω) n i) =ᵐ[P]
+      condExp (compensatorMeshFiltration (Target.normalizedFiltration κ B
+        (fun r => (hBm.comp (measurable_const.prodMk measurable_id) : Measurable (B r))) hc h0) n i) P
+        (meshMassIncrement (C.normalizedDiskScalar θ hθ) n i) := by
+  let b := Target.normalizedDriver κ B hc h0
+  have hm (t : ℝ≥0) : Measurable (B t) := hBm.comp (measurable_const.prodMk measurable_id)
+  let ℱ := Target.normalizedFiltration κ B hm hc h0
+  let A := C.normalizedDiskScalar θ hθ
+  let V (i : ℕ) (ω : Ω) := (Target.potential κ θ (b ω) (compensatorMeshTime n i)).toReal
+  have hq := Target.potentialDifference_comp_eq_current_sub_condExp b
+    (Target.normalizedDriver_measurable κ B hm hc h0)
+    (Target.normalizedDriver_isBrownian κ hκ B hB hc h0) W
+    (Target.normalizedDriver_law κ hκ B hB hm hc h0 W hW) κ θ n i
+    (fun j => Target.measurable_potential κ θ (compensatorMeshTime n j))
+    (fun j => normalized_potential_lintegral_ne_top (hBm := hBm)
+      hB hκ hκ8 hc h0 F hw θ hθ (compensatorMeshTime n j))
+  have hA : StronglyAdapted (compensatorMeshFiltration ℱ n)
+      (fun j => A (compensatorMeshTime n j)) :=
+    fun j => C.normalizedDiskScalar_stronglyAdapted hκ hc h0 θ hθ _
+  have hV (j : ℕ) : V j =ᵐ[P]
+      P[C.diskTerminalScalar θ hθ-A (compensatorMeshTime n j) |
+        compensatorMeshFiltration ℱ n j] :=
+    C.normalized_potential_condExp hκ hc h0 F hw θ hθ (compensatorMeshTime n j)
+  exact hq.trans (remainingPotential_increment P (compensatorMeshFiltration ℱ n)
+    (fun j => A (compensatorMeshTime n j)) V (C.diskTerminalScalar θ hθ) hA
+    (fun j => C.normalizedDiskScalar_integrable θ hθ (compensatorMeshTime n j))
+    ((C.compactWeightedMass_terminal_memLp _ _
+      (Target.diskSourceHalfPlane_compact hθ)).integrable one_le_two) hV i)
+
+theorem normalized_discreteMass_tendstoInMeasure
+    (hB : IsBrownianReal B P) (hκ : 0<κ) (hκ8 : κ<8)
+    (hc : ∀ ω, Continuous (fun t => B t ω)) (h0 : ∀ ω, B 0 ω=0)
+    (F : Ω → ℝ≥0 → ℂ → ℂ)
+    (hw : ∀ ω, IsCapacityTwoWitness (fun t => Real.sqrt κ*B t ω) (γ ω) (G ω) (F ω))
+    (W : Target.WienerLaw) (hW : Target.IsWiener W)
+    (θ : ℝ) (hθ : θ ∈ Ioo (0:ℝ) Real.pi) (ℓ : ℝ) (hℓ : 0 ≤ ℓ) :
+    TendstoInMeasure P
+      (fun n ω => Target.discreteMass κ θ W (Target.normalizedDriver κ B hc h0 ω) ℓ n) atTop
+      (fun ω => massAtExtendedTime (fun t => C.normalizedDiskScalar θ hθ t ω)
+        (C.diskTerminalScalar θ hθ ω)
+        (Target.levelTime κ θ (Target.normalizedDriver κ B hc h0 ω) ℓ)) := by
+  exact target_discreteMass_tendstoInMeasure P κ θ W (Target.normalizedDriver κ B hc h0) ℓ
+    (compensatorMeshFiltration (Target.normalizedFiltration κ B
+      (fun r => (hBm.comp (measurable_const.prodMk measurable_id) : Measurable (B r))) hc h0))
+    (C.normalizedDiskScalar θ hθ) (C.diskTerminalScalar θ hθ)
+    (C.normalizedDiskScalar_measurable θ hθ)
+    (fun n i => C.normalizedDiskScalar_stronglyAdapted hκ hc h0 θ hθ _)
+    (C.compactWeightedMass_terminal_memLp _ _ (Target.diskSourceHalfPlane_compact hθ))
+    (C.normalizedDiskScalar_paths hκ θ hθ)
+    (normalized_levelTime_measurable (hBm := hBm) hκ hc h0 F hw θ ℓ hℓ)
+    (C.normalized_potentialDifference_eq_increment hB hκ hκ8 hc h0 F hw W hW θ hθ)
+
+end SLEExactGauge.Multipoint.CanonicalMass
+
+end
+
+end OAI
diff --git a/lean/OAI/Probability/SLE/Geometry/NormalizedRadiusCell.lean b/lean/OAI/Probability/SLE/Geometry/NormalizedRadiusCell.lean
new file mode 100644
index 0000000000000000000000000000000000000000..b0c9ebc316e84b788012b13166c0e167cead4d69
--- /dev/null
+++ b/lean/OAI/Probability/SLE/Geometry/NormalizedRadiusCell.lean
@@ -0,0 +1,168 @@
+import OAI.Probability.SLE.Geometry.NormalizedCellAllTimes
+import OAI.Probability.SLE.Geometry.NormalizedCanonicalRestart
+import OAI.Probability.SLE.Geometry.NormalizedRadiusRestart
+import OAI.Probability.SLE.Loewner.RawDiskRadiusLaw
+
+namespace OAI
+
+/-! The cell comparison at the actual future radius time. The normalized
+disk variable is the same raw variable used in the prescribed coefficients. -/
+noncomputable section
+open Set Filter _root_.MeasureTheory _root_.OAI.MeasureTheory ProbabilityTheory Metric
+open scoped Topology NNReal ENNReal
+
+namespace SLEExactGauge.Multipoint
+local instance radiusCellMeasurable : MeasurableSpace C(ℝ≥0,ℝ) := borel _
+local instance radiusCellBorel : BorelSpace C(ℝ≥0,ℝ) := ⟨rfl⟩
+
+lemma CanonicalMass.normalized_cell_bounds_at_finite_radius
+    {Ω : Type*} [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 ω)) (hκ : 0 < κ)
+    (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 ω)
+    (E : Set C(ℝ≥0,ℝ)) (hE : MeasurableSet E)
+    (hEf : ∀ᵐ p ∂P.map (sourceDriverPath B hc), p∈E)
+    (hEp : ∀ p∈E, PositiveMassPaths (fun t => R.process t p) (R.terminal p))
+    (hgrowth : PublishedDiskUnivalentGrowth)
+    (hpublished : PublishedTraceGeneration (P.map (sourceDriverPath B hc)) κ (fun t p => p t))
+    (τ : Ω → ℝ≥0)
+    (hτ : IsStoppingTime (Filtration.natural B (fun s =>
+      (hBm.comp (measurable_const.prodMk measurable_id) : Measurable (B s)).stronglyMeasurable))
+      (fun ω => (τ ω:WithTop ℝ≥0)))
+    (a : Ω → ℝ≥0) (haM : Measurable[hτ.measurableSpace] a) (ha : ∀ ω, 0 < a ω)
+    (β : Ω → ℝ≥0 → ℂ) (G' F' : Ω → ℝ≥0 → ℂ → ℂ)
+    (hβ : ∀ᵐ ω ∂P, IsCapacityTwoWitness
+      (fun t => Real.sqrt κ*normalizedRestartDriverPath B hc τ a ω t)
+      (β ω) (G' ω) (F' ω)) :
+    ∀ᵐ ω ∂P, ∀ (θ : ℝ) (_hθ : θ ∈ Ioo (0:ℝ) Real.pi)
+      (z : ℂ) (_hz : z ∈ survivingDomain (γ ω) (τ ω))
+      (r : ℝ) (_hr : 0 < r)
+      (_hR : fullRadius (G ω) (τ ω) z=(2048*Real.pi)*r)
+      (_hpolar : G ω (τ ω) z=(Real.sqrt κ*B (τ ω) ω:ℝ)+
+        (a ω:ℂ)*Complex.exp (θ*Complex.I))
+      (u : ℝ) (_hbase : fullRadius (G ω) (τ ω) z=(2*z.im)*Real.exp (-u))
+      (v : ℝ) (_hv : 0 < v)
+      (_hf : radiusLevelTime (β ω) (G' ω) (Target.diskMapInv θ 0) v < ∞),
+      let L := ENNReal.ofReal (R.diskAtRadius κ θ v (normalizedRestartDriverPath B hc τ a ω))
+      let N := extendedCanonicalMass C.process C.rational.terminal
+        (radiusLevelTime (γ ω) (G ω) z (u+v)) ω
+      ENNReal.ofReal (((128*Real.pi)*r)^dimension κ)*L ≤
+          N (Subtype.val ⁻¹' closedBall z ((4096*Real.pi)*r)) ∧
+        ∀ A : Set ℂ, MeasurableSet A → A ⊆ closedBall z (2*r) →
+          A ⊆ survivingDomain (γ ω) (τ ω) →
+          N (Subtype.val ⁻¹' A) ≤ ENNReal.ofReal (((32768*Real.pi)*r)^dimension κ)*L := by
+  filter_upwards [C.normalized_cell_bounds_all_times hB hc hκ F hw R he E hE hEf hEp
+    hgrowth hpublished τ hτ a haM ha,hβ] with ω hcell hb
+  intro θ hθ z hz r hr hR hpolar u hbase v hv hf
+  obtain ⟨t,ht,htR⟩ := exists_live_level_of_radiusLevelTime_lt_top _ _ _ _ hf
+  have hU : Continuous (fun t => Real.sqrt κ*B t ω) := (hc ω).const_mul _
+  have hb' : IsCapacityTwoWitness
+      (normalizedRestartDriver (fun t => Real.sqrt κ*B t ω) (τ ω) (a ω))
+      (β ω) (G' ω) (F' ω) := by
+    rw [← normalizedRestartDriverPath_driver κ B hc τ a ω]
+    exact hb
+  have hF : F ω (τ ω) ((a ω:ℂ)*Target.diskMapInv θ 0+
+      (Real.sqrt κ*B (τ ω) ω:ℝ))=z := by
+    rw [Target.diskMapInv_zero]
+    rw [add_comm,← hpolar]
+    exact (hw ω).2.2.2.2.2.2.2.1 (τ ω) z hz
+  have hphysical := (hw ω).normalized_restart_level_of_live_source hU (τ ω) (a ω)
+    (ha ω) hb' (Target.diskMapInv θ 0) u v (by simpa only [hF] using hbase) t ht htR
+  rw [hF] at hphysical
+  have htime := radiusLevelTime_eq_of_live_level
+    ((normalizedRestartDriverPath B hc τ a ω).continuous.const_mul _) hb _ v t ht htR
+  have hdisk : R.diskAtRadius κ θ v (normalizedRestartDriverPath B hc τ a ω)=
+      compactWeightedMass (Target.diskMassWeight κ θ hθ) (Target.diskSourceHalfPlane θ)
+        (R.process t (normalizedRestartDriverPath B hc τ a ω)) := by
+    unfold RawCanonicalMass.diskAtRadius
+    rw [canonicalRadiusLevel_eq κ _ hb v hv.le,htime]
+    simp only [extendedCanonicalMass,ENNReal.coe_lt_top,ite_true,ENNReal.toNNReal_coe,
+      diskMassValue_toReal_eq κ θ hθ]
+  dsimp only
+  rw [hphysical.2]
+  simp only [extendedCanonicalMass,ENNReal.coe_lt_top,ite_true,ENNReal.toNNReal_coe,hdisk]
+  exact hcell t θ hθ z hz r hr hR hpolar
+
+lemma CanonicalMass.normalized_cell_bounds_at_radius
+    {Ω : Type*} [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 ω)) (hκ : 0 < κ)
+    (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 ω)
+    (E : Set C(ℝ≥0,ℝ)) (hE : MeasurableSet E)
+    (hEf : ∀ᵐ p ∂P.map (sourceDriverPath B hc), p∈E)
+    (hEp : ∀ p∈E, PositiveMassPaths (fun t => R.process t p) (R.terminal p))
+    (hgrowth : PublishedDiskUnivalentGrowth)
+    (hpublished : PublishedTraceGeneration (P.map (sourceDriverPath B hc)) κ (fun t p => p t))
+    (τ : Ω → ℝ≥0)
+    (hτ : IsStoppingTime (Filtration.natural B (fun s =>
+      (hBm.comp (measurable_const.prodMk measurable_id) : Measurable (B s)).stronglyMeasurable))
+      (fun ω => (τ ω:WithTop ℝ≥0)))
+    (a : Ω → ℝ≥0) (haM : Measurable[hτ.measurableSpace] a) (ha : ∀ ω, 0 < a ω) :
+    ∀ᵐ ω ∂P, ∀ (θ : ℝ) (_hθ : θ ∈ Ioo (0:ℝ) Real.pi)
+      (z : ℂ) (_hz : z ∈ survivingDomain (γ ω) (τ ω))
+      (r : ℝ) (_hr : 0 < r)
+      (_hR : fullRadius (G ω) (τ ω) z=(2048*Real.pi)*r)
+      (_hpolar : G ω (τ ω) z=(Real.sqrt κ*B (τ ω) ω:ℝ)+
+        (a ω:ℂ)*Complex.exp (θ*Complex.I))
+      (u : ℝ) (_hu : 0 ≤ u)
+      (_hbase : fullRadius (G ω) (τ ω) z=(2*z.im)*Real.exp (-u))
+      (v : ℝ) (_hv : 0 < v)
+      (_hf : radiusLevelTime (γ ω) (G ω) z (u+v) < ∞),
+      let L := ENNReal.ofReal (R.diskAtRadius κ θ v (normalizedRestartDriverPath B hc τ a ω))
+      let N := extendedCanonicalMass C.process C.rational.terminal
+        (radiusLevelTime (γ ω) (G ω) z (u+v)) ω
+      ENNReal.ofReal (((128*Real.pi)*r)^dimension κ)*L ≤
+          N (Subtype.val ⁻¹' closedBall z ((4096*Real.pi)*r)) ∧
+        ∀ A : Set ℂ, MeasurableSet A → A ⊆ closedBall z (2*r) →
+          A ⊆ survivingDomain (γ ω) (τ ω) →
+          N (Subtype.val ⁻¹' A) ≤ ENNReal.ofReal (((32768*Real.pi)*r)^dimension κ)*L := by
+  obtain ⟨Φ,Gc,Fc,_hΦ,hW⟩ := exists_measurable_canonical_witness _ κ hpublished
+  have hm (s : ℝ≥0) : Measurable (B s) := hBm.of_uncurry_left
+  let Y := normalizedRestartDriverPath B hc τ a
+  have hY : Measurable Y := measurable_scaleDriverPath.comp
+    ((haM.mono hτ.measurableSpace_le le_rfl).inv.prodMk
+      (sourceRestartDriverPath_measurable B hm hc τ hτ))
+  have hYlaw : P.map Y=P.map (sourceDriverPath B hc) := by
+    change P.map (fun ω => scaleDriverPath (a ω)⁻¹
+      (sourceRestartDriverPath B hc τ ω))=P.map (sourceDriverPath B hc)
+    simpa only [Measure.restrict_univ,measure_univ,one_smul] using
+      source_restart_random_scale_driver_law B hB hm hc τ hτ
+        (fun ω => (a ω)⁻¹) haM.inv (fun ω => inv_pos.mpr (ha ω))
+        univ MeasurableSet.univ
+  have hβ := canonical_witness_pullback hW Y hY hYlaw
+  filter_upwards [C.normalized_cell_bounds_at_finite_radius hB hc hκ F hw R he E hE
+    hEf hEp hgrowth hpublished τ hτ a haM ha (fun ω => Φ (Y ω))
+    (fun ω => Gc (Y ω)) (fun ω => Fc (Y ω)) hβ,hβ] with ω hcell hb
+  intro θ hθ z hz r hr hR hpolar u hu hbase v hv hf
+  have hF : F ω (τ ω) ((a ω:ℂ)*Target.diskMapInv θ 0+
+      (Real.sqrt κ*B (τ ω) ω:ℝ))=z := by
+    rw [Target.diskMapInv_zero,add_comm,← hpolar]
+    exact (hw ω).2.2.2.2.2.2.2.1 (τ ω) z hz
+  have hb' : IsCapacityTwoWitness
+      (normalizedRestartDriver (fun t => Real.sqrt κ*B t ω) (τ ω) (a ω))
+      (Φ (Y ω)) (Gc (Y ω)) (Fc (Y ω)) := by
+    rw [← normalizedRestartDriverPath_driver κ B hc τ a ω]
+    exact hb
+  have hequiv := (hw ω).normalized_restart_radius_finite_iff ((hc ω).const_mul _)
+    (τ ω) (a ω) (ha ω) hb' (Target.diskMapInv θ 0)
+    (Target.diskMapInv_maps hθ (by simp)) u v hu hv (by simpa only [hF] using hbase)
+  rw [hF] at hequiv
+  exact hcell θ hθ z hz r hr hR hpolar u hbase v hv (hequiv.mp hf)
+
+end SLEExactGauge.Multipoint
+
+end
+
+end OAI
diff --git a/lean/OAI/Probability/SLE/Geometry/NormalizedRadiusRestart.lean b/lean/OAI/Probability/SLE/Geometry/NormalizedRadiusRestart.lean
new file mode 100644
index 0000000000000000000000000000000000000000..efbbab203fd341449ee7bc94dc1a09c7b4cff8a7
--- /dev/null
+++ b/lean/OAI/Probability/SLE/Geometry/NormalizedRadiusRestart.lean
@@ -0,0 +1,105 @@
+import OAI.Probability.SLE.Loewner.RestartDomainEquality
+import OAI.Probability.SLE.Mass.RestartStoppedMass
+
+namespace OAI
+
+/-! Exact finite radius-time transport through a normalized restart.
+The physical and normalized frontiers reach their corresponding levels together. -/
+noncomputable section
+open Set Filter
+open scoped Topology NNReal ENNReal
+
+namespace SLEExactGauge
+
+lemma IsCapacityTwoWitness.scaled_radius_finite_iff
+    {U : ℝ≥0 → ℝ} {β : ℝ≥0 → ℂ} {G F : ℝ≥0 → ℂ → ℂ}
+    (hb : IsCapacityTwoWitness U β G F) (hU : Continuous U)
+    (a : ℝ≥0) (ha : 0 < a) (w : ℂ) (v : ℝ) :
+    radiusLevelTime (sourceScaleTrace a β) (sourceScaleChart a G) ((a:ℂ)*w) v < ∞ ↔
+      radiusLevelTime β G w v < ∞ := by
+  have haC : (a:ℂ) ≠ 0 := by exact_mod_cast ha.ne'
+  have haR : (a:ℝ) ≠ 0 := by exact_mod_cast ha.ne'
+  have hs := source_scale_witness a ha U β G F hb
+  have hsU : Continuous (fun t => (a:ℝ)*U (sourceScaleTime a t)) := by
+    unfold sourceScaleTime
+    fun_prop
+  have htime (t : ℝ≥0) : a^2*sourceScaleTime a t=t := by
+    unfold sourceScaleTime
+    field_simp
+  constructor
+  · intro hf
+    obtain ⟨t,ht,hR⟩ := exists_live_level_of_radiusLevelTime_lt_top _ _ _ _ hf
+    have htlive : w ∈ survivingDomain β (sourceScaleTime a t) := by
+      simpa only [source_scale_domain_iff a _ ha β,mul_div_cancel_left₀ w haC] using ht
+    have hscaled := hb.scaled_radius a ha (sourceScaleTime a t) w htlive
+    rw [htime t,hR] at hscaled
+    have hR' : fullRadius G (sourceScaleTime a t) w=(2*w.im)*Real.exp (-v) := by
+      apply mul_left_cancel₀ haR
+      rw [← hscaled]
+      simp only [Complex.mul_im,Complex.ofReal_re,Complex.ofReal_im,zero_mul,add_zero]
+      ring
+    rw [radiusLevelTime_eq_of_live_level hU hb w v _ htlive hR']
+    exact ENNReal.coe_lt_top
+  · intro hf
+    obtain ⟨t,ht,hR⟩ := exists_live_level_of_radiusLevelTime_lt_top β G w v hf
+    have htlive : (a:ℂ)*w ∈ survivingDomain (sourceScaleTrace a β) (a^2*t) := by
+      rw [source_scale_domain_iff a _ ha β,source_scale_time_mul_sq a t ha,
+        mul_div_cancel_left₀ w haC]
+      exact ht
+    have hR' : fullRadius (sourceScaleChart a G) (a^2*t) ((a:ℂ)*w)=
+        (2*((a:ℂ)*w).im)*Real.exp (-v) := by
+      rw [hb.scaled_radius a ha t w ht,hR]
+      simp only [Complex.mul_im,Complex.ofReal_re,Complex.ofReal_im,zero_mul,add_zero]
+      ring
+    rw [radiusLevelTime_eq_of_live_level hsU hs _ v _ htlive hR']
+    exact ENNReal.coe_lt_top
+
+lemma IsCapacityTwoWitness.normalized_restart_radius_finite_iff
+    {U : ℝ≥0 → ℝ} {γ β : ℝ≥0 → ℂ} {G F G' F' : ℝ≥0 → ℂ → ℂ}
+    (hw : IsCapacityTwoWitness U γ G F) (hU : Continuous U)
+    (T a : ℝ≥0) (ha : 0 < a)
+    (hb : IsCapacityTwoWitness (normalizedRestartDriver U T a) β G' F')
+    (w : ℂ) (hwH : w ∈ upperHalfPlane) (u v : ℝ) (hu : 0 ≤ u) (hv : 0 < v)
+    (hbase : fullRadius G T (F T ((a:ℂ)*w+(U T:ℂ))) =
+      (2*(F T ((a:ℂ)*w+(U T:ℂ))).im)*Real.exp (-u)) :
+    radiusLevelTime γ G (F T ((a:ℂ)*w+(U T:ℂ))) (u+v) < ∞ ↔
+      radiusLevelTime β G' w v < ∞ := by
+  have hscaled := normalized_restart_witness T a ha hb
+  have hwup : (a:ℂ)*w ∈ upperHalfPlane := by
+    change 0 < ((a:ℂ)*w).im
+    simpa only [Complex.mul_im,Complex.ofReal_re,Complex.ofReal_im,zero_mul,add_zero]
+      using mul_pos (show (0:ℝ)<a from ha) hwH
+  rw [hw.restart_radius_finite_iff hU T hscaled _ hwup u v hu hv hbase]
+  apply hb.scaled_radius_finite_iff
+  unfold normalizedRestartDriver
+  fun_prop
+  exact ha
+
+lemma IsCapacityTwoWitness.normalized_restart_radius_time
+    {U : ℝ≥0 → ℝ} {γ β : ℝ≥0 → ℂ} {G F G' F' : ℝ≥0 → ℂ → ℂ}
+    (hw : IsCapacityTwoWitness U γ G F) (hU : Continuous U)
+    (T a : ℝ≥0) (ha : 0 < a)
+    (hb : IsCapacityTwoWitness (normalizedRestartDriver U T a) β G' F')
+    (w : ℂ) (hwH : w ∈ upperHalfPlane) (u v : ℝ) (hu : 0 ≤ u) (hv : 0 < v)
+    (hbase : fullRadius G T (F T ((a:ℂ)*w+(U T:ℂ))) =
+      (2*(F T ((a:ℂ)*w+(U T:ℂ))).im)*Real.exp (-u)) :
+    radiusLevelTime γ G (F T ((a:ℂ)*w+(U T:ℂ))) (u+v) =
+      (T:ℝ≥0∞)+(a:ℝ≥0∞)^2*radiusLevelTime β G' w v := by
+  have hV : Continuous (normalizedRestartDriver U T a) := by
+    unfold normalizedRestartDriver
+    fun_prop
+  by_cases hf : radiusLevelTime β G' w v < ∞
+  · obtain ⟨t,ht,hR⟩ := exists_live_level_of_radiusLevelTime_lt_top β G' w v hf
+    rw [radiusLevelTime_eq_of_live_level hV hb w v t ht hR,
+      (hw.normalized_restart_level_of_live_source hU T a ha hb w u v hbase t ht hR).2]
+    simp only [ENNReal.coe_add,ENNReal.coe_mul,ENNReal.coe_pow]
+  · have hp : ¬radiusLevelTime γ G (F T ((a:ℂ)*w+(U T:ℂ))) (u+v)<∞ :=
+      fun h => hf ((hw.normalized_restart_radius_finite_iff hU T a ha hb w hwH u v hu hv hbase).mp h)
+    rw [not_lt_top_iff.mp hf,not_lt_top_iff.mp hp,ENNReal.mul_top,add_top]
+    exact pow_ne_zero _ (by exact_mod_cast ha.ne')
+
+end SLEExactGauge
+
+end
+
+end OAI
diff --git a/lean/OAI/Probability/SLE/Geometry/NormalizedRawAllTimes.lean b/lean/OAI/Probability/SLE/Geometry/NormalizedRawAllTimes.lean
new file mode 100644
index 0000000000000000000000000000000000000000..69137a2b68804026e92f4088be5396618c19a522
--- /dev/null
+++ b/lean/OAI/Probability/SLE/Geometry/NormalizedRawAllTimes.lean
@@ -0,0 +1,96 @@
+import OAI.Probability.SLE.Geometry.NormalizedRestartGoodSet
+import OAI.Probability.SLE.Mass.PositiveMassContinuity
+
+namespace OAI
+
+/-! Random normalization commutes with the raw mass process on one event
+  for every finite horizon. Future-dependent horizons may then be used. -/
+noncomputable section
+open Set Filter _root_.MeasureTheory _root_.OAI.MeasureTheory ProbabilityTheory
+open scoped Topology NNReal ENNReal CompactlySupported
+
+namespace SLEExactGauge.Multipoint
+local instance normalizedAllTimesMeasurable : MeasurableSpace C(ℝ≥0,ℝ) := borel _
+local instance normalizedAllTimesBorel : BorelSpace C(ℝ≥0,ℝ) := ⟨rfl⟩
+local instance normalizedAllTimesLocallyCompact : LocallyCompactSpace upperHalfPlane :=
+  isOpen_upperHalfPlane.locallyCompactSpace
+
+variable {Ω : Type*} [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 ω))
+  (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 ω)
+  (E : Set C(ℝ≥0,ℝ)) (hE : MeasurableSet E)
+  (hEf : ∀ᵐ p ∂P.map (sourceDriverPath B hc), p∈E)
+  (hEp : ∀ p∈E, PositiveMassPaths (fun t => R.process t p) (R.terminal p))
+  (τ : Ω → ℝ≥0)
+  (hτ : IsStoppingTime (Filtration.natural B (fun s =>
+    (hBm.comp (measurable_const.prodMk measurable_id) : Measurable (B s)).stronglyMeasurable))
+    (fun ω => (τ ω:WithTop ℝ≥0)))
+  (a : Ω → ℝ≥0) (haM : Measurable[hτ.measurableSpace] a) (ha : ∀ ω, 0<a ω)
+
+include C hB hc F hw R he E hE hEf hEp τ hτ a haM ha in
+theorem CanonicalMass.normalized_raw_scaling_all_times :
+    ∀ᵐ ω ∂P, ∀ t : ℝ≥0,
+      dilationMass κ (a ω) (ha ω) (R.process t
+        (scaleDriverPath (a ω)⁻¹ (sourceRestartDriverPath B hc τ ω))) =
+      R.process ((a ω)^2*t) (sourceRestartDriverPath B hc τ ω) := by
+  let Y := fun ω => scaleDriverPath (a ω)⁻¹ (sourceRestartDriverPath B hc τ ω)
+  have hm (s : ℝ≥0) : Measurable (B s) := hBm.of_uncurry_left
+  have hYm : Measurable Y := measurable_scaleDriverPath.comp
+    ((haM.mono hτ.measurableSpace_le le_rfl).inv.prodMk
+      (sourceRestartDriverPath_measurable B hm hc τ hτ))
+  have hYlaw := source_restart_random_scale_driver_law B hB hm hc τ hτ
+    (fun ω => (a ω)⁻¹) haM.inv (fun ω => inv_pos.mpr (ha ω))
+  let L := fun t ω => dilationMass κ (a ω) (ha ω) (R.process t (Y ω))
+  let N := fun t ω => R.process ((a ω)^2*t) (sourceRestartDriverPath B hc τ ω)
+  have hdense (j : ℕ) : ∀ᵐ ω ∂P, L (TopologicalSpace.denseSeq ℝ≥0 j) ω=N (TopologicalSpace.denseSeq ℝ≥0 j) ω := by
+    filter_upwards [C.random_raw_scaled_mass_eq hB hc F hw R he E hE hEf hEp
+      hτ.measurableSpace hτ.measurableSpace_le Y hYm hYlaw a
+      (fun _ => TopologicalSpace.denseSeq ℝ≥0 j) haM measurable_const ha] with ω hω
+    simpa only [L,N,Y,scaleDriverPath_inv_cancel (a ω) (ha ω)] using hω
+  have hYgood := normalized_restart_mem_full_driver_set hB hm hc τ hτ a haM ha E hE hEf
+  have hNgood := sourceRestart_mem_full_driver_set hB hm hc τ hτ E hE hEf
+  apply random_radon_process_eq_of_positive_tests P (localTestFamily upperHalfPlane) L N
+  · intro t ω
+    let := (R.radon t (Y ω)).2
+    exact (conformalMass_radon _ _ _).1
+  · intro t ω
+    exact (R.radon _ _).1
+  · intro f _hf
+    filter_upwards [ae_all_iff.mpr hdense,hYgood,hNgood] with ω hω hYω hNω
+    have hpY := hEp _ hYω
+    have hpN := hEp _ hNω
+    have hL : Continuous (fun t => ∫ z,f z ∂L t ω) :=
+      conformalMass_test_continuous _ _ _ hpY.continuous_real_tests f
+    have hN : Continuous (fun t => ∫ z,f z ∂N t ω) :=
+      (hpN.continuous_real_tests f).comp (continuous_const.mul continuous_id)
+    have heq := (TopologicalSpace.denseRange_denseSeq ℝ≥0).equalizer hL hN
+      (by funext j; simp only [Function.comp_apply]; rw [hω j])
+    intro t
+    exact congrFun heq t
+
+include C hB hc F hw R he E hE hEf hEp τ hτ a haM ha in
+theorem CanonicalMass.normalized_raw_restart_all_times (hκ : 0<κ)
+    (hpublished : PublishedTraceGeneration (P.map (sourceDriverPath B hc)) κ (fun t p => p t)) :
+    ∀ᵐ ω ∂P, ∀ t : ℝ≥0, C.process (τ ω+(a ω)^2*t) ω-C.process (τ ω) ω =
+      weightedImageMass (stoppedMassPoint B κ γ G F hw τ ω) (stoppedMassWeight B κ F τ ω)
+        (dilationMass κ (a ω) (ha ω) (R.process t
+          (scaleDriverPath (a ω)⁻¹ (sourceRestartDriverPath B hc τ ω)))) := by
+  filter_upwards [C.normalized_raw_scaling_all_times hB hc F hw R he E hE hEf hEp τ hτ a haM ha,
+    C.raw_fixed_restart hB hc hκ F hw R he E hE hEf hEp hpublished τ hτ] with ω hs hr
+  intro t
+  rw [hr ((a ω)^2*t)]
+  change weightedImageMass _ _ (R.process ((a ω)^2*t) (sourceRestartDriverPath B hc τ ω))=_
+  rw [hs t]
+
+end SLEExactGauge.Multipoint
+
+end
+
+end OAI
diff --git a/lean/OAI/Probability/SLE/Geometry/NormalizedRawRestart.lean b/lean/OAI/Probability/SLE/Geometry/NormalizedRawRestart.lean
new file mode 100644
index 0000000000000000000000000000000000000000..9dccfe101134ffa123afef6c578e0bf22db1c1f6
--- /dev/null
+++ b/lean/OAI/Probability/SLE/Geometry/NormalizedRawRestart.lean
@@ -0,0 +1,73 @@
+import OAI.Probability.SLE.Loewner.RawFixedRestart
+import OAI.Probability.SLE.Geometry.RandomRawScaleTests
+
+namespace OAI
+
+/-! The same raw canonical functional after a finite stopping time and a
+positive normalization scale chosen from the stopped past. -/
+noncomputable section
+open Set Filter _root_.MeasureTheory _root_.OAI.MeasureTheory ProbabilityTheory
+open scoped Topology NNReal ENNReal
+
+namespace SLEExactGauge
+
+lemma scaleDriverPath_inv_cancel (c : ℝ≥0) (hc : 0 < c) (p : C(ℝ≥0,ℝ)) :
+    scaleDriverPath c (scaleDriverPath c⁻¹ p)=p := by
+  ext t
+  change (c:ℝ)*(((c⁻¹:ℝ≥0):ℝ)*p (t/c^2/(c⁻¹)^2))=p t
+  rw [← mul_assoc]
+  rw [show t/c^2/(c⁻¹)^2=t by field_simp [hc.ne']]
+  rw [NNReal.coe_inv,mul_inv_cancel₀ (show (c:ℝ)≠0 from ne_of_gt hc),one_mul]
+
+namespace Multipoint
+local instance normalizedRawRestartMeasurable : MeasurableSpace C(ℝ≥0,ℝ) := borel _
+local instance normalizedRawRestartBorel : BorelSpace C(ℝ≥0,ℝ) := ⟨rfl⟩
+
+lemma CanonicalMass.normalized_raw_restart
+    {Ω : Type*} [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 ω)) (hκ : 0 < κ)
+    (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 ω)
+    (E : Set C(ℝ≥0,ℝ)) (hE : MeasurableSet E)
+    (hEf : ∀ᵐ p ∂P.map (sourceDriverPath B hc), p∈E)
+    (hEp : ∀ p∈E, PositiveMassPaths (fun t => R.process t p) (R.terminal p))
+    (hpublished : PublishedTraceGeneration (P.map (sourceDriverPath B hc)) κ (fun t p => p t))
+    (τ : Ω → ℝ≥0)
+    (hτ : IsStoppingTime (Filtration.natural B (fun s =>
+      (hBm.comp (measurable_const.prodMk measurable_id) : Measurable (B s)).stronglyMeasurable))
+      (fun ω => (τ ω:WithTop ℝ≥0)))
+    (a T : Ω → ℝ≥0) (haM : Measurable[hτ.measurableSpace] a)
+    (hT : Measurable[hτ.measurableSpace] T) (ha : ∀ ω, 0 < a ω) :
+    ∀ᵐ ω ∂P, C.process (τ ω+(a ω)^2*T ω) ω-C.process (τ ω) ω =
+      weightedImageMass (stoppedMassPoint B κ γ G F hw τ ω) (stoppedMassWeight B κ F τ ω)
+        (dilationMass κ (a ω) (ha ω) (R.process (T ω)
+          (scaleDriverPath (a ω)⁻¹ (sourceRestartDriverPath B hc τ ω)))) := by
+  have hm (s : ℝ≥0) : Measurable (B s) := hBm.comp (measurable_const.prodMk measurable_id)
+  let Y : Ω → C(ℝ≥0,ℝ) := fun ω =>
+    scaleDriverPath (a ω)⁻¹ (sourceRestartDriverPath B hc τ ω)
+  have hYm : Measurable Y := measurable_scaleDriverPath.comp
+    ((haM.mono hτ.measurableSpace_le le_rfl).inv.prodMk
+      (sourceRestartDriverPath_measurable B hm hc τ hτ))
+  have hYlaw := source_restart_random_scale_driver_law B hB hm hc τ hτ
+    (fun ω => (a ω)⁻¹) haM.inv (fun ω => inv_pos.mpr (ha ω))
+  have hs := C.random_raw_scaled_mass_eq hB hc F hw R he E hE hEf hEp
+    hτ.measurableSpace hτ.measurableSpace_le Y hYm hYlaw a T haM hT ha
+  filter_upwards [C.raw_fixed_restart hB hc hκ F hw R he E hE hEf hEp hpublished τ hτ,hs]
+    with ω hr hsω
+  rw [hr ((a ω)^2*T ω)]
+  change weightedImageMass _ _ (R.process ((a ω)^2*T ω) (sourceRestartDriverPath B hc τ ω))=_
+  rw [hsω]
+  simp only [Y,scaleDriverPath_inv_cancel (a ω) (ha ω)]
+
+end Multipoint
+end SLEExactGauge
+
+end
+
+end OAI
diff --git a/lean/OAI/Probability/SLE/Geometry/NormalizedReflectedSlit.lean b/lean/OAI/Probability/SLE/Geometry/NormalizedReflectedSlit.lean
new file mode 100644
index 0000000000000000000000000000000000000000..508bbcd6fba1eae0a723baf12ed285c5513f9bc0
--- /dev/null
+++ b/lean/OAI/Probability/SLE/Geometry/NormalizedReflectedSlit.lean
@@ -0,0 +1,52 @@
+import OAI.Probability.SLE.Geometry.ReflectedInvertedUpperConnected
+import OAI.Probability.SLE.Geometry.SymmetricChartUpperBijective
+
+namespace OAI
+
+/-! The reflected-slit Riemann map normalized at infinity, including its
+exact upper-side image. This remains a static conformal chart. -/
+noncomputable section
+open Set Complex Metric Function
+open scoped ComplexConjugate
+
+namespace SLEExactGauge
+
+theorem reflected_slit_exists_normalized_chart
+    (p : C(unitInterval,ℂ)) (hi : Injective p) (h0 : p 0=0)
+    (hH : ∀ t : unitInterval, t ≠ 0 → p t ∈ upperHalfPlane) :
+    ∃ (f : ℂ → ℂ) (a : ℝ), 0 < a ∧
+      BijOn f (invertedExterior (reflectedArcSet p)) (ball 0 1) ∧
+      DifferentiableOn ℂ f (invertedExterior (reflectedArcSet p)) ∧
+      f 0=0 ∧ deriv f 0=(a:ℂ) ∧
+      (∀ z ∈ invertedExterior (reflectedArcSet p), f (conj z)=conj (f z)) ∧
+      BijOn f (invertedExterior (reflectedArcSet p) ∩ upperHalfPlane)
+        (ball 0 1 ∩ upperHalfPlane) := by
+  have hK : IsCompact (reflectedArcSet p) := (isCompact_range p.continuous).union
+    ((isCompact_range p.continuous).image Complex.continuous_conj)
+  have ho := invertedExterior_isOpen hK
+  have hz := zero_mem_invertedExterior (reflectedArcSet p)
+  have hproper : invertedExterior (reflectedArcSet p) ≠ univ := by
+    intro he
+    have hp1 : p 1 ≠ 0 := by
+      intro hp1
+      have ht := hi (hp1.trans h0.symm)
+      norm_num at ht
+    have hm : (p 1)⁻¹ ∈ invertedExterior (reflectedArcSet p) := by rw [he]; trivial
+    rcases hm with hm|hm
+    · exact inv_ne_zero hp1 hm
+    · apply hm
+      rw [inv_inv]
+      exact Or.inl (mem_range_self 1)
+  obtain ⟨f,hb,hf,hf0,a,ha,hfa⟩ := exists_zero_normalized_riemann_chart ho
+    (reflected_slit_inverted_simplyConnected p hi h0 hH) hproper hz
+  have hD := invertedExterior_conj (reflectedArcSet_conj p)
+  have hsym := normalized_riemann_chart_conj ho hz hD hf hb hf0 hfa
+  have hupper := normalized_riemann_maps_upper ho hz hD
+    (reflected_inverted_upper_connected p hi h0 hH).isPreconnected hf hb hf0 ha hfa
+  exact ⟨f,a,ha,hb,hf,hf0,hfa,hsym,symmetric_disk_chart_upper_bijOn hD hb hsym hupper⟩
+
+end SLEExactGauge
+
+end
+
+end OAI
diff --git a/lean/OAI/Probability/SLE/Geometry/NormalizedRestartDensity.lean b/lean/OAI/Probability/SLE/Geometry/NormalizedRestartDensity.lean
new file mode 100644
index 0000000000000000000000000000000000000000..d4af305a7dac2fe531640aca59f46298dff3b9de
--- /dev/null
+++ b/lean/OAI/Probability/SLE/Geometry/NormalizedRestartDensity.lean
@@ -0,0 +1,64 @@
+import OAI.Probability.SLE.Geometry.NormalizedRadiusRestart
+
+namespace OAI
+
+/-! The stopped Green density factors exactly across a normalized restart,
+including paths whose deeper radius time is infinite. -/
+noncomputable section
+open Set Filter
+open scoped Topology NNReal ENNReal
+
+namespace SLEExactGauge
+
+lemma IsCapacityTwoWitness.normalized_restart_stopped_green_eq
+    {U : ℝ≥0 → ℝ} {γ β : ℝ≥0 → ℂ} {G F G' F' : ℝ≥0 → ℂ → ℂ}
+    (hw : IsCapacityTwoWitness U γ G F) (hU : Continuous U) (T a : ℝ≥0) (ha : 0 < a)
+    (hb : IsCapacityTwoWitness (normalizedRestartDriver U T a) β G' F')
+    (κ : ℝ) (w : ℂ) (hwH : w ∈ upperHalfPlane) (u v : ℝ) (hu : 0 ≤ u) (hv : 0 < v)
+    (hbase : fullRadius G T (F T ((a:ℂ)*w+(U T:ℂ))) =
+      (2*(F T ((a:ℂ)*w+(U T:ℂ))).im)*Real.exp (-u)) :
+    greenDensity κ U γ G T (F T ((a:ℂ)*w+(U T:ℂ))) *
+        (stoppedGreen κ (normalizedRestartDriver U T a) β G' w v / initialGreen κ w) =
+      stoppedGreen κ U γ G (F T ((a:ℂ)*w+(U T:ℂ))) (u+v) := by
+  have hbup := normalized_restart_witness T a ha hb
+  have haR : 0 < (a:ℝ) := ha
+  have hwup : (a:ℂ)*w ∈ upperHalfPlane := by
+    change 0 < ((a:ℂ)*w).im
+    simpa only [Complex.mul_im,Complex.ofReal_re,Complex.ofReal_im,zero_mul,add_zero]
+      using mul_pos haR hwH
+  have hV : Continuous (normalizedRestartDriver U T a) := by
+    unfold normalizedRestartDriver
+    fun_prop
+  by_cases hf : radiusLevelTime β G' w v < ∞
+  · obtain ⟨t,ht,hR⟩ := exists_live_level_of_radiusLevelTime_lt_top β G' w v hf
+    have htu : (a:ℂ)*w ∈ survivingDomain (sourceScaleTrace a β) (a^2*t) := by
+      rw [source_scale_domain_iff a _ ha β,source_scale_time_mul_sq a t ha,
+        mul_div_cancel_left₀ w (by exact_mod_cast ha.ne' : (a:ℂ)≠0)]
+      exact ht
+    have hphysical := hw.normalized_restart_level_of_live_source hU T a ha hb w u v hbase t ht hR
+    have hgreen := hw.restart_green_composition hU T hbup κ (a^2*t) ((a:ℂ)*w) htu
+    have hscale := hb.scaled_green hV a ha κ t w ht
+    have hdriver : (fun t => (a:ℝ)*normalizedRestartDriver U T a (sourceScaleTime a t)) =
+        (fun t => U (T+t)-U T) := by
+      funext r
+      unfold normalizedRestartDriver sourceScaleTime
+      have htime : a^2*(r/a^2)=r := by field_simp
+      rw [htime]
+      field_simp
+    rw [hdriver] at hscale
+    rw [hscale] at hgreen
+    rw [stoppedGreen_eq_of_live_level hV hb κ w v t ht hR,
+      stoppedGreen_eq_of_live_level hU hw κ _ _ (T+a^2*t)
+        (hw.restart_forward_composition T hbup (a^2*t) ((a:ℂ)*w) htu).1 hphysical.1,
+      hgreen,hw.restart_green_initial hU T hbup κ ((a:ℂ)*w) hwup,
+      initialGreen_pos_real_mul κ a haR w hwH]
+    field_simp [(initialGreen_pos κ w hwH).ne']
+  · have hp : ¬radiusLevelTime γ G (F T ((a:ℂ)*w+(U T:ℂ))) (u+v)<∞ :=
+      fun h => hf ((hw.normalized_restart_radius_finite_iff hU T a ha hb w hwH u v hu hv hbase).mp h)
+    simp only [stoppedGreen,ite_eq_right hf,ite_eq_right hp,zero_div,mul_zero]
+
+end SLEExactGauge
+
+end
+
+end OAI
diff --git a/lean/OAI/Probability/SLE/Geometry/NormalizedRestartGoodSet.lean b/lean/OAI/Probability/SLE/Geometry/NormalizedRestartGoodSet.lean
new file mode 100644
index 0000000000000000000000000000000000000000..ede4eb2670b89ce6ddec31cecb4e925ff3cae794
--- /dev/null
+++ b/lean/OAI/Probability/SLE/Geometry/NormalizedRestartGoodSet.lean
@@ -0,0 +1,43 @@
+import OAI.Probability.SLE.Geometry.NormalizedRawRestart
+
+namespace OAI
+
+/-! Every measurable full-law certificate is retained by the randomly
+normalized fresh driver, on the original probability space. -/
+noncomputable section
+open Set Filter _root_.MeasureTheory _root_.OAI.MeasureTheory ProbabilityTheory
+open scoped Topology NNReal ENNReal
+
+namespace SLEExactGauge
+local instance normalizedGoodMeasurable : MeasurableSpace C(ℝ≥0,ℝ) := borel _
+local instance normalizedGoodBorel : BorelSpace C(ℝ≥0,ℝ) := ⟨rfl⟩
+
+lemma normalized_restart_mem_full_driver_set
+    {Ω : Type*} [MeasurableSpace Ω] {P : Measure Ω} [IsProbabilityMeasure P]
+    {B : ℝ≥0 → Ω → ℝ} (hB : IsBrownianReal B P)
+    (hm : ∀ t, Measurable (B t)) (hc : ∀ ω, Continuous (fun t => B t ω))
+    (τ : Ω → ℝ≥0)
+    (hτ : IsStoppingTime (Filtration.natural B (fun t => (hm t).stronglyMeasurable))
+      (fun ω => (τ ω:WithTop ℝ≥0)))
+    (a : Ω → ℝ≥0) (haM : Measurable[hτ.measurableSpace] a) (ha : ∀ ω, 0 < a ω)
+    (E : Set C(ℝ≥0,ℝ)) (hE : MeasurableSet E)
+    (hEf : ∀ᵐ p ∂P.map (sourceDriverPath B hc), p∈E) :
+    ∀ᵐ ω ∂P, scaleDriverPath (a ω)⁻¹ (sourceRestartDriverPath B hc τ ω) ∈ E := by
+  let Y : Ω → C(ℝ≥0,ℝ) := fun ω =>
+    scaleDriverPath (a ω)⁻¹ (sourceRestartDriverPath B hc τ ω)
+  have hY : Measurable Y := measurable_scaleDriverPath.comp
+    ((haM.mono hτ.measurableSpace_le le_rfl).inv.prodMk
+      (sourceRestartDriverPath_measurable B hm hc τ hτ))
+  have hlaw : P.map Y=P.map (sourceDriverPath B hc) := by
+    simpa only [Measure.restrict_univ,measure_univ,one_smul] using
+      source_restart_random_scale_driver_law B hB hm hc τ hτ
+        (fun ω => (a ω)⁻¹) haM.inv (fun ω => inv_pos.mpr (ha ω))
+        univ MeasurableSet.univ
+  apply (ae_map_iff hY.aemeasurable hE).mp
+  rwa [hlaw]
+
+end SLEExactGauge
+
+end
+
+end OAI
diff --git a/lean/OAI/Probability/SLE/Geometry/NormalizedRestartKernel.lean b/lean/OAI/Probability/SLE/Geometry/NormalizedRestartKernel.lean
new file mode 100644
index 0000000000000000000000000000000000000000..14958c862e023dd3e3668e91fe3462747e93a40e
--- /dev/null
+++ b/lean/OAI/Probability/SLE/Geometry/NormalizedRestartKernel.lean
@@ -0,0 +1,104 @@
+import OAI.Probability.SLE.Geometry.ScaledMarkedKernel
+import OAI.Probability.SLE.Geometry.NormalizedMarkedState
+
+namespace OAI
+
+/-! Centered-density domination for the actual capacity-normalized restart.
+The fresh marked point has unit modulus in the application; its source
+radius level is transported to the original physical radius level. -/
+
+noncomputable section
+open Set Filter
+open scoped Topology NNReal ENNReal
+
+namespace SLEExactGauge
+
+def normalizedRestartDriver (U : ℝ≥0 → ℝ) (T a : ℝ≥0) (t : ℝ≥0) : ℝ :=
+  (U (T + a ^ 2 * t) - U T) / (a : ℝ)
+
+lemma normalized_restart_witness
+    {U : ℝ≥0 → ℝ} (T a : ℝ≥0) (ha : 0 < a)
+    {β : ℝ≥0 → ℂ} {G' F' : ℝ≥0 → ℂ → ℂ}
+    (hb : IsCapacityTwoWitness (normalizedRestartDriver U T a) β G' F') :
+    IsCapacityTwoWitness (fun t => U (T + t) - U T)
+      (sourceScaleTrace a β) (sourceScaleChart a G') (sourceScaleChart a F') := by
+  have hh := source_scale_witness a ha _ β G' F' hb
+  have htime (t : ℝ≥0) : a ^ 2 * sourceScaleTime a t = t := by
+    dsimp only [sourceScaleTime]
+    field_simp
+  have hdriver : (fun t => (a : ℝ) * normalizedRestartDriver U T a (sourceScaleTime a t)) =
+      (fun t => U (T + t) - U T) := by
+    funext t
+    unfold normalizedRestartDriver
+    rw [htime t]
+    field_simp
+  rwa [hdriver] at hh
+
+lemma initialGreen_pos_real_mul
+    (κ : ℝ) (a : ℝ) (ha : 0 < a) (w : ℂ) (hw : w ∈ upperHalfPlane) :
+    initialGreen κ ((a : ℂ) * w) = a ^ (-codimension κ) * initialGreen κ w := by
+  have him : 2 * ((a : ℂ) * w).im = a * (2 * w.im) := by
+    simp only [Complex.mul_im, Complex.ofReal_re, Complex.ofReal_im, zero_mul, add_zero]
+    ring
+  rw [initialGreen, him, sin_arg_pos_real_mul a ha,
+    Real.mul_rpow ha.le (mul_pos (by norm_num) hw).le, initialGreen, mul_assoc]
+
+/-- The normalized fresh finite-centered density is dominated by the
+terminal physical density, relative to the density at the actual past stop. -/
+theorem IsCapacityTwoWitness.normalized_restart_stopped_green_lower
+    {U : ℝ≥0 → ℝ} {γ β : ℝ≥0 → ℂ} {G F G' F' : ℝ≥0 → ℂ → ℂ}
+    (hw : IsCapacityTwoWitness U γ G F) (hU : Continuous U) (T a : ℝ≥0) (ha : 0 < a)
+    (hb : IsCapacityTwoWitness (normalizedRestartDriver U T a) β G' F')
+    (κ : ℝ) (w : ℂ) (hwH : w ∈ upperHalfPlane) (u v : ℝ)
+    (hbase : fullRadius G T (F T ((a : ℂ) * w + (U T : ℂ))) =
+      (2 * (F T ((a : ℂ) * w + (U T : ℂ))).im) * Real.exp (-u)) :
+    greenDensity κ U γ G T (F T ((a : ℂ) * w + (U T : ℂ))) *
+        (stoppedGreen κ (normalizedRestartDriver U T a) β G' w v / initialGreen κ w) ≤
+      stoppedGreen κ U γ G (F T ((a : ℂ) * w + (U T : ℂ))) (u + v) := by
+  have hbup := normalized_restart_witness T a ha hb
+  have haR : 0 < (a : ℝ) := ha
+  have hwup : (a : ℂ) * w ∈ upperHalfPlane := by
+    change 0 < ((a : ℂ) * w).im
+    simpa only [Complex.mul_im, Complex.ofReal_re, Complex.ofReal_im, zero_mul, add_zero] using
+      mul_pos haR hwH
+  have hV : Continuous (normalizedRestartDriver U T a) := by
+    unfold normalizedRestartDriver
+    fun_prop
+  by_cases hfinite : radiusLevelTime β G' w v < ∞
+  · obtain ⟨t, ht, hR⟩ := exists_live_level_of_radiusLevelTime_lt_top β G' w v hfinite
+    have htu : (a : ℂ) * w ∈ survivingDomain (sourceScaleTrace a β) (a ^ 2 * t) := by
+      rw [source_scale_domain_iff a _ ha β, source_scale_time_mul_sq a t ha,
+        mul_div_cancel_left₀ w (by exact_mod_cast ha.ne' : (a : ℂ) ≠ 0)]
+      exact ht
+    have hRu : fullRadius (sourceScaleChart a G') (a ^ 2 * t) ((a : ℂ) * w) =
+        (2 * ((a : ℂ) * w).im) * Real.exp (-v) := by
+      rw [hb.scaled_radius a ha t w ht, hR]
+      simp only [Complex.mul_im, Complex.ofReal_re, Complex.ofReal_im, zero_mul, add_zero]
+      ring
+    have hphysical := hw.restart_level_of_live_source hU T hbup ((a : ℂ) * w) u v hbase
+      (a ^ 2 * t) htu hRu
+    have hgreen := hw.restart_green_composition hU T hbup κ (a ^ 2 * t) ((a : ℂ) * w) htu
+    have hscale := hb.scaled_green hV a ha κ t w ht
+    have hdriver : (fun t => (a : ℝ) * normalizedRestartDriver U T a (sourceScaleTime a t)) =
+        (fun t => U (T + t) - U T) := by
+      funext r
+      unfold normalizedRestartDriver sourceScaleTime
+      have htime : a ^ 2 * (r / a ^ 2) = r := by field_simp
+      rw [htime]
+      field_simp
+    rw [hdriver] at hscale
+    rw [hscale] at hgreen
+    rw [stoppedGreen_eq_of_live_level hV hb κ w v t ht hR,
+      stoppedGreen_eq_of_live_level hU hw κ _ _ (T + a ^ 2 * t)
+        (hw.restart_forward_composition T hbup (a ^ 2 * t) ((a : ℂ) * w) htu).1 hphysical.1,
+      hgreen, hw.restart_green_initial hU T hbup κ ((a : ℂ) * w) hwup,
+      initialGreen_pos_real_mul κ a haR w hwH]
+    exact le_of_eq (by field_simp [(initialGreen_pos κ w hwH).ne'])
+  · simp only [stoppedGreen, ite_eq_right hfinite, zero_div, mul_zero]
+    exact stoppedGreen_nonneg hw κ _ _
+
+end SLEExactGauge
+
+end
+
+end OAI
diff --git a/lean/OAI/Probability/SLE/Geometry/NormalizedRiemannChart.lean b/lean/OAI/Probability/SLE/Geometry/NormalizedRiemannChart.lean
new file mode 100644
index 0000000000000000000000000000000000000000..541647a55dd3b9393a597de174134b2396f566f0
--- /dev/null
+++ b/lean/OAI/Probability/SLE/Geometry/NormalizedRiemannChart.lean
@@ -0,0 +1,57 @@
+import OAI.Probability.SLE.Loewner.ReflectedSlitRiemann
+
+namespace OAI
+
+/-! Normalization of the Riemann chart at the inversion origin. The
+phase is fixed by requiring a positive real first derivative. -/
+noncomputable section
+open Set Complex Metric Function
+
+namespace SLEExactGauge
+
+theorem exists_zero_normalized_riemann_chart {D : Set ℂ}
+    (ho : IsOpen D) (hs : IsSimplyConnected D) (hne : D ≠ univ) (h0 : (0:ℂ) ∈ D) :
+    ∃ f : ℂ → ℂ, BijOn f D (ball 0 1) ∧ DifferentiableOn ℂ f D ∧ f 0=0 ∧
+      ∃ a : ℝ, 0 < a ∧ deriv f 0=(a:ℂ) := by
+  have hroots := hs.hasHolomorphicSquareRoots ho
+  obtain ⟨f,hf,hmax⟩ := TauCeti.exists_isMaxOn_norm_deriv_of_hasHolomorphicSquareRoots
+    hroots ho hs.isPathConnected.isConnected.isPreconnected hne h0
+  have hsurj := TauCeti.surjOn_ball_of_isMaxOn ho hroots h0 hf hmax
+  have hd : deriv f 0 ≠ 0 := hf.deriv_ne_zero ho h0
+  let c : ℂ := (‖deriv f 0‖:ℂ)/deriv f 0
+  have hdn : 0 < ‖deriv f 0‖ := norm_pos_iff.mpr hd
+  have hc : c ≠ 0 := div_ne_zero (by exact_mod_cast hdn.ne') hd
+  have hcn : ‖c‖=1 := by
+    simp only [c,norm_div,Complex.norm_real,Real.norm_eq_abs,abs_of_pos hdn]
+    exact div_self hdn.ne'
+  let g : ℂ → ℂ := fun z => c*f z
+  have hgm : MapsTo g D (ball 0 1) := by
+    intro z hz
+    have hh := hf.mapsTo hz
+    simpa only [g,mem_ball,dist_zero_right,norm_mul,hcn,one_mul] using hh
+  have hgi : InjOn g D := by
+    intro z hz w hw he
+    apply hf.injOn hz hw
+    exact mul_left_cancel₀ hc he
+  have hgs : SurjOn g D (ball 0 1) := by
+    intro w hw
+    have hcInv : ‖c⁻¹‖=1 := by rw [norm_inv,hcn,inv_one]
+    have hw' : c⁻¹*w ∈ ball (0:ℂ) 1 := by
+      simpa only [mem_ball,dist_zero_right,norm_mul,hcInv,one_mul] using hw
+    obtain ⟨z,hz,hfz⟩ := hsurj hw'
+    refine ⟨z,hz,?_⟩
+    change c*f z=w
+    rw [hfz,← mul_assoc,mul_inv_cancel₀ hc,one_mul]
+  refine ⟨g,⟨hgm,hgi,hgs⟩,hf.differentiableOn.const_mul c,?_,‖deriv f 0‖,hdn,?_⟩
+  · simp only [g,hf.map_base,mul_zero]
+  · have hh := ((hf.differentiableOn.differentiableAt (ho.mem_nhds h0)).hasDerivAt.const_mul c).deriv
+    change deriv g 0=(‖deriv f 0‖:ℂ)
+    rw [hh]
+    dsimp only [c]
+    exact div_mul_cancel₀ _ hd
+
+end SLEExactGauge
+
+end
+
+end OAI
diff --git a/lean/OAI/Probability/SLE/Geometry/NormalizedRiemannUniqueness.lean b/lean/OAI/Probability/SLE/Geometry/NormalizedRiemannUniqueness.lean
new file mode 100644
index 0000000000000000000000000000000000000000..2447b26543a8411cf80b0ad11aad7bdab8e84ddf
--- /dev/null
+++ b/lean/OAI/Probability/SLE/Geometry/NormalizedRiemannUniqueness.lean
@@ -0,0 +1,61 @@
+import OAI.Probability.SLE.Geometry.NormalizedRiemannChart
+import Mathlib.Analysis.Complex.Schwarz
+
+namespace OAI
+
+/-! Uniqueness at a fixed derivative, in the form needed to reflect the
+normalized exterior chart. Only the reference map must be onto the disk. -/
+noncomputable section
+open Set Complex Metric Function
+open scoped Topology
+
+namespace SLEExactGauge
+
+lemma disk_selfMap_eq_id_of_deriv_one {f : ℂ → ℂ}
+    (hf : DifferentiableOn ℂ f (ball 0 1))
+    (hm : MapsTo f (ball 0 1) (ball 0 1)) (h0 : f 0=0) (hd : deriv f 0=1) :
+    EqOn f id (ball 0 1) := by
+  have hclosed : MapsTo f (ball 0 1) (closedBall (f 0) 1) := by
+    rw [h0]
+    exact hm.mono_right ball_subset_closedBall
+  have h := Complex.affine_of_mapsTo_ball_of_norm_dslope_eq_div hf hclosed
+    (mem_ball_self zero_lt_one) (by simp [hd])
+  intro z hz
+  simpa only [h0,sub_zero,dslope_same,hd,smul_eq_mul,mul_one,zero_add,id_eq] using h hz
+
+theorem riemann_chart_eq_of_deriv_eq {D : Set ℂ} (ho : IsOpen D) (h0D : (0:ℂ) ∈ D)
+    {f g : ℂ → ℂ} (hf : DifferentiableOn ℂ f D) (hg : DifferentiableOn ℂ g D)
+    (hfm : MapsTo f D (ball 0 1)) (hgb : BijOn g D (ball 0 1))
+    (hf0 : f 0=0) (hg0 : g 0=0) (hd : deriv f 0=deriv g 0) : EqOn f g D := by
+  let j := invFunOn g D
+  have hjm : MapsTo j (ball 0 1) D := hgb.surjOn.mapsTo_invFunOn
+  have hjd : DifferentiableOn ℂ j (ball 0 1) := by
+    simpa only [hgb.image_eq] using DifferentiableOn.invFunOn hg ho hgb.injOn
+  have hj0 : j 0=0 := by
+    change invFunOn g D 0=0
+    simpa only [hg0] using hgb.injOn.leftInvOn_invFunOn h0D
+  have hjAt : HasDerivAt j (deriv g 0)⁻¹ 0 := by
+    simpa only [hg0] using TauCeti.hasDerivAt_invFunOn hg ho hgb.injOn h0D
+  have hgd : deriv g 0 ≠ 0 := TauCeti.deriv_ne_zero_of_injOn hg ho hgb.injOn h0D
+  let H := f ∘ j
+  have hHd : DifferentiableOn ℂ H (ball 0 1) := hf.comp hjd hjm
+  have hHm : MapsTo H (ball 0 1) (ball 0 1) := hfm.comp hjm
+  have hH0 : H 0=0 := by simp only [H,Function.comp_apply,hj0,hf0]
+  have hH1 : deriv H 0=1 := by
+    have hfAt : HasDerivAt f (deriv f 0) (j 0) := by
+      rw [hj0]
+      exact (hf.differentiableAt (ho.mem_nhds h0D)).hasDerivAt
+    have he := (hfAt.comp 0 hjAt).deriv
+    change deriv H 0=1
+    rw [he,hd,mul_inv_cancel₀ hgd]
+  have hHi := disk_selfMap_eq_id_of_deriv_one hHd hHm hH0 hH1
+  intro z hz
+  have hh := hHi (hgb.mapsTo hz)
+  change f (invFunOn g D (g z))=g z at hh
+  rwa [hgb.injOn.leftInvOn_invFunOn hz] at hh
+
+end SLEExactGauge
+
+end
+
+end OAI
diff --git a/lean/OAI/Probability/SLE/Geometry/NormalizedStoppedDisk.lean b/lean/OAI/Probability/SLE/Geometry/NormalizedStoppedDisk.lean
new file mode 100644
index 0000000000000000000000000000000000000000..e7a8b0aa124830c8f2ee37aead64079d43cf6a2b
--- /dev/null
+++ b/lean/OAI/Probability/SLE/Geometry/NormalizedStoppedDisk.lean
@@ -0,0 +1,51 @@
+import OAI.Probability.SLE.Mass.NormalizedDiskCompensator
+
+namespace OAI
+
+/-! Measurable finite-or-terminal evaluation of the canonical disk mass
+on the normalized Brownian time scale. -/
+
+noncomputable section
+open Set Filter _root_.MeasureTheory _root_.OAI.MeasureTheory
+open scoped NNReal ENNReal
+
+namespace SLEExactGauge.Multipoint.CanonicalMass
+
+variable {Ω : Type*} [MeasurableSpace Ω] {P : Measure Ω} {κ : ℝ}
+  {B : ℝ≥0 → Ω → ℝ} {hBm : Measurable (Function.uncurry B)}
+  {γ : Ω → ℝ≥0 → ℂ} {G : Ω → ℝ≥0 → ℂ → ℂ}
+  (C : CanonicalMass P κ B hBm γ G)
+
+lemma normalizedStoppedDisk_measurable
+    (θ : ℝ) (hθ : θ∈Ioo (0:ℝ) Real.pi) (T : Ω → ℝ≥0∞) (hT : Measurable T) :
+    Measurable (fun ω => massAtExtendedTime (fun t => C.normalizedDiskScalar θ hθ t ω)
+      (C.diskTerminalScalar θ hθ ω) (T ω)) := by
+  have hw := compactWeightedMass_measurable (Target.diskMassWeight κ θ hθ)
+    (Target.diskSourceHalfPlane θ) (Target.diskSourceHalfPlane_compact hθ).measurableSet
+  have hm := _root_.OAI.MeasureTheory.IsProgressive.random_time_measurable C.progressive
+    (fun ω => (T ω).toNNReal/κ.toNNReal) (hT.ennreal_toNNReal.div_const _)
+  exact (hw.comp C.rational.terminal_measurable).ite
+    (measurableSet_eq_fun hT measurable_const) (hw.comp hm)
+
+lemma normalizedStoppedDisk_nonneg
+    (θ : ℝ) (hθ : θ∈Ioo (0:ℝ) Real.pi) (T : ℝ≥0∞) (ω : Ω) :
+    0 ≤ massAtExtendedTime (fun t => C.normalizedDiskScalar θ hθ t ω)
+      (C.diskTerminalScalar θ hθ ω) T := by
+  unfold massAtExtendedTime
+  split_ifs <;> exact compactWeightedMass_nonneg _ _ _
+
+lemma normalizedStoppedDisk_le_terminal
+    (hκ : 0<κ) (θ : ℝ) (hθ : θ∈Ioo (0:ℝ) Real.pi) (T : Ω → ℝ≥0∞) :
+    ∀ᵐ ω ∂P, massAtExtendedTime (fun t => C.normalizedDiskScalar θ hθ t ω)
+      (C.diskTerminalScalar θ hθ ω) (T ω) ≤ C.diskTerminalScalar θ hθ ω := by
+  filter_upwards [C.normalizedDiskScalar_paths hκ θ hθ] with ω hp
+  unfold massAtExtendedTime
+  split_ifs
+  · exact le_rfl
+  · exact hp.2.2.2.2 _
+
+end SLEExactGauge.Multipoint.CanonicalMass
+
+end
+
+end OAI
diff --git a/lean/OAI/Probability/SLE/Geometry/OpenBoundaryTrace.lean b/lean/OAI/Probability/SLE/Geometry/OpenBoundaryTrace.lean
new file mode 100644
index 0000000000000000000000000000000000000000..68e174f8e2c4854ae2d3ff0935627171311be1cc
--- /dev/null
+++ b/lean/OAI/Probability/SLE/Geometry/OpenBoundaryTrace.lean
@@ -0,0 +1,65 @@
+import OAI.Probability.SLE.Loewner.RawBoundaryReverseTrace
+
+namespace OAI
+
+/-! The terminal value of a reverse path does not require a derivative
+beyond its interval of definition. A linear continuation supplies the
+unused terminal right derivative without changing the path. -/
+noncomputable section
+open Set Filter Complex
+open scoped Topology NNReal
+
+namespace SLEExactGauge.Target
+
+theorem boundary_reverse_eq_trace_of_open_derivative
+    (b : Driver) (T : ℝ≥0) (hT : 0 < T) (b' : ℝ → ℝ)
+    (hd : ∀ t ∈ Icc 0 (T : ℝ), HasDerivWithinAt (driverValue b)
+      (b' t) (Icc 0 (T : ℝ)) t)
+    {L : ℝ} (hL : 0 ≤ L) (hb : ∀ t ∈ Icc 0 (T : ℝ), |b' t| ≤ L)
+    (q : ℝ → ℂ) (hqc : ContinuousOn q (Icc 0 (T : ℝ)))
+    (hq0 : q 0=(b T : ℂ))
+    (hq : ∀ t ∈ Ioo 0 (T : ℝ), HasDerivWithinAt q
+      (-2/(q t-(driverValue b ((T : ℝ)-t) : ℂ))) (Ici t) t)
+    (hqp : ∀ t ∈ Ioc 0 (T : ℝ), 0 < (q t).im) :
+    q T=trace 1 b T := by
+  let v : ℂ := -2/(q T-(driverValue b 0 : ℂ))
+  let r (t : ℝ) : ℂ := if t ≤ T then q t else q T+(t-T) • v
+  have he (t : ℝ) (ht : t ≤ T) : r t=q t := ite_eq_left ht
+  have hr (t : ℝ) (ht : t ∈ Ioc 0 (T : ℝ)) : HasDerivWithinAt r
+      (-2/(r t-(driverValue b ((T : ℝ)-t) : ℂ))) (Ici t) t := by
+    by_cases htT : t < T
+    · have hevent : r =ᶠ[𝓝[Ici t] t] q := by
+        filter_upwards [mem_nhdsWithin_of_mem_nhds (gt_mem_nhds htT)] with s hs
+        exact he s hs.le
+      rw [he t ht.2]
+      exact (hq t ⟨ht.1,htT⟩).congr_of_eventuallyEq hevent (he t ht.2)
+    · have htEq : t=(T : ℝ) := le_antisymm ht.2 (le_of_not_gt htT)
+      subst t
+      have hevent : r =ᶠ[𝓝[Ici (T : ℝ)] (T : ℝ)]
+          (fun s : ℝ => q T+(s-T) • v) := by
+        filter_upwards [self_mem_nhdsWithin] with s hs
+        by_cases hsT : s ≤ T
+        · have heq : s=(T : ℝ) := le_antisymm hsT hs
+          subst s
+          simp [r]
+        · exact ite_eq_right hsT
+      have hh : HasDerivWithinAt (fun s : ℝ => q T+(s-T) • v) v (Ici (T : ℝ)) T := by
+        convert! ((((hasDerivAt_id (T : ℝ)).sub_const (T : ℝ)).smul_const v).const_add
+          (q T)).hasDerivWithinAt using 1
+        simp only [one_smul]
+      have hh' := hh.congr_of_eventuallyEq hevent (by simp [r])
+      simpa only [he (T : ℝ) le_rfl,sub_self,v] using hh'
+  have hrc : ContinuousOn r (Icc 0 (T : ℝ)) := by
+    apply hqc.congr
+    intro t ht
+    exact he t ht.2
+  have hz : r 0=(b T : ℂ) := (he 0 T.coe_nonneg).trans hq0
+  have hh := boundary_reverse_eq_trace b T hT b' hd hL hb r hrc hz hr
+    (fun t ht => by rw [he t ht.2]; exact hqp t ht)
+  simpa only [he (T : ℝ) le_rfl] using hh
+
+end SLEExactGauge.Target
+
+end
+
+end OAI
diff --git a/lean/OAI/Probability/SLE/Geometry/OuterCoefficientLimit.lean b/lean/OAI/Probability/SLE/Geometry/OuterCoefficientLimit.lean
new file mode 100644
index 0000000000000000000000000000000000000000..ceed89fa64bc496275aa495a69056fb88bbd355c
--- /dev/null
+++ b/lean/OAI/Probability/SLE/Geometry/OuterCoefficientLimit.lean
@@ -0,0 +1,103 @@
+import OAI.Probability.SLE.Stochastic.WienerCoefficientLimit
+import OAI.Probability.SLE.Loewner.TargetOuterMeasurability
+
+namespace OAI
+
+/-! The bounded clipping permits the mesh limit to pass through the exact
+invariant-angle integral without an estimate uniform in the angle. -/
+
+noncomputable section
+open Set Filter _root_.MeasureTheory _root_.OAI.MeasureTheory ProbabilityTheory
+open scoped Topology NNReal ENNReal
+
+namespace SLEExactGauge.Target
+
+def clippedCoefficient (κ : ℝ) (W : WienerLaw) (ℓ u : ℝ) (k : ℕ) (θ : ℝ) : ℝ :=
+  limUnder atTop (fun n : ℕ => ∫ b, levelDensity κ θ b ℓ *
+    (clip u (discreteMass κ θ W b ℓ n))^k ∂W)
+
+end SLEExactGauge.Target
+
+namespace SLEExactGauge.Multipoint.CanonicalMass
+
+variable {Ω : Type*} [mΩ : MeasurableSpace Ω] {P : Measure Ω}
+  [IsProbabilityMeasure P] {κ : ℝ}
+  {B : ℝ≥0 → Ω → ℝ} {hBm : Measurable (Function.uncurry B)}
+  {γ : Ω → ℝ≥0 → ℂ} {G : Ω → ℝ≥0 → ℂ → ℂ}
+  (C : CanonicalMass P κ B hBm γ G)
+
+include C in
+theorem clippedCoefficient_tendsto
+    (hB : IsBrownianReal B P) (hκ : 0<κ) (hκ8 : κ<8)
+    (hc : ∀ ω, Continuous (fun t => B t ω)) (h0 : ∀ ω, B 0 ω=0)
+    (F : Ω → ℝ≥0 → ℂ → ℂ)
+    (hw : ∀ ω, IsCapacityTwoWitness (fun t => Real.sqrt κ*B t ω) (γ ω) (G ω) (F ω))
+    (W : Target.WienerLaw) (hW : Target.IsWiener W)
+    (θ : ℝ) (hθ : θ ∈ Ioo (0:ℝ) Real.pi) (ℓ : ℝ) (hℓ : 0 ≤ ℓ)
+    (u : ℝ) (hu : 0 ≤ u) (k : ℕ) :
+    Tendsto (fun n => ∫ b, Target.levelDensity κ θ b ℓ *
+      (Target.clip u (Target.discreteMass κ θ W b ℓ n))^k ∂W) atTop
+      (𝓝 (Target.clippedCoefficient κ W ℓ u k θ)) := by
+  have h := C.wiener_clipped_coefficient_limit hB hκ hκ8 hc h0 F hw W hW θ hθ ℓ hℓ u hu k
+  simpa only [Target.clippedCoefficient,h.limUnder_eq] using h
+
+theorem clippedCoefficient_eq_mass
+    (hB : IsBrownianReal B P) (hκ : 0<κ) (hκ8 : κ<8)
+    (hc : ∀ ω, Continuous (fun t => B t ω)) (h0 : ∀ ω, B 0 ω=0)
+    (F : Ω → ℝ≥0 → ℂ → ℂ)
+    (hw : ∀ ω, IsCapacityTwoWitness (fun t => Real.sqrt κ*B t ω) (γ ω) (G ω) (F ω))
+    (W : Target.WienerLaw) (hW : Target.IsWiener W)
+    (θ : ℝ) (hθ : θ ∈ Ioo (0:ℝ) Real.pi) (ℓ : ℝ) (hℓ : 0 ≤ ℓ)
+    (u : ℝ) (hu : 0 ≤ u) (k : ℕ) :
+    Target.clippedCoefficient κ W ℓ u k θ =
+      ∫ ω, Target.levelDensity κ θ (Target.normalizedDriver κ B hc h0 ω) ℓ *
+        (Target.clip u (massAtExtendedTime (fun t => C.normalizedDiskScalar θ hθ t ω)
+          (C.diskTerminalScalar θ hθ ω)
+          (Target.levelTime κ θ (Target.normalizedDriver κ B hc h0 ω) ℓ)))^k ∂P :=
+  (C.wiener_clipped_coefficient_limit hB hκ hκ8 hc h0 F hw W hW θ hθ ℓ hℓ u hu k).limUnder_eq
+
+include C in
+theorem outer_clipped_coefficient_limit
+    (hB : IsBrownianReal B P) (hκ : 0<κ) (hκ8 : κ<8)
+    (hc : ∀ ω, Continuous (fun t => B t ω)) (h0 : ∀ ω, B 0 ω=0)
+    (F : Ω → ℝ≥0 → ℂ → ℂ)
+    (hw : ∀ ω, IsCapacityTwoWitness (fun t => Real.sqrt κ*B t ω) (γ ω) (G ω) (F ω))
+    (W : Target.WienerLaw) (hW : Target.IsWiener W)
+    (ℓ : ℝ) (hℓ : 0 ≤ ℓ) (u : ℝ) (hu : 0 ≤ u) (k : ℕ) :
+    Tendsto (fun n => ∫ θ, ∫ b, Target.levelDensity κ θ b ℓ *
+      (Target.clip u (Target.discreteMass κ θ W b ℓ n))^k ∂W ∂Target.angleLaw κ) atTop
+      (𝓝 (∫ θ, Target.clippedCoefficient κ W ℓ u k θ ∂Target.angleLaw κ)) := by
+  let : IsProbabilityMeasure W := hW.isGaussianProcess.isProbabilityMeasure
+  let : IsProbabilityMeasure (Target.angleLaw κ) := Target.angleLaw_isProbability hκ
+  apply tendsto_integral_of_dominated_convergence (fun _ => u^k)
+  · intro n
+    exact (Target.aemeasurable_coefficient_integrand κ ℓ u W n k).aestronglyMeasurable.integral_prod_right'
+  · exact integrable_const _
+  · intro n
+    filter_upwards [Target.angleLaw_ae_mem κ] with θ hθ
+    have hb := wiener_clipped_coefficient_bound (hBm := hBm) hB hκ hκ8 hc h0 F hw W hW θ hθ ℓ hℓ u hu n k
+    rw [Real.norm_of_nonneg hb.1]
+    exact hb.2
+  · filter_upwards [Target.angleLaw_ae_mem κ] with θ hθ
+    exact C.clippedCoefficient_tendsto hB hκ hκ8 hc h0 F hw W hW θ hθ ℓ hℓ u hu k
+
+include C in
+theorem finiteMoment_eq_outer_clipped_limit
+    (hB : IsBrownianReal B P) (hκ : 0<κ) (hκ8 : κ<8)
+    (hc : ∀ ω, Continuous (fun t => B t ω)) (h0 : ∀ ω, B 0 ω=0)
+    (F : Ω → ℝ≥0 → ℂ → ℂ)
+    (hw : ∀ ω, IsCapacityTwoWitness (fun t => Real.sqrt κ*B t ω) (γ ω) (G ω) (F ω))
+    (W : Target.WienerLaw) (hW : Target.IsWiener W) (ℓ : ℝ) (hℓ : 0 ≤ ℓ) (k : ℕ) :
+    Target.finiteMoment κ W k ℓ = limUnder atTop (fun u : ℕ =>
+      ∫ θ, Target.clippedCoefficient κ W ℓ u k θ ∂Target.angleLaw κ) := by
+  unfold Target.finiteMoment
+  congr 1
+  funext u
+  exact (C.outer_clipped_coefficient_limit hB hκ hκ8 hc h0 F hw W hW ℓ hℓ u
+    (Nat.cast_nonneg u) k).limUnder_eq
+
+end SLEExactGauge.Multipoint.CanonicalMass
+
+end
+
+end OAI
diff --git a/lean/OAI/Probability/SLE/Geometry/OutwardRealBarrier.lean b/lean/OAI/Probability/SLE/Geometry/OutwardRealBarrier.lean
new file mode 100644
index 0000000000000000000000000000000000000000..513e0b2be685de82339093f31e37dd7094bc3c09
--- /dev/null
+++ b/lean/OAI/Probability/SLE/Geometry/OutwardRealBarrier.lean
@@ -0,0 +1,50 @@
+import Mathlib
+
+namespace OAI
+
+/-! A forward Loewner real coordinate outside the driver range moves
+outward. This elementary barrier also applies before a finite lifetime. -/
+noncomputable section
+open Set
+
+namespace SLEExactGauge
+
+lemma outward_real_barrier {a b c : ℝ} (X u D : ℝ → ℝ)
+    (hX : ContinuousOn X (Icc a b))
+    (hd : ∀ t ∈ Ico a b, HasDerivWithinAt X (2*(X t-u t)/D t) (Ici t) t)
+    (hD : ∀ t ∈ Ico a b, 0 < D t)
+    (hu : ∀ t ∈ Ico a b, u t ≤ c) (hc : c < X a) :
+    ∀ t ∈ Icc a b, X a ≤ X t := by
+  have hh := image_le_of_deriv_right_lt_deriv_boundary hX.neg
+    (fun t ht => (hd t ht).neg) (B := fun _ => -X a) (B' := fun _ => 0) le_rfl
+    (fun t => hasDerivAt_const t (-X a)) (fun t ht he => ?_)
+  · intro t ht
+    have h := hh ht
+    change -X t ≤ -X a at h
+    linarith
+  · change -X t = -X a at he
+    have hval : X t=X a := by linarith
+    have hp : 0 < X t-u t := by rw [hval]; linarith [hu t ht]
+    exact neg_neg_of_pos (div_pos (mul_pos (by norm_num) hp) (hD t ht))
+
+lemma inward_negative_real_barrier {a b c : ℝ} (X u D : ℝ → ℝ)
+    (hX : ContinuousOn X (Icc a b))
+    (hd : ∀ t ∈ Ico a b, HasDerivWithinAt X (2*(X t-u t)/D t) (Ici t) t)
+    (hD : ∀ t ∈ Ico a b, 0 < D t)
+    (hu : ∀ t ∈ Ico a b, c ≤ u t) (hc : X a < c) :
+    ∀ t ∈ Icc a b, X t ≤ X a := by
+  have hd' (t : ℝ) (ht : t ∈ Ico a b) :
+      HasDerivWithinAt (fun s => -X s) (2*((-X t)-(-u t))/D t) (Ici t) t := by
+    convert! (hd t ht).neg using 1
+    ring
+  have hh := outward_real_barrier (fun t => -X t) (fun t => -u t) D hX.neg hd' hD
+    (fun t ht => neg_le_neg (hu t ht)) (neg_lt_neg hc)
+  intro t ht
+  have h := hh t ht
+  linarith
+
+end SLEExactGauge
+
+end
+
+end OAI
diff --git a/lean/OAI/Probability/SLE/Geometry/PastDensityIntegral.lean b/lean/OAI/Probability/SLE/Geometry/PastDensityIntegral.lean
new file mode 100644
index 0000000000000000000000000000000000000000..1100a095a111f95f72023233a97d35a04f6870e3
--- /dev/null
+++ b/lean/OAI/Probability/SLE/Geometry/PastDensityIntegral.lean
@@ -0,0 +1,38 @@
+import OAI.Probability.SLE.Geometry.FiniteStoppedScalar
+
+namespace OAI
+
+/-! Equality of densities on stopped-past events also identifies every
+nonnegative measurable test of that same past. -/
+noncomputable section
+open Set _root_.MeasureTheory _root_.OAI.MeasureTheory
+open scoped ENNReal
+
+namespace SLEExactGauge
+
+lemma past_density_test_integral
+    {Ω : Type*} [mΩ : MeasurableSpace Ω] (P Q : Measure Ω)
+    (m : MeasurableSpace Ω) (hm : m ≤ mΩ)
+    (M : Ω → ℝ≥0∞) (hM : Measurable[m] M) (E : Set Ω) (hE : MeasurableSet[m] E)
+    (hmean : ∀ A : Set Ω, MeasurableSet[m] A → (∫⁻ ω in A∩E, M ω ∂P)=Q (A∩E))
+    (f : Ω → ℝ≥0∞) (hf : Measurable[m] f)
+    (A : Set Ω) (hA : MeasurableSet[m] A) :
+    (∫⁻ ω in A∩E, M ω*f ω ∂P)=(∫⁻ ω in A∩E, f ω ∂Q) := by
+  have heq (D : Set Ω) (hD : MeasurableSet[m] D) :
+      ((P.withDensity M).restrict E) D=(Q.restrict E) D := by
+    rw [Measure.restrict_apply (hm _ hD),Measure.restrict_apply (hm _ hD),
+      withDensity_apply _ (hm _ (hD.inter hE))]
+    exact hmean D hD
+  have hh := @lintegral_eq_of_stopped_events Ω mΩ ((P.withDensity M).restrict E) (Q.restrict E)
+    m hm heq (A.indicator f) (hf.indicator hA)
+  rw [lintegral_indicator (hm _ hA),lintegral_indicator (hm _ hA),
+    Measure.restrict_restrict (hm _ hA),Measure.restrict_restrict (hm _ hA),
+    setLIntegral_withDensity_eq_setLIntegral_mul P (hM.mono hm le_rfl)
+      (hf.mono hm le_rfl) (hm _ (hA.inter hE))] at hh
+  exact hh
+
+end SLEExactGauge
+
+end
+
+end OAI
diff --git a/lean/OAI/Probability/SLE/Geometry/PhysicalCellDisk.lean b/lean/OAI/Probability/SLE/Geometry/PhysicalCellDisk.lean
new file mode 100644
index 0000000000000000000000000000000000000000..52d9053f6846684d91a5fe173bd07293ef01908f
--- /dev/null
+++ b/lean/OAI/Probability/SLE/Geometry/PhysicalCellDisk.lean
@@ -0,0 +1,55 @@
+import OAI.Probability.SLE.Geometry.DiskQuarterGeometry
+import OAI.Probability.SLE.Multipoint.MultipointPhysicalGeometry
+
+namespace OAI
+
+/-! Physical quarter-disk charts at actual surviving Loewner points. -/
+
+noncomputable section
+open Set Filter Metric Complex
+open scoped Topology NNReal
+
+namespace SLEExactGauge
+
+lemma IsCapacityTwoWitness.quarter_disk_chart_bounds
+    {U : ℝ≥0 → ℝ} {γ : ℝ≥0 → ℂ} {G F : ℝ≥0 → ℂ → ℂ}
+    (hw : IsCapacityTwoWitness U γ G F) (hgrowth : PublishedDiskUnivalentGrowth)
+    (t : ℝ≥0) (z : ℂ) (hz : z ∈ survivingDomain γ t)
+    (hR : 0 < fullRadius G t z) :
+    let f := physicalDiskChart id F G t z
+    IsCompact (f '' closedBall 0 (1/4)) ∧
+    closedBall z (fullRadius G t z / (1024 * Real.pi)) ⊆ f '' closedBall 0 (1/4) ∧
+    f '' closedBall 0 (1/4) ⊆ closedBall z (2*fullRadius G t z) ∧
+    f '' closedBall 0 (1/4) ⊆ survivingDomain γ t ∧
+    ∀ w ∈ closedBall (0:ℂ) (1/4), ‖deriv f w‖ ≤ 16*fullRadius G t z := by
+  let f := physicalDiskChart id F G t z
+  obtain ⟨hd,hi,hzero,hder,_⟩ := hw.physical_disk_chart id differentiableOn_id
+    (fun _ _ _ _ h => h) t z hz
+  change DifferentiableOn ℂ f (ball 0 1) at hd
+  change InjOn f (ball 0 1) at hi
+  change f 0=z at hzero
+  have hder' : ‖deriv f 0‖ = fullRadius G t z := by
+    change ‖deriv f 0‖ = physicalConformalRadius id G t z at hder
+    simpa [physicalConformalRadius] using hder
+  have hsub : closedBall (0:ℂ) (1/4) ⊆ ball 0 1 := by
+    intro w hw
+    have hh : ‖w‖ ≤ 1/4 := by simpa only [mem_closedBall,dist_zero_right] using hw
+    apply mem_ball_zero_iff.mpr
+    linarith
+  refine ⟨(isCompact_closedBall _ _).image_of_continuousOn (hd.continuousOn.mono hsub),?_,?_,?_,?_⟩
+  · simpa only [hzero,hder'] using univalent_quarter_closed_image_contains hd hi (hder' ▸ hR)
+  · simpa only [hzero,hder'] using univalent_quarter_closed_image_bound hgrowth hd hi
+  · rintro _ ⟨w,hw',rfl⟩
+    have hgw : 0 < (G t z).im := hw.imag_positive t z hz
+    have hmap := diskToHalfPlane_maps hgw (hsub hw')
+    rcases hw with ⟨_,_,_,_,_,_,hFmap,_,_,_,_,_,_⟩
+    exact hFmap t hmap
+  · intro w hw'
+    have hn : ‖w‖ ≤ 1/4 := by simpa only [mem_closedBall,dist_zero_right] using hw'
+    simpa only [hder'] using univalent_quarter_derivative_upper hgrowth hd hi hn
+
+end SLEExactGauge
+
+end
+
+end OAI
diff --git a/lean/OAI/Probability/SLE/Geometry/PhysicalCenteredWeights.lean b/lean/OAI/Probability/SLE/Geometry/PhysicalCenteredWeights.lean
new file mode 100644
index 0000000000000000000000000000000000000000..e204b8d1951bc24aead70e033becb56903e82004
--- /dev/null
+++ b/lean/OAI/Probability/SLE/Geometry/PhysicalCenteredWeights.lean
@@ -0,0 +1,142 @@
+import OAI.Probability.SLE.Multipoint.MultipointCenteredWeights
+import OAI.Probability.SLE.Angle.TargetDiskRadius
+
+namespace OAI
+
+/-! The fixed-center product estimate in physical conformal coordinates.
+Derivative factors are retained so that area transport cancels them in
+the disk moment integral, including near the endpoint angles. -/
+
+noncomputable section
+open Set Filter MeasureTheory ProbabilityTheory
+open scoped NNReal ENNReal
+
+namespace SLEExactGauge.Multipoint
+
+lemma physical_stoppedGreen_level_bound
+    {U : ℝ≥0 → ℝ} {γ : ℝ≥0 → ℂ} {G F : ℝ≥0 → ℂ → ℂ}
+    (hU : Continuous U) (hw : IsCapacityTwoWitness U γ G F)
+    {κ : ℝ} (hκ : 0<κ) (hκ8 : κ<8) (z : ℂ) (hz : z ∈ upperHalfPlane)
+    (D : ℝ) (hD : 0<D) (e : ℝ) (he : 0<e) :
+    D^(-codimension κ) * stoppedGreen κ U γ G z (Real.log (2*z.im*D/e)) ≤
+      e^(-codimension κ) := by
+  have hh := stoppedGreen_level_bound hU hw hκ hκ8 z hz (e/D) (div_pos he hD)
+  have heq : 2*z.im/(e/D)=2*z.im*D/e := by field_simp
+  rw [heq] at hh
+  apply (mul_le_mul_of_nonneg_left hh (Real.rpow_nonneg hD.le _)).trans_eq
+  rw [Real.div_rpow he.le hD.le]
+  field_simp [(Real.rpow_pos_of_pos hD (-codimension κ)).ne']
+
+lemma centered_target_weights_capped
+    (κ : ℝ) (m : ℕ) (b e : Fin (m+1) → ℝ)
+    (hb : ∀ i, 0<b i) (he : ∀ i, 0<e i) :
+    (∏ i : Fin m, (e i.succ)^(-codimension κ)) *
+        (∏ i, min 1 ((e i/b i)^(1-κ/8))) ≤
+      (e 0)^(codimension κ) * ∏ i, (b i)^(-codimension κ) := by
+  have hα : codimension κ=1-κ/8 := by unfold codimension dimension; ring
+  rw [← hα,Fin.prod_univ_succ]
+  have hroot : min 1 ((e 0/b 0)^codimension κ) ≤
+      (e 0)^codimension κ*(b 0)^(-codimension κ) := by
+    rw [Real.rpow_neg (hb 0).le,← div_eq_mul_inv,← Real.div_rpow (he 0).le (hb 0).le]
+    exact min_le_right _ _
+  have htail : (∏ i : Fin m, (e i.succ)^(-codimension κ)) *
+      (∏ i : Fin m, min 1 ((e i.succ/b i.succ)^codimension κ)) ≤
+      ∏ i : Fin m, (b i.succ)^(-codimension κ) := by
+    rw [← Finset.prod_mul_distrib]
+    apply Finset.prod_le_prod₀
+    · intro i _
+      exact mul_nonneg (Real.rpow_nonneg (he i.succ).le _)
+        (le_min zero_le_one (Real.rpow_nonneg (div_nonneg (he i.succ).le (hb i.succ).le) _))
+    · exact fun i _ => target_weight_capped (hb i.succ) (he i.succ)
+  calc
+    _ = min 1 ((e 0/b 0)^codimension κ) *
+        ((∏ i : Fin m, (e i.succ)^(-codimension κ)) *
+          ∏ i : Fin m, min 1 ((e i.succ/b i.succ)^codimension κ)) := by ring
+    _ ≤ ((e 0)^codimension κ*(b 0)^(-codimension κ)) *
+        ∏ i : Fin m, (b i.succ)^(-codimension κ) :=
+      mul_le_mul hroot htail
+        (mul_nonneg (Finset.prod_nonneg (fun i _ => Real.rpow_nonneg (he i.succ).le _))
+          (Finset.prod_nonneg (fun i _ =>
+            le_min zero_le_one (Real.rpow_nonneg (div_nonneg (he i.succ).le (hb i.succ).le) _))))
+        (mul_nonneg (Real.rpow_nonneg (he 0).le _) (Real.rpow_nonneg (hb 0).le _))
+    _ = _ := by rw [Fin.prod_univ_succ]; ring
+
+theorem physical_stoppedGreen_centered_product_bound
+    {Ω : Type*} [mΩ : MeasurableSpace Ω]
+    {P : Measure Ω} {B : ℝ≥0 → Ω → ℝ} (hB : IsBrownianReal B P)
+    (hm : ∀ t, Measurable (B t)) (hBm : Measurable (Function.uncurry B))
+    (hc : ∀ ω, Continuous (fun t => B t ω)) (h0 : ∀ ω, B 0 ω=0)
+    {κ : ℝ} (hκ : 0<κ) (hκ8 : κ<8)
+    (γ : Ω → ℝ≥0 → ℂ) (G F : Ω → ℝ≥0 → ℂ → ℂ)
+    (hw : ∀ ω, IsCapacityTwoWitness (fun t => Real.sqrt κ*B t ω) (γ ω) (G ω) (F ω))
+    (hgrowth : PublishedDiskUnivalentGrowth)
+    (J : ℂ → ℂ) (hJ : DifferentiableOn ℂ J upperHalfPlane) (hJinj : InjOn J upperHalfPlane)
+    (m : ℕ) (z : Fin (m+1) → ℂ) (hz : ∀ i, z i ∈ upperHalfPlane)
+    (hne : Function.Injective z) (b e : Fin (m+1) → ℝ)
+    (he : ∀ i, 0<e i) (hb : ∀ i, 0<b i)
+    (hbR : ∀ i, b i ≤ 2*(z i).im*‖deriv J (z i)‖)
+    (hsep : ∀ i j, i≠j → b i ≤ dist (J (z i)) (J (z j))) :
+    (∫⁻ ω, {ω | ∃ t : ℝ≥0, z 0 ∈ survivingDomain (γ ω) t ∧
+        physicalConformalRadius J (G ω) t (z 0) ≤ e 0}.indicator
+      (fun ω => ENNReal.ofReal (∏ i : Fin m,
+        ‖deriv J (z i.succ)‖^(-codimension κ) *
+          stoppedGreen κ (fun t => Real.sqrt κ*B t ω) (γ ω) (G ω) (z i.succ)
+            (Real.log (2*(z i.succ).im*‖deriv J (z i.succ)‖/e i.succ)))) ω ∂P) ≤
+      ENNReal.ofReal (multipointConstant κ (m+1) *
+        (e 0)^(codimension κ) * ∏ i, (b i)^(-codimension κ)) := by
+  classical
+  let R := fun i => 2*(z i).im*‖deriv J (z i)‖
+  have hR (i) : 0<R i := (hb i).trans_le (hbR i)
+  have hD (i) : 0<‖deriv J (z i)‖ :=
+    pos_of_mul_pos_right (hR i) (mul_nonneg (by norm_num) (hz i).le)
+  let E₀ := {ω | ∃ t : ℝ≥0, z 0 ∈ survivingDomain (γ ω) t ∧
+    physicalConformalRadius J (G ω) t (z 0) ≤ e 0}
+  let E := {ω | ω ∈ E₀ ∧ ∀ i : Fin m,
+    radiusLevelTime (γ ω) (G ω) (z i.succ) (Real.log (R i.succ/e i.succ))<∞}
+  let Y := fun (i : Fin m) ω => ‖deriv J (z i.succ)‖^(-codimension κ) *
+    stoppedGreen κ (fun t => Real.sqrt κ*B t ω) (γ ω) (G ω) (z i.succ)
+      (Real.log (R i.succ/e i.succ))
+  let c := ∏ i : Fin m, (e i.succ)^(-codimension κ)
+  have hc0 : 0 ≤ c := Finset.prod_nonneg (fun i _ => Real.rpow_nonneg (he i.succ).le _)
+  have hM : 0 ≤ multipointConstant κ (m+1) := (multipointConstant_pos _ _).le
+  have hint := lintegral_indicator_ofReal_prod_le_event P E₀ E Y
+    (fun i => (e i.succ)^(-codimension κ))
+    (fun i ω => mul_nonneg (Real.rpow_nonneg (norm_nonneg _) _)
+      (stoppedGreen_nonneg (hw ω) κ _ _))
+    (fun ω _ i => physical_stoppedGreen_level_bound ((hc ω).const_mul _) (hw ω)
+      hκ hκ8 _ (hz i.succ) _ (hD i.succ) _ (he i.succ)) (fun ω hω hn => by
+      have hn' : ¬∀ i : Fin m,
+          radiusLevelTime (γ ω) (G ω) (z i.succ) (Real.log (R i.succ/e i.succ))<∞ :=
+        fun hi => hn ⟨hω,hi⟩
+      obtain ⟨i,hi⟩ := not_forall.mp hn'
+      exact ⟨i,by simp only [Y,stoppedGreen,ite_eq_right hi,mul_zero]⟩)
+  have hprob := capped_physical_radius_multipoint_bound hB hm hBm hc h0 hκ hκ8
+    γ G F hw hgrowth J hJ hJinj z hz hne R b e he hb hbR (fun _ => rfl) hsep
+  have hsub : E ⊆ {ω | ∀ i, ∃ t : ℝ≥0, z i ∈ survivingDomain (γ ω) t ∧
+      physicalConformalRadius J (G ω) t (z i) ≤ e i} := by
+    intro ω hω
+    refine Fin.cases hω.1 (fun i => ?_)
+    obtain ⟨t,ht,hRt⟩ := (physical_radius_eq_hit_iff_finite_level
+      ((hc ω).const_mul _) (hw ω) J (z i.succ) (R i.succ) (e i.succ)
+      (hR i.succ) (he i.succ) rfl).mpr (hω.2 i)
+    exact ⟨t,ht,hRt.le⟩
+  calc
+    _ ≤ ENNReal.ofReal c * P E := hint
+    _ ≤ ENNReal.ofReal c * ENNReal.ofReal
+        (multipointConstant κ (m+1) * ∏ i, min 1 ((e i/b i)^(1-κ/8))) :=
+      mul_le_mul' le_rfl ((measure_mono hsub).trans
+        (by simpa only [multipointConstant,Fintype.card_fin] using hprob))
+    _ = ENNReal.ofReal (multipointConstant κ (m+1) *
+        (c * ∏ i, min 1 ((e i/b i)^(1-κ/8)))) := by
+      rw [← ENNReal.ofReal_mul hc0]
+      congr 1
+      ring
+    _ ≤ _ := ENNReal.ofReal_le_ofReal (by
+      simpa only [c,mul_assoc] using
+        mul_le_mul_of_nonneg_left (centered_target_weights_capped κ m b e hb he) hM)
+
+end SLEExactGauge.Multipoint
+
+end
+
+end OAI
diff --git a/lean/OAI/Probability/SLE/Geometry/PhysicalGuideCompactness.lean b/lean/OAI/Probability/SLE/Geometry/PhysicalGuideCompactness.lean
new file mode 100644
index 0000000000000000000000000000000000000000..2e7b93898d53564496c9ca2d0aecb4e86f86c670
--- /dev/null
+++ b/lean/OAI/Probability/SLE/Geometry/PhysicalGuideCompactness.lean
@@ -0,0 +1,113 @@
+import OAI.Probability.SLE.Geometry.GuideLimitIdentification
+import Mathlib.Topology.ContinuousMap.Bounded.ArzelaAscoli
+
+namespace OAI
+
+/-!
+Uniform subsequence compactness for the physical guide curves. A common speed
+bound and bounded starting points put the entire family in one compact disk;
+Arzelà–Ascoli then gives a uniformly convergent subsequence on the fixed interval.
+-/
+
+noncomputable section
+open Set Filter Metric
+open scoped Topology NNReal BoundedContinuousFunction
+
+namespace SLEExactGauge.PhysicalGuideCompactness
+
+/-- A common Lipschitz bound and bounded tips suffice for uniform subsequence
+compactness of the physical guides. The limit retains the same speed bound. -/
+theorem exists_uniform_subsequence
+    (αₙ : ℕ → ℝ → ℂ) {T R : ℝ} (hT : 0 ≤ T) (C : ℝ≥0)
+    (hL : ∀ n, LipschitzOnWith C (αₙ n) (Icc 0 T))
+    (htip : ∀ n, ‖αₙ n 0‖ ≤ R) :
+    ∃ α : ℝ → ℂ, ∃ φ : ℕ → ℕ, StrictMono φ ∧
+      TendstoUniformlyOn (fun n => αₙ (φ n)) α atTop (Icc 0 T) ∧
+      LipschitzOnWith C α (Icc 0 T) ∧ ContinuousOn α (Icc 0 T) ∧ ‖α 0‖ ≤ R := by
+  classical
+  let I := Icc (0 : ℝ) T
+  have : CompactSpace I := isCompact_iff_compactSpace.mp isCompact_Icc
+  let f : ℕ → I →ᵇ ℂ := fun n => BoundedContinuousFunction.mkOfCompact
+    ⟨I.domRestrict (αₙ n), (hL n).continuousOn.domRestrict⟩
+  have hfL : ∀ n, LipschitzWith C (f n) := fun n => (hL n).to_restrict
+  have hbound n (t : I) : ‖f n t‖ ≤ R + C * T := by
+    have hd := (hL n).dist_le_mul t t.property 0 (show 0 ∈ I from ⟨le_rfl, hT⟩)
+    rw [Real.dist_eq, sub_zero, abs_of_nonneg t.property.1] at hd
+    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 t.property.2 C.coe_nonneg))
+  have heq : Equicontinuous ((↑) : Set.range f → I → ℂ) := by
+    apply (LipschitzWith.uniformEquicontinuous _ C ?_).equicontinuous
+    rintro ⟨g, n, rfl⟩
+    exact hfL n
+  have hcompact : IsCompact (closure (Set.range f)) :=
+    BoundedContinuousFunction.arzela_ascoli (closedBall (0 : ℂ) (R + C * T))
+      (isCompact_closedBall _ _) (Set.range f)
+      (by rintro g t ⟨n, rfl⟩; simpa only [mem_closedBall, dist_zero_right] using hbound n t)
+      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 α : ℝ → ℂ := fun t => if ht : t ∈ I then b ⟨t, ht⟩ else 0
+  have hu : TendstoUniformlyOn (fun n => αₙ (φ n)) α atTop I := by
+    apply Metric.tendstoUniformlyOn_iff.mpr
+    intro ε hε
+    filter_upwards [Metric.tendstoUniformly_iff.mp hb ε hε] with n hn
+    intro t ht
+    simpa [α, f, ht] using hn ⟨t, ht⟩
+  have hαL : LipschitzOnWith C α I := by
+    apply lipschitzOnWith_iff_dist_le_mul.mpr
+    intro s hs t ht
+    exact le_of_tendsto ((hu.tendsto_at hs).dist (hu.tendsto_at ht))
+      (Eventually.of_forall fun n => (hL (φ n)).dist_le_mul s hs t ht)
+  have hα0 : ‖α 0‖ ≤ R := le_of_tendsto
+    (hu.tendsto_at (show 0 ∈ I from ⟨le_rfl, hT⟩)).norm
+    (Eventually.of_forall fun n => htip (φ n))
+  exact ⟨α, φ, hφ, hu, hαL, hαL.continuousOn, hα0⟩
+
+/-- The fixed lower chord bound of a guide patch passes to its uniform limit. -/
+theorem lower_chord_bound_of_uniform_limit
+    {αₙ : ℕ → ℝ → ℂ} {α : ℝ → ℂ} {I : Set ℝ} {c : ℝ}
+    (hu : TendstoUniformlyOn αₙ α atTop I)
+    (hchord : ∀ n s, s ∈ I → ∀ t, t ∈ I →
+      c * |s - t| ≤ dist (αₙ n s) (αₙ n t)) :
+    ∀ s ∈ I, ∀ t ∈ I, c * |s - t| ≤ dist (α s) (α t) := by
+  intro s hs t ht
+  exact ge_of_tendsto ((hu.tendsto_at hs).dist (hu.tendsto_at ht))
+    (Eventually.of_forall fun n => hchord n s hs t ht)
+
+/-- Positive lower chord bounds force a guide to be simple. -/
+theorem injective_of_lower_chord_bound
+    {α : ℝ → ℂ} {I : Set ℝ} {c : ℝ} (hc : 0 < c)
+    (hchord : ∀ s ∈ I, ∀ t ∈ I, c * |s - t| ≤ dist (α s) (α t)) :
+    InjOn α I := by
+  intro s hs t ht he
+  have hh := hchord s hs t ht
+  rw [he, dist_self] at hh
+  have ha : |s - t| = 0 := by nlinarith [abs_nonneg (s - t)]
+  exact sub_eq_zero.mp (abs_eq_zero.mp ha)
+
+/-- Bi-Lipschitz physical guide patches have simple, uniformly convergent
+subsequential limits with the same two chord constants. -/
+theorem exists_simple_uniform_subsequence
+    (αₙ : ℕ → ℝ → ℂ) {T R c : ℝ} (hT : 0 ≤ T) (C : ℝ≥0) (hc : 0 < c)
+    (hL : ∀ n, LipschitzOnWith C (αₙ n) (Icc 0 T))
+    (htip : ∀ n, ‖αₙ n 0‖ ≤ R)
+    (hchord : ∀ n s, s ∈ Icc 0 T → ∀ t, t ∈ Icc 0 T →
+      c * |s - t| ≤ dist (αₙ n s) (αₙ n t)) :
+    ∃ α : ℝ → ℂ, ∃ φ : ℕ → ℕ, StrictMono φ ∧
+      TendstoUniformlyOn (fun n => αₙ (φ n)) α atTop (Icc 0 T) ∧
+      LipschitzOnWith C α (Icc 0 T) ∧ ContinuousOn α (Icc 0 T) ∧ ‖α 0‖ ≤ R ∧
+      (∀ s ∈ Icc 0 T, ∀ t ∈ Icc 0 T, c * |s - t| ≤ dist (α s) (α t)) ∧
+      InjOn α (Icc 0 T) := by
+  obtain ⟨α, φ, hφ, hu, hLα, hcont, htipα⟩ :=
+    exists_uniform_subsequence αₙ hT C hL htip
+  have hchordα := lower_chord_bound_of_uniform_limit hu (fun n => hchord (φ n))
+  exact ⟨α, φ, hφ, hu, hLα, hcont, htipα, hchordα,
+    injective_of_lower_chord_bound hc hchordα⟩
+
+end SLEExactGauge.PhysicalGuideCompactness
+
+end
+
+end OAI
diff --git a/lean/OAI/Probability/SLE/Geometry/PhysicalRouteProbability.lean b/lean/OAI/Probability/SLE/Geometry/PhysicalRouteProbability.lean
new file mode 100644
index 0000000000000000000000000000000000000000..d7b5632c2476b42052d76c9d07c2156cc314b785
--- /dev/null
+++ b/lean/OAI/Probability/SLE/Geometry/PhysicalRouteProbability.lean
@@ -0,0 +1,69 @@
+import OAI.Probability.SLE.Geometry.WaypointRouteProbability
+
+namespace OAI
+
+/-! A uniform positive tube probability for any fixed-speed physical
+route on the finite exit window. It is a consequence of the cited planar
+Wiener support input and compactness of based Lipschitz routes. -/
+
+noncomputable section
+open Set Metric MeasureTheory
+open scoped Topology NNReal ENNReal BoundedContinuousFunction
+
+namespace SLEExactGauge.RibbonCoordinates
+open Target
+
+def basedPhysicalRoute (r : ℝ → ℂ) (hr : Continuous r) : unitInterval →ᵇ ℂ :=
+  BoundedContinuousFunction.mkOfCompact
+    ⟨fun t => r (3 * (t : ℝ)) - r 0, by fun_prop⟩
+
+lemma basedPhysicalRoute_zero (r : ℝ → ℂ) (hr : Continuous r) :
+    basedPhysicalRoute r hr 0 = 0 := by
+  change r (3 * (0 : ℝ)) - r 0 = 0
+  simp only [mul_zero, sub_self]
+
+lemma basedPhysicalRoute_lipschitz (r : ℝ → ℂ) (C : ℝ≥0) (hr : LipschitzWith C r) :
+    LipschitzWith (3 * C) (basedPhysicalRoute r hr.continuous) := by
+  apply LipschitzWith.of_dist_le_mul
+  intro u v
+  have hh := hr.dist_le_mul (3 * (u : ℝ)) (3 * (v : ℝ))
+  change dist (r (3 * (u : ℝ)) - r 0) (r (3 * (v : ℝ)) - r 0) ≤ _
+  rw [dist_sub_right]
+  have hd : dist (3 * (u : ℝ)) (3 * (v : ℝ)) = 3 * dist u v := by
+    rw [Subtype.dist_eq, Real.dist_eq, Real.dist_eq, ← mul_sub, abs_mul]
+    norm_num
+  rw [hd] at hh
+  convert hh using 1
+  push_cast
+  ring
+
+theorem uniform_physical_route_tube_probability
+    (hpublished : PublishedPlanarWienerUnitSupport)
+    (W : WienerLaw) (hW : IsWiener W) (C : ℝ≥0) {ε : ℝ} (hε : 0 < ε) :
+    ∃ q : ℝ≥0∞, 0 < q ∧ ∀ r : ℝ → ℂ, LipschitzWith C r →
+      q ≤ (W.prod W) {b | ∀ t ∈ Icc (0 : ℝ) 3,
+        dist (physicalUnitBrownianPath (r 0) b t) (r t) < ε} := by
+  obtain ⟨q, hq, hbound⟩ := uniform_planarWiener_tube_probability hpublished W hW (3 * C) hε
+  refine ⟨q, hq, fun r hr => ?_⟩
+  refine (hbound (basedPhysicalRoute r hr.continuous)
+    (basedPhysicalRoute_lipschitz r C hr) (basedPhysicalRoute_zero r hr.continuous)).trans
+    (measure_mono ?_)
+  intro b hb t ht
+  let u : unitInterval := ⟨t / 3, by linarith [ht.1], by linarith [ht.2]⟩
+  have hu : unitClipPoint (t / 3) = u := Subtype.ext (unitClip_of_mem u.property)
+  have he : 3 * (u : ℝ) = t := by dsimp only [u]; ring
+  have hh := hb u
+  change dist (planarUnitPath b u) (r (3 * (u : ℝ)) - r 0) < ε at hh
+  rw [he] at hh
+  unfold physicalUnitBrownianPath
+  rw [hu]
+  rw [dist_eq_norm] at hh ⊢
+  convert hh using 1
+  congr 1
+  ring
+
+end SLEExactGauge.RibbonCoordinates
+
+end
+
+end OAI
diff --git a/lean/OAI/Probability/SLE/Geometry/PolarBoundarySeparation.lean b/lean/OAI/Probability/SLE/Geometry/PolarBoundarySeparation.lean
new file mode 100644
index 0000000000000000000000000000000000000000..b0be0ee0ad0c646f2db417ef5a68cfdc363fb029
--- /dev/null
+++ b/lean/OAI/Probability/SLE/Geometry/PolarBoundarySeparation.lean
@@ -0,0 +1,154 @@
+import OAI.Probability.SLE.Geometry.ClosedArcCrossing
+import OAI.Probability.SLE.Loewner.UnivalentArcRayCrossing
+
+namespace OAI
+
+/-! A small inverse semicircle, closed outside the image domain, traps
+its radial interior. All intersections and transversality are explicit. -/
+noncomputable section
+open Set Filter Metric Function
+open scoped Topology
+
+namespace SLEExactGauge
+
+lemma path_ofLine_hasStrictDerivAt {f : ℝ → ℂ} (hf : ContinuousOn f (Icc 0 1))
+    {a b : ℂ} (h0 : f 0=a) (h1 : f 1=b) {t : ℝ} (ht : t∈Ioo 0 1)
+    {α : ℂ} (hd : HasStrictDerivAt f α t) :
+    HasStrictDerivAt (Path.ofLine hf h0 h1).extend α t := by
+  apply hd.congr_of_eventuallyEq
+  filter_upwards [(show Ioo (0:ℝ) 1∈𝓝 t from Ioo_mem_nhds ht.1 ht.2)] with u hu
+  exact (Path.extend_apply (Path.ofLine hf h0 h1) (Ioo_subset_Icc_self hu)).symm
+
+lemma polar_point_injective (x r s α θ : ℝ) (hr : 0<r) (hs : 0<s)
+    (hα : α∈Ioo 0 Real.pi) (hθ : θ∈Ioo 0 Real.pi)
+    (he : (x:ℂ)+(r:ℂ)*Complex.exp ((α:ℂ)*Complex.I)=
+      (x:ℂ)+(s:ℂ)*Complex.exp ((θ:ℂ)*Complex.I)) : r=s ∧ α=θ := by
+  have he' := add_left_cancel he
+  have hrs : r=s := by
+    have hn := congrArg norm he'
+    simpa [norm_mul,Complex.norm_exp,Complex.mul_re,abs_of_pos hr,abs_of_pos hs] using hn
+  subst s
+  have hexp : Complex.exp ((α:ℂ)*Complex.I)=Complex.exp ((θ:ℂ)*Complex.I) :=
+    mul_left_cancel₀ (Complex.ofReal_ne_zero.mpr hr.ne') he'
+  have ha : (α:ℂ)*Complex.I∈{z : ℂ | 0<z.im ∧ z.im<Real.pi} := by simpa using hα
+  have ht : (θ:ℂ)*Complex.I∈{z : ℂ | 0<z.im ∧ z.im<Real.pi} := by simpa using hθ
+  have hi := congrArg Complex.im (exp_injective_strip ha ht hexp)
+  exact ⟨rfl,by simpa using hi⟩
+
+lemma polar_arc_traps_radial_point {F : ℂ → ℂ} {D : Set ℂ}
+    (hF : DifferentiableOn ℂ F upperHalfPlane) (hi : InjOn F upperHalfPlane)
+    (hmap : MapsTo F upperHalfPlane D)
+    (x r ρ R θ : ℝ) (hρ : 0<ρ) (hρr : ρ<r) (hrR : r<R)
+    (hθ : θ∈Ioo 0 Real.pi)
+    (c : ℝ → ℂ) (hc : Continuous c)
+    (he : ∀ a∈Ioo 0 Real.pi, c a=F ((x:ℂ)+(r:ℂ)*Complex.exp ((a:ℂ)*Complex.I)))
+    (hc0 : c 0∉D) (hcπ : c Real.pi∉D)
+    (q : Path (c Real.pi) (c 0)) (hq : ∀ u, q u∉D)
+    (w : ℂ) (ε : ℝ) (hε : 0<ε)
+    (hcball : ∀ a∈Icc 0 Real.pi, c a∈ball w ε)
+    (hqball : ∀ u, q u∈ball w ε)
+    (hR : F ((x:ℂ)+(R:ℂ)*Complex.exp ((θ:ℂ)*Complex.I))∉ball w ε) :
+    F ((x:ℂ)+(ρ:ℂ)*Complex.exp ((θ:ℂ)*Complex.I))∈ball w ε := by
+  by_contra hρout
+  have hr : 0<r := hρ.trans hρr
+  have hρR : 0<R-ρ := sub_pos.mpr (hρr.trans hrR)
+  let A (u : ℝ) := c (Real.pi*u)
+  let B (u : ℝ) := F ((x:ℂ)+((ρ+(R-ρ)*u:ℝ):ℂ)*Complex.exp ((θ:ℂ)*Complex.I))
+  have hlin (u : ℝ) (hu : u∈Icc 0 1) : 0<ρ+(R-ρ)*u :=
+    add_pos_of_pos_of_nonneg hρ (mul_nonneg hρR.le hu.1)
+  have hB : ContinuousOn B (Icc 0 1) := by
+    apply hF.continuousOn.comp (by fun_prop)
+    intro u hu
+    exact univalent_polar_point_mem x _ θ (hlin u hu) hθ
+  let a : Path (c 0) (c Real.pi) := Path.ofLine (f := A) (hf := (hc.comp (show Continuous (fun u : ℝ => Real.pi*u) by fun_prop)).continuousOn)
+    (by simp [A]) (by simp [A])
+  let p : Path (B 0) (B 1) := Path.ofLine hB rfl rfl
+  let s : unitInterval := ⟨(r-ρ)/(R-ρ), by
+    constructor
+    · exact (div_pos (sub_pos.mpr hρr) hρR).le
+    · exact (div_le_one hρR).mpr (by linarith)⟩
+  let t : unitInterval := ⟨θ/Real.pi, by
+    constructor
+    · exact (div_pos hθ.1 Real.pi_pos).le
+    · exact (div_le_one Real.pi_pos).mpr hθ.2.le⟩
+  have hs : 0<(s:ℝ) ∧ (s:ℝ)<1 :=
+    ⟨div_pos (sub_pos.mpr hρr) hρR,(div_lt_one hρR).mpr (by linarith)⟩
+  have ht : 0<(t:ℝ) ∧ (t:ℝ)<1 :=
+    ⟨div_pos hθ.1 Real.pi_pos,(div_lt_one Real.pi_pos).mpr hθ.2⟩
+  have hst : ρ+(R-ρ)*(s:ℝ)=r := by dsimp [s]; field_simp; ring
+  have htt : Real.pi*(t:ℝ)=θ := by dsimp [t]; field_simp
+  have hpin (u : unitInterval) : p u∈D :=
+    hmap (univalent_polar_point_mem x _ θ (hlin u u.property) hθ)
+  have hp0 : B 0∉ball w ε := by simpa [B] using hρout
+  have hp1 : B 1∉ball w ε := by simpa [B] using hR
+  have hcross : a t=p s := by
+    change c (Real.pi*(t:ℝ))=B s
+    rw [htt,he θ hθ]
+    simp only [B,hst]
+  have huniq (u v : unitInterval) (hev : a v=p u) : u=s ∧ v=t := by
+    have hv0 : (v:ℝ)≠0 := by
+      intro hv
+      apply hc0
+      have : a v=c 0 := by change c (Real.pi*(v:ℝ))=c 0; rw [hv,mul_zero]
+      rw [←this,hev]
+      exact hpin u
+    have hv1 : (v:ℝ)≠1 := by
+      intro hv
+      apply hcπ
+      have : a v=c Real.pi := by change c (Real.pi*(v:ℝ))=c Real.pi; rw [hv,mul_one]
+      rw [←this,hev]
+      exact hpin u
+    have hv : Real.pi*(v:ℝ)∈Ioo 0 Real.pi :=
+      ⟨mul_pos Real.pi_pos (lt_of_le_of_ne v.property.1 hv0.symm),
+       by nlinarith [lt_of_le_of_ne v.property.2 hv1,Real.pi_pos]⟩
+    change c (Real.pi*(v:ℝ))=B u at hev
+    rw [he _ hv] at hev
+    have hpre := hi (univalent_polar_point_mem x r _ hr hv)
+      (univalent_polar_point_mem x _ θ (hlin u u.property) hθ) hev
+    obtain ⟨hrad,hang⟩ := polar_point_injective x r _ _ θ hr (hlin u u.property) hv hθ hpre
+    constructor
+    · apply Subtype.ext
+      dsimp [s]
+      apply (eq_div_iff hρR.ne').mpr
+      nlinarith [hrad]
+    · apply Subtype.ext
+      dsimp [t]
+      exact (eq_div_iff Real.pi_ne_zero).mpr (by linarith [hang])
+  let z := (x:ℂ)+(r:ℂ)*Complex.exp ((θ:ℂ)*Complex.I)
+  let V := deriv F z*Complex.exp ((θ:ℂ)*Complex.I)
+  have hV : V≠0 := mul_ne_zero
+    (univalent_deriv_ne_zero isOpen_upperHalfPlane hF hi (univalent_polar_point_mem x r θ hr hθ))
+    (Complex.exp_ne_zero _)
+  have haD : HasStrictDerivAt a.extend ((Real.pi*r:ℝ) • (Complex.I*V)) t := by
+    apply path_ofLine_hasStrictDerivAt _ _ _ ht
+    have hd := (holomorphic_polar_arc_strict hF x r θ hr hθ).scomp_of_eq (t:ℝ)
+      (show HasStrictDerivAt (fun u : ℝ => Real.pi*u) Real.pi t by
+        simpa using (hasStrictDerivAt_id (t:ℝ)).const_mul Real.pi) htt.symm
+    have heq : (fun u : ℝ => F ((x:ℂ)+(r:ℂ)*Complex.exp (((Real.pi*u:ℝ):ℂ)*Complex.I)))
+        =ᶠ[𝓝 (t:ℝ)] A := by
+      filter_upwards [(isOpen_Ioo.mem_nhds (show (t:ℝ)∈Ioo 0 1 from ht))] with u hu
+      exact (he _ ⟨mul_pos Real.pi_pos hu.1,by nlinarith [hu.2,Real.pi_pos]⟩).symm
+    have hd' := hd.congr_of_eventuallyEq heq
+    convert hd' using 1
+    dsimp [V,z]
+    simp only [Complex.ofReal_mul]
+    ring
+  have hpD : HasStrictDerivAt p.extend ((R-ρ) • V) s := by
+    apply path_ofLine_hasStrictDerivAt hB rfl rfl hs
+    have hd := (holomorphic_polar_ray_strict hF x r θ hr hθ).scomp_of_eq (s:ℝ)
+      (show HasStrictDerivAt (fun u : ℝ => ρ+(R-ρ)*u) (R-ρ) s by
+        simpa using ((hasStrictDerivAt_id (s:ℝ)).const_mul (R-ρ)).const_add ρ) hst.symm
+    exact hd
+  apply small_closed_arc_no_transverse_crossing a q p hpin hq w ε hε
+    (fun u => hcball _ ⟨mul_nonneg Real.pi_pos.le u.property.1,by nlinarith [u.property.2,Real.pi_pos]⟩)
+    hqball hp0 hp1 s t hs ht hcross huniq _ _ haD hpD
+  intro u v huv
+  apply transverse_radial_angular (Real.pi*r) (R-ρ) V
+    (mul_pos Real.pi_pos hr).ne' hρR.ne' hV u v
+  simpa only [Complex.real_smul,Complex.ofReal_mul,mul_assoc] using huv
+
+end SLEExactGauge
+
+end
+
+end OAI
diff --git a/lean/OAI/Probability/SLE/Geometry/PolarLaplacianFlux.lean b/lean/OAI/Probability/SLE/Geometry/PolarLaplacianFlux.lean
new file mode 100644
index 0000000000000000000000000000000000000000..8cbb1d81a4581214e5e122a5e7bfb7b6ed3df59b
--- /dev/null
+++ b/lean/OAI/Probability/SLE/Geometry/PolarLaplacianFlux.lean
@@ -0,0 +1,122 @@
+import OAI.Probability.SLE.RadiusClocks
+
+namespace OAI
+
+/-! The unweighted polar divergence identity on a closed annulus. -/
+noncomputable section
+open Set Filter Metric Function Complex MeasureTheory InnerProductSpace
+open scoped Topology Laplacian
+
+namespace SLEExactGauge
+
+def radialLaplacianFlux (u : ℂ → ℝ) (p : ℝ × ℝ) : ℝ :=
+  p.1 * fderiv ℝ u (polarPoint p.1 p.2) (circleMap 0 1 p.2)
+
+def angularLaplacianFlux (u : ℂ → ℝ) (p : ℝ × ℝ) : ℝ :=
+  p.1⁻¹ * fderiv ℝ u (polarPoint p.1 p.2) (polarPoint p.1 p.2 * I)
+
+lemma radialLaplacianFlux_differentiableAt {u : ℂ → ℝ} {r θ : ℝ}
+    (hu : ContDiffAt ℝ 2 u (polarPoint r θ)) :
+    DifferentiableAt ℝ (radialLaplacianFlux u) (r,θ) := by
+  have hp := polarPoint_contDiff.differentiable (by simp) (r,θ)
+  have hd := ((hu.fderiv_right (m := 1) (by norm_num)).differentiableAt
+    (by norm_num)).comp (r,θ) hp
+  exact differentiableAt_fst.mul (hd.clm_apply (by unfold circleMap; fun_prop))
+
+lemma angularLaplacianFlux_differentiableAt {u : ℂ → ℝ} {r θ : ℝ}
+    (hr : r≠0) (hu : ContDiffAt ℝ 2 u (polarPoint r θ)) :
+    DifferentiableAt ℝ (angularLaplacianFlux u) (r,θ) := by
+  have hp := polarPoint_contDiff.differentiable (by simp) (r,θ)
+  have hd := ((hu.fderiv_right (m := 1) (by norm_num)).differentiableAt
+    (by norm_num)).comp (r,θ) hp
+  exact (differentiableAt_fst.inv hr).mul (hd.clm_apply (hp.mul_const I))
+
+lemma radialLaplacianFlux_radial_hasDeriv {u : ℂ → ℝ} {r θ : ℝ}
+    (hu : ContDiffAt ℝ 2 u (polarPoint r θ)) :
+    HasDerivAt (fun s => radialLaplacianFlux u (s,θ))
+      (fderiv ℝ u (polarPoint r θ) (circleMap 0 1 θ)+
+        r*fderiv ℝ (fderiv ℝ u) (polarPoint r θ) (circleMap 0 1 θ) (circleMap 0 1 θ)) r := by
+  convert! (hasDerivAt_id r).mul (radial_second_hasDeriv hu) using 1
+  simp only [one_mul,id_eq]
+
+lemma angularLaplacianFlux_angular_hasDeriv {u : ℂ → ℝ} {r θ : ℝ}
+    (hu : ContDiffAt ℝ 2 u (polarPoint r θ)) :
+    HasDerivAt (fun φ => angularLaplacianFlux u (r,φ))
+      (r⁻¹*(fderiv ℝ (fderiv ℝ u) (polarPoint r θ) (polarPoint r θ*I) (polarPoint r θ*I)-
+        fderiv ℝ u (polarPoint r θ) (polarPoint r θ))) θ :=
+  (angular_second_hasDeriv hu).const_mul r⁻¹
+
+lemma polarLaplacian_divergence {u : ℂ → ℝ} {r θ : ℝ}
+    (hr : r≠0) (hu : ContDiffAt ℝ 2 u (polarPoint r θ)) :
+    fderiv ℝ (radialLaplacianFlux u) (r,θ) (1,0)+
+      fderiv ℝ (angularLaplacianFlux u) (r,θ) (0,1)=
+        r*(Δ u) (polarPoint r θ) := by
+  have hf := (radialLaplacianFlux_differentiableAt hu).hasFDerivAt.comp_hasDerivAt r
+    ((hasDerivAt_id r).prodMk (hasDerivAt_const r θ))
+  have hg := (angularLaplacianFlux_differentiableAt hr hu).hasFDerivAt.comp_hasDerivAt θ
+    ((hasDerivAt_const θ r).prodMk (hasDerivAt_id θ))
+  rw [hf.unique (radialLaplacianFlux_radial_hasDeriv hu),
+    hg.unique (angularLaplacianFlux_angular_hasDeriv hu)]
+  have he : fderiv ℝ u (polarPoint r θ) (polarPoint r θ)=
+      r*fderiv ℝ u (polarPoint r θ) (circleMap 0 1 θ) := by
+    conv_lhs => arg 2; rw [polarPoint]
+    simp only [map_smul,smul_eq_mul]
+  rw [he]
+  have hh := polar_laplacian_identity (u := u) r θ
+  apply (mul_left_cancel₀ hr)
+  field_simp [hr]
+  nlinarith only [hh]
+
+lemma annulus_laplacian_flux {u : ℂ → ℝ} {a R : ℝ}
+    (ha : 0<a) (haR : a≤R)
+    (hu : ∀ z : ℂ, a≤‖z‖ → ‖z‖≤R → ContDiffAt ℝ 2 u z) :
+    (∫ r in a..R, ∫ θ in -Real.pi..Real.pi, r*(Δ u) (polarPoint r θ))=
+      (∫ θ in -Real.pi..Real.pi, radialLaplacianFlux u (R,θ))-
+      (∫ θ in -Real.pi..Real.pi, radialLaplacianFlux u (a,θ)) := by
+  let S := uIcc a R ×ˢ uIcc (-Real.pi) Real.pi
+  have hmem (p : ℝ × ℝ) (hp : p∈S) : p.1≠0 ∧ ContDiffAt ℝ 2 u (polarPoint p.1 p.2) := by
+    have hr : p.1∈Icc a R := by simpa only [uIcc_of_le haR] using hp.1
+    have hn : ‖polarPoint p.1 p.2‖=p.1 := by
+      rw [polarPoint_norm,abs_of_pos (ha.trans_le hr.1)]
+    exact ⟨(ha.trans_le hr.1).ne',hu _ (by rw [hn]; exact hr.1) (by rw [hn]; exact hr.2)⟩
+  have hf : ContinuousOn (radialLaplacianFlux u) S := fun p hp =>
+    (radialLaplacianFlux_differentiableAt (hmem p hp).2).continuousAt.continuousWithinAt
+  have hg : ContinuousOn (angularLaplacianFlux u) S := fun p hp =>
+    (angularLaplacianFlux_differentiableAt (hmem p hp).1 (hmem p hp).2).continuousAt.continuousWithinAt
+  have hl : ContinuousOn (fun p : ℝ × ℝ => p.1*(Δ u) (polarPoint p.1 p.2)) S := by
+    intro p hp
+    exact (continuousAt_fst.mul ((plane_laplacian_continuousAt (hmem p hp).2).comp
+      (f := fun p : ℝ × ℝ => polarPoint p.1 p.2)
+      polarPoint_contDiff.continuous.continuousAt)).continuousWithinAt
+  have he : EqOn (fun p : ℝ × ℝ => fderiv ℝ (radialLaplacianFlux u) p (1,0)+
+      fderiv ℝ (angularLaplacianFlux u) p (0,1))
+      (fun p => p.1*(Δ u) (polarPoint p.1 p.2)) S :=
+    fun p hp => polarLaplacian_divergence (hmem p hp).1 (hmem p hp).2
+  have hi : IntegrableOn (fun p : ℝ × ℝ => fderiv ℝ (radialLaplacianFlux u) p (1,0)+
+      fderiv ℝ (angularLaplacianFlux u) p (0,1)) S :=
+    (hl.integrableOn_compact (isCompact_uIcc.prod isCompact_uIcc)).congr_fun
+      (fun p hp => (he hp).symm) (measurableSet_uIcc.prod measurableSet_uIcc)
+  have hm : Ioo (min a R) (max a R) ×ˢ Ioo (min (-Real.pi) Real.pi) (max (-Real.pi) Real.pi) ⊆ S :=
+    prod_mono Ioo_subset_Icc_self Ioo_subset_Icc_self
+  have hh := integral2_divergence_prod_of_hasFDerivAt (radialLaplacianFlux u) (angularLaplacianFlux u)
+    (fderiv ℝ (radialLaplacianFlux u)) (fderiv ℝ (angularLaplacianFlux u)) a (-Real.pi) R Real.pi hf hg
+    (fun p hp => (radialLaplacianFlux_differentiableAt (hmem p (hm hp)).2).hasFDerivAt)
+    (fun p hp => (angularLaplacianFlux_differentiableAt (hmem p (hm hp)).1
+      (hmem p (hm hp)).2).hasFDerivAt) hi
+  have hi_eq : (∫ r in a..R, ∫ θ in -Real.pi..Real.pi,
+      fderiv ℝ (radialLaplacianFlux u) (r,θ) (1,0)+
+        fderiv ℝ (angularLaplacianFlux u) (r,θ) (0,1))=
+      ∫ r in a..R, ∫ θ in -Real.pi..Real.pi, r*(Δ u) (polarPoint r θ) := by
+    apply intervalIntegral.integral_congr
+    intro r hr
+    apply intervalIntegral.integral_congr
+    intro θ hθ
+    exact he ⟨hr,hθ⟩
+  rw [hi_eq] at hh
+  simpa only [angularLaplacianFlux,polarPoint_endpoints,sub_self,zero_add] using hh
+
+end SLEExactGauge
+
+end
+
+end OAI
diff --git a/lean/OAI/Probability/SLE/Geometry/PositiveKernelTests.lean b/lean/OAI/Probability/SLE/Geometry/PositiveKernelTests.lean
new file mode 100644
index 0000000000000000000000000000000000000000..93e07ad1f1f5ac6ce36c851c3e896056ac9bd86d
--- /dev/null
+++ b/lean/OAI/Probability/SLE/Geometry/PositiveKernelTests.lean
@@ -0,0 +1,66 @@
+import OAI.Probability.SLE.Mass.CanonicalMassUniqueness
+
+namespace OAI
+
+/-! Positive compact tests of random measures whose mean is bounded by
+the initial Green measure. Exceptional infinite values need no modification. -/
+
+noncomputable section
+open Set Filter _root_.MeasureTheory _root_.OAI.MeasureTheory Classical
+open scoped NNReal ENNReal Topology CompactlySupported
+
+namespace SLEExactGauge.Multipoint
+
+local instance positiveKernelTestsLocallyCompact : LocallyCompactSpace upperHalfPlane :=
+  isOpen_upperHalfPlane.locallyCompactSpace
+
+lemma positive_kernel_test_lintegral_ne_top
+    {Ω : Type*} [MeasurableSpace Ω] (P : Measure Ω) (κ : ℝ)
+    (μ : Ω → Measure upperHalfPlane) (hμ : Measurable μ)
+    (hbound : P.bind μ ≤ initialGreenMeasure κ)
+    (f : C_c(upperHalfPlane,ℝ)) (hf : ∀ z, 0 ≤ f z) :
+    (∫⁻ ω, ∫⁻ z, ENNReal.ofReal (f z) ∂μ ω ∂P) ≠ ∞ := by
+  let : IsFiniteMeasureOnCompacts (initialGreenMeasure κ) := initialGreenMeasure_finite_on_compacts κ
+  have hi : Integrable (fun z => f z) (P.bind μ) := f.integrable.mono_measure hbound
+  have hfM : Measurable (fun z => ENNReal.ofReal (f z)) := f.continuous.measurable.ennreal_ofReal
+  rw [← Measure.lintegral_bind (m := P) hμ.aemeasurable hfM.aemeasurable,
+    ← ofReal_integral_eq_lintegral_ofReal hi (ae_of_all _ hf)]
+  exact ENNReal.ofReal_ne_top
+
+lemma positive_kernel_test_integrable
+    {Ω : Type*} [MeasurableSpace Ω] (P : Measure Ω) (κ : ℝ)
+    (μ : Ω → Measure upperHalfPlane) (hμ : Measurable μ)
+    (hbound : P.bind μ ≤ initialGreenMeasure κ)
+    (f : C_c(upperHalfPlane,ℝ)) (hf : ∀ z, 0 ≤ f z) :
+    Integrable (fun ω => ∫ z, f z ∂μ ω) P := by
+  have hq : Measurable (fun ω => ∫⁻ z, ENNReal.ofReal (f z) ∂μ ω) :=
+    (Measure.measurable_lintegral f.continuous.measurable.ennreal_ofReal).comp hμ
+  have hi := integrable_toReal_of_lintegral_ne_top hq.aemeasurable
+    (positive_kernel_test_lintegral_ne_top P κ μ hμ hbound f hf)
+  convert hi using 1
+  funext ω
+  exact integral_eq_lintegral_of_nonneg_ae (ae_of_all _ hf) f.continuous.measurable.aestronglyMeasurable
+
+lemma positive_kernel_integral_bind
+    {Ω : Type*} [MeasurableSpace Ω] (P : Measure Ω) (κ : ℝ)
+    (μ : Ω → Measure upperHalfPlane) (hμ : Measurable μ)
+    (hbound : P.bind μ ≤ initialGreenMeasure κ)
+    (f : C_c(upperHalfPlane,ℝ)) (hf : ∀ z, 0 ≤ f z) :
+    (∫ ω, ∫ z, f z ∂μ ω ∂P) = ∫ z, f z ∂P.bind μ := by
+  have hq : Measurable (fun ω => ∫⁻ z, ENNReal.ofReal (f z) ∂μ ω) :=
+    (Measure.measurable_lintegral f.continuous.measurable.ennreal_ofReal).comp hμ
+  have he (ω : Ω) : (∫ z, f z ∂μ ω)=(∫⁻ z, ENNReal.ofReal (f z) ∂μ ω).toReal :=
+    integral_eq_lintegral_of_nonneg_ae (ae_of_all _ hf) f.continuous.measurable.aestronglyMeasurable
+  have hfM : Measurable (fun z => ENNReal.ofReal (f z)) := f.continuous.measurable.ennreal_ofReal
+  simp_rw [he]
+  rw [integral_toReal hq.aemeasurable
+    (ae_lt_top hq (positive_kernel_test_lintegral_ne_top P κ μ hμ hbound f hf)),
+    ← Measure.lintegral_bind (m := P) hμ.aemeasurable hfM.aemeasurable]
+  exact (integral_eq_lintegral_of_nonneg_ae (ae_of_all _ hf)
+    f.continuous.measurable.aestronglyMeasurable).symm
+
+end SLEExactGauge.Multipoint
+
+end
+
+end OAI
diff --git a/lean/OAI/Probability/SLE/Geometry/PositiveRealDiskEstimate.lean b/lean/OAI/Probability/SLE/Geometry/PositiveRealDiskEstimate.lean
new file mode 100644
index 0000000000000000000000000000000000000000..11203009e877cf17ab0dcada2720c655cbae82fa
--- /dev/null
+++ b/lean/OAI/Probability/SLE/Geometry/PositiveRealDiskEstimate.lean
@@ -0,0 +1,51 @@
+import Mathlib.Analysis.Complex.BorelCaratheodory
+import Mathlib.Analysis.Complex.AbsMax
+
+namespace OAI
+
+/-! The positive-real disk estimate used after inversion of a small
+reflected slit. Its constant is the hydrodynamic mass at the origin. -/
+noncomputable section
+open Set Filter Function Metric Complex
+open scoped Topology
+
+namespace SLEExactGauge
+
+lemma real_nonneg_of_sphere_nonneg {H : ℂ → ℂ} {R : ℝ} (hR : 0<R)
+    (hH : DifferentiableOn ℂ H (closedBall 0 R))
+    (hb : ∀ z∈sphere (0:ℂ) R, 0≤(H z).re) :
+    ∀ z∈closedBall (0:ℂ) R, 0≤(H z).re := by
+  have heD : DifferentiableOn ℂ (fun z => Complex.exp (-H z)) (closedBall 0 R) := hH.neg.cexp
+  have he : DiffContOnCl ℂ (fun z => Complex.exp (-H z)) (ball 0 R) := by
+    refine ⟨heD.mono ball_subset_closedBall,?_⟩
+    rw [closure_ball (0:ℂ) hR.ne']
+    exact heD.continuousOn
+  intro z hz
+  have hmax := Complex.norm_le_of_forall_mem_frontier_norm_le isBounded_ball he
+    (C := 1) (fun w hw => by
+      have hw' : w∈sphere (0:ℂ) R := by rwa [frontier_ball (0:ℂ) hR.ne'] at hw
+      rw [Complex.norm_exp,neg_re,Real.exp_le_one_iff]
+      exact neg_nonpos.mpr (hb w hw'))
+    (show z∈closure (ball (0:ℂ) R) by rwa [closure_ball (0:ℂ) hR.ne'])
+  rw [Complex.norm_exp,neg_re,Real.exp_le_one_iff] at hmax
+  exact neg_nonpos.mp hmax
+
+theorem positive_real_disk_deviation {H : ℂ → ℂ} {m : ℝ} (hm : 0<m)
+    (hH : DifferentiableOn ℂ H (ball 0 1)) (h0 : H 0=(m:ℂ))
+    (hpos : ∀ z∈ball (0:ℂ) 1, 0≤(H z).re)
+    {w : ℂ} (hw : w∈ball (0:ℂ) 1) :
+    ‖H w-(m:ℂ)‖≤2*m*‖w‖/(1-‖w‖) := by
+  have hf : DifferentiableOn ℂ (fun z => (m:ℂ)-H z) (ball 0 1) :=
+    hH.const_sub (m:ℂ)
+  have hb := Complex.borelCaratheodory_zero hm hf (fun z hz => by
+    change ((m:ℂ)-H z).re≤m
+    simp only [sub_re,ofReal_re]
+    linarith [hpos z hz]) zero_lt_one hw
+    (by rw [h0,sub_self])
+  simpa only [norm_sub_rev] using hb
+
+end SLEExactGauge
+
+end
+
+end OAI
diff --git a/lean/OAI/Probability/SLE/Geometry/ProductDensity.lean b/lean/OAI/Probability/SLE/Geometry/ProductDensity.lean
new file mode 100644
index 0000000000000000000000000000000000000000..ac216e5ba4b80d265f1523218ef670060d8c5a9c
--- /dev/null
+++ b/lean/OAI/Probability/SLE/Geometry/ProductDensity.lean
@@ -0,0 +1,32 @@
+import Mathlib.MeasureTheory.Measure.Prod
+import Mathlib.MeasureTheory.Measure.WithDensity
+
+namespace OAI
+
+/-! Sectionwise integration of a measurable density on a product measure. -/
+noncomputable section
+open MeasureTheory
+open scoped ENNReal
+
+namespace SLEExactGauge
+
+lemma product_withDensity_lintegral
+    {X Y : Type*} [MeasurableSpace X] [MeasurableSpace Y]
+    (μ : Measure X) [SFinite μ] (ν : Measure Y) [SFinite ν]
+    (d : X × Y → ℝ≥0∞) (hd : Measurable d)
+    (f : X × Y → ℝ≥0∞) (hf : Measurable f) :
+    (∫⁻ p, f p ∂(μ.prod ν).withDensity d) =
+      ∫⁻ x, ∫⁻ y, f (x,y) ∂ν.withDensity (fun y => d (x,y)) ∂μ := by
+  rw [lintegral_withDensity_eq_lintegral_mul _ hd hf,
+    lintegral_prod _ (hd.mul hf).aemeasurable]
+  apply lintegral_congr
+  intro x
+  have hdx : Measurable (fun y => d (x,y)) := hd.comp (measurable_const.prodMk measurable_id)
+  have hfx : Measurable (fun y => f (x,y)) := hf.comp (measurable_const.prodMk measurable_id)
+  exact (lintegral_withDensity_eq_lintegral_mul ν hdx hfx).symm
+
+end SLEExactGauge
+
+end
+
+end OAI
diff --git a/lean/OAI/Probability/SLE/Geometry/PublishedBoundaryExtension.lean b/lean/OAI/Probability/SLE/Geometry/PublishedBoundaryExtension.lean
new file mode 100644
index 0000000000000000000000000000000000000000..9b3805b169cafa53fa5ff9162502ee9fe789f4d4
--- /dev/null
+++ b/lean/OAI/Probability/SLE/Geometry/PublishedBoundaryExtension.lean
@@ -0,0 +1,53 @@
+import OAI.Probability.SLE.LoewnerCharts
+
+namespace OAI
+
+/-! A precise deterministic published input for boundary extensions.
+Rohde–Schramm, *Basic properties of SLE*, Annals of Mathematics 161 (2005),
+Theorem 4.1, pp. 898–899. A continuous Loewner driver whose tip limits form
+a continuous trace has inverse maps continuous on the closed half-plane.
+The input below keeps only this conclusion, composed with the continuous
+inclusion into the one-point compactification. It has no stochastic or
+uniform ribbon estimate. -/
+
+noncomputable section
+open Set Filter
+open scoped Topology NNReal
+
+namespace SLEExactGauge
+
+def PublishedLoewnerBoundaryExtension : Prop :=
+  ∀ (U : ℝ≥0 → ℝ) (γ : ℝ≥0 → ℂ) (G F : ℝ≥0 → ℂ → ℂ),
+    Continuous U → IsCapacityTwoWitness U γ G F →
+    ∀ t : ℝ≥0, ∃ Fbar : ℂ → OnePoint ℂ,
+      ContinuousOn Fbar {z : ℂ | 0 ≤ z.im} ∧
+      (∀ z ∈ upperHalfPlane, Fbar z = (F t z : OnePoint ℂ)) ∧
+      Fbar (U t : ℂ) = (γ t : OnePoint ℂ)
+
+theorem normalized_capacity_inverse_boundary_extension
+    (hpublished : PublishedLoewnerBoundaryExtension)
+    {U : ℝ≥0 → ℝ} {γ : ℝ≥0 → ℂ} {G F : ℝ≥0 → ℂ → ℂ}
+    (hU : Continuous U) (hw : IsCapacityTwoWitness U γ G F)
+    (t : ℝ≥0) (c : ℝ) (hc : 0 < c) :
+    ∃ Fbar : ℂ → OnePoint ℂ,
+      ContinuousOn Fbar {z : ℂ | 0 ≤ z.im} ∧
+      (∀ z ∈ upperHalfPlane,
+        Fbar z = (F t ((U t : ℂ) + (c : ℂ) * z) : OnePoint ℂ)) ∧
+      Fbar 0 = (γ t : OnePoint ℂ) := by
+  obtain ⟨Fb, hFb, hext, htip⟩ := hpublished U γ G F hU hw t
+  let A : ℂ → ℂ := fun z => (U t : ℂ) + (c : ℂ) * z
+  have hA : Continuous A := continuous_const.add (continuous_const.mul continuous_id)
+  have him : ∀ z, (A z).im = c * z.im := by intro z; simp [A]
+  refine ⟨Fb ∘ A, hFb.comp hA.continuousOn (fun z hz => ?_), ?_, ?_⟩
+  · change 0 ≤ (A z).im
+    rw [him]
+    exact mul_nonneg hc.le hz
+  · intro z hz
+    exact hext (A z) (by change 0 < (A z).im; rw [him]; exact mul_pos hc hz)
+  · simpa only [Function.comp_apply, A, mul_zero, add_zero] using htip
+
+end SLEExactGauge
+
+end
+
+end OAI
diff --git a/lean/OAI/Probability/SLE/Geometry/PublishedConformalCompactness.lean b/lean/OAI/Probability/SLE/Geometry/PublishedConformalCompactness.lean
new file mode 100644
index 0000000000000000000000000000000000000000..13dee01bac96cc44a378092fb0e0726751b2b8c9
--- /dev/null
+++ b/lean/OAI/Probability/SLE/Geometry/PublishedConformalCompactness.lean
@@ -0,0 +1,46 @@
+import OAI.Probability.SLE.LoewnerCharts
+
+namespace OAI
+
+/-! The classical published normal-family input, restricted to the interior
+normalization used in the ribbon proof.
+
+P. L. Duren, *Univalent Functions*, Springer, 1983, §1.3, unnumbered
+theorem on p. 9: compactness of the normalized schlicht class. The
+half-plane specialization below follows by disk automorphisms and affine
+normalization, using the growth/distortion bounds in §2.3. The moving
+normalization points stay on one compact semicircle, their images are
+bounded, and the derivative norms stay bounded above and away from zero.
+The nonvanishing derivative of the univalent limit is the local mapping
+property in §1.2, p. 5.
+
+This is an explicit hypothesis, not an axiom. It contains no boundary
+guide, SLE passage, sausage estimate, or uniformity over stopped pasts.
+-/
+
+noncomputable section
+open Set Filter Metric
+open scoped Topology
+
+namespace SLEExactGauge
+
+/-- The minimal nondegenerate univalent normal-family consequence used
+at the ribbon waypoint. -/
+def PublishedHalfPlaneUnivalentCompactness : Prop :=
+  ∀ (Fₙ : ℕ → ℂ → ℂ) (zₙ : ℕ → ℂ) (s m M : ℝ),
+    0 < s → 0 < m →
+    (∀ n, DifferentiableOn ℂ (Fₙ n) upperHalfPlane) →
+    (∀ n, InjOn (Fₙ n) upperHalfPlane) →
+    (∀ n, ‖zₙ n‖ = 1 ∧ s ≤ (zₙ n).im) →
+    (∀ n, ‖Fₙ n (zₙ n)‖ ≤ M) →
+    (∀ n, m ≤ ‖deriv (Fₙ n) (zₙ n)‖ ∧ ‖deriv (Fₙ n) (zₙ n)‖ ≤ M) →
+    ∃ (φ : ℕ → ℕ) (F : ℂ → ℂ), StrictMono φ ∧
+      DifferentiableOn ℂ F upperHalfPlane ∧ InjOn F upperHalfPlane ∧
+      (∀ z ∈ upperHalfPlane, deriv F z ≠ 0) ∧
+      TendstoLocallyUniformlyOn (fun n => Fₙ (φ n)) F atTop upperHalfPlane
+
+end SLEExactGauge
+
+end
+
+end OAI
diff --git a/lean/OAI/Probability/SLE/Geometry/PublishedConformalExitLaw.lean b/lean/OAI/Probability/SLE/Geometry/PublishedConformalExitLaw.lean
new file mode 100644
index 0000000000000000000000000000000000000000..085941c296641cc45f96e90f30e66ff96854ca80
--- /dev/null
+++ b/lean/OAI/Probability/SLE/Geometry/PublishedConformalExitLaw.lean
@@ -0,0 +1,53 @@
+import OAI.Probability.SLE.Geometry.WaypointRouteProbability
+
+namespace OAI
+
+/-! Finite-window consequences of published conformal invariance of planar
+Brownian motion: G. F. Lawler, *Conformally Invariant Processes in the Plane*,
+AMS (2005), Theorem 2.2. The half-plane harmonic-measure formula is recorded
+in Lawler--Werness, Ann. Probab. 41 (2013), 1513--1555, §2.1, unnumbered
+display for S-hat (electronic reprint p. 5, DOI 10.1214/11-AOP695).
+
+Only finite exits during one unit Brownian window are used. Time is
+deterministically rescaled from [0,1] to [0,3]. The input states actual
+map-out limits and exit-event upper bounds, with no ribbon hypotheses and
+no positive lower probability or angle estimate. -/
+
+noncomputable section
+open Set Filter MeasureTheory
+open scoped Topology NNReal ENNReal
+
+namespace SLEExactGauge
+open Target RibbonCoordinates
+
+def UnitWindowFirstExit (D : Set ℂ) (ζ : ℝ → ℂ) (τ : ℝ) : Prop :=
+  τ ∈ Ioc (0 : ℝ) 3 ∧ ζ τ ∉ D ∧ MapsTo ζ (Ico 0 τ) D
+
+def unitWindowExitArc (D : Set ℂ) (g : ℂ → ℂ) (w : ℂ) (side : ℝ) :
+    Set (Driver × Driver) :=
+  {b | ∃ τ : ℝ, UnitWindowFirstExit D (physicalUnitBrownianPath w b) τ ∧
+    ∃ x : ℝ, 0 < side * x ∧
+      Tendsto (fun t => g (physicalUnitBrownianPath w b t)) (𝓝[<] τ) (𝓝 (x : ℂ))}
+
+def PublishedHalfPlaneConformalExitLaw : Prop :=
+  ∀ (W : WienerLaw), IsWiener W → ∀ (D : Set ℂ) (g f : ℂ → ℂ),
+    IsOpen D → D ⊆ upperHalfPlane →
+    DifferentiableOn ℂ g D → DifferentiableOn ℂ f upperHalfPlane →
+    MapsTo g D upperHalfPlane → MapsTo f upperHalfPlane D →
+    (∀ z ∈ D, f (g z) = z) → (∀ z ∈ upperHalfPlane, g (f z) = z) →
+    ∀ w ∈ D,
+      (∀ᵐ b ∂(W.prod W), ∀ τ : ℝ,
+        UnitWindowFirstExit D (physicalUnitBrownianPath w b) τ →
+          ∃ x : ℝ, x ≠ 0 ∧
+            Tendsto (fun t => g (physicalUnitBrownianPath w b t))
+              (𝓝[<] τ) (𝓝 (x : ℂ))) ∧
+      (W.prod W) (unitWindowExitArc D g w (-1)) ≤
+        ENNReal.ofReal ((g w).arg / Real.pi) ∧
+      (W.prod W) (unitWindowExitArc D g w 1) ≤
+        ENNReal.ofReal (1 - (g w).arg / Real.pi)
+
+end SLEExactGauge
+
+end
+
+end OAI
diff --git a/lean/OAI/Probability/SLE/Geometry/PublishedCrosscutStraightening.lean b/lean/OAI/Probability/SLE/Geometry/PublishedCrosscutStraightening.lean
new file mode 100644
index 0000000000000000000000000000000000000000..024fac05a7c551ed8c3a7cdc75528bf64f9565dc
--- /dev/null
+++ b/lean/OAI/Probability/SLE/Geometry/PublishedCrosscutStraightening.lean
@@ -0,0 +1,67 @@
+import OAI.Probability.SLE.LoewnerCharts
+
+namespace OAI
+
+/-! The relative half-plane proper-arc consequence of the published
+Jordan--Schönflies theorem.  Reference: C. Thomassen, *The Jordan-Schönflies
+Theorem and the Classification of Surfaces*, Amer. Math. Monthly 99 (1992),
+116--130, Theorem 3.1, p. 123, DOI 10.1080/00029890.1992.11995820.
+
+The consequence used here is obtained by compactifying at infinity and
+applying the extension theorem to the two Jordan curves consisting of the
+proper arc and each real half-axis; the two extensions agree on their common
+arc and glue.  The real boundary is prescribed pointwise.  We parameterize
+this precise topological input explicitly.  It contains no SLE, ribbon,
+Brownian probability, harmonic measure or angle estimate. -/
+
+noncomputable section
+open Set Filter
+open scoped Topology NNReal
+
+namespace SLEExactGauge
+
+def PublishedHalfPlaneCrosscutStraightening : Prop :=
+  ∀ β : ℝ≥0 → ℂ, Continuous β → Function.Injective β → β 0 = 0 →
+    (∀ t : ℝ≥0, 0 < t → β t ∈ upperHalfPlane) →
+    Tendsto β atTop (cocompact ℂ) →
+    ∃ h : ℂ ≃ₜ ℂ, (∀ x : ℝ, h (x : ℂ) = (x : ℂ)) ∧
+      MapsTo h upperHalfPlane upperHalfPlane ∧
+      ∀ t : ℝ≥0, h (β t) = (t : ℂ) * Complex.I
+
+namespace CrosscutSides
+
+/-- Straightening identifies the entire interior zero set, including
+nonlocal pieces of the original access guide. -/
+theorem straightened_real_zero_iff
+    (β : ℝ≥0 → ℂ) (h : ℂ ≃ₜ ℂ)
+    (hH : MapsTo h upperHalfPlane upperHalfPlane)
+    (hβ : ∀ t : ℝ≥0, h (β t) = (t : ℂ) * Complex.I)
+    {z : ℂ} (hz : z ∈ upperHalfPlane) :
+    (h z).re = 0 ↔ ∃ t : ℝ≥0, 0 < t ∧ β t = z := by
+  constructor
+  · intro hre
+    have him : 0 < (h z).im := hH hz
+    let t : ℝ≥0 := ⟨(h z).im, him.le⟩
+    refine ⟨t, by exact_mod_cast him, h.injective ?_⟩
+    rw [hβ]
+    have ht : (t : ℂ) = ((h z).im : ℂ) := by norm_cast
+    rw [ht]
+    apply Complex.ext <;> simp [hre]
+  · rintro ⟨t, _, rfl⟩
+    rw [hβ]
+    simp
+
+theorem straightening_preserves_real_exit_limit
+    {ι : Type*} {l : Filter ι} (h : ℂ ≃ₜ ℂ)
+    (hreal : ∀ x : ℝ, h (x : ℂ) = (x : ℂ))
+    (f : ι → ℂ) (x : ℝ) (hf : Tendsto f l (𝓝 (x : ℂ))) :
+    Tendsto (fun i => (h (f i)).re) l (𝓝 x) := by
+  simpa only [Function.comp_def, hreal, Complex.ofReal_re] using
+    (Complex.continuous_re.continuousAt.comp h.continuous.continuousAt).tendsto.comp hf
+
+end CrosscutSides
+end SLEExactGauge
+
+end
+
+end OAI
diff --git a/lean/OAI/Probability/SLE/Geometry/PublishedFiniteBoundaryExtension.lean b/lean/OAI/Probability/SLE/Geometry/PublishedFiniteBoundaryExtension.lean
new file mode 100644
index 0000000000000000000000000000000000000000..fb36862b359a0b05848700e8da443a64d936cbf8
--- /dev/null
+++ b/lean/OAI/Probability/SLE/Geometry/PublishedFiniteBoundaryExtension.lean
@@ -0,0 +1,90 @@
+import OAI.Probability.SLE.Geometry.RandomBoundaryTubes
+
+namespace OAI
+
+/-! The finite-valued form of Rohde--Schramm, *Basic properties of SLE*,
+Annals of Mathematics 161 (2005), Theorem 4.1, pp. 898--899. The theorem
+extends the inverse Loewner map continuously to the closed half-plane.
+Keeping its values in `ℂ` allows arbitrary deterministic stopped charts
+to act on an entire fresh continuous trace, before any passage event is
+selected. This is an explicit published input, not a continuation or
+passage estimate. -/
+
+noncomputable section
+open Set Filter MeasureTheory
+open scoped Topology NNReal
+
+namespace SLEExactGauge
+
+local instance : LocallyCompactSpace closedHalfPlane :=
+  isClosed_closedHalfPlane.locallyCompactSpace
+local instance finiteBoundaryComplexPathMeasurable : MeasurableSpace C(ℝ≥0, ℂ) := borel _
+local instance finiteBoundaryComplexPathBorel : BorelSpace C(ℝ≥0, ℂ) := ⟨rfl⟩
+local instance finiteBoundaryClosedPathMeasurable : MeasurableSpace C(ℝ≥0, closedHalfPlane) := borel _
+local instance finiteBoundaryClosedPathBorel : BorelSpace C(ℝ≥0, closedHalfPlane) := ⟨rfl⟩
+
+def PublishedFiniteLoewnerBoundaryExtension : Prop :=
+  ∀ (U : ℝ≥0 → ℝ) (γ : ℝ≥0 → ℂ) (G F : ℝ≥0 → ℂ → ℂ),
+    Continuous U → IsCapacityTwoWitness U γ G F →
+    ∀ t : ℝ≥0, ∃ Fbar : ℂ → ℂ,
+      ContinuousOn Fbar closedHalfPlane ∧
+      (∀ z ∈ upperHalfPlane, Fbar z = F t z) ∧
+      Fbar (U t : ℂ) = γ t
+
+theorem PublishedFiniteLoewnerBoundaryExtension.to_onePoint
+    (h : PublishedFiniteLoewnerBoundaryExtension) : PublishedLoewnerBoundaryExtension := by
+  intro U γ G F hU hw t
+  obtain ⟨Fb, hc, he, ht⟩ := h U γ G F hU hw t
+  exact ⟨fun z => (Fb z : OnePoint ℂ), OnePoint.continuous_coe.comp_continuousOn hc,
+    fun z hz => congrArg (fun w : ℂ => (w : OnePoint ℂ)) (he z hz),
+    congrArg (fun w : ℂ => (w : OnePoint ℂ)) ht⟩
+
+theorem normalized_finite_capacity_inverse_boundary_extension
+    (hpublished : PublishedFiniteLoewnerBoundaryExtension)
+    {U : ℝ≥0 → ℝ} {γ : ℝ≥0 → ℂ} {G F : ℝ≥0 → ℂ → ℂ}
+    (hU : Continuous U) (hw : IsCapacityTwoWitness U γ G F)
+    (t : ℝ≥0) (c : ℝ) (hc : 0 < c) :
+    ∃ Fbar : C(closedHalfPlane, ℂ),
+      (∀ z : closedHalfPlane, z.1 ∈ upperHalfPlane →
+        Fbar z = F t ((U t : ℂ) + (c : ℂ) * z)) ∧
+      Fbar ⟨0, by simp [closedHalfPlane]⟩ = γ t := by
+  obtain ⟨Fb, hFb, hext, htip⟩ := hpublished U γ G F hU hw t
+  let A : ℂ → ℂ := fun z => (U t : ℂ) + (c : ℂ) * z
+  have hA : Continuous A := continuous_const.add (continuous_const.mul continuous_id)
+  have him (z : ℂ) : (A z).im = c * z.im := by simp [A]
+  have hAc : MapsTo A closedHalfPlane closedHalfPlane := by
+    intro z hz
+    change 0 ≤ (A z).im
+    rw [him]
+    exact mul_nonneg hc.le hz
+  let Fbar : C(closedHalfPlane, ℂ) := ⟨fun z => Fb (A z),
+    (hFb.comp hA.continuousOn hAc).domRestrict⟩
+  refine ⟨Fbar, ?_, ?_⟩
+  · intro z hz
+    exact hext _ (by change 0 < (A z).im; rw [him]; exact mul_pos hc hz)
+  · change Fb ((U t : ℂ) + (c : ℂ) * 0) = γ t
+    simpa only [mul_zero, add_zero] using htip
+
+/-- A finite boundary chart acts measurably on continuous trace paths. -/
+def finiteBoundaryPath (Fbar : C(closedHalfPlane, ℂ))
+    (p : C(ℝ≥0, ℂ)) : C(ℝ≥0, ℂ) := Fbar.comp (liftClosedPath p)
+
+theorem measurable_finiteBoundaryPath (Fbar : C(closedHalfPlane, ℂ)) :
+    Measurable (finiteBoundaryPath Fbar) := by
+  apply ContinuousMap.measurable_iff_eval.mpr
+  intro t
+  exact Fbar.continuous.measurable.comp
+    ((continuous_eval_const t).measurable.comp measurable_liftClosedPath)
+
+theorem finiteBoundaryPath_apply (Fbar : C(closedHalfPlane, ℂ))
+    (p : C(ℝ≥0, ℂ)) (hp : ClosedPathProperty p) (t : ℝ≥0) :
+    finiteBoundaryPath Fbar p t = Fbar ⟨p t, hp t⟩ := by
+  change Fbar (liftClosedPath p t) = _
+  congr 1
+  exact Subtype.ext (liftClosedPath_apply p hp t)
+
+end SLEExactGauge
+
+end
+
+end OAI
diff --git a/lean/OAI/Probability/SLE/Geometry/PublishedInputs.lean b/lean/OAI/Probability/SLE/Geometry/PublishedInputs.lean
new file mode 100644
index 0000000000000000000000000000000000000000..661c49bd0d02342b0cca6a027b38bf186575d0ad
--- /dev/null
+++ b/lean/OAI/Probability/SLE/Geometry/PublishedInputs.lean
@@ -0,0 +1,57 @@
+import OAI.Probability.SLE.Gauge.LargerGaugeMain
+
+namespace OAI
+
+/-!
+Precisely specialized published input for a Brownian-driven presentation.
+
+S. Rohde and O. Schramm, *Basic properties of SLE*, Annals of Mathematics
+161 (2005), 883–924, Theorem 5.1 (Continuity), p. 899;
+https://annals.math.princeton.edu/wp-content/uploads/annals-v161-n2-p07.pdf.
+
+Only existence of a measurable continuous capacity-two trace is requested.
+The Loewner equations and inverse-tip limit in `IsCapacityTwoTrace` fix its
+normalization. No Hausdorff bound is included in this input. It is a parameter
+of the conditional theorem below, not a global axiom.
+-/
+
+noncomputable section
+open Set Filter MeasureTheory
+open scoped Topology ENNReal NNReal
+
+namespace SLEExactGauge
+
+/-- The consequence of Rohde–Schramm Theorem 5.1 needed to pass from a
+Brownian driver to the continuous trace convention used in this development. -/
+def PublishedTraceGeneration
+    {Ω : Type*} [MeasurableSpace Ω] (P : Measure Ω)
+    (κ : ℝ) (B : ℝ≥0 → Ω → ℝ) : Prop :=
+  ∃ γ : Ω → ℝ≥0 → ℂ,
+    (∀ t, Measurable (fun ω => γ ω t)) ∧
+    ∀ᵐ ω ∂P, IsCapacityTwoTrace (fun t => Real.sqrt κ * B t ω) (γ ω)
+
+/-- The actual larger-gauge main corollary, conditional only on the published
+trace-generation input when starting from a Brownian driver. -/
+theorem larger_gauge_corollary_of_published_trace_generation
+    {Ω : Type*} [MeasurableSpace Ω] (P : Measure Ω) [IsProbabilityMeasure P]
+    (κ : ℝ) (hκ : 0 < κ) (hκ8 : κ < 8)
+    (B : ℝ≥0 → Ω → ℝ) (hB : ProbabilityTheory.IsBrownianReal B P)
+    (hpublished : PublishedTraceGeneration P κ B) :
+    ∃ γ : Ω → ℝ≥0 → ℂ, IsOrdinaryChordalSLE κ γ P ∧
+      ∀ᵐ ω ∂P, ∀ s t : ℝ≥0, 0 < s → s < t →
+        (¬ SigmaFinite ((hausdorffGauge (schrammGauge κ)).restrict
+          (segment (γ ω) s t))) ∧
+        hausdorffGauge (schrammGauge κ) (segment (γ ω) s t) = ∞ := by
+  obtain ⟨γ, hm, htrace⟩ := hpublished
+  have hSLE : IsOrdinaryChordalSLE κ γ P := ⟨hm, B, hB, htrace⟩
+  refine ⟨γ, hSLE, ?_⟩
+  filter_upwards [schramm_gauge_not_sigmaFinite_on_all_segments P κ hκ hκ8 γ hSLE,
+    schramm_gauge_infinite_on_all_segments P κ hκ hκ8 γ hSLE]
+    with ω hσ hinfinite s t hs hst
+  exact ⟨hσ s t hs hst, hinfinite s t hs hst⟩
+
+end SLEExactGauge
+
+end
+
+end OAI
diff --git a/lean/OAI/Probability/SLE/Geometry/PublishedPlanarDiskOpenness.lean b/lean/OAI/Probability/SLE/Geometry/PublishedPlanarDiskOpenness.lean
new file mode 100644
index 0000000000000000000000000000000000000000..e3577aebdede5633f9476df8529c71e0e3184361
--- /dev/null
+++ b/lean/OAI/Probability/SLE/Geometry/PublishedPlanarDiskOpenness.lean
@@ -0,0 +1,24 @@
+import Mathlib
+
+namespace OAI
+
+/-! The planar-disk specialization of invariance of domain used for an
+embedded ribbon coordinate patch. This is an explicit published parameter,
+not a new axiom. Reference: A. Hatcher, Algebraic Topology (Cambridge, 2002),
+Theorem 2B.3, p. 172, specialized to n=2 and an open Euclidean disk.
+https://pi.math.cornell.edu/~hatcher/AT/ATch2.pdf -/
+
+noncomputable section
+open Set Metric
+
+namespace SLEExactGauge
+
+def PublishedPlanarDiskOpenness : Prop :=
+  ∀ (P : ℂ → ℂ) (x : ℂ) (r : ℝ), 0 < r →
+    ContinuousOn P (ball x r) → InjOn P (ball x r) → IsOpen (P '' ball x r)
+
+end SLEExactGauge
+
+end
+
+end OAI
diff --git a/lean/OAI/Probability/SLE/Geometry/PublishedWienerSupport.lean b/lean/OAI/Probability/SLE/Geometry/PublishedWienerSupport.lean
new file mode 100644
index 0000000000000000000000000000000000000000..fdd22cfaf5127996cbed8303b8b3897289849e6c
--- /dev/null
+++ b/lean/OAI/Probability/SLE/Geometry/PublishedWienerSupport.lean
@@ -0,0 +1,85 @@
+import OAI.Probability.SLE.MomentGauge
+import OAI.Probability.SLE.Geometry.CompactTubeProbability
+import Mathlib.Topology.ContinuousMap.Compact
+
+namespace OAI
+
+/-! The finite-window planar Brownian support input.
+
+Millet--Sanz-Sole (1994), A simple proof of the support theorem for
+diffusion processes, Seminaire de Probabilites XXVIII, Theorem 3.5,
+p. 47: specialize to dimension two, identity diffusion and zero drift.
+Only positivity of uniform tubes about based continuous paths on [0,1]
+is retained. The product of two real Wiener laws is the planar law.
+The Hölder support statement implies this weaker uniform-topology
+consequence, using density of polygonal Cameron--Martin paths.
+https://www.numdam.org/article/SPS_1994__28__36_0.pdf
+-/
+
+noncomputable section
+open Set Metric MeasureTheory
+open scoped Topology NNReal ENNReal BoundedContinuousFunction
+
+namespace SLEExactGauge
+open Target
+
+local instance wienerDriverSecondCountable : SecondCountableTopology Driver :=
+  ContinuousMapZero.isEmbedding_toContinuousMap.secondCountableTopology
+
+local instance wienerUnitMeasurableSpace : MeasurableSpace (unitInterval →ᵇ ℂ) := borel _
+local instance wienerUnitBorelSpace : BorelSpace (unitInterval →ᵇ ℂ) := ⟨rfl⟩
+
+def planarUnitPath (b : Driver × Driver) : unitInterval →ᵇ ℂ :=
+  BoundedContinuousFunction.mkOfCompact
+    ⟨fun t => (b.1 ⟨(t : ℝ), t.property.1⟩ : ℂ) +
+      (b.2 ⟨(t : ℝ), t.property.1⟩ : ℂ) * Complex.I, by fun_prop⟩
+
+theorem continuous_planarUnitPath : Continuous planarUnitPath := by
+  have hc : Continuous (fun b : Driver × Driver =>
+      (⟨fun t : unitInterval => (b.1 ⟨(t : ℝ), t.property.1⟩ : ℂ) +
+        (b.2 ⟨(t : ℝ), t.property.1⟩ : ℂ) * Complex.I, by fun_prop⟩ : C(unitInterval, ℂ))) := by
+    apply ContinuousMap.continuous_of_continuous_uncurry
+    change Continuous (fun z : (Driver × Driver) × unitInterval =>
+      (z.1.1 ⟨(z.2 : ℝ), z.2.property.1⟩ : ℂ) +
+        (z.1.2 ⟨(z.2 : ℝ), z.2.property.1⟩ : ℂ) * Complex.I)
+    fun_prop
+  exact (ContinuousMap.isometryEquivBoundedOfCompact unitInterval ℂ).continuous.comp hc
+
+/-- A precise published input about ordinary planar Brownian motion,
+without any ribbon geometry or uniform-in-route probability conclusion. -/
+def PublishedPlanarWienerUnitSupport : Prop :=
+  ∀ W : WienerLaw, IsWiener W → ∀ f : unitInterval →ᵇ ℂ, f 0 = 0 →
+    ∀ r : ℝ, 0 < r → 0 < (W.prod W) (planarUnitPath ⁻¹' ball f r)
+
+/-- The uniform probability needed for the bounded-speed physical route
+family is derived from the pointwise published support statement. -/
+theorem uniform_planarWiener_tube_probability
+    (hpublished : PublishedPlanarWienerUnitSupport)
+    (W : WienerLaw) (hW : IsWiener W) (C : ℝ≥0) {ε : ℝ} (hε : 0 < ε) :
+    ∃ q : ℝ≥0∞, 0 < q ∧ ∀ f : unitInterval →ᵇ ℂ,
+      LipschitzWith C f → f 0 = 0 → q ≤ (W.prod W)
+        {b | ∀ t : unitInterval, dist (planarUnitPath b t) (f t) < ε} := by
+  have hm := continuous_planarUnitPath.measurable
+  have hs : ∀ f : unitInterval →ᵇ ℂ, f 0 = 0 → ∀ r : ℝ, 0 < r →
+      0 < Measure.map planarUnitPath (W.prod W) (ball f r) := by
+    intro f hf r hr
+    rw [Measure.map_apply hm isOpen_ball.measurableSet]
+    exact hpublished W hW f hf r hr
+  obtain ⟨q, hq, hbound⟩ := CompactRouteTubes.uniform_tube_probability_of_based_support
+    (Measure.map planarUnitPath (W.prod W)) C hε hs
+  refine ⟨q, hq, ?_⟩
+  intro f hf hf0
+  have he : {g : unitInterval →ᵇ ℂ | ∀ t, dist (g t) (f t) < ε} = ball f ε := by
+    ext g
+    exact (BoundedContinuousFunction.dist_lt_iff_of_compact hε).symm
+  have hb := hbound f hf hf0
+  rw [he, Measure.map_apply hm isOpen_ball.measurableSet] at hb
+  exact hb.trans (measure_mono (by
+    intro b hb t
+    exact (BoundedContinuousFunction.dist_coe_le_dist t).trans_lt hb))
+
+end SLEExactGauge
+
+end
+
+end OAI
diff --git a/lean/OAI/Probability/SLE/Geometry/PuncturedDiskHomeomorph.lean b/lean/OAI/Probability/SLE/Geometry/PuncturedDiskHomeomorph.lean
new file mode 100644
index 0000000000000000000000000000000000000000..ffbbd9a4c2adc6e958ffe2c13a0d63c1d21424b5
--- /dev/null
+++ b/lean/OAI/Probability/SLE/Geometry/PuncturedDiskHomeomorph.lean
@@ -0,0 +1,57 @@
+import Mathlib.Analysis.Complex.Basic
+import Mathlib.Topology.Homeomorph.Lemmas
+import Mathlib.Topology.Instances.ENNReal.Lemmas
+
+namespace OAI
+
+/-! Restrict a closed-disk homeomorphism fixing infinity to the punctured disk. -/
+noncomputable section
+open Set Complex Metric
+
+namespace SLEExactGauge
+
+lemma closedDisk_map_ne_one
+    (e : closedBall (0:ℂ) 1 ≃ₜ closedBall (0:ℂ) 1)
+    (h1 : e ⟨1,by norm_num⟩=⟨1,by norm_num⟩)
+    (z : closedBall (0:ℂ) 1) (hz : (z:ℂ) ≠ 1) : (e z:ℂ) ≠ 1 := by
+  intro he
+  apply hz
+  have hh : e z=e ⟨1,by norm_num⟩ := (Subtype.ext he).trans h1.symm
+  exact congrArg Subtype.val (e.injective hh)
+
+def puncturedDiskHomeomorph
+    (e : closedBall (0:ℂ) 1 ≃ₜ closedBall (0:ℂ) 1)
+    (h1 : e ⟨1,by norm_num⟩=⟨1,by norm_num⟩) :
+    {w : ℂ // ‖w‖ ≤ 1 ∧ w ≠ 1} ≃ₜ {w : ℂ // ‖w‖ ≤ 1 ∧ w ≠ 1} := by
+  let lift (w : {w : ℂ // ‖w‖ ≤ 1 ∧ w ≠ 1}) : closedBall (0:ℂ) 1 :=
+    ⟨w,by simpa only [mem_closedBall,dist_zero_right] using w.property.1⟩
+  have hlift : Continuous lift := continuous_subtype_val.subtype_mk _
+  have h1i : e.symm ⟨1,by norm_num⟩=⟨1,by norm_num⟩ := by
+    have hh := congrArg e.symm h1
+    rw [e.symm_apply_apply] at hh
+    exact hh.symm
+  let f (w : {w : ℂ // ‖w‖ ≤ 1 ∧ w ≠ 1}) : ℂ := e (lift w)
+  let g (w : {w : ℂ // ‖w‖ ≤ 1 ∧ w ≠ 1}) : ℂ := e.symm (lift w)
+  have hf (w : {w : ℂ // ‖w‖ ≤ 1 ∧ w ≠ 1}) : ‖f w‖ ≤ 1 ∧ f w ≠ 1 := by
+    refine ⟨?_,closedDisk_map_ne_one e h1 (lift w) w.property.2⟩
+    simpa only [mem_closedBall,dist_zero_right] using (e (lift w)).property
+  have hg (w : {w : ℂ // ‖w‖ ≤ 1 ∧ w ≠ 1}) : ‖g w‖ ≤ 1 ∧ g w ≠ 1 := by
+    refine ⟨?_,closedDisk_map_ne_one e.symm h1i (lift w) w.property.2⟩
+    simpa only [mem_closedBall,dist_zero_right] using (e.symm (lift w)).property
+  exact
+    { toFun := fun w => ⟨f w,hf w⟩
+      invFun := fun w => ⟨g w,hg w⟩
+      left_inv := fun w => by
+        apply Subtype.ext
+        exact congrArg (fun z : closedBall (0:ℂ) 1 => (z:ℂ)) (e.symm_apply_apply (lift w))
+      right_inv := fun w => by
+        apply Subtype.ext
+        exact congrArg (fun z : closedBall (0:ℂ) 1 => (z:ℂ)) (e.apply_symm_apply (lift w))
+      continuous_toFun := (continuous_subtype_val.comp (e.continuous.comp hlift)).subtype_mk _
+      continuous_invFun := (continuous_subtype_val.comp (e.symm.continuous.comp hlift)).subtype_mk _ }
+
+end SLEExactGauge
+
+end
+
+end OAI
diff --git a/lean/OAI/Probability/SLE/Geometry/RadiusCellTail.lean b/lean/OAI/Probability/SLE/Geometry/RadiusCellTail.lean
new file mode 100644
index 0000000000000000000000000000000000000000..26290dec6bad21c87663970047074bd50f826eb9
--- /dev/null
+++ b/lean/OAI/Probability/SLE/Geometry/RadiusCellTail.lean
@@ -0,0 +1,109 @@
+import OAI.Probability.SLE.Geometry.FiniteCellTailKernel
+import OAI.Probability.SLE.Geometry.ExtendedDiskAngle
+
+namespace OAI
+
+/-! The physical cell-tail bound at a literal, possibly infinite radius
+start. Finite cutoffs exhaust the actual centered law. -/
+noncomputable section
+open Set Filter _root_.MeasureTheory _root_.OAI.MeasureTheory ProbabilityTheory Metric
+open scoped Topology NNReal ENNReal
+
+namespace SLEExactGauge.Multipoint
+local instance cellTailRadiusMeasurable : MeasurableSpace C(ℝ≥0,ℝ) := borel _
+local instance cellTailRadiusBorel : BorelSpace C(ℝ≥0,ℝ) := ⟨rfl⟩
+
+theorem CanonicalMass.cell_mass_disk_tail_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)
+    (K : Set ℂ) (hK : MeasurableSet K) (hKball : K⊆closedBall z (2*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 →
+      finiteCenteredLaw P κ B γ G z (u+v)
+        (A∩C.finiteCellMassTest (fun ω => radiusLevelTime (γ ω) (G ω) z (u+v)) K
+          (ENNReal.ofReal (((32768*Real.pi)*r)^dimension κ)*ENNReal.ofReal b)) ≤
+      ∫⁻ ω 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) := 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.finiteCellMassTest (fun ω => radiusLevelTime (γ ω) (G ω) z (u+v)) K
+    (ENNReal.ofReal (((32768*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 : ℕ) : Q (E n∩test) ≤ ∫⁻ ω in E n, f ω ∂Q := by
+    let τ := cutoffStop σ n
+    have hτ := cutoffStop_stopping ℱ σ hσ (n:ℝ≥0)
+    have hEn := 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.finite_cell_mass_disk_tail 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) K hK hKball 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
+  have hcover := stopped_past_cover_of_ae_finite Q σ hfinite A
+  have hcover' : A∩test =ᵐ[Q] (⋃ n, E n)∩test := by
+    filter_upwards [hcover] with ω hω
+    exact propext (and_congr_left fun _ => Iff.of_eq hω)
+  have hmono' : Monotone (fun n => E n∩test) := fun _ _ h => inter_subset_inter (hmono h) subset_rfl
+  calc
+    Q (A∩test)=Q ((⋃ n, E n)∩test) := measure_congr hcover'
+    _ = Q (⋃ n, E n∩test) := by rw [iUnion_inter]
+    _ = ⨆ n, Q (E n∩test) := hmono'.measure_iUnion
+    _ ≤ ∫⁻ ω in A, f ω ∂Q := iSup_le fun n =>
+      (hbound n).trans (lintegral_mono_set inter_subset_left)
+
+end SLEExactGauge.Multipoint
+
+end
+
+end OAI
diff --git a/lean/OAI/Probability/SLE/Geometry/RandomBoundaryTubes.lean b/lean/OAI/Probability/SLE/Geometry/RandomBoundaryTubes.lean
new file mode 100644
index 0000000000000000000000000000000000000000..f51b4833a6337115522c0201e019b92ad1d2548e
--- /dev/null
+++ b/lean/OAI/Probability/SLE/Geometry/RandomBoundaryTubes.lean
@@ -0,0 +1,207 @@
+import OAI.Probability.SLE.Geometry.StoppedBoundaryMeasurability
+import OAI.Probability.SLE.Geometry.RandomRestartEvents
+import OAI.Probability.SLE.Geometry.GeometricTubeSupport
+
+namespace OAI
+
+/-! Measurable continuation tubes whose physical boundary charts depend on
+the stopped past. Positivity of each section uses the published geometric
+support theorem only for one fixed open tube at a time. -/
+
+noncomputable section
+open Set Filter MeasureTheory TopologicalSpace
+open scoped Topology NNReal ENNReal
+
+namespace SLEExactGauge
+
+local instance : LocallyCompactSpace closedHalfPlane :=
+  isClosed_closedHalfPlane.locallyCompactSpace
+
+def ClosedPathProperty (p : C(ℝ≥0, ℂ)) : Prop := ∀ t, 0 ≤ (p t).im
+
+theorem isClosed_closedPathProperty : IsClosed {p | ClosedPathProperty p} := by
+  have he : {p | ClosedPathProperty p} =
+      ⋂ t : ℝ≥0, {p : C(ℝ≥0, ℂ) | 0 ≤ (p t).im} := by
+    ext p
+    simp only [ClosedPathProperty, mem_ofPred_eq, mem_iInter]
+  rw [he]
+  exact isClosed_iInter fun t =>
+    isClosed_le continuous_const (Complex.continuous_im.comp (continuous_eval_const t))
+
+/-- Give arbitrary continuous paths a measurable closed-half-plane version.
+On every actual chordal trace this is precisely the original path. -/
+def liftClosedPath (p : C(ℝ≥0, ℂ)) : C(ℝ≥0, closedHalfPlane) := by
+  classical
+  exact if hp : ClosedPathProperty p then
+    ⟨fun t => ⟨p t, hp t⟩, p.continuous.subtype_mk _⟩
+  else ContinuousMap.const _ ⟨0, by simp [closedHalfPlane]⟩
+
+theorem liftClosedPath_apply (p : C(ℝ≥0, ℂ)) (hp : ClosedPathProperty p)
+    (t : ℝ≥0) : (liftClosedPath p t : ℂ) = p t := by
+  simp [liftClosedPath, hp]
+
+theorem measurable_liftClosedPath : Measurable liftClosedPath := by
+  classical
+  apply ContinuousMap.measurable_iff_eval.mpr
+  intro t
+  have hf : Measurable (fun p : {p : C(ℝ≥0, ℂ) | ClosedPathProperty p} =>
+      (⟨p.1 t, p.2 t⟩ : closedHalfPlane)) :=
+    ((ContinuousMap.measurable_eval t).comp measurable_subtype_coe).subtype_mk
+  convert hf.dite (g := fun _ => (⟨0, by simp [closedHalfPlane]⟩ : closedHalfPlane))
+    measurable_const isClosed_closedPathProperty.measurableSet using 1
+  funext p
+  by_cases hp : ClosedPathProperty p <;> simp [liftClosedPath, hp]
+
+def pathTubeEventIn {Y : Type*} [TopologicalSpace Y] (O W : Set Y) :
+    Set C(ℝ≥0, Y) :=
+  {p | ∃ T : ℝ≥0, 0 < T ∧ MapsTo p (Icc 0 T) O ∧ p T ∈ W}
+
+theorem isOpen_pathTubeEventIn {Y : Type*} [TopologicalSpace Y]
+    {O W : Set Y} (hO : IsOpen O) (hW : IsOpen W) :
+    IsOpen (pathTubeEventIn O W) := by
+  have he : pathTubeEventIn O W = ⋃ T : ℝ≥0, ⋃ (_ : 0 < T),
+      {p : C(ℝ≥0, Y) | MapsTo p (Icc 0 T) O} ∩
+        (fun p : C(ℝ≥0, Y) => p T) ⁻¹' W := by
+    ext p
+    simp only [pathTubeEventIn, mem_ofPred_eq, mem_iUnion, mem_inter_iff, mem_preimage]
+    constructor <;> rintro ⟨T, hT, hN, hV⟩ <;> exact ⟨T, hT, hN, hV⟩
+  rw [he]
+  exact isOpen_iUnion fun T => isOpen_iUnion fun _ =>
+    (ContinuousMap.isOpen_setOfPred_mapsTo isCompact_Icc hO).inter
+      (hW.preimage (continuous_eval_const T))
+
+def randomBoundaryTubeSet {Ω : Type*}
+    (Fb : Ω → C(closedHalfPlane, OnePoint ℂ)) (O W : Set (OnePoint ℂ)) :
+    Set (Ω × C(ℝ≥0, closedHalfPlane)) :=
+  {x | (Fb x.1).comp x.2 ∈ pathTubeEventIn O W}
+
+theorem measurableSet_randomBoundaryTubeSet
+    {Ω : Type*} [MeasurableSpace Ω]
+    (Fb : Ω → C(closedHalfPlane, OnePoint ℂ)) (hFb : Measurable Fb)
+    {O W : Set (OnePoint ℂ)} (hO : IsOpen O) (hW : IsOpen W) :
+    MeasurableSet (randomBoundaryTubeSet Fb O W) := by
+  have hc : Continuous (fun x : C(ℝ≥0, closedHalfPlane) ×
+      C(closedHalfPlane, OnePoint ℂ) => x.2.comp x.1) := ContinuousMap.continuous_comp'
+  exact (isOpen_pathTubeEventIn hO hW).measurableSet.preimage
+    (hc.measurable.comp (measurable_snd.prodMk (hFb.comp measurable_fst)))
+
+/-- Each physical open continuation has positive probability under the
+fresh trace law once one simple parameter route lies in it. -/
+theorem boundary_tube_positive_of_geometric_support
+    {Ω : Type*} [MeasurableSpace Ω] (P : Measure Ω)
+    (gp : Ω → C(ℝ≥0, ℂ)) (hclosed : ∀ ω, ClosedPathProperty (gp ω))
+    (hsupport : PublishedGeometricTubeSupport P (fun ω => gp ω))
+    (Fb : C(closedHalfPlane, OnePoint ℂ))
+    (O W : Set (OnePoint ℂ)) (hO : IsOpen O) (hW : IsOpen W)
+    (z : ℂ) (p : Path (0 : ℂ) z) (hinj : Function.Injective p)
+    (hpH : ∀ t, t ≠ 0 → p t ∈ upperHalfPlane)
+    (hroute : ∀ t, Fb ⟨p t, by
+      by_cases ht : t = 0
+      · simp [ht, closedHalfPlane]
+      · exact (show 0 < (p t).im from hpH t ht).le⟩ ∈ O)
+    (hend : Fb ⟨z, by simpa using (show 0 < (p 1).im from hpH 1 (by norm_num)).le⟩ ∈ W) :
+    0 < P {ω | Fb.comp (liftClosedPath (gp ω)) ∈ pathTubeEventIn O W} := by
+  obtain ⟨N, hN, hNe⟩ := isOpen_induced_iff.mp (hO.preimage Fb.continuous)
+  obtain ⟨V, hV, hVe⟩ := isOpen_induced_iff.mp (hW.preimage Fb.continuous)
+  have hpclosed (t : unitInterval) : p t ∈ closedHalfPlane := by
+    by_cases ht : t = 0
+    · simp [ht, closedHalfPlane]
+    · exact (show 0 < (p t).im from hpH t ht).le
+  have hNr : range p ⊆ N := by
+    rintro _ ⟨t, rfl⟩
+    have ht := hroute t
+    change (⟨p t, hpclosed t⟩ : closedHalfPlane) ∈ Fb ⁻¹' O at ht
+    rw [← hNe] at ht
+    exact ht
+  have hzV : z ∈ V := by
+    change (⟨z, by simpa using (show 0 < (p 1).im from hpH 1 (by norm_num)).le⟩ : closedHalfPlane) ∈
+      Fb ⁻¹' W at hend
+    rw [← hVe] at hend
+    exact hend
+  apply (hsupport z p hinj hpH N V hN hV hNr hzV).trans_le
+  apply measure_mono
+  rintro ω ⟨T, hT, htrace, hlast⟩
+  refine ⟨T, hT, ?_, ?_⟩
+  · intro t ht
+    have hn : liftClosedPath (gp ω) t ∈ Subtype.val ⁻¹' N := by
+      change (liftClosedPath (gp ω) t : ℂ) ∈ N
+      rw [liftClosedPath_apply _ (hclosed ω)]
+      exact htrace ht
+    rw [hNe] at hn
+    exact hn
+  · have hv : liftClosedPath (gp ω) T ∈ Subtype.val ⁻¹' V := by
+      change (liftClosedPath (gp ω) T : ℂ) ∈ V
+      rw [liftClosedPath_apply _ (hclosed ω)]
+      exact hlast
+    rw [hVe] at hv
+    exact hv
+
+/-- The restricted restart law also holds after applying the measurable
+closed-half-plane lift to the fresh path. -/
+theorem restart_law_liftClosedPath
+    {Ω : Type*} [mΩ : MeasurableSpace Ω] (P : Measure Ω)
+    (m : MeasurableSpace Ω)
+    (Y gp : Ω → C(ℝ≥0, ℂ)) (hY : Measurable[mΩ] Y) (hgp : Measurable[mΩ] gp)
+    (hlaw : ∀ A : Set Ω, MeasurableSet[m] A →
+      @Measure.map Ω C(ℝ≥0, ℂ) mΩ _ Y (P.restrict A) =
+        P A • @Measure.map Ω C(ℝ≥0, ℂ) mΩ _ gp P) :
+    ∀ A : Set Ω, MeasurableSet[m] A →
+      @Measure.map Ω C(ℝ≥0, closedHalfPlane) mΩ _ (liftClosedPath ∘ Y) (P.restrict A) =
+        P A • @Measure.map Ω C(ℝ≥0, closedHalfPlane) mΩ _ (liftClosedPath ∘ gp) P := by
+  let : MeasurableSpace Ω := mΩ
+  intro A hA
+  rw [← Measure.map_map measurable_liftClosedPath hY, hlaw A hA,
+    Measure.map_smul _ measurable_liftClosedPath.aemeasurable,
+    Measure.map_map measurable_liftClosedPath hgp]
+
+/-- No uniform support constant is needed for random pasts. Pointwise
+simple access routes imply strictly positive conditional passage probability.
+-/
+theorem conditional_random_boundary_tube_positive
+    {Ω : Type*} [mΩ : MeasurableSpace Ω]
+    (P : Measure Ω) [IsFiniteMeasure P]
+    (m : MeasurableSpace Ω) (hm : m ≤ mΩ)
+    (Y gp : Ω → C(ℝ≥0, ℂ)) (hY : Measurable[mΩ] Y) (hgp : Measurable[mΩ] gp)
+    (hlaw : ∀ A : Set Ω, MeasurableSet[m] A →
+      @Measure.map Ω C(ℝ≥0, ℂ) mΩ _ Y (P.restrict A) =
+        P A • @Measure.map Ω C(ℝ≥0, ℂ) mΩ _ gp P)
+    (hclosed : ∀ ω, ClosedPathProperty (gp ω))
+    (hsupport : @PublishedGeometricTubeSupport Ω mΩ P (fun ω => gp ω))
+    (Fb : Ω → C(closedHalfPlane, OnePoint ℂ)) (hFb : Measurable[m] Fb)
+    (O W : Set (OnePoint ℂ)) (hO : IsOpen O) (hW : IsOpen W)
+    (E : Set Ω)
+    (hgeometry : ∀ ω ∈ E, ∃ z : ℂ, ∃ p : Path (0 : ℂ) z,
+      Function.Injective p ∧
+      ∃ hpH : ∀ t, t ≠ 0 → p t ∈ upperHalfPlane,
+        (∀ t, Fb ω ⟨p t, by
+          by_cases ht : t = 0
+          · simp [ht, closedHalfPlane]
+          · exact (show 0 < (p t).im from hpH t ht).le⟩ ∈ O) ∧
+        Fb ω ⟨z, by simpa using (show 0 < (p 1).im from hpH 1 (by norm_num)).le⟩ ∈ W) :
+    ∀ᵐ ω ∂P, ω ∈ E →
+      0 < P⁻[({ω | (Fb ω).comp (liftClosedPath (Y ω)) ∈
+        pathTubeEventIn O W}).indicator (fun _ => 1) | m] ω := by
+  let : MeasurableSpace Ω := mΩ
+  let ν := P.map (liftClosedPath ∘ gp)
+  have hC := @measurableSet_randomBoundaryTubeSet Ω m Fb hFb O W hO hW
+  apply conditional_passage_positive_of_random_sections P ν m hm
+    (liftClosedPath ∘ Y) (measurable_liftClosedPath.comp hY)
+    (restart_law_liftClosedPath P m Y gp hY hgp hlaw) E
+    (randomBoundaryTubeSet Fb O W) hC
+  apply Eventually.of_forall
+  intro ω hω
+  obtain ⟨z, p, hinj, hpH, hroute, hend⟩ := hgeometry ω hω
+  have hs : MeasurableSet {x : C(ℝ≥0, closedHalfPlane) |
+      (Fb ω).comp x ∈ pathTubeEventIn O W} :=
+    hC.preimage measurable_prodMk_left
+  change 0 < P.map (liftClosedPath ∘ gp)
+    {x | (Fb ω).comp x ∈ pathTubeEventIn O W}
+  rw [Measure.map_apply (measurable_liftClosedPath.comp hgp) hs]
+  exact boundary_tube_positive_of_geometric_support P gp hclosed hsupport
+    (Fb ω) O W hO hW z p hinj hpH hroute hend
+
+end SLEExactGauge
+
+end
+
+end OAI
diff --git a/lean/OAI/Probability/SLE/Geometry/RandomKernelSupport.lean b/lean/OAI/Probability/SLE/Geometry/RandomKernelSupport.lean
new file mode 100644
index 0000000000000000000000000000000000000000..44560e541d3e5741b1a97418ccd4c6c303e31ca1
--- /dev/null
+++ b/lean/OAI/Probability/SLE/Geometry/RandomKernelSupport.lean
@@ -0,0 +1,96 @@
+import OAI.Probability.SLE.Geometry.RandomSpatialTestingAE
+import OAI.Probability.SLE.Mass.RadonTestFamily
+
+namespace OAI
+
+/-! A conditional measure kernel inherits the support of its past-measurable
+comparison kernel. Localization only uses finite compact masses. -/
+
+noncomputable section
+open Set Filter MeasureTheory ProbabilityTheory Classical
+open scoped ENNReal
+
+namespace SLEExactGauge
+
+lemma restricted_random_set_measurable
+    {Ω X : Type*} [MeasurableSpace Ω] [MeasurableSpace X]
+    (μ : Ω → Measure X) (hμ : Measurable μ) (K : Set X) (hK : MeasurableSet K)
+    (hfin : ∀ ω, μ ω K < ∞) (A : Set (Ω × X)) (hA : MeasurableSet A) :
+    Measurable (fun ω => (μ ω).restrict K (Prod.mk ω ⁻¹' A)) := by
+  have hm : Measurable (fun ω => (μ ω).restrict K) := by
+    apply Measure.measurable_of_measurable_coe
+    intro S hS
+    simp only [Measure.restrict_apply hS]
+    exact (Measure.measurable_coe (hS.inter hK)).comp hμ
+  let κ : Kernel Ω X := ⟨_,hm⟩
+  exact Kernel.measurable_kernel_prodMk_left_of_finite (κ := κ) hA
+    (fun ω => ⟨by
+      change (μ ω).restrict K univ < ∞
+      simpa only [Measure.restrict_apply_univ] using hfin ω⟩)
+
+lemma setLIntegral_random_indicator
+    {Ω X : Type*} [MeasurableSpace Ω] [MeasurableSpace X]
+    (μ : Measure X) (K : Set X) (A : Set (Ω × X)) (hA : MeasurableSet A) (ω : Ω) :
+    (∫⁻ x in K, A.indicator (fun _ => (1 : ℝ≥0∞)) (ω,x) ∂μ) =
+      μ.restrict K (Prod.mk ω ⁻¹' A) := by
+  have he : (fun x => A.indicator (fun _ => (1 : ℝ≥0∞)) (ω,x)) =
+      (Prod.mk ω ⁻¹' A).indicator (fun _ => 1) := by
+    funext x
+    by_cases hx : (ω,x) ∈ A <;> simp [hx]
+  rw [he,lintegral_indicator (hA.preimage measurable_prodMk_left)]
+  simp only [lintegral_one,Measure.restrict_apply_univ]
+
+/-- If the conditional mean measures agree on every past event, then the
+first measure gives no mass to any jointly past-measurable random set
+which the second measure avoids. -/
+theorem ae_avoids_random_set_of_conditional_kernel
+    {Ω X : Type*} [mΩ : MeasurableSpace Ω] [MeasurableSpace X]
+    (m : MeasurableSpace Ω) (hm : m ≤ mΩ) (P : @Measure Ω mΩ)
+    (μ ν : Ω → Measure X)
+    (hμ : @Measurable Ω (Measure X) mΩ inferInstance μ)
+    (hν : @Measurable Ω (Measure X) mΩ inferInstance ν)
+    (K : ℕ → Set X) (hKm : ∀ n, MeasurableSet (K n))
+    (hcover : ∀ x, ∃ n, x ∈ K n)
+    (hμK : ∀ n ω, μ ω (K n) < ∞)
+    (hνK : ∀ n, ∀ᵐ ω ∂P, ν ω (K n) < ∞)
+    (hmean : ∀ n, P.bind μ (K n) < ∞)
+    (hevent : ∀ E : Set Ω, MeasurableSet[m] E →
+      (P.restrict E).bind μ = (P.restrict E).bind ν)
+    (A : Set (Ω × X)) (hA : @MeasurableSet (Ω × X) (m.prod inferInstance) A)
+    (hzero : ∀ ω, ν ω (Prod.mk ω ⁻¹' A) = 0) :
+    ∀ᵐ ω ∂P, μ ω (Prod.mk ω ⁻¹' A) = 0 := by
+  let : MeasurableSpace Ω := mΩ
+  have hprod : m.prod (inferInstance : MeasurableSpace X) ≤
+      mΩ.prod (inferInstance : MeasurableSpace X) :=
+    sup_le_sup (MeasurableSpace.comap_mono hm) le_rfl
+  have hA' : MeasurableSet A := hprod _ hA
+  have hn (n : ℕ) : ∀ᵐ ω ∂P, (μ ω).restrict (K n) (Prod.mk ω ⁻¹' A) = 0 := by
+    have htest := conditional_random_spatial_test_on_ae m hm P μ ν hμ hν
+      (K n) (hKm n) (Eventually.of_forall (hμK n)) (hνK n) (hmean n) hevent
+      (A.indicator (fun _ => 1)) (measurable_const.indicator hA)
+    have hleft : (∫⁻ ω, (μ ω).restrict (K n) (Prod.mk ω ⁻¹' A) ∂P) = 0 := by
+      simp_rw [setLIntegral_random_indicator _ _ _ hA'] at htest
+      rw [htest]
+      apply lintegral_eq_zero_of_ae_eq_zero
+      filter_upwards [] with ω
+      have hle : (ν ω).restrict (K n) ≤ ν ω := Measure.restrict_le_self
+      exact le_zero_iff.mp ((hle _).trans_eq (hzero ω))
+    exact (lintegral_eq_zero_iff (restricted_random_set_measurable μ hμ _ (hKm n)
+      (hμK n) A hA')).mp hleft
+  filter_upwards [ae_all_iff.mpr hn] with ω hω
+  have hsub : Prod.mk ω ⁻¹' A ⊆ ⋃ n, (Prod.mk ω ⁻¹' A) ∩ K n := by
+    intro x hx
+    obtain ⟨n,hn⟩ := hcover x
+    exact mem_iUnion.mpr ⟨n,hx,hn⟩
+  apply le_zero_iff.mp
+  apply (measure_mono hsub).trans_eq
+  apply measure_iUnion_null
+  intro n
+  rw [← Measure.restrict_apply (hA'.preimage measurable_prodMk_left)]
+  exact hω n
+
+end SLEExactGauge
+
+end
+
+end OAI
diff --git a/lean/OAI/Probability/SLE/Geometry/RandomRawScaleTests.lean b/lean/OAI/Probability/SLE/Geometry/RandomRawScaleTests.lean
new file mode 100644
index 0000000000000000000000000000000000000000..e156b9ee6805a62f9f222de24d886cf5f8b81426
--- /dev/null
+++ b/lean/OAI/Probability/SLE/Geometry/RandomRawScaleTests.lean
@@ -0,0 +1,116 @@
+import OAI.Probability.SLE.Loewner.RawScaleTests
+import OAI.Probability.SLE.Geometry.RestartAE
+import OAI.Probability.SLE.Mass.RandomRadonEquality
+
+namespace OAI
+
+/-! The raw mass scaling identity survives a scale, time and spatial test
+chosen from the stopped past. No uncountable common exceptional set is used. -/
+
+noncomputable section
+open Set Filter _root_.MeasureTheory _root_.OAI.MeasureTheory ProbabilityTheory
+open scoped Topology NNReal ENNReal
+
+namespace SLEExactGauge.Multipoint
+
+local instance randomRawScaleTestsMeasurable : MeasurableSpace C(ℝ≥0,ℝ) := borel _
+local instance randomRawScaleTestsBorel : BorelSpace C(ℝ≥0,ℝ) := ⟨rfl⟩
+
+lemma CanonicalMass.random_raw_scaled_test_eq
+    {Ω : 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 ω))
+    (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 ω)
+    (E : Set C(ℝ≥0,ℝ)) (hE : MeasurableSet E)
+    (hEf : ∀ᵐ p ∂P.map (sourceDriverPath B hc), p∈E)
+    (hEp : ∀ p∈E, PositiveMassPaths (fun t => R.process t p) (R.terminal p))
+    (m : MeasurableSpace Ω) (hm : m ≤ mΩ)
+    (Y : Ω → C(ℝ≥0,ℝ)) (hY : Measurable[mΩ] Y)
+    (hlaw : ∀ A : Set Ω, MeasurableSet[m] A →
+      @Measure.map Ω C(ℝ≥0,ℝ) mΩ (borel _) Y (P.restrict A) =
+        P A • @Measure.map Ω C(ℝ≥0,ℝ) mΩ (borel _) (sourceDriverPath B hc) P)
+    (c T : Ω → ℝ≥0) (hcM : Measurable[m] c) (hT : Measurable[m] T)
+    (hpos : ∀ ω, 0<c ω)
+    (f : Ω × upperHalfPlane → ℝ≥0∞) (hf : Measurable[m.prod inferInstance] f) :
+    ∀ᵐ ω ∂P,
+      (∫⁻ z, f (ω,z) ∂dilationMass κ (c ω) (hpos ω) (R.process (T ω) (Y ω))) =
+        ∫⁻ z, f (ω,z) ∂(R.process ((c ω)^2*T ω) (scaleDriverPath (c ω) (Y ω))) := by
+  let : MeasurableSpace Ω := mΩ
+  have hbp : Measurable (sourceDriverPath B hc) := source_path_measurable _
+    (fun s => hBm.comp (measurable_const.prodMk measurable_id))
+  let : IsProbabilityMeasure (P.map (sourceDriverPath B hc)) :=
+    (Measure.isProbabilityMeasure_map_iff hbp.aemeasurable).mpr inferInstance
+  let μ : Ω × C(ℝ≥0,ℝ) → Measure upperHalfPlane :=
+    fun p => R.process (T p.1) p.2
+  have hμ : @Measurable (Ω × C(ℝ≥0,ℝ)) _ (m.prod (borel _)) _ μ := by
+    let : MeasurableSpace Ω := m
+    exact _root_.OAI.MeasureTheory.IsProgressive.parameter_time_measurable R.progressive Prod.snd measurable_snd
+      (fun p => T p.1) (hT.comp measurable_fst)
+  have hμfin (p : Ω × C(ℝ≥0,ℝ)) : IsFiniteMeasureOnCompacts (μ p) := (R.radon _ _).2
+  have hleftM := @dilationMass_measurable_family (Ω × C(ℝ≥0,ℝ)) (m.prod (borel _))
+    κ (fun p => c p.1) (hcM.comp measurable_fst) (fun p => hpos p.1) μ hμ hμfin
+  have hrightM := @RawCanonicalMass.scaled_parameter_measurable (Ω × C(ℝ≥0,ℝ))
+    (m.prod (borel _)) R (fun p => c p.1) (fun p => T p.1)
+    (hcM.comp measurable_fst) (hT.comp measurable_fst) Prod.snd measurable_snd
+  let g : (Ω × C(ℝ≥0,ℝ)) × upperHalfPlane → ℝ≥0∞ := fun p => f (p.1.1,p.2)
+  have hg : @Measurable _ _ ((m.prod (borel C(ℝ≥0,ℝ))).prod inferInstance) _ g :=
+    hf.comp (measurable_fst.fst.prodMk measurable_snd)
+  have hleft := @halfPlane_random_test_measurable (Ω × C(ℝ≥0,ℝ)) (m.prod (borel _)) _ hleftM (fun p => by
+    let := hμfin p
+    exact (conformalMass_radon _ _ (μ p)).2) g hg
+  have hright := @halfPlane_random_test_measurable (Ω × C(ℝ≥0,ℝ)) (m.prod (borel _)) _ hrightM
+    (fun p => (R.radon _ _).2) g hg
+  exact @restart_ae_random_test Ω C(ℝ≥0,ℝ) mΩ (borel _) P inferInstance (P.map (sourceDriverPath B hc)) inferInstance m hm Y hY hlaw
+    _ (measurableSet_eq_fun hleft hright)
+    (fun ω => C.raw_scaled_test_eq hB hc F hw R he E hE hEf hEp
+      (c ω) (hpos ω) (T ω) (fun z => f (ω,z))
+      (hf.comp (measurable_const.prodMk measurable_id)))
+
+lemma CanonicalMass.random_raw_scaled_mass_eq
+    {Ω : 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 ω))
+    (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 ω)
+    (E : Set C(ℝ≥0,ℝ)) (hE : MeasurableSet E)
+    (hEf : ∀ᵐ p ∂P.map (sourceDriverPath B hc), p∈E)
+    (hEp : ∀ p∈E, PositiveMassPaths (fun t => R.process t p) (R.terminal p))
+    (m : MeasurableSpace Ω) (hm : m ≤ mΩ)
+    (Y : Ω → C(ℝ≥0,ℝ)) (hY : Measurable[mΩ] Y)
+    (hlaw : ∀ A : Set Ω, MeasurableSet[m] A →
+      @Measure.map Ω C(ℝ≥0,ℝ) mΩ (borel _) Y (P.restrict A) =
+        P A • @Measure.map Ω C(ℝ≥0,ℝ) mΩ (borel _) (sourceDriverPath B hc) P)
+    (c T : Ω → ℝ≥0) (hcM : Measurable[m] c) (hT : Measurable[m] T)
+    (hpos : ∀ ω, 0<c ω) :
+    ∀ᵐ ω ∂P, dilationMass κ (c ω) (hpos ω) (R.process (T ω) (Y ω)) =
+      R.process ((c ω)^2*T ω) (scaleDriverPath (c ω) (Y ω)) := by
+  let : MeasurableSpace Ω := mΩ
+  apply random_halfPlane_measure_eq_of_lintegrals P
+    (fun ω => dilationMass κ (c ω) (hpos ω) (R.process (T ω) (Y ω)))
+    (fun ω => R.process ((c ω)^2*T ω) (scaleDriverPath (c ω) (Y ω)))
+  · intro ω
+    let := (R.radon (T ω) (Y ω)).2
+    exact (conformalMass_radon _ _ _).1
+  · intro ω
+    exact (R.radon _ _).1
+  · intro f hf
+    exact C.random_raw_scaled_test_eq hB hc F hw R he E hE hEf hEp m hm Y hY hlaw
+      c T hcM hT hpos (fun p => ENNReal.ofReal (f p.2))
+      (f.continuous.measurable.ennreal_ofReal.comp measurable_snd)
+
+end SLEExactGauge.Multipoint
+
+end
+
+end OAI
diff --git a/lean/OAI/Probability/SLE/Geometry/RandomRestartEvents.lean b/lean/OAI/Probability/SLE/Geometry/RandomRestartEvents.lean
new file mode 100644
index 0000000000000000000000000000000000000000..3a79032701a49554bc36d3e852efb453b5477118
--- /dev/null
+++ b/lean/OAI/Probability/SLE/Geometry/RandomRestartEvents.lean
@@ -0,0 +1,118 @@
+import OAI.Probability.SLE.Gauge.StoppedTubePassage
+
+namespace OAI
+
+/-! Random geometric restrictions after restart. The actual restricted
+restart law determines the joint law of the stopped past and the fresh path.
+Consequently a past-measurable family of positive-probability passage events
+has positive conditional probability, without countable past certificates. -/
+
+noncomputable section
+open Set Filter MeasureTheory
+open scoped ENNReal
+
+namespace SLEExactGauge
+
+theorem restart_joint_law
+    {Ω 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 • ν) :
+    @Measure.map Ω (Ω × X) mΩ (m.prod mX) (fun ω => (ω, Y ω)) P =
+      @Measure.prod Ω X m mX (P.trim hm) ν := by
+  have hj : @Measurable Ω (Ω × X) mΩ (m.prod mX) (fun ω => (ω, Y ω)) :=
+    (measurable_id'' hm).prodMk hY
+  apply @Measure.ext_prod Ω X m mX
+  intro A B hA hB
+  rw [Measure.map_apply hj (hA.prod hB), Measure.prod_prod,
+    trim_measurableSet_eq hm hA]
+  have he : (fun ω => (ω, Y ω)) ⁻¹' (A ×ˢ B) = Y ⁻¹' B ∩ A := by
+    ext ω
+    simp only [mem_preimage, mem_prod, mem_inter_iff, and_comm]
+  rw [he, ← Measure.restrict_apply (hY hB), ← Measure.map_apply hY hB,
+    hlaw A hA, Measure.smul_apply, smul_eq_mul]
+
+theorem restart_lintegral_random_test
+    {Ω X : Type*} [mΩ : MeasurableSpace Ω] [mX : MeasurableSpace X]
+    (P : Measure Ω) [IsFiniteMeasure P] (ν : Measure X) [IsFiniteMeasure ν]
+    (m : MeasurableSpace Ω) (hm : m ≤ mΩ)
+    (Y : Ω → X) (hY : Measurable[mΩ] Y)
+    (hlaw : ∀ A : Set Ω, MeasurableSet[m] A →
+      @Measure.map Ω X mΩ mX Y (P.restrict A) = P A • ν)
+    (f : Ω × X → ℝ≥0∞) (hf : @Measurable (Ω × X) ℝ≥0∞ (m.prod mX) _ f) :
+    (∫⁻ ω, f (ω, Y ω) ∂P) = ∫⁻ ω, ∫⁻ x, f (ω, x) ∂ν ∂P := by
+  have hj : @Measurable Ω (Ω × X) mΩ (m.prod mX) (fun ω => (ω, Y ω)) :=
+    (measurable_id'' hm).prodMk hY
+  calc
+    _ = @lintegral (Ω × X) (m.prod mX)
+        (@Measure.map Ω (Ω × X) mΩ (m.prod mX) (fun ω => (ω, Y ω)) P) f :=
+      (@lintegral_map Ω (Ω × X) mΩ (m.prod mX) P f (fun ω => (ω, Y ω)) hf hj).symm
+    _ = @lintegral (Ω × X) (m.prod mX) (@Measure.prod Ω X m mX (P.trim hm) ν) f := by
+      rw [@restart_joint_law Ω X mΩ mX P inferInstance ν inferInstance m hm Y hY hlaw]
+    _ = @lintegral Ω m (P.trim hm) (fun ω => ∫⁻ x, f (ω, x) ∂ν) :=
+      lintegral_prod f hf.aemeasurable
+    _ = _ := lintegral_trim hm hf.lintegral_prod_right'
+
+/-- Conditional integration for a genuinely random restriction on the
+fresh path, provided its dependence on the stopped past is measurable. -/
+theorem restart_condLExp_random_test
+    {Ω X : Type*} [mΩ : MeasurableSpace Ω] [mX : MeasurableSpace X]
+    (P : Measure Ω) [IsFiniteMeasure P] (ν : Measure X) [IsFiniteMeasure ν]
+    (m : MeasurableSpace Ω) (hm : m ≤ mΩ)
+    (Y : Ω → X) (hY : Measurable[mΩ] Y)
+    (hlaw : ∀ A : Set Ω, MeasurableSet[m] A →
+      @Measure.map Ω X mΩ mX Y (P.restrict A) = P A • ν)
+    (f : Ω × X → ℝ≥0∞) (hf : @Measurable (Ω × X) ℝ≥0∞ (m.prod mX) _ f) :
+    (fun ω => ∫⁻ x, f (ω, x) ∂ν) =ᵐ[P]
+      P⁻[(fun ω => f (ω, Y ω)) | m] := by
+  apply ae_eq_condLExp hm P _ hf.lintegral_prod_right'
+  intro A hA
+  let fA : Ω × X → ℝ≥0∞ := (A ×ˢ (univ : Set X)).indicator f
+  have hfA : @Measurable (Ω × X) ℝ≥0∞ (m.prod mX) _ fA :=
+    hf.indicator (hA.prod MeasurableSet.univ)
+  have h := @restart_lintegral_random_test Ω X mΩ mX P inferInstance ν inferInstance
+    m hm Y hY hlaw fA hfA
+  have hleft : (fun ω => fA (ω, Y ω)) = A.indicator (fun ω => f (ω, Y ω)) := by
+    funext ω
+    by_cases hω : ω ∈ A <;> simp [fA, hω]
+  have hright : (fun ω => ∫⁻ x, fA (ω, x) ∂ν) =
+      A.indicator (fun ω => ∫⁻ x, f (ω, x) ∂ν) := by
+    funext ω
+    by_cases hω : ω ∈ A <;> simp [fA, hω]
+  rw [hleft, hright, lintegral_indicator (hm A hA), lintegral_indicator (hm A hA)] at h
+  exact h.symm
+
+theorem conditional_passage_positive_of_random_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 • ν)
+    (E : Set Ω) (C : Set (Ω × X)) (hC : @MeasurableSet (Ω × X) (m.prod mX) C)
+    (hpositive : ∀ᵐ ω ∂P, ω ∈ E → 0 < ν {x | (ω, x) ∈ C}) :
+    ∀ᵐ ω ∂P, ω ∈ E →
+      0 < 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
+  have he := @restart_condLExp_random_test Ω X mΩ mX P inferInstance ν inferInstance m hm Y hY hlaw
+    (C.indicator (fun _ => 1)) hf
+  filter_upwards [he, hpositive] with ω hω hp hωE
+  have hs : MeasurableSet {x | (ω, x) ∈ C} := hC.preimage measurable_prodMk_left
+  have hsection : (∫⁻ x, C.indicator (fun _ => 1) (ω, x) ∂ν) = ν {x | (ω, x) ∈ C} := by
+    have heq : (fun x => C.indicator (fun _ => (1 : ℝ≥0∞)) (ω, x)) =
+        ({x | (ω, x) ∈ C}).indicator (fun _ => 1) := by
+      funext x
+      rfl
+    rw [heq, lintegral_indicator hs, setLIntegral_const, one_mul]
+  rw [hsection] at hω
+  exact hω ▸ hp hωE
+
+end SLEExactGauge
+
+end
+
+end OAI
diff --git a/lean/OAI/Probability/SLE/Geometry/RandomSpatialTesting.lean b/lean/OAI/Probability/SLE/Geometry/RandomSpatialTesting.lean
new file mode 100644
index 0000000000000000000000000000000000000000..92b5c5e903b0aeb506e6a9bc86fe06b520fbf0de
--- /dev/null
+++ b/lean/OAI/Probability/SLE/Geometry/RandomSpatialTesting.lean
@@ -0,0 +1,198 @@
+import Mathlib.Probability.Kernel.MeasurableLIntegral
+import Mathlib.MeasureTheory.Measure.GiryMonad
+import Mathlib.MeasureTheory.Measure.Prod
+import Mathlib.MeasureTheory.Integral.Lebesgue.Add
+
+namespace OAI
+
+/-! Deterministic spatial tests in an eventwise conditional measure identity
+can be replaced by arbitrary nonnegative past-measurable spatial tests.
+The proof compares the two joint measures on measurable rectangles. -/
+
+noncomputable section
+open Set Filter MeasureTheory ProbabilityTheory Classical
+open scoped ENNReal
+
+namespace SLEExactGauge
+
+private def pairedMeasure {Ω X : Type*} [MeasurableSpace Ω] [MeasurableSpace X]
+    (μ : Ω → Measure X) (ω : Ω) : Measure (Ω × X) :=
+  (μ ω).map (Prod.mk ω)
+
+private lemma pairedMeasure_measurable
+    {Ω X : Type*} [MeasurableSpace Ω] [MeasurableSpace X]
+    (μ : Ω → Measure X) (hμ : Measurable μ) (hfin : ∀ ω, IsFiniteMeasure (μ ω)) :
+    Measurable (pairedMeasure μ) := by
+  let κ : Kernel Ω X := ⟨μ,hμ⟩
+  apply Measure.measurable_of_measurable_coe
+  intro A hA
+  have h := Kernel.measurable_kernel_prodMk_left_of_finite (κ := κ) hA hfin
+  simpa only [pairedMeasure,Measure.map_apply measurable_prodMk_left hA] using (show Measurable (fun a => μ a (Prod.mk a ⁻¹' A)) from h)
+
+private lemma pairedMeasure_rectangle
+    {Ω X : Type*} [MeasurableSpace Ω] [MeasurableSpace X]
+    (P : Measure Ω) (μ : Ω → Measure X) (hμ : Measurable μ)
+    (hfin : ∀ ω, IsFiniteMeasure (μ ω))
+    (A : Set Ω) (hA : MeasurableSet A) (K : Set X) (hK : MeasurableSet K) :
+    P.bind (pairedMeasure μ) (A ×ˢ K) = (P.restrict A).bind μ K := by
+  rw [Measure.bind_apply (hA.prod hK) (pairedMeasure_measurable μ hμ hfin).aemeasurable,
+    Measure.bind_apply hK hμ.aemeasurable]
+  rw [← lintegral_indicator hA]
+  apply lintegral_congr
+  intro ω
+  rw [pairedMeasure,Measure.map_apply measurable_prodMk_left (hA.prod hK)]
+  by_cases hω : ω ∈ A <;> simp [hω]
+
+private lemma pairedMeasure_lintegral
+    {Ω X : Type*} [MeasurableSpace Ω] [MeasurableSpace X]
+    (P : Measure Ω) (μ : Ω → Measure X) (hμ : Measurable μ)
+    (hfin : ∀ ω, IsFiniteMeasure (μ ω))
+    (f : Ω × X → ℝ≥0∞) (hf : Measurable f) :
+    ∫⁻ p, f p ∂P.bind (pairedMeasure μ) = ∫⁻ ω, ∫⁻ x, f (ω,x) ∂μ ω ∂P := by
+  rw [Measure.lintegral_bind (pairedMeasure_measurable μ hμ hfin).aemeasurable hf.aemeasurable]
+  apply lintegral_congr
+  intro ω
+  exact lintegral_map hf measurable_prodMk_left
+
+private lemma finite_spatial_test_measurable
+    {Ω X : Type*} [MeasurableSpace Ω] [MeasurableSpace X]
+    (μ : Ω → Measure X) (hμ : Measurable μ) (hfin : ∀ ω, IsFiniteMeasure (μ ω))
+    (f : Ω × X → ℝ≥0∞) (hf : Measurable f) :
+    Measurable (fun ω => ∫⁻ x, f (ω,x) ∂μ ω) := by
+  have h := (Measure.measurable_lintegral hf).comp (pairedMeasure_measurable μ hμ hfin)
+  convert h using 1
+  funext ω
+  exact (lintegral_map hf measurable_prodMk_left).symm
+
+private lemma measurable_measure_restrict
+    {Ω X : Type*} [MeasurableSpace Ω] [MeasurableSpace X]
+    (μ : Ω → Measure X) (hμ : Measurable μ) (K : Set X) (hK : MeasurableSet K) :
+    Measurable (fun ω => (μ ω).restrict K) := by
+  apply Measure.measurable_of_measurable_coe
+  intro A hA
+  simp only [Measure.restrict_apply hA]
+  exact (Measure.measurable_coe (hA.inter hK)).comp hμ
+
+/-- Finite mean kernels that agree after restriction to every past event
+agree on every nonnegative joint past/spatial test. Pointwise masses may be
+unbounded; only their total mean must be finite. -/
+theorem conditional_random_spatial_test_finite
+    {Ω X : Type*} [mΩ : MeasurableSpace Ω] [MeasurableSpace X]
+    (m : MeasurableSpace Ω) (hm : m ≤ mΩ) (P : @Measure Ω mΩ)
+    (μ ν : Ω → Measure X)
+    (hμ : @Measurable Ω (Measure X) mΩ inferInstance μ)
+    (hν : @Measurable Ω (Measure X) mΩ inferInstance ν)
+    (hμfin : ∀ ω, IsFiniteMeasure (μ ω)) (hνfin : ∀ ω, IsFiniteMeasure (ν ω))
+    (hmean : P.bind μ univ < ∞)
+    (hevent : ∀ A : Set Ω, MeasurableSet[m] A →
+      (P.restrict A).bind μ = (P.restrict A).bind ν)
+    (f : Ω × X → ℝ≥0∞) (hf : @Measurable (Ω × X) ℝ≥0∞ (m.prod inferInstance) _ f) :
+    ∫⁻ ω, ∫⁻ x, f (ω,x) ∂μ ω ∂P = ∫⁻ ω, ∫⁻ x, f (ω,x) ∂ν ω ∂P := by
+  let : MeasurableSpace Ω := mΩ
+  have hprod : m.prod (inferInstance : MeasurableSpace X) ≤
+      mΩ.prod (inferInstance : MeasurableSpace X) :=
+    sup_le_sup (MeasurableSpace.comap_mono hm) le_rfl
+  let Jμ := P.bind (pairedMeasure μ)
+  let Jν := P.bind (pairedMeasure ν)
+  have hJfin : IsFiniteMeasure Jμ := by
+    constructor
+    have he := pairedMeasure_rectangle P μ hμ hμfin univ MeasurableSet.univ univ MeasurableSet.univ
+    have hvalue : Jμ univ = P.bind μ univ := by
+      simpa only [univ_prod_univ,Measure.restrict_univ,Jμ] using he
+    rw [hvalue]
+    exact hmean
+  let : IsFiniteMeasure Jμ := hJfin
+  have hrect (A : Set Ω) (K : Set X) (hA : MeasurableSet[m] A) (hK : MeasurableSet K) :
+      Jμ.trim hprod (A ×ˢ K) = Jν.trim hprod (A ×ˢ K) := by
+    rw [trim_measurableSet_eq hprod (hA.prod hK),
+      trim_measurableSet_eq hprod (hA.prod hK)]
+    rw [pairedMeasure_rectangle P μ hμ hμfin A (hm _ hA) K hK,
+      pairedMeasure_rectangle P ν hν hνfin A (hm _ hA) K hK,hevent A hA]
+  have heq : Jμ.trim hprod = Jν.trim hprod := by
+    let : MeasurableSpace Ω := m
+    apply Measure.ext_prod
+    intro A K hA hK
+    exact hrect A K hA hK
+  have hf' : Measurable f := hf.mono hprod le_rfl
+  rw [← pairedMeasure_lintegral P μ hμ hμfin f hf',
+    ← pairedMeasure_lintegral P ν hν hνfin f hf']
+  rw [← lintegral_trim hprod hf,← lintegral_trim hprod hf,heq]
+
+/-- A local version for a fixed finite spatial set, suitable for compact
+restrictions of locally finite random Radon measures. -/
+theorem conditional_random_spatial_test_on
+    {Ω X : Type*} [mΩ : MeasurableSpace Ω] [MeasurableSpace X]
+    (m : MeasurableSpace Ω) (hm : m ≤ mΩ) (P : @Measure Ω mΩ)
+    (μ ν : Ω → Measure X)
+    (hμ : @Measurable Ω (Measure X) mΩ inferInstance μ)
+    (hν : @Measurable Ω (Measure X) mΩ inferInstance ν)
+    (K : Set X) (hK : MeasurableSet K)
+    (hμK : ∀ ω, μ ω K < ∞) (hνK : ∀ ω, ν ω K < ∞)
+    (hmean : P.bind μ K < ∞)
+    (hevent : ∀ A : Set Ω, MeasurableSet[m] A →
+      (P.restrict A).bind μ = (P.restrict A).bind ν)
+    (f : Ω × X → ℝ≥0∞) (hf : @Measurable (Ω × X) ℝ≥0∞ (m.prod inferInstance) _ f) :
+    ∫⁻ ω, ∫⁻ x in K, f (ω,x) ∂μ ω ∂P =
+      ∫⁻ ω, ∫⁻ x in K, f (ω,x) ∂ν ω ∂P := by
+  let : MeasurableSpace Ω := mΩ
+  have hμr := measurable_measure_restrict μ hμ K hK
+  have hνr := measurable_measure_restrict ν hν K hK
+  have hμfin (ω : Ω) : IsFiniteMeasure ((μ ω).restrict K) :=
+    ⟨by simpa only [Measure.restrict_apply_univ] using hμK ω⟩
+  have hνfin (ω : Ω) : IsFiniteMeasure ((ν ω).restrict K) :=
+    ⟨by simpa only [Measure.restrict_apply_univ] using hνK ω⟩
+  have hmr : P.bind (fun ω => (μ ω).restrict K) univ < ∞ := by
+    rw [Measure.bind_apply MeasurableSet.univ hμr.aemeasurable]
+    simp only [Measure.restrict_apply_univ]
+    rwa [Measure.bind_apply hK hμ.aemeasurable] at hmean
+  apply conditional_random_spatial_test_finite m hm P _ _ hμr hνr hμfin hνfin hmr _ f hf
+  intro A hA
+  apply Measure.ext
+  intro S hS
+  rw [Measure.bind_apply hS hμr.aemeasurable,Measure.bind_apply hS hνr.aemeasurable]
+  simp only [Measure.restrict_apply hS]
+  rw [← Measure.bind_apply (hS.inter hK) hμ.aemeasurable,
+    ← Measure.bind_apply (hS.inter hK) hν.aemeasurable,hevent A hA]
+
+/-- Countably many finite-mean spatial pieces suffice; neither random
+measure needs finite mass on the entire space. -/
+theorem conditional_random_spatial_test
+    {Ω X : Type*} [mΩ : MeasurableSpace Ω] [MeasurableSpace X]
+    (m : MeasurableSpace Ω) (hm : m ≤ mΩ) (P : @Measure Ω mΩ)
+    (μ ν : Ω → Measure X)
+    (hμ : @Measurable Ω (Measure X) mΩ inferInstance μ)
+    (hν : @Measurable Ω (Measure X) mΩ inferInstance ν)
+    (K : ℕ → Set X) (hKm : ∀ n, MeasurableSet (K n))
+    (hdis : Pairwise (fun i j => Disjoint (K i) (K j))) (hcover : ⋃ n, K n = univ)
+    (hμK : ∀ n ω, μ ω (K n) < ∞) (hνK : ∀ n ω, ν ω (K n) < ∞)
+    (hmean : ∀ n, P.bind μ (K n) < ∞)
+    (hevent : ∀ A : Set Ω, MeasurableSet[m] A →
+      (P.restrict A).bind μ = (P.restrict A).bind ν)
+    (f : Ω × X → ℝ≥0∞) (hf : @Measurable (Ω × X) ℝ≥0∞ (m.prod inferInstance) _ f) :
+    ∫⁻ ω, ∫⁻ x, f (ω,x) ∂μ ω ∂P = ∫⁻ ω, ∫⁻ x, f (ω,x) ∂ν ω ∂P := by
+  let : MeasurableSpace Ω := mΩ
+  have hprod : m.prod (inferInstance : MeasurableSpace X) ≤
+      mΩ.prod (inferInstance : MeasurableSpace X) :=
+    sup_le_sup (MeasurableSpace.comap_mono hm) le_rfl
+  have hf' : Measurable f := hf.mono hprod le_rfl
+  have hparts (n : ℕ) := conditional_random_spatial_test_on m hm P μ ν hμ hν
+    (K n) (hKm n) (hμK n) (hνK n) (hmean n) hevent f hf
+  have hmeas (ρ : Ω → Measure X) (hr : Measurable ρ)
+      (hfinite : ∀ n ω, ρ ω (K n) < ∞) (n : ℕ) :
+      Measurable (fun ω => ∫⁻ x in K n, f (ω,x) ∂ρ ω) := by
+    apply finite_spatial_test_measurable _ (measurable_measure_restrict ρ hr _ (hKm n)) _ f hf'
+    intro ω
+    exact ⟨by simpa only [Measure.restrict_apply_univ] using hfinite n ω⟩
+  have hsplit (ρ : Ω → Measure X) (ω : Ω) :
+      (∫⁻ x, f (ω,x) ∂ρ ω) = ∑' n, ∫⁻ x in K n, f (ω,x) ∂ρ ω := by
+    simpa only [hcover,Measure.restrict_univ] using lintegral_iUnion hKm hdis (fun x => f (ω,x))
+  simp_rw [hsplit]
+  rw [lintegral_tsum (fun n => (hmeas μ hμ hμK n).aemeasurable),
+    lintegral_tsum (fun n => (hmeas ν hν hνK n).aemeasurable)]
+  simp_rw [hparts]
+
+end SLEExactGauge
+
+end
+
+end OAI
diff --git a/lean/OAI/Probability/SLE/Geometry/RandomSpatialTestingAE.lean b/lean/OAI/Probability/SLE/Geometry/RandomSpatialTestingAE.lean
new file mode 100644
index 0000000000000000000000000000000000000000..c70461bb894f792fcb6eb6748ff2c0fa4117838f
--- /dev/null
+++ b/lean/OAI/Probability/SLE/Geometry/RandomSpatialTestingAE.lean
@@ -0,0 +1,98 @@
+import OAI.Probability.SLE.Geometry.RandomSpatialTesting
+
+namespace OAI
+
+/-! Local random spatial testing only needs almost-sure finite compact
+masses. Infinite exceptional restrictions are set to zero measurably. -/
+
+noncomputable section
+open Set Filter MeasureTheory ProbabilityTheory Classical
+open scoped ENNReal
+
+namespace SLEExactGauge
+
+private lemma finite_restriction_version
+    {Ω X : Type*} [MeasurableSpace Ω] [MeasurableSpace X]
+    (P : Measure Ω) (μ : Ω → Measure X) (hμ : Measurable μ)
+    (K : Set X) (hK : MeasurableSet K) (hfin : ∀ᵐ ω ∂P, μ ω K < ∞) :
+    ∃ ρ : Ω → Measure X, Measurable ρ ∧
+      (∀ ω, IsFiniteMeasure (ρ ω)) ∧ ρ =ᵐ[P] (fun ω => (μ ω).restrict K) := by
+  let ρ (ω : Ω) := if μ ω K < ∞ then (μ ω).restrict K else 0
+  have hm : Measurable (fun ω => (μ ω).restrict K) := by
+    apply Measure.measurable_of_measurable_coe
+    intro A hA
+    simp only [Measure.restrict_apply hA]
+    exact (Measure.measurable_coe (hA.inter hK)).comp hμ
+  have hE : MeasurableSet {ω | μ ω K < ∞} :=
+    measurableSet_lt ((Measure.measurable_coe hK).comp hμ) measurable_const
+  refine ⟨ρ,hm.ite hE measurable_const,?_,?_⟩
+  · intro ω
+    dsimp only [ρ]
+    split_ifs with hω
+    · exact ⟨by simpa only [Measure.restrict_apply_univ] using hω⟩
+    · infer_instance
+  · filter_upwards [hfin] with ω hω
+    exact ite_eq_left hω
+
+private lemma bind_restrict_right
+    {Ω X : Type*} [MeasurableSpace Ω] [MeasurableSpace X]
+    (P : Measure Ω) (μ : Ω → Measure X) (hμ : Measurable μ)
+    (K : Set X) (hK : MeasurableSet K) :
+    P.bind (fun ω => (μ ω).restrict K) = (P.bind μ).restrict K := by
+  have hm : Measurable (fun ω => (μ ω).restrict K) := by
+    apply Measure.measurable_of_measurable_coe
+    intro A hA
+    simp only [Measure.restrict_apply hA]
+    exact (Measure.measurable_coe (hA.inter hK)).comp hμ
+  apply Measure.ext
+  intro A hA
+  rw [Measure.bind_apply hA hm.aemeasurable,Measure.restrict_apply hA,
+    Measure.bind_apply (hA.inter hK) hμ.aemeasurable]
+  simp only [Measure.restrict_apply hA]
+
+theorem conditional_random_spatial_test_on_ae
+    {Ω X : Type*} [mΩ : MeasurableSpace Ω] [MeasurableSpace X]
+    (m : MeasurableSpace Ω) (hm : m ≤ mΩ) (P : @Measure Ω mΩ)
+    (μ ν : Ω → Measure X)
+    (hμ : @Measurable Ω (Measure X) mΩ inferInstance μ)
+    (hν : @Measurable Ω (Measure X) mΩ inferInstance ν)
+    (K : Set X) (hK : MeasurableSet K)
+    (hμK : ∀ᵐ ω ∂P, μ ω K < ∞) (hνK : ∀ᵐ ω ∂P, ν ω K < ∞)
+    (hmean : P.bind μ K < ∞)
+    (hevent : ∀ A : Set Ω, MeasurableSet[m] A →
+      (P.restrict A).bind μ = (P.restrict A).bind ν)
+    (f : Ω × X → ℝ≥0∞) (hf : @Measurable (Ω × X) ℝ≥0∞ (m.prod inferInstance) _ f) :
+    ∫⁻ ω, ∫⁻ x in K, f (ω,x) ∂μ ω ∂P =
+      ∫⁻ ω, ∫⁻ x in K, f (ω,x) ∂ν ω ∂P := by
+  let : MeasurableSpace Ω := mΩ
+  obtain ⟨ρ,hρ,hρfin,hρeq⟩ := finite_restriction_version P μ hμ K hK hμK
+  obtain ⟨σ,hσ,hσfin,hσeq⟩ := finite_restriction_version P ν hν K hK hνK
+  have hρbind (Q : Measure Ω) (he : ρ =ᵐ[Q] (fun ω => (μ ω).restrict K)) :
+      Q.bind ρ = (Q.bind μ).restrict K :=
+    (Measure.bind_congr_right he).trans (bind_restrict_right Q μ hμ K hK)
+  have hσbind (Q : Measure Ω) (he : σ =ᵐ[Q] (fun ω => (ν ω).restrict K)) :
+      Q.bind σ = (Q.bind ν).restrict K :=
+    (Measure.bind_congr_right he).trans (bind_restrict_right Q ν hν K hK)
+  have hρmean : P.bind ρ univ < ∞ := by
+    rw [hρbind P hρeq,Measure.restrict_apply_univ]
+    exact hmean
+  have hE (A : Set Ω) (hA : MeasurableSet[m] A) :
+      (P.restrict A).bind ρ = (P.restrict A).bind σ := by
+    rw [hρbind _ hρeq.restrict,hσbind _ hσeq.restrict,hevent A hA]
+  have h := conditional_random_spatial_test_finite m hm P ρ σ hρ hσ hρfin hσfin hρmean hE f hf
+  calc
+    (∫⁻ ω, ∫⁻ x in K, f (ω,x) ∂μ ω ∂P) = ∫⁻ ω, ∫⁻ x, f (ω,x) ∂ρ ω ∂P := by
+      apply lintegral_congr_ae
+      filter_upwards [hρeq] with ω hω
+      rw [hω]
+    _ = ∫⁻ ω, ∫⁻ x, f (ω,x) ∂σ ω ∂P := h
+    _ = ∫⁻ ω, ∫⁻ x in K, f (ω,x) ∂ν ω ∂P := by
+      apply lintegral_congr_ae
+      filter_upwards [hσeq] with ω hω
+      rw [hω]
+
+end SLEExactGauge
+
+end
+
+end OAI
diff --git a/lean/OAI/Probability/SLE/Geometry/RationalTestPath.lean b/lean/OAI/Probability/SLE/Geometry/RationalTestPath.lean
new file mode 100644
index 0000000000000000000000000000000000000000..bd09d9bddc7afef2497f94a256922b5355d4ebfb
--- /dev/null
+++ b/lean/OAI/Probability/SLE/Geometry/RationalTestPath.lean
@@ -0,0 +1,88 @@
+import OAI.Probability.SLE.Mass.RadonPathCertificates
+import OAI.Probability.SLE.StoppedMeasures
+
+namespace OAI
+
+/-! A Borel certificate that rational test values extend to a continuous
+real path. This makes the good-path event countably measurable. -/
+
+noncomputable section
+open Set Filter MeasureTheory
+open scoped Topology CompactlySupported NNReal
+
+namespace SLEExactGauge
+
+local instance rationalTestPathMeasurable : MeasurableSpace C(ℝ,ℝ) := borel _
+local instance rationalTestPathBorel : BorelSpace C(ℝ,ℝ) := ⟨rfl⟩
+
+def rationalTestPathValues (f : C(ℝ,ℝ)) : ℚ → ℝ := fun q => f (q:ℝ)
+
+lemma rationalTestPathValues_embedding : MeasurableEmbedding rationalTestPathValues := by
+  apply Continuous.measurableEmbedding
+  · exact continuous_pi fun q => continuous_eval_const (q:ℝ)
+  · intro f g h
+    apply DFunLike.coe_injective
+    exact Rat.denseRange_cast.equalizer f.continuous g.continuous h
+
+variable {X : Type*} [TopologicalSpace X] [T2Space X] [LocallyCompactSpace X]
+  [MeasurableSpace X] [BorelSpace X]
+
+def HasContinuousRationalTests (D : LocalTestFamily X) (μ : ℚ → Measure X) : Prop :=
+  ∀ j, (fun q => ∫ x, D.test j x ∂μ q) ∈ range rationalTestPathValues
+
+omit [T2Space X] [LocallyCompactSpace X] [BorelSpace X] in
+lemma measurableSet_hasContinuousRationalTests
+    {Y : Type*} [MeasurableSpace Y] (D : LocalTestFamily X)
+    (μ : ℚ → Y → Measure X)
+    (hm : ∀ q j, Measurable (fun y => ∫ x, D.test j x ∂μ q y)) :
+    MeasurableSet {y | HasContinuousRationalTests D (fun q => μ q y)} := by
+  simp only [HasContinuousRationalTests,Set.ofPred_forall]
+  apply MeasurableSet.iInter
+  intro j
+  exact rationalTestPathValues_embedding.measurableSet_range.preimage
+    (measurable_pi_iff.mpr (fun q => hm q j))
+
+theorem HasContinuousRationalTests.continuous_extension
+    (D : LocalTestFamily upperHalfPlane) (μ : ℚ → Measure upperHalfPlane)
+    (hr : ∀ q, (μ q).Regular) (hc : HasContinuousRationalTests D μ) :
+    (∀ q : ℚ, 0 ≤ q → rationalRadonExtension (fun q (_ : Unit) => μ q) (q:ℝ).toNNReal () = μ q) ∧
+    ∀ f : C_c(upperHalfPlane,ℝ),
+      Continuous (fun t => ∫ z, f z ∂rationalRadonExtension (fun q (_ : Unit) => μ q) t ()) := by
+  let : LocallyCompactSpace upperHalfPlane := isOpen_upperHalfPlane.locallyCompactSpace
+  choose F hF using hc
+  have hcoord (t : ℝ≥0) (j : ℕ) :
+      (∫ z, D.test j z ∂rationalRadonExtension (fun q (_ : Unit) => μ q) t ()) = F j (t:ℝ) := by
+    let (n : ℕ) : IsFiniteMeasureOnCompacts (μ (leftRationalSample n t)) := by
+      let := hr (leftRationalSample n t)
+      infer_instance
+    have hl (k : ℕ) : Tendsto (fun n => ∫ z, D.test k z ∂μ (leftRationalSample n t)) atTop
+        (𝓝 (F k (t:ℝ))) := by
+      have he (q : ℚ) : (∫ z, D.test k z ∂μ q)=F k (q:ℝ) := congr_fun (hF k) q |>.symm
+      simpa only [he,Function.comp_def] using
+        (F k).continuous.continuousAt.tendsto.comp (leftRationalSample_tendsto t)
+    obtain ⟨ν,hν,_,hνl⟩ := D.exists_radon_limit (fun n => μ (leftRationalSample n t))
+      (fun k => ⟨F k (t:ℝ),hl k⟩)
+    have he := canonicalRadonLimit_identified (fun n => μ (leftRationalSample n t)) ν ⟨hν,hνl⟩
+    change (∫ z, D.test j z ∂canonicalRadonLimit (fun n => μ (leftRationalSample n t))) = _
+    rw [he]
+    exact tendsto_nhds_unique (hνl (D.test j)) (hl j)
+  constructor
+  · intro q hq
+    let := (rationalRadonExtension_regular (fun q (_ : Unit) => μ q) (q:ℝ).toNNReal ()).1
+    let := hr q
+    apply D.measure_eq_of_test_integrals
+    intro j
+    rw [hcoord,Real.coe_toNNReal _ (Rat.cast_nonneg.mpr hq)]
+    exact congr_fun (hF j) q
+  · apply D.continuous_integrals_of_tests
+      (fun t => rationalRadonExtension (fun q (_ : Unit) => μ q) t ())
+      (fun t => (rationalRadonExtension_regular _ t ()).1)
+    intro j
+    simp_rw [hcoord]
+    exact (F j).continuous.comp NNReal.continuous_coe
+
+end SLEExactGauge
+
+end
+
+end OAI
diff --git a/lean/OAI/Probability/SLE/Geometry/RealSymmetricDiskMapSign.lean b/lean/OAI/Probability/SLE/Geometry/RealSymmetricDiskMapSign.lean
new file mode 100644
index 0000000000000000000000000000000000000000..8403a5f5b8aee6a37d973b55bbb1cc618c0f2c04
--- /dev/null
+++ b/lean/OAI/Probability/SLE/Geometry/RealSymmetricDiskMapSign.lean
@@ -0,0 +1,74 @@
+import OAI.Probability.SLE.Geometry.ReflectedRiemannSymmetry
+import Mathlib.Analysis.Calculus.Deriv.Slope
+
+namespace OAI
+
+/-! The normalized chart preserves the upper side. Reflection excludes
+interior real values, and the positive derivative fixes the component sign. -/
+noncomputable section
+open Set Complex Filter Function
+open scoped Topology ComplexConjugate
+
+namespace SLEExactGauge
+
+lemma real_symmetric_injective_im_ne_zero {D : Set ℂ} {f : ℂ → ℂ}
+    (hD : MapsTo conj D D) (hi : InjOn f D)
+    (hs : ∀ z ∈ D, f (conj z)=conj (f z)) {z : ℂ} (hz : z ∈ D) (him : 0 < z.im) :
+    (f z).im ≠ 0 := by
+  intro he
+  have hfconj : conj (f z)=f z := by apply Complex.ext <;> simp [he]
+  have hzconj := hi (hD hz) hz ((hs z hz).trans hfconj)
+  have hh := congrArg Complex.im hzconj
+  simp only [conj_im] at hh
+  linarith
+
+lemma positive_derivative_upper_witness {D : Set ℂ} (ho : IsOpen D) (h0D : (0:ℂ) ∈ D)
+    {f : ℂ → ℂ} (hf : DifferentiableOn ℂ f D) (hf0 : f 0=0)
+    {a : ℝ} (ha : 0 < a) (hd : deriv f 0=(a:ℂ)) :
+    ∃ z ∈ D, 0 < z.im ∧ 0 < (f z).im := by
+  have hfAt : HasDerivAt f (a:ℂ) 0 := by
+    rw [← hd]
+    exact (hf.differentiableAt (ho.mem_nhds h0D)).hasDerivAt
+  have hline : HasDerivAt (fun t : ℝ => (t:ℂ)*I) I 0 := by
+    simpa using ((hasDerivAt_id (0:ℝ)).ofReal_comp.mul_const I)
+  have hfLine : HasDerivAt f (a:ℂ) ((0:ℂ)*I) := by simpa using hfAt
+  have hcomp : HasDerivAt (fun t : ℝ => f ((t:ℂ)*I)) (I*(a:ℂ)) 0 := by
+    convert! HasDerivAt.scomp (h := fun t : ℝ => (t:ℂ)*I) (0:ℝ) hfLine hline using 1
+  have him : HasDerivAt (fun t : ℝ => (f ((t:ℂ)*I)).im) a 0 := by
+    convert! Complex.imCLM.hasFDerivAt.comp_hasDerivAt (0:ℝ) hcomp using 1
+    simp
+  have hslope : Tendsto (fun t : ℝ => (f ((t:ℂ)*I)).im/t) (𝓝[>] 0) (𝓝 a) := by
+    simpa only [zero_add,ofReal_zero,zero_mul,hf0,zero_im,sub_zero,smul_eq_mul,div_eq_inv_mul] using
+      him.tendsto_slope_zero_right
+  have hpos := hslope.eventually (Ioi_mem_nhds ha)
+  have hDnear : ∀ᶠ t : ℝ in 𝓝[>] 0, (t:ℂ)*I ∈ D := by
+    have hc : Continuous (fun t : ℝ => (t:ℂ)*I) := by fun_prop
+    exact ((hc.tendsto 0).eventually (by simpa using ho.mem_nhds h0D)).filter_mono
+      nhdsWithin_le_nhds
+  have htp : ∀ᶠ t : ℝ in 𝓝[>] 0, 0 < t := self_mem_nhdsWithin
+  obtain ⟨t,ht,hmem,hval⟩ := (htp.and (hDnear.and hpos)).exists
+  refine ⟨(t:ℂ)*I,hmem,by simpa using ht,?_⟩
+  exact ((div_pos_iff.mp hval).resolve_right (fun h => (not_lt_of_ge ht.le) h.2)).1
+
+theorem normalized_riemann_maps_upper {D : Set ℂ} (ho : IsOpen D) (h0D : (0:ℂ) ∈ D)
+    (hD : MapsTo conj D D) (hc : IsPreconnected (D ∩ upperHalfPlane))
+    {f : ℂ → ℂ} (hf : DifferentiableOn ℂ f D) (hb : BijOn f D (Metric.ball 0 1))
+    (hf0 : f 0=0) {a : ℝ} (ha : 0 < a) (hd : deriv f 0=(a:ℂ)) :
+    MapsTo f (D ∩ upperHalfPlane) upperHalfPlane := by
+  have hs := normalized_riemann_chart_conj ho h0D hD hf hb hf0 hd
+  obtain ⟨w,hw,hwH,hfw⟩ := positive_derivative_upper_witness ho h0D hf hf0 ha hd
+  intro z hz
+  have hn := real_symmetric_injective_im_ne_zero hD hb.injOn hs hz.1 hz.2
+  by_contra hneg
+  have hlt : (f z).im < 0 := lt_of_le_of_ne (le_of_not_gt hneg) hn
+  have hcont : ContinuousOn (fun z => (f z).im) (D ∩ upperHalfPlane) :=
+    Complex.continuous_im.comp_continuousOn (hf.continuousOn.mono inter_subset_left)
+  obtain ⟨v,hv,hvim⟩ := hc.intermediate_value hz ⟨hw,hwH⟩ hcont
+    (show (0:ℝ) ∈ Icc (f z).im (f w).im from ⟨hlt.le,hfw.le⟩)
+  exact real_symmetric_injective_im_ne_zero hD hb.injOn hs hv.1 hv.2 hvim
+
+end SLEExactGauge
+
+end
+
+end OAI
diff --git a/lean/OAI/Probability/SLE/Geometry/RecenteredGuideCompactness.lean b/lean/OAI/Probability/SLE/Geometry/RecenteredGuideCompactness.lean
new file mode 100644
index 0000000000000000000000000000000000000000..0273f5c7d6232e74c0a44ad18807ad73a05d7c09
--- /dev/null
+++ b/lean/OAI/Probability/SLE/Geometry/RecenteredGuideCompactness.lean
@@ -0,0 +1,192 @@
+import OAI.Probability.SLE.Geometry.ActualGuideCompactness
+import OAI.Probability.SLE.Geometry.PublishedFiniteBoundaryExtension
+
+namespace OAI
+
+/-! Actual stopped charts recentered at their physical tips. The tip may
+escape to infinity as the ribbon front varies; subtracting it before the
+normal-family argument removes any artificial bound on its location. -/
+
+noncomputable section
+open Set Filter MeasureTheory Metric
+open scoped Topology NNReal
+
+namespace SLEExactGauge
+
+theorem recentered_actual_guide_compactness
+    {Ω : Type} [MeasurableSpace Ω] (P : Measure Ω) [IsProbabilityMeasure P]
+    (κ : ℝ) (hκ : 0 < κ) (hκ8 : κ < 8)
+    (γ : Ω → ℝ≥0 → ℂ) (hSLE : IsOrdinaryChordalSLE κ γ P)
+    (hcompact : PublishedHalfPlaneUnivalentCompactness)
+    (hboundary : PublishedFiniteLoewnerBoundaryExtension)
+    (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 : ℝ)
+    (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))
+    (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))
+    (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) : ℂ)‖) :
+    ∃ (b : ℕ → ℝ) (Fb : ℕ → C(closedHalfPlane, ℂ)) (βₙ : ℕ → ℝ → ℂ)
+      (φ : ℕ → ℕ) (F : ℂ → ℂ) (α β : ℝ → ℂ),
+      (∀ 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)) ∧
+      (∀ n, ContinuousOn (βₙ n) (Icc 0 2)) ∧ (∀ n, βₙ n 0 = 0) ∧
+      (∀ n t, t ∈ Icc (0 : ℝ) 2 → 0 ≤ (βₙ n t).im) ∧
+      (∀ n t, t ∈ Icc (0 : ℝ) 2 → ∀ ht : 0 ≤ (βₙ n t).im,
+        Fb n ⟨βₙ n t, ht⟩ = αₙ n t - γₙ n (T n)) ∧
+      StrictMono φ ∧ DifferentiableOn ℂ F upperHalfPlane ∧ InjOn F upperHalfPlane ∧
+      (∀ z ∈ upperHalfPlane, deriv F z ≠ 0) ∧ α 0 ∉ F '' upperHalfPlane ∧
+      TendstoLocallyUniformlyOn
+        (fun n z => normalizedInverse (F₀ (φ n) (T (φ n))) (U (φ n) (T (φ n)))
+          (b (φ n)) z - γₙ (φ n) (T (φ n))) F atTop upperHalfPlane ∧
+      TendstoUniformlyOn (fun n t => αₙ (φ n) t - γₙ (φ n) (T (φ n))) α atTop (Icc 0 2) ∧
+      TendstoUniformlyOn (fun n => βₙ (φ n)) β atTop (Icc 0 2) ∧
+      α 0 = 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) := by
+  have hguide n := normalized_actual_access_guide hboundary.to_onePoint (hw n) (hU n)
+    (T n) (hT n) (hfresh n) (αₙ n) (by norm_num : (0 : ℝ) < 2)
+    (by norm_num : (1 / 2 : ℝ) ∈ Ioc 0 2) (hαL n).continuousOn
+    (PhysicalGuideCompactness.injective_of_lower_chord_bound hc (hchord n)) (hα0 n) (hαD n)
+  choose b hb oldFb βₙ oldBar oldExt hβc hβi hβ0 hβH oldRelation hβnorm hβeq using hguide
+  choose Fb₀ hFb₀ hFb₀zero using fun n =>
+    normalized_finite_capacity_inverse_boundary_extension hboundary (hU n) (hw n) (T n) (b n) (hb n)
+  let a := fun n => γₙ n (T n)
+  let α' := fun n t => αₙ n t - a n
+  let Fb : ℕ → C(closedHalfPlane, ℂ) := fun n => Fb₀ n - ContinuousMap.const _ (a n)
+  let Fn := fun n z => normalizedInverse (F₀ n (T n)) (U n (T n)) (b n) z - a n
+  let g₀ := fun n => normalizedForward (G n (T n)) (U n (T n)) (b n)
+  let g := fun n z => g₀ n (z + a n)
+  let D := fun n => {z : ℂ | z + a n ∈ survivingDomain (γₙ n) (T n)}
+  have hcharts n := normalized_capacity_charts (hw n) (T n) (b n) (hb n)
+  have hD n : IsOpen (D n) :=
+    (isOpen_survivingDomain (hw n).1 _).preimage (continuous_id.add continuous_const)
+  have hFn n : DifferentiableOn ℂ (Fn n) upperHalfPlane := (hcharts n).1.sub_const _
+  have hiFn n : InjOn (Fn n) upperHalfPlane := by
+    intro z hz w hw' he
+    exact (hcharts n).2.1 hz hw' (sub_left_inj.mp he)
+  have hg n : DifferentiableOn ℂ (g n) (D n) :=
+    (hcharts n).2.2.1.comp (differentiable_id.add_const _).differentiableOn (fun _ hz => hz)
+  have hig n : InjOn (g n) (D n) := by
+    intro z hz w hw' he
+    exact add_right_cancel ((hcharts n).2.2.2.1 hz hw' he)
+  have hFD n : MapsTo (Fn n) upperHalfPlane (D n) := by
+    intro z hz
+    simpa only [D, mem_ofPred_eq, Fn, sub_add_cancel] using (hcharts n).2.2.2.2.1 hz
+  have hgH n : MapsTo (g n) (D n) upperHalfPlane := fun _ hz => (hcharts n).2.2.2.2.2.1 hz
+  have hgf n z (hz : z ∈ upperHalfPlane) : g n (Fn n z) = z := by
+    simpa only [g, Fn, sub_add_cancel] using (hcharts n).2.2.2.2.2.2.1 z hz
+  have hβHclosed n t (ht : t ∈ Icc (0 : ℝ) 2) : 0 ≤ (βₙ n t).im := by
+    by_cases ht0 : t = 0
+    · simp only [ht0, hβ0, Complex.zero_im, le_refl]
+    · exact (show 0 < (βₙ n t).im from hβH n ⟨lt_of_le_of_ne ht.1 (Ne.symm ht0), ht.2⟩).le
+  have hext n (z : closedHalfPlane) (hz : z.1 ∈ upperHalfPlane) : Fb n z = Fn n z := by
+    change Fb₀ n z - a n = F₀ n (T n) ((U n (T n) : ℂ) + (b n : ℂ) * z) - a n
+    rw [hFb₀ n z hz]
+  have hrelation n t (ht : t ∈ Ioc (0 : ℝ) 2) : Fn n (βₙ n t) = α' n t := by
+    dsimp only [Fn, α']
+    congr 1
+    apply OnePoint.coe_injective
+    exact (oldExt n _ (hβH n ht)).symm.trans (oldRelation n t ⟨ht.1.le, ht.2⟩)
+  have hbarRelation n t (ht : t ∈ Icc (0 : ℝ) 2) :
+      Fb n ⟨βₙ n t, hβHclosed n t ht⟩ = α' n t := by
+    by_cases ht0 : t = 0
+    · subst t
+      change Fb₀ n ⟨βₙ n 0, _⟩ - a n = αₙ n 0 - a n
+      rw [hα0 n]
+      congr 1
+      simpa only [hβ0] using hFb₀zero n
+    · have ht' : t ∈ Ioc (0 : ℝ) 2 := ⟨lt_of_le_of_ne ht.1 (Ne.symm ht0), ht.2⟩
+      rw [hext n _ (hβH n ht')]
+      exact hrelation n t ht'
+  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 hαL' n : LipschitzOnWith C (α' n) (Icc 0 2) := by
+    apply lipschitzOnWith_iff_dist_le_mul.mpr
+    intro u hu v hv
+    simpa only [α', dist_sub_right] using (hαL n).dist_le_mul u hu v hv
+  have hα0' n : α' n 0 = 0 := by simp only [α', a, hα0, sub_self]
+  have hchord' (n : ℕ) (u : ℝ) (hu : u ∈ Icc (0 : ℝ) 2)
+      (v : ℝ) (hv : v ∈ Icc (0 : ℝ) 2) : c * |u - v| ≤ dist (α' n u) (α' n v) := by
+    simpa only [α', dist_sub_right] using hchord n u hu v hv
+  have hβeq' n t (ht : t ∈ Ioc (0 : ℝ) 2) : βₙ n t = g n (α' n t) := by
+    simpa only [g, α', sub_add_cancel, g₀, normalizedForward] using hβeq n t ht
+  have hway n : ‖βₙ n (1 / 2)‖ = 1 ∧ s ≤ (βₙ n (1 / 2)).im := by
+    refine ⟨hβnorm n, ?_⟩
+    have hn := hβnorm n
+    rw [hβeq n _ (by norm_num : (1 / 2 : ℝ) ∈ Ioc 0 2), norm_div,
+      Complex.norm_real, Real.norm_eq_abs, abs_of_pos (hb n)] at hn
+    have he : b n = ‖G n (T n) (αₙ n (1 / 2)) - (U n (T n) : ℂ)‖ :=
+      ((div_eq_one_iff_eq (hb n).ne').mp hn).symm
+    rw [hβeq n _ (by norm_num : (1 / 2 : ℝ) ∈ Ioc 0 2), Complex.div_ofReal_im, he]
+    exact hangle n
+  have homit n : (0 : ℂ) ∉ Fn n '' upperHalfPlane := by
+    rintro ⟨z, hz, he⟩
+    have hh := (hcharts n).2.2.2.2.1 hz
+    have he' : normalizedInverse (F₀ n (T n)) (U n (T n)) (b n) z = a n := sub_eq_zero.mp he
+    rw [he'] at hh
+    exact hh.1.2 ⟨T n, ⟨bot_le, le_rfl⟩, rfl⟩
+  have hclear' : ∀ δ : ℝ, 0 < δ → δ ≤ 2 → ∃ r : ℝ, 0 < r ∧
+      ∀ n t, t ∈ Icc δ 2 → ball (α' n t) r ⊆ D n := by
+    intro δ hδ hδ2
+    obtain ⟨r, hr, hball⟩ := hclear δ hδ hδ2
+    refine ⟨r, hr, ?_⟩
+    intro n t ht z hz
+    apply hball n t ht
+    rw [mem_ball, dist_eq_norm]
+    change ‖z + a n - αₙ n t‖ < r
+    have hz' : ‖z - (αₙ n t - a n)‖ < r := by
+      simpa only [mem_ball, dist_eq_norm, α'] using hz
+    convert hz' using 1
+    congr 1
+    ring
+  obtain ⟨ρ, hρ, hballs⟩ := hclear' (1 / 2) (by norm_num) (by norm_num)
+  obtain ⟨φ, F, α, β, 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⟩ :=
+    GuideCompactness.exists_joint_guide_limit_of_clearance P κ hκ hκ8 γ hSLE hcompact
+      Fn g D Fbar α' βₙ (fun _ => 0) C (by norm_num) (by norm_num) (by norm_num)
+      hs hρ hc hC hD hFn hiFn hg hig hFD hgH hgf hbar hbarext hαL' hα0'
+      (fun _ => le_rfl) hchord' hβc hβ0 hβHclosed hway
+      (fun n => hballs n _ (by norm_num)) homit hrelation
+      (fun n t ht => by
+        dsimp only [Fbar]
+        rw [dite_eq_left (show βₙ n t ∈ closedHalfPlane from hβHclosed n t ht)]
+        exact congrArg (fun z : ℂ => (z : OnePoint ℂ)) (hbarRelation n t ht))
+      hβeq' hclear'
+  have hzero : α 0 = 0 := by
+    exact tendsto_nhds_unique hatip (tendsto_const_nhds :
+      Tendsto (fun _ : ℕ => (0 : ℂ)) atTop (𝓝 0))
+  exact ⟨b, Fb, βₙ, φ, F, α, β, hb, hext, hβc, hβ0, hβHclosed,
+    (fun n t ht _ => hbarRelation n t ht),
+    hφ, hF, hiF, hFne, homitlim, hFconv, hαconv, hβconv, hzero, hαLlim,
+    hαclim, hαilim, hβlim0, hβlimc, hβlimi, hβlimH, hlimrel⟩
+
+end SLEExactGauge
+
+end
+
+end OAI
diff --git a/lean/OAI/Probability/SLE/Geometry/ReciprocalInverseLimit.lean b/lean/OAI/Probability/SLE/Geometry/ReciprocalInverseLimit.lean
new file mode 100644
index 0000000000000000000000000000000000000000..e40b815f6df9103f421e61075b5e0afc207210b3
--- /dev/null
+++ b/lean/OAI/Probability/SLE/Geometry/ReciprocalInverseLimit.lean
@@ -0,0 +1,65 @@
+import OAI.Probability.SLE.Loewner.SlitInverseGerm
+
+namespace OAI
+
+/-! A germ tangent to the identity gives a normalized inverse chart at
+infinity after conjugate inversion. -/
+noncomputable section
+open Set Filter Complex Function Metric
+open scoped Topology ComplexConjugate
+
+namespace SLEExactGauge
+
+lemma conjugateInversion_ne_zero {z : ℂ} (hz : z ≠ 0) : conjugateInversion z ≠ 0 := by
+  change (conj z)⁻¹ ≠ 0
+  apply inv_ne_zero
+  intro he
+  apply hz
+  simpa only [conj_conj,map_zero] using congrArg conj he
+
+lemma conjugateInversion_tendsto_zero :
+    Tendsto conjugateInversion (cocompact ℂ) (𝓝 (0:ℂ)) := by
+  have hi : Tendsto (fun z : ℂ => z⁻¹) (cocompact ℂ) (𝓝 0) := by
+    simpa only [Metric.cobounded_eq_cocompact] using
+      (tendsto_inv₀_cobounded : Tendsto (fun z : ℂ => z⁻¹) (Bornology.cobounded ℂ) (𝓝 0))
+  convert! (Complex.continuous_conj.tendsto 0).comp hi using 1
+  · ext z
+    simp only [Function.comp_apply,conjugateInversion,map_inv₀]
+  · simp
+
+lemma conjugateInversion_tendsto_punctured_zero :
+    Tendsto conjugateInversion (cocompact ℂ) (𝓝[≠] (0:ℂ)) := by
+  apply tendsto_nhdsWithin_iff.mpr
+  refine ⟨conjugateInversion_tendsto_zero,?_⟩
+  filter_upwards [(isCompact_singleton (x := (0:ℂ))).compl_mem_cocompact] with z hz
+  exact conjugateInversion_ne_zero hz
+
+lemma conjugateInversion_ratio {r : ℂ → ℂ} (z : ℂ) :
+    conjugateInversion (r (conjugateInversion z))/z =
+      conj ((r (conjugateInversion z)/conjugateInversion z)⁻¹) := by
+  change (conj (r (conjugateInversion z)))⁻¹/z =
+    conj ((r (conjugateInversion z)/(conj z)⁻¹)⁻¹)
+  rw [inv_div,map_div₀,map_inv₀,conj_conj]
+  simp only [div_eq_mul_inv]
+  ring
+
+lemma reciprocal_inverse_tendsto_ratio {r : ℂ → ℂ}
+    (hr : HasDerivAt r 1 0) (hr0 : r 0=0) :
+    Tendsto (fun z : ℂ => conjugateInversion (r (conjugateInversion z))/z)
+      (cocompact ℂ) (𝓝 1) := by
+  have hs : Tendsto (fun w : ℂ => r w/w) (𝓝[≠] 0) (𝓝 1) := by
+    convert! hr.tendsto_slope using 1
+    ext w
+    simp only [slope_def_field,hr0,sub_zero]
+  have ht := (hs.comp conjugateInversion_tendsto_punctured_zero).inv₀ one_ne_zero
+  have hc := (Complex.continuous_conj.tendsto (1:ℂ)⁻¹).comp ht
+  simp only [inv_one,map_one] at hc
+  apply hc.congr'
+  filter_upwards [(isCompact_singleton (x := (0:ℂ))).compl_mem_cocompact] with z hz
+  exact (conjugateInversion_ratio (r := r) z).symm
+
+end SLEExactGauge
+
+end
+
+end OAI
diff --git a/lean/OAI/Probability/SLE/Geometry/RectangleCauchyBoundary.lean b/lean/OAI/Probability/SLE/Geometry/RectangleCauchyBoundary.lean
new file mode 100644
index 0000000000000000000000000000000000000000..58ac3f8b2ea4dbda224e37c37d2605b78d23b08b
--- /dev/null
+++ b/lean/OAI/Probability/SLE/Geometry/RectangleCauchyBoundary.lean
@@ -0,0 +1,45 @@
+import OAI.Probability.SLE.Geometry.RectangleWedgeSplit
+
+namespace OAI
+
+/-! Boundary-integral control on a closed rectangle. -/
+noncomputable section
+open Complex MeasureTheory Set
+open scoped Topology Interval
+
+namespace SLEExactGauge
+
+lemma rectangle_vertical_integrable {f : ℂ → ℂ} {z w : ℂ}
+    (hC : ContinuousOn f (Rectangle z w)) {x : ℝ} (hx : x∈uIcc z.re w.re) :
+    IntervalIntegrable (fun y : ℝ => f (x+y*I)) volume z.im w.im := by
+  apply ContinuousOn.intervalIntegrable
+  apply hC.comp (continuous_const.add (continuous_ofReal.mul_const I)).continuousOn
+  intro y hy
+  change (x+(y:ℂ)*I).re∈uIcc z.re w.re ∧ (x+(y:ℂ)*I).im∈uIcc z.im w.im
+  simpa only [add_re,add_im,ofReal_re,ofReal_im,mul_re,mul_im,I_re,I_im,
+    mul_zero,mul_one,zero_mul,sub_zero,add_zero,zero_add] using And.intro hx hy
+
+lemma rectangle_wedge_split_of_continuous {f : ℂ → ℂ} {z w : ℂ}
+    (hC : ContinuousOn f (Rectangle z w)) {c : ℝ} (hc : c∈uIcc z.im w.im) :
+    wedgeIntegral z w f+wedgeIntegral w z f=
+      (wedgeIntegral z (⟨w.re,c⟩:ℂ) f+wedgeIntegral (⟨w.re,c⟩:ℂ) z f)+
+      (wedgeIntegral (⟨z.re,c⟩:ℂ) w f+wedgeIntegral w (⟨z.re,c⟩:ℂ) f) := by
+  have hz := (IntervalIntegrable.trans_iff hc).mp
+    (rectangle_vertical_integrable hC (left_mem_uIcc : z.re∈uIcc z.re w.re))
+  have hw := (IntervalIntegrable.trans_iff hc).mp
+    (rectangle_vertical_integrable hC (right_mem_uIcc : w.re∈uIcc z.re w.re))
+  exact rectangle_wedge_split f z w c hz.1 hz.2 hw.1 hw.2
+
+lemma rectangle_wedge_eq_zero {f : ℂ → ℂ} {z w : ℂ}
+    (hC : ContinuousOn f (Rectangle z w))
+    (hD : DifferentiableOn ℂ f
+      (Ioo (min z.re w.re) (max z.re w.re) ×ℂ Ioo (min z.im w.im) (max z.im w.im))) :
+    wedgeIntegral z w f+wedgeIntegral w z f=0 := by
+  rw [wedgeIntegral_add_wedgeIntegral_eq]
+  exact integral_boundary_rect_eq_zero_of_continuousOn_of_differentiableOn f z w hC hD
+
+end SLEExactGauge
+
+end
+
+end OAI
diff --git a/lean/OAI/Probability/SLE/Geometry/RectangleCrossing.lean b/lean/OAI/Probability/SLE/Geometry/RectangleCrossing.lean
new file mode 100644
index 0000000000000000000000000000000000000000..2c14ba8394b1430691372dc59628dade5adb60d2
--- /dev/null
+++ b/lean/OAI/Probability/SLE/Geometry/RectangleCrossing.lean
@@ -0,0 +1,115 @@
+import FixedPointTheorems.brouwer
+import Mathlib
+
+namespace OAI
+
+/-! Two transverse continuous crossings of a rectangle intersect, by
+Brouwer's fixed-point theorem and the two-dimensional Poincaré–Miranda
+argument. No simplicity or regularity of the crossing is needed. -/
+
+noncomputable section
+open Set
+open scoped Topology
+
+namespace SLEExactGauge.RectangleCrossing
+
+def clampUnit (u : ℝ) : ℝ := max 0 (min 1 u)
+
+theorem clampUnit_mem (u : ℝ) : clampUnit u ∈ Icc (0 : ℝ) 1 := by
+  exact ⟨le_max_left _ _, max_le zero_le_one (min_le_left _ _)⟩
+
+theorem clampUnit_continuous : Continuous clampUnit := by
+  unfold clampUnit
+  fun_prop
+
+theorem clampUnit_fixed_forces_zero
+    (u a : ℝ) (hu : u ∈ Icc (0 : ℝ) 1)
+    (hlower : u = 0 → a ≤ 0) (hupper : u = 1 → 0 ≤ a)
+    (he : clampUnit (u - a) = u) : a = 0 := by
+  apply le_antisymm
+  · by_contra hn
+    have ha : 0 < a := lt_of_not_ge hn
+    have hu0 : 0 < u := lt_of_le_of_ne hu.1 (by
+      intro h
+      exact (not_le_of_gt ha) (hlower h.symm))
+    have hlt : clampUnit (u - a) < u :=
+      max_lt hu0 ((min_le_right _ _).trans_lt (by linarith))
+    exact (ne_of_lt hlt) he
+  · by_contra hn
+    have ha : a < 0 := lt_of_not_ge hn
+    have hu1 : u < 1 := lt_of_le_of_ne hu.2 (by
+      intro h
+      exact (not_le_of_gt ha) (hupper h))
+    have hlt : u < clampUnit (u - a) :=
+      (lt_min hu1 (by linarith)).trans_le (le_max_right _ _)
+    exact (ne_of_gt hlt) he
+
+def unitSquare : Set (ℝ × ℝ) := Icc (0, 0) (1, 1)
+
+/-- The rectangle intermediate-value theorem with signs on its four
+faces. The map can have arbitrary behavior in the interior. -/
+theorem poincare_miranda_square
+    (F : ℝ × ℝ → ℝ × ℝ) (hF : ContinuousOn F unitSquare)
+    (hleft : ∀ y ∈ Icc (0 : ℝ) 1, (F (0, y)).1 ≤ 0)
+    (hright : ∀ y ∈ Icc (0 : ℝ) 1, 0 ≤ (F (1, y)).1)
+    (hbottom : ∀ x ∈ Icc (0 : ℝ) 1, (F (x, 0)).2 ≤ 0)
+    (htop : ∀ x ∈ Icc (0 : ℝ) 1, 0 ≤ (F (x, 1)).2) :
+    ∃ z ∈ unitSquare, F z = (0, 0) := by
+  have hFc : Continuous (fun z : unitSquare => F z) := hF.domRestrict
+  let f : C(unitSquare, unitSquare) :=
+    ⟨fun z => ⟨(clampUnit (z.val.1 - (F z).1), clampUnit (z.val.2 - (F z).2)),
+      ⟨⟨(clampUnit_mem _).1, (clampUnit_mem _).1⟩,
+        ⟨(clampUnit_mem _).2, (clampUnit_mem _).2⟩⟩⟩,
+      (clampUnit_continuous.comp (continuous_subtype_val.fst.sub hFc.fst)).prodMk
+        (clampUnit_continuous.comp (continuous_subtype_val.snd.sub hFc.snd)) |>.subtype_mk _⟩
+  obtain ⟨z, hz⟩ := brouwer_fixed_point unitSquare (convex_Icc _ _) isCompact_Icc
+    ⟨(0, 0), by simp [unitSquare]⟩ f
+  have hx : z.val.1 ∈ Icc (0 : ℝ) 1 := ⟨z.property.1.1, z.property.2.1⟩
+  have hy : z.val.2 ∈ Icc (0 : ℝ) 1 := ⟨z.property.1.2, z.property.2.2⟩
+  have hfx : (F z).1 = 0 := clampUnit_fixed_forces_zero _ _ hx
+    (fun he => by rw [show z.val = (0, z.val.2) from Prod.ext he rfl]; exact hleft z.val.2 hy)
+    (fun he => by rw [show z.val = (1, z.val.2) from Prod.ext he rfl]; exact hright z.val.2 hy)
+    (congrArg (fun w : unitSquare => w.val.1) hz)
+  have hfy : (F z).2 = 0 := clampUnit_fixed_forces_zero _ _ hy
+    (fun he => by rw [show z.val = (z.val.1, 0) from Prod.ext rfl he]; exact hbottom z.val.1 hx)
+    (fun he => by rw [show z.val = (z.val.1, 1) from Prod.ext rfl he]; exact htop z.val.1 hx)
+    (congrArg (fun w : unitSquare => w.val.2) hz)
+  exact ⟨z, z.property, Prod.ext hfx hfy⟩
+
+/-- A longitudinal crossing and a transverse crossing of any nondegenerate
+axis-aligned rectangle meet, even when either path has self-intersections. -/
+theorem paths_intersect_rectangle
+    (p q : ℝ → ℂ) (a b c d : ℝ) (_hab : a < b) (_hcd : c < d)
+    (hp : ContinuousOn p (Icc 0 1)) (hq : ContinuousOn q (Icc 0 1))
+    (hpr : ∀ t ∈ Icc (0 : ℝ) 1, (p t).re ∈ Icc a b ∧ (p t).im ∈ Icc c d)
+    (hqr : ∀ t ∈ Icc (0 : ℝ) 1, (q t).re ∈ Icc a b ∧ (q t).im ∈ Icc c d)
+    (hp0 : (p 0).re = a) (hp1 : (p 1).re = b)
+    (hq0 : (q 0).im = c) (hq1 : (q 1).im = d) :
+    ∃ s ∈ Icc (0 : ℝ) 1, ∃ t ∈ Icc (0 : ℝ) 1, p s = q t := by
+  let F : ℝ × ℝ → ℝ × ℝ := fun z =>
+    ((p z.1).re - (q z.2).re, (q z.2).im - (p z.1).im)
+  have hfst : MapsTo Prod.fst unitSquare (Icc (0 : ℝ) 1) :=
+    fun z hz => ⟨hz.1.1, hz.2.1⟩
+  have hsnd : MapsTo Prod.snd unitSquare (Icc (0 : ℝ) 1) :=
+    fun z hz => ⟨hz.1.2, hz.2.2⟩
+  have hpc := hp.comp continuous_fst.continuousOn hfst
+  have hqc := hq.comp continuous_snd.continuousOn hsnd
+  have hFc : ContinuousOn F unitSquare :=
+    (Complex.continuous_re.continuousOn.comp hpc (mapsTo_univ _ _)).sub
+      (Complex.continuous_re.continuousOn.comp hqc (mapsTo_univ _ _)) |>.prodMk
+        ((Complex.continuous_im.continuousOn.comp hqc (mapsTo_univ _ _)).sub
+          (Complex.continuous_im.continuousOn.comp hpc (mapsTo_univ _ _)))
+  obtain ⟨z, hz, he⟩ := poincare_miranda_square F hFc
+    (fun t ht => by dsimp [F]; rw [hp0]; linarith [(hqr t ht).1.1])
+    (fun t ht => by dsimp [F]; rw [hp1]; linarith [(hqr t ht).1.2])
+    (fun s hs => by dsimp [F]; rw [hq0]; linarith [(hpr s hs).2.1])
+    (fun s hs => by dsimp [F]; rw [hq1]; linarith [(hpr s hs).2.2])
+  refine ⟨z.1, hfst hz, z.2, hsnd hz, Complex.ext ?_ ?_⟩
+  · exact sub_eq_zero.mp (congrArg Prod.fst he)
+  · exact (sub_eq_zero.mp (congrArg Prod.snd he)).symm
+
+end SLEExactGauge.RectangleCrossing
+
+end
+
+end OAI
diff --git a/lean/OAI/Probability/SLE/Geometry/RectangleLogBoundary.lean b/lean/OAI/Probability/SLE/Geometry/RectangleLogBoundary.lean
new file mode 100644
index 0000000000000000000000000000000000000000..50513d345a9e3c4b554b2f81ea82424a80783036
--- /dev/null
+++ b/lean/OAI/Probability/SLE/Geometry/RectangleLogBoundary.lean
@@ -0,0 +1,63 @@
+import OAI.Probability.SLE.Stochastic.LogRatioPaths
+
+namespace OAI
+
+/-! Explicit compatible logarithms on the four sides of a path-crossing
+rectangle. No assertion about logarithms in its interior is made. -/
+noncomputable section
+open Set Filter Metric Function
+open scoped Topology
+
+namespace SLEExactGauge
+
+lemma exists_continuous_path_log (f : C(unitInterval,ℂ)) (hn : ∀ t, f t≠0)
+    (a : ℂ) (ha : Complex.exp a=f 0) :
+    ∃ L : C(unitInterval,ℂ), (∀ t, Complex.exp (L t)=f t) ∧ L 0=a := by
+  let g : C(unitInterval,{z : ℂ // z≠0}) := ⟨fun t => ⟨f t,hn t⟩,f.continuous.subtype_mk _⟩
+  obtain ⟨L,hL,h0⟩ := Complex.isCoveringMap_exp.exists_path_lifts g a (Subtype.ext ha.symm)
+  exact ⟨L,fun t => congrArg Subtype.val (congr_fun hL t),h0⟩
+
+lemma rectangle_difference_boundary_log (c p : C(unitInterval,ℂ))
+    (hc : c 0=c 1) (hbase : ∀ s, c 0-p s≠0)
+    (L₀ L₁ : C(unitInterval,ℂ))
+    (hL₀ : ∀ t, Complex.exp (L₀ t)=c t-p 0)
+    (hL₁ : ∀ t, Complex.exp (L₁ t)=c t-p 1)
+    (h₀ : L₀ 0=L₀ 1) (h₁ : L₁ 0=L₁ 1) :
+    ∃ K : C(unitInterval × unitInterval,ℂ), ∀ q,
+      q.1=0 ∨ q.1=1 ∨ q.2=0 ∨ q.2=1 →
+      Complex.exp (K q)=c q.2-p q.1 := by
+  let f : C(unitInterval,ℂ) := ⟨fun s => c 0-p s,continuous_const.sub p.continuous⟩
+  obtain ⟨B,hB,hB0⟩ := exists_continuous_path_log f hbase (L₀ 0) (hL₀ 0)
+  let d := B 1-L₁ 0
+  have hd : Complex.exp d=1 := by
+    dsimp [d]
+    rw [Complex.exp_sub,hB,hL₁]
+    exact div_self (hbase 1)
+  have hB1 : L₁ 0+d=B 1 := by dsimp [d]; ring
+  let K : C(unitInterval × unitInterval,ℂ) :=
+    ⟨fun q => (1-(q.1:ℂ))*L₀ q.2+(q.1:ℂ)*(L₁ q.2+d)+B q.1-
+      (1-(q.1:ℂ))*B 0-(q.1:ℂ)*B 1,by fun_prop⟩
+  refine ⟨K,fun q hq => ?_⟩
+  rcases hq with hq | hq | hq | hq
+  · have he : K q=L₀ q.2 := by simp [K,hq]
+    rw [he,hL₀,hq]
+  · have he : K q=L₁ q.2+d := by simp [K,hq]
+    rw [he,Complex.exp_add,hd,mul_one,hL₁,hq]
+  · have he : K q=B q.1 := by
+      dsimp [K]
+      rw [hq,hB0,hB1]
+      ring
+    rw [he,hB]
+    simp [f,hq]
+  · have he : K q=B q.1 := by
+      dsimp [K]
+      rw [hq,← h₀,← h₁,hB0,hB1]
+      ring
+    rw [he,hB]
+    simp [f,hq,← hc]
+
+end SLEExactGauge
+
+end
+
+end OAI
diff --git a/lean/OAI/Probability/SLE/Geometry/RectangleWedgeSplit.lean b/lean/OAI/Probability/SLE/Geometry/RectangleWedgeSplit.lean
new file mode 100644
index 0000000000000000000000000000000000000000..0247630b4aab4de083d1fc60e868e6a34c02b016
--- /dev/null
+++ b/lean/OAI/Probability/SLE/Geometry/RectangleWedgeSplit.lean
@@ -0,0 +1,31 @@
+import Mathlib.Analysis.Complex.HasPrimitives
+
+namespace OAI
+
+/-! Splitting a rectangular Cauchy integral along a horizontal line. This
+is the local gluing identity needed for a constant boundary interval. -/
+noncomputable section
+open Complex MeasureTheory Set
+open scoped Interval
+
+namespace SLEExactGauge
+
+lemma rectangle_wedge_split (f : ℂ → ℂ) (z w : ℂ) (c : ℝ)
+    (hz₁ : IntervalIntegrable (fun y : ℝ => f (z.re+y*I)) volume z.im c)
+    (hz₂ : IntervalIntegrable (fun y : ℝ => f (z.re+y*I)) volume c w.im)
+    (hw₁ : IntervalIntegrable (fun y : ℝ => f (w.re+y*I)) volume z.im c)
+    (hw₂ : IntervalIntegrable (fun y : ℝ => f (w.re+y*I)) volume c w.im) :
+    wedgeIntegral z w f+wedgeIntegral w z f=
+      (wedgeIntegral z (⟨w.re,c⟩:ℂ) f+wedgeIntegral (⟨w.re,c⟩:ℂ) z f)+
+      (wedgeIntegral (⟨z.re,c⟩:ℂ) w f+wedgeIntegral w (⟨z.re,c⟩:ℂ) f) := by
+  simp only [wedgeIntegral_add_wedgeIntegral_eq]
+  rw [← intervalIntegral.integral_add_adjacent_intervals hz₁ hz₂,
+    ← intervalIntegral.integral_add_adjacent_intervals hw₁ hw₂]
+  simp only [smul_add]
+  abel
+
+end SLEExactGauge
+
+end
+
+end OAI
diff --git a/lean/OAI/Probability/SLE/Geometry/ReflectedInvertedUpperConnected.lean b/lean/OAI/Probability/SLE/Geometry/ReflectedInvertedUpperConnected.lean
new file mode 100644
index 0000000000000000000000000000000000000000..67c93cce726a0624f1e531cd573c9e444dc3ef17
--- /dev/null
+++ b/lean/OAI/Probability/SLE/Geometry/ReflectedInvertedUpperConnected.lean
@@ -0,0 +1,89 @@
+import OAI.Probability.SLE.Geometry.InvertedArcComponents
+
+namespace OAI
+
+/-! The upper component of the inverted reflected-slit domain is a
+conjugate-inversion image of the original half-plane slit domain. -/
+noncomputable section
+open Set Complex Function
+open scoped ComplexConjugate
+
+namespace SLEExactGauge
+
+def conjugateInversion (z : ℂ) : ℂ := (conj z)⁻¹
+
+@[simp] lemma conjugateInversion_involutive (z : ℂ) :
+    conjugateInversion (conjugateInversion z)=z := by
+  simp only [conjugateInversion,map_inv₀,conj_conj,inv_inv]
+
+lemma conjugateInversion_upper {z : ℂ} (hz : z ∈ upperHalfPlane) :
+    conjugateInversion z ∈ upperHalfPlane := by
+  have hzn : z ≠ 0 := by
+    intro he
+    simp only [upperHalfPlane,mem_ofPred_eq,he,zero_im,lt_self_iff_false] at hz
+  change 0 < ((conj z)⁻¹).im
+  rw [inv_im,conj_im,neg_neg]
+  exact div_pos hz (normSq_pos.mpr (by simpa using hzn))
+
+theorem reflected_inverted_upper_image
+    (p : C(unitInterval,ℂ)) (h0 : p 0=0)
+    (hH : ∀ t : unitInterval, t ≠ 0 → p t ∈ upperHalfPlane) :
+    invertedExterior (reflectedArcSet p) ∩ upperHalfPlane =
+      conjugateInversion '' (upperHalfPlane \ range p) := by
+  have hp : ∀ t, 0 ≤ (p t).im := by
+    intro t
+    by_cases ht : t=0
+    · simp [ht,h0]
+    · exact (hH t ht).le
+  have hn : ∀ z ∈ upperHalfPlane, z ≠ (0:ℂ) := by
+    intro z hz he
+    simp only [upperHalfPlane,mem_ofPred_eq,he,zero_im,lt_self_iff_false] at hz
+  apply Subset.antisymm
+  · rintro z ⟨hzD,hzH⟩
+    have hzn := hn z hzH
+    have hnot : conjugateInversion z ∉ range p := by
+      intro he
+      have hzinv : z⁻¹ ∈ reflectedArcSet p := by
+        right
+        refine ⟨conjugateInversion z,he,?_⟩
+        simp only [conjugateInversion,map_inv₀,conj_conj]
+      exact (hzD.resolve_left hzn) hzinv
+    exact ⟨conjugateInversion z,⟨conjugateInversion_upper hzH,hnot⟩,
+      conjugateInversion_involutive z⟩
+  · rintro z ⟨w,⟨hwH,hwP⟩,rfl⟩
+    refine ⟨Or.inr ?_,conjugateInversion_upper hwH⟩
+    intro he
+    have hwInv : (conj w) ∈ reflectedArcSet p := by
+      simpa only [conjugateInversion,inv_inv] using he
+    rcases hwInv with ⟨t,ht⟩|⟨v,hv,heq⟩
+    · have hh := congrArg Complex.im ht
+      rw [conj_im] at hh
+      have hpt := hp t
+      change 0 < w.im at hwH
+      linarith
+    · have hvw : v=w := by
+        have hh := congrArg conj heq
+        simpa only [conj_conj] using hh
+      exact hwP (hvw ▸ hv)
+
+theorem reflected_inverted_upper_connected
+    (p : C(unitInterval,ℂ)) (hi : Injective p) (h0 : p 0=0)
+    (hH : ∀ t : unitInterval, t ≠ 0 → p t ∈ upperHalfPlane) :
+    IsConnected (invertedExterior (reflectedArcSet p) ∩ upperHalfPlane) := by
+  rw [reflected_inverted_upper_image p h0 hH]
+  apply (simple_arc_halfPlane_complement_connected p hi h0 hH).image
+  intro z hz
+  have hzn : conj z ≠ 0 := by
+    intro he
+    have hh := congrArg Complex.im he
+    simp only [conj_im,zero_im] at hh
+    have hzH := hz.1
+    change 0 < z.im at hzH
+    linarith
+  exact (Complex.continuous_conj.continuousAt.inv₀ hzn).continuousWithinAt
+
+end SLEExactGauge
+
+end
+
+end OAI
diff --git a/lean/OAI/Probability/SLE/Geometry/ReflectedRealSeparation.lean b/lean/OAI/Probability/SLE/Geometry/ReflectedRealSeparation.lean
new file mode 100644
index 0000000000000000000000000000000000000000..ddf9fe0f1a9e31022abf8b38453c2d91a7dd34c7
--- /dev/null
+++ b/lean/OAI/Probability/SLE/Geometry/ReflectedRealSeparation.lean
@@ -0,0 +1,74 @@
+import OAI.Probability.SLE.Loewner.ReflectedForwardContinuity
+import OAI.Probability.SLE.Loewner.SlitBoundaryTip
+
+namespace OAI
+
+/-! A real point different from the root never maps to the driving tip
+under the normalized analytic continuation of an initial slit chart. -/
+noncomputable section
+open Set Filter Function Complex
+open scoped Topology
+
+namespace SLEExactGauge
+
+theorem initialReflectedForward_ne_driver (p : C(unitInterval,ℂ)) (hi : Injective p)
+    (h0 : p 0=0) (hH : ∀ t : unitInterval, t≠0 → p t∈upperHalfPlane)
+    {s : unitInterval} (hs : s<1) {x : ℝ} (hx : x≠0) :
+    initialReflectedForward p hi h0 hH s (x:ℂ)≠(initialDrivingValue p hi h0 hH s hs:ℂ) := by
+  let G := initialReflectedForward p hi h0 hH s
+  have hD : IsOpen (reflectedArcSet p)ᶜ :=
+    ((isCompact_range p.continuous).union
+      ((isCompact_range p.continuous).image Complex.continuous_conj)).isClosed.isOpen_compl
+  have hxD : (x:ℂ)∈(reflectedArcSet p)ᶜ := real_not_reflected_arc p h0 hH hx
+  have hc : ContinuousAt G (x:ℂ) :=
+    ((initialReflectedForward_differentiable p hi h0 hH s).differentiableAt
+      (hD.mem_nhds hxD)).continuousAt
+  let v := fun y : ℝ => (x:ℂ)+(y:ℂ)*I
+  have hv : Tendsto v (𝓝[>] (0:ℝ)) (𝓝 (x:ℂ)) := by
+    have h : Continuous v := by dsimp [v]; fun_prop
+    simpa only [v,ofReal_zero,zero_mul,add_zero] using
+      (h.tendsto 0).mono_left nhdsWithin_le_nhds
+  have hm : ∀ᶠ y : ℝ in 𝓝[>] (0:ℝ), v y∈upperHalfPlane ∩ (reflectedArcSet p)ᶜ := by
+    filter_upwards [self_mem_nhdsWithin,hv.eventually (hD.mem_nhds hxD)] with y hy hyD
+    exact ⟨by simpa [v,upperHalfPlane] using hy,hyD⟩
+  obtain ⟨B,hBc,hBF,hBu⟩ := exists_initial_inverse_boundary_tip p hi h0 hH hs
+  have hGmem : ∀ᶠ y : ℝ in 𝓝[>] (0:ℝ), G (v y)∈{z : ℂ | 0 ≤ z.im} := by
+    filter_upwards [hm] with y hy
+    have hd : v y∈upperHalfPlane \ range (initialSubarc p s) :=
+      ⟨hy.1,fun he => hy.2 (reflected_initial_subset p s (Or.inl he))⟩
+    rw [show G (v y)=initialForwardChart p hi h0 hH s (v y) from
+      initialReflectedForward_eq p hi h0 hH s hd]
+    exact (show 0<(initialForwardChart p hi h0 hH s (v y)).im from
+      initialForwardChart_mem_upper p hi h0 hH s hd).le
+  have hq : G (x:ℂ)∈{z : ℂ | 0 ≤ z.im} := by
+    change 0 ≤ (initialReflectedForward p hi h0 hH s (x:ℂ)).im
+    rw [initialReflectedForward_real p hi h0 hH s hx]
+  have hlim := (hBc _ hq).tendsto.comp
+    (tendsto_nhdsWithin_iff.mpr ⟨hc.tendsto.comp hv,hGmem⟩)
+  have hleft : B (G (x:ℂ))=(x:ℂ) := by
+    apply tendsto_nhds_unique hlim
+    apply hv.congr'
+    filter_upwards [hm] with y hy
+    have hd : v y∈upperHalfPlane \ range (initialSubarc p s) :=
+      ⟨hy.1,fun he => hy.2 (reflected_initial_subset p s (Or.inl he))⟩
+    have he : G (v y)=initialForwardChart p hi h0 hH s (v y) :=
+      initialReflectedForward_eq p hi h0 hH s hd
+    symm
+    change B (G (v y))=v y
+    rw [he,hBF _ (initialForwardChart_mem_upper p hi h0 hH s hd),
+      initialInverse_forward_at p hi h0 hH s hd]
+  intro he
+  change G (x:ℂ)=(initialDrivingValue p hi h0 hH s hs:ℂ) at he
+  rw [he,hBu] at hleft
+  by_cases hs0 : s=0
+  · rw [hs0,h0] at hleft
+    exact hx (ofReal_eq_zero.mp hleft.symm)
+  · have hp := hH s hs0
+    rw [hleft] at hp
+    simp [upperHalfPlane] at hp
+
+end SLEExactGauge
+
+end
+
+end OAI
diff --git a/lean/OAI/Probability/SLE/Geometry/ReflectedRiemannSymmetry.lean b/lean/OAI/Probability/SLE/Geometry/ReflectedRiemannSymmetry.lean
new file mode 100644
index 0000000000000000000000000000000000000000..5e50786c697f8739f460596971006743150f26ab
--- /dev/null
+++ b/lean/OAI/Probability/SLE/Geometry/ReflectedRiemannSymmetry.lean
@@ -0,0 +1,61 @@
+import OAI.Probability.SLE.Geometry.NormalizedRiemannUniqueness
+import Mathlib.Analysis.Calculus.Deriv.Star
+
+namespace OAI
+
+/-! The positive-real derivative normalization makes the conformal chart
+of a reflection-invariant domain commute with complex conjugation. -/
+noncomputable section
+open Set Complex Metric Function
+open scoped Topology ComplexConjugate
+
+namespace SLEExactGauge
+
+theorem normalized_riemann_chart_conj {D : Set ℂ}
+    (ho : IsOpen D) (h0D : (0:ℂ) ∈ D) (hD : MapsTo conj D D)
+    {f : ℂ → ℂ} (hf : DifferentiableOn ℂ f D) (hb : BijOn f D (ball 0 1))
+    (h0 : f 0=0) {a : ℝ} (hd : deriv f 0=(a:ℂ)) :
+    ∀ z ∈ D, f (conj z)=conj (f z) := by
+  let g := conj ∘ f ∘ conj
+  have hgd : DifferentiableOn ℂ g D := by
+    intro z hz
+    have hh := (hf.differentiableAt (ho.mem_nhds (hD hz))).conj_conj
+    simpa only [conj_conj] using hh.differentiableWithinAt
+  have hgm : MapsTo g D (ball 0 1) := by
+    intro z hz
+    have hh := hb.mapsTo (hD hz)
+    simpa only [g,Function.comp_apply,mem_ball,dist_zero_right,norm_conj] using hh
+  have hg0 : g 0=0 := by simp [g,h0]
+  have hgder : deriv g 0=deriv f 0 := by
+    dsimp only [g]
+    rw [deriv_conj_conj]
+    simp only [Function.comp_apply,map_zero,hd,conj_ofReal]
+  have he := riemann_chart_eq_of_deriv_eq ho h0D hgd hf hgm hb hg0 h0 hgder
+  intro z hz
+  have hh := congrArg conj (he hz)
+  simpa only [g,Function.comp_apply,conj_conj] using hh
+
+lemma reflectedArcSet_conj (p : C(unitInterval,ℂ)) :
+    MapsTo conj (reflectedArcSet p) (reflectedArcSet p) := by
+  intro z hz
+  rcases hz with hz|⟨w,hw,rfl⟩
+  · exact Or.inr ⟨z,hz,rfl⟩
+  · rw [conj_conj]
+    exact Or.inl hw
+
+lemma invertedExterior_conj {K : Set ℂ} (hK : MapsTo conj K K) :
+    MapsTo conj (invertedExterior K) (invertedExterior K) := by
+  intro z hz
+  rcases hz with rfl|hz
+  · exact Or.inl (map_zero conj)
+  · right
+    intro h
+    apply hz
+    have hh := hK h
+    simpa only [map_inv₀,conj_conj] using hh
+
+end SLEExactGauge
+
+end
+
+end OAI
diff --git a/lean/OAI/Probability/SLE/Geometry/ReflectedSimpleArc.lean b/lean/OAI/Probability/SLE/Geometry/ReflectedSimpleArc.lean
new file mode 100644
index 0000000000000000000000000000000000000000..efb4938ee4ee296e9fc6cb86480688150f1d60c3
--- /dev/null
+++ b/lean/OAI/Probability/SLE/Geometry/ReflectedSimpleArc.lean
@@ -0,0 +1,76 @@
+import OAI.Probability.SLE.Geometry.SimplePathConcatenation
+import OAI.Probability.SLE.Geometry.SimpleArcPlaneComplement
+import OAI.Probability.SLE.Geometry.SimpleSlitConnected
+
+namespace OAI
+
+/-! Reflecting a simple attached arc across the real boundary produces
+one simple planar arc, whose entire complement is connected. -/
+noncomputable section
+open Set Complex Function
+open scoped Topology ComplexConjugate unitInterval
+
+namespace SLEExactGauge
+
+def reflectedArcSet (p : C(unitInterval,ℂ)) : Set ℂ :=
+  range p ∪ conj '' range p
+
+theorem reflectedArc_is_simple_arc (p : C(unitInterval,ℂ))
+    (hi : Injective p) (h0 : p 0=0)
+    (hH : ∀ t : unitInterval, t ≠ 0 → p t ∈ upperHalfPlane) :
+    ∃ q : C(unitInterval,ℂ), Injective q ∧ range q=reflectedArcSet p := by
+  let r : Path (0:ℂ) (p 1) := ⟨p,h0,rfl⟩
+  let l : Path (conj (p 1)) 0 := {
+    toFun := fun t => conj (p (unitInterval.symm t))
+    continuous_toFun := Complex.continuous_conj.comp (p.continuous.comp unitInterval.continuous_symm)
+    source' := by simp
+    target' := by simp [h0] }
+  have hl : Injective l := by
+    intro s t he
+    apply unitInterval.symm_bijective.injective
+    apply hi
+    change conj (p (unitInterval.symm s))=conj (p (unitInterval.symm t)) at he
+    simpa only [conj_conj] using congrArg conj he
+  have hr : Injective r := hi
+  have hc (s t : unitInterval) (he : l s=r t) : s=1 ∧ t=0 := by
+    have ht : t=0 := by
+      by_contra ht
+      have htp := hH t ht
+      have hsp : 0 ≤ (p (unitInterval.symm s)).im := by
+        by_cases hs : unitInterval.symm s=0
+        · simp [hs,h0]
+        · exact (hH _ hs).le
+      have hh := congrArg Complex.im he
+      change -(p (unitInterval.symm s)).im=(p t).im at hh
+      change 0 < (p t).im at htp
+      linarith
+    have hs : s=1 := by
+      have hz : p (unitInterval.symm s)=p 0 := by
+        have hh : conj (p (unitInterval.symm s))=0 := by simpa [l,r,ht,h0] using he
+        have hh' := congrArg conj hh
+        simpa [h0] using hh'
+      have hsym := hi hz
+      simpa using congrArg unitInterval.symm hsym
+    exact ⟨hs,ht⟩
+  refine ⟨(l.trans r).toContinuousMap,path_trans_injective l r hl hr hc,?_⟩
+  rw [Path.coe_toContinuousMap,Path.trans_range]
+  have hlrange : range l=conj '' range p := by
+    change range (fun t => conj (p (unitInterval.symm t)))=conj '' range p
+    exact (unitInterval.symm_bijective.surjective.range_comp
+      (fun t => conj (p t))).trans (range_comp conj p)
+  rw [hlrange]
+  exact union_comm _ _
+
+theorem reflectedArc_complement_connected (p : C(unitInterval,ℂ))
+    (hi : Injective p) (h0 : p 0=0)
+    (hH : ∀ t : unitInterval, t ≠ 0 → p t ∈ upperHalfPlane) :
+    IsConnected (reflectedArcSet p)ᶜ := by
+  obtain ⟨q,hq,hqrange⟩ := reflectedArc_is_simple_arc p hi h0 hH
+  rw [← hqrange]
+  exact simple_arc_plane_complement_connected q hq
+
+end SLEExactGauge
+
+end
+
+end OAI
diff --git a/lean/OAI/Probability/SLE/Geometry/RegularSlitTube.lean b/lean/OAI/Probability/SLE/Geometry/RegularSlitTube.lean
new file mode 100644
index 0000000000000000000000000000000000000000..c13b1f3c050f82225032f05143ebf3a954b0be47
--- /dev/null
+++ b/lean/OAI/Probability/SLE/Geometry/RegularSlitTube.lean
@@ -0,0 +1,122 @@
+import OAI.Probability.SLE.Loewner.RealCharacteristicAvoidance
+import OAI.Probability.SLE.Loewner.LoewnerTipVisit
+import OAI.Probability.SLE.Geometry.ActualCompactAvoidance
+
+namespace OAI
+
+/-! Open-tube support for a deterministic slit with regular real
+characteristics. The slit geometry and the existence of these
+characteristics remain explicit deterministic obligations. -/
+noncomputable section
+open Set Filter Metric _root_.MeasureTheory _root_.OAI.MeasureTheory ProbabilityTheory
+open scoped Topology NNReal ENNReal
+
+namespace SLEExactGauge
+
+def RegularRealCharacteristics (V : ℝ≥0 → ℝ) (T : ℝ≥0) : Prop :=
+  ∀ x : ℝ, x ≠ 0 → ∃ q : ℝ → ℝ, q 0=x ∧
+    (∀ t ∈ Icc 0 (T : ℝ), HasDerivWithinAt q
+      (2/(q t-V t.toNNReal)) (Icc 0 (T : ℝ)) t) ∧
+    ∀ t ∈ Icc 0 (T : ℝ), q t-V t.toNNReal ≠ 0
+
+lemma regular_slit_driver_trace_containment
+    {V : ℝ≥0 → ℝ} (hV : Continuous V)
+    {β : ℝ≥0 → ℂ} {H J : ℝ≥0 → ℂ → ℂ}
+    (hv : IsCapacityTwoWitness V β H J) (T : ℝ≥0)
+    (hfree : upperHalfPlane \ (β '' Icc 0 T) ⊆ survivingDomain β T)
+    (hreal : RegularRealCharacteristics V T)
+    (N : Set ℂ) (hN : IsOpen N) (hsub : β '' Icc 0 T ⊆ N) :
+    ∃ δ : ℝ, 0 < δ ∧ ∀ (U : ℝ≥0 → ℝ), Continuous U →
+      ∀ (γ : ℝ≥0 → ℂ) (G F : ℝ≥0 → ℂ → ℂ), IsCapacityTwoWitness U γ G F →
+      (∀ t ∈ Icc 0 T, |U t-V t| ≤ δ) → MapsTo γ (Icc 0 T) N := by
+  apply driver_neighborhood_trace_containment V hV T N hN
+  intro z hz hzN
+  have hztrace : z ∉ β '' Icc 0 T := fun h => hzN (hsub h)
+  by_cases him : 0 < z.im
+  · exact stableTraceAvoidance_of_surviving hv T (hfree ⟨him,hztrace⟩)
+  · have hz0 : z.im=0 := le_antisymm (le_of_not_gt him) hz
+    have hez : z=(z.re : ℂ) := by apply Complex.ext <;> simp [hz0]
+    have hx : z.re ≠ 0 := by
+      intro he
+      have he0 : z=0 := by simpa only [he,Complex.ofReal_zero] using hez
+      apply hztrace
+      exact ⟨0,⟨le_rfl,zero_le⟩,hv.2.1.trans he0.symm⟩
+    obtain ⟨q,hq0,hqd,hn⟩ := hreal z.re hx
+    have hh := stableTraceAvoidance_of_real_characteristic V hV T q hqd hn
+    rwa [hq0,← hez] at hh
+
+theorem regular_slit_driver_tube
+    {V : ℝ≥0 → ℝ} (hV : Continuous V)
+    {β : ℝ≥0 → ℂ} {H J : ℝ≥0 → ℂ → ℂ}
+    (hv : IsCapacityTwoWitness V β H J) (T : ℝ≥0)
+    (hfree : upperHalfPlane \ (β '' Icc 0 T) ⊆ survivingDomain β T)
+    (hreal : RegularRealCharacteristics V T) (htip : 0 < (β T).im)
+    (N W : Set ℂ) (hN : IsOpen N) (hW : IsOpen W)
+    (hsub : β '' Icc 0 T ⊆ N) (hend : β T ∈ W) :
+    ∃ δ : ℝ, 0 < δ ∧ ∀ (U : ℝ≥0 → ℝ), Continuous U →
+      ∀ (γ : ℝ≥0 → ℂ) (G F : ℝ≥0 → ℂ → ℂ), IsCapacityTwoWitness U γ G F →
+      (∀ t ∈ Icc 0 T, |U t-V t| ≤ δ) →
+      ∃ t : ℝ≥0, 0 < t ∧ MapsTo γ (Icc 0 t) N ∧ γ t ∈ W := by
+  obtain ⟨δ₁,hδ₁,hstay⟩ := regular_slit_driver_trace_containment hV hv T hfree hreal N hN hsub
+  obtain ⟨r,hr,hrW⟩ := Metric.isOpen_iff.mp hW _ hend
+  obtain ⟨δ₂,hδ₂,hvisit⟩ := driver_neighborhood_visits_tip hv T (lt_min hr htip)
+    (min_le_right r (β T).im) isCompact_empty (empty_subset _)
+  refine ⟨min δ₁ δ₂,lt_min hδ₁ hδ₂,?_⟩
+  intro U hU γ G F hw hc
+  have hs := hstay U hU γ G F hw (fun t ht => (hc t ht).trans (min_le_left _ _))
+  obtain ⟨_,t,ht,hb⟩ := hvisit U γ G F hw (fun t ht => (hc t ht).trans (min_le_right _ _))
+  have ht0 : 0 < t := by
+    by_contra hn
+    have he : t=0 := le_antisymm (le_of_not_gt hn) zero_le
+    have hi := ball_subset_halfPlane (min_le_right r (β T).im) hb
+    rw [he,hw.2.1] at hi
+    exact (lt_irrefl (0 : ℝ)) hi
+  exact ⟨t,ht0,fun s hs' => hs ⟨hs'.1,hs'.2.trans ht.2⟩,
+    hrW ((ball_subset_ball (min_le_left _ _)) hb)⟩
+
+theorem regular_slit_tube_positive
+    {Ω : Type*} [MeasurableSpace Ω] {P : Measure Ω} [IsProbabilityMeasure P]
+    {κ : ℝ} {γ : Ω → ℝ≥0 → ℂ} (a : RegularSLEPresentation P κ γ)
+    (hκ : 0 < κ) (V : C(ℝ≥0,ℝ)) (hV0 : V 0=0)
+    {β : ℝ≥0 → ℂ} {H J : ℝ≥0 → ℂ → ℂ}
+    (hv : IsCapacityTwoWitness V β H J) (T : ℝ≥0) (hT : 0 < T)
+    (hfree : upperHalfPlane \ (β '' Icc 0 T) ⊆ survivingDomain β T)
+    (hreal : RegularRealCharacteristics V T) (htip : 0 < (β T).im)
+    (N W : Set ℂ) (hN : IsOpen N) (hW : IsOpen W)
+    (hsub : β '' Icc 0 T ⊆ N) (hend : β T ∈ W) :
+    0 < (P.comap (Subtype.val : a.samples → Ω))
+      {ω | ∃ t : ℝ≥0, 0 < t ∧ MapsTo (γ ω) (Icc 0 t) N ∧ γ ω t ∈ W} := by
+  obtain ⟨δ,hδ,hh⟩ := regular_slit_driver_tube V.continuous hv T hfree hreal htip
+    N W hN hW hsub hend
+  have hp := regular_scaled_driver_tube_positive a hκ V hV0 T hT hδ
+  apply hp.trans_le (measure_mono ?_)
+  intro ω hω
+  exact hh (fun t => Real.sqrt κ*a.B t ω) (continuous_const.mul (a.continuous_B ω))
+    (γ ω) (a.G ω) (a.F ω) (a.witness ω) (fun t ht => (hω t ht).le)
+
+theorem ordinary_regular_slit_tube_positive
+    {Ω : Type*} [MeasurableSpace Ω] (P : Measure Ω) [IsProbabilityMeasure P]
+    (κ : ℝ) (hκ : 0 < κ) (γ : Ω → ℝ≥0 → ℂ)
+    (hSLE : IsOrdinaryChordalSLE κ γ P)
+    (V : C(ℝ≥0,ℝ)) (hV0 : V 0=0)
+    {β : ℝ≥0 → ℂ} {H J : ℝ≥0 → ℂ → ℂ}
+    (hv : IsCapacityTwoWitness V β H J) (T : ℝ≥0) (hT : 0 < T)
+    (hfree : upperHalfPlane \ (β '' Icc 0 T) ⊆ survivingDomain β T)
+    (hreal : RegularRealCharacteristics V T) (htip : 0 < (β T).im)
+    (N W : Set ℂ) (hN : IsOpen N) (hW : IsOpen W)
+    (hsub : β '' Icc 0 T ⊆ N) (hend : β T ∈ W) :
+    0 < P {ω | ∃ t : ℝ≥0, 0 < t ∧ MapsTo (γ ω) (Icc 0 t) N ∧ γ ω t ∈ W} := by
+  obtain ⟨a⟩ := exists_regular_sle_presentation hSLE
+  have hp := regular_slit_tube_positive a hκ V hV0 hv T hT hfree hreal htip N W hN hW hsub hend
+  apply hp.trans_le
+  have hh := Measure.le_map_apply (μ := P.comap (Subtype.val : a.samples → Ω))
+    a.measurePreserving_val.measurable.aemeasurable
+    {ω | ∃ t : ℝ≥0, 0 < t ∧ MapsTo (γ ω) (Icc 0 t) N ∧ γ ω t ∈ W}
+  rw [a.measurePreserving_val.map_eq] at hh
+  convert! hh using 1
+
+end SLEExactGauge
+
+end
+
+end OAI
diff --git a/lean/OAI/Probability/SLE/Geometry/RemainderKernelCancellation.lean b/lean/OAI/Probability/SLE/Geometry/RemainderKernelCancellation.lean
new file mode 100644
index 0000000000000000000000000000000000000000..8c56b756da3c37d8ffdb689ca5fd27b630f126e4
--- /dev/null
+++ b/lean/OAI/Probability/SLE/Geometry/RemainderKernelCancellation.lean
@@ -0,0 +1,56 @@
+import OAI.Probability.SLE.Mass.RandomMeasureDifference
+import OAI.Probability.SLE.Mass.LevelConditionalMean
+
+namespace OAI
+
+/-! A conditional sum identity identifies the positive remaining measure.
+Cancellation uses sigma finiteness, not finite total trace mass. -/
+
+noncomputable section
+open Set Filter MeasureTheory
+open scoped ENNReal
+
+namespace SLEExactGauge
+
+lemma bind_add_of_ae
+    {Ω X : Type*} [MeasurableSpace Ω] [MeasurableSpace X] (P : Measure Ω)
+    (μ ν η : Ω → Measure X) (hμ : Measurable μ) (hν : Measurable ν) (hη : Measurable η)
+    (hsum : ∀ᵐ ω ∂P, η ω + μ ω = ν ω) : P.bind η + P.bind μ = P.bind ν := by
+  apply Measure.ext
+  intro A hA
+  rw [Measure.add_apply,Measure.bind_apply hA hη.aemeasurable,
+    Measure.bind_apply hA hμ.aemeasurable,Measure.bind_apply hA hν.aemeasurable]
+  have hηA : Measurable (fun ω => η ω A) := (Measure.measurable_coe hA).comp hη
+  rw [← lintegral_add_left hηA]
+  apply lintegral_congr_ae
+  filter_upwards [hsum] with ω hω
+  simpa only [Measure.add_apply] using congrArg (fun ρ : Measure X => ρ A) hω
+
+lemma bind_remainder_eq_of_sum
+    {Ω X : Type*} [MeasurableSpace Ω] [MeasurableSpace X] (P : Measure Ω)
+    (μ ν η : Ω → Measure X) (hμ : Measurable μ) (hν : Measurable ν) (hη : Measurable η)
+    [SigmaFinite (P.bind μ)] (K : Measure X)
+    (hsum : ∀ᵐ ω ∂P, η ω + μ ω = ν ω)
+    (hkernel : P.bind ν = P.bind μ + K) : P.bind η = K := by
+  apply (Measure.add_left_inj (P.bind μ) (P.bind η) K).mp
+  calc
+    P.bind η + P.bind μ = P.bind ν := bind_add_of_ae P μ ν η hμ hν hη hsum
+    _ = P.bind μ + K := hkernel
+    _ = K + P.bind μ := add_comm _ _
+
+
+lemma restricted_bind_le_of_ae_le
+    {Ω X : Type*} [MeasurableSpace Ω] [MeasurableSpace X] (P : Measure Ω)
+    (μ ν : Ω → Measure X) (hμ : Measurable μ) (hν : Measurable ν)
+    (hle : ∀ᵐ ω ∂P, μ ω ≤ ν ω) (E : Set Ω) : (P.restrict E).bind μ ≤ P.bind ν := by
+  apply Measure.le_iff.mpr
+  intro A hA
+  rw [Measure.bind_apply hA hμ.aemeasurable,Measure.bind_apply hA hν.aemeasurable]
+  exact (lintegral_mono_ae ((ae_restrict_of_ae hle).mono (fun ω hω => hω A))).trans
+    (lintegral_mono' Measure.restrict_le_self (le_refl _))
+
+end SLEExactGauge
+
+end
+
+end OAI
diff --git a/lean/OAI/Probability/SLE/Geometry/RestartAE.lean b/lean/OAI/Probability/SLE/Geometry/RestartAE.lean
new file mode 100644
index 0000000000000000000000000000000000000000..76166a0d6437cb002aa7e2c112f19dfee8a01a71
--- /dev/null
+++ b/lean/OAI/Probability/SLE/Geometry/RestartAE.lean
@@ -0,0 +1,33 @@
+import OAI.Probability.SLE.Geometry.RandomRestartEvents
+
+namespace OAI
+
+/-! A measurable family of full fresh-law events remains almost sure when
+its parameter is selected from the original stopped past. -/
+
+noncomputable section
+open Set Filter MeasureTheory
+
+namespace SLEExactGauge
+
+theorem restart_ae_random_test
+    {Ω X : Type*} [mΩ : MeasurableSpace Ω] [mX : MeasurableSpace X]
+    (P : Measure Ω) [IsFiniteMeasure P] (ν : Measure X) [IsFiniteMeasure ν]
+    (m : MeasurableSpace Ω) (hm : m ≤ mΩ)
+    (Y : Ω → X) (hY : Measurable[mΩ] Y)
+    (hlaw : ∀ A : Set Ω, MeasurableSet[m] A →
+      @Measure.map Ω X mΩ mX Y (P.restrict A) = P A • ν)
+    (R : Ω × X → Prop) (hR : @MeasurableSet (Ω × X) (m.prod mX) {p | R p})
+    (hsections : ∀ ω, ∀ᵐ x ∂ν, R (ω,x)) : ∀ᵐ ω ∂P, R (ω,Y ω) := by
+  have hprod : ∀ᵐ p ∂@Measure.prod Ω X m mX (P.trim hm) ν, R p :=
+    (Measure.ae_prod_iff_ae_ae hR).mpr (Eventually.of_forall hsections)
+  rw [← @restart_joint_law Ω X mΩ mX P inferInstance ν inferInstance m hm Y hY hlaw] at hprod
+  have hj : @Measurable Ω (Ω × X) mΩ (m.prod mX) (fun ω => (ω,Y ω)) :=
+    (measurable_id'' hm).prodMk hY
+  exact (ae_map_iff hj.aemeasurable hR).mp hprod
+
+end SLEExactGauge
+
+end
+
+end OAI
diff --git a/lean/OAI/Probability/SLE/Geometry/RestartCellBounds.lean b/lean/OAI/Probability/SLE/Geometry/RestartCellBounds.lean
new file mode 100644
index 0000000000000000000000000000000000000000..6a220713abada5d35c6c701276eb31a956027a35
--- /dev/null
+++ b/lean/OAI/Probability/SLE/Geometry/RestartCellBounds.lean
@@ -0,0 +1,89 @@
+import OAI.Probability.SLE.Geometry.ActualMarkedCell
+import OAI.Probability.SLE.Mass.StoppedInverseMass
+
+namespace OAI
+
+/-! Deterministic cell bounds once the actual increment is expressed through
+the inverse map and a normalized fresh mass. -/
+noncomputable section
+open Set Filter _root_.MeasureTheory _root_.OAI.MeasureTheory Metric
+open scoped Topology NNReal ENNReal
+
+namespace SLEExactGauge
+open Multipoint
+local instance restartCellLocallyCompact : LocallyCompactSpace upperHalfPlane :=
+  isOpen_upperHalfPlane.locallyCompactSpace
+
+lemma weightedImageMass_subtype_apply
+    (J : upperHalfPlane → upperHalfPlane) (hJ : Measurable J)
+    (w : upperHalfPlane → ℝ≥0∞) (μ : Measure upperHalfPlane)
+    (A : Set ℂ) (hA : MeasurableSet A) :
+    weightedImageMass J w μ (Subtype.val ⁻¹' A) =
+      weightedImageMass (fun z => (J z:ℂ)) w μ A := by
+  rw [weightedImageMass_apply J hJ w μ _ (hA.preimage measurable_subtype_coe)]
+  change _ = weightedImageMass (Subtype.val ∘ J) w μ A
+  rw [weightedImageMass_apply _ (measurable_subtype_coe.comp hJ) w μ A hA]
+  rfl
+
+lemma IsCapacityTwoWitness.restarted_cell_mass_bounds
+    {U : ℝ≥0 → ℝ} {γ : ℝ≥0 → ℂ} {G F : ℝ≥0 → ℂ → ℂ}
+    (hw : IsCapacityTwoWitness U γ G F) (hgrowth : PublishedDiskUnivalentGrowth)
+    (κ : ℝ) (hκ : 0 < κ) (t s : ℝ≥0) (hts : t ≤ s)
+    (N : ℝ≥0 → Measure upperHalfPlane) (hmono : Monotone N)
+    [IsFiniteMeasureOnCompacts (N t)]
+    (hzero : ∀ A : Set ℂ, A ⊆ survivingDomain γ t → N t (Subtype.val ⁻¹' A)=0)
+    (θ : ℝ) (hθ : θ ∈ Ioo (0:ℝ) Real.pi) (a : ℝ≥0) (ha : 0 < a)
+    (μ : Measure upperHalfPlane) [IsFiniteMeasureOnCompacts μ]
+    (he : N s-N t = weightedImageMass
+      (fun w : upperHalfPlane => (⟨F t ((w:ℂ)+(U t:ℂ)),
+        ((hw.2.2.2.2.2.2.1 t (by
+          simpa only [upperHalfPlane,mem_ofPred_eq,Complex.add_im,Complex.ofReal_im,add_zero]
+            using w.property)).1.1)⟩ : upperHalfPlane))
+      (fun w => ENNReal.ofReal (‖deriv (F t) ((w:ℂ)+(U t:ℂ))‖^dimension κ))
+      (dilationMass κ a ha μ))
+    (z : ℂ) (hz : z ∈ survivingDomain γ t)
+    (hpolar : G t z=(U t:ℂ)+(a:ℂ)*Complex.exp (θ*Complex.I))
+    (r : ℝ) (hr : 0 < r) (hR : fullRadius G t z=(2048*Real.pi)*r) :
+    let L := ENNReal.ofReal (compactWeightedMass (Target.diskMassWeight κ θ hθ)
+      (Target.diskSourceHalfPlane θ) μ)
+    ENNReal.ofReal (((128*Real.pi)*r)^dimension κ)*L ≤
+        N s (Subtype.val ⁻¹' closedBall z ((4096*Real.pi)*r)) ∧
+      ∀ A : Set ℂ, MeasurableSet A → A ⊆ closedBall z (2*r) →
+        A ⊆ survivingDomain γ t →
+        N s (Subtype.val ⁻¹' A) ≤ ENNReal.ofReal (((32768*Real.pi)*r)^dimension κ)*L := by
+  let J : upperHalfPlane → upperHalfPlane := fun w =>
+    ⟨F t ((w:ℂ)+(U t:ℂ)),((hw.2.2.2.2.2.2.1 t (by
+      simpa only [upperHalfPlane,mem_ofPred_eq,Complex.add_im,Complex.ofReal_im,add_zero]
+        using w.property)).1.1)⟩
+  have hJ : Measurable J := by
+    apply Measurable.subtype_mk
+    apply Continuous.measurable
+    apply (hw.2.2.2.2.1 t).continuousOn.comp_continuous
+      (continuous_subtype_val.add continuous_const)
+    intro w
+    change 0 < ((w:ℂ)+(U t:ℂ)).im
+    simpa only [upperHalfPlane,mem_ofPred_eq,Complex.add_im,Complex.ofReal_im,add_zero]
+      using w.property
+  have heval (A : Set ℂ) (hA : MeasurableSet A) :
+      (N s-N t) (Subtype.val ⁻¹' A) =
+        weightedImageMass (fun w : upperHalfPlane => F t ((w:ℂ)+(U t:ℂ)))
+          (fun w => ENNReal.ofReal (‖deriv (F t) ((w:ℂ)+(U t:ℂ))‖^dimension κ))
+          (dilationMass κ a ha μ) A := by
+    rw [he]
+    exact weightedImageMass_subtype_apply J hJ _ _ A hA
+  have hb := hw.cell_mass_comparison hgrowth κ hκ θ hθ t z hz r hr hR a ha hpolar μ
+  refine ⟨?_,?_⟩
+  · have h := heval (closedBall z ((4096*Real.pi)*r)) isClosed_closedBall.measurableSet
+    exact (hb.1.trans_eq h.symm).trans (Measure.sub_le _)
+  · intro A hA hAc hAs
+    have h := hb.2 A hAc
+    rw [← heval A hA] at h
+    have hzA := hzero A hAs
+    rw [measure_sub_apply_of_zero (N t) (N s) (hmono hts) (Subtype.val ⁻¹' A) hzA] at h
+    exact h
+
+end SLEExactGauge
+
+end
+
+end OAI
diff --git a/lean/OAI/Probability/SLE/Geometry/RestartConformalRadius.lean b/lean/OAI/Probability/SLE/Geometry/RestartConformalRadius.lean
new file mode 100644
index 0000000000000000000000000000000000000000..e000f45bbe10d259b080e8c409c8600a6064364a
--- /dev/null
+++ b/lean/OAI/Probability/SLE/Geometry/RestartConformalRadius.lean
@@ -0,0 +1,109 @@
+import OAI.Probability.SLE.StoppedMeasures
+
+namespace OAI
+
+/-! Exact composition of the actual restarted maps, obtained from reverse
+Loewner uniqueness. The conformal-radius and marked-angle identities then
+use differentiation on the actual surviving domain. -/
+
+noncomputable section
+open Set Filter
+open scoped Topology NNReal
+
+namespace SLEExactGauge
+
+lemma IsCapacityTwoWitness.restart_inverse_composition
+    {U : ℝ≥0 → ℝ} {γ β : ℝ≥0 → ℂ} {G F G' F' : ℝ≥0 → ℂ → ℂ}
+    (hw : IsCapacityTwoWitness U γ G F) (T : ℝ≥0)
+    (hb : IsCapacityTwoWitness (fun t => U (T + t) - U T) β G' F')
+    (t : ℝ≥0) (v : ℂ) (hv : v ∈ upperHalfPlane) :
+    F (T + t) (v + (U T : ℂ)) = F T (F' t v + (U T : ℂ)) := by
+  let Q : ℝ → ℂ := fun s => G' ((t : ℝ) - s).toNNReal (F' t v)
+  have hQ0 : Q 0 = v := by
+    simp only [Q, sub_zero, Real.toNNReal_coe]
+    exact hb.2.2.2.2.2.2.2.2.1 t v hv
+  have hQd (s : ℝ) (hs : s ∈ Icc 0 (t : ℝ)) :
+      HasDerivWithinAt Q
+        (reverseField v.im (U (T + ((t : ℝ) - s).toNNReal) - U T) (Q s))
+        (Icc 0 (t : ℝ)) s := hb.reverse_path_derivative t v hv le_rfl s hs
+  have hh := hw.source_shifted_reverse_identifies T t v hv le_rfl Q hQ0 hQd
+  have hQt : Q t = F' t v := by
+    simp only [Q, sub_self, Real.toNNReal_zero]
+    exact hb.2.2.2.2.2.2.2.2.2.1 _ (hb.2.2.2.2.2.2.1 t hv).1.1
+  rwa [hQt] at hh
+
+theorem IsCapacityTwoWitness.restart_forward_composition
+    {U : ℝ≥0 → ℝ} {γ β : ℝ≥0 → ℂ} {G F G' F' : ℝ≥0 → ℂ → ℂ}
+    (hw : IsCapacityTwoWitness U γ G F) (T : ℝ≥0)
+    (hb : IsCapacityTwoWitness (fun t => U (T + t) - U T) β G' F')
+    (t : ℝ≥0) (z : ℂ) (hz : z ∈ survivingDomain β t) :
+    F T (z + (U T : ℂ)) ∈ survivingDomain γ (T + t) ∧
+      G (T + t) (F T (z + (U T : ℂ))) = G' t z + (U T : ℂ) := by
+  have hv : G' t z ∈ upperHalfPlane := hb.2.2.2.2.2.1 t hz
+  have hvi : G' t z + (U T : ℂ) ∈ upperHalfPlane := by
+    simpa only [upperHalfPlane, mem_ofPred_eq, Complex.add_im, Complex.ofReal_im, add_zero] using hv
+  have hh := hw.restart_inverse_composition T hb t (G' t z) hv
+  rw [hb.2.2.2.2.2.2.2.1 t z hz] at hh
+  rw [← hh]
+  exact ⟨hw.2.2.2.2.2.2.1 (T + t) hvi, hw.2.2.2.2.2.2.2.2.1 (T + t) _ hvi⟩
+
+lemma IsCapacityTwoWitness.restart_derivative_composition
+    {U : ℝ≥0 → ℝ} {γ β : ℝ≥0 → ℂ} {G F G' F' : ℝ≥0 → ℂ → ℂ}
+    (hw : IsCapacityTwoWitness U γ G F) (T : ℝ≥0)
+    (hb : IsCapacityTwoWitness (fun t => U (T + t) - U T) β G' F')
+    (t : ℝ≥0) (z : ℂ) (hz : z ∈ survivingDomain β t) :
+    deriv (G (T + t)) (F T (z + (U T : ℂ))) * deriv (F T) (z + (U T : ℂ)) =
+      deriv (G' t) z := by
+  have hphysical := (hw.restart_forward_composition T hb t z hz).1
+  have hzH : z + (U T : ℂ) ∈ upperHalfPlane := by
+    simpa only [upperHalfPlane, mem_ofPred_eq, Complex.add_im, Complex.ofReal_im, add_zero] using hz.1.1
+  have hDF := ((hw.2.2.2.2.1 T).differentiableAt
+    (isOpen_upperHalfPlane.mem_nhds hzH)).hasDerivAt.comp z ((hasDerivAt_id z).add_const (U T : ℂ))
+  have hDG := ((hw.2.2.2.1 (T + t)).differentiableAt
+    ((isOpen_survivingDomain hw.1 (T + t)).mem_nhds hphysical)).hasDerivAt
+  have he : (fun u => G (T + t) (F T (u + (U T : ℂ)))) =ᶠ[𝓝 z]
+      (fun u => G' t u + (U T : ℂ)) := by
+    filter_upwards [(isOpen_survivingDomain hb.1 t).mem_nhds hz] with u hu
+    exact (hw.restart_forward_composition T hb t u hu).2
+  have hD := ((hDG.comp z hDF).congr_of_eventuallyEq he.symm).unique
+    (((hb.2.2.2.1 t).differentiableAt
+      ((isOpen_survivingDomain hb.1 t).mem_nhds hz)).hasDerivAt.add_const (U T : ℂ))
+  simpa only [mul_one] using hD
+
+theorem IsCapacityTwoWitness.restart_radius_composition
+    {U : ℝ≥0 → ℝ} {γ β : ℝ≥0 → ℂ} {G F G' F' : ℝ≥0 → ℂ → ℂ}
+    (hw : IsCapacityTwoWitness U γ G F) (hU : Continuous U) (T : ℝ≥0)
+    (hb : IsCapacityTwoWitness (fun t => U (T + t) - U T) β G' F')
+    (t : ℝ≥0) (z : ℂ) (hz : z ∈ survivingDomain β t) :
+    fullRadius G (T + t) (F T (z + (U T : ℂ))) =
+      ‖deriv (F T) (z + (U T : ℂ))‖ * fullRadius G' t z := by
+  have hforward := hw.restart_forward_composition T hb t z hz
+  have hnorm := congrArg norm (hw.restart_derivative_composition T hb t z hz)
+  rw [norm_mul] at hnorm
+  have hGpos := hw.derivative_norm_positive hU (T + t) _ hforward.1
+  have hUp : Continuous (fun t => U (T + t) - U T) :=
+    (hU.comp (continuous_const.add continuous_id)).sub continuous_const
+  have hG'pos := hb.derivative_norm_positive hUp t z hz
+  unfold fullRadius
+  rw [hforward.2]
+  simp only [Complex.add_im, Complex.ofReal_im, add_zero]
+  rw [← mul_div_assoc]
+  apply (eq_div_iff hG'pos.ne').mpr
+  rw [← hnorm]
+  field_simp [hGpos.ne']
+
+lemma IsCapacityTwoWitness.restart_centered_value
+    {U : ℝ≥0 → ℝ} {γ β : ℝ≥0 → ℂ} {G F G' F' : ℝ≥0 → ℂ → ℂ}
+    (hw : IsCapacityTwoWitness U γ G F) (T : ℝ≥0)
+    (hb : IsCapacityTwoWitness (fun t => U (T + t) - U T) β G' F')
+    (t : ℝ≥0) (z : ℂ) (hz : z ∈ survivingDomain β t) :
+    G (T + t) (F T (z + (U T : ℂ))) - (U (T + t) : ℂ) =
+      G' t z - ((U (T + t) - U T : ℝ) : ℂ) := by
+  rw [(hw.restart_forward_composition T hb t z hz).2, Complex.ofReal_sub]
+  ring
+
+end SLEExactGauge
+
+end
+
+end OAI
diff --git a/lean/OAI/Probability/SLE/Geometry/RestartContinuationKernel.lean b/lean/OAI/Probability/SLE/Geometry/RestartContinuationKernel.lean
new file mode 100644
index 0000000000000000000000000000000000000000..a0d3e6d12af39825f27d60977652e89a92bd0641
--- /dev/null
+++ b/lean/OAI/Probability/SLE/Geometry/RestartContinuationKernel.lean
@@ -0,0 +1,252 @@
+import OAI.Probability.SLE.Loewner.StoppedDriverConcatenation
+import OAI.Probability.SLE.Geometry.RandomRestartEvents
+
+namespace OAI
+
+/-! Conditional path tests after a finite restart. Splitting again at τ+t
+identifies the conditional mean in the full original stopped filtration;
+no factorization of its events through the restarted path is required. -/
+
+noncomputable section
+open Set Filter _root_.MeasureTheory _root_.OAI.MeasureTheory ProbabilityTheory
+open scoped Topology NNReal ENNReal
+
+namespace SLEExactGauge
+
+local instance continuationDriverMeasurable : MeasurableSpace C(ℝ≥0,ℝ) := borel _
+local instance continuationDriverBorel : BorelSpace C(ℝ≥0,ℝ) := ⟨rfl⟩
+
+def driverContinuationMean (ν : Measure C(ℝ≥0,ℝ)) (t : ℝ≥0)
+    (f : C(ℝ≥0,ℝ) → ℝ≥0∞) (p : C(ℝ≥0,ℝ)) : ℝ≥0∞ :=
+  ∫⁻ q, f (concatenateDriverPath t (driverPathStopped t p) q) ∂ν
+
+lemma driverContinuation_test_measurable (t : ℝ≥0)
+    (f : C(ℝ≥0,ℝ) → ℝ≥0∞) (hf : Measurable f) :
+    Measurable[(driverPathFiltration t).prod (borel C(ℝ≥0,ℝ))]
+      (fun x : C(ℝ≥0,ℝ) × C(ℝ≥0,ℝ) =>
+        f (concatenateDriverPath t (driverPathStopped t x.1) x.2)) := by
+  exact hf.comp (measurable_concatenateDriverPath.comp
+    (measurable_const.prodMk (((driverPathStopped_measurable_past t).comp measurable_fst).prodMk
+      measurable_snd)))
+
+lemma driverContinuationMean_measurable (ν : Measure C(ℝ≥0,ℝ)) [SFinite ν]
+    (t : ℝ≥0) (f : C(ℝ≥0,ℝ) → ℝ≥0∞) (hf : Measurable f) :
+    Measurable[driverPathFiltration t] (driverContinuationMean ν t f) :=
+  @Measurable.lintegral_prod_right' _ _ (driverPathFiltration t) (borel _) ν _ _
+    (driverContinuation_test_measurable t f hf)
+
+lemma sourceRestartDriverPath_measurable
+    {Ω : Type*} [MeasurableSpace Ω]
+    (B : ℝ≥0 → Ω → ℝ) (hm : ∀ t, Measurable (B t))
+    (hc : ∀ ω, Continuous (fun t => B t ω)) (τ : Ω → ℝ≥0)
+    (hτ : IsStoppingTime (Filtration.natural B (fun t => (hm t).stronglyMeasurable))
+      (fun ω => (τ ω : WithTop ℝ≥0))) :
+    Measurable (sourceRestartDriverPath B hc τ) :=
+  source_path_measurable _ (fun t => (measurable_pi_apply t).comp
+    (brownianRestart_measurable hm hc (stopping_time_measurable_nnreal hτ)))
+
+theorem source_driver_continuation_condLExp
+    {Ω : Type*} [mΩ : MeasurableSpace Ω] {P : Measure Ω} [IsProbabilityMeasure P]
+    {B : ℝ≥0 → Ω → ℝ} (hB : IsBrownianReal B P)
+    (hm : ∀ t, Measurable (B t)) (hc : ∀ ω, Continuous (fun t => B t ω))
+    (t : ℝ≥0) (f : C(ℝ≥0,ℝ) → ℝ≥0∞) (hf : Measurable f) :
+    (fun ω => driverContinuationMean (P.map (sourceDriverPath B hc)) t f
+      (sourceDriverPath B hc ω)) =ᵐ[P]
+    P⁻[(fun ω => f (sourceDriverPath B hc ω)) |
+      (Filtration.natural B (fun s => (hm s).stronglyMeasurable)) t] := by
+  let ℱ := Filtration.natural B (fun s => (hm s).stronglyMeasurable)
+  have hσ := isStoppingTime_const ℱ t
+  have hp : Measurable (sourceDriverPath B hc) := source_path_measurable _ hm
+  let ν := P.map (sourceDriverPath B hc)
+  let : IsProbabilityMeasure ν := (Measure.isProbabilityMeasure_map_iff hp.aemeasurable).mpr inferInstance
+  have hZ : Measurable[hσ.measurableSpace]
+      (fun ω => driverPathStopped t (sourceDriverPath B hc ω)) :=
+    source_stoppedDriverPath_measurable B hm hc (fun _ => t) hσ
+  have htest : Measurable[hσ.measurableSpace.prod (borel C(ℝ≥0,ℝ))]
+      (fun x : Ω × C(ℝ≥0,ℝ) =>
+        f (concatenateDriverPath t (driverPathStopped t (sourceDriverPath B hc x.1)) x.2)) :=
+    hf.comp (measurable_concatenateDriverPath.comp
+      (measurable_const.prodMk ((hZ.comp measurable_fst).prodMk measurable_snd)))
+  have h := restart_condLExp_random_test P ν hσ.measurableSpace hσ.measurableSpace_le
+    (sourceRestartDriverPath B hc (fun _ => t))
+    (sourceRestartDriverPath_measurable B hm hc _ hσ)
+    (fun A hA => source_restart_continuous_driver_law hB hm hc _ hσ hA) _ htest
+  have he (ω : Ω) : concatenateDriverPath t
+      (driverPathStopped t (sourceDriverPath B hc ω))
+      (sourceRestartDriverPath B hc (fun _ => t) ω)=sourceDriverPath B hc ω :=
+    concatenate_stopped_restart _ _
+  simpa only [driverContinuationMean,he,IsStoppingTime.measurableSpace_const] using h
+
+/-- Deterministic-time conditional identities identify the continuation
+section on the canonical driver law. -/
+theorem driverContinuationMean_eq_of_past_integrals
+    {Ω : Type*} [mΩ : MeasurableSpace Ω] {P : Measure Ω} [IsProbabilityMeasure P]
+    {B : ℝ≥0 → Ω → ℝ} (hB : IsBrownianReal B P)
+    (hm : ∀ t, Measurable (B t)) (hc : ∀ ω, Continuous (fun t => B t ω))
+    (t : ℝ≥0) (f K : C(ℝ≥0,ℝ) → ℝ≥0∞) (hf : Measurable f)
+    (hK : Measurable[driverPathFiltration t] K)
+    (hmean : ∀ A : Set Ω,
+      MeasurableSet[(Filtration.natural B (fun s => (hm s).stronglyMeasurable)) t] A →
+      (∫⁻ ω in A, f (sourceDriverPath B hc ω) ∂P)=
+        ∫⁻ ω in A, K (sourceDriverPath B hc ω) ∂P) :
+    driverContinuationMean (P.map (sourceDriverPath B hc)) t f =ᵐ[P.map (sourceDriverPath B hc)] K := by
+  let ℱ := Filtration.natural B (fun s => (hm s).stronglyMeasurable)
+  have hp : Measurable (sourceDriverPath B hc) := source_path_measurable _ hm
+  let : IsProbabilityMeasure (P.map (sourceDriverPath B hc)) :=
+    (Measure.isProbabilityMeasure_map_iff hp.aemeasurable).mpr inferInstance
+  have hBP : Measurable[ℱ t,driverPathFiltration t] (sourceDriverPath B hc) :=
+    driverPath_measurable_past_of_adapted ℱ _
+      (fun s => (Filtration.stronglyAdapted_natural (fun s => (hm s).stronglyMeasurable) s).measurable) t
+  have hk := ae_eq_condLExp (ℱ.le t) P (fun ω => f (sourceDriverPath B hc ω))
+    (hK.comp hBP) (fun A hA => (hmean A hA).symm)
+  have he := (source_driver_continuation_condLExp hB hm hc t f hf).trans hk.symm
+  exact (ae_map_iff hp.aemeasurable (measurableSet_eq_fun
+    ((driverContinuationMean_measurable _ t f hf).mono (driverPathFiltration.le t) le_rfl)
+    (hK.mono (driverPathFiltration.le t) le_rfl))).mpr he
+
+/-- The conditioning sigma algebra is the full original past at τ+t. -/
+theorem source_restart_continuation_condLExp
+    {Ω : Type*} [mΩ : MeasurableSpace Ω] {P : Measure Ω} [IsProbabilityMeasure P]
+    {B : ℝ≥0 → Ω → ℝ} (hB : IsBrownianReal B P)
+    (hm : ∀ t, Measurable (B t)) (hc : ∀ ω, Continuous (fun t => B t ω))
+    (τ : Ω → ℝ≥0)
+    (hτ : IsStoppingTime (Filtration.natural B (fun s => (hm s).stronglyMeasurable))
+      (fun ω => (τ ω : WithTop ℝ≥0)))
+    (t : ℝ≥0) (f : C(ℝ≥0,ℝ) → ℝ≥0∞) (hf : Measurable f) :
+    (fun ω => driverContinuationMean (P.map (sourceDriverPath B hc)) t f
+      (sourceRestartDriverPath B hc τ ω)) =ᵐ[P]
+    P⁻[(fun ω => f (sourceRestartDriverPath B hc τ ω)) | shiftedStoppingFiltration hτ t] := by
+  let σ := fun ω => τ ω+t
+  have hσ := stopping_time_add_nnreal hτ t
+  have hp : Measurable (sourceDriverPath B hc) := source_path_measurable _ hm
+  let ν := P.map (sourceDriverPath B hc)
+  let : IsProbabilityMeasure ν := (Measure.isProbabilityMeasure_map_iff hp.aemeasurable).mpr inferInstance
+  have hY := driverPath_measurable_past_of_adapted (shiftedStoppingFiltration hτ)
+    (sourceRestartDriverPath B hc τ) (sourceRestartDriverPath_shifted_adapted B hm hc τ hτ) t
+  have hZ : Measurable[hσ.measurableSpace]
+      (fun ω => driverPathStopped t (sourceRestartDriverPath B hc τ ω)) :=
+    (driverPathStopped_measurable_past t).comp hY
+  have htest : Measurable[hσ.measurableSpace.prod (borel C(ℝ≥0,ℝ))]
+      (fun x : Ω × C(ℝ≥0,ℝ) =>
+        f (concatenateDriverPath t (driverPathStopped t (sourceRestartDriverPath B hc τ x.1)) x.2)) :=
+    hf.comp (measurable_concatenateDriverPath.comp
+      (measurable_const.prodMk ((hZ.comp measurable_fst).prodMk measurable_snd)))
+  have h := restart_condLExp_random_test P ν hσ.measurableSpace hσ.measurableSpace_le
+    (sourceRestartDriverPath B hc σ) (sourceRestartDriverPath_measurable B hm hc σ hσ)
+    (fun A hA => source_restart_continuous_driver_law hB hm hc σ hσ hA) _ htest
+  have he (ω : Ω) : concatenateDriverPath t
+      (driverPathStopped t (sourceRestartDriverPath B hc τ ω))
+      (sourceRestartDriverPath B hc σ ω)=sourceRestartDriverPath B hc τ ω :=
+    (sourceRestartDriverPath_split B hc τ t ω).symm
+  simpa only [driverContinuationMean,he,shiftedStoppingFiltration,σ,ν] using h
+
+/-- A canonical section identity therefore holds in the larger shifted
+filtration, not merely in the natural filtration of the fresh driver. -/
+theorem source_restart_condLExp_of_section_ae
+    {Ω : Type*} [mΩ : MeasurableSpace Ω] {P : Measure Ω} [IsProbabilityMeasure P]
+    {B : ℝ≥0 → Ω → ℝ} (hB : IsBrownianReal B P)
+    (hm : ∀ t, Measurable (B t)) (hc : ∀ ω, Continuous (fun t => B t ω))
+    (τ : Ω → ℝ≥0)
+    (hτ : IsStoppingTime (Filtration.natural B (fun s => (hm s).stronglyMeasurable))
+      (fun ω => (τ ω : WithTop ℝ≥0)))
+    (t : ℝ≥0) (f K : C(ℝ≥0,ℝ) → ℝ≥0∞) (hf : Measurable f) (hK : Measurable K)
+    (hsection : driverContinuationMean (P.map (sourceDriverPath B hc)) t f
+      =ᵐ[P.map (sourceDriverPath B hc)] K) :
+    (fun ω => K (sourceRestartDriverPath B hc τ ω)) =ᵐ[P]
+    P⁻[(fun ω => f (sourceRestartDriverPath B hc τ ω)) | shiftedStoppingFiltration hτ t] := by
+  have hp : Measurable (sourceDriverPath B hc) := source_path_measurable _ hm
+  let : IsProbabilityMeasure (P.map (sourceDriverPath B hc)) :=
+    (Measure.isProbabilityMeasure_map_iff hp.aemeasurable).mpr inferInstance
+  have hfull := sourceRestart_mem_full_driver_set hB hm hc τ hτ _
+    (measurableSet_eq_fun
+      ((driverContinuationMean_measurable _ t f hf).mono (driverPathFiltration.le t) le_rfl) hK) hsection
+  have he : (fun ω => driverContinuationMean (P.map (sourceDriverPath B hc)) t f
+      (sourceRestartDriverPath B hc τ ω)) =ᵐ[P]
+      (fun ω => K (sourceRestartDriverPath B hc τ ω)) := hfull
+  exact he.symm.trans (source_restart_continuation_condLExp hB hm hc τ hτ t f hf)
+
+
+theorem source_restart_integral_of_section_ae
+    {Ω : Type*} [mΩ : MeasurableSpace Ω] {P : Measure Ω} [IsProbabilityMeasure P]
+    {B : ℝ≥0 → Ω → ℝ} (hB : IsBrownianReal B P)
+    (hm : ∀ t, Measurable (B t)) (hc : ∀ ω, Continuous (fun t => B t ω))
+    (τ : Ω → ℝ≥0)
+    (hτ : IsStoppingTime (Filtration.natural B (fun s => (hm s).stronglyMeasurable))
+      (fun ω => (τ ω : WithTop ℝ≥0)))
+    (t : ℝ≥0) (f K : C(ℝ≥0,ℝ) → ℝ≥0∞) (hf : Measurable f) (hK : Measurable K)
+    (hsection : driverContinuationMean (P.map (sourceDriverPath B hc)) t f
+      =ᵐ[P.map (sourceDriverPath B hc)] K)
+    (E : Set Ω) (hE : MeasurableSet[shiftedStoppingFiltration hτ t] E) :
+    (∫⁻ ω in E, f (sourceRestartDriverPath B hc τ ω) ∂P)=
+      ∫⁻ ω in E, K (sourceRestartDriverPath B hc τ ω) ∂P := by
+  have he := source_restart_condLExp_of_section_ae hB hm hc τ hτ t f K hf hK hsection
+  calc
+    _ = ∫⁻ ω in E,
+        P⁻[(fun ω => f (sourceRestartDriverPath B hc τ ω)) | shiftedStoppingFiltration hτ t] ω ∂P :=
+      (setLIntegral_condLExp ((shiftedStoppingFiltration hτ).le t) P _ hE).symm
+    _ = _ := lintegral_congr_ae (ae_restrict_of_ae he.symm)
+
+
+theorem source_restart_integral_of_original_kernel
+    {Ω : Type*} [mΩ : MeasurableSpace Ω] {P : Measure Ω} [IsProbabilityMeasure P]
+    {B : ℝ≥0 → Ω → ℝ} (hB : IsBrownianReal B P)
+    (hm : ∀ t, Measurable (B t)) (hc : ∀ ω, Continuous (fun t => B t ω))
+    (t : ℝ≥0) (f K : C(ℝ≥0,ℝ) → ℝ≥0∞) (hf : Measurable f)
+    (hK : Measurable[driverPathFiltration t] K)
+    (hmean : ∀ A : Set Ω,
+      MeasurableSet[(Filtration.natural B (fun s => (hm s).stronglyMeasurable)) t] A →
+      (∫⁻ ω in A, f (sourceDriverPath B hc ω) ∂P)=
+        ∫⁻ ω in A, K (sourceDriverPath B hc ω) ∂P)
+    (τ : Ω → ℝ≥0)
+    (hτ : IsStoppingTime (Filtration.natural B (fun s => (hm s).stronglyMeasurable))
+      (fun ω => (τ ω : WithTop ℝ≥0)))
+    (E : Set Ω) (hE : MeasurableSet[shiftedStoppingFiltration hτ t] E) :
+    (∫⁻ ω in E, f (sourceRestartDriverPath B hc τ ω) ∂P)=
+      ∫⁻ ω in E, K (sourceRestartDriverPath B hc τ ω) ∂P :=
+  source_restart_integral_of_section_ae hB hm hc τ hτ t f K hf
+    (hK.mono (driverPathFiltration.le t) le_rfl)
+    (driverContinuationMean_eq_of_past_integrals hB hm hc t f K hf hK hmean) E hE
+
+
+/-- Measure-kernel form of the continuation identity. This applies to the
+sum of the finite-time raw mass and its current Green measure. -/
+theorem source_restart_bind_of_original_kernel
+    {Ω : Type*} [mΩ : MeasurableSpace Ω] {P : Measure Ω} [IsProbabilityMeasure P]
+    {B : ℝ≥0 → Ω → ℝ} (hB : IsBrownianReal B P)
+    (hm : ∀ t, Measurable (B t)) (hc : ∀ ω, Continuous (fun t => B t ω))
+    (t : ℝ≥0) (N K : C(ℝ≥0,ℝ) → Measure upperHalfPlane) (hN : Measurable N)
+    (hK : Measurable[driverPathFiltration t] K)
+    (hmean : ∀ A : Set Ω,
+      MeasurableSet[(Filtration.natural B (fun s => (hm s).stronglyMeasurable)) t] A →
+      (P.restrict A).bind (fun ω => N (sourceDriverPath B hc ω))=
+        (P.restrict A).bind (fun ω => K (sourceDriverPath B hc ω)))
+    (τ : Ω → ℝ≥0)
+    (hτ : IsStoppingTime (Filtration.natural B (fun s => (hm s).stronglyMeasurable))
+      (fun ω => (τ ω : WithTop ℝ≥0)))
+    (E : Set Ω) (hE : MeasurableSet[shiftedStoppingFiltration hτ t] E) :
+    (P.restrict E).bind (fun ω => N (sourceRestartDriverPath B hc τ ω))=
+      (P.restrict E).bind (fun ω => K (sourceRestartDriverPath B hc τ ω)) := by
+  have hp : Measurable (sourceDriverPath B hc) := source_path_measurable _ hm
+  have hY := sourceRestartDriverPath_measurable B hm hc τ hτ
+  have hKm := hK.mono (driverPathFiltration.le t) le_rfl
+  have hNY : Measurable (fun ω => N (sourceRestartDriverPath B hc τ ω)) := hN.comp hY
+  have hKY : Measurable (fun ω => K (sourceRestartDriverPath B hc τ ω)) := hKm.comp hY
+  have hNB : Measurable (fun ω => N (sourceDriverPath B hc ω)) := hN.comp hp
+  have hKB : Measurable (fun ω => K (sourceDriverPath B hc ω)) := hKm.comp hp
+  apply Measure.ext
+  intro S hS
+  rw [Measure.bind_apply hS hNY.aemeasurable,
+    Measure.bind_apply hS hKY.aemeasurable]
+  apply source_restart_integral_of_original_kernel hB hm hc t
+    (fun p => N p S) (fun p => K p S)
+    ((Measure.measurable_coe hS).comp hN) ((Measure.measurable_coe hS).comp hK) ?_ τ hτ E hE
+  intro A hA
+  have he := congrArg (fun μ : Measure upperHalfPlane => μ S) (hmean A hA)
+  simpa only [Measure.bind_apply hS hNB.aemeasurable,
+    Measure.bind_apply hS hKB.aemeasurable] using he
+
+end SLEExactGauge
+
+end
+
+end OAI
diff --git a/lean/OAI/Probability/SLE/Geometry/RestartDerivativeMeasurability.lean b/lean/OAI/Probability/SLE/Geometry/RestartDerivativeMeasurability.lean
new file mode 100644
index 0000000000000000000000000000000000000000..b74402bfb825203b9fb17821a806590cf23a14b5
--- /dev/null
+++ b/lean/OAI/Probability/SLE/Geometry/RestartDerivativeMeasurability.lean
@@ -0,0 +1,85 @@
+import OAI.Probability.SLE.ChartMeasurability
+import Mathlib.Analysis.Calculus.Deriv.Slope
+
+namespace OAI
+
+/-! The inverse-Loewner derivative is measurable in the original stopped
+past. Difference quotients stay inside the upper half-plane. -/
+
+noncomputable section
+open Set Filter MeasureTheory Classical
+open scoped NNReal ENNReal Topology
+
+namespace SLEExactGauge
+
+local instance : LocallyCompactSpace upperHalfPlane := isOpen_upperHalfPlane.locallyCompactSpace
+
+def halfPlaneRealShift (z : upperHalfPlane) (a : ℝ) : upperHalfPlane :=
+  ⟨(z:ℂ)+(a:ℂ),by simpa only [upperHalfPlane,mem_ofPred_eq,Complex.add_im,
+    Complex.ofReal_im,add_zero] using z.property⟩
+
+lemma halfPlaneRealShift_continuous (a : ℝ) : Continuous (fun z => halfPlaneRealShift z a) :=
+  (continuous_subtype_val.add continuous_const).subtype_mk _
+
+theorem measurable_halfPlane_derivative
+    {Ω : Type*} [MeasurableSpace Ω] (J : Ω → ℂ → ℂ)
+    (hJ : Measurable (fun p : Ω × upperHalfPlane => J p.1 p.2))
+    (hd : ∀ ω (z : upperHalfPlane), DifferentiableAt ℂ (J ω) z) :
+    Measurable (fun p : Ω × upperHalfPlane => deriv (J p.1) p.2) := by
+  let a : ℕ → ℝ := fun n => 1/((n:ℝ)+1)
+  let Q : ℕ → Ω × upperHalfPlane → ℂ := fun n p =>
+    (a n:ℂ)⁻¹*(J p.1 (halfPlaneRealShift p.2 (a n))-J p.1 p.2)
+  have hQ (n : ℕ) : Measurable (Q n) := by
+    exact measurable_const.mul ((hJ.comp (measurable_fst.prodMk
+      ((halfPlaneRealShift_continuous (a n)).measurable.comp measurable_snd))).sub hJ)
+  apply measurable_of_tendsto_metrizable hQ
+  apply tendsto_pi_nhds.mpr
+  intro p
+  have ha : Tendsto (fun n => (a n:ℂ)) atTop (𝓝[≠] 0) := by
+    apply tendsto_nhdsWithin_iff.mpr
+    constructor
+    · simpa only [a,Complex.ofReal_zero,Function.comp_def] using
+        Complex.continuous_ofReal.continuousAt.tendsto.comp
+          (tendsto_one_div_add_atTop_nhds_zero_nat (𝕜 := ℝ))
+    · exact Eventually.of_forall (fun n => by
+        simp only [mem_compl_iff,mem_singleton_iff,Complex.ofReal_eq_zero]
+        dsimp only [a]
+        positivity)
+  have hh := (hd p.1 p.2).hasDerivAt.tendsto_slope_zero.comp ha
+  simpa only [Q,halfPlaneRealShift,smul_eq_mul,Function.comp_def] using hh
+
+theorem source_stopped_inverse_derivative_measurable
+    {Ω : Type*} [mΩ : MeasurableSpace Ω] (B : ℝ≥0 → Ω → ℝ)
+    (hm : ∀ t, Measurable (B t)) (hc : ∀ ω, Continuous (fun t => B t ω))
+    (κ : ℝ) (γ : Ω → ℝ≥0 → ℂ) (G F : Ω → ℝ≥0 → ℂ → ℂ)
+    (hw : ∀ ω, IsCapacityTwoWitness (fun t => Real.sqrt κ*B t ω) (γ ω) (G ω) (F ω))
+    (τ : Ω → ℝ≥0)
+    (hτ : IsStoppingTime (Filtration.natural B (fun t => (hm t).stronglyMeasurable))
+      (fun ω => (τ ω:WithTop ℝ≥0))) :
+    Measurable[hτ.measurableSpace.prod inferInstance]
+      (fun p : Ω × upperHalfPlane =>
+        deriv (F p.1 (τ p.1)) ((p.2:ℂ)+(Real.sqrt κ*B (τ p.1) p.1:ℝ))) := by
+  let J : Ω → ℂ → ℂ := fun ω z => F ω (τ ω) (z+(Real.sqrt κ*B (τ ω) ω:ℝ))
+  have hmJ : Measurable[hτ.measurableSpace.prod inferInstance]
+      (fun p : Ω × upperHalfPlane => J p.1 p.2) :=
+    continuous_eval.measurable.comp
+      ((source_stopped_inversePath_measurable B hm hc κ γ G F hw τ hτ).comp
+        measurable_fst |>.prodMk measurable_snd)
+  have hd (ω : Ω) (z : upperHalfPlane) :
+      HasDerivAt (J ω) (deriv (F ω (τ ω)) ((z:ℂ)+(Real.sqrt κ*B (τ ω) ω:ℝ))) z := by
+    have hz : (z:ℂ)+(Real.sqrt κ*B (τ ω) ω:ℝ) ∈ upperHalfPlane := by
+      simpa only [upperHalfPlane,mem_ofPred_eq,Complex.add_im,Complex.ofReal_im,add_zero]
+        using z.property
+    simpa only [J,Function.comp_def,id_eq,mul_one] using
+      (((hw ω).2.2.2.2.1 (τ ω)).differentiableAt
+        (isOpen_upperHalfPlane.mem_nhds hz)).hasDerivAt.comp (z:ℂ)
+        ((hasDerivAt_id (z:ℂ)).add_const ((Real.sqrt κ*B (τ ω) ω:ℝ):ℂ))
+  have he (p : Ω × upperHalfPlane) := (hd p.1 p.2).deriv
+  simpa only [he] using @measurable_halfPlane_derivative Ω hτ.measurableSpace J hmJ
+    (fun ω z => (hd ω z).differentiableAt)
+
+end SLEExactGauge
+
+end
+
+end OAI
diff --git a/lean/OAI/Probability/SLE/Geometry/RestartFutureGreen.lean b/lean/OAI/Probability/SLE/Geometry/RestartFutureGreen.lean
new file mode 100644
index 0000000000000000000000000000000000000000..b2f1a1c494ec3e21385fb151acce525025348d23
--- /dev/null
+++ b/lean/OAI/Probability/SLE/Geometry/RestartFutureGreen.lean
@@ -0,0 +1,57 @@
+import OAI.Probability.SLE.Geometry.RestartHalfPlaneGreen
+
+namespace OAI
+
+/-! The same inverse-map change of variables holds for the Green
+remainder at every later time, including tests meeting the old trace. -/
+
+noncomputable section
+open Set Filter _root_.MeasureTheory _root_.OAI.MeasureTheory Classical
+open scoped NNReal ENNReal Topology
+
+namespace SLEExactGauge.Multipoint
+
+theorem restart_future_halfPlane_green_test
+    {U : ℝ≥0 → ℝ} {γ β : ℝ≥0 → ℂ} {G F G' F' : ℝ≥0 → ℂ → ℂ}
+    (hw : IsCapacityTwoWitness U γ G F) (hU : Continuous U) (T : ℝ≥0)
+    (hb : IsCapacityTwoWitness (fun t => U (T+t)-U T) β G' F')
+    {κ : ℝ} (hκ : 0 < κ) (t : ℝ≥0) (f : upperHalfPlane → ℝ≥0∞) :
+    (∫⁻ z : upperHalfPlane, ENNReal.ofReal (‖deriv (F T) ((z:ℂ)+(U T:ℂ))‖^dimension κ) *
+      f (halfPlaneInversePoint hw T z)
+        ∂(volume.withDensity (fun z => ENNReal.ofReal
+          (greenDensity κ (fun r => U (T+r)-U T) β G' t z))).comap Subtype.val) =
+      ∫⁻ x, f x ∂(volume.withDensity (fun x =>
+        ENNReal.ofReal (greenDensity κ U γ G (T+t) x))).comap Subtype.val := by
+  let e := extendHalfPlaneENN f
+  have hUp : Continuous (fun r => U (T+r)-U T) :=
+    (hU.comp (continuous_const.add continuous_id)).sub continuous_const
+  rw [halfPlane_realDensity_lintegral _ (currentGreen_measurable hb hUp hκ t),
+    halfPlane_realDensity_lintegral _ (currentGreen_measurable hw hU hκ (T+t))]
+  have he := hw.restart_green_integral hU T hb κ t e
+  have hs : Function.support (fun z => e z * ENNReal.ofReal
+      (greenDensity κ U γ G (T+t) z)) ⊆ survivingDomain γ (T+t) := by
+    intro z hz
+    by_contra hn
+    exact hz (by simp only [greenDensity,ite_eq_right hn,ENNReal.ofReal_zero,mul_zero])
+  have hsT := hs.trans (survivingDomain_antitone γ (le_add_right le_rfl))
+  rw [setLIntegral_eq_of_support_subset hsT] at he
+  rw [setLIntegral_eq_of_support_subset (hs.trans (fun _ hz => hz.1.1))]
+  rw [he]
+  apply setLIntegral_congr_fun isOpen_upperHalfPlane.measurableSet
+  intro z hz
+  dsimp only
+  rw [show extendHalfPlaneENN (fun w : upperHalfPlane =>
+      ENNReal.ofReal (‖deriv (F T) ((w:ℂ)+(U T:ℂ))‖^dimension κ) *
+        f (halfPlaneInversePoint hw T w)) z =
+      ENNReal.ofReal (‖deriv (F T) (z+(U T:ℂ))‖^dimension κ) *
+        e (F T (z+(U T:ℂ))) from by
+    rw [extendHalfPlaneENN,dite_eq_left hz]
+    change _ = _ * extendHalfPlaneENN f (halfPlaneInversePoint hw T ⟨z,hz⟩)
+    rw [extendHalfPlaneENN_apply]]
+  ac_rfl
+
+end SLEExactGauge.Multipoint
+
+end
+
+end OAI
diff --git a/lean/OAI/Probability/SLE/Geometry/RestartGreenCovariance.lean b/lean/OAI/Probability/SLE/Geometry/RestartGreenCovariance.lean
new file mode 100644
index 0000000000000000000000000000000000000000..f2a03c571167a38f0605484b377323394256164f
--- /dev/null
+++ b/lean/OAI/Probability/SLE/Geometry/RestartGreenCovariance.lean
@@ -0,0 +1,93 @@
+import OAI.Probability.SLE.Mass.RestartMassCoordinates
+
+namespace OAI
+
+/-! Exact survival and Green-density covariance under the actual restart
+map. The area Jacobian changes the Green exponent into the mass exponent. -/
+
+noncomputable section
+open Set Filter _root_.MeasureTheory _root_.OAI.MeasureTheory Classical
+open scoped NNReal ENNReal Topology
+
+namespace SLEExactGauge
+
+lemma IsCapacityTwoWitness.restart_surviving_iff
+    {U : ℝ≥0 → ℝ} {γ β : ℝ≥0 → ℂ} {G F G' F' : ℝ≥0 → ℂ → ℂ}
+    (hw : IsCapacityTwoWitness U γ G F) (T : ℝ≥0)
+    (hb : IsCapacityTwoWitness (fun t => U (T+t)-U T) β G' F')
+    (t : ℝ≥0) (z : ℂ) (hz : z ∈ upperHalfPlane) :
+    F T (z+(U T:ℂ)) ∈ survivingDomain γ (T+t) ↔ z ∈ survivingDomain β t := by
+  refine ⟨?_,fun h => (hw.restart_forward_composition T hb t z h).1⟩
+  intro hy
+  let y := F T (z+(U T:ℂ))
+  let v := G (T+t) y-(U T:ℂ)
+  have hv : v ∈ upperHalfPlane := by
+    simpa only [v,upperHalfPlane,mem_ofPred_eq,Complex.sub_im,Complex.ofReal_im,sub_zero]
+      using hw.2.2.2.2.2.1 (T+t) hy
+  have hfv := hb.2.2.2.2.2.2.1 t hv
+  have hi : F T (F' t v+(U T:ℂ)) = F T (z+(U T:ℂ)) := by
+    rw [← hw.restart_inverse_composition T hb t v hv]
+    change F (T+t) ((G (T+t) y-(U T:ℂ))+(U T:ℂ)) = y
+    rw [sub_add_cancel,hw.2.2.2.2.2.2.2.1 (T+t) y hy]
+  have hfH : F' t v+(U T:ℂ) ∈ upperHalfPlane := by
+    simpa only [upperHalfPlane,mem_ofPred_eq,Complex.add_im,Complex.ofReal_im,add_zero]
+      using hfv.1.1
+  have hzH : z+(U T:ℂ) ∈ upperHalfPlane := by
+    simpa only [upperHalfPlane,mem_ofPred_eq,Complex.add_im,Complex.ofReal_im,add_zero] using hz
+  have hh := congrArg (G T) hi
+  rw [hw.2.2.2.2.2.2.2.2.1 T _ hfH,hw.2.2.2.2.2.2.2.2.1 T _ hzH] at hh
+  have he : F' t v = z := add_right_cancel hh
+  rwa [he] at hfv
+
+lemma IsCapacityTwoWitness.restart_green_covariance_alive
+    {U : ℝ≥0 → ℝ} {γ β : ℝ≥0 → ℂ} {G F G' F' : ℝ≥0 → ℂ → ℂ}
+    (hw : IsCapacityTwoWitness U γ G F) (hU : Continuous U) (T : ℝ≥0)
+    (hb : IsCapacityTwoWitness (fun t => U (T+t)-U T) β G' F')
+    (κ : ℝ) (t : ℝ≥0) (z : ℂ) (hz : z ∈ survivingDomain β t) :
+    greenDensity κ U γ G (T+t) (F T (z+(U T:ℂ))) =
+      ‖deriv (F T) (z+(U T:ℂ))‖ ^ (-codimension κ) *
+        greenDensity κ (fun r => U (T+r)-U T) β G' t z := by
+  have hy := (hw.restart_forward_composition T hb t z hz).1
+  have hUp : Continuous (fun r => U (T+r)-U T) :=
+    (hU.comp (continuous_const.add continuous_id)).sub continuous_const
+  rw [greenDensity,ite_eq_left hy,greenDensity,ite_eq_left hz,
+    hw.restart_radius_composition hU T hb t z hz,hw.restart_centered_value T hb t z hz,
+    Real.mul_rpow (norm_nonneg _) (hb.fullRadius_positive hUp t z hz).le]
+  ring
+
+theorem IsCapacityTwoWitness.restart_green_area_covariance
+    {U : ℝ≥0 → ℝ} {γ β : ℝ≥0 → ℂ} {G F G' F' : ℝ≥0 → ℂ → ℂ}
+    (hw : IsCapacityTwoWitness U γ G F) (hU : Continuous U) (T : ℝ≥0)
+    (hb : IsCapacityTwoWitness (fun t => U (T+t)-U T) β G' F')
+    (κ : ℝ) (t : ℝ≥0) (z : ℂ) (hz : z ∈ upperHalfPlane) :
+    ‖deriv (F T) (z+(U T:ℂ))‖^2 *
+        greenDensity κ U γ G (T+t) (F T (z+(U T:ℂ))) =
+      ‖deriv (F T) (z+(U T:ℂ))‖^(dimension κ) *
+        greenDensity κ (fun r => U (T+r)-U T) β G' t z := by
+  by_cases halive : z ∈ survivingDomain β t
+  · have hy := (hw.restart_forward_composition T hb t z halive).1
+    have hUp : Continuous (fun r => U (T+r)-U T) :=
+      (hU.comp (continuous_const.add continuous_id)).sub continuous_const
+    have hr := hw.restart_radius_composition hU T hb t z halive
+    have hR := hw.fullRadius_positive hU (T+t) _ hy
+    have hR' := hb.fullRadius_positive hUp t z halive
+    have hd : 0 < ‖deriv (F T) (z+(U T:ℂ))‖ := by
+      rw [hr] at hR
+      nlinarith [norm_nonneg (deriv (F T) (z+(U T:ℂ)))]
+    have hp : ‖deriv (F T) (z+(U T:ℂ))‖^2 *
+        ‖deriv (F T) (z+(U T:ℂ))‖^(-codimension κ) =
+        ‖deriv (F T) (z+(U T:ℂ))‖^(dimension κ) := by
+      rw [← Real.rpow_natCast,← Real.rpow_add hd]
+      congr 1
+      simp only [codimension,Nat.cast_ofNat]
+      ring
+    rw [hw.restart_green_covariance_alive hU T hb κ t z halive,← mul_assoc,hp]
+  · have hy : F T (z+(U T:ℂ)) ∉ survivingDomain γ (T+t) :=
+      fun h => halive ((hw.restart_surviving_iff T hb t z hz).mp h)
+    simp only [greenDensity,ite_eq_right hy,ite_eq_right halive,mul_zero]
+
+end SLEExactGauge
+
+end
+
+end OAI
diff --git a/lean/OAI/Probability/SLE/Geometry/RestartGreenIntegral.lean b/lean/OAI/Probability/SLE/Geometry/RestartGreenIntegral.lean
new file mode 100644
index 0000000000000000000000000000000000000000..ef1e3c1fb7da944750abd2664614a0b3b1d5ab0e
--- /dev/null
+++ b/lean/OAI/Probability/SLE/Geometry/RestartGreenIntegral.lean
@@ -0,0 +1,72 @@
+import OAI.Probability.SLE.Geometry.RestartGreenCovariance
+import OAI.Probability.SLE.Gauge.ConformalSausageTransfer
+
+namespace OAI
+
+/-! Change of variables for the conditional Green potential at a restart.
+The identity accepts arbitrary nonnegative spatial tests. -/
+
+noncomputable section
+open Set Filter _root_.MeasureTheory _root_.OAI.MeasureTheory Classical
+open scoped NNReal ENNReal Topology
+
+namespace SLEExactGauge
+
+theorem IsCapacityTwoWitness.restart_green_integral
+    {U : ℝ≥0 → ℝ} {γ β : ℝ≥0 → ℂ} {G F G' F' : ℝ≥0 → ℂ → ℂ}
+    (hw : IsCapacityTwoWitness U γ G F) (hU : Continuous U) (T : ℝ≥0)
+    (hb : IsCapacityTwoWitness (fun t => U (T+t)-U T) β G' F')
+    (κ : ℝ) (t : ℝ≥0) (f : ℂ → ℝ≥0∞) :
+    (∫⁻ x in survivingDomain γ T, f x * ENNReal.ofReal (greenDensity κ U γ G (T+t) x)) =
+      ∫⁻ z in upperHalfPlane, f (F T (z+(U T:ℂ))) *
+        ENNReal.ofReal (‖deriv (F T) (z+(U T:ℂ))‖^(dimension κ)) *
+        ENNReal.ofReal (greenDensity κ (fun r => U (T+r)-U T) β G' t z) := by
+  let J : ℂ → ℂ := fun z => F T (z+(U T:ℂ))
+  have hshift (z : ℂ) (hz : z ∈ upperHalfPlane) : z+(U T:ℂ) ∈ upperHalfPlane := by
+    simpa only [upperHalfPlane,mem_ofPred_eq,Complex.add_im,Complex.ofReal_im,add_zero] using hz
+  have himage : J '' upperHalfPlane = survivingDomain γ T := by
+    ext y
+    constructor
+    · rintro ⟨z,hz,rfl⟩
+      exact hw.2.2.2.2.2.2.1 T (hshift z hz)
+    · intro hy
+      refine ⟨G T y-(U T:ℂ),?_,?_⟩
+      · simpa only [upperHalfPlane,mem_ofPred_eq,Complex.sub_im,Complex.ofReal_im,sub_zero]
+          using hw.2.2.2.2.2.1 T hy
+      · change F T ((G T y-(U T:ℂ))+(U T:ℂ)) = y
+        rw [sub_add_cancel,hw.2.2.2.2.2.2.2.1 T y hy]
+  have hinj : InjOn J upperHalfPlane := by
+    intro z hz v hv he
+    have h := congrArg (G T) he
+    change G T (F T (z+(U T:ℂ))) = G T (F T (v+(U T:ℂ))) at h
+    rw [hw.2.2.2.2.2.2.2.2.1 T _ (hshift z hz),
+      hw.2.2.2.2.2.2.2.2.1 T _ (hshift v hv)] at h
+    exact add_right_cancel h
+  have hd (z : ℂ) (hz : z ∈ upperHalfPlane) :
+      HasDerivAt J (deriv (F T) (z+(U T:ℂ))) z := by
+    have h := ((hw.2.2.2.2.1 T).differentiableAt
+      (isOpen_upperHalfPlane.mem_nhds (hshift z hz))).hasDerivAt.comp z
+      ((hasDerivAt_id z).add_const (U T:ℂ))
+    simpa only [Function.comp_def,id_eq,mul_one,J] using h
+  rw [← himage]
+  rw [lintegral_image_eq_lintegral_abs_det_fderiv_mul volume isOpen_upperHalfPlane.measurableSet
+    (fun z hz => ((hd z hz).hasFDerivAt.restrictScalars ℝ).hasFDerivWithinAt) hinj]
+  apply setLIntegral_congr_fun isOpen_upperHalfPlane.measurableSet
+  intro z hz
+  dsimp only
+  rw [complex_derivative_real_det,abs_of_nonneg (sq_nonneg _)]
+  have he := congrArg ENNReal.ofReal (hw.restart_green_area_covariance hU T hb κ t z hz)
+  rw [ENNReal.ofReal_mul (sq_nonneg _),
+    ENNReal.ofReal_mul (Real.rpow_nonneg (norm_nonneg _) _)] at he
+  change ENNReal.ofReal (‖deriv (F T) (z+(U T:ℂ))‖^2) *
+    (f (J z) * ENNReal.ofReal (greenDensity κ U γ G (T+t) (J z))) = _
+  calc
+    _ = f (J z) * (ENNReal.ofReal (‖deriv (F T) (z+(U T:ℂ))‖^2) *
+        ENNReal.ofReal (greenDensity κ U γ G (T+t) (J z))) := by ring
+    _ = _ := by rw [he]; ac_rfl
+
+end SLEExactGauge
+
+end
+
+end OAI
diff --git a/lean/OAI/Probability/SLE/Geometry/RestartGreenKernel.lean b/lean/OAI/Probability/SLE/Geometry/RestartGreenKernel.lean
new file mode 100644
index 0000000000000000000000000000000000000000..09bc6e942549eb326ce9f54646fc3336589871be
--- /dev/null
+++ b/lean/OAI/Probability/SLE/Geometry/RestartGreenKernel.lean
@@ -0,0 +1,119 @@
+import OAI.Probability.SLE.Geometry.RestartConformalRadius
+import OAI.Probability.SLE.Loewner.ActualRadiusStops
+
+namespace OAI
+
+/-! The finite centered density after a genuine restart. Only forward
+composition is needed: a live source radius level gives the physical level,
+and a source path that never reaches the level contributes zero density. -/
+
+noncomputable section
+open Set Filter
+open scoped Topology NNReal ENNReal
+
+namespace SLEExactGauge
+
+lemma IsCapacityTwoWitness.restart_initial_radius
+    {U : ℝ≥0 → ℝ} {γ β : ℝ≥0 → ℂ} {G F G' F' : ℝ≥0 → ℂ → ℂ}
+    (hw : IsCapacityTwoWitness U γ G F) (hU : Continuous U) (T : ℝ≥0)
+    (hb : IsCapacityTwoWitness (fun t => U (T + t) - U T) β G' F')
+    (z : ℂ) (hz : z ∈ upperHalfPlane) :
+    fullRadius G T (F T (z + (U T : ℂ))) =
+      ‖deriv (F T) (z + (U T : ℂ))‖ * (2 * z.im) := by
+  have hUp : Continuous (fun t => U (T + t) - U T) :=
+    (hU.comp (continuous_const.add continuous_id)).sub continuous_const
+  simpa only [add_zero, hb.fullRadius_initial hUp z (hb.live_initial hz)] using
+    hw.restart_radius_composition hU T hb 0 z (hb.live_initial hz)
+
+lemma IsCapacityTwoWitness.restart_inverse_derivative_norm_pos
+    {U : ℝ≥0 → ℝ} {γ β : ℝ≥0 → ℂ} {G F G' F' : ℝ≥0 → ℂ → ℂ}
+    (hw : IsCapacityTwoWitness U γ G F) (hU : Continuous U) (T : ℝ≥0)
+    (hb : IsCapacityTwoWitness (fun t => U (T + t) - U T) β G' F')
+    (z : ℂ) (hz : z ∈ upperHalfPlane) :
+    0 < ‖deriv (F T) (z + (U T : ℂ))‖ := by
+  have hzH : z + (U T : ℂ) ∈ upperHalfPlane := by
+    simpa only [upperHalfPlane, mem_ofPred_eq, Complex.add_im, Complex.ofReal_im, add_zero] using hz
+  have hp := hw.fullRadius_positive hU T _ (hw.2.2.2.2.2.2.1 T hzH)
+  rw [hw.restart_initial_radius hU T hb z hz] at hp
+  exact (mul_pos_iff.mp hp).resolve_right (by simp [not_lt.mpr (norm_nonneg _)]) |>.1
+
+lemma IsCapacityTwoWitness.restart_green_composition
+    {U : ℝ≥0 → ℝ} {γ β : ℝ≥0 → ℂ} {G F G' F' : ℝ≥0 → ℂ → ℂ}
+    (hw : IsCapacityTwoWitness U γ G F) (hU : Continuous U) (T : ℝ≥0)
+    (hb : IsCapacityTwoWitness (fun t => U (T + t) - U T) β G' F')
+    (κ : ℝ) (t : ℝ≥0) (z : ℂ) (hz : z ∈ survivingDomain β t) :
+    greenDensity κ U γ G (T + t) (F T (z + (U T : ℂ))) =
+      ‖deriv (F T) (z + (U T : ℂ))‖ ^ (-codimension κ) *
+        greenDensity κ (fun t => U (T + t) - U T) β G' t z := by
+  have hUp : Continuous (fun t => U (T + t) - U T) :=
+    (hU.comp (continuous_const.add continuous_id)).sub continuous_const
+  rw [greenDensity, ite_eq_left (hw.restart_forward_composition T hb t z hz).1,
+    hw.restart_radius_composition hU T hb t z hz,
+    hw.restart_centered_value T hb t z hz,
+    Real.mul_rpow (norm_nonneg _) (hb.fullRadius_positive hUp t z hz).le,
+    greenDensity, ite_eq_left hz, mul_assoc]
+
+lemma IsCapacityTwoWitness.restart_green_initial
+    {U : ℝ≥0 → ℝ} {γ β : ℝ≥0 → ℂ} {G F G' F' : ℝ≥0 → ℂ → ℂ}
+    (hw : IsCapacityTwoWitness U γ G F) (hU : Continuous U) (T : ℝ≥0)
+    (hb : IsCapacityTwoWitness (fun t => U (T + t) - U T) β G' F')
+    (κ : ℝ) (z : ℂ) (hz : z ∈ upperHalfPlane) :
+    greenDensity κ U γ G T (F T (z + (U T : ℂ))) =
+      ‖deriv (F T) (z + (U T : ℂ))‖ ^ (-codimension κ) * initialGreen κ z := by
+  have hUp : Continuous (fun t => U (T + t) - U T) :=
+    (hU.comp (continuous_const.add continuous_id)).sub continuous_const
+  simpa only [add_zero, hb.green_initial hUp (by simp) κ hz] using
+    hw.restart_green_composition hU T hb κ 0 z (hb.live_initial hz)
+
+lemma IsCapacityTwoWitness.restart_level_of_live_source
+    {U : ℝ≥0 → ℝ} {γ β : ℝ≥0 → ℂ} {G F G' F' : ℝ≥0 → ℂ → ℂ}
+    (hw : IsCapacityTwoWitness U γ G F) (hU : Continuous U) (T : ℝ≥0)
+    (hb : IsCapacityTwoWitness (fun t => U (T + t) - U T) β G' F')
+    (z : ℂ) (u v : ℝ)
+    (hbase : fullRadius G T (F T (z + (U T : ℂ))) =
+      (2 * (F T (z + (U T : ℂ))).im) * Real.exp (-u))
+    (t : ℝ≥0) (hz : z ∈ survivingDomain β t)
+    (hlevel : fullRadius G' t z = (2 * z.im) * Real.exp (-v)) :
+    fullRadius G (T + t) (F T (z + (U T : ℂ))) =
+      (2 * (F T (z + (U T : ℂ))).im) * Real.exp (-(u + v)) ∧
+    radiusLevelTime γ G (F T (z + (U T : ℂ))) (u + v) = (T + t : ℝ≥0) := by
+  have he : fullRadius G (T + t) (F T (z + (U T : ℂ))) =
+      (2 * (F T (z + (U T : ℂ))).im) * Real.exp (-(u + v)) := by
+    rw [hw.restart_radius_composition hU T hb t z hz, hlevel,
+      ← mul_assoc, ← hw.restart_initial_radius hU T hb z hz.1.1, hbase,
+      neg_add, Real.exp_add]
+    ring
+  exact ⟨he, radiusLevelTime_eq_of_live_level hU hw _ _ _
+    (hw.restart_forward_composition T hb t z hz).1 he⟩
+
+/-- Pointwise domination suffices for conditional lower bounds. On every
+source path which reaches its radius level, this is an equality. -/
+theorem IsCapacityTwoWitness.restart_stopped_green_lower
+    {U : ℝ≥0 → ℝ} {γ β : ℝ≥0 → ℂ} {G F G' F' : ℝ≥0 → ℂ → ℂ}
+    (hw : IsCapacityTwoWitness U γ G F) (hU : Continuous U) (T : ℝ≥0)
+    (hb : IsCapacityTwoWitness (fun t => U (T + t) - U T) β G' F')
+    (κ : ℝ) (z : ℂ) (hz : z ∈ upperHalfPlane) (u v : ℝ)
+    (hbase : fullRadius G T (F T (z + (U T : ℂ))) =
+      (2 * (F T (z + (U T : ℂ))).im) * Real.exp (-u)) :
+    greenDensity κ U γ G T (F T (z + (U T : ℂ))) *
+        (stoppedGreen κ (fun t => U (T + t) - U T) β G' z v / initialGreen κ z) ≤
+      stoppedGreen κ U γ G (F T (z + (U T : ℂ))) (u + v) := by
+  have hUp : Continuous (fun t => U (T + t) - U T) :=
+    (hU.comp (continuous_const.add continuous_id)).sub continuous_const
+  by_cases hfinite : radiusLevelTime β G' z v < ∞
+  · obtain ⟨t, ht, hR⟩ := exists_live_level_of_radiusLevelTime_lt_top β G' z v hfinite
+    have hphysical := hw.restart_level_of_live_source hU T hb z u v hbase t ht hR
+    rw [stoppedGreen_eq_of_live_level hUp hb κ z v t ht hR,
+      stoppedGreen_eq_of_live_level hU hw κ _ _ (T + t)
+        (hw.restart_forward_composition T hb t z ht).1 hphysical.1,
+      hw.restart_green_composition hU T hb κ t z ht,
+      hw.restart_green_initial hU T hb κ z hz]
+    exact le_of_eq (by field_simp [(initialGreen_pos κ z hz).ne'])
+  · simp only [stoppedGreen, ite_eq_right hfinite, zero_div, mul_zero]
+    exact stoppedGreen_nonneg hw κ _ _
+
+end SLEExactGauge
+
+end
+
+end OAI
diff --git a/lean/OAI/Probability/SLE/Geometry/RestartHalfPlaneGreen.lean b/lean/OAI/Probability/SLE/Geometry/RestartHalfPlaneGreen.lean
new file mode 100644
index 0000000000000000000000000000000000000000..1f23beaeaf10d05f468603ce8c2034ff310e6dfb
--- /dev/null
+++ b/lean/OAI/Probability/SLE/Geometry/RestartHalfPlaneGreen.lean
@@ -0,0 +1,89 @@
+import OAI.Probability.SLE.Geometry.RestartInitialGreenIntegral
+import OAI.Probability.SLE.StochasticIntegrals
+
+namespace OAI
+
+/-! Half-plane form of the inverse-map Green covariance, including tests
+that reach the old trace. The current Green density vanishes off survival. -/
+
+noncomputable section
+open Set Filter _root_.MeasureTheory _root_.OAI.MeasureTheory Classical
+open scoped NNReal ENNReal Topology
+
+namespace SLEExactGauge.Multipoint
+
+def extendHalfPlaneENN (f : upperHalfPlane → ℝ≥0∞) (z : ℂ) : ℝ≥0∞ :=
+  if hz : z ∈ upperHalfPlane then f ⟨z,hz⟩ else 0
+
+@[simp] lemma extendHalfPlaneENN_apply (f : upperHalfPlane → ℝ≥0∞) (z : upperHalfPlane) :
+    extendHalfPlaneENN f z=f z := dite_eq_left z.property
+
+def halfPlaneInversePoint
+    {U : ℝ≥0 → ℝ} {γ : ℝ≥0 → ℂ} {G F : ℝ≥0 → ℂ → ℂ}
+    (hw : IsCapacityTwoWitness U γ G F) (T : ℝ≥0) (z : upperHalfPlane) : upperHalfPlane :=
+  ⟨F T ((z:ℂ)+(U T:ℂ)),(hw.2.2.2.2.2.2.1 T (by
+    simpa only [upperHalfPlane,mem_ofPred_eq,Complex.add_im,Complex.ofReal_im,add_zero]
+      using z.property)).1.1⟩
+
+lemma currentGreen_measurable
+    {U : ℝ≥0 → ℝ} {γ : ℝ≥0 → ℂ} {G F : ℝ≥0 → ℂ → ℂ}
+    (hw : IsCapacityTwoWitness U γ G F) (hU : Continuous U)
+    {κ : ℝ} (hκ : 0 < κ) (T : ℝ≥0) : Measurable (greenDensity κ U γ G T) := by
+  have h : Measurable (fun p : ℝ≥0 × ℂ => greenDensity κ U γ G p.1 p.2) :=
+    hw.killed_green_measurable (κ := κ) hU hκ
+  have hp : Measurable (fun z : ℂ => (T,z)) := measurable_const.prodMk measurable_id
+  simpa only [Function.comp_def] using h.comp hp
+
+lemma halfPlane_realDensity_lintegral (ρ : ℂ → ℝ) (hρ : Measurable ρ)
+    (f : upperHalfPlane → ℝ≥0∞) :
+    (∫⁻ z, f z ∂(volume.withDensity (fun x => ENNReal.ofReal (ρ x))).comap Subtype.val) =
+      ∫⁻ z in upperHalfPlane, extendHalfPlaneENN f z * ENNReal.ofReal (ρ z) := by
+  calc
+    _ = ∫⁻ z : upperHalfPlane, extendHalfPlaneENN f z
+        ∂(volume.withDensity (fun x => ENNReal.ofReal (ρ x))).comap Subtype.val := by
+      apply lintegral_congr
+      intro z
+      exact (extendHalfPlaneENN_apply f z).symm
+    _ = ∫⁻ z in upperHalfPlane, extendHalfPlaneENN f z
+        ∂volume.withDensity (fun x => ENNReal.ofReal (ρ x)) :=
+      lintegral_subtype_comap isOpen_upperHalfPlane.measurableSet _
+    _ = _ := by
+      rw [setLIntegral_withDensity_eq_setLIntegral_mul_non_measurable volume hρ.ennreal_ofReal _
+        isOpen_upperHalfPlane.measurableSet (ae_of_all _ (fun _ => ENNReal.ofReal_lt_top))]
+      apply lintegral_congr
+      intro z
+      exact mul_comm _ _
+
+theorem restart_halfPlane_green_test
+    {U : ℝ≥0 → ℝ} {γ β : ℝ≥0 → ℂ} {G F G' F' : ℝ≥0 → ℂ → ℂ}
+    (hw : IsCapacityTwoWitness U γ G F) (hU : Continuous U) (T : ℝ≥0)
+    (hb : IsCapacityTwoWitness (fun t => U (T+t)-U T) β G' F')
+    {κ : ℝ} (hκ : 0 < κ) (f : upperHalfPlane → ℝ≥0∞) :
+    (∫⁻ z : upperHalfPlane, ENNReal.ofReal (‖deriv (F T) ((z:ℂ)+(U T:ℂ))‖^dimension κ) *
+      f (halfPlaneInversePoint hw T z)
+        ∂initialGreenMeasure κ) =
+      ∫⁻ x, f x ∂(volume.withDensity (fun x =>
+        ENNReal.ofReal (greenDensity κ U γ G T x))).comap Subtype.val := by
+  let e := extendHalfPlaneENN f
+  have he (z : upperHalfPlane) : f (halfPlaneInversePoint hw T z) =
+      e (F T ((z:ℂ)+(U T:ℂ))) := by
+    change f (halfPlaneInversePoint hw T z) = extendHalfPlaneENN f (halfPlaneInversePoint hw T z)
+    exact (extendHalfPlaneENN_apply f _).symm
+  simp_rw [he]
+  rw [restart_initialGreen_test hw hU T hb κ e]
+  have hρ : Measurable (greenDensity κ U γ G T) :=
+    currentGreen_measurable hw hU hκ T
+  rw [halfPlane_realDensity_lintegral _ hρ f]
+  have hs : Function.support (fun z => e z * ENNReal.ofReal (greenDensity κ U γ G T z)) ⊆
+      survivingDomain γ T := by
+    intro z hz
+    by_contra hn
+    exact hz (by simp only [greenDensity,ite_eq_right hn,ENNReal.ofReal_zero,mul_zero])
+  rw [setLIntegral_eq_of_support_subset hs,
+    setLIntegral_eq_of_support_subset (hs.trans (fun _ hz => hz.1.1))]
+
+end SLEExactGauge.Multipoint
+
+end
+
+end OAI
diff --git a/lean/OAI/Probability/SLE/Geometry/RestartInitialGreenIntegral.lean b/lean/OAI/Probability/SLE/Geometry/RestartInitialGreenIntegral.lean
new file mode 100644
index 0000000000000000000000000000000000000000..3f46d3af811e9894596e5d16a7516df97dbbcbde
--- /dev/null
+++ b/lean/OAI/Probability/SLE/Geometry/RestartInitialGreenIntegral.lean
@@ -0,0 +1,53 @@
+import OAI.Probability.SLE.Geometry.RestartGreenIntegral
+import OAI.Probability.SLE.Mass.LevelMeanMeasure
+
+namespace OAI
+
+/-! The image of the initial Green measure is the current Green potential.
+This is the exact terminal-mean identity for an inverse-Loewner restart. -/
+
+noncomputable section
+open Set Filter _root_.MeasureTheory _root_.OAI.MeasureTheory Classical
+open scoped NNReal ENNReal Topology
+
+namespace SLEExactGauge.Multipoint
+
+lemma initialGreenMeasure_lintegral (κ : ℝ) (f : ℂ → ℝ≥0∞) :
+    (∫⁻ z : upperHalfPlane, f z ∂initialGreenMeasure κ) =
+      ∫⁻ z in upperHalfPlane, f z * ENNReal.ofReal (initialGreen κ z) ∂volume := by
+  have hρ : Measurable (fun z => ENNReal.ofReal (initialGreen κ z)) := by
+    unfold initialGreen
+    fun_prop
+  rw [initialGreenMeasure,lintegral_subtype_comap isOpen_upperHalfPlane.measurableSet,
+    setLIntegral_withDensity_eq_setLIntegral_mul_non_measurable volume hρ f
+      isOpen_upperHalfPlane.measurableSet (ae_of_all _ (fun _ => ENNReal.ofReal_lt_top))]
+  apply lintegral_congr
+  intro z
+  exact mul_comm _ _
+
+theorem restart_initialGreen_test
+    {U : ℝ≥0 → ℝ} {γ β : ℝ≥0 → ℂ} {G F G' F' : ℝ≥0 → ℂ → ℂ}
+    (hw : IsCapacityTwoWitness U γ G F) (hU : Continuous U) (T : ℝ≥0)
+    (hb : IsCapacityTwoWitness (fun t => U (T+t)-U T) β G' F')
+    (κ : ℝ) (f : ℂ → ℝ≥0∞) :
+    (∫⁻ z : upperHalfPlane, ENNReal.ofReal (‖deriv (F T) ((z:ℂ)+(U T:ℂ))‖^dimension κ) *
+      f (F T ((z:ℂ)+(U T:ℂ))) ∂initialGreenMeasure κ) =
+      ∫⁻ x in survivingDomain γ T, f x * ENNReal.ofReal (greenDensity κ U γ G T x) := by
+  rw [initialGreenMeasure_lintegral κ (fun z : ℂ =>
+    ENNReal.ofReal (‖deriv (F T) (z+(U T:ℂ))‖^dimension κ) * f (F T (z+(U T:ℂ))))]
+  have he := hw.restart_green_integral hU T hb κ 0 f
+  simp only [add_zero] at he
+  rw [he]
+  apply setLIntegral_congr_fun isOpen_upperHalfPlane.measurableSet
+  intro z hz
+  dsimp only
+  have hUp : Continuous (fun t => U (T+t)-U T) :=
+    (hU.comp (continuous_const.add continuous_id)).sub continuous_const
+  rw [hb.green_initial hUp (by simp) κ hz]
+  ac_rfl
+
+end SLEExactGauge.Multipoint
+
+end
+
+end OAI
diff --git a/lean/OAI/Probability/SLE/Geometry/RestartSectionUpper.lean b/lean/OAI/Probability/SLE/Geometry/RestartSectionUpper.lean
new file mode 100644
index 0000000000000000000000000000000000000000..b8da8f2bda24e0cc9d455bb3a6e4187d3e40391d
--- /dev/null
+++ b/lean/OAI/Probability/SLE/Geometry/RestartSectionUpper.lean
@@ -0,0 +1,58 @@
+import OAI.Probability.SLE.Geometry.RestartWeightedKernel
+
+namespace OAI
+
+/-! Upper bounds from measurable random sections of the independent fresh
+driver law. The past state is allowed to vary without countable certificates. -/
+
+noncomputable section
+open Set Filter MeasureTheory
+open scoped ENNReal
+
+namespace SLEExactGauge
+
+theorem restart_event_section_upper_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 Ω) (hE : MeasurableSet[m] E) (T : Set Ω)
+    (r : Ω → ℝ≥0∞)
+    (hsections : ∀ ω ∈ E, ν {x | (ω, x) ∈ C} ≤ r ω)
+    (hactual : ∀ᵐ ω ∂P, ω ∈ E → ω ∈ T → (ω, Y ω) ∈ C)
+    (A : Set Ω) (hA : MeasurableSet[m] A) :
+    P (A ∩ E ∩ T) ≤ ∫⁻ ω in A ∩ E, r ω ∂P := by
+  let : MeasurableSpace Ω := mΩ
+  let H : Set Ω := {ω | (ω, Y ω) ∈ C}
+  have hH : MeasurableSet H := hC.preimage ((measurable_id'' hm).prodMk hY)
+  let K : Ω × X → ℝ≥0∞ := C.indicator (fun _ => 1)
+  have hK : @Measurable (Ω × X) ℝ≥0∞ (m.prod mX) _ K := measurable_const.indicator hC
+  have hsection (ω : Ω) : (∫⁻ x, K (ω, x) ∂ν) = ν {x | (ω, x) ∈ C} := by
+    have hCx : MeasurableSet {x | (ω, x) ∈ C} :=
+      hC.preimage (measurable_const.prodMk measurable_id)
+    exact lintegral_indicator_one hCx
+  calc
+    _ ≤ P (A ∩ E ∩ H) := by
+      apply measure_mono_ae
+      filter_upwards [hactual] with ω hω
+      exact fun hmem => ⟨hmem.1, hω hmem.1.2 hmem.2⟩
+    _ = ∫⁻ ω in A ∩ E, K (ω, Y ω) ∂P := by
+      rw [show (fun ω => K (ω, Y ω)) = H.indicator (fun _ => 1) from rfl,
+        setLIntegral_indicator hH, lintegral_one, Measure.restrict_apply_univ]
+      rw [inter_comm H]
+    _ = ∫⁻ ω in A ∩ E, ∫⁻ x, K (ω, x) ∂ν ∂P :=
+      restart_setLIntegral_random_test P ν m hm Y hY hlaw K hK (A ∩ E) (hA.inter hE)
+    _ ≤ _ := by
+      apply setLIntegral_mono' (hm (A ∩ E) (hA.inter hE))
+      intro ω hω
+      rw [hsection]
+      exact hsections ω hω.2
+
+end SLEExactGauge
+
+end
+
+end OAI
diff --git a/lean/OAI/Probability/SLE/Geometry/RestartWeightedKernel.lean b/lean/OAI/Probability/SLE/Geometry/RestartWeightedKernel.lean
new file mode 100644
index 0000000000000000000000000000000000000000..3fd21644993f4a328cb149eb7ea469586f7dad57
--- /dev/null
+++ b/lean/OAI/Probability/SLE/Geometry/RestartWeightedKernel.lean
@@ -0,0 +1,75 @@
+import OAI.Probability.SLE.Geometry.RandomRestartEvents
+
+namespace OAI
+
+/-! Integration of measurable marked-state density kernels against the
+actual independent restarted driver. This is used with the proved centered
+SLE section bounds and the deterministic restarted Green-density bound. -/
+
+noncomputable section
+open Set Filter MeasureTheory
+open scoped ENNReal
+
+namespace SLEExactGauge
+
+theorem restart_setLIntegral_random_test
+    {Ω X : Type*} [mΩ : MeasurableSpace Ω] [mX : MeasurableSpace X]
+    (P : Measure Ω) [IsFiniteMeasure P] (ν : Measure X) [IsFiniteMeasure ν]
+    (m : MeasurableSpace Ω) (hm : m ≤ mΩ)
+    (Y : Ω → X) (hY : Measurable[mΩ] Y)
+    (hlaw : ∀ A : Set Ω, MeasurableSet[m] A →
+      @Measure.map Ω X mΩ mX Y (P.restrict A) = P A • ν)
+    (f : Ω × X → ℝ≥0∞) (hf : @Measurable (Ω × X) ℝ≥0∞ (m.prod mX) _ f)
+    (A : Set Ω) (hA : MeasurableSet[m] A) :
+    (∫⁻ ω in A, f (ω, Y ω) ∂P) = ∫⁻ ω in A, ∫⁻ x, f (ω, x) ∂ν ∂P := by
+  let : MeasurableSpace Ω := mΩ
+  let fA : Ω × X → ℝ≥0∞ := (A ×ˢ (univ : Set X)).indicator f
+  have hfA : @Measurable (Ω × X) ℝ≥0∞ (m.prod mX) _ fA :=
+    hf.indicator (hA.prod MeasurableSet.univ)
+  have he := @restart_lintegral_random_test Ω X mΩ mX P inferInstance ν inferInstance
+    m hm Y hY hlaw fA hfA
+  have hleft : (fun ω => fA (ω, Y ω)) = A.indicator (fun ω => f (ω, Y ω)) := by
+    funext ω
+    by_cases hω : ω ∈ A <;> simp [fA, hω]
+  have hright : (fun ω => ∫⁻ x, fA (ω, x) ∂ν) =
+      A.indicator (fun ω => ∫⁻ x, f (ω, x) ∂ν) := by
+    funext ω
+    by_cases hω : ω ∈ A <;> simp [fA, hω]
+  rw [hleft, hright, lintegral_indicator (hm A hA), lintegral_indicator (hm A hA)] at he
+  exact he
+
+/-- A lower section bound gives a lower tilted probability on every event
+in the stopped past. The density domination is pointwise along the actual
+fresh driver and is supplied by Loewner restart composition. -/
+theorem restart_weighted_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 • ν)
+    (K : Ω × X → ℝ≥0∞) (hK : @Measurable (Ω × X) ℝ≥0∞ (m.prod mX) _ K)
+    (C : Set (Ω × X)) (hC : @MeasurableSet (Ω × X) (m.prod mX) C)
+    (V Z : Ω → ℝ≥0∞) (q : ℝ≥0∞) (hq : q ≠ ∞)
+    (E : Set Ω) (hE : MeasurableSet[mΩ] E)
+    (hsections : ∀ᵐ ω ∂P, q * V ω ≤ ∫⁻ x, C.indicator K (ω, x) ∂ν)
+    (hactual : ∀ᵐ ω ∂P, C.indicator K (ω, Y ω) ≤ E.indicator Z ω)
+    (A : Set Ω) (hA : MeasurableSet[m] A) :
+    q * (∫⁻ ω in A, V ω ∂P) ≤ P.withDensity Z (A ∩ E) := by
+  let : MeasurableSpace Ω := mΩ
+  calc
+    _ = ∫⁻ ω in A, q * V ω ∂P := (lintegral_const_mul' q V hq).symm
+    _ ≤ ∫⁻ ω in A, ∫⁻ x, C.indicator K (ω, x) ∂ν ∂P :=
+      lintegral_mono_ae (ae_restrict_of_ae hsections)
+    _ = ∫⁻ ω in A, C.indicator K (ω, Y ω) ∂P :=
+      (restart_setLIntegral_random_test P ν m hm Y hY hlaw (C.indicator K)
+        (hK.indicator hC) A hA).symm
+    _ ≤ ∫⁻ ω in A, E.indicator Z ω ∂P := lintegral_mono_ae (ae_restrict_of_ae hactual)
+    _ = P.withDensity Z (A ∩ E) := by
+      rw [setLIntegral_indicator hE, inter_comm, withDensity_apply _ ((hm A hA).inter hE)]
+
+end SLEExactGauge
+
+end
+
+end OAI
diff --git a/lean/OAI/Probability/SLE/Geometry/RightLimitMeasurability.lean b/lean/OAI/Probability/SLE/Geometry/RightLimitMeasurability.lean
new file mode 100644
index 0000000000000000000000000000000000000000..08a6686460126231aba0bd2f0fa9d56c77486f57
--- /dev/null
+++ b/lean/OAI/Probability/SLE/Geometry/RightLimitMeasurability.lean
@@ -0,0 +1,85 @@
+import Mathlib
+
+namespace OAI
+
+/-! A measurable right-limit criterion for a family continuous away from the
+endpoint. The interval suprema control all heights, not just a sequence. -/
+noncomputable section
+open Set Filter MeasureTheory Metric
+open scoped Topology ENNReal
+
+namespace SLEExactGauge
+
+def rightLimitError {Ω : Type*} (f : ℝ → Ω → ℂ) (g : Ω → ℂ)
+    (n : ℕ) (ω : Ω) : ℝ≥0∞ :=
+  ⨆ y : Ioo (0:ℝ) (1/((n:ℝ)+1)), edist (f y ω) (g ω)
+
+lemma measurable_rightLimitError {Ω : Type*} [MeasurableSpace Ω]
+    (f : ℝ → Ω → ℂ) (g : Ω → ℂ)
+    (hf : ∀ y, Measurable (f y)) (hg : Measurable g)
+    (hc : ∀ ω, ContinuousOn (fun y => f y ω) (Ioi 0)) (n : ℕ) :
+    Measurable (rightLimitError f g n) := by
+  suffices Measurable (⨆ y : Ioo (0:ℝ) (1/((n:ℝ)+1)),
+      fun ω => edist (f y ω) (g ω)) by
+    change Measurable (fun ω => ⨆ y : Ioo (0:ℝ) (1/((n:ℝ)+1)), edist (f y ω) (g ω))
+    convert this using 1
+    funext ω
+    exact (iSup_apply (f := fun y : Ioo (0:ℝ) (1/((n:ℝ)+1)) =>
+      fun ω => edist (f y ω) (g ω))).symm
+  apply measurable_iSup_of_lowerSemicontinuous
+  · intro y
+    exact (hf y).edist hg
+  · intro ω
+    have hcont : Continuous (fun y : Ioo (0:ℝ) (1/((n:ℝ)+1)) => f y ω) :=
+      (hc ω).comp_continuous continuous_subtype_val (fun y => y.property.1)
+    exact (hcont.edist continuous_const).lowerSemicontinuous
+
+lemma tendsto_right_iff_interval_errors {Ω : Type*}
+    (f : ℝ → Ω → ℂ) (g : Ω → ℂ) (ω : Ω) :
+    Tendsto (fun y => f y ω) (𝓝[>] 0) (𝓝 (g ω)) ↔
+      ∀ k : ℕ, ∃ n : ℕ, rightLimitError f g n ω ≤
+        ENNReal.ofReal (1/((k:ℝ)+1)) := by
+  constructor
+  · intro h k
+    have hk : 0 < (1:ℝ)/((k:ℝ)+1) := by positivity
+    obtain ⟨δ,hδ,hb⟩ := Metric.tendsto_nhdsWithin_nhds.mp h _ hk
+    obtain ⟨n,hn⟩ := ((tendsto_one_div_add_atTop_nhds_zero_nat (𝕜 := ℝ)).eventually
+      (gt_mem_nhds hδ)).exists
+    refine ⟨n,iSup_le fun y => ?_⟩
+    have hy : dist (y:ℝ) 0 < δ := by
+      rw [Real.dist_eq,sub_zero,abs_of_pos y.property.1]
+      exact y.property.2.trans hn
+    rw [edist_dist]
+    exact ENNReal.ofReal_le_ofReal (hb y.property.1 hy).le
+  · intro h
+    apply Metric.tendsto_nhdsWithin_nhds.mpr
+    intro ε hε
+    obtain ⟨k,hk⟩ := ((tendsto_one_div_add_atTop_nhds_zero_nat (𝕜 := ℝ)).eventually
+      (gt_mem_nhds hε)).exists
+    obtain ⟨n,hn⟩ := h k
+    refine ⟨1/((n:ℝ)+1),by positivity,?_⟩
+    intro y hy hyδ
+    have hy0 : 0 < y := hy
+    have hy' : y < 1/((n:ℝ)+1) := by
+      simpa only [Real.dist_eq,sub_zero,abs_of_pos hy0] using hyδ
+    have hb : edist (f y ω) (g ω) ≤ ENNReal.ofReal (1/((k:ℝ)+1)) :=
+      (le_iSup (fun z : Ioo (0:ℝ) (1/((n:ℝ)+1)) => edist (f z ω) (g ω))
+        ⟨y,hy,hy'⟩).trans hn
+    have hd : dist (f y ω) (g ω) ≤ 1/((k:ℝ)+1) := by
+      exact (ENNReal.ofReal_le_ofReal_iff (by positivity)).mp (by simpa only [edist_dist] using hb)
+    exact hd.trans_lt hk
+
+lemma measurableSet_tendsto_right {Ω : Type*} [MeasurableSpace Ω]
+    (f : ℝ → Ω → ℂ) (g : Ω → ℂ)
+    (hf : ∀ y, Measurable (f y)) (hg : Measurable g)
+    (hc : ∀ ω, ContinuousOn (fun y => f y ω) (Ioi 0)) :
+    MeasurableSet {ω | Tendsto (fun y => f y ω) (𝓝[>] 0) (𝓝 (g ω))} := by
+  simp_rw [tendsto_right_iff_interval_errors f g,Set.ofPred_forall,Set.ofPred_exists]
+  exact MeasurableSet.iInter fun k => MeasurableSet.iUnion fun n =>
+    measurableSet_le (measurable_rightLimitError f g hf hg hc n) measurable_const
+
+end SLEExactGauge
+
+end
+
+end OAI
diff --git a/lean/OAI/Probability/SLE/Geometry/RobustTransverseCrossing.lean b/lean/OAI/Probability/SLE/Geometry/RobustTransverseCrossing.lean
new file mode 100644
index 0000000000000000000000000000000000000000..6bb6445f4de906df9cfa8f8934dbdd8bb88b2c9f
--- /dev/null
+++ b/lean/OAI/Probability/SLE/Geometry/RobustTransverseCrossing.lean
@@ -0,0 +1,72 @@
+import OAI.Probability.SLE.Geometry.LongitudinalCrossing
+
+namespace OAI
+
+/-! Rectangle separation remains valid for a perturbed transverse route:
+its ends may lie beyond the narrow core, with no regularity of the past. -/
+
+noncomputable section
+open Set Metric
+open scoped Topology
+
+namespace SLEExactGauge.RectangleCrossing
+
+theorem transverse_crossing_beyond_edges_hits_past
+    (p q : ℝ → ℂ) {T a b c d : ℝ} (hT : 0 < T) (hab : a < b) (hcd : c < d)
+    (hp : ContinuousOn p (Icc 0 T)) (hq : ContinuousOn q (Icc 0 1))
+    (hp0 : (p 0).re < a) (hpT : b < (p T).re)
+    (hpim : ∀ t ∈ Icc (0 : ℝ) T, (p t).im ∈ Icc c d)
+    (hqr : ∀ t ∈ Icc (0 : ℝ) 1, (q t).re ∈ Icc a b)
+    (hq0 : (q 0).im < c) (hq1 : d < (q 1).im) :
+    ∃ s ∈ Icc (0 : ℝ) T, ∃ t ∈ Icc (0 : ℝ) 1, p s = q t := by
+  obtain ⟨u, v, hu, huv, hv, hqu, hqv, hrect⟩ := last_rear_before_first_front
+    (fun t => (q t).im) (by norm_num : (0 : ℝ) < 1) hcd
+    (Complex.continuous_im.comp_continuousOn hq) hq0 hq1
+  have hmap : MapsTo (intervalParam u v) (Icc (0 : ℝ) 1) (Icc 0 1) :=
+    fun t ht => (Icc_subset_Icc hu hv.le) (intervalParam_mem huv.le ht)
+  have hparam : Continuous (intervalParam u v) := by unfold intervalParam; fun_prop
+  obtain ⟨s, hs, t, ht, he⟩ := transverse_crossing_hits_past p
+    (fun t => q (intervalParam u v t)) hT hab hcd hp
+    (hq.comp hparam.continuousOn hmap) hp0 hpT hpim
+    (fun t ht => ⟨hqr _ (hmap ht), hrect _ (intervalParam_mem huv.le ht)⟩)
+    (by simpa [intervalParam] using hqu) (by simpa [intervalParam] using hqv)
+  exact ⟨s, hs, intervalParam u v t, hmap ht, he⟩
+
+def transverseTemplate (k t : ℝ) : ℂ :=
+  (((k - 1 / 2 : ℝ) : ℂ)) + (((t - 1 / 2 : ℝ) : ℂ)) * Complex.I
+
+/-- A fixed coordinate tube around the transverse segment forces a hit
+of any continuous past crossing the ribbon's narrow core. -/
+theorem near_transverse_template_hits_past
+    (p q : ℝ → ℂ) {T k ε δ : ℝ} (hT : 0 < T) (hk : 1 ≤ k)
+    (hε : 0 < ε) (hεsmall : ε ≤ 1 / 8) (hδ : δ ≤ 1 / 8)
+    (hp : ContinuousOn p (Icc 0 T)) (hq : ContinuousOn q (Icc 0 1))
+    (hp0 : (p 0).re = 0) (hpT : (p T).re = k)
+    (hpim : ∀ t ∈ Icc (0 : ℝ) T, |(p t).im| ≤ ε)
+    (hnear : ∀ t ∈ Icc (0 : ℝ) 1, dist (q t) (transverseTemplate k t) < δ) :
+    ∃ s ∈ Icc (0 : ℝ) T, ∃ t ∈ Icc (0 : ℝ) 1, p s = q t := by
+  have hre t (ht : t ∈ Icc (0 : ℝ) 1) : |(q t).re - (k - 1 / 2)| < δ := by
+    have hh := (Complex.abs_re_le_norm (q t - transverseTemplate k t)).trans_lt
+      (show ‖q t - transverseTemplate k t‖ < δ by simpa only [dist_eq_norm] using hnear t ht)
+    simpa [transverseTemplate] using hh
+  have him t (ht : t ∈ Icc (0 : ℝ) 1) : |(q t).im - (t - 1 / 2)| < δ := by
+    have hh := (Complex.abs_im_le_norm (q t - transverseTemplate k t)).trans_lt
+      (show ‖q t - transverseTemplate k t‖ < δ by simpa only [dist_eq_norm] using hnear t ht)
+    simpa [transverseTemplate] using hh
+  apply transverse_crossing_beyond_edges_hits_past p q hT
+    (by norm_num : k - 3 / 4 < k - 1 / 4) (by linarith : -ε < ε) hp hq
+    (by rw [hp0]; linarith) (by rw [hpT]; linarith)
+    (fun t ht => abs_le.mp (hpim t ht))
+  · intro t ht
+    have hh := abs_lt.mp (hre t ht)
+    constructor <;> linarith
+  · have hh := abs_lt.mp (him 0 (by norm_num))
+    linarith
+  · have hh := abs_lt.mp (him 1 (by norm_num))
+    linarith
+
+end SLEExactGauge.RectangleCrossing
+
+end
+
+end OAI
diff --git a/lean/OAI/Probability/SLE/Geometry/RootCoefficientBound.lean b/lean/OAI/Probability/SLE/Geometry/RootCoefficientBound.lean
new file mode 100644
index 0000000000000000000000000000000000000000..d823ea54eafc2cbf498ccc4c9b87e20b656fcff6
--- /dev/null
+++ b/lean/OAI/Probability/SLE/Geometry/RootCoefficientBound.lean
@@ -0,0 +1,46 @@
+import OAI.Probability.SLE.Geometry.ExteriorFirstCoefficient
+import OAI.Probability.SLE.Geometry.RootExteriorFlux
+
+namespace OAI
+
+/-! The area estimate controls the derivative of the normalized root
+factor appearing in the odd-root transform. -/
+noncomputable section
+open Set Filter Metric Function
+open scoped Topology
+
+namespace SLEExactGauge
+
+lemma root_factor_derivative_le_one {q : ℂ → ℂ}
+    (hq : DifferentiableOn ℂ q (ball 0 1)) (hq0 : q 0=1)
+    (hne : ∀ z∈ball (0:ℂ) 1, q z≠0)
+    (hi : InjOn (fun z : ℂ => z*q (z^2)) (ball 0 1)) :
+    ‖deriv q 0‖≤1 := by
+  obtain ⟨b,hb,hb0,he,_⟩ := root_exterior_laurent_data hq hq0 hne
+  let C (w : ℂ) := w*b (w^2)
+  have hs (w : ℂ) (hw : w∈ball (0:ℂ) 1) : w^2∈ball (0:ℂ) 1 := by
+    rw [mem_ball_zero_iff,norm_pow]
+    exact pow_lt_one₀ (norm_nonneg _) (mem_ball_zero_iff.mp hw) (by norm_num)
+  have hC : DifferentiableOn ℂ C (ball 0 1) :=
+    differentiableOn_id.mul (hb.comp (differentiable_id.pow 2).differentiableOn hs)
+  have hCd : deriv C 0=b 0 := by
+    have hbD : HasDerivAt b (deriv b 0) ((0:ℂ)^2) := by
+      simpa only [zero_pow (by norm_num : (2:ℕ)≠0)] using
+        (hb.differentiableAt (ball_mem_nhds (0:ℂ) zero_lt_one)).hasDerivAt
+    have hd := (hasDerivAt_id (0:ℂ)).mul
+      (hbD.comp (0:ℂ) (hasDerivAt_pow 2 (0:ℂ)))
+    change HasDerivAt C _ (0:ℂ) at hd
+    simpa only [Function.comp_apply,id_eq,zero_pow (by norm_num : (2:ℕ)≠0),mul_zero,zero_mul,
+      add_zero,one_mul] using hd.deriv
+  have hf := (root_exterior_univalent hq hne hi).1
+  have hval (z : ℂ) (hz : 1<‖z‖) : rootExteriorChart q z=z+C z⁻¹ :=
+    he z (norm_ne_zero_iff.mp (ne_of_gt (zero_lt_one.trans hz)))
+  have hh := exterior_first_coefficient_le_one hf hC hval
+    (fun r hr => root_exterior_flux_nonneg hq hne hi hr)
+  simpa only [hCd,hb0,norm_neg] using hh
+
+end SLEExactGauge
+
+end
+
+end OAI
diff --git a/lean/OAI/Probability/SLE/Geometry/RootExteriorChart.lean b/lean/OAI/Probability/SLE/Geometry/RootExteriorChart.lean
new file mode 100644
index 0000000000000000000000000000000000000000..3be40ddf709fb2205abd51f5e73f9680ec713a88
--- /dev/null
+++ b/lean/OAI/Probability/SLE/Geometry/RootExteriorChart.lean
@@ -0,0 +1,90 @@
+import OAI.Probability.SLE.Loewner.UnivalentOddRoot
+
+namespace OAI
+
+/-! The odd-root transform produces an actual exterior univalent map.
+Its first Laurent coefficient is the negative derivative of the root
+factor; the remainder is represented by a holomorphic disk function. -/
+noncomputable section
+open Set Filter Metric Function
+open scoped Topology
+
+namespace SLEExactGauge
+
+def rootExteriorChart (q : ℂ → ℂ) (z : ℂ) : ℂ := z/(q (z⁻¹^2))
+
+lemma root_exterior_laurent_data {q : ℂ → ℂ}
+    (hq : DifferentiableOn ℂ q (ball 0 1)) (hq0 : q 0=1)
+    (hne : ∀ z∈ball (0:ℂ) 1, q z≠0) :
+    ∃ b : ℂ → ℂ, DifferentiableOn ℂ b (ball 0 1) ∧ b 0= -deriv q 0 ∧
+      (∀ z : ℂ, z≠0 → rootExteriorChart q z=z+z⁻¹*b (z⁻¹^2)) ∧
+      Tendsto (fun z : ℂ => z*(rootExteriorChart q z-z)) (cocompact ℂ) (𝓝 (-deriv q 0)) := by
+  let b := dslope (fun z => (q z)⁻¹) 0
+  have hqi : DifferentiableOn ℂ (fun z => (q z)⁻¹) (ball 0 1) := hq.inv hne
+  have hb : DifferentiableOn ℂ b (ball 0 1) :=
+    (Complex.differentiableOn_dslope (ball_mem_nhds (0:ℂ) zero_lt_one)).mpr hqi
+  have hb0 : b 0= -deriv q 0 := by
+    dsimp only [b]
+    rw [dslope_same]
+    have hd := ((hq.differentiableAt (ball_mem_nhds (0:ℂ) zero_lt_one)).hasDerivAt).inv
+      (by rw [hq0]; exact one_ne_zero)
+    change HasDerivAt (fun z => (q z)⁻¹) _ 0 at hd
+    simpa [hq0] using hd.deriv
+  have he (z : ℂ) (hz : z≠0) : rootExteriorChart q z=z+z⁻¹*b (z⁻¹^2) := by
+    have hid := sub_smul_dslope (fun z => (q z)⁻¹) 0 (z⁻¹^2)
+    change (z⁻¹^2-0)*b (z⁻¹^2)=(q (z⁻¹^2))⁻¹-(q 0)⁻¹ at hid
+    rw [hq0,inv_one,sub_zero] at hid
+    dsimp only [rootExteriorChart]
+    have hqi : (q (z⁻¹^2))⁻¹=1+z⁻¹^2*b (z⁻¹^2) := by linear_combination -hid
+    rw [div_eq_mul_inv,hqi]
+    field_simp
+  refine ⟨b,hb,hb0,he,?_⟩
+  have hinv : Tendsto (fun z : ℂ => z⁻¹) (cocompact ℂ) (𝓝 0) := by
+    simpa only [Metric.cobounded_eq_cocompact] using (tendsto_inv₀_cobounded : Tendsto (fun z : ℂ => z⁻¹) (Bornology.cobounded ℂ) (𝓝 0))
+  have hpow : Tendsto (fun z : ℂ => z⁻¹^2) (cocompact ℂ) (𝓝 0) := by
+    simpa using hinv.pow 2
+  have hlim := (hb.differentiableAt (ball_mem_nhds (0:ℂ) zero_lt_one)).continuousAt.tendsto.comp hpow
+  rw [hb0] at hlim
+  apply hlim.congr'
+  filter_upwards [(isCompact_singleton (x := (0:ℂ))).compl_mem_cocompact] with z hz
+  have hz0 : z≠0 := hz
+  rw [he z hz0]
+  dsimp only [Function.comp_def]
+  field_simp
+  ring
+
+lemma root_exterior_univalent {q : ℂ → ℂ}
+    (hq : DifferentiableOn ℂ q (ball 0 1))
+    (hne : ∀ z∈ball (0:ℂ) 1, q z≠0)
+    (hi : InjOn (fun z : ℂ => z*q (z^2)) (ball 0 1)) :
+    DifferentiableOn ℂ (rootExteriorChart q) {z : ℂ | 1<‖z‖} ∧
+      InjOn (rootExteriorChart q) {z : ℂ | 1<‖z‖} := by
+  have hzinv (z : ℂ) (hz : 1<‖z‖) : ‖z⁻¹‖<1 := by
+    rw [norm_inv]
+    exact inv_lt_one_of_one_lt₀ hz
+  have hzsq (z : ℂ) (hz : 1<‖z‖) : z⁻¹^2∈ball (0:ℂ) 1 := by
+    rw [mem_ball_zero_iff,norm_pow]
+    exact pow_lt_one₀ (norm_nonneg _) (hzinv z hz) (by norm_num)
+  constructor
+  · intro z hz
+    have hz0 : z≠0 := norm_ne_zero_iff.mp (ne_of_gt (zero_lt_one.trans hz))
+    have harg := (hasDerivAt_inv hz0).differentiableAt.pow 2
+    have hcomp : DifferentiableAt ℂ (fun w : ℂ => q (w⁻¹^2)) z :=
+      ((hq.differentiableAt (isOpen_ball.mem_nhds (hzsq z hz))).comp z harg)
+    exact ((differentiableAt_id : DifferentiableAt ℂ (fun w : ℂ => w) z).div hcomp
+      (hne _ (hzsq z hz))).differentiableWithinAt
+  · intro z hz w hw he
+    have hz0 : z≠0 := norm_ne_zero_iff.mp (ne_of_gt (zero_lt_one.trans hz))
+    have hw0 : w≠0 := norm_ne_zero_iff.mp (ne_of_gt (zero_lt_one.trans hw))
+    have hzi : z⁻¹∈ball (0:ℂ) 1 := mem_ball_zero_iff.mpr (hzinv z hz)
+    have hwi : w⁻¹∈ball (0:ℂ) 1 := mem_ball_zero_iff.mpr (hzinv w hw)
+    have hrecip : z⁻¹*q (z⁻¹^2)=w⁻¹*q (w⁻¹^2) := by
+      have hh := congrArg Inv.inv he
+      simpa [rootExteriorChart,div_eq_mul_inv,mul_comm] using hh
+    exact inv_injective (hi hzi hwi hrecip)
+
+end SLEExactGauge
+
+end
+
+end OAI
diff --git a/lean/OAI/Probability/SLE/Geometry/RootExteriorCompact.lean b/lean/OAI/Probability/SLE/Geometry/RootExteriorCompact.lean
new file mode 100644
index 0000000000000000000000000000000000000000..e5a18c3efeb63911b4a9c0b30acb8b03dea0663b
--- /dev/null
+++ b/lean/OAI/Probability/SLE/Geometry/RootExteriorCompact.lean
@@ -0,0 +1,71 @@
+import OAI.Probability.SLE.Geometry.RootExteriorChart
+
+namespace OAI
+
+/-! The exterior map has compact omitted set. This supplies the compact
+region used in the area proof of the second-coefficient estimate. -/
+noncomputable section
+open Set Filter Metric Function
+open scoped Topology
+
+namespace SLEExactGauge
+
+lemma univalent_image_isOpen {D : Set ℂ} (hD : IsOpen D) {f : ℂ → ℂ}
+    (hf : DifferentiableOn ℂ f D) (hi : InjOn f D) : IsOpen (f '' D) := by
+  apply isOpen_iff_mem_nhds.mpr
+  rintro _ ⟨z,hz,rfl⟩
+  apply univalent_nhds_le_map hD hf hi hz
+  exact image_mem_map (hD.mem_nhds hz)
+
+lemma root_exterior_contains_far_points {q : ℂ → ℂ}
+    (hq : DifferentiableOn ℂ q (ball 0 1))
+    (hi : InjOn (fun z : ℂ => z*q (z^2)) (ball 0 1)) :
+    ∃ R : ℝ, 0<R ∧ ∀ w : ℂ, R<‖w‖ →
+      w∈rootExteriorChart q '' {z : ℂ | 1<‖z‖} := by
+  let H (z : ℂ) := z*q (z^2)
+  have hs (z : ℂ) (hz : z∈ball (0:ℂ) 1) : z^2∈ball (0:ℂ) 1 := by
+    rw [mem_ball_zero_iff,norm_pow]
+    exact pow_lt_one₀ (norm_nonneg _) (mem_ball_zero_iff.mp hz) (by norm_num)
+  have hH : DifferentiableOn ℂ H (ball 0 1) :=
+    differentiableOn_id.mul (hq.comp (differentiable_id.pow 2).differentiableOn hs)
+  have hH0 : H 0=0 := by simp [H]
+  have hnhds : H '' ball (0:ℂ) 1∈𝓝 0 := by
+    simpa only [hH0] using (univalent_image_isOpen isOpen_ball hH hi).mem_nhds
+      (mem_image_of_mem H (mem_ball_self zero_lt_one))
+  obtain ⟨ε,hε,hεH⟩ := Metric.mem_nhds_iff.mp hnhds
+  refine ⟨max 1 ε⁻¹,lt_of_lt_of_le zero_lt_one (le_max_left _ _),?_⟩
+  intro w hw
+  have hw0 : w≠0 := norm_ne_zero_iff.mp (ne_of_gt ((lt_of_lt_of_le zero_lt_one (le_max_left _ _)).trans hw))
+  have hwi : w⁻¹∈ball (0:ℂ) ε := by
+    rw [mem_ball_zero_iff,norm_inv]
+    exact (inv_lt_comm₀ (norm_pos_iff.mpr hw0) hε).mpr ((le_max_right _ _).trans_lt hw)
+  obtain ⟨z,hz,hzw⟩ := hεH hwi
+  have hz0 : z≠0 := by intro he; rw [he,hH0] at hzw; exact (inv_ne_zero hw0) hzw.symm
+  refine ⟨z⁻¹,?_,?_⟩
+  · change 1<‖z⁻¹‖
+    rw [norm_inv]
+    exact (one_lt_inv₀ (norm_pos_iff.mpr hz0)).mpr (mem_ball_zero_iff.mp hz)
+  · apply inv_injective
+    simpa [rootExteriorChart,H,div_eq_mul_inv,mul_comm] using hzw
+
+lemma root_exterior_omitted_isCompact {q : ℂ → ℂ}
+    (hq : DifferentiableOn ℂ q (ball 0 1))
+    (hne : ∀ z∈ball (0:ℂ) 1, q z≠0)
+    (hi : InjOn (fun z : ℂ => z*q (z^2)) (ball 0 1)) :
+    IsCompact (rootExteriorChart q '' {z : ℂ | 1<‖z‖})ᶜ := by
+  have hD : IsOpen {z : ℂ | 1<‖z‖} := isOpen_lt continuous_const continuous_norm
+  obtain ⟨hf,hfI⟩ := root_exterior_univalent hq hne hi
+  have hc : IsClosed (rootExteriorChart q '' {z : ℂ | 1<‖z‖})ᶜ :=
+    (univalent_image_isOpen hD hf hfI).isClosed_compl
+  obtain ⟨R,_,hR⟩ := root_exterior_contains_far_points hq hi
+  have hb : (rootExteriorChart q '' {z : ℂ | 1<‖z‖})ᶜ⊆closedBall (0:ℂ) R := by
+    intro z hz
+    rw [mem_closedBall,dist_zero_right]
+    exact le_of_not_gt (fun h => hz (hR z h))
+  exact (isCompact_closedBall (0:ℂ) R).of_isClosed_subset hc hb
+
+end SLEExactGauge
+
+end
+
+end OAI
diff --git a/lean/OAI/Probability/SLE/Geometry/RootExteriorFlux.lean b/lean/OAI/Probability/SLE/Geometry/RootExteriorFlux.lean
new file mode 100644
index 0000000000000000000000000000000000000000..dc75f3a4b93608262cb58ad93ee63fe3e8aa8f3d
--- /dev/null
+++ b/lean/OAI/Probability/SLE/Geometry/RootExteriorFlux.lean
@@ -0,0 +1,55 @@
+import OAI.Probability.SLE.Geometry.RootExteriorRadius
+import OAI.Probability.SLE.Geometry.ConformalLaplacianIntegral
+import OAI.Probability.SLE.Geometry.ExteriorCompactFlux
+
+namespace OAI
+
+/-! Positivity of the signed boundary area for the actual exterior root
+map. Compact omitted sets and the ordinary area change of variables
+supply the sign, without a boundary regularity assumption at radius one. -/
+noncomputable section
+open Set Filter Metric Function Complex MeasureTheory InnerProductSpace
+open scoped Topology Laplacian
+
+namespace SLEExactGauge
+
+lemma root_exterior_flux_nonneg {q : ℂ → ℂ}
+    (hq : DifferentiableOn ℂ q (ball 0 1))
+    (hne : ∀ z∈ball (0:ℂ) 1, q z≠0)
+    (hi : InjOn (fun z : ℂ => z*q (z^2)) (ball 0 1))
+    {r : ℝ} (hr : 1<r) :
+    0≤∫ θ in -Real.pi..Real.pi,
+      radialLaplacianFlux (fun z => ‖rootExteriorChart q z‖^2) (r,θ) := by
+  let F := rootExteriorChart q
+  let D := {z : ℂ | r<‖z‖}
+  have hD : IsOpen D := isOpen_lt continuous_const continuous_norm
+  have hDsub : D⊆{z : ℂ | 1<‖z‖} := fun z hz => hr.trans hz
+  obtain ⟨hF,hFi⟩ := root_exterior_univalent hq hne hi
+  have hK : IsCompact (F '' D)ᶜ := root_exterior_omitted_radius_isCompact hq hne hi hr
+  obtain ⟨u,hu,hs,he,_,hint⟩ := exterior_compact_test_laplacian_nonpos hD
+    (hF.mono hDsub) (hFi.mono hDsub) hK
+  have hFc (z : ℂ) (hz : r≤‖z‖) : AnalyticAt ℂ F z :=
+    hF.analyticAt ((isOpen_lt continuous_const continuous_norm).mem_nhds (hr.trans_le hz))
+  have hv (z : ℂ) (hz : r≤‖z‖) : ContDiffAt ℝ 2 (u ∘ F) z :=
+    hu.contDiffAt.comp z ((hFc z hz).contDiffAt.restrict_scalars ℝ)
+  have hvs : HasCompactSupport (u ∘ F) := by
+    rw [hasCompactSupport_iff_eventuallyEq,Filter.coclosedCompact_eq_cocompact] at hs ⊢
+    exact (root_exterior_tendsto_cocompact hq hne).eventually hs
+  have hpos := exterior_compact_flux_nonneg (zero_lt_one.trans hr) hv hvs hint
+  convert! hpos using 1
+  apply intervalIntegral.integral_congr
+  intro θ _
+  have hn : ‖polarPoint r θ‖=r := by
+    rw [polarPoint_norm,abs_of_pos (zero_lt_one.trans hr)]
+  have hz : F (polarPoint r θ)∈(F '' D)ᶜ :=
+    root_exterior_circle_omitted hq hne hi hr hn
+  have hlocal : (u ∘ F) =ᶠ[𝓝 (polarPoint r θ)] (fun z => ‖F z‖^2) :=
+    (he _ hz).comp_tendsto (hFc _ hn.ge).continuousAt
+  simp only [radialLaplacianFlux,hlocal.fderiv_eq]
+  rfl
+
+end SLEExactGauge
+
+end
+
+end OAI
diff --git a/lean/OAI/Probability/SLE/Geometry/RootExteriorRadius.lean b/lean/OAI/Probability/SLE/Geometry/RootExteriorRadius.lean
new file mode 100644
index 0000000000000000000000000000000000000000..0404f3f43fad4e09a0f0dc636753bb7b7fe19017
--- /dev/null
+++ b/lean/OAI/Probability/SLE/Geometry/RootExteriorRadius.lean
@@ -0,0 +1,105 @@
+import OAI.Probability.SLE.Geometry.RootExteriorCompact
+
+namespace OAI
+
+/-! Compact omitted sets for every circle strictly outside the unit disk. -/
+noncomputable section
+open Set Filter Metric Function
+open scoped Topology
+
+namespace SLEExactGauge
+
+lemma root_exterior_contains_far_points_radius {q : ℂ → ℂ}
+    (hq : DifferentiableOn ℂ q (ball 0 1))
+    (hi : InjOn (fun z : ℂ => z*q (z^2)) (ball 0 1))
+    {r : ℝ} (hr : 1<r) :
+    ∃ R : ℝ, 0<R ∧ ∀ w : ℂ, R<‖w‖ →
+      w∈rootExteriorChart q '' {z : ℂ | r<‖z‖} := by
+  let H (z : ℂ) := z*q (z^2)
+  have hr0 : 0<r := zero_lt_one.trans hr
+  have hri : 0<r⁻¹ := inv_pos.mpr hr0
+  have hri1 : r⁻¹<1 := inv_lt_one_of_one_lt₀ hr
+  have hsub : ball (0:ℂ) r⁻¹ ⊆ ball 0 1 := ball_subset_ball hri1.le
+  have hs (z : ℂ) (hz : z∈ball (0:ℂ) r⁻¹) : z^2∈ball (0:ℂ) 1 := by
+    rw [mem_ball_zero_iff,norm_pow]
+    exact pow_lt_one₀ (norm_nonneg _) (mem_ball_zero_iff.mp (hsub hz)) (by norm_num)
+  have hH : DifferentiableOn ℂ H (ball 0 r⁻¹) :=
+    differentiableOn_id.mul (hq.comp (differentiable_id.pow 2).differentiableOn hs)
+  have hH0 : H 0=0 := by simp [H]
+  have hnhds : H '' ball (0:ℂ) r⁻¹∈𝓝 0 := by
+    simpa only [hH0] using (univalent_image_isOpen isOpen_ball hH (hi.mono hsub)).mem_nhds
+      (mem_image_of_mem H (mem_ball_self hri))
+  obtain ⟨ε,hε,hεH⟩ := Metric.mem_nhds_iff.mp hnhds
+  refine ⟨max 1 ε⁻¹,lt_of_lt_of_le zero_lt_one (le_max_left _ _),?_⟩
+  intro w hw
+  have hw0 : w≠0 := norm_ne_zero_iff.mp (ne_of_gt ((lt_of_lt_of_le zero_lt_one (le_max_left _ _)).trans hw))
+  have hwi : w⁻¹∈ball (0:ℂ) ε := by
+    rw [mem_ball_zero_iff,norm_inv]
+    exact (inv_lt_comm₀ (norm_pos_iff.mpr hw0) hε).mpr ((le_max_right _ _).trans_lt hw)
+  obtain ⟨z,hz,hzw⟩ := hεH hwi
+  have hz0 : z≠0 := by intro he; rw [he,hH0] at hzw; exact (inv_ne_zero hw0) hzw.symm
+  refine ⟨z⁻¹,?_,?_⟩
+  · change r<‖z⁻¹‖
+    rw [norm_inv]
+    exact (lt_inv_comm₀ hr0 (norm_pos_iff.mpr hz0)).mpr (mem_ball_zero_iff.mp hz)
+  · apply inv_injective
+    simpa [rootExteriorChart,H,div_eq_mul_inv,mul_comm] using hzw
+
+lemma root_exterior_omitted_radius_isCompact {q : ℂ → ℂ}
+    (hq : DifferentiableOn ℂ q (ball 0 1))
+    (hne : ∀ z∈ball (0:ℂ) 1, q z≠0)
+    (hi : InjOn (fun z : ℂ => z*q (z^2)) (ball 0 1))
+    {r : ℝ} (hr : 1<r) :
+    IsCompact (rootExteriorChart q '' {z : ℂ | r<‖z‖})ᶜ := by
+  have hD : IsOpen {z : ℂ | r<‖z‖} := isOpen_lt continuous_const continuous_norm
+  have hsub : {z : ℂ | r<‖z‖} ⊆ {z : ℂ | 1<‖z‖} := fun z hz => hr.trans hz
+  obtain ⟨hf,hfI⟩ := root_exterior_univalent hq hne hi
+  have hc : IsClosed (rootExteriorChart q '' {z : ℂ | r<‖z‖})ᶜ :=
+    (univalent_image_isOpen hD (hf.mono hsub) (hfI.mono hsub)).isClosed_compl
+  obtain ⟨R,_,hR⟩ := root_exterior_contains_far_points_radius hq hi hr
+  have hb : (rootExteriorChart q '' {z : ℂ | r<‖z‖})ᶜ⊆closedBall (0:ℂ) R := by
+    intro z hz
+    rw [mem_closedBall,dist_zero_right]
+    exact le_of_not_gt (fun h => hz (hR z h))
+  exact (isCompact_closedBall (0:ℂ) R).of_isClosed_subset hc hb
+
+lemma root_exterior_circle_omitted {q : ℂ → ℂ}
+    (hq : DifferentiableOn ℂ q (ball 0 1))
+    (hne : ∀ z∈ball (0:ℂ) 1, q z≠0)
+    (hi : InjOn (fun z : ℂ => z*q (z^2)) (ball 0 1))
+    {r : ℝ} (hr : 1<r) {z : ℂ} (hz : ‖z‖=r) :
+    rootExteriorChart q z ∈ (rootExteriorChart q '' {w : ℂ | r<‖w‖})ᶜ := by
+  rintro ⟨w,hw,he⟩
+  have hzw := (root_exterior_univalent hq hne hi).2 (hr.trans hw)
+    (by change 1<‖z‖; rw [hz]; exact hr) he
+  subst w
+  exact lt_irrefl r (hz ▸ hw)
+
+lemma root_exterior_tendsto_cocompact {q : ℂ → ℂ}
+    (hq : DifferentiableOn ℂ q (ball 0 1))
+    (hne : ∀ z∈ball (0:ℂ) 1, q z≠0) :
+    Tendsto (rootExteriorChart q) (cocompact ℂ) (cocompact ℂ) := by
+  have hinv : Tendsto (fun z : ℂ => z⁻¹) (cocompact ℂ) (𝓝 0) := by
+    simpa only [Metric.cobounded_eq_cocompact] using
+      (tendsto_inv₀_cobounded : Tendsto (fun z : ℂ => z⁻¹) (Bornology.cobounded ℂ) (𝓝 0))
+  have hpow : Tendsto (fun z : ℂ => z⁻¹^2) (cocompact ℂ) (𝓝 0) := by simpa using hinv.pow 2
+  have hqcont := (hq.differentiableAt (ball_mem_nhds (0:ℂ) zero_lt_one)).continuousAt
+  have hlim : Tendsto (fun z : ℂ => (rootExteriorChart q z)⁻¹)
+      (cocompact ℂ) (𝓝 0) := by
+    have hh := hinv.mul (hqcont.tendsto.comp hpow)
+    simp only [rootExteriorChart,inv_div]
+    simpa only [div_eq_mul_inv,mul_comm,zero_mul,Function.comp_def] using hh
+  have hne' : ∀ᶠ z in cocompact ℂ, (rootExteriorChart q z)⁻¹≠0 := by
+    filter_upwards [(isCompact_singleton (x := (0:ℂ))).compl_mem_cocompact,
+      hpow (ball_mem_nhds (0:ℂ) zero_lt_one)] with z hz hqz
+    exact inv_ne_zero (div_ne_zero hz (hne _ hqz))
+  have ht : Tendsto (fun z : ℂ => (rootExteriorChart q z)⁻¹)
+      (cocompact ℂ) (𝓝[≠] 0) := tendsto_nhdsWithin_iff.mpr ⟨hlim,hne'⟩
+  have hh := tendsto_inv₀_nhdsNE_zero.comp ht
+  simpa only [Function.comp_def,inv_inv,Metric.cobounded_eq_cocompact] using hh
+
+end SLEExactGauge
+
+end
+
+end OAI
diff --git a/lean/OAI/Probability/SLE/Geometry/RoundedConnector.lean b/lean/OAI/Probability/SLE/Geometry/RoundedConnector.lean
new file mode 100644
index 0000000000000000000000000000000000000000..ff15d2c7043935e16145170118a10ef034be17f1
--- /dev/null
+++ b/lean/OAI/Probability/SLE/Geometry/RoundedConnector.lean
@@ -0,0 +1,135 @@
+import OAI.Probability.SLE.Gauge.SerpentineCurve
+
+namespace OAI
+
+/-! The two quarter-circles used by the low connector from the real
+boundary to the first serpentine column. The radius is measured in
+ribbon-width units, so a radius at least fifty gives the same derivative
+and tangent bounds as the array. -/
+
+noncomputable section
+open Set Metric
+open scoped NNReal
+
+namespace SLEExactGauge.Serpentine
+
+def quarterLength (r : ℝ) : ℝ := Real.pi * r / 2
+
+def quarterBend (r t : ℝ) : ℂ :=
+  ((r / 50 : ℝ) : ℂ) * circularPiece 0 0 (50 * t / r)
+
+def quarterTangent (r t : ℝ) : ℂ := circularTangent 0 (50 * t / r)
+
+def upperQuarter (r t : ℝ) : ℂ :=
+  ((r : ℂ) + (r : ℂ) * Complex.I) - quarterBend r (quarterLength r - t)
+
+def upperQuarterTangent (r t : ℝ) : ℂ := quarterTangent r (quarterLength r - t)
+
+lemma quarterBend_eq (r t : ℝ) :
+    quarterBend r t = ((r - r * Real.cos (t / r) : ℝ) : ℂ) +
+      ((r * Real.sin (t / r) : ℝ) : ℂ) * Complex.I := by
+  have hs : side 0 = 1 := by simp [side]
+  have he : 50 * t / r / 50 = t / r := by ring
+  simp only [quarterBend, circularPiece, Nat.cast_zero, mul_zero, zero_add,
+    hs, one_mul, he]
+  push_cast
+  ring
+
+lemma quarterTangent_eq (r t : ℝ) :
+    quarterTangent r t = (Real.sin (t / r) : ℂ) +
+      (Real.cos (t / r) : ℂ) * Complex.I := by
+  have hs : side 0 = 1 := by simp [side]
+  have he : 50 * t / r / 50 = t / r := by ring
+  simp only [quarterTangent, circularTangent, hs, one_mul, he]
+
+lemma quarterBend_hasDerivAt {r : ℝ} (hr : 0 < r) (t : ℝ) :
+    HasDerivAt (quarterBend r) (quarterTangent r t) t := by
+  have ht : HasDerivAt (fun u : ℝ => 50 * u / r) (50 / r) t := by
+    simpa using ((hasDerivAt_id t).const_mul 50).div_const r
+  have hh := (circularPiece_hasDerivAt 0 0 (50 * t / r)).scomp t ht
+  have hh' := hh.const_mul ((r / 50 : ℝ) : ℂ)
+  convert hh' using 1 <;> try rfl
+  change quarterTangent r t = ((r / 50 : ℝ) : ℂ) * ((50 / r : ℝ) • circularTangent 0 (50 * t / r))
+  rw [Complex.real_smul, ← mul_assoc]
+  have he : ((r / 50 : ℝ) : ℂ) * ((50 / r : ℝ) : ℂ) = 1 := by
+    push_cast
+    field_simp [hr.ne']
+  rw [he, one_mul]
+  rfl
+
+lemma quarterTangent_norm (r t : ℝ) : ‖quarterTangent r t‖ = 1 :=
+  circularTangent_norm 0 _
+
+lemma quarterTangent_lipschitz {r : ℝ} (hr : 50 ≤ r) :
+    LipschitzWith (1 / 50) (quarterTangent r) := by
+  have hr0 : 0 < r := by linarith
+  apply lipschitzWith_iff_dist_le_mul.mpr
+  intro t u
+  have hh := (circularTangent_lipschitz 0).dist_le_mul (50 * t / r) (50 * u / r)
+  have he : dist (50 * t / r) (50 * u / r) = (50 / r) * dist t u := by
+    have halg : 50 * t / r - 50 * u / r = (50 / r) * (t - u) := by ring
+    rw [Real.dist_eq, Real.dist_eq, halg,
+      abs_mul, abs_of_pos (div_pos (by norm_num) hr0)]
+  have hfac : (50 : ℝ) / r ≤ 1 := (div_le_one hr0).mpr hr
+  change dist (circularTangent 0 (50 * t / r)) (circularTangent 0 (50 * u / r)) ≤ _
+  rw [he] at hh
+  calc
+    _ ≤ (1 / 50 : ℝ) * ((50 / r) * dist t u) := hh
+    _ ≤ (1 / 50 : ℝ) * dist t u := by
+      gcongr
+      exact mul_le_of_le_one_left (dist_nonneg) hfac
+
+lemma quarterBend_zero (r : ℝ) : quarterBend r 0 = 0 := by
+  simp [quarterBend_eq]
+
+lemma quarterTangent_zero (r : ℝ) : quarterTangent r 0 = Complex.I := by
+  simp [quarterTangent_eq]
+
+lemma quarterBend_end {r : ℝ} (hr : 0 < r) :
+    quarterBend r (quarterLength r) = (r : ℂ) + (r : ℂ) * Complex.I := by
+  have he : quarterLength r / r = Real.pi / 2 := by unfold quarterLength; field_simp [hr.ne']
+  simp [quarterBend_eq, he]
+
+lemma quarterTangent_end {r : ℝ} (hr : 0 < r) :
+    quarterTangent r (quarterLength r) = 1 := by
+  have he : quarterLength r / r = Real.pi / 2 := by unfold quarterLength; field_simp [hr.ne']
+  simp [quarterTangent_eq, he]
+
+lemma upperQuarter_hasDerivAt {r : ℝ} (hr : 0 < r) (t : ℝ) :
+    HasDerivAt (upperQuarter r) (upperQuarterTangent r t) t := by
+  have ht : HasDerivAt (fun u : ℝ => quarterLength r - u) (-1) t :=
+    (hasDerivAt_id t).const_sub _
+  have hh := ((quarterBend_hasDerivAt hr (quarterLength r - t)).scomp t ht).const_sub
+    ((r : ℂ) + (r : ℂ) * Complex.I)
+  convert hh using 1 <;> first | rfl | simp only [neg_smul, one_smul, neg_neg]
+  rfl
+
+lemma upperQuarterTangent_norm (r t : ℝ) : ‖upperQuarterTangent r t‖ = 1 :=
+  quarterTangent_norm _ _
+
+lemma upperQuarterTangent_lipschitz {r : ℝ} (hr : 50 ≤ r) :
+    LipschitzWith (1 / 50) (upperQuarterTangent r) := by
+  apply lipschitzWith_iff_dist_le_mul.mpr
+  intro t u
+  simpa only [upperQuarterTangent, dist_sub_left] using
+    (quarterTangent_lipschitz hr).dist_le_mul (quarterLength r - t) (quarterLength r - u)
+
+lemma upperQuarter_zero {r : ℝ} (hr : 0 < r) : upperQuarter r 0 = 0 := by
+  simp [upperQuarter, quarterBend_end hr]
+
+lemma upperQuarter_end {r : ℝ} :
+    upperQuarter r (quarterLength r) = (r : ℂ) + (r : ℂ) * Complex.I := by
+  simp [upperQuarter, quarterBend_zero]
+
+lemma upperQuarterTangent_zero {r : ℝ} (hr : 0 < r) : upperQuarterTangent r 0 = 1 := by
+  simp [upperQuarterTangent, quarterTangent_end hr]
+
+lemma upperQuarterTangent_end (r : ℝ) :
+    upperQuarterTangent r (quarterLength r) = Complex.I := by
+  simp [upperQuarterTangent, quarterTangent_zero]
+
+end SLEExactGauge.Serpentine
+
+end
+
+end OAI
diff --git a/lean/OAI/Probability/SLE/Geometry/RoundedConnectorBands.lean b/lean/OAI/Probability/SLE/Geometry/RoundedConnectorBands.lean
new file mode 100644
index 0000000000000000000000000000000000000000..1dd250355d5b00fb98a6be3855b0b2bf7f989158
--- /dev/null
+++ b/lean/OAI/Probability/SLE/Geometry/RoundedConnectorBands.lean
@@ -0,0 +1,77 @@
+import OAI.Probability.SLE.Geometry.RoundedConnector
+
+namespace OAI
+
+/-! Embedded normal bands over the quarter-circles of the connector. -/
+
+noncomputable section
+open Set Metric
+
+namespace SLEExactGauge.Serpentine
+
+def quarterNormal (r t a : ℝ) : ℂ :=
+  quarterBend r t + (a : ℂ) * Complex.I * quarterTangent r t
+
+def upperQuarterNormal (r t a : ℝ) : ℂ :=
+  upperQuarter r t + (a : ℂ) * Complex.I * upperQuarterTangent r t
+
+lemma quarterNormal_eq (r t a : ℝ) :
+    quarterNormal r t a = ((r - (r + a) * Real.cos (t / r) : ℝ) : ℂ) +
+      (((r + a) * Real.sin (t / r) : ℝ) : ℂ) * Complex.I := by
+  rw [quarterNormal, quarterBend_eq, quarterTangent_eq]
+  apply Complex.ext <;> simp only [Complex.add_re, Complex.add_im, Complex.mul_re,
+    Complex.mul_im, Complex.ofReal_re, Complex.ofReal_im, Complex.I_re, Complex.I_im] <;> ring
+
+lemma quarter_angle_bound {r t : ℝ} (hr : 0 < r) (ht : t ∈ Icc (0 : ℝ) (quarterLength r)) :
+    t / r ∈ Icc (0 : ℝ) (Real.pi / 2) := by
+  constructor
+  · exact div_nonneg ht.1 hr.le
+  · apply (div_le_iff₀ hr).mpr
+    dsimp only [quarterLength] at ht
+    linarith [ht.2]
+
+lemma quarterNormal_bounds {r t a : ℝ} (hr : 1 < r)
+    (ht : t ∈ Icc (0 : ℝ) (quarterLength r)) (ha : |a| ≤ 1) :
+    -1 ≤ (quarterNormal r t a).re ∧ (quarterNormal r t a).re ≤ r ∧
+    0 ≤ (quarterNormal r t a).im ∧ (quarterNormal r t a).im ≤ r + 1 := by
+  have hr0 : 0 < r := by linarith
+  have hθ := quarter_angle_bound hr0 ht
+  have hsin : 0 ≤ Real.sin (t / r) := Real.sin_nonneg_of_mem_Icc
+    ⟨hθ.1, hθ.2.trans (by linarith [Real.pi_pos])⟩
+  have hcos : 0 ≤ Real.cos (t / r) := Real.cos_nonneg_of_mem_Icc
+    ⟨by linarith [Real.pi_pos, hθ.1], hθ.2⟩
+  have ha' := abs_le.mp ha
+  have hR : 0 < r + a := by linarith
+  simp only [quarterNormal_eq, 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, sub_zero, add_zero, mul_one, zero_add]
+  have hc0 := mul_nonneg hR.le hcos
+  have hc1 := mul_le_mul_of_nonneg_left (Real.cos_le_one (t / r)) hR.le
+  have hs0 := mul_nonneg hR.le hsin
+  have hs1 := mul_le_mul_of_nonneg_left (Real.sin_le_one (t / r)) hR.le
+  exact ⟨by linarith, by linarith, hs0, by linarith⟩
+
+lemma upperQuarterNormal_reverse (r t a : ℝ) :
+    upperQuarterNormal r t a = ((r : ℂ) + (r : ℂ) * Complex.I) -
+      quarterNormal r (quarterLength r - t) (-a) := by
+  simp only [upperQuarterNormal, upperQuarter, upperQuarterTangent, quarterNormal,
+    Complex.ofReal_neg]
+  ring
+
+lemma upperQuarterNormal_bounds {r t a : ℝ} (hr : 1 < r)
+    (ht : t ∈ Icc (0 : ℝ) (quarterLength r)) (ha : |a| ≤ 1) :
+    0 ≤ (upperQuarterNormal r t a).re ∧ (upperQuarterNormal r t a).re ≤ r + 1 ∧
+    -1 ≤ (upperQuarterNormal r t a).im ∧ (upperQuarterNormal r t a).im ≤ r := by
+  have ht' : quarterLength r - t ∈ Icc (0 : ℝ) (quarterLength r) := ⟨by linarith [ht.2], by linarith [ht.1]⟩
+  have ha' : |-a| ≤ 1 := by simpa only [abs_neg] using ha
+  obtain ⟨hre0, hre1, him0, him1⟩ := quarterNormal_bounds hr ht' ha'
+  simp only [upperQuarterNormal_reverse, Complex.sub_re, Complex.sub_im, 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, sub_zero, add_zero, mul_one, zero_add]
+  exact ⟨by linarith, by linarith, by linarith, by linarith⟩
+
+end SLEExactGauge.Serpentine
+
+end
+
+end OAI
diff --git a/lean/OAI/Probability/SLE/Geometry/RoundedConnectorCurve.lean b/lean/OAI/Probability/SLE/Geometry/RoundedConnectorCurve.lean
new file mode 100644
index 0000000000000000000000000000000000000000..e0783afaf03909a252fb64b42e40de782b3f76b7
--- /dev/null
+++ b/lean/OAI/Probability/SLE/Geometry/RoundedConnectorCurve.lean
@@ -0,0 +1,158 @@
+import OAI.Probability.SLE.Geometry.RoundedConnector
+
+namespace OAI
+
+/-! The actual arclength connector from zero to a distant vertical column:
+vertical, quarter-circle, horizontal, quarter-circle, then vertical. -/
+
+noncomputable section
+open Set Metric
+open scoped NNReal
+
+namespace SLEExactGauge.Serpentine
+
+lemma translate_curve_hasDerivAt (f df : ℝ → ℂ)
+    (hf : ∀ t, HasDerivAt f (df t) t) (v : ℂ) (a t : ℝ) :
+    HasDerivAt (fun u => v + f (u - a)) (df (t - a)) t := by
+  have hh : HasDerivAt (fun u => f (u - a)) (df (t - a)) t := by
+    convert (hf (t - a)).scomp t ((hasDerivAt_id t).sub_const a) using 1 <;>
+      first | rfl | simp only [one_smul]
+  exact hh.const_add v
+
+lemma linear_curve_hasDerivAt (v d : ℂ) (t : ℝ) :
+    HasDerivAt (fun u : ℝ => v + (u : ℂ) * d) d t := by
+  convert ((Complex.ofRealCLM.hasDerivAt (x := t)).mul_const d).const_add v using 1 <;>
+    first | rfl | simp only [Complex.ofRealCLM_apply, Complex.ofReal_one, one_mul]
+
+def connectorSecond (H r : ℝ) : ℝ := H + quarterLength r
+
+def connectorThird (H r X : ℝ) : ℝ := connectorSecond H r + X - 2 * r
+
+def connectorFourth (H r X : ℝ) : ℝ := connectorThird H r X + quarterLength r
+
+def connectorInitial (t : ℝ) : ℂ := (t : ℂ) * Complex.I
+
+def connectorFirstTurn (H r t : ℝ) : ℂ :=
+  (H : ℂ) * Complex.I + quarterBend r (t - H)
+
+def connectorHorizontal (H r t : ℝ) : ℂ :=
+  (r : ℂ) + ((H + r : ℝ) : ℂ) * Complex.I + ((t - connectorSecond H r : ℝ) : ℂ)
+
+def connectorLastTurn (H r X t : ℝ) : ℂ :=
+  ((X - r : ℝ) : ℂ) + ((H + r : ℝ) : ℂ) * Complex.I +
+    upperQuarter r (t - connectorThird H r X)
+
+def connectorTail (H r X t : ℝ) : ℂ :=
+  (X : ℂ) + ((H + 2 * r + (t - connectorFourth H r X) : ℝ) : ℂ) * Complex.I
+
+def lowConnector (H r X : ℝ) : ℝ → ℂ :=
+  curveJoin (connectorFourth H r X)
+    (curveJoin (connectorThird H r X)
+      (curveJoin (connectorSecond H r)
+        (curveJoin H connectorInitial (connectorFirstTurn H r))
+        (connectorHorizontal H r))
+      (connectorLastTurn H r X))
+    (connectorTail H r X)
+
+def lowConnectorTangent (H r X : ℝ) : ℝ → ℂ :=
+  curveJoin (connectorFourth H r X)
+    (curveJoin (connectorThird H r X)
+      (curveJoin (connectorSecond H r)
+        (curveJoin H (fun _ => Complex.I) (fun t => quarterTangent r (t - H)))
+        (fun _ => 1))
+      (fun t => upperQuarterTangent r (t - connectorThird H r X)))
+    (fun _ => Complex.I)
+
+lemma connector_cuts {H r X : ℝ} (hr : 0 < r) (hX : 2 * r < X) :
+    H < connectorSecond H r ∧ connectorSecond H r < connectorThird H r X ∧
+      connectorThird H r X < connectorFourth H r X := by
+  have hq : 0 < quarterLength r := by unfold quarterLength; positivity
+  dsimp [connectorSecond, connectorThird, connectorFourth]
+  constructor
+  · linarith
+  constructor <;> linarith
+
+lemma connector_position_matches {H r X : ℝ} (hr : 0 < r) :
+    connectorInitial H = connectorFirstTurn H r H ∧
+    connectorFirstTurn H r (connectorSecond H r) = connectorHorizontal H r (connectorSecond H r) ∧
+    connectorHorizontal H r (connectorThird H r X) = connectorLastTurn H r X (connectorThird H r X) ∧
+    connectorLastTurn H r X (connectorFourth H r X) = connectorTail H r X (connectorFourth H r X) := by
+  refine ⟨?_, ?_, ?_, ?_⟩
+  · simp [connectorInitial, connectorFirstTurn, quarterBend_zero]
+  · simp only [connectorFirstTurn, connectorSecond, add_sub_cancel_left, quarterBend_end hr,
+      connectorHorizontal, sub_self, Complex.ofReal_zero, add_zero]
+    push_cast
+    ring
+  · simp only [connectorHorizontal, connectorLastTurn, sub_self, upperQuarter_zero hr, add_zero]
+    dsimp only [connectorThird]
+    push_cast
+    ring
+  · have he : connectorFourth H r X - connectorThird H r X = quarterLength r := by
+      dsimp [connectorFourth]; ring
+    simp only [connectorLastTurn, connectorTail, he, upperQuarter_end, sub_self, add_zero]
+    push_cast
+    ring
+
+lemma lowConnector_hasDerivAt {H r X : ℝ} (hr : 0 < r) (hX : 2 * r < X) (t : ℝ) :
+    HasDerivAt (lowConnector H r X) (lowConnectorTangent H r X t) t := by
+  obtain ⟨hc1, hc2, hc3⟩ := connector_cuts (H := H) hr hX
+  obtain ⟨hp1, hp2, hp3, hp4⟩ := connector_position_matches (H := H) (X := X) hr
+  have hd0 (u : ℝ) : HasDerivAt connectorInitial Complex.I u := by
+    change HasDerivAt (fun t : ℝ => (t : ℂ) * Complex.I) Complex.I u
+    simpa only [zero_add] using linear_curve_hasDerivAt 0 Complex.I u
+  have hd1 (u : ℝ) : HasDerivAt (connectorFirstTurn H r) (quarterTangent r (u - H)) u :=
+    translate_curve_hasDerivAt _ _ (quarterBend_hasDerivAt hr) _ _ _
+  have hd2 (u : ℝ) : HasDerivAt (connectorHorizontal H r) 1 u := by
+    have hh := translate_curve_hasDerivAt (fun v : ℝ => (v : ℂ)) (fun _ => 1)
+      (fun v => by simpa only [zero_add, mul_one] using linear_curve_hasDerivAt 0 1 v)
+      ((r : ℂ) + ((H + r : ℝ) : ℂ) * Complex.I) (connectorSecond H r) u
+    exact hh
+  have hd3 (u : ℝ) : HasDerivAt (connectorLastTurn H r X)
+      (upperQuarterTangent r (u - connectorThird H r X)) u :=
+    translate_curve_hasDerivAt _ _ (upperQuarter_hasDerivAt hr) _ _ _
+  have hd4 (u : ℝ) : HasDerivAt (connectorTail H r X) Complex.I u := by
+    have hh := linear_curve_hasDerivAt
+      ((X : ℂ) + ((H + 2 * r - connectorFourth H r X : ℝ) : ℂ) * Complex.I) Complex.I u
+    convert hh using 1
+    funext v
+    simp only [connectorTail]
+    push_cast
+    ring
+  have hj1 := curveJoin_hasDerivAt H _ _ _ _ hd0 hd1 hp1
+    (by simp [quarterTangent_zero])
+  have hp2' : curveJoin H connectorInitial (connectorFirstTurn H r) (connectorSecond H r) =
+      connectorHorizontal H r (connectorSecond H r) := by
+    rw [curveJoin_of_gt hc1]; exact hp2
+  have hj2 := curveJoin_hasDerivAt (connectorSecond H r) _ _ _ _ hj1 hd2 hp2'
+    (by rw [curveJoin_of_gt hc1]; simp [connectorSecond, quarterTangent_end hr])
+  have hp3' : curveJoin (connectorSecond H r)
+      (curveJoin H connectorInitial (connectorFirstTurn H r)) (connectorHorizontal H r)
+      (connectorThird H r X) = connectorLastTurn H r X (connectorThird H r X) := by
+    rw [curveJoin_of_gt hc2]; exact hp3
+  have hj3 := curveJoin_hasDerivAt (connectorThird H r X) _ _ _ _ hj2 hd3 hp3'
+    (by rw [curveJoin_of_gt hc2]; simp [upperQuarterTangent_zero hr])
+  have hp4' : curveJoin (connectorThird H r X)
+      (curveJoin (connectorSecond H r)
+        (curveJoin H connectorInitial (connectorFirstTurn H r)) (connectorHorizontal H r))
+      (connectorLastTurn H r X) (connectorFourth H r X) = connectorTail H r X (connectorFourth H r X) := by
+    rw [curveJoin_of_gt hc3]; exact hp4
+  exact curveJoin_hasDerivAt (connectorFourth H r X) _ _ _ _ hj3 hd4 hp4'
+    (by rw [curveJoin_of_gt hc3]; simp [connectorFourth, upperQuarterTangent_end]) t
+
+lemma lowConnectorTangent_norm (H r X t : ℝ) : ‖lowConnectorTangent H r X t‖ = 1 := by
+  unfold lowConnectorTangent curveJoin
+  split
+  · split
+    · split
+      · split
+        · exact Complex.norm_I
+        · exact quarterTangent_norm _ _
+      · exact norm_one
+    · exact upperQuarterTangent_norm _ _
+  · exact Complex.norm_I
+
+end SLEExactGauge.Serpentine
+
+end
+
+end OAI
diff --git a/lean/OAI/Probability/SLE/Geometry/RoundedConnectorGeometry.lean b/lean/OAI/Probability/SLE/Geometry/RoundedConnectorGeometry.lean
new file mode 100644
index 0000000000000000000000000000000000000000..175bbe2cd1fb1355d6186881704d47ecbd1906c4
--- /dev/null
+++ b/lean/OAI/Probability/SLE/Geometry/RoundedConnectorGeometry.lean
@@ -0,0 +1,171 @@
+import OAI.Probability.SLE.Geometry.RoundedConnectorCurve
+import OAI.Probability.SLE.Gauge.NormalRibbonInjectivity
+
+namespace OAI
+
+/-! Uniform local geometry of the actual rounded connector. -/
+
+noncomputable section
+open Set Metric
+open scoped NNReal
+
+namespace SLEExactGauge.Serpentine
+
+lemma shifted_lipschitz {f : ℝ → ℂ} {K : ℝ≥0} (hf : LipschitzWith K f) (a : ℝ) :
+    LipschitzWith K (fun t => f (t - a)) := by
+  apply lipschitzWith_iff_dist_le_mul.mpr
+  intro t u
+  simpa only [dist_sub_right] using hf.dist_le_mul (t - a) (u - a)
+
+lemma lowConnectorTangent_lipschitz {H r X : ℝ} (hr : 50 ≤ r) (hX : 2 * r < X) :
+    LipschitzWith (1 / 50) (lowConnectorTangent H r X) := by
+  have hr0 : 0 < r := by linarith
+  obtain ⟨hc1, hc2, hc3⟩ := connector_cuts (H := H) hr0 hX
+  have hI : LipschitzWith (1 / 50) (fun _ : ℝ => Complex.I) :=
+    (LipschitzWith.const _).weaken (by norm_num)
+  have h1 : LipschitzWith (1 / 50) (fun _ : ℝ => (1 : ℂ)) :=
+    (LipschitzWith.const _).weaken (by norm_num)
+  have hq := shifted_lipschitz (quarterTangent_lipschitz hr) H
+  have hu := shifted_lipschitz (upperQuarterTangent_lipschitz hr) (connectorThird H r X)
+  have hj1 := curveJoin_lipschitz (c := H) hI hq (by simp [quarterTangent_zero])
+  have hj2 := curveJoin_lipschitz (c := connectorSecond H r) hj1 h1 (by
+    rw [curveJoin_of_gt hc1]
+    simp [connectorSecond, quarterTangent_end hr0])
+  have hj3 := curveJoin_lipschitz (c := connectorThird H r X) hj2 hu (by
+    rw [curveJoin_of_gt hc2]
+    simp [upperQuarterTangent_zero hr0])
+  exact curveJoin_lipschitz (c := connectorFourth H r X) hj3 hI (by
+    rw [curveJoin_of_gt hc3]
+    simp [connectorFourth, upperQuarterTangent_end])
+
+lemma lowConnector_initial {H r X t : ℝ} (hr : 0 < r) (hX : 2 * r < X) (ht : t ≤ H) :
+    lowConnector H r X t = (t : ℂ) * Complex.I ∧
+      lowConnectorTangent H r X t = Complex.I := by
+  obtain ⟨hc1, hc2, hc3⟩ := connector_cuts (H := H) hr hX
+  have ht2 : t ≤ connectorSecond H r := ht.trans hc1.le
+  have ht3 : t ≤ connectorThird H r X := ht2.trans hc2.le
+  have ht4 : t ≤ connectorFourth H r X := ht3.trans hc3.le
+  simp only [lowConnector, lowConnectorTangent, curveJoin_of_le ht4,
+    curveJoin_of_le ht3, curveJoin_of_le ht2, curveJoin_of_le ht, connectorInitial, and_self]
+
+lemma lowConnector_normal_patch_bounds {H r X : ℝ} (hr : 50 ≤ r) (hX : 2 * r < X) (k : ℝ) :
+    LipschitzOnWith 2 (normalRibbon (lowConnector H r X) (lowConnectorTangent H r X))
+      (RibbonCoordinates.ribbonStepPatch k) ∧
+    ∀ z ∈ RibbonCoordinates.ribbonStepPatch k,
+      ∀ w ∈ RibbonCoordinates.ribbonStepPatch k,
+        dist z w ≤ 2 * dist (normalRibbon (lowConnector H r X) (lowConnectorTangent H r X) z)
+          (normalRibbon (lowConnector H r X) (lowConnectorTangent H r X) w) := by
+  have hr0 : 0 < r := by linarith
+  have hbound z (hz : z ∈ RibbonCoordinates.ribbonStepPatch k)
+      w (hw : w ∈ RibbonCoordinates.ribbonStepPatch k) :=
+    normalRibbon_patch_bounds (lowConnector H r X) (lowConnectorTangent H r X) (k - 1) (k + 3)
+      (by ring_nf; norm_num)
+      (fun t _ => (lowConnector_hasDerivAt hr0 hX t).hasDerivWithinAt)
+      (fun t _ => lowConnectorTangent_norm H r X t)
+      (lowConnectorTangent_lipschitz hr hX).lipschitzOnWith
+      z w ⟨⟨hz.1, hz.2.1⟩, hz.2.2⟩ ⟨⟨hw.1, hw.2.1⟩, hw.2.2⟩
+  exact ⟨lipschitzOnWith_iff_dist_le_mul.mpr (fun z hz w hw => (hbound z hz w hw).1),
+    fun z hz w hw => (hbound z hz w hw).2⟩
+
+lemma quarterTangent_nonneg {r t : ℝ} (hr : 0 < r)
+    (ht : t ∈ Icc (0 : ℝ) (quarterLength r)) :
+    0 ≤ (quarterTangent r t).re ∧ 0 ≤ (quarterTangent r t).im := by
+  have hθ : t / r ∈ Icc (0 : ℝ) (Real.pi / 2) := by
+    constructor
+    · exact div_nonneg ht.1 hr.le
+    · apply (div_le_iff₀ hr).mpr
+      dsimp only [quarterLength] at ht
+      linarith [ht.2]
+  simp only [quarterTangent_eq, 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, sub_zero, add_zero, mul_one, zero_add]
+  exact ⟨Real.sin_nonneg_of_mem_Icc ⟨hθ.1, hθ.2.trans (by linarith [Real.pi_pos])⟩,
+    Real.cos_nonneg_of_mem_Icc ⟨by linarith [Real.pi_pos, hθ.1], hθ.2⟩⟩
+
+lemma lowConnectorTangent_nonneg {H r X : ℝ} (hr : 0 < r) (hX : 2 * r < X) (t : ℝ) :
+    0 ≤ (lowConnectorTangent H r X t).re ∧ 0 ≤ (lowConnectorTangent H r X t).im := by
+  obtain ⟨hc1, hc2, hc3⟩ := connector_cuts (H := H) hr hX
+  by_cases h4 : t ≤ connectorFourth H r X
+  · by_cases h3 : t ≤ connectorThird H r X
+    · by_cases h2 : t ≤ connectorSecond H r
+      · by_cases h1 : t ≤ H
+        · simp only [lowConnectorTangent, curveJoin_of_le h4, curveJoin_of_le h3,
+            curveJoin_of_le h2, curveJoin_of_le h1, Complex.I_re, Complex.I_im]
+          norm_num
+        · simp only [lowConnectorTangent, curveJoin_of_le h4, curveJoin_of_le h3,
+            curveJoin_of_le h2, curveJoin_of_gt (lt_of_not_ge h1)]
+          apply quarterTangent_nonneg hr
+          constructor
+          · linarith
+          · dsimp only [connectorSecond] at h2
+            linarith
+      · simp only [lowConnectorTangent, curveJoin_of_le h4, curveJoin_of_le h3,
+          curveJoin_of_gt (lt_of_not_ge h2), Complex.one_re, Complex.one_im]
+        norm_num
+    · simp only [lowConnectorTangent, curveJoin_of_le h4, curveJoin_of_gt (lt_of_not_ge h3),
+        upperQuarterTangent]
+      apply quarterTangent_nonneg hr
+      constructor
+      · dsimp only [connectorFourth] at h4
+        linarith
+      · linarith
+  · simp only [lowConnectorTangent, curveJoin_of_gt (lt_of_not_ge h4), Complex.I_re, Complex.I_im]
+    norm_num
+
+lemma lowConnector_taxicab_speed {H r X : ℝ} (hr : 0 < r) (hX : 2 * r < X) (t : ℝ) :
+    1 ≤ (lowConnectorTangent H r X t).re + (lowConnectorTangent H r X t).im := by
+  obtain ⟨hre, him⟩ := lowConnectorTangent_nonneg (H := H) hr hX t
+  have hn := lowConnectorTangent_norm H r X t
+  have hs := Complex.sq_norm (lowConnectorTangent H r X t)
+  rw [hn, Complex.normSq_apply] at hs
+  have hab := mul_nonneg hre him
+  nlinarith [sq_nonneg ((lowConnectorTangent H r X t).re +
+    (lowConnectorTangent H r X t).im - 1)]
+
+lemma lowConnector_chord_bound {H r X : ℝ} (hr : 0 < r) (hX : 2 * r < X) (s t : ℝ) :
+    |s - t| ≤ 2 * ‖lowConnector H r X s - lowConnector H r X t‖ := by
+  let F := fun u => (lowConnector H r X u).re + (lowConnector H r X u).im
+  have hF (u : ℝ) : HasDerivAt F
+      ((lowConnectorTangent H r X u).re + (lowConnectorTangent H r X u).im) u := by
+    have hr' := Complex.reCLM.hasFDerivAt.comp_hasDerivAt u (lowConnector_hasDerivAt (H := H) hr hX u)
+    have hi' := Complex.imCLM.hasFDerivAt.comp_hasDerivAt u (lowConnector_hasDerivAt (H := H) hr hX u)
+    exact hr'.add hi'
+  have hslow (a b : ℝ) (hab : a ≤ b) : b - a ≤ 2 * ‖lowConnector H r X b - lowConnector H r X a‖ := by
+    have hder : ∀ u ∈ interior (Icc a b), (1 : ℝ) ≤ deriv F u := by
+      intro u _
+      rw [(hF u).deriv]
+      exact lowConnector_taxicab_speed (H := H) hr hX u
+    have hh := (convex_Icc a b).mul_sub_le_image_sub_of_le_deriv
+      (fun u _ => (hF u).continuousAt.continuousWithinAt)
+      (fun u _ => (hF u).differentiableAt.differentiableWithinAt)
+      hder a ⟨le_rfl, hab⟩ b ⟨hab, le_rfl⟩ hab
+    have hre := Complex.abs_re_le_norm (lowConnector H r X b - lowConnector H r X a)
+    have him := Complex.abs_im_le_norm (lowConnector H r X b - lowConnector H r X a)
+    have hbnd : F b - F a ≤ 2 * ‖lowConnector H r X b - lowConnector H r X a‖ := by
+      dsimp only [F]
+      rw [Complex.sub_re] at hre
+      rw [Complex.sub_im] at him
+      have h1 := le_abs_self ((lowConnector H r X b).re - (lowConnector H r X a).re)
+      have h2 := le_abs_self ((lowConnector H r X b).im - (lowConnector H r X a).im)
+      linarith
+    linarith
+  by_cases hst : s ≤ t
+  · rw [abs_of_nonpos (sub_nonpos.mpr hst), neg_sub, norm_sub_rev]
+    exact hslow s t hst
+  · rw [abs_of_nonneg (sub_nonneg.mpr (le_of_not_ge hst))]
+    exact hslow t s (le_of_not_ge hst)
+
+/-- The normal ribbon around the whole low connector is embedded. -/
+theorem lowConnector_normal_injective {H r X : ℝ} (hr : 50 ≤ r) (hX : 2 * r < X) :
+    InjOn (normalRibbon (lowConnector H r X) (lowConnectorTangent H r X))
+      {z : ℂ | 0 ≤ z.re ∧ |z.im| ≤ 1} := by
+  have hr0 : 0 < r := by linarith
+  exact normalRibbon_injective_of_chord_bound _ _ (lowConnector_hasDerivAt hr0 hX)
+    (lowConnectorTangent_norm H r X) (lowConnectorTangent_lipschitz hr hX)
+    (fun s t _ _ => lowConnector_chord_bound hr0 hX s t)
+
+end SLEExactGauge.Serpentine
+
+end
+
+end OAI
diff --git a/lean/OAI/Probability/SLE/Geometry/RoundedConnectorRegion.lean b/lean/OAI/Probability/SLE/Geometry/RoundedConnectorRegion.lean
new file mode 100644
index 0000000000000000000000000000000000000000..a6014845ae11d9180386ee52c5b0e634617b1a4c
--- /dev/null
+++ b/lean/OAI/Probability/SLE/Geometry/RoundedConnectorRegion.lean
@@ -0,0 +1,63 @@
+import OAI.Probability.SLE.Geometry.RoundedConnectorGeometry
+import OAI.Probability.SLE.Geometry.RoundedConnectorBands
+
+namespace OAI
+
+/-! The connector changes horizontal position only at low height. -/
+
+noncomputable section
+open Set Metric
+
+namespace SLEExactGauge.Serpentine
+
+lemma lowConnector_normal_im_upper {H r X : ℝ} (hr : 1 < r) (hX : 2 * r < X)
+    {z : ℂ} (hz : z.re ≤ connectorFourth H r X) (ha : |z.im| ≤ 1) :
+    (normalRibbon (lowConnector H r X) (lowConnectorTangent H r X) z).im ≤ H + 2 * r + 1 := by
+  have hr0 : 0 < r := by linarith
+  obtain ⟨hc1, hc2, hc3⟩ := connector_cuts (H := H) hr0 hX
+  by_cases h3 : z.re ≤ connectorThird H r X
+  · by_cases h2 : z.re ≤ connectorSecond H r
+    · by_cases h1 : z.re ≤ H
+      · simp only [normalRibbon, lowConnector, lowConnectorTangent, curveJoin_of_le hz,
+          curveJoin_of_le h3, curveJoin_of_le h2, curveJoin_of_le h1, connectorInitial,
+          Complex.add_im, Complex.mul_im, Complex.mul_re, Complex.ofReal_re, Complex.ofReal_im,
+          Complex.I_re, Complex.I_im, mul_zero, mul_one, sub_zero, add_zero]
+        linarith
+      · have ht : z.re - H ∈ Icc (0 : ℝ) (quarterLength r) := by
+          constructor
+          · linarith
+          · dsimp only [connectorSecond] at h2
+            linarith
+        have hb := (quarterNormal_bounds hr ht ha).2.2.2
+        simp only [normalRibbon, lowConnector, lowConnectorTangent, curveJoin_of_le hz,
+          curveJoin_of_le h3, curveJoin_of_le h2, curveJoin_of_gt (lt_of_not_ge h1), connectorFirstTurn]
+        rw [add_assoc]
+        change ((H : ℂ) * Complex.I + quarterNormal r (z.re - H) z.im).im ≤ _
+        simp only [Complex.add_im, Complex.mul_im, Complex.ofReal_re, Complex.ofReal_im,
+          Complex.I_re, Complex.I_im, mul_one, mul_zero, add_zero]
+        linarith
+    · simp only [normalRibbon, lowConnector, lowConnectorTangent, curveJoin_of_le hz,
+        curveJoin_of_le h3, curveJoin_of_gt (lt_of_not_ge h2), connectorHorizontal,
+        Complex.add_im, Complex.mul_im, Complex.ofReal_re, Complex.ofReal_im,
+        Complex.I_re, Complex.I_im, mul_zero, mul_one, add_zero, zero_add]
+      linarith [(abs_le.mp ha).2]
+  · have ht : z.re - connectorThird H r X ∈ Icc (0 : ℝ) (quarterLength r) := by
+      constructor
+      · linarith
+      · dsimp only [connectorFourth] at hz
+        linarith
+    have hb := (upperQuarterNormal_bounds hr ht ha).2.2.2
+    simp only [normalRibbon, lowConnector, lowConnectorTangent, curveJoin_of_le hz,
+      curveJoin_of_gt (lt_of_not_ge h3), connectorLastTurn]
+    rw [add_assoc]
+    change ((((X - r : ℝ) : ℂ) + ((H + r : ℝ) : ℂ) * Complex.I) +
+      upperQuarterNormal r (z.re - connectorThird H r X) z.im).im ≤ _
+    simp only [Complex.add_im, Complex.mul_im, Complex.ofReal_re, Complex.ofReal_im,
+      Complex.I_re, Complex.I_im, mul_one, mul_zero, add_zero, zero_add]
+    linarith
+
+end SLEExactGauge.Serpentine
+
+end
+
+end OAI
diff --git a/lean/OAI/Probability/SLE/Geometry/ScaledMarkedKernel.lean b/lean/OAI/Probability/SLE/Geometry/ScaledMarkedKernel.lean
new file mode 100644
index 0000000000000000000000000000000000000000..5407a896eb5aa867dcbeec95902552306f3b3511
--- /dev/null
+++ b/lean/OAI/Probability/SLE/Geometry/ScaledMarkedKernel.lean
@@ -0,0 +1,88 @@
+import OAI.Probability.SLE.Geometry.RestartGreenKernel
+import OAI.Probability.SLE.InteriorDiskProof
+
+namespace OAI
+
+/-! Exact scaling of the marked radius, angle, and Green kernel. These
+identities normalize a random restarted marked point to modulus one. -/
+
+noncomputable section
+open Set Filter
+open scoped Topology NNReal ENNReal
+
+namespace SLEExactGauge
+
+lemma source_scale_time_mul_sq (c t : ℝ≥0) (hc : 0 < c) :
+    sourceScaleTime c (c ^ 2 * t) = t := by
+  unfold sourceScaleTime
+  exact mul_div_cancel_left₀ t (pow_ne_zero 2 hc.ne')
+
+lemma sin_arg_pos_real_mul (c : ℝ) (hc : 0 < c) (z : ℂ) :
+    Real.sin (Complex.arg ((c : ℂ) * z)) = Real.sin (Complex.arg z) := by
+  rw [Complex.sin_arg, Complex.sin_arg, Complex.mul_im, Complex.ofReal_re,
+    Complex.ofReal_im, zero_mul, add_zero, norm_mul, Complex.norm_real,
+    Real.norm_eq_abs, abs_of_pos hc]
+  by_cases hz : z = 0
+  · simp [hz]
+  · field_simp
+
+lemma IsCapacityTwoWitness.scaled_derivative
+    {U : ℝ≥0 → ℝ} {γ : ℝ≥0 → ℂ} {G F : ℝ≥0 → ℂ → ℂ}
+    (hw : IsCapacityTwoWitness U γ G F) (c : ℝ≥0) (hc : 0 < c)
+    (t : ℝ≥0) (z : ℂ) (hz : z ∈ survivingDomain γ t) :
+    deriv (sourceScaleChart c G (c ^ 2 * t)) ((c : ℂ) * z) = deriv (G t) z := by
+  have hcC : (c : ℂ) ≠ 0 := by exact_mod_cast hc.ne'
+  have hdiv : (c : ℂ) * z / (c : ℂ) = z := mul_div_cancel_left₀ z hcC
+  have hGd := ((hw.2.2.2.1 t).differentiableAt
+    ((isOpen_survivingDomain hw.1 t).mem_nhds hz)).hasDerivAt
+  have hGd' : HasDerivAt (G t) (deriv (G t) z) ((c : ℂ) * z / (c : ℂ)) := by
+    rwa [hdiv]
+  have hd := (hGd'.comp ((c : ℂ) * z)
+    ((hasDerivAt_id ((c : ℂ) * z)).div_const (c : ℂ))).const_mul (c : ℂ)
+  change deriv (fun w => (c : ℂ) * G (sourceScaleTime c (c ^ 2 * t)) (w / (c : ℂ)))
+    ((c : ℂ) * z) = _
+  rw [source_scale_time_mul_sq c t hc]
+  have hcoeff : (c : ℂ) * (deriv (G t) z * (1 / (c : ℂ))) = deriv (G t) z := by
+    field_simp
+  simpa only [Function.comp_def, id_eq, hcoeff] using hd.deriv
+
+lemma IsCapacityTwoWitness.scaled_radius
+    {U : ℝ≥0 → ℝ} {γ : ℝ≥0 → ℂ} {G F : ℝ≥0 → ℂ → ℂ}
+    (hw : IsCapacityTwoWitness U γ G F) (c : ℝ≥0) (hc : 0 < c)
+    (t : ℝ≥0) (z : ℂ) (hz : z ∈ survivingDomain γ t) :
+    fullRadius (sourceScaleChart c G) (c ^ 2 * t) ((c : ℂ) * z) =
+      (c : ℝ) * fullRadius G t z := by
+  have hcC : (c : ℂ) ≠ 0 := by exact_mod_cast hc.ne'
+  rw [fullRadius, hw.scaled_derivative c hc t z hz,
+    sourceScaleChart, source_scale_time_mul_sq c t hc, mul_div_cancel_left₀ z hcC,
+    Complex.mul_im, Complex.ofReal_re, Complex.ofReal_im, zero_mul, add_zero, fullRadius]
+  ring
+
+lemma IsCapacityTwoWitness.scaled_green
+    {U : ℝ≥0 → ℝ} {γ : ℝ≥0 → ℂ} {G F : ℝ≥0 → ℂ → ℂ}
+    (hw : IsCapacityTwoWitness U γ G F) (hU : Continuous U)
+    (c : ℝ≥0) (hc : 0 < c) (κ : ℝ) (t : ℝ≥0) (z : ℂ)
+    (hz : z ∈ survivingDomain γ t) :
+    greenDensity κ (fun t => (c : ℝ) * U (sourceScaleTime c t))
+        (sourceScaleTrace c γ) (sourceScaleChart c G) (c ^ 2 * t) ((c : ℂ) * z) =
+      (c : ℝ) ^ (-codimension κ) * greenDensity κ U γ G t z := by
+  have hcC : (c : ℂ) ≠ 0 := by exact_mod_cast hc.ne'
+  have hscaled : (c : ℂ) * z ∈ survivingDomain (sourceScaleTrace c γ) (c ^ 2 * t) := by
+    rw [source_scale_domain_iff c _ hc γ, source_scale_time_mul_sq c t hc,
+      mul_div_cancel_left₀ z hcC]
+    exact hz
+  have hcenter : sourceScaleChart c G (c ^ 2 * t) ((c : ℂ) * z) -
+      ((c : ℝ) * U (sourceScaleTime c (c ^ 2 * t)) : ℝ) =
+      (c : ℂ) * (G t z - (U t : ℂ)) := by
+    rw [sourceScaleChart, source_scale_time_mul_sq c t hc, mul_div_cancel_left₀ z hcC,
+      Complex.ofReal_mul]
+    ring
+  rw [greenDensity, ite_eq_left hscaled, hw.scaled_radius c hc t z hz, hcenter,
+    sin_arg_pos_real_mul c hc, Real.mul_rpow c.coe_nonneg (hw.fullRadius_positive hU t z hz).le,
+    greenDensity, ite_eq_left hz, mul_assoc]
+
+end SLEExactGauge
+
+end
+
+end OAI
diff --git a/lean/OAI/Probability/SLE/Geometry/SchoenfliesInsideTransport.lean b/lean/OAI/Probability/SLE/Geometry/SchoenfliesInsideTransport.lean
new file mode 100644
index 0000000000000000000000000000000000000000..3c45e23dda004107e6f15b6d9da784b27ae7e09f
--- /dev/null
+++ b/lean/OAI/Probability/SLE/Geometry/SchoenfliesInsideTransport.lean
@@ -0,0 +1,79 @@
+import OAI.Probability.SLE.Geometry.ComplexJordanExtension
+
+namespace OAI
+
+/-! Plane homeomorphisms preserve the bounded complementary region.
+This identifies the side selected by a relative Schoenflies extension. -/
+noncomputable section
+open Set
+
+namespace SLEExactGauge
+
+lemma plane_homeomorph_bounded_image (h : Schoenflies.Plane ≃ₜ Schoenflies.Plane)
+    {S : Set Schoenflies.Plane} (hS : Bornology.IsBounded S) :
+    Bornology.IsBounded (h '' S) :=
+  (hS.isCompact_closure.image h.continuous).isBounded.subset (image_mono subset_closure)
+
+lemma plane_homeomorph_bounded_image_iff (h : Schoenflies.Plane ≃ₜ Schoenflies.Plane)
+    (S : Set Schoenflies.Plane) : Bornology.IsBounded (h '' S) ↔ Bornology.IsBounded S := by
+  refine ⟨fun hs => ?_,plane_homeomorph_bounded_image h⟩
+  have hh := plane_homeomorph_bounded_image h.symm hs
+  simpa only [image_image,h.symm_apply_apply,image_id'] using hh
+
+theorem plane_homeomorph_inside (h : Schoenflies.Plane ≃ₜ Schoenflies.Plane)
+    (C : Set Schoenflies.Plane) : h '' Schoenflies.inside C = Schoenflies.inside (h '' C) := by
+  ext z
+  constructor
+  · rintro ⟨x,hx,rfl⟩
+    have hxC : x ∈ Cᶜ := hx.1
+    refine ⟨?_,?_⟩
+    · rintro ⟨y,hy,he⟩
+      exact hx.1 (h.injective he ▸ hy)
+    have hh := h.image_connectedComponentIn hxC
+    rw [h.image_compl] at hh
+    rw [← hh]
+    exact plane_homeomorph_bounded_image h hx.2
+  · intro hz
+    refine ⟨h.symm z,?_,h.apply_symm_apply z⟩
+    have hxC : h.symm z ∉ C := by
+      intro hc
+      apply hz.1
+      exact ⟨h.symm z,hc,h.apply_symm_apply z⟩
+    refine ⟨hxC,?_⟩
+    have hh := h.image_connectedComponentIn (s := Cᶜ) (x := h.symm z) hxC
+    rw [h.image_compl,h.apply_symm_apply] at hh
+    apply (plane_homeomorph_bounded_image_iff h _).mp
+    rw [hh]
+    exact hz.2
+
+theorem plane_homeomorph_jordan (h : Schoenflies.Plane ≃ₜ Schoenflies.Plane)
+    {C : Set Schoenflies.Plane} (hC : Schoenflies.IsJordanCurve C) :
+    Schoenflies.IsJordanCurve (h '' C) := by
+  obtain ⟨p,hp,hpC⟩ := hC
+  refine ⟨h ∘ p,⟨h.continuous.comp_continuousOn hp.continuousOn,
+    congrArg h hp.closes,?_⟩,?_⟩
+  · intro s hs t ht he
+    exact hp.injOn hs ht (h.injective he)
+  · rw [image_comp, hpC]
+
+theorem separating_inside_eq_open
+    {C U : Set Schoenflies.Plane} (hC : Schoenflies.IsSeparating C)
+    (hU : IsOpen U) (hconn : IsPreconnected U) (hne : U.Nonempty)
+    (hbounded : Bornology.IsBounded U) (hfront : frontier U=C) :
+    Schoenflies.inside C=U := by
+  have hsub : U ⊆ Cᶜ := by
+    intro z hz hzC
+    have hh : z ∈ frontier U := hfront.symm ▸ hzC
+    rw [hU.frontier_eq] at hh
+    exact hh.2 hz
+  obtain ⟨x,hx⟩ := hne
+  have hcomp := Schoenflies.Plane.connectedComponentIn_eq_of_frontier_disjoint
+    hU hconn hsub (by simp only [hfront,inter_compl_self]) hx
+  have hxin : x ∈ Schoenflies.inside C := ⟨hsub hx,hcomp.symm ▸ hbounded⟩
+  exact (hC.connectedComponentIn_eq_inside hxin).symm.trans hcomp
+
+end SLEExactGauge
+
+end
+
+end OAI
diff --git a/lean/OAI/Probability/SLE/Geometry/ShrinkingPhysicalSegments.lean b/lean/OAI/Probability/SLE/Geometry/ShrinkingPhysicalSegments.lean
new file mode 100644
index 0000000000000000000000000000000000000000..7e039701133ec967ecc94ef827577e7d1fd2d4fb
--- /dev/null
+++ b/lean/OAI/Probability/SLE/Geometry/ShrinkingPhysicalSegments.lean
@@ -0,0 +1,34 @@
+import OAI.Probability.SLE.Loewner.FutureArcThinCrossing
+
+namespace OAI
+
+/-! A common vanishing bound for the physical images of shrinking
+parameter segments. -/
+noncomputable section
+open Set Filter Function Complex Metric
+open scoped Topology
+
+namespace SLEExactGauge
+
+lemma shrinking_physical_segment_bound (p : C(unitInterval,ℂ))
+    {s : unitInterval} {t r : ℕ → unitInterval}
+    (ht : Tendsto t atTop (𝓝 s)) (hr : Tendsto r atTop (𝓝 s))
+    (htr : ∀ n, t n≤r n) :
+    ∃ ε : ℕ → ℝ, Tendsto ε atTop (𝓝 0) ∧
+      ∀ n, ∀ v∈Icc (t n) (r n), ‖p v-p s‖≤ε n := by
+  have hmax (n : ℕ) : ∃ v∈Icc (t n) (r n),
+      ∀ w∈Icc (t n) (r n), ‖p w-p s‖≤‖p v-p s‖ := by
+    exact isCompact_Icc.exists_isMaxOn (nonempty_Icc.mpr (htr n))
+      (p.continuous.sub continuous_const).norm.continuousOn
+  choose v hv hbound using hmax
+  have hvlim : Tendsto v atTop (𝓝 s) :=
+    tendsto_of_tendsto_of_tendsto_of_le_of_le ht hr (fun n => (hv n).1) (fun n => (hv n).2)
+  refine ⟨fun n => ‖p (v n)-p s‖,?_,hbound⟩
+  simpa only [sub_self,norm_zero,Function.comp_def] using
+    ((p.continuous.tendsto s).comp hvlim).sub_const (p s) |>.norm
+
+end SLEExactGauge
+
+end
+
+end OAI
diff --git a/lean/OAI/Probability/SLE/Geometry/ShrinkingStripEnergy.lean b/lean/OAI/Probability/SLE/Geometry/ShrinkingStripEnergy.lean
new file mode 100644
index 0000000000000000000000000000000000000000..c268ddda12f1f7c4b335c8b98250d0dfea7dce68
--- /dev/null
+++ b/lean/OAI/Probability/SLE/Geometry/ShrinkingStripEnergy.lean
@@ -0,0 +1,99 @@
+import OAI.Probability.SLE.Geometry.HolomorphicStripSections
+
+namespace OAI
+
+/-! Finite energy at the left end of a strip supplies arbitrarily far-left
+angular sections of arbitrarily small oscillation. -/
+noncomputable section
+open Set Filter Metric Function MeasureTheory
+open scoped Topology ENNReal
+
+namespace SLEExactGauge
+
+lemma holomorphic_left_strip_energy_tendsto_zero {f : ℂ → ℂ}
+    (hf : DifferentiableOn ℂ f {z | 0<z.im ∧ z.im<Real.pi})
+    (he : (∫⁻ z in {z : ℂ | z.re<0 ∧ 0<z.im ∧ z.im<Real.pi},
+      ENNReal.ofReal (‖deriv f z‖^2))<∞) :
+    Tendsto (fun n : ℕ => ∫ z in {z : ℂ | z.re< -(n:ℝ) ∧ 0<z.im ∧ z.im<Real.pi},
+      ‖deriv f z‖^2) atTop (𝓝 0) := by
+  let S (n : ℕ) : Set ℂ := {z | z.re< -(n:ℝ) ∧ 0<z.im ∧ z.im<Real.pi}
+  have hs (n : ℕ) : IsOpen (S n) := (isOpen_lt Complex.continuous_re continuous_const).inter
+    ((isOpen_lt continuous_const Complex.continuous_im).inter
+      (isOpen_lt Complex.continuous_im continuous_const))
+  have ha : Antitone S := by
+    intro m n hmn z hz
+    exact ⟨hz.1.trans_le (neg_le_neg (by exact_mod_cast hmn)),hz.2⟩
+  have hi : IntegrableOn (fun z => ‖deriv f z‖^2) (S 0) := by
+    have hm := deriv_memLp_two_of_energy (hs 0) (hf.mono fun _ hz => hz.2)
+      (by simpa [S] using he)
+    exact hm.norm.integrable_sq
+  have hempty : (⋂ n, S n)=∅ := by
+    apply eq_empty_iff_forall_notMem.mpr
+    intro z hz
+    obtain ⟨n,hn⟩ := exists_nat_gt (-z.re)
+    have hz' := (mem_iInter.mp hz n).1
+    linarith
+  simpa only [hempty,setIntegral_empty] using
+    (tendsto_setIntegral_of_antitone (fun n => (hs n).measurableSet) ha ⟨0,hi⟩)
+
+lemma exists_small_holomorphic_section {f : ℂ → ℂ}
+    (hf : DifferentiableOn ℂ f {z | 0<z.im ∧ z.im<Real.pi})
+    (he : (∫⁻ z in {z : ℂ | z.re<0 ∧ 0<z.im ∧ z.im<Real.pi},
+      ENNReal.ofReal (‖deriv f z‖^2))<∞)
+    (Q ε : ℝ) (hε : 0<ε) :
+    ∃ v : ℝ, v<Q ∧
+      MemLp (deriv (fun θ : ℝ => f ((v:ℂ)+(θ:ℂ)*Complex.I))) 2
+        (volume.restrict (Ioo 0 Real.pi)) ∧
+      ∀ θ∈Ioo 0 Real.pi, ∀ φ∈Ioo 0 Real.pi,
+      ‖f ((v:ℂ)+(θ:ℂ)*Complex.I)-f ((v:ℂ)+(φ:ℂ)*Complex.I)‖<ε := by
+  let S (n : ℕ) : Set ℂ := {z | z.re< -(n:ℝ) ∧ 0<z.im ∧ z.im<Real.pi}
+  let E (n : ℕ) := ∫ z in S n, ‖deriv f z‖^2
+  have hlim : Tendsto E atTop (𝓝 0) := holomorphic_left_strip_energy_tendsto_zero hf he
+  have hsmall : ∀ᶠ n in atTop, Real.sqrt Real.pi * Real.sqrt (E n)<ε := by
+    have hlim' : Tendsto (fun n => Real.sqrt Real.pi * Real.sqrt (E n)) atTop (𝓝 0) := by
+      simpa only [Real.sqrt_zero,mul_zero] using hlim.sqrt.const_mul (Real.sqrt Real.pi)
+    exact hlim'.eventually (gt_mem_nhds hε)
+  have hfar : ∀ᶠ n : ℕ in atTop, -(n:ℝ)<Q :=
+    (tendsto_neg_atTop_atBot.comp (tendsto_natCast_atTop_atTop (R := ℝ))).eventually
+      (eventually_lt_atBot Q)
+  obtain ⟨n,hn,hne⟩ := (hfar.and hsmall).exists
+  let q := -(n:ℝ)-1
+  let T : Set ℂ := {z | q<z.re ∧ z.re<q+1 ∧ 0<z.im ∧ z.im<Real.pi}
+  have hTS : T⊆S n := by
+    intro z hz
+    exact ⟨by linarith [hz.2.1],hz.2.2⟩
+  have hSn : IsOpen (S n) := (isOpen_lt Complex.continuous_re continuous_const).inter
+    ((isOpen_lt continuous_const Complex.continuous_im).inter
+      (isOpen_lt Complex.continuous_im continuous_const))
+  have hS0 : S n⊆{z : ℂ | z.re<0 ∧ 0<z.im ∧ z.im<Real.pi} :=
+    fun _ hz => ⟨hz.1.trans_le (by simp),hz.2⟩
+  have heSn : (∫⁻ z in S n, ENNReal.ofReal (‖deriv f z‖^2))<∞ :=
+    (lintegral_mono_set hS0).trans_lt he
+  have hTfinite : (∫⁻ z in T, ENNReal.ofReal (‖deriv f z‖^2))<∞ :=
+    (lintegral_mono_set hTS).trans_lt heSn
+  obtain ⟨v,hv,hvm,hvE⟩ := exists_holomorphic_energy_section hf q hTfinite
+  have hES : (∫ z in T, ‖deriv f z‖^2) ≤ E n := by
+    apply setIntegral_mono_set
+      (deriv_memLp_two_of_energy hSn (hf.mono fun _ hz => hz.2) heSn).norm.integrable_sq
+      (ae_of_all _ (fun _ => sq_nonneg _)) hTS.eventuallySubset
+  have hS : IsOpen {z : ℂ | 0<z.im ∧ z.im<Real.pi} :=
+    (isOpen_lt continuous_const Complex.continuous_im).inter
+      (isOpen_lt Complex.continuous_im continuous_const)
+  have hd (θ : ℝ) (hθ : θ∈Ioo 0 Real.pi) :
+      DifferentiableAt ℝ (fun θ : ℝ => f ((v:ℂ)+(θ:ℂ)*Complex.I)) θ := by
+    have hz : (v:ℂ)+(θ:ℂ)*Complex.I∈{z : ℂ | 0<z.im ∧ z.im<Real.pi} := by
+      simpa using hθ
+    exact ((hf.differentiableAt (hS.mem_nhds hz)).restrictScalars ℝ).comp θ
+      ((Complex.ofRealCLM.differentiableAt.mul_const Complex.I).const_add (v:ℂ))
+  refine ⟨v,lt_of_lt_of_le hv.2 (by dsimp [q]; linarith),hvm,?_⟩
+  intro θ hθ φ hφ
+  have hb := complex_angular_oscillation hφ hθ
+    (fun s hs => hd s (ordConnected_Ioo.uIcc_subset hφ hθ hs)) hvm
+  exact hb.trans_lt ((mul_le_mul_of_nonneg_left (Real.sqrt_le_sqrt (hvE.trans hES))
+    (Real.sqrt_nonneg _)).trans_lt hne)
+
+end SLEExactGauge
+
+end
+
+end OAI
diff --git a/lean/OAI/Probability/SLE/Geometry/SimpleArcComplement.lean b/lean/OAI/Probability/SLE/Geometry/SimpleArcComplement.lean
new file mode 100644
index 0000000000000000000000000000000000000000..f75c14e12a9ca0d6ba3b340b6a6f39248858d581
--- /dev/null
+++ b/lean/OAI/Probability/SLE/Geometry/SimpleArcComplement.lean
@@ -0,0 +1,48 @@
+import OAI.Probability.SLE.Geometry.ArcRealRetraction
+
+namespace OAI
+
+/-! Every point of the half-plane outside a simple attached arc lies in
+an unbounded complementary component. -/
+noncomputable section
+open Set Filter Function
+open scoped Topology
+
+namespace SLEExactGauge
+
+theorem simple_arc_halfPlane_component_unbounded
+    (p : C(unitInterval,ℂ)) (hi : Injective p) (h0 : p 0=0)
+    (hH : ∀ t : unitInterval, t ≠ 0 → p t ∈ upperHalfPlane)
+    {z : ℂ} (hz : z ∈ upperHalfPlane \ range p) :
+    ¬ Bornology.IsBounded (connectedComponentIn (upperHalfPlane \ range p) z) := by
+  let K : Set ℂ := range p ∪ {w : ℂ | w.im=0}
+  have hK : IsClosed K := (p.continuous.isClosedEmbedding hi).isClosed_range.union
+    (isClosed_eq Complex.continuous_im continuous_const)
+  obtain ⟨r,hrK,hrfix⟩ := simple_arc_real_retraction p hi h0 hH
+  have hzK : z ∉ K := by
+    rintro (h | h)
+    · exact hz.2 h
+    · exact hz.1.ne' h
+  have hn := retract_complement_component_unbounded hK r r.continuous hrK hrfix hzK
+  have hsub : connectedComponentIn Kᶜ z ⊆ upperHalfPlane \ range p := by
+    intro w hw
+    have hwK := connectedComponentIn_subset Kᶜ z hw
+    have him : 0 < w.im := by
+      by_contra hh
+      have hnonpos : w.im ≤ 0 := le_of_not_gt hh
+      obtain ⟨v,hv,hvim⟩ := isPreconnected_connectedComponentIn.intermediate_value
+        hw (mem_connectedComponentIn hzK) Complex.continuous_im.continuousOn
+        (show (0 : ℝ) ∈ Icc w.im z.im from ⟨hnonpos,hz.1.le⟩)
+      exact connectedComponentIn_subset Kᶜ z hv (Or.inr hvim)
+    exact ⟨him,fun h => hwK (Or.inl h)⟩
+  have hcc : connectedComponentIn Kᶜ z ⊆
+      connectedComponentIn (upperHalfPlane \ range p) z :=
+    isPreconnected_connectedComponentIn.subset_connectedComponentIn
+      (mem_connectedComponentIn hzK) hsub
+  exact fun hb => hn (hb.subset hcc)
+
+end SLEExactGauge
+
+end
+
+end OAI
diff --git a/lean/OAI/Probability/SLE/Geometry/SimpleArcPlaneComplement.lean b/lean/OAI/Probability/SLE/Geometry/SimpleArcPlaneComplement.lean
new file mode 100644
index 0000000000000000000000000000000000000000..dbfe6047dc6ab23a1e06118b4ae33c383d8d9bf5
--- /dev/null
+++ b/lean/OAI/Probability/SLE/Geometry/SimpleArcPlaneComplement.lean
@@ -0,0 +1,103 @@
+import OAI.Probability.SLE.Stochastic.PlanarRetractComplement
+import Mathlib.Analysis.Normed.Module.Connected
+import Mathlib.Topology.TietzeExtension
+
+namespace OAI
+
+/-! A finite simple planar arc has connected complement. The argument
+uses its interval-coordinate retraction, the circle obstruction, and a
+large sphere meeting every unbounded complementary component. -/
+noncomputable section
+open Set Complex Metric Function
+
+namespace SLEExactGauge
+
+theorem simple_arc_retraction (p : C(unitInterval,ℂ)) (hi : Injective p) :
+    ∃ r : C(ℂ,ℂ), (∀ z, r z ∈ range p) ∧ ∀ z ∈ range p, r z=z := by
+  let t : C(unitInterval,ℝ) := ⟨fun u => u,continuous_subtype_val⟩
+  obtain ⟨g,hg⟩ := t.exists_extension' (p.continuous.isClosedEmbedding hi)
+  let v (z : ℂ) : unitInterval := ⟨max 0 (min 1 (g z)),
+    le_max_left _ _,max_le zero_le_one (min_le_left _ _)⟩
+  have hv : Continuous v := (continuous_const.max
+    (continuous_const.min g.continuous)).subtype_mk _
+  refine ⟨⟨fun z => p (v z),p.continuous.comp hv⟩,
+    fun z => mem_range_self (v z),?_⟩
+  rintro _ ⟨u,rfl⟩
+  have hgu : g (p u)=(u:ℝ) := congr_fun hg u
+  have hvu : v (p u)=u := by
+    apply Subtype.ext
+    simp only [v,hgu,min_eq_right u.property.2,max_eq_right u.property.1]
+  exact congrArg p hvu
+
+lemma unbounded_component_meets_sphere {K : Set ℂ} {z : ℂ}
+    (hz : z ∈ K) (hK : IsPreconnected K) (hu : ¬ Bornology.IsBounded K)
+    {R : ℝ} (hR : ‖z‖ ≤ R) : (K ∩ sphere (0:ℂ) R).Nonempty := by
+  have he : ∃ v ∈ K, R < ‖v‖ := by
+    by_contra he
+    push Not at he
+    apply hu
+    apply (isBounded_closedBall (x := (0:ℂ)) (r := R)).subset
+    intro v hv
+    simpa only [mem_closedBall,dist_zero_right] using he v hv
+  obtain ⟨v,hv,hvR⟩ := he
+  obtain ⟨w,hw,hwR⟩ := hK.intermediate_value hz hv continuous_norm.continuousOn
+    (show R ∈ Icc ‖z‖ ‖v‖ from ⟨hR,hvR.le⟩)
+  exact ⟨w,hw,by simpa only [mem_sphere,dist_zero_right] using hwR⟩
+
+theorem bounded_complement_connected_of_unbounded_components
+    {K : Set ℂ} (hb : Bornology.IsBounded K)
+    (hu : ∀ z ∉ K, ¬ Bornology.IsBounded (connectedComponentIn Kᶜ z)) :
+    IsConnected Kᶜ := by
+  obtain ⟨R,hR,hKR⟩ := hb.subset_ball_lt 0 (0:ℂ)
+  have hbase : ((R+1:ℝ):ℂ) ∈ Kᶜ := by
+    intro h
+    have hh := hKR h
+    simp only [mem_ball,dist_zero_right,Complex.norm_real,Real.norm_eq_abs,
+      abs_of_pos (by linarith : 0 < R+1)] at hh
+    linarith
+  let w : ℂ := ((R+1:ℝ):ℂ)
+  have heq : Kᶜ = connectedComponentIn Kᶜ w := by
+    apply Subset.antisymm _ (connectedComponentIn_subset _ _)
+    intro z hz
+    let S := max R (max ‖z‖ ‖w‖)+1
+    have hRS : R < S := by dsimp [S]; linarith [le_max_left R (max ‖z‖ ‖w‖)]
+    have hzS : ‖z‖ ≤ S := by
+      dsimp [S]
+      linarith [(le_max_left ‖z‖ ‖w‖).trans (le_max_right R (max ‖z‖ ‖w‖))]
+    have hwS : ‖w‖ ≤ S := by
+      dsimp [S]
+      linarith [(le_max_right ‖z‖ ‖w‖).trans (le_max_right R (max ‖z‖ ‖w‖))]
+    have hsK : sphere (0:ℂ) S ⊆ Kᶜ := by
+      intro v hv hvK
+      have hbv := hKR hvK
+      have hsv : ‖v‖=S := by simpa only [mem_sphere,dist_zero_right] using hv
+      rw [mem_ball,dist_zero_right,hsv] at hbv
+      linarith
+    have hs : IsPreconnected (sphere (0:ℂ) S) :=
+      isPreconnected_sphere (by rw [Complex.rank_real_complex]; norm_num) _ _
+    obtain ⟨u,huC,huS⟩ := unbounded_component_meets_sphere
+      (mem_connectedComponentIn hz) isPreconnected_connectedComponentIn (hu z hz) hzS
+    obtain ⟨v,hvC,hvS⟩ := unbounded_component_meets_sphere
+      (mem_connectedComponentIn hbase) isPreconnected_connectedComponentIn (hu w hbase) hwS
+    have huv := hs.subset_connectedComponentIn huS hsK hvS
+    rw [← connectedComponentIn_eq huC] at huv
+    have hwv := connectedComponentIn_eq hvC
+    rw [hwv,← connectedComponentIn_eq huv]
+    exact mem_connectedComponentIn hz
+  rw [heq]
+  exact isConnected_connectedComponentIn_iff.mpr hbase
+
+theorem simple_arc_plane_complement_connected
+    (p : C(unitInterval,ℂ)) (hi : Injective p) :
+    IsConnected (range p)ᶜ := by
+  obtain ⟨r,hr,hrfix⟩ := simple_arc_retraction p hi
+  exact bounded_complement_connected_of_unbounded_components
+    (isCompact_range p.continuous).isBounded
+    (fun _ hz => retract_complement_component_unbounded
+      (p.continuous.isClosedEmbedding hi).isClosed_range r r.continuous hr hrfix hz)
+
+end SLEExactGauge
+
+end
+
+end OAI
diff --git a/lean/OAI/Probability/SLE/Geometry/SimplePathConcatenation.lean b/lean/OAI/Probability/SLE/Geometry/SimplePathConcatenation.lean
new file mode 100644
index 0000000000000000000000000000000000000000..ccc2f646b27da41514e9838b3ac09afe42fe725c
--- /dev/null
+++ b/lean/OAI/Probability/SLE/Geometry/SimplePathConcatenation.lean
@@ -0,0 +1,45 @@
+import Mathlib.Topology.Path
+
+namespace OAI
+
+/-! Injectivity of two simple paths joined only at their common endpoint. -/
+noncomputable section
+open Set Function
+open scoped unitInterval
+
+namespace SLEExactGauge
+
+theorem path_trans_injective {X : Type*} [TopologicalSpace X] {a b c : X}
+    (p : Path a b) (q : Path b c) (hp : Injective p) (hq : Injective q)
+    (hcross : ∀ s t, p s=q t → s=1 ∧ t=0) : Injective (p.trans q) := by
+  intro s t he
+  rw [Path.trans_apply,Path.trans_apply] at he
+  split_ifs at he with hs ht ht
+  · have hh := congrArg (fun u : unitInterval => (u:ℝ)) (hp he)
+    apply Subtype.ext
+    dsimp only at hh
+    linarith
+  · obtain ⟨h₁,h₂⟩ := hcross _ _ he
+    have h₁' := congrArg (fun u : unitInterval => (u:ℝ)) h₁
+    have h₂' := congrArg (fun u : unitInterval => (u:ℝ)) h₂
+    apply Subtype.ext
+    dsimp only at h₁' h₂'
+    norm_num at h₁' h₂'
+    linarith
+  · obtain ⟨h₁,h₂⟩ := hcross _ _ he.symm
+    have h₁' := congrArg (fun u : unitInterval => (u:ℝ)) h₁
+    have h₂' := congrArg (fun u : unitInterval => (u:ℝ)) h₂
+    apply Subtype.ext
+    dsimp only at h₁' h₂'
+    norm_num at h₁' h₂'
+    linarith
+  · have hh := congrArg (fun u : unitInterval => (u:ℝ)) (hq he)
+    apply Subtype.ext
+    dsimp only at hh
+    linarith
+
+end SLEExactGauge
+
+end
+
+end OAI
diff --git a/lean/OAI/Probability/SLE/Geometry/SimpleSlitConnected.lean b/lean/OAI/Probability/SLE/Geometry/SimpleSlitConnected.lean
new file mode 100644
index 0000000000000000000000000000000000000000..68dd430bf7fbddfb1216555fc846c040ffe28c2e
--- /dev/null
+++ b/lean/OAI/Probability/SLE/Geometry/SimpleSlitConnected.lean
@@ -0,0 +1,53 @@
+import OAI.Probability.SLE.Geometry.HalfPlaneExteriorConnected
+
+namespace OAI
+
+/-! The domain left by an arbitrary finite simple attached arc is
+connected, and its complement is connected and unbounded. These are the
+topological inputs for constructing its normalized conformal charts. -/
+noncomputable section
+open Set Complex Metric
+
+namespace SLEExactGauge
+
+theorem simple_arc_halfPlane_complement_connected
+    (p : C(unitInterval,ℂ)) (hi : Function.Injective p) (h0 : p 0=0)
+    (hH : ∀ t : unitInterval, t ≠ 0 → p t ∈ upperHalfPlane) :
+    IsConnected (upperHalfPlane \ range p) :=
+  halfPlane_complement_connected_of_unbounded_components
+    (isCompact_range p.continuous).isBounded
+    (fun _ hz => simple_arc_halfPlane_component_unbounded p hi h0 hH hz)
+
+theorem attached_arc_domain_complement_preconnected
+    (p : C(unitInterval,ℂ)) (h0 : p 0=0) :
+    IsPreconnected (upperHalfPlane \ range p)ᶜ := by
+  have he : (upperHalfPlane \ range p)ᶜ = {z : ℂ | z.im ≤ 0} ∪ range p := by
+    ext z
+    change (¬ (0 < z.im ∧ z ∉ range p)) ↔ z.im ≤ 0 ∨ z ∈ range p
+    simp only [not_and_or,not_lt,not_not]
+  rw [he]
+  exact (convex_halfSpace_im_le (0:ℝ)).isPreconnected.union 0 (by simp)
+    (by rw [← h0]; exact mem_range_self 0)
+    (isPreconnected_range p.continuous)
+
+theorem attached_arc_domain_complement_unbounded (p : C(unitInterval,ℂ)) :
+    ¬ Bornology.IsBounded (upperHalfPlane \ range p)ᶜ := by
+  intro hb
+  obtain ⟨R,hR,hbound⟩ := hb.subset_ball_lt 0 (0:ℂ)
+  have hz : -((R+1:ℝ):ℂ)*I ∈ (upperHalfPlane \ range p)ᶜ := by
+    intro hz
+    have hi := hz.1
+    change 0 < (-((R+1:ℝ):ℂ)*I).im at hi
+    simp only [mul_im,neg_re,ofReal_re,I_im,neg_im,ofReal_im,I_re,
+      mul_one,neg_zero,mul_zero,add_zero] at hi
+    linarith
+  have hn := hbound hz
+  simp only [mem_ball,dist_zero_right,norm_mul,norm_neg,Complex.norm_real,
+    Real.norm_eq_abs,norm_I,mul_one,abs_of_pos (by linarith : 0 < R+1)] at hn
+  linarith
+
+end SLEExactGauge
+
+end
+
+end OAI