diff --git a/lean/OAI/Probability/SLE/Geometry/SimpleSlitRiemann.lean b/lean/OAI/Probability/SLE/Geometry/SimpleSlitRiemann.lean
new file mode 100644
index 0000000000000000000000000000000000000000..49802be5325e8cf7ecd64e4da7c29a3a1eace6f3
--- /dev/null
+++ b/lean/OAI/Probability/SLE/Geometry/SimpleSlitRiemann.lean
@@ -0,0 +1,44 @@
+import OAI.Probability.SLE.Geometry.SimpleSlitConnected
+import TauCeti.Analysis.Complex.Conformal.SimplyConnected
+
+namespace OAI
+
+/-! Conformal charts for arbitrary finite simple attached arcs, using
+the Riemann mapping theorem and connectedness of the complement. -/
+noncomputable section
+open Set Complex Metric Function
+
+namespace SLEExactGauge
+
+theorem simple_arc_halfPlane_simplyConnected
+    (p : C(unitInterval,ℂ)) (hi : Injective p) (h0 : p 0=0)
+    (hH : ∀ t : unitInterval, t ≠ 0 → p t ∈ upperHalfPlane) :
+    IsSimplyConnected (upperHalfPlane \ range p) := by
+  have ho : IsOpen (upperHalfPlane \ range p) :=
+    isOpen_upperHalfPlane.sdiff (isCompact_range p.continuous).isClosed
+  apply TauCeti.isSimplyConnected_of_filledHull_subset ho
+    (simple_arc_halfPlane_complement_connected p hi h0 hH)
+  exact (TauCeti.filledHull_eq_self (attached_arc_domain_complement_preconnected p h0)
+    (attached_arc_domain_complement_unbounded p)).le
+
+theorem simple_arc_exists_disk_chart
+    (p : C(unitInterval,ℂ)) (hi : Injective p) (h0 : p 0=0)
+    (hH : ∀ t : unitInterval, t ≠ 0 → p t ∈ upperHalfPlane) :
+    ∃ f : ℂ → ℂ, BijOn f (upperHalfPlane \ range p) (ball 0 1) ∧
+      DifferentiableOn ℂ f (upperHalfPlane \ range p) ∧
+      DifferentiableOn ℂ (invFunOn f (upperHalfPlane \ range p)) (ball 0 1) ∧
+      LeftInvOn (invFunOn f (upperHalfPlane \ range p)) f (upperHalfPlane \ range p) ∧
+      RightInvOn (invFunOn f (upperHalfPlane \ range p)) f (ball 0 1) := by
+  have ho : IsOpen (upperHalfPlane \ range p) :=
+    isOpen_upperHalfPlane.sdiff (isCompact_range p.continuous).isClosed
+  apply TauCeti.exists_bijOn_ball_differentiableOn_invFunOn ho
+    (simple_arc_halfPlane_simplyConnected p hi h0 hH)
+  intro he
+  have hz : (0:ℂ) ∈ upperHalfPlane \ range p := by rw [he]; trivial
+  exact (lt_irrefl (0:ℝ)) hz.1
+
+end SLEExactGauge
+
+end
+
+end OAI
diff --git a/lean/OAI/Probability/SLE/Geometry/SingleCrossingObstruction.lean b/lean/OAI/Probability/SLE/Geometry/SingleCrossingObstruction.lean
new file mode 100644
index 0000000000000000000000000000000000000000..b4721f00886fb1a3ea8b87feedf259563645b155
--- /dev/null
+++ b/lean/OAI/Probability/SLE/Geometry/SingleCrossingObstruction.lean
@@ -0,0 +1,137 @@
+import OAI.Probability.SLE.Geometry.LocalLogObstruction
+import OAI.Probability.SLE.Geometry.RectangleLogBoundary
+import Mathlib.Topology.Order.ProjIcc
+
+namespace OAI
+
+/-! The local crossing obstruction in the parameter square. Clamping
+extends the difference map to the plane; the four-side logarithm supplies
+its outer boundary logarithm. -/
+noncomputable section
+open Set Filter Metric Function
+open scoped Topology
+
+namespace SLEExactGauge
+
+def unitClamp (x : ℝ) : unitInterval := projIcc 0 1 zero_le_one x
+
+lemma continuous_unitClamp : Continuous unitClamp := continuous_projIcc (h := zero_le_one)
+
+@[simp] lemma unitClamp_coe (t : unitInterval) : unitClamp (t:ℝ)=t := projIcc_val zero_le_one t
+
+lemma unitClamp_eq_interior {x : ℝ} {t : unitInterval}
+    (ht₀ : 0<(t:ℝ)) (ht₁ : (t:ℝ)<1) (h : unitClamp x=t) : x=(t:ℝ) := by
+  have hx₀ : 0<x := by
+    by_contra hn
+    have he : unitClamp x=0 := projIcc_of_le_left zero_le_one (le_of_not_gt hn)
+    rw [he] at h
+    have hv := congrArg (fun u : unitInterval => (u:ℝ)) h
+    simp only [Set.Icc.coe_zero] at hv
+    linarith
+  have hx₁ : x<1 := by
+    by_contra hn
+    have he : unitClamp x=1 := projIcc_of_right_le zero_le_one (le_of_not_gt hn)
+    rw [he] at h
+    have hv := congrArg (fun u : unitInterval => (u:ℝ)) h
+    simp only [Set.Icc.coe_one] at hv
+    linarith
+  have he : unitClamp x=⟨x,hx₀.le,hx₁.le⟩ := projIcc_of_mem zero_le_one ⟨hx₀.le,hx₁.le⟩
+  rw [he] at h
+  exact congrArg (fun u : unitInterval => (u:ℝ)) h
+
+def crossingSquareParam (z : ℂ) : unitInterval × unitInterval :=
+  (unitClamp z.re,unitClamp z.im)
+
+lemma continuous_crossingSquareParam : Continuous crossingSquareParam :=
+  (continuous_unitClamp.comp Complex.continuous_re).prodMk
+    (continuous_unitClamp.comp Complex.continuous_im)
+
+def crossingSquareMap (c p : C(unitInterval,ℂ)) (z : ℂ) : ℂ :=
+  c (crossingSquareParam z).2-p (crossingSquareParam z).1
+
+lemma continuous_crossingSquareMap (c p : C(unitInterval,ℂ)) : Continuous (crossingSquareMap c p) :=
+  (c.continuous.comp (continuous_crossingSquareParam.snd)).sub
+    (p.continuous.comp (continuous_crossingSquareParam.fst))
+
+lemma crossingSquareMap_zero_iff (c p : C(unitInterval,ℂ))
+    (s t : unitInterval) (hs : 0<(s:ℝ) ∧ (s:ℝ)<1) (ht : 0<(t:ℝ) ∧ (t:ℝ)<1)
+    (hcross : c t=p s) (hu : ∀ u v, c v=p u → u=s ∧ v=t) (z : ℂ) :
+    crossingSquareMap c p z=0 ↔ z=(s:ℂ)+(t:ℂ)*Complex.I := by
+  constructor
+  · intro hz
+    obtain ⟨hre,him⟩ := hu _ _ (sub_eq_zero.mp hz)
+    have hr := unitClamp_eq_interior hs.1 hs.2 hre
+    have hi := unitClamp_eq_interior ht.1 ht.2 him
+    apply Complex.ext <;> simp [hr,hi]
+  · intro hz
+    subst z
+    simp [crossingSquareMap,crossingSquareParam,hcross]
+
+lemma crossingSquareParam_on_outer_circle (s t : unitInterval) (z : ℂ) (hz : ‖z‖=4) :
+    let q := crossingSquareParam (z+((s:ℂ)+(t:ℂ)*Complex.I))
+    q.1=0 ∨ q.1=1 ∨ q.2=0 ∨ q.2=1 := by
+  dsimp only
+  by_contra hn
+  push Not at hn
+  let a := z+((s:ℂ)+(t:ℂ)*Complex.I)
+  let u := unitClamp a.re
+  let v := unitClamp a.im
+  have hu₀ : 0<(u:ℝ) := lt_of_le_of_ne u.property.1 (fun he => hn.1 (Subtype.ext he.symm))
+  have hu₁ : (u:ℝ)<1 := lt_of_le_of_ne u.property.2 (fun he => hn.2.1 (Subtype.ext he))
+  have hv₀ : 0<(v:ℝ) := lt_of_le_of_ne v.property.1 (fun he => hn.2.2.1 (Subtype.ext he.symm))
+  have hv₁ : (v:ℝ)<1 := lt_of_le_of_ne v.property.2 (fun he => hn.2.2.2 (Subtype.ext he))
+  have har := unitClamp_eq_interior hu₀ hu₁ (rfl : unitClamp a.re=u)
+  have hai := unitClamp_eq_interior hv₀ hv₁ (rfl : unitClamp a.im=v)
+  have hre : a.re=z.re+(s:ℝ) := by simp [a]
+  have him : a.im=z.im+(t:ℝ) := by simp [a]
+  have hr : |z.re|<1 := abs_lt.mpr ⟨by linarith [s.property.2],by linarith [s.property.1]⟩
+  have hi : |z.im|<1 := abs_lt.mpr ⟨by linarith [t.property.2],by linarith [t.property.1]⟩
+  have hnorm := Complex.norm_le_abs_re_add_abs_im z
+  linarith
+
+lemma no_single_locally_injective_crossing (c p : C(unitInterval,ℂ))
+    (s t : unitInterval) (hs : 0<(s:ℝ) ∧ (s:ℝ)<1) (ht : 0<(t:ℝ) ∧ (t:ℝ)<1)
+    (hcross : c t=p s) (hu : ∀ u v, c v=p u → u=s ∧ v=t)
+    (hi : ∃ ρ : ℝ, 0<ρ ∧ InjOn (crossingSquareMap c p)
+      (closedBall ((s:ℂ)+(t:ℂ)*Complex.I) ρ))
+    (hloop : c 0=c 1) (hbase : ∀ u, c 0-p u≠0)
+    (L₀ L₁ : C(unitInterval,ℂ))
+    (hL₀ : ∀ u, Complex.exp (L₀ u)=c u-p 0)
+    (hL₁ : ∀ u, Complex.exp (L₁ u)=c u-p 1)
+    (h₀ : L₀ 0=L₀ 1) (h₁ : L₁ 0=L₁ 1) : False := by
+  obtain ⟨K,hK⟩ := rectangle_difference_boundary_log c p hloop hbase L₀ L₁ hL₀ hL₁ h₀ h₁
+  let a := (s:ℂ)+(t:ℂ)*Complex.I
+  let f := fun z : ℂ => crossingSquareMap c p (z+a)
+  have hf : Continuous f := (continuous_crossingSquareMap c p).comp (continuous_id.add continuous_const)
+  have hf0 : f 0=0 := by
+    simpa only [f,zero_add] using (crossingSquareMap_zero_iff c p s t hs ht hcross hu a).mpr rfl
+  have hzero (z : ℂ) : f z=0 → z=0 := by
+    intro hz
+    have he := (crossingSquareMap_zero_iff c p s t hs ht hcross hu (z+a)).mp hz
+    have he' : z+a=0+a := by simpa only [zero_add] using he
+    exact add_right_cancel he'
+  obtain ⟨ρ,hρ,hiρ⟩ := hi
+  let r := min ρ 1
+  have hr : 0<r := lt_min hρ zero_lt_one
+  have hir : InjOn f (closedBall 0 r) := by
+    intro z hz w hw he
+    have hm (z : ℂ) (hz : z∈closedBall 0 r) : z+a∈closedBall a ρ := by
+      simpa only [mem_closedBall,dist_eq_norm,add_sub_cancel_right,sub_zero] using
+        (mem_closedBall_zero_iff.mp hz).trans (min_le_left ρ 1)
+    exact add_right_cancel (hiρ (hm z hz) (hm w hw) he)
+  let L : C(sphere (0:ℂ) 4,ℂ) := K.comp
+    ⟨fun z => crossingSquareParam ((z:ℂ)+a),
+      continuous_crossingSquareParam.comp (continuous_subtype_val.add continuous_const)⟩
+  apply isolated_zero_no_continuous_boundary_log f 4 r (by norm_num) hr
+    ((min_le_right ρ 1).trans (by norm_num)) hf.continuousOn
+    (fun z _ hz => hzero z (by rwa [hf0] at hz)) hir L
+  intro z
+  rw [hf0,sub_zero]
+  exact hK _ (crossingSquareParam_on_outer_circle s t z
+    (by simpa only [mem_sphere,dist_zero_right] using z.property))
+
+end SLEExactGauge
+
+end
+
+end OAI
diff --git a/lean/OAI/Probability/SLE/Geometry/SmallImageSector.lean b/lean/OAI/Probability/SLE/Geometry/SmallImageSector.lean
new file mode 100644
index 0000000000000000000000000000000000000000..b9cff18ac6c9a5780c236d3b8fa30a79d0926fa0
--- /dev/null
+++ b/lean/OAI/Probability/SLE/Geometry/SmallImageSector.lean
@@ -0,0 +1,218 @@
+import OAI.Probability.SLE.Geometry.SmallImageSemicircle
+import OAI.Probability.SLE.AngularLaws
+
+namespace OAI
+
+/-!
+The central-sector extension of `es:good-semicircle`. The already proved
+omitted-value estimate gives a universal constant `4096 * π` in place of the
+sharper constant `6` in the manuscript; this suffices for the splice.
+-/
+
+noncomputable section
+open Set Filter MeasureTheory Metric
+open scoped Topology
+
+namespace SLEExactGauge.SmallImageSemicircle
+
+lemma log_norm_fderiv_le_of_height
+    {F : ℂ → ℂ} (hF : DifferentiableOn ℂ F {z | 0 < z.im})
+    (hi : InjOn F {z | 0 < z.im}) {a : ℂ}
+    (ha : ∀ z, 0 < z.im → F z ≠ a) {b : ℝ} (hb : 0 < b)
+    {w : ℂ} (hw : b ≤ w.im) :
+    DifferentiableAt ℝ (fun z => Real.log ‖F z - a‖) w ∧
+      ‖fderiv ℝ (fun z => Real.log ‖F z - a‖) w‖ ≤ (128 * Real.pi) / b := by
+  have hwH : 0 < w.im := hb.trans_le hw
+  have hball : ball w b ⊆ {z : ℂ | 0 < z.im} := by
+    intro z hz
+    have hdist : ‖z - w‖ < b := mem_ball_iff_norm.mp hz
+    have him := (le_abs_self (w.im - z.im)).trans
+      (by simpa only [Complex.sub_im, abs_sub_comm] using Complex.abs_im_le_norm (z - w))
+    change 0 < z.im
+    linarith
+  have hnot : a ∉ F '' ball w b := by
+    rintro ⟨z, hz, he⟩
+    exact ha z (hball hz) he
+  have hbound := univalent_omitted_value_bound_ball hb (hF.mono hball) (hi.mono hball) a hnot
+  have hFd : DifferentiableAt ℂ F w := hF.differentiableAt
+    ((isOpen_lt continuous_const Complex.continuous_im).mem_nhds hwH)
+  have hn : F w - a ≠ 0 := sub_ne_zero.mpr (ha w hwH)
+  have hnp : 0 < ‖F w - a‖ := norm_pos_iff.mpr hn
+  refine ⟨(((hFd.restrictScalars ℝ).sub_const a).norm ℝ hn).log hnp.ne', ?_⟩
+  have hlog := norm_fderiv_log_norm_div_le hFd a (by norm_num : (0 : ℝ) < 1) hn
+  simp only [div_one] at hlog
+  apply hlog.trans
+  apply (div_le_div_iff₀ hnp hb).mpr
+  nlinarith [hbound]
+
+/-- Uniform comparison with the top of the selected semicircle on the central
+sector. The straight segment stays above height `B/16`. -/
+theorem central_sector_log_bound
+    {F : ℂ → ℂ} (hF : DifferentiableOn ℂ F {z | 0 < z.im})
+    (hi : InjOn F {z | 0 < z.im}) {a : ℂ}
+    (ha : ∀ z, 0 < z.im → F z ≠ a) {B : ℝ} (hB : 0 < B)
+    {z : ℂ} (hzlow : B / 8 ≤ ‖z‖) (hzup : ‖z‖ ≤ B)
+    (hzim : ‖z‖ / 2 ≤ z.im) :
+    Real.log ‖F z - a‖ ≤ Real.log ‖F ((B : ℂ) * Complex.I) - a‖ + 4096 * Real.pi := by
+  let S : Set ℂ := {w | B / 16 ≤ w.im}
+  have hS : Convex ℝ S := by
+    intro x hx y hy s t hs ht hst
+    change B / 16 ≤ (s • x + t • y).im
+    simp only [Complex.add_im, Complex.smul_im, smul_eq_mul]
+    dsimp only [S, Set.mem_ofPred_eq] at hx hy
+    nlinarith [mul_le_mul_of_nonneg_left hx hs, mul_le_mul_of_nonneg_left hy ht]
+  have hzS : z ∈ S := by change B / 16 ≤ z.im; linarith
+  have htopS : (B : ℂ) * Complex.I ∈ S := by
+    change B / 16 ≤ ((B : ℂ) * Complex.I).im
+    simp only [Complex.mul_im, Complex.ofReal_re, Complex.I_im, Complex.ofReal_im,
+      Complex.I_re, mul_one, mul_zero, add_zero]
+    linarith
+  have hlog := Convex.norm_image_sub_le_of_norm_fderiv_le
+    (fun w hw => (log_norm_fderiv_le_of_height hF hi ha (by positivity : 0 < B / 16) hw).1)
+    (fun w hw => (log_norm_fderiv_le_of_height hF hi ha (by positivity : 0 < B / 16) hw).2)
+    hS htopS hzS
+  have hdist : ‖z - (B : ℂ) * Complex.I‖ ≤ 2 * B := by
+    calc
+      ‖z - (B : ℂ) * Complex.I‖ ≤ ‖z‖ + ‖(B : ℂ) * Complex.I‖ := norm_sub_le _ _
+      _ ≤ 2 * B := by
+        simp only [norm_mul, Complex.norm_real, Real.norm_eq_abs, abs_of_pos hB,
+          Complex.norm_I, mul_one]
+        linarith
+  have hnon : 0 ≤ (128 * Real.pi) / (B / 16) := by positivity
+  have hconst : (128 * Real.pi) / (B / 16) * (2 * B) = 4096 * Real.pi := by
+    field_simp
+    ring
+  have hh := hlog.trans (mul_le_mul_of_nonneg_left hdist hnon)
+  rw [hconst, Real.norm_eq_abs] at hh
+  linarith [le_abs_self (Real.log ‖F z - a‖ - Real.log ‖F ((B : ℂ) * Complex.I) - a‖)]
+
+theorem central_sector_norm_bound
+    {F : ℂ → ℂ} (hF : DifferentiableOn ℂ F {z | 0 < z.im})
+    (hi : InjOn F {z | 0 < z.im}) {a : ℂ}
+    (ha : ∀ z, 0 < z.im → F z ≠ a) {B : ℝ} (hB : 0 < B)
+    {z : ℂ} (hzlow : B / 8 ≤ ‖z‖) (hzup : ‖z‖ ≤ B)
+    (hzim : ‖z‖ / 2 ≤ z.im) :
+    ‖F z - a‖ ≤ ‖F ((B : ℂ) * Complex.I) - a‖ * Real.exp (4096 * Real.pi) := by
+  have hzH : 0 < z.im := by linarith
+  have htopH : 0 < ((B : ℂ) * Complex.I).im := by simpa using hB
+  have hnz : 0 < ‖F z - a‖ := norm_pos_iff.mpr (sub_ne_zero.mpr (ha z hzH))
+  have hntop : 0 < ‖F ((B : ℂ) * Complex.I) - a‖ :=
+    norm_pos_iff.mpr (sub_ne_zero.mpr (ha _ htopH))
+  have hh := Real.exp_le_exp.mpr (central_sector_log_bound hF hi ha hB hzlow hzup hzim)
+  simpa only [Real.exp_add, Real.exp_log hnz, Real.exp_log hntop] using hh
+
+/-- Semicircles and their central sectors can be made arbitrarily small in
+parameter space while preserving a uniform image bound. -/
+theorem exists_arbitrarily_small_image_sector
+    {F : ℂ → ℂ} (hF : DifferentiableOn ℂ F {z | 0 < z.im})
+    (hi : InjOn F {z | 0 < z.im}) {a : ℂ}
+    (ha : ∀ z, 0 < z.im → F z ≠ a) {r A t₀ : ℝ} {β : ℝ → ℂ}
+    (hr : 0 < r) (hA : 2 * Real.pi ^ 2 < A)
+    (ht₀ : 0 < t₀) (hβ : ContinuousOn β (Icc 0 t₀)) (hβ₀ : β 0 = 0)
+    (hβH : ∀ t ∈ Ioc 0 t₀, 0 < (β t).im)
+    (hsmall : ∀ t ∈ Ioc 0 t₀, ‖F (β t) - a‖ ≤ r * Real.exp (-A)) :
+    ∀ δ : ℝ, 0 < δ → ∃ B ∈ Ioo 0 δ,
+      (∀ θ ∈ Ioo 0 Real.pi,
+        ‖F ((B : ℂ) * Complex.exp ((θ : ℂ) * Complex.I)) - a‖ ≤
+          r * Real.exp (-A + Real.pi * Real.sqrt (2 * A))) ∧
+      ∀ z : ℂ, B / 8 ≤ ‖z‖ → ‖z‖ ≤ B → ‖z‖ / 2 ≤ z.im →
+        ‖F z - a‖ ≤ r * Real.exp (-A + Real.pi * Real.sqrt (2 * A) + 4096 * Real.pi) := by
+  intro δ hδ
+  obtain ⟨B, hB, hcircle⟩ := exists_arbitrarily_small_image_semicircle hF hi ha hr hA
+    ht₀ hβ hβ₀ hβH hsmall δ hδ
+  refine ⟨B, hB, hcircle, ?_⟩
+  intro z hzlow hzup hzim
+  have htop := hcircle (Real.pi / 2) ⟨by positivity, by linarith [Real.pi_pos]⟩
+  simp only [Complex.ofReal_div, Complex.ofReal_ofNat, Complex.exp_pi_div_two_mul_I] at htop
+  calc
+    ‖F z - a‖ ≤ ‖F ((B : ℂ) * Complex.I) - a‖ * Real.exp (4096 * Real.pi) :=
+      central_sector_norm_bound hF hi ha hB.1 hzlow hzup hzim
+    _ ≤ (r * Real.exp (-A + Real.pi * Real.sqrt (2 * A))) * Real.exp (4096 * Real.pi) :=
+      mul_le_mul_of_nonneg_right htop (Real.exp_pos _).le
+    _ = _ := by simp only [Real.exp_add, mul_assoc]
+
+lemma sector_exponential_lt_quarter {A : ℝ} (hA : 65536 ≤ A) :
+    Real.exp (-A + Real.pi * Real.sqrt (2 * A) + 4096 * Real.pi) < 1 / 4 := by
+  have hApos : 0 < A := lt_of_lt_of_le (by norm_num) hA
+  have hsqrt : Real.sqrt (2 * A) ≤ A / 8 := by
+    apply (sq_le_sq₀ (Real.sqrt_nonneg _) (by positivity)).mp
+    rw [Real.sq_sqrt (by positivity)]
+    nlinarith [mul_nonneg (show 0 ≤ A by positivity) (show 0 ≤ A - 128 by linarith)]
+  have hpi : Real.pi * Real.sqrt (2 * A) ≤ 4 * (A / 8) :=
+    mul_le_mul Real.pi_lt_four.le hsqrt (Real.sqrt_nonneg _) (by norm_num)
+  have hexp : -A + Real.pi * Real.sqrt (2 * A) + 4096 * Real.pi < -3 := by
+    linarith [Real.pi_lt_four]
+  have hthree : (4 : ℝ) < Real.exp 3 := by
+    have hh := Real.add_one_lt_exp (show (3 : ℝ) ≠ 0 by norm_num)
+    norm_num only at hh
+    exact hh
+  calc
+    _ < Real.exp (-3) := Real.exp_lt_exp.mpr hexp
+    _ < 1 / 4 := by
+      rw [Real.exp_neg, ← one_div]
+      exact one_div_lt_one_div_of_lt (by norm_num) hthree
+
+/-- A fixed sufficiently deep guide segment provides the small semicircle
+and central sector used to splice the initial passage. -/
+theorem exists_arbitrarily_small_quarter_image_sector
+    {F : ℂ → ℂ} (hF : DifferentiableOn ℂ F {z | 0 < z.im})
+    (hi : InjOn F {z | 0 < z.im}) {a : ℂ}
+    (ha : ∀ z, 0 < z.im → F z ≠ a) {r t₀ : ℝ} {β : ℝ → ℂ}
+    (hr : 0 < r) (ht₀ : 0 < t₀) (hβ : ContinuousOn β (Icc 0 t₀)) (hβ₀ : β 0 = 0)
+    (hβH : ∀ t ∈ Ioc 0 t₀, 0 < (β t).im)
+    (hsmall : ∀ t ∈ Ioc 0 t₀, ‖F (β t) - a‖ ≤ r * Real.exp (-65536)) :
+    ∀ δ : ℝ, 0 < δ → ∃ B ∈ Ioo 0 δ,
+      (∀ θ ∈ Ioo 0 Real.pi,
+        ‖F ((B : ℂ) * Complex.exp ((θ : ℂ) * Complex.I)) - a‖ < r / 4) ∧
+      ∀ z : ℂ, B / 8 ≤ ‖z‖ → ‖z‖ ≤ B → ‖z‖ / 2 ≤ z.im → ‖F z - a‖ < r / 4 := by
+  have hA : 2 * Real.pi ^ 2 < (65536 : ℝ) := by
+    nlinarith [Real.pi_pos, Real.pi_lt_four]
+  intro δ hδ
+  obtain ⟨B, hB, hcircle, hsector⟩ := exists_arbitrarily_small_image_sector hF hi ha hr hA
+    ht₀ hβ hβ₀ hβH hsmall δ hδ
+  have hc := semicircle_exponential_lt_quarter (A := 65536) (by norm_num)
+  have hs := sector_exponential_lt_quarter (A := 65536) (by norm_num)
+  refine ⟨B, hB, ?_, ?_⟩
+  · intro θ hθ
+    have hle := hcircle θ hθ
+    have he : Real.exp (-(65536 : ℝ) + Real.pi * Real.sqrt (2 * 65536)) < 1 / 4 :=
+      (Real.exp_le_exp.mpr (by norm_num)).trans_lt hc
+    exact hle.trans_lt (by simpa only [div_eq_mul_inv, one_mul] using mul_lt_mul_of_pos_left he hr)
+  · intro z hzlow hzup hzim
+    exact (hsector z hzlow hzup hzim).trans_lt
+      (by simpa only [div_eq_mul_inv, one_mul] using mul_lt_mul_of_pos_left hs hr)
+
+/-- Full access-guide formulation: convergence to the omitted boundary value
+itself supplies the initial short segment needed above. -/
+theorem access_guide_has_arbitrarily_small_quarter_image_sector
+    {F : ℂ → ℂ} (hF : DifferentiableOn ℂ F {z | 0 < z.im})
+    (hi : InjOn F {z | 0 < z.im}) {a : ℂ}
+    (ha : ∀ z, 0 < z.im → F z ≠ a) {r T : ℝ} {β : ℝ → ℂ}
+    (hr : 0 < r) (hT : 0 < T) (hβ : ContinuousOn β (Icc 0 T)) (hβ₀ : β 0 = 0)
+    (hβH : ∀ t ∈ Ioc 0 T, 0 < (β t).im)
+    (hlimit : Tendsto (F ∘ β) (𝓝[>] 0) (𝓝 a)) :
+    ∀ δ : ℝ, 0 < δ → ∃ B ∈ Ioo 0 δ,
+      (∀ θ ∈ Ioo 0 Real.pi,
+        ‖F ((B : ℂ) * Complex.exp ((θ : ℂ) * Complex.I)) - a‖ < r / 4) ∧
+      ∀ z : ℂ, B / 8 ≤ ‖z‖ → ‖z‖ ≤ B → ‖z‖ / 2 ≤ z.im → ‖F z - a‖ < r / 4 := by
+  have hε : 0 < r * Real.exp (-65536) := mul_pos hr (Real.exp_pos _)
+  obtain ⟨d, hd, hdbound⟩ := Metric.tendsto_nhdsWithin_nhds.mp hlimit _ hε
+  let t₀ := min T (d / 2)
+  have ht₀ : 0 < t₀ := lt_min hT (by positivity)
+  have ht₀T : t₀ ≤ T := min_le_left _ _
+  have hsmall : ∀ t ∈ Ioc 0 t₀, ‖F (β t) - a‖ ≤ r * Real.exp (-65536) := by
+    intro t ht
+    apply le_of_lt
+    have htd : dist t 0 < d := by
+      rw [Real.dist_eq, sub_zero, abs_of_pos ht.1]
+      exact (ht.2.trans (min_le_right _ _)).trans_lt (by linarith)
+    simpa only [Function.comp_apply, dist_eq_norm] using hdbound ht.1 htd
+  exact exists_arbitrarily_small_quarter_image_sector hF hi ha hr ht₀
+    (hβ.mono (Icc_subset_Icc_right ht₀T)) hβ₀
+    (fun t ht => hβH t ⟨ht.1, ht.2.trans ht₀T⟩) hsmall
+
+end SLEExactGauge.SmallImageSemicircle
+
+end
+
+end OAI
diff --git a/lean/OAI/Probability/SLE/Geometry/SmallImageSemicircle.lean b/lean/OAI/Probability/SLE/Geometry/SmallImageSemicircle.lean
new file mode 100644
index 0000000000000000000000000000000000000000..12a1c4717e7be0a0a345f919b45008695277381b
--- /dev/null
+++ b/lean/OAI/Probability/SLE/Geometry/SmallImageSemicircle.lean
@@ -0,0 +1,392 @@
+import OAI.Probability.SLE.DyadicStrips
+
+namespace OAI
+
+/-!
+Angular Sobolev estimates for the small-image semicircle lemma
+`es:good-semicircle`. In particular, the absolute continuity used below is
+proved for the actual clipped conformal logarithm.
+-/
+
+noncomputable section
+open Set Filter MeasureTheory Metric
+open scoped Topology ENNReal NNReal
+
+namespace SLEExactGauge.SmallImageSemicircle
+
+lemma integral_abs_le_angular_energy {g : ℝ → ℝ}
+    (hg : MemLp g 2 (volume.restrict (Ioo 0 Real.pi))) :
+    (∫ θ in Ioo 0 Real.pi, |g θ|) ≤
+      Real.sqrt Real.pi * Real.sqrt (∫ θ in Ioo 0 Real.pi, (g θ) ^ 2) := by
+  have h1 : MemLp (fun _ : ℝ => (1 : ℝ)) 2 (volume.restrict (Ioo 0 Real.pi)) :=
+    memLp_const 1
+  have h := integral_mul_le_Lp_mul_Lq_of_nonneg Real.HolderConjugate.two_two
+    (ae_of_all _ (fun θ => norm_nonneg (g θ))) (ae_of_all _ (fun _ => zero_le_one))
+    (by simpa using hg.norm) (by simpa using h1)
+  simpa only [mul_one, Real.rpow_two, one_pow, Real.norm_eq_abs, sq_abs,
+    integral_const, smul_eq_mul, mul_one, one_mul, Measure.real, Measure.restrict_apply_univ,
+    Real.volume_Ioo, sub_zero,
+    ENNReal.toReal_ofReal Real.pi_pos.le, Real.sqrt_eq_rpow, mul_comm] using h
+
+/-- A section which is absolutely continuous on compact subintervals has
+oscillation controlled by its full angular derivative energy. -/
+theorem angular_oscillation_bound {f : ℝ → ℝ} {x y : ℝ}
+    (hx : x ∈ Ioo 0 Real.pi) (hy : y ∈ Ioo 0 Real.pi)
+    (hf : AbsolutelyContinuousOnInterval f x y)
+    (hderiv : 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θ
+    have hθ' := uIoc_subset_uIcc hθ
+    exact ordConnected_Ioo.uIcc_subset hx hy hθ'
+  have hi : IntegrableOn (fun θ => |deriv f θ|) (Ioo 0 Real.pi) := by
+    simpa only [IntegrableOn, Real.norm_eq_abs] using (hderiv.integrable (by norm_num)).norm
+  calc
+    |f y - f x| = ‖∫ θ in x..y, deriv f θ‖ := by
+      rw [hf.integral_deriv_eq_sub, Real.norm_eq_abs]
+    _ ≤ ∫ θ in uIoc x y, |deriv f θ| := by
+      simpa only [Real.norm_eq_abs] using
+        (intervalIntegral.norm_integral_le_integral_norm_uIoc (f := deriv f) (a := x) (b := y))
+    _ ≤ ∫ θ in Ioo 0 Real.pi, |deriv f θ| :=
+      setIntegral_mono_set hi (ae_of_all _ (fun θ => abs_nonneg (deriv f θ)))
+        hsub.eventuallySubset
+    _ ≤ _ := integral_abs_le_angular_energy hderiv
+
+theorem anchored_angular_bound {f : ℝ → ℝ} {θ₀ : ℝ}
+    (hθ₀ : θ₀ ∈ Ioo 0 Real.pi) (hzero : f θ₀ = 0)
+    (hac : ∀ θ ∈ Ioo 0 Real.pi, AbsolutelyContinuousOnInterval f θ₀ θ)
+    (hderiv : MemLp (deriv f) 2 (volume.restrict (Ioo 0 Real.pi))) :
+    ∀ θ ∈ Ioo 0 Real.pi, |f θ| ≤ Real.sqrt Real.pi *
+      Real.sqrt (∫ φ in Ioo 0 Real.pi, (deriv f φ) ^ 2) := by
+  intro θ hθ
+  simpa only [hzero, sub_zero] using angular_oscillation_bound hθ₀ hθ (hac θ hθ) hderiv
+
+/-- The exact angular constant in the manuscript. -/
+theorem anchored_angular_bound_of_energy {f : ℝ → ℝ} {θ₀ H : ℝ}
+    (hH : 0 ≤ H) (hθ₀ : θ₀ ∈ Ioo 0 Real.pi) (hzero : f θ₀ = 0)
+    (hac : ∀ θ ∈ Ioo 0 Real.pi, AbsolutelyContinuousOnInterval f θ₀ θ)
+    (hderiv : MemLp (deriv f) 2 (volume.restrict (Ioo 0 Real.pi)))
+    (henergy : (∫ φ in Ioo 0 Real.pi, (deriv f φ) ^ 2) ≤ 2 * Real.pi * H) :
+    ∀ θ ∈ Ioo 0 Real.pi, f θ ≤ Real.pi * Real.sqrt (2 * H) := by
+  intro θ hθ
+  have h := anchored_angular_bound hθ₀ hzero hac hderiv θ hθ
+  have hE : 0 ≤ ∫ φ in Ioo 0 Real.pi, (deriv f φ) ^ 2 :=
+    integral_nonneg (fun _ => sq_nonneg _)
+  have hs := sq_le_sq₀ (abs_nonneg (f θ)) (by positivity) |>.mpr h
+  rw [mul_pow, Real.sq_sqrt Real.pi_pos.le, Real.sq_sqrt hE] at hs
+  have hr : (Real.pi * Real.sqrt (2 * H)) ^ 2 = Real.pi ^ 2 * (2 * H) := by
+    rw [mul_pow, Real.sq_sqrt (by positivity)]
+  have hsq : |f θ| ^ 2 ≤ (Real.pi * Real.sqrt (2 * H)) ^ 2 := by
+    rw [hr]
+    nlinarith [mul_le_mul_of_nonneg_left henergy Real.pi_pos.le]
+  exact (le_abs_self _).trans ((sq_le_sq₀ (abs_nonneg _) (by positivity)).mp hsq)
+
+def stripPoint (v θ : ℝ) : ℂ := (v : ℂ) + (θ : ℂ) * Complex.I
+
+lemma stripPoint_mem {v θ : ℝ} (hθ : θ ∈ Ioo 0 Real.pi) :
+    stripPoint v θ ∈ {z : ℂ | 0 < z.im ∧ z.im < Real.pi} := by
+  simpa only [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, Set.mem_ofPred_eq, Set.mem_Ioo] using hθ
+
+/-- Compact angular sections of the actual conformal logarithm are
+absolutely continuous. The omitted point removes the logarithmic singularity. -/
+theorem conformal_section_absolutelyContinuous
+    {F : ℂ → ℂ} (hF : DifferentiableOn ℂ F {z | 0 < z.im})
+    {a : ℂ} (ha : ∀ z, 0 < z.im → F z ≠ a)
+    {r : ℝ} (hr : 0 < r) (H v : ℝ) {x y : ℝ}
+    (hx : x ∈ Ioo 0 Real.pi) (hy : y ∈ Ioo 0 Real.pi) :
+    AbsolutelyContinuousOnInterval
+      (fun θ => conformalStripLog F a r H (stripPoint v θ)) x y := by
+  let g : ℝ → ℝ := fun θ => Real.log (‖F (Complex.exp (stripPoint v θ)) - a‖ / r)
+  have hgd : ContDiffOn ℝ 1 g (uIcc x y) := by
+    intro θ hθ
+    have hθ' : θ ∈ Ioo 0 Real.pi := ordConnected_Ioo.uIcc_subset hx hy hθ
+    have hz := exp_strip_halfplane (stripPoint_mem (v := v) hθ')
+    have hFo : ContDiffAt ℝ 1 F (Complex.exp (stripPoint v θ)) :=
+      ((hF.analyticAt (isOpen_lt continuous_const Complex.continuous_im |>.mem_nhds hz)).restrictScalars
+        (𝕜 := ℝ)).contDiffAt
+    have hpt : ContDiffAt ℝ 1 (fun t => Complex.exp (stripPoint v t)) θ := by
+      dsimp only [stripPoint]
+      have hcast : ContDiffAt ℝ 1 (fun t : ℝ => (t : ℂ)) θ :=
+        Complex.ofRealCLM.contDiff.contDiffAt
+      fun_prop
+    have hnonzero := sub_ne_zero.mpr (ha _ hz)
+    exact ((((hFo.comp θ hpt).sub contDiffAt_const).norm ℝ hnonzero).div_const r).log
+      (div_ne_zero (norm_ne_zero_iff.mpr hnonzero) hr.ne') |>.contDiffWithinAt
+  obtain ⟨K, hK⟩ := hgd.exists_lipschitzOnWith (by norm_num) (convex_uIcc x y) isCompact_uIcc
+  exact ((lipschitz_clip H).comp_lipschitzOnWith hK).absolutelyContinuousOnInterval
+
+lemma angular_deriv_le_gradient {u : ℂ → ℝ} {v θ : ℝ}
+    (hu : DifferentiableAt ℝ u (stripPoint v θ)) :
+    |deriv (fun t => u (stripPoint v t)) θ| ≤ ‖gradient u (stripPoint v θ)‖ := by
+  have hp : HasDerivAt (stripPoint v) Complex.I θ := by
+    change HasDerivAt (fun t : ℝ => (v : ℂ) + (t : ℂ) * Complex.I) Complex.I θ
+    simpa [stripPoint] using
+      ((Complex.ofRealCLM.hasDerivAt (x := θ)).mul_const Complex.I).const_add (v : ℂ)
+  change |deriv (u ∘ stripPoint v) θ| ≤ _
+  rw [(hu.hasFDerivAt.comp_hasDerivAt θ hp).deriv, ← real_gradient_im]
+  exact Complex.abs_im_le_norm _
+
+/-- A unit logarithmic slab contains a section whose full angular energy
+is at most the total strip energy. Differentiability is required only almost
+everywhere, as supplied by the locally Lipschitz conformal logarithm. -/
+theorem exists_section_of_strip_energy
+    (u : ℂ → ℝ) (q : ℝ)
+    (hg : MemLp (gradient u) 2
+      (volume.restrict {z : ℂ | 0 < z.im ∧ z.im < Real.pi}))
+    (hd : ∀ᵐ z ∂volume, z ∈ {z : ℂ | 0 < z.im ∧ z.im < Real.pi} →
+      DifferentiableAt ℝ u z) :
+    ∃ v ∈ Ioo q (q + 1),
+      MemLp (deriv (fun θ => u (stripPoint v θ))) 2 (volume.restrict (Ioo 0 Real.pi)) ∧
+      (∫ θ in Ioo 0 Real.pi, (deriv (fun t => u (stripPoint v t)) θ) ^ 2) ≤
+        ∫ z in {z : ℂ | 0 < z.im ∧ z.im < Real.pi}, ‖gradient u z‖ ^ 2 := by
+  let J := Ioo q (q + 1)
+  let K := Ioo 0 Real.pi
+  let S := {z : ℂ | 0 < z.im ∧ z.im < Real.pi}
+  let T := {z : ℂ | q < z.re ∧ z.re < q + 1 ∧ 0 < z.im ∧ z.im < Real.pi}
+  let e := Complex.measurableEquivRealProd.symm
+  have he : MeasurePreserving e volume volume := Complex.volume_preserving_equiv_real_prod.symm _
+  have hpre : e ⁻¹' T = J ×ˢ K := by
+    ext z
+    simp [e, T, J, K, and_assoc]
+  have hTS : T ⊆ S := fun _ hz => hz.2.2
+  have hiS : IntegrableOn (fun z => ‖gradient u z‖ ^ 2) S := hg.norm.integrable_sq
+  have hiT := hiS.mono_set hTS
+  have hip : Integrable (fun z : ℝ × ℝ => ‖gradient u (e z)‖ ^ 2)
+      ((volume.restrict J).prod (volume.restrict K)) := by
+    rw [Measure.prod_restrict]
+    exact hpre ▸ (he.integrableOn_comp_preimage e.measurableEmbedding).mpr hiT
+  have heq : (∫ v in J, ∫ θ in K, ‖gradient u (e (v, θ))‖ ^ 2) =
+      ∫ z in T, ‖gradient u z‖ ^ 2 := by
+    rw [← integral_prod _ hip, Measure.prod_restrict, ← hpre]
+    simpa only [Measure.volume_eq_prod] using
+      he.setIntegral_preimage_emb e.measurableEmbedding (fun z => ‖gradient u z‖ ^ 2) T
+  have hep : (∫ v in J, ∫ θ in K, ‖gradient u (e (v, θ))‖ ^ 2) ≤
+      ∫ z in S, ‖gradient u z‖ ^ 2 := by
+    rw [heq]
+    exact setIntegral_mono_set hiS (ae_of_all _ (fun _ => sq_nonneg _)) hTS.eventuallySubset
+  have had : ∀ᵐ v ∂volume.restrict J, ∀ᵐ θ ∂volume.restrict K,
+      DifferentiableAt ℝ u (e (v, θ)) := by
+    have hdp : ∀ᵐ z ∂(volume : Measure (ℝ × ℝ)), e z ∈ S → DifferentiableAt ℝ u (e z) :=
+      ae_of_ae_map he.measurable.aemeasurable (he.map_eq.symm ▸ hd)
+    have hdr := ae_restrict_of_ae (s := J ×ˢ K) hdp
+    rw [Measure.volume_eq_prod, ← Measure.prod_restrict] at hdr
+    filter_upwards [Measure.ae_ae_of_ae_prod hdr] with v hv
+    filter_upwards [hv, ae_restrict_mem measurableSet_Ioo] with θ hθ hθK
+    exact hθ hθK
+  let energy (v : ℝ) := ∫ θ in K, ‖gradient u (e (v, θ))‖ ^ 2
+  have hei : Integrable energy (volume.restrict J) := hip.integral_prod_left
+  have hgood : ∀ᵐ v ∂volume.restrict J,
+      v ∈ J ∧ Integrable (fun θ => ‖gradient u (e (v, θ))‖ ^ 2) (volume.restrict K) ∧
+        ∀ᵐ θ ∂volume.restrict K, DifferentiableAt ℝ u (e (v, θ)) := by
+    filter_upwards [ae_restrict_mem measurableSet_Ioo, hip.prod_right_ae, had] with v hv hi hdv
+    exact ⟨hv, hi, hdv⟩
+  have hprob : IsProbabilityMeasure (volume.restrict J) := by
+    constructor
+    simp [J, Real.volume_Ioo]
+  let := hprob
+  let Good (v : ℝ) := v ∈ J ∧
+    Integrable (fun θ => ‖gradient u (e (v, θ))‖ ^ 2) (volume.restrict K) ∧
+      ∀ᵐ θ ∂volume.restrict K, DifferentiableAt ℝ u (e (v, θ))
+  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
+  obtain ⟨hvJ, hvI, hvD⟩ := hv'
+  have hbound : ∀ᵐ θ ∂volume.restrict K,
+      |deriv (fun t => u (stripPoint v t)) θ| ≤ ‖gradient u (e (v, θ))‖ := by
+    filter_upwards [hvD] with θ hθ
+    have hepoint : e (v, θ) = stripPoint v θ := by
+      apply Complex.ext <;> simp [e, stripPoint]
+    simpa only [hepoint] using angular_deriv_le_gradient (hepoint ▸ hθ)
+  have hdi : Integrable (fun θ => (deriv (fun t => u (stripPoint v t)) θ) ^ 2)
+      (volume.restrict K) := by
+    apply hvI.mono' ((aestronglyMeasurable_deriv _ _).pow 2)
+    filter_upwards [hbound] with θ hθ
+    rw [Real.norm_eq_abs, abs_of_nonneg (sq_nonneg _)]
+    simpa only [sq_abs, Pi.pow_apply] using
+      (sq_le_sq₀ (abs_nonneg _) (norm_nonneg _)).mpr hθ
+  refine ⟨v, hvJ, ?_, ?_⟩
+  · exact (memLp_two_iff_integrable_sq_norm (aestronglyMeasurable_deriv _ _)).mpr
+      (by simpa only [Real.norm_eq_abs, sq_abs] using hdi)
+  · apply (integral_mono_ae hdi hvI ?_).trans (hve.trans hep)
+    filter_upwards [hbound] with θ hθ
+    simpa only [sq_abs] using
+      (sq_le_sq₀ (abs_nonneg _) (norm_nonneg _)).mpr hθ
+
+/-- The guide crosses every smaller semicircle, supplying the anchor required
+by the angular Sobolev estimate. -/
+theorem access_segment_section_anchor
+    {F : ℂ → ℂ} {a : ℂ} {r t₀ : ℝ} {β : ℝ → ℂ}
+    (ht₀ : 0 < t₀) (hβ : ContinuousOn β (Icc 0 t₀)) (hβ₀ : β 0 = 0)
+    (hβH : ∀ t ∈ Ioc 0 t₀, 0 < (β t).im)
+    (hsmall : ∀ t ∈ Ioc 0 t₀, ‖F (β t) - a‖ ≤ r)
+    {v : ℝ} (hv : v < Real.log ‖β t₀‖) :
+    ∃ θ ∈ Ioo 0 Real.pi, ‖F (Complex.exp (stripPoint v θ)) - a‖ ≤ r := by
+  have hbH := hβH t₀ ⟨ht₀, le_rfl⟩
+  have hbne : β t₀ ≠ 0 := by intro h; simp [h] at hbH
+  have hbpos : 0 < ‖β t₀‖ := norm_pos_iff.mpr hbne
+  have hB : Real.exp v < ‖β t₀‖ := by
+    simpa only [Real.exp_log hbpos] using Real.exp_lt_exp.mpr hv
+  obtain ⟨t, ht, htnorm⟩ := intermediate_value_Icc ht₀.le hβ.norm
+    (show Real.exp v ∈ Icc ‖β 0‖ ‖β t₀‖ by
+      simpa only [hβ₀, norm_zero, Set.mem_Icc] using And.intro (Real.exp_pos v).le hB.le)
+  change ‖β t‖ = Real.exp v at htnorm
+  have htpos : 0 < t := by
+    by_contra hn
+    have heq : t = 0 := le_antisymm (le_of_not_gt hn) ht.1
+    rw [heq, hβ₀, norm_zero] at htnorm
+    exact (Real.exp_pos v).ne' htnorm.symm
+  have htH := hβH t ⟨htpos, ht.2⟩
+  have htne : β t ≠ 0 := by intro h; simp [h] at htH
+  have harg : (β t).arg ∈ Ioo 0 Real.pi := by
+    refine ⟨lt_of_le_of_ne (Complex.arg_nonneg_iff.mpr htH.le) ?_,
+      Complex.arg_lt_pi_iff.mpr (Or.inr htH.ne')⟩
+    intro heq
+    exact htH.ne' (Complex.arg_eq_zero_iff.mp heq.symm).2
+  have hlog : Complex.log (β t) = stripPoint v (β t).arg := by
+    apply Complex.ext <;> simp [stripPoint, Complex.log_re, Complex.log_im, htnorm]
+  refine ⟨(β t).arg, harg, ?_⟩
+  rw [← hlog, Complex.exp_log htne]
+  exact hsmall t ⟨htpos, ht.2⟩
+
+/-- The exact semicircle estimate before writing the base radius as
+`r * exp (-A)`. The section anchor is a direct consequence of an access guide,
+as proved above. -/
+theorem exists_small_image_semicircle_of_anchors
+    {F : ℂ → ℂ} (hF : DifferentiableOn ℂ F {z | 0 < z.im})
+    (hi : InjOn F {z | 0 < z.im}) {a : ℂ}
+    (ha : ∀ z, 0 < z.im → F z ≠ a) {r A q : ℝ}
+    (hr : 0 < r) (hA : 2 * Real.pi ^ 2 < A)
+    (hanchor : ∀ v ∈ Ioo q (q + 1),
+      ∃ θ ∈ Ioo 0 Real.pi, ‖F (Complex.exp (stripPoint v θ)) - a‖ ≤ r) :
+    ∃ B ∈ Ioo (Real.exp q) (Real.exp (q + 1)),
+      ∀ θ ∈ Ioo 0 Real.pi,
+        ‖F ((B : ℂ) * Complex.exp ((θ : ℂ) * Complex.I)) - a‖ ≤
+          r * Real.exp (Real.pi * Real.sqrt (2 * A)) := by
+  have hApos : 0 < A := (by positivity : 0 < 2 * Real.pi ^ 2).trans hA
+  let u := conformalStripLog F a r A
+  have hD : 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 hcomp : DifferentiableOn ℂ (F ∘ Complex.exp)
+      {z : ℂ | 0 < z.im ∧ z.im < Real.pi} :=
+    hF.comp Complex.differentiable_exp.differentiableOn exp_strip_halfplane
+  have hd : ∀ᵐ z ∂volume, z ∈ {z : ℂ | 0 < z.im ∧ z.im < Real.pi} →
+      DifferentiableAt ℝ u z :=
+    truncated_log_ae_differentiable hD hcomp a r A hr hApos
+  obtain ⟨hg, he, -⟩ := conformal_strip_total_energy hF hi a r A hr hApos
+  obtain ⟨v, hv, hvd, hve⟩ := exists_section_of_strip_energy u q hg hd
+  obtain ⟨θ₀, hθ₀, hzero⟩ := hanchor v hv
+  have hz : u (stripPoint v θ₀) = 0 :=
+    truncatedConformalLog_eq_zero (F := F ∘ Complex.exp) hr hApos.le hzero
+  have hbound := anchored_angular_bound_of_energy hApos.le hθ₀ hz
+    (fun θ hθ => conformal_section_absolutelyContinuous hF ha hr A v hθ₀ hθ)
+    hvd (hve.trans he)
+  have hstrict : Real.pi * Real.sqrt (2 * A) < A := by
+    have hs := Real.sq_sqrt (show 0 ≤ 2 * A by positivity)
+    have hsq : (Real.pi * Real.sqrt (2 * A)) ^ 2 < A ^ 2 := by
+      rw [mul_pow, hs]
+      nlinarith [mul_lt_mul_of_pos_right hA hApos]
+    exact (sq_lt_sq₀ (by positivity) hApos.le).mp hsq
+  refine ⟨Real.exp v, ⟨Real.exp_lt_exp.mpr hv.1, Real.exp_lt_exp.mpr hv.2⟩, ?_⟩
+  intro θ hθ
+  have hb := hbound θ hθ
+  have hlog : Real.log (‖F (Complex.exp (stripPoint v θ)) - a‖ / r) ≤
+      Real.pi * Real.sqrt (2 * A) := by
+    change min A (max 0 (Real.log (‖F (Complex.exp (stripPoint v θ)) - a‖ / r))) ≤ _ at hb
+    have hmax : max 0 (Real.log (‖F (Complex.exp (stripPoint v θ)) - a‖ / r)) < A := by
+      by_contra hn
+      rw [min_eq_left (le_of_not_gt hn)] at hb
+      exact (not_le_of_gt hstrict) hb
+    rw [min_eq_right hmax.le] at hb
+    exact (le_max_right _ _).trans hb
+  have hn : 0 < ‖F (Complex.exp (stripPoint v θ)) - a‖ :=
+    norm_pos_iff.mpr (sub_ne_zero.mpr (ha _ (exp_strip_halfplane (stripPoint_mem hθ))))
+  have hnorm := Real.exp_le_exp.mpr hlog
+  rw [Real.exp_log (div_pos hn hr)] at hnorm
+  have hnorm' := (div_le_iff₀ hr).mp hnorm
+  simpa only [stripPoint, Complex.exp_add, Complex.ofReal_exp, mul_comm] using hnorm'
+
+/-- `es:good-semicircle`, with the initial short guide segment appearing
+explicitly. This proves the manuscript's bound in every unit logarithmic slab
+below the segment's terminal radius. -/
+theorem exists_small_image_semicircle
+    {F : ℂ → ℂ} (hF : DifferentiableOn ℂ F {z | 0 < z.im})
+    (hi : InjOn F {z | 0 < z.im}) {a : ℂ}
+    (ha : ∀ z, 0 < z.im → F z ≠ a) {r A q t₀ : ℝ} {β : ℝ → ℂ}
+    (hr : 0 < r) (hA : 2 * Real.pi ^ 2 < A)
+    (ht₀ : 0 < t₀) (hβ : ContinuousOn β (Icc 0 t₀)) (hβ₀ : β 0 = 0)
+    (hβH : ∀ t ∈ Ioc 0 t₀, 0 < (β t).im)
+    (hsmall : ∀ t ∈ Ioc 0 t₀, ‖F (β t) - a‖ ≤ r * Real.exp (-A))
+    (hq : q + 1 ≤ Real.log ‖β t₀‖) :
+    ∃ B ∈ Ioo (Real.exp q) (Real.exp (q + 1)),
+      ∀ θ ∈ Ioo 0 Real.pi,
+        ‖F ((B : ℂ) * Complex.exp ((θ : ℂ) * Complex.I)) - a‖ ≤
+          r * Real.exp (-A + Real.pi * Real.sqrt (2 * A)) := by
+  obtain ⟨B, hB, hbound⟩ := exists_small_image_semicircle_of_anchors hF hi ha
+    (mul_pos hr (Real.exp_pos _)) hA (fun v hv =>
+      access_segment_section_anchor ht₀ hβ hβ₀ hβH hsmall (hv.2.trans_le hq))
+  refine ⟨B, hB, ?_⟩
+  intro θ hθ
+  simpa only [Real.exp_add, mul_assoc] using hbound θ hθ
+
+/-- The numerical choice used after the semicircle and sector estimates. -/
+lemma semicircle_exponential_lt_quarter {A : ℝ} (hA : 64 ≤ A) :
+    Real.exp (-A + Real.pi * Real.sqrt (2 * A) + 6) < 1 / 4 := by
+  have hApos : 0 < A := lt_of_lt_of_le (by norm_num) hA
+  have hsqrt : Real.sqrt (2 * A) ≤ A / 5 := by
+    apply (sq_le_sq₀ (Real.sqrt_nonneg _) (by positivity)).mp
+    rw [Real.sq_sqrt (by positivity)]
+    nlinarith [mul_nonneg (show 0 ≤ A by positivity) (show 0 ≤ A - 50 by linarith)]
+  have hpi : Real.pi * Real.sqrt (2 * A) ≤ 4 * (A / 5) :=
+    mul_le_mul Real.pi_lt_four.le hsqrt (Real.sqrt_nonneg _) (by norm_num)
+  have hexp : -A + Real.pi * Real.sqrt (2 * A) + 6 < -3 := by linarith
+  have hthree : (4 : ℝ) < Real.exp 3 := by
+    have hh := Real.add_one_lt_exp (show (3 : ℝ) ≠ 0 by norm_num)
+    norm_num only at hh
+    exact hh
+  calc
+    Real.exp (-A + Real.pi * Real.sqrt (2 * A) + 6) < Real.exp (-3) :=
+      Real.exp_lt_exp.mpr hexp
+    _ < 1 / 4 := by
+      rw [Real.exp_neg, ← one_div]
+      exact one_div_lt_one_div_of_lt (by norm_num) hthree
+
+/-- The guide supplies small-image semicircles at arbitrarily small radii.
+The image estimate is uniform in the chosen radius. -/
+theorem exists_arbitrarily_small_image_semicircle
+    {F : ℂ → ℂ} (hF : DifferentiableOn ℂ F {z | 0 < z.im})
+    (hi : InjOn F {z | 0 < z.im}) {a : ℂ}
+    (ha : ∀ z, 0 < z.im → F z ≠ a) {r A t₀ : ℝ} {β : ℝ → ℂ}
+    (hr : 0 < r) (hA : 2 * Real.pi ^ 2 < A)
+    (ht₀ : 0 < t₀) (hβ : ContinuousOn β (Icc 0 t₀)) (hβ₀ : β 0 = 0)
+    (hβH : ∀ t ∈ Ioc 0 t₀, 0 < (β t).im)
+    (hsmall : ∀ t ∈ Ioc 0 t₀, ‖F (β t) - a‖ ≤ r * Real.exp (-A)) :
+    ∀ δ : ℝ, 0 < δ → ∃ B ∈ Ioo 0 δ, ∀ θ ∈ Ioo 0 Real.pi,
+      ‖F ((B : ℂ) * Complex.exp ((θ : ℂ) * Complex.I)) - a‖ ≤
+        r * Real.exp (-A + Real.pi * Real.sqrt (2 * A)) := by
+  intro δ hδ
+  let q := min (Real.log δ) (Real.log ‖β t₀‖) - 1
+  have hq : q + 1 ≤ Real.log ‖β t₀‖ := by
+    dsimp [q]
+    linarith [min_le_right (Real.log δ) (Real.log ‖β t₀‖)]
+  obtain ⟨B, hB, hbound⟩ := exists_small_image_semicircle hF hi ha hr hA ht₀
+    hβ hβ₀ hβH hsmall hq
+  refine ⟨B, ⟨(Real.exp_pos q).trans hB.1, hB.2.trans_le ?_⟩, hbound⟩
+  calc
+    Real.exp (q + 1) ≤ Real.exp (Real.log δ) := by
+      apply Real.exp_le_exp.mpr
+      dsimp [q]
+      linarith [min_le_left (Real.log δ) (Real.log ‖β t₀‖)]
+    _ = δ := Real.exp_log hδ
+
+end SLEExactGauge.SmallImageSemicircle
+
+end
+
+end OAI
diff --git a/lean/OAI/Probability/SLE/Geometry/SmallLoopCrossing.lean b/lean/OAI/Probability/SLE/Geometry/SmallLoopCrossing.lean
new file mode 100644
index 0000000000000000000000000000000000000000..dfce30bfff4f8ac0bba19b9af2efb7f394dbc079
--- /dev/null
+++ b/lean/OAI/Probability/SLE/Geometry/SmallLoopCrossing.lean
@@ -0,0 +1,38 @@
+import OAI.Probability.SLE.Geometry.SingleCrossingObstruction
+
+namespace OAI
+
+/-! A loop contained in a ball cannot have exactly one locally invertible
+crossing with a path whose two endpoints lie outside that ball. -/
+noncomputable section
+open Set Filter Metric Function
+open scoped Topology
+
+namespace SLEExactGauge
+
+lemma small_loop_no_single_crossing (c p : C(unitInterval,ℂ))
+    (a : ℂ) (r : ℝ) (hr : 0<r) (hc : ∀ u, c u∈ball a r)
+    (hp₀ : p 0∉ball a r) (hp₁ : p 1∉ball a r)
+    (s t : unitInterval) (hs : 0<(s:ℝ) ∧ (s:ℝ)<1) (ht : 0<(t:ℝ) ∧ (t:ℝ)<1)
+    (hcross : c t=p s) (hu : ∀ u v, c v=p u → u=s ∧ v=t)
+    (hi : ∃ ρ : ℝ, 0<ρ ∧ InjOn (crossingSquareMap c p)
+      (closedBall ((s:ℂ)+(t:ℂ)*Complex.I) ρ)) (hloop : c 0=c 1) : False := by
+  obtain ⟨A,hA⟩ := continuous_log_on_ball_away a (p 0) r hr hp₀
+  obtain ⟨B,hB⟩ := continuous_log_on_ball_away a (p 1) r hr hp₁
+  let c' : C(unitInterval,ball a r) := ⟨fun u => ⟨c u,hc u⟩,c.continuous.subtype_mk _⟩
+  have hc' : c' 0=c' 1 := Subtype.ext hloop
+  have hbase (u : unitInterval) : c 0-p u≠0 := by
+    intro he
+    have he' := (hu u 0 (sub_eq_zero.mp he)).2
+    have heR := congrArg (fun x : unitInterval => (x:ℝ)) he'
+    simp only [Set.Icc.coe_zero] at heR
+    linarith [ht.1]
+  exact no_single_locally_injective_crossing c p s t hs ht hcross hu hi hloop hbase
+    (A.comp c') (B.comp c') (fun u => hA (c' u)) (fun u => hB (c' u))
+    (congrArg A hc') (congrArg B hc')
+
+end SLEExactGauge
+
+end
+
+end OAI
diff --git a/lean/OAI/Probability/SLE/Geometry/SpatialExhaustion.lean b/lean/OAI/Probability/SLE/Geometry/SpatialExhaustion.lean
new file mode 100644
index 0000000000000000000000000000000000000000..aeecf21d39bda12807f2735952b37e2ed58b84c9
--- /dev/null
+++ b/lean/OAI/Probability/SLE/Geometry/SpatialExhaustion.lean
@@ -0,0 +1,134 @@
+import OAI.Probability.SLE.Geometry.BoundaryNull
+import OAI.Probability.SLE.Gauge.CoverLimits
+
+namespace OAI
+
+/-! Removing the time and height cutoffs in the whole-trace upper bound. -/
+
+noncomputable section
+open Set Filter MeasureTheory Metric
+open scoped Topology ENNReal NNReal
+
+namespace SLEExactGauge
+
+def interiorSpatialCutoff (R : ℝ) (n : ℕ) : Set ℂ :=
+  closedBall 0 R ∩ {z | 1 / ((n : ℝ) + 1) ≤ z.im}
+
+def compactTraceCutoff (γ : ℝ≥0 → ℂ) (R : ℝ) (n : ℕ) : Set ℂ :=
+  interiorSpatialCutoff R n ∩ (γ '' Icc 0 (n : ℝ≥0))
+
+lemma interiorSpatialCutoff_isCompact (R : ℝ) (n : ℕ) :
+    IsCompact (interiorSpatialCutoff R n) :=
+  (isCompact_closedBall (0 : ℂ) R).inter_right
+    (isClosed_le continuous_const Complex.continuous_im)
+
+lemma interiorSpatialCutoff_subset (R : ℝ) (n : ℕ) :
+    interiorSpatialCutoff R n ⊆ upperHalfPlane ∩ closedBall 0 R := by
+  intro z hz
+  exact ⟨(by change 0 < z.im; exact (by positivity : (0 : ℝ) < 1 / ((n : ℝ) + 1)).trans_le hz.2),
+    hz.1⟩
+
+lemma compactTraceCutoff_monotone (γ : ℝ≥0 → ℂ) (R : ℝ) :
+    Monotone (compactTraceCutoff γ R) := by
+  intro n m hnm z hz
+  refine ⟨⟨hz.1.1, ?_⟩, ?_⟩
+  · exact (one_div_le_one_div_of_le (by positivity : (0 : ℝ) < (n : ℝ) + 1)
+      (by exact_mod_cast Nat.add_le_add_right hnm 1 : (n : ℝ) + 1 ≤ (m : ℝ) + 1)).trans hz.1.2
+  · exact image_mono (Icc_subset_Icc_right (Nat.cast_le.mpr hnm)) hz.2
+
+lemma iUnion_compactTraceCutoff (γ : ℝ≥0 → ℂ) (R : ℝ) :
+    (⋃ n, compactTraceCutoff γ R n) =
+      wholeTrace γ ∩ closedBall 0 R ∩ upperHalfPlane := by
+  ext z
+  constructor
+  · intro hz
+    obtain ⟨n, hn⟩ := mem_iUnion.mp hz
+    exact ⟨⟨image_subset_range _ _ hn.2, hn.1.1⟩,
+      (interiorSpatialCutoff_subset R n hn.1).1⟩
+  · rintro ⟨⟨⟨t, rfl⟩, hzR⟩, hzy⟩
+    have hy : 0 < (γ t).im := hzy
+    obtain ⟨n, hn⟩ := exists_nat_ge (max (t : ℝ) (1 / (γ t).im))
+    have htn : t ≤ (n : ℝ≥0) := by
+      exact_mod_cast (le_max_left _ _).trans hn
+    have hprod : 1 ≤ (γ t).im * ((n : ℝ) + 1) := by
+      have hdiv : 1 / (γ t).im ≤ (n : ℝ) + 1 :=
+        (le_max_right _ _).trans (hn.trans (by linarith))
+      simpa only [mul_comm] using (div_le_iff₀ hy).mp hdiv
+    refine mem_iUnion.mpr ⟨n, ⟨hzR, ?_⟩, t, ⟨zero_le, htn⟩, rfl⟩
+    exact (div_le_iff₀ (by positivity : (0 : ℝ) < (n : ℝ) + 1)).mpr hprod
+
+lemma sle_compact_trace_aemeasurable
+    {Ω : Type*} [MeasurableSpace Ω] (P : Measure Ω)
+    (κ : ℝ) (γ : Ω → ℝ≥0 → ℂ) (hSLE : IsOrdinaryChordalSLE κ γ P)
+    (h : ℝ → ℝ) (hh : IsGauge h) (K : Set ℂ) (hK : IsClosed K)
+    (s t : ℝ≥0) :
+    AEMeasurable (fun ω => hausdorffGauge h (K ∩ (γ ω '' Icc s t))) P := by
+  obtain ⟨a⟩ := exists_regular_sle_presentation hSLE
+  let f : a.samples → C(ℝ≥0, ℂ) := fun ω => ⟨γ ω, a.trace_continuous ω⟩
+  have hf : Measurable f := source_whole_path_measurable f
+    (fun u => (hSLE.1 u).comp measurable_subtype_coe)
+  have hm := (source_compact_trace_measure_measurable h hh K hK s t).comp hf
+  have hemb : MeasurableEmbedding (Subtype.val : a.samples → Ω) :=
+    MeasurableEmbedding.subtype_coe a.measurable_samples
+  exact (a.measurePreserving_val.aemeasurable_comp_iff hemb).mp hm.aemeasurable
+
+/-- Exhaustion by compact interior sets in the upper Hausdorff estimate
+of Proposition `prop:dense-cover-upper`. -/
+theorem whole_trace_expectation_of_compact_interior_bounds
+    {Ω : Type*} [MeasurableSpace Ω] (P : Measure Ω)
+    (κ : ℝ) (hκ : 0 < κ)
+    (γ : Ω → ℝ≥0 → ℂ) (hSLE : IsOrdinaryChordalSLE κ γ P)
+    (h : ℝ → ℝ) (hh : IsGauge h)
+    (hf : HasSmallRadiusFormula h (hFormula κ)) (R : ℝ) (C : ℝ≥0∞)
+    (hcompact : ∀ (T : ℝ≥0) (K : Set ℂ), IsCompact K →
+      K ⊆ upperHalfPlane ∩ closedBall 0 R →
+      (∫⁻ ω, hausdorffGauge h (K ∩ (γ ω '' Icc 0 T)) ∂P) ≤ C) :
+    (∫⁻ ω, hausdorffGauge h (wholeTrace (γ ω) ∩ closedBall 0 R) ∂P) ≤ C := by
+  have hnull := explicit_gauge_real_axis_null hκ hh hf
+  have heq : ∀ᵐ ω ∂P,
+      hausdorffGauge h (wholeTrace (γ ω) ∩ closedBall 0 R) =
+        hausdorffGauge h (⋃ n, compactTraceCutoff (γ ω) R n) := by
+    obtain ⟨B, hB, htrace⟩ := hSLE.2
+    filter_upwards [htrace] with ω hω
+    obtain ⟨G, F, hw⟩ := hω
+    rw [iUnion_compactTraceCutoff]
+    apply measure_inter_eq_interior_of_null_boundary
+    apply measure_mono_null (t := range ((↑) : ℝ → ℂ)) _ hnull
+    rintro z ⟨⟨⟨t, rfl⟩, _⟩, hz⟩
+    have hz0 : (γ ω t).im = 0 := le_antisymm (le_of_not_gt hz) (hw.2.2.1 t)
+    refine ⟨(γ ω t).re, ?_⟩
+    apply Complex.ext <;> simp [hz0]
+  rw [lintegral_congr_ae heq]
+  apply expected_measure_iUnion_le P (hausdorffGauge h)
+    (fun n ω => compactTraceCutoff (γ ω) R n)
+    (fun ω => compactTraceCutoff_monotone (γ ω) R)
+  · intro n
+    exact sle_compact_trace_aemeasurable P κ γ hSLE h hh
+      (interiorSpatialCutoff R n) (interiorSpatialCutoff_isCompact R n).isClosed 0 n
+  · intro n
+    exact hcompact n (interiorSpatialCutoff R n)
+      (interiorSpatialCutoff_isCompact R n) (interiorSpatialCutoff_subset R n)
+
+/-- Compact interior upper estimates imply the whole-trace upper bound. -/
+theorem mainConclusion_of_uniform_compact_interior_bounds
+    {Ω : Type*} [MeasurableSpace Ω] (P : Measure Ω) [IsProbabilityMeasure P]
+    (κ : ℝ) (hκ : 0 < κ) (hκ8 : κ < 8)
+    (γ : Ω → ℝ≥0 → ℂ) (hSLE : IsOrdinaryChordalSLE κ γ P)
+    (h : ℝ → ℝ) (hh : IsGauge h)
+    (hf : HasSmallRadiusFormula h (hFormula κ))
+    (hcompact : ∀ R : ℝ, 0 < R → ∃ C : ℝ≥0∞, C < ∞ ∧
+      ∀ (T : ℝ≥0) (K : Set ℂ), IsCompact K →
+        K ⊆ upperHalfPlane ∩ closedBall 0 R →
+        (∫⁻ ω, hausdorffGauge h (K ∩ (γ ω '' Icc 0 T)) ∂P) ≤ C) :
+    MainConclusion P h γ := by
+  apply (mainConclusion_iff_finiteExpectedWholeTrace P κ hκ hκ8 γ hSLE h hh hf).mpr
+  intro R hR
+  obtain ⟨C, hC, hbound⟩ := hcompact R hR
+  exact (whole_trace_expectation_of_compact_interior_bounds P κ hκ γ hSLE h hh hf
+    R C hbound).trans_lt hC
+
+end SLEExactGauge
+
+end
+
+end OAI
diff --git a/lean/OAI/Probability/SLE/Geometry/SpatialPastKernels.lean b/lean/OAI/Probability/SLE/Geometry/SpatialPastKernels.lean
new file mode 100644
index 0000000000000000000000000000000000000000..5dff371c3394e6da567909a4d9e833e824b2190a
--- /dev/null
+++ b/lean/OAI/Probability/SLE/Geometry/SpatialPastKernels.lean
@@ -0,0 +1,160 @@
+import OAI.Probability.SLE.Geometry.JointRadiusKernel
+import Mathlib.Analysis.ODE.ExistUnique
+
+namespace OAI
+
+/-! Spatial Loewner kernels up to a deterministic time depend only on the
+driver up to that time. The marked point is kept as a measurable parameter. -/
+
+noncomputable section
+open Set Filter MeasureTheory ProbabilityTheory Classical
+open scoped Topology NNReal ENNReal
+
+namespace SLEExactGauge
+
+lemma clipped_flow_eqOn_prefix
+    {U V : ℝ≥0 → ℝ} {Q R : ℝ → ℂ × ℝ}
+    (lo hi : ℝ) (hle : lo ≤ hi) (T : ℝ≥0)
+    (hU : ∀ t, t ≤ T → U t = V t)
+    (hQ : ∀ t, 0 ≤ t → HasDerivWithinAt Q
+      (clippedLogLoewnerField lo hi hle (U t.toNNReal) (Q t)) (Ici 0) t)
+    (hR : ∀ t, 0 ≤ t → HasDerivWithinAt R
+      (clippedLogLoewnerField lo hi hle (V t.toNNReal) (R t)) (Ici 0) t)
+    (hzero : Q 0 = R 0) : EqOn Q R (Icc 0 (T : ℝ)) := by
+  obtain ⟨_, K, _, hlip⟩ := clippedLogLoewnerField_bounds lo hi hle
+  apply ODE_solution_unique_of_mem_Icc_right
+    (v := fun t q => clippedLogLoewnerField lo hi hle (U t.toNNReal) q)
+    (s := fun _ => univ) (K := K)
+  · intro t _
+    exact (hlip _).lipschitzOnWith
+  · intro t ht
+    exact (hQ t ht.1).continuousWithinAt.mono Icc_subset_Ici_self
+  · intro t ht
+    exact (hQ t ht.1).mono (Ici_subset_Ici.mpr ht.1)
+  · simp
+  · intro t ht
+    exact (hR t ht.1).continuousWithinAt.mono Icc_subset_Ici_self
+  · intro t ht
+    have htT : t.toNNReal ≤ T := Real.toNNReal_le_iff_le_coe.mpr ht.2.le
+    rw [hU _ htT]
+    exact (hR t ht.1).mono (Ici_subset_Ici.mpr ht.1)
+  · simp
+  · exact hzero
+
+lemma spatial_clipped_eqOn_prefix
+    {Ω : Type*} {m m' : MeasurableSpace Ω} {U V : ℝ≥0 → Ω → ℝ}
+    (c : @SpatialClippedFamily Ω m U) (d : @SpatialClippedFamily Ω m' V)
+    (T : ℝ≥0) (hUV : ∀ t, t ≤ T → ∀ ω, U t ω = V t ω) :
+    ∀ n z ω, EqOn (fun t => (@SpatialClippedFamily.Q Ω m U c) n t (z,ω))
+      (fun t => (@SpatialClippedFamily.Q Ω m' V d) n t (z,ω))
+      (Icc 0 (T : ℝ)) := by
+  intro n z ω
+  apply clipped_flow_eqOn_prefix (-(n : ℝ)) n _ T
+    (fun t ht => hUV t ht ω) (@SpatialClippedFamily.derivative Ω m U c n z ω)
+      (@SpatialClippedFamily.derivative Ω m' V d n z ω)
+  rw [@SpatialClippedFamily.initial Ω m U c, @SpatialClippedFamily.initial Ω m' V d]
+
+lemma exists_past_spatial_family
+    {Ω : Type*} [mΩ : MeasurableSpace Ω] {B : ℝ≥0 → Ω → ℝ}
+    (hm : ∀ t, Measurable (B t)) (hc : ∀ ω, Continuous (fun t => B t ω))
+    (κ : ℝ) (c : SpatialClippedFamily (fun t ω => Real.sqrt κ * B t ω))
+    (T : ℝ≥0) :
+    ∃ d : @SpatialClippedFamily Ω
+        (Filtration.natural B (fun t => (hm t).stronglyMeasurable) T)
+        (fun t ω => Real.sqrt κ * B (min t T) ω),
+      ∀ n z ω, EqOn (fun t => (@SpatialClippedFamily.Q Ω mΩ _ c) n t (z,ω))
+        (fun t => (@SpatialClippedFamily.Q Ω
+          (Filtration.natural B (fun t => (hm t).stronglyMeasurable) T) _ d) n t (z,ω))
+        (Icc 0 (T : ℝ)) := by
+  have hBm : Measurable (fun p : ℝ≥0 × Ω => B p.1 p.2) :=
+    measurable_uncurry_of_continuous_of_measurable hc hm
+  have hf := measurable_driver_frozen B hBm hc T
+  let : MeasurableSpace Ω := Filtration.natural B (fun t => (hm t).stronglyMeasurable) T
+  have hfm : Measurable (fun p : ℝ≥0 × Ω => Real.sqrt κ * B (min p.1 T) p.2) := by
+    have h := hf.comp (NNReal.continuous_coe.measurable.prodMap measurable_id)
+    have h' := h.const_mul (Real.sqrt κ)
+    change Measurable (fun p : ℝ≥0 × Ω =>
+      Real.sqrt κ * B (min (p.1 : ℝ).toNNReal T) p.2) at h'
+    simpa only [Real.toNNReal_coe] using h'
+  let d := spatialClippedFamily (fun t ω => Real.sqrt κ * B (min t T) ω) hfm
+    (fun ω => ((hc ω).comp (continuous_id.min continuous_const)).const_mul _)
+  refine ⟨d, spatial_clipped_eqOn_prefix c d T ?_⟩
+  intro t ht ω
+  rw [min_eq_left ht]
+
+/-- All three spatial kernels are jointly measurable in the marked point,
+sample, and time restricted to the natural past at `T`. -/
+theorem actual_spatial_past_kernels
+    {Ω : 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) :
+    let mT := Filtration.natural B (fun t => (hm t).stronglyMeasurable) T
+    @Measurable (Iic T × (ℂ × Ω)) ℝ ((inferInstance : MeasurableSpace (Iic T)).prod
+      ((borel ℂ).prod mT)) (borel ℝ)
+      (fun p => greenDensity κ (fun t => Real.sqrt κ * B t p.2.2)
+        (γ p.2.2) (G p.2.2) p.1 p.2.1) ∧
+    @Measurable (Iic T × (ℂ × Ω)) ℝ ((inferInstance : MeasurableSpace (Iic T)).prod
+      ((borel ℂ).prod mT)) (borel ℝ)
+      (fun p => if p.2.1 ∈ survivingDomain (γ p.2.2) p.1 then
+        fullRadius (G p.2.2) p.1 p.2.1 else 0) ∧
+    @MeasurableSet (Iic T × (ℂ × Ω)) ((inferInstance : MeasurableSpace (Iic T)).prod
+      ((borel ℂ).prod mT)) {p | p.2.1 ∈ survivingDomain (γ p.2.2) p.1} := by
+  let c := spatialClippedFamily (fun t ω => Real.sqrt κ * B t ω)
+    ((measurable_uncurry_of_continuous_of_measurable hc hm).const_mul _)
+    (fun ω => (hc ω).const_mul _)
+  obtain ⟨d, hd⟩ := exists_past_spatial_family hm hc κ c T
+  have hf := measurable_driver_frozen B
+    (measurable_uncurry_of_continuous_of_measurable hc hm) hc T
+  let : MeasurableSpace Ω := Filtration.natural B (fun t => (hm t).stronglyMeasurable) T
+  have hmap : Measurable (fun p : Iic T × (ℂ × Ω) => ((p.1 : ℝ≥0),p.2)) :=
+    measurable_subtype_coe.prodMap measurable_id
+  have hBm : Measurable (fun p : ℝ≥0 × Ω => B (min p.1 T) p.2) := by
+    have h := hf.comp (NNReal.continuous_coe.measurable.prodMap measurable_id)
+    change Measurable (fun p : ℝ≥0 × Ω => B (min (p.1 : ℝ).toNNReal T) p.2) at h
+    simpa only [Real.toNNReal_coe] using h
+  have he (n : ℕ) (p : Iic T × (ℂ × Ω)) :
+      (@SpatialClippedFamily.Q Ω mΩ _ c) n (p.1 : ℝ≥0) p.2 = d.Q n (p.1 : ℝ≥0) p.2 :=
+    hd n p.2.1 p.2.2 ⟨p.1.val.coe_nonneg, by exact_mod_cast p.1.property⟩
+  have hv (n : ℕ) (p : Iic T × (ℂ × Ω)) :
+      (@SpatialClippedFamily.valid Ω mΩ _ c) n p.1 p.2.1 p.2.2 ↔ d.valid n p.1 p.2.1 p.2.2 := by
+    simp only [SpatialClippedFamily.valid, he]
+  have hgreen (p : Iic T × (ℂ × Ω)) :
+      d.jointGreen κ (fun t ω => B (min t T) ω) (p.1,p.2) =
+      greenDensity κ (fun t => Real.sqrt κ * B t p.2.2)
+        (γ p.2.2) (G p.2.2) p.1 p.2.1 := by
+    rw [← (@SpatialClippedFamily.jointGreen_eq Ω mΩ _ c) κ B p.2.2 ((hc p.2.2).const_mul _) (fun _ => rfl) (hw p.2.2)]
+    unfold SpatialClippedFamily.jointGreen
+    congr 1
+    funext n
+    simp only [SpatialClippedFamily.greenApprox, hv, he,
+      min_eq_left (show (p.1 : ℝ≥0) ≤ T from p.1.property)]
+  have hradius (p : Iic T × (ℂ × Ω)) : d.jointRadius (p.1,p.2) =
+      if p.2.1 ∈ survivingDomain (γ p.2.2) p.1 then
+        fullRadius (G p.2.2) p.1 p.2.1 else 0 := by
+    rw [← (@SpatialClippedFamily.jointRadius_eq Ω mΩ _ c) p.2.2 ((hc p.2.2).const_mul _) (hw p.2.2)]
+    unfold SpatialClippedFamily.jointRadius
+    congr 1
+    funext n
+    simp only [SpatialClippedFamily.radiusApprox, hv, he]
+  have hlive (p : Iic T × (ℂ × Ω)) : d.jointLive (p.1,p.2) ↔
+      p.2.1 ∈ survivingDomain (γ p.2.2) p.1 := by
+    rw [← (@SpatialClippedFamily.jointLive_iff Ω mΩ _ c) p.2.2 ((hc p.2.2).const_mul _) (hw p.2.2)]
+    exact exists_congr (fun n => (hv n p).symm)
+  refine ⟨?_, ?_, ?_⟩
+  · convert ((d.jointGreen_measurable κ (fun t ω => B (min t T) ω) hBm).comp hmap) using 1
+    funext p
+    exact (hgreen p).symm
+  · convert (d.jointRadius_measurable.comp hmap) using 1
+    funext p
+    exact (hradius p).symm
+  · convert d.jointLive_measurable.preimage hmap using 1
+    ext p
+    exact (hlive p).symm
+
+end SLEExactGauge
+
+end
+
+end OAI
diff --git a/lean/OAI/Probability/SLE/Geometry/StableTraceAvoidance.lean b/lean/OAI/Probability/SLE/Geometry/StableTraceAvoidance.lean
new file mode 100644
index 0000000000000000000000000000000000000000..dc277f37296ec6a6e8e01553ffb65875ed1d33b9
--- /dev/null
+++ b/lean/OAI/Probability/SLE/Geometry/StableTraceAvoidance.lean
@@ -0,0 +1,102 @@
+import OAI.Probability.SLE.Loewner.RealBoundaryTraceAvoidance
+import OAI.Probability.SLE.Loewner.LoewnerCompactDriverNeighborhood
+import OAI.Probability.SLE.Loewner.LoewnerTraceHeight
+
+namespace OAI
+
+/-! Local trace exclusions patch to an open tube by compactness. The
+bounded rectangle comes directly from the driver and capacity bounds. -/
+noncomputable section
+open Set Filter Metric Complex
+open scoped Topology NNReal
+
+namespace SLEExactGauge
+
+def StableTraceAvoidance (V : ℝ≥0 → ℝ) (T : ℝ≥0) (z : ℂ) : Prop :=
+  ∃ r δ : ℝ, 0 < r ∧ 0 < δ ∧ ∀ (U : ℝ≥0 → ℝ), Continuous U →
+    ∀ (γ : ℝ≥0 → ℂ) (G F : ℝ≥0 → ℂ → ℂ), IsCapacityTwoWitness U γ G F →
+    (∀ t ∈ Icc 0 T, |U t-V t| ≤ δ) → ∀ t ∈ Icc 0 T, γ t ∉ ball z r
+
+lemma stableTraceAvoidance_of_surviving
+    {V : ℝ≥0 → ℝ} {β : ℝ≥0 → ℂ} {H J : ℝ≥0 → ℂ → ℂ}
+    (hv : IsCapacityTwoWitness V β H J) (T : ℝ≥0) {z : ℂ}
+    (hz : z ∈ survivingDomain β T) : StableTraceAvoidance V T z := by
+  obtain ⟨r,hr,hball⟩ := Metric.isOpen_iff.mp (isOpen_survivingDomain hv.1 T) z hz
+  have hclosed : closedBall z (r/2) ⊆ survivingDomain β T := by
+    intro w hw
+    apply hball
+    rw [mem_ball]
+    exact (mem_closedBall.mp hw).trans_lt (half_lt_self hr)
+  obtain ⟨δ,hδ,hkeep⟩ := driver_neighborhood_preserves_compact hv T
+    (isCompact_closedBall z (r/2)) hclosed
+  refine ⟨r/2,δ,by positivity,hδ,?_⟩
+  intro U _ γ G F hw hc t ht hb
+  have hD := hkeep U γ G F hw hc (ball_subset_closedBall hb)
+  exact hD.1.2 ⟨t,ht,rfl⟩
+
+lemma stableTraceAvoidance_of_real_trajectory
+    (V : ℝ≥0 → ℝ) (T : ℝ≥0) (q : ℝ → ℝ) {m : ℝ} (hm : 0 < m)
+    (hgap : ∀ t ∈ Icc 0 (T : ℝ), m ≤ q t-V t.toNNReal)
+    (hqd : ∀ t ∈ Icc 0 (T : ℝ), HasDerivWithinAt q
+      (2/(q t-V t.toNNReal)) (Icc 0 (T : ℝ)) t) :
+    StableTraceAvoidance V T (q 0 : ℂ) := by
+  obtain ⟨ε,hε,hh⟩ := real_boundary_driver_trace_avoidance V T q hm hgap hqd
+  exact ⟨ε,ε,hε,hε,hh⟩
+
+theorem driver_neighborhood_trace_containment
+    (V : ℝ≥0 → ℝ) (hV : Continuous V) (T : ℝ≥0) (N : Set ℂ) (hN : IsOpen N)
+    (hlocal : ∀ z : ℂ, 0 ≤ z.im → z ∉ N → StableTraceAvoidance V T z) :
+    ∃ δ : ℝ, 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
+  classical
+  by_contra hn
+  push Not at hn
+  have hc (n : ℕ) := hn ((n+1:ℝ)⁻¹) (by positivity)
+  choose U hU γ G F hw hclose hfail using hc
+  have hbad (n : ℕ) : ∃ t ∈ Icc 0 T, γ n t ∉ N := by
+    by_contra hn
+    apply hfail n
+    intro t ht
+    by_contra htn
+    exact hn ⟨t,ht,htn⟩
+  choose t ht htN using hbad
+  obtain ⟨M,hM,hMb⟩ := ((isCompact_Icc.image hV).isBounded).exists_pos_norm_lt
+  have hVM (s : ℝ≥0) (hs : s ∈ Icc 0 T) : |V s| < M := by
+    simpa only [Real.norm_eq_abs] using hMb (V s) (mem_image_of_mem V hs)
+  have hUb (n : ℕ) (s : ℝ≥0) (hs : s ∈ Icc 0 T) : |U n s| ≤ M+1 := by
+    have hi : (n+1:ℝ)⁻¹ ≤ 1 := (inv_le_one₀ (by positivity)).mpr
+      (by linarith [Nat.cast_nonneg (α := ℝ) n])
+    have hh := (hclose n s hs).trans hi
+    have hab := abs_sub_abs_le_abs_sub (U n s) (V s)
+    linarith [hVM s hs]
+  let K := closedBall (0 : ℂ) (M+1+2*Real.sqrt T) ∩
+    ({z : ℂ | 0 ≤ z.im} ∩ Nᶜ)
+  have hK : IsCompact K := (isCompact_closedBall _ _).inter_right
+    ((isClosed_le continuous_const Complex.continuous_im).inter hN.isClosed_compl)
+  have hmem (n : ℕ) : γ n (t n) ∈ K := by
+    have hr := (hw n).trace_abs_re_le (t n)
+      (fun s hs => hUb n s ⟨zero_le,hs.2.trans (ht n).2⟩)
+    have hi := ((hw n).trace_height_le (t n)).trans
+      (mul_le_mul_of_nonneg_left (Real.sqrt_le_sqrt (by exact_mod_cast (ht n).2)) (by norm_num))
+    have hn := Complex.norm_le_abs_re_add_abs_im (γ n (t n))
+    rw [abs_of_nonneg ((hw n).2.2.1 (t n))] at hn
+    refine ⟨?_,(hw n).2.2.1 (t n),htN n⟩
+    rw [mem_closedBall,dist_zero_right]
+    exact hn.trans (add_le_add hr hi)
+  obtain ⟨z,hz,φ,hφ,hlim⟩ := hK.tendsto_subseq hmem
+  obtain ⟨r,δ,hr,hδ,havoid⟩ := hlocal z hz.2.1 hz.2.2
+  have hdlim : Tendsto (fun n : ℕ => (φ n+1:ℝ)⁻¹) atTop (𝓝 0) :=
+    (tendsto_inv_atTop_zero.comp
+      (tendsto_atTop_add_const_right atTop 1 tendsto_natCast_atTop_atTop)).comp hφ.tendsto_atTop
+  have he : ∀ᶠ n in atTop, γ (φ n) (t (φ n)) ∈ ball z r ∧ (φ n+1:ℝ)⁻¹ < δ :=
+    (hlim.eventually (ball_mem_nhds z hr)).and (hdlim.eventually (Iio_mem_nhds hδ))
+  obtain ⟨n,hnball,hnd⟩ := he.exists
+  exact havoid (U (φ n)) (hU (φ n)) (γ (φ n)) (G (φ n)) (F (φ n)) (hw (φ n))
+    (fun s hs => (hclose (φ n) s hs).trans hnd.le) _ (ht (φ n)) hnball
+
+end SLEExactGauge
+
+end
+
+end OAI
diff --git a/lean/OAI/Probability/SLE/Geometry/StoppedBoundaryMeasurability.lean b/lean/OAI/Probability/SLE/Geometry/StoppedBoundaryMeasurability.lean
new file mode 100644
index 0000000000000000000000000000000000000000..a7e5f3ceed9444e096933ddfaf21f39a633d67b7
--- /dev/null
+++ b/lean/OAI/Probability/SLE/Geometry/StoppedBoundaryMeasurability.lean
@@ -0,0 +1,133 @@
+import OAI.Probability.SLE.ChartMeasurability
+import OAI.Probability.SLE.Geometry.PublishedBoundaryExtension
+import Mathlib.Topology.Compactification.OnePoint.Sphere
+
+namespace OAI
+
+/-! Boundary charts are measurable from the stopped past. Their values on
+the real line are limits of measurable interior values, so choosing the
+published continuous extension introduces no additional random information.
+-/
+
+noncomputable section
+open Set Filter MeasureTheory ProbabilityTheory TopologicalSpace
+open scoped Topology NNReal
+
+namespace SLEExactGauge
+
+abbrev closedHalfPlane : Set ℂ := {z | 0 ≤ z.im}
+
+theorem isClosed_closedHalfPlane : IsClosed closedHalfPlane :=
+  isClosed_le continuous_const Complex.continuous_im
+
+instance onePointComplexPolishSpace : PolishSpace (OnePoint ℂ) :=
+  (onePointEquivSphereOfFinrankEq (V := ℂ) (ι := Fin 3)
+    (by simp [Complex.finrank_real_complex])).isClosedEmbedding.polishSpace
+
+instance onePointComplexMeasurableSpace : MeasurableSpace (OnePoint ℂ) := borel _
+instance onePointComplexBorelSpace : BorelSpace (OnePoint ℂ) := ⟨rfl⟩
+
+local instance : LocallyCompactSpace closedHalfPlane :=
+  isClosed_closedHalfPlane.locallyCompactSpace
+local instance : PolishSpace closedHalfPlane := isClosed_closedHalfPlane.polishSpace
+local instance : Nonempty closedHalfPlane := ⟨⟨0, by simp [closedHalfPlane]⟩⟩
+local instance : MeasurableSpace C(closedHalfPlane, OnePoint ℂ) := borel _
+local instance : BorelSpace C(closedHalfPlane, OnePoint ℂ) := ⟨rfl⟩
+
+/-- A boundary evaluation is the limit along vertical interior approaches. -/
+theorem boundary_extension_eval_measurable
+    {Ω : Type*} [MeasurableSpace Ω]
+    (f : Ω → ℂ → ℂ) (Fb : Ω → C(closedHalfPlane, OnePoint ℂ))
+    (hf : ∀ z ∈ upperHalfPlane, Measurable (fun ω => f ω z))
+    (hext : ∀ ω (z : closedHalfPlane), z.1 ∈ upperHalfPlane →
+      Fb ω z = (f ω z : OnePoint ℂ))
+    (z : closedHalfPlane) : Measurable (fun ω => Fb ω z) := by
+  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ₙ n).1.im
+    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
+    have hlim : Tendsto (fun n : ℕ =>
+        z.1 + ((1 / ((n : ℝ) + 1) : ℝ) : ℂ) * Complex.I) atTop (𝓝 z.1) := by
+      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 hlim
+  apply measurable_of_tendsto_metrizable
+    (f := fun n ω => Fb ω (zₙ n))
+  · intro n
+    have he : (fun ω => Fb ω (zₙ n)) = fun ω => (f ω (zₙ n) : OnePoint ℂ) :=
+      funext (fun ω => hext ω _ (hH n))
+    rw [he]
+    exact OnePoint.continuous_coe.measurable.comp (hf _ (hH n))
+  · exact tendsto_pi_nhds.mpr (fun ω => (Fb ω).continuous.tendsto z |>.comp hz)
+
+/-- Borel measurability of a closed-half-plane continuous map is detected
+by its evaluations on a countable dense set. -/
+theorem closed_halfplane_boundary_map_measurable
+    {Ω : Type*} [MeasurableSpace Ω]
+    (Fb : Ω → C(closedHalfPlane, OnePoint ℂ))
+    (hFb : ∀ z, Measurable (fun ω => Fb ω z)) : Measurable Fb :=
+  ContinuousMap.measurable_iff_eval.mpr hFb
+
+theorem boundary_extension_family_measurable
+    {Ω : Type*} [MeasurableSpace Ω]
+    (f : Ω → ℂ → ℂ) (Fb : Ω → C(closedHalfPlane, OnePoint ℂ))
+    (hf : ∀ z ∈ upperHalfPlane, Measurable (fun ω => f ω z))
+    (hext : ∀ ω (z : closedHalfPlane), z.1 ∈ upperHalfPlane →
+      Fb ω z = (f ω z : OnePoint ℂ)) : Measurable Fb :=
+  closed_halfplane_boundary_map_measurable Fb
+    (boundary_extension_eval_measurable f Fb hf hext)
+
+/-- The actual normalized inverse at a finite stopping time admits a
+past-measurable family of continuous boundary extensions. -/
+theorem source_stopped_boundaryPath_measurable
+    (hpublished : PublishedLoewnerBoundaryExtension)
+    {Ω : 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, OnePoint ℂ),
+      Measurable[hτ.measurableSpace] Fb ∧
+      (∀ ω (z : closedHalfPlane), z.1 ∈ upperHalfPlane →
+        Fb ω z = (F ω (τ ω) (z + (Real.sqrt κ * B (τ ω) ω : ℝ)) : OnePoint ℂ)) ∧
+      ∀ ω, Fb ω ⟨0, by simp [closedHalfPlane]⟩ = (γ ω (τ ω) : OnePoint ℂ) := by
+  choose Fb hcont hext htip using fun ω =>
+    normalized_capacity_inverse_boundary_extension hpublished
+      (continuous_const.mul (hc ω)) (hw ω) (τ ω) 1 zero_lt_one
+  let fbar (ω : Ω) : C(closedHalfPlane, OnePoint ℂ) :=
+    ⟨fun z => Fb ω z, (hcont ω).domRestrict⟩
+  have hext' (ω : Ω) (z : closedHalfPlane) (hz : z.1 ∈ upperHalfPlane) :
+      fbar ω z = (F ω (τ ω) (z + (Real.sqrt κ * B (τ ω) ω : ℝ)) : OnePoint ℂ) := by
+    change Fb ω z = _
+    simpa only [Complex.ofReal_one, one_mul, add_comm,
+      Pi.mul_apply]
+      using hext ω z hz
+  refine ⟨fbar, ?_, hext', fun ω => htip ω⟩
+  apply @boundary_extension_family_measurable Ω hτ.measurableSpace
+    (fun ω z => F ω (τ ω) (z + (Real.sqrt κ * B (τ ω) ω : ℝ))) fbar
+    _ hext'
+  intro z hz
+  exact (continuous_eval_const (⟨z, hz⟩ : upperHalfPlane)).measurable.comp
+    (source_stopped_inversePath_measurable B hm hc κ γ G F hw τ hτ)
+
+end SLEExactGauge
+
+end
+
+end OAI
diff --git a/lean/OAI/Probability/SLE/Geometry/StoppedBoundaryRestart.lean b/lean/OAI/Probability/SLE/Geometry/StoppedBoundaryRestart.lean
new file mode 100644
index 0000000000000000000000000000000000000000..8f3fa4ba72a5ed5b8889c0cd685096bb31ffe771
--- /dev/null
+++ b/lean/OAI/Probability/SLE/Geometry/StoppedBoundaryRestart.lean
@@ -0,0 +1,271 @@
+import OAI.Probability.SLE.StoppedMeasures
+import OAI.Probability.SLE.LowerPositivity
+import OAI.Probability.SLE.Geometry.BoundaryNull
+import OAI.Probability.SLE.Geometry.PublishedBoundaryExtension
+import OAI.Probability.SLE.Geometry.GeometricTubeSupport
+
+namespace OAI
+
+/-!
+The stopped restart identity at every future time. Positive gauge measure on
+each nondegenerate trace segment and nullity of the real axis force interior
+trace times to be dense. This is a measurable path property, hence transfers
+through the actual stopped trace law. Continuity of the published inverse-map
+boundary extension then gives the identity also at boundary visits.
+-/
+
+noncomputable section
+open Set Filter MeasureTheory ProbabilityTheory Metric TopologicalSpace
+open scoped Topology NNReal ENNReal
+
+namespace SLEExactGauge.StoppedBoundaryRestart
+
+/-- A positive-mass trace segment cannot lie on the null real axis. -/
+theorem segment_has_interior_time
+    (γ : ℝ≥0 → ℂ) (μ : Measure ℂ) (hH : ∀ u, 0 ≤ (γ u).im)
+    (hnull : μ (range ((↑) : ℝ → ℂ)) = 0)
+    {s t : ℝ≥0} (hpos : 0 < μ (γ '' Icc s t)) :
+    ∃ u ∈ Icc s t, γ u ∈ upperHalfPlane := by
+  by_contra hn
+  have hsub : γ '' Icc s t ⊆ range ((↑) : ℝ → ℂ) := by
+    rintro z ⟨u, hu, rfl⟩
+    have hi : (γ u).im = 0 := le_antisymm
+      (le_of_not_gt (fun hp => hn ⟨u, hu, hp⟩)) (hH u)
+    refine ⟨(γ u).re, ?_⟩
+    apply Complex.ext <;> simp [hi]
+  have hz : μ (γ '' Icc s t) = 0 := measure_mono_null hsub hnull
+  simp only [hz, lt_self_iff_false] at hpos
+
+/-- Positive mass on every positive-time segment makes the interior trace
+visits dense, including at time zero. -/
+theorem dense_interior_times
+    (γ : ℝ≥0 → ℂ) (μ : Measure ℂ) (hH : ∀ u, 0 ≤ (γ u).im)
+    (hnull : μ (range ((↑) : ℝ → ℂ)) = 0)
+    (hpos : ∀ s t : ℝ≥0, 0 < s → s < t → 0 < μ (γ '' Icc s t)) :
+    Dense {u : ℝ≥0 | γ u ∈ upperHalfPlane} := by
+  apply dense_of_exists_between
+  intro a b hab
+  obtain ⟨s, has, hsb⟩ := exists_between hab
+  obtain ⟨t, hst, htb⟩ := exists_between hsb
+  obtain ⟨u, hu, hγu⟩ := segment_has_interior_time γ μ hH hnull
+    (hpos s t (lt_of_le_of_lt (show (0 : ℝ≥0) ≤ a from bot_le) has) hst)
+  exact ⟨u, hγu, has.trans_le hu.1, hu.2.trans_lt htb⟩
+
+local instance : MeasurableSpace C(ℝ≥0, ℂ) := borel _
+local instance : BorelSpace C(ℝ≥0, ℂ) := ⟨rfl⟩
+local instance : MeasurableSpace C(ℝ≥0, ℝ) := borel _
+local instance : BorelSpace C(ℝ≥0, ℝ) := ⟨rfl⟩
+
+/-- Countably many open hit tests encode dense interior trace times. -/
+def CountableInteriorHits (p : C(ℝ≥0, ℂ)) : Prop :=
+  ∀ i j : ℕ, denseSeq ℝ≥0 i < denseSeq ℝ≥0 j →
+    ∃ k : ℕ, denseSeq ℝ≥0 i < denseSeq ℝ≥0 k ∧
+      denseSeq ℝ≥0 k < denseSeq ℝ≥0 j ∧ p (denseSeq ℝ≥0 k) ∈ upperHalfPlane
+
+theorem countableInteriorHits_iff (p : C(ℝ≥0, ℂ)) :
+    CountableInteriorHits p ↔ Dense {t : ℝ≥0 | p t ∈ upperHalfPlane} := by
+  constructor
+  · intro hh
+    apply dense_of_exists_between
+    intro a b hab
+    obtain ⟨i, hi⟩ := (denseRange_denseSeq ℝ≥0).exists_mem_open isOpen_Ioo
+      (nonempty_Ioo.mpr hab)
+    obtain ⟨j, hj⟩ := (denseRange_denseSeq ℝ≥0).exists_mem_open isOpen_Ioo
+      (nonempty_Ioo.mpr hi.2)
+    obtain ⟨k, hik, hkj, hk⟩ := hh i j hj.1
+    exact ⟨denseSeq ℝ≥0 k, hk, hi.1.trans hik, hkj.trans hj.2⟩
+  · intro hd i j hij
+    obtain ⟨t, htH, ht⟩ := hd.exists_between hij
+    obtain ⟨k, hk⟩ := (denseRange_denseSeq ℝ≥0).exists_mem_open
+      (isOpen_Ioo.inter (isOpen_upperHalfPlane.preimage p.continuous)) ⟨t, ht, htH⟩
+    exact ⟨k, hk.1.1, hk.1.2, hk.2⟩
+
+theorem measurableSet_countableInteriorHits :
+    MeasurableSet {p : C(ℝ≥0, ℂ) | CountableInteriorHits p} := by
+  simp only [CountableInteriorHits, ofPred_forall]
+  apply MeasurableSet.iInter
+  intro i
+  apply MeasurableSet.iInter
+  intro j
+  by_cases hij : denseSeq ℝ≥0 i < denseSeq ℝ≥0 j
+  · simp only [hij, iInter_true, ofPred_exists]
+    apply MeasurableSet.iUnion
+    intro k
+    by_cases hk : denseSeq ℝ≥0 i < denseSeq ℝ≥0 k ∧
+        denseSeq ℝ≥0 k < denseSeq ℝ≥0 j
+    · simp only [hk.1, hk.2, true_and]
+      exact (isOpen_upperHalfPlane.preimage (continuous_eval_const _)).measurableSet
+    · have he : {p : C(ℝ≥0, ℂ) | denseSeq ℝ≥0 i < denseSeq ℝ≥0 k ∧
+          denseSeq ℝ≥0 k < denseSeq ℝ≥0 j ∧ p (denseSeq ℝ≥0 k) ∈ upperHalfPlane} = ∅ := by
+        ext p
+        simp only [mem_ofPred_eq, mem_empty_iff_false, iff_false]
+        exact fun hp => hk ⟨hp.1, hp.2.1⟩
+      rw [he]
+      exact MeasurableSet.empty
+  · simp only [hij, iInter_false]
+    exact MeasurableSet.univ
+
+def GoodBoundaryPath (p : C(ℝ≥0, ℂ)) : Prop :=
+  CountableInteriorHits p ∧ ∀ t, 0 ≤ (p t).im
+
+theorem measurableSet_goodBoundaryPath :
+    MeasurableSet {p : C(ℝ≥0, ℂ) | GoodBoundaryPath p} := by
+  change MeasurableSet ({p : C(ℝ≥0, ℂ) | CountableInteriorHits p} ∩
+    {p : C(ℝ≥0, ℂ) | ∀ t, 0 ≤ (p t).im})
+  apply measurableSet_countableInteriorHits.inter
+  have he : {p : C(ℝ≥0, ℂ) | ∀ t, 0 ≤ (p t).im} =
+      ⋂ t : ℝ≥0, {p : C(ℝ≥0, ℂ) | 0 ≤ (p t).im} := by ext p; simp
+  rw [he]
+  exact (isClosed_iInter (fun t => isClosed_le continuous_const
+    (Complex.continuous_im.comp (continuous_eval_const t)))).measurableSet
+
+/-- Only continuity and density are needed to fill in the boundary-time
+values of an inverse-chart identity. -/
+theorem extend_restart_identity
+    (p : C(ℝ≥0, ℂ)) (γ : ℝ≥0 → ℂ) (hγ : Continuous γ)
+    (Fbar : ℂ → OnePoint ℂ)
+    (hFbar : ContinuousOn Fbar {z : ℂ | 0 ≤ z.im})
+    (hp : GoodBoundaryPath p)
+    (heq : ∀ t, p t ∈ upperHalfPlane → (γ t : OnePoint ℂ) = Fbar (p t)) :
+    ∀ t, (γ t : OnePoint ℂ) = Fbar (p t) := by
+  have hc : Continuous (Fbar ∘ p) := hFbar.comp_continuous p.continuous hp.2
+  have hset : IsClosed {t : ℝ≥0 | (γ t : OnePoint ℂ) = Fbar (p t)} :=
+    isClosed_eq (OnePoint.continuous_coe.comp hγ) hc
+  have hsub : {t : ℝ≥0 | p t ∈ upperHalfPlane} ⊆
+      {t : ℝ≥0 | (γ t : OnePoint ℂ) = Fbar (p t)} := fun t ht => heq t ht
+  have hall := closure_minimal hsub hset
+  rw [(countableInteriorHits_iff p).mp hp.1 |>.closure_eq] at hall
+  exact fun t => hall (mem_univ t)
+
+/-- The proved lower Hausdorff estimate and real-axis nullity give the
+measurable dense-interior path property for ordinary SLE. -/
+theorem ordinarySLE_ae_goodBoundaryPath
+    {Ω : Type*} [MeasurableSpace Ω] {P : Measure Ω} [IsProbabilityMeasure P]
+    {κ : ℝ} (hκ : 0 < κ) (hκ8 : κ < 8)
+    (γ : Ω → ℝ≥0 → ℂ) (hcont : ∀ ω, Continuous (γ ω))
+    (hSLE : IsOrdinaryChordalSLE κ γ P) :
+    ∀ᵐ ω ∂P, GoodBoundaryPath (sourceTracePath γ hcont ω) := by
+  obtain ⟨_, _, htrace⟩ := hSLE.2
+  have hpos := sourceLowerMain_proved Ω inferInstance P inferInstance κ hκ hκ8
+    γ hSLE (explicitGauge κ)
+    (explicitGauge_isGauge hκ)
+    (explicitGauge_small_formula κ)
+  have hnull := explicit_gauge_real_axis_null hκ
+    (explicitGauge_isGauge hκ)
+    (explicitGauge_small_formula κ)
+  filter_upwards [hpos, htrace] with ω hp ht
+  obtain ⟨G, F, hw⟩ := ht
+  refine ⟨(countableInteriorHits_iff _).mpr ?_, hw.2.2.1⟩
+  exact dense_interior_times (γ ω) (hausdorffGauge (explicitGauge κ))
+    hw.2.2.1 hnull hp
+
+/-- The actual stopped trace law admits the continuous boundary restart
+identity at every future time, conditional only on the cited deterministic
+Rohde–Schramm boundary-extension input. -/
+theorem stopped_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) :
+    ∃ Φ : 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))),
+        (∀ (A : Set Ω), MeasurableSet[hτ.measurableSpace] A →
+          (P.restrict A).map (fun ω => Φ (sourceRestartDriverPath B hc τ ω)) =
+            P A • P.map (sourceTracePath γ (fun ω => (hw ω).1))) ∧
+        (∀ᵐ ω ∂P, ∃ Fbar : ℂ → OnePoint ℂ,
+          ContinuousOn Fbar {z : ℂ | 0 ≤ z.im} ∧
+          (∀ z ∈ upperHalfPlane, Fbar z =
+            (F ω (τ ω) ((Real.sqrt κ * B (τ ω) ω : ℝ) + z) : OnePoint ℂ)) ∧
+          Fbar 0 = (γ ω (τ ω) : OnePoint ℂ) ∧
+          ∀ t : ℝ≥0, (γ ω (τ ω + t) : OnePoint ℂ) =
+            Fbar (Φ (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
+  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 : ∀ᵐ ω ∂P, GoodBoundaryPath (gp ω) :=
+    ordinarySLE_ae_goodBoundaryPath hκ hκ8 γ (fun ω => (hw ω).1) hSLE
+  have hgoodLaw : ∀ᵐ p ∂P.map gp, GoodBoundaryPath p :=
+    (ae_map_iff hgm.aemeasurable measurableSet_goodBoundaryPath).mpr hgood
+  refine ⟨Φ, hΦm, hΦ, ?_⟩
+  intro τ hτ
+  refine ⟨(hlaw τ hτ).1, ?_⟩
+  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, GoodBoundaryPath (Φ (rp ω)) := by
+    have he := hgoodLaw
+    rw [← hrestartLaw] at he
+    exact (ae_map_iff (hΦm.comp hrm).aemeasurable measurableSet_goodBoundaryPath).mp he
+  filter_upwards [hgoodRestart, (hlaw τ hτ).2] with ω hgoodω heq
+  obtain ⟨Fbar, hFc, hFH, hF0⟩ := normalized_capacity_inverse_boundary_extension
+    hpublished (continuous_const.mul (hc ω)) (hw ω) (τ ω) 1 zero_lt_one
+  have hFH' : ∀ z ∈ upperHalfPlane, Fbar z =
+      (F ω (τ ω) ((Real.sqrt κ * B (τ ω) ω : ℝ) + z) : OnePoint ℂ) := by
+    simpa only [Complex.ofReal_one, one_mul, Pi.mul_apply] using hFH
+  refine ⟨Fbar, hFc, hFH', hF0, ?_⟩
+  apply extend_restart_identity (Φ (rp ω)) (fun t => γ ω (τ ω + t))
+    ((hw ω).1.comp (continuous_const.add continuous_id)) Fbar hFc hgoodω
+  intro t ht
+  rw [hFH' _ ht, heq t ht, add_comm (Φ (rp ω) t)]
+
+/-- A tube event maps back to the physical domain at every time, including
+boundary visits, under the continuous boundary restart identity. -/
+theorem boundary_restart_tube_transfer
+    (p : C(ℝ≥0, ℂ)) (γ : ℝ≥0 → ℂ) (τ : ℝ≥0) (Fbar : ℂ → OnePoint ℂ)
+    (heq : ∀ t, (γ (τ + t) : OnePoint ℂ) = Fbar (p t))
+    (N V O W : Set ℂ)
+    (hN : MapsTo Fbar N (((↑) : ℂ → OnePoint ℂ) '' O))
+    (hV : MapsTo Fbar V (((↑) : ℂ → OnePoint ℂ) '' W))
+    (hp : p ∈ pathTubeEvent N V) :
+    ∃ T : ℝ≥0, 0 < T ∧ MapsTo (fun t => γ (τ + t)) (Icc 0 T) O ∧ γ (τ + T) ∈ W := by
+  obtain ⟨T, hT, hpN, hpV⟩ := hp
+  have hmap {A S : Set ℂ} (hh : MapsTo Fbar A (((↑) : ℂ → OnePoint ℂ) '' S))
+      (t : ℝ≥0) (ht : p t ∈ A) : γ (τ + t) ∈ S := by
+    obtain ⟨z, hz, he⟩ := hh ht
+    have hz' : z = γ (τ + t) := OnePoint.coe_injective (he.trans (heq t).symm)
+    exact hz' ▸ hz
+  exact ⟨T, hT, fun t ht => hmap hN t (hpN ht), hmap hV T hpV⟩
+
+/-- A past-restricted stopped-law tube probability is a lower bound for
+any physical event containing that tube almost surely. This formulation
+uses the full-measure boundary restart identity without imposing pathwise
+identities on exceptional samples. -/
+theorem restricted_tube_probability_le
+    {Ω : Type*} [MeasurableSpace Ω] {P : Measure Ω}
+    (p : Ω → C(ℝ≥0, ℂ)) (hp : Measurable p) (Q : Measure C(ℝ≥0, ℂ))
+    (A C : Set Ω) (hC : MeasurableSet C) (N V : Set ℂ)
+    (hN : IsOpen N) (hV : IsOpen V)
+    (hlaw : (P.restrict A).map p = P A • Q)
+    (htransfer : ∀ᵐ ω ∂P, p ω ∈ pathTubeEvent N V → ω ∈ C) :
+    P A * Q (pathTubeEvent N V) ≤ P (A ∩ C) := by
+  have ht := measurableSet_pathTubeEvent hN hV
+  calc
+    P A * Q (pathTubeEvent N V) = (P.restrict A).map p (pathTubeEvent N V) := by
+      rw [hlaw, Measure.smul_apply, smul_eq_mul]
+    _ = (P.restrict A) (p ⁻¹' pathTubeEvent N V) := Measure.map_apply hp ht
+    _ ≤ (P.restrict A) C := measure_mono_ae (ae_restrict_of_ae htransfer)
+    _ = P (A ∩ C) := by rw [Measure.restrict_apply hC, inter_comm]
+
+end SLEExactGauge.StoppedBoundaryRestart
+
+end
+
+end OAI
diff --git a/lean/OAI/Probability/SLE/Geometry/StoppedFutureGreen.lean b/lean/OAI/Probability/SLE/Geometry/StoppedFutureGreen.lean
new file mode 100644
index 0000000000000000000000000000000000000000..03a241b719541d4825ed5640c01bf30431dcb429
--- /dev/null
+++ b/lean/OAI/Probability/SLE/Geometry/StoppedFutureGreen.lean
@@ -0,0 +1,85 @@
+import OAI.Probability.SLE.Geometry.RestartFutureGreen
+import OAI.Probability.SLE.Geometry.CanonicalGreenPast
+import OAI.Probability.SLE.Mass.StoppedInverseMass
+
+namespace OAI
+
+/-! Every later Green remainder transforms under the same stopped inverse
+map and the same derivative weight as the canonical mass. -/
+
+noncomputable section
+open Set Filter _root_.MeasureTheory _root_.OAI.MeasureTheory Classical
+open scoped NNReal ENNReal Topology
+
+namespace SLEExactGauge.Multipoint
+
+local instance stoppedFutureGreenDriverMeasurable : MeasurableSpace C(ℝ≥0,ℝ) := borel _
+local instance stoppedFutureGreenDriverBorel : BorelSpace C(ℝ≥0,ℝ) := ⟨rfl⟩
+
+ theorem stopped_future_green_covariance
+    {Ω : Type*} [MeasurableSpace Ω] {P : Measure Ω}
+    (B : ℝ≥0 → Ω → ℝ) (κ : ℝ) (γ : Ω → ℝ≥0 → ℂ)
+    (G F : Ω → ℝ≥0 → ℂ → ℂ)
+    (hw : ∀ ω, IsCapacityTwoWitness (fun t => Real.sqrt κ*B t ω) (γ ω) (G ω) (F ω))
+    (τ : Ω → ℝ≥0) (hm : ∀ t, Measurable (B t))
+    (hc : ∀ ω, Continuous (fun t => B t ω))
+    (hτ : IsStoppingTime (Filtration.natural B (fun t => (hm t).stronglyMeasurable))
+      (fun ω => (τ ω:WithTop ℝ≥0))) (hκ : 0 < κ)
+    (hFresh : ∀ᵐ ω ∂P, ∃ (β : ℝ≥0 → ℂ) (G' F' : ℝ≥0 → ℂ → ℂ),
+      IsCapacityTwoWitness (fun t => Real.sqrt κ*B (τ ω+t) ω-Real.sqrt κ*B (τ ω) ω) β G' F') :
+    ∀ᵐ ω ∂P, ∀ t : ℝ≥0,
+      weightedImageMass (stoppedMassPoint B κ γ G F hw τ ω) (stoppedMassWeight B κ F τ ω)
+        (canonicalGreenMass κ t (sourceRestartDriverPath B hc τ ω)) =
+      halfPlaneGreenMeasure κ B γ G (τ ω+t) ω := by
+  have hJ := stoppedMassPoint_measurable B κ γ G F hw τ hm hc hτ
+  have hW := stoppedMassWeight_measurable B κ γ G F hw τ hm hc hτ hκ
+  filter_upwards [hFresh] with ω hω
+  obtain ⟨β,G',F',hb⟩ := hω
+  have hb' : IsCapacityTwoWitness
+      (fun s => Real.sqrt κ*(sourceRestartDriverPath B hc τ ω) s) β G' F' := by
+    convert hb using 1
+    funext s
+    change Real.sqrt κ*(B (τ ω+s) ω-B (τ ω) ω) = _
+    ring
+  have hpair : @Measurable upperHalfPlane (Ω × upperHalfPlane) inferInstance
+      (hτ.measurableSpace.prod inferInstance) (fun z => (ω,z)) :=
+    @measurable_prodMk_left Ω upperHalfPlane hτ.measurableSpace inferInstance ω
+  have hJω : Measurable (stoppedMassPoint B κ γ G F hw τ ω) :=
+    @Measurable.comp upperHalfPlane (Ω × upperHalfPlane) upperHalfPlane
+      inferInstance (hτ.measurableSpace.prod inferInstance) inferInstance
+      (fun p => stoppedMassPoint B κ γ G F hw τ p.1 p.2) (fun z => (ω,z)) hJ hpair
+  have hWω : Measurable (stoppedMassWeight B κ F τ ω) :=
+    @Measurable.comp upperHalfPlane (Ω × upperHalfPlane) ℝ≥0∞
+      inferInstance (hτ.measurableSpace.prod inferInstance) inferInstance
+      (fun p => stoppedMassWeight B κ F τ p.1 p.2) (fun z => (ω,z)) hW hpair
+  intro t
+  rw [canonicalGreenMass_eq κ _ hb' t]
+  have hdriver : (fun s => Real.sqrt κ*(sourceRestartDriverPath B hc τ ω) s) =
+      (fun s => Real.sqrt κ*B (τ ω+s) ω-Real.sqrt κ*B (τ ω) ω) := by
+    funext s
+    change Real.sqrt κ*(B (τ ω+s) ω-B (τ ω) ω) = _
+    ring
+  rw [hdriver]
+  apply Measure.ext
+  intro A hA
+  let f : upperHalfPlane → ℝ≥0∞ := A.indicator (fun _ => 1)
+  have hf : Measurable f := measurable_const.indicator hA
+  have htest := restart_future_halfPlane_green_test (hw ω) ((hc ω).const_mul _)
+    (τ ω) hb hκ t f
+  calc
+    _ = ∫⁻ z, f z ∂weightedImageMass (stoppedMassPoint B κ γ G F hw τ ω)
+        (stoppedMassWeight B κ F τ ω)
+        ((volume.withDensity (fun z => ENNReal.ofReal
+          (greenDensity κ (fun s => Real.sqrt κ*B (τ ω+s) ω-Real.sqrt κ*B (τ ω) ω)
+            β G' t z))).comap Subtype.val) := by
+      rw [lintegral_indicator hA,lintegral_one,Measure.restrict_apply_univ]
+    _ = _ := (weightedImageMass_lintegral _ hJω _ hWω _ f hf).trans htest
+    _ = halfPlaneGreenMeasure κ B γ G (τ ω+t) ω A := by
+      rw [lintegral_indicator hA,lintegral_one,Measure.restrict_apply_univ]
+      rfl
+
+end SLEExactGauge.Multipoint
+
+end
+
+end OAI
diff --git a/lean/OAI/Probability/SLE/Geometry/StoppedMarkedStateMeasurability.lean b/lean/OAI/Probability/SLE/Geometry/StoppedMarkedStateMeasurability.lean
new file mode 100644
index 0000000000000000000000000000000000000000..04876c63dab6a7ebcb2ef757fc5355f164c265e0
--- /dev/null
+++ b/lean/OAI/Probability/SLE/Geometry/StoppedMarkedStateMeasurability.lean
@@ -0,0 +1,170 @@
+import OAI.Probability.SLE.ChartMeasurability
+import OAI.Probability.SLE.Geometry.NormalizedMarkedState
+
+namespace OAI
+
+/-! Actual finite-stop marked states are measurable in the stopped past.
+The scale is positive on every outcome and agrees with the true centered
+modulus on the live event. -/
+
+noncomputable section
+open Set Filter MeasureTheory ProbabilityTheory Classical
+open scoped Topology NNReal ENNReal
+
+namespace SLEExactGauge
+
+def positiveMarkedScale (q : ℂ) : ℝ≥0 := if 0 < ‖q‖ then ‖q‖₊ else 1
+
+lemma positiveMarkedScale_pos (q : ℂ) : 0 < positiveMarkedScale q := by
+  unfold positiveMarkedScale
+  split_ifs with hq
+  · exact_mod_cast hq
+  · exact zero_lt_one
+
+lemma positiveMarkedScale_eq {q : ℂ} (hq : q ≠ 0) : positiveMarkedScale q = ‖q‖₊ := by
+  exact ite_eq_left (norm_pos_iff.mpr hq)
+
+lemma positiveMarkedScale_measurable : Measurable positiveMarkedScale :=
+  Measurable.ite (measurableSet_lt measurable_const measurable_norm)
+    measurable_nnnorm measurable_const
+
+lemma unitMarkedState_measurable : Measurable unitMarkedState := by
+  unfold unitMarkedState
+  fun_prop
+
+def stoppedMarkedCenter {Ω : Type*} (κ : ℝ) (B : ℝ≥0 → Ω → ℝ)
+    (γ : Ω → ℝ≥0 → ℂ) (G : Ω → ℝ≥0 → ℂ → ℂ) (τ : Ω → ℝ≥0)
+    (z : ℂ) (ω : Ω) : ℂ :=
+  (if z ∈ survivingDomain (γ ω) (τ ω) then G ω (τ ω) z else 0) -
+    (Real.sqrt κ * B (τ ω) ω : ℝ)
+
+def stoppedMarkedScale {Ω : Type*} (κ : ℝ) (B : ℝ≥0 → Ω → ℝ)
+    (γ : Ω → ℝ≥0 → ℂ) (G : Ω → ℝ≥0 → ℂ → ℂ) (τ : Ω → ℝ≥0)
+    (z : ℂ) (ω : Ω) : ℝ≥0 := positiveMarkedScale (stoppedMarkedCenter κ B γ G τ z ω)
+
+def stoppedMarkedUnit {Ω : Type*} (κ : ℝ) (B : ℝ≥0 → Ω → ℝ)
+    (γ : Ω → ℝ≥0 → ℂ) (G : Ω → ℝ≥0 → ℂ → ℂ) (τ : Ω → ℝ≥0)
+    (z : ℂ) (ω : Ω) : ℂ := unitMarkedState (stoppedMarkedCenter κ B γ G τ z ω)
+
+def stoppedMarkedGood {Ω : Type*} (κ : ℝ) (B : ℝ≥0 → Ω → ℝ)
+    (γ : Ω → ℝ≥0 → ℂ) (G : Ω → ℝ≥0 → ℂ → ℂ) (τ : Ω → ℝ≥0)
+    (z : ℂ) (s : ℝ) : Set Ω :=
+  {ω | z ∈ survivingDomain (γ ω) (τ ω) ∧ s ≤ (stoppedMarkedUnit κ B γ G τ z ω).im}
+
+lemma stoppedMarkedScale_pos {Ω : Type*} (κ : ℝ) (B : ℝ≥0 → Ω → ℝ)
+    (γ : Ω → ℝ≥0 → ℂ) (G : Ω → ℝ≥0 → ℂ → ℂ) (τ : Ω → ℝ≥0)
+    (z : ℂ) (ω : Ω) : 0 < stoppedMarkedScale κ B γ G τ z ω :=
+  positiveMarkedScale_pos _
+
+lemma stoppedMarkedCenter_eq {Ω : Type*} (κ : ℝ) (B : ℝ≥0 → Ω → ℝ)
+    (γ : Ω → ℝ≥0 → ℂ) (G : Ω → ℝ≥0 → ℂ → ℂ) (τ : Ω → ℝ≥0)
+    (z : ℂ) (ω : Ω) (hz : z ∈ survivingDomain (γ ω) (τ ω)) :
+    stoppedMarkedCenter κ B γ G τ z ω = G ω (τ ω) z - (Real.sqrt κ * B (τ ω) ω : ℝ) := by
+  rw [stoppedMarkedCenter, ite_eq_left hz]
+
+section Source
+variable {Ω : Type*} [MeasurableSpace Ω]
+  (B : ℝ≥0 → Ω → ℝ) (hm : ∀ t, Measurable (B t))
+  (hc : ∀ ω, Continuous (fun t => B t ω))
+  (κ : ℝ) (γ : Ω → ℝ≥0 → ℂ) (G F : Ω → ℝ≥0 → ℂ → ℂ)
+  (hw : ∀ ω, IsCapacityTwoWitness (fun t => Real.sqrt κ * B t ω) (γ ω) (G ω) (F ω))
+  (τ : Ω → ℝ≥0)
+  (hτ : IsStoppingTime (Filtration.natural B (fun t => (hm t).stronglyMeasurable))
+    (fun ω => (τ ω : WithTop ℝ≥0)))
+
+include hc in
+lemma source_stoppedDriver_measurable :
+    Measurable[hτ.measurableSpace] (fun ω => Real.sqrt κ * B (τ ω) ω) := by
+  have hb := measurable_stoppedValue
+    ((Filtration.stronglyAdapted_natural (fun t => (hm t).stronglyMeasurable)).isStronglyProgressive_of_continuous hc) hτ
+  exact measurable_const.mul hb
+
+include hc hw in
+lemma source_stoppedMarkedCenter_measurable (z : ℂ) :
+    Measurable[hτ.measurableSpace] (stoppedMarkedCenter κ B γ G τ z) := by
+  exact (source_killedChart_stopped_measurable hm hc κ γ G F hw z τ hτ).sub
+    (Complex.measurable_ofReal.comp (source_stoppedDriver_measurable B hm hc κ τ hτ))
+
+include hc hw in
+lemma source_stoppedMarkedScale_measurable (z : ℂ) :
+    Measurable[hτ.measurableSpace] (stoppedMarkedScale κ B γ G τ z) :=
+  positiveMarkedScale_measurable.comp
+    (source_stoppedMarkedCenter_measurable B hm hc κ γ G F hw τ hτ z)
+
+include hc hw in
+lemma source_stoppedMarkedUnit_measurable (z : ℂ) :
+    Measurable[hτ.measurableSpace] (stoppedMarkedUnit κ B γ G τ z) :=
+  unitMarkedState_measurable.comp
+    (source_stoppedMarkedCenter_measurable B hm hc κ γ G F hw τ hτ z)
+
+omit [MeasurableSpace Ω] in
+include hw in
+lemma source_stopped_live_iff_killedChart_im_pos (z : ℂ) (ω : Ω) :
+    z ∈ survivingDomain (γ ω) (τ ω) ↔
+      0 < (if z ∈ survivingDomain (γ ω) (τ ω) then G ω (τ ω) z else 0).im := by
+  by_cases hz : z ∈ survivingDomain (γ ω) (τ ω)
+  · simp only [ite_eq_left hz]
+    exact iff_of_true hz ((hw ω).imag_positive (τ ω) z hz)
+  · simp only [ite_eq_right hz, Complex.zero_im, lt_self_iff_false, iff_false]
+    exact hz
+
+include hc hw in
+lemma source_stopped_live_measurable (z : ℂ) :
+    MeasurableSet[hτ.measurableSpace] {ω | z ∈ survivingDomain (γ ω) (τ ω)} := by
+  have he : {ω | z ∈ survivingDomain (γ ω) (τ ω)} =
+      {ω | 0 < (if z ∈ survivingDomain (γ ω) (τ ω) then G ω (τ ω) z else 0).im} := by
+    ext ω
+    exact source_stopped_live_iff_killedChart_im_pos B κ γ G F hw τ z ω
+  rw [he]
+  exact measurableSet_lt measurable_const (Complex.measurable_im.comp
+    (source_killedChart_stopped_measurable hm hc κ γ G F hw z τ hτ))
+
+include hc hw in
+lemma source_stoppedMarkedGood_measurable (z : ℂ) (s : ℝ) :
+    MeasurableSet[hτ.measurableSpace] (stoppedMarkedGood κ B γ G τ z s) :=
+  (source_stopped_live_measurable B hm hc κ γ G F hw τ hτ z).inter
+    (measurableSet_le measurable_const (Complex.measurable_im.comp
+      (source_stoppedMarkedUnit_measurable B hm hc κ γ G F hw τ hτ z)))
+
+omit [MeasurableSpace Ω] in
+include hw in
+lemma stoppedMarkedScale_eq_on_live (z : ℂ) (ω : Ω)
+    (hz : z ∈ survivingDomain (γ ω) (τ ω)) :
+    stoppedMarkedScale κ B γ G τ z ω =
+      ‖G ω (τ ω) z - (Real.sqrt κ * B (τ ω) ω : ℝ)‖₊ := by
+  unfold stoppedMarkedScale
+  rw [stoppedMarkedCenter_eq κ B γ G τ z ω hz]
+  exact positiveMarkedScale_eq ((hw ω).centered_ne_zero _ z hz)
+
+omit [MeasurableSpace Ω] in
+lemma stoppedMarkedUnit_im_on_live (z : ℂ) (ω : Ω)
+    (hz : z ∈ survivingDomain (γ ω) (τ ω)) :
+    (stoppedMarkedUnit κ B γ G τ z ω).im =
+      Real.sin (Complex.arg (G ω (τ ω) z - (Real.sqrt κ * B (τ ω) ω : ℝ))) := by
+  unfold stoppedMarkedUnit
+  rw [stoppedMarkedCenter_eq κ B γ G τ z ω hz, unitMarkedState_im]
+
+omit [MeasurableSpace Ω] in
+include hc hw in
+/-- Exact geometric data required by the conformal dense estimate. -/
+theorem source_stoppedMarkedState_geometry (z : ℂ) (ω : Ω)
+    (hz : z ∈ survivingDomain (γ ω) (τ ω)) :
+    let w := stoppedMarkedUnit κ B γ G τ z ω
+    let f := normalizedInverse (F ω (τ ω)) (Real.sqrt κ * B (τ ω) ω)
+      (stoppedMarkedScale κ B γ G τ z ω : ℝ)
+    ‖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 ω) (τ ω) z := by
+  dsimp only
+  rw [stoppedMarkedScale_eq_on_live B κ γ G F hw τ z ω hz]
+  simp only [coe_nnnorm]
+  unfold stoppedMarkedUnit
+  rw [stoppedMarkedCenter_eq κ B γ G τ z ω hz]
+  exact (hw ω).normalized_marked_state ((hc ω).const_mul _) (τ ω) z hz
+
+end Source
+end SLEExactGauge
+
+end
+
+end OAI
diff --git a/lean/OAI/Probability/SLE/Geometry/StrictRealLocalChart.lean b/lean/OAI/Probability/SLE/Geometry/StrictRealLocalChart.lean
new file mode 100644
index 0000000000000000000000000000000000000000..ad37a94d9e4792c86c3d6269c105e49b4c706eae
--- /dev/null
+++ b/lean/OAI/Probability/SLE/Geometry/StrictRealLocalChart.lean
@@ -0,0 +1,44 @@
+import OAI.Probability.SLE.Loewner.SlitReciprocalChart
+import OAI.Probability.SLE.DiskHalfPlane
+
+namespace OAI
+
+/-! A reflection-symmetric analytic germ tangent to the identity preserves
+the upper side in a sufficiently small neighborhood. -/
+noncomputable section
+open Set Filter Complex Function Metric
+open scoped Topology ComplexConjugate
+
+namespace SLEExactGauge
+
+lemma strict_real_germ_maps_upper {D : Set ℂ} (hD : D ∈ 𝓝 (0:ℂ))
+    {f : ℂ → ℂ} (hf : HasStrictDerivAt f 1 0)
+    (hs : ∀ z ∈ D, f (conj z)=conj (f z)) :
+    ∃ r : ℝ, 0<r ∧ MapsTo f (ball 0 r ∩ upperHalfPlane) upperHalfPlane := by
+  have hd : HasStrictFDerivAt (fun z : ℂ => f z-z) (0:ℂ →L[ℂ] ℂ) 0 := by
+    convert! (hf.sub (hasStrictDerivAt_id (0:ℂ))).hasStrictFDerivAt using 1
+    simp
+  obtain ⟨S,hS,hL⟩ := hd.exists_lipschitzOnWith_of_nnnorm_lt (1/2) (by simp)
+  obtain ⟨r,hr,hrS⟩ := Metric.mem_nhds_iff.mp (inter_mem hS hD)
+  refine ⟨r,hr,?_⟩
+  intro z hz
+  have hcz : conj z ∈ ball (0:ℂ) r := by
+    simpa only [mem_ball,dist_zero_right,norm_conj] using hz.1
+  have hbound := hL.norm_sub_le (hrS hz.1).1 (hrS hcz).1
+  have hnorm : ‖z-conj z‖=2*z.im := by
+    simpa only [star_def] using norm_sub_conj_of_im_pos hz.2
+  rw [hnorm] at hbound
+  have hlo := (neg_le_abs _).trans
+    (Complex.abs_im_le_norm (f z-z-(f (conj z)-conj z)))
+  rw [hs z (hrS hz.1).2] at hlo hbound
+  simp only [sub_im,conj_im] at hlo
+  change 0 < (f z).im
+  have hzH : 0 < z.im := hz.2
+  norm_num at hbound
+  linarith
+
+end SLEExactGauge
+
+end
+
+end OAI
diff --git a/lean/OAI/Probability/SLE/Geometry/SubarcParameter.lean b/lean/OAI/Probability/SLE/Geometry/SubarcParameter.lean
new file mode 100644
index 0000000000000000000000000000000000000000..97993cf0539ba7e246807fe1c75f32a112da787c
--- /dev/null
+++ b/lean/OAI/Probability/SLE/Geometry/SubarcParameter.lean
@@ -0,0 +1,44 @@
+import OAI.Probability.SLE.Loewner.InitialSubarcReparam
+
+namespace OAI
+
+/-! Continuous rescaling onto a fixed initial parameter interval. -/
+noncomputable section
+open Set Filter Function
+open scoped Topology
+
+namespace SLEExactGauge
+
+def subarcParameter (b : unitInterval) (hb : b≠0) (t : unitInterval) : unitInterval :=
+  ⟨min ((t:ℝ)/(b:ℝ)) 1,
+    le_min (div_nonneg t.property.1 (unitInterval.pos_iff_ne_zero.mpr hb).le)
+      zero_le_one,min_le_right _ _⟩
+
+lemma subarcParameter_continuous (b : unitInterval) (hb : b≠0) :
+    Continuous (subarcParameter b hb) := by
+  apply Continuous.subtype_mk
+  exact (continuous_subtype_val.div_const (b:ℝ)).min continuous_const
+
+lemma subarcParameter_mul (b : unitInterval) (hb : b≠0) (t : unitInterval) :
+    b*subarcParameter b hb t=min t b := by
+  have hbpos : 0<(b:ℝ) := unitInterval.pos_iff_ne_zero.mpr hb
+  apply Subtype.ext
+  change (b:ℝ)*min ((t:ℝ)/(b:ℝ)) 1=min (t:ℝ) (b:ℝ)
+  rw [mul_min_of_nonneg _ _ hbpos.le,mul_div_cancel₀ _ hbpos.ne',mul_one]
+
+@[simp] lemma subarcParameter_self (b : unitInterval) (hb : b≠0) :
+    subarcParameter b hb b=1 := by
+  have hbpos : 0<(b:ℝ) := unitInterval.pos_iff_ne_zero.mpr hb
+  apply Subtype.ext
+  change min ((b:ℝ)/(b:ℝ)) 1=1
+  rw [div_self hbpos.ne',min_self]
+
+lemma subarcParameter_mul_of_le (b : unitInterval) (hb : b≠0)
+    {t : unitInterval} (ht : t≤b) : b*subarcParameter b hb t=t := by
+  rw [subarcParameter_mul,min_eq_left ht]
+
+end SLEExactGauge
+
+end
+
+end OAI
diff --git a/lean/OAI/Probability/SLE/Geometry/SymmetricChartUpperBijective.lean b/lean/OAI/Probability/SLE/Geometry/SymmetricChartUpperBijective.lean
new file mode 100644
index 0000000000000000000000000000000000000000..f3c026281cfb285408964048d757c9a9512c7d61
--- /dev/null
+++ b/lean/OAI/Probability/SLE/Geometry/SymmetricChartUpperBijective.lean
@@ -0,0 +1,49 @@
+import OAI.Probability.SLE.Geometry.RealSymmetricDiskMapSign
+
+namespace OAI
+
+/-! Restricting a symmetric disk chart to its upper component preserves
+surjectivity onto the upper half disk. -/
+noncomputable section
+open Set Complex
+open scoped ComplexConjugate
+
+namespace SLEExactGauge
+
+theorem symmetric_disk_chart_upper_bijOn {D : Set ℂ} {f : ℂ → ℂ}
+    (hD : MapsTo conj D D) (hb : BijOn f D (Metric.ball 0 1))
+    (hs : ∀ z ∈ D, f (conj z)=conj (f z))
+    (hu : MapsTo f (D ∩ upperHalfPlane) upperHalfPlane) :
+    BijOn f (D ∩ upperHalfPlane) (Metric.ball 0 1 ∩ upperHalfPlane) := by
+  refine ⟨fun z hz => ⟨hb.mapsTo hz.1,hu hz⟩,hb.injOn.mono inter_subset_left,?_⟩
+  intro w hw
+  obtain ⟨z,hz,hzw⟩ := hb.surjOn hw.1
+  refine ⟨z,⟨hz,?_⟩,hzw⟩
+  by_contra hn
+  have hzle : z.im ≤ 0 := le_of_not_gt hn
+  by_cases hz0 : z.im=0
+  · have hconj : conj z=z := by apply Complex.ext <;> simp [hz0]
+    have he := hs z hz
+    rw [hconj,hzw] at he
+    have him := congrArg Complex.im he
+    simp only [conj_im] at him
+    have hwH := hw.2
+    change 0 < w.im at hwH
+    linarith
+  · have hzneg : z.im < 0 := lt_of_le_of_ne hzle hz0
+    have hcH : conj z ∈ upperHalfPlane := by
+      change 0 < (conj z).im
+      simpa only [conj_im] using neg_pos.mpr hzneg
+    have hfH := hu ⟨hD hz,hcH⟩
+    rw [hs z hz,hzw] at hfH
+    change 0 < (conj w).im at hfH
+    rw [conj_im] at hfH
+    have hwH := hw.2
+    change 0 < w.im at hwH
+    linarith
+
+end SLEExactGauge
+
+end
+
+end OAI
diff --git a/lean/OAI/Probability/SLE/Geometry/SymmetricSlope.lean b/lean/OAI/Probability/SLE/Geometry/SymmetricSlope.lean
new file mode 100644
index 0000000000000000000000000000000000000000..008f4b413ff493351660e49001cfe29eb0e54d31
--- /dev/null
+++ b/lean/OAI/Probability/SLE/Geometry/SymmetricSlope.lean
@@ -0,0 +1,48 @@
+import OAI.Probability.SLE.Geometry.ReflectedRiemannSymmetry
+import Mathlib.Analysis.Complex.RemovableSingularity
+
+namespace OAI
+
+/-! Reflection is preserved by the removable difference quotient at the
+origin; consequently its Taylor coefficients there are real. -/
+noncomputable section
+open Set Filter Complex Function Metric
+open scoped Topology ComplexConjugate
+
+namespace SLEExactGauge
+
+lemma derivative_real_of_reflection {D : Set ℂ} (hD : D ∈ 𝓝 (0:ℂ))
+    {f : ℂ → ℂ} (hs : ∀ z ∈ D, f (conj z)=conj (f z)) :
+    conj (deriv f 0)=deriv f 0 := by
+  have he : (conj ∘ f ∘ conj) =ᶠ[𝓝 (0:ℂ)] f := by
+    filter_upwards [hD] with z hz
+    simp only [Function.comp_apply,hs z hz,conj_conj]
+  have hd := he.deriv_eq
+  simpa only [deriv_conj_conj,Function.comp_apply,map_zero] using hd
+
+lemma dslope_reflection {D : Set ℂ} (hD : D ∈ 𝓝 (0:ℂ))
+    {f : ℂ → ℂ} (hs : ∀ z ∈ D, f (conj z)=conj (f z)) :
+    ∀ z ∈ D, dslope f 0 (conj z)=conj (dslope f 0 z) := by
+  have hz : f 0=conj (f 0) := by simpa only [map_zero] using hs 0 (mem_of_mem_nhds hD)
+  intro z hzm
+  by_cases he : z=0
+  · simpa only [he,map_zero,dslope_same] using (derivative_real_of_reflection hD hs).symm
+  · have hec : conj z ≠ 0 := by
+      intro hc
+      apply he
+      simpa only [conj_conj,map_zero] using congrArg conj hc
+    simp only [dslope_of_ne _ he,dslope_of_ne _ hec,slope,vsub_eq_sub,sub_zero,
+      smul_eq_mul,hs z hzm,map_mul,map_inv₀,map_sub,hz.symm]
+
+lemma analyticAt_dslope_zero {f : ℂ → ℂ} (hf : AnalyticAt ℂ f 0) :
+    AnalyticAt ℂ (dslope f 0) 0 := by
+  obtain ⟨r,hr,ha⟩ := hf.exists_ball_analyticOnNhd
+  have hd := (Complex.differentiableOn_dslope (ball_mem_nhds (0:ℂ) hr)).mpr
+    ha.differentiableOn
+  exact hd.analyticAt (ball_mem_nhds (0:ℂ) hr)
+
+end SLEExactGauge
+
+end
+
+end OAI
diff --git a/lean/OAI/Probability/SLE/Geometry/ThinCrossingEnergy.lean b/lean/OAI/Probability/SLE/Geometry/ThinCrossingEnergy.lean
new file mode 100644
index 0000000000000000000000000000000000000000..27dc1f639c7efc81013cc37734d37d021ff731fc
--- /dev/null
+++ b/lean/OAI/Probability/SLE/Geometry/ThinCrossingEnergy.lean
@@ -0,0 +1,45 @@
+import OAI.Probability.SLE.Loewner.InverseRectangleEnergy
+import OAI.Probability.SLE.Loewner.InverseVerticalEnergy
+
+namespace OAI
+
+/-! A thin mapped crossing with a small physical image forces large
+Dirichlet energy whenever the inverse is separated at a fixed height. -/
+noncomputable section
+open Set Filter Function Complex Metric MeasureTheory
+open scoped Topology ENNReal
+
+namespace SLEExactGauge
+
+theorem initialInverse_thin_crossing_bound (p : C(unitInterval,ℂ)) (hi : Injective p)
+    (h0 : p 0=0) (hH : ∀ t : unitInterval, t≠0 → p t∈upperHalfPlane)
+    {R : ℝ} (hR : 0<R) (hp : ∀ t : unitInterval, ‖p t‖<R)
+    (s : unitInterval) {a b L h δ ε : ℝ} (hab : a<b)
+    (hh : 0<h) (hh1 : h≤1) (hδ : 0≤δ) (c : ℂ)
+    (hx : ∀ x∈Ioo a b, |x|≤L)
+    (hhigh : ∀ x∈Ioo a b, δ+ε≤
+      ‖initialInverseChart p hi h0 hH s ((x:ℂ)+(h:ℂ)*I)-c‖)
+    (hlow : ∀ x∈Ioo a b, ∃ y∈Ioc 0 h,
+      ‖initialInverseChart p hi h0 hH s ((x:ℂ)+(y:ℂ)*I)-c‖≤ε) :
+    (b-a)*δ^2≤h*(volume (closedBall (0:ℂ) (L+2+3*R))).toReal := by
+  obtain ⟨hbound,hiE,hsections⟩ := initialInverse_rectangle_energy p hi h0 hH hR hp s
+    a b L hh hh1 hx
+  have hpoint : ∀ᵐ x : ℝ ∂volume.restrict (Ioo a b),
+      δ^2≤h*(∫ y in Ioc 0 h,
+        ‖deriv (initialInverseChart p hi h0 hH s) ((x:ℂ)+(y:ℂ)*I)‖^2) := by
+    filter_upwards [hsections,ae_restrict_mem measurableSet_Ioo] with x hxE hxI
+    exact holomorphic_vertical_separation (initialInverseChart_differentiableOn p hi h0 hH s)
+      x hh hδ c (hhigh x hxI) (hlow x hxI) hxE
+  have h := integral_mono_ae (integrable_const (δ^2)) (hiE.const_mul h) hpoint
+  rw [integral_const,integral_const_mul] at h
+  have hm : (volume.restrict (Ioo a b)).real Set.univ=b-a := by
+    simp only [Measure.real,Measure.restrict_apply_univ,Real.volume_Ioo]
+    exact ENNReal.toReal_ofReal (sub_pos.mpr hab).le
+  simp only [smul_eq_mul,hm] at h
+  exact h.trans (mul_le_mul_of_nonneg_left hbound hh.le)
+
+end SLEExactGauge
+
+end
+
+end OAI
diff --git a/lean/OAI/Probability/SLE/Geometry/TransportCrosscutPartition.lean b/lean/OAI/Probability/SLE/Geometry/TransportCrosscutPartition.lean
new file mode 100644
index 0000000000000000000000000000000000000000..24c58aa078bfd9419085d9684d676d4d1e5036ab
--- /dev/null
+++ b/lean/OAI/Probability/SLE/Geometry/TransportCrosscutPartition.lean
@@ -0,0 +1,58 @@
+import OAI.Probability.SLE.Geometry.SchoenfliesInsideTransport
+
+namespace OAI
+
+/-! Transport the proved polygonal crosscut theorem after an ambient
+straightening of just the interior arc. -/
+noncomputable section
+open Set
+
+namespace SLEExactGauge
+
+theorem plane_homeomorph_arc (H : Schoenflies.Plane ≃ₜ Schoenflies.Plane)
+    {A : Set Schoenflies.Plane} {p q : Schoenflies.Plane}
+    (hA : Schoenflies.IsArcBetween A p q) :
+    Schoenflies.IsArcBetween (H '' A) (H p) (H q) := by
+  obtain ⟨f,hfc,hfi,hfA,hf0,hf1⟩ := hA
+  refine ⟨H ∘ f,H.continuous.comp_continuousOn hfc,?_,?_,?_,?_⟩
+  · exact H.injective.injOn.comp hfi (mapsTo_univ _ _)
+  · rw [image_comp,hfA]
+  · exact congrArg H hf0
+  · exact congrArg H hf1
+
+theorem plane_crosscut_partition_of_straightening
+    {C P A B : Set Schoenflies.Plane} {p q : Schoenflies.Plane}
+    (hC : Schoenflies.IsJordanCurve C)
+    (hP : Schoenflies.IsArcBetween P p q)
+    (hcut : Schoenflies.IsCutPair C p q A B)
+    (hp : p ∈ C) (hq : q ∈ C)
+    (hin : P \ {p,q} ⊆ Schoenflies.inside C)
+    (H : Schoenflies.Plane ≃ₜ Schoenflies.Plane)
+    (hpoly : Schoenflies.IsPolygonal (H '' P)) :
+    Schoenflies.inside C \ P =
+      Schoenflies.inside (A ∪ P) ∪ Schoenflies.inside (B ∪ P) ∧
+    Disjoint (Schoenflies.inside (A ∪ P)) (Schoenflies.inside (B ∪ P)) := by
+  have hc : Schoenflies.IsCrosscut (H '' C) (H '' P) (H p) (H q) := by
+    refine ⟨plane_homeomorph_jordan H hC,plane_homeomorph_arc H hP,hpoly,
+      mem_image_of_mem H hp,mem_image_of_mem H hq,?_⟩
+    rw [← image_pair,← image_sdiff H.injective]
+    exact (image_mono hin).trans (plane_homeomorph_inside H C).subset
+  have hcuts : Schoenflies.IsCutPair (H '' C) (H p) (H q) (H '' A) (H '' B) := by
+    refine ⟨plane_homeomorph_arc H hcut.fst,plane_homeomorph_arc H hcut.snd,?_,?_⟩
+    · rw [← image_union,hcut.union_eq]
+    · rw [← image_inter H.injective,hcut.inter_eq,image_pair]
+  obtain ⟨he,hd,-⟩ := Schoenflies.crosscut_theorem hc hcuts
+  refine ⟨?_,?_⟩
+  · apply H.injective.image_injective
+    simpa only [image_sdiff H.injective,plane_homeomorph_inside,image_union] using he
+  · rw [Set.disjoint_left] at hd ⊢
+    intro z hz hz'
+    apply hd (a := H z)
+    · simpa only [plane_homeomorph_inside,image_union] using mem_image_of_mem H hz
+    · simpa only [plane_homeomorph_inside,image_union] using mem_image_of_mem H hz'
+
+end SLEExactGauge
+
+end
+
+end OAI
diff --git a/lean/OAI/Probability/SLE/Geometry/TransverseCurveDifference.lean b/lean/OAI/Probability/SLE/Geometry/TransverseCurveDifference.lean
new file mode 100644
index 0000000000000000000000000000000000000000..7b7e982790f4c2a22f2d3eb183ccc16e8c3a43fc
--- /dev/null
+++ b/lean/OAI/Probability/SLE/Geometry/TransverseCurveDifference.lean
@@ -0,0 +1,80 @@
+import OAI.Probability.SLE.Geometry.SmallLoopCrossing
+import Mathlib.Analysis.Calculus.InverseFunctionTheorem.FDeriv
+
+namespace OAI
+
+/-! A transverse crossing of two smooth planar curves is a locally
+injective zero of their two-parameter difference map. -/
+noncomputable section
+open Set Filter Metric Function
+open scoped Topology
+
+namespace SLEExactGauge
+
+lemma exists_injective_closedBall_of_strict_deriv {f : ℂ → ℂ} {a : ℂ}
+    {L : ℂ →L[ℝ] ℂ} (h : HasStrictFDerivAt f L a) (hi : Injective L) :
+    ∃ r : ℝ, 0<r ∧ InjOn f (closedBall a r) := by
+  let e : ℂ ≃L[ℝ] ℂ := (LinearEquiv.ofBijective L.toLinearMap
+    ⟨hi,LinearMap.injective_iff_surjective.mp hi⟩).toContinuousLinearEquiv
+  have he : (e : ℂ →L[ℝ] ℂ)=L := by ext z; rfl
+  have h' : HasStrictFDerivAt f (e : ℂ →L[ℝ] ℂ) a := by rwa [he]
+  let g := h'.toOpenPartialHomeomorph f
+  have ha : a∈g.source := h'.mem_toOpenPartialHomeomorph_source
+  obtain ⟨r,hr,hball⟩ := Metric.mem_nhds_iff.mp (g.open_source.mem_nhds ha)
+  refine ⟨r/2,half_pos hr,g.injOn.mono ?_⟩
+  exact (closedBall_subset_ball (half_lt_self hr)).trans hball
+
+lemma transverse_difference_locally_injective {c p : ℝ → ℂ} {s t : ℝ} {α β : ℂ}
+    (hc : HasStrictDerivAt c α t) (hp : HasStrictDerivAt p β s)
+    (htrans : ∀ u v : ℝ, u • α-v • β=0 → u=0 ∧ v=0) :
+    ∃ r : ℝ, 0<r ∧ InjOn (fun z : ℂ => c z.im-p z.re)
+      (closedBall ((s:ℂ)+(t:ℂ)*Complex.I) r) := by
+  let L : ℂ →L[ℝ] ℂ := Complex.imCLM.smulRight α-Complex.reCLM.smulRight β
+  have hc' : HasStrictFDerivAt (fun z : ℂ => c z.im)
+      (Complex.imCLM.smulRight α) ((s:ℂ)+(t:ℂ)*Complex.I) := by
+    have hcbase : HasStrictDerivAt c α (((s:ℂ)+(t:ℂ)*Complex.I).im) := by simpa using hc
+    have hcomp : (ContinuousLinearMap.toSpanSingleton ℝ α).comp Complex.imCLM=
+        Complex.imCLM.smulRight α := by ext z; rfl
+    simpa only [hcomp] using
+      hcbase.hasStrictFDerivAt.comp ((s:ℂ)+(t:ℂ)*Complex.I) Complex.imCLM.hasStrictFDerivAt
+  have hp' : HasStrictFDerivAt (fun z : ℂ => p z.re)
+      (Complex.reCLM.smulRight β) ((s:ℂ)+(t:ℂ)*Complex.I) := by
+    have hpbase : HasStrictDerivAt p β (((s:ℂ)+(t:ℂ)*Complex.I).re) := by simpa using hp
+    have hcomp : (ContinuousLinearMap.toSpanSingleton ℝ β).comp Complex.reCLM=
+        Complex.reCLM.smulRight β := by ext z; rfl
+    simpa only [hcomp] using
+      hpbase.hasStrictFDerivAt.comp ((s:ℂ)+(t:ℂ)*Complex.I) Complex.reCLM.hasStrictFDerivAt
+  apply exists_injective_closedBall_of_strict_deriv (L := L) (hc'.sub hp')
+  intro z w he
+  have hz : L (z-w)=0 := by rw [map_sub,he,sub_self]
+  have hzw : (z-w).im • α-(z-w).re • β=0 := hz
+  obtain ⟨him,hre⟩ := htrans _ _ hzw
+  apply Complex.ext
+  · exact sub_eq_zero.mp hre
+  · exact sub_eq_zero.mp him
+
+lemma transverse_radial_angular (A B : ℝ) (q : ℂ)
+    (hA : A≠0) (hB : B≠0) (hq : q≠0) :
+    ∀ u v : ℝ, u • ((A:ℂ)*Complex.I*q)-v • ((B:ℂ)*q)=0 → u=0 ∧ v=0 := by
+  intro u v he
+  have heq : ((u*A:ℝ):ℂ)*Complex.I-((v*B:ℝ):ℂ)=0 := by
+    apply (mul_eq_zero.mp (show (((u*A:ℝ):ℂ)*Complex.I-((v*B:ℝ):ℂ))*q=0 by
+      calc
+        _ = u • ((A:ℂ)*Complex.I*q)-v • ((B:ℂ)*q) := by
+          simp only [Complex.real_smul,Complex.ofReal_mul]
+          ring
+        _ = 0 := he)).resolve_right hq
+  have hr := congrArg Complex.re heq
+  have hi := congrArg Complex.im heq
+  simp only [Complex.sub_re,Complex.mul_re,Complex.ofReal_re,Complex.ofReal_im,
+    Complex.I_re,Complex.I_im,mul_zero,zero_mul,sub_self,zero_sub,Complex.zero_re] at hr
+  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,sub_zero,Complex.zero_im] at hi
+  exact ⟨(mul_eq_zero.mp hi).resolve_right hA,
+    (mul_eq_zero.mp (neg_eq_zero.mp hr)).resolve_right hB⟩
+
+end SLEExactGauge
+
+end
+
+end OAI
diff --git a/lean/OAI/Probability/SLE/Geometry/UniformAccessLocalization.lean b/lean/OAI/Probability/SLE/Geometry/UniformAccessLocalization.lean
new file mode 100644
index 0000000000000000000000000000000000000000..b26e1f31468700e2ad31c1bc93398aa7c7d5c914
--- /dev/null
+++ b/lean/OAI/Probability/SLE/Geometry/UniformAccessLocalization.lean
@@ -0,0 +1,104 @@
+import OAI.Probability.SLE.Gauge.EarlyPassageLocalization
+
+namespace OAI
+
+/-! A common access radius from the converging inverse guides. A fixed
+positive guide time has a nonzero limiting parameter value; all sufficiently
+late guides therefore cross one common radius while their physical images
+stay in the prescribed small ball. This supplies the actual uniform
+localization hypotheses used before the first-height restart. -/
+
+noncomputable section
+open Set Filter MeasureTheory ProbabilityTheory Metric
+open scoped Topology NNReal ENNReal
+
+namespace SLEExactGauge
+
+theorem common_access_guide_radius
+    (δ : ℝ) (hδ : 0 < δ)
+    (β : ℕ → ℝ → ℂ) (hβc : ∀ n, ContinuousOn (β n) (Icc 0 δ))
+    (hβ0 : ∀ n, β n 0 = 0) (hβH : ∀ n t, t ∈ Icc 0 δ → 0 ≤ (β n t).im)
+    (z : ℂ) (hz : z ≠ 0) (hconv : Tendsto (fun n => β n δ) atTop (𝓝 z))
+    (Fbar : ℕ → ℂ → OnePoint ℂ) (α : ℕ → ℝ → ℂ) (a : ℕ → ℂ)
+    (C : ℝ≥0) (hα : ∀ n, LipschitzOnWith C (α n) (Icc 0 δ))
+    (hα0 : ∀ n, α n 0 = a n)
+    (hmap : ∀ n t, t ∈ Icc 0 δ → Fbar n (β n t) = (α n t : OnePoint ℂ)) :
+    ∃ b₀ : ℝ, 0 < b₀ ∧ ∀ᶠ n in atTop, ∃ S : ℝ, 0 < S ∧ S ≤ δ ∧
+      ContinuousOn (β n) (Icc 0 S) ∧ β n 0 = 0 ∧ ‖β n S‖ = b₀ ∧
+      (∀ t ∈ Icc 0 S, 0 ≤ (β n t).im) ∧
+      ∀ t ∈ Icc 0 S, ∃ w : ℂ, Fbar n (β n t) = (w : OnePoint ℂ) ∧
+        ‖w - a n‖ ≤ (C : ℝ) * δ := by
+  let b₀ : ℝ := ‖z‖ / 2
+  have hb₀ : 0 < b₀ := by dsimp [b₀]; exact half_pos (norm_pos_iff.mpr hz)
+  have hzgt : b₀ < ‖z‖ := by dsimp [b₀]; exact half_lt_self (norm_pos_iff.mpr hz)
+  have hlarge : ∀ᶠ n in atTop, b₀ < ‖β n δ‖ := hconv.norm.eventually (lt_mem_nhds hzgt)
+  refine ⟨b₀, hb₀, ?_⟩
+  filter_upwards [hlarge] with n hn
+  obtain ⟨S, hS, hnorm⟩ := intermediate_value_Icc hδ.le (hβc n).norm
+    (show b₀ ∈ Icc ‖β n 0‖ ‖β n δ‖ by rw [hβ0 n, norm_zero]; exact ⟨hb₀.le, hn.le⟩)
+  change ‖β n S‖ = b₀ at hnorm
+  have hSpos : 0 < S := by
+    by_contra h
+    have hS0 : S = 0 := le_antisymm (le_of_not_gt h) hS.1
+    rw [hS0, hβ0 n, norm_zero] at hnorm
+    exact hb₀.ne' hnorm.symm
+  have hsub : Icc 0 S ⊆ Icc 0 δ := Icc_subset_Icc_right hS.2
+  refine ⟨S, hSpos, hS.2, (hβc n).mono hsub, hβ0 n, hnorm,
+    fun t ht => hβH n t (hsub ht), ?_⟩
+  intro t ht
+  refine ⟨α n t, hmap n t (hsub ht), ?_⟩
+  have hb := (hα n).dist_le_mul t (hsub ht) 0 ⟨le_rfl, hδ.le⟩
+  rw [hα0 n, dist_eq_norm] at hb
+  have hdist : dist t 0 = t := by rw [Real.dist_eq, sub_zero, abs_of_nonneg ht.1]
+  rw [hdist] at hb
+  exact hb.trans (mul_le_mul_of_nonneg_left (hsub ht).2 C.coe_nonneg)
+
+/-- The common guide radius feeds the already proved actual localization
+estimate for every late member of the conformal family. -/
+theorem common_access_gives_firstHeight_localization
+    (κ : ℝ) (hκ : 0 < κ) (hκ8 : κ < 8) :
+    ∃ b C c L₀ : ℝ, 0 < b ∧ 0 < C ∧ 0 < c ∧ 1 < L₀ ∧
+    ∀ (Ω : Type*) [MeasurableSpace Ω] (P : Measure Ω) [IsProbabilityMeasure P]
+      (γ : Ω → ℝ≥0 → ℂ), IsOrdinaryChordalSLE κ γ P →
+      (∀ ω, Continuous (γ ω)) → (∀ ω, γ ω 0 = 0) → (∀ ω t, 0 ≤ (γ ω t).im) →
+    ∀ (F : ℕ → ℂ → ℂ) (Fbar : ℕ → ℂ → OnePoint ℂ),
+      (∀ n, DifferentiableOn ℂ (F n) upperHalfPlane) →
+      (∀ n, InjOn (F n) upperHalfPlane) →
+      (∀ n, ContinuousOn (Fbar n) closedHalfPlane) →
+      (∀ n z, z ∈ upperHalfPlane → Fbar n z = (F n z : OnePoint ℂ)) →
+    ∀ (δ : ℝ), 0 < δ →
+    ∀ (β : ℕ → ℝ → ℂ), (∀ n, ContinuousOn (β n) (Icc 0 δ)) →
+      (∀ n, β n 0 = 0) → (∀ n t, t ∈ Icc 0 δ → 0 ≤ (β n t).im) →
+    ∀ (z : ℂ), z ≠ 0 → Tendsto (fun n => β n δ) atTop (𝓝 z) →
+    ∀ (α : ℕ → ℝ → ℂ) (a : ℕ → ℂ) (Cg : ℝ≥0),
+      (∀ n, LipschitzOnWith Cg (α n) (Icc 0 δ)) → (∀ n, α n 0 = a n) →
+      (∀ n t, t ∈ Icc 0 δ → Fbar n (β n t) = (α n t : OnePoint ℂ)) →
+    ∀ (r : ℝ), 0 < r → (Cg : ℝ) * δ ≤ r →
+    ∃ b₀ : ℝ, 0 < b₀ ∧ ∀ᶠ n in atTop,
+      ∀ L : ℝ, L₀ ≤ L → ∀ B : ℝ, 0 < B → B / 2 ≤ b₀ * L ^ b → ∀ T : ℝ≥0,
+        let σ := fun ω => FirstHeightSupport.boundedFirstHeightTime (γ ω) B T
+        P (FirstHeightSupport.stoppedNarrowCertificate γ σ B T \
+          EarlyPassageLocalization.stoppedImageEvent γ σ (Fbar n) (a n) (L * r)) ≤
+            ENNReal.ofReal (C * L ^ (-c)) := by
+  obtain ⟨b, C, c, L₀, hb, hC, hc, hL₀, hloc⟩ :=
+    EarlyPassageLocalization.bounded_firstHeight_localization κ hκ hκ8
+  refine ⟨b, C, c, L₀, hb, hC, hc, hL₀, ?_⟩
+  intro Ω m P hP γ hSLE hγc hγ0 hγH F Fbar hF hinj hbar hext δ hδ β hβc hβ0 hβH
+    z hz hconv α a Cg hα hα0 hmap r hr hbound
+  obtain ⟨b₀, hb₀, haccess⟩ := common_access_guide_radius δ hδ β hβc hβ0 hβH
+    z hz hconv Fbar α a Cg hα hα0 hmap
+  refine ⟨b₀, hb₀, ?_⟩
+  filter_upwards [haccess] with n hn
+  obtain ⟨S, hS, _, hβS, hβzero, hβnorm, hH, himage⟩ := hn
+  intro L hL B hB hBL T
+  apply hloc Ω P γ hSLE hγc hγ0 hγH (F n) (Fbar n) (hF n) (hinj n) (hbar n)
+    (hext n) (a n) r hr (β n) S b₀ hS hb₀ hβS hβzero hβnorm hH _ L hL B hB hBL T
+  intro t ht
+  obtain ⟨w, he, hw⟩ := himage t ht
+  exact ⟨w, he, hw.trans hbound⟩
+
+end SLEExactGauge
+
+end
+
+end OAI
diff --git a/lean/OAI/Probability/SLE/Geometry/UniformGuideCompactness.lean b/lean/OAI/Probability/SLE/Geometry/UniformGuideCompactness.lean
new file mode 100644
index 0000000000000000000000000000000000000000..e31cb25690faf51331e89b6a9958cfab3606c806
--- /dev/null
+++ b/lean/OAI/Probability/SLE/Geometry/UniformGuideCompactness.lean
@@ -0,0 +1,77 @@
+import OAI.Probability.SLE.Geometry.PublishedConformalCompactness
+import OAI.Probability.SLE.Geometry.GuideTipCollapse
+
+namespace OAI
+
+/-! Uniform access-guide collapse from the univalent normal-family
+theorem and conformal localization. This supplies the boundary control
+in `es:guide-compactness` under waypoint normalization bounds. -/
+
+noncomputable section
+open Set Filter MeasureTheory Metric
+open scoped Topology ENNReal NNReal
+
+namespace SLEExactGauge
+
+theorem uniform_tip_collapse_of_published_compactness
+    {Ω : Type} [MeasurableSpace Ω] (P : Measure Ω) [IsProbabilityMeasure P]
+    (κ : ℝ) (hκ : 0 < κ) (hκ8 : κ < 8)
+    (γ : Ω → ℝ≥0 → ℂ) (hSLE : IsOrdinaryChordalSLE κ γ P)
+    (hpublished : PublishedHalfPlaneUnivalentCompactness)
+    (Fₙ : ℕ → ℂ → ℂ) (Fbar : ℕ → ℂ → OnePoint ℂ)
+    (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 ℂ))
+    (zₙ aₙ : ℕ → ℂ) (s m M : ℝ) (hs : 0 < s) (hm : 0 < m)
+    (hz : ∀ n, ‖zₙ n‖ = 1 ∧ s ≤ (zₙ n).im)
+    (hwaypoint : ∀ n, ‖Fₙ n (zₙ n)‖ ≤ M)
+    (hderiv : ∀ n, m ≤ ‖deriv (Fₙ n) (zₙ n)‖ ∧ ‖deriv (Fₙ n) (zₙ n)‖ ≤ M)
+    (htip : ∀ n, ‖aₙ n‖ ≤ M)
+    (β : ℕ → ℝ → ℂ) (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
+  intro ε hε
+  by_contra! hnone
+  let h : ℕ → ℝ := fun j => min T (1 / ((j : ℝ) + 1))
+  have hh : ∀ j, 0 < h j := fun j => lt_min hT (by positivity)
+  have hhT : ∀ j, h j ≤ T := fun _ => min_le_left _ _
+  have hbad : ∀ j, ∃ n t, t ∈ Icc 0 (h j) ∧ ε ≤ ‖β n t‖ :=
+    fun j => hnone (h j) (hh j) (hhT j)
+  choose index t ht hlarge using hbad
+  have htlim : Tendsto t atTop (𝓝 0) :=
+    squeeze_zero (fun j => (ht j).1)
+      (fun j => (ht j).2.trans (min_le_right _ _))
+      tendsto_one_div_add_atTop_nhds_zero_nat
+  have htipball : ∀ j, aₙ (index j) ∈ closedBall 0 M := by
+    intro j
+    simpa only [mem_closedBall, dist_zero_right] using htip (index j)
+  obtain ⟨a, _, φ, hφ, halim⟩ := (isCompact_closedBall (0 : ℂ) M).tendsto_subseq htipball
+  obtain ⟨ψ, F, hψ, hF, hinj, _hne, hconv⟩ := hpublished
+    (fun j => Fₙ (index (φ j))) (fun j => zₙ (index (φ j))) s m M hs hm
+    (fun j => hFn _) (fun j => hinjn _) (fun j => hz _)
+    (fun j => hwaypoint _) (fun j => hderiv _)
+  let seq : ℕ → ℕ := fun j => index (φ (ψ j))
+  have halim' : Tendsto (fun j => aₙ (seq j)) atTop (𝓝 a) := by
+    simpa only [Function.comp_def, seq] using halim.comp hψ.tendsto_atTop
+  have htlim' : Tendsto (fun j => t (φ (ψ j))) atTop (𝓝 0) :=
+    htlim.comp (hφ.tendsto_atTop.comp hψ.tendsto_atTop)
+  obtain ⟨δ, hδ, _, hδbound⟩ := uniform_tip_collapse P κ hκ hκ8 γ hSLE
+    (fun j => Fₙ (seq j)) (fun j => Fbar (seq j)) F
+    (fun j => hFn _) (fun j => hinjn _) (fun j => hbar _) (fun j => hext _)
+    hconv hF.continuousOn hinj (fun j => aₙ (seq j)) a halim'
+    (fun j => β (seq j)) T C hT hC (fun j => hβ _) (fun j => hβ0 _)
+    (fun j => hβH _) (fun j => himage _) ε hε
+  obtain ⟨j, hj⟩ := (htlim'.eventually (Iio_mem_nhds hδ)).exists
+  have htj : t (φ (ψ j)) ∈ Icc 0 δ := ⟨(ht _).1, hj.le⟩
+  exact (not_lt_of_ge (hlarge _)) (hδbound j _ htj)
+
+end SLEExactGauge
+
+end
+
+end OAI
diff --git a/lean/OAI/Probability/SLE/Geometry/UnitWindowPlanarExit.lean b/lean/OAI/Probability/SLE/Geometry/UnitWindowPlanarExit.lean
new file mode 100644
index 0000000000000000000000000000000000000000..f35863c3980818d5d7f544c4cb1c712ec91da084
--- /dev/null
+++ b/lean/OAI/Probability/SLE/Geometry/UnitWindowPlanarExit.lean
@@ -0,0 +1,110 @@
+import OAI.Probability.SLE.Geometry.PublishedConformalExitLaw
+import OAI.Probability.SLE.Loewner.HalfPlaneFiniteExit
+import OAI.Probability.SLE.Loewner.HalfPlaneExitBounds
+
+namespace OAI
+
+/-! The exact deterministic rescaling between the published unit-window
+exit events and the original planar Wiener process. -/
+noncomputable section
+open Set Filter MeasureTheory ProbabilityTheory
+open scoped Topology NNReal ENNReal
+
+namespace SLEExactGauge
+open Target RibbonCoordinates
+
+def unitWindowStop (τ : ℝ) : ℝ≥0 := (τ/3).toNNReal
+
+lemma unitWindowStop_coe {τ : ℝ} (hτ : 0 ≤ τ) : (unitWindowStop τ:ℝ)=τ/3 :=
+  Real.coe_toNNReal (τ/3) (by positivity)
+
+lemma unitWindowStop_bounds {τ : ℝ} (hτ : τ∈Ioc (0:ℝ) 3) :
+    0 < unitWindowStop τ ∧ unitWindowStop τ ≤ 1 := by
+  constructor
+  · exact_mod_cast (show (0:ℝ)<(unitWindowStop τ:ℝ) by
+      rw [unitWindowStop_coe hτ.1.le]
+      exact div_pos hτ.1 (by norm_num))
+  · apply NNReal.coe_le_coe.mp
+    rw [unitWindowStop_coe hτ.1.le,NNReal.coe_one]
+    linarith [hτ.2]
+
+lemma physicalUnitBrownianPath_at_scale (w : ℂ) (b : Driver×Driver) (s : ℝ≥0) (hs : s ≤ 1) :
+    physicalUnitBrownianPath w b (3*(s:ℝ))=w+Complex.equivRealProdCLM.symm (planarWiener s b) := by
+  have hclip : unitClipPoint (3*(s:ℝ)/3)=(⟨(s:ℝ),s.coe_nonneg,by exact_mod_cast hs⟩ : unitInterval) := by
+    apply Subtype.ext
+    change unitClip (3*(s:ℝ)/3)=(s:ℝ)
+    rw [mul_div_cancel_left₀ _ (by norm_num : (3:ℝ)≠0)]
+    exact unitClip_of_mem ⟨s.coe_nonneg,by exact_mod_cast hs⟩
+  rw [physicalUnitBrownianPath,hclip]
+  change w+((b.1 s:ℂ)+(b.2 s:ℂ)*Complex.I)=_
+  rw [Complex.equivRealProdCLM_symm_apply]
+  rfl
+
+lemma physicalUnitBrownianPath_eq_planar (w : ℂ) (b : Driver×Driver) {t : ℝ}
+    (ht : t∈Icc (0:ℝ) 3) :
+    physicalUnitBrownianPath w b t=w+Complex.equivRealProdCLM.symm (planarWiener (unitWindowStop t) b) := by
+  have hs : unitWindowStop t ≤ 1 := by
+    apply NNReal.coe_le_coe.mp
+    rw [unitWindowStop_coe ht.1,NNReal.coe_one]
+    linarith [ht.2]
+  have he : 3*(unitWindowStop t:ℝ)=t := by rw [unitWindowStop_coe ht.1]; ring
+  simpa only [he] using physicalUnitBrownianPath_at_scale w b (unitWindowStop t) hs
+
+lemma unitWindowFirstExit_planar {D : Set ℂ} {w : ℂ} {b : Driver×Driver} {τ : ℝ}
+    (h : UnitWindowFirstExit D (physicalUnitBrownianPath w b) τ) :
+    0 < unitWindowStop τ ∧ unitWindowStop τ ≤ 1 ∧
+      (∀ s<unitWindowStop τ, w+Complex.equivRealProdCLM.symm (planarWiener s b)∈D) ∧
+      w+Complex.equivRealProdCLM.symm (planarWiener (unitWindowStop τ) b)∉D := by
+  have hs := unitWindowStop_bounds h.1
+  refine ⟨hs.1,hs.2,?_,?_⟩
+  · intro s hsτ
+    have ht : 3*(s:ℝ)<τ := by
+      have hh : (s:ℝ)<unitWindowStop τ := hsτ
+      rw [unitWindowStop_coe h.1.1.le] at hh
+      linarith
+    have hh := h.2.2 ⟨by positivity,ht⟩
+    rwa [physicalUnitBrownianPath_at_scale w b s (hsτ.le.trans hs.2)] at hh
+  · simpa only [physicalUnitBrownianPath_eq_planar w b ⟨h.1.1.le,h.1.2⟩] using h.2.1
+
+lemma unitWindow_map_limit_iff (w : ℂ) (b : Driver×Driver) (g : ℂ → ℂ)
+    {τ : ℝ} (hτ : τ∈Ioc (0:ℝ) 3) (z : ℂ) :
+    Tendsto (fun t => g (physicalUnitBrownianPath w b t)) (𝓝[<] τ) (𝓝 z) ↔
+      Tendsto (fun s => g (w+Complex.equivRealProdCLM.symm (planarWiener s b)))
+        (𝓝[<] (unitWindowStop τ)) (𝓝 z) := by
+  have hs := unitWindowStop_bounds hτ
+  have hscale : 3*(unitWindowStop τ:ℝ)=τ := by rw [unitWindowStop_coe hτ.1.le]; ring
+  constructor
+  · intro hh
+    have ht : Tendsto (fun s : ℝ≥0 => 3*(s:ℝ)) (𝓝[<] unitWindowStop τ) (𝓝[<] τ) := by
+      apply tendsto_nhdsWithin_iff.mpr
+      constructor
+      · have hc : Continuous (fun s : ℝ≥0 => 3*(s:ℝ)) := continuous_const.mul NNReal.continuous_coe
+        have hh := hc.tendsto (unitWindowStop τ)
+        rw [hscale] at hh
+        exact hh.mono_left nhdsWithin_le_nhds
+      · filter_upwards [self_mem_nhdsWithin] with s hst
+        have hh : (s:ℝ)<unitWindowStop τ := hst
+        rw [unitWindowStop_coe hτ.1.le] at hh
+        change 3*(s:ℝ)<τ
+        linarith
+    apply (hh.comp ht).congr'
+    filter_upwards [self_mem_nhdsWithin] with s hst
+    exact congrArg g (physicalUnitBrownianPath_at_scale w b s (le_of_lt hst |>.trans hs.2))
+  · intro hh
+    have ht : Tendsto unitWindowStop (𝓝[<] τ) (𝓝[<] unitWindowStop τ) := by
+      apply tendsto_nhdsWithin_iff.mpr
+      constructor
+      · exact ((continuous_real_toNNReal.comp (continuous_id.div_const 3)).tendsto τ).mono_left nhdsWithin_le_nhds
+      · filter_upwards [self_mem_nhdsWithin,nhdsWithin_le_nhds (Ioi_mem_nhds hτ.1)] with t htt ht0
+        apply NNReal.coe_lt_coe.mp
+        rw [unitWindowStop_coe (le_of_lt ht0),unitWindowStop_coe hτ.1.le]
+        exact div_lt_div_of_pos_right htt (by norm_num)
+    apply (hh.comp ht).congr'
+    filter_upwards [self_mem_nhdsWithin,nhdsWithin_le_nhds (Ioi_mem_nhds hτ.1)] with t htt ht0
+    exact congrArg g (physicalUnitBrownianPath_eq_planar w b ⟨ht0.le,htt.le.trans hτ.2⟩).symm
+
+end SLEExactGauge
+
+end
+
+end OAI
diff --git a/lean/OAI/Probability/SLE/Geometry/WaypointAngleNumerics.lean b/lean/OAI/Probability/SLE/Geometry/WaypointAngleNumerics.lean
new file mode 100644
index 0000000000000000000000000000000000000000..2820299ed71dc9b804e2246bc25157c19a4ef584
--- /dev/null
+++ b/lean/OAI/Probability/SLE/Geometry/WaypointAngleNumerics.lean
@@ -0,0 +1,64 @@
+import OAI.Probability.SLE.Geometry.PublishedConformalExitLaw
+
+namespace OAI
+
+/-! The quantitative conversion from the two half-plane exit-arc
+probabilities to the exact sine normalization used by guide compactness. -/
+
+noncomputable section
+open Set
+open scoped ENNReal
+
+namespace SLEExactGauge.CrosscutSides
+
+theorem sine_lower_bound_of_two_arc_bounds
+    {θ q : ℝ} (hθ : θ ∈ Icc 0 Real.pi)
+    (hl : q ≤ θ / Real.pi) (hr : q ≤ 1 - θ / Real.pi) :
+    2 * q ≤ Real.sin θ := by
+  have hl' := (le_div_iff₀ Real.pi_pos).mp hl
+  have hr' : q * Real.pi ≤ Real.pi - θ := by
+    have hh := mul_le_mul_of_nonneg_right hr Real.pi_pos.le
+    have he : (1 - θ / Real.pi) * Real.pi = Real.pi - θ := by
+      field_simp
+    rw [he] at hh
+    exact hh
+  by_cases hh : θ ≤ Real.pi / 2
+  · calc
+      2 * q ≤ 2 / Real.pi * θ := by
+        rw [div_mul_eq_mul_div]
+        apply (le_div_iff₀ Real.pi_pos).mpr
+        nlinarith
+      _ ≤ Real.sin θ := Real.mul_le_sin hθ.1 hh
+  · calc
+      2 * q ≤ 2 / Real.pi * (Real.pi - θ) := by
+        rw [div_mul_eq_mul_div]
+        apply (le_div_iff₀ Real.pi_pos).mpr
+        nlinarith
+      _ ≤ Real.sin (Real.pi - θ) :=
+        Real.mul_le_sin (by linarith [hθ.2]) (by linarith)
+      _ = Real.sin θ := Real.sin_pi_sub θ
+
+theorem positive_angle_of_two_exit_probability_bounds
+    {q : ℝ≥0∞} (hq : 0 < q) {w : ℂ} (hw : 0 < w.im)
+    (hl : q ≤ ENNReal.ofReal (w.arg / Real.pi))
+    (hr : q ≤ ENNReal.ofReal (1 - w.arg / Real.pi)) :
+    0 < q.toReal ∧ 2 * q.toReal ≤ w.im / ‖w‖ := by
+  have hθ : w.arg ∈ Icc (0 : ℝ) Real.pi :=
+    ⟨Complex.arg_nonneg_iff.mpr hw.le, Complex.arg_le_pi w⟩
+  have hfin : q ≠ ⊤ := ne_top_of_le_ne_top ENNReal.ofReal_ne_top hl
+  have hlreal : q.toReal ≤ w.arg / Real.pi := by
+    simpa only [ENNReal.toReal_ofReal (div_nonneg hθ.1 Real.pi_pos.le)] using
+      ENNReal.toReal_mono ENNReal.ofReal_ne_top hl
+  have hrnonneg : 0 ≤ 1 - w.arg / Real.pi :=
+    sub_nonneg.mpr ((div_le_one Real.pi_pos).mpr hθ.2)
+  have hrreal : q.toReal ≤ 1 - w.arg / Real.pi := by
+    simpa only [ENNReal.toReal_ofReal hrnonneg] using
+      ENNReal.toReal_mono ENNReal.ofReal_ne_top hr
+  refine ⟨ENNReal.toReal_pos hq.ne' hfin, ?_⟩
+  simpa only [Complex.sin_arg] using sine_lower_bound_of_two_arc_bounds hθ hlreal hrreal
+
+end SLEExactGauge.CrosscutSides
+
+end
+
+end OAI
diff --git a/lean/OAI/Probability/SLE/Geometry/WaypointCrosscutSides.lean b/lean/OAI/Probability/SLE/Geometry/WaypointCrosscutSides.lean
new file mode 100644
index 0000000000000000000000000000000000000000..b36478b50420a034c0df19777e03d25d930cbab2
--- /dev/null
+++ b/lean/OAI/Probability/SLE/Geometry/WaypointCrosscutSides.lean
@@ -0,0 +1,119 @@
+import OAI.Probability.SLE.Gauge.WaypointBrownianPassages
+import OAI.Probability.SLE.Geometry.FirstDomainExit
+
+namespace OAI
+
+/-! The two actual physical waypoint tubes start on opposite local sides
+of any correctly straightened access guide.  The local side assertion is
+derived from openness; it is not a ribbon-angle input. -/
+
+noncomputable section
+open Set Metric MeasureTheory
+open scoped Topology NNReal ENNReal
+
+namespace SLEExactGauge.RibbonCoordinates
+open CrosscutSides
+
+theorem waypoint_quarter_ball_side
+    (k side : ℝ) (hside : side = -1 ∨ side = 1) {z : ℂ}
+    (hz : z ∈ ball (waypointRoute k side (1 / 4)) (1 / 32)) :
+    z ∈ ball ((k + 1 / 2 : ℝ) : ℂ) (1 / 4) ∧ 0 < side * z.im := by
+  have habs : |side| = 1 := by rcases hside with rfl | rfl <;> norm_num
+  have he : waypointRoute k side (1 / 4) =
+      ((k + 1 / 2 : ℝ) : ℂ) + ((side / 8 : ℝ) : ℂ) * Complex.I := by
+    simp only [waypointRoute, unitClip]
+    norm_num
+    congr 1
+    ring
+  have hdist : dist (waypointRoute k side (1 / 4)) ((k + 1 / 2 : ℝ) : ℂ) = 1 / 8 := by
+    rw [he, dist_eq_norm, add_sub_cancel_left, norm_mul, Complex.norm_I,
+      mul_one, Complex.norm_real, Real.norm_eq_abs, abs_div, habs]
+    norm_num
+  have him := (Complex.abs_im_le_norm (z - waypointRoute k side (1 / 4))).trans_lt
+    (show ‖z - waypointRoute k side (1 / 4)‖ < 1 / 32 by
+      simpa only [mem_ball, dist_eq_norm] using hz)
+  rw [Complex.sub_im, he, Complex.add_im, Complex.ofReal_im, Complex.mul_im,
+    Complex.ofReal_re, Complex.I_im, Complex.ofReal_im, Complex.I_re] at him
+  norm_num at him
+  constructor
+  · have hh := dist_triangle z (waypointRoute k side (1 / 4)) ((k + 1 / 2 : ℝ) : ℂ)
+    rw [hdist] at hh
+    have hz' : dist z (waypointRoute k side (1 / 4)) < 1 / 32 := hz
+    exact lt_of_le_of_lt hh (by linarith)
+  · have hh := abs_lt.mp him
+    rcases hside with rfl | rfl <;> norm_num at * <;> linarith
+
+theorem physical_quarter_tube_coordinate
+    (hopen : PublishedPlanarDiskOpenness)
+    (P : ℂ → ℂ) (hP : ContinuousOn P closedRibbon) (hi : InjOn P closedRibbon)
+    (K : ℝ≥0) (hK : 0 < (K : ℝ)) {k side : ℝ}
+    (hk : 1 ≤ k) (hside : side = -1 ∨ side = 1)
+    (hlower : ∀ v ∈ crossingPatch k, ∀ w ∈ crossingPatch k,
+      dist v w ≤ K * dist (P v) (P w)) {y : ℂ}
+    (hy : dist y (P (waypointRoute k side (1 / 4))) < (1 / 32 : ℝ) / K) :
+    ∃ z ∈ ball ((k + 1 / 2 : ℝ) : ℂ) (1 / 4), 0 < side * z.im ∧ P z = y := by
+  have habs : |side| = 1 := by rcases hside with rfl | rfl <;> norm_num
+  have hpatch := waypointRoute_ball_subset_patch k side habs (1 / 4)
+  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 (1 / 4))
+    (by norm_num : (0 : ℝ) < 1 / 32) hK (hP.mono (hpatch.trans hsub))
+    (hopen P _ _ (by norm_num) (hP.mono hball) (hi.mono hball))
+    (fun z hz => hlower z (hpatch hz) _ (hpatch (mem_closedBall_self (by norm_num)))) hy
+  exact ⟨z, (waypoint_quarter_ball_side k side hside hz).1,
+    (waypoint_quarter_ball_side k side hside hz).2, he⟩
+
+/-- Any local straightening of the access guide fixes one orientation for
+the entire pair of physical quarter-time tube neighborhoods. -/
+theorem physical_waypoint_tubes_opposite_sides
+    (hopen : PublishedPlanarDiskOpenness)
+    (P : ℂ → ℂ) (hP : ContinuousOn P closedRibbon) (hi : InjOn P closedRibbon)
+    (K : ℝ≥0) (hK : 0 < (K : ℝ)) {k : ℝ} (hk : 1 ≤ k)
+    (hlower : ∀ v ∈ crossingPatch k, ∀ w ∈ crossingPatch k,
+      dist v w ≤ K * dist (P v) (P w))
+    (f : ℂ → ℂ) (j : ℂ → ℝ)
+    (hf : ContinuousOn f (ball ((k + 1 / 2 : ℝ) : ℂ) (1 / 4)))
+    (hfi : InjOn f (ball ((k + 1 / 2 : ℝ) : ℂ) (1 / 4)))
+    (hzero : ∀ z ∈ ball ((k + 1 / 2 : ℝ) : ℂ) (1 / 4),
+      (f z).re = 0 ↔ z.im = 0)
+    (hrel : ∀ z ∈ ball ((k + 1 / 2 : ℝ) : ℂ) (1 / 4), j (P z) = (f z).re) :
+    ∃ side : ℝ, (side = -1 ∨ side = 1) ∧
+      (∀ y : ℂ, dist y (P (waypointRoute k side (1 / 4))) < (1 / 32 : ℝ) / K →
+        0 < j y) ∧
+      (∀ y : ℂ, dist y (P (waypointRoute k (-side) (1 / 4))) < (1 / 32 : ℝ) / K →
+        j y < 0) := by
+  have hcenter : (f ((k + 1 / 2 : ℝ) : ℂ)).re = 0 :=
+    (hzero _ (mem_ball_self (by norm_num))).mpr (by simp)
+  have hsides := opposite_half_disk_signs f ((k + 1 / 2 : ℝ) : ℂ)
+    (by norm_num) hf (hopen f _ _ (by norm_num) hf hfi) hcenter hzero
+  rcases hsides with ⟨hpos, hneg⟩ | ⟨hneg, hpos⟩
+  · refine ⟨1, Or.inr rfl, ?_, ?_⟩
+    · intro y hy
+      obtain ⟨z, hz, hi', rfl⟩ := physical_quarter_tube_coordinate hopen P hP hi K hK
+        hk (Or.inr rfl) hlower hy
+      rw [hrel z hz]
+      exact hpos z hz (by simpa using hi')
+    · intro y hy
+      obtain ⟨z, hz, hi', rfl⟩ := physical_quarter_tube_coordinate hopen P hP hi K hK
+        hk (Or.inl rfl) hlower hy
+      rw [hrel z hz]
+      exact hneg z hz (by nlinarith)
+  · refine ⟨-1, Or.inl rfl, ?_, ?_⟩
+    · intro y hy
+      obtain ⟨z, hz, hi', rfl⟩ := physical_quarter_tube_coordinate hopen P hP hi K hK
+        hk (Or.inl rfl) hlower hy
+      rw [hrel z hz]
+      exact hpos z hz (by nlinarith)
+    · intro y hy
+      have hy' : dist y (P (waypointRoute k 1 (1 / 4))) < (1 / 32 : ℝ) / K := by
+        simpa only [neg_neg] using hy
+      obtain ⟨z, hz, hi', rfl⟩ := physical_quarter_tube_coordinate hopen P hP hi K hK
+        hk (Or.inr rfl) hlower hy'
+      rw [hrel z hz]
+      exact hneg z hz (by simpa using hi')
+
+end SLEExactGauge.RibbonCoordinates
+
+end
+
+end OAI
diff --git a/lean/OAI/Probability/SLE/Geometry/WaypointDerivativeBounds.lean b/lean/OAI/Probability/SLE/Geometry/WaypointDerivativeBounds.lean
new file mode 100644
index 0000000000000000000000000000000000000000..60baadd2b36d5f95aed4d07e97eed1924691ec3b
--- /dev/null
+++ b/lean/OAI/Probability/SLE/Geometry/WaypointDerivativeBounds.lean
@@ -0,0 +1,113 @@
+import OAI.Probability.SLE.AngularLaws
+import OAI.Probability.SLE.NearRealContraction
+
+namespace OAI
+
+/-! Nondegenerate waypoint normalization from actual inverse charts and
+physical clearance. The existing weak omitted-value estimate is enough;
+no sharp conformal-radius comparison is required. -/
+
+noncomputable section
+open Set Filter Metric
+open scoped Topology
+
+namespace SLEExactGauge
+
+theorem waypoint_derivative_bounds_of_clearance
+    (F g : ℂ → ℂ) (D : Set ℂ) (hD : IsOpen D)
+    (hF : DifferentiableOn ℂ F upperHalfPlane) (hiF : InjOn F upperHalfPlane)
+    (hg : DifferentiableOn ℂ g D) (hig : InjOn g D)
+    (hFD : MapsTo F upperHalfPlane D) (hgH : MapsTo g D upperHalfPlane)
+    (hgf : ∀ z ∈ upperHalfPlane, g (F z) = z)
+    (z a : ℂ) (s ρ R : ℝ) (hs : 0 < s) (hρ : 0 < ρ)
+    (hz : ‖z‖ = 1) (hzs : s ≤ z.im)
+    (hclear : ball (F z) ρ ⊆ D) (ha : a ∉ F '' upperHalfPlane)
+    (hnear : ‖F z - a‖ ≤ R) :
+    ρ / (128 * Real.pi) ≤ ‖deriv F z‖ ∧
+      ‖deriv F z‖ ≤ (128 * Real.pi) * R / s := by
+  have hzH : z ∈ upperHalfPlane := hs.trans_le hzs
+  have hy : 0 < z.im := hzH
+  have hC : 0 < 128 * Real.pi := by positivity
+  have hball := ball_subset_upperHalfPlane (le_rfl : z.im ≤ z.im)
+  have hu := univalent_omitted_value_bound_ball hy (hF.mono hball)
+    (hiF.mono hball) a (fun ha' => ha (image_mono hball ha'))
+  have hgF : HasDerivAt g (deriv g (F z)) (F z) :=
+    (hg.differentiableAt (hD.mem_nhds (hFD hzH))).hasDerivAt
+  have hFz := (hF.differentiableAt (isOpen_upperHalfPlane.mem_nhds hzH)).hasDerivAt
+  have heq : (g ∘ F) =ᶠ[𝓝 z] id := by
+    filter_upwards [isOpen_upperHalfPlane.mem_nhds hzH] with w hw
+    exact hgf w hw
+  have hprod : deriv g (F z) * deriv F z = 1 :=
+    ((hgF.comp z hFz).congr_of_eventuallyEq heq.symm).unique (hasDerivAt_id z)
+  have hnormprod : ‖deriv g (F z)‖ * ‖deriv F z‖ = 1 := by
+    simpa only [norm_mul, norm_one] using congrArg norm hprod
+  have homit : (z.re : ℂ) ∉ g '' ball (F z) ρ := by
+    rintro ⟨w, hw, he⟩
+    have hh := hgH (hclear hw)
+    rw [he] at hh
+    simp only [upperHalfPlane, mem_ofPred_eq, Complex.ofReal_im, lt_self_iff_false] at hh
+  have hl := univalent_omitted_value_bound_ball hρ (hg.mono hclear)
+    (hig.mono hclear) (z.re : ℂ) homit
+  have hvertical : ‖g (F z) - (z.re : ℂ)‖ = z.im := by
+    rw [hgf z hzH]
+    have he : z - (z.re : ℂ) = (z.im : ℂ) * Complex.I := by
+      apply Complex.ext <;> simp
+    rw [he, norm_mul, Complex.norm_I, mul_one, Complex.norm_real, Real.norm_eq_abs,
+      abs_of_pos hy]
+  rw [hvertical] at hl
+  have hy1 : z.im ≤ 1 := by simpa only [hz] using Complex.im_le_norm z
+  constructor
+  · apply (div_le_iff₀ hC).mpr
+    have hh := mul_le_mul_of_nonneg_right hl (norm_nonneg (deriv F z))
+    rw [mul_assoc, hnormprod, mul_one] at hh
+    nlinarith [norm_nonneg (deriv F z)]
+  · apply (le_div_iff₀ hs).mpr
+    have hsu := mul_le_mul_of_nonneg_right hzs (norm_nonneg (deriv F z))
+    have hR := mul_le_mul_of_nonneg_left hnear hC.le
+    nlinarith
+
+/-- Bounded physical tips, a common clearance ball, and an interior
+waypoint angle supply exactly the normal-family normalization constants. -/
+theorem waypoint_family_normalization_of_clearance
+    (F g : ℕ → ℂ → ℂ) (D : ℕ → Set ℂ) (hD : ∀ n, IsOpen (D n))
+    (hF : ∀ n, DifferentiableOn ℂ (F n) upperHalfPlane)
+    (hiF : ∀ 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)
+    (z a : ℕ → ℂ) (s ρ R A : ℝ) (hs : 0 < s) (hρ : 0 < ρ)
+    (hz : ∀ n, ‖z n‖ = 1 ∧ s ≤ (z n).im)
+    (hclear : ∀ n, ball (F n (z n)) ρ ⊆ D n)
+    (ha : ∀ n, a n ∉ F n '' upperHalfPlane)
+    (hnear : ∀ n, ‖F n (z n) - a n‖ ≤ R) (htip : ∀ n, ‖a n‖ ≤ A) :
+    ∃ m M : ℝ, 0 < m ∧
+      (∀ n, ‖F n (z n)‖ ≤ M) ∧
+      (∀ n, m ≤ ‖deriv (F n) (z n)‖ ∧ ‖deriv (F n) (z n)‖ ≤ M) ∧
+      (∀ n, ‖a n‖ ≤ M) := by
+  let M := max A (max (A + R) ((128 * Real.pi) * R / s))
+  have hAM : A ≤ M := le_max_left _ _
+  have hvalM : A + R ≤ M := (le_max_left _ _).trans (le_max_right _ _)
+  have hderM : (128 * Real.pi) * R / s ≤ M :=
+    (le_max_right _ _).trans (le_max_right _ _)
+  refine ⟨ρ / (128 * Real.pi), M, by positivity, ?_, ?_, ?_⟩
+  · intro n
+    calc
+      ‖F n (z n)‖ ≤ ‖F n (z n) - a n‖ + ‖a n‖ := by
+        simpa only [add_comm] using norm_le_insert' (F n (z n)) (a n)
+      _ ≤ R + A := add_le_add (hnear n) (htip n)
+      _ = A + R := add_comm _ _
+      _ ≤ M := hvalM
+  · intro n
+    have hb := waypoint_derivative_bounds_of_clearance (F n) (g n) (D n) (hD n)
+      (hF n) (hiF n) (hg n) (hig n) (hFD n) (hgH n) (hgf n)
+      (z n) (a n) s ρ R hs hρ (hz n).1 (hz n).2 (hclear n) (ha n) (hnear n)
+    exact ⟨hb.1, hb.2.trans hderM⟩
+  · exact fun n => (htip n).trans hAM
+
+end SLEExactGauge
+
+end
+
+end OAI
diff --git a/lean/OAI/Probability/SLE/Geometry/WaypointRouteAvoidance.lean b/lean/OAI/Probability/SLE/Geometry/WaypointRouteAvoidance.lean
new file mode 100644
index 0000000000000000000000000000000000000000..c87b6ec679287644c5350310fa2bd0001a41f35d
--- /dev/null
+++ b/lean/OAI/Probability/SLE/Geometry/WaypointRouteAvoidance.lean
@@ -0,0 +1,98 @@
+import OAI.Probability.SLE.Geometry.WaypointRoutes
+
+namespace OAI
+
+/-! After the initial free move, either waypoint route remains a fixed
+distance from the complete access guide. Embedded coordinate disks turn
+this into physical separation, including nonlocal pieces of the guide. -/
+
+noncomputable section
+open Set Metric
+open scoped Topology NNReal
+
+namespace SLEExactGauge.RibbonCoordinates
+
+theorem waypointRoute_before_two_offset
+    (k side : ℝ) (hside : |side| = 1) {t : ℝ}
+    (ht : t ∈ Icc (1 / 4 : ℝ) 2) :
+    1 / 8 ≤ |(waypointRoute k side t).im| := by
+  have hclip : 1 / 4 ≤ unitClip t :=
+    (show 1 / 4 ≤ min 1 t from le_min (by norm_num) ht.1).trans (le_max_right _ _)
+  rw [waypointRoute_im, unitClip_of_nonpos (by linarith [ht.2] : t - 2 ≤ 0),
+    sub_zero, abs_mul, hside, one_mul, abs_of_nonneg (by positivity)]
+  linarith
+
+theorem waypointRoute_guide_separation
+    (k side : ℝ) (hside : |side| = 1) {x t u : ℝ}
+    (hx : |x| ≤ 1 / 16) (ht : 1 / 4 ≤ t) (hu : 0 ≤ u) :
+    1 / 16 ≤ dist (waypointRoute k side t) (guideCoordinate k x u) := by
+  by_cases ht2 : t ≤ 2
+  · have hroute := waypointRoute_before_two_offset k side hside ⟨ht, ht2⟩
+    have hguide := (guideCoordinate_im_bound (k := k) (x := x) hu).trans hx
+    have hh : |(waypointRoute k side t).im| ≤
+        |(waypointRoute k side t).im - (guideCoordinate k x u).im| +
+          |(guideCoordinate k x u).im| := by
+      simpa only [sub_add_cancel] using abs_add_le
+        ((waypointRoute k side t).im - (guideCoordinate k x u).im)
+        (guideCoordinate k x u).im
+    have hn := Complex.abs_im_le_norm (waypointRoute k side t - guideCoordinate k x u)
+    rw [Complex.sub_im] at hn
+    rw [dist_eq_norm]
+    linarith
+  · have hc : unitClip (t - 1) = 1 := unitClip_of_one_le (by linarith)
+    have hn := Complex.abs_re_le_norm (waypointRoute k side t - guideCoordinate k x u)
+    rw [Complex.sub_re, waypointRoute_re, guideCoordinate_re, hc] at hn
+    have hh := neg_le_abs (k + 1 / 2 - 1 - (k + u))
+    rw [dist_eq_norm]
+    linarith
+
+theorem waypointRoute_ball_subset_patch
+    (k side : ℝ) (hside : |side| = 1) (t : ℝ) :
+    closedBall (waypointRoute k side t) (1 / 32) ⊆ crossingPatch k := by
+  intro z hz
+  have hn : ‖z - waypointRoute k side t‖ ≤ 1 / 32 := by
+    simpa only [mem_closedBall, dist_eq_norm] using hz
+  have hre := (Complex.abs_re_le_norm (z - waypointRoute k side t)).trans hn
+  have him := (Complex.abs_im_le_norm (z - waypointRoute k side t)).trans hn
+  rw [Complex.sub_re, waypointRoute_re] at hre
+  rw [Complex.sub_im] at him
+  have hclip0 := unitClip_nonneg (t - 1)
+  have hclip1 := unitClip_le_one (t - 1)
+  have hr := abs_le.mp hre
+  have hi := abs_le.mp him
+  have hri := abs_le.mp (waypointRoute_im_bound k side hside t)
+  exact ⟨by linarith, by linarith, abs_le.mpr ⟨by linarith, by linarith⟩⟩
+
+/-- Physical separation follows from the full ribbon embedding: a nonlocal
+guide point cannot enter the image of a local coordinate disk either. -/
+theorem physical_waypointRoute_avoids_complete_guide
+    (hpublished : PublishedPlanarDiskOpenness)
+    (P : ℂ → ℂ) (hP : ContinuousOn P closedRibbon) (hi : InjOn P closedRibbon)
+    (K : ℝ≥0) (hK : 0 < (K : ℝ)) {k x side t u : ℝ}
+    (hk : 1 ≤ k) (hx : |x| ≤ 1 / 16) (hside : |side| = 1)
+    (hlower : ∀ v ∈ crossingPatch k, ∀ w ∈ crossingPatch k,
+      dist v w ≤ K * dist (P v) (P w))
+    (ht : 1 / 4 ≤ t) (hu : 0 ≤ u) :
+    P (guideCoordinate k x u) ∉ ball (P (waypointRoute k side t)) ((1 / 32 : ℝ) / K) := by
+  intro hmem
+  have hpatch := waypointRoute_ball_subset_patch k side hside t
+  have hsub := crossingPatch_subset_closedRibbon hk
+  have hball : ball (waypointRoute k side t) (1 / 32) ⊆ closedRibbon :=
+    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)))) hmem
+  have hguide : guideCoordinate k x u ∈ closedRibbon :=
+    ⟨by rw [guideCoordinate_re]; linarith,
+      (guideCoordinate_im_bound hu).trans (hx.trans (by norm_num))⟩
+  have heq : z = guideCoordinate k x u := hi (hball hz) hguide he
+  have hd := waypointRoute_guide_separation k side hside hx ht hu
+  rw [heq, mem_ball, dist_comm] at hz
+  linarith
+
+end SLEExactGauge.RibbonCoordinates
+
+end
+
+end OAI
diff --git a/lean/OAI/Probability/SLE/Geometry/WaypointRouteProbability.lean b/lean/OAI/Probability/SLE/Geometry/WaypointRouteProbability.lean
new file mode 100644
index 0000000000000000000000000000000000000000..4d0228a253f91de0977f84c12e097dcc0d489780
--- /dev/null
+++ b/lean/OAI/Probability/SLE/Geometry/WaypointRouteProbability.lean
@@ -0,0 +1,142 @@
+import OAI.Probability.SLE.Geometry.WaypointRouteAvoidance
+import OAI.Probability.SLE.Geometry.PublishedWienerSupport
+
+namespace OAI
+
+/-! Uniform positive probabilities for physical waypoint-route tubes.
+Their constants depend only on the patch speed and tube radius. -/
+
+noncomputable section
+open Set Metric MeasureTheory
+open scoped Topology NNReal ENNReal BoundedContinuousFunction
+
+namespace SLEExactGauge.RibbonCoordinates
+open Target RectangleCrossing
+
+def basedPhysicalWaypointRoute (P : ℂ → ℂ) (k side : ℝ)
+    (hP : ContinuousOn P (crossingPatch k)) (hside : |side| = 1) : unitInterval →ᵇ ℂ :=
+  BoundedContinuousFunction.mkOfCompact
+    ⟨fun t => P (waypointRoute k side (3 * (t : ℝ))) - P ((k + 1 / 2 : ℝ) : ℂ),
+      (hP.comp ((waypointRoute_continuous k side).comp (by fun_prop)).continuousOn
+        (fun t _ => waypointRoute_mem_patch k side hside _)).sub continuousOn_const |>.domRestrict⟩
+
+theorem basedPhysicalWaypointRoute_zero
+    (P : ℂ → ℂ) (k side : ℝ)
+    (hP : ContinuousOn P (crossingPatch k)) (hside : |side| = 1) :
+    basedPhysicalWaypointRoute P k side hP hside 0 = 0 := by
+  change P (waypointRoute k side (3 * (0 : ℝ))) - P ((k + 1 / 2 : ℝ) : ℂ) = 0
+  rw [mul_zero, waypointRoute_zero, sub_self]
+
+theorem basedPhysicalWaypointRoute_lipschitz
+    (P : ℂ → ℂ) (k side : ℝ) (hside : |side| = 1) (C : ℝ≥0)
+    (hP : LipschitzOnWith C P (crossingPatch k)) :
+    LipschitzWith (9 * C) (basedPhysicalWaypointRoute P k side hP.continuousOn hside) := by
+  apply LipschitzWith.of_dist_le_mul
+  intro u v
+  have hh := hP.dist_le_mul (waypointRoute k side (3 * (u : ℝ)))
+    (waypointRoute_mem_patch k side hside _)
+    (waypointRoute k side (3 * (v : ℝ))) (waypointRoute_mem_patch k side hside _)
+  have hr := (waypointRoute_lipschitz k side hside).dist_le_mul
+    (3 * (u : ℝ)) (3 * (v : ℝ))
+  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 hr
+  have hp := hh.trans (mul_le_mul_of_nonneg_left hr C.coe_nonneg)
+  change dist (P (waypointRoute k side (3 * (u : ℝ))) - P ((k + 1 / 2 : ℝ) : ℂ))
+    (P (waypointRoute k side (3 * (v : ℝ))) - P ((k + 1 / 2 : ℝ) : ℂ)) ≤ _
+  rw [dist_sub_right]
+  convert hp using 1
+  push_cast
+  ring
+
+def unitClipPoint (t : ℝ) : unitInterval :=
+  ⟨unitClip t, unitClip_nonneg t, unitClip_le_one t⟩
+
+theorem continuous_unitClipPoint : Continuous unitClipPoint :=
+  unitClip_lipschitz.continuous.subtype_mk _
+
+def physicalUnitBrownianPath (a : ℂ) (b : Driver × Driver) (t : ℝ) : ℂ :=
+  a + planarUnitPath b (unitClipPoint (t / 3))
+
+theorem physicalUnitBrownianPath_continuous (a : ℂ) (b : Driver × Driver) :
+    Continuous (physicalUnitBrownianPath a b) := by
+  exact continuous_const.add ((planarUnitPath b).continuous.comp
+    (continuous_unitClipPoint.comp (by fun_prop)))
+
+/-- Pointwise Brownian support gives a single positive probability for
+every physical route with the fixed patch speed bound. -/
+theorem uniform_physical_waypoint_tube_probability
+    (hpublished : PublishedPlanarWienerUnitSupport)
+    (W : WienerLaw) (hW : IsWiener W) (C : ℝ≥0) {ε : ℝ} (hε : 0 < ε) :
+    ∃ q : ℝ≥0∞, 0 < q ∧ ∀ P : ℂ → ℂ, ∀ k side : ℝ, |side| = 1 →
+      LipschitzOnWith C P (crossingPatch k) → q ≤ (W.prod W) {b |
+        ∀ t ∈ Icc (0 : ℝ) 3,
+          dist (physicalUnitBrownianPath (P ((k + 1 / 2 : ℝ) : ℂ)) b t)
+            (P (waypointRoute k side t)) < ε} := by
+  obtain ⟨q, hq, hbound⟩ := uniform_planarWiener_tube_probability hpublished W hW (9 * C) hε
+  refine ⟨q, hq, ?_⟩
+  intro P k side hside hP
+  refine (hbound (basedPhysicalWaypointRoute P k side hP.continuousOn hside)
+    (basedPhysicalWaypointRoute_lipschitz P k side hside C hP)
+    (basedPhysicalWaypointRoute_zero P k side hP.continuousOn hside)).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 [u]; ring
+  have hh := hb u
+  change dist (planarUnitPath b u)
+    (P (waypointRoute k side (3 * (u : ℝ))) - P ((k + 1 / 2 : ℝ) : ℂ)) < ε at hh
+  rw [he] at hh
+  unfold physicalUnitBrownianPath
+  rw [hu]
+  rw [dist_eq_norm] at hh ⊢
+  convert hh using 1
+  congr 1
+  ring
+
+/-- Either orientation of the final physical leg forces a hit of the
+actual stopped past. -/
+theorem physical_waypoint_tube_hits_past
+    (hpublished : PublishedPlanarDiskOpenness)
+    (P : ℂ → ℂ) (hP : ContinuousOn P closedRibbon) (hi : InjOn P closedRibbon)
+    (K : ℝ≥0) (hK : 0 < (K : ℝ)) {k ε T side : ℝ}
+    (hk : 1 ≤ k) (hε : 0 < ε) (hεsmall : ε ≤ 1 / 8) (hT : 0 < T)
+    (hside : side = -1 ∨ side = 1)
+    (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 3))
+    (hnear : ∀ t ∈ Icc (0 : ℝ) 3,
+      dist (ζ t) (P (waypointRoute k side t)) < (1 / 32 : ℝ) / K) :
+    ∃ s ∈ Icc (0 : ℝ) T, ∃ t ∈ Icc (0 : ℝ) 3, γ s = ζ t := by
+  have hrad : (1 / 32 : ℝ) / K ≤ (1 / 8 : ℝ) / K :=
+    div_le_div_of_nonneg_right (by norm_num) hK.le
+  rcases hside with rfl | rfl
+  · have hmap : MapsTo (fun t : ℝ => 2 + t) (Icc 0 1) (Icc 0 3) := by
+      intro t ht
+      constructor <;> linarith [ht.1, ht.2]
+    obtain ⟨s, hs, t, ht, he⟩ := physical_transverse_tube_hits_past hpublished P hP hi K hK
+      hk hε hεsmall hT hlower γ xp (fun t => ζ (2 + t)) hxp hγ hxp0 hxpT hcore
+      (hζ.comp (by fun_prop) hmap) (fun t ht => by
+        have hh := (hnear _ (hmap ht)).trans_le hrad
+        rwa [waypointRoute_final_negative k ht] at hh)
+    exact ⟨s, hs, 2 + t, hmap ht, he⟩
+  · have hmap : MapsTo (fun t : ℝ => 3 - t) (Icc 0 1) (Icc 0 3) := by
+      intro t ht
+      constructor <;> linarith [ht.1, ht.2]
+    obtain ⟨s, hs, t, ht, he⟩ := physical_transverse_tube_hits_past hpublished P hP hi K hK
+      hk hε hεsmall hT hlower γ xp (fun t => ζ (3 - t)) hxp hγ hxp0 hxpT hcore
+      (hζ.comp (by fun_prop) hmap) (fun t ht => by
+        have hh := (hnear _ (hmap ht)).trans_le hrad
+        rwa [waypointRoute_final_positive k ht] at hh)
+    exact ⟨s, hs, 3 - t, hmap ht, he⟩
+
+end SLEExactGauge.RibbonCoordinates
+
+end
+
+end OAI
diff --git a/lean/OAI/Probability/SLE/Geometry/WaypointRoutes.lean b/lean/OAI/Probability/SLE/Geometry/WaypointRoutes.lean
new file mode 100644
index 0000000000000000000000000000000000000000..b29b3cb0926350121bd67c8d97fca33dbbc72467
--- /dev/null
+++ b/lean/OAI/Probability/SLE/Geometry/WaypointRoutes.lean
@@ -0,0 +1,133 @@
+import OAI.Probability.SLE.Gauge.RibbonRouteLifting
+import OAI.Probability.SLE.Gauge.RibbonSideCorridors
+import OAI.Probability.SLE.Geometry.CompactTubeProbability
+
+namespace OAI
+
+/-! Explicit bounded-speed routes from the waypoint to either side of the
+core and then across it behind the front. These are the deterministic
+templates for the two Brownian tube events in the waypoint argument. -/
+
+noncomputable section
+open Set Metric
+open scoped Topology NNReal BoundedContinuousFunction ENNReal
+
+namespace SLEExactGauge.RibbonCoordinates
+open RectangleCrossing
+
+def unitClip (t : ℝ) : ℝ := max 0 (min 1 t)
+
+theorem unitClip_lipschitz : LipschitzWith 1 unitClip :=
+  (LipschitzWith.id.const_min 1).const_max 0
+
+theorem unitClip_nonneg (t : ℝ) : 0 ≤ unitClip t := le_max_left _ _
+
+theorem unitClip_le_one (t : ℝ) : unitClip t ≤ 1 := by
+  exact max_le (by norm_num) (min_le_left _ _)
+
+theorem unitClip_of_nonpos {t : ℝ} (ht : t ≤ 0) : unitClip t = 0 := by
+  exact max_eq_left ((min_le_right _ _).trans ht)
+
+theorem unitClip_of_one_le {t : ℝ} (ht : 1 ≤ t) : unitClip t = 1 := by
+  rw [unitClip, min_eq_left ht, max_eq_right (by norm_num)]
+
+theorem unitClip_of_mem {t : ℝ} (ht : t ∈ Icc (0 : ℝ) 1) : unitClip t = t := by
+  rw [unitClip, min_eq_right ht.2, max_eq_right ht.1]
+
+def waypointRoute (k side t : ℝ) : ℂ :=
+  (((k + 1 / 2 - unitClip (t - 1) : ℝ) : ℂ)) +
+    (((side * (unitClip t / 2 - unitClip (t - 2)) : ℝ) : ℂ)) * Complex.I
+
+@[simp] theorem waypointRoute_re (k side t : ℝ) :
+    (waypointRoute k side t).re = k + 1 / 2 - unitClip (t - 1) := by
+  simp [waypointRoute]
+
+@[simp] theorem waypointRoute_im (k side t : ℝ) :
+    (waypointRoute k side t).im = side * (unitClip t / 2 - unitClip (t - 2)) := by
+  simp [waypointRoute]
+
+theorem waypointRoute_zero (k side : ℝ) : waypointRoute k side 0 = ((k + 1 / 2 : ℝ) : ℂ) := by
+  norm_num [waypointRoute, unitClip]
+
+theorem waypointRoute_continuous (k side : ℝ) : Continuous (waypointRoute k side) := by
+  have hc := unitClip_lipschitz.continuous
+  unfold waypointRoute
+  fun_prop
+
+theorem waypointRoute_lipschitz (k side : ℝ) (hside : |side| = 1) :
+    LipschitzWith 3 (waypointRoute k side) := by
+  apply LipschitzWith.of_dist_le_mul
+  intro u v
+  have h₀ := unitClip_lipschitz.dist_le_mul u v
+  have h₁ := unitClip_lipschitz.dist_le_mul (u - 1) (v - 1)
+  have h₂ := unitClip_lipschitz.dist_le_mul (u - 2) (v - 2)
+  simp only [Real.dist_eq, NNReal.coe_one, one_mul, sub_sub_sub_cancel_right] at h₀ h₁ h₂
+  have him : |side * (unitClip u / 2 - unitClip (u - 2)) -
+      side * (unitClip v / 2 - unitClip (v - 2))| ≤ 3 / 2 * |u - v| := by
+    rw [← mul_sub, abs_mul, hside, one_mul]
+    have he : (unitClip u / 2 - unitClip (u - 2)) -
+        (unitClip v / 2 - unitClip (v - 2)) =
+        (unitClip u - unitClip v) / 2 - (unitClip (u - 2) - unitClip (v - 2)) := by ring
+    rw [he]
+    have hh := abs_sub ( (unitClip u - unitClip v) / 2) (unitClip (u - 2) - unitClip (v - 2))
+    rw [abs_div, abs_of_pos (by norm_num : (0 : ℝ) < 2)] at hh
+    linarith
+  have hre : |(k + 1 / 2 - unitClip (u - 1)) -
+      (k + 1 / 2 - unitClip (v - 1))| ≤ |u - v| := by
+    simpa only [sub_sub_sub_cancel_left, abs_sub_comm] using h₁
+  have hh := Complex.norm_le_abs_re_add_abs_im (waypointRoute k side u - waypointRoute k side v)
+  simp only [Complex.sub_re, Complex.sub_im, waypointRoute_re, waypointRoute_im] at hh
+  rw [dist_eq_norm, Real.dist_eq]
+  norm_num only [NNReal.coe_ofNat]
+  nlinarith [abs_nonneg (u - v)]
+
+theorem waypointRoute_im_bound (k side : ℝ) (hside : |side| = 1) (t : ℝ) :
+    |(waypointRoute k side t).im| ≤ 1 / 2 := by
+  rw [waypointRoute_im, abs_mul, hside, one_mul]
+  have h₀ := unitClip_nonneg t
+  have h₁ := unitClip_le_one t
+  have h₂ := unitClip_nonneg (t - 2)
+  have h₃ := unitClip_le_one (t - 2)
+  by_cases ht : t ≤ 2
+  · rw [unitClip_of_nonpos (by linarith : t - 2 ≤ 0), sub_zero, abs_of_nonneg (by positivity)]
+    linarith
+  · rw [unitClip_of_one_le (by linarith : 1 ≤ t)]
+    exact abs_le.mpr ⟨by linarith, by linarith⟩
+
+theorem waypointRoute_mem_patch (k side : ℝ) (hside : |side| = 1) (t : ℝ) :
+    waypointRoute k side t ∈ crossingPatch k := by
+  have h₀ := unitClip_nonneg (t - 1)
+  have h₁ := unitClip_le_one (t - 1)
+  refine ⟨?_, ?_, (waypointRoute_im_bound k side hside t).trans (by norm_num)⟩
+  · rw [waypointRoute_re]; linarith
+  · rw [waypointRoute_re]; linarith
+
+/-- The final leg is the fixed transverse template, with one orientation
+for each side. -/
+theorem waypointRoute_final_negative (k : ℝ) {t : ℝ} (ht : t ∈ Icc (0 : ℝ) 1) :
+    waypointRoute k (-1) (2 + t) = transverseTemplate k t := by
+  have h₁ : unitClip (2 + t - 1) = 1 := unitClip_of_one_le (by linarith [ht.1])
+  have h₂ : unitClip (2 + t) = 1 := unitClip_of_one_le (by linarith [ht.1])
+  have h₃ : unitClip (2 + t - 2) = t := by simpa using unitClip_of_mem ht
+  unfold waypointRoute transverseTemplate
+  rw [h₁, h₂, h₃]
+  push_cast
+  ring
+
+theorem waypointRoute_final_positive (k : ℝ) {t : ℝ} (ht : t ∈ Icc (0 : ℝ) 1) :
+    waypointRoute k 1 (3 - t) = transverseTemplate k t := by
+  have h₁ : unitClip (3 - t - 1) = 1 := unitClip_of_one_le (by linarith [ht.2])
+  have h₂ : unitClip (3 - t) = 1 := unitClip_of_one_le (by linarith [ht.2])
+  have h₃ : unitClip (3 - t - 2) = 1 - t := by
+    rw [show 3 - t - 2 = 1 - t by ring]
+    exact unitClip_of_mem ⟨by linarith [ht.2], by linarith [ht.1]⟩
+  unfold waypointRoute transverseTemplate
+  rw [h₁, h₂, h₃]
+  push_cast
+  ring
+
+end SLEExactGauge.RibbonCoordinates
+
+end
+
+end OAI
diff --git a/lean/OAI/Probability/SLE/Geometry/WaypointTubeGeometry.lean b/lean/OAI/Probability/SLE/Geometry/WaypointTubeGeometry.lean
new file mode 100644
index 0000000000000000000000000000000000000000..7d54ea69d1ca4183025a343544a0c905a728e49d
--- /dev/null
+++ b/lean/OAI/Probability/SLE/Geometry/WaypointTubeGeometry.lean
@@ -0,0 +1,65 @@
+import OAI.Probability.SLE.Geometry.WaypointCrosscutSides
+
+namespace OAI
+
+/-! Pointwise geometry of either physical Brownian tube, retaining
+its chosen side for the conformal exit-arc law. -/
+
+noncomputable section
+open Set Metric
+open scoped Topology NNReal
+
+namespace SLEExactGauge.RibbonCoordinates
+
+theorem physical_waypoint_tube_geometry
+    (hopen : PublishedPlanarDiskOpenness)
+    (P : ℂ → ℂ) (hP : ContinuousOn P closedRibbon) (hi : InjOn P closedRibbon)
+    (hH : ∀ z ∈ closedRibbon, 0 < z.re → P z ∈ upperHalfPlane)
+    (K : ℝ≥0) (hK : 0 < (K : ℝ)) {k ε x side : ℝ}
+    (hk : 1 ≤ k) (hε : 0 < ε) (hεsmall : ε ≤ 1 / 8) (hx : |x| ≤ 1 / 16)
+    (hside : side = -1 ∨ side = 1)
+    (hlower : ∀ u ∈ crossingPatch k, ∀ v ∈ crossingPatch k,
+      dist u v ≤ K * dist (P u) (P v))
+    (γ xp : ℝ≥0 → ℂ) (T : ℝ≥0) (hT : 0 < T)
+    (hxp : ContinuousOn xp (Icc 0 T)) (hγ : EqOn γ (P ∘ xp) (Icc 0 T))
+    (hxp0 : (xp 0).re = 0) (hxpT : (xp T).re = k)
+    (hcoords : MapsTo xp (Icc 0 T) closedRibbon)
+    (hcore : ∀ t ∈ Icc 0 T, (xp t).re ≤ k ∧ |(xp t).im| ≤ ε)
+    (hunbounded : ¬ Bornology.IsBounded (P '' futureRibbon k))
+    (ζ : ℝ → ℂ) (hζ : Continuous ζ)
+    (hnear : ∀ t ∈ Icc (0 : ℝ) 3,
+      dist (ζ t) (P (waypointRoute k side t)) < (1 / 32 : ℝ) / K) :
+    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
+  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 ⟨physical_early_waypoint_tube_survives hopen P hP hi hH K hK γ T hk hε hεsmall
+    habs hpast hunbounded hlower ζ (fun t ht => hnear 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 hnear 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)
+      hζ.continuousOn hnear
+    exact ⟨s.toNNReal, hmap hs, t, ht, he⟩
+
+end SLEExactGauge.RibbonCoordinates
+
+end
+
+end OAI
diff --git a/lean/OAI/Probability/SLE/Geometry/WeightedCompactKernel.lean b/lean/OAI/Probability/SLE/Geometry/WeightedCompactKernel.lean
new file mode 100644
index 0000000000000000000000000000000000000000..3d0572a75eb71f416f1160eb8c61a041368aa594
--- /dev/null
+++ b/lean/OAI/Probability/SLE/Geometry/WeightedCompactKernel.lean
@@ -0,0 +1,71 @@
+import OAI.Probability.SLE.Geometry.WeightedCompactTerminal
+import OAI.Probability.SLE.Geometry.PositiveKernelTests
+
+namespace OAI
+
+/-! Compact weighted tests of a positive kernel dominated in mean by the
+initial Green measure. This also treats exceptional nonintegrable sections. -/
+
+noncomputable section
+open Set Filter _root_.MeasureTheory _root_.OAI.MeasureTheory
+open scoped Topology NNReal ENNReal
+
+namespace SLEExactGauge.Multipoint
+
+lemma compactWeightedMass_kernel_lintegral_ne_top
+    {Ω : Type*} [MeasurableSpace Ω] (P : Measure Ω) (κ : ℝ)
+    (μ : Ω → Measure upperHalfPlane) (hμ : Measurable μ)
+    (hbound : P.bind μ ≤ initialGreenMeasure κ)
+    (w : C(upperHalfPlane,ℝ≥0)) (K : Set upperHalfPlane) (hK : IsCompact K) :
+    (∫⁻ ω, ∫⁻ z in K, (w z:ℝ≥0∞) ∂μ ω ∂P) ≠ ∞ := by
+  let f : upperHalfPlane → ℝ := K.indicator (fun z => (w z:ℝ))
+  have hfm : Measurable f :=
+    (continuous_subtype_val.comp w.continuous).measurable.indicator hK.measurableSet
+  have he (z : upperHalfPlane) : ENNReal.ofReal (f z)=K.indicator (fun z => (w z:ℝ≥0∞)) z := by
+    by_cases hz : z ∈ K <;> simp [f,hz]
+  have hfi : Integrable f (P.bind μ) := by
+    let : IsFiniteMeasureOnCompacts (initialGreenMeasure κ) := initialGreenMeasure_finite_on_compacts κ
+    exact ((integrable_indicator_iff hK.measurableSet).mpr
+      (compact_weight_integrable w K hK (initialGreenMeasure κ))).mono_measure hbound
+  simp_rw [← lintegral_indicator hK.measurableSet,← he]
+  rw [← Measure.lintegral_bind (m := P) hμ.aemeasurable hfm.ennreal_ofReal.aemeasurable]
+  exact (lintegral_ofReal_lt_top_of_integrable hfi).ne
+
+lemma compactWeightedMass_kernel_integrable
+    {Ω : Type*} [MeasurableSpace Ω] (P : Measure Ω) (κ : ℝ)
+    (μ : Ω → Measure upperHalfPlane) (hμ : Measurable μ)
+    (hbound : P.bind μ ≤ initialGreenMeasure κ)
+    (w : C(upperHalfPlane,ℝ≥0)) (K : Set upperHalfPlane) (hK : IsCompact K) :
+    Integrable (fun ω => compactWeightedMass w K (μ ω)) P ∧
+      (∫ ω, compactWeightedMass w K (μ ω) ∂P) =
+        compactWeightedMass w K (P.bind μ) := by
+  let f : upperHalfPlane → ℝ := K.indicator (fun z => (w z:ℝ))
+  have hfm : Measurable f :=
+    (continuous_subtype_val.comp w.continuous).measurable.indicator hK.measurableSet
+  have hf0 (z : upperHalfPlane) : 0 ≤ f z := by
+    exact indicator_nonneg (fun z _ => (w z).coe_nonneg) z
+  have hfi : Integrable f (P.bind μ) := by
+    let : IsFiniteMeasureOnCompacts (initialGreenMeasure κ) := initialGreenMeasure_finite_on_compacts κ
+    exact ((integrable_indicator_iff hK.measurableSet).mpr
+      (compact_weight_integrable w K hK (initialGreenMeasure κ))).mono_measure hbound
+  have hm : Measurable (fun ω => ∫⁻ z, ENNReal.ofReal (f z) ∂μ ω) :=
+    (Measure.measurable_lintegral hfm.ennreal_ofReal).comp hμ
+  have hfin : (∫⁻ ω, ∫⁻ z, ENNReal.ofReal (f z) ∂μ ω ∂P) ≠ ∞ := by
+    rw [← Measure.lintegral_bind (m := P) hμ.aemeasurable hfm.ennreal_ofReal.aemeasurable,
+      ← ofReal_integral_eq_lintegral_ofReal hfi (ae_of_all _ hf0)]
+    exact ENNReal.ofReal_ne_top
+  have he (ν : Measure upperHalfPlane) : compactWeightedMass w K ν =
+      (∫⁻ z, ENNReal.ofReal (f z) ∂ν).toReal := by
+    rw [compactWeightedMass,← integral_indicator hK.measurableSet]
+    exact integral_eq_lintegral_of_nonneg_ae (ae_of_all _ hf0) hfm.aestronglyMeasurable
+  refine ⟨?_,?_⟩
+  · simpa only [he] using integrable_toReal_of_lintegral_ne_top hm.aemeasurable hfin
+  · simp_rw [he]
+    rw [integral_toReal hm.aemeasurable (ae_lt_top hm hfin),
+      ← Measure.lintegral_bind (m := P) hμ.aemeasurable hfm.ennreal_ofReal.aemeasurable]
+
+end SLEExactGauge.Multipoint
+
+end
+
+end OAI
diff --git a/lean/OAI/Probability/SLE/Geometry/WeightedCompactTerminal.lean b/lean/OAI/Probability/SLE/Geometry/WeightedCompactTerminal.lean
new file mode 100644
index 0000000000000000000000000000000000000000..19753a6b85797fa436b73828594b4d551ff10d9f
--- /dev/null
+++ b/lean/OAI/Probability/SLE/Geometry/WeightedCompactTerminal.lean
@@ -0,0 +1,146 @@
+import OAI.Probability.SLE.Mass.WeightedCompactMass
+import OAI.Probability.SLE.Mass.MassCompensatorRecovery
+
+namespace OAI
+
+/-! The compact weighted canonical mass is a continuous increasing scalar
+process with an integrable squared terminal bound. -/
+
+noncomputable section
+open Set Filter _root_.MeasureTheory _root_.OAI.MeasureTheory ProbabilityTheory
+open scoped Topology NNReal ENNReal
+
+namespace SLEExactGauge.Multipoint
+
+def compactWeightedMass (w : C(upperHalfPlane,ℝ≥0))
+    (K : Set upperHalfPlane) (μ : Measure upperHalfPlane) : ℝ :=
+  ∫ z in K, (w z:ℝ) ∂μ
+
+lemma compactWeightedMass_eq_lintegral (w : C(upperHalfPlane,ℝ≥0))
+    (K : Set upperHalfPlane) (μ : Measure upperHalfPlane) :
+    compactWeightedMass w K μ = (∫⁻ z in K, (w z:ℝ≥0∞) ∂μ).toReal := by
+  have h := integral_eq_lintegral_of_nonneg_ae
+    (μ := μ.restrict K) (ae_of_all _ (fun z => (w z).coe_nonneg))
+    (continuous_subtype_val.comp w.continuous).measurable.aestronglyMeasurable
+  simpa only [compactWeightedMass,ENNReal.ofReal_coe_nnreal] using h
+
+lemma compactWeightedMass_measurable (w : C(upperHalfPlane,ℝ≥0))
+    (K : Set upperHalfPlane) (hK : MeasurableSet K) :
+    Measurable (compactWeightedMass w K) := by
+  have he : compactWeightedMass w K =
+      (fun μ => (∫⁻ z, K.indicator (fun z => (w z:ℝ≥0∞)) z ∂μ).toReal) := by
+    funext μ
+    rw [compactWeightedMass_eq_lintegral,lintegral_indicator hK]
+  rw [he]
+  exact (Measure.measurable_lintegral
+    (w.continuous.measurable.coe_nnreal_ennreal.indicator hK)).ennreal_toReal
+
+lemma compactWeightedMass_nonneg (w : C(upperHalfPlane,ℝ≥0))
+    (K : Set upperHalfPlane) (μ : Measure upperHalfPlane) :
+    0 ≤ compactWeightedMass w K μ :=
+  integral_nonneg (fun z => (w z).coe_nonneg)
+
+@[simp] lemma compactWeightedMass_zero (w : C(upperHalfPlane,ℝ≥0))
+    (K : Set upperHalfPlane) : compactWeightedMass w K 0 = 0 := by
+  simp [compactWeightedMass]
+
+lemma compactWeightedMass_mono (w : C(upperHalfPlane,ℝ≥0))
+    (K : Set upperHalfPlane) (hK : IsCompact K)
+    {μ ν : Measure upperHalfPlane} [IsFiniteMeasureOnCompacts ν] (hμν : μ ≤ ν) :
+    compactWeightedMass w K μ ≤ compactWeightedMass w K ν := by
+  let : IsFiniteMeasure (μ.restrict K) :=
+    ⟨lt_of_le_of_lt (Measure.restrict_mono le_rfl hμν univ) (by simpa using hK.measure_lt_top (μ := ν))⟩
+  let : IsFiniteMeasure (ν.restrict K) := ⟨by simpa using hK.measure_lt_top (μ := ν)⟩
+  obtain ⟨M,hM⟩ := compact_weight_bounded w K hK
+  exact sub_nonneg.mp (integral_weight_difference_le (μ.restrict K) (ν.restrict K)
+    (Measure.restrict_mono le_rfl hμν) _ (compact_weight_integrable w K hK ν) M
+    (ae_of_all _ (fun z => (w z).coe_nonneg))
+    ((ae_restrict_mem hK.measurableSet).mono (fun z hz => NNReal.coe_le_coe.mpr (hM z hz)))).1
+
+lemma compactWeightedMass_le (w : C(upperHalfPlane,ℝ≥0))
+    (K : Set upperHalfPlane) (hK : IsCompact K)
+    (M : ℝ≥0) (hM : ∀ z ∈ K, w z ≤ M)
+    (μ : Measure upperHalfPlane) [IsFiniteMeasureOnCompacts μ] :
+    compactWeightedMass w K μ ≤ (M:ℝ)*(μ K).toReal := by
+  let : IsFiniteMeasure (μ.restrict K) := ⟨by simpa using hK.measure_lt_top (μ := μ)⟩
+  have h := integral_mono_ae (compact_weight_integrable w K hK μ)
+    (integrable_const (μ := μ.restrict K) (M:ℝ))
+    ((ae_restrict_mem hK.measurableSet).mono (fun z hz => NNReal.coe_le_coe.mpr (hM z hz)))
+  simpa only [compactWeightedMass,integral_const,smul_eq_mul,measureReal_def,
+    Measure.restrict_apply_univ,mul_comm] using h
+
+lemma compactWeightedMass_tendsto
+    (w : C(upperHalfPlane,ℝ≥0)) (K : Set upperHalfPlane) (hK : IsCompact K)
+    (N : ℝ≥0 → Measure upperHalfPlane) (ν : Measure upperHalfPlane)
+    [IsFiniteMeasureOnCompacts ν] (hNr : ∀ t, IsFiniteMeasureOnCompacts (N t))
+    (hdom : ∀ t, N t ≤ ν)
+    (hlim : Tendsto (fun t => (ν-N t) K) atTop (𝓝 0)) :
+    Tendsto (fun t => compactWeightedMass w K (N t)) atTop
+      (𝓝 (compactWeightedMass w K ν)) := by
+  obtain ⟨M,hM⟩ := compact_weight_bounded w K hK
+  have hb (t : ℝ≥0) : |compactWeightedMass w K (N t)-compactWeightedMass w K ν| ≤
+      (M:ℝ)*((ν-N t) K).toReal := by
+    let := hNr t
+    have h := compact_weight_difference_le w K hK M hM (N t) ν (hdom t)
+    have he : ((ν-N t) K).toReal = (ν K).toReal-(N t K).toReal := by
+      rw [sub_apply_of_finite_restriction (hdom t) hK.measurableSet hK.measure_lt_top.ne,
+        ENNReal.toReal_sub_of_le (hdom t K) hK.measure_lt_top.ne]
+    rw [he]
+    have hn : (N t K).toReal ≤ (ν K).toReal :=
+      ENNReal.toReal_mono hK.measure_lt_top.ne (hdom t K)
+    simpa only [compactWeightedMass,abs_sub_comm,abs_of_nonneg (sub_nonneg.mpr hn)] using h
+  have hl : Tendsto (fun t => (M:ℝ)*((ν-N t) K).toReal) atTop (𝓝 0) := by
+    simpa only [Function.comp_def,ENNReal.toReal_zero,mul_zero] using
+      tendsto_const_nhds.mul ((ENNReal.tendsto_toReal ENNReal.zero_ne_top).comp hlim)
+  have hz := squeeze_zero (fun t => abs_nonneg (compactWeightedMass w K (N t)-
+    compactWeightedMass w K ν)) hb hl
+  exact tendsto_iff_dist_tendsto_zero.mpr (by simpa only [Real.dist_eq] using hz)
+
+namespace CanonicalMass
+
+variable {Ω : Type*} [mΩ : MeasurableSpace Ω] {P : Measure Ω} {κ : ℝ}
+  {B : ℝ≥0 → Ω → ℝ} {hBm : Measurable (Function.uncurry B)}
+  {γ : Ω → ℝ≥0 → ℂ} {G : Ω → ℝ≥0 → ℂ → ℂ}
+  (C : CanonicalMass P κ B hBm γ G)
+
+lemma compactWeightedMass_terminal_memLp
+    (w : C(upperHalfPlane,ℝ≥0)) (K : Set upperHalfPlane) (hK : IsCompact K) :
+    MemLp (fun ω => compactWeightedMass w K (C.rational.terminal ω)) 2 P := by
+  obtain ⟨M,hM⟩ := compact_weight_bounded w K hK
+  have hm := (Measure.measurable_coe hK.measurableSet).comp C.rational.terminal_measurable
+  have hLp := memLp_toReal_two P _ hm _ (C.rational.moments K hK 2) le_rfl
+  apply (hLp.const_mul (M:ℝ)).mono'
+    ((compactWeightedMass_measurable w K hK.measurableSet).comp
+      C.rational.terminal_measurable).aestronglyMeasurable
+  filter_upwards [] with ω
+  let := (C.rational.terminal_radon ω).2
+  dsimp only [Function.comp_def]
+  rw [Real.norm_of_nonneg (compactWeightedMass_nonneg w K _)]
+  exact compactWeightedMass_le w K hK M hM _
+
+lemma compactWeightedMass_paths
+    (w : C(upperHalfPlane,ℝ≥0)) (K : Set upperHalfPlane) (hK : IsCompact K) :
+    ∀ᵐ ω ∂P, Monotone (fun t => compactWeightedMass w K (C.process t ω)) ∧
+      compactWeightedMass w K (C.process 0 ω)=0 ∧
+      Continuous (fun t => compactWeightedMass w K (C.process t ω)) ∧
+      Tendsto (fun t => compactWeightedMass w K (C.process t ω)) atTop
+        (𝓝 (compactWeightedMass w K (C.rational.terminal ω))) ∧
+      ∀ t, compactWeightedMass w K (C.process t ω) ≤
+        compactWeightedMass w K (C.rational.terminal ω) := by
+  filter_upwards [C.paths,C.exhaustion] with ω hp he
+  let := (C.rational.terminal_radon ω).2
+  refine ⟨?_,?_,hp.weighted_compact_continuous (fun t => (C.radon t ω).2) w K hK,
+    compactWeightedMass_tendsto w K hK _ _ (fun t => (C.radon t ω).2) hp.dominated (he K hK),?_⟩
+  · intro s t hst
+    let := (C.radon t ω).2
+    exact compactWeightedMass_mono w K hK (hp.monotone hst)
+  · rw [hp.zero,compactWeightedMass_zero]
+  · intro t
+    exact compactWeightedMass_mono w K hK (hp.dominated t)
+
+end CanonicalMass
+end SLEExactGauge.Multipoint
+
+end
+
+end OAI
diff --git a/lean/OAI/Probability/SLE/Loewner/ActualApproach.lean b/lean/OAI/Probability/SLE/Loewner/ActualApproach.lean
new file mode 100644
index 0000000000000000000000000000000000000000..221eee2369fa2e39c2dae15859e3b7df02326a52
--- /dev/null
+++ b/lean/OAI/Probability/SLE/Loewner/ActualApproach.lean
@@ -0,0 +1,147 @@
+import OAI.Probability.SLE.Loewner.CanonicalApproach
+import OAI.Probability.SLE.Geometry.RestartSectionUpper
+import OAI.Probability.SLE.Loewner.RestartDomainEquality
+import OAI.Probability.SLE.Geometry.FiniteDensityAtRadiusState
+import OAI.Probability.SLE.Geometry.StoppedMarkedStateMeasurability
+
+namespace OAI
+
+/-! The one-point approach estimate conditional on an actual finite stopped
+past. The density on that past is the exact terminal finite-centered law. -/
+
+noncomputable section
+open Set Filter MeasureTheory ProbabilityTheory
+open scoped Topology NNReal ENNReal
+
+namespace SLEExactGauge
+
+local instance actualApproachDriverMeasurable : MeasurableSpace C(ℝ≥0, ℝ) := borel _
+local instance actualApproachDriverBorel : BorelSpace C(ℝ≥0, ℝ) := ⟨rfl⟩
+local instance actualApproachPathMeasurable : MeasurableSpace C(ℝ≥0, ℂ) := borel _
+local instance actualApproachPathBorel : BorelSpace C(ℝ≥0, ℂ) := ⟨rfl⟩
+
+lemma greenDensity_radius_factor
+    {U : ℝ≥0 → ℝ} {γ : ℝ≥0 → ℂ} {G F : ℝ≥0 → ℂ → ℂ}
+    (hw : IsCapacityTwoWitness U γ G F) (hU : Continuous U)
+    (κ : ℝ) (T : ℝ≥0) (z : ℂ) (hz : z ∈ survivingDomain γ T) :
+    (Real.sin (Complex.arg (G T z - (U T : ℂ)))) ^ greenExponent κ =
+      (fullRadius G T z) ^ codimension κ * greenDensity κ U γ G T z := by
+  have hR := hw.fullRadius_positive hU T z hz
+  rw [greenDensity, ite_eq_left hz, ← mul_assoc, ← Real.rpow_add hR,
+    add_neg_cancel, Real.rpow_zero, one_mul]
+
+theorem actual_conditional_radius_approach
+    {Ω : 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 → ℂ → ℂ)
+    (hw : ∀ ω, IsCapacityTwoWitness (fun t => Real.sqrt κ * B t ω) (γ ω) (G ω) (F ω))
+    (htrace : PublishedTraceGeneration (P.map (sourceDriverPath B hc)) κ (fun t p => p t))
+    (τ : Ω → ℝ≥0)
+    (hτ : IsStoppingTime (Filtration.natural B
+      (fun _t => (hBm.comp (measurable_const.prodMk measurable_id)).stronglyMeasurable))
+      (fun ω => (τ ω : WithTop ℝ≥0)))
+    (z : ℂ) (hz : z ∈ upperHalfPlane) (u : ℝ) (hu : 0 ≤ u)
+    (v : ℝ≥0) (hv : 1 ≤ (v : ℝ))
+    (E : Set Ω) (hE : MeasurableSet[hτ.measurableSpace] E)
+    (hlive : ∀ ω ∈ E, z ∈ survivingDomain (γ ω) (τ ω))
+    (hbase : ∀ ω ∈ E, fullRadius (G ω) (τ ω) z = (2 * z.im) * Real.exp (-u))
+    (A : Set Ω) (hA : MeasurableSet[hτ.measurableSpace] A) :
+    P (A ∩ E ∩ {ω | radiusLevelTime (γ ω) (G ω) z (u + v) < ∞}) ≤
+      ENNReal.ofReal (uniformInverseAngleConstant κ 1 * Real.exp (-codimension κ * v) *
+        ((2 * z.im) * Real.exp (-u)) ^ codimension κ * initialGreen κ z) *
+        finiteCenteredLaw P κ B γ G z (u + v) (A ∩ E) := by
+  classical
+  let hm (t : ℝ≥0) : Measurable (B t) := hBm.comp (measurable_const.prodMk measurable_id)
+  let ν := P.map (sourceDriverPath B hc)
+  have hbp : Measurable (sourceDriverPath B hc) := source_path_measurable _ hm
+  have : IsProbabilityMeasure ν :=
+    (Measure.isProbabilityMeasure_map_iff hbp.aemeasurable).mpr inferInstance
+  obtain ⟨Φ, Gc, Fc, hΦ, hW⟩ := exists_measurable_canonical_witness ν κ htrace
+  let Y := sourceRestartDriverPath B hc τ
+  have hY : Measurable Y := source_path_measurable Y (fun t =>
+    (measurable_pi_apply t).comp (brownianRestart_measurable hm hc
+      (stopping_time_measurable_nnreal hτ)))
+  have hYlaw (A : Set Ω) (hA : MeasurableSet[hτ.measurableSpace] A) :
+      (P.restrict A).map Y = P A • ν :=
+    source_restart_continuous_driver_law hB hm hc τ hτ hA
+  have hYlaw₀ : P.map Y = ν := by
+    simpa only [Measure.restrict_univ, measure_univ, one_smul] using hYlaw univ MeasurableSet.univ
+  have hdriver (ω : Ω) : (fun t => Real.sqrt κ * Y ω t) =
+      (fun t => Real.sqrt κ * B (τ ω + t) ω - Real.sqrt κ * B (τ ω) ω) := by
+    funext t
+    exact mul_sub _ _ _
+  have hrestart := canonical_witness_pullback hW Y hY hYlaw₀
+  let w := stoppedMarkedCenter κ B γ G τ z
+  have hwm : Measurable[hτ.measurableSpace] w :=
+    source_stoppedMarkedCenter_measurable B hm hc κ γ G F hw τ hτ z
+  have hwH (ω : Ω) (hω : ω ∈ E) : w ω ∈ upperHalfPlane := by
+    dsimp only [w]
+    rw [stoppedMarkedCenter_eq κ B γ G τ z ω (hlive ω hω)]
+    simpa only [upperHalfPlane, mem_ofPred_eq, Complex.sub_im, Complex.ofReal_im, sub_zero]
+      using (hw ω).imag_positive (τ ω) z (hlive ω hω)
+  have hpoint (ω : Ω) (hω : ω ∈ E) :
+      F ω (τ ω) (w ω + (Real.sqrt κ * B (τ ω) ω : ℝ)) = z := by
+    dsimp only [w]
+    rw [stoppedMarkedCenter_eq κ B γ G τ z ω (hlive ω hω), sub_add_cancel]
+    exact (hw ω).2.2.2.2.2.2.2.1 _ _ (hlive ω hω)
+  let C : Set (Ω × C(ℝ≥0, ℝ)) :=
+    {p | canonicalRadiusLevel κ ((v : ℝ), w p.1, p.2) < ∞}
+  have hC : @MeasurableSet (Ω × C(ℝ≥0, ℝ))
+      (hτ.measurableSpace.prod inferInstance) C :=
+    @measurableSet_lt _ _ _ _ _ (hτ.measurableSpace.prod inferInstance) _ _ _ _ _
+      ((canonicalRadiusLevel_measurable κ).comp
+        (measurable_const.prodMk ((hwm.comp measurable_fst).prodMk measurable_snd))) measurable_const
+  let r : Ω → ℝ≥0∞ := fun ω => ENNReal.ofReal
+    (uniformInverseAngleConstant κ 1 * Real.exp (-codimension κ * v) *
+      (Real.sin (Complex.arg (w ω))) ^ greenExponent κ)
+  have hsections (ω : Ω) (hω : ω ∈ E) : ν {p | (ω, p) ∈ C} ≤ r ω :=
+    canonical_radius_approach ν (canonical_driver_isBrownian B hB hm hc) κ hκ hκ8
+      Φ Gc Fc hW (w ω) (hwH ω hω) v hv
+  have hactual : ∀ᵐ ω ∂P, ω ∈ E →
+      radiusLevelTime (γ ω) (G ω) z (u + v) < ∞ → (ω, Y ω) ∈ C := by
+    filter_upwards [hrestart] with ω hω hωE hfinite
+    have hω' := hdriver ω ▸ hω
+    have hbase' := hbase ω hωE
+    rw [← hpoint ω hωE] at hbase' hfinite
+    have hs := ((hw ω).restart_radius_finite_iff ((hc ω).const_mul _) (τ ω) hω'
+      (w ω) (hwH ω hωE) u v hu (by linarith) hbase').mp hfinite
+    change canonicalRadiusLevel κ ((v : ℝ), w ω, Y ω) < ∞
+    rwa [canonicalRadiusLevel_eq κ (Y ω) hω _ v.coe_nonneg (w ω)]
+  have hbound := restart_event_section_upper_bound P ν hτ.measurableSpace hτ.measurableSpace_le
+    Y hY hYlaw C hC E hE {ω | radiusLevelTime (γ ω) (G ω) z (u + v) < ∞}
+    r hsections hactual A hA
+  obtain ⟨M, _, _, hMactual, hMpast⟩ :=
+    exists_finiteDensity_at_radius_state hB hBm hc hB0 κ hκ hκ8 γ G F hw
+      τ hτ z hz u v hu (by linarith) E hE hlive hbase
+  let K := uniformInverseAngleConstant κ 1 * Real.exp (-codimension κ * v) *
+    ((2 * z.im) * Real.exp (-u)) ^ codimension κ * initialGreen κ z
+  have hK0 : 0 ≤ K := by
+    exact mul_nonneg (mul_nonneg (mul_nonneg
+      (uniformInverseAngleConstant_pos κ 1 hκ hκ8 (by norm_num)).le (Real.exp_pos _).le)
+      (Real.rpow_nonneg (mul_nonneg (mul_nonneg (by norm_num) hz.le) (Real.exp_pos _).le) _))
+      (initialGreen_pos κ z hz).le
+  have heq : r =ᵐ[P.restrict (A ∩ E)] (fun ω => ENNReal.ofReal K * M ω) := by
+    filter_upwards [ae_restrict_of_ae hMactual, ae_restrict_mem (hτ.measurableSpace_le _ (hA.inter hE))]
+      with ω hMω hω
+    rw [hMω hω.2, ← ENNReal.ofReal_mul hK0]
+    apply congrArg ENNReal.ofReal
+    dsimp only [r, K, w]
+    rw [stoppedMarkedCenter_eq κ B γ G τ z ω (hlive ω hω.2),
+      greenDensity_radius_factor (hw ω) ((hc ω).const_mul _) κ (τ ω) z (hlive ω hω.2),
+      hbase ω hω.2]
+    field_simp [(initialGreen_pos κ z hz).ne']
+  calc
+    _ ≤ ∫⁻ ω in A ∩ E, r ω ∂P := hbound
+    _ = ∫⁻ ω in A ∩ E, ENNReal.ofReal K * M ω ∂P := lintegral_congr_ae heq
+    _ = ENNReal.ofReal K * (∫⁻ ω in A ∩ E, M ω ∂P) :=
+      lintegral_const_mul' _ _ ENNReal.ofReal_ne_top
+    _ = _ := by rw [hMpast A hA]
+
+end SLEExactGauge
+
+end
+
+end OAI
diff --git a/lean/OAI/Probability/SLE/Loewner/ActualApproachAtRadius.lean b/lean/OAI/Probability/SLE/Loewner/ActualApproachAtRadius.lean
new file mode 100644
index 0000000000000000000000000000000000000000..894da70724d67b2d874bb48986415e7ebeee5535
--- /dev/null
+++ b/lean/OAI/Probability/SLE/Loewner/ActualApproachAtRadius.lean
@@ -0,0 +1,105 @@
+import OAI.Probability.SLE.Loewner.ActualApproach
+import OAI.Probability.SLE.Loewner.ActualRadiusStopsRegular
+import OAI.Probability.SLE.Gauge.ExtendedExperimentStop
+
+namespace OAI
+
+/-! The conditional approach estimate on the whole past of an actual
+radius stop, including samples where that stop is never reached. -/
+
+noncomputable section
+open Set Filter MeasureTheory ProbabilityTheory
+open scoped Topology NNReal ENNReal
+
+namespace SLEExactGauge
+
+local instance radiusApproachDriverMeasurable : MeasurableSpace C(ℝ≥0, ℝ) := borel _
+local instance radiusApproachDriverBorel : BorelSpace C(ℝ≥0, ℝ) := ⟨rfl⟩
+
+theorem actual_radius_level_finite_state
+    {U : ℝ≥0 → ℝ} {γ : ℝ≥0 → ℂ} {G F : ℝ≥0 → ℂ → ℂ}
+    (hw : IsCapacityTwoWitness U γ G F) (hU : Continuous U)
+    (z : ℂ) (u : ℝ) (hfinite : radiusLevelTime γ G z u ≠ ∞) :
+    z ∈ survivingDomain γ (radiusLevelTime γ G z u).toNNReal ∧
+      fullRadius G (radiusLevelTime γ G z u).toNNReal z = (2 * z.im) * Real.exp (-u) := by
+  obtain ⟨T, hT, hR⟩ := exists_live_level_of_radiusLevelTime_lt_top γ G z u (lt_top_iff_ne_top.mpr hfinite)
+  rw [radiusLevelTime_eq_of_live_level hU hw z u T hT hR, ENNReal.toNNReal_coe]
+  exact ⟨hT, hR⟩
+
+theorem actual_conditional_approach_at_radius_stop
+    {Ω : 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 → ℂ → ℂ)
+    (hw : ∀ ω, IsCapacityTwoWitness (fun t => Real.sqrt κ * B t ω) (γ ω) (G ω) (F ω))
+    (htrace : PublishedTraceGeneration (P.map (sourceDriverPath B hc)) κ (fun t p => p t))
+    (z : ℂ) (hz : z ∈ upperHalfPlane) (u : ℝ) (hu : 0 ≤ u)
+    (v : ℝ≥0) (hv : 1 ≤ (v : ℝ))
+    (A : Set Ω)
+    (hA : MeasurableSet[(actual_radiusLevelTime_stopping hB
+      (fun _t => hBm.comp (measurable_const.prodMk measurable_id)) hBm hc hB0
+      κ hκ hκ8 γ G F hw z hz u hu).measurableSpace] A) :
+    P (A ∩ {ω | radiusLevelTime (γ ω) (G ω) z (u + v) < ∞}) ≤
+      ENNReal.ofReal (uniformInverseAngleConstant κ 1 * Real.exp (-codimension κ * v) *
+        ((2 * z.im) * Real.exp (-u)) ^ codimension κ * initialGreen κ z) *
+        finiteCenteredLaw P κ B γ G z (u + v) A := by
+  let hm (t : ℝ≥0) : Measurable (B t) := hBm.comp (measurable_const.prodMk measurable_id)
+  let σ : Ω → WithTop ℝ≥0 := fun ω => radiusLevelTime (γ ω) (G ω) z u
+  have hσ := actual_radiusLevelTime_stopping hB hm hBm hc hB0 κ hκ hκ8 γ G F hw z hz u hu
+  let Q := finiteCenteredLaw P κ B γ G z (u + v)
+  let K := ENNReal.ofReal (uniformInverseAngleConstant κ 1 * Real.exp (-codimension κ * v) *
+    ((2 * z.im) * Real.exp (-u)) ^ codimension κ * initialGreen κ z)
+  let T : Set Ω := {ω | radiusLevelTime (γ ω) (G ω) z (u + v) < ∞}
+  let D (n : ℕ) := A ∩ {ω | σ ω ≤ ((n : ℝ≥0) : WithTop ℝ≥0)}
+  have hmono : Monotone (fun n => D n ∩ T) := by
+    intro n k hnk ω hω
+    refine ⟨⟨hω.1.1, ?_⟩, hω.2⟩
+    change σ ω ≤ ((k : ℝ≥0) : WithTop ℝ≥0)
+    exact hω.1.2.trans (WithTop.coe_le_coe.mpr (by exact_mod_cast hnk))
+  have hcover : A ∩ T = ⋃ n, D n ∩ T := by
+    ext ω
+    constructor
+    · rintro ⟨hωA, hωT⟩
+      have hfinite : σ ω ≠ ⊤ := by
+        have hlt := (radiusLevelTime_mono ((hc ω).const_mul _) (hw ω) z hu
+          (show u ≤ u + v by linarith [v.coe_nonneg])).trans_lt hωT
+        exact hlt.ne
+      lift σ ω to ℝ≥0 using hfinite with t ht
+      obtain ⟨n, hn⟩ := exists_nat_ge (t : ℝ)
+      apply mem_iUnion.mpr
+      refine ⟨n, ⟨hωA, ?_⟩, hωT⟩
+      change σ ω ≤ ((n : ℝ≥0) : WithTop ℝ≥0)
+      rw [← ht]
+      exact WithTop.coe_le_coe.mpr (by exact_mod_cast hn)
+    · intro hω
+      obtain ⟨n, hn⟩ := mem_iUnion.mp hω
+      exact ⟨hn.1.1, hn.2⟩
+  have hlocal (n : ℕ) : P (D n ∩ T) ≤ K * Q A := by
+    let τ := cutoffStop σ (n : ℝ≥0)
+    have hτ := cutoffStop_stopping _ σ hσ (n : ℝ≥0)
+    have hD := cutoffStop_success_measurable _ σ hσ (n : ℝ≥0) A hA
+    have hstate (ω : Ω) (hω : ω ∈ D n) :
+        z ∈ survivingDomain (γ ω) (τ ω) ∧
+          fullRadius (G ω) (τ ω) z = (2 * z.im) * Real.exp (-u) := by
+      have hfin : radiusLevelTime (γ ω) (G ω) z u ≠ ∞ :=
+        ne_top_of_le_ne_top WithTop.coe_ne_top hω.2
+      have he : τ ω = (radiusLevelTime (γ ω) (G ω) z u).toNNReal :=
+        cutoffStop_eq_on_success σ _ ω hω.2
+      rw [he]
+      exact actual_radius_level_finite_state (hw ω) ((hc ω).const_mul _) z u hfin
+    have hh := actual_conditional_radius_approach P κ hκ hκ8 B hB hBm hc hB0 γ G F hw htrace
+      τ hτ z hz u hu v hv (D n) hD (fun ω hω => (hstate ω hω).1)
+      (fun ω hω => (hstate ω hω).2) (D n) hD
+    simp only [inter_self] at hh
+    exact hh.trans (mul_le_mul' le_rfl (measure_mono inter_subset_left))
+  change P (A ∩ T) ≤ K * Q A
+  rw [hcover, hmono.measure_iUnion]
+  exact iSup_le hlocal
+
+end SLEExactGauge
+
+end
+
+end OAI
diff --git a/lean/OAI/Probability/SLE/Loewner/ActualDiskGrowth.lean b/lean/OAI/Probability/SLE/Loewner/ActualDiskGrowth.lean
new file mode 100644
index 0000000000000000000000000000000000000000..a0932cf7680133157a1c46202253de406237666b
--- /dev/null
+++ b/lean/OAI/Probability/SLE/Loewner/ActualDiskGrowth.lean
@@ -0,0 +1,19 @@
+import OAI.Probability.SLE.Loewner.UnivalentSecondCoefficient
+import OAI.Probability.SLE.Geometry.DiskGrowthFromSecondCoefficient
+
+namespace OAI
+
+/-! The sharp disk-growth estimate follows from the odd-root area
+estimate and radial integration. -/
+noncomputable section
+
+namespace SLEExactGauge
+
+theorem actual_diskUnivalentGrowth : PublishedDiskUnivalentGrowth :=
+  diskGrowth_of_secondDerivative (fun _ hf hi => univalent_second_derivative_bound hf hi)
+
+end SLEExactGauge
+
+end
+
+end OAI
diff --git a/lean/OAI/Probability/SLE/Loewner/ActualRadiusStops.lean b/lean/OAI/Probability/SLE/Loewner/ActualRadiusStops.lean
new file mode 100644
index 0000000000000000000000000000000000000000..353f6a5ddb4a212ad541360e8000a6b07a9d6c45
--- /dev/null
+++ b/lean/OAI/Probability/SLE/Loewner/ActualRadiusStops.lean
@@ -0,0 +1,141 @@
+import OAI.Probability.SLE.KernelExpectation
+import OAI.Probability.SLE.Mass.DenseCoverMassTests
+
+namespace OAI
+
+/-! Geometric conformal-radius levels have increasing stopping-time
+versions. Running maxima make the versions increasing on every outcome,
+while preserving the actual geometric times almost surely. -/
+
+noncomputable section
+open Set Filter MeasureTheory ProbabilityTheory
+open scoped Topology NNReal ENNReal
+
+namespace SLEExactGauge
+
+lemma exists_live_level_of_radiusLevelTime_lt_top
+    (γ : ℝ≥0 → ℂ) (G : ℝ≥0 → ℂ → ℂ) (z : ℂ) (u : ℝ)
+    (h : radiusLevelTime γ G z u < ∞) :
+    ∃ t : ℝ≥0, z ∈ survivingDomain γ t ∧
+      fullRadius G t z = (2 * z.im) * Real.exp (-u) := by
+  by_contra hn
+  exact h.ne (radiusLevelTime_eq_top_of_no_level γ G z u hn)
+
+lemma live_radius_level_before
+    {U : ℝ≥0 → ℝ} {γ : ℝ≥0 → ℂ} {G F : ℝ≥0 → ℂ → ℂ}
+    (hU : Continuous U) (hw : IsCapacityTwoWitness U γ G F)
+    (z : ℂ) {u v : ℝ} (hu : 0 ≤ u) (huv : u ≤ v)
+    (T : ℝ≥0) (hT : z ∈ survivingDomain γ T)
+    (hR : fullRadius G T z = (2 * z.im) * Real.exp (-v)) :
+    ∃ t : ℝ≥0, t ≤ T ∧ z ∈ survivingDomain γ t ∧
+      fullRadius G t z = (2 * z.im) * Real.exp (-u) := by
+  let L : ℝ → ℝ := fun s => Real.log ((2 * z.im) / fullRadius G s.toNNReal z)
+  have hy : 0 < 2 * z.im := mul_pos (by norm_num) hT.1.1
+  have hz0 := survivingDomain_antitone γ (show (0 : ℝ≥0) ≤ T from zero_le) hT
+  have hL0 : L 0 = 0 := by
+    simp only [L, Real.toNNReal_zero, hw.fullRadius_initial hU z hz0,
+      div_self hy.ne', Real.log_one]
+  have hLT : L T = v := by
+    dsimp only [L]
+    rw [Real.toNNReal_coe, ← logRadiusClock_logCoordinates hU hw z T hT]
+    exact (fullRadius_level_iff_logClock hU hw z T hT v).mp hR
+  have hLc : ContinuousOn L (Icc 0 (T : ℝ)) :=
+    fun s hs => (loewner_radius_clock_derivative hU hw T z hT s hs).continuousWithinAt
+  obtain ⟨s, hs, hsu⟩ := intermediate_value_Icc T.coe_nonneg hLc
+    (show u ∈ Icc (L 0) (L T) from ⟨by rwa [hL0], by rwa [hLT]⟩)
+  have hsl := hw.live_at_real_time T z hT s hs.2
+  refine ⟨s.toNNReal, Real.toNNReal_le_iff_le_coe.mpr hs.2, hsl, ?_⟩
+  apply (fullRadius_level_iff_logClock hU hw z s.toNNReal hsl u).mpr
+  rw [logRadiusClock_logCoordinates hU hw z s.toNNReal hsl]
+  exact hsu
+
+lemma radiusLevelTime_mono
+    {U : ℝ≥0 → ℝ} {γ : ℝ≥0 → ℂ} {G F : ℝ≥0 → ℂ → ℂ}
+    (hU : Continuous U) (hw : IsCapacityTwoWitness U γ G F)
+    (z : ℂ) {u v : ℝ} (hu : 0 ≤ u) (huv : u ≤ v) :
+    radiusLevelTime γ G z u ≤ radiusLevelTime γ G z v := by
+  by_cases hv : radiusLevelTime γ G z v = ∞
+  · rw [hv]; exact le_top
+  obtain ⟨T, hT, hR⟩ := exists_live_level_of_radiusLevelTime_lt_top γ G z v
+    (lt_top_iff_ne_top.mpr hv)
+  obtain ⟨t, ht, htl, htr⟩ := live_radius_level_before hU hw z hu huv T hT hR
+  rw [radiusLevelTime_eq_of_live_level hU hw z u t htl htr,
+    radiusLevelTime_eq_of_live_level hU hw z v T hT hR]
+  exact_mod_cast ht
+
+def runningMaxStops {Ω : Type*} (ρ : ℕ → Ω → WithTop ℝ≥0) :
+    ℕ → Ω → WithTop ℝ≥0
+  | 0 => ρ 0
+  | n + 1 => fun ω => max (runningMaxStops ρ n ω) (ρ (n + 1) ω)
+
+lemma runningMaxStops_stopping
+    {Ω : Type*} [mΩ : MeasurableSpace Ω] (ℱ : Filtration ℝ≥0 mΩ)
+    (ρ : ℕ → Ω → WithTop ℝ≥0) (hρ : ∀ j, IsStoppingTime ℱ (ρ j)) :
+    ∀ j, IsStoppingTime ℱ (runningMaxStops ρ j)
+  | 0 => hρ 0
+  | j + 1 => (runningMaxStops_stopping ℱ ρ hρ j).max (hρ (j + 1))
+
+lemma runningMaxStops_monotone {Ω : Type*}
+    (ρ : ℕ → Ω → WithTop ℝ≥0) (ω : Ω) :
+    Monotone (fun j => runningMaxStops ρ j ω) :=
+  monotone_nat_of_le_succ (fun _j => le_max_left _ _)
+
+lemma runningMaxStops_eq_of_monotone {Ω : Type*}
+    (ρ : ℕ → Ω → WithTop ℝ≥0) (ω : Ω) (hmono : Monotone (fun j => ρ j ω)) :
+    ∀ j, runningMaxStops ρ j ω = ρ j ω
+  | 0 => rfl
+  | j + 1 => by
+    change max (runningMaxStops ρ j ω) (ρ (j + 1) ω) = ρ (j + 1) ω
+    rw [runningMaxStops_eq_of_monotone ρ ω hmono j,
+      max_eq_right (hmono (Nat.le_succ j))]
+
+/-- One increasing stopping sequence represents all prescribed radius
+levels simultaneously, including outcomes on which a level is never hit. -/
+theorem exists_monotone_radiusLevel_stops
+    {Ω : 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))
+    (hBc : ∀ ω, Continuous (fun t => B t ω)) (hB0 : ∀ ω, B 0 ω = 0)
+    (κ : ℝ) (hκ : 0 < κ) (hκ8 : κ < 8)
+    (γ : Ω → ℝ≥0 → ℂ) (G F : Ω → ℝ≥0 → ℂ → ℂ)
+    (hw : ∀ᵐ ω ∂P, IsCapacityTwoWitness
+      (fun t => Real.sqrt κ * B t ω) (γ ω) (G ω) (F ω))
+    (z : ℂ) (hz : z ∈ upperHalfPlane)
+    (u : ℕ → ℝ) (hu : ∀ j, 0 ≤ u j) (hmono : Monotone u) :
+    ∃ τ : ℕ → Ω → WithTop ℝ≥0,
+      (∀ j, IsStoppingTime (Filtration.natural B (fun t => (hm t).stronglyMeasurable)) (τ j)) ∧
+      (∀ ω, Monotone (fun j => τ j ω)) ∧
+      ∀ᵐ ω ∂P, ∀ j, τ j ω = radiusLevelTime (γ ω) (G ω) z (u j) := by
+  let A₀ := logAngleSq κ (initialLogCoordinates z) 0
+  have hA₀ : 0 < A₀ := logAngleSq_pos _ _ _
+  let ε (n : ℕ) := A₀ / ((n : ℝ) + 1)
+  have hε (n : ℕ) : 0 < ε n := by dsimp [ε]; positivity
+  have hε₀ (n : ℕ) : ε n ≤ A₀ :=
+    div_le_self hA₀.le (by have h := Nat.cast_nonneg (α := ℝ) n; linarith)
+  have hεlim : Tendsto ε atTop (𝓝 0) := by
+    have hh := (tendsto_one_div_add_atTop_nhds_zero_nat (𝕜 := ℝ)).const_mul A₀
+    simpa only [mul_one_div, mul_zero] using hh
+  let a (j n : ℕ) : AngularLocalization B hm κ z (u j) (ε n) :=
+    Classical.choice (exists_angularLocalization hB hm hBm hBc hB0 κ hκ hκ8 z (u j)
+      (ε n) (hu j) (hε n) (hε₀ n))
+  let ρ := fun j => localizedRadiusStop (a j)
+  refine ⟨runningMaxStops ρ,
+    runningMaxStops_stopping _ ρ (fun j => localizedRadiusStop_stopping (a j)),
+    runningMaxStops_monotone ρ, ?_⟩
+  filter_upwards [hw] with ω hω
+  have he (j : ℕ) : ρ j ω = radiusLevelTime (γ ω) (G ω) z (u j) :=
+    localizedRadiusStop_eq_source (a j) hεlim hBc hz ω (γ ω) (G ω) (F ω) hω
+  have hρmono : Monotone (fun j => ρ j ω) := by
+    intro i j hij
+    change ρ i ω ≤ ρ j ω
+    rw [he i, he j]
+    exact radiusLevelTime_mono ((hBc ω).const_mul _) hω z (hu i) (hmono hij)
+  intro j
+  rw [runningMaxStops_eq_of_monotone ρ ω hρmono j, he j]
+
+end SLEExactGauge
+
+end
+
+end OAI
diff --git a/lean/OAI/Probability/SLE/Loewner/ActualRadiusStopsRegular.lean b/lean/OAI/Probability/SLE/Loewner/ActualRadiusStopsRegular.lean
new file mode 100644
index 0000000000000000000000000000000000000000..bc66fbc787be142f4f8dda6d3e49033552ebb20a
--- /dev/null
+++ b/lean/OAI/Probability/SLE/Loewner/ActualRadiusStopsRegular.lean
@@ -0,0 +1,66 @@
+import OAI.Probability.SLE.Loewner.ActualRadiusStops
+
+namespace OAI
+
+/-! For a regular Brownian driver with an actual capacity witness at every
+sample, the literal geometric radius-level time is a stopping time. No
+modification on an exceptional set is needed. -/
+
+noncomputable section
+open Set Filter MeasureTheory ProbabilityTheory
+open scoped Topology NNReal ENNReal
+
+namespace SLEExactGauge
+
+theorem actual_radiusLevelTime_stopping
+    {Ω : 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 : ℝ) (hu : 0 ≤ u) :
+    IsStoppingTime (Filtration.natural B (fun t => (hm t).stronglyMeasurable))
+      (fun ω => (radiusLevelTime (γ ω) (G ω) z u : WithTop ℝ≥0)) := by
+  let A₀ := logAngleSq κ (initialLogCoordinates z) 0
+  have hA₀ : 0 < A₀ := logAngleSq_pos _ _ _
+  let ε (n : ℕ) := A₀ / ((n : ℝ) + 1)
+  have hε (n : ℕ) : 0 < ε n := by dsimp [ε]; positivity
+  have hε₀ (n : ℕ) : ε n ≤ A₀ :=
+    div_le_self hA₀.le (by have h := Nat.cast_nonneg (α := ℝ) n; linarith)
+  have hεlim : Tendsto ε atTop (𝓝 0) := by
+    have hh := (tendsto_one_div_add_atTop_nhds_zero_nat (𝕜 := ℝ)).const_mul A₀
+    simpa only [mul_one_div, mul_zero] using hh
+  let a (n : ℕ) : AngularLocalization B hm κ z u (ε n) :=
+    Classical.choice (exists_angularLocalization hB hm hBm hc hB0 κ hκ hκ8 z u
+      (ε n) hu (hε n) (hε₀ n))
+  have he : localizedRadiusStop a = fun ω => radiusLevelTime (γ ω) (G ω) z u := by
+    funext ω
+    exact localizedRadiusStop_eq_source a hεlim hc hz ω (γ ω) (G ω) (F ω) (hw ω)
+  rw [← he]
+  exact localizedRadiusStop_stopping a
+
+lemma actual_radiusLevelTime_past_mono
+    {Ω : 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 v : ℝ) (hu : 0 ≤ u) (huv : u ≤ v) :
+    (actual_radiusLevelTime_stopping hB hm hBm hc hB0 κ hκ hκ8 γ G F hw z hz u hu).measurableSpace ≤
+      (actual_radiusLevelTime_stopping hB hm hBm hc hB0 κ hκ hκ8 γ G F hw z hz v
+        (hu.trans huv)).measurableSpace :=
+  (actual_radiusLevelTime_stopping hB hm hBm hc hB0 κ hκ hκ8 γ G F hw z hz u hu).measurableSpace_mono
+    (actual_radiusLevelTime_stopping hB hm hBm hc hB0 κ hκ hκ8 γ G F hw z hz v (hu.trans huv))
+    (fun ω => radiusLevelTime_mono ((hc ω).const_mul _) (hw ω) z hu huv)
+
+end SLEExactGauge
+
+end
+
+end OAI
diff --git a/lean/OAI/Probability/SLE/Loewner/CanonicalApproach.lean b/lean/OAI/Probability/SLE/Loewner/CanonicalApproach.lean
new file mode 100644
index 0000000000000000000000000000000000000000..4c0115a729f061b31b432df7429554a17cf7fe4a
--- /dev/null
+++ b/lean/OAI/Probability/SLE/Loewner/CanonicalApproach.lean
@@ -0,0 +1,46 @@
+import OAI.Probability.SLE.Loewner.CanonicalRadiusKernel
+import OAI.Probability.SLE.OccupationBound
+
+namespace OAI
+
+/-! A jointly measurable canonical kernel for the one-point approach
+estimate permits random marked-state substitution at a stopped past. -/
+
+noncomputable section
+open Set Filter MeasureTheory ProbabilityTheory
+open scoped Topology NNReal ENNReal
+
+namespace SLEExactGauge
+
+local instance approachDriverMeasurable : MeasurableSpace C(ℝ≥0, ℝ) := borel _
+local instance approachDriverBorel : BorelSpace C(ℝ≥0, ℝ) := ⟨rfl⟩
+
+theorem canonical_radius_approach
+    (ν : Measure C(ℝ≥0, ℝ)) [IsProbabilityMeasure ν]
+    (hB : IsBrownianReal (fun (t : ℝ≥0) (p : C(ℝ≥0, ℝ)) => p t) ν)
+    (κ : ℝ) (hκ : 0 < κ) (hκ8 : κ < 8)
+    (Φ : C(ℝ≥0, ℝ) → C(ℝ≥0, ℂ))
+    (Gc Fc : C(ℝ≥0, ℝ) → ℝ≥0 → ℂ → ℂ)
+    (hw : ∀ᵐ p ∂ν, IsCapacityTwoWitness
+      (fun t => Real.sqrt κ * p t) (Φ p) (Gc p) (Fc p))
+    (w : ℂ) (hwH : w ∈ upperHalfPlane) (v : ℝ≥0) (hv : 1 ≤ (v : ℝ)) :
+    ν {p | canonicalRadiusLevel κ ((v : ℝ), w, p) < ∞} ≤
+      ENNReal.ofReal (uniformInverseAngleConstant κ 1 * Real.exp (-codimension κ * v) *
+        (Real.sin (Complex.arg w)) ^ greenExponent κ) := by
+  have he : ν {p | canonicalRadiusLevel κ ((v : ℝ), w, p) < ∞} =
+      ν {p | radiusLevelTime (Φ p) (Gc p) w v < ∞} := by
+    apply measure_congr
+    filter_upwards [hw] with p hp
+    rw [canonicalRadiusLevel_eq κ p hp _ v.coe_nonneg w]
+  rw [he]
+  calc
+    _ = ENNReal.ofReal (ν {p | radiusLevelTime (Φ p) (Gc p) w v < ∞}).toReal :=
+      (ENNReal.ofReal_toReal (measure_ne_top _ _)).symm
+    _ ≤ _ := ENNReal.ofReal_le_ofReal (radius_approach hB κ hκ hκ8
+      (fun p t => Φ p t) Gc Fc hw w hwH v hv)
+
+end SLEExactGauge
+
+end
+
+end OAI
diff --git a/lean/OAI/Probability/SLE/Loewner/CanonicalCapacityWitness.lean b/lean/OAI/Probability/SLE/Loewner/CanonicalCapacityWitness.lean
new file mode 100644
index 0000000000000000000000000000000000000000..a6015927df75c148cc31de5ab10f65bff262384a
--- /dev/null
+++ b/lean/OAI/Probability/SLE/Loewner/CanonicalCapacityWitness.lean
@@ -0,0 +1,79 @@
+import OAI.Probability.SLE.Loewner.CanonicalHydrodynamic
+import OAI.Probability.SLE.Loewner.CanonicalFlowEvolution
+
+namespace OAI
+
+/-! All components of the raw capacity-two witness on the normalized
+Wiener space, using the same continuous trace modification throughout. -/
+noncomputable section
+open Set Filter _root_.MeasureTheory _root_.OAI.MeasureTheory ProbabilityTheory
+open scoped Topology NNReal ENNReal
+
+namespace SLEExactGauge
+
+theorem exists_canonical_capacity_witness
+    {Ω : 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 Ψ ∧
+      ∀ᵐ b ∂W, IsCapacityTwoWitness (fun t => b (κ.toNNReal*t)) (Ψ b)
+        (fun t z => Target.flow κ b z (κ*t))
+        (fun t z => Target.inverseFlow κ b (κ*t) z) := by
+  obtain ⟨Ψ,hΨ,hΨeq,htrace⟩ := exists_canonical_all_time_boundary_limit
+    κ hκ hκ8 B hB hm hc h0 γ G F hw W hW
+  have hsurv := ae_canonical_survival κ hκ B hB hm hc h0 γ G F hw W hW Ψ hΨ hΨeq
+  have hhol := ae_canonical_inverse_holomorphic κ hκ B hB hm hc h0 γ G F hw W hW
+  have hnonzero := ae_canonical_inverse_deriv_ne_zero κ hκ B hB hm hc h0 γ G F hw W hW
+  have hinfty := ae_canonical_dense_infinity κ hκ B hB hm hc h0 γ G F hw W hW
+  refine ⟨Ψ,hΨ,?_⟩
+  filter_upwards [htrace,hsurv,hhol,hnonzero,hinfty] with b htr hD hF hF' hnorm
+  have hset (T : ℝ≥0) : {z | Target.Surviving κ b z (κ*T)}=survivingDomain (Ψ b) T := by
+    ext z
+    exact hD T z
+  have hG (T : ℝ≥0) : DifferentiableOn ℂ (fun z => Target.flow κ b z (κ*T))
+      (survivingDomain (Ψ b) T) := by
+    have hf : DifferentiableOn ℂ (Target.inverseFlow κ b (κ.toNNReal*T)) upperHalfPlane := by
+      simpa only [NNReal.coe_mul,Real.coe_toNNReal _ hκ.le] using hF T
+    have hf' : ∀ w ∈ upperHalfPlane,
+        deriv (Target.inverseFlow κ b (κ.toNNReal*T)) w ≠ 0 := by
+      simpa only [NNReal.coe_mul,Real.coe_toNNReal _ hκ.le] using hF' T
+    simpa only [NNReal.coe_mul,Real.coe_toNNReal _ hκ.le,hset] using
+      Target.differentiableOn_flow_of_inverse κ hκ b (κ.toNNReal*T) hf hf'
+  refine ⟨(Ψ b).continuous,htr.1,htr.2.1,hG,hF,?_,?_,?_,?_,?_,?_,?_,?_⟩
+  · intro T z hz
+    exact Target.surviving_flow_mem_upperHalfPlane κ b z (κ*T)
+      (mul_nonneg hκ.le T.coe_nonneg) ((hD T z).mpr hz)
+  · intro T z hz
+    apply (hD T _).mp
+    simpa only [NNReal.coe_mul,Real.coe_toNNReal _ hκ.le] using
+      Target.inverseFlow_surviving κ hκ b (κ.toNNReal*T) z hz
+  · intro T z hz
+    exact Target.inverseFlow_eq_of_surviving κ b (κ*T)
+      (mul_nonneg hκ.le T.coe_nonneg) z _ ((hD T z).mpr hz) rfl
+  · intro T z hz
+    simpa only [NNReal.coe_mul,Real.coe_toNNReal _ hκ.le] using
+      Target.flow_inverseFlow κ hκ b (κ.toNNReal*T) z hz
+  · intro z hz
+    simpa only [NNReal.coe_zero,mul_zero] using Target.flow_zero κ b z hz
+  · intro T z hz
+    exact canonical_flow_time_derivative κ hκ b (Ψ b) hD T z hz
+  · intro T
+    have hcont : ContinuousOn (fun z => z*(Target.flow κ b z (κ*T)-z))
+        (survivingDomain (Ψ b) T) :=
+      continuous_id.continuousOn.mul ((hG T).continuousOn.sub continuous_id.continuousOn)
+    have hn : DenseInfinityCriterion (fun z => z*(Target.flow κ b z (κ*T)-z))
+        (survivingDomain (Ψ b) T) (2*(T:ℂ)) := by
+      simpa only [hset] using hnorm T
+    exact hn.tendsto (isOpen_survivingDomain (Ψ b).continuous T) hcont
+  · intro T
+    simpa only [Target.rawTipAt,NNReal.coe_mul,Real.coe_toNNReal _ hκ.le] using htr.2.2 T
+
+end SLEExactGauge
+
+end
+
+end OAI
diff --git a/lean/OAI/Probability/SLE/Loewner/CanonicalFlowEvolution.lean b/lean/OAI/Probability/SLE/Loewner/CanonicalFlowEvolution.lean
new file mode 100644
index 0000000000000000000000000000000000000000..1a8db847acc51b7f05f5f3e6e7ffd0cfbf639079
--- /dev/null
+++ b/lean/OAI/Probability/SLE/Loewner/CanonicalFlowEvolution.lean
@@ -0,0 +1,40 @@
+import OAI.Probability.SLE.Loewner.CanonicalSurvival
+import OAI.Probability.SLE.Angle.TargetFlowEvolution
+
+namespace OAI
+
+/-! The geometric surviving domain is open in time. Its raw-flow
+identification therefore supplies the local interval needed for the ODE. -/
+noncomputable section
+open Set Filter
+open scoped Topology NNReal
+
+namespace SLEExactGauge
+
+lemma survivingDomain_exists_later (γ : C(ℝ≥0,ℂ)) (T : ℝ≥0) (z : ℂ)
+    (hz : z ∈ survivingDomain γ T) :
+    ∃ S : ℝ≥0, T<S ∧ z ∈ survivingDomain γ S := by
+  have hopen : IsOpen {S : ℝ≥0 | z ∈ survivingDomain γ S} :=
+    source_survival_open.preimage ((continuous_const.prodMk continuous_id).prodMk continuous_const)
+  have hn : ∀ᶠ S in 𝓝[>] T, z ∈ survivingDomain γ S :=
+    (show ∀ᶠ S in 𝓝 T, z ∈ survivingDomain γ S from hopen.mem_nhds hz).filter_mono
+      nhdsWithin_le_nhds
+  have hgt : ∀ᶠ S in 𝓝[>] T, T<S := self_mem_nhdsWithin
+  obtain ⟨S,hST,hS⟩ := (hgt.and hn).exists
+  exact ⟨S,hST,hS⟩
+
+lemma canonical_flow_time_derivative
+    (κ : ℝ) (hκ : 0 < κ) (b : Target.Driver) (γ : C(ℝ≥0,ℂ))
+    (hD : ∀ (T : ℝ≥0) (z : ℂ),
+      Target.Surviving κ b z (κ*T) ↔ z ∈ survivingDomain γ T)
+    (T : ℝ≥0) (z : ℂ) (hz : z ∈ survivingDomain γ T) :
+    HasDerivWithinAt (fun u : ℝ => Target.flow κ b z (κ*u.toNNReal))
+      (2/(Target.flow κ b z (κ*T)-(b (κ.toNNReal*T):ℂ))) (Ici 0) T := by
+  obtain ⟨S,hST,hS⟩ := survivingDomain_exists_later γ T z hz
+  exact Target.physical_flow_hasDerivWithinAt κ hκ b z T S hST ((hD S z).mpr hS)
+
+end SLEExactGauge
+
+end
+
+end OAI
diff --git a/lean/OAI/Probability/SLE/Loewner/CanonicalHydrodynamic.lean b/lean/OAI/Probability/SLE/Loewner/CanonicalHydrodynamic.lean
new file mode 100644
index 0000000000000000000000000000000000000000..c14aa1c95f809d0980ed444a5d3d8da8990bdc68
--- /dev/null
+++ b/lean/OAI/Probability/SLE/Loewner/CanonicalHydrodynamic.lean
@@ -0,0 +1,87 @@
+import OAI.Probability.SLE.Loewner.CanonicalInverseNonzero
+import OAI.Probability.SLE.Loewner.CanonicalSurvival
+import OAI.Probability.SLE.Loewner.TargetForwardAnalytic
+import OAI.Probability.SLE.Gauge.DenseInfinityCriterion
+
+namespace OAI
+
+/-! Hydrodynamic normalization transfers through countably many spatial
+tests, followed by continuity on the open surviving domain. -/
+noncomputable section
+open Set Filter _root_.MeasureTheory _root_.OAI.MeasureTheory ProbabilityTheory TopologicalSpace
+open scoped Topology NNReal ENNReal
+
+namespace SLEExactGauge
+
+local instance hydroDriverPolish : PolishSpace Target.Driver :=
+  ContinuousMapZero.isClosedEmbedding_toContinuousMap.polishSpace
+local instance hydroDriverMetric : MetricSpace Target.Driver :=
+  TopologicalSpace.metrizableSpaceMetric Target.Driver
+
+lemma measurableSet_raw_dense_infinity (κ : ℝ) :
+    MeasurableSet {q : ℝ≥0 × Target.Driver |
+      DenseInfinityCriterion (fun z => z*(Target.flow κ q.2 z (κ.toNNReal*q.1)-z))
+        {z | Target.Surviving κ q.2 z (κ.toNNReal*q.1)} (2*(q.1:ℂ))} := by
+  simp only [DenseInfinityCriterion,ofPred_forall,ofPred_exists]
+  apply MeasurableSet.iInter
+  intro k
+  apply MeasurableSet.iUnion
+  intro N
+  apply MeasurableSet.iInter
+  intro n
+  apply MeasurableSet.iInter
+  intro _hn
+  have hm : Measurable (fun q : ℝ≥0 × Target.Driver =>
+      (κ.toNNReal*q.1,(q.2,denseSeq ℂ n))) :=
+    (measurable_const.mul measurable_fst).prodMk (measurable_snd.prodMk measurable_const)
+  have hs := MeasurableSet.preimage
+    (f := fun q : ℝ≥0 × Target.Driver => (κ.toNNReal*q.1,(q.2,denseSeq ℂ n)))
+    (Target.measurableSet_surviving κ) hm
+  have hf : Measurable (fun q : ℝ≥0 × Target.Driver =>
+      ‖denseSeq ℂ n*(Target.flow κ q.2 (denseSeq ℂ n) (κ.toNNReal*q.1)-denseSeq ℂ n)
+        -2*(q.1:ℂ)‖) := by
+    exact ((measurable_const.mul ((Target.measurable_flow κ).comp hm |>.sub measurable_const)).sub
+      (measurable_const.mul measurable_fst.coe_nnreal_real.complex_ofReal)).norm
+  convert hs.compl.union (measurableSet_le hf
+    (measurable_const : Measurable (fun _ : ℝ≥0 × Target.Driver => (1/((k:ℝ)+1))))) using 1
+  ext q
+  simp only [mem_union,mem_compl_iff,mem_ofPred_eq,mem_preimage,imp_iff_not_or,
+    NNReal.coe_mul]
+
+lemma ae_canonical_dense_infinity
+    {Ω : Type*} [MeasurableSpace Ω] {P : Measure Ω}
+    (κ : ℝ) (hκ : 0 < κ) (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) :
+    ∀ᵐ b ∂W, ∀ T : ℝ≥0,
+      DenseInfinityCriterion (fun z => z*(Target.flow κ b z (κ*T)-z))
+        {z | Target.Surviving κ b z (κ*T)} (2*(T:ℂ)) := by
+  have : IsProbabilityMeasure W := hW.isGaussianProcess.isProbabilityMeasure
+  let p (T : ℝ≥0) (b : Target.Driver) :=
+    DenseInfinityCriterion (fun z => z*(Target.flow κ b z (κ.toNNReal*T)-z))
+      {z | Target.Surviving κ b z (κ.toNNReal*T)} (2*(T:ℂ))
+  have hsource : ∀ᵐ ω ∂P, ∀ T, p T (Target.normalizedDriver κ B hc h0 ω) := by
+    apply ae_of_all
+    intro ω T k
+    have hnorm := (hw ω).2.2.2.2.2.2.2.2.2.2.2.1 T
+    obtain ⟨N,hN⟩ := denseInfinityCriterion_of_tendsto hnorm k
+    refine ⟨N,fun n hn hs => ?_⟩
+    rw [Real.coe_toNNReal _ hκ.le] at hs ⊢
+    have hD := (Target.surviving_iff_witness κ hκ _ _ _ _ _ (hw ω)
+      (Target.normalizedDriver_matches κ hκ B hc h0 ω) T _).mp hs
+    have he := Target.flow_eq_witness κ hκ _ _ _ _ _ (hw ω)
+      (Target.normalizedDriver_matches κ hκ B hc h0 ω) T _ hD
+    simpa only [he] using hN n hn hD
+  have hall := ae_forall_parameter_of_hasLaw
+    (Target.normalizedDriver_law κ hκ B hB hm hc h0 W hW)
+    p (measurableSet_raw_dense_infinity κ) hsource
+  filter_upwards [hall] with b hb T
+  simpa only [p,NNReal.coe_mul,Real.coe_toNNReal _ hκ.le] using hb T
+
+end SLEExactGauge
+
+end
+
+end OAI
diff --git a/lean/OAI/Probability/SLE/Loewner/CanonicalInverseAngle.lean b/lean/OAI/Probability/SLE/Loewner/CanonicalInverseAngle.lean
new file mode 100644
index 0000000000000000000000000000000000000000..a442734f79222767640afbba3f6c3e0f7e79ce5b
--- /dev/null
+++ b/lean/OAI/Probability/SLE/Loewner/CanonicalInverseAngle.lean
@@ -0,0 +1,258 @@
+import OAI.Probability.SLE.Loewner.CanonicalRadiusKernel
+import OAI.Probability.SLE.SpatialMeans
+import OAI.Probability.SLE.OccupationBound
+
+namespace OAI
+
+/-! Jointly measurable stopped-angle kernels on continuous driver space.
+The uniform good-angle estimate is a consequence of the proved inverse-angle
+moment bound under the finite centered law. -/
+
+noncomputable section
+open Set Filter MeasureTheory ProbabilityTheory
+open scoped Topology NNReal ENNReal
+
+namespace SLEExactGauge
+
+local instance angleDriverMeasurable : MeasurableSpace C(ℝ≥0, ℝ) := borel _
+local instance angleDriverBorel : BorelSpace C(ℝ≥0, ℝ) := ⟨rfl⟩
+
+def canonicalStoppedCenter (κ : ℝ) (q : ℝ × (ℂ × C(ℝ≥0, ℝ))) : ℂ :=
+  (canonicalRadiusFamily κ).jointChart ((canonicalRadiusLevel κ q).toNNReal, q.2) -
+    ((Real.sqrt κ * q.2.2 (canonicalRadiusLevel κ q).toNNReal : ℝ) : ℂ)
+
+def canonicalStoppedSine (κ : ℝ) (q : ℝ × (ℂ × C(ℝ≥0, ℝ))) : ℝ :=
+  if canonicalRadiusLevel κ q < ∞ then Real.sin (canonicalStoppedCenter κ q).arg else 0
+
+def canonicalStoppedAngleSq (κ : ℝ) (q : ℝ × (ℂ × C(ℝ≥0, ℝ))) : ℝ :=
+  (canonicalStoppedSine κ q) ^ 2
+
+def canonicalInverseAngle (κ : ℝ) (q : ℝ × (ℂ × C(ℝ≥0, ℝ))) : ℝ :=
+  (canonicalStoppedAngleSq κ q) ^ (-greenExponent κ / 2)
+
+lemma canonicalStoppedCenter_measurable (κ : ℝ) : Measurable (canonicalStoppedCenter κ) := by
+  have ht := ENNReal.measurable_toNNReal.comp (canonicalRadiusLevel_measurable κ)
+  have hp : Measurable (fun q : ℝ × (ℂ × C(ℝ≥0, ℝ)) => q.2.2) :=
+    measurable_snd.comp measurable_snd
+  have he := continuous_eval.measurable.comp (hp.prodMk ht)
+  exact ((canonicalRadiusFamily κ).jointChart_measurable.comp
+    (ht.prodMk measurable_snd)).sub (Complex.measurable_ofReal.comp (he.const_mul _))
+
+lemma canonicalStoppedSine_measurable (κ : ℝ) : Measurable (canonicalStoppedSine κ) :=
+  Measurable.ite (measurableSet_lt (canonicalRadiusLevel_measurable κ) measurable_const)
+    (Real.measurable_sin.comp (Complex.measurable_arg.comp
+      (canonicalStoppedCenter_measurable κ))) measurable_const
+
+lemma canonicalStoppedAngleSq_measurable (κ : ℝ) : Measurable (canonicalStoppedAngleSq κ) :=
+  (canonicalStoppedSine_measurable κ).pow_const 2
+
+lemma canonicalInverseAngle_measurable (κ : ℝ) : Measurable (canonicalInverseAngle κ) :=
+  (canonicalStoppedAngleSq_measurable κ).pow measurable_const
+
+lemma canonicalStoppedAngleSq_nonneg (κ : ℝ) (q : ℝ × (ℂ × C(ℝ≥0, ℝ))) :
+    0 ≤ canonicalStoppedAngleSq κ q := sq_nonneg _
+
+lemma canonicalInverseAngle_nonneg (κ : ℝ) (q : ℝ × (ℂ × C(ℝ≥0, ℝ))) :
+    0 ≤ canonicalInverseAngle κ q := Real.rpow_nonneg (sq_nonneg _) _
+
+lemma canonicalStoppedCenter_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 < ∞) :
+    canonicalStoppedCenter κ (u, z, p) =
+      G (radiusLevelTime γ G z u).toNNReal z -
+        ((Real.sqrt κ * p (radiusLevelTime γ G z u).toNNReal : ℝ) : ℂ) := by
+  obtain ⟨T, hT, hTR⟩ := exists_live_level_of_radiusLevelTime_lt_top γ G z u hfinite
+  have he := radiusLevelTime_eq_of_live_level (p.continuous.const_mul _) hw z u T hT hTR
+  unfold canonicalStoppedCenter
+  rw [canonicalRadiusLevel_eq κ p hw u hu z, he, ENNReal.toNNReal_coe,
+    (canonicalRadiusFamily κ).jointChart_eq p (p.continuous.const_mul _) hw T z,
+    ite_eq_left hT]
+
+lemma canonicalStoppedSine_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 < ∞) :
+    canonicalStoppedSine κ (u, z, p) =
+      Real.sin (Complex.arg (G (radiusLevelTime γ G z u).toNNReal z -
+        ((Real.sqrt κ * p (radiusLevelTime γ G z u).toNNReal : ℝ) : ℂ))) := by
+  rw [canonicalStoppedSine, canonicalRadiusLevel_eq κ p hw u hu z, ite_eq_left hfinite,
+    canonicalStoppedCenter_eq κ p hw u hu z hfinite]
+
+lemma canonicalStoppedAngleSq_eq (κ : ℝ) (p : C(ℝ≥0, ℝ))
+    {γ : ℝ≥0 → ℂ} {G F : ℝ≥0 → ℂ → ℂ}
+    (hw : IsCapacityTwoWitness (fun t => Real.sqrt κ * p t) γ G F)
+    (u : ℝ) (hu : 0 ≤ u) (z : ℂ) :
+    canonicalStoppedAngleSq κ (u, z, p) =
+      stoppedAngleSq κ (fun t => p t) γ G z u := by
+  unfold canonicalStoppedAngleSq canonicalStoppedSine stoppedAngleSq
+  rw [canonicalRadiusLevel_eq κ p hw u hu z]
+  split_ifs with hf
+  · rw [canonicalStoppedCenter_eq κ p hw u hu z hf]
+  · norm_num
+
+lemma canonicalInverseAngle_eq (κ : ℝ) (p : C(ℝ≥0, ℝ))
+    {γ : ℝ≥0 → ℂ} {G F : ℝ≥0 → ℂ → ℂ}
+    (hw : IsCapacityTwoWitness (fun t => Real.sqrt κ * p t) γ G F)
+    (u : ℝ) (hu : 0 ≤ u) (z : ℂ) :
+    canonicalInverseAngle κ (u, z, p) =
+      stoppedInverseAngle κ (fun t => p t) γ G z u (greenExponent κ) := by
+  rw [canonicalInverseAngle, stoppedInverseAngle, canonicalStoppedAngleSq_eq κ p hw u hu z]
+
+lemma measurable_canonicalStoppedSine_random_state
+    {Ω : Type*} [MeasurableSpace Ω] (κ : ℝ)
+    {Y : Ω → C(ℝ≥0, ℝ)} (hY : Measurable Y)
+    {u : Ω → ℝ} (hu : Measurable u) {z : Ω → ℂ} (hz : Measurable z) :
+    Measurable (fun ω => canonicalStoppedSine κ (u ω, z ω, Y ω)) :=
+  (canonicalStoppedSine_measurable κ).comp (hu.prodMk (hz.prodMk hY))
+
+/-- One common measurable event can be used for all random marked states. -/
+lemma measurableSet_canonical_good_angle_random_state
+    {Ω : Type*} [MeasurableSpace Ω] (κ s : ℝ)
+    {Y : Ω → C(ℝ≥0, ℝ)} (hY : Measurable Y)
+    {u : Ω → ℝ} (hu : Measurable u) {z : Ω → ℂ} (hz : Measurable z) :
+    MeasurableSet {ω | canonicalRadiusLevel κ (u ω, z ω, Y ω) < ∞ ∧
+      s ≤ canonicalStoppedSine κ (u ω, z ω, Y ω)} :=
+  (measurableSet_lt (measurable_canonicalRadiusLevel_random_state κ hY hu hz)
+    measurable_const).inter
+    (measurableSet_le measurable_const (measurable_canonicalStoppedSine_random_state κ hY hu hz))
+
+/-- The inverse-angle moment bound, represented by a
+single jointly measurable canonical kernel. -/
+theorem canonical_uniform_inverse_angle
+    (ν : Measure C(ℝ≥0, ℝ)) [IsProbabilityMeasure ν]
+    (hB : IsBrownianReal (fun (t : ℝ≥0) (p : C(ℝ≥0, ℝ)) => p t) ν)
+    (κ : ℝ) (hκ : 0 < κ) (hκ8 : κ < 8)
+    (Φ : C(ℝ≥0, ℝ) → C(ℝ≥0, ℂ))
+    (Gc Fc : C(ℝ≥0, ℝ) → ℝ≥0 → ℂ → ℂ)
+    (hw : ∀ᵐ p ∂ν, IsCapacityTwoWitness
+      (fun t => Real.sqrt κ * p t) (Φ p) (Gc p) (Fc p))
+    (z : ℂ) (hz : z ∈ upperHalfPlane) (v : ℝ≥0) (hv : 1 ≤ (v : ℝ)) :
+    Integrable (fun p => canonicalInverseAngle κ ((v : ℝ), z, p))
+      (ν.withDensity (fun p => canonicalFiniteDensity κ ((v : ℝ), z, p))) ∧
+    (∫ p, canonicalInverseAngle κ ((v : ℝ), z, p)
+      ∂ν.withDensity (fun p => canonicalFiniteDensity κ ((v : ℝ), z, p))) ≤
+        uniformInverseAngleConstant κ 1 := by
+  obtain ⟨hi, hb⟩ := uniform_inverse_angle hB κ hκ hκ8
+    (fun p t => Φ p t) Gc Fc hw z hz 1 (by norm_num) v hv
+  have heq := canonical_finiteCenteredLaw_eq ν κ Φ Gc Fc hw v v.coe_nonneg z
+  rw [heq] at hi hb
+  have he : (fun p => stoppedInverseAngle κ (fun t => p t) (Φ p) (Gc p) z v
+      (greenExponent κ)) =ᵐ[ν.withDensity (fun p => canonicalFiniteDensity κ ((v : ℝ), z, p))]
+      (fun p => canonicalInverseAngle κ ((v : ℝ), z, p)) := by
+    filter_upwards [(withDensity_absolutelyContinuous ν _).ae_le hw] with p hp
+    exact (canonicalInverseAngle_eq κ p hp v v.coe_nonneg z).symm
+  exact ⟨hi.congr he, (integral_congr_ae he).symm.trans_le hb⟩
+
+/-- Under the finite centered law the canonical stopped point is live and
+its angle is strictly in the upper half-plane. -/
+theorem canonical_finiteCenteredLaw_live_angle
+    (ν : Measure C(ℝ≥0, ℝ)) [IsProbabilityMeasure ν]
+    (hB : IsBrownianReal (fun (t : ℝ≥0) (p : C(ℝ≥0, ℝ)) => p t) ν)
+    (κ : ℝ) (hκ : 0 < κ) (hκ8 : κ < 8)
+    (Φ : C(ℝ≥0, ℝ) → C(ℝ≥0, ℂ))
+    (Gc Fc : C(ℝ≥0, ℝ) → ℝ≥0 → ℂ → ℂ)
+    (hw : ∀ᵐ p ∂ν, IsCapacityTwoWitness
+      (fun t => Real.sqrt κ * p t) (Φ p) (Gc p) (Fc p))
+    (z : ℂ) (hz : z ∈ upperHalfPlane) (u : ℝ) (hu : 0 ≤ u) :
+    ∀ᵐ p ∂ν.withDensity (fun p => canonicalFiniteDensity κ (u, z, p)),
+      canonicalRadiusLevel κ (u, z, p) < ∞ ∧ 0 < canonicalStoppedSine κ (u, z, p) := by
+  have hl := finiteCenteredLaw_live_compact hB κ hκ hκ8
+    (fun p t => Φ p t) Gc Fc hw z hz u hu
+  rw [canonical_finiteCenteredLaw_eq ν κ Φ Gc Fc hw u hu z] at hl
+  filter_upwards [hl, (withDensity_absolutelyContinuous ν _).ae_le hw] with p hp hwp
+  obtain ⟨T, hT, hTR, he, _⟩ := hp
+  have hf : radiusLevelTime (Φ p) (Gc p) z u < ∞ := by
+    rw [he]
+    exact ENNReal.coe_lt_top
+  refine ⟨by rwa [canonicalRadiusLevel_eq κ p hwp u hu z], ?_⟩
+  rw [canonicalStoppedSine, canonicalRadiusLevel_eq κ p hwp u hu z, ite_eq_left hf,
+    canonicalStoppedCenter_eq κ p hwp u hu z hf, he, ENNReal.toNNReal_coe,
+    Complex.sin_arg]
+  apply div_pos
+  · simpa only [Complex.sub_im, Complex.ofReal_im, sub_zero] using hwp.imag_positive T z hT
+  · apply norm_pos_iff.mpr
+    intro hezero
+    have him := hwp.imag_positive T z hT
+    have heIm := congrArg Complex.im hezero
+    simp only [Complex.sub_im, Complex.ofReal_im, Complex.zero_im, sub_zero] at heIm
+    exact (ne_of_gt him) heIm
+
+/-- A uniform positive fraction of every finite centered law has an angle
+bounded away from the real axis. The same threshold works for every marked
+point and every radius level at least one. -/
+theorem canonical_uniform_good_angle
+    (ν : Measure C(ℝ≥0, ℝ)) [IsProbabilityMeasure ν]
+    (hB : IsBrownianReal (fun (t : ℝ≥0) (p : C(ℝ≥0, ℝ)) => p t) ν)
+    (κ : ℝ) (hκ : 0 < κ) (hκ8 : κ < 8)
+    (Φ : C(ℝ≥0, ℝ) → C(ℝ≥0, ℂ))
+    (Gc Fc : C(ℝ≥0, ℝ) → ℝ≥0 → ℂ → ℂ)
+    (hw : ∀ᵐ p ∂ν, IsCapacityTwoWitness
+      (fun t => Real.sqrt κ * p t) (Φ p) (Gc p) (Fc p)) :
+    ∃ s : ℝ, 0 < s ∧ ∀ z ∈ upperHalfPlane, ∀ v : ℝ≥0, 1 ≤ (v : ℝ) →
+      ENNReal.ofReal (1 / 2 : ℝ) ≤
+        (ν.withDensity (fun p => canonicalFiniteDensity κ ((v : ℝ), z, p)))
+          {p | canonicalRadiusLevel κ ((v : ℝ), z, p) < ∞ ∧
+            s ≤ canonicalStoppedSine κ ((v : ℝ), z, p)} := by
+  let K := uniformInverseAngleConstant κ 1
+  have hK : 0 < K := uniformInverseAngleConstant_pos κ 1 hκ hκ8 (by norm_num)
+  let M := 2 * K + 1
+  have hM : 0 < M := by dsimp [M]; positivity
+  let b := -greenExponent κ / 2
+  have hb : b < 0 := by dsimp [b]; linarith [greenExponent_pos κ hκ hκ8]
+  let d := M ^ b⁻¹
+  have hd : 0 < d := Real.rpow_pos_of_pos hM _
+  have hdM : d ^ b = M := Real.rpow_inv_rpow hM.le hb.ne
+  refine ⟨Real.sqrt d, Real.sqrt_pos.mpr hd, ?_⟩
+  intro z hz v hv
+  let Q := ν.withDensity (fun p => canonicalFiniteDensity κ ((v : ℝ), z, p))
+  have hprob : IsProbabilityMeasure Q := by
+    dsimp only [Q]
+    rw [← canonical_finiteCenteredLaw_eq ν κ Φ Gc Fc hw v v.coe_nonneg z]
+    exact finiteCenteredLaw_probability hB κ hκ hκ8 (fun p t => Φ p t) Gc Fc hw z hz v v.coe_nonneg
+  let : IsProbabilityMeasure Q := hprob
+  let X := fun p => canonicalInverseAngle κ ((v : ℝ), z, p)
+  obtain ⟨hXi, hXb⟩ := canonical_uniform_inverse_angle ν hB κ hκ hκ8 Φ Gc Fc hw z hz v hv
+  let A : Set C(ℝ≥0, ℝ) := {p | M ≤ X p}
+  let E : Set C(ℝ≥0, ℝ) := {p | canonicalRadiusLevel κ ((v : ℝ), z, p) < ∞ ∧
+    Real.sqrt d ≤ canonicalStoppedSine κ ((v : ℝ), z, p)}
+  have hA : Q A ≤ ENNReal.ofReal (1 / 2 : ℝ) := by
+    apply (nonnegative_integral_tail X hXi
+      (fun p => canonicalInverseAngle_nonneg κ _) K M hM hXb).trans
+    apply ENNReal.ofReal_le_ofReal
+    apply (div_le_iff₀ hM).mpr
+    dsimp [M]
+    linarith
+  have hcover : ∀ᵐ p ∂Q, p ∈ A ∪ E := by
+    filter_upwards [canonical_finiteCenteredLaw_live_angle ν hB κ hκ hκ8 Φ Gc Fc hw
+      z hz v v.coe_nonneg] with p hp
+    by_cases hAp : M ≤ X p
+    · exact Or.inl hAp
+    right
+    refine ⟨hp.1, ?_⟩
+    have hx : 0 < canonicalStoppedAngleSq κ ((v : ℝ), z, p) := sq_pos_of_pos hp.2
+    have hdx : d ≤ canonicalStoppedAngleSq κ ((v : ℝ), z, p) := by
+      apply ((Real.rpow_le_rpow_iff_of_neg hx hd hb)).mp
+      rw [hdM]
+      exact le_of_lt (lt_of_not_ge hAp)
+    exact (Real.sqrt_le_iff).mpr ⟨hp.2.le, by simpa only [canonicalStoppedAngleSq] using hdx⟩
+  have htotal : 1 ≤ Q A + Q E := by
+    calc
+      1 = Q Set.univ := (measure_univ : Q Set.univ = 1).symm
+      _ ≤ Q (A ∪ E) := measure_mono_ae (hcover.mono fun _ hp _ => hp)
+      _ ≤ Q A + Q E := measure_union_le _ _
+  have htotalR := ENNReal.toReal_mono (by finiteness) htotal
+  have hAR := ENNReal.toReal_mono (by finiteness) hA
+  rw [ENNReal.toReal_one, ENNReal.toReal_add (by finiteness) (by finiteness)] at htotalR
+  norm_num only [ENNReal.toReal_ofReal, show (0 : ℝ) ≤ 1 / 2 by norm_num, max_eq_left] at hAR
+  apply (ENNReal.toReal_le_toReal (by finiteness) (by finiteness)).mp
+  norm_num only [ENNReal.toReal_ofReal, show (0 : ℝ) ≤ 1 / 2 by norm_num, max_eq_left]
+  linarith
+
+end SLEExactGauge
+
+end
+
+end OAI
diff --git a/lean/OAI/Probability/SLE/Loewner/CanonicalInverseHolomorphic.lean b/lean/OAI/Probability/SLE/Loewner/CanonicalInverseHolomorphic.lean
new file mode 100644
index 0000000000000000000000000000000000000000..a33243fbfa85185a3cb09f745f0612400790b3f4
--- /dev/null
+++ b/lean/OAI/Probability/SLE/Loewner/CanonicalInverseHolomorphic.lean
@@ -0,0 +1,118 @@
+import OAI.Probability.SLE.Geometry.CanonicalBoundaryLimit
+
+namespace OAI
+
+/-! Holomorphicity of the raw inverse under the canonical Wiener law.
+Clipping the endpoint inside the half-plane makes differentiability a Borel
+condition on a continuous function space. -/
+noncomputable section
+open Set Filter _root_.MeasureTheory _root_.OAI.MeasureTheory ProbabilityTheory
+open scoped Topology NNReal ENNReal
+
+namespace SLEExactGauge
+
+local instance inverseHolomorphicMapMeasurable : MeasurableSpace C(ℂ,ℂ) := borel _
+local instance inverseHolomorphicMapBorel : BorelSpace C(ℂ,ℂ) := ⟨rfl⟩
+local instance inverseHolomorphicDriverPolish : PolishSpace Target.Driver :=
+  ContinuousMapZero.isClosedEmbedding_toContinuousMap.polishSpace
+local instance inverseHolomorphicDriverMetric : MetricSpace Target.Driver :=
+  TopologicalSpace.metrizableSpaceMetric Target.Driver
+
+def upperClip (η : ℝ) (z : ℂ) : ℂ := ⟨z.re,max η z.im⟩
+
+lemma continuous_upperClip (η : ℝ) : Continuous (upperClip η) := by
+  convert (Complex.continuous_ofReal.comp Complex.continuous_re).add
+    ((Complex.continuous_ofReal.comp ((continuous_const (y := η)).max Complex.continuous_im)).mul
+      (continuous_const (y := Complex.I))) using 1
+  funext z
+  apply Complex.ext <;> simp [upperClip]
+
+lemma upperClip_eq {η : ℝ} {z : ℂ} (h : η ≤ z.im) : upperClip η z=z := by
+  apply Complex.ext
+  · rfl
+  · exact max_eq_right h
+
+def clippedRawInverse (κ : ℝ) (hκ : 0 < κ) (j : ℕ)
+    (q : ℝ≥0 × Target.Driver) : C(ℂ,ℂ) :=
+  ⟨fun z => Target.inverseFlow κ q.2 (κ.toNNReal*q.1) (upperClip (1/((j:ℝ)+1)) z),
+    (Target.continuousOn_inverseFlow κ hκ q.2 (κ.toNNReal*q.1)).comp_continuous
+      (continuous_upperClip _) (fun z => (show 0 < (1:ℝ)/((j:ℝ)+1) by positivity).trans_le
+        (le_max_left _ _))⟩
+
+lemma measurable_clippedRawInverse (κ : ℝ) (hκ : 0 < κ) (j : ℕ) :
+    Measurable (clippedRawInverse κ hκ j) := by
+  apply ContinuousMap.measurable_iff_eval.mpr
+  intro z
+  exact @Measurable.comp (ℝ≥0 × Target.Driver) (ℝ≥0 × (Target.Driver × ℂ)) ℂ
+    inferInstance inferInstance inferInstance
+    (fun q => Target.inverseFlow κ q.2.1 q.1 q.2.2)
+    (fun q => (κ.toNNReal*q.1,(q.2,upperClip (1/((j:ℝ)+1)) z)))
+    (Target.measurable_inverseFlow κ)
+    ((measurable_const.mul measurable_fst).prodMk (measurable_snd.prodMk measurable_const))
+
+lemma clippedRawInverse_eventuallyEq (κ : ℝ) (hκ : 0 < κ) (j : ℕ)
+    (q : ℝ≥0 × Target.Driver) (z : ℂ) (hz : 1/((j:ℝ)+1) < z.im) :
+    (clippedRawInverse κ hκ j q : ℂ → ℂ) =ᶠ[𝓝 z]
+      Target.inverseFlow κ q.2 (κ.toNNReal*q.1) := by
+  have hn : {w : ℂ | 1/((j:ℝ)+1) < w.im} ∈ 𝓝 z :=
+    (isOpen_lt continuous_const Complex.continuous_im).mem_nhds hz
+  filter_upwards [hn] with w hw
+  change Target.inverseFlow κ q.2 (κ.toNNReal*q.1) (upperClip _ w)=_
+  rw [upperClip_eq hw.le]
+
+lemma ae_canonical_inverse_holomorphic
+    {Ω : Type*} [MeasurableSpace Ω] {P : Measure Ω}
+    (κ : ℝ) (hκ : 0 < κ) (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) :
+    ∀ᵐ b ∂W, ∀ T : ℝ≥0,
+      DifferentiableOn ℂ (Target.inverseFlow κ b (κ*T)) upperHalfPlane := by
+  have : IsProbabilityMeasure W := hW.isGaussianProcess.isProbabilityMeasure
+  have hDiff : MeasurableSet {q : C(ℂ,ℂ) × ℂ | DifferentiableAt ℂ q.1 q.2} :=
+    measurableSet_of_differentiableAt_with_param ℂ continuous_eval
+  have hfixed (j : ℕ) : MeasurableSet {q : ((ℝ≥0 × ℂ) × Target.Driver) |
+      1/((j:ℝ)+1) < q.1.2.im →
+        DifferentiableAt ℂ (clippedRawInverse κ hκ j (q.1.1,q.2)) q.1.2} := by
+    have hlt : MeasurableSet {q : ((ℝ≥0 × ℂ) × Target.Driver) |
+        1/((j:ℝ)+1) < q.1.2.im} :=
+      measurableSet_lt measurable_const measurable_fst.snd.im
+    have hd := hDiff.preimage
+      (((measurable_clippedRawInverse κ hκ j).comp
+        (measurable_fst.fst.prodMk measurable_snd)).prodMk measurable_fst.snd)
+    convert hlt.compl.union hd using 1
+    ext q
+    simp only [mem_union,mem_compl_iff,mem_ofPred_eq,mem_preimage,Function.comp_apply,
+      imp_iff_not_or]
+  have hsource (j : ℕ) : ∀ᵐ ω ∂P, ∀ r : ℝ≥0 × ℂ,
+      1/((j:ℝ)+1) < r.2.im → DifferentiableAt ℂ
+        (clippedRawInverse κ hκ j (r.1,Target.normalizedDriver κ B hc h0 ω)) r.2 := by
+    apply ae_of_all
+    rintro ω ⟨T,z⟩ hz
+    have hzH : z ∈ upperHalfPlane := (show 0 < (1:ℝ)/((j:ℝ)+1) by positivity).trans hz
+    have hF : DifferentiableAt ℂ (F ω T) z :=
+      ((hw ω).2.2.2.2.1 T z hzH).differentiableAt (isOpen_upperHalfPlane.mem_nhds hzH)
+    apply hF.congr_of_eventuallyEq
+    filter_upwards [clippedRawInverse_eventuallyEq κ hκ j
+      (T,Target.normalizedDriver κ B hc h0 ω) z hz,
+      isOpen_upperHalfPlane.mem_nhds hzH] with w he hwH
+    rw [he,Real.coe_toNNReal _ hκ.le]
+    exact Target.inverseFlow_eq_witness κ hκ _ _ _ _ _ (hw ω)
+      (Target.normalizedDriver_matches κ hκ B hc h0 ω) T w hwH
+  have hLaw := Target.normalizedDriver_law κ hκ B hB hm hc h0 W hW
+  have hall (j : ℕ) := ae_forall_parameter_of_hasLaw hLaw
+    (fun (r : ℝ≥0 × ℂ) (b : Target.Driver) => 1/((j:ℝ)+1) < r.2.im →
+      DifferentiableAt ℂ (clippedRawInverse κ hκ j (r.1,b)) r.2) (hfixed j) (hsource j)
+  filter_upwards [ae_all_iff.mpr hall] with b hb T z hz
+  obtain ⟨j,hj⟩ := ((tendsto_one_div_add_atTop_nhds_zero_nat (𝕜 := ℝ)).eventually
+    (gt_mem_nhds (show 0 < z.im from hz))).exists
+  have h := (hb j (T,z) hj).congr_of_eventuallyEq
+    (clippedRawInverse_eventuallyEq κ hκ j (T,b) z hj).symm
+  simpa only [NNReal.coe_mul,Real.coe_toNNReal _ hκ.le] using h.differentiableWithinAt
+
+end SLEExactGauge
+
+end
+
+end OAI
diff --git a/lean/OAI/Probability/SLE/Loewner/CanonicalInverseNonzero.lean b/lean/OAI/Probability/SLE/Loewner/CanonicalInverseNonzero.lean
new file mode 100644
index 0000000000000000000000000000000000000000..128d7739cea5a1514c1fd39094af293598092ad0
--- /dev/null
+++ b/lean/OAI/Probability/SLE/Loewner/CanonicalInverseNonzero.lean
@@ -0,0 +1,88 @@
+import OAI.Probability.SLE.Loewner.CanonicalInverseHolomorphic
+import OAI.Probability.SLE.Geometry.NormalizedMarkedState
+
+namespace OAI
+
+/-! Nonvanishing derivative of the canonical inverse, transferred through
+the same measurable clipped functions used for holomorphicity. -/
+noncomputable section
+open Set Filter _root_.MeasureTheory _root_.OAI.MeasureTheory ProbabilityTheory
+open scoped Topology NNReal ENNReal
+
+namespace SLEExactGauge
+
+local instance inverseNonzeroMapMeasurable : MeasurableSpace C(ℂ,ℂ) := borel _
+local instance inverseNonzeroMapBorel : BorelSpace C(ℂ,ℂ) := ⟨rfl⟩
+local instance inverseNonzeroDriverPolish : PolishSpace Target.Driver :=
+  ContinuousMapZero.isClosedEmbedding_toContinuousMap.polishSpace
+local instance inverseNonzeroDriverMetric : MetricSpace Target.Driver :=
+  TopologicalSpace.metrizableSpaceMetric Target.Driver
+
+lemma IsCapacityTwoWitness.inverse_deriv_ne_zero
+    {U : ℝ≥0 → ℝ} {γ : ℝ≥0 → ℂ} {G F : ℝ≥0 → ℂ → ℂ}
+    (hw : IsCapacityTwoWitness U γ G F) (T : ℝ≥0) (w : ℂ) (hwH : w ∈ upperHalfPlane) :
+    deriv (F T) w ≠ 0 := by
+  have h := hw.inverse_derivative_identity T (F T w) (hw.2.2.2.2.2.2.1 T hwH)
+  rw [hw.2.2.2.2.2.2.2.2.1 T w hwH] at h
+  intro hn
+  rw [hn,zero_mul] at h
+  exact zero_ne_one h
+
+lemma ae_canonical_inverse_deriv_ne_zero
+    {Ω : Type*} [MeasurableSpace Ω] {P : Measure Ω}
+    (κ : ℝ) (hκ : 0 < κ) (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) :
+    ∀ᵐ b ∂W, ∀ (T : ℝ≥0) (z : ℂ), z ∈ upperHalfPlane →
+      deriv (Target.inverseFlow κ b (κ*T)) z ≠ 0 := by
+  have : IsProbabilityMeasure W := hW.isGaussianProcess.isProbabilityMeasure
+  have hDeriv : Measurable (fun q : C(ℂ,ℂ) × ℂ => deriv (q.1 : ℂ → ℂ) q.2) :=
+    measurable_deriv_with_param continuous_eval
+  have hfixed (j : ℕ) : MeasurableSet {q : (ℝ≥0 × ℂ) × Target.Driver |
+      1/((j:ℝ)+1) < q.1.2.im →
+        deriv (clippedRawInverse κ hκ j (q.1.1,q.2) : ℂ → ℂ) q.1.2 ≠ 0} := by
+    have hlt : MeasurableSet {q : (ℝ≥0 × ℂ) × Target.Driver |
+        1/((j:ℝ)+1) < q.1.2.im} := measurableSet_lt measurable_const measurable_fst.snd.im
+    have hmD : Measurable (fun q : (ℝ≥0 × ℂ) × Target.Driver =>
+        deriv (clippedRawInverse κ hκ j (q.1.1,q.2) : ℂ → ℂ) q.1.2) :=
+      hDeriv.comp (((measurable_clippedRawInverse κ hκ j).comp
+        (measurable_fst.fst.prodMk measurable_snd)).prodMk measurable_fst.snd)
+    convert hlt.compl.union (measurableSet_eq_fun hmD
+      (measurable_const : Measurable (fun _ : (ℝ≥0 × ℂ) × Target.Driver => (0 : ℂ)))).compl using 1
+    ext q
+    simp only [mem_union,mem_compl_iff,mem_ofPred_eq,imp_iff_not_or]
+  have hsource (j : ℕ) : ∀ᵐ ω ∂P, ∀ r : ℝ≥0 × ℂ,
+      1/((j:ℝ)+1) < r.2.im → deriv
+        (clippedRawInverse κ hκ j (r.1,Target.normalizedDriver κ B hc h0 ω) : ℂ → ℂ) r.2 ≠ 0 := by
+    apply ae_of_all
+    rintro ω ⟨T,z⟩ hz
+    have hzH : z ∈ upperHalfPlane := (show 0 < (1:ℝ)/((j:ℝ)+1) by positivity).trans hz
+    have he : (clippedRawInverse κ hκ j (T,Target.normalizedDriver κ B hc h0 ω) : ℂ → ℂ)
+        =ᶠ[𝓝 z] F ω T := by
+      filter_upwards [clippedRawInverse_eventuallyEq κ hκ j
+        (T,Target.normalizedDriver κ B hc h0 ω) z hz,
+        isOpen_upperHalfPlane.mem_nhds hzH] with w he hwH
+      rw [he,Real.coe_toNNReal _ hκ.le]
+      exact Target.inverseFlow_eq_witness κ hκ _ _ _ _ _ (hw ω)
+        (Target.normalizedDriver_matches κ hκ B hc h0 ω) T w hwH
+    rw [he.deriv_eq]
+    exact (hw ω).inverse_deriv_ne_zero T z hzH
+  have hLaw := Target.normalizedDriver_law κ hκ B hB hm hc h0 W hW
+  have hall (j : ℕ) := ae_forall_parameter_of_hasLaw hLaw
+    (fun (r : ℝ≥0 × ℂ) (b : Target.Driver) => 1/((j:ℝ)+1) < r.2.im →
+      deriv (clippedRawInverse κ hκ j (r.1,b) : ℂ → ℂ) r.2 ≠ 0) (hfixed j) (hsource j)
+  filter_upwards [ae_all_iff.mpr hall] with b hb T z hz
+  obtain ⟨j,hj⟩ := ((tendsto_one_div_add_atTop_nhds_zero_nat (𝕜 := ℝ)).eventually
+    (gt_mem_nhds (show 0 < z.im from hz))).exists
+  have he := (clippedRawInverse_eventuallyEq κ hκ j (T,b) z hj).deriv_eq
+  have h := hb j (T,z) hj
+  rw [he] at h
+  simpa only [NNReal.coe_mul,Real.coe_toNNReal _ hκ.le] using h
+
+end SLEExactGauge
+
+end
+
+end OAI
diff --git a/lean/OAI/Probability/SLE/Loewner/CanonicalRadiusKernel.lean b/lean/OAI/Probability/SLE/Loewner/CanonicalRadiusKernel.lean
new file mode 100644
index 0000000000000000000000000000000000000000..d9592c6f97b7f8e4d93381b81d806406271ddfef
--- /dev/null
+++ b/lean/OAI/Probability/SLE/Loewner/CanonicalRadiusKernel.lean
@@ -0,0 +1,195 @@
+import OAI.Probability.SLE.Geometry.JointRadiusKernel
+import OAI.Probability.SLE.Geometry.CanonicalRestartWitness
+
+namespace OAI
+
+/-! The radius kernels on continuous driver space. The measurable functions
+are fixed independently of any probability law or marked point. -/
+
+noncomputable section
+open Set Filter MeasureTheory ProbabilityTheory TopologicalSpace Classical
+open scoped Topology NNReal ENNReal
+
+namespace SLEExactGauge
+
+local instance radiusDriverMeasurable : MeasurableSpace C(ℝ≥0, ℝ) := borel _
+local instance radiusDriverBorel : BorelSpace C(ℝ≥0, ℝ) := ⟨rfl⟩
+
+def canonicalRadiusFamily (κ : ℝ) :
+    SpatialClippedFamily (fun (t : ℝ≥0) (p : C(ℝ≥0, ℝ)) => Real.sqrt κ * p t) :=
+  spatialClippedFamily _
+    (((continuous_eval.comp (continuous_snd.prodMk continuous_fst)).measurable).const_mul _)
+    (fun p => p.continuous.const_mul _)
+
+def canonicalRadius (κ : ℝ) : ℝ≥0 × (ℂ × C(ℝ≥0, ℝ)) → ℝ :=
+  (canonicalRadiusFamily κ).jointRadius
+
+def canonicalRadiusLevel (κ : ℝ) : ℝ × (ℂ × C(ℝ≥0, ℝ)) → ℝ≥0∞ :=
+  (canonicalRadiusFamily κ).jointRadiusLevel
+
+lemma canonicalRadius_measurable (κ : ℝ) : Measurable (canonicalRadius κ) :=
+  (canonicalRadiusFamily κ).jointRadius_measurable
+
+lemma canonicalRadiusLevel_measurable (κ : ℝ) : Measurable (canonicalRadiusLevel κ) :=
+  (canonicalRadiusFamily κ).jointRadiusLevel_measurable
+
+lemma canonicalRadius_eq (κ : ℝ) (p : C(ℝ≥0, ℝ))
+    {γ : ℝ≥0 → ℂ} {G F : ℝ≥0 → ℂ → ℂ}
+    (hw : IsCapacityTwoWitness (fun t => Real.sqrt κ * p t) γ G F)
+    (t : ℝ≥0) (z : ℂ) :
+    canonicalRadius κ (t, z, p) =
+      if z ∈ survivingDomain γ t then fullRadius G t z else 0 :=
+  (canonicalRadiusFamily κ).jointRadius_eq p (p.continuous.const_mul _) hw t z
+
+lemma canonicalRadiusLevel_eq (κ : ℝ) (p : C(ℝ≥0, ℝ))
+    {γ : ℝ≥0 → ℂ} {G F : ℝ≥0 → ℂ → ℂ}
+    (hw : IsCapacityTwoWitness (fun t => Real.sqrt κ * p t) γ G F)
+    (u : ℝ) (hu : 0 ≤ u) (z : ℂ) :
+    canonicalRadiusLevel κ (u, z, p) = radiusLevelTime γ G z u :=
+  (canonicalRadiusFamily κ).jointRadiusLevel_eq p (p.continuous.const_mul _) hw u hu z
+
+lemma measurable_canonicalRadiusLevel_random_state
+    {Ω : Type*} [MeasurableSpace Ω] (κ : ℝ)
+    {Y : Ω → C(ℝ≥0, ℝ)} (hY : Measurable Y)
+    {u : Ω → ℝ} (hu : Measurable u) {z : Ω → ℂ} (hz : Measurable z) :
+    Measurable (fun ω => canonicalRadiusLevel κ (u ω, z ω, Y ω)) :=
+  (canonicalRadiusLevel_measurable κ).comp (hu.prodMk (hz.prodMk hY))
+
+/-- A random measurable marked state has an actual radius-level time with a
+measurable version, with no point-dependent selection of an exceptional set. -/
+theorem aemeasurable_radiusLevelTime_random_state
+    {Ω : Type*} [MeasurableSpace Ω] {P : Measure Ω} (κ : ℝ)
+    {Y : Ω → C(ℝ≥0, ℝ)} (hY : Measurable Y)
+    (γ : Ω → ℝ≥0 → ℂ) (G F : Ω → ℝ≥0 → ℂ → ℂ)
+    (hw : ∀ᵐ ω ∂P, IsCapacityTwoWitness
+      (fun t => Real.sqrt κ * Y ω t) (γ ω) (G ω) (F ω))
+    {u : Ω → ℝ} (hum : Measurable u) (hu : ∀ᵐ ω ∂P, 0 ≤ u ω)
+    {z : Ω → ℂ} (hz : Measurable z) :
+    AEMeasurable (fun ω => radiusLevelTime (γ ω) (G ω) (z ω) (u ω)) P := by
+  apply (measurable_canonicalRadiusLevel_random_state κ hY hum hz).aemeasurable.congr
+  filter_upwards [hw, hu] with ω hω huω
+  exact canonicalRadiusLevel_eq κ (Y ω) hω (u ω) huω (z ω)
+
+/-- The same fixed kernel applies to any random driver with the canonical
+driver law, including the actual post-stopping driver. -/
+theorem canonicalRadiusLevel_same_law_witness
+    {Ω : Type*} [MeasurableSpace Ω] {P : Measure Ω}
+    (ν : 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))
+    (Y : Ω → C(ℝ≥0, ℝ)) (hY : Measurable Y) (hlaw : P.map Y = ν) :
+    ∀ᵐ ω ∂P, ∀ u, 0 ≤ u → ∀ z,
+      canonicalRadiusLevel κ (u, z, Y ω) =
+        radiusLevelTime (Φ (Y ω)) (Gc (Y ω)) z u := by
+  have hW := canonical_witness_pullback hw Y hY hlaw
+  filter_upwards [hW] with ω hω
+  exact fun u hu z => canonicalRadiusLevel_eq κ (Y ω) hω u hu z
+
+def canonicalGreen (κ : ℝ) : ℝ≥0 × (ℂ × C(ℝ≥0, ℝ)) → ℝ :=
+  (canonicalRadiusFamily κ).jointGreen κ (fun t p => p t)
+
+lemma canonicalGreen_measurable (κ : ℝ) : Measurable (canonicalGreen κ) :=
+  (canonicalRadiusFamily κ).jointGreen_measurable κ (fun t p => p t)
+    (continuous_eval.comp (continuous_snd.prodMk continuous_fst)).measurable
+
+lemma canonicalGreen_eq (κ : ℝ) (p : C(ℝ≥0, ℝ))
+    {γ : ℝ≥0 → ℂ} {G F : ℝ≥0 → ℂ → ℂ}
+    (hw : IsCapacityTwoWitness (fun t => Real.sqrt κ * p t) γ G F)
+    (t : ℝ≥0) (z : ℂ) :
+    canonicalGreen κ (t, z, p) =
+      greenDensity κ (fun t => Real.sqrt κ * p t) γ G t z :=
+  (canonicalRadiusFamily κ).jointGreen_eq κ (fun t p => p t) p
+    (p.continuous.const_mul _) (fun _ => rfl) hw t z
+
+def canonicalStoppedGreen (κ : ℝ) (p : ℝ × (ℂ × C(ℝ≥0, ℝ))) : ℝ :=
+  if canonicalRadiusLevel κ p < ∞ then
+    canonicalGreen κ ((canonicalRadiusLevel κ p).toNNReal, p.2)
+  else 0
+
+lemma canonicalStoppedGreen_measurable (κ : ℝ) : Measurable (canonicalStoppedGreen κ) := by
+  apply Measurable.ite (measurableSet_lt (canonicalRadiusLevel_measurable κ) measurable_const)
+    _ measurable_const
+  exact (canonicalGreen_measurable κ).comp
+    ((ENNReal.measurable_toNNReal.comp (canonicalRadiusLevel_measurable κ)).prodMk measurable_snd)
+
+lemma canonicalStoppedGreen_eq (κ : ℝ) (p : C(ℝ≥0, ℝ))
+    {γ : ℝ≥0 → ℂ} {G F : ℝ≥0 → ℂ → ℂ}
+    (hw : IsCapacityTwoWitness (fun t => Real.sqrt κ * p t) γ G F)
+    (u : ℝ) (hu : 0 ≤ u) (z : ℂ) :
+    canonicalStoppedGreen κ (u, z, p) =
+      stoppedGreen κ (fun t => Real.sqrt κ * p t) γ G z u := by
+  unfold canonicalStoppedGreen
+  rw [canonicalRadiusLevel_eq κ p hw u hu z]
+  unfold stoppedGreen
+  split_ifs
+  · exact canonicalGreen_eq κ p hw _ z
+  · rfl
+
+def canonicalFiniteDensity (κ : ℝ) (p : ℝ × (ℂ × C(ℝ≥0, ℝ))) : ℝ≥0∞ :=
+  ENNReal.ofReal (canonicalStoppedGreen κ p / initialGreen κ p.2.1)
+
+lemma canonicalFiniteDensity_measurable (κ : ℝ) : Measurable (canonicalFiniteDensity κ) := by
+  have hinit : Measurable (initialGreen κ) := by
+    unfold initialGreen
+    fun_prop
+  exact ENNReal.measurable_ofReal.comp
+    ((canonicalStoppedGreen_measurable κ).div
+      (hinit.comp (measurable_fst.comp measurable_snd)))
+
+lemma canonicalFiniteDensity_eq (κ : ℝ) (p : C(ℝ≥0, ℝ))
+    {γ : ℝ≥0 → ℂ} {G F : ℝ≥0 → ℂ → ℂ}
+    (hw : IsCapacityTwoWitness (fun t => Real.sqrt κ * p t) γ G F)
+    (u : ℝ) (hu : 0 ≤ u) (z : ℂ) :
+    canonicalFiniteDensity κ (u, z, p) = ENNReal.ofReal
+      (stoppedGreen κ (fun t => Real.sqrt κ * p t) γ G z u / initialGreen κ z) := by
+  simp only [canonicalFiniteDensity, canonicalStoppedGreen_eq κ p hw u hu z]
+
+/-- The tilted-density kernel is jointly measurable in level, marked point,
+and driver, and represents the actual density on one common full-measure set. -/
+theorem canonical_density_same_law_witness
+    {Ω : Type*} [MeasurableSpace Ω] {P : Measure Ω}
+    (ν : 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))
+    (Y : Ω → C(ℝ≥0, ℝ)) (hY : Measurable Y) (hlaw : P.map Y = ν) :
+    ∀ᵐ ω ∂P, ∀ u, 0 ≤ u → ∀ z,
+      canonicalStoppedGreen κ (u, z, Y ω) =
+        stoppedGreen κ (fun t => Real.sqrt κ * Y ω t) (Φ (Y ω)) (Gc (Y ω)) z u ∧
+      canonicalFiniteDensity κ (u, z, Y ω) = ENNReal.ofReal
+        (stoppedGreen κ (fun t => Real.sqrt κ * Y ω t)
+          (Φ (Y ω)) (Gc (Y ω)) z u / initialGreen κ z) := by
+  have hW := canonical_witness_pullback hw Y hY hlaw
+  filter_upwards [hW] with ω hω
+  exact fun u hu z => ⟨canonicalStoppedGreen_eq κ (Y ω) hω u hu z,
+    canonicalFiniteDensity_eq κ (Y ω) hω u hu z⟩
+
+lemma measurable_canonicalFiniteDensity_random_state
+    {Ω : Type*} [MeasurableSpace Ω] (κ : ℝ)
+    {Y : Ω → C(ℝ≥0, ℝ)} (hY : Measurable Y)
+    {u : Ω → ℝ} (hu : Measurable u) {z : Ω → ℂ} (hz : Measurable z) :
+    Measurable (fun ω => canonicalFiniteDensity κ (u ω, z ω, Y ω)) :=
+  (canonicalFiniteDensity_measurable κ).comp (hu.prodMk (hz.prodMk hY))
+
+theorem canonical_finiteCenteredLaw_eq
+    (ν : 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))
+    (u : ℝ) (hu : 0 ≤ u) (z : ℂ) :
+    finiteCenteredLaw ν κ (fun t p => p t) (fun p t => Φ p t) Gc z u =
+      ν.withDensity (fun p => canonicalFiniteDensity κ (u, z, p)) := by
+  unfold finiteCenteredLaw
+  apply withDensity_congr_ae
+  filter_upwards [hw] with p hp
+  exact (canonicalFiniteDensity_eq κ p hp u hu z).symm
+
+end SLEExactGauge
+
+end
+
+end OAI
diff --git a/lean/OAI/Probability/SLE/Loewner/CanonicalSurvival.lean b/lean/OAI/Probability/SLE/Loewner/CanonicalSurvival.lean
new file mode 100644
index 0000000000000000000000000000000000000000..279bc3354688510439b6cfe49b01aed9a6e0c01a
--- /dev/null
+++ b/lean/OAI/Probability/SLE/Loewner/CanonicalSurvival.lean
@@ -0,0 +1,75 @@
+import OAI.Probability.SLE.Geometry.CanonicalBoundaryLimit
+
+namespace OAI
+
+/-! The measurable canonical trace has exactly the raw surviving domain,
+simultaneously for every time and point. -/
+noncomputable section
+open Set Filter _root_.MeasureTheory _root_.OAI.MeasureTheory ProbabilityTheory
+open scoped Topology NNReal ENNReal
+
+namespace SLEExactGauge
+
+local instance survivalComplexMeasurable : MeasurableSpace C(ℝ≥0,ℂ) := borel _
+local instance survivalComplexBorel : BorelSpace C(ℝ≥0,ℂ) := ⟨rfl⟩
+local instance survivalDriverPolish : PolishSpace Target.Driver :=
+  ContinuousMapZero.isClosedEmbedding_toContinuousMap.polishSpace
+local instance survivalDriverMetric : MetricSpace Target.Driver :=
+  TopologicalSpace.metrizableSpaceMetric Target.Driver
+
+lemma ae_canonical_survival
+    {Ω : Type*} [MeasurableSpace Ω] {P : Measure Ω}
+    (κ : ℝ) (hκ : 0 < κ) (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,ℂ)) (hΨ : Measurable Ψ)
+    (hΨeq : ∀ ω, Ψ (Target.normalizedDriver κ B hc h0 ω)=sourceTracePath γ (fun ω => (hw ω).1) ω) :
+    ∀ᵐ b ∂W, ∀ (T : ℝ≥0) (z : ℂ),
+      Target.Surviving κ b z (κ*T) ↔ z ∈ survivingDomain (Ψ b) T := by
+  have : IsProbabilityMeasure W := hW.isGaussianProcess.isProbabilityMeasure
+  let p (r : ℝ≥0 × ℂ) (b : Target.Driver) :=
+    Target.Surviving κ b r.2 (κ.toNNReal*r.1) ↔ r.2 ∈ survivingDomain (Ψ b) r.1
+  have hA : MeasurableSet {q : (ℝ≥0 × ℂ) × Target.Driver |
+      Target.Surviving κ q.2 q.1.2 (κ.toNNReal*q.1.1)} := by
+    have hmA : Measurable (fun q : (ℝ≥0 × ℂ) × Target.Driver =>
+        (κ.toNNReal*q.1.1,(q.2,q.1.2))) :=
+      (measurable_const.mul measurable_fst.fst).prodMk
+        (measurable_snd.prodMk measurable_fst.snd)
+    exact MeasurableSet.preimage
+      (f := fun q : (ℝ≥0 × ℂ) × Target.Driver => (κ.toNNReal*q.1.1,(q.2,q.1.2)))
+      (Target.measurableSet_surviving κ) hmA
+  have hD : MeasurableSet {q : (ℝ≥0 × ℂ) × Target.Driver |
+      q.1.2 ∈ survivingDomain (Ψ q.2) q.1.1} := by
+    have hmD : Measurable (fun q : (ℝ≥0 × ℂ) × Target.Driver => ((Ψ q.2,q.1.1),q.1.2)) :=
+      (((hΨ.comp measurable_snd).prodMk measurable_fst.fst).prodMk measurable_fst.snd)
+    exact MeasurableSet.preimage
+      (f := fun q : (ℝ≥0 × ℂ) × Target.Driver => ((Ψ q.2,q.1.1),q.1.2))
+      source_survival_open.measurableSet hmD
+  have hp : MeasurableSet {q : (ℝ≥0 × ℂ) × Target.Driver | p q.1 q.2} := by
+    convert (hA.inter hD).union (hA.compl.inter hD.compl) using 1
+    ext q
+    simp only [p,mem_union,mem_inter_iff,mem_compl_iff,mem_ofPred_eq]
+    tauto
+  have hLaw := Target.normalizedDriver_law κ hκ B hB hm hc h0 W hW
+  have hsource : ∀ᵐ ω ∂P, ∀ r, p r (Target.normalizedDriver κ B hc h0 ω) := by
+    apply ae_of_all
+    rintro ω ⟨T,z⟩
+    have he : (Ψ (Target.normalizedDriver κ B hc h0 ω) : ℝ≥0 → ℂ)=γ ω := by
+      funext t
+      have h := congrArg (fun e : C(ℝ≥0,ℂ) => e t) (hΨeq ω)
+      simpa only [sourceTracePath,ContinuousMap.coe_mk] using h
+    change Target.Surviving κ _ z (κ.toNNReal*T) ↔ z ∈ survivingDomain _ T
+    rw [Real.coe_toNNReal _ hκ.le,he]
+    exact Target.surviving_iff_witness κ hκ _ _ _ _ _ (hw ω)
+      (Target.normalizedDriver_matches κ hκ B hc h0 ω) T z
+  have hall := ae_forall_parameter_of_hasLaw hLaw p hp hsource
+  filter_upwards [hall] with b hb T z
+  simpa only [p,NNReal.coe_mul,Real.coe_toNNReal _ hκ.le] using hb (T,z)
+
+end SLEExactGauge
+
+end
+
+end OAI
diff --git a/lean/OAI/Probability/SLE/Loewner/CanonicalTraceCandidate.lean b/lean/OAI/Probability/SLE/Loewner/CanonicalTraceCandidate.lean
new file mode 100644
index 0000000000000000000000000000000000000000..2ed0e38d2703f028c03b9280f213cc22f3c5ec73
--- /dev/null
+++ b/lean/OAI/Probability/SLE/Loewner/CanonicalTraceCandidate.lean
@@ -0,0 +1,85 @@
+import OAI.Probability.SLE.Loewner.TargetTraceCandidate
+import OAI.Probability.SLE.Angle.TargetBrownianNormalization
+
+namespace OAI
+
+/-! The raw inverse-flow trace candidate has a measurable continuous-path
+modification under the actual Wiener law. No trace-generation input is used. -/
+noncomputable section
+open Set Filter _root_.MeasureTheory _root_.OAI.MeasureTheory ProbabilityTheory
+open scoped Topology NNReal ENNReal
+
+namespace SLEExactGauge
+
+local instance candidateRealMeasurable : MeasurableSpace C(ℝ≥0,ℝ) := borel _
+local instance candidateRealBorel : BorelSpace C(ℝ≥0,ℝ) := ⟨rfl⟩
+local instance candidateComplexMeasurable : MeasurableSpace C(ℝ≥0,ℂ) := borel _
+local instance candidateComplexBorel : BorelSpace C(ℝ≥0,ℂ) := ⟨rfl⟩
+
+def unnormalizeDriver (κ : ℝ) (b : Target.Driver) : C(ℝ≥0,ℝ) :=
+  ⟨fun t => b (κ.toNNReal*t)/Real.sqrt κ, by fun_prop⟩
+
+lemma measurable_unnormalizeDriver (κ : ℝ) : Measurable (unnormalizeDriver κ) := by
+  apply source_path_measurable
+  intro t
+  exact (continuous_eval_const _).measurable.div_const _
+
+lemma unnormalize_normalizedDriver {Ω : Type*}
+    (κ : ℝ) (hκ : 0 < κ) (B : ℝ≥0 → Ω → ℝ)
+    (hc : ∀ ω, Continuous (fun t => B t ω)) (h0 : ∀ ω, B 0 ω=0) (ω : Ω) :
+    unnormalizeDriver κ (Target.normalizedDriver κ B hc h0 ω)=sourceDriverPath B hc ω := by
+  ext t
+  change (Real.sqrt κ*B ((κ.toNNReal*t)/κ.toNNReal) ω)/Real.sqrt κ=B t ω
+  rw [mul_div_cancel_left₀ _ (Real.toNNReal_pos.mpr hκ).ne',
+    mul_div_cancel_left₀ _ (Real.sqrt_pos.mpr hκ).ne']
+
+theorem exists_canonical_trace_candidate_modification
+    {Ω : 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) ω) ∧
+      ∀ T : ℝ≥0, ∀ᵐ b ∂W,
+        Tendsto (fun n => Target.rawTipApprox κ n T b) atTop (𝓝 (Ψ b T)) ∧
+        Target.traceCandidate κ T b=Ψ b T := by
+  have : IsProbabilityMeasure P := hB.isGaussianProcess.isProbabilityMeasure
+  obtain ⟨Φ,hΦ,hΦeq,_⟩ := sourceStoppedTraceLaw κ hκ hκ8 B hB hm hc γ G F hw
+  let Ψ : Target.Driver → C(ℝ≥0,ℂ) := Φ ∘ unnormalizeDriver κ
+  have hΨ : Measurable Ψ := hΦ.comp (measurable_unnormalizeDriver κ)
+  have hΨeq (ω : Ω) : Ψ (Target.normalizedDriver κ B hc h0 ω)=
+      sourceTracePath γ (fun ω => (hw ω).1) ω := by
+    change Φ (unnormalizeDriver κ (Target.normalizedDriver κ B hc h0 ω)) =
+      sourceTracePath γ (fun ω => (hw ω).1) ω
+    rw [unnormalize_normalizedDriver κ hκ B hc h0]
+    exact hΦeq ω
+  refine ⟨Ψ,hΨ,hΨeq,?_⟩
+  intro T
+  have hset : MeasurableSet {b : Target.Driver |
+      Tendsto (fun n => Target.rawTipApprox κ n T b-Ψ b T) atTop (𝓝 (0:ℂ))} :=
+    measurableSet_tendsto _ (fun n =>
+      ((Target.measurable_rawTipApprox κ n).comp (measurable_const.prodMk measurable_id)).sub
+        ((continuous_eval_const T).measurable.comp hΨ))
+  have hLaw := Target.normalizedDriver_law κ hκ B hB hm hc h0 W hW
+  have hae : ∀ᵐ b ∂W, Tendsto (fun n => Target.rawTipApprox κ n T b-Ψ b T) atTop (𝓝 (0:ℂ)) := by
+    rw [← hLaw.map_eq]
+    apply (ae_map_iff hLaw.aemeasurable hset).mpr
+    apply ae_of_all
+    intro ω
+    apply tendsto_sub_nhds_zero_iff.mpr
+    have h := Target.rawTipApprox_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
+    simpa only [hΨeq,sourceTracePath,ContinuousMap.coe_mk] using h
+  filter_upwards [hae] with b hb
+  have ht := tendsto_sub_nhds_zero_iff.mp hb
+  exact ⟨ht,ht.limUnder_eq⟩
+
+end SLEExactGauge
+
+end
+
+end OAI
diff --git a/lean/OAI/Probability/SLE/Loewner/CanonicalTraceDischarge.lean b/lean/OAI/Probability/SLE/Loewner/CanonicalTraceDischarge.lean
new file mode 100644
index 0000000000000000000000000000000000000000..6e10991c511e3336f22699f259376bb90e8df70f
--- /dev/null
+++ b/lean/OAI/Probability/SLE/Loewner/CanonicalTraceDischarge.lean
@@ -0,0 +1,53 @@
+import OAI.Probability.SLE.Loewner.CanonicalCapacityWitness
+import OAI.Probability.SLE.Angle.TargetPathNormalization
+import OAI.Probability.SLE.Geometry.PublishedInputs
+
+namespace OAI
+
+/-! A capacity-two SLE presentation gives a canonical trace on its
+continuous-driver law through the raw inverse-flow witness. -/
+noncomputable section
+open Set Filter _root_.MeasureTheory _root_.OAI.MeasureTheory ProbabilityTheory
+open scoped Topology NNReal ENNReal
+
+namespace SLEExactGauge
+
+local instance traceDischargeRealMeasurable : MeasurableSpace C(ℝ≥0,ℝ) := borel _
+local instance traceDischargeRealBorel : BorelSpace C(ℝ≥0,ℝ) := ⟨rfl⟩
+local instance traceDischargeComplexMeasurable : MeasurableSpace C(ℝ≥0,ℂ) := borel _
+local instance traceDischargeComplexBorel : BorelSpace C(ℝ≥0,ℂ) := ⟨rfl⟩
+
+theorem canonical_driver_trace_generation_of_witness
+    {Ω : 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 ω)) :
+    PublishedTraceGeneration (P.map (sourceDriverPath B hc)) κ (fun t p => p t) := by
+  let W : Target.WienerLaw := P.map (Target.normalizedDriver κ B hc h0)
+  have hW : Target.IsWiener W := Target.normalizedDriver_isWiener κ hκ B hB hm hc h0
+  obtain ⟨Ψ,hΨ,hΨw⟩ := exists_canonical_capacity_witness
+    κ hκ hκ8 B hB hm hc h0 γ G F hw W hW
+  let Φ : C(ℝ≥0,ℝ) → C(ℝ≥0,ℂ) := Ψ ∘ normalizePath κ
+  refine ⟨fun p t => Φ p t,fun t => ?_,?_⟩
+  · exact (continuous_eval_const t).measurable.comp (hΨ.comp (measurable_normalizePath κ))
+  · rw [← unnormalizeDriver_law κ hκ B hB hm hc h0 W hW]
+    rw [ae_iff,(measurableEmbedding_unnormalizeDriver κ hκ).map_apply]
+    apply ae_iff.mp
+    filter_upwards [hΨw] with b hb
+    have he : (fun t => Real.sqrt κ*(unnormalizeDriver κ b) t)=
+        (fun t => b (κ.toNNReal*t)) := by
+      funext t
+      change Real.sqrt κ*(b (κ.toNNReal*t)/Real.sqrt κ)=_
+      exact mul_div_cancel₀ _ (Real.sqrt_pos.mpr hκ).ne'
+    have hΦ : (Φ (unnormalizeDriver κ b) : ℝ≥0 → ℂ)=Ψ b := by
+      simp only [Φ,Function.comp_apply,normalize_unnormalize κ hκ]
+    rw [he,hΦ]
+    exact ⟨_,_,hb⟩
+
+end SLEExactGauge
+
+end
+
+end OAI
diff --git a/lean/OAI/Probability/SLE/Loewner/CapacityDriverContinuity.lean b/lean/OAI/Probability/SLE/Loewner/CapacityDriverContinuity.lean
new file mode 100644
index 0000000000000000000000000000000000000000..0b1699d83bca2616768594673feca42a03303e63
--- /dev/null
+++ b/lean/OAI/Probability/SLE/Loewner/CapacityDriverContinuity.lean
@@ -0,0 +1,50 @@
+import OAI.Probability.SLE.Loewner.InitialDrivingContinuity
+
+namespace OAI
+
+/-! Continuity of the driver and Loewner kernel in the exact capacity clock. -/
+noncomputable section
+open Set Filter Function Complex
+open scoped Topology
+
+namespace SLEExactGauge
+
+theorem capacityDriverOnPrefix_continuous (p : C(unitInterval,ℂ)) (hi : Injective p)
+    (h0 : p 0=0) (hH : ∀ t : unitInterval, t≠0 → p t∈upperHalfPlane)
+    {T : unitInterval} (hT : T<1) :
+    Continuous (capacityDriverOnPrefix p hi h0 hH T hT) := by
+  rw [continuous_iff_continuousAt]
+  intro c
+  have he : capacityDriverOnPrefix p hi h0 hH T hT=
+      initialDriving p hi h0 hH ∘ capacityParameterOnPrefix p hi h0 hH T := by
+    funext u
+    exact (initialDriving_of_lt p hi h0 hH
+      ((capacityParameterOnPrefix_le p hi h0 hH T u).trans_lt hT)).symm
+  rw [he]
+  exact (initialDriving_continuousAt p hi h0 hH
+    ((capacityParameterOnPrefix_le p hi h0 hH T c).trans_lt hT)).comp
+      (capacityParameterOnPrefix_continuous p hi h0 hH T).continuousAt
+
+theorem capacityLoewnerKernel_continuous (p : C(unitInterval,ℂ)) (hi : Injective p)
+    (h0 : p 0=0) (hH : ∀ t : unitInterval, t≠0 → p t∈upperHalfPlane)
+    {T : unitInterval} (hT : T<1) {z : ℂ}
+    (hz : z∈upperHalfPlane \ range (initialSubarc p T)) :
+    Continuous (fun c : ℝ => 1/(capacityForwardOnPrefix p hi h0 hH T z c-
+      (capacityDriverOnPrefix p hi h0 hH T hT c:ℂ))) := by
+  have hf := (capacityForwardOnPrefix_lipschitz p hi h0 hH hT hz).continuous
+  have hu := Complex.continuous_ofReal.comp (capacityDriverOnPrefix_continuous p hi h0 hH hT)
+  refine continuous_const.div (hf.sub hu) ?_
+  intro c he
+  have him := congrArg Complex.im he
+  have hpos : 0<(capacityForwardOnPrefix p hi h0 hH T z c).im :=
+    initialForwardChart_im_pos p hi h0 hH _
+      ⟨hz.1,fun he => hz.2 (initialSubarc_range_mono p
+        (capacityParameterOnPrefix_le p hi h0 hH T c) he)⟩
+  simp only [sub_im,ofReal_im,sub_zero,zero_im] at him
+  linarith
+
+end SLEExactGauge
+
+end
+
+end OAI
diff --git a/lean/OAI/Probability/SLE/Loewner/CapacityForwardDerivative.lean b/lean/OAI/Probability/SLE/Loewner/CapacityForwardDerivative.lean
new file mode 100644
index 0000000000000000000000000000000000000000..3812efd81f54606680cede2fb1dc550f365a89a6
--- /dev/null
+++ b/lean/OAI/Probability/SLE/Loewner/CapacityForwardDerivative.lean
@@ -0,0 +1,71 @@
+import OAI.Probability.SLE.Loewner.CapacityForwardLipschitz
+import Mathlib.Analysis.BoundedVariation
+import Mathlib.Analysis.Calculus.Deriv.Basic
+
+namespace OAI
+
+/-! The exact capacity-parametrized map has an almost-everywhere time
+derivative, with the height bound needed for the Loewner evolution. -/
+noncomputable section
+open Set Filter Function Complex MeasureTheory
+open scoped Topology
+
+namespace SLEExactGauge
+
+noncomputable def capacityForwardOnPrefix (p : C(unitInterval,ℂ)) (hi : Injective p)
+    (h0 : p 0=0) (hH : ∀ t : unitInterval, t≠0 → p t∈upperHalfPlane)
+    (T : unitInterval) (z : ℂ) (c : ℝ) : ℂ :=
+  initialForwardChart p hi h0 hH
+    (prefixCapacityTime p hi h0 hH T
+      (projIcc 0 (initialCapacity p hi h0 hH T)
+        (initialCapacity_nonneg p hi h0 hH T) c)) z
+
+theorem capacityForwardOnPrefix_at_initialCapacity (p : C(unitInterval,ℂ)) (hi : Injective p)
+    (h0 : p 0=0) (hH : ∀ t : unitInterval, t≠0 → p t∈upperHalfPlane)
+    (T : unitInterval) (z : ℂ) {s : unitInterval} (hs : s≤T) :
+    capacityForwardOnPrefix p hi h0 hH T z (initialCapacity p hi h0 hH s)=
+      initialForwardChart p hi h0 hH s z := by
+  have hm : initialCapacity p hi h0 hH s∈Icc 0 (initialCapacity p hi h0 hH T) :=
+    ⟨initialCapacity_nonneg p hi h0 hH s,initialCapacity_monotone p hi h0 hH hs⟩
+  have he := prefixCapacityTime_capacity p hi h0 hH T
+    (projIcc 0 (initialCapacity p hi h0 hH T)
+      (initialCapacity_nonneg p hi h0 hH T) (initialCapacity p hi h0 hH s))
+  have ht : prefixCapacityTime p hi h0 hH T
+      (projIcc 0 (initialCapacity p hi h0 hH T)
+        (initialCapacity_nonneg p hi h0 hH T) (initialCapacity p hi h0 hH s))=s := by
+    apply (initialCapacity_strictMono p hi h0 hH).injective
+    simpa only [projIcc_of_mem _ hm] using he
+  exact congrArg (fun r => initialForwardChart p hi h0 hH r z) ht
+
+theorem capacityForwardOnPrefix_lipschitz (p : C(unitInterval,ℂ)) (hi : Injective p)
+    (h0 : p 0=0) (hH : ∀ t : unitInterval, t≠0 → p t∈upperHalfPlane)
+    {T : unitInterval} (hT : T<1) {z : ℂ}
+    (hz : z∈upperHalfPlane \ range (initialSubarc p T)) :
+    LipschitzWith (NNReal.mk ((initialForwardChart p hi h0 hH T z).im)⁻¹
+      (inv_nonneg.mpr (le_of_lt (initialForwardChart_im_pos p hi h0 hH T hz))))
+      (capacityForwardOnPrefix p hi h0 hH T z) := by
+  have hh := (capacityForward_lipschitz p hi h0 hH hT hz).comp
+    (LipschitzWith.projIcc (initialCapacity_nonneg p hi h0 hH T))
+  unfold capacityForwardOnPrefix
+  convert! hh using 1; simp only [_root_.mul_one]
+
+theorem capacityForwardOnPrefix_ae_differentiable (p : C(unitInterval,ℂ)) (hi : Injective p)
+    (h0 : p 0=0) (hH : ∀ t : unitInterval, t≠0 → p t∈upperHalfPlane)
+    {T : unitInterval} (hT : T<1) {z : ℂ}
+    (hz : z∈upperHalfPlane \ range (initialSubarc p T)) :
+    ∀ᵐ c : ℝ, DifferentiableAt ℝ (capacityForwardOnPrefix p hi h0 hH T z) c :=
+  (capacityForwardOnPrefix_lipschitz p hi h0 hH hT hz).ae_differentiableAt_real
+
+theorem capacityForwardOnPrefix_derivative_bound (p : C(unitInterval,ℂ)) (hi : Injective p)
+    (h0 : p 0=0) (hH : ∀ t : unitInterval, t≠0 → p t∈upperHalfPlane)
+    {T : unitInterval} (hT : T<1) {z : ℂ}
+    (hz : z∈upperHalfPlane \ range (initialSubarc p T)) (c : ℝ) :
+    ‖deriv (capacityForwardOnPrefix p hi h0 hH T z) c‖≤
+      ((initialForwardChart p hi h0 hH T z).im)⁻¹ :=
+  norm_deriv_le_of_lipschitz (capacityForwardOnPrefix_lipschitz p hi h0 hH hT hz)
+
+end SLEExactGauge
+
+end
+
+end OAI
diff --git a/lean/OAI/Probability/SLE/Loewner/CapacityForwardLipschitz.lean b/lean/OAI/Probability/SLE/Loewner/CapacityForwardLipschitz.lean
new file mode 100644
index 0000000000000000000000000000000000000000..80c6ffebd18e754be2444fc5927ce29a11282448
--- /dev/null
+++ b/lean/OAI/Probability/SLE/Loewner/CapacityForwardLipschitz.lean
@@ -0,0 +1,93 @@
+import OAI.Probability.SLE.Loewner.InitialForwardIncrement
+import OAI.Probability.SLE.Loewner.InitialCapacityClock
+import Mathlib.Topology.MetricSpace.Lipschitz
+
+namespace OAI
+
+/-! On any strictly surviving prefix, the exact forward flow is Lipschitz
+in its capacity parameter. -/
+noncomputable section
+open Set Filter Function Complex
+open scoped Topology
+
+namespace SLEExactGauge
+
+lemma initialForwardChart_im_pos (p : C(unitInterval,ℂ)) (hi : Injective p)
+    (h0 : p 0=0) (hH : ∀ t : unitInterval, t≠0 → p t∈upperHalfPlane)
+    (T : unitInterval) {z : ℂ} (hz : z∈upperHalfPlane \ range (initialSubarc p T)) :
+    0<(initialForwardChart p hi h0 hH T z).im :=
+  initialForwardChart_mem_upper p hi h0 hH T hz
+
+theorem initialForward_prefix_bound (p : C(unitInterval,ℂ)) (hi : Injective p)
+    (h0 : p 0=0) (hH : ∀ t : unitInterval, t≠0 → p t∈upperHalfPlane)
+    {T : unitInterval} (hT : T<1) {z : ℂ}
+    (hz : z∈upperHalfPlane \ range (initialSubarc p T))
+    {s t : unitInterval} (hs : s≤T) (ht : t≤T) :
+    ‖initialForwardChart p hi h0 hH t z-initialForwardChart p hi h0 hH s z‖≤
+      |initialCapacity p hi h0 hH t-initialCapacity p hi h0 hH s|/
+        (initialForwardChart p hi h0 hH T z).im := by
+  have hy : 0<(initialForwardChart p hi h0 hH T z).im :=
+    initialForwardChart_mem_upper p hi h0 hH T hz
+  have hdom (r : unitInterval) (hr : r≤T) :
+      z∈upperHalfPlane \ range (initialSubarc p r) :=
+    ⟨hz.1,fun he => hz.2 (initialSubarc_range_mono p hr he)⟩
+  have hordered (a b : unitInterval) (hb : b≤T) (hab : a≤b) :
+      ‖initialForwardChart p hi h0 hH b z-initialForwardChart p hi h0 hH a z‖≤
+        |initialCapacity p hi h0 hH b-initialCapacity p hi h0 hH a|/
+          (initialForwardChart p hi h0 hH T z).im := by
+    have hc : 0 ≤ initialCapacity p hi h0 hH b-initialCapacity p hi h0 hH a :=
+      sub_nonneg.mpr (initialCapacity_monotone p hi h0 hH hab)
+    rw [abs_of_nonneg hc]
+    obtain rfl | hab := hab.eq_or_lt
+    · simp only [sub_self,norm_zero,zero_div,le_refl]
+    have hh := initialForward_increment_bound p hi h0 hH hab (hb.trans_lt hT) (hdom b hb)
+    exact hh.trans (div_le_div_of_nonneg_left hc hy
+      (initialForward_height_antitone p hi h0 hH hb hT hz))
+  rcases le_total s t with hst | hts
+  · exact hordered s t ht hst
+  · simpa only [norm_sub_rev,abs_sub_comm] using hordered t s hs hts
+
+noncomputable def prefixCapacityTime (p : C(unitInterval,ℂ)) (hi : Injective p)
+    (h0 : p 0=0) (hH : ∀ t : unitInterval, t≠0 → p t∈upperHalfPlane)
+    (T : unitInterval) (c : Icc 0 (initialCapacity p hi h0 hH T)) : unitInterval :=
+  (initialCapacityHomeomorph p hi h0 hH).symm
+    ⟨c.1,c.2.1,c.2.2.trans (initialCapacity_monotone p hi h0 hH le_top)⟩
+
+@[simp] lemma prefixCapacityTime_capacity (p : C(unitInterval,ℂ)) (hi : Injective p)
+    (h0 : p 0=0) (hH : ∀ t : unitInterval, t≠0 → p t∈upperHalfPlane)
+    (T : unitInterval) (c : Icc 0 (initialCapacity p hi h0 hH T)) :
+    initialCapacity p hi h0 hH (prefixCapacityTime p hi h0 hH T c)=(c:ℝ) :=
+  initialCapacityHomeomorph_symm_capacity p hi h0 hH _
+
+lemma prefixCapacityTime_le (p : C(unitInterval,ℂ)) (hi : Injective p)
+    (h0 : p 0=0) (hH : ∀ t : unitInterval, t≠0 → p t∈upperHalfPlane)
+    (T : unitInterval) (c : Icc 0 (initialCapacity p hi h0 hH T)) :
+    prefixCapacityTime p hi h0 hH T c≤T := by
+  apply (initialCapacity_strictMono p hi h0 hH).le_iff_le.mp
+  rw [prefixCapacityTime_capacity]
+  exact c.2.2
+
+theorem capacityForward_lipschitz (p : C(unitInterval,ℂ)) (hi : Injective p)
+    (h0 : p 0=0) (hH : ∀ t : unitInterval, t≠0 → p t∈upperHalfPlane)
+    {T : unitInterval} (hT : T<1) {z : ℂ}
+    (hz : z∈upperHalfPlane \ range (initialSubarc p T)) :
+    LipschitzWith (NNReal.mk ((initialForwardChart p hi h0 hH T z).im)⁻¹
+      (inv_nonneg.mpr (le_of_lt (initialForwardChart_im_pos p hi h0 hH T hz))))
+      (fun c : Icc 0 (initialCapacity p hi h0 hH T) =>
+        initialForwardChart p hi h0 hH (prefixCapacityTime p hi h0 hH T c) z) := by
+  apply LipschitzWith.of_dist_le_mul
+  intro c d
+  rw [dist_eq_norm,Subtype.dist_eq]
+  change ‖initialForwardChart p hi h0 hH (prefixCapacityTime p hi h0 hH T c) z-
+      initialForwardChart p hi h0 hH (prefixCapacityTime p hi h0 hH T d) z‖≤
+    ((initialForwardChart p hi h0 hH T z).im)⁻¹*dist (c:ℝ) (d:ℝ)
+  have hh := initialForward_prefix_bound p hi h0 hH hT hz
+    (prefixCapacityTime_le p hi h0 hH T d) (prefixCapacityTime_le p hi h0 hH T c)
+  rw [prefixCapacityTime_capacity,prefixCapacityTime_capacity] at hh
+  simpa only [Real.dist_eq,div_eq_mul_inv,mul_comm] using hh
+
+end SLEExactGauge
+
+end
+
+end OAI
diff --git a/lean/OAI/Probability/SLE/Loewner/CapacityLoewnerDerivative.lean b/lean/OAI/Probability/SLE/Loewner/CapacityLoewnerDerivative.lean
new file mode 100644
index 0000000000000000000000000000000000000000..424e74a48f9ef6fb8e6fbf6dd8a3eae1cb0dd7b2
--- /dev/null
+++ b/lean/OAI/Probability/SLE/Loewner/CapacityLoewnerDerivative.lean
@@ -0,0 +1,73 @@
+import OAI.Probability.SLE.Loewner.CapacityRightLoewner
+import Mathlib.Topology.Order.LeftRightNhds
+import Mathlib.Analysis.Calculus.TangentCone.Real
+
+namespace OAI
+
+/-! At every differentiability point the real time derivative is the
+identified Loewner kernel. Lipschitz regularity then gives the a.e. ODE. -/
+noncomputable section
+open Set Filter Function Complex MeasureTheory
+open scoped Topology
+
+namespace SLEExactGauge
+
+theorem capacityForward_deriv_at_capacity (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)
+    {z : ℂ} (hz : z∈upperHalfPlane \ range (initialSubarc p T))
+    (hd : DifferentiableAt ℝ (capacityForwardOnPrefix p hi h0 hH T z)
+      (initialCapacity p hi h0 hH s)) :
+    deriv (capacityForwardOnPrefix p hi h0 hH T z) (initialCapacity p hi h0 hH s)=
+      1/(initialForwardChart p hi h0 hH s z-
+        (initialDrivingValue p hi h0 hH s (hsT.trans hT):ℂ)) := by
+  have hcap := initialCapacity_strictMono p hi h0 hH hsT
+  have hr : HasDerivWithinAt (capacityForwardOnPrefix p hi h0 hH T z)
+      (1/(initialForwardChart p hi h0 hH s z-
+        (initialDrivingValue p hi h0 hH s (hsT.trans hT):ℂ)))
+      (Ioi (initialCapacity p hi h0 hH s)) (initialCapacity p hi h0 hH s) := by
+    apply (hasDerivWithinAt_iff_tendsto_slope' (by simp)).mpr
+    have hh := (hasDerivWithinAt_iff_tendsto_slope' (by simp)).mp
+      (capacityForward_hasDerivWithinAt_right p hi h0 hH hsT hT hz)
+    rwa [nhdsWithin_Ioc_eq_nhdsGT hcap] at hh
+  have hu := uniqueDiffOn_Ici (initialCapacity p hi h0 hH s)
+    (initialCapacity p hi h0 hH s) (Set.mem_Ici.mpr le_rfl)
+  exact (hd.hasDerivAt.hasDerivWithinAt.derivWithin hu).symm.trans
+    (hr.Ici_of_Ioi.derivWithin hu)
+
+lemma capacityParameterOnPrefix_le (p : C(unitInterval,ℂ)) (hi : Injective p)
+    (h0 : p 0=0) (hH : ∀ t : unitInterval, t≠0 → p t∈upperHalfPlane)
+    (T : unitInterval) (c : ℝ) : capacityParameterOnPrefix p hi h0 hH T c≤T :=
+  prefixCapacityTime_le p hi h0 hH T _
+
+noncomputable def capacityDriverOnPrefix (p : C(unitInterval,ℂ)) (hi : Injective p)
+    (h0 : p 0=0) (hH : ∀ t : unitInterval, t≠0 → p t∈upperHalfPlane)
+    (T : unitInterval) (hT : T<1) (c : ℝ) : ℝ :=
+  initialDrivingValue p hi h0 hH (capacityParameterOnPrefix p hi h0 hH T c)
+    ((capacityParameterOnPrefix_le p hi h0 hH T c).trans_lt hT)
+
+theorem capacityForward_ae_loewner (p : C(unitInterval,ℂ)) (hi : Injective p)
+    (h0 : p 0=0) (hH : ∀ t : unitInterval, t≠0 → p t∈upperHalfPlane)
+    {T : unitInterval} (hT : T<1) {z : ℂ}
+    (hz : z∈upperHalfPlane \ range (initialSubarc p T)) :
+    ∀ᵐ c : ℝ, c∈Ico 0 (initialCapacity p hi h0 hH T) →
+      deriv (capacityForwardOnPrefix p hi h0 hH T z) c=
+        1/(capacityForwardOnPrefix p hi h0 hH T z c-
+          (capacityDriverOnPrefix p hi h0 hH T hT c:ℂ)) := by
+  filter_upwards [capacityForwardOnPrefix_ae_differentiable p hi h0 hH hT hz] with c hd hc
+  let s := capacityParameterOnPrefix p hi h0 hH T c
+  have hcap : initialCapacity p hi h0 hH s=c :=
+    capacityParameterOnPrefix_capacity p hi h0 hH T ⟨hc.1,hc.2.le⟩
+  have hsT : s<T := (initialCapacity_strictMono p hi h0 hH).lt_iff_lt.mp
+    (by rw [hcap]; exact hc.2)
+  have hh := capacityForward_deriv_at_capacity p hi h0 hH hsT hT hz
+    (by rwa [hcap])
+  rw [hcap] at hh
+  rw [← capacityForwardOnPrefix_at_initialCapacity p hi h0 hH T z hsT.le,hcap] at hh
+  exact hh
+
+end SLEExactGauge
+
+end
+
+end OAI
diff --git a/lean/OAI/Probability/SLE/Loewner/CapacityLoewnerIntegral.lean b/lean/OAI/Probability/SLE/Loewner/CapacityLoewnerIntegral.lean
new file mode 100644
index 0000000000000000000000000000000000000000..c8f2e5ca8a7f26f541b34616d1e3316cdcb09a2a
--- /dev/null
+++ b/lean/OAI/Probability/SLE/Loewner/CapacityLoewnerIntegral.lean
@@ -0,0 +1,55 @@
+import OAI.Probability.SLE.Loewner.CapacityDriverContinuity
+import OAI.Probability.SLE.Loewner.CapacityPointwiseLoewner
+
+namespace OAI
+
+/-! The right Loewner evolution has a continuous kernel. Its integral
+identity therefore gives the ordinary derivative on the full prefix. -/
+noncomputable section
+open Set Filter Function Complex MeasureTheory
+open scoped Topology
+
+namespace SLEExactGauge
+
+theorem capacityForward_integral_kernel (p : C(unitInterval,ℂ)) (hi : Injective p)
+    (h0 : p 0=0) (hH : ∀ t : unitInterval, t≠0 → p t∈upperHalfPlane)
+    {T : unitInterval} (hT : T<1) {z : ℂ}
+    (hz : z∈upperHalfPlane \ range (initialSubarc p T))
+    {c : ℝ} (hc : c∈Icc 0 (initialCapacity p hi h0 hH T)) :
+    (∫ u in 0..c, 1/(capacityForwardOnPrefix p hi h0 hH T z u-
+      (capacityDriverOnPrefix p hi h0 hH T hT u:ℂ)))=
+      capacityForwardOnPrefix p hi h0 hH T z c-capacityForwardOnPrefix p hi h0 hH T z 0 := by
+  apply intervalIntegral.integral_eq_sub_of_hasDeriv_right_of_le hc.1
+    (capacityForwardOnPrefix_lipschitz p hi h0 hH hT hz).continuous.continuousOn
+  · intro u hu
+    exact (capacityForward_hasDerivWithinAt_Ici p hi h0 hH hT hz
+      ⟨hu.1.le,hu.2.trans_le hc.2⟩).mono Ioi_subset_Ici_self
+  · exact (capacityLoewnerKernel_continuous p hi h0 hH hT hz).intervalIntegrable 0 c
+
+theorem capacityForward_hasDerivWithinAt_prefix (p : C(unitInterval,ℂ)) (hi : Injective p)
+    (h0 : p 0=0) (hH : ∀ t : unitInterval, t≠0 → p t∈upperHalfPlane)
+    {T : unitInterval} (hT : T<1) {z : ℂ}
+    (hz : z∈upperHalfPlane \ range (initialSubarc p T))
+    {c : ℝ} (hc : c∈Icc 0 (initialCapacity p hi h0 hH T)) :
+    HasDerivWithinAt (capacityForwardOnPrefix p hi h0 hH T z)
+      (1/(capacityForwardOnPrefix p hi h0 hH T z c-
+        (capacityDriverOnPrefix p hi h0 hH T hT c:ℂ)))
+      (Icc 0 (initialCapacity p hi h0 hH T)) c := by
+  let f := capacityForwardOnPrefix p hi h0 hH T z
+  let k := fun u => 1/(f u-(capacityDriverOnPrefix p hi h0 hH T hT u:ℂ))
+  have hk : Continuous k := capacityLoewnerKernel_continuous p hi h0 hH hT hz
+  have hI : HasDerivAt (fun u => f 0+∫ v in 0..u, k v) (k c) c := by
+    simpa only [zero_add] using (intervalIntegral.integral_hasDerivAt_right
+      (hk.intervalIntegrable 0 c) hk.aestronglyMeasurable.stronglyMeasurableAtFilter
+        hk.continuousAt).const_add (f 0)
+  apply hI.hasDerivWithinAt.congr_of_mem (fun u hu => ?_) hc
+  change f u=f 0+∫ v in 0..u, k v
+  rw [capacityForward_integral_kernel p hi h0 hH hT hz hu]
+  dsimp only [f]
+  abel
+
+end SLEExactGauge
+
+end
+
+end OAI
diff --git a/lean/OAI/Probability/SLE/Loewner/CapacityParameterContinuity.lean b/lean/OAI/Probability/SLE/Loewner/CapacityParameterContinuity.lean
new file mode 100644
index 0000000000000000000000000000000000000000..422024b39443d5949b434edb41a4c3b177aa8ca9
--- /dev/null
+++ b/lean/OAI/Probability/SLE/Loewner/CapacityParameterContinuity.lean
@@ -0,0 +1,64 @@
+import OAI.Probability.SLE.Loewner.CapacityForwardDerivative
+
+namespace OAI
+
+/-! Continuity and exact values of the real, clipped capacity clock. -/
+noncomputable section
+open Set Filter Function Complex
+open scoped Topology
+
+namespace SLEExactGauge
+
+noncomputable def capacityParameterOnPrefix (p : C(unitInterval,ℂ)) (hi : Injective p)
+    (h0 : p 0=0) (hH : ∀ t : unitInterval, t≠0 → p t∈upperHalfPlane)
+    (T : unitInterval) (c : ℝ) : unitInterval :=
+  prefixCapacityTime p hi h0 hH T
+    (projIcc 0 (initialCapacity p hi h0 hH T) (initialCapacity_nonneg p hi h0 hH T) c)
+
+lemma prefixCapacityTime_continuous (p : C(unitInterval,ℂ)) (hi : Injective p)
+    (h0 : p 0=0) (hH : ∀ t : unitInterval, t≠0 → p t∈upperHalfPlane)
+    (T : unitInterval) : Continuous (prefixCapacityTime p hi h0 hH T) := by
+  unfold prefixCapacityTime
+  exact (initialCapacityHomeomorph p hi h0 hH).symm.continuous.comp
+    (continuous_subtype_val.subtype_mk _)
+
+lemma capacityParameterOnPrefix_continuous (p : C(unitInterval,ℂ)) (hi : Injective p)
+    (h0 : p 0=0) (hH : ∀ t : unitInterval, t≠0 → p t∈upperHalfPlane)
+    (T : unitInterval) : Continuous (capacityParameterOnPrefix p hi h0 hH T) :=
+  (prefixCapacityTime_continuous p hi h0 hH T).comp
+    (LipschitzWith.projIcc (initialCapacity_nonneg p hi h0 hH T)).continuous
+
+lemma capacityParameterOnPrefix_capacity (p : C(unitInterval,ℂ)) (hi : Injective p)
+    (h0 : p 0=0) (hH : ∀ t : unitInterval, t≠0 → p t∈upperHalfPlane)
+    (T : unitInterval) {c : ℝ} (hc : c∈Icc 0 (initialCapacity p hi h0 hH T)) :
+    initialCapacity p hi h0 hH (capacityParameterOnPrefix p hi h0 hH T c)=c := by
+  rw [capacityParameterOnPrefix,prefixCapacityTime_capacity,projIcc_of_mem _ hc]
+
+lemma capacityParameterOnPrefix_at_initialCapacity (p : C(unitInterval,ℂ)) (hi : Injective p)
+    (h0 : p 0=0) (hH : ∀ t : unitInterval, t≠0 → p t∈upperHalfPlane)
+    (T : unitInterval) {s : unitInterval} (hs : s≤T) :
+    capacityParameterOnPrefix p hi h0 hH T (initialCapacity p hi h0 hH s)=s := by
+  apply (initialCapacity_strictMono p hi h0 hH).injective
+  exact capacityParameterOnPrefix_capacity p hi h0 hH T
+    ⟨initialCapacity_nonneg p hi h0 hH s,initialCapacity_monotone p hi h0 hH hs⟩
+
+lemma capacityParameterOnPrefix_mem_Ioc (p : C(unitInterval,ℂ)) (hi : Injective p)
+    (h0 : p 0=0) (hH : ∀ t : unitInterval, t≠0 → p t∈upperHalfPlane)
+    (T : unitInterval) {s : unitInterval} {c : ℝ}
+    (hc : c∈Ioc (initialCapacity p hi h0 hH s) (initialCapacity p hi h0 hH T)) :
+    capacityParameterOnPrefix p hi h0 hH T c∈Ioc s T := by
+  have hcap := capacityParameterOnPrefix_capacity p hi h0 hH T
+    ⟨(initialCapacity_nonneg p hi h0 hH s).trans hc.1.le,hc.2⟩
+  constructor
+  · apply (initialCapacity_strictMono p hi h0 hH).lt_iff_lt.mp
+    rw [hcap]
+    exact hc.1
+  · apply (initialCapacity_strictMono p hi h0 hH).le_iff_le.mp
+    rw [hcap]
+    exact hc.2
+
+end SLEExactGauge
+
+end
+
+end OAI
diff --git a/lean/OAI/Probability/SLE/Loewner/CapacityPointwiseLoewner.lean b/lean/OAI/Probability/SLE/Loewner/CapacityPointwiseLoewner.lean
new file mode 100644
index 0000000000000000000000000000000000000000..b51fe343f07f3e29f3d32d3406e2dbc9ff5e4878
--- /dev/null
+++ b/lean/OAI/Probability/SLE/Loewner/CapacityPointwiseLoewner.lean
@@ -0,0 +1,42 @@
+import OAI.Probability.SLE.Loewner.CapacityLoewnerDerivative
+
+namespace OAI
+
+/-! Pointwise right evolution on every finite surviving capacity prefix. -/
+noncomputable section
+open Set Filter Function Complex
+open scoped Topology
+
+namespace SLEExactGauge
+
+theorem capacityForward_hasDerivWithinAt_Ici (p : C(unitInterval,ℂ)) (hi : Injective p)
+    (h0 : p 0=0) (hH : ∀ t : unitInterval, t≠0 → p t∈upperHalfPlane)
+    {T : unitInterval} (hT : T<1) {z : ℂ}
+    (hz : z∈upperHalfPlane \ range (initialSubarc p T))
+    {c : ℝ} (hc : c∈Ico 0 (initialCapacity p hi h0 hH T)) :
+    HasDerivWithinAt (capacityForwardOnPrefix p hi h0 hH T z)
+      (1/(capacityForwardOnPrefix p hi h0 hH T z c-
+        (capacityDriverOnPrefix p hi h0 hH T hT c:ℂ))) (Ici c) c := by
+  let s := capacityParameterOnPrefix p hi h0 hH T c
+  have hcap : initialCapacity p hi h0 hH s=c :=
+    capacityParameterOnPrefix_capacity p hi h0 hH T ⟨hc.1,hc.2.le⟩
+  have hsT : s<T := (initialCapacity_strictMono p hi h0 hH).lt_iff_lt.mp
+    (by rw [hcap]; exact hc.2)
+  have hcaplt := initialCapacity_strictMono p hi h0 hH hsT
+  have hr : HasDerivWithinAt (capacityForwardOnPrefix p hi h0 hH T z)
+      (1/(initialForwardChart p hi h0 hH s z-
+        (initialDrivingValue p hi h0 hH s (hsT.trans hT):ℂ)))
+      (Ioi (initialCapacity p hi h0 hH s)) (initialCapacity p hi h0 hH s) := by
+    apply (hasDerivWithinAt_iff_tendsto_slope' (by simp)).mpr
+    have hh := (hasDerivWithinAt_iff_tendsto_slope' (by simp)).mp
+      (capacityForward_hasDerivWithinAt_right p hi h0 hH hsT hT hz)
+    rwa [nhdsWithin_Ioc_eq_nhdsGT hcaplt] at hh
+  have hh := hr.Ici_of_Ioi
+  rw [← capacityForwardOnPrefix_at_initialCapacity p hi h0 hH T z hsT.le,hcap] at hh
+  exact hh
+
+end SLEExactGauge
+
+end
+
+end OAI
diff --git a/lean/OAI/Probability/SLE/Loewner/CapacityRadiusBound.lean b/lean/OAI/Probability/SLE/Loewner/CapacityRadiusBound.lean
new file mode 100644
index 0000000000000000000000000000000000000000..44323f1c42068bba7cff783b74baa1f0da9905ef
--- /dev/null
+++ b/lean/OAI/Probability/SLE/Loewner/CapacityRadiusBound.lean
@@ -0,0 +1,51 @@
+import OAI.Probability.SLE.Loewner.InitialCapacity
+import OAI.Probability.SLE.Loewner.RadiusHullInverse
+
+namespace OAI
+
+/-! A finite slit contained in a disk of radius R has capacity at most
+R squared, by comparison with the explicit half-disk hull. -/
+noncomputable section
+open Set Filter Complex Function Metric
+open scoped Topology
+
+namespace SLEExactGauge
+
+lemma SimpleSlitChart.capacity_le_radius_sq {p : C(unitInterval,ℂ)} (P : SimpleSlitChart p)
+    {R : ℝ} (hR : 0<R) (hp : ∀ u : unitInterval, ‖p u‖≤R) : P.capacity≤R^2 := by
+  have hm : MapsTo (radiusHullInverse R) upperHalfPlane (upperHalfPlane \ range p) := by
+    intro z hz
+    have hh := radiusHullInverse_mapsTo hR hz
+    refine ⟨hh.2,?_⟩
+    rintro ⟨u,hu⟩
+    have hn := hp u
+    rw [hu] at hn
+    linarith [hh.1]
+  apply nested_hydrodynamic_coefficient_le P.forward_differentiable P.bijOn.mapsTo
+    (radiusHullInverse_differentiableOn hR) hm P.coefficient
+    (by simpa only [ofReal_pow] using radiusHullMap_coefficient hR)
+    (radiusHullInverse_normalized hR)
+  exact fun _ hz => radiusHullMap_inverse hR hz
+
+lemma initialCapacity_le_radius_sq (p : C(unitInterval,ℂ)) (hi : Injective p) (h0 : p 0=0)
+    (hH : ∀ t : unitInterval, t ≠ 0 → p t ∈ upperHalfPlane)
+    {R : ℝ} (hR : 0<R) (t : unitInterval)
+    (hp : ∀ u ∈ Icc 0 t, ‖p u‖≤R) : initialCapacity p hi h0 hH t≤R^2 := by
+  by_cases ht : t=0
+  · simp only [ht,initialCapacity_zero]
+    positivity
+  rw [initialCapacity,dite_eq_right ht]
+  apply SimpleSlitChart.capacity_le_radius_sq _ hR
+  intro u
+  have hm : initialSubarc p t u ∈ p '' Icc 0 t := by
+    rw [← initialSubarc_range]
+    exact mem_range_self u
+  obtain ⟨v,hv,he⟩ := hm
+  rw [← he]
+  exact hp v hv
+
+end SLEExactGauge
+
+end
+
+end OAI
diff --git a/lean/OAI/Probability/SLE/Loewner/CapacityRightLoewner.lean b/lean/OAI/Probability/SLE/Loewner/CapacityRightLoewner.lean
new file mode 100644
index 0000000000000000000000000000000000000000..688f5f26a7ad73364ca280b21346ab0db4250c8d
--- /dev/null
+++ b/lean/OAI/Probability/SLE/Loewner/CapacityRightLoewner.lean
@@ -0,0 +1,77 @@
+import OAI.Probability.SLE.Loewner.InitialForwardKernelLimit
+import OAI.Probability.SLE.Loewner.CapacityParameterContinuity
+import Mathlib.Analysis.Calculus.Deriv.Slope
+
+namespace OAI
+
+/-! The Loewner right derivative in the exact capacity clock. No
+regularity of the driving function is assumed for this identification. -/
+noncomputable section
+open Set Filter Function Complex
+open scoped Topology
+
+namespace SLEExactGauge
+
+lemma capacityParameterOnPrefix_tendsto_Ioc (p : C(unitInterval,ℂ)) (hi : Injective p)
+    (h0 : p 0=0) (hH : ∀ t : unitInterval, t≠0 → p t∈upperHalfPlane)
+    {s T : unitInterval} (hsT : s<T) :
+    Tendsto (capacityParameterOnPrefix p hi h0 hH T)
+      (𝓝[Ioc (initialCapacity p hi h0 hH s) (initialCapacity p hi h0 hH T)]
+        (initialCapacity p hi h0 hH s)) (𝓝[Ioc s T] s) := by
+  apply tendsto_nhdsWithin_iff.mpr
+  constructor
+  · have hh := ((capacityParameterOnPrefix_continuous p hi h0 hH T).tendsto
+      (initialCapacity p hi h0 hH s)).mono_left
+        (show 𝓝[Ioc (initialCapacity p hi h0 hH s) (initialCapacity p hi h0 hH T)]
+          (initialCapacity p hi h0 hH s)≤𝓝 (initialCapacity p hi h0 hH s) from inf_le_left)
+    rwa [capacityParameterOnPrefix_at_initialCapacity p hi h0 hH T hsT.le] at hh
+  · filter_upwards [self_mem_nhdsWithin] with c hc
+    exact capacityParameterOnPrefix_mem_Ioc p hi h0 hH T hc
+
+theorem capacityForward_quotient_tendsto (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)
+    {z : ℂ} (hz : z∈upperHalfPlane \ range (initialSubarc p T)) :
+    Tendsto (fun c : ℝ =>
+      (capacityForwardOnPrefix p hi h0 hH T z c-
+        capacityForwardOnPrefix p hi h0 hH T z (initialCapacity p hi h0 hH s))/
+      ((c-initialCapacity p hi h0 hH s:ℝ):ℂ))
+      (𝓝[Ioc (initialCapacity p hi h0 hH s) (initialCapacity p hi h0 hH T)]
+        (initialCapacity p hi h0 hH s))
+      (𝓝 (1/(initialForwardChart p hi h0 hH s z-
+        (initialDrivingValue p hi h0 hH s (hsT.trans hT):ℂ)))) := by
+  have hh := (initialForward_quotient_tendsto p hi h0 hH hsT hT hz).comp
+    (capacityParameterOnPrefix_tendsto_Ioc p hi h0 hH hsT)
+  apply hh.congr'
+  filter_upwards [self_mem_nhdsWithin] with c hc
+  have hcap := capacityParameterOnPrefix_capacity p hi h0 hH T
+    (show c∈Icc 0 (initialCapacity p hi h0 hH T) from
+      ⟨(initialCapacity_nonneg p hi h0 hH s).trans hc.1.le,hc.2⟩)
+  simp only [comp_apply,hcap,capacityForwardOnPrefix_at_initialCapacity p hi h0 hH T z hsT.le]
+  rfl
+
+theorem capacityForward_hasDerivWithinAt_right (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)
+    {z : ℂ} (hz : z∈upperHalfPlane \ range (initialSubarc p T)) :
+    HasDerivWithinAt (capacityForwardOnPrefix p hi h0 hH T z)
+      (1/(initialForwardChart p hi h0 hH s z-
+        (initialDrivingValue p hi h0 hH s (hsT.trans hT):ℂ)))
+      (Ioc (initialCapacity p hi h0 hH s) (initialCapacity p hi h0 hH T))
+      (initialCapacity p hi h0 hH s) := by
+  apply (hasDerivWithinAt_iff_tendsto_slope' (by simp)).mpr
+  have hh := capacityForward_quotient_tendsto p hi h0 hH hsT hT hz
+  have he : slope (capacityForwardOnPrefix p hi h0 hH T z) (initialCapacity p hi h0 hH s)=
+      fun c : ℝ => (capacityForwardOnPrefix p hi h0 hH T z c-
+        capacityForwardOnPrefix p hi h0 hH T z (initialCapacity p hi h0 hH s))/
+        ((c-initialCapacity p hi h0 hH s:ℝ):ℂ) := by
+    funext c
+    simp only [slope_def_module,Complex.real_smul,ofReal_inv,div_eq_mul_inv,mul_comm]
+  rw [he]
+  exact hh
+
+end SLEExactGauge
+
+end
+
+end OAI
diff --git a/lean/OAI/Probability/SLE/Loewner/FillEndpoint.lean b/lean/OAI/Probability/SLE/Loewner/FillEndpoint.lean
new file mode 100644
index 0000000000000000000000000000000000000000..2ec6c07d12a24329df8dd3ecf31eff767cd3596c
--- /dev/null
+++ b/lean/OAI/Probability/SLE/Loewner/FillEndpoint.lean
@@ -0,0 +1,37 @@
+import Mathlib.Topology.Order.LeftRight
+import Mathlib.Topology.Instances.Real.Lemmas
+
+namespace OAI
+
+/-! Fill a one-sided limit at the initial endpoint of an interval. -/
+noncomputable section
+open Set Filter
+open scoped Topology
+
+namespace SLEExactGauge
+
+theorem continuousOn_fill_endpoint {X : Type*} [TopologicalSpace X]
+    {f : ℝ → X} {a : X}
+    (hf : ∀ r∈Ioc (0:ℝ) 1, ContinuousAt f r)
+    (ha : Tendsto f (𝓝[>] (0:ℝ)) (𝓝 a)) :
+    ContinuousOn (fun r : ℝ => if r=0 then a else f r) (Icc 0 1) := by
+  intro r hr
+  by_cases he : r=0
+  · subst r
+    have hgt : ContinuousWithinAt (fun r : ℝ => if r=0 then a else f r) (Ioi 0) 0 := by
+      change Tendsto _ (𝓝[>] (0:ℝ)) (𝓝 (if (0:ℝ)=0 then a else f 0))
+      rw [ite_eq_left rfl]
+      apply ha.congr'
+      filter_upwards [self_mem_nhdsWithin] with r hr
+      exact (ite_eq_right (ne_of_gt hr)).symm
+    exact (continuousWithinAt_Ioi_iff_Ici.mp hgt).mono (fun _ h => h.1)
+  · have hp : 0<r := lt_of_le_of_ne hr.1 (Ne.symm he)
+    apply ((hf r ⟨hp,hr.2⟩).congr_of_eventuallyEq ?_).continuousWithinAt
+    filter_upwards [lt_mem_nhds hp] with s hs
+    exact ite_eq_right (ne_of_gt hs)
+
+end SLEExactGauge
+
+end
+
+end OAI
diff --git a/lean/OAI/Probability/SLE/Loewner/ForwardCapacityError.lean b/lean/OAI/Probability/SLE/Loewner/ForwardCapacityError.lean
new file mode 100644
index 0000000000000000000000000000000000000000..f9cd57a8bd188a5f9f2ea262c229c393e9edecb4
--- /dev/null
+++ b/lean/OAI/Probability/SLE/Loewner/ForwardCapacityError.lean
@@ -0,0 +1,68 @@
+import OAI.Probability.SLE.Loewner.ForwardInfinityBounds
+
+namespace OAI
+
+/-! The capacity coefficient is obtained directly from the forward ODE,
+with an error tending to zero as the initial point tends to infinity. -/
+noncomputable section
+open Set Filter Complex
+open scoped Topology
+
+namespace SLEExactGauge
+
+theorem forward_far_capacity_error {T M : ℝ} (hT : 0 ≤ T) (hM : 0 ≤ M)
+    (q : ℝ → ℂ) (u : ℝ → ℝ) (z : ℂ)
+    (hc : ContinuousOn q (Icc 0 T)) (hq0 : q 0=z)
+    (hd : ∀ t ∈ Ico 0 T, HasDerivWithinAt q
+      (2/(q t-(u t : ℂ))) (Ici t) t)
+    (hu : ∀ t ∈ Icc 0 T, |u t| ≤ M)
+    (hlarge : 8*(M+T+1) ≤ ‖z‖) :
+    ‖z*(q T-z)-2*(T : ℂ)‖ ≤ 4*T*(M+T)/‖z‖ := by
+  obtain ⟨hdisp,hcenter⟩ := forward_far_displacement hT hM q u z hc hq0 hd hu hlarge
+  have hr : 0 < ‖z‖ := by nlinarith
+  have hfac : 4/‖z‖ ≤ 1 := (div_le_one hr).mpr (by nlinarith)
+  let e (t : ℝ) : ℂ := z*(q t-z)-2*(t : ℂ)
+  have hec : ContinuousOn e (Icc 0 T) := by
+    exact (continuousOn_const.mul (hc.sub continuousOn_const)).sub
+      (continuous_const.mul Complex.continuous_ofReal).continuousOn
+  have hed (t : ℝ) (ht : t ∈ Ico 0 T) : HasDerivWithinAt e
+      (z*(2/(q t-(u t : ℂ)))-2) (Ici t) t := by
+    have hl : HasDerivWithinAt (fun s : ℝ => (2:ℂ)*(s:ℂ)) 2 (Ici t) t := by
+      convert! ((hasDerivAt_id t).ofReal_comp.const_mul (2:ℂ)).hasDerivWithinAt using 1
+      simp
+    exact (((hd t ht).sub_const z).const_mul z).sub hl
+  have heb (t : ℝ) (ht : t ∈ Ico 0 T) :
+      ‖z*(2/(q t-(u t : ℂ)))-2‖ ≤ 4*(M+T)/‖z‖ := by
+    have ht' := Ico_subset_Icc_self ht
+    have hden := hcenter t ht'
+    have hdenpos : 0 < ‖q t-(u t : ℂ)‖ := (half_pos hr).trans_le hden
+    have hne : q t-(u t : ℂ) ≠ 0 := norm_pos_iff.mp hdenpos
+    have hdispt : ‖q t-z‖ ≤ T := by
+      have hm := mul_le_mul_of_nonneg_right hfac ht.1
+      exact (hdisp t ht').trans (hm.trans (by simpa using ht'.2))
+    have hnum : ‖z-q t+(u t : ℂ)‖ ≤ M+T := by
+      have hh := norm_add_le (z-q t) (u t : ℂ)
+      rw [norm_sub_rev z (q t),Complex.norm_real,Real.norm_eq_abs] at hh
+      linarith [hu t ht']
+    have heq : z*(2/(q t-(u t : ℂ)))-2 =
+        2*(z-q t+(u t : ℂ))/(q t-(u t : ℂ)) := by
+      field_simp [hne]
+      ring
+    rw [heq,norm_div,norm_mul]
+    norm_num only [norm_ofNat]
+    calc
+      2*‖z-q t+(u t : ℂ)‖/‖q t-(u t : ℂ)‖
+          ≤ 2*(M+T)/‖q t-(u t : ℂ)‖ := by gcongr
+      _ ≤ 2*(M+T)/(‖z‖/2) :=
+        div_le_div_of_nonneg_left (by positivity) (half_pos hr) hden
+      _ = 4*(M+T)/‖z‖ := by ring
+  have hh := norm_image_sub_le_of_norm_deriv_right_le_segment hec hed heb T ⟨hT,le_rfl⟩
+  have he0 : e 0=0 := by simp [e,hq0]
+  rw [he0,sub_zero,sub_zero] at hh
+  exact hh.trans_eq (by ring)
+
+end SLEExactGauge
+
+end
+
+end OAI
diff --git a/lean/OAI/Probability/SLE/Loewner/ForwardHeightSquareIncrement.lean b/lean/OAI/Probability/SLE/Loewner/ForwardHeightSquareIncrement.lean
new file mode 100644
index 0000000000000000000000000000000000000000..2be6838383aafa7198c39812d90271b6cda26487
--- /dev/null
+++ b/lean/OAI/Probability/SLE/Loewner/ForwardHeightSquareIncrement.lean
@@ -0,0 +1,55 @@
+import OAI.Probability.SLE.Loewner.CapacityPointwiseLoewner
+import OAI.Probability.SLE.Geometry.EndpointMonotonicity
+
+namespace OAI
+
+/-! The squared height can decrease by at most twice elapsed capacity.
+The proof uses pointwise right derivatives and includes both endpoints. -/
+noncomputable section
+open Set Filter Function Complex
+open scoped Topology
+
+namespace SLEExactGauge
+
+lemma height_kernel_square_bound (z : ℂ) (u : ℝ) :
+    2*z.im^2/Complex.normSq (z-(u:ℂ))-2≤0 := by
+  have hsq : z.im^2≤Complex.normSq (z-(u:ℂ)) := by
+    simp only [Complex.normSq_apply,sub_im,ofReal_im,sub_zero]
+    nlinarith [sq_nonneg (z-(u:ℂ)).re]
+  by_cases hn : Complex.normSq (z-(u:ℂ))=0
+  · simp only [hn,div_zero,zero_sub]
+    norm_num
+  · have hpos := lt_of_le_of_ne (Complex.normSq_nonneg (z-(u:ℂ))) (Ne.symm hn)
+    have hb : 2*z.im^2/Complex.normSq (z-(u:ℂ))≤2 :=
+      (div_le_iff₀ hpos).mpr (by nlinarith)
+    linarith
+
+theorem height_square_increment {f : ℝ → ℂ} {u : ℝ → ℝ} {a b : ℝ}
+    (hab : a≤b) (hf : ContinuousOn f (Icc a b))
+    (hd : ∀ c∈Ico a b, HasDerivWithinAt f (1/(f c-(u c:ℂ))) (Ici c) c) :
+    (f a).im^2≤(f b).im^2+2*(b-a) := by
+  let g (c : ℝ) := -(f c).im^2-2*c
+  let v (c : ℝ) := 2*(f c).im^2/Complex.normSq (f c-(u c:ℂ))-2
+  have hg : ContinuousOn g (Icc a b) :=
+    ((Complex.continuous_im.comp_continuousOn hf).pow 2).neg.sub
+      (continuousOn_const.mul continuousOn_id)
+  have hgd (c : ℝ) (hc : c∈Ico a b) : HasDerivWithinAt g (v c) (Ici c) c := by
+    have hi := Complex.imCLM.hasFDerivAt.comp_hasDerivWithinAt c (hd c hc)
+    change HasDerivWithinAt (fun x => (f x).im) (1/(f c-(u c:ℂ))).im (Ici c) c at hi
+    have hh := (hi.pow 2).neg.sub ((hasDerivWithinAt_id c (Ici c)).const_mul 2)
+    convert! hh using 1
+    dsimp only [v]
+    simp only [Complex.div_im,one_im,one_re,zero_mul,one_mul,sub_im,ofReal_im,sub_zero]
+    ring
+  have hb := image_le_of_deriv_right_le_deriv_boundary hg hgd
+    (B := fun _ => g a) (B' := fun _ => 0) le_rfl continuousOn_const
+    (fun c _ => hasDerivWithinAt_const c (Ici c) (g a))
+    (fun c _ => height_kernel_square_bound (f c) (u c)) (show b∈Icc a b from ⟨hab,le_rfl⟩)
+  dsimp only [g] at hb
+  linarith
+
+end SLEExactGauge
+
+end
+
+end OAI
diff --git a/lean/OAI/Probability/SLE/Loewner/ForwardInfinityBounds.lean b/lean/OAI/Probability/SLE/Loewner/ForwardInfinityBounds.lean
new file mode 100644
index 0000000000000000000000000000000000000000..2014c9273d276b61936fe5e79bfe1f0eebbc410e
--- /dev/null
+++ b/lean/OAI/Probability/SLE/Loewner/ForwardInfinityBounds.lean
@@ -0,0 +1,79 @@
+import Mathlib
+
+namespace OAI
+
+/-! Uniform bounds for forward Loewner trajectories far from the origin.
+Only the bounded driver on the fixed time interval is used. -/
+noncomputable section
+open Set Filter Complex
+open scoped Topology
+
+namespace SLEExactGauge
+
+lemma forward_far_center_lower {q z : ℂ} {u M A r : ℝ}
+    (hr : r=‖z‖) (hu : |u| ≤ M) (hq : ‖q-z‖ ≤ A)
+    (hsize : 2*(M+A) ≤ r) : r/2 ≤ ‖q-(u : ℂ)‖ := by
+  have h1 := norm_le_norm_sub_add z q
+  have h2 := norm_le_norm_sub_add q (u : ℂ)
+  rw [norm_sub_rev z q] at h1
+  rw [Complex.norm_real,Real.norm_eq_abs] at h2
+  linarith
+
+theorem forward_far_displacement {T M : ℝ} (hT : 0 ≤ T) (hM : 0 ≤ M)
+    (q : ℝ → ℂ) (u : ℝ → ℝ) (z : ℂ)
+    (hc : ContinuousOn q (Icc 0 T)) (hq0 : q 0=z)
+    (hd : ∀ t ∈ Ico 0 T, HasDerivWithinAt q
+      (2/(q t-(u t : ℂ))) (Ici t) t)
+    (hu : ∀ t ∈ Icc 0 T, |u t| ≤ M)
+    (hlarge : 8*(M+T+1) ≤ ‖z‖) :
+    (∀ t ∈ Icc 0 T, ‖q t-z‖ ≤ (4/‖z‖)*t) ∧
+      ∀ t ∈ Icc 0 T, ‖z‖/2 ≤ ‖q t-(u t : ℂ)‖ := by
+  let r : ℝ := ‖z‖
+  have hr : 0 < r := by dsimp [r]; nlinarith
+  have hr8 : 8 ≤ r := by dsimp [r]; nlinarith
+  have hfac : 8/r ≤ 1 := (div_le_one hr).mpr hr8
+  have hbnd (t : ℝ) (ht : t ∈ Icc 0 T) : 1+(8/r)*t ≤ 1+T := by
+    have hh := mul_le_mul_of_nonneg_right hfac ht.1
+    nlinarith [ht.2]
+  have hsize : 2*(M+(1+T)) ≤ r := by dsimp [r]; nlinarith
+  have hrough : ∀ t ∈ Icc 0 T, ‖q t-z‖ ≤ 1+(8/r)*t := by
+    apply image_norm_le_of_norm_deriv_right_lt_deriv_boundary
+      (hc.sub continuousOn_const) (fun t ht => (hd t ht).sub_const z)
+      (B := fun t => 1+(8/r)*t) (B' := fun _ => 8/r)
+    · simp [hq0]
+    · intro t
+      convert! ((hasDerivAt_id t).const_mul (8/r)).const_add 1 using 1
+      simp
+    · intro t ht he
+      have hcenter := forward_far_center_lower (q := q t) (z := z)
+        (u := u t) (M := M) (A := 1+T) rfl (hu t (Ico_subset_Icc_self ht))
+        (he.le.trans (hbnd t (Ico_subset_Icc_self ht))) hsize
+      have hnorm : ‖2/(q t-(u t : ℂ))‖ ≤ 4/r := by
+        rw [norm_div]
+        norm_num only [norm_ofNat]
+        have hh := div_le_div_of_nonneg_left (by norm_num : (0:ℝ) ≤ 2)
+          (half_pos hr) hcenter
+        convert! hh using 1
+        field_simp
+        ring
+      exact hnorm.trans_lt (div_lt_div_of_pos_right (by norm_num) hr)
+  have hcenter (t : ℝ) (ht : t ∈ Icc 0 T) : r/2 ≤ ‖q t-(u t : ℂ)‖ :=
+    forward_far_center_lower rfl (hu t ht) ((hrough t ht).trans (hbnd t ht)) hsize
+  refine ⟨?_,hcenter⟩
+  have hderiv (t : ℝ) (ht : t ∈ Ico 0 T) : ‖2/(q t-(u t : ℂ))‖ ≤ 4/r := by
+    rw [norm_div]
+    norm_num only [norm_ofNat]
+    have hh := div_le_div_of_nonneg_left (by norm_num : (0:ℝ) ≤ 2)
+      (half_pos hr) (hcenter t (Ico_subset_Icc_self ht))
+    convert! hh using 1
+    field_simp
+    ring
+  intro t ht
+  simpa only [hq0,sub_zero] using
+    norm_image_sub_le_of_norm_deriv_right_le_segment hc hd hderiv t ht
+
+end SLEExactGauge
+
+end
+
+end OAI
diff --git a/lean/OAI/Probability/SLE/Loewner/FreshCapacityWitness.lean b/lean/OAI/Probability/SLE/Loewner/FreshCapacityWitness.lean
new file mode 100644
index 0000000000000000000000000000000000000000..83eb5c5c05b63e0f47e3c3716789282901e424c2
--- /dev/null
+++ b/lean/OAI/Probability/SLE/Loewner/FreshCapacityWitness.lean
@@ -0,0 +1,48 @@
+import OAI.Probability.SLE.Geometry.CanonicalRestartWitness
+
+namespace OAI
+
+/-! The published trace-generation input is used only on the single
+continuous Brownian path law. Strong Markov supplies the fresh witness. -/
+
+noncomputable section
+open Set Filter MeasureTheory ProbabilityTheory Classical
+open scoped NNReal ENNReal Topology
+
+namespace SLEExactGauge
+
+local instance : MeasurableSpace C(ℝ≥0,ℝ) := borel _
+local instance : BorelSpace C(ℝ≥0,ℝ) := ⟨rfl⟩
+
+theorem fresh_capacity_witness_exists
+    {Ω : Type*} [MeasurableSpace Ω] {P : Measure Ω} [IsProbabilityMeasure P]
+    {κ : ℝ} {B : ℝ≥0 → Ω → ℝ} (hB : IsBrownianReal B P)
+    (hm : ∀ t, Measurable (B t)) (hc : ∀ ω, Continuous (fun t => B t ω))
+    (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))) :
+    ∀ᵐ ω ∂P, ∃ (β : ℝ≥0 → ℂ) (G' F' : ℝ≥0 → ℂ → ℂ),
+      IsCapacityTwoWitness (fun t => Real.sqrt κ*B (τ ω+t) ω-Real.sqrt κ*B (τ ω) ω)
+        β G' F' := by
+  obtain ⟨Φ,Gc,Fc,_,hW⟩ := exists_measurable_canonical_witness _ κ hpublished
+  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
+  filter_upwards [canonical_witness_pullback hW _ hY hLaw] with ω hω
+  refine ⟨Φ (sourceRestartDriverPath B hc τ ω),Gc (sourceRestartDriverPath B hc τ ω),
+    Fc (sourceRestartDriverPath B hc τ ω),?_⟩
+  convert hω using 1
+  funext t
+  change Real.sqrt κ*B (τ ω+t) ω-Real.sqrt κ*B (τ ω) ω =
+    Real.sqrt κ*(B (τ ω+t) ω-B (τ ω) ω)
+  ring
+
+end SLEExactGauge
+
+end
+
+end OAI
diff --git a/lean/OAI/Probability/SLE/Loewner/FreshTipMapOut.lean b/lean/OAI/Probability/SLE/Loewner/FreshTipMapOut.lean
new file mode 100644
index 0000000000000000000000000000000000000000..79eba7b6696c82d19f6d2f4a167c264f5cf78724
--- /dev/null
+++ b/lean/OAI/Probability/SLE/Loewner/FreshTipMapOut.lean
@@ -0,0 +1,139 @@
+import OAI.Probability.SLE.PhysicalTransport
+import OAI.Probability.SLE.Gauge.RibbonSurvival
+
+namespace OAI
+
+/-! Mapping the actual geometric continuation into the restarted half-plane.
+At a first height crossing the tip is fresh. The fresh-tip chart limit then maps a simple access path continuously to a simple path
+starting at the restarted driving point. -/
+
+noncomputable section
+open Set Filter MeasureTheory Metric
+open scoped Topology NNReal unitInterval
+
+namespace SLEExactGauge
+
+theorem tip_survives_prior_of_strict_height
+    (γ : ℝ≥0 → ℂ) (T : ℝ≥0) (hheight : 0 < (γ T).im)
+    (hfirst : ∀ u : ℝ≥0, u < T → (γ u).im < (γ T).im) :
+    ∀ s : ℝ≥0, s < T → γ T ∈ survivingDomain γ s := by
+  intro s hs
+  have hfree : range (upwardRay (γ T)) ⊆ upperHalfPlane \ (γ '' Icc 0 s) := by
+    rintro z ⟨u, rfl⟩
+    have him : (upwardRay (γ T) u).im = (γ T).im + (u : ℝ) := by simp [upwardRay]
+    refine ⟨by change 0 < (upwardRay (γ T) u).im; rw [him]; positivity, ?_⟩
+    rintro ⟨v, hv, he⟩
+    have hh := hfirst v (hv.2.trans_lt hs)
+    have he' := congrArg Complex.im he
+    rw [him] at he'
+    linarith [u.coe_nonneg]
+  have hh := survives_of_unbounded_free_curve γ s (upwardRay (γ T))
+    (upwardRay_continuous _) hfree (upwardRay_unbounded _) (mem_range_self 0)
+  simpa only [upwardRay, NNReal.coe_zero, Complex.ofReal_zero, zero_mul, add_zero] using hh
+
+/-- Extend the map only at the accessible tip. This is sufficient to map
+the entire simple continuation Path, and does not require a boundary
+extension of the forward conformal map at other hull points. -/
+theorem map_out_simple_access_path
+    (D : Set ℂ) (_hD : IsOpen D) (g : ℂ → ℂ)
+    (hg : ContinuousOn g D) (hgi : InjOn g D) (hgH : MapsTo g D upperHalfPlane)
+    (ζ w : ℂ) (u : ℝ) (hζ : ζ ∉ D)
+    (hlim : Tendsto g (𝓝[D] ζ) (𝓝 (u : ℂ)))
+    (p : Path ζ w) (hp : Function.Injective p)
+    (hpD : ∀ t, t ≠ 0 → p t ∈ D) :
+    ∃ q : Path (0 : ℂ) (g w - (u : ℂ)), Function.Injective q ∧
+      (∀ t, t ≠ 0 → q t ∈ upperHalfPlane) ∧
+      (∀ t, t ≠ 0 → q t = g (p t) - (u : ℂ)) := by
+  classical
+  let gb := Function.update g ζ (u : ℂ)
+  have hs : insert ζ D \ {ζ} = 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 => hζ (he ▸ hz)⟩
+  have hgb : ContinuousOn gb (insert ζ D) := by
+    rw [continuousOn_update_iff, hs]
+    exact ⟨hg, fun _ => hlim⟩
+  have hpS : range p ⊆ insert ζ D := by
+    rintro z ⟨t, rfl⟩
+    by_cases ht : t = 0
+    · simpa only [ht, p.source] using mem_insert ζ D
+    · exact mem_insert_of_mem ζ (hpD t ht)
+  have hne (t : unitInterval) (ht : t ≠ 0) : p t ≠ ζ :=
+    fun he => hζ (he ▸ hpD t ht)
+  have heval (t : unitInterval) (ht : t ≠ 0) : gb (p t) = g (p t) :=
+    Function.update_of_ne (hne t ht) _ _
+  have hw : gb w = g w := by
+    simpa only [p.target] using heval 1 one_ne_zero
+  let q : Path (0 : ℂ) (g w - (u : ℂ)) := {
+    toFun := fun t => gb (p t) - (u : ℂ)
+    continuous_toFun := ((hgb.mono hpS).comp_continuous p.continuous
+      (fun t => mem_range_self t)).sub continuous_const
+    source' := by simp [gb]
+    target' := by simp only [p.target, hw] }
+  have hqH (t : unitInterval) (ht : t ≠ 0) : q t ∈ upperHalfPlane := by
+    change 0 < (gb (p t) - (u : ℂ)).im
+    rw [heval t ht]
+    simpa only [upperHalfPlane, mem_ofPred_eq, Complex.sub_im, Complex.ofReal_im,
+      sub_zero] using hgH (hpD t ht)
+  refine ⟨q, ?_, hqH, fun t ht => by change gb (p t) - _ = _; rw [heval t ht]⟩
+  intro s t he
+  by_cases hs0 : s = 0
+  · subst s
+    by_contra ht0
+    have hh := hqH t (Ne.symm ht0)
+    rw [← he, q.source] at hh
+    simp only [upperHalfPlane, mem_ofPred_eq, Complex.zero_im, lt_self_iff_false] at hh
+  by_cases ht0 : t = 0
+  · subst t
+    have hh := hqH s hs0
+    rw [he, q.source] at hh
+    simp only [upperHalfPlane, mem_ofPred_eq, Complex.zero_im, lt_self_iff_false] at hh
+  apply hp
+  apply hgi (hpD s hs0) (hpD t ht0)
+  have he' : gb (p s) - (u : ℂ) = gb (p t) - (u : ℂ) := he
+  rw [heval s hs0, heval t ht0] at he'
+  exact sub_left_injective he'
+
+/-- Actual capacity charts at a first height crossing map the physical
+simple continuation to a supported simple path in the restarted half-plane,
+with the conformal map-back identity at every positive path time. -/
+theorem IsCapacityTwoWitness.map_out_access_at_first_height
+    {U : ℝ≥0 → ℝ} {γ : ℝ≥0 → ℂ} {G F : ℝ≥0 → ℂ → ℂ}
+    (hw : IsCapacityTwoWitness U γ G F) (hU : Continuous U)
+    (T : ℝ≥0) (hT : 0 < T) (hheight : 0 < (γ T).im)
+    (hfirst : ∀ u : ℝ≥0, u < T → (γ u).im < (γ T).im)
+    (w : ℂ) (p : Path (γ T) w) (hp : Function.Injective p)
+    (hpD : ∀ t, t ≠ 0 → p t ∈ survivingDomain γ T) :
+    ∃ q : Path (0 : ℂ) (G T w - (U T : ℂ)), Function.Injective q ∧
+      (∀ t, t ≠ 0 → q t ∈ upperHalfPlane) ∧
+      (∀ t, t ≠ 0 → F T (q t + (U T : ℂ)) = p t) := by
+  have hgi : InjOn (G T) (survivingDomain γ T) := by
+    intro z hz v hv 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 v) := congrArg (F T) he
+      _ = v := hw.2.2.2.2.2.2.2.1 T v hv
+  have htip : γ T ∉ survivingDomain γ T := by
+    intro hh
+    exact hh.1.2 (mem_image_of_mem γ ⟨zero_le, le_rfl⟩)
+  obtain ⟨q, hq, hqH, hqeq⟩ := map_out_simple_access_path
+    (survivingDomain γ T) (isOpen_survivingDomain hw.1 T) (G T)
+    (hw.2.2.2.1 T).continuousOn hgi (hw.2.2.2.2.2.1 T)
+    (γ T) w (U T) htip
+    (hw.fresh_tip_chart_tendsto hU hT
+      (tip_survives_prior_of_strict_height γ T hheight hfirst)) p hp hpD
+  refine ⟨q, hq, hqH, ?_⟩
+  intro t ht
+  rw [hqeq t ht, sub_add_cancel]
+  exact hw.2.2.2.2.2.2.2.1 T (p t) (hpD t ht)
+
+end SLEExactGauge
+
+end
+
+end OAI
diff --git a/lean/OAI/Probability/SLE/Loewner/FutureArcThinCrossing.lean b/lean/OAI/Probability/SLE/Loewner/FutureArcThinCrossing.lean
new file mode 100644
index 0000000000000000000000000000000000000000..6086d886a39d2244e9e88945417e8250c6984646
--- /dev/null
+++ b/lean/OAI/Probability/SLE/Loewner/FutureArcThinCrossing.lean
@@ -0,0 +1,66 @@
+import OAI.Probability.SLE.Loewner.InverseThinCollapse
+import OAI.Probability.SLE.Loewner.FutureSlitHeight
+import OAI.Probability.SLE.Loewner.MappedFutureRange
+
+namespace OAI
+
+/-! A real crossing of the actual mapped future supplies the small
+inverse values required by the Dirichlet-energy criterion. -/
+noncomputable section
+open Set Filter Function Complex Metric MeasureTheory
+open scoped Topology
+
+namespace SLEExactGauge
+
+theorem mappedFutureArc_thin_crossing (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) {x ε : ℝ} (c : ℂ)
+    (hx : x∈Ioo (initialDrivingValue p hi h0 hH s (hst.trans ht))
+        (initialForwardChart p hi h0 hH s (p t)).re ∨
+      x∈Ioo (initialForwardChart p hi h0 hH s (p t)).re
+        (initialDrivingValue p hi h0 hH s (hst.trans ht)))
+    (hp : ∀ v∈Ioc s t, ‖p v-c‖≤ε) :
+    ∃ y∈Ioc 0 (Real.sqrt (2*(initialCapacity p hi h0 hH t-initialCapacity p hi h0 hH s))),
+      ‖initialInverseChart p hi h0 hH s ((x:ℂ)+(y:ℂ)*I)-c‖≤ε := by
+  let q := mappedFutureArc p hi h0 hH hst ht
+  have hq0 : (q 0).re=initialDrivingValue p hi h0 hH s (hst.trans ht) := by
+    simp [q]
+  have hq1 : q 1=initialForwardChart p hi h0 hH s (p t) := by
+    rw [mappedFutureArc_segment p hi h0 hH hst ht one_ne_zero,slitSegmentParameter_one]
+  have hcont : ContinuousOn (fun u => (q u).re) (Icc (0:unitInterval) 1) :=
+    (Complex.continuous_re.comp q.continuous).continuousOn
+  have hex : ∃ u∈Icc (0:unitInterval) 1, (q u).re=x := by
+    rcases hx with hx | hx
+    · apply intermediate_value_Icc (show (0:unitInterval)≤1 from zero_le_one) hcont
+      simpa only [hq0,hq1] using ⟨hx.1.le,hx.2.le⟩
+    · apply intermediate_value_Icc' (show (0:unitInterval)≤1 from zero_le_one) hcont
+      simpa only [hq0,hq1] using ⟨hx.1.le,hx.2.le⟩
+  obtain ⟨u,_,hux⟩ := hex
+  have hu : u≠0 := by
+    intro he
+    subst u
+    rw [hq0] at hux
+    rcases hx with hx | hx <;> linarith [hx.1,hx.2]
+  have hpos : 0<(q u).im := mappedFutureArc_upper p hi h0 hH hst ht hu
+  have him : (centeredFutureArc p hi h0 hH hst ht u).im=(q u).im := by
+    change (q u-(_ : ℂ)).im=(q u).im
+    simp only [sub_im,ofReal_im,sub_zero]
+  have hsq := centeredFutureArc_height_sq_le p hi h0 hH hst ht u
+  rw [him] at hsq
+  have hcap : 0≤2*(initialCapacity p hi h0 hH t-initialCapacity p hi h0 hH s) :=
+    mul_nonneg (by norm_num) (sub_nonneg.mpr (initialCapacity_monotone p hi h0 hH hst.le))
+  have hheight : (q u).im≤Real.sqrt (2*(initialCapacity p hi h0 hH t-initialCapacity p hi h0 hH s)) :=
+    (Real.le_sqrt hpos.le hcap).mpr hsq
+  have hcoord : (x:ℂ)+((q u).im:ℂ)*I=q u := by
+    apply Complex.ext <;> simp [hux]
+  refine ⟨(q u).im,⟨hpos,hheight⟩,?_⟩
+  rw [hcoord,mappedFutureArc_segment p hi h0 hH hst ht hu,
+    initialInverse_forward_at p hi h0 hH s
+      (point_after_prefix_mem_domain p hi hH (slitSegmentParameter_gt hst hu))]
+  exact hp _ ⟨slitSegmentParameter_gt hst hu,slitSegmentParameter_le s t hst.le u⟩
+
+end SLEExactGauge
+
+end
+
+end OAI
diff --git a/lean/OAI/Probability/SLE/Loewner/FutureCapacityAdditive.lean b/lean/OAI/Probability/SLE/Loewner/FutureCapacityAdditive.lean
new file mode 100644
index 0000000000000000000000000000000000000000..ae5dcdef0232bbdc5747d1fe77cd00959b058a00
--- /dev/null
+++ b/lean/OAI/Probability/SLE/Loewner/FutureCapacityAdditive.lean
@@ -0,0 +1,86 @@
+import OAI.Probability.SLE.Loewner.FutureComposedCharts
+import OAI.Probability.SLE.Loewner.ShiftedHydrodynamicComposition
+import OAI.Probability.SLE.Loewner.SlitChartUniqueness
+
+namespace OAI
+
+/-! Removing an initial slit and its exact mapped future adds the two
+hydrodynamic capacities. The composed chart is the later normalized
+chart, including when the initial time is zero. -/
+noncomputable section
+open Set Filter Function Complex
+open scoped Topology
+
+namespace SLEExactGauge
+
+variable (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)
+
+noncomputable def composedFutureSlitChart : SimpleSlitChart (initialSubarc p t) := by
+  have h := future_composed_chart_properties p hi h0 hH hst ht
+  have hG := h.1
+  have hF := h.2.1
+  have hGm := h.2.2.1
+  have hFm := h.2.2.2.1
+  have hl := h.2.2.2.2.1
+  have hr := h.2.2.2.2.2
+  let Q := futureSlitChart p hi h0 hH hst ht
+  let U := initialDrivingValue p hi h0 hH s (hst.trans ht)
+  refine ⟨futureComposedForward p hi h0 hH hst ht,
+    futureComposedInverse p hi h0 hH hst ht,initialCapacity p hi h0 hH s+Q.capacity,
+    add_pos_of_nonneg_of_pos (initialCapacity_nonneg p hi h0 hH s) Q.capacity_pos,
+    ?_,hG,hF,hFm,hl,hr,?_,?_,?_⟩
+  · refine ⟨hGm,?_,?_⟩
+    · intro z hz w hw he
+      have hh := congrArg (futureComposedInverse p hi h0 hH hst ht) he
+      simpa only [hl z hz,hl w hw] using hh
+    · intro w hw
+      exact ⟨_,hFm hw,hr w hw⟩
+  · simpa only [futureComposedForward,ofReal_add] using
+      shifted_hydrodynamic_coefficient U (initialForwardChart_coefficient p hi h0 hH s) Q.coefficient
+  · exact shifted_inverse_normalized U (initialInverseChart_normalized p hi h0 hH s)
+      Q.inverse_normalized (fun _ hz => (Q.inverse_mapsTo hz).1)
+  · intro z hz
+    have hsub : z∈upperHalfPlane \ range (initialSubarc p s) :=
+      ⟨hz.1,fun he => hz.2 (initialSubarc_range_mono p hst.le he)⟩
+    have hd := (initialForward_centered_bijOn p hi h0 hH hst ht).mapsTo hz
+    have hh := Q.height_le _ hd
+    change (Q.forward (initialForwardChart p hi h0 hH s z-(U:ℂ))).im≤
+      (initialForwardChart p hi h0 hH s z-(U:ℂ)).im at hh
+    simp only [sub_im,ofReal_im,sub_zero] at hh
+    change ((U:ℂ)+Q.forward (initialForwardChart p hi h0 hH s z-(U:ℂ))).im≤z.im
+    simpa only [add_im,ofReal_im,zero_add] using
+      hh.trans (initialForwardChart_height_le p hi h0 hH s hsub)
+
+theorem futureSlitChart_capacity_eq :
+    (futureSlitChart p hi h0 hH hst ht).capacity=
+      initialCapacity p hi h0 hH t-initialCapacity p hi h0 hH s := by
+  have ht0 : t≠0 := ne_of_gt (lt_of_le_of_lt bot_le hst)
+  have hh := ((composedFutureSlitChart p hi h0 hH hst ht).unique_on_domain
+    (initialSlitChart p hi h0 hH t ht0)).2.2
+  change initialCapacity p hi h0 hH s+(futureSlitChart p hi h0 hH hst ht).capacity=
+    (initialSlitChart p hi h0 hH t ht0).capacity at hh
+  rw [initialCapacity,dite_eq_right ht0]
+  linarith
+
+theorem futureComposedForward_eq {z : ℂ}
+    (hz : z∈upperHalfPlane \ range (initialSubarc p t)) :
+    futureComposedForward p hi h0 hH hst ht z=initialForwardChart p hi h0 hH t z := by
+  have ht0 : t≠0 := ne_of_gt (lt_of_le_of_lt bot_le hst)
+  have hh := ((composedFutureSlitChart p hi h0 hH hst ht).unique_on_domain
+    (initialSlitChart p hi h0 hH t ht0)).1 hz
+  simpa only [composedFutureSlitChart,initialForwardChart,dite_eq_right ht0] using hh
+
+theorem futureComposedInverse_eq {z : ℂ} (hz : z∈upperHalfPlane) :
+    futureComposedInverse p hi h0 hH hst ht z=initialInverseChart p hi h0 hH t z := by
+  have ht0 : t≠0 := ne_of_gt (lt_of_le_of_lt bot_le hst)
+  have hh := ((composedFutureSlitChart p hi h0 hH hst ht).unique_on_domain
+    (initialSlitChart p hi h0 hH t ht0)).2.1 hz
+  simpa only [composedFutureSlitChart,initialInverseChart,dite_eq_right ht0] using hh
+
+end SLEExactGauge
+
+end
+
+end OAI
diff --git a/lean/OAI/Probability/SLE/Loewner/FutureComposedCharts.lean b/lean/OAI/Probability/SLE/Loewner/FutureComposedCharts.lean
new file mode 100644
index 0000000000000000000000000000000000000000..49d33647bf7a8b12f074568c9d9d935144ec3b40
--- /dev/null
+++ b/lean/OAI/Probability/SLE/Loewner/FutureComposedCharts.lean
@@ -0,0 +1,94 @@
+import OAI.Probability.SLE.Loewner.FutureSlitDomain
+import OAI.Probability.SLE.Loewner.InitialChartNormalization
+
+namespace OAI
+
+/-! Forward and inverse charts obtained by removing a future segment
+after an initial slit. The real translation keeps their normalization. -/
+noncomputable section
+open Set Filter Function Complex
+open scoped Topology
+
+namespace SLEExactGauge
+
+variable (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)
+
+noncomputable def futureComposedForward (z : ℂ) : ℂ :=
+  (initialDrivingValue p hi h0 hH s (hst.trans ht):ℂ)+
+    (futureSlitChart p hi h0 hH hst ht).forward
+      (initialForwardChart p hi h0 hH s z-
+        (initialDrivingValue p hi h0 hH s (hst.trans ht):ℂ))
+
+noncomputable def futureComposedInverse (z : ℂ) : ℂ :=
+  initialInverseChart p hi h0 hH s
+    ((initialDrivingValue p hi h0 hH s (hst.trans ht):ℂ)+
+      (futureSlitChart p hi h0 hH hst ht).inverse
+        (z-(initialDrivingValue p hi h0 hH s (hst.trans ht):ℂ)))
+
+theorem future_composed_chart_properties :
+    DifferentiableOn ℂ (futureComposedForward p hi h0 hH hst ht)
+      (upperHalfPlane \ range (initialSubarc p t)) ∧
+    DifferentiableOn ℂ (futureComposedInverse p hi h0 hH hst ht) upperHalfPlane ∧
+    MapsTo (futureComposedForward p hi h0 hH hst ht)
+      (upperHalfPlane \ range (initialSubarc p t)) upperHalfPlane ∧
+    MapsTo (futureComposedInverse p hi h0 hH hst ht)
+      upperHalfPlane (upperHalfPlane \ range (initialSubarc p t)) ∧
+    (∀ z∈upperHalfPlane \ range (initialSubarc p t),
+      futureComposedInverse p hi h0 hH hst ht (futureComposedForward p hi h0 hH hst ht z)=z) ∧
+    ∀ z∈upperHalfPlane,
+      futureComposedForward p hi h0 hH hst ht (futureComposedInverse p hi h0 hH hst ht z)=z := by
+  let U : ℝ := initialDrivingValue p hi h0 hH s (hst.trans ht)
+  let Q := futureSlitChart p hi h0 hH hst ht
+  have hshift : MapsTo (fun z : ℂ => z-(U:ℂ)) upperHalfPlane upperHalfPlane := by
+    intro z hz
+    change 0<(z-(U:ℂ)).im
+    simpa only [sub_im,ofReal_im,sub_zero] using (show 0<z.im from hz)
+  have hadd : MapsTo (fun z : ℂ => (U:ℂ)+z) upperHalfPlane upperHalfPlane := by
+    intro z hz
+    change 0<((U:ℂ)+z).im
+    simpa only [add_im,ofReal_im,zero_add] using (show 0<z.im from hz)
+  have hsub : upperHalfPlane \ range (initialSubarc p t) ⊆
+      upperHalfPlane \ range (initialSubarc p s) := by
+    intro z hz
+    exact ⟨hz.1,fun he => hz.2 (initialSubarc_range_mono p hst.le he)⟩
+  have hA := initialForward_centered_bijOn p hi h0 hH hst ht
+  have hJH : MapsTo Q.inverse upperHalfPlane upperHalfPlane :=
+    fun _ hz => (Q.inverse_mapsTo hz).1
+  have hinner : MapsTo (fun z : ℂ => (U:ℂ)+Q.inverse (z-(U:ℂ)))
+      upperHalfPlane upperHalfPlane := hadd.comp (hJH.comp hshift)
+  have hFin : MapsTo (futureComposedInverse p hi h0 hH hst ht)
+      upperHalfPlane (upperHalfPlane \ range (initialSubarc p t)) := by
+    intro z hz
+    have hb := initialInverseChart_mem_domain p hi h0 hH s (hinner hz)
+    apply (initialForward_centered_mem_domain_iff p hi h0 hH hst ht hb).mp
+    change initialForwardChart p hi h0 hH s
+      (initialInverseChart p hi h0 hH s ((U:ℂ)+Q.inverse (z-(U:ℂ))))-(U:ℂ)∈
+        upperHalfPlane \ range (centeredFutureArc p hi h0 hH hst ht)
+    rw [initialForward_inverse p hi h0 hH s (hinner hz),add_sub_cancel_left]
+    exact Q.inverse_mapsTo (hshift hz)
+  refine ⟨?_,?_,?_,hFin,?_,?_⟩
+  · apply DifferentiableOn.const_add
+    exact Q.forward_differentiable.comp
+      (((initialForwardChart_differentiableOn_current p hi h0 hH s).mono hsub).sub_const _) hA.mapsTo
+  · exact (initialInverseChart_differentiableOn p hi h0 hH s).comp
+      ((Q.inverse_differentiable.comp (differentiableOn_id.sub_const _) hshift).const_add _) hinner
+  · intro z hz
+    exact hadd (Q.bijOn.mapsTo (hA.mapsTo hz))
+  · intro z hz
+    change initialInverseChart p hi h0 hH s ((U:ℂ)+Q.inverse
+      (((U:ℂ)+Q.forward (initialForwardChart p hi h0 hH s z-(U:ℂ)))-(U:ℂ)))=z
+    rw [add_sub_cancel_left,Q.left_inverse _ (hA.mapsTo hz),add_sub_cancel,
+      initialInverse_forward_at p hi h0 hH s (hsub hz)]
+  · intro z hz
+    change (U:ℂ)+Q.forward (initialForwardChart p hi h0 hH s
+      (initialInverseChart p hi h0 hH s ((U:ℂ)+Q.inverse (z-(U:ℂ))))-(U:ℂ))=z
+    rw [initialForward_inverse p hi h0 hH s (hinner hz),add_sub_cancel_left,
+      Q.right_inverse _ (hshift hz),add_sub_cancel]
+
+end SLEExactGauge
+
+end
+
+end OAI
diff --git a/lean/OAI/Probability/SLE/Loewner/FutureSlitDomain.lean b/lean/OAI/Probability/SLE/Loewner/FutureSlitDomain.lean
new file mode 100644
index 0000000000000000000000000000000000000000..b7795112cbd15b0779b6821f34dfaf8844a8f917
--- /dev/null
+++ b/lean/OAI/Probability/SLE/Loewner/FutureSlitDomain.lean
@@ -0,0 +1,94 @@
+import OAI.Probability.SLE.Loewner.MappedFutureRange
+
+namespace OAI
+
+/-! Exact transport of the later slit complement to the centered future
+slit complement. -/
+noncomputable section
+open Set Filter Function Complex
+open scoped Topology
+
+namespace SLEExactGauge
+
+lemma initialInverseChart_mem_domain (p : C(unitInterval,ℂ)) (hi : Injective p)
+    (h0 : p 0=0) (hH : ∀ t : unitInterval, t≠0 → p t∈upperHalfPlane)
+    (s : unitInterval) {w : ℂ} (hw : w∈upperHalfPlane) :
+    initialInverseChart p hi h0 hH s w∈upperHalfPlane \ range (initialSubarc p s) := by
+  by_cases hs : s=0
+  · subst s
+    simp only [initialInverseChart_zero,id_eq]
+    refine ⟨hw,?_⟩
+    rintro ⟨u,hu⟩
+    have hw0 : w=0 := by simpa only [initialSubarc_apply,zero_mul,h0] using hu.symm
+    rw [hw0] at hw
+    exact (lt_irrefl (0:ℝ)) hw
+  · rw [initialInverseChart,dite_eq_right hs]
+    exact (initialSlitChart p hi h0 hH s hs).inverse_mapsTo hw
+
+lemma centeredFutureArc_range_iff (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) (w : ℂ) :
+    w-(initialDrivingValue p hi h0 hH s (hst.trans ht):ℂ)∈
+        range (centeredFutureArc p hi h0 hH hst ht) ↔
+      w∈range (mappedFutureArc p hi h0 hH hst ht) := by
+  constructor
+  · rintro ⟨u,hu⟩
+    exact ⟨u,sub_left_inj.mp hu⟩
+  · rintro ⟨u,hu⟩
+    exact ⟨u,congrArg (fun z : ℂ => z-_) hu⟩
+
+lemma initialForward_centered_mem_domain_iff (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)
+    {z : ℂ} (hz : z∈upperHalfPlane \ range (initialSubarc p s)) :
+    initialForwardChart p hi h0 hH s z-
+        (initialDrivingValue p hi h0 hH s (hst.trans ht):ℂ)∈
+      upperHalfPlane \ range (centeredFutureArc p hi h0 hH hst ht) ↔
+      z∈upperHalfPlane \ range (initialSubarc p t) := by
+  have hw := initialForwardChart_mem_upper p hi h0 hH s hz
+  have hshift : initialForwardChart p hi h0 hH s z-
+      (initialDrivingValue p hi h0 hH s (hst.trans ht):ℂ)∈upperHalfPlane := by
+    change 0<(_-(_ : ℂ)).im
+    change 0<(initialForwardChart p hi h0 hH s z).im at hw
+    simpa only [sub_im,ofReal_im,sub_zero] using hw
+  simp only [Set.mem_sdiff,hshift,hz.1,true_and,
+    centeredFutureArc_range_iff,initialForward_avoids_future_iff p hi h0 hH hst ht hz]
+
+theorem initialForward_centered_bijOn (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) :
+    BijOn (fun z => initialForwardChart p hi h0 hH s z-
+      (initialDrivingValue p hi h0 hH s (hst.trans ht):ℂ))
+      (upperHalfPlane \ range (initialSubarc p t))
+      (upperHalfPlane \ range (centeredFutureArc p hi h0 hH hst ht)) := by
+  have hsub : upperHalfPlane \ range (initialSubarc p t) ⊆
+      upperHalfPlane \ range (initialSubarc p s) := by
+    intro z hz
+    exact ⟨hz.1,fun h => hz.2 (initialSubarc_range_mono p hst.le h)⟩
+  refine ⟨fun z hz => (initialForward_centered_mem_domain_iff p hi h0 hH hst ht
+    (hsub hz)).mpr hz,?_,?_⟩
+  · intro z hz w hw he
+    have hEq := congrArg (initialInverseChart p hi h0 hH s) (sub_left_inj.mp he)
+    simpa only [initialInverse_forward_at p hi h0 hH s (hsub hz),
+      initialInverse_forward_at p hi h0 hH s (hsub hw)] using hEq
+  · intro w hw
+    let U : ℝ := initialDrivingValue p hi h0 hH s (hst.trans ht)
+    have hwH : w+(U:ℂ)∈upperHalfPlane := by
+      change 0<(w+(U:ℂ)).im
+      simpa only [add_im,ofReal_im,add_zero] using (show 0<w.im from hw.1)
+    let z := initialInverseChart p hi h0 hH s (w+(U:ℂ))
+    have hz := initialInverseChart_mem_domain p hi h0 hH s hwH
+    have he : initialForwardChart p hi h0 hH s z-(U:ℂ)=w := by
+      rw [initialForward_inverse p hi h0 hH s hwH,add_sub_cancel_right]
+    refine ⟨z,?_,he⟩
+    apply (initialForward_centered_mem_domain_iff p hi h0 hH hst ht hz).mp
+    change initialForwardChart p hi h0 hH s z-(U:ℂ)∈
+      upperHalfPlane \ range (centeredFutureArc p hi h0 hH hst ht)
+    rw [he]
+    exact hw
+
+end SLEExactGauge
+
+end
+
+end OAI
diff --git a/lean/OAI/Probability/SLE/Loewner/FutureSlitHeight.lean b/lean/OAI/Probability/SLE/Loewner/FutureSlitHeight.lean
new file mode 100644
index 0000000000000000000000000000000000000000..2bbdd657aca0a358d0f53044af464ee8717dbf67
--- /dev/null
+++ b/lean/OAI/Probability/SLE/Loewner/FutureSlitHeight.lean
@@ -0,0 +1,37 @@
+import OAI.Probability.SLE.Loewner.InitialTipHeightBound
+import OAI.Probability.SLE.Loewner.FutureSlitRadius
+
+namespace OAI
+
+/-! Every point of a mapped future segment lies in a strip whose squared
+height is at most twice the exact remaining capacity. -/
+noncomputable section
+open Set Filter Function Complex
+open scoped Topology
+
+namespace SLEExactGauge
+
+theorem centeredFutureArc_height_sq_le (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) :
+    (centeredFutureArc p hi h0 hH hst ht u).im^2≤
+      2*(initialCapacity p hi h0 hH t-initialCapacity p hi h0 hH s) := by
+  by_cases hu : u=0
+  · subst u
+    simp only [centeredFutureArc_zero,zero_im,zero_pow two_ne_zero]
+    exact mul_nonneg (by norm_num) (sub_nonneg.mpr (initialCapacity_monotone p hi h0 hH hst.le))
+  have hv := slitSegmentParameter_le s t hst.le u
+  have hh := initialForward_tip_height_bound p hi h0 hH (slitSegmentParameter_gt hst hu)
+    (hv.trans_lt ht)
+  have he : (centeredFutureArc p hi h0 hH hst ht u).im=
+      (initialForwardChart p hi h0 hH s (p (slitSegmentParameter s t hst.le u))).im := by
+    change (mappedFutureArc p hi h0 hH hst ht u-(_ : ℂ)).im=_
+    rw [sub_im,ofReal_im,sub_zero,mappedFutureArc_segment p hi h0 hH hst ht hu]
+  rw [he]
+  exact hh.trans (by linarith [initialCapacity_monotone p hi h0 hH hv])
+
+end SLEExactGauge
+
+end
+
+end OAI
diff --git a/lean/OAI/Probability/SLE/Loewner/FutureSlitRadius.lean b/lean/OAI/Probability/SLE/Loewner/FutureSlitRadius.lean
new file mode 100644
index 0000000000000000000000000000000000000000..4e2fd9afae4209cb8a6532d669a17142851183b6
--- /dev/null
+++ b/lean/OAI/Probability/SLE/Loewner/FutureSlitRadius.lean
@@ -0,0 +1,55 @@
+import OAI.Probability.SLE.Geometry.CenteredFutureSlit
+import OAI.Probability.SLE.Loewner.CapacityRadiusBound
+
+namespace OAI
+
+/-! The complete mapped future slit shrinks to the driving value as its
+terminal time decreases to the current time. -/
+noncomputable section
+open Set Filter Function Metric Complex
+open scoped Topology
+
+namespace SLEExactGauge
+
+theorem centeredFutureArc_small (p : C(unitInterval,ℂ)) (hi : Injective p)
+    (h0 : p 0=0) (hH : ∀ t : unitInterval, t≠0 → p t∈upperHalfPlane)
+    (s : unitInterval) (hs : s<1) {ε : ℝ} (hε : 0<ε) :
+    ∃ δ : ℝ, 0<δ ∧ ∀ (t : unitInterval) (hst : s<t) (ht : t<1),
+      (t:ℝ)-(s:ℝ)<δ → ∀ u : unitInterval,
+        ‖centeredFutureArc p hi h0 hH hst ht u‖<ε := by
+  have hn := Metric.tendsto_nhds.mp (initialDrivingValue_spec p hi h0 hH s hs) ε hε
+  obtain ⟨δ,hδ,hnear⟩ := Metric.mem_nhdsWithin_iff.mp hn
+  refine ⟨δ,hδ,fun t hst ht htd u => ?_⟩
+  by_cases hu : u=0
+  · subst u
+    simpa only [centeredFutureArc_zero,norm_zero] using hε
+  have hp : 0<(u:ℝ) := unitInterval.pos_iff_ne_zero.mpr hu
+  have hd : 0<(t:ℝ)-(s:ℝ) := sub_pos.mpr hst
+  have hrpos : 0<((t:ℝ)-(s:ℝ))*(u:ℝ) := mul_pos hd hp
+  have hrlt : ((t:ℝ)-(s:ℝ))*(u:ℝ)<δ := by
+    have hm := mul_le_mul_of_nonneg_left u.property.2 hd.le
+    linarith
+  have he := hnear (show ((t:ℝ)-(s:ℝ))*(u:ℝ)∈ball (0:ℝ) δ ∩ Ioi 0 from
+    ⟨by simpa only [mem_ball,Real.dist_eq,sub_zero,abs_of_pos hrpos] using hrlt,hrpos⟩)
+  change ‖mappedFutureArc p hi h0 hH hst ht u-(_ : ℂ)‖<ε
+  rw [mappedFutureArc_of_ne_zero p hi h0 hH hst ht hu]
+  change dist (initialForwardChart p hi h0 hH s
+    (p (slitFutureParameter s (((t:ℝ)-(s:ℝ))*(u:ℝ)))))
+      (initialDrivingValue p hi h0 hH s hs:ℂ)<ε at he
+  simpa only [mappedFutureRaw,dist_eq_norm] using he
+
+theorem futureSlitChart_capacity_small (p : C(unitInterval,ℂ)) (hi : Injective p)
+    (h0 : p 0=0) (hH : ∀ t : unitInterval, t≠0 → p t∈upperHalfPlane)
+    (s : unitInterval) (hs : s<1) {ε : ℝ} (hε : 0<ε) :
+    ∃ δ : ℝ, 0<δ ∧ ∀ (t : unitInterval) (hst : s<t) (ht : t<1),
+      (t:ℝ)-(s:ℝ)<δ → (futureSlitChart p hi h0 hH hst ht).capacity≤ε^2 := by
+  obtain ⟨δ,hδ,hm⟩ := centeredFutureArc_small p hi h0 hH s hs hε
+  exact ⟨δ,hδ,fun t hst ht htd =>
+    (futureSlitChart p hi h0 hH hst ht).capacity_le_radius_sq hε
+      (fun u => (hm t hst ht htd u).le)⟩
+
+end SLEExactGauge
+
+end
+
+end OAI
diff --git a/lean/OAI/Probability/SLE/Loewner/HalfPlaneDisplacementBound.lean b/lean/OAI/Probability/SLE/Loewner/HalfPlaneDisplacementBound.lean
new file mode 100644
index 0000000000000000000000000000000000000000..3d8a5c933c6dc1680b2f1a6a2e7af1051992ca72
--- /dev/null
+++ b/lean/OAI/Probability/SLE/Loewner/HalfPlaneDisplacementBound.lean
@@ -0,0 +1,56 @@
+import OAI.Probability.SLE.Mass.HalfPlaneZeroMass
+
+namespace OAI
+
+/-! The total hydrodynamic mass bounds a nonnegative-imaginary displacement. -/
+noncomputable section
+open Set Filter Complex Function Metric
+open scoped Topology
+
+namespace SLEExactGauge
+
+lemma hydrodynamic_vertical_limits {f : ℂ → ℂ} {c : ℝ}
+    (hcoef : Tendsto (fun z : ℂ => z*f z)
+      (cocompact ℂ ⊓ 𝓟 upperHalfPlane) (𝓝 (-c:ℂ))) :
+    Tendsto (fun n : ℕ => f (verticalInfinity n)) atTop (𝓝 0) ∧
+      Tendsto (fun n : ℕ => ((n:ℝ)+1)*(f (verticalInfinity n)).im) atTop (𝓝 c) := by
+  have hp := hcoef.comp verticalInfinity_tendsto
+  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))
+  have hh := hp.mul (hi.comp (verticalInfinity_tendsto.mono_right inf_le_left))
+  have hzero : Tendsto (fun n : ℕ => f (verticalInfinity n)) atTop (𝓝 0) := by
+    simp only [mul_zero] at hh
+    apply hh.congr
+    intro n
+    have hn : verticalInfinity n ≠ 0 := by
+      intro he
+      have hv := verticalInfinity_mem n
+      simp only [upperHalfPlane,mem_ofPred_eq,he,zero_im,lt_self_iff_false] at hv
+    simp only [Function.comp_apply]
+    field_simp [hn]
+  refine ⟨hzero,?_⟩
+  have ht := (Complex.continuous_re.tendsto (-c:ℂ) |>.comp hp).neg
+  simpa only [Function.comp_apply,verticalInfinity,mul_re,mul_im,ofReal_re,ofReal_im,
+    I_re,I_im,mul_zero,zero_mul,add_zero,mul_one,neg_re,neg_neg,neg_zero,zero_sub] using ht
+
+lemma nonnegative_im_hydrodynamic_bound {f : ℂ → ℂ} {c : ℝ}
+    (hf : DifferentiableOn ℂ f upperHalfPlane)
+    (hm : ∀ z∈upperHalfPlane, 0≤(f z).im) (hc : 0≤c)
+    (hcoef : Tendsto (fun z : ℂ => z*f z)
+      (cocompact ℂ ⊓ 𝓟 upperHalfPlane) (𝓝 (-c:ℂ)))
+    {z : ℂ} (hz : z∈upperHalfPlane) : ‖f z‖≤c/z.im := by
+  obtain ⟨hzero,hmass⟩ := hydrodynamic_vertical_limits hcoef
+  rcases holomorphic_nonnegative_im_dichotomy hf hm with ⟨a,ha⟩ | hpos
+  · have ht : Tendsto (fun _ : ℕ => a) atTop (𝓝 0) :=
+      hzero.congr (fun n => ha _ (verticalInfinity_mem n))
+    have ha0 : a=0 := tendsto_nhds_unique tendsto_const_nhds ht
+    rw [ha z hz,ha0,norm_zero]
+    exact div_nonneg hc (show 0<z.im from hz).le
+  · exact norm_le_mass_div_height hz hc (halfPlane_vanishing_mass_bound hf hpos hzero hmass hz)
+
+end SLEExactGauge
+
+end
+
+end OAI
diff --git a/lean/OAI/Probability/SLE/Loewner/HalfPlaneExitBounds.lean b/lean/OAI/Probability/SLE/Loewner/HalfPlaneExitBounds.lean
new file mode 100644
index 0000000000000000000000000000000000000000..444a0374dd0d02a0278a0f8ab5cf114ad63dc702
--- /dev/null
+++ b/lean/OAI/Probability/SLE/Loewner/HalfPlaneExitBounds.lean
@@ -0,0 +1,55 @@
+import OAI.Probability.SLE.Loewner.HalfPlaneExitWeights
+import OAI.Probability.SLE.Geometry.HarmonicExitProbability
+
+namespace OAI
+
+/-! The two half-plane angular upper bounds for finite physical exits. -/
+noncomputable section
+open Set Filter MeasureTheory ProbabilityTheory
+open scoped Topology NNReal ENNReal
+
+namespace SLEExactGauge
+open Target
+
+def planarHalfPlaneExitArc (D : Set ℂ) (g : ℂ → ℂ) (w : ℂ) (T : ℝ≥0) (positive : Bool) :
+    Set (Driver×Driver) :=
+  {b | ∃ τ : ℝ≥0, 0 < τ ∧ τ ≤ T ∧
+    (∀ t<τ, w+Complex.equivRealProdCLM.symm (planarWiener t b)∈D) ∧
+    w+Complex.equivRealProdCLM.symm (planarWiener τ b)∉D ∧
+    ∃ x : ℝ, (if positive then 0<x else x<0) ∧
+      Tendsto (fun t => g (w+Complex.equivRealProdCLM.symm (planarWiener t b))) (𝓝[<] τ) (𝓝 (x:ℂ))}
+
+theorem planarHalfPlaneExitArc_bound
+    (W : WienerLaw) (hW : IsWiener W) {D : Set ℂ} (hD : IsOpen D)
+    (w : ℂ) (hw : w∈D) {g : ℂ → ℂ} (hg : DifferentiableOn ℂ g D)
+    (hgH : MapsTo g D upperHalfPlane) (T : ℝ≥0) (positive : Bool) :
+    (W.prod W) (planarHalfPlaneExitArc D g w T positive) ≤
+      ENNReal.ofReal (halfPlaneExitWeight positive (g w)) := 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)
+  let u (z : ℝ×ℝ) := halfPlaneExitWeight positive (g (w+Complex.equivRealProdCLM.symm z))
+  obtain ⟨hu,hhar⟩ := halfPlaneExitWeight_planar positive hD hg hgH w
+  have hub (z) (hz : z∈planarTranslatedDomain D w) : |u z|≤(1:ℝ≥0) := by
+    have hh := halfPlaneExitWeight_bounds positive (hgH hz)
+    rw [abs_of_nonneg hh.1]
+    exact hh.2
+  have hup (z) (hz : z∈planarTranslatedDomain D w) : 0 ≤ u z :=
+    (halfPlaneExitWeight_bounds positive (hgH hz)).1
+  have hh := e.nonnegative_harmonic_exit_bound W hW T hU u hu hhar 1 hub hup
+    (planarHalfPlaneExitArc D g w T positive) 1 (by norm_num) (by
+      rintro b ⟨τ,hτ,hτT,hp,hx,x,hs,hlim⟩
+      refine ⟨τ,hτ,hτT,hp,hx,?_⟩
+      cases positive
+      · have him : ∀ᶠ t in 𝓝[<] τ, 0 ≤ (g (w+Complex.equivRealProdCLM.symm (planarWiener t b))).im :=
+          (show ∀ᶠ t in 𝓝[<] τ, t<τ from self_mem_nhdsWithin).mono
+            (fun t ht => (hgH (hp t ht)).le)
+        exact halfPlaneExitWeight_negative_limit hs him hlim
+      · exact halfPlaneExitWeight_positive_limit hs hlim)
+  simpa [u] using hh
+
+end SLEExactGauge
+
+end
+
+end OAI
diff --git a/lean/OAI/Probability/SLE/Loewner/HalfPlaneExitWeights.lean b/lean/OAI/Probability/SLE/Loewner/HalfPlaneExitWeights.lean
new file mode 100644
index 0000000000000000000000000000000000000000..e5c58b140d2624dc8b99f8d4271a7e6d7a77191d
--- /dev/null
+++ b/lean/OAI/Probability/SLE/Loewner/HalfPlaneExitWeights.lean
@@ -0,0 +1,66 @@
+import OAI.Probability.SLE.Stochastic.PlanarHolomorphicTests
+import Mathlib.Analysis.SpecialFunctions.Complex.LogDeriv
+
+namespace OAI
+
+/-! The bounded angular harmonic functions for the two sides of the
+real boundary, together with their one-sided boundary limits. -/
+noncomputable section
+open Set Filter MeasureTheory ProbabilityTheory
+open scoped Topology NNReal ENNReal
+
+namespace SLEExactGauge
+
+def halfPlaneExitWeight (positive : Bool) (z : ℂ) : ℝ :=
+  if positive then 1-z.arg/Real.pi else z.arg/Real.pi
+
+lemma halfPlaneExitWeight_bounds (s : Bool) {z : ℂ} (hz : 0 < z.im) :
+    halfPlaneExitWeight s z∈Icc (0:ℝ) 1 := by
+  have h0 : 0 ≤ z.arg/Real.pi := div_nonneg (Complex.arg_nonneg_iff.mpr hz.le) Real.pi_pos.le
+  have h1 : z.arg/Real.pi ≤ 1 := (div_le_one Real.pi_pos).mpr (Complex.arg_le_pi z)
+  cases s <;> simp only [halfPlaneExitWeight,Bool.false_eq_true,↓reduceIte,mem_Icc] <;>
+    constructor <;> linarith
+
+lemma halfPlaneExitWeight_planar (s : Bool) {D : Set ℂ} (hD : IsOpen D)
+    {g : ℂ → ℂ} (hg : DifferentiableOn ℂ g D) (hgH : MapsTo g D upperHalfPlane) (w : ℂ) :
+    ContDiffOn ℝ (⊤ : ℕ∞)
+      (fun z => halfPlaneExitWeight s (g (w+Complex.equivRealProdCLM.symm z))) (planarTranslatedDomain D w) ∧
+    ∀ z∈planarTranslatedDomain D w,
+      planarGenerator (fun z => halfPlaneExitWeight s (g (w+Complex.equivRealProdCLM.symm z))) z=0 := by
+  have hlog : DifferentiableOn ℂ Complex.log upperHalfPlane := by
+    intro z hz
+    exact (Complex.differentiableAt_log (Complex.mem_slitPlane_iff.mpr (Or.inr (ne_of_gt hz)))).differentiableWithinAt
+  let Q (z : ℂ) := Complex.log (g z)/(Real.pi:ℂ)
+  have hQ : DifferentiableOn ℂ Q D := (hlog.comp hg hgH).div_const _
+  cases s
+  · have hh := (holomorphic_planar_components hD hQ w).2
+    simpa only [halfPlaneExitWeight,Bool.false_eq_true,↓reduceIte,Q,Complex.div_ofReal_im,Complex.log_im] using hh
+  · have hQc : DifferentiableOn ℂ (fun z => Complex.I-Q z) D := (differentiableOn_const Complex.I).sub hQ
+    have hh := (holomorphic_planar_components hD hQc w).2
+    simpa only [halfPlaneExitWeight,↓reduceIte,Q,Complex.sub_im,Complex.I_im,
+      Complex.div_ofReal_im,Complex.log_im] using hh
+
+lemma halfPlaneExitWeight_negative_limit {A : Type*} {l : Filter A}
+    {ζ : A → ℂ} {x : ℝ} (hx : x<0) (hζ : ∀ᶠ t in l, 0 ≤ (ζ t).im)
+    (hlim : Tendsto ζ l (𝓝 (x:ℂ))) :
+    Tendsto (fun t => halfPlaneExitWeight false (ζ t)) l (𝓝 1) := by
+  have hh := (Complex.tendsto_arg_nhdsWithin_im_nonneg_of_re_neg_of_im_zero
+    (z := (x:ℂ)) (by simpa using hx) (by simp)).comp
+      (tendsto_nhdsWithin_iff.mpr ⟨hlim,hζ⟩)
+  simpa only [halfPlaneExitWeight,Bool.false_eq_true,↓reduceIte,Function.comp_apply,
+    div_self Real.pi_ne_zero] using hh.div_const Real.pi
+
+lemma halfPlaneExitWeight_positive_limit {A : Type*} {l : Filter A}
+    {ζ : A → ℂ} {x : ℝ} (hx : 0<x) (hlim : Tendsto ζ l (𝓝 (x:ℂ))) :
+    Tendsto (fun t => halfPlaneExitWeight true (ζ t)) l (𝓝 1) := by
+  have hh := (Complex.continuousAt_arg (Complex.mem_slitPlane_iff.mpr
+    (Or.inl (by simpa using hx)))).tendsto.comp hlim
+  have hq := hh.div_const Real.pi
+  simpa only [halfPlaneExitWeight,↓reduceIte,Function.comp_apply,
+    Complex.arg_ofReal_of_nonneg hx.le,zero_div,sub_zero] using tendsto_const_nhds.sub hq
+
+end SLEExactGauge
+
+end
+
+end OAI
diff --git a/lean/OAI/Probability/SLE/Loewner/HalfPlaneFiniteExit.lean b/lean/OAI/Probability/SLE/Loewner/HalfPlaneFiniteExit.lean
new file mode 100644
index 0000000000000000000000000000000000000000..ba90fba180481f93ca4b11939f3079b443063d98
--- /dev/null
+++ b/lean/OAI/Probability/SLE/Loewner/HalfPlaneFiniteExit.lean
@@ -0,0 +1,79 @@
+import OAI.Probability.SLE.Geometry.NoBoundaryAtoms
+import OAI.Probability.SLE.Geometry.HalfPlaneChartBoundary
+
+namespace OAI
+
+/-! Finite nonzero real limits of conformal half-plane maps at actual
+finite physical Brownian exits. -/
+noncomputable section
+open Set Filter MeasureTheory ProbabilityTheory Metric
+open scoped Topology NNReal ENNReal
+
+namespace SLEExactGauge
+open Target
+
+theorem halfPlane_finite_exit_limit
+    (W : WienerLaw) (hW : IsWiener W) {D : Set ℂ} (hD : IsOpen D)
+    {g f : ℂ → ℂ} (hg : DifferentiableOn ℂ g D)
+    (hf : DifferentiableOn ℂ f upperHalfPlane)
+    (hgH : MapsTo g D upperHalfPlane) (hfD : MapsTo f upperHalfPlane D)
+    (hinv : ∀ z∈D, f (g z)=z) (w : ℂ) (hw : w∈D) (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 →
+      ∃ x : ℝ, x≠0 ∧
+        Tendsto (fun t => g (w+Complex.equivRealProdCLM.symm (planarWiener t b)))
+          (𝓝[<] τ) (𝓝 (x:ℂ)) := by
+  let v := g w
+  have hv : 0 < v.im := hgH hw
+  let F := halfPlaneToDisk v ∘ g
+  let H := f ∘ diskToHalfPlane v
+  have hF : DifferentiableOn ℂ F D := (halfPlaneToDisk_differentiable hv).comp hg hgH
+  have hFD : MapsTo F D (ball 0 1) := (halfPlaneToDisk_maps hv).comp hgH
+  have hH : ContinuousOn H (ball 0 1) := hf.continuousOn.comp
+    (diskToHalfPlane_differentiable v).continuousOn (diskToHalfPlane_maps hv)
+  have hHD : MapsTo H (ball 0 1) D := hfD.comp (diskToHalfPlane_maps hv)
+  have hFG (z) (hz : z∈D) : diskToHalfPlane v (F z)=g z :=
+    diskToHalfPlane_halfPlaneToDisk hv (hgH hz)
+  have hHF (z) (hz : z∈D) : H (F z)=z := by
+    change f (diskToHalfPlane v (F z))=z
+    rw [hFG z hz,hinv z hz]
+  have hF0 : F w=0 := by simp [F,v,halfPlaneToDisk]
+  have hlim := conformal_disk_finite_exit_limit W hW hD w hw hF hFD hH hHD hHF T
+  have hnull1 := planarDiskExitAtom_null W hW hD w hw hF hFD hF0 1 (by simp) T
+  have hnull0 := planarDiskExitAtom_null W hW hD w hw hF hFD hF0
+    (halfPlaneToDisk v 0) (halfPlaneToDisk_zero_norm hv) T
+  have hno1 : ∀ᵐ b ∂W.prod W, b∉planarDiskExitAtom D F w 1 T := by
+    simpa only [ae_iff,not_not,ofPred_mem_eq] using hnull1
+  have hno0 : ∀ᵐ b ∂W.prod W, b∉planarDiskExitAtom D F w (halfPlaneToDisk v 0) T := by
+    simpa only [ae_iff,not_not,ofPred_mem_eq] using hnull0
+  filter_upwards [hlim,hno1,hno0] with b hb hb1 hb0
+  intro τ hτ hτT hp hx
+  obtain ⟨c,hcn,hc⟩ := hb τ hτ hτT hp hx
+  have hc1 : c≠1 := by
+    intro he
+    exact hb1 ⟨τ,hτ,hτT,hp,hx,he ▸ hc⟩
+  have hc0 : c≠halfPlaneToDisk v 0 := by
+    intro he
+    exact hb0 ⟨τ,hτ,hτT,hp,hx,he ▸ hc⟩
+  have hgconv := (diskToHalfPlane_continuousAt (v := v) hc1).tendsto.comp hc
+  have heq : (fun t => diskToHalfPlane v (F (w+Complex.equivRealProdCLM.symm (planarWiener t b))))
+      =ᶠ[𝓝[<] τ] (fun t => g (w+Complex.equivRealProdCLM.symm (planarWiener t b))) := by
+    filter_upwards [self_mem_nhdsWithin] with t ht
+    exact hFG _ (hp t ht)
+  have hgconv' := hgconv.congr' heq
+  let z := diskToHalfPlane v c
+  have hzI : z.im=0 := diskToHalfPlane_boundary_im hcn
+  have hz0 : z≠0 := diskToHalfPlane_boundary_ne_zero hv hc1 hc0
+  have hzreal : z=(z.re:ℂ) := by apply Complex.ext <;> simp [hzI]
+  refine ⟨z.re,?_,?_⟩
+  · intro he
+    exact hz0 (by rw [hzreal,he,Complex.ofReal_zero])
+  · change Tendsto _ (𝓝[<] τ) (𝓝 z) at hgconv'
+    rwa [hzreal] at hgconv'
+
+end SLEExactGauge
+
+end
+
+end OAI
diff --git a/lean/OAI/Probability/SLE/Loewner/HydrodynamicAsymptotics.lean b/lean/OAI/Probability/SLE/Loewner/HydrodynamicAsymptotics.lean
new file mode 100644
index 0000000000000000000000000000000000000000..2d24aa42a247f8373e39f117acb8a5d3e2d4be55
--- /dev/null
+++ b/lean/OAI/Probability/SLE/Loewner/HydrodynamicAsymptotics.lean
@@ -0,0 +1,52 @@
+import OAI.Probability.SLE.Loewner.HydrodynamicCoefficient
+
+namespace OAI
+
+/-! Elementary consequences of hydrodynamic normalization, including
+the inverse coefficient and escape of the normalized inverse to infinity. -/
+noncomputable section
+open Set Filter Complex Function Metric
+open scoped Topology
+
+namespace SLEExactGauge
+
+lemma normalized_ratio_tendsto_cocompact {F : ℂ → ℂ}
+    (hF : Tendsto (fun z : ℂ => F z/z) (cocompact ℂ ⊓ 𝓟 upperHalfPlane) (𝓝 1)) :
+    Tendsto F (cocompact ℂ ⊓ 𝓟 upperHalfPlane) (cocompact ℂ) := by
+  have hr : Tendsto (fun z : ℂ => ‖F z/z‖) (cocompact ℂ ⊓ 𝓟 upperHalfPlane) (𝓝 1) := by
+    simpa only [norm_one] using hF.norm
+  have hn := Filter.Tendsto.pos_mul_atTop (by norm_num : (0:ℝ)<1) hr
+    (tendsto_norm_cocompact_atTop.mono_left (show cocompact ℂ ⊓ 𝓟 upperHalfPlane ≤ cocompact ℂ from inf_le_left))
+  have hnorm : Tendsto (fun z : ℂ => ‖F z‖) (cocompact ℂ ⊓ 𝓟 upperHalfPlane) atTop := by
+    apply hn.congr'
+    filter_upwards [(show ∀ᶠ z : ℂ in cocompact ℂ, z ≠ 0 from
+      (isCompact_singleton (x := (0:ℂ))).compl_mem_cocompact).filter_mono
+      (show cocompact ℂ ⊓ 𝓟 upperHalfPlane ≤ cocompact ℂ from inf_le_left)] with z hz
+    rw [norm_div,div_mul_cancel₀ _ (norm_ne_zero_iff.mpr hz)]
+  have hb := tendsto_norm_atTop_iff_cobounded.mp hnorm
+  simpa only [Metric.cobounded_eq_cocompact] using hb
+
+lemma inverse_hydrodynamic_coefficient {G F : ℂ → ℂ} {c : ℂ}
+    (hG : Tendsto (fun z : ℂ => z*(G z-z)) (cocompact ℂ) (𝓝 c))
+    (hF : Tendsto (fun z : ℂ => F z/z) (cocompact ℂ ⊓ 𝓟 upperHalfPlane) (𝓝 1))
+    (hGF : ∀ z ∈ upperHalfPlane, G (F z)=z) :
+    Tendsto (fun z : ℂ => z*(F z-z)) (cocompact ℂ ⊓ 𝓟 upperHalfPlane) (𝓝 (-c)) := by
+  have he := normalized_ratio_tendsto_cocompact hF
+  have hq : Tendsto (fun z : ℂ => z/F z) (cocompact ℂ ⊓ 𝓟 upperHalfPlane) (𝓝 1) := by
+    simpa only [inv_div,inv_one] using hF.inv₀ one_ne_zero
+  have ht := (hq.mul (hG.comp he)).neg
+  simp only [one_mul] at ht
+  apply ht.congr'
+  filter_upwards [he.eventually ((isCompact_singleton (x := (0:ℂ))).compl_mem_cocompact),
+    (show ∀ᶠ z in cocompact ℂ ⊓ 𝓟 upperHalfPlane, z∈upperHalfPlane from
+      eventually_inf_principal.mpr (Eventually.of_forall (fun _ h => h)))] with z hz hzH
+  simp only [Function.comp_apply,hGF z hzH]
+  have hz0 : F z ≠ 0 := hz
+  field_simp [hz0]
+  ring
+
+end SLEExactGauge
+
+end
+
+end OAI
diff --git a/lean/OAI/Probability/SLE/Loewner/HydrodynamicCoefficient.lean b/lean/OAI/Probability/SLE/Loewner/HydrodynamicCoefficient.lean
new file mode 100644
index 0000000000000000000000000000000000000000..85b9bf0cc3ba014d893aec99a738d569775cb28f
--- /dev/null
+++ b/lean/OAI/Probability/SLE/Loewner/HydrodynamicCoefficient.lean
@@ -0,0 +1,43 @@
+import OAI.Probability.SLE.Loewner.HydrodynamicHeight
+
+namespace OAI
+
+/-! A height-decreasing half-plane chart has nonnegative hydrodynamic
+coefficient. The argument uses the actual Laurent limit on the imaginary axis. -/
+noncomputable section
+open Set Filter Complex Function Metric
+open scoped Topology
+
+namespace SLEExactGauge
+
+lemma hydrodynamic_coefficient_nonneg {G : ℂ → ℂ} {c : ℝ}
+    (hc : Tendsto (fun z : ℂ => z*(G z-z)) (cocompact ℂ) (𝓝 (c:ℂ)))
+    (hheight : ∀ᶠ z in cocompact ℂ ⊓ 𝓟 upperHalfPlane, (G z).im ≤ z.im) : 0≤c := by
+  have hv := verticalInfinity_tendsto
+  have hr := Complex.continuous_re.tendsto (c:ℂ) |>.comp (hc.comp (hv.mono_right inf_le_left))
+  have hn : ∀ᶠ n in atTop, 0 ≤ (verticalInfinity n*(G (verticalInfinity n)-verticalInfinity n)).re := by
+    filter_upwards [hv.eventually hheight] with n hn
+    have hy : 0 < (n:ℝ)+1 := by positivity
+    simp only [verticalInfinity,mul_im,mul_re,ofReal_re,ofReal_im,I_re,I_im,mul_zero,
+      add_zero,mul_one,sub_im,sub_re,zero_sub] at hn ⊢
+    nlinarith
+  have hh : 0 ≤ (c:ℂ).re := ge_of_tendsto hr (by
+    simpa only [Function.comp_apply] using hn)
+  simpa only [ofReal_re] using hh
+
+lemma normalized_inverse_height
+    {D : Set ℂ} {G F : ℂ → ℂ}
+    (hG : MapsTo G D upperHalfPlane)
+    (hF : DifferentiableOn ℂ F upperHalfPlane) (hmap : MapsTo F upperHalfPlane upperHalfPlane)
+    (hleft : ∀ z ∈ D, F (G z)=z)
+    (hn : Tendsto (fun z : ℂ => F z/z) (cocompact ℂ ⊓ 𝓟 upperHalfPlane) (𝓝 1)) :
+    ∀ z ∈ D, (G z).im ≤ z.im := by
+  intro z hz
+  have hh := normalized_halfPlane_height hF hmap hn (hG hz)
+  rwa [hleft z hz] at hh
+
+end SLEExactGauge
+
+end
+
+end OAI
diff --git a/lean/OAI/Probability/SLE/Loewner/HydrodynamicComposition.lean b/lean/OAI/Probability/SLE/Loewner/HydrodynamicComposition.lean
new file mode 100644
index 0000000000000000000000000000000000000000..802b5c6bbe9800c9479a9625a25da8a5ec7c7374
--- /dev/null
+++ b/lean/OAI/Probability/SLE/Loewner/HydrodynamicComposition.lean
@@ -0,0 +1,97 @@
+import OAI.Probability.SLE.Loewner.HydrodynamicAsymptotics
+
+namespace OAI
+
+/-! The coefficient of a normalized composition subtracts capacities.
+Schwarz–Pick then makes capacity monotone under inclusion of slit domains. -/
+noncomputable section
+open Set Filter Complex Function Metric
+open scoped Topology
+
+namespace SLEExactGauge
+
+lemma hydrodynamic_ratio_limit {G : ℂ → ℂ} {c : ℂ}
+    (hG : Tendsto (fun z : ℂ => z*(G z-z)) (cocompact ℂ) (𝓝 c)) :
+    Tendsto (fun z : ℂ => G z/z) (cocompact ℂ) (𝓝 1) := 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))
+  have hh := (hG.mul (hi.pow 2)).const_add 1
+  simp only [zero_pow two_ne_zero,mul_zero,add_zero] at hh
+  apply hh.congr'
+  filter_upwards [(isCompact_singleton (x := (0:ℂ))).compl_mem_cocompact] with z hz
+  have hz0 : z ≠ 0 := hz
+  field_simp [hz0]
+  ring
+
+lemma hydrodynamic_composition_coefficient {G H F : ℂ → ℂ} {c d : ℂ}
+    (hG : Tendsto (fun z : ℂ => z*(G z-z)) (cocompact ℂ) (𝓝 c))
+    (hH : Tendsto (fun z : ℂ => z*(H z-z)) (cocompact ℂ) (𝓝 d))
+    (hF : Tendsto (fun z : ℂ => F z/z) (cocompact ℂ ⊓ 𝓟 upperHalfPlane) (𝓝 1))
+    (hHF : ∀ z ∈ upperHalfPlane, H (F z)=z) :
+    Tendsto (fun z : ℂ => z*(G (F z)-z)) (cocompact ℂ ⊓ 𝓟 upperHalfPlane) (𝓝 (c-d)) := by
+  have hescape := normalized_ratio_tendsto_cocompact hF
+  have hquot : Tendsto (fun z : ℂ => z/F z) (cocompact ℂ ⊓ 𝓟 upperHalfPlane) (𝓝 1) := by
+    simpa only [inv_div,inv_one] using hF.inv₀ one_ne_zero
+  have hh := (hquot.mul (hG.comp hescape)).add (inverse_hydrodynamic_coefficient hH hF hHF)
+  simp only [one_mul,sub_eq_add_neg] at hh ⊢
+  apply hh.congr'
+  filter_upwards [hescape.eventually ((isCompact_singleton (x := (0:ℂ))).compl_mem_cocompact)] with z hz
+  simp only [Function.comp_apply]
+  have hz0 : F z ≠ 0 := hz
+  field_simp [hz0]
+  ring
+
+lemma hydrodynamic_composition_ratio {G F : ℂ → ℂ} {c : ℂ}
+    (hG : Tendsto (fun z : ℂ => z*(G z-z)) (cocompact ℂ) (𝓝 c))
+    (hF : Tendsto (fun z : ℂ => F z/z) (cocompact ℂ ⊓ 𝓟 upperHalfPlane) (𝓝 1)) :
+    Tendsto (fun z : ℂ => G (F z)/z) (cocompact ℂ ⊓ 𝓟 upperHalfPlane) (𝓝 1) := by
+  have he := normalized_ratio_tendsto_cocompact hF
+  have hh := ((hydrodynamic_ratio_limit hG).comp he).mul hF
+  simp only [mul_one] at hh
+  apply hh.congr'
+  filter_upwards [he.eventually ((isCompact_singleton (x := (0:ℂ))).compl_mem_cocompact)] with z hz
+  simp only [Function.comp_apply]
+  have hz0 : F z ≠ 0 := hz
+  field_simp [hz0]
+
+
+lemma normalized_selfMap_coefficient_nonpos {G : ℂ → ℂ} {c : ℝ}
+    (hd : DifferentiableOn ℂ G upperHalfPlane) (hm : MapsTo G upperHalfPlane upperHalfPlane)
+    (hc : Tendsto (fun z : ℂ => z*(G z-z)) (cocompact ℂ ⊓ 𝓟 upperHalfPlane) (𝓝 (c:ℂ)))
+    (hn : Tendsto (fun z : ℂ => G z/z) (cocompact ℂ ⊓ 𝓟 upperHalfPlane) (𝓝 1)) : c≤0 := by
+  have hr := Complex.continuous_re.tendsto (c:ℂ) |>.comp (hc.comp verticalInfinity_tendsto)
+  have hh : ∀ᶠ n in atTop, (verticalInfinity n*(G (verticalInfinity n)-verticalInfinity n)).re ≤ 0 := by
+    apply Eventually.of_forall
+    intro n
+    have hheight := normalized_halfPlane_height hd hm hn (verticalInfinity_mem n)
+    have hy : 0 < (n:ℝ)+1 := by positivity
+    simp only [verticalInfinity,mul_im,mul_re,ofReal_re,ofReal_im,I_re,I_im,mul_zero,
+      add_zero,mul_one,sub_im,sub_re,zero_sub] at hheight ⊢
+    nlinarith
+  have hle : (c:ℂ).re ≤ 0 := le_of_tendsto hr (by
+    simpa only [Function.comp_apply] using hh)
+  simpa only [ofReal_re] using hle
+
+theorem nested_hydrodynamic_coefficient_le
+    {D : Set ℂ} {G H F : ℂ → ℂ} {c d : ℝ}
+    (hG : DifferentiableOn ℂ G D) (hGm : MapsTo G D upperHalfPlane)
+    (hF : DifferentiableOn ℂ F upperHalfPlane) (hFm : MapsTo F upperHalfPlane D)
+    (hc : Tendsto (fun z : ℂ => z*(G z-z)) (cocompact ℂ) (𝓝 (c:ℂ)))
+    (hd : Tendsto (fun z : ℂ => z*(H z-z)) (cocompact ℂ) (𝓝 (d:ℂ)))
+    (hn : Tendsto (fun z : ℂ => F z/z) (cocompact ℂ ⊓ 𝓟 upperHalfPlane) (𝓝 1))
+    (hHF : ∀ z ∈ upperHalfPlane, H (F z)=z) : c≤d := by
+  have hcomp := hydrodynamic_composition_coefficient hc hd hn hHF
+  have hnorm := hydrodynamic_composition_ratio hc hn
+  have hle := normalized_selfMap_coefficient_nonpos (hG.comp hF hFm)
+    (hGm.comp hFm) (c := c-d) (by
+      convert! hcomp using 1
+      simp only [ofReal_sub])
+    (by convert! hnorm using 1)
+  linarith
+
+end SLEExactGauge
+
+end
+
+end OAI
diff --git a/lean/OAI/Probability/SLE/Loewner/HydrodynamicHeight.lean b/lean/OAI/Probability/SLE/Loewner/HydrodynamicHeight.lean
new file mode 100644
index 0000000000000000000000000000000000000000..18a1910c359275c9dd7773cf172406cbea864337
--- /dev/null
+++ b/lean/OAI/Probability/SLE/Loewner/HydrodynamicHeight.lean
@@ -0,0 +1,61 @@
+import OAI.Probability.SLE.Geometry.HalfPlaneJulia
+import OAI.Probability.SLE.Loewner.SlitInverseAtInfinity
+
+namespace OAI
+
+/-! Normalization at infinity forces a half-plane self-map to increase
+height. This compares the inverse maps of nested slit domains. -/
+noncomputable section
+open Set Filter Complex Function Metric
+open scoped Topology
+
+namespace SLEExactGauge
+
+def verticalInfinity (n : ℕ) : ℂ := (((n:ℝ)+1:ℝ):ℂ)*I
+
+lemma verticalHeights_tendsto : Tendsto (fun n : ℕ => (n:ℝ)+1) atTop atTop := by
+  convert! (tendsto_natCast_atTop_atTop (R := ℝ)).comp (tendsto_add_atTop_nat 1) using 1
+  ext n
+  simp only [Function.comp_apply,Nat.cast_add,Nat.cast_one]
+
+lemma verticalInfinity_mem (n : ℕ) : verticalInfinity n ∈ upperHalfPlane := by
+  simp only [verticalInfinity,upperHalfPlane,mem_ofPred_eq,mul_im,ofReal_re,I_im,mul_one,
+    ofReal_im,I_re,mul_zero,add_zero]
+  positivity
+
+lemma verticalInfinity_tendsto :
+    Tendsto verticalInfinity atTop (cocompact ℂ ⊓ 𝓟 upperHalfPlane) := by
+  apply tendsto_inf.mpr
+  constructor
+  · rw [← Metric.cobounded_eq_cocompact,← tendsto_norm_atTop_iff_cobounded]
+    have hh : Tendsto (fun n : ℕ => (n:ℝ)+1) atTop atTop :=
+      verticalHeights_tendsto
+    have hnorm : (fun n : ℕ => ‖verticalInfinity n‖)=(fun n : ℕ => (n:ℝ)+1) := by
+      funext n
+      simp only [verticalInfinity,norm_mul,Complex.norm_real,Real.norm_eq_abs,norm_I,
+        mul_one,abs_of_pos (by positivity : 0<(n:ℝ)+1)]
+    rw [hnorm]
+    exact hh
+  · exact tendsto_principal.mpr (Eventually.of_forall verticalInfinity_mem)
+
+theorem normalized_halfPlane_height {F : ℂ → ℂ}
+    (hF : DifferentiableOn ℂ F upperHalfPlane) (hmap : MapsTo F upperHalfPlane upperHalfPlane)
+    (hn : Tendsto (fun z : ℂ => F z/z) (cocompact ℂ ⊓ 𝓟 upperHalfPlane) (𝓝 1))
+    {z : ℂ} (hz : z ∈ upperHalfPlane) : z.im ≤ (F z).im := by
+  have hr := hn.comp verticalInfinity_tendsto
+  have he (n : ℕ) : F (verticalInfinity n)/(((n:ℝ)+1:ℝ):ℂ) =
+      (F (verticalInfinity n)/verticalInfinity n)*I := by
+    have hne : (((n:ℝ)+1:ℝ):ℂ) ≠ 0 := ofReal_ne_zero.mpr (by positivity)
+    simp only [verticalInfinity]
+    field_simp
+  have hlim : Tendsto (fun n : ℕ => F (verticalInfinity n)/(((n:ℝ)+1:ℝ):ℂ)) atTop (𝓝 I) := by
+    simpa only [Function.comp_apply,he,one_mul] using hr.mul_const I
+  exact halfPlane_julia_at_infinity hF hmap (fun n => (n:ℝ)+1)
+    (fun n => by positivity)
+    (tendsto_inv_atTop_zero.comp (verticalHeights_tendsto)) hlim hz
+
+end SLEExactGauge
+
+end
+
+end OAI
diff --git a/lean/OAI/Probability/SLE/Loewner/InitialCapacity.lean b/lean/OAI/Probability/SLE/Loewner/InitialCapacity.lean
new file mode 100644
index 0000000000000000000000000000000000000000..153c0014675745f4a0585a36517c92454af7f0ad
--- /dev/null
+++ b/lean/OAI/Probability/SLE/Loewner/InitialCapacity.lean
@@ -0,0 +1,88 @@
+import OAI.Probability.SLE.Loewner.InitialSubarc
+
+namespace OAI
+
+/-! A monotone positive capacity parameter on the exact initial subarcs. -/
+noncomputable section
+open Set Filter Function
+open scoped Topology
+
+namespace SLEExactGauge
+
+structure SimpleSlitChart (p : C(unitInterval,ℂ)) where
+  forward : ℂ → ℂ
+  inverse : ℂ → ℂ
+  capacity : ℝ
+  capacity_pos : 0<capacity
+  bijOn : BijOn forward (upperHalfPlane \ range p) upperHalfPlane
+  forward_differentiable : DifferentiableOn ℂ forward (upperHalfPlane \ range p)
+  inverse_differentiable : DifferentiableOn ℂ inverse upperHalfPlane
+  inverse_mapsTo : MapsTo inverse upperHalfPlane (upperHalfPlane \ range p)
+  left_inverse : ∀ z ∈ upperHalfPlane \ range p, inverse (forward z)=z
+  right_inverse : ∀ z ∈ upperHalfPlane, forward (inverse z)=z
+  coefficient : Tendsto (fun z : ℂ => z*(forward z-z)) (cocompact ℂ) (𝓝 (capacity:ℂ))
+  inverse_normalized : Tendsto (fun z : ℂ => inverse z/z)
+    (cocompact ℂ ⊓ 𝓟 upperHalfPlane) (𝓝 1)
+  height_le : ∀ z ∈ upperHalfPlane \ range p, (forward z).im≤z.im
+
+lemma exists_simpleSlitChart (p : C(unitInterval,ℂ)) (hi : Injective p) (h0 : p 0=0)
+    (hH : ∀ t : unitInterval, t ≠ 0 → p t ∈ upperHalfPlane) : Nonempty (SimpleSlitChart p) := by
+  obtain ⟨G,F,c,hc,hb,hdG,hdF,hm,hl,hr,hlim,hn,hh⟩ :=
+    simple_slit_exists_positive_capacity_chart p hi h0 hH
+  exact ⟨⟨G,F,c,hc,hb,hdG,hdF,hm,hl,hr,hlim,hn,hh⟩⟩
+
+noncomputable def initialSlitChart (p : C(unitInterval,ℂ)) (hi : Injective p) (h0 : p 0=0)
+    (hH : ∀ t : unitInterval, t ≠ 0 → p t ∈ upperHalfPlane)
+    (t : unitInterval) (ht : t ≠ 0) : SimpleSlitChart (initialSubarc p t) :=
+  Classical.choice (exists_simpleSlitChart _ (initialSubarc_injective hi ht)
+    (by simpa only [initialSubarc_zero] using h0) (initialSubarc_upper hH ht))
+
+lemma SimpleSlitChart.capacity_le_of_range_subset
+    {p q : C(unitInterval,ℂ)} (P : SimpleSlitChart p) (Q : SimpleSlitChart q)
+    (hpq : range p ⊆ range q) : P.capacity≤Q.capacity := by
+  have hdom : upperHalfPlane \ range q ⊆ upperHalfPlane \ range p := by
+    intro z hz
+    exact ⟨hz.1,fun hp => hz.2 (hpq hp)⟩
+  exact nested_hydrodynamic_coefficient_le P.forward_differentiable P.bijOn.mapsTo
+    Q.inverse_differentiable (Q.inverse_mapsTo.mono_right hdom)
+    P.coefficient Q.coefficient Q.inverse_normalized Q.right_inverse
+
+noncomputable def initialCapacity (p : C(unitInterval,ℂ)) (hi : Injective p) (h0 : p 0=0)
+    (hH : ∀ t : unitInterval, t ≠ 0 → p t ∈ upperHalfPlane) (t : unitInterval) : ℝ :=
+  if ht : t=0 then 0 else (initialSlitChart p hi h0 hH t ht).capacity
+
+@[simp] lemma initialCapacity_zero (p : C(unitInterval,ℂ)) (hi : Injective p) (h0 : p 0=0)
+    (hH : ∀ t : unitInterval, t ≠ 0 → p t ∈ upperHalfPlane) : initialCapacity p hi h0 hH 0=0 := by
+  simp [initialCapacity]
+
+lemma initialCapacity_pos (p : C(unitInterval,ℂ)) (hi : Injective p) (h0 : p 0=0)
+    (hH : ∀ t : unitInterval, t ≠ 0 → p t ∈ upperHalfPlane)
+    {t : unitInterval} (ht : t ≠ 0) : 0 < initialCapacity p hi h0 hH t := by
+  rw [initialCapacity,dite_eq_right ht]
+  exact (initialSlitChart p hi h0 hH t ht).capacity_pos
+
+lemma initialCapacity_nonneg (p : C(unitInterval,ℂ)) (hi : Injective p) (h0 : p 0=0)
+    (hH : ∀ t : unitInterval, t ≠ 0 → p t ∈ upperHalfPlane) (t : unitInterval) :
+    0 ≤ initialCapacity p hi h0 hH t := by
+  by_cases ht : t=0
+  · simp only [ht,initialCapacity_zero,le_refl]
+  · exact (initialCapacity_pos p hi h0 hH ht).le
+
+theorem initialCapacity_monotone (p : C(unitInterval,ℂ)) (hi : Injective p) (h0 : p 0=0)
+    (hH : ∀ t : unitInterval, t ≠ 0 → p t ∈ upperHalfPlane) :
+    Monotone (initialCapacity p hi h0 hH) := by
+  intro s t hst
+  by_cases hs : s=0
+  · rw [hs,initialCapacity_zero]
+    exact initialCapacity_nonneg p hi h0 hH t
+  have ht : t≠0 := by
+    intro ht
+    exact hs (le_antisymm (ht ▸ hst) bot_le)
+  rw [initialCapacity,dite_eq_right hs,initialCapacity,dite_eq_right ht]
+  exact SimpleSlitChart.capacity_le_of_range_subset _ _ (initialSubarc_range_mono p hst)
+
+end SLEExactGauge
+
+end
+
+end OAI
diff --git a/lean/OAI/Probability/SLE/Loewner/InitialCapacityAtZero.lean b/lean/OAI/Probability/SLE/Loewner/InitialCapacityAtZero.lean
new file mode 100644
index 0000000000000000000000000000000000000000..1fb1bba591d88bfd6423abccd4d0f3ef93bb9d4d
--- /dev/null
+++ b/lean/OAI/Probability/SLE/Loewner/InitialCapacityAtZero.lean
@@ -0,0 +1,46 @@
+import OAI.Probability.SLE.Loewner.CapacityRadiusBound
+
+namespace OAI
+
+/-! The capacity of initial subarcs tends to zero at the starting point,
+by the explicit half-disk capacity bound. -/
+noncomputable section
+open Set Filter Complex Function Metric
+open scoped Topology
+
+namespace SLEExactGauge
+
+theorem initialCapacity_continuousAt_zero (p : C(unitInterval,ℂ)) (hi : Injective p)
+    (h0 : p 0=0) (hH : ∀ t : unitInterval, t ≠ 0 → p t ∈ upperHalfPlane) :
+    ContinuousAt (initialCapacity p hi h0 hH) 0 := by
+  rw [Metric.continuousAt_iff]
+  intro ε hε
+  let R : ℝ := Real.sqrt ε/2
+  have hR : 0<R := div_pos (Real.sqrt_pos.mpr hε) (by norm_num)
+  have hR2 : R^2<ε := by
+    dsimp only [R]
+    nlinarith [Real.sq_sqrt hε.le,Real.sqrt_nonneg ε]
+  have hp := p.continuous.continuousAt.preimage_mem_nhds (ball_mem_nhds (p 0) hR)
+  obtain ⟨δ,hδ,hδp⟩ := Metric.mem_nhds_iff.mp hp
+  refine ⟨δ,hδ,?_⟩
+  intro t ht
+  have hbound : ∀ u ∈ Icc (0:unitInterval) t, ‖p u‖≤R := by
+    intro u hu
+    have hdist : dist u (0:unitInterval) ≤ dist t (0:unitInterval) := by
+      change |(u:ℝ)-0|≤|(t:ℝ)-0|
+      simp only [sub_zero,abs_of_nonneg u.property.1,abs_of_nonneg t.property.1]
+      exact_mod_cast hu.2
+    have hpu := hδp (hdist.trans_lt ht)
+    have hlt : ‖p u‖<R := by
+      simpa only [mem_preimage,mem_ball,h0,dist_zero_right] using hpu
+    exact hlt.le
+  have hc := initialCapacity_le_radius_sq p hi h0 hH hR t hbound
+  rw [initialCapacity_zero,Real.dist_eq,sub_zero,
+    abs_of_nonneg (initialCapacity_nonneg p hi h0 hH t)]
+  exact hc.trans_lt hR2
+
+end SLEExactGauge
+
+end
+
+end OAI
diff --git a/lean/OAI/Probability/SLE/Loewner/InitialCapacityClock.lean b/lean/OAI/Probability/SLE/Loewner/InitialCapacityClock.lean
new file mode 100644
index 0000000000000000000000000000000000000000..1931e185c225ff459ee87ed7647dadb5cc344644
--- /dev/null
+++ b/lean/OAI/Probability/SLE/Loewner/InitialCapacityClock.lean
@@ -0,0 +1,51 @@
+import OAI.Probability.SLE.Loewner.InitialCapacityContinuity
+import OAI.Probability.SLE.Loewner.InitialCapacityStrict
+import Mathlib.Topology.Order.IntermediateValue
+import Mathlib.Order.Hom.Set
+
+namespace OAI
+
+/-! The capacity of a simple attached slit is a genuine continuous clock,
+with an exact continuous inverse on its full range. -/
+noncomputable section
+open Set Function
+open scoped Topology
+
+namespace SLEExactGauge
+
+lemma initialCapacity_range (p : C(unitInterval,ℂ)) (hi : Injective p)
+    (h0 : p 0=0) (hH : ∀ t : unitInterval, t ≠ 0 → p t ∈ upperHalfPlane) :
+    range (initialCapacity p hi h0 hH)=Icc 0 (initialCapacity p hi h0 hH 1) := by
+  have hh := (initialCapacity_continuous p hi h0 hH).image_Icc_of_strictMono
+    (initialCapacity_strictMono p hi h0 hH) (a := 0) (b := 1)
+  have hIcc : Icc (0:unitInterval) 1=univ := by
+    ext x
+    simp only [mem_Icc,mem_univ,iff_true]
+    exact ⟨bot_le,le_top⟩
+  simpa only [hIcc,image_univ,initialCapacity_zero] using hh
+
+noncomputable def initialCapacityHomeomorph (p : C(unitInterval,ℂ)) (hi : Injective p)
+    (h0 : p 0=0) (hH : ∀ t : unitInterval, t ≠ 0 → p t ∈ upperHalfPlane) :
+    unitInterval ≃ₜ Icc 0 (initialCapacity p hi h0 hH 1) :=
+  (((initialCapacity_strictMono p hi h0 hH).orderIso (initialCapacity p hi h0 hH)).trans
+    (Set.orderIsoOfEq _ _ (initialCapacity_range p hi h0 hH))).toHomeomorph
+
+@[simp] lemma initialCapacityHomeomorph_apply (p : C(unitInterval,ℂ)) (hi : Injective p)
+    (h0 : p 0=0) (hH : ∀ t : unitInterval, t ≠ 0 → p t ∈ upperHalfPlane)
+    (t : unitInterval) :
+    ((initialCapacityHomeomorph p hi h0 hH t : Icc 0 (initialCapacity p hi h0 hH 1)):ℝ)=
+      initialCapacity p hi h0 hH t := rfl
+
+@[simp] lemma initialCapacityHomeomorph_symm_capacity (p : C(unitInterval,ℂ)) (hi : Injective p)
+    (h0 : p 0=0) (hH : ∀ t : unitInterval, t ≠ 0 → p t ∈ upperHalfPlane)
+    (c : Icc 0 (initialCapacity p hi h0 hH 1)) :
+    initialCapacity p hi h0 hH ((initialCapacityHomeomorph p hi h0 hH).symm c)=(c:ℝ) := by
+  have hh := congrArg (fun x : Icc 0 (initialCapacity p hi h0 hH 1) => (x:ℝ))
+    ((initialCapacityHomeomorph p hi h0 hH).apply_symm_apply c)
+  exact hh
+
+end SLEExactGauge
+
+end
+
+end OAI
diff --git a/lean/OAI/Probability/SLE/Loewner/InitialCapacityContinuity.lean b/lean/OAI/Probability/SLE/Loewner/InitialCapacityContinuity.lean
new file mode 100644
index 0000000000000000000000000000000000000000..1a0ca8c8ae8b92cfb07bbf2275bbbaa78d893672
--- /dev/null
+++ b/lean/OAI/Probability/SLE/Loewner/InitialCapacityContinuity.lean
@@ -0,0 +1,88 @@
+import OAI.Probability.SLE.Loewner.InitialCapacityTerminal
+import OAI.Probability.SLE.Loewner.InitialForwardComparison
+import OAI.Probability.SLE.Mass.VerticalDisplacementMass
+
+namespace OAI
+
+/-! Continuity of the full capacity parameter. The capacity of the initial
+slit and its complementary capacity relative to the final slit give the two
+inequalities for every subsequential limit. -/
+noncomputable section
+open Set Filter Function Complex
+open scoped Topology
+
+namespace SLEExactGauge
+
+lemma initialCapacity_limit_value_at (p : C(unitInterval,ℂ)) (hi : Injective p)
+    (h0 : p 0=0) (hH : ∀ t : unitInterval, t ≠ 0 → p t ∈ upperHalfPlane)
+    {t : ℕ → unitInterval} {F : ℂ → ℂ} {c : ℝ}
+    (hF : DifferentiableOn ℂ F upperHalfPlane)
+    (hlim : TendstoLocallyUniformlyOn (fun n => initialInverseChart p hi h0 hH (t n))
+      F atTop upperHalfPlane) {s : unitInterval} (hs : s≠0) (ht : Tendsto t atTop (𝓝 s))
+    (hcap : Tendsto (fun n => initialCapacity p hi h0 hH (t n)) atTop (𝓝 c)) :
+    c=initialCapacity p hi h0 hH s := by
+  let P := initialSlitChart p hi h0 hH s hs
+  have heF : EqOn F P.inverse upperHalfPlane := by
+    simpa only [initialInverseChart,dite_eq_right hs] using
+      initialInverse_limit_eq_at p hi h0 hH hF hlim hs ht
+  have hlow : P.capacity≤c := by
+    apply hydrodynamic_mass_le_of_displacement
+      (inverse_hydrodynamic_coefficient P.coefficient P.inverse_normalized P.right_inverse)
+    intro z hz
+    rw [← heF hz]
+    exact initialInverse_limit_displacement p hi h0 hH hlim hcap hz
+  obtain ⟨Q⟩ := exists_simpleSlitChart p hi h0 hH
+  obtain ⟨φ,hφ,hforward⟩ := initialInverse_limit_forward_on_final p hi h0 hH hF hlim hs ht
+  have hbound (z : ℂ) (hz : z∈upperHalfPlane) :
+      ‖P.forward (Q.inverse z)-z‖≤(Q.capacity-c)/z.im := by
+    have hleft := ((hforward (Q.inverse z) (Q.inverse_mapsTo hz)).sub_const z).norm
+    have hright := ((tendsto_const_nhds (x := Q.capacity)).sub
+      (hcap.comp hφ.tendsto_atTop)).div_const z.im
+    exact le_of_tendsto_of_tendsto hleft hright
+      (Eventually.of_forall fun n => initialForward_comparison_to_final p hi h0 hH Q _ hz)
+  have hcomp : Tendsto (fun z : ℂ => z*(P.forward (Q.inverse z)-z))
+      (cocompact ℂ ⊓ 𝓟 upperHalfPlane) (𝓝 (-((Q.capacity-P.capacity:ℝ):ℂ))) := by
+    have he : -((Q.capacity-P.capacity:ℝ):ℂ)=(P.capacity:ℂ)-Q.capacity := by
+      push_cast
+      ring
+    rw [he]
+    exact hydrodynamic_composition_coefficient P.coefficient Q.coefficient
+      Q.inverse_normalized Q.right_inverse
+  have hupper := hydrodynamic_mass_le_of_displacement hcomp hbound
+  rw [initialCapacity,dite_eq_right hs]
+  change c=P.capacity
+  exact le_antisymm (by linarith) hlow
+
+theorem initialCapacity_continuousAt (p : C(unitInterval,ℂ)) (hi : Injective p)
+    (h0 : p 0=0) (hH : ∀ t : unitInterval, t ≠ 0 → p t ∈ upperHalfPlane)
+    (s : unitInterval) : ContinuousAt (initialCapacity p hi h0 hH) s := by
+  by_cases hs : s=0
+  · subst s
+    exact initialCapacity_continuousAt_zero p hi h0 hH
+  apply tendsto_of_subseq_tendsto
+  intro t ht
+  have hb (n : ℕ) : initialCapacity p hi h0 hH (t n)∈
+      Icc 0 (initialCapacity p hi h0 hH 1) :=
+    ⟨initialCapacity_nonneg p hi h0 hH _,initialCapacity_monotone p hi h0 hH le_top⟩
+  obtain ⟨c,_,φ,hφ,hcap⟩ := isCompact_Icc.tendsto_subseq hb
+  obtain ⟨ψ,F,hψ,hF,hFlim⟩ := initialInverseChart_subsequence p hi h0 hH (t ∘ φ)
+  have ht' : Tendsto (fun n => t (φ (ψ n))) atTop (𝓝 s) :=
+    (ht.comp hφ.tendsto_atTop).comp hψ.tendsto_atTop
+  have hc' := hcap.comp hψ.tendsto_atTop
+  have he := initialCapacity_limit_value_at p hi h0 hH hF hFlim hs ht' hc'
+  refine ⟨φ ∘ ψ,?_⟩
+  change Tendsto (fun n => initialCapacity p hi h0 hH (t (φ (ψ n))))
+    atTop (𝓝 (initialCapacity p hi h0 hH s))
+  change Tendsto (fun n => initialCapacity p hi h0 hH (t (φ (ψ n)))) atTop (𝓝 c) at hc'
+  rwa [he] at hc'
+
+theorem initialCapacity_continuous (p : C(unitInterval,ℂ)) (hi : Injective p)
+    (h0 : p 0=0) (hH : ∀ t : unitInterval, t ≠ 0 → p t ∈ upperHalfPlane) :
+    Continuous (initialCapacity p hi h0 hH) :=
+  continuous_iff_continuousAt.mpr (initialCapacity_continuousAt p hi h0 hH)
+
+end SLEExactGauge
+
+end
+
+end OAI
diff --git a/lean/OAI/Probability/SLE/Loewner/InitialCapacityStrict.lean b/lean/OAI/Probability/SLE/Loewner/InitialCapacityStrict.lean
new file mode 100644
index 0000000000000000000000000000000000000000..ae0bd992fd3d0ed00859eacc712afcfc80f67a47
--- /dev/null
+++ b/lean/OAI/Probability/SLE/Loewner/InitialCapacityStrict.lean
@@ -0,0 +1,64 @@
+import OAI.Probability.SLE.Loewner.InitialCapacityAtZero
+
+namespace OAI
+
+/-! Capacity strictly increases when a simple attached slit is extended. -/
+noncomputable section
+open Set Filter Function
+open scoped Topology
+
+namespace SLEExactGauge
+
+lemma SimpleSlitChart.capacity_lt_of_domain_difference
+    {p q : C(unitInterval,ℂ)} (P : SimpleSlitChart p) (Q : SimpleSlitChart q)
+    (hpq : range p ⊆ range q) {z : ℂ}
+    (hz : z∈upperHalfPlane \ range p) (hzq : z∈range q) :
+    P.capacity<Q.capacity := by
+  have hle := P.capacity_le_of_range_subset Q hpq
+  apply lt_of_le_of_ne hle
+  intro he
+  have hdom : upperHalfPlane \ range q ⊆ upperHalfPlane \ range p :=
+    fun _ hw => ⟨hw.1,fun hp => hw.2 (hpq hp)⟩
+  have hm := Q.inverse_mapsTo.mono_right hdom
+  have hd := P.forward_differentiable.comp Q.inverse_differentiable hm
+  have hh := hydrodynamic_composition_coefficient P.coefficient Q.coefficient
+    Q.inverse_normalized Q.right_inverse
+  have hcoef : Tendsto (fun w : ℂ => w*(P.forward (Q.inverse w)-w))
+      (cocompact ℂ ⊓ 𝓟 upperHalfPlane) (𝓝 0) := by
+    simpa only [he,sub_self] using hh
+  have hn := hydrodynamic_composition_ratio P.coefficient Q.inverse_normalized
+  have heq := holomorphic_zero_hydrodynamic_mass (hd.sub differentiableOn_id)
+    (fun w hw => by
+      have hb := normalized_halfPlane_height hd (P.bijOn.mapsTo.comp hm) hn hw
+      change 0 ≤ (P.forward (Q.inverse w)-w).im
+      simpa only [Function.comp_apply,Complex.sub_im] using sub_nonneg.mpr hb) hcoef
+  have hwH := P.bijOn.mapsTo hz
+  have hsame : Q.inverse (P.forward z)=z := by
+    apply P.bijOn.injOn (hm hwH) hz
+    exact sub_eq_zero.mp (heq (P.forward z) hwH)
+  exact (Q.inverse_mapsTo hwH).2 (hsame.symm ▸ hzq)
+
+theorem initialCapacity_strictMono (p : C(unitInterval,ℂ)) (hi : Injective p)
+    (h0 : p 0=0) (hH : ∀ t : unitInterval, t ≠ 0 → p t ∈ upperHalfPlane) :
+    StrictMono (initialCapacity p hi h0 hH) := by
+  intro s t hst
+  have ht : t≠0 := ne_of_gt (bot_le.trans_lt hst)
+  by_cases hs : s=0
+  · rw [hs,initialCapacity_zero]
+    exact initialCapacity_pos p hi h0 hH ht
+  rw [initialCapacity,dite_eq_right hs,initialCapacity,dite_eq_right ht]
+  apply SimpleSlitChart.capacity_lt_of_domain_difference _ _
+    (initialSubarc_range_mono p hst.le) (z := p t)
+  · refine ⟨hH t ht,?_⟩
+    rw [initialSubarc_range]
+    rintro ⟨u,hu,he⟩
+    have hut := hi he
+    exact (not_le_of_gt hst) (hut ▸ hu.2)
+  · rw [initialSubarc_range]
+    exact mem_image_of_mem p ⟨bot_le,le_rfl⟩
+
+end SLEExactGauge
+
+end
+
+end OAI
diff --git a/lean/OAI/Probability/SLE/Loewner/InitialCapacityTerminal.lean b/lean/OAI/Probability/SLE/Loewner/InitialCapacityTerminal.lean
new file mode 100644
index 0000000000000000000000000000000000000000..94299ed337f67336c0ec58a201f3ddec656f6265
--- /dev/null
+++ b/lean/OAI/Probability/SLE/Loewner/InitialCapacityTerminal.lean
@@ -0,0 +1,82 @@
+import OAI.Probability.SLE.Loewner.SlitChartLimitUniqueness
+
+namespace OAI
+
+/-! Continuity of initial-subarc capacity at its terminal time. Compactness
+of the actual inverse charts identifies every scalar subsequential limit. -/
+noncomputable section
+open Set Filter Function Complex
+open scoped Topology
+
+namespace SLEExactGauge
+
+lemma SimpleSlitChart.capacity_eq_initial_final {p : C(unitInterval,ℂ)}
+    (P : SimpleSlitChart p) (hi : Injective p) (h0 : p 0=0)
+    (hH : ∀ t : unitInterval, t ≠ 0 → p t ∈ upperHalfPlane) :
+    P.capacity = initialCapacity p hi h0 hH 1 := by
+  have h1 : (1:unitInterval)≠0 := by norm_num
+  rw [initialCapacity,dite_eq_right h1]
+  have hr : range (initialSubarc p 1)=range p := by
+    ext z
+    simp only [mem_range,initialSubarc_apply,one_mul]
+  exact le_antisymm
+    (P.capacity_le_of_range_subset (initialSlitChart p hi h0 hH 1 h1) hr.ge)
+    ((initialSlitChart p hi h0 hH 1 h1).capacity_le_of_range_subset P hr.le)
+
+lemma initialCapacity_terminal_limit_value (p : C(unitInterval,ℂ)) (hi : Injective p)
+    (h0 : p 0=0) (hH : ∀ t : unitInterval, t ≠ 0 → p t ∈ upperHalfPlane)
+    {t : ℕ → unitInterval} {F : ℂ → ℂ} {c : ℝ}
+    (hF : DifferentiableOn ℂ F upperHalfPlane)
+    (hlim : TendstoLocallyUniformlyOn (fun n => initialInverseChart p hi h0 hH (t n))
+      F atTop upperHalfPlane) (ht : Tendsto t atTop (𝓝 1))
+    (hcap : Tendsto (fun n => initialCapacity p hi h0 hH (t n)) atTop (𝓝 c)) :
+    c = initialCapacity p hi h0 hH 1 := by
+  obtain ⟨P⟩ := exists_simpleSlitChart p hi h0 hH
+  have heq := initialInverse_limit_eq_final p hi h0 hH P hF hlim ht
+  have hcoef := inverse_hydrodynamic_coefficient P.coefficient P.inverse_normalized P.right_inverse
+  have hmass := (hydrodynamic_vertical_limits (c := P.capacity) hcoef).2
+  have hle : P.capacity≤c := by
+    apply le_of_tendsto hmass
+    apply Eventually.of_forall
+    intro n
+    have hb := initialInverse_limit_displacement p hi h0 hH hlim hcap (verticalInfinity_mem n)
+    rw [heq (verticalInfinity_mem n)] at hb
+    have him := (Complex.im_le_norm (P.inverse (verticalInfinity n)-verticalInfinity n)).trans hb
+    have hy : 0<(n:ℝ)+1 := by positivity
+    have hbound := (le_div_iff₀ hy).mp (show
+      (P.inverse (verticalInfinity n)-verticalInfinity n).im≤c/((n:ℝ)+1) from by
+        simpa only [verticalInfinity,mul_im,ofReal_re,I_im,mul_one,ofReal_im,I_re,mul_zero,add_zero]
+          using him)
+    nlinarith
+  have hge : c ≤ initialCapacity p hi h0 hH 1 := by
+    apply le_of_tendsto hcap
+    exact Eventually.of_forall fun n => initialCapacity_monotone p hi h0 hH
+      (show t n≤1 from le_top)
+  rw [P.capacity_eq_initial_final hi h0 hH] at hle
+  exact le_antisymm hge hle
+
+theorem initialCapacity_continuousAt_one (p : C(unitInterval,ℂ)) (hi : Injective p)
+    (h0 : p 0=0) (hH : ∀ t : unitInterval, t ≠ 0 → p t ∈ upperHalfPlane) :
+    ContinuousAt (initialCapacity p hi h0 hH) 1 := by
+  apply tendsto_of_subseq_tendsto
+  intro t ht
+  have hb (n : ℕ) : initialCapacity p hi h0 hH (t n)∈
+      Icc 0 (initialCapacity p hi h0 hH 1) :=
+    ⟨initialCapacity_nonneg p hi h0 hH _,initialCapacity_monotone p hi h0 hH le_top⟩
+  obtain ⟨c,_,φ,hφ,hcap⟩ := isCompact_Icc.tendsto_subseq hb
+  obtain ⟨ψ,F,hψ,hF,hFlim⟩ := initialInverseChart_subsequence p hi h0 hH (t ∘ φ)
+  have ht' : Tendsto (fun n => t (φ (ψ n))) atTop (𝓝 1) :=
+    (ht.comp hφ.tendsto_atTop).comp hψ.tendsto_atTop
+  have hc' := hcap.comp hψ.tendsto_atTop
+  have he := initialCapacity_terminal_limit_value p hi h0 hH hF hFlim ht' hc'
+  refine ⟨φ ∘ ψ,?_⟩
+  change Tendsto (fun n => initialCapacity p hi h0 hH (t (φ (ψ n))))
+    atTop (𝓝 (initialCapacity p hi h0 hH 1))
+  change Tendsto (fun n => initialCapacity p hi h0 hH (t (φ (ψ n)))) atTop (𝓝 c) at hc'
+  rwa [he] at hc'
+
+end SLEExactGauge
+
+end
+
+end OAI
diff --git a/lean/OAI/Probability/SLE/Loewner/InitialChartIdentities.lean b/lean/OAI/Probability/SLE/Loewner/InitialChartIdentities.lean
new file mode 100644
index 0000000000000000000000000000000000000000..efa3616950bc8d5c6298ac1470d09fcf5ab00b00
--- /dev/null
+++ b/lean/OAI/Probability/SLE/Loewner/InitialChartIdentities.lean
@@ -0,0 +1,34 @@
+import OAI.Probability.SLE.Loewner.InitialForwardChart
+
+namespace OAI
+
+/-! Forward identities on the domain at the current time, rather than
+only on the common final domain. -/
+noncomputable section
+open Set Function
+
+namespace SLEExactGauge
+
+lemma initialForwardChart_mem_upper (p : C(unitInterval,ℂ)) (hi : Injective p)
+    (h0 : p 0=0) (hH : ∀ t : unitInterval, t ≠ 0 → p t ∈ upperHalfPlane)
+    (s : unitInterval) {z : ℂ} (hz : z∈upperHalfPlane \ range (initialSubarc p s)) :
+    initialForwardChart p hi h0 hH s z∈upperHalfPlane := by
+  by_cases hs : s=0
+  · simpa only [hs,initialForwardChart_zero,id_eq] using hz.1
+  · rw [initialForwardChart,dite_eq_right hs]
+    exact (initialSlitChart p hi h0 hH s hs).bijOn.mapsTo hz
+
+lemma initialInverse_forward_at (p : C(unitInterval,ℂ)) (hi : Injective p)
+    (h0 : p 0=0) (hH : ∀ t : unitInterval, t ≠ 0 → p t ∈ upperHalfPlane)
+    (s : unitInterval) {z : ℂ} (hz : z∈upperHalfPlane \ range (initialSubarc p s)) :
+    initialInverseChart p hi h0 hH s (initialForwardChart p hi h0 hH s z)=z := by
+  by_cases hs : s=0
+  · simp only [hs,initialForwardChart_zero,initialInverseChart_zero,id_eq]
+  · rw [initialForwardChart,dite_eq_right hs,initialInverseChart,dite_eq_right hs]
+    exact (initialSlitChart p hi h0 hH s hs).left_inverse z hz
+
+end SLEExactGauge
+
+end
+
+end OAI
diff --git a/lean/OAI/Probability/SLE/Loewner/InitialChartNormalization.lean b/lean/OAI/Probability/SLE/Loewner/InitialChartNormalization.lean
new file mode 100644
index 0000000000000000000000000000000000000000..9a3785aa4f35115e7a0c81d3d8e1282d600e122c
--- /dev/null
+++ b/lean/OAI/Probability/SLE/Loewner/InitialChartNormalization.lean
@@ -0,0 +1,61 @@
+import OAI.Probability.SLE.Loewner.InitialChartIdentities
+import OAI.Probability.SLE.Loewner.RadiusHullInverse
+
+namespace OAI
+
+/-! Normalization and height of the initial chart family, including its
+identity chart at time zero. -/
+noncomputable section
+open Set Filter Function Complex
+open scoped Topology
+
+namespace SLEExactGauge
+
+lemma initialForwardChart_differentiableOn_current (p : C(unitInterval,ℂ)) (hi : Injective p)
+    (h0 : p 0=0) (hH : ∀ t : unitInterval, t≠0 → p t∈upperHalfPlane)
+    (s : unitInterval) :
+    DifferentiableOn ℂ (initialForwardChart p hi h0 hH s)
+      (upperHalfPlane \ range (initialSubarc p s)) := by
+  by_cases hs : s=0
+  · simp only [hs,initialForwardChart_zero]
+    exact differentiableOn_id
+  · simpa only [initialForwardChart,dite_eq_right hs] using
+      (initialSlitChart p hi h0 hH s hs).forward_differentiable
+
+lemma initialForwardChart_coefficient (p : C(unitInterval,ℂ)) (hi : Injective p)
+    (h0 : p 0=0) (hH : ∀ t : unitInterval, t≠0 → p t∈upperHalfPlane)
+    (s : unitInterval) :
+    Tendsto (fun z : ℂ => z*(initialForwardChart p hi h0 hH s z-z)) (cocompact ℂ)
+      (𝓝 (initialCapacity p hi h0 hH s:ℂ)) := by
+  by_cases hs : s=0
+  · simp only [hs,initialForwardChart_zero,id_eq,sub_self,mul_zero,initialCapacity_zero,ofReal_zero]
+    exact tendsto_const_nhds
+  · simpa only [initialForwardChart,initialCapacity,dite_eq_right hs] using
+      (initialSlitChart p hi h0 hH s hs).coefficient
+
+lemma initialInverseChart_normalized (p : C(unitInterval,ℂ)) (hi : Injective p)
+    (h0 : p 0=0) (hH : ∀ t : unitInterval, t≠0 → p t∈upperHalfPlane)
+    (s : unitInterval) :
+    Tendsto (fun z : ℂ => initialInverseChart p hi h0 hH s z/z)
+      (cocompact ℂ ⊓ 𝓟 upperHalfPlane) (𝓝 1) := by
+  by_cases hs : s=0
+  · apply ratio_one_of_bounded_displacement (R := 0)
+    intro z _
+    simp only [hs,initialInverseChart_zero,id_eq,sub_self,norm_zero,le_refl]
+  · simpa only [initialInverseChart,dite_eq_right hs] using
+      (initialSlitChart p hi h0 hH s hs).inverse_normalized
+
+lemma initialForwardChart_height_le (p : C(unitInterval,ℂ)) (hi : Injective p)
+    (h0 : p 0=0) (hH : ∀ t : unitInterval, t≠0 → p t∈upperHalfPlane)
+    (s : unitInterval) {z : ℂ} (hz : z∈upperHalfPlane \ range (initialSubarc p s)) :
+    (initialForwardChart p hi h0 hH s z).im≤z.im := by
+  by_cases hs : s=0
+  · simp only [hs,initialForwardChart_zero,id_eq,le_refl]
+  · simpa only [initialForwardChart,dite_eq_right hs] using
+      (initialSlitChart p hi h0 hH s hs).height_le z hz
+
+end SLEExactGauge
+
+end
+
+end OAI
diff --git a/lean/OAI/Probability/SLE/Loewner/InitialConeFromInterval.lean b/lean/OAI/Probability/SLE/Loewner/InitialConeFromInterval.lean
new file mode 100644
index 0000000000000000000000000000000000000000..316e54662fb0948919b68c5aee21a910b5d1efbe
--- /dev/null
+++ b/lean/OAI/Probability/SLE/Loewner/InitialConeFromInterval.lean
@@ -0,0 +1,41 @@
+import OAI.Probability.SLE.Loewner.LocalReverseCone
+import OAI.Probability.SLE.LoewnerCharts
+
+namespace OAI
+
+/-! The initial cone only uses the driving derivative inside its interval;
+no continuation of that derivative beyond the terminal time is needed. -/
+noncomputable section
+open Set Filter Complex
+open scoped Topology
+
+namespace SLEExactGauge
+
+lemma exists_initial_reverse_cone_of_interval_derivative {T L : ℝ}
+    (hT : 0 < T) (hL : 0 ≤ L) (q : ℝ → ℂ) (u u' : ℝ → ℝ)
+    (hqc : ContinuousOn q (Icc 0 T))
+    (hu : ∀ t ∈ Icc 0 T, HasDerivWithinAt u (u' t) (Icc 0 T) t)
+    (hq0 : q 0=(u 0 : ℂ))
+    (hq : ∀ t ∈ Ioc 0 T, HasDerivWithinAt q
+      (-2/(q t-(u t : ℂ))) (Ici t) t)
+    (hqp : ∀ t ∈ Ioc 0 T, 0 < (q t).im)
+    (hb : ∀ t ∈ Icc 0 T, |u' t| ≤ L) :
+    ∃ a : ℝ, 0 < a ∧ a ≤ T ∧
+      ∀ t ∈ Icc 0 a, ((q t).re-u t)^2 ≤ t ∧ 3*t ≤ (q t).im^2 := by
+  have hhalf : T/2 < T := half_lt_self hT
+  have hsub : Icc 0 (T/2) ⊆ Icc 0 T := Icc_subset_Icc_right hhalf.le
+  have hpos (t : ℝ) (ht : t ∈ Ioc 0 (T/2)) : t ∈ Ioc 0 T :=
+    ⟨ht.1,ht.2.trans hhalf.le⟩
+  obtain ⟨a,ha,haT,hcone⟩ := exists_initial_reverse_cone (half_pos hT) hL q u u'
+    (hqc.mono hsub) (fun t ht => (hu t (hsub ht)).continuousWithinAt.mono hsub) hq0
+    (fun t ht => hq t (hpos t ht))
+    (fun t ht => hasDerivWithinAt_Ici_of_Icc ⟨ht.1.le,ht.2.trans_lt hhalf⟩
+      (hu t ⟨ht.1.le,ht.2.trans hhalf.le⟩))
+    (fun t ht => hqp t (hpos t ht)) (fun t ht => hb t ⟨ht.1.le,ht.2.trans hhalf.le⟩)
+  exact ⟨a,ha,haT.trans hhalf.le,hcone⟩
+
+end SLEExactGauge
+
+end
+
+end OAI
diff --git a/lean/OAI/Probability/SLE/Loewner/InitialDrivingBound.lean b/lean/OAI/Probability/SLE/Loewner/InitialDrivingBound.lean
new file mode 100644
index 0000000000000000000000000000000000000000..61697492486c4aee9ab654f58a29cd445161d0b7
--- /dev/null
+++ b/lean/OAI/Probability/SLE/Loewner/InitialDrivingBound.lean
@@ -0,0 +1,42 @@
+import OAI.Probability.SLE.Loewner.SlitUniformForwardBound
+import OAI.Probability.SLE.Loewner.InitialDrivingLimit
+
+namespace OAI
+
+/-! Every simple slit in a fixed disk has uniformly bounded driving
+coordinates, including when the tip approaches either end. -/
+noncomputable section
+open Set Filter Function Complex
+open scoped Topology
+
+namespace SLEExactGauge
+
+theorem initialDrivingValue_bound (p : C(unitInterval,ℂ)) (hi : Injective p)
+    (h0 : p 0=0) (hH : ∀ t : unitInterval, t≠0 → p t∈upperHalfPlane)
+    {R : ℝ} (hR : 0<R) (hp : ∀ t : unitInterval, ‖p t‖<R)
+    (s : unitInterval) (hs : s<1) :
+    |initialDrivingValue p hi h0 hH s hs|≤(512*Real.pi+9)*R := by
+  by_cases hs0 : s=0
+  · subst s
+    rw [initialDrivingValue_zero,abs_zero]
+    positivity
+  have hl := (initialDrivingValue_spec p hi h0 hH s hs).norm
+  rw [Complex.norm_real,Real.norm_eq_abs] at hl
+  apply le_of_tendsto hl
+  have hd : 0<1-(s:ℝ) := sub_pos.mpr hs
+  filter_upwards [self_mem_nhdsWithin,
+    Filter.Eventually.filter_mono inf_le_left (gt_mem_nhds hd)] with r hr hrd
+  have hz := slitFuturePoint_mem_domain p hi hH s (show r∈Ioo 0 (1-(s:ℝ)) from ⟨hr,hrd⟩)
+  rw [initialForwardChart,dite_eq_right hs0]
+  change ‖(initialSlitChart p hi h0 hH s hs0).forward
+    (p (slitFutureParameter s r))‖≤_
+  exact (initialSlitChart p hi h0 hH s hs0).forward_uniform_near
+    (initialSubarc_injective hi hs0) (by simpa only [initialSubarc_zero] using h0)
+    (initialSubarc_upper hH hs0) hR
+    (fun u => hp _) hz ((hp _).le.trans (by linarith))
+
+end SLEExactGauge
+
+end
+
+end OAI
diff --git a/lean/OAI/Probability/SLE/Loewner/InitialDrivingContinuity.lean b/lean/OAI/Probability/SLE/Loewner/InitialDrivingContinuity.lean
new file mode 100644
index 0000000000000000000000000000000000000000..657f12d0560edfd2ddda64f84d43163be696da9e
--- /dev/null
+++ b/lean/OAI/Probability/SLE/Loewner/InitialDrivingContinuity.lean
@@ -0,0 +1,71 @@
+import OAI.Probability.SLE.Stochastic.DrivingLeftCluster
+
+namespace OAI
+
+/-! Full continuity of the actual slit driving value before the final
+parameter, derived from the inverse energy and boundary noncollapse. -/
+noncomputable section
+open Set Filter Function Complex Metric
+open scoped Topology
+
+namespace SLEExactGauge
+
+theorem initialDriving_tendsto_from_left (p : C(unitInterval,ℂ)) (hi : Injective p)
+    (h0 : p 0=0) (hH : ∀ t : unitInterval, t≠0 → p t∈upperHalfPlane)
+    {R : ℝ} (hR : 0<R) (hp : ∀ t : unitInterval, ‖p t‖<R)
+    {s : unitInterval} (hs0 : s≠0) (hs : s<1)
+    {t : ℕ → unitInterval} (hts : ∀ n, t n<s) (ht : Tendsto t atTop (𝓝 s)) :
+    Tendsto (fun n => initialDriving p hi h0 hH (t n)) atTop
+      (𝓝 (initialDriving p hi h0 hH s)) := by
+  apply tendsto_of_subseq_tendsto
+  intro ns hns
+  let M := (512*Real.pi+9)*R
+  have hbound (n : ℕ) : initialDriving p hi h0 hH (t (ns n))∈Icc (-M) M := by
+    rw [initialDriving_of_lt p hi h0 hH ((hts (ns n)).trans hs)]
+    exact abs_le.mp (initialDrivingValue_bound p hi h0 hH hR hp _ _)
+  obtain ⟨a,_,φ,hφ,hlim⟩ := isCompact_Icc.tendsto_subseq hbound
+  have he := initialDriving_left_cluster p hi h0 hH hR hp hs0 hs
+    (fun n => hts (ns (φ n))) ((ht.comp hns).comp hφ.tendsto_atTop) hlim
+  exact ⟨φ,by simpa only [Function.comp_def,he] using hlim⟩
+
+theorem initialDriving_continuousWithinAt_left (p : C(unitInterval,ℂ)) (hi : Injective p)
+    (h0 : p 0=0) (hH : ∀ t : unitInterval, t≠0 → p t∈upperHalfPlane)
+    {s : unitInterval} (hs : s<1) :
+    ContinuousWithinAt (initialDriving p hi h0 hH) (Iio s) s := by
+  by_cases hs0 : s=0
+  · subst s
+    have hem : Iio (0:unitInterval)=∅ := by
+      ext x
+      simp only [mem_Iio,mem_empty_iff_false,iff_false]
+      exact not_lt_of_ge (show (0:unitInterval)≤x from x.property.1)
+    rw [hem]
+    exact continuousWithinAt_of_notMem_closure (by simp)
+  obtain ⟨R0,hRp⟩ := (isCompact_range p.continuous).isBounded.exists_norm_le
+  let R := max R0 0+1
+  have hR : 0<R := by dsimp [R]; positivity
+  have hpR (u : unitInterval) : ‖p u‖<R :=
+    (hRp _ (mem_range_self u)).trans_lt (by dsimp [R]; linarith [le_max_left R0 0])
+  apply tendsto_of_seq_tendsto
+  intro t ht
+  have hts : ∀ᶠ n in atTop, t n<s := (tendsto_nhdsWithin_iff.mp ht).2
+  obtain ⟨N,hN⟩ := eventually_atTop.mp hts
+  have ht' : Tendsto (fun n => t (n+N)) atTop (𝓝 s) :=
+    (ht.mono_right nhdsWithin_le_nhds).comp (tendsto_add_atTop_nat N)
+  have hres := initialDriving_tendsto_from_left p hi h0 hH hR
+    hpR hs0 hs
+    (fun n => hN (n+N) (by omega)) ht'
+  exact (tendsto_add_atTop_iff_nat N).mp hres
+
+theorem initialDriving_continuousAt (p : C(unitInterval,ℂ)) (hi : Injective p)
+    (h0 : p 0=0) (hH : ∀ t : unitInterval, t≠0 → p t∈upperHalfPlane)
+    {s : unitInterval} (hs : s<1) :
+    ContinuousAt (initialDriving p hi h0 hH) s := by
+  exact continuousAt_iff_continuous_left'_right'.mpr
+    ⟨initialDriving_continuousWithinAt_left p hi h0 hH hs,
+      initialDriving_continuousWithinAt_right p hi h0 hH hs⟩
+
+end SLEExactGauge
+
+end
+
+end OAI
diff --git a/lean/OAI/Probability/SLE/Loewner/InitialDrivingIncrement.lean b/lean/OAI/Probability/SLE/Loewner/InitialDrivingIncrement.lean
new file mode 100644
index 0000000000000000000000000000000000000000..eee8b8e823b7a6319c093d75b65464e4a3e446a0
--- /dev/null
+++ b/lean/OAI/Probability/SLE/Loewner/InitialDrivingIncrement.lean
@@ -0,0 +1,66 @@
+import OAI.Probability.SLE.Loewner.InitialDrivingBound
+import OAI.Probability.SLE.Loewner.FutureCapacityAdditive
+
+namespace OAI
+
+/-! A small mapped future slit forces its two driving values to be
+close, without any assumed continuity of the driver. -/
+noncomputable section
+open Set Filter Function Complex
+open scoped Topology
+
+namespace SLEExactGauge
+
+theorem initialDriving_increment_bound (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) {R : ℝ} (hR : 0<R)
+    (hp : ∀ u : unitInterval, ‖centeredFutureArc p hi h0 hH hst ht u‖<R) :
+    |initialDrivingValue p hi h0 hH t ht-
+      initialDrivingValue p hi h0 hH s (hst.trans ht)|≤(512*Real.pi+9)*R := by
+  let U := initialDrivingValue p hi h0 hH s (hst.trans ht)
+  let Q := futureSlitChart p hi h0 hH hst ht
+  let w (r : ℝ) := initialForwardChart p hi h0 hH s (p (slitFutureParameter t r))-(U:ℂ)
+  have hpt := point_after_prefix_mem_domain p hi hH hst
+  have hopen : IsOpen (upperHalfPlane \ range (initialSubarc p s)) :=
+    isOpen_upperHalfPlane.sdiff (isCompact_range (initialSubarc p s).continuous).isClosed
+  have hG := ((initialForwardChart_differentiableOn_current p hi h0 hH s).differentiableAt
+    (hopen.mem_nhds hpt)).continuousAt
+  have hf : Tendsto (fun r : ℝ => p (slitFutureParameter t r)) (𝓝 0) (𝓝 (p t)) := by
+    have hcont : Continuous (fun r : ℝ => p (slitFutureParameter t r)) :=
+      p.continuous.comp (slitFutureParameter_continuous t)
+    simpa only [slitFutureParameter_zero] using hcont.tendsto 0
+  have hwlim : Tendsto w (𝓝 0) (𝓝 (centeredFutureArc p hi h0 hH hst ht 1)) := by
+    have hh := (hG.tendsto.comp hf).sub_const (U:ℂ)
+    have he : centeredFutureArc p hi h0 hH hst ht 1=
+        initialForwardChart p hi h0 hH s (p t)-(U:ℂ) := by
+      change mappedFutureArc p hi h0 hH hst ht 1-(U:ℂ)=_
+      rw [mappedFutureArc_segment p hi h0 hH hst ht one_ne_zero,slitSegmentParameter_one]
+    rwa [he]
+  have hnorm : ∀ᶠ r : ℝ in 𝓝[>] 0, ‖w r‖<2*R := by
+    exact (hwlim.norm.eventually (gt_mem_nhds ((hp 1).trans (by linarith)))).filter_mono inf_le_left
+  have hl := ((initialDrivingValue_spec p hi h0 hH t ht).sub_const (U:ℂ)).norm
+  have hl' : Tendsto (fun r : ℝ => ‖initialForwardChart p hi h0 hH t
+      (p (slitFutureParameter t r))-(U:ℂ)‖) (𝓝[>] 0)
+      (𝓝 |initialDrivingValue p hi h0 hH t ht-U|) := by
+    simpa only [←ofReal_sub,Complex.norm_real,Real.norm_eq_abs] using hl
+  apply le_of_tendsto hl'
+  have hd : 0<1-(t:ℝ) := sub_pos.mpr ht
+  filter_upwards [self_mem_nhdsWithin,hnorm,
+    Filter.Eventually.filter_mono inf_le_left (gt_mem_nhds hd)] with r hr hwr hrd
+  have hz := slitFuturePoint_mem_domain p hi hH t (show r∈Ioo 0 (1-(t:ℝ)) from ⟨hr,hrd⟩)
+  have hw := (initialForward_centered_bijOn p hi h0 hH hst ht).mapsTo hz
+  have hb := Q.forward_uniform_near
+    (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) hR hp hw hwr.le
+  have he : (U:ℂ)+Q.forward (w r)=initialForwardChart p hi h0 hH t
+      (p (slitFutureParameter t r)) := futureComposedForward_eq p hi h0 hH hst ht hz
+  have he' : Q.forward (w r)=initialForwardChart p hi h0 hH t
+      (p (slitFutureParameter t r))-(U:ℂ) := by linear_combination he
+  rwa [he'] at hb
+
+end SLEExactGauge
+
+end
+
+end OAI
diff --git a/lean/OAI/Probability/SLE/Loewner/InitialDrivingLimit.lean b/lean/OAI/Probability/SLE/Loewner/InitialDrivingLimit.lean
new file mode 100644
index 0000000000000000000000000000000000000000..686a70aa51b163163c4c68d564e631e3a5e85eca
--- /dev/null
+++ b/lean/OAI/Probability/SLE/Loewner/InitialDrivingLimit.lean
@@ -0,0 +1,65 @@
+import OAI.Probability.SLE.Loewner.InitialSlitFuture
+import OAI.Probability.SLE.Loewner.SlitForwardEndpoint
+
+namespace OAI
+
+/-! The mapped future of a simple slit approaches a real boundary point.
+This supplies the driving value directly from the prescribed arc. -/
+noncomputable section
+open Set Filter Function Complex
+open scoped Topology
+
+namespace SLEExactGauge
+
+theorem exists_initial_driving_limit (p : C(unitInterval,ℂ)) (hi : Injective p)
+    (h0 : p 0=0) (hH : ∀ t : unitInterval, t≠0 → p t∈upperHalfPlane)
+    (s : unitInterval) (hs : s<1) :
+    ∃ a : ℝ, Tendsto
+      (fun r : ℝ => initialForwardChart p hi h0 hH s (p (slitFutureParameter s r)))
+      (𝓝[>] (0:ℝ)) (𝓝 (a:ℂ)) := by
+  have hD : 0<1-(s:ℝ) := sub_pos.mpr (show (s:ℝ)<1 from hs)
+  have hC : Continuous (fun r : ℝ => p (slitFutureParameter s r)) :=
+    p.continuous.comp (slitFutureParameter_continuous s)
+  have hz : Tendsto (fun r : ℝ => p (slitFutureParameter s r))
+      (𝓝[>] (0:ℝ)) (𝓝 (p s)) := by
+    have hc : Tendsto (fun r : ℝ => p (slitFutureParameter s r))
+        (𝓝 (0:ℝ)) (𝓝 (p s)) := by
+      simpa only [slitFutureParameter_zero] using hC.tendsto 0
+    exact hc.mono_left nhdsWithin_le_nhds
+  by_cases hs0 : s=0
+  · refine ⟨0,?_⟩
+    simpa only [hs0,initialForwardChart_zero,id_eq,h0,ofReal_zero] using hz
+  · simpa only [initialForwardChart,dite_eq_right hs0] using
+      (initialSlitChart p hi h0 hH s hs0).exists_forward_endpoint_limit hD hC.continuousOn
+      hz (fun _ hr => slitFuturePoint_mem_domain p hi hH s hr) (slit_tip_not_mem_domain p s)
+
+noncomputable def initialDrivingValue (p : C(unitInterval,ℂ)) (hi : Injective p)
+    (h0 : p 0=0) (hH : ∀ t : unitInterval, t≠0 → p t∈upperHalfPlane)
+    (s : unitInterval) (hs : s<1) : ℝ :=
+  Classical.choose (exists_initial_driving_limit p hi h0 hH s hs)
+
+theorem initialDrivingValue_spec (p : C(unitInterval,ℂ)) (hi : Injective p)
+    (h0 : p 0=0) (hH : ∀ t : unitInterval, t≠0 → p t∈upperHalfPlane)
+    (s : unitInterval) (hs : s<1) :
+    Tendsto (fun r : ℝ => initialForwardChart p hi h0 hH s (p (slitFutureParameter s r)))
+      (𝓝[>] (0:ℝ)) (𝓝 ((initialDrivingValue p hi h0 hH s hs):ℂ)) :=
+  Classical.choose_spec (exists_initial_driving_limit p hi h0 hH s hs)
+
+@[simp] theorem initialDrivingValue_zero (p : C(unitInterval,ℂ)) (hi : Injective p)
+    (h0 : p 0=0) (hH : ∀ t : unitInterval, t≠0 → p t∈upperHalfPlane) :
+    initialDrivingValue p hi h0 hH 0 zero_lt_one=0 := by
+  have hz := initialDrivingValue_spec p hi h0 hH 0 zero_lt_one
+  have hC := (p.continuous.comp (slitFutureParameter_continuous 0)).tendsto 0
+    |>.mono_left (show 𝓝[>] (0:ℝ)≤𝓝 (0:ℝ) from inf_le_left)
+  simp only [initialForwardChart_zero,id_eq] at hz
+  change Tendsto (fun r => p (slitFutureParameter 0 r)) (𝓝[>] (0:ℝ))
+    (𝓝 (p (slitFutureParameter 0 0))) at hC
+  have he := tendsto_nhds_unique hz hC
+  simpa only [slitFutureParameter_zero,h0,ofReal_zero,initialForwardChart_zero,id_eq,
+    ofReal_eq_zero] using he
+
+end SLEExactGauge
+
+end
+
+end OAI
diff --git a/lean/OAI/Probability/SLE/Loewner/InitialDrivingRightContinuity.lean b/lean/OAI/Probability/SLE/Loewner/InitialDrivingRightContinuity.lean
new file mode 100644
index 0000000000000000000000000000000000000000..9792d60a6ce9b51acb195e9c2cc218f3be02f28a
--- /dev/null
+++ b/lean/OAI/Probability/SLE/Loewner/InitialDrivingRightContinuity.lean
@@ -0,0 +1,55 @@
+import OAI.Probability.SLE.Loewner.InitialDrivingIncrement
+import OAI.Probability.SLE.Loewner.FutureSlitRadius
+
+namespace OAI
+
+/-! Right continuity of the actual driving value follows from shrinking
+mapped future slits and the uniform boundary-coordinate estimate. -/
+noncomputable section
+open Set Filter Function Complex Metric
+open scoped Topology
+
+namespace SLEExactGauge
+
+noncomputable def initialDriving (p : C(unitInterval,ℂ)) (hi : Injective p)
+    (h0 : p 0=0) (hH : ∀ t : unitInterval, t≠0 → p t∈upperHalfPlane)
+    (s : unitInterval) : ℝ :=
+  if hs : s<1 then initialDrivingValue p hi h0 hH s hs else 0
+
+lemma initialDriving_of_lt (p : C(unitInterval,ℂ)) (hi : Injective p)
+    (h0 : p 0=0) (hH : ∀ t : unitInterval, t≠0 → p t∈upperHalfPlane)
+    {s : unitInterval} (hs : s<1) :
+    initialDriving p hi h0 hH s=initialDrivingValue p hi h0 hH s hs := dite_eq_left hs
+
+theorem initialDriving_continuousWithinAt_right (p : C(unitInterval,ℂ)) (hi : Injective p)
+    (h0 : p 0=0) (hH : ∀ t : unitInterval, t≠0 → p t∈upperHalfPlane)
+    {s : unitInterval} (hs : s<1) :
+    ContinuousWithinAt (initialDriving p hi h0 hH) (Ioi s) s := by
+  apply Metric.tendsto_nhds.mpr
+  intro ε hε
+  let C : ℝ := 512*Real.pi+9
+  have hC : 0<C := by dsimp only [C]; positivity
+  let R : ℝ := ε/(2*C)
+  have hR : 0<R := div_pos hε (mul_pos (by norm_num) hC)
+  obtain ⟨δ,hδ,hsmall⟩ := centeredFutureArc_small p hi h0 hH s hs hR
+  have htime : Tendsto (fun t : unitInterval => (t:ℝ)-(s:ℝ)) (𝓝[>] s) (𝓝 0) := by
+    have hc : Continuous (fun t : unitInterval => (t:ℝ)-(s:ℝ)) :=
+      continuous_subtype_val.sub continuous_const
+    have hh := (hc.tendsto s).mono_left (show 𝓝[>] s≤𝓝 s from inf_le_left)
+    simpa only [sub_self] using hh
+  filter_upwards [self_mem_nhdsWithin,htime.eventually (gt_mem_nhds hδ),
+    Filter.Eventually.filter_mono inf_le_left (gt_mem_nhds hs)] with t hst htd ht
+  rw [Real.dist_eq,initialDriving_of_lt p hi h0 hH ht,initialDriving_of_lt p hi h0 hH hs]
+  have hb := initialDriving_increment_bound p hi h0 hH hst ht hR (hsmall t hst ht htd)
+  apply hb.trans_lt
+  change C*R<ε
+  dsimp only [R]
+  have he : C*(ε/(2*C))=ε/2 := by field_simp
+  rw [he]
+  linarith
+
+end SLEExactGauge
+
+end
+
+end OAI
diff --git a/lean/OAI/Probability/SLE/Loewner/InitialDrivingTip.lean b/lean/OAI/Probability/SLE/Loewner/InitialDrivingTip.lean
new file mode 100644
index 0000000000000000000000000000000000000000..44da184bda8a4be3fa7fcd94a32361015143660e
--- /dev/null
+++ b/lean/OAI/Probability/SLE/Loewner/InitialDrivingTip.lean
@@ -0,0 +1,75 @@
+import OAI.Probability.SLE.Loewner.CapacityLoewnerIntegral
+import OAI.Probability.SLE.Loewner.SlitChartBoundaryExtension
+
+namespace OAI
+
+/-! The radial inverse limit at the proved driving value is the prescribed
+simple-arc tip. -/
+noncomputable section
+open Set Filter Function Complex
+open scoped Topology
+
+namespace SLEExactGauge
+
+theorem initialInverse_radial_driver_limit (p : C(unitInterval,ℂ)) (hi : Injective p)
+    (h0 : p 0=0) (hH : ∀ t : unitInterval, t≠0 → p t∈upperHalfPlane)
+    {s : unitInterval} (hs : s<1) :
+    Tendsto (fun y : ℝ => initialInverseChart p hi h0 hH s
+      ((initialDrivingValue p hi h0 hH s hs:ℂ)+(y:ℂ)*I))
+      (𝓝[>] (0:ℝ)) (𝓝 (p s)) := by
+  by_cases hs0 : s=0
+  · subst s
+    simp only [initialInverseChart_zero,initialDrivingValue_zero,ofReal_zero,zero_add,h0,id_eq]
+    have hh := (Complex.continuous_ofReal.tendsto 0).mul_const I
+    simpa only [ofReal_zero,zero_mul] using hh.mono_left nhdsWithin_le_nhds
+  obtain ⟨B,hB,hBF⟩ := (initialSlitChart p hi h0 hH s hs0).exists_boundary_extension
+  have hBe : ∀ z∈upperHalfPlane, B z=initialInverseChart p hi h0 hH s z := by
+    intro z hz
+    simpa only [initialInverseChart,dite_eq_right hs0] using hBF z hz
+  let u := initialDrivingValue p hi h0 hH s hs
+  have hG := initialDrivingValue_spec p hi h0 hH s hs
+  have hGmem : ∀ᶠ r : ℝ in 𝓝[>] (0:ℝ),
+      initialForwardChart p hi h0 hH s (p (slitFutureParameter s r))∈{z : ℂ | 0≤z.im} := by
+    filter_upwards [self_mem_nhdsWithin,mem_nhdsWithin_of_mem_nhds
+      (gt_mem_nhds (sub_pos.mpr (show (s:ℝ)<1 from hs)))] with r hr hrd
+    exact (show 0<(initialForwardChart p hi h0 hH s
+      (p (slitFutureParameter s r))).im from initialForwardChart_mem_upper p hi h0 hH s
+        (slitFuturePoint_mem_domain p hi hH s ⟨hr,hrd⟩)).le
+  have hBg := (hB (u:ℂ) (by simp)).tendsto.comp
+    (tendsto_nhdsWithin_iff.mpr ⟨hG,hGmem⟩)
+  have hphysical : Tendsto (fun r : ℝ => p (slitFutureParameter s r))
+      (𝓝[>] (0:ℝ)) (𝓝 (p s)) := by
+    have hc : Continuous (fun r : ℝ => p (slitFutureParameter s r)) :=
+      p.continuous.comp (slitFutureParameter_continuous s)
+    simpa only [slitFutureParameter_zero] using
+      (hc.tendsto 0).mono_left (show 𝓝[>] (0:ℝ)≤𝓝 (0:ℝ) from nhdsWithin_le_nhds)
+  have heq : B (u:ℂ)=p s := by
+    apply tendsto_nhds_unique hBg
+    apply hphysical.congr'
+    filter_upwards [self_mem_nhdsWithin,mem_nhdsWithin_of_mem_nhds
+      (gt_mem_nhds (sub_pos.mpr (show (s:ℝ)<1 from hs)))] with r hr hrd
+    have hd := slitFuturePoint_mem_domain p hi hH s (show r∈Ioo 0 (1-(s:ℝ)) from ⟨hr,hrd⟩)
+    symm
+    change B (initialForwardChart p hi h0 hH s (p (slitFutureParameter s r)))=
+      p (slitFutureParameter s r)
+    rw [hBe _ (initialForwardChart_mem_upper p hi h0 hH s hd),initialInverse_forward_at p hi h0 hH s hd]
+  have hzlim : Tendsto (fun y : ℝ => (u:ℂ)+(y:ℂ)*I) (𝓝[>] (0:ℝ)) (𝓝 (u:ℂ)) := by
+    have hc : Continuous (fun y : ℝ => (u:ℂ)+(y:ℂ)*I) :=
+      continuous_const.add (Complex.continuous_ofReal.mul continuous_const)
+    simpa only [ofReal_zero,zero_mul,add_zero] using
+      (hc.tendsto 0).mono_left
+        (show 𝓝[>] (0:ℝ)≤𝓝 (0:ℝ) from nhdsWithin_le_nhds)
+  have hzmem : ∀ᶠ y : ℝ in 𝓝[>] (0:ℝ), (u:ℂ)+(y:ℂ)*I∈{z : ℂ | 0≤z.im} := by
+    filter_upwards [self_mem_nhdsWithin] with y hy
+    simpa using hy.le
+  have hh := (hB (u:ℂ) (by simp)).tendsto.comp (tendsto_nhdsWithin_iff.mpr ⟨hzlim,hzmem⟩)
+  rw [heq] at hh
+  apply hh.congr'
+  filter_upwards [self_mem_nhdsWithin] with y hy
+  exact hBe _ (by simpa [upperHalfPlane] using hy)
+
+end SLEExactGauge
+
+end
+
+end OAI
diff --git a/lean/OAI/Probability/SLE/Loewner/InitialForwardBaseBounds.lean b/lean/OAI/Probability/SLE/Loewner/InitialForwardBaseBounds.lean
new file mode 100644
index 0000000000000000000000000000000000000000..c15f3c2ca397d98b41fa88ff8878c1014d3501cc
--- /dev/null
+++ b/lean/OAI/Probability/SLE/Loewner/InitialForwardBaseBounds.lean
@@ -0,0 +1,47 @@
+import OAI.Probability.SLE.Loewner.InitialForwardChart
+import OAI.Probability.SLE.Loewner.SlitChartVerticalBounds
+
+namespace OAI
+
+/-! Uniform interior control at a single exterior base point for every initial chart. -/
+noncomputable section
+open Set Filter Function Complex Metric
+open scoped Topology
+
+namespace SLEExactGauge
+
+lemma initialForwardChart_base_bounds (p : C(unitInterval,ℂ)) (hi : Injective p)
+    (h0 : p 0=0) (hH : ∀ t : unitInterval, t ≠ 0 → p t ∈ upperHalfPlane)
+    {R : ℝ} (hR : 0<R) (hp : ∀ u : unitInterval, ‖p u‖≤R) (t : unitInterval) :
+    3*R/2≤(initialForwardChart p hi h0 hH t (((2*R:ℝ):ℂ)*I)).im ∧
+      ‖initialForwardChart p hi h0 hH t (((2*R:ℝ):ℂ)*I)‖≤3*R := by
+  by_cases ht : t=0
+  · simp only [ht,initialForwardChart_zero,id_eq]
+    have hn : ‖((2*R:ℝ):ℂ)*I‖=2*R := by
+      simp [abs_of_pos hR]
+    rw [hn]
+    simp only [mul_im,ofReal_re,I_im,mul_one,ofReal_im,I_re,mul_zero,add_zero]
+    constructor <;> linarith
+  · rw [initialForwardChart,dite_eq_right ht]
+    apply (initialSlitChart p hi h0 hH t ht).vertical_base_bounds hR
+    intro u
+    exact hp (t*u)
+
+lemma initialForward_base_mem_domain (p : C(unitInterval,ℂ)) {R : ℝ}
+    (hR : 0<R) (hp : ∀ u : unitInterval, ‖p u‖≤R) :
+    (((2*R:ℝ):ℂ)*I)∈upperHalfPlane \ range p := by
+  have hn : ‖((2*R:ℝ):ℂ)*I‖=2*R := by
+    simp [abs_of_pos hR]
+  refine ⟨?_,?_⟩
+  · change 0<(((2*R:ℝ):ℂ)*I).im
+    simpa using mul_pos (by norm_num : (0:ℝ)<2) hR
+  · rintro ⟨u,hu⟩
+    have hh := hp u
+    rw [hu,hn] at hh
+    linarith
+
+end SLEExactGauge
+
+end
+
+end OAI
diff --git a/lean/OAI/Probability/SLE/Loewner/InitialForwardChart.lean b/lean/OAI/Probability/SLE/Loewner/InitialForwardChart.lean
new file mode 100644
index 0000000000000000000000000000000000000000..08dfd65fa82e342d457b876feed10de185ca99c1
--- /dev/null
+++ b/lean/OAI/Probability/SLE/Loewner/InitialForwardChart.lean
@@ -0,0 +1,76 @@
+import OAI.Probability.SLE.Loewner.InitialInverseChart
+import OAI.Probability.SLE.Geometry.HalfPlaneCayleyInverse
+
+namespace OAI
+
+/-! Forward maps for initial slits, all defined analytically on the final slit complement. -/
+noncomputable section
+open Set Filter Function Complex
+open scoped Topology
+
+namespace SLEExactGauge
+
+noncomputable def initialForwardChart (p : C(unitInterval,ℂ)) (hi : Injective p)
+    (h0 : p 0=0) (hH : ∀ t : unitInterval, t ≠ 0 → p t ∈ upperHalfPlane)
+    (t : unitInterval) : ℂ → ℂ :=
+  if ht : t=0 then id else (initialSlitChart p hi h0 hH t ht).forward
+
+@[simp] lemma initialForwardChart_zero (p : C(unitInterval,ℂ)) (hi : Injective p)
+    (h0 : p 0=0) (hH : ∀ t : unitInterval, t ≠ 0 → p t ∈ upperHalfPlane) :
+    initialForwardChart p hi h0 hH 0=id := by simp [initialForwardChart]
+
+lemma initialSubarc_range_subset (p : C(unitInterval,ℂ)) (t : unitInterval) :
+    range (initialSubarc p t) ⊆ range p := by
+  rintro _ ⟨u,rfl⟩
+  exact mem_range_self (t*u)
+
+lemma initialForwardChart_mapsTo (p : C(unitInterval,ℂ)) (hi : Injective p)
+    (h0 : p 0=0) (hH : ∀ t : unitInterval, t ≠ 0 → p t ∈ upperHalfPlane)
+    (t : unitInterval) :
+    MapsTo (initialForwardChart p hi h0 hH t) (upperHalfPlane \ range p) upperHalfPlane := by
+  intro z hz
+  by_cases ht : t=0
+  · simpa only [ht,initialForwardChart_zero,id_eq] using hz.1
+  · rw [initialForwardChart,dite_eq_right ht]
+    exact (initialSlitChart p hi h0 hH t ht).bijOn.mapsTo
+      ⟨hz.1,fun h => hz.2 (initialSubarc_range_subset p t h)⟩
+
+lemma initialForwardChart_differentiableOn (p : C(unitInterval,ℂ)) (hi : Injective p)
+    (h0 : p 0=0) (hH : ∀ t : unitInterval, t ≠ 0 → p t ∈ upperHalfPlane)
+    (t : unitInterval) :
+    DifferentiableOn ℂ (initialForwardChart p hi h0 hH t) (upperHalfPlane \ range p) := by
+  by_cases ht : t=0
+  · simp only [ht,initialForwardChart_zero]
+    exact differentiableOn_id
+  · rw [initialForwardChart,dite_eq_right ht]
+    exact (initialSlitChart p hi h0 hH t ht).forward_differentiable.mono
+      (fun _ hz => ⟨hz.1,fun h => hz.2 (initialSubarc_range_subset p t h)⟩)
+
+lemma initialInverse_forward_on_final (p : C(unitInterval,ℂ)) (hi : Injective p)
+    (h0 : p 0=0) (hH : ∀ t : unitInterval, t ≠ 0 → p t ∈ upperHalfPlane)
+    (t : unitInterval) {z : ℂ} (hz : z∈upperHalfPlane \ range p) :
+    initialInverseChart p hi h0 hH t (initialForwardChart p hi h0 hH t z)=z := by
+  by_cases ht : t=0
+  · simp [ht]
+  · rw [initialInverseChart,dite_eq_right ht,initialForwardChart,dite_eq_right ht]
+    exact (initialSlitChart p hi h0 hH t ht).left_inverse _
+      ⟨hz.1,fun h => hz.2 (initialSubarc_range_subset p t h)⟩
+
+lemma initialForward_inverse (p : C(unitInterval,ℂ)) (hi : Injective p)
+    (h0 : p 0=0) (hH : ∀ t : unitInterval, t ≠ 0 → p t ∈ upperHalfPlane)
+    (t : unitInterval) {z : ℂ} (hz : z∈upperHalfPlane) :
+    initialForwardChart p hi h0 hH t (initialInverseChart p hi h0 hH t z)=z := by
+  by_cases ht : t=0
+  · simp [ht]
+  · rw [initialForwardChart,dite_eq_right ht,initialInverseChart,dite_eq_right ht]
+    exact (initialSlitChart p hi h0 hH t ht).right_inverse _ hz
+
+lemma halfPlaneCayley_differentiableOn : DifferentiableOn ℂ halfPlaneCayley upperHalfPlane := by
+  apply (differentiableOn_id.sub_const I).div (differentiableOn_id.add_const I)
+  exact fun z hz => halfPlaneCayley_den_ne (show 0<z.im from hz).le
+
+end SLEExactGauge
+
+end
+
+end OAI
diff --git a/lean/OAI/Probability/SLE/Loewner/InitialForwardComparison.lean b/lean/OAI/Probability/SLE/Loewner/InitialForwardComparison.lean
new file mode 100644
index 0000000000000000000000000000000000000000..771492fc0e897df11c598e148ec4002e44229daf
--- /dev/null
+++ b/lean/OAI/Probability/SLE/Loewner/InitialForwardComparison.lean
@@ -0,0 +1,54 @@
+import OAI.Probability.SLE.Loewner.InitialInverseLimitAt
+
+namespace OAI
+
+/-! The complementary hydrodynamic mass, measured from the common final
+domain to each initial domain. -/
+noncomputable section
+open Set Filter Function
+open scoped Topology
+
+namespace SLEExactGauge
+
+lemma initialForward_comparison_to_final (p : C(unitInterval,ℂ)) (hi : Injective p)
+    (h0 : p 0=0) (hH : ∀ t : unitInterval, t ≠ 0 → p t ∈ upperHalfPlane)
+    (Q : SimpleSlitChart p) (t : unitInterval) {z : ℂ} (hz : z∈upperHalfPlane) :
+    ‖initialForwardChart p hi h0 hH t (Q.inverse z)-z‖≤
+      (Q.capacity-initialCapacity p hi h0 hH t)/z.im := by
+  by_cases ht : t=0
+  · simpa only [ht,initialForwardChart_zero,initialCapacity_zero,id_eq,sub_zero] using
+      Q.inverse_displacement hz
+  · rw [initialForwardChart,dite_eq_right ht,initialCapacity,dite_eq_right ht]
+    exact (initialSlitChart p hi h0 hH t ht).inverse_comparison Q
+      (initialSubarc_range_subset p t) hz
+
+lemma initialInverse_limit_forward_on_final (p : C(unitInterval,ℂ)) (hi : Injective p)
+    (h0 : p 0=0) (hH : ∀ t : unitInterval, t ≠ 0 → p t ∈ upperHalfPlane)
+    {t : ℕ → unitInterval} {F : ℂ → ℂ} (hF : DifferentiableOn ℂ F upperHalfPlane)
+    (hlim : TendstoLocallyUniformlyOn (fun n => initialInverseChart p hi h0 hH (t n))
+      F atTop upperHalfPlane) {s : unitInterval} (hs : s≠0) (ht : Tendsto t atTop (𝓝 s)) :
+    ∃ φ : ℕ → ℕ, StrictMono φ ∧ ∀ z∈upperHalfPlane \ range p,
+      Tendsto (fun n => initialForwardChart p hi h0 hH (t (φ n)) z)
+        atTop (𝓝 ((initialSlitChart p hi h0 hH s hs).forward z)) := by
+  let P := initialSlitChart p hi h0 hH s hs
+  have heF := initialInverse_limit_eq_at p hi h0 hH hF hlim hs ht
+  have hPinv : EqOn F P.inverse upperHalfPlane := by
+    simpa only [initialInverseChart,dite_eq_right hs] using heF
+  obtain ⟨φ,hφ,hforward⟩ := initialInverse_limit_forward_subsequence p hi h0 hH hF hlim
+  refine ⟨φ,hφ,fun z hz => ?_⟩
+  have hzP : z∈upperHalfPlane \ range (initialSubarc p s) :=
+    ⟨hz.1,fun hh => hz.2 (initialSubarc_range_subset p s hh)⟩
+  have hcov : SurjOn F upperHalfPlane (upperHalfPlane \ range p) :=
+    initialInverse_limit_covers_final_domain p hi h0 hH hF hlim
+  have he : invFunOn F upperHalfPlane z=P.forward z := by
+    apply initialInverse_limit_injOn p hi h0 hH hlim
+      (hcov.mapsTo_invFunOn hz) (P.bijOn.mapsTo hzP)
+    rw [hcov.rightInvOn_invFunOn hz,hPinv (P.bijOn.mapsTo hzP),P.left_inverse z hzP]
+  rw [← he]
+  exact hforward z hz
+
+end SLEExactGauge
+
+end
+
+end OAI
diff --git a/lean/OAI/Probability/SLE/Loewner/InitialForwardIncrement.lean b/lean/OAI/Probability/SLE/Loewner/InitialForwardIncrement.lean
new file mode 100644
index 0000000000000000000000000000000000000000..189f296fa436ca42cdb60b439360de0172d1fc38
--- /dev/null
+++ b/lean/OAI/Probability/SLE/Loewner/InitialForwardIncrement.lean
@@ -0,0 +1,59 @@
+import OAI.Probability.SLE.Loewner.FutureCapacityAdditive
+
+namespace OAI
+
+/-! Exact capacity increments control forward-map motion on the common
+surviving domain. -/
+noncomputable section
+open Set Filter Function Complex
+open scoped Topology
+
+namespace SLEExactGauge
+
+theorem initialForward_increment_bound (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)
+    {z : ℂ} (hz : z∈upperHalfPlane \ range (initialSubarc p t)) :
+    ‖initialForwardChart p hi h0 hH t z-initialForwardChart p hi h0 hH s z‖≤
+      (initialCapacity p hi h0 hH t-initialCapacity p hi h0 hH s)/
+        (initialForwardChart p hi h0 hH t z).im := by
+  let Q := futureSlitChart p hi h0 hH hst ht
+  let U := initialDrivingValue p hi h0 hH s (hst.trans ht)
+  let w := initialForwardChart p hi h0 hH s z-(U:ℂ)
+  have hw : w∈upperHalfPlane \ range (centeredFutureArc p hi h0 hH hst ht) :=
+    (initialForward_centered_bijOn p hi h0 hH hst ht).mapsTo hz
+  have hc : Q.capacity=initialCapacity p hi h0 hH t-initialCapacity p hi h0 hH s :=
+    futureSlitChart_capacity_eq p hi h0 hH hst ht
+  have he : (U:ℂ)+Q.forward w=initialForwardChart p hi h0 hH t z :=
+    futureComposedForward_eq p hi h0 hH hst ht hz
+  have him : (Q.forward w).im=(initialForwardChart p hi h0 hH t z).im := by
+    simpa only [add_im,ofReal_im,zero_add] using congrArg Complex.im he
+  have hd : Q.forward w-w=
+      initialForwardChart p hi h0 hH t z-initialForwardChart p hi h0 hH s z := by
+    dsimp only [w] at he ⊢
+    linear_combination he
+  have hb := Q.forward_displacement hw
+  rwa [hc,him,hd] at hb
+
+theorem initialForward_height_antitone (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)
+    {z : ℂ} (hz : z∈upperHalfPlane \ range (initialSubarc p t)) :
+    (initialForwardChart p hi h0 hH t z).im≤(initialForwardChart p hi h0 hH s z).im := by
+  obtain rfl | hst := hst.eq_or_lt
+  · exact le_rfl
+  let Q := futureSlitChart p hi h0 hH hst ht
+  let U := initialDrivingValue p hi h0 hH s (hst.trans ht)
+  have hw := (initialForward_centered_bijOn p hi h0 hH hst ht).mapsTo hz
+  have hb := Q.height_le _ hw
+  have he : (U:ℂ)+Q.forward (initialForwardChart p hi h0 hH s z-(U:ℂ))=
+      initialForwardChart p hi h0 hH t z := futureComposedForward_eq p hi h0 hH hst ht hz
+  have him := congrArg Complex.im he
+  simp only [add_im,ofReal_im,zero_add,sub_im,sub_zero] at hb him
+  rwa [← him]
+
+end SLEExactGauge
+
+end
+
+end OAI
diff --git a/lean/OAI/Probability/SLE/Loewner/InitialForwardJointContinuity.lean b/lean/OAI/Probability/SLE/Loewner/InitialForwardJointContinuity.lean
new file mode 100644
index 0000000000000000000000000000000000000000..6a1df12e846c3164f2e01dff884b764e4e7cefcc
--- /dev/null
+++ b/lean/OAI/Probability/SLE/Loewner/InitialForwardJointContinuity.lean
@@ -0,0 +1,48 @@
+import OAI.Probability.SLE.Loewner.InitialForwardTimeContinuity
+
+namespace OAI
+
+/-! The moving slit domain is open, and its actual forward coordinates
+depend continuously on both time and the surviving point. -/
+noncomputable section
+open Set Filter Function
+open scoped Topology
+
+namespace SLEExactGauge
+
+lemma isOpen_initialSlitDomain (p : C(unitInterval,ℂ)) :
+    IsOpen {a : unitInterval × ℂ | a.2∈upperHalfPlane \ range (initialSubarc p a.1)} := by
+  have hc : Continuous (fun a : unitInterval × unitInterval => (a.1,p (a.1*a.2))) :=
+    continuous_fst.prodMk (p.continuous.comp (continuous_fst.mul continuous_snd))
+  have hr : {a : unitInterval × ℂ | a.2∈range (initialSubarc p a.1)}=
+      range (fun a : unitInterval × unitInterval => (a.1,p (a.1*a.2))) := by
+    ext a
+    constructor
+    · rintro ⟨u,hu⟩
+      exact ⟨(a.1,u),Prod.ext rfl hu⟩
+    · rintro ⟨⟨s,u⟩,he⟩
+      obtain ⟨hs,hz⟩ := Prod.mk.inj he
+      dsimp only at hs hz
+      subst s
+      exact ⟨u,hz⟩
+  have hclosed : IsClosed {a : unitInterval × ℂ | a.2∈range (initialSubarc p a.1)} := by
+    rw [hr]
+    exact (isCompact_range hc).isClosed
+  exact (isOpen_upperHalfPlane.preimage continuous_snd).sdiff hclosed
+
+theorem initialForwardChart_joint_continuous (p : C(unitInterval,ℂ)) (hi : Injective p)
+    (h0 : p 0=0) (hH : ∀ t : unitInterval, t ≠ 0 → p t ∈ upperHalfPlane) :
+    Continuous (fun a : {a : unitInterval × ℂ |
+      a.2∈upperHalfPlane \ range (initialSubarc p a.1)} =>
+        initialForwardChart p hi h0 hH a.1.1 a.1.2) := by
+  apply SeqContinuous.continuous
+  intro v a hv
+  have ht := ((continuous_fst.comp continuous_subtype_val).tendsto a).comp hv
+  have hz := ((continuous_snd.comp continuous_subtype_val).tendsto a).comp hv
+  exact initialForwardChart_tendsto p hi h0 hH ht hz a.property (fun n => (v n).property)
+
+end SLEExactGauge
+
+end
+
+end OAI
diff --git a/lean/OAI/Probability/SLE/Loewner/InitialForwardKernel.lean b/lean/OAI/Probability/SLE/Loewner/InitialForwardKernel.lean
new file mode 100644
index 0000000000000000000000000000000000000000..894f2152069d4419b98f495048163e9c79f01d89
--- /dev/null
+++ b/lean/OAI/Probability/SLE/Loewner/InitialForwardKernel.lean
@@ -0,0 +1,50 @@
+import OAI.Probability.SLE.Loewner.SlitCapacityQuotient
+import OAI.Probability.SLE.Loewner.InitialForwardIncrement
+import OAI.Probability.SLE.Loewner.FutureSlitRadius
+
+namespace OAI
+
+/-! The exact chart composition turns the static small-slit estimate
+into an estimate for the evolving map's capacity difference quotient. -/
+noncomputable section
+open Set Filter Function Complex Metric
+open scoped Topology
+
+namespace SLEExactGauge
+
+theorem initialForward_quotient_kernel (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)
+    {z : ℂ} (hz : z∈upperHalfPlane \ range (initialSubarc p t))
+    {R : ℝ} (hR : 0<R)
+    (hp : ∀ u : unitInterval, ‖centeredFutureArc p hi h0 hH hst ht u‖<R)
+    (hn : 2*R≤‖initialForwardChart p hi h0 hH s z-
+      (initialDrivingValue p hi h0 hH s (hst.trans ht):ℂ)‖) :
+    ‖(initialForwardChart p hi h0 hH t z-initialForwardChart p hi h0 hH s z)/
+        ((initialCapacity p hi h0 hH t-initialCapacity p hi h0 hH s:ℝ):ℂ)-
+      1/(initialForwardChart p hi h0 hH s z-
+        (initialDrivingValue p hi h0 hH s (hst.trans ht):ℂ))‖≤
+      10*R/‖initialForwardChart p hi h0 hH s z-
+        (initialDrivingValue p hi h0 hH s (hst.trans ht):ℂ)‖^2 := by
+  let Q := futureSlitChart p hi h0 hH hst ht
+  let U := initialDrivingValue p hi h0 hH s (hst.trans ht)
+  let w := initialForwardChart p hi h0 hH s z-(U:ℂ)
+  have hw : w∈upperHalfPlane \ range (centeredFutureArc p hi h0 hH hst ht) :=
+    (initialForward_centered_bijOn p hi h0 hH hst ht).mapsTo hz
+  have hb := Q.forward_quotient_kernel
+    (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) hR hp hw.1 hn
+  have he : (U:ℂ)+Q.forward w=initialForwardChart p hi h0 hH t z :=
+    futureComposedForward_eq p hi h0 hH hst ht hz
+  have hd : Q.forward w-w=
+      initialForwardChart p hi h0 hH t z-initialForwardChart p hi h0 hH s z := by
+    dsimp only [w] at he ⊢
+    linear_combination he
+  rwa [hd,show Q.capacity=_ from futureSlitChart_capacity_eq p hi h0 hH hst ht] at hb
+
+end SLEExactGauge
+
+end
+
+end OAI
diff --git a/lean/OAI/Probability/SLE/Loewner/InitialForwardKernelLimit.lean b/lean/OAI/Probability/SLE/Loewner/InitialForwardKernelLimit.lean
new file mode 100644
index 0000000000000000000000000000000000000000..d81e5ab0e1f5e5a91d8785757bbe311cd6580197
--- /dev/null
+++ b/lean/OAI/Probability/SLE/Loewner/InitialForwardKernelLimit.lean
@@ -0,0 +1,65 @@
+import OAI.Probability.SLE.Loewner.InitialForwardKernel
+import OAI.Probability.SLE.Loewner.CapacityForwardDerivative
+
+namespace OAI
+
+/-! The exact capacity difference quotient tends to the Loewner
+kernel as the future slit shrinks to its driving point. -/
+noncomputable section
+open Set Filter Function Complex Metric
+open scoped Topology
+
+namespace SLEExactGauge
+
+theorem initialForward_quotient_tendsto (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)
+    {z : ℂ} (hz : z∈upperHalfPlane \ range (initialSubarc p T)) :
+    Tendsto (fun t : unitInterval =>
+      (initialForwardChart p hi h0 hH t z-initialForwardChart p hi h0 hH s z)/
+        ((initialCapacity p hi h0 hH t-initialCapacity p hi h0 hH s:ℝ):ℂ))
+      (𝓝[Ioc s T] s) (𝓝 (1/(initialForwardChart p hi h0 hH s z-
+        (initialDrivingValue p hi h0 hH s (hsT.trans hT):ℂ)))) := by
+  let w := initialForwardChart p hi h0 hH s z-
+    (initialDrivingValue p hi h0 hH s (hsT.trans hT):ℂ)
+  have hzS : z∈upperHalfPlane \ range (initialSubarc p s) :=
+    ⟨hz.1,fun hh => hz.2 (initialSubarc_range_mono p hsT.le hh)⟩
+  have hwim : 0<w.im := by
+    simpa only [w,sub_im,ofReal_im,sub_zero] using
+      initialForwardChart_im_pos p hi h0 hH s hzS
+  have hwn : 0<‖w‖ := hwim.trans_le ((le_abs_self w.im).trans (abs_im_le_norm w))
+  have hw2 : 0<‖w‖^2 := sq_pos_of_pos hwn
+  apply Metric.tendsto_nhds.mpr
+  intro ε hε
+  let R := min (‖w‖/4) (ε*‖w‖^2/20)
+  have hR : 0<R := lt_min (by positivity) (by positivity)
+  have hRn : 2*R≤‖w‖ := by
+    have hh := min_le_left (‖w‖/4) (ε*‖w‖^2/20)
+    change R≤‖w‖/4 at hh
+    linarith
+  have hRe : 10*R/‖w‖^2<ε := by
+    have hh := min_le_right (‖w‖/4) (ε*‖w‖^2/20)
+    change R≤ε*‖w‖^2/20 at hh
+    apply (div_lt_iff₀ hw2).mpr
+    nlinarith [mul_pos hε hw2]
+  obtain ⟨δ,hδ,hsmall⟩ := centeredFutureArc_small p hi h0 hH s (hsT.trans hT) hR
+  have htime : Tendsto (fun t : unitInterval => (t:ℝ)-(s:ℝ)) (𝓝[Ioc s T] s) (𝓝 0) := by
+    have hcont : Continuous (fun t : unitInterval => (t:ℝ)-(s:ℝ)) :=
+      continuous_subtype_val.sub continuous_const
+    have hh := (hcont.tendsto s).mono_left
+      (show 𝓝[Ioc s T] s≤𝓝 s from inf_le_left)
+    simpa only [sub_self] using hh
+  filter_upwards [self_mem_nhdsWithin,htime.eventually (gt_mem_nhds hδ)] with t ht htd
+  have htt : t<1 := ht.2.trans_lt hT
+  have hzt : z∈upperHalfPlane \ range (initialSubarc p t) :=
+    ⟨hz.1,fun hh => hz.2 (initialSubarc_range_mono p ht.2 hh)⟩
+  have hb := initialForward_quotient_kernel p hi h0 hH ht.1 htt hzt hR
+    (hsmall t ht.1 htt htd) hRn
+  rw [dist_eq_norm]
+  exact hb.trans_lt hRe
+
+end SLEExactGauge
+
+end
+
+end OAI
diff --git a/lean/OAI/Probability/SLE/Loewner/InitialForwardLimit.lean b/lean/OAI/Probability/SLE/Loewner/InitialForwardLimit.lean
new file mode 100644
index 0000000000000000000000000000000000000000..2c128c93d6e710f4cd8b72ae050b035086ca432e
--- /dev/null
+++ b/lean/OAI/Probability/SLE/Loewner/InitialForwardLimit.lean
@@ -0,0 +1,53 @@
+import OAI.Probability.SLE.Loewner.InitialForwardNormalFamily
+import OAI.Probability.SLE.Loewner.InitialForwardBaseBounds
+import OAI.Probability.SLE.Geometry.HolomorphicDiskInterior
+
+namespace OAI
+
+/-! Limits of the compactified forward charts stay in the open disk. -/
+noncomputable section
+open Set Filter Function Complex Metric
+open scoped Topology
+
+namespace SLEExactGauge
+
+lemma initialForwardCayley_limit_interior (p : C(unitInterval,ℂ)) (hi : Injective p)
+    (h0 : p 0=0) (hH : ∀ t : unitInterval, t ≠ 0 → p t ∈ upperHalfPlane)
+    {t : ℕ → unitInterval} {A : ℂ → ℂ}
+    (hA : DifferentiableOn ℂ A (upperHalfPlane \ range p))
+    (hlim : TendstoLocallyUniformlyOn
+      (fun n z => halfPlaneCayley (initialForwardChart p hi h0 hH (t n) z))
+      A atTop (upperHalfPlane \ range p)) :
+    ∀ z∈upperHalfPlane \ range p, ‖A z‖<1 := by
+  obtain ⟨R0,hR0⟩ := (isCompact_range p.continuous).isBounded.exists_norm_le
+  let R := max R0 1
+  have hR : 0<R := lt_of_lt_of_le zero_lt_one (le_max_right _ _)
+  have hp (u : unitInterval) : ‖p u‖≤R := (hR0 _ (mem_range_self u)).trans (le_max_left _ _)
+  let b : ℂ := ((2*R:ℝ):ℂ)*I
+  have hb : b∈upperHalfPlane \ range p := initialForward_base_mem_domain p hR hp
+  have hbound (n : ℕ) := initialForwardChart_base_bounds p hi h0 hH hR hp (t n)
+  obtain ⟨v,_,φ,hφ,hv⟩ := (isCompact_closedBall (0:ℂ) (3*R)).tendsto_subseq (fun n => by
+    rw [mem_closedBall,dist_zero_right]
+    exact (hbound n).2)
+  have hvim : 3*R/2≤v.im := ge_of_tendsto (continuous_im.continuousAt.tendsto.comp hv)
+    (Eventually.of_forall fun n => (hbound (φ n)).1)
+  have hvH : v∈upperHalfPlane := lt_of_lt_of_le (by positivity : 0<3*R/2) hvim
+  have he : A b=halfPlaneCayley v := by
+    apply tendsto_nhds_unique ((hlim.tendsto_at hb).comp hφ.tendsto_atTop)
+    exact (halfPlaneCayley_differentiableOn.continuousOn v hvH).continuousAt
+      (isOpen_upperHalfPlane.mem_nhds hvH) |>.tendsto.comp hv
+  have hAb : ‖A b‖<1 := by rw [he]; exact halfPlaneCayley_norm_lt hvH
+  have hnorm : ∀ z∈upperHalfPlane \ range p, ‖A z‖≤1 := by
+    intro z hz
+    apply le_of_tendsto (hlim.tendsto_at hz).norm
+    exact Eventually.of_forall fun n => (halfPlaneCayley_norm_lt
+      (initialForwardChart_mapsTo p hi h0 hH (t n) hz)).le
+  exact holomorphic_disk_strict_of_point
+    (isOpen_upperHalfPlane.sdiff (isCompact_range p.continuous).isClosed)
+    (simple_arc_halfPlane_complement_connected p hi h0 hH).isPreconnected hA hnorm hb hAb
+
+end SLEExactGauge
+
+end
+
+end OAI
diff --git a/lean/OAI/Probability/SLE/Loewner/InitialForwardNormalFamily.lean b/lean/OAI/Probability/SLE/Loewner/InitialForwardNormalFamily.lean
new file mode 100644
index 0000000000000000000000000000000000000000..e57dda6a8605ed7c9fa4047573e3b61b63ed2723
--- /dev/null
+++ b/lean/OAI/Probability/SLE/Loewner/InitialForwardNormalFamily.lean
@@ -0,0 +1,37 @@
+import OAI.Probability.SLE.Loewner.InitialForwardChart
+import OAI.Probability.SLE.Loewner.InitialInverseNormalFamily
+
+namespace OAI
+
+/-! The compactified forward charts form a bounded normal family on the final domain. -/
+noncomputable section
+open Set Filter Function
+open scoped Topology
+
+namespace SLEExactGauge
+
+theorem initialForwardCayley_subsequence (p : C(unitInterval,ℂ)) (hi : Injective p)
+    (h0 : p 0=0) (hH : ∀ t : unitInterval, t ≠ 0 → p t ∈ upperHalfPlane)
+    (t : ℕ → unitInterval) :
+    ∃ (φ : ℕ → ℕ) (F : ℂ → ℂ), StrictMono φ ∧
+      DifferentiableOn ℂ F (upperHalfPlane \ range p) ∧
+      TendstoLocallyUniformlyOn
+        (fun n z => halfPlaneCayley (initialForwardChart p hi h0 hH (t (φ n)) z))
+        F atTop (upperHalfPlane \ range p) := by
+  have hD : IsOpen (upperHalfPlane \ range p) :=
+    isOpen_upperHalfPlane.sdiff (isCompact_range p.continuous).isClosed
+  apply TauCeti.montel (F := fun n z => halfPlaneCayley (initialForwardChart p hi h0 hH (t n) z)) hD
+  · intro n
+    exact halfPlaneCayley_differentiableOn.comp
+      (initialForwardChart_differentiableOn p hi h0 hH (t n))
+      (initialForwardChart_mapsTo p hi h0 hH (t n))
+  · apply TauCeti.isLocallyBoundedOn_of_forall_norm_le (C := 1)
+    intro n z hz
+    exact (halfPlaneCayley_norm_lt
+      (initialForwardChart_mapsTo p hi h0 hH (t n) hz)).le
+
+end SLEExactGauge
+
+end
+
+end OAI
diff --git a/lean/OAI/Probability/SLE/Loewner/InitialForwardRecovery.lean b/lean/OAI/Probability/SLE/Loewner/InitialForwardRecovery.lean
new file mode 100644
index 0000000000000000000000000000000000000000..5969a14734ca00de2ab51fd0c4ee4c716d20db43
--- /dev/null
+++ b/lean/OAI/Probability/SLE/Loewner/InitialForwardRecovery.lean
@@ -0,0 +1,41 @@
+import OAI.Probability.SLE.Loewner.InitialForwardLimit
+
+namespace OAI
+
+/-! Recover actual forward coordinates from their compactified limits. -/
+noncomputable section
+open Set Filter Function Complex
+open scoped Topology
+
+namespace SLEExactGauge
+
+lemma initialForward_limit_tendsto (p : C(unitInterval,ℂ)) (hi : Injective p)
+    (h0 : p 0=0) (hH : ∀ t : unitInterval, t ≠ 0 → p t ∈ upperHalfPlane)
+    {t : ℕ → unitInterval} {A : ℂ → ℂ}
+    (hA : DifferentiableOn ℂ A (upperHalfPlane \ range p))
+    (hlim : TendstoLocallyUniformlyOn
+      (fun n z => halfPlaneCayley (initialForwardChart p hi h0 hH (t n) z))
+      A atTop (upperHalfPlane \ range p)) {z : ℂ} (hz : z∈upperHalfPlane \ range p) :
+    Tendsto (fun n => initialForwardChart p hi h0 hH (t n) z)
+      atTop (𝓝 (halfPlaneCayleyInv (A z))) := by
+  have hn := initialForwardCayley_limit_interior p hi h0 hH hA hlim z hz
+  have hne : A z≠1 := by
+    intro he
+    simp only [he,norm_one,lt_self_iff_false] at hn
+  have hc : ContinuousAt halfPlaneCayleyInv (A z) := by
+    apply (continuousAt_const.mul (continuousAt_const.add continuousAt_id)).div
+      (continuousAt_const.sub continuousAt_id)
+    exact sub_ne_zero.mpr hne.symm
+  have ht := hc.tendsto.comp (hlim.tendsto_at hz)
+  apply ht.congr
+  intro n
+  exact halfPlaneCayleyInv_cayley
+    (show 0≤(initialForwardChart p hi h0 hH (t n) z).im from
+      (show 0<(initialForwardChart p hi h0 hH (t n) z).im from
+        initialForwardChart_mapsTo p hi h0 hH (t n) hz).le)
+
+end SLEExactGauge
+
+end
+
+end OAI
diff --git a/lean/OAI/Probability/SLE/Loewner/InitialForwardTimeContinuity.lean b/lean/OAI/Probability/SLE/Loewner/InitialForwardTimeContinuity.lean
new file mode 100644
index 0000000000000000000000000000000000000000..d48206791186c894ce2b43554079973ee11f140d
--- /dev/null
+++ b/lean/OAI/Probability/SLE/Loewner/InitialForwardTimeContinuity.lean
@@ -0,0 +1,53 @@
+import OAI.Probability.SLE.Loewner.InitialInverseTimeContinuity
+import OAI.Probability.SLE.Loewner.InitialChartIdentities
+
+namespace OAI
+
+/-! Continuity of the forward coordinates along any sequence of surviving
+points, using the actual inverse charts and Hurwitz's theorem. -/
+noncomputable section
+open Set Filter Function Metric
+open scoped Topology
+
+namespace SLEExactGauge
+
+theorem initialForwardChart_tendsto (p : C(unitInterval,ℂ)) (hi : Injective p)
+    (h0 : p 0=0) (hH : ∀ t : unitInterval, t ≠ 0 → p t ∈ upperHalfPlane)
+    {t : ℕ → unitInterval} {s : unitInterval} (ht : Tendsto t atTop (𝓝 s))
+    {z : ℕ → ℂ} {a : ℂ} (hz : Tendsto z atTop (𝓝 a))
+    (ha : a∈upperHalfPlane \ range (initialSubarc p s))
+    (hzD : ∀ n, z n∈upperHalfPlane \ range (initialSubarc p (t n))) :
+    Tendsto (fun n => initialForwardChart p hi h0 hH (t n) (z n))
+      atTop (𝓝 (initialForwardChart p hi h0 hH s a)) := by
+  have hbase := initialInverseChart_locallyUniform_continuous p hi h0 hH s
+  have hconv : TendstoLocallyUniformlyOn (fun n => initialInverseChart p hi h0 hH (t n))
+      (initialInverseChart p hi h0 hH s) atTop upperHalfPlane := by
+    intro U hU w hw
+    obtain ⟨V,hV,hN⟩ := hbase U hU w hw
+    exact ⟨V,hV,ht.eventually hN⟩
+  have hconst := hz.tendstoUniformlyOn_const upperHalfPlane |>.tendstoLocallyUniformlyOn
+  have hdiff := hconv.sub hconst
+  have hnc : ¬ ∀ w∈upperHalfPlane, initialInverseChart p hi h0 hH s w-a=0 := by
+    intro h
+    exact initialInverse_limit_not_constant p hi h0 hH hconv a
+      (fun w hw => sub_eq_zero.mp (h w hw))
+  apply Metric.tendsto_nhds.mpr
+  intro ε hε
+  have hevent := TauCeti.hurwitz_eventually_exists_eq_zero isOpen_upperHalfPlane
+    (convex_halfSpace_im_gt (0:ℝ)).isPreconnected
+    (Eventually.of_forall fun n => (initialInverseChart_differentiableOn p hi h0 hH (t n)).sub_const (z n))
+    hdiff (initialForwardChart_mem_upper p hi h0 hH s ha)
+    (sub_eq_zero.mpr (initialInverse_forward_at p hi h0 hH s ha)) hnc hε
+  filter_upwards [hevent] with n hn
+  obtain ⟨w,hw,hew⟩ := hn
+  have he : w=initialForwardChart p hi h0 hH (t n) (z n) := by
+    apply initialInverseChart_injOn p hi h0 hH (t n) hw.1
+      (initialForwardChart_mem_upper p hi h0 hH (t n) (hzD n))
+    exact (sub_eq_zero.mp hew).trans (initialInverse_forward_at p hi h0 hH (t n) (hzD n)).symm
+  simpa only [← he,mem_ball] using hw.2
+
+end SLEExactGauge
+
+end
+
+end OAI
diff --git a/lean/OAI/Probability/SLE/Loewner/InitialHeightCapacityIncrement.lean b/lean/OAI/Probability/SLE/Loewner/InitialHeightCapacityIncrement.lean
new file mode 100644
index 0000000000000000000000000000000000000000..7353d7bd2fc7effbecb08a2d2f233eab1dfc8094
--- /dev/null
+++ b/lean/OAI/Probability/SLE/Loewner/InitialHeightCapacityIncrement.lean
@@ -0,0 +1,41 @@
+import OAI.Probability.SLE.Loewner.ForwardHeightSquareIncrement
+
+namespace OAI
+
+/-! Height loss on a surviving initial-slit prefix is bounded by twice
+the exact capacity increment. -/
+noncomputable section
+open Set Filter Function Complex
+open scoped Topology
+
+namespace SLEExactGauge
+
+theorem initialForward_height_capacity_increment (p : C(unitInterval,ℂ)) (hi : Injective p)
+    (h0 : p 0=0) (hH : ∀ t : unitInterval, t≠0 → p t∈upperHalfPlane)
+    {s r T : unitInterval} (hsr : s≤r) (hrT : r≤T) (hT : T<1)
+    {z : ℂ} (hz : z∈upperHalfPlane \ range (initialSubarc p T)) :
+    (initialForwardChart p hi h0 hH s z).im^2≤
+      (initialForwardChart p hi h0 hH r z).im^2+
+        2*(initialCapacity p hi h0 hH r-initialCapacity p hi h0 hH s) := by
+  have ha := initialCapacity_nonneg p hi h0 hH s
+  have hsr' := initialCapacity_monotone p hi h0 hH hsr
+  have hrT' := initialCapacity_monotone p hi h0 hH hrT
+  have hc : ContinuousOn (capacityForwardOnPrefix p hi h0 hH T z)
+      (Icc (initialCapacity p hi h0 hH s) (initialCapacity p hi h0 hH r)) :=
+    (capacityForwardOnPrefix_lipschitz p hi h0 hH hT hz).continuous.continuousOn
+  have hd (c : ℝ) (hcc : c∈Ico (initialCapacity p hi h0 hH s)
+      (initialCapacity p hi h0 hH r)) :
+      HasDerivWithinAt (capacityForwardOnPrefix p hi h0 hH T z)
+        (1/(capacityForwardOnPrefix p hi h0 hH T z c-
+          (capacityDriverOnPrefix p hi h0 hH T hT c:ℂ))) (Ici c) c :=
+    capacityForward_hasDerivWithinAt_Ici p hi h0 hH hT hz
+      ⟨ha.trans hcc.1,hcc.2.trans_le hrT'⟩
+  have hh := height_square_increment hsr' hc hd
+  simpa only [capacityForwardOnPrefix_at_initialCapacity p hi h0 hH T z (hsr.trans hrT),
+    capacityForwardOnPrefix_at_initialCapacity p hi h0 hH T z hrT] using hh
+
+end SLEExactGauge
+
+end
+
+end OAI
diff --git a/lean/OAI/Probability/SLE/Loewner/InitialInverseChart.lean b/lean/OAI/Probability/SLE/Loewner/InitialInverseChart.lean
new file mode 100644
index 0000000000000000000000000000000000000000..3d45701417dbeaac546c9e833922262973399f3f
--- /dev/null
+++ b/lean/OAI/Probability/SLE/Loewner/InitialInverseChart.lean
@@ -0,0 +1,71 @@
+import OAI.Probability.SLE.Loewner.SlitChartDisplacement
+import OAI.Probability.SLE.Loewner.InitialCapacityAtZero
+
+namespace OAI
+
+/-! The actual normalized inverse charts of initial subarcs start at the identity. -/
+noncomputable section
+open Set Filter Function Metric
+open scoped Topology
+
+namespace SLEExactGauge
+
+noncomputable def initialInverseChart (p : C(unitInterval,ℂ)) (hi : Injective p)
+    (h0 : p 0=0) (hH : ∀ t : unitInterval, t ≠ 0 → p t ∈ upperHalfPlane)
+    (t : unitInterval) : ℂ → ℂ :=
+  if ht : t=0 then id else (initialSlitChart p hi h0 hH t ht).inverse
+
+@[simp] lemma initialInverseChart_zero (p : C(unitInterval,ℂ)) (hi : Injective p)
+    (h0 : p 0=0) (hH : ∀ t : unitInterval, t ≠ 0 → p t ∈ upperHalfPlane) :
+    initialInverseChart p hi h0 hH 0=id := by simp [initialInverseChart]
+
+lemma initialInverseChart_differentiableOn (p : C(unitInterval,ℂ)) (hi : Injective p)
+    (h0 : p 0=0) (hH : ∀ t : unitInterval, t ≠ 0 → p t ∈ upperHalfPlane)
+    (t : unitInterval) : DifferentiableOn ℂ (initialInverseChart p hi h0 hH t) upperHalfPlane := by
+  by_cases ht : t=0
+  · simp only [ht,initialInverseChart_zero]
+    exact differentiableOn_id
+  · rw [initialInverseChart,dite_eq_right ht]
+    exact (initialSlitChart p hi h0 hH t ht).inverse_differentiable
+
+lemma initialInverseChart_displacement (p : C(unitInterval,ℂ)) (hi : Injective p)
+    (h0 : p 0=0) (hH : ∀ t : unitInterval, t ≠ 0 → p t ∈ upperHalfPlane)
+    (t : unitInterval) {z : ℂ} (hz : z∈upperHalfPlane) :
+    ‖initialInverseChart p hi h0 hH t z-z‖≤ initialCapacity p hi h0 hH t/z.im := by
+  by_cases ht : t=0
+  · simp [ht]
+  · rw [initialInverseChart,dite_eq_right ht,initialCapacity,dite_eq_right ht]
+    exact (initialSlitChart p hi h0 hH t ht).inverse_displacement hz
+
+lemma compact_upperHalfPlane_min_height {K : Set ℂ} (hK : IsCompact K)
+    (hKH : K ⊆ upperHalfPlane) (hne : K.Nonempty) :
+    ∃ m : ℝ, 0< m ∧ ∀ z∈K, m≤ z.im := by
+  obtain ⟨z,hz,hmin⟩ := hK.exists_isMinOn hne Complex.continuous_im.continuousOn
+  exact ⟨z.im,hKH hz,fun w hw => hmin hw⟩
+
+theorem initialInverseChart_tendsto_identity (p : C(unitInterval,ℂ)) (hi : Injective p)
+    (h0 : p 0=0) (hH : ∀ t : unitInterval, t ≠ 0 → p t ∈ upperHalfPlane) :
+    TendstoLocallyUniformlyOn (initialInverseChart p hi h0 hH) id (𝓝 0) upperHalfPlane := by
+  rw [tendstoLocallyUniformlyOn_iff_forall_isCompact isOpen_upperHalfPlane]
+  intro K hKH hK
+  by_cases hne : K.Nonempty
+  · obtain ⟨m,hm,hmin⟩ := compact_upperHalfPlane_min_height hK hKH hne
+    have hcap : Tendsto (initialCapacity p hi h0 hH) (𝓝 0) (𝓝 0) := by
+      simpa only [initialCapacity_zero] using (initialCapacity_continuousAt_zero p hi h0 hH).tendsto
+    have hsmall : Tendsto (fun t => initialCapacity p hi h0 hH t/m) (𝓝 0) (𝓝 0) := by
+      simpa only [zero_div] using hcap.div_const m
+    rw [Metric.tendstoUniformlyOn_iff]
+    intro ε hε
+    filter_upwards [hsmall.eventually (gt_mem_nhds hε)] with t ht
+    intro z hz
+    rw [dist_eq_norm,show id z=z from rfl,norm_sub_rev]
+    exact ((initialInverseChart_displacement p hi h0 hH t (hKH hz)).trans
+      (div_le_div_of_nonneg_left (initialCapacity_nonneg p hi h0 hH t) hm (hmin z hz))).trans_lt ht
+  · simpa only [not_nonempty_iff_eq_empty.mp hne] using
+      (tendstoUniformlyOn_empty : TendstoUniformlyOn (initialInverseChart p hi h0 hH) id (𝓝 0) ∅)
+
+end SLEExactGauge
+
+end
+
+end OAI
diff --git a/lean/OAI/Probability/SLE/Loewner/InitialInverseCommonDomain.lean b/lean/OAI/Probability/SLE/Loewner/InitialInverseCommonDomain.lean
new file mode 100644
index 0000000000000000000000000000000000000000..494167874ae6288514d89c2a7ce2ff03c202c9a9
--- /dev/null
+++ b/lean/OAI/Probability/SLE/Loewner/InitialInverseCommonDomain.lean
@@ -0,0 +1,45 @@
+import OAI.Probability.SLE.Loewner.InitialForwardRecovery
+import OAI.Probability.SLE.Loewner.InitialInverseLimit
+import OAI.Probability.SLE.Geometry.LocallyUniformEvaluation
+
+namespace OAI
+
+/-! Every inverse-chart limit covers the common final slit domain.
+No convergence of the times, nor a boundary driving value, is assumed here. -/
+noncomputable section
+open Set Filter Function Complex
+open scoped Topology
+
+namespace SLEExactGauge
+
+theorem initialInverse_limit_covers_final_domain (p : C(unitInterval,ℂ)) (hi : Injective p)
+    (h0 : p 0=0) (hH : ∀ t : unitInterval, t ≠ 0 → p t ∈ upperHalfPlane)
+    {t : ℕ → unitInterval} {F : ℂ → ℂ}
+    (hF : DifferentiableOn ℂ F upperHalfPlane)
+    (hlim : TendstoLocallyUniformlyOn (fun n => initialInverseChart p hi h0 hH (t n))
+      F atTop upperHalfPlane) :
+    ∀ z∈upperHalfPlane \ range p, ∃ w∈upperHalfPlane, F w=z := by
+  obtain ⟨φ,A,hφ,hA,hAlim⟩ := initialForwardCayley_subsequence p hi h0 hH t
+  have hFsub := locallyUniform_reindex hlim hφ.tendsto_atTop
+  intro z hz
+  have hAz := initialForwardCayley_limit_interior p hi h0 hH hA hAlim z hz
+  have hw : halfPlaneCayleyInv (A z)∈upperHalfPlane := halfPlaneCayleyInv_open hAz
+  refine ⟨halfPlaneCayleyInv (A z),hw,?_⟩
+  have hforward := initialForward_limit_tendsto p hi h0 hH hA hAlim hz
+  have heval := locallyUniform_evaluation_tendsto isOpen_upperHalfPlane
+    hF.continuousOn hFsub hw hforward
+  have hconstant : Tendsto (fun n => initialInverseChart p hi h0 hH (t (φ n))
+      (initialForwardChart p hi h0 hH (t (φ n)) z)) atTop (𝓝 z) := by
+    have he : (fun n => initialInverseChart p hi h0 hH (t (φ n))
+        (initialForwardChart p hi h0 hH (t (φ n)) z)) = (fun _ : ℕ => z) := by
+      funext n
+      exact initialInverse_forward_on_final p hi h0 hH (t (φ n)) hz
+    rw [he]
+    exact tendsto_const_nhds
+  exact tendsto_nhds_unique heval hconstant
+
+end SLEExactGauge
+
+end
+
+end OAI
diff --git a/lean/OAI/Probability/SLE/Loewner/InitialInverseEnergyBound.lean b/lean/OAI/Probability/SLE/Loewner/InitialInverseEnergyBound.lean
new file mode 100644
index 0000000000000000000000000000000000000000..05e51f45f005aebeedd0447551f3259c776a8fb3
--- /dev/null
+++ b/lean/OAI/Probability/SLE/Loewner/InitialInverseEnergyBound.lean
@@ -0,0 +1,52 @@
+import OAI.Probability.SLE.Loewner.SlitUniformInverseBound
+import OAI.Probability.SLE.Loewner.InverseDirichletEnergy
+
+namespace OAI
+
+/-! A common finite Dirichlet-energy bound for the whole initial inverse
+family on a fixed upper half-disk. -/
+noncomputable section
+open Set Filter Function Complex Metric MeasureTheory
+open scoped Topology ENNReal
+
+namespace SLEExactGauge
+
+theorem initialInverse_dirichlet_bound (p : C(unitInterval,ℂ)) (hi : Injective p)
+    (h0 : p 0=0) (hH : ∀ t : unitInterval, t≠0 → p t∈upperHalfPlane)
+    {R : ℝ} (hR : 0<R) (hp : ∀ t : unitInterval, ‖p t‖<R)
+    (s : unitInterval) (A : ℝ) :
+    (∫⁻ z in upperHalfPlane ∩ ball (0:ℂ) A,
+      ENNReal.ofReal (‖deriv (initialInverseChart p hi h0 hH s) z‖^2))≤
+        volume (closedBall (0:ℂ) (A+3*R)) := by
+  let F := initialInverseChart p hi h0 hH s
+  let S := upperHalfPlane ∩ ball (0:ℂ) A
+  have hS : MeasurableSet S := isOpen_upperHalfPlane.measurableSet.inter measurableSet_ball
+  have hd (z : ℂ) (hz : z∈S) : HasDerivAt F (deriv F z) z :=
+    ((initialInverseChart_differentiableOn p hi h0 hH s).differentiableAt
+      (isOpen_upperHalfPlane.mem_nhds hz.1)).hasDerivAt
+  have hinj : InjOn F S := by
+    intro z hz w hw he
+    have hz' := initialForward_inverse p hi h0 hH s hz.1
+    have hw' := initialForward_inverse p hi h0 hH s hw.1
+    change initialForwardChart p hi h0 hH s (F z)=z at hz'
+    change initialForwardChart p hi h0 hH s (F w)=w at hw'
+    rw [he,hw'] at hz'
+    exact hz'.symm
+  have he : (∫⁻ z in S, ENNReal.ofReal (‖deriv F z‖^2))=volume (F '' S) := by
+    have hh := lintegral_abs_det_fderiv_eq_addHaar_image volume hS
+      (fun z hz => ((hd z hz).hasFDerivAt.restrictScalars ℝ).hasFDerivWithinAt) hinj
+    simpa only [complex_derivative_real_det,abs_pow,abs_norm] using hh
+  change (∫⁻ z in S, ENNReal.ofReal (‖deriv F z‖^2))≤_
+  rw [he]
+  apply measure_mono
+  rintro _ ⟨z,hz,rfl⟩
+  rw [mem_closedBall_zero_iff]
+  have hb := initialInverse_uniform_bound p hi h0 hH hR hp s hz.1
+  have hzA : ‖z‖<A := mem_ball_zero_iff.mp hz.2
+  exact hb.trans (by linarith)
+
+end SLEExactGauge
+
+end
+
+end OAI
diff --git a/lean/OAI/Probability/SLE/Loewner/InitialInverseEnergyIntegral.lean b/lean/OAI/Probability/SLE/Loewner/InitialInverseEnergyIntegral.lean
new file mode 100644
index 0000000000000000000000000000000000000000..b5fcb546bb6b6606557f6783352255d09557319f
--- /dev/null
+++ b/lean/OAI/Probability/SLE/Loewner/InitialInverseEnergyIntegral.lean
@@ -0,0 +1,41 @@
+import OAI.Probability.SLE.Loewner.InitialInverseEnergyBound
+
+namespace OAI
+
+/-! Real, integrable versions of the common inverse Dirichlet bound. -/
+noncomputable section
+open Set Filter Function Complex Metric MeasureTheory
+open scoped Topology ENNReal
+
+namespace SLEExactGauge
+
+lemma initialInverse_energy_integrable (p : C(unitInterval,ℂ)) (hi : Injective p)
+    (h0 : p 0=0) (hH : ∀ t : unitInterval, t≠0 → p t∈upperHalfPlane)
+    {R : ℝ} (hR : 0<R) (hp : ∀ t : unitInterval, ‖p t‖<R)
+    (s : unitInterval) (A : ℝ) :
+    IntegrableOn (fun z => ‖deriv (initialInverseChart p hi h0 hH s) z‖^2)
+      (upperHalfPlane ∩ ball (0:ℂ) A) := by
+  have hm : Measurable (fun z => ‖deriv (initialInverseChart p hi h0 hH s) z‖^2) :=
+    (measurable_deriv _).norm.pow_const 2
+  refine ⟨hm.aestronglyMeasurable,?_⟩
+  rw [hasFiniteIntegral_iff_ofReal (ae_of_all _ (fun z => sq_nonneg _))]
+  exact (initialInverse_dirichlet_bound p hi h0 hH hR hp s A).trans_lt
+    (isCompact_closedBall (0:ℂ) (A+3*R)).measure_lt_top
+
+lemma initialInverse_energy_integral_le (p : C(unitInterval,ℂ)) (hi : Injective p)
+    (h0 : p 0=0) (hH : ∀ t : unitInterval, t≠0 → p t∈upperHalfPlane)
+    {R : ℝ} (hR : 0<R) (hp : ∀ t : unitInterval, ‖p t‖<R)
+    (s : unitInterval) (A : ℝ) :
+    (∫ z in upperHalfPlane ∩ ball (0:ℂ) A,
+      ‖deriv (initialInverseChart p hi h0 hH s) z‖^2)≤
+        (volume (closedBall (0:ℂ) (A+3*R))).toReal := by
+  rw [integral_eq_lintegral_of_nonneg_ae (ae_of_all _ (fun z => sq_nonneg _))
+    ((measurable_deriv _).norm.pow_const 2).aestronglyMeasurable]
+  exact ENNReal.toReal_mono (isCompact_closedBall (0:ℂ) (A+3*R)).measure_lt_top.ne
+    (initialInverse_dirichlet_bound p hi h0 hH hR hp s A)
+
+end SLEExactGauge
+
+end
+
+end OAI
diff --git a/lean/OAI/Probability/SLE/Loewner/InitialInverseJointContinuity.lean b/lean/OAI/Probability/SLE/Loewner/InitialInverseJointContinuity.lean
new file mode 100644
index 0000000000000000000000000000000000000000..18ca51df5e3107fba0684ee1fcff8fbbfbfaba8b
--- /dev/null
+++ b/lean/OAI/Probability/SLE/Loewner/InitialInverseJointContinuity.lean
@@ -0,0 +1,51 @@
+import OAI.Probability.SLE.Loewner.InitialInverseLimitAt
+
+namespace OAI
+
+/-! Joint continuity of the exact inverse charts in time and an interior
+half-plane coordinate. -/
+noncomputable section
+open Set Filter Function
+open scoped Topology
+
+namespace SLEExactGauge
+
+lemma initialInverse_limit_eq (p : C(unitInterval,ℂ)) (hi : Injective p)
+    (h0 : p 0=0) (hH : ∀ t : unitInterval, t ≠ 0 → p t ∈ upperHalfPlane)
+    {t : ℕ → unitInterval} {F : ℂ → ℂ} (hF : DifferentiableOn ℂ F upperHalfPlane)
+    (hlim : TendstoLocallyUniformlyOn (fun n => initialInverseChart p hi h0 hH (t n))
+      F atTop upperHalfPlane) {s : unitInterval} (ht : Tendsto t atTop (𝓝 s)) :
+    EqOn F (initialInverseChart p hi h0 hH s) upperHalfPlane := by
+  by_cases hs : s=0
+  · subst s
+    intro z hz
+    have hzero := ((initialInverseChart_tendsto_identity p hi h0 hH).tendsto_at hz).comp ht
+    have he : F z=id z := tendsto_nhds_unique (hlim.tendsto_at hz) hzero
+    simpa only [initialInverseChart_zero] using he
+  · exact initialInverse_limit_eq_at p hi h0 hH hF hlim hs ht
+
+theorem initialInverseChart_joint_continuous (p : C(unitInterval,ℂ)) (hi : Injective p)
+    (h0 : p 0=0) (hH : ∀ t : unitInterval, t ≠ 0 → p t ∈ upperHalfPlane) :
+    Continuous (fun a : unitInterval × upperHalfPlane =>
+      initialInverseChart p hi h0 hH a.1 a.2) := by
+  rw [continuous_iff_continuousAt]
+  intro a
+  apply tendsto_of_subseq_tendsto
+  intro v hv
+  have ht : Tendsto (fun n => (v n).1) atTop (𝓝 a.1) :=
+    (continuous_fst.tendsto a).comp hv
+  have hz : Tendsto (fun n => ((v n).2:ℂ)) atTop (𝓝 (a.2:ℂ)) :=
+    ((continuous_subtype_val.comp continuous_snd).tendsto a).comp hv
+  obtain ⟨φ,F,hφ,hF,hlim⟩ := initialInverseChart_subsequence p hi h0 hH (fun n => (v n).1)
+  have he := initialInverse_limit_eq p hi h0 hH hF hlim (ht.comp hφ.tendsto_atTop)
+  have heval := locallyUniform_evaluation_tendsto isOpen_upperHalfPlane hF.continuousOn
+    hlim a.2.property (hz.comp hφ.tendsto_atTop)
+  rw [he a.2.property] at heval
+  refine ⟨φ,?_⟩
+  exact heval
+
+end SLEExactGauge
+
+end
+
+end OAI
diff --git a/lean/OAI/Probability/SLE/Loewner/InitialInverseLimit.lean b/lean/OAI/Probability/SLE/Loewner/InitialInverseLimit.lean
new file mode 100644
index 0000000000000000000000000000000000000000..93f540d5bec5a81ec37a89b1ecfbfb0bbe5b5f72
--- /dev/null
+++ b/lean/OAI/Probability/SLE/Loewner/InitialInverseLimit.lean
@@ -0,0 +1,72 @@
+import OAI.Probability.SLE.Loewner.InitialInverseNormalFamily
+import TauCeti.Analysis.Complex.Conformal.Hurwitz
+
+namespace OAI
+
+/-! Limits of initial inverse slit charts remain nondegenerate and univalent. -/
+noncomputable section
+open Set Filter Function Metric
+open scoped Topology
+
+namespace SLEExactGauge
+
+lemma initialInverseChart_im_ge (p : C(unitInterval,ℂ)) (hi : Injective p)
+    (h0 : p 0=0) (hH : ∀ t : unitInterval, t ≠ 0 → p t ∈ upperHalfPlane)
+    (t : unitInterval) {z : ℂ} (hz : z∈upperHalfPlane) :
+    z.im≤(initialInverseChart p hi h0 hH t z).im := by
+  by_cases ht : t=0
+  · simp only [ht,initialInverseChart_zero,id_eq,le_refl]
+  · rw [initialInverseChart,dite_eq_right ht]
+    exact (initialSlitChart p hi h0 hH t ht).inverse_im_ge hz
+
+lemma initialInverseChart_injOn (p : C(unitInterval,ℂ)) (hi : Injective p)
+    (h0 : p 0=0) (hH : ∀ t : unitInterval, t ≠ 0 → p t ∈ upperHalfPlane)
+    (t : unitInterval) : InjOn (initialInverseChart p hi h0 hH t) upperHalfPlane := by
+  by_cases ht : t=0
+  · simp only [ht,initialInverseChart_zero]
+    exact injective_id.injOn
+  · rw [initialInverseChart,dite_eq_right ht]
+    exact (initialSlitChart p hi h0 hH t ht).inverse_injOn
+
+lemma initialInverse_limit_im_ge (p : C(unitInterval,ℂ)) (hi : Injective p)
+    (h0 : p 0=0) (hH : ∀ t : unitInterval, t ≠ 0 → p t ∈ upperHalfPlane)
+    {t : ℕ → unitInterval} {F : ℂ → ℂ}
+    (hlim : TendstoLocallyUniformlyOn (fun n => initialInverseChart p hi h0 hH (t n))
+      F atTop upperHalfPlane) {z : ℂ} (hz : z∈upperHalfPlane) : z.im≤(F z).im :=
+  ge_of_tendsto (Complex.continuous_im.continuousAt.tendsto.comp (hlim.tendsto_at hz))
+    (Eventually.of_forall fun n => initialInverseChart_im_ge p hi h0 hH (t n) hz)
+
+lemma initialInverse_limit_injOn (p : C(unitInterval,ℂ)) (hi : Injective p)
+    (h0 : p 0=0) (hH : ∀ t : unitInterval, t ≠ 0 → p t ∈ upperHalfPlane)
+    {t : ℕ → unitInterval} {F : ℂ → ℂ}
+    (hlim : TendstoLocallyUniformlyOn (fun n => initialInverseChart p hi h0 hH (t n))
+      F atTop upperHalfPlane) : InjOn F upperHalfPlane := by
+  rcases TauCeti.hurwitz_injOn isOpen_upperHalfPlane
+    (convex_halfSpace_im_gt (0:ℝ)).isPreconnected
+    (Eventually.of_forall fun n => initialInverseChart_differentiableOn p hi h0 hH (t n)) hlim
+    (Eventually.of_forall fun n => initialInverseChart_injOn p hi h0 hH (t n)) with hh | ⟨c,hc⟩
+  · exact hh
+  · let y := max c.im 0+1
+    have hy : 0<y := by dsimp [y]; linarith [le_max_right c.im 0]
+    have hz : (y:ℂ)*Complex.I∈upperHalfPlane := by simpa [upperHalfPlane] using hy
+    have hh := initialInverse_limit_im_ge p hi h0 hH hlim hz
+    rw [hc _ hz] at hh
+    simp only [Complex.mul_im,Complex.ofReal_re,Complex.I_im,mul_one,
+      Complex.ofReal_im,Complex.I_re,mul_zero,add_zero] at hh
+    exact False.elim (by dsimp [y] at hh; linarith [le_max_left c.im 0])
+
+lemma initialInverse_limit_displacement (p : C(unitInterval,ℂ)) (hi : Injective p)
+    (h0 : p 0=0) (hH : ∀ t : unitInterval, t ≠ 0 → p t ∈ upperHalfPlane)
+    {t : ℕ → unitInterval} {F : ℂ → ℂ} {c : ℝ}
+    (hlim : TendstoLocallyUniformlyOn (fun n => initialInverseChart p hi h0 hH (t n))
+      F atTop upperHalfPlane)
+    (hcap : Tendsto (fun n => initialCapacity p hi h0 hH (t n)) atTop (𝓝 c))
+    {z : ℂ} (hz : z∈upperHalfPlane) : ‖F z-z‖≤c/z.im :=
+  le_of_tendsto_of_tendsto ((hlim.tendsto_at hz).sub_const z).norm (hcap.div_const z.im)
+    (Eventually.of_forall fun n => initialInverseChart_displacement p hi h0 hH (t n) hz)
+
+end SLEExactGauge
+
+end
+
+end OAI
diff --git a/lean/OAI/Probability/SLE/Loewner/InitialInverseLimitAt.lean b/lean/OAI/Probability/SLE/Loewner/InitialInverseLimitAt.lean
new file mode 100644
index 0000000000000000000000000000000000000000..9436092d50ed4cef5b264f3a8bcbb52c01ebfd7f
--- /dev/null
+++ b/lean/OAI/Probability/SLE/Loewner/InitialInverseLimitAt.lean
@@ -0,0 +1,35 @@
+import OAI.Probability.SLE.Loewner.InitialInverseRangeAt
+import OAI.Probability.SLE.Loewner.SlitChartLimitUniqueness
+
+namespace OAI
+
+/-! Both-sided identification of the actual initial inverse-chart limits. -/
+noncomputable section
+open Set Filter Function
+open scoped Topology
+
+namespace SLEExactGauge
+
+theorem initialInverse_limit_eq_at (p : C(unitInterval,ℂ)) (hi : Injective p)
+    (h0 : p 0=0) (hH : ∀ t : unitInterval, t ≠ 0 → p t ∈ upperHalfPlane)
+    {t : ℕ → unitInterval} {F : ℂ → ℂ} (hF : DifferentiableOn ℂ F upperHalfPlane)
+    (hlim : TendstoLocallyUniformlyOn (fun n => initialInverseChart p hi h0 hH (t n))
+      F atTop upperHalfPlane) {s : unitInterval} (hs : s≠0) (ht : Tendsto t atTop (𝓝 s)) :
+    EqOn F (initialInverseChart p hi h0 hH s) upperHalfPlane := by
+  obtain ⟨R0,hR0⟩ := (isCompact_range p.continuous).isBounded.exists_norm_le
+  let R := max R0 1
+  have hR : 0<R := lt_of_lt_of_le zero_lt_one (le_max_right _ _)
+  have hp (u : unitInterval) : ‖p u‖≤R := (hR0 _ (mem_range_self u)).trans (le_max_left _ _)
+  rw [initialInverseChart,dite_eq_right hs]
+  exact (initialSlitChart p hi h0 hH s hs).eq_inverse_of_vertical_bounds hF
+    (initialInverse_limit_bijOn_at p hi h0 hH hF hlim ht)
+    (fun _ hz => initialInverse_limit_im_ge p hi h0 hH hlim hz)
+    hR (fun u => hp (s*u))
+    (fun _ hz => initialInverse_limit_uniform_displacement p hi h0 hH hlim hz)
+    (fun _ hz => initialInverse_limit_inverse_far_height p hi h0 hH hF hlim hR hp hz)
+
+end SLEExactGauge
+
+end
+
+end OAI
diff --git a/lean/OAI/Probability/SLE/Loewner/InitialInverseNormalFamily.lean b/lean/OAI/Probability/SLE/Loewner/InitialInverseNormalFamily.lean
new file mode 100644
index 0000000000000000000000000000000000000000..d8b297a41a3830dc6a8d90a8677b99196129eb6b
--- /dev/null
+++ b/lean/OAI/Probability/SLE/Loewner/InitialInverseNormalFamily.lean
@@ -0,0 +1,53 @@
+import OAI.Probability.SLE.Loewner.InitialInverseChart
+import TauCeti.Analysis.Complex.Conformal.Montel.Basic
+
+namespace OAI
+
+/-! Compactness of the actual inverse charts of all initial subarcs.
+The uniform bound is supplied by their common final capacity. -/
+noncomputable section
+open Set Filter Function Metric
+open scoped Topology
+
+namespace SLEExactGauge
+
+lemma initialInverseChart_locallyBounded (p : C(unitInterval,ℂ)) (hi : Injective p)
+    (h0 : p 0=0) (hH : ∀ t : unitInterval, t ≠ 0 → p t ∈ upperHalfPlane) :
+    TauCeti.IsLocallyBoundedOn (initialInverseChart p hi h0 hH) upperHalfPlane := by
+  intro K hKH hK
+  by_cases hne : K.Nonempty
+  · obtain ⟨m,hm,hmin⟩ := compact_upperHalfPlane_min_height hK hKH hne
+    obtain ⟨R,hR⟩ := hK.isBounded.exists_norm_le
+    let C := initialCapacity p hi h0 hH 1
+    have hC : 0≤C := initialCapacity_nonneg p hi h0 hH 1
+    refine ⟨R+C/m,fun t z hz => ?_⟩
+    have hcap : initialCapacity p hi h0 hH t≤C :=
+      initialCapacity_monotone p hi h0 hH (show t≤1 from le_top)
+    have him : 0<z.im := hKH hz
+    calc
+      ‖initialInverseChart p hi h0 hH t z‖ ≤
+          ‖initialInverseChart p hi h0 hH t z-z‖+‖z‖ := norm_le_norm_sub_add _ _
+      _ ≤ initialCapacity p hi h0 hH t/z.im+R :=
+        add_le_add (initialInverseChart_displacement p hi h0 hH t (hKH hz)) (hR z hz)
+      _ ≤ C/m+R := by
+        have hb := (div_le_div_of_nonneg_right hcap him.le).trans
+          (div_le_div_of_nonneg_left hC hm (hmin z hz))
+        linarith
+      _ = R+C/m := add_comm _ _
+  · exact ⟨0,fun _ _ hz => False.elim (hne ⟨_,hz⟩)⟩
+
+theorem initialInverseChart_subsequence (p : C(unitInterval,ℂ)) (hi : Injective p)
+    (h0 : p 0=0) (hH : ∀ t : unitInterval, t ≠ 0 → p t ∈ upperHalfPlane)
+    (t : ℕ → unitInterval) :
+    ∃ (φ : ℕ → ℕ) (F : ℂ → ℂ), StrictMono φ ∧ DifferentiableOn ℂ F upperHalfPlane ∧
+      TendstoLocallyUniformlyOn (fun n => initialInverseChart p hi h0 hH (t (φ n)))
+        F atTop upperHalfPlane :=
+  TauCeti.montel isOpen_upperHalfPlane
+    (fun n => initialInverseChart_differentiableOn p hi h0 hH (t n))
+    ((initialInverseChart_locallyBounded p hi h0 hH).comp t)
+
+end SLEExactGauge
+
+end
+
+end OAI
diff --git a/lean/OAI/Probability/SLE/Loewner/InitialInversePartialDomain.lean b/lean/OAI/Probability/SLE/Loewner/InitialInversePartialDomain.lean
new file mode 100644
index 0000000000000000000000000000000000000000..6205cac12778fcc400bb44efb2261ff6415c7914
--- /dev/null
+++ b/lean/OAI/Probability/SLE/Loewner/InitialInversePartialDomain.lean
@@ -0,0 +1,78 @@
+import OAI.Probability.SLE.Loewner.InitialLimitInverse
+import OAI.Probability.SLE.Geometry.SubarcParameter
+
+namespace OAI
+
+/-! The inverse limit covers any fixed later subarc complement on which
+the approximating charts are eventually defined. -/
+noncomputable section
+open Set Filter Function
+open scoped Topology
+
+namespace SLEExactGauge
+
+lemma initialInverse_limit_covers_subarc (p : C(unitInterval,ℂ)) (hi : Injective p)
+    (h0 : p 0=0) (hH : ∀ t : unitInterval, t ≠ 0 → p t ∈ upperHalfPlane)
+    {t : ℕ → unitInterval} {F : ℂ → ℂ} (hF : DifferentiableOn ℂ F upperHalfPlane)
+    (hlim : TendstoLocallyUniformlyOn (fun n => initialInverseChart p hi h0 hH (t n))
+      F atTop upperHalfPlane) (b : unitInterval) (hb : b≠0)
+    (hbt : ∀ᶠ n in atTop, t n≤b) :
+    SurjOn F upperHalfPlane (upperHalfPlane \ range (initialSubarc p b)) := by
+  obtain ⟨N,hN⟩ := eventually_atTop.mp hbt
+  let hib := initialSubarc_injective hi hb
+  have h0b : initialSubarc p b 0=0 := by simpa only [initialSubarc_zero] using h0
+  let hHb := initialSubarc_upper hH hb
+  let u : ℕ → unitInterval := fun n => subarcParameter b hb (t (n+N))
+  have he (n : ℕ) : b*u n=t (n+N) :=
+    subarcParameter_mul_of_le b hb (hN (n+N) (by omega))
+  have hshift := locallyUniform_reindex hlim (tendsto_add_atTop_nat N)
+  have hq : TendstoLocallyUniformlyOn
+      (fun n => initialInverseChart (initialSubarc p b) hib h0b hHb (u n)) F atTop upperHalfPlane := by
+    apply hshift.congr
+    intro n z hz
+    have hh := initialInverseChart_subarc p hi h0 hH b hb hib h0b hHb (u n) hz
+    rw [he n] at hh
+    exact hh.symm
+  exact initialInverse_limit_covers_final_domain (initialSubarc p b) hib h0b hHb hF hq
+
+lemma exists_later_subarc_domain (p : C(unitInterval,ℂ)) (hi : Injective p)
+    {s : unitInterval} (hs : s<1) {z : ℂ}
+    (hz : z∈upperHalfPlane \ range (initialSubarc p s)) :
+    ∃ b : unitInterval, s<b ∧ z∈upperHalfPlane \ range (initialSubarc p b) := by
+  by_cases hzp : z∈range p
+  · obtain ⟨u,hu⟩ := hzp
+    have hsu : s<u := by
+      by_contra hn
+      apply hz.2
+      rw [initialSubarc_range]
+      exact ⟨u,⟨bot_le,le_of_not_gt hn⟩,hu⟩
+    obtain ⟨b,hsb,hbu⟩ := exists_between hsu
+    refine ⟨b,hsb,hz.1,?_⟩
+    rw [initialSubarc_range]
+    rintro ⟨v,hv,hv_eq⟩
+    have hvu : v=u := hi (hv_eq.trans hu.symm)
+    exact (not_le_of_gt hbu) (hvu ▸ hv.2)
+  · refine ⟨1,hs,hz.1,?_⟩
+    exact fun hh => hzp (initialSubarc_range_subset p 1 hh)
+
+lemma initialInverse_limit_covers_at (p : C(unitInterval,ℂ)) (hi : Injective p)
+    (h0 : p 0=0) (hH : ∀ t : unitInterval, t ≠ 0 → p t ∈ upperHalfPlane)
+    {t : ℕ → unitInterval} {F : ℂ → ℂ} (hF : DifferentiableOn ℂ F upperHalfPlane)
+    (hlim : TendstoLocallyUniformlyOn (fun n => initialInverseChart p hi h0 hH (t n))
+      F atTop upperHalfPlane) {s : unitInterval} (ht : Tendsto t atTop (𝓝 s)) :
+    SurjOn F upperHalfPlane (upperHalfPlane \ range (initialSubarc p s)) := by
+  intro z hz
+  by_cases hs : s=1
+  · subst s
+    apply initialInverse_limit_covers_final_domain p hi h0 hH hF hlim z
+    simpa only [Set.mem_sdiff,mem_range,initialSubarc_apply,one_mul] using hz
+  · obtain ⟨b,hsb,hzb⟩ := exists_later_subarc_domain p hi (lt_of_le_of_ne le_top hs) hz
+    have hb : b≠0 := ne_of_gt (lt_of_le_of_lt bot_le hsb)
+    exact initialInverse_limit_covers_subarc p hi h0 hH hF hlim b hb
+      (ht.eventually (Iio_mem_nhds hsb) |>.mono fun _ hh => hh.le) hzb
+
+end SLEExactGauge
+
+end
+
+end OAI
diff --git a/lean/OAI/Probability/SLE/Loewner/InitialInverseRange.lean b/lean/OAI/Probability/SLE/Loewner/InitialInverseRange.lean
new file mode 100644
index 0000000000000000000000000000000000000000..00be8e952acf9b7768807800fe4e6efa69aad7c9
--- /dev/null
+++ b/lean/OAI/Probability/SLE/Loewner/InitialInverseRange.lean
@@ -0,0 +1,102 @@
+import OAI.Probability.SLE.Loewner.InitialInverseCommonDomain
+import Mathlib.Topology.Order.DenselyOrdered
+
+namespace OAI
+
+/-! At the terminal initial-arc time, the inverse limits have exactly the
+prescribed slit domain as their image. -/
+noncomputable section
+open Set Filter Function Complex
+open scoped Topology
+
+namespace SLEExactGauge
+
+lemma initialInverseChart_avoids_prefix (p : C(unitInterval,ℂ)) (hi : Injective p)
+    (h0 : p 0=0) (hH : ∀ t : unitInterval, t ≠ 0 → p t ∈ upperHalfPlane)
+    (t u : unitInterval) (hut : u≤t) {z : ℂ} (hz : z∈upperHalfPlane) :
+    initialInverseChart p hi h0 hH t z≠p u := by
+  by_cases ht : t=0
+  · have hu : u=0 := le_antisymm (ht ▸ hut) bot_le
+    simp only [ht,initialInverseChart_zero,id_eq,hu,h0]
+    intro he
+    have hh : 0<z.im := hz
+    simp [he] at hh
+  · rw [initialInverseChart,dite_eq_right ht]
+    intro he
+    have hm := (initialSlitChart p hi h0 hH t ht).inverse_mapsTo hz
+    apply hm.2
+    rw [he,initialSubarc_range]
+    exact mem_image_of_mem p ⟨bot_le,hut⟩
+
+lemma initialInverse_limit_not_constant (p : C(unitInterval,ℂ)) (hi : Injective p)
+    (h0 : p 0=0) (hH : ∀ t : unitInterval, t ≠ 0 → p t ∈ upperHalfPlane)
+    {t : ℕ → unitInterval} {F : ℂ → ℂ}
+    (hlim : TendstoLocallyUniformlyOn (fun n => initialInverseChart p hi h0 hH (t n))
+      F atTop upperHalfPlane) (c : ℂ) : ¬ ∀ z∈upperHalfPlane, F z=c := by
+  intro hc
+  have hinj := initialInverse_limit_injOn p hi h0 hH hlim
+  have h1 : I∈upperHalfPlane := by simp [upperHalfPlane]
+  have h2 : 2*I∈upperHalfPlane := by simp [upperHalfPlane]
+  have he := hinj h1 h2 ((hc I h1).trans (hc (2*I) h2).symm)
+  have hh := congrArg Complex.im he
+  norm_num at hh
+
+lemma initialInverse_limit_avoids_before_one (p : C(unitInterval,ℂ)) (hi : Injective p)
+    (h0 : p 0=0) (hH : ∀ t : unitInterval, t ≠ 0 → p t ∈ upperHalfPlane)
+    {t : ℕ → unitInterval} {F : ℂ → ℂ}
+    (hlim : TendstoLocallyUniformlyOn (fun n => initialInverseChart p hi h0 hH (t n))
+      F atTop upperHalfPlane) (ht : Tendsto t atTop (𝓝 1))
+    (u : unitInterval) (hu : u<1) : ∀ z∈upperHalfPlane, F z≠p u := by
+  have hne : ∀ᶠ n in atTop, ∀ z∈upperHalfPlane,
+      initialInverseChart p hi h0 hH (t n) z≠p u := by
+    filter_upwards [ht.eventually (Ioi_mem_nhds hu)] with n hn
+    exact fun _ hz => initialInverseChart_avoids_prefix p hi h0 hH (t n) u hn.le hz
+  exact TauCeti.hurwitz_forall_ne isOpen_upperHalfPlane
+    (convex_halfSpace_im_gt (0:ℝ)).isPreconnected
+    (Eventually.of_forall fun n => initialInverseChart_differentiableOn p hi h0 hH (t n))
+    hlim hne (initialInverse_limit_not_constant p hi h0 hH hlim (p u))
+
+lemma initialInverse_limit_mapsTo_final (p : C(unitInterval,ℂ)) (hi : Injective p)
+    (h0 : p 0=0) (hH : ∀ t : unitInterval, t ≠ 0 → p t ∈ upperHalfPlane)
+    {t : ℕ → unitInterval} {F : ℂ → ℂ} (hF : DifferentiableOn ℂ F upperHalfPlane)
+    (hlim : TendstoLocallyUniformlyOn (fun n => initialInverseChart p hi h0 hH (t n))
+      F atTop upperHalfPlane) (ht : Tendsto t atTop (𝓝 1)) :
+    MapsTo F upperHalfPlane (upperHalfPlane \ range p) := by
+  have hopen : IsOpen (F '' upperHalfPlane) := by
+    rcases (hF.analyticOnNhd isOpen_upperHalfPlane).is_constant_or_isOpen
+      (convex_halfSpace_im_gt (0:ℝ)).isPreconnected with ⟨c,hc⟩ | ho
+    · exact False.elim (initialInverse_limit_not_constant p hi h0 hH hlim c hc)
+    · exact ho _ Subset.rfl isOpen_upperHalfPlane
+  intro z hz
+  refine ⟨lt_of_lt_of_le hz (initialInverse_limit_im_ge p hi h0 hH hlim hz),?_⟩
+  rintro ⟨u,hu⟩
+  have hbefore := initialInverse_limit_avoids_before_one p hi h0 hH hlim ht
+  by_cases hu1 : u<1
+  · exact hbefore u hu1 z hz hu.symm
+  have heu : u=1 := le_antisymm le_top (le_of_not_gt hu1)
+  subst u
+  have hp1 : p 1∈F '' upperHalfPlane := ⟨z,hz,hu.symm⟩
+  have hpre : p ⁻¹' (F '' upperHalfPlane)∈𝓝 (1:unitInterval) :=
+    p.continuous.continuousAt.preimage_mem_nhds (hopen.mem_nhds hp1)
+  have hcl : (1:unitInterval)∈closure (Iio (1:unitInterval)) := by
+    rw [closure_Iio' (show (Iio (1:unitInterval)).Nonempty from ⟨0,by norm_num⟩)]
+    exact mem_Iic.mpr (le_refl (1:unitInterval))
+  obtain ⟨v,hvp,hvlt⟩ := mem_closure_iff_nhds.mp hcl _ hpre
+  obtain ⟨w,hw,hew⟩ := hvp
+  exact hbefore v hvlt w hw hew
+
+theorem initialInverse_limit_bijOn_final (p : C(unitInterval,ℂ)) (hi : Injective p)
+    (h0 : p 0=0) (hH : ∀ t : unitInterval, t ≠ 0 → p t ∈ upperHalfPlane)
+    {t : ℕ → unitInterval} {F : ℂ → ℂ} (hF : DifferentiableOn ℂ F upperHalfPlane)
+    (hlim : TendstoLocallyUniformlyOn (fun n => initialInverseChart p hi h0 hH (t n))
+      F atTop upperHalfPlane) (ht : Tendsto t atTop (𝓝 1)) :
+    BijOn F upperHalfPlane (upperHalfPlane \ range p) :=
+  ⟨initialInverse_limit_mapsTo_final p hi h0 hH hF hlim ht,
+    initialInverse_limit_injOn p hi h0 hH hlim,
+    initialInverse_limit_covers_final_domain p hi h0 hH hF hlim⟩
+
+end SLEExactGauge
+
+end
+
+end OAI
diff --git a/lean/OAI/Probability/SLE/Loewner/InitialInverseRangeAt.lean b/lean/OAI/Probability/SLE/Loewner/InitialInverseRangeAt.lean
new file mode 100644
index 0000000000000000000000000000000000000000..d9321bfa8af0f69a9c0f7af5d4b6523225c1df06
--- /dev/null
+++ b/lean/OAI/Probability/SLE/Loewner/InitialInverseRangeAt.lean
@@ -0,0 +1,77 @@
+import OAI.Probability.SLE.Loewner.InitialInversePartialDomain
+
+namespace OAI
+
+/-! Exact image of an inverse-chart limit at an arbitrary initial time,
+from either side of that time. -/
+noncomputable section
+open Set Filter Function Complex
+open scoped Topology
+
+namespace SLEExactGauge
+
+lemma initialInverse_limit_avoids_before_time (p : C(unitInterval,ℂ)) (hi : Injective p)
+    (h0 : p 0=0) (hH : ∀ t : unitInterval, t ≠ 0 → p t ∈ upperHalfPlane)
+    {t : ℕ → unitInterval} {F : ℂ → ℂ}
+    (hlim : TendstoLocallyUniformlyOn (fun n => initialInverseChart p hi h0 hH (t n))
+      F atTop upperHalfPlane) {s : unitInterval} (ht : Tendsto t atTop (𝓝 s))
+    (u : unitInterval) (hu : u<s) : ∀ z∈upperHalfPlane, F z≠p u := by
+  have hne : ∀ᶠ n in atTop, ∀ z∈upperHalfPlane,
+      initialInverseChart p hi h0 hH (t n) z≠p u := by
+    filter_upwards [ht.eventually (Ioi_mem_nhds hu)] with n hn
+    exact fun _ hz => initialInverseChart_avoids_prefix p hi h0 hH (t n) u hn.le hz
+  exact TauCeti.hurwitz_forall_ne isOpen_upperHalfPlane
+    (convex_halfSpace_im_gt (0:ℝ)).isPreconnected
+    (Eventually.of_forall fun n => initialInverseChart_differentiableOn p hi h0 hH (t n))
+    hlim hne (initialInverse_limit_not_constant p hi h0 hH hlim (p u))
+
+lemma initialInverse_limit_mapsTo_at (p : C(unitInterval,ℂ)) (hi : Injective p)
+    (h0 : p 0=0) (hH : ∀ t : unitInterval, t ≠ 0 → p t ∈ upperHalfPlane)
+    {t : ℕ → unitInterval} {F : ℂ → ℂ} (hF : DifferentiableOn ℂ F upperHalfPlane)
+    (hlim : TendstoLocallyUniformlyOn (fun n => initialInverseChart p hi h0 hH (t n))
+      F atTop upperHalfPlane) {s : unitInterval} (ht : Tendsto t atTop (𝓝 s)) :
+    MapsTo F upperHalfPlane (upperHalfPlane \ range (initialSubarc p s)) := by
+  have hopen : IsOpen (F '' upperHalfPlane) := by
+    rcases (hF.analyticOnNhd isOpen_upperHalfPlane).is_constant_or_isOpen
+      (convex_halfSpace_im_gt (0:ℝ)).isPreconnected with ⟨c,hc⟩ | ho
+    · exact False.elim (initialInverse_limit_not_constant p hi h0 hH hlim c hc)
+    · exact ho _ Subset.rfl isOpen_upperHalfPlane
+  intro z hz
+  have hpos : 0<(F z).im := lt_of_lt_of_le hz (initialInverse_limit_im_ge p hi h0 hH hlim hz)
+  refine ⟨hpos,?_⟩
+  rw [initialSubarc_range]
+  rintro ⟨u,hu,heu⟩
+  have hbefore := initialInverse_limit_avoids_before_time p hi h0 hH hlim ht
+  by_cases hus : u<s
+  · exact hbefore u hus z hz heu.symm
+  have hus : u=s := le_antisymm hu.2 (le_of_not_gt hus)
+  subst u
+  by_cases hs : s=0
+  · rw [hs,h0] at heu
+    rw [← heu] at hpos
+    exact (lt_irrefl (0:ℝ)) hpos
+  have hp : p s∈F '' upperHalfPlane := ⟨z,hz,heu.symm⟩
+  have hpre : p ⁻¹' (F '' upperHalfPlane)∈𝓝 s :=
+    p.continuous.continuousAt.preimage_mem_nhds (hopen.mem_nhds hp)
+  have hcl : s∈closure (Iio s) := by
+    rw [closure_Iio' (show (Iio s).Nonempty from ⟨0,bot_lt_iff_ne_bot.mpr hs⟩)]
+    exact mem_Iic.mpr le_rfl
+  obtain ⟨v,hvp,hvs⟩ := mem_closure_iff_nhds.mp hcl _ hpre
+  obtain ⟨w,hw,hew⟩ := hvp
+  exact hbefore v hvs w hw hew
+
+theorem initialInverse_limit_bijOn_at (p : C(unitInterval,ℂ)) (hi : Injective p)
+    (h0 : p 0=0) (hH : ∀ t : unitInterval, t ≠ 0 → p t ∈ upperHalfPlane)
+    {t : ℕ → unitInterval} {F : ℂ → ℂ} (hF : DifferentiableOn ℂ F upperHalfPlane)
+    (hlim : TendstoLocallyUniformlyOn (fun n => initialInverseChart p hi h0 hH (t n))
+      F atTop upperHalfPlane) {s : unitInterval} (ht : Tendsto t atTop (𝓝 s)) :
+    BijOn F upperHalfPlane (upperHalfPlane \ range (initialSubarc p s)) :=
+  ⟨initialInverse_limit_mapsTo_at p hi h0 hH hF hlim ht,
+    initialInverse_limit_injOn p hi h0 hH hlim,
+    initialInverse_limit_covers_at p hi h0 hH hF hlim ht⟩
+
+end SLEExactGauge
+
+end
+
+end OAI
diff --git a/lean/OAI/Probability/SLE/Loewner/InitialInverseTimeContinuity.lean b/lean/OAI/Probability/SLE/Loewner/InitialInverseTimeContinuity.lean
new file mode 100644
index 0000000000000000000000000000000000000000..1335e68fbf253ae5a6932bf1b161c23b751bce7f
--- /dev/null
+++ b/lean/OAI/Probability/SLE/Loewner/InitialInverseTimeContinuity.lean
@@ -0,0 +1,34 @@
+import OAI.Probability.SLE.Loewner.InitialInverseJointContinuity
+import Mathlib.Topology.UniformSpace.HeineCantor
+
+namespace OAI
+
+/-! Local uniform time continuity of the exact inverse slit charts. -/
+noncomputable section
+open Set Filter Function
+open scoped Topology
+
+namespace SLEExactGauge
+
+theorem initialInverseChart_locallyUniform_continuous (p : C(unitInterval,ℂ)) (hi : Injective p)
+    (h0 : p 0=0) (hH : ∀ t : unitInterval, t ≠ 0 → p t ∈ upperHalfPlane)
+    (s : unitInterval) :
+    TendstoLocallyUniformlyOn (initialInverseChart p hi h0 hH)
+      (initialInverseChart p hi h0 hH s) (𝓝 s) upperHalfPlane := by
+  rw [tendstoLocallyUniformlyOn_iff_forall_isCompact isOpen_upperHalfPlane]
+  intro K hKH hK
+  let : CompactSpace K := isCompact_iff_compactSpace.mp hK
+  have hc : Continuous (fun a : unitInterval × K =>
+      initialInverseChart p hi h0 hH a.1 a.2) := by
+    exact (initialInverseChart_joint_continuous p hi h0 hH).comp
+      (continuous_fst.prodMk (Continuous.subtype_mk
+        (continuous_subtype_val.comp continuous_snd) (fun a => hKH a.2.property)))
+  have hu := Continuous.tendstoUniformly
+    (fun t (z : K) => initialInverseChart p hi h0 hH t z) hc s
+  exact tendstoUniformlyOn_iff_tendstoUniformly_comp_coe.mpr hu
+
+end SLEExactGauge
+
+end
+
+end OAI
diff --git a/lean/OAI/Probability/SLE/Loewner/InitialLimitInverse.lean b/lean/OAI/Probability/SLE/Loewner/InitialLimitInverse.lean
new file mode 100644
index 0000000000000000000000000000000000000000..d362811b59d5214af78c7f3d8ae4d05d02e2d994
--- /dev/null
+++ b/lean/OAI/Probability/SLE/Loewner/InitialLimitInverse.lean
@@ -0,0 +1,86 @@
+import OAI.Probability.SLE.Loewner.InitialInverseRange
+import OAI.Probability.SLE.Loewner.SlitChartFarHeight
+import TauCeti.Analysis.Complex.Conformal.Inverse.Function
+
+namespace OAI
+
+/-! The inverse of a terminal inverse-chart limit is holomorphic and retains
+the common far-height bound. -/
+noncomputable section
+open Set Filter Function Complex
+open scoped Topology
+
+namespace SLEExactGauge
+
+lemma initialForwardChart_far_height (p : C(unitInterval,ℂ)) (hi : Injective p)
+    (h0 : p 0=0) (hH : ∀ t : unitInterval, t ≠ 0 → p t ∈ upperHalfPlane)
+    {R : ℝ} (hR : 0<R) (hp : ∀ u : unitInterval, ‖p u‖≤R)
+    (t : unitInterval) {z : ℂ} (hz : 2*R≤z.im) :
+    ‖initialForwardChart p hi h0 hH t z-z‖≤3*R^2/z.im := by
+  by_cases ht : t=0
+  · simp only [ht,initialForwardChart_zero,id_eq,sub_self,norm_zero]
+    exact div_nonneg (by positivity) (by linarith)
+  · rw [initialForwardChart,dite_eq_right ht]
+    exact (initialSlitChart p hi h0 hH t ht).far_height_displacement hR
+      (fun u => hp (t*u)) hz
+
+lemma initialInverse_limit_forward_subsequence (p : C(unitInterval,ℂ)) (hi : Injective p)
+    (h0 : p 0=0) (hH : ∀ t : unitInterval, t ≠ 0 → p t ∈ upperHalfPlane)
+    {t : ℕ → unitInterval} {F : ℂ → ℂ} (hF : DifferentiableOn ℂ F upperHalfPlane)
+    (hlim : TendstoLocallyUniformlyOn (fun n => initialInverseChart p hi h0 hH (t n))
+      F atTop upperHalfPlane) :
+    ∃ φ : ℕ → ℕ, StrictMono φ ∧ ∀ z∈upperHalfPlane \ range p,
+      Tendsto (fun n => initialForwardChart p hi h0 hH (t (φ n)) z)
+        atTop (𝓝 (invFunOn F upperHalfPlane z)) := by
+  have hcov : SurjOn F upperHalfPlane (upperHalfPlane \ range p) :=
+    initialInverse_limit_covers_final_domain p hi h0 hH hF hlim
+  have hinj := initialInverse_limit_injOn p hi h0 hH hlim
+  obtain ⟨φ,A,hφ,hA,hAlim⟩ := initialForwardCayley_subsequence p hi h0 hH t
+  refine ⟨φ,hφ,fun z hz => ?_⟩
+  have hw := halfPlaneCayleyInv_open
+    (initialForwardCayley_limit_interior p hi h0 hH hA hAlim z hz)
+  have hfwd := initialForward_limit_tendsto p hi h0 hH hA hAlim hz
+  have heval := locallyUniform_evaluation_tendsto isOpen_upperHalfPlane
+    hF.continuousOn (locallyUniform_reindex hlim hφ.tendsto_atTop) hw hfwd
+  have he : F (halfPlaneCayleyInv (A z))=z := by
+    apply tendsto_nhds_unique heval
+    simpa only [initialInverse_forward_on_final p hi h0 hH _ hz] using
+      (tendsto_const_nhds : Tendsto (fun _ : ℕ => z) atTop (𝓝 z))
+  have hwG : halfPlaneCayleyInv (A z)=invFunOn F upperHalfPlane z := by
+    apply hinj hw (hcov.mapsTo_invFunOn hz)
+    exact he.trans (hcov.rightInvOn_invFunOn hz).symm
+  rwa [hwG] at hfwd
+
+lemma initialInverse_limit_inverse_far_height (p : C(unitInterval,ℂ)) (hi : Injective p)
+    (h0 : p 0=0) (hH : ∀ t : unitInterval, t ≠ 0 → p t ∈ upperHalfPlane)
+    {t : ℕ → unitInterval} {F : ℂ → ℂ} (hF : DifferentiableOn ℂ F upperHalfPlane)
+    (hlim : TendstoLocallyUniformlyOn (fun n => initialInverseChart p hi h0 hH (t n))
+      F atTop upperHalfPlane)
+    {R : ℝ} (hR : 0<R) (hp : ∀ u : unitInterval, ‖p u‖≤R)
+    {z : ℂ} (hz : 2*R≤z.im) :
+    ‖invFunOn F upperHalfPlane z-z‖≤3*R^2/z.im := by
+  have hzD : z∈upperHalfPlane \ range p := by
+    refine ⟨by change 0<z.im; linarith,?_⟩
+    rintro ⟨u,hu⟩
+    have hn := (Complex.im_le_norm z).trans (hu ▸ hp u)
+    linarith
+  obtain ⟨φ,_,hφ⟩ := initialInverse_limit_forward_subsequence p hi h0 hH hF hlim
+  exact le_of_tendsto ((hφ z hzD).sub_const z).norm
+    (Eventually.of_forall fun n => initialForwardChart_far_height p hi h0 hH hR hp _ hz)
+
+lemma initialInverse_limit_uniform_displacement (p : C(unitInterval,ℂ)) (hi : Injective p)
+    (h0 : p 0=0) (hH : ∀ t : unitInterval, t ≠ 0 → p t ∈ upperHalfPlane)
+    {t : ℕ → unitInterval} {F : ℂ → ℂ}
+    (hlim : TendstoLocallyUniformlyOn (fun n => initialInverseChart p hi h0 hH (t n))
+      F atTop upperHalfPlane) {z : ℂ} (hz : z∈upperHalfPlane) :
+    ‖F z-z‖ ≤ initialCapacity p hi h0 hH 1/z.im := by
+  apply le_of_tendsto ((hlim.tendsto_at hz).sub_const z).norm
+  exact Eventually.of_forall fun n => (initialInverseChart_displacement p hi h0 hH (t n) hz).trans
+    (div_le_div_of_nonneg_right (initialCapacity_monotone p hi h0 hH (show t n≤1 from le_top))
+      (show 0<z.im from hz).le)
+
+end SLEExactGauge
+
+end
+
+end OAI
diff --git a/lean/OAI/Probability/SLE/Loewner/InitialReflectedForward.lean b/lean/OAI/Probability/SLE/Loewner/InitialReflectedForward.lean
new file mode 100644
index 0000000000000000000000000000000000000000..e624536fd5a2ecb19a16187de549ae5ff19c2d48
--- /dev/null
+++ b/lean/OAI/Probability/SLE/Loewner/InitialReflectedForward.lean
@@ -0,0 +1,108 @@
+import OAI.Probability.SLE.Loewner.SlitUniformForwardBound
+import OAI.Probability.SLE.Loewner.ReflectedExteriorHeight
+import OAI.Probability.SLE.Loewner.InitialForwardJointContinuity
+
+namespace OAI
+
+/-! The normalized initial forward maps continued across the real axis
+away from the attached slit. These are the same maps on the upper side. -/
+noncomputable section
+open Set Filter Function Complex Metric
+open scoped Topology ComplexConjugate
+
+namespace SLEExactGauge
+
+noncomputable def initialReflectedChart (p : C(unitInterval,ℂ)) (hi : Injective p)
+    (h0 : p 0=0) (hH : ∀ t : unitInterval, t≠0 → p t∈upperHalfPlane)
+    (s : unitInterval) (hs : s≠0) : ReflectedCapacityChart (initialSubarc p s) :=
+  Classical.choice (exists_reflectedCapacityChart (initialSubarc p s)
+    (initialSubarc_injective hi hs) (by simpa only [initialSubarc_zero] using h0)
+    (initialSubarc_upper hH hs))
+
+noncomputable def initialReflectedForward (p : C(unitInterval,ℂ)) (hi : Injective p)
+    (h0 : p 0=0) (hH : ∀ t : unitInterval, t≠0 → p t∈upperHalfPlane)
+    (s : unitInterval) : ℂ → ℂ :=
+  if hs : s=0 then id else (initialReflectedChart p hi h0 hH s hs).chart.forward
+
+lemma reflected_initial_subset (p : C(unitInterval,ℂ)) (s : unitInterval) :
+    reflectedArcSet (initialSubarc p s) ⊆ reflectedArcSet p := by
+  intro z hz
+  rcases hz with hz | ⟨w,hw,rfl⟩
+  · exact Or.inl (initialSubarc_range_subset p s hz)
+  · exact Or.inr ⟨w,initialSubarc_range_subset p s hw,rfl⟩
+
+lemma initialReflectedForward_eq (p : C(unitInterval,ℂ)) (hi : Injective p)
+    (h0 : p 0=0) (hH : ∀ t : unitInterval, t≠0 → p t∈upperHalfPlane)
+    (s : unitInterval) {z : ℂ} (hz : z∈upperHalfPlane \ range (initialSubarc p s)) :
+    initialReflectedForward p hi h0 hH s z=initialForwardChart p hi h0 hH s z := by
+  by_cases hs : s=0
+  · subst s
+    simp [initialReflectedForward]
+  · simp only [initialReflectedForward,initialForwardChart,dite_eq_right hs]
+    exact ((initialSlitChart p hi h0 hH s hs).unique_on_domain
+      (initialReflectedChart p hi h0 hH s hs).chart).1 hz |>.symm
+
+lemma initialReflectedForward_differentiable (p : C(unitInterval,ℂ)) (hi : Injective p)
+    (h0 : p 0=0) (hH : ∀ t : unitInterval, t≠0 → p t∈upperHalfPlane)
+    (s : unitInterval) :
+    DifferentiableOn ℂ (initialReflectedForward p hi h0 hH s) (reflectedArcSet p)ᶜ := by
+  by_cases hs : s=0
+  · simp only [initialReflectedForward,dite_eq_left hs]
+    exact differentiableOn_id
+  · rw [initialReflectedForward,dite_eq_right hs]
+    exact ((initialReflectedChart p hi h0 hH s hs).forward_differentiable
+      (by simpa only [initialSubarc_zero] using h0)).mono
+      (compl_subset_compl.mpr (reflected_initial_subset p s))
+
+lemma real_not_reflected_arc (p : C(unitInterval,ℂ)) (h0 : p 0=0)
+    (hH : ∀ t : unitInterval, t≠0 → p t∈upperHalfPlane)
+    {x : ℝ} (hx : x≠0) : (x:ℂ)∉reflectedArcSet p := by
+  have hreal : (x:ℂ)∉range p := by
+    rintro ⟨s,hs⟩
+    by_cases hs0 : s=0
+    · have he : (x:ℂ)=0 := by simpa only [hs0,h0] using hs.symm
+      exact hx (ofReal_eq_zero.mp he)
+    · have hh := hH s hs0
+      rw [hs] at hh
+      simp [upperHalfPlane] at hh
+  rintro (hz | ⟨w,hw,he⟩)
+  · exact hreal hz
+  · apply hreal
+    have hwx : w=(x:ℂ) := by
+      have hh := congrArg conj he
+      simpa only [conj_conj,conj_ofReal] using hh
+    rwa [hwx] at hw
+
+lemma initialReflectedForward_real (p : C(unitInterval,ℂ)) (hi : Injective p)
+    (h0 : p 0=0) (hH : ∀ t : unitInterval, t≠0 → p t∈upperHalfPlane)
+    (s : unitInterval) {x : ℝ} (hx : x≠0) :
+    (initialReflectedForward p hi h0 hH s (x:ℂ)).im=0 := by
+  by_cases hs : s=0
+  · simp [initialReflectedForward,hs]
+  · rw [initialReflectedForward,dite_eq_right hs]
+    have hh := (initialReflectedChart p hi h0 hH s hs).forward_reflection
+      (fun hz => real_not_reflected_arc p h0 hH hx (reflected_initial_subset p s hz))
+    rw [conj_ofReal] at hh
+    have he := congrArg Complex.im hh
+    simp only [conj_im] at he
+    linarith
+
+lemma initialReflectedForward_uniform_bound (p : C(unitInterval,ℂ)) (hi : Injective p)
+    (h0 : p 0=0) (hH : ∀ t : unitInterval, t≠0 → p t∈upperHalfPlane)
+    {R : ℝ} (hR : 0<R) (hp : ∀ s, ‖p s‖<R) (s : unitInterval)
+    {z : ℂ} (hz : z∉reflectedArcSet p) (hzR : ‖z‖≤2*R) :
+    ‖initialReflectedForward p hi h0 hH s z‖≤(512*Real.pi+9)*R := by
+  by_cases hs : s=0
+  · simp only [initialReflectedForward,dite_eq_left hs,id_eq]
+    exact hzR.trans (by nlinarith [Real.pi_pos])
+  · rw [initialReflectedForward,dite_eq_right hs]
+    exact (initialReflectedChart p hi h0 hH s hs).forward_bounded_in_two_radius
+      (initialSubarc_injective hi hs) (by simpa only [initialSubarc_zero] using h0)
+      (initialSubarc_upper hH hs) hR (fun t => hp (s*t))
+      (fun he => hz (reflected_initial_subset p s he)) hzR
+
+end SLEExactGauge
+
+end
+
+end OAI
diff --git a/lean/OAI/Probability/SLE/Loewner/InitialSlitFuture.lean b/lean/OAI/Probability/SLE/Loewner/InitialSlitFuture.lean
new file mode 100644
index 0000000000000000000000000000000000000000..f82c495920c2b5ed376dc5b2746a2db5eb130415
--- /dev/null
+++ b/lean/OAI/Probability/SLE/Loewner/InitialSlitFuture.lean
@@ -0,0 +1,55 @@
+import OAI.Probability.SLE.Loewner.InitialForwardChart
+import Mathlib.Topology.Order.ProjIcc
+
+namespace OAI
+
+/-! The physical future of an initial simple slit, with an exact real
+offset parameter and no choice of conformal chart. -/
+noncomputable section
+open Set Filter Function
+open scoped Topology
+
+namespace SLEExactGauge
+
+def slitFutureParameter (s : unitInterval) (r : ℝ) : unitInterval :=
+  projIcc 0 1 zero_le_one ((s:ℝ)+r)
+
+lemma slitFutureParameter_continuous (s : unitInterval) :
+    Continuous (slitFutureParameter s) :=
+  continuous_projIcc.comp (continuous_const.add continuous_id)
+
+@[simp] lemma slitFutureParameter_zero (s : unitInterval) :
+    slitFutureParameter s 0=s := by
+  simp only [slitFutureParameter,add_zero,projIcc_val]
+
+lemma slitFutureParameter_coe (s : unitInterval) {r : ℝ}
+    (hr : r∈Ioo 0 (1-(s:ℝ))) :
+    (slitFutureParameter s r:ℝ)=(s:ℝ)+r := by
+  exact congrArg Subtype.val (projIcc_of_mem zero_le_one
+    (show (s:ℝ)+r∈Icc (0:ℝ) 1 from ⟨by linarith [s.property.1,hr.1],by linarith [hr.2]⟩))
+
+lemma slitFuturePoint_mem_domain (p : C(unitInterval,ℂ)) (hi : Injective p)
+    (hH : ∀ t : unitInterval, t≠0 → p t∈upperHalfPlane)
+    (s : unitInterval) {r : ℝ} (hr : r∈Ioo 0 (1-(s:ℝ))) :
+    p (slitFutureParameter s r)∈upperHalfPlane \ range (initialSubarc p s) := by
+  have he := slitFutureParameter_coe s hr
+  have hlt : s<slitFutureParameter s r := by
+    change (s:ℝ)<(slitFutureParameter s r:ℝ)
+    rw [he]
+    linarith [hr.1]
+  refine ⟨hH _ (ne_of_gt (lt_of_le_of_lt bot_le hlt)),?_⟩
+  rw [initialSubarc_range]
+  rintro ⟨u,hu,heq⟩
+  exact (not_le_of_gt hlt) (hi heq ▸ hu.2)
+
+lemma slit_tip_not_mem_domain (p : C(unitInterval,ℂ)) (s : unitInterval) :
+    p s∉upperHalfPlane \ range (initialSubarc p s) := by
+  intro h
+  apply h.2
+  exact ⟨1,by simp only [initialSubarc_apply,mul_one]⟩
+
+end SLEExactGauge
+
+end
+
+end OAI
diff --git a/lean/OAI/Probability/SLE/Loewner/InitialSubarc.lean b/lean/OAI/Probability/SLE/Loewner/InitialSubarc.lean
new file mode 100644
index 0000000000000000000000000000000000000000..deff4378286b86608bc9c2c3e7567f963aefd963
--- /dev/null
+++ b/lean/OAI/Probability/SLE/Loewner/InitialSubarc.lean
@@ -0,0 +1,66 @@
+import OAI.Probability.SLE.Loewner.PositiveSlitCapacity
+
+namespace OAI
+
+/-! Initial subarcs of a prescribed simple attached arc, with their exact
+range and nested domains. These are the family to be parametrized by capacity. -/
+noncomputable section
+open Set Function
+
+namespace SLEExactGauge
+
+def initialSubarc (p : C(unitInterval,ℂ)) (t : unitInterval) : C(unitInterval,ℂ) where
+  toFun u := p (t*u)
+  continuous_toFun := p.continuous.comp (continuous_const.mul continuous_id)
+
+@[simp] lemma initialSubarc_apply (p : C(unitInterval,ℂ)) (t u : unitInterval) :
+    initialSubarc p t u=p (t*u) := rfl
+
+@[simp] lemma initialSubarc_zero (p : C(unitInterval,ℂ)) (t : unitInterval) :
+    initialSubarc p t 0=p 0 := by simp [initialSubarc]
+
+lemma initialSubarc_injective {p : C(unitInterval,ℂ)} (hp : Injective p)
+    {t : unitInterval} (ht : t ≠ 0) : Injective (initialSubarc p t) := by
+  intro u v he
+  exact mul_left_cancel₀ ht (hp he)
+
+lemma initialSubarc_upper {p : C(unitInterval,ℂ)}
+    (hp : ∀ u : unitInterval, u ≠ 0 → p u ∈ upperHalfPlane)
+    {t : unitInterval} (ht : t ≠ 0) :
+    ∀ u : unitInterval, u ≠ 0 → initialSubarc p t u ∈ upperHalfPlane := by
+  intro u hu
+  exact hp (t*u) (mul_ne_zero ht hu)
+
+theorem initialSubarc_range (p : C(unitInterval,ℂ)) (t : unitInterval) :
+    range (initialSubarc p t)=p '' Icc 0 t := by
+  apply Subset.antisymm
+  · rintro _ ⟨u,rfl⟩
+    refine ⟨t*u,⟨bot_le,?_⟩,rfl⟩
+    have hh := mul_le_mul_of_nonneg_left u.property.2 t.property.1
+    exact_mod_cast (by simpa only [mul_one] using hh : (t:ℝ)*(u:ℝ)≤(t:ℝ))
+  · rintro _ ⟨r,hr,rfl⟩
+    by_cases ht : t=0
+    · have hr0 : r=0 := le_antisymm (ht ▸ hr.2) bot_le
+      exact ⟨0,by simp [hr0]⟩
+    · have htpos : 0<(t:ℝ) := by
+        exact_mod_cast (unitInterval.pos_iff_ne_zero.mpr ht)
+      let u : unitInterval := ⟨(r:ℝ)/(t:ℝ),div_nonneg r.property.1 htpos.le,
+        (div_le_one htpos).mpr (by exact_mod_cast hr.2)⟩
+      refine ⟨u,?_⟩
+      have he : t*u=r := by
+        apply Subtype.ext
+        change (t:ℝ)*((r:ℝ)/(t:ℝ))=(r:ℝ)
+        field_simp
+      simp only [initialSubarc_apply,he]
+
+lemma initialSubarc_range_mono (p : C(unitInterval,ℂ))
+    {s t : unitInterval} (hst : s≤t) :
+    range (initialSubarc p s) ⊆ range (initialSubarc p t) := by
+  rw [initialSubarc_range,initialSubarc_range]
+  exact image_mono (Icc_subset_Icc_right hst)
+
+end SLEExactGauge
+
+end
+
+end OAI
diff --git a/lean/OAI/Probability/SLE/Loewner/InitialSubarcReparam.lean b/lean/OAI/Probability/SLE/Loewner/InitialSubarcReparam.lean
new file mode 100644
index 0000000000000000000000000000000000000000..37bd2216df936f7e6b06924d30d1acb6056a634f
--- /dev/null
+++ b/lean/OAI/Probability/SLE/Loewner/InitialSubarcReparam.lean
@@ -0,0 +1,55 @@
+import OAI.Probability.SLE.Loewner.SlitChartRangeUniqueness
+import OAI.Probability.SLE.Loewner.InitialForwardChart
+
+namespace OAI
+
+/-! Exact capacity and inverse-chart identities under initial-subarc
+reparametrization. -/
+noncomputable section
+open Set Filter Function
+open scoped Topology
+
+namespace SLEExactGauge
+
+lemma initialSubarc_mul (p : C(unitInterval,ℂ)) (b u : unitInterval) :
+    initialSubarc (initialSubarc p b) u=initialSubarc p (b*u) := by
+  ext v
+  simp only [initialSubarc_apply,mul_assoc]
+
+lemma initialCapacity_subarc (p : C(unitInterval,ℂ)) (hi : Injective p)
+    (h0 : p 0=0) (hH : ∀ t : unitInterval, t ≠ 0 → p t ∈ upperHalfPlane)
+    (b : unitInterval) (hb : b≠0)
+    (hib : Injective (initialSubarc p b)) (h0b : initialSubarc p b 0=0)
+    (hHb : ∀ t : unitInterval, t ≠ 0 → initialSubarc p b t∈upperHalfPlane)
+    (u : unitInterval) :
+    initialCapacity (initialSubarc p b) hib h0b hHb u=initialCapacity p hi h0 hH (b*u) := by
+  by_cases hu : u=0
+  · simp only [hu,mul_zero,initialCapacity_zero]
+  have hbu : b*u≠0 := mul_ne_zero hb hu
+  rw [initialCapacity,dite_eq_right hu,initialCapacity,dite_eq_right hbu]
+  exact ((initialSlitChart (initialSubarc p b) hib h0b hHb u hu).eq_of_range_eq
+    (initialSlitChart p hi h0 hH (b*u) hbu)
+    (congrArg (fun q : C(unitInterval,ℂ) => range q) (initialSubarc_mul p b u))).1
+
+lemma initialInverseChart_subarc (p : C(unitInterval,ℂ)) (hi : Injective p)
+    (h0 : p 0=0) (hH : ∀ t : unitInterval, t ≠ 0 → p t ∈ upperHalfPlane)
+    (b : unitInterval) (hb : b≠0)
+    (hib : Injective (initialSubarc p b)) (h0b : initialSubarc p b 0=0)
+    (hHb : ∀ t : unitInterval, t ≠ 0 → initialSubarc p b t∈upperHalfPlane)
+    (u : unitInterval) :
+    EqOn (initialInverseChart (initialSubarc p b) hib h0b hHb u)
+      (initialInverseChart p hi h0 hH (b*u)) upperHalfPlane := by
+  by_cases hu : u=0
+  · simp only [hu,mul_zero,initialInverseChart_zero]
+    exact fun _ _ => rfl
+  have hbu : b*u≠0 := mul_ne_zero hb hu
+  rw [initialInverseChart,dite_eq_right hu,initialInverseChart,dite_eq_right hbu]
+  exact ((initialSlitChart (initialSubarc p b) hib h0b hHb u hu).eq_of_range_eq
+    (initialSlitChart p hi h0 hH (b*u) hbu)
+    (congrArg (fun q : C(unitInterval,ℂ) => range q) (initialSubarc_mul p b u))).2.1
+
+end SLEExactGauge
+
+end
+
+end OAI
diff --git a/lean/OAI/Probability/SLE/Loewner/InitialTipHeightBound.lean b/lean/OAI/Probability/SLE/Loewner/InitialTipHeightBound.lean
new file mode 100644
index 0000000000000000000000000000000000000000..b5357eb249ba46d1ae19a9393115499d8cc74c03
--- /dev/null
+++ b/lean/OAI/Probability/SLE/Loewner/InitialTipHeightBound.lean
@@ -0,0 +1,56 @@
+import OAI.Probability.SLE.Loewner.InitialHeightCapacityIncrement
+import OAI.Probability.SLE.Loewner.MovingForwardBoundaryHeight
+import OAI.Probability.SLE.Geometry.ApproachIntervalEndpoint
+
+namespace OAI
+
+/-! A future point has initial-chart height controlled by the capacity
+remaining before that point is swallowed. -/
+noncomputable section
+open Set Filter Function Complex Metric
+open scoped Topology
+
+namespace SLEExactGauge
+
+theorem initialForward_tip_height_bound (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) :
+    (initialForwardChart p hi h0 hH s (p t)).im^2≤
+      2*(initialCapacity p hi h0 hH t-initialCapacity p hi h0 hH s) := by
+  let r := approachIntervalEndpoint hst
+  have hr (n : ℕ) : r n∈Ico s t := approachIntervalEndpoint_mem hst n
+  have hrt : Tendsto r atTop (𝓝 t) := approachIntervalEndpoint_tendsto hst
+  obtain ⟨M,hM⟩ := (isCompact_range p.continuous).isBounded.exists_norm_le
+  let R := max M 0+1
+  have hR : 0<R := by dsimp only [R]; linarith [le_max_right M (0:ℝ)]
+  have hp : ∀ u : unitInterval, ‖p u‖<R := by
+    intro u
+    have hh := hM (p u) (mem_range_self u)
+    dsimp only [R]
+    linarith [le_max_left M (0:ℝ)]
+  have hzd (n : ℕ) : p t∈upperHalfPlane \ range (initialSubarc p (r n)) :=
+    point_after_prefix_mem_domain p hi hH (hr n).2
+  have hheight : Tendsto (fun n => (initialForwardChart p hi h0 hH (r n) (p t)).im)
+      atTop (𝓝 0) :=
+    initialForward_boundary_height_zero p hi h0 hH hrt tendsto_const_nhds hzd
+      (slit_tip_not_mem_domain p t)
+      (fun n => initialForward_uniform_near p hi h0 hH hR hp (r n) (hzd n)
+        (by linarith [hp t]))
+  have hcap := ((initialCapacity_continuous p hi h0 hH).tendsto t).comp hrt
+  have hlim := (hheight.pow 2).add
+    ((hcap.sub_const (initialCapacity p hi h0 hH s)).const_mul 2)
+  have hineq (n : ℕ) :
+      (initialForwardChart p hi h0 hH s (p t)).im^2≤
+        (initialForwardChart p hi h0 hH (r n) (p t)).im^2+
+          2*(initialCapacity p hi h0 hH (r n)-initialCapacity p hi h0 hH s) := by
+    obtain ⟨T,hrT,hTt⟩ := exists_between (hr n).2
+    exact initialForward_height_capacity_increment p hi h0 hH (hr n).1 hrT.le
+      (hTt.trans ht) (point_after_prefix_mem_domain p hi hH hTt)
+  have hh := ge_of_tendsto hlim (Eventually.of_forall hineq)
+  simpa only [zero_pow two_ne_zero,zero_add] using hh
+
+end SLEExactGauge
+
+end
+
+end OAI
diff --git a/lean/OAI/Probability/SLE/Loewner/InverseBoundaryArc.lean b/lean/OAI/Probability/SLE/Loewner/InverseBoundaryArc.lean
new file mode 100644
index 0000000000000000000000000000000000000000..7af493c89a94040835a32c6cda20276cd583e7cd
--- /dev/null
+++ b/lean/OAI/Probability/SLE/Loewner/InverseBoundaryArc.lean
@@ -0,0 +1,52 @@
+import OAI.Probability.SLE.Loewner.InverseBoundaryCluster
+import OAI.Probability.SLE.Geometry.FiniteEnergyArcExtension
+
+namespace OAI
+
+/-! Endpoint values of continuously extended inverse-chart arcs lie on
+the physical frontier, independently of a global boundary extension. -/
+noncomputable section
+open Set Filter Metric Function
+open scoped Topology
+
+namespace SLEExactGauge
+
+lemma inverse_limit_mem_frontier_filter {A : Type*} {l : Filter A} [l.NeBot]
+    {D : Set ℂ} (hD : IsOpen D) {g f : ℂ → ℂ} (hg : ContinuousOn g D)
+    (hgH : MapsTo g D upperHalfPlane) (hfD : MapsTo f upperHalfPlane D)
+    (hinv : ∀ w∈upperHalfPlane, g (f w)=w)
+    {w : A → ℂ} (hw : ∀ᶠ a in l, w a∈upperHalfPlane) {x : ℂ}
+    (hx : x∉upperHalfPlane) (hlim : Tendsto w l (𝓝 x)) {z : ℂ}
+    (hz : Tendsto (fun a => f (w a)) l (𝓝 z)) : z∈frontier D := by
+  have hcl : z∈closure D := mem_closure_of_tendsto hz (hw.mono fun _ ha => hfD ha)
+  have hnot : z∉D := by
+    intro hzin
+    have hg' := ((hg z hzin).continuousAt (hD.mem_nhds hzin)).tendsto.comp hz
+    have he : Tendsto w l (𝓝 (g z)) := hg'.congr' (hw.mono fun a ha => hinv (w a) ha)
+    have heq : g z=x := tendsto_nhds_unique he hlim
+    exact hx (heq ▸ hgH hzin)
+  exact ⟨hcl,by simpa only [hD.interior_eq] using hnot⟩
+
+lemma inverse_arc_endpoint_mem_frontier {D : Set ℂ} (hD : IsOpen D)
+    {g f : ℂ → ℂ} (hg : ContinuousOn g D)
+    (hgH : MapsTo g D upperHalfPlane) (hfD : MapsTo f upperHalfPlane D)
+    (hinv : ∀ w∈upperHalfPlane, g (f w)=w)
+    {w c : ℝ → ℂ} (hw : Continuous w) (hc : Continuous c)
+    {a b s : ℝ} (hab : a<b) (hs : s∈Icc a b)
+    (hwin : MapsTo w (Ioo a b) upperHalfPlane)
+    (hws : w s∉upperHalfPlane) (heq : EqOn c (f ∘ w) (Ioo a b)) :
+    c s∈frontier D := by
+  have hscl : s∈closure (Ioo a b) := by rwa [closure_Ioo (ne_of_lt hab)]
+  have : (𝓝[Ioo a b] s).NeBot := mem_closure_iff_nhdsWithin_neBot.mp hscl
+  have hmem : ∀ᶠ θ in 𝓝[Ioo a b] s, θ∈Ioo a b := self_mem_nhdsWithin
+  apply inverse_limit_mem_frontier_filter hD hg hgH hfD hinv
+    (hmem.mono fun _ h => hwin h) hws
+    ((hw.tendsto s).mono_left nhdsWithin_le_nhds)
+  exact ((hc.tendsto s).mono_left nhdsWithin_le_nhds).congr'
+    (hmem.mono fun _ hθ => heq hθ)
+
+end SLEExactGauge
+
+end
+
+end OAI
diff --git a/lean/OAI/Probability/SLE/Loewner/InverseBoundaryBound.lean b/lean/OAI/Probability/SLE/Loewner/InverseBoundaryBound.lean
new file mode 100644
index 0000000000000000000000000000000000000000..f38523653df134a51c82d7d9f4349de3eaf889b1
--- /dev/null
+++ b/lean/OAI/Probability/SLE/Loewner/InverseBoundaryBound.lean
@@ -0,0 +1,51 @@
+import OAI.Probability.SLE.LoewnerCharts
+
+namespace OAI
+
+/-! Hydrodynamic normalization prevents an inverse chart from escaping to
+infinity above a bounded set. This is independent of boundary extension. -/
+noncomputable section
+open Set Filter Metric Function
+open scoped Topology NNReal
+
+namespace SLEExactGauge
+
+lemma inverse_bound_of_hydrodynamic {D : Set ℂ} {g f : ℂ → ℂ} {c : ℂ}
+    (hmap : MapsTo f upperHalfPlane D)
+    (hinv : ∀ w∈upperHalfPlane, g (f w)=w)
+    (hlim : Tendsto (fun z : ℂ => z*(g z-z)) (cocompact ℂ ⊓ 𝓟 D) (𝓝 c))
+    (R : ℝ) : ∃ M : ℝ, ∀ w∈upperHalfPlane, ‖w‖≤R → ‖f w‖≤M := by
+  have he := Metric.tendsto_nhds.mp hlim 1 zero_lt_one
+  rw [eventually_inf_principal,← Metric.cobounded_eq_cocompact] at he
+  obtain ⟨N,_,hN⟩ := Filter.hasBasis_cobounded_norm.eventually_iff.mp he
+  refine ⟨max (max N 1) (R+‖c‖+1),fun w hw hR => ?_⟩
+  by_cases hz : ‖f w‖ ≤ max N 1
+  · exact hz.trans (le_max_left _ _)
+  have hz' := lt_of_not_ge hz
+  have hzN : N≤‖f w‖ := (le_max_left _ _).trans hz'.le
+  have hz1 : 1≤‖f w‖ := (le_max_right _ _).trans hz'.le
+  have hsmall := hN hzN (hmap hw)
+  have hp : ‖f w‖*‖g (f w)-f w‖≤‖c‖+1 := by
+    have htri := norm_le_norm_sub_add (f w*(g (f w)-f w)) c
+    rw [norm_mul] at htri
+    have hd : ‖f w*(g (f w)-f w)-c‖<1 := by simpa only [dist_eq_norm] using hsmall
+    linarith
+  have hd : ‖g (f w)-f w‖≤‖c‖+1 :=
+    (le_mul_of_one_le_left (norm_nonneg _) hz1).trans hp
+  have htri := norm_le_norm_sub_add (f w) (g (f w))
+  rw [hinv w hw] at htri hd
+  rw [norm_sub_rev w (f w)] at hd
+  exact (show ‖f w‖≤R+‖c‖+1 by linarith).trans (le_max_right _ _)
+
+lemma IsCapacityTwoWitness.inverse_bounded_over_ball
+    {U : ℝ≥0 → ℝ} {γ : ℝ≥0 → ℂ} {G F : ℝ≥0 → ℂ → ℂ}
+    (hw : IsCapacityTwoWitness U γ G F) (t : ℝ≥0) (R : ℝ) :
+    ∃ M : ℝ, ∀ w∈upperHalfPlane, ‖w‖≤R → ‖F t w‖≤M :=
+  inverse_bound_of_hydrodynamic (hw.2.2.2.2.2.2.1 t)
+    (hw.2.2.2.2.2.2.2.2.1 t) (hw.2.2.2.2.2.2.2.2.2.2.2.1 t) R
+
+end SLEExactGauge
+
+end
+
+end OAI
diff --git a/lean/OAI/Probability/SLE/Loewner/InverseBoundaryClosingPath.lean b/lean/OAI/Probability/SLE/Loewner/InverseBoundaryClosingPath.lean
new file mode 100644
index 0000000000000000000000000000000000000000..b00dd2b6fc1f9e312cd016aec89e0835f3ca1c9a
--- /dev/null
+++ b/lean/OAI/Probability/SLE/Loewner/InverseBoundaryClosingPath.lean
@@ -0,0 +1,78 @@
+import OAI.Probability.SLE.Loewner.InverseSmallSemicircles
+import OAI.Probability.SLE.Loewner.TraceBoundaryBarrier
+
+namespace OAI
+
+/-! A small image semicircle can be closed by a small path outside the
+surviving domain. The closing path is supplied by the actual finite trace
+and real boundary, not by a further topological input. -/
+noncomputable section
+open Set Filter Metric Function
+open scoped Topology NNReal
+
+namespace SLEExactGauge
+
+lemma IsCapacityTwoWitness.exists_small_inverse_closing_path
+    {U : ℝ≥0 → ℝ} {γ : ℝ≥0 → ℂ} {G F : ℝ≥0 → ℂ → ℂ}
+    (hw : IsCapacityTwoWitness U γ G F) (t : ℝ≥0) (x Q ε : ℝ) (hε : 0<ε) :
+    ∃ (v : ℝ) (c : ℝ → ℂ) (p : Path (c Real.pi) (c 0)), v<Q ∧ Continuous c ∧
+      (∀ θ∈Ioo 0 Real.pi, c θ=F t ((x:ℂ)+Complex.exp ((v:ℂ)+(θ:ℂ)*Complex.I))) ∧
+      (∀ θ∈Icc 0 Real.pi, dist (c θ) (c 0)<ε) ∧
+      (∀ s, dist (p s) (c 0)<ε ∧ p s∉survivingDomain γ t) ∧
+      c 0∈frontier (survivingDomain γ t) ∧ c Real.pi∈frontier (survivingDomain γ t) ∧
+      MapsTo c (Ioo 0 Real.pi) (survivingDomain γ t) ∧ InjOn c (Ioo 0 Real.pi) := by
+  obtain ⟨M,hM⟩ := hw.inverse_bounded_over_ball t (‖(x:ℂ)‖+1)
+  let R := max (M+1) 0
+  obtain ⟨δ,hδ,hpath⟩ := traceBoundaryBarrier_uniform_paths hw.1 t R (le_max_right _ _)
+    (ε/2) (half_pos hε)
+  let η := min 1 (min (ε/2) (δ/2))
+  have hη : 0<η := lt_min zero_lt_one (lt_min (half_pos hε) (half_pos hδ))
+  obtain ⟨v,c,hv,hc,he,hdiam,hc0,hcπ,hmap,hinj⟩ :=
+    hw.exists_small_inverse_semicircle t x (min Q 0) η hη
+  have hv0 : v<0 := hv.trans_le (min_le_right _ _)
+  have hη1 : η≤1 := min_le_left _ _
+  have hηε : η≤ε/2 := (min_le_right _ _).trans (min_le_left _ _)
+  have hηδ : η≤δ/2 := (min_le_right _ _).trans (min_le_right _ _)
+  let a := Real.pi/2
+  have ha : a∈Ioo 0 Real.pi := ⟨half_pos Real.pi_pos,by dsimp [a]; linarith [Real.pi_pos]⟩
+  have hwa : (x:ℂ)+Complex.exp ((v:ℂ)+(a:ℂ)*Complex.I)∈upperHalfPlane := by
+    have he' := exp_strip_halfplane (x := (v:ℂ)+(a:ℂ)*Complex.I) (by simpa using ha)
+    change 0<((x:ℂ)+Complex.exp ((v:ℂ)+(a:ℂ)*Complex.I)).im
+    simpa only [Set.mem_ofPred_eq,Complex.add_im,Complex.ofReal_im,zero_add] using he'
+  have hna : ‖(x:ℂ)+Complex.exp ((v:ℂ)+(a:ℂ)*Complex.I)‖≤‖(x:ℂ)‖+1 := by
+    refine (norm_add_le _ _).trans (add_le_add le_rfl ?_)
+    rw [Complex.norm_exp]
+    simpa using (Real.exp_le_one_iff.mpr hv0.le)
+  have hca : ‖c a‖≤M := by rw [he a ha]; exact hM _ hwa hna
+  have hcb (s : ℝ) (hs : s∈Icc 0 Real.pi) : ‖c s‖≤R := by
+    have hd : ‖c s-c a‖≤η := hdiam s hs a (Ioo_subset_Icc_self ha)
+    calc
+      ‖c s‖ ≤ ‖c s-c a‖+‖c a‖ := by
+        convert norm_add_le (c s-c a) (c a) using 1; simp
+      _ ≤ η+M := add_le_add hd hca
+      _ ≤ 1+M := add_le_add hη1 le_rfl
+      _ = M+1 := add_comm _ _
+      _ ≤ R := le_max_left _ _
+  have h0 : c 0∈traceBoundaryBarrier γ t R :=
+    frontier_mem_traceBoundaryBarrier hw.1 hc0 (hcb 0 ⟨le_rfl,Real.pi_pos.le⟩)
+  have hπ : c Real.pi∈traceBoundaryBarrier γ t R :=
+    frontier_mem_traceBoundaryBarrier hw.1 hcπ (hcb Real.pi ⟨Real.pi_pos.le,le_rfl⟩)
+  have hdπ : dist (c Real.pi) (c 0)≤η := by
+    simpa only [dist_eq_norm] using hdiam Real.pi ⟨Real.pi_pos.le,le_rfl⟩ 0 ⟨le_rfl,Real.pi_pos.le⟩
+  obtain ⟨p,hpB,hp⟩ := hpath (c Real.pi) hπ (c 0) h0 (hdπ.trans_lt (hηδ.trans_lt (half_lt_self hδ)))
+  refine ⟨v,c,p,hv.trans_le (min_le_left _ _),hc,he,?_,?_,hc0,hcπ,hmap,hinj⟩
+  · intro θ hθ
+    have hdθ : dist (c θ) (c 0)≤η := by
+      simpa only [dist_eq_norm] using hdiam θ hθ 0 ⟨le_rfl,Real.pi_pos.le⟩
+    exact hdθ.trans_lt (hηε.trans_lt (half_lt_self hε))
+  · intro s
+    refine ⟨?_,fun hD => (disjoint_left.mp (traceBoundaryBarrier_disjoint_domain γ t R)) (hpB s) hD⟩
+    have htri := dist_triangle (p s) (c Real.pi) (c 0)
+    have hps := hp s
+    linarith
+
+end SLEExactGauge
+
+end
+
+end OAI
diff --git a/lean/OAI/Probability/SLE/Loewner/InverseBoundaryCluster.lean b/lean/OAI/Probability/SLE/Loewner/InverseBoundaryCluster.lean
new file mode 100644
index 0000000000000000000000000000000000000000..d30e68fbeb803af5e9f508dd7ac07181adcddf68
--- /dev/null
+++ b/lean/OAI/Probability/SLE/Loewner/InverseBoundaryCluster.lean
@@ -0,0 +1,56 @@
+import OAI.Probability.SLE.Loewner.InverseBoundaryBound
+
+namespace OAI
+
+/-! Finite inverse-chart cluster points above the real axis lie on the
+ physical domain boundary. No boundary extension is assumed. -/
+noncomputable section
+open Set Filter Metric Function
+open scoped Topology NNReal
+
+namespace SLEExactGauge
+
+lemma inverse_limit_mem_frontier {D : Set ℂ} (hD : IsOpen D)
+    {g f : ℂ → ℂ} (hg : ContinuousOn g D)
+    (hgH : MapsTo g D upperHalfPlane) (hfD : MapsTo f upperHalfPlane D)
+    (hinv : ∀ w∈upperHalfPlane, g (f w)=w)
+    {w : ℕ → ℂ} (hw : ∀ n, w n∈upperHalfPlane) {x : ℝ}
+    (hlim : Tendsto w atTop (𝓝 (x:ℂ))) {z : ℂ}
+    (hz : Tendsto (fun n => f (w n)) atTop (𝓝 z)) : z∈frontier D := by
+  have hcl : z∈closure D := mem_closure_of_tendsto hz (Eventually.of_forall fun n => hfD (hw n))
+  have hnot : z∉D := by
+    intro hzin
+    have hg' := ((hg z hzin).continuousAt (hD.mem_nhds hzin)).tendsto.comp hz
+    have he : Tendsto w atTop (𝓝 (g z)) := by
+      convert hg' using 1
+      funext n
+      exact (hinv (w n) (hw n)).symm
+    have heq : g z=(x:ℂ) := tendsto_nhds_unique he hlim
+    have him := hgH hzin
+    rw [heq] at him
+    change 0 < (x:ℂ).im at him
+    norm_num at him
+  exact ⟨hcl,by simpa only [hD.interior_eq] using hnot⟩
+
+lemma IsCapacityTwoWitness.inverse_boundary_subsequence
+    {U : ℝ≥0 → ℝ} {γ : ℝ≥0 → ℂ} {G F : ℝ≥0 → ℂ → ℂ}
+    (h : IsCapacityTwoWitness U γ G F) (t : ℝ≥0)
+    (w : ℕ → ℂ) (hw : ∀ n, w n∈upperHalfPlane) (x : ℝ)
+    (hlim : Tendsto w atTop (𝓝 (x:ℂ))) :
+    ∃ (φ : ℕ → ℕ) (z : ℂ), StrictMono φ ∧ z∈frontier (survivingDomain γ t) ∧
+      Tendsto (fun n => F t (w (φ n))) atTop (𝓝 z) := by
+  obtain ⟨R,hR⟩ := (Metric.isBounded_range_of_tendsto w hlim).exists_norm_le
+  obtain ⟨M,hM⟩ := h.inverse_bounded_over_ball t R
+  obtain ⟨z,_,φ,hφ,hconv⟩ := (isCompact_closedBall (0:ℂ) M).tendsto_subseq (fun n => by
+    rw [mem_closedBall,dist_zero_right]
+    exact hM (w n) (hw n) (hR _ (mem_range_self n)))
+  refine ⟨φ,z,hφ,?_,hconv⟩
+  exact inverse_limit_mem_frontier (isOpen_survivingDomain h.1 t)
+    ((h.2.2.2.1 t).continuousOn) (h.2.2.2.2.2.1 t) (h.2.2.2.2.2.2.1 t)
+    (h.2.2.2.2.2.2.2.2.1 t) (fun n => hw (φ n)) (hlim.comp hφ.tendsto_atTop) hconv
+
+end SLEExactGauge
+
+end
+
+end OAI
diff --git a/lean/OAI/Probability/SLE/Loewner/InverseBoundaryShrink.lean b/lean/OAI/Probability/SLE/Loewner/InverseBoundaryShrink.lean
new file mode 100644
index 0000000000000000000000000000000000000000..1a8866ad47dec2d78af84c01e9109066dd6f76b7
--- /dev/null
+++ b/lean/OAI/Probability/SLE/Loewner/InverseBoundaryShrink.lean
@@ -0,0 +1,106 @@
+import OAI.Probability.SLE.Geometry.PolarBoundarySeparation
+import OAI.Probability.SLE.Loewner.InverseBoundaryClosingPath
+
+namespace OAI
+
+/-! Small closed image semicircles force the images of their entire
+half-disks to be small. The Loewner height inequality supplies the exterior
+endpoint of each radial crossing. -/
+noncomputable section
+open Set Filter Metric Function
+open scoped Topology NNReal
+
+namespace SLEExactGauge
+
+lemma IsCapacityTwoWitness.inverse_im_ge
+    {U : ℝ≥0 → ℝ} {γ : ℝ≥0 → ℂ} {G F : ℝ≥0 → ℂ → ℂ}
+    (hw : IsCapacityTwoWitness U γ G F) (t : ℝ≥0) {w : ℂ} (hwH : w∈upperHalfPlane) :
+    w.im≤(F t w).im := by
+  have hz := hw.2.2.2.2.2.2.1 t hwH
+  have h := hw.imag_ge_terminal t (F t w) hz 0 ⟨le_rfl,t.coe_nonneg⟩
+  simpa only [Real.toNNReal_zero,hw.2.2.2.2.2.2.2.2.1 t w hwH,hw.initial_value (F t w) hz.1.1] using h
+
+lemma IsCapacityTwoWitness.inverse_arc_traps_radial_point
+    {U : ℝ≥0 → ℝ} {γ : ℝ≥0 → ℂ} {G F : ℝ≥0 → ℂ → ℂ}
+    (hw : IsCapacityTwoWitness U γ G F) (t : ℝ≥0)
+    (x r ρ θ : ℝ) (hρ : 0<ρ) (hρr : ρ<r) (hθ : θ∈Ioo 0 Real.pi)
+    (c : ℝ → ℂ) (hc : Continuous c)
+    (he : ∀ a∈Ioo 0 Real.pi, c a=F t ((x:ℂ)+(r:ℂ)*Complex.exp ((a:ℂ)*Complex.I)))
+    (hc0 : c 0∉survivingDomain γ t) (hcπ : c Real.pi∉survivingDomain γ t)
+    (q : Path (c Real.pi) (c 0)) (hq : ∀ u, q u∉survivingDomain γ t)
+    (w : ℂ) (ε : ℝ) (hε : 0<ε)
+    (hcball : ∀ a∈Icc 0 Real.pi, c a∈ball w ε)
+    (hqball : ∀ u, q u∈ball w ε) :
+    F t ((x:ℂ)+(ρ:ℂ)*Complex.exp ((θ:ℂ)*Complex.I))∈ball w ε := by
+  let E := Complex.exp ((θ:ℂ)*Complex.I)
+  have hE : 0<E.im := exp_strip_halfplane (x := (θ:ℂ)*Complex.I) (by simpa using hθ)
+  obtain ⟨R,hR⟩ := exists_gt (max r ((w.im+ε)/E.im))
+  have hrR : r<R := (le_max_left _ _).trans_lt hR
+  have hRE : w.im+ε<R*E.im :=
+    (div_lt_iff₀ hE).mp ((le_max_right _ _).trans_lt hR)
+  have hRH := univalent_polar_point_mem x R θ ((hρ.trans hρr).trans hrR) hθ
+  have hRout : F t ((x:ℂ)+(R:ℂ)*E)∉ball w ε := by
+    intro hm
+    have him : R*E.im≤(F t ((x:ℂ)+(R:ℂ)*E)).im := by
+      simpa only [Complex.add_im,Complex.ofReal_im,Complex.mul_im,Complex.ofReal_re,
+        zero_mul,add_zero,zero_add] using hw.inverse_im_ge t hRH
+    have hdist : ‖F t ((x:ℂ)+(R:ℂ)*E)-w‖<ε := by
+      simpa only [mem_ball,dist_eq_norm] using hm
+    have hle := (le_abs_self (F t ((x:ℂ)+(R:ℂ)*E)-w).im).trans
+      (Complex.abs_im_le_norm (F t ((x:ℂ)+(R:ℂ)*E)-w))
+    rw [Complex.sub_im] at hle
+    linarith
+  have hi : InjOn (F t) upperHalfPlane := by
+    intro a ha b hb hab
+    have := congrArg (G t) hab
+    simpa only [hw.2.2.2.2.2.2.2.2.1 t a ha,hw.2.2.2.2.2.2.2.2.1 t b hb] using this
+  exact polar_arc_traps_radial_point (hw.2.2.2.2.1 t) hi (hw.2.2.2.2.2.2.1 t)
+    x r ρ R θ hρ hρr hrR hθ c hc he hc0 hcπ q hq w ε hε hcball hqball hRout
+
+lemma polar_representation_upperHalfPlane (x : ℝ) {w : ℂ} (hw : w∈upperHalfPlane) :
+    ∃ ρ θ : ℝ, 0<ρ ∧ θ∈Ioo 0 Real.pi ∧ ρ=‖w-(x:ℂ)‖ ∧
+      w=(x:ℂ)+(ρ:ℂ)*Complex.exp ((θ:ℂ)*Complex.I) := by
+  let z := w-(x:ℂ)
+  have him : 0<z.im := by
+    change 0<w.im at hw
+    simpa [z] using hw
+  have hz : z≠0 := by
+    intro h
+    rw [h] at him
+    exact (lt_irrefl 0) him
+  have ha0 : 0<z.arg := lt_of_le_of_ne (Complex.arg_nonneg_iff.mpr him.le)
+    (fun h => him.ne' (Complex.arg_eq_zero_iff.mp h.symm).2)
+  have haπ : z.arg<Real.pi := Complex.arg_lt_pi_iff.mpr (Or.inr him.ne')
+  refine ⟨‖z‖,z.arg,norm_pos_iff.mpr hz,⟨ha0,haπ⟩,rfl,?_⟩
+  rw [Complex.norm_mul_exp_arg_mul_I]
+  dsimp [z]
+  abel
+
+lemma IsCapacityTwoWitness.small_boundary_halfdisk
+    {U : ℝ≥0 → ℝ} {γ : ℝ≥0 → ℂ} {G F : ℝ≥0 → ℂ → ℂ}
+    (hw : IsCapacityTwoWitness U γ G F) (t : ℝ≥0) (x ε : ℝ) (hε : 0<ε) :
+    ∃ r : ℝ, 0<r ∧ ∃ z : ℂ, ∀ w∈upperHalfPlane,
+      dist w (x:ℂ)<r → dist (F t w) z<ε := by
+  obtain ⟨v,c,q,_,hc,he,hcb,hqb,hc0,hcπ,_,_⟩ :=
+    hw.exists_small_inverse_closing_path t x 0 ε hε
+  refine ⟨Real.exp v,Real.exp_pos _,c 0,?_⟩
+  intro w hwH hwr
+  obtain ⟨ρ,θ,hρ,hθ,hρeq,hweq⟩ := polar_representation_upperHalfPlane x hwH
+  have hρr : ρ<Real.exp v := by simpa only [hρeq,dist_eq_norm] using hwr
+  rw [hweq]
+  apply hw.inverse_arc_traps_radial_point t x (Real.exp v) ρ θ hρ hρr hθ c hc
+  · intro a ha
+    rw [he a ha,Complex.exp_add]
+    rw [←Complex.ofReal_exp]
+  · simpa only [(isOpen_survivingDomain hw.1 t).interior_eq] using hc0.2
+  · simpa only [(isOpen_survivingDomain hw.1 t).interior_eq] using hcπ.2
+  · exact fun u => (hqb u).2
+  · exact hε
+  · exact hcb
+  · exact fun u => (hqb u).1
+
+end SLEExactGauge
+
+end
+
+end OAI
diff --git a/lean/OAI/Probability/SLE/Loewner/InverseCircleArea.lean b/lean/OAI/Probability/SLE/Loewner/InverseCircleArea.lean
new file mode 100644
index 0000000000000000000000000000000000000000..900a0d52b23ba06a9185081c42f3af818f30b83a
--- /dev/null
+++ b/lean/OAI/Probability/SLE/Loewner/InverseCircleArea.lean
@@ -0,0 +1,50 @@
+import OAI.Probability.SLE.Geometry.HolomorphicRadialFlux
+
+namespace OAI
+
+/-! Inversion of circle averages and the elementary signed-area identity
+for a map with leading term z and a holomorphic inverse-radius remainder. -/
+noncomputable section
+open Set Filter Metric Function Complex MeasureTheory InnerProductSpace Real
+open scoped Topology Laplacian ComplexConjugate
+
+namespace SLEExactGauge
+
+lemma circleAverage_inv_radius {E : Type*} [NormedAddCommGroup E] [NormedSpace ℝ E]
+    (f : ℂ → E) (r : ℝ) :
+    circleAverage (fun z => f z⁻¹) 0 r=circleAverage f 0 r⁻¹ := by
+  calc
+    _ = circleAverage (fun z : ℂ => f (((r:ℂ)*z+0)⁻¹)) 0 1 :=
+      circleAverage_eq_circleAverage_zero_one
+    _ = circleAverage (fun z : ℂ => f (((r⁻¹:ℝ):ℂ)*z⁻¹)) 0 1 := by
+      congr 1
+      ext z
+      simp only [add_zero,mul_inv_rev,Complex.ofReal_inv,mul_comm]
+    _ = circleAverage (fun z : ℂ => f (((r⁻¹:ℝ):ℂ)*z)) 0 1 := by
+      exact circleAverage_zero_one_congr_inv (f := fun z : ℂ => f (((r⁻¹:ℝ):ℂ)*z))
+    _ = _ := by
+      simpa only [add_zero] using
+        (circleAverage_eq_circleAverage_zero_one (f := f) (c := (0:ℂ)) (R := r⁻¹)).symm
+
+lemma inverse_area_density_identity (z c cp : ℂ) (hz : z≠0) :
+    2*((z-z⁻¹*cp)*conj (z+c)).re=
+      2*‖z‖^2+2*‖z‖^2*(z⁻¹*c-z⁻¹^2*cp).re-
+        2*(z⁻¹*cp*conj c).re := by
+  have hh : (z-z⁻¹*cp)*conj (z+c)=
+      ((‖z‖^2:ℝ):ℂ)+((‖z‖^2:ℝ):ℂ)*(conj (z⁻¹*c)-z⁻¹^2*cp)-z⁻¹*cp*conj c := by
+    have hnorm : ((‖z‖^2:ℝ):ℂ)=z*conj z := by
+      simpa only [Complex.ofReal_pow] using (Complex.mul_conj' z).symm
+    rw [hnorm]
+    simp only [map_add,map_mul,map_inv₀]
+    field_simp [hz]
+    ring
+  rw [hh]
+  simp only [Complex.add_re,Complex.sub_re,Complex.mul_re,
+    Complex.ofReal_re,Complex.ofReal_im,zero_mul,sub_zero,Complex.conj_re]
+  ring
+
+end SLEExactGauge
+
+end
+
+end OAI
diff --git a/lean/OAI/Probability/SLE/Loewner/InverseDirichletEnergy.lean b/lean/OAI/Probability/SLE/Loewner/InverseDirichletEnergy.lean
new file mode 100644
index 0000000000000000000000000000000000000000..02633e66550c05152caf6654257a20708d7d6f61
--- /dev/null
+++ b/lean/OAI/Probability/SLE/Loewner/InverseDirichletEnergy.lean
@@ -0,0 +1,47 @@
+import OAI.Probability.SLE.Loewner.InverseBoundaryBound
+import OAI.Probability.SLE.Gauge.ConformalSausageTransfer
+
+namespace OAI
+
+/-! Finite local Dirichlet energy for the inverse Loewner chart follows
+from injectivity, the area formula and hydrodynamic boundedness. -/
+noncomputable section
+open Set Filter Metric Function MeasureTheory
+open scoped Topology NNReal ENNReal
+
+namespace SLEExactGauge
+
+lemma IsCapacityTwoWitness.inverse_local_dirichlet_finite
+    {U : ℝ≥0 → ℝ} {γ : ℝ≥0 → ℂ} {G F : ℝ≥0 → ℂ → ℂ}
+    (hw : IsCapacityTwoWitness U γ G F) (t : ℝ≥0) (x : ℂ) (R : ℝ) :
+    (∫⁻ z in upperHalfPlane ∩ ball x R, ENNReal.ofReal (‖deriv (F t) z‖^2))<∞ := by
+  let S := upperHalfPlane ∩ ball x R
+  have hS : MeasurableSet S := isOpen_upperHalfPlane.measurableSet.inter measurableSet_ball
+  have hder (z : ℂ) (hz : z∈S) : HasDerivAt (F t) (deriv (F t) z) z :=
+    ((hw.2.2.2.2.1 t).differentiableAt (isOpen_upperHalfPlane.mem_nhds hz.1)).hasDerivAt
+  have hinj : InjOn (F t) S := by
+    intro z hz w hw' he
+    have h1 := hw.2.2.2.2.2.2.2.2.1 t z hz.1
+    have h2 := hw.2.2.2.2.2.2.2.2.1 t w hw'.1
+    rw [he,h2] at h1
+    exact h1.symm
+  have harea : (∫⁻ z in S, ENNReal.ofReal (‖deriv (F t) z‖^2)) = volume (F t '' S) := by
+    have he := lintegral_abs_det_fderiv_eq_addHaar_image volume hS
+      (fun z hz => ((hder z hz).hasFDerivAt.restrictScalars ℝ).hasFDerivWithinAt) hinj
+    simpa only [complex_derivative_real_det,abs_pow,abs_norm] using he
+  obtain ⟨M,hM⟩ := hw.inverse_bounded_over_ball t (R+‖x‖)
+  have himage : F t '' S ⊆ closedBall (0:ℂ) M := by
+    rintro _ ⟨z,hz,rfl⟩
+    rw [mem_closedBall,dist_zero_right]
+    apply hM z hz.1
+    have hnear : ‖z-x‖<R := by simpa only [mem_ball,dist_eq_norm] using hz.2
+    have := norm_le_norm_sub_add z x
+    linarith
+  rw [harea]
+  exact (measure_mono himage).trans_lt (isCompact_closedBall (0:ℂ) M).measure_lt_top
+
+end SLEExactGauge
+
+end
+
+end OAI
diff --git a/lean/OAI/Probability/SLE/Loewner/InverseRectangleEnergy.lean b/lean/OAI/Probability/SLE/Loewner/InverseRectangleEnergy.lean
new file mode 100644
index 0000000000000000000000000000000000000000..c30a43308e598a939a24cd37289db746a85acafd
--- /dev/null
+++ b/lean/OAI/Probability/SLE/Loewner/InverseRectangleEnergy.lean
@@ -0,0 +1,78 @@
+import OAI.Probability.SLE.Loewner.InverseVerticalDifferentiation
+
+namespace OAI
+
+/-! Fubini transfers the common inverse-chart Dirichlet bound to
+vertical sections over a bounded real interval. -/
+noncomputable section
+open Set Filter Function Complex Metric MeasureTheory
+open scoped Topology ENNReal
+
+namespace SLEExactGauge
+
+theorem initialInverse_rectangle_energy (p : C(unitInterval,ℂ)) (hi : Injective p)
+    (h0 : p 0=0) (hH : ∀ t : unitInterval, t≠0 → p t∈upperHalfPlane)
+    {R : ℝ} (hR : 0<R) (hp : ∀ t : unitInterval, ‖p t‖<R)
+    (s : unitInterval) (a b L : ℝ) {h : ℝ} (_hh : 0<h) (hh1 : h≤1)
+    (hx : ∀ x∈Ioo a b, |x|≤L) :
+    (∫ x in Ioo a b, ∫ y in Ioc 0 h,
+      ‖deriv (initialInverseChart p hi h0 hH s) ((x:ℂ)+(y:ℂ)*Complex.I)‖^2)≤
+        (volume (closedBall (0:ℂ) (L+2+3*R))).toReal ∧
+    IntegrableOn (fun x : ℝ => ∫ y in Ioc 0 h,
+      ‖deriv (initialInverseChart p hi h0 hH s) ((x:ℂ)+(y:ℂ)*Complex.I)‖^2)
+      (Ioo a b) ∧
+    ∀ᵐ x : ℝ ∂volume.restrict (Ioo a b),
+      MemLp (fun y : ℝ => deriv (initialInverseChart p hi h0 hH s)
+        ((x:ℂ)+(y:ℂ)*Complex.I)) 2 (volume.restrict (Ioc 0 h)) := by
+  let F := initialInverseChart p hi h0 hH s
+  let J := Ioo a b
+  let K := Ioc 0 h
+  let S := upperHalfPlane ∩ ball (0:ℂ) (L+2)
+  let T := {z : ℂ | z.re∈J ∧ z.im∈K}
+  let e := Complex.measurableEquivRealProd.symm
+  have he : MeasurePreserving e volume volume := Complex.volume_preserving_equiv_real_prod.symm _
+  have hpre : e ⁻¹' T=J ×ˢ K := by ext z; simp [e,T,J,K]
+  have hTS : T⊆S := by
+    intro z hz
+    refine ⟨hz.2.1,mem_ball_zero_iff.mpr ?_⟩
+    have hb := norm_le_abs_re_add_abs_im z
+    rw [abs_of_pos hz.2.1] at hb
+    have hx' := hx z.re hz.1
+    have hy' : z.im≤1 := hz.2.2.trans hh1
+    linarith
+  have hiS : IntegrableOn (fun z => ‖deriv F z‖^2) S :=
+    initialInverse_energy_integrable p hi h0 hH hR hp s (L+2)
+  have hiT := hiS.mono_set hTS
+  have hip : Integrable (fun z : ℝ × ℝ => ‖deriv F (e z)‖^2)
+      ((volume.restrict J).prod (volume.restrict K)) := by
+    rw [Measure.prod_restrict]
+    exact hpre ▸ (he.integrableOn_comp_preimage e.measurableEmbedding).mpr hiT
+  have heq : (∫ x in J, ∫ y in K, ‖deriv F (e (x,y))‖^2)=
+      ∫ z in T, ‖deriv F z‖^2 := by
+    rw [← integral_prod _ hip,Measure.prod_restrict,←hpre]
+    simpa only [Measure.volume_eq_prod] using
+      he.setIntegral_preimage_emb e.measurableEmbedding (fun z => ‖deriv F z‖^2) T
+  have hbound : (∫ x in J, ∫ y in K, ‖deriv F (e (x,y))‖^2)≤
+      (volume (closedBall (0:ℂ) (L+2+3*R))).toReal := by
+    rw [heq]
+    exact (setIntegral_mono_set hiS (ae_of_all _ (fun z => sq_nonneg _)) hTS.eventuallySubset).trans
+      (initialInverse_energy_integral_le p hi h0 hH hR hp s (L+2))
+  have hsections : ∀ᵐ x : ℝ ∂volume.restrict J,
+      MemLp (fun y : ℝ => deriv F (e (x,y))) 2 (volume.restrict K) := by
+    filter_upwards [hip.prod_right_ae] with x hxi
+    have hm : AEStronglyMeasurable (fun y : ℝ => deriv F (e (x,y))) (volume.restrict K) :=
+      ((measurable_deriv F).comp (e.measurable.comp measurable_prodMk_left)).aestronglyMeasurable
+    exact (memLp_two_iff_integrable_sq_norm hm).mpr hxi
+  have heval (x y : ℝ) : e (x,y)=(x:ℂ)+(y:ℂ)*Complex.I := by
+    apply Complex.ext <;> simp [e]
+  constructor
+  · simpa only [heval] using hbound
+  · constructor
+    · simpa only [heval,F,J,K,IntegrableOn] using hip.integral_prod_left
+    · simpa only [heval] using hsections
+
+end SLEExactGauge
+
+end
+
+end OAI
diff --git a/lean/OAI/Probability/SLE/Loewner/InverseSmallSemicircles.lean b/lean/OAI/Probability/SLE/Loewner/InverseSmallSemicircles.lean
new file mode 100644
index 0000000000000000000000000000000000000000..70d0ae110823d444975168dce4889b47647a967c
--- /dev/null
+++ b/lean/OAI/Probability/SLE/Loewner/InverseSmallSemicircles.lean
@@ -0,0 +1,90 @@
+import OAI.Probability.SLE.Loewner.InverseStripEnergy
+import OAI.Probability.SLE.Geometry.ShrinkingStripEnergy
+import OAI.Probability.SLE.Loewner.InverseBoundaryArc
+
+namespace OAI
+
+/-! Arbitrarily small closed image semicircles at each real boundary point.
+The endpoint values are obtained from finite energy, not from an assumed
+continuous extension of the inverse map. -/
+noncomputable section
+open Set Filter Metric Function MeasureTheory
+open scoped Topology NNReal ENNReal
+
+namespace SLEExactGauge
+
+lemma IsCapacityTwoWitness.inverse_log_holomorphic
+    {U : ℝ≥0 → ℝ} {γ : ℝ≥0 → ℂ} {G F : ℝ≥0 → ℂ → ℂ}
+    (hw : IsCapacityTwoWitness U γ G F) (t : ℝ≥0) (x : ℝ) :
+    DifferentiableOn ℂ (fun z => F t ((x:ℂ)+Complex.exp z))
+      {z | 0<z.im ∧ z.im<Real.pi} := by
+  apply (hw.2.2.2.2.1 t).comp
+    ((differentiable_const (x:ℂ)).add Complex.differentiable_exp).differentiableOn
+  intro z hz
+  change 0<((x:ℂ)+Complex.exp z).im
+  simpa only [Set.mem_ofPred_eq,Complex.add_im,Complex.ofReal_im,zero_add] using exp_strip_halfplane hz
+
+lemma IsCapacityTwoWitness.exists_small_inverse_semicircle
+    {U : ℝ≥0 → ℝ} {γ : ℝ≥0 → ℂ} {G F : ℝ≥0 → ℂ → ℂ}
+    (hw : IsCapacityTwoWitness U γ G F) (t : ℝ≥0) (x Q ε : ℝ) (hε : 0<ε) :
+    ∃ (v : ℝ) (c : ℝ → ℂ), v<Q ∧ Continuous c ∧
+      (∀ θ∈Ioo 0 Real.pi, c θ=F t ((x:ℂ)+Complex.exp ((v:ℂ)+(θ:ℂ)*Complex.I))) ∧
+      (∀ θ∈Icc 0 Real.pi, ∀ φ∈Icc 0 Real.pi, ‖c θ-c φ‖≤ε) ∧
+      c 0∈frontier (survivingDomain γ t) ∧ c Real.pi∈frontier (survivingDomain γ t) ∧
+      MapsTo c (Ioo 0 Real.pi) (survivingDomain γ t) ∧ InjOn c (Ioo 0 Real.pi) := by
+  let f : ℂ → ℂ := fun z => F t ((x:ℂ)+Complex.exp z)
+  have hf := hw.inverse_log_holomorphic t x
+  obtain ⟨v,hv,hd,hsmall⟩ := exists_small_holomorphic_section hf
+    (hw.inverse_strip_dirichlet_finite t x 0) Q ε hε
+  let w : ℝ → ℂ := fun θ => (x:ℂ)+Complex.exp ((v:ℂ)+(θ:ℂ)*Complex.I)
+  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 hsection (θ : ℝ) (hθ : θ∈Ioo 0 Real.pi) :
+      DifferentiableAt ℝ (fun θ : ℝ => F t (w θ)) θ := by
+    change DifferentiableAt ℝ (f ∘ fun θ : ℝ => (v:ℂ)+(θ:ℂ)*Complex.I) θ
+    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:ℂ))
+  obtain ⟨c,hc,he⟩ := finite_energy_angular_extension hsection hd
+  have hwc : Continuous w := by dsimp [w]; fun_prop
+  have hwin : MapsTo w (Ioo 0 Real.pi) upperHalfPlane := by
+    intro θ hθ
+    change 0<((x:ℂ)+Complex.exp ((v:ℂ)+(θ:ℂ)*Complex.I)).im
+    simpa only [Set.mem_ofPred_eq,Complex.add_im,Complex.ofReal_im,zero_add] using
+      exp_strip_halfplane (x := (v:ℂ)+(θ:ℂ)*Complex.I) (by simpa using hθ)
+  have hwend (s : ℝ) (hs : s=0 ∨ s=Real.pi) : w s∉upperHalfPlane := by
+    rcases hs with rfl | rfl <;>
+      simp [w,upperHalfPlane,Complex.exp_add,Complex.exp_ofReal_mul_I,← Complex.ofReal_exp]
+  have hend (s : ℝ) (hs : s∈Icc 0 Real.pi) (hs' : s=0 ∨ s=Real.pi) :
+      c s∈frontier (survivingDomain γ t) :=
+    inverse_arc_endpoint_mem_frontier (isOpen_survivingDomain hw.1 t)
+      (hw.2.2.2.1 t).continuousOn (hw.2.2.2.2.2.1 t) (hw.2.2.2.2.2.2.1 t)
+      (hw.2.2.2.2.2.2.2.2.1 t) hwc hc Real.pi_pos hs hwin (hwend s hs') he
+  refine ⟨v,c,hv,hc,he,?_,hend 0 ⟨le_rfl,Real.pi_pos.le⟩ (Or.inl rfl),
+    hend Real.pi ⟨Real.pi_pos.le,le_rfl⟩ (Or.inr rfl),?_,?_⟩
+  · apply continuous_angular_oscillation_on_endpoints hc ε
+    intro θ hθ φ hφ
+    rw [he hθ,he hφ]
+    exact (hsmall θ hθ φ hφ).le
+  · intro θ hθ
+    rw [he hθ]
+    exact hw.2.2.2.2.2.2.1 t (hwin hθ)
+  · intro θ hθ φ hφ heq
+    rw [he hθ,he hφ] at heq
+    change F t (w θ)=F t (w φ) at heq
+    have hwθ := hw.2.2.2.2.2.2.2.2.1 t (w θ) (hwin hθ)
+    have hwφ := hw.2.2.2.2.2.2.2.2.1 t (w φ) (hwin hφ)
+    have hww : w θ=w φ := by rw [heq,hwφ] at hwθ; exact hwθ.symm
+    have harg := exp_injective_strip
+      (x₁ := (v:ℂ)+(θ:ℂ)*Complex.I) (x₂ := (v:ℂ)+(φ:ℂ)*Complex.I)
+      (by simpa using hθ) (by simpa using hφ) (add_left_cancel hww)
+    have him := congrArg Complex.im harg
+    simpa using him
+
+end SLEExactGauge
+
+end
+
+end OAI
diff --git a/lean/OAI/Probability/SLE/Loewner/InverseStripEnergy.lean b/lean/OAI/Probability/SLE/Loewner/InverseStripEnergy.lean
new file mode 100644
index 0000000000000000000000000000000000000000..9258a6539df7e4f54a85e4ffb99e9000d70b64bc
--- /dev/null
+++ b/lean/OAI/Probability/SLE/Loewner/InverseStripEnergy.lean
@@ -0,0 +1,64 @@
+import OAI.Probability.SLE.Loewner.InverseDirichletEnergy
+import OAI.Probability.SLE.DyadicStrips
+
+namespace OAI
+
+/-! Finite energy in logarithmic boundary coordinates. The exponential
+chart is injective on the half-plane strip, so no new growth input is used. -/
+noncomputable section
+open Set Filter Metric Function MeasureTheory
+open scoped Topology NNReal ENNReal
+
+namespace SLEExactGauge
+
+lemma IsCapacityTwoWitness.inverse_strip_dirichlet_finite
+    {U : ℝ≥0 → ℝ} {γ : ℝ≥0 → ℂ} {G F : ℝ≥0 → ℂ → ℂ}
+    (hw : IsCapacityTwoWitness U γ G F) (t : ℝ≥0) (x q : ℝ) :
+    (∫⁻ z in {z : ℂ | z.re<q ∧ 0<z.im ∧ z.im<Real.pi},
+      ENNReal.ofReal (‖deriv (fun w => F t ((x:ℂ)+Complex.exp w)) z‖^2))<∞ := by
+  let S : Set ℂ := {z | z.re<q ∧ 0<z.im ∧ z.im<Real.pi}
+  let A : ℂ → ℂ := fun z => (x:ℂ)+Complex.exp z
+  let f : ℂ → ℂ := fun z => F t (A z)
+  have hS : IsOpen S := (isOpen_lt Complex.continuous_re continuous_const).inter
+    ((isOpen_lt continuous_const Complex.continuous_im).inter
+      (isOpen_lt Complex.continuous_im continuous_const))
+  have hAH : MapsTo A S upperHalfPlane := by
+    intro z hz
+    change 0<((x:ℂ)+Complex.exp z).im
+    have he : 0<(Complex.exp z).im := exp_strip_halfplane hz.2
+    simpa only [Complex.add_im,Complex.ofReal_im,zero_add] using he
+  have hf : DifferentiableOn ℂ f S := (hw.2.2.2.2.1 t).comp
+    ((differentiable_const (x:ℂ)).add Complex.differentiable_exp).differentiableOn hAH
+  have hi : InjOn f S := by
+    intro z hz w hw' he
+    have hAz := hw.2.2.2.2.2.2.2.2.1 t (A z) (hAH hz)
+    have hAw := hw.2.2.2.2.2.2.2.2.1 t (A w) (hAH hw')
+    have heA : A z=A w := by
+      rw [show F t (A z)=F t (A w) from he,hAw] at hAz
+      exact hAz.symm
+    exact exp_injective_strip hz.2 hw'.2 (add_left_cancel heA)
+  have harea : (∫⁻ z in S, ENNReal.ofReal (‖deriv f z‖^2))=volume (f '' S) := by
+    have hd (z : ℂ) (hz : z∈S) :=
+      (hf.differentiableAt (hS.mem_nhds hz)).hasDerivAt
+    have he := lintegral_abs_det_fderiv_eq_addHaar_image volume hS.measurableSet
+      (fun z hz => ((hd z hz).hasFDerivAt.restrictScalars ℝ).hasFDerivWithinAt) hi
+    simpa only [complex_derivative_real_det,abs_pow,abs_norm] using he
+  obtain ⟨M,hM⟩ := hw.inverse_bounded_over_ball t (‖(x:ℂ)‖+Real.exp q)
+  have himage : f '' S ⊆ closedBall (0:ℂ) M := by
+    rintro _ ⟨z,hz,rfl⟩
+    rw [mem_closedBall,dist_zero_right]
+    apply hM (A z) (hAH hz)
+    calc
+      ‖A z‖ ≤ ‖(x:ℂ)‖+‖Complex.exp z‖ := norm_add_le _ _
+      _ ≤ ‖(x:ℂ)‖+Real.exp q := by
+        rw [Complex.norm_exp]
+        exact add_le_add le_rfl (Real.exp_le_exp.mpr hz.1.le)
+  change (∫⁻ z in S, ENNReal.ofReal (‖deriv f z‖^2))<∞
+  rw [harea]
+  exact (measure_mono himage).trans_lt (isCompact_closedBall (0:ℂ) M).measure_lt_top
+
+end SLEExactGauge
+
+end
+
+end OAI
diff --git a/lean/OAI/Probability/SLE/Loewner/InverseThinCollapse.lean b/lean/OAI/Probability/SLE/Loewner/InverseThinCollapse.lean
new file mode 100644
index 0000000000000000000000000000000000000000..eb8b165b2f1f8d3f067417997126d8a95a2bf82b
--- /dev/null
+++ b/lean/OAI/Probability/SLE/Loewner/InverseThinCollapse.lean
@@ -0,0 +1,80 @@
+import OAI.Probability.SLE.Geometry.BoundarySeparationRectangle
+import OAI.Probability.SLE.Loewner.InitialInverseTimeContinuity
+
+namespace OAI
+
+/-! Thin crossings whose physical images shrink to one point force
+collapse of a whole real boundary interval in the limiting inverse. -/
+noncomputable section
+open Set Filter Function Complex Metric MeasureTheory
+open scoped Topology ENNReal
+
+namespace SLEExactGauge
+
+theorem initialInverse_thin_crossing_collapse (p : C(unitInterval,ℂ)) (hi : Injective p)
+    (h0 : p 0=0) (hH : ∀ t : unitInterval, t≠0 → p t∈upperHalfPlane)
+    {R : ℝ} (hR : 0<R) (hp : ∀ t : unitInterval, ‖p t‖<R)
+    {s : unitInterval} {t : ℕ → unitInterval} (ht : Tendsto t atTop (𝓝 s))
+    {B : ℂ → ℂ} (hB : ContinuousOn B {z : ℂ | 0≤z.im})
+    (hBF : ∀ z∈upperHalfPlane, B z=initialInverseChart p hi h0 hH s z)
+    {a b : ℝ} {c : ℂ} {ε η : ℕ → ℝ}
+    (hε : Tendsto ε atTop (𝓝 0)) (hη : Tendsto η atTop (𝓝 0))
+    (hlow : ∀ᶠ n in atTop, ∀ x∈Ioo a b, ∃ y∈Ioc 0 (η n),
+      ‖initialInverseChart p hi h0 hH (t n) ((x:ℂ)+(y:ℂ)*I)-c‖≤ε n) :
+    ∀ x∈Ioo a b, B (x:ℂ)=c := by
+  intro x hx
+  by_contra hne
+  obtain ⟨a',b',H,δ,haa,hab,hbb,hHpos,hδ,hsep⟩ :=
+    boundary_separation_rectangle hB hBF hx hne
+  let L := max |a'| |b'|
+  have hxL : ∀ u∈Ioo a' b', |u|≤L := by
+    intro u hu
+    exact abs_le.mpr ⟨by dsimp [L]; linarith [hu.1,neg_abs_le a',le_max_left |a'| |b'|],
+      by dsimp [L]; linarith [hu.2,le_abs_self b',le_max_right |a'| |b'|]⟩
+  let C := (volume (closedBall (0:ℂ) (L+2+3*R))).toReal
+  have hC : 0≤C := ENNReal.toReal_nonneg
+  let D := (b'-a')*δ^2
+  have hD : 0<D := mul_pos (sub_pos.mpr hab) (sq_pos_of_pos hδ)
+  let h := min H (min 1 (D/(2*(C+1))))
+  have hh : 0<h := lt_min hHpos (lt_min zero_lt_one (div_pos hD (by positivity)))
+  have hhH : h≤H := min_le_left _ _
+  have hh1 : h≤1 := (min_le_right _ _).trans (min_le_left _ _)
+  have hhD : h*(2*(C+1))≤D :=
+    (le_div_iff₀ (by positivity : 0<2*(C+1))).mp
+      ((min_le_right _ _).trans (min_le_right _ _))
+  have hsmall : h*C<D := by nlinarith
+  let K := (fun u : ℝ => (u:ℂ)+(h:ℂ)*I) '' Icc a' b'
+  have hK : IsCompact K := isCompact_Icc.image (by fun_prop)
+  have hKH : K⊆upperHalfPlane := by
+    rintro _ ⟨u,hu,rfl⟩
+    simpa [upperHalfPlane] using hh
+  have hu := (tendstoLocallyUniformlyOn_iff_forall_isCompact isOpen_upperHalfPlane).mp
+    (initialInverseChart_locallyUniform_continuous p hi h0 hH s) K hKH hK
+  have hu' := ht.eventually ((Metric.tendstoUniformlyOn_iff.mp hu) δ hδ)
+  have he' := hε.eventually (gt_mem_nhds hδ)
+  have hη' := hη.eventually (gt_mem_nhds hh)
+  obtain ⟨n,hn,he,hηn,hlown⟩ := (hu'.and (he'.and (hη'.and hlow))).exists
+  have hhigh : ∀ u∈Ioo a' b', δ+ε n≤
+      ‖initialInverseChart p hi h0 hH (t n) ((u:ℂ)+(h:ℂ)*I)-c‖ := by
+    intro u huI
+    have hdist := hn _ (mem_image_of_mem _ ⟨huI.1.le,huI.2.le⟩)
+    have hs := hsep u ⟨huI.1.le,huI.2.le⟩ h ⟨hh,hhH⟩
+    have htri := norm_sub_le_norm_sub_add_norm_sub
+      (initialInverseChart p hi h0 hH s ((u:ℂ)+(h:ℂ)*I))
+      (initialInverseChart p hi h0 hH (t n) ((u:ℂ)+(h:ℂ)*I)) c
+    rw [dist_eq_norm] at hdist
+    linarith
+  have hlow' : ∀ u∈Ioo a' b', ∃ y∈Ioc 0 h,
+      ‖initialInverseChart p hi h0 hH (t n) ((u:ℂ)+(y:ℂ)*I)-c‖≤ε n := by
+    intro u huI
+    obtain ⟨y,hy,hyc⟩ := hlown u ⟨haa.trans huI.1,huI.2.trans hbb⟩
+    exact ⟨y,⟨hy.1,hy.2.trans hηn.le⟩,hyc⟩
+  have hbound := initialInverse_thin_crossing_bound p hi h0 hH hR hp (t n)
+    hab hh hh1 hδ.le c hxL hhigh hlow'
+  exact (not_le_of_gt hsmall) hbound
+
+end SLEExactGauge
+
+end
+
+end OAI
diff --git a/lean/OAI/Probability/SLE/Loewner/InverseVerticalDifferentiation.lean b/lean/OAI/Probability/SLE/Loewner/InverseVerticalDifferentiation.lean
new file mode 100644
index 0000000000000000000000000000000000000000..d394f167544523f01a636362706241abbd3226cf
--- /dev/null
+++ b/lean/OAI/Probability/SLE/Loewner/InverseVerticalDifferentiation.lean
@@ -0,0 +1,36 @@
+import OAI.Probability.SLE.Loewner.InitialInverseEnergyIntegral
+import OAI.Probability.SLE.Loewner.VerticalIntervalEnergy
+
+namespace OAI
+
+/-! Exact derivatives on vertical lines in the upper half-plane. -/
+noncomputable section
+open Set Filter Function Complex MeasureTheory
+open scoped Topology
+
+namespace SLEExactGauge
+
+lemma holomorphic_vertical_hasDerivAt {F : ℂ → ℂ}
+    (hF : DifferentiableOn ℂ F upperHalfPlane) (x : ℝ) {y : ℝ} (hy : 0<y) :
+    HasDerivAt (fun t : ℝ => F ((x:ℂ)+(t:ℂ)*Complex.I))
+      (Complex.I*deriv F ((x:ℂ)+(y:ℂ)*Complex.I)) y := by
+  have hp : (x:ℂ)+(y:ℂ)*Complex.I∈upperHalfPlane := by
+    change 0<((x:ℂ)+(y:ℂ)*Complex.I).im
+    simpa only [add_im,ofReal_im,mul_im,ofReal_re,I_im,I_re,mul_one,mul_zero,add_zero,zero_add] using hy
+  have hc := ((Complex.ofRealCLM.hasDerivAt (x := y)).mul_const Complex.I).const_add (x:ℂ)
+  have hd := ((hF.differentiableAt (isOpen_upperHalfPlane.mem_nhds hp)).hasDerivAt.hasFDerivAt).restrictScalars ℝ
+  have hh := hd.comp_hasDerivAt y hc
+  simpa only [ContinuousLinearMap.coe_restrictScalars',ContinuousLinearMap.toSpanSingleton_apply,
+    Complex.ofRealCLM_apply,ofReal_one,one_mul,mul_one,smul_eq_mul,Function.comp_def,mul_comm] using hh
+
+lemma holomorphic_vertical_deriv_norm {F : ℂ → ℂ}
+    (hF : DifferentiableOn ℂ F upperHalfPlane) (x : ℝ) {y : ℝ} (hy : 0<y) :
+    ‖deriv (fun t : ℝ => F ((x:ℂ)+(t:ℂ)*Complex.I)) y‖=
+      ‖deriv F ((x:ℂ)+(y:ℂ)*Complex.I)‖ := by
+  rw [(holomorphic_vertical_hasDerivAt hF x hy).deriv,norm_mul,norm_I,one_mul]
+
+end SLEExactGauge
+
+end
+
+end OAI
diff --git a/lean/OAI/Probability/SLE/Loewner/InverseVerticalEnergy.lean b/lean/OAI/Probability/SLE/Loewner/InverseVerticalEnergy.lean
new file mode 100644
index 0000000000000000000000000000000000000000..c5c2884eda8d1507efe61944e9aa67b27189d209
--- /dev/null
+++ b/lean/OAI/Probability/SLE/Loewner/InverseVerticalEnergy.lean
@@ -0,0 +1,52 @@
+import OAI.Probability.SLE.Loewner.InverseVerticalDifferentiation
+
+namespace OAI
+
+/-! Vertical energy controls separation from a small physical image. -/
+noncomputable section
+open Set Filter Function Complex Metric MeasureTheory
+open scoped Topology ENNReal
+
+namespace SLEExactGauge
+
+lemma holomorphic_vertical_energy {F : ℂ → ℂ}
+    (hF : DifferentiableOn ℂ F upperHalfPlane) (x : ℝ) {h y : ℝ}
+    (hh : 0<h) (hy : y∈Ioc 0 h)
+    (hE : MemLp (fun t : ℝ => deriv F ((x:ℂ)+(t:ℂ)*I)) 2
+      (volume.restrict (Ioc 0 h))) :
+    ‖F ((x:ℂ)+(h:ℂ)*I)-F ((x:ℂ)+(y:ℂ)*I)‖^2 ≤
+      h*(∫ t in Ioc 0 h, ‖deriv F ((x:ℂ)+(t:ℂ)*I)‖^2) := by
+  let f := fun t : ℝ => F ((x:ℂ)+(t:ℂ)*I)
+  have hn : ∀ᵐ t : ℝ ∂volume.restrict (Ioc 0 h),
+      ‖deriv f t‖=‖deriv F ((x:ℂ)+(t:ℂ)*I)‖ := by
+    filter_upwards [ae_restrict_mem measurableSet_Ioc] with t ht
+    exact holomorphic_vertical_deriv_norm hF x ht.1
+  have hd : MemLp (deriv f) 2 (volume.restrict (Ioc 0 h)) :=
+    (memLp_congr_norm (measurable_deriv f).aestronglyMeasurable
+      hE.aestronglyMeasurable hn).mpr hE
+  have hb := complex_interval_energy_oscillation hh hy ⟨hh,le_rfl⟩
+    (fun t ht => (holomorphic_vertical_hasDerivAt hF x
+      (ordConnected_Ioc.uIcc_subset hy ⟨hh,le_rfl⟩ ht).1).differentiableAt) hd
+  have he := integral_congr_ae (hn.mono fun t ht => congrArg (fun r : ℝ => r^2) ht)
+  rw [he] at hb
+  exact hb
+
+lemma holomorphic_vertical_separation {F : ℂ → ℂ}
+    (hF : DifferentiableOn ℂ F upperHalfPlane) (x : ℝ) {h δ ε : ℝ}
+    (hh : 0<h) (hδ : 0≤δ) (c : ℂ)
+    (hhigh : δ+ε≤‖F ((x:ℂ)+(h:ℂ)*I)-c‖)
+    (hlow : ∃ y∈Ioc 0 h, ‖F ((x:ℂ)+(y:ℂ)*I)-c‖≤ε)
+    (hE : MemLp (fun t : ℝ => deriv F ((x:ℂ)+(t:ℂ)*I)) 2
+      (volume.restrict (Ioc 0 h))) :
+    δ^2 ≤ h*(∫ t in Ioc 0 h, ‖deriv F ((x:ℂ)+(t:ℂ)*I)‖^2) := by
+  obtain ⟨y,hy,hyc⟩ := hlow
+  have htriangle := norm_sub_le_norm_sub_add_norm_sub (F ((x:ℂ)+(h:ℂ)*I))
+    (F ((x:ℂ)+(y:ℂ)*I)) c
+  have hsep : δ≤‖F ((x:ℂ)+(h:ℂ)*I)-F ((x:ℂ)+(y:ℂ)*I)‖ := by linarith
+  exact (pow_le_pow_left₀ hδ hsep 2).trans (holomorphic_vertical_energy hF x hh hy hE)
+
+end SLEExactGauge
+
+end
+
+end OAI
diff --git a/lean/OAI/Probability/SLE/Loewner/LinearReverseTrajectory.lean b/lean/OAI/Probability/SLE/Loewner/LinearReverseTrajectory.lean
new file mode 100644
index 0000000000000000000000000000000000000000..71e750d68448c341f743378766eccca173ceb368
--- /dev/null
+++ b/lean/OAI/Probability/SLE/Loewner/LinearReverseTrajectory.lean
@@ -0,0 +1,105 @@
+import OAI.Probability.SLE.Loewner.SmoothRawTraceContinuity
+import OAI.Probability.SLE.Loewner.PositiveReverseUniqueness
+
+namespace OAI
+
+/-! Linear drivers and their autonomous centered reverse trajectories.
+These give concrete steering curves for the geometric support construction. -/
+noncomputable section
+open Set Filter Complex
+open scoped Topology NNReal
+
+namespace SLEExactGauge.Target
+
+def linearDriver (c : ℝ) : Driver :=
+  ⟨⟨fun t => c*(t:ℝ), continuous_const.mul continuous_subtype_val⟩, by simp⟩
+
+@[simp] lemma linearDriver_apply (c : ℝ) (t : ℝ≥0) :
+    linearDriver c t=c*(t:ℝ) := rfl
+
+lemma linearDriver_value (c t : ℝ) (ht : 0 ≤ t) :
+    driverValue (linearDriver c) t=c*t := by
+  simp only [driverValue,linearDriver_apply,Real.coe_toNNReal _ ht]
+
+lemma linearDriver_derivative (c t : ℝ) (ht : 0 ≤ t) :
+    HasDerivWithinAt (driverValue (linearDriver c)) c (Ici 0) t := by
+  have h := ((hasDerivAt_id t).const_mul c).hasDerivWithinAt (s := Ici 0)
+  simpa only [mul_one] using h.congr
+    (fun s hs => (linearDriver_value c s hs)) (linearDriver_value c t ht)
+
+private lemma approximation_height_pos (n : ℕ) : 0 < 1/((n:ℝ)+1) := by positivity
+
+def linearReverseBase (c : ℝ) (n : ℕ) : ℝ → ℂ :=
+  (exists_reverse_trajectory (fun s => -c*s) (by fun_prop)
+    (((1/((n:ℝ)+1):ℝ):ℂ)*I) (by simpa only [Complex.mul_im,Complex.ofReal_re,Complex.ofReal_im,Complex.I_im,Complex.I_re,mul_one,mul_zero,add_zero] using approximation_height_pos n)).choose
+
+lemma linearReverseBase_spec (c : ℝ) (n : ℕ) :
+    linearReverseBase c n 0=(((1/((n:ℝ)+1):ℝ):ℂ)*I) ∧
+    (∀ t, 0 ≤ t → 1/((n:ℝ)+1) ≤ (linearReverseBase c n t).im) ∧
+    ∀ t, 0 ≤ t → HasDerivWithinAt (linearReverseBase c n)
+      (-2/(linearReverseBase c n t-((-c*t:ℝ):ℂ))) (Ici 0) t := by
+  simpa only [linearReverseBase,Complex.mul_im,Complex.ofReal_re,Complex.ofReal_im,
+    Complex.I_im,Complex.I_re,mul_one,mul_zero,add_zero] using
+    (exists_reverse_trajectory (fun s => -c*s) (by fun_prop)
+    (((1/((n:ℝ)+1):ℝ):ℂ)*I) (by simpa only [Complex.mul_im,Complex.ofReal_re,Complex.ofReal_im,Complex.I_im,Complex.I_re,mul_one,mul_zero,add_zero] using approximation_height_pos n)).choose_spec
+
+def linearReverseApprox (c : ℝ) (n : ℕ) (t : ℝ) : ℂ :=
+  linearReverseBase c n t+((c*t:ℝ):ℂ)
+
+lemma linearReverseApprox_derivative (c : ℝ) (n : ℕ) (t : ℝ) (ht : 0 ≤ t) :
+    HasDerivWithinAt (linearReverseApprox c n)
+      ((c:ℂ)-2/linearReverseApprox c n t) (Ici 0) t := by
+  have hd := (linearReverseBase_spec c n).2.2 t ht
+  have hc := (((hasDerivAt_id t).const_mul c).ofReal_comp).hasDerivWithinAt (s := Ici 0)
+  have h := hd.add hc
+  change HasDerivWithinAt (linearReverseApprox c n)
+    (-2/(linearReverseBase c n t-((-c*t:ℝ):ℂ))+((c*1:ℝ):ℂ)) (Ici 0) t at h
+  exact h.congr_deriv (by
+    simp only [linearReverseApprox,Complex.ofReal_neg,Complex.ofReal_mul,mul_one,
+      neg_div]
+    ring)
+
+lemma linearReverseApprox_height (c : ℝ) (n : ℕ) (t : ℝ) (ht : 0 ≤ t) :
+    0 < (linearReverseApprox c n t).im := by
+  simpa only [linearReverseApprox,Complex.add_im,Complex.ofReal_im,add_zero] using
+    (approximation_height_pos n).trans_le ((linearReverseBase_spec c n).2.1 t ht)
+
+lemma linearReverseApprox_eq_inverse (c : ℝ) (n : ℕ) (T : ℝ≥0) :
+    linearReverseApprox c n T = inverseFlow 1 (linearDriver c) T
+      ((linearDriver c T:ℂ)+(((1/((n:ℝ)+1):ℝ):ℂ)*I)) := by
+  let q := linearReverseBase c n
+  let r (s : ℝ) := q s+((c*(T:ℝ):ℝ):ℂ)
+  have hq := linearReverseBase_spec c n
+  have hr (s : ℝ) (hs : s ∈ Icc 0 (T:ℝ)) : HasDerivWithinAt r
+      (-2/(r s-(driverValue (linearDriver c) ((T:ℝ)-s):ℂ))) (Icc 0 (T:ℝ)) s := by
+    have h := ((hq.2.2 s hs.1).add_const ((c*(T:ℝ):ℝ):ℂ)).mono (show Icc 0 (T:ℝ) ⊆ Ici 0 from Icc_subset_Ici_self)
+    have he : r s-(driverValue (linearDriver c) ((T:ℝ)-s):ℂ)=q s-((-c*s:ℝ):ℂ) := by
+      rw [linearDriver_value _ _ (sub_nonneg.mpr hs.2)]
+      dsimp [r]
+      push_cast
+      ring
+    simpa only [r,q,he] using h
+  have hrp (s : ℝ) (hs : s ∈ Icc 0 (T:ℝ)) : 0 < (r s).im := by
+    simpa only [r,Complex.add_im,Complex.ofReal_im,add_zero] using
+      (approximation_height_pos n).trans_le (hq.2.1 s hs.1)
+  obtain ⟨v,hv0,hvp,hvd,hvend⟩ := exists_raw_reverse_trajectory (linearDriver c) T
+    ((linearDriver c T:ℂ)+(((1/((n:ℝ)+1):ℝ):ℂ)*I))
+    (by simpa only [upperHalfPlane,mem_ofPred_eq,Complex.add_im,Complex.mul_im,Complex.ofReal_re,Complex.ofReal_im,Complex.I_im,Complex.I_re,mul_one,mul_zero,add_zero,zero_add] using approximation_height_pos n)
+  have hvpos (s : ℝ) (hs : s ∈ Icc 0 (T:ℝ)) : 0 < (v s).im := by
+    apply (approximation_height_pos n).trans_le
+    simpa only [Complex.add_im,Complex.ofReal_im,Complex.ofReal_re,Complex.mul_im,
+      Complex.I_im,Complex.I_re,mul_one,mul_zero,add_zero,zero_add] using hvp s hs.1
+  have he := positive_reverse_unique T.coe_nonneg r v
+    (fun s => driverValue (linearDriver c) ((T:ℝ)-s))
+    (fun s hs => (hr s hs).continuousWithinAt)
+    (fun s hs => (hvd s hs.1).continuousWithinAt.mono Icc_subset_Ici_self)
+    (fun s hs => hasDerivWithinAt_Ici_of_Icc hs (hr s (Ico_subset_Icc_self hs)))
+    (fun s hs => (hvd s hs.1).mono (Ici_subset_Ici.mpr hs.1)) hrp hvpos
+    (by simp only [r,q,hq.1,hv0,linearDriver_apply]; ring)
+  exact (he T ⟨T.coe_nonneg,le_rfl⟩).trans hvend.symm
+
+end SLEExactGauge.Target
+
+end
+
+end OAI
diff --git a/lean/OAI/Probability/SLE/Loewner/LocalReverseCone.lean b/lean/OAI/Probability/SLE/Loewner/LocalReverseCone.lean
new file mode 100644
index 0000000000000000000000000000000000000000..3abd105923b43628a422267ce0a2863197c00268
--- /dev/null
+++ b/lean/OAI/Probability/SLE/Loewner/LocalReverseCone.lean
@@ -0,0 +1,56 @@
+import OAI.Probability.SLE.Loewner.ReverseBoundaryCone
+
+namespace OAI
+
+/-! A continuous positive reverse solution starting at the driver is
+non-tangential on a sufficiently short initial interval. -/
+noncomputable section
+open Set Filter Metric Complex
+open scoped Topology
+
+namespace SLEExactGauge
+
+theorem exists_initial_reverse_cone {T L : ℝ} (hT : 0 < T) (hL : 0 ≤ L)
+    (q : ℝ → ℂ) (u u' : ℝ → ℝ)
+    (hc : ContinuousOn q (Icc 0 T)) (huc : ContinuousOn u (Icc 0 T))
+    (hq0 : q 0=(u 0 : ℂ))
+    (hq : ∀ t ∈ Ioc 0 T, HasDerivWithinAt q
+      (-2/(q t-(u t : ℂ))) (Ici t) t)
+    (hu : ∀ t ∈ Ioc 0 T, HasDerivWithinAt u (u' t) (Ici t) t)
+    (hp : ∀ t ∈ Ioc 0 T, 0 < (q t).im)
+    (hb : ∀ t ∈ Ioc 0 T, |u' t| ≤ L) :
+    ∃ a : ℝ, 0 < a ∧ a ≤ T ∧
+      ∀ t ∈ Icc 0 a, ((q t).re-u t)^2 ≤ t ∧ 3*t ≤ (q t).im^2 := by
+  let M : ℝ := 1/(2*(L+1))
+  have hMpos : 0 < M := by dsimp [M]; positivity
+  have hsmall : 2*L*M ≤ 1 := by
+    have hd : 0 < 2*(L+1) := by positivity
+    calc
+      2*L*M = (2*L)/(2*(L+1)) := by dsimp [M]; ring
+      _ ≤ 1 := (div_le_one hd).mpr (by linarith)
+  have hc0 := ((hc.sub (Complex.continuous_ofReal.comp_continuousOn huc)) 0 ⟨le_rfl,hT.le⟩).norm
+  have hv : ‖q 0-(u 0 : ℂ)‖ < M := by simpa only [hq0,sub_self,norm_zero] using hMpos
+  have he : ∀ᶠ t in 𝓝[Icc 0 T] 0, ‖q t-(u t : ℂ)‖ < M :=
+    hc0.eventually (Iio_mem_nhds hv)
+  obtain ⟨δ,hδ,hδb⟩ := Metric.mem_nhdsWithin_iff.mp he
+  let a : ℝ := min T (δ/2)
+  have ha : 0 < a := lt_min hT (half_pos hδ)
+  have haT : a ≤ T := min_le_left _ _
+  have hsub : Icc 0 a ⊆ Icc 0 T := Icc_subset_Icc_right haT
+  have hsub' : Ioc 0 a ⊆ Ioc 0 T := Ioc_subset_Ioc_right haT
+  refine ⟨a,ha,haT,reverse_boundary_cone_of_small_center ha.le hL hsmall q u u'
+    (hc.mono hsub) (huc.mono hsub) hq0
+    (fun t ht => hq t (hsub' ht)) (fun t ht => hu t (hsub' ht))
+    (fun t ht => hp t (hsub' ht)) (fun t ht => hb t (hsub' ht)) ?_⟩
+  intro t ht
+  apply le_of_lt
+  apply hδb
+  refine ⟨?_,hsub (Ioc_subset_Icc_self ht)⟩
+  rw [mem_ball,Real.dist_eq,sub_zero,abs_of_pos ht.1]
+  exact (ht.2.trans (min_le_right _ _)).trans_lt (half_lt_self hδ)
+
+end SLEExactGauge
+
+end
+
+end OAI
diff --git a/lean/OAI/Probability/SLE/Loewner/LoewnerCompactDriverNeighborhood.lean b/lean/OAI/Probability/SLE/Loewner/LoewnerCompactDriverNeighborhood.lean
new file mode 100644
index 0000000000000000000000000000000000000000..89fd9044bb9bc79e50a99493178119cd27f87054
--- /dev/null
+++ b/lean/OAI/Probability/SLE/Loewner/LoewnerCompactDriverNeighborhood.lean
@@ -0,0 +1,40 @@
+import OAI.Probability.SLE.Loewner.LoewnerCompactSurvival
+import OAI.Probability.SLE.Loewner.LoewnerInverseDriverContinuity
+
+namespace OAI
+
+/-! Compact survival holds throughout a uniform neighborhood of a fixed
+driver, with no regularity assumption on the perturbed trace beyond its
+actual capacity witness. -/
+noncomputable section
+open Set Filter
+open scoped Topology NNReal
+
+namespace SLEExactGauge
+
+theorem driver_neighborhood_preserves_compact
+    {V : ℝ≥0 → ℝ} {β : ℝ≥0 → ℂ} {H J : ℝ≥0 → ℂ → ℂ}
+    (hv : IsCapacityTwoWitness V β H J) (T : ℝ≥0)
+    {K : Set ℂ} (hK : IsCompact K) (hKD : K ⊆ survivingDomain β T) :
+    ∃ δ : ℝ, 0 < δ ∧ ∀ (U : ℝ≥0 → ℝ) (γ : ℝ≥0 → ℂ)
+      (G F : ℝ≥0 → ℂ → ℂ), IsCapacityTwoWitness U γ G F →
+      (∀ t ∈ Icc 0 T, |U t-V t| ≤ δ) → K ⊆ survivingDomain γ T := by
+  classical
+  by_contra hn
+  push Not at hn
+  have hc (n : ℕ) := hn ((n+1:ℝ)⁻¹) (by positivity)
+  choose U γ G F hw hclose hfail using hc
+  have hδ : Tendsto (fun n : ℕ => (n+1:ℝ)⁻¹) atTop (𝓝 0) := by
+    exact tendsto_inv_atTop_zero.comp
+      (tendsto_atTop_add_const_right atTop 1 tendsto_natCast_atTop_atTop)
+  have hl := inverse_maps_locally_uniform_of_drivers U γ G F hw hv T
+    (fun n : ℕ => (n+1:ℝ)⁻¹) hδ hclose
+  have he := compact_survival_of_inverse_convergence U γ G F hw hv T hl hK hKD
+  obtain ⟨n,hn⟩ := he.exists
+  exact hfail n hn
+
+end SLEExactGauge
+
+end
+
+end OAI
diff --git a/lean/OAI/Probability/SLE/Loewner/LoewnerCompactSurvival.lean b/lean/OAI/Probability/SLE/Loewner/LoewnerCompactSurvival.lean
new file mode 100644
index 0000000000000000000000000000000000000000..43b4023e70d00a68336628184b99bbc6fa0d39db
--- /dev/null
+++ b/lean/OAI/Probability/SLE/Loewner/LoewnerCompactSurvival.lean
@@ -0,0 +1,42 @@
+import OAI.Probability.SLE.Loewner.LoewnerKernelContinuity
+
+namespace OAI
+
+/-! Compact subsets of the limiting surviving domain stay in the
+surviving domains of all sufficiently close drivers. -/
+noncomputable section
+open Set Filter
+open scoped Topology NNReal
+
+namespace SLEExactGauge
+
+theorem compact_survival_of_inverse_convergence
+    (U : ℕ → ℝ≥0 → ℝ) (γ : ℕ → ℝ≥0 → ℂ) (G F : ℕ → ℝ≥0 → ℂ → ℂ)
+    (h : ∀ n, IsCapacityTwoWitness (U n) (γ n) (G n) (F n))
+    {V : ℝ≥0 → ℝ} {β : ℝ≥0 → ℂ} {H J : ℝ≥0 → ℂ → ℂ}
+    (hv : IsCapacityTwoWitness V β H J) (T : ℝ≥0)
+    (hl : TendstoLocallyUniformlyOn (fun n => F n T) (J T) atTop upperHalfPlane)
+    {K : Set ℂ} (hK : IsCompact K) (hKD : K ⊆ survivingDomain β T) :
+    ∀ᶠ n in atTop, K ⊆ survivingDomain (γ n) T := by
+  classical
+  have hp (z : K) : ∃ r : ℝ, 0 < r ∧
+      ∀ᶠ n in atTop, Metric.ball (z:ℂ) r ⊆ survivingDomain (γ n) T := by
+    obtain ⟨r,hr,he⟩ := inverse_image_neighborhood_persists U γ G F h hv T hl
+      (hv.2.2.2.2.2.1 T (hKD z.property))
+    rw [hv.2.2.2.2.2.2.2.1 T z (hKD z.property)] at he
+    exact ⟨r,hr,he⟩
+  choose r hr hp using hp
+  obtain ⟨s,hs⟩ := hK.elim_finite_subcover (fun z : K => Metric.ball (z:ℂ) (r z))
+    (fun _ => Metric.isOpen_ball) (fun z hz =>
+      mem_iUnion.mpr ⟨⟨z,hz⟩,Metric.mem_ball_self (hr ⟨z,hz⟩)⟩)
+  have he : ∀ᶠ n in atTop, ∀ z ∈ s, Metric.ball (z:ℂ) (r z) ⊆ survivingDomain (γ n) T := by
+    exact s.eventually_all.mpr (fun z _ => hp z)
+  filter_upwards [he] with n hn z hz
+  obtain ⟨w,hw,hwz⟩ := mem_iUnion₂.mp (hs hz)
+  exact hn w hw hwz
+
+end SLEExactGauge
+
+end
+
+end OAI
diff --git a/lean/OAI/Probability/SLE/Loewner/LoewnerDriverBounds.lean b/lean/OAI/Probability/SLE/Loewner/LoewnerDriverBounds.lean
new file mode 100644
index 0000000000000000000000000000000000000000..bc2a7d1ed7acfe98c970a9b03ea1fb8b5951c01b
--- /dev/null
+++ b/lean/OAI/Probability/SLE/Loewner/LoewnerDriverBounds.lean
@@ -0,0 +1,98 @@
+import OAI.Probability.SLE.LoewnerReflection
+
+namespace OAI
+
+/-! Deterministic confinement from the driving function, obtained from the
+reverse Loewner equation before taking the actual boundary trace limit. -/
+noncomputable section
+open Set Filter Complex
+open scoped Topology NNReal
+
+namespace SLEExactGauge
+
+variable {U : ℝ≥0 → ℝ} {γ : ℝ≥0 → ℂ} {G F : ℝ≥0 → ℂ → ℂ}
+
+lemma IsCapacityTwoWitness.reverse_path_unclipped
+    (h : IsCapacityTwoWitness U γ G F) (T : ℝ≥0) {w : ℂ}
+    (hw : w ∈ upperHalfPlane) {s : ℝ} (hs : s ∈ Icc 0 (T : ℝ)) :
+    HasDerivWithinAt (fun t : ℝ => G ((T : ℝ) - t).toNNReal (F T w))
+      (-2 / (G ((T : ℝ) - s).toNNReal (F T w) - (U ((T : ℝ) - s).toNNReal : ℂ)))
+      (Icc 0 (T : ℝ)) s := by
+  have hz := h.2.2.2.2.2.2.1 T hw
+  have hi := h.imag_ge_terminal T (F T w) hz ((T : ℝ) - s)
+    ⟨by linarith [hs.2], by linarith [hs.1]⟩
+  rw [h.2.2.2.2.2.2.2.2.1 T w hw] at hi
+  simpa only [reverseField, reverseCenter_eq hi, div_eq_mul_inv] using
+    h.reverse_path_derivative T w hw le_rfl s hs
+
+lemma IsCapacityTwoWitness.inverse_re_le
+    (h : IsCapacityTwoWitness U γ G F) (T : ℝ≥0) {w : ℂ}
+    (hw : w ∈ upperHalfPlane) {M : ℝ}
+    (hwM : w.re ≤ M) (hU : ∀ t ∈ Icc 0 T, U t ≤ M) : (F T w).re ≤ M := by
+  let q (s : ℝ) := G ((T : ℝ) - s).toNNReal (F T w)
+  have hq (s : ℝ) (hs : s ∈ Icc 0 (T : ℝ)) := h.reverse_path_unclipped T hw hs
+  have hq0 : q 0 = w := by
+    simp only [q, sub_zero, Real.toNNReal_coe]
+    exact h.2.2.2.2.2.2.2.2.1 T w hw
+  have hqT : q T = F T w := by
+    simp only [q, sub_self, Real.toNNReal_zero]
+    exact h.initial_value _ (h.2.2.2.2.2.2.1 T hw).1.1
+  apply le_of_forall_pos_le_add
+  intro ε hε
+  have hr (s : ℝ) (hs : s ∈ Icc 0 (T : ℝ)) :
+      HasDerivWithinAt (fun t => (q t).re)
+        ((-2 * ((q s).re - U ((T : ℝ) - s).toNNReal)) /
+          normSq (q s - (U ((T : ℝ) - s).toNNReal : ℂ))) (Icc 0 (T : ℝ)) s := by
+    have hd := Complex.reCLM.hasFDerivAt.comp_hasDerivWithinAt s (hq s hs)
+    change HasDerivWithinAt (fun t => (q t).re)
+      ((-2 / (q s - (U ((T : ℝ) - s).toNNReal : ℂ))).re) _ _ at hd
+    simpa only [Function.comp_def, Complex.div_re, Complex.neg_re, Complex.re_ofNat,
+      Complex.neg_im, Complex.im_ofNat, neg_zero, zero_mul, zero_div, add_zero,
+      Complex.sub_re, Complex.ofReal_re] using hd
+  have hc : ContinuousOn (fun t => (q t).re) (Icc 0 (T : ℝ)) :=
+    fun s hs => (hr s hs).continuousWithinAt
+  have hbound := image_le_of_deriv_right_lt_deriv_boundary hc
+    (fun s hs => hasDerivWithinAt_Ici_of_Icc hs (hr s ⟨hs.1,hs.2.le⟩))
+    (B := fun _ => M + ε) (B' := fun _ => 0)
+    (by rw [hq0]; linarith)
+    (fun _ => hasDerivAt_const _ _) (fun s hs he => ?_)
+    (show (T : ℝ) ∈ Icc 0 (T : ℝ) from ⟨T.coe_nonneg,le_rfl⟩)
+  · simpa only [hqT] using hbound
+  · have ht : ((T : ℝ)-s).toNNReal ∈ Icc 0 T := by
+      refine ⟨zero_le,?_⟩
+      exact_mod_cast (show (((T : ℝ)-s).toNNReal : ℝ) ≤ T by
+        rw [Real.coe_toNNReal _ (by linarith [hs.2])]; linarith [hs.1])
+    have him : 0 < (q s).im := h.imag_positive _ _
+      (survivingDomain_antitone γ ht.2 (h.2.2.2.2.2.2.1 T hw))
+    have hne : q s - (U ((T : ℝ)-s).toNNReal : ℂ) ≠ 0 := by
+      intro hn
+      have hh := congrArg Complex.im hn
+      simp only [Complex.sub_im,Complex.ofReal_im,sub_zero,Complex.zero_im] at hh
+      exact him.ne' hh
+    apply div_neg_of_neg_of_pos _ (Complex.normSq_pos.mpr hne)
+    rw [he]
+    nlinarith [hU _ ht]
+
+lemma IsCapacityTwoWitness.trace_re_le
+    (h : IsCapacityTwoWitness U γ G F) (T : ℝ≥0) {M : ℝ}
+    (hU : ∀ t ∈ Icc 0 T, U t ≤ M) : (γ T).re ≤ M := by
+  have hl := Complex.continuous_re.continuousAt.tendsto.comp
+    (h.2.2.2.2.2.2.2.2.2.2.2.2 T)
+  apply le_of_tendsto hl
+  filter_upwards [self_mem_nhdsWithin] with y hy
+  apply h.inverse_re_le T (show (U T : ℂ)+(y:ℂ)*I ∈ upperHalfPlane by
+    simpa [upperHalfPlane] using hy) (by simpa using hU T ⟨zero_le,le_rfl⟩) hU
+
+lemma IsCapacityTwoWitness.trace_abs_re_le
+    (h : IsCapacityTwoWitness U γ G F) (T : ℝ≥0) {M : ℝ}
+    (hU : ∀ t ∈ Icc 0 T, |U t| ≤ M) : |(γ T).re| ≤ M := by
+  apply abs_le.mpr
+  refine ⟨?_,h.trace_re_le T (fun t ht => (le_abs_self _).trans (hU t ht))⟩
+  have hh := h.mirror.trace_re_le T (fun t ht => (neg_le_abs _).trans (hU t ht))
+  simpa only [Function.comp_apply,loewnerMirror_re,neg_le] using hh
+
+end SLEExactGauge
+
+end
+
+end OAI
diff --git a/lean/OAI/Probability/SLE/Loewner/LoewnerHeightClearance.lean b/lean/OAI/Probability/SLE/Loewner/LoewnerHeightClearance.lean
new file mode 100644
index 0000000000000000000000000000000000000000..4ebc56ecfca4fb1dec142f63ebfbf48086076625
--- /dev/null
+++ b/lean/OAI/Probability/SLE/Loewner/LoewnerHeightClearance.lean
@@ -0,0 +1,65 @@
+import OAI.Probability.SLE.Gauge.RibbonSurvival
+import OAI.Probability.SLE.Geometry.NormalizedMarkedState
+import OAI.Probability.SLE.Geometry.HyperbolicGuideCompactness
+
+namespace OAI
+
+/-! A hypothetical upper bound on the trace height gives a physical
+clearance ball and hence a lower bound on the inverse derivative. -/
+noncomputable section
+open Set Filter Metric
+open scoped Topology NNReal
+
+namespace SLEExactGauge
+
+lemma survives_above_trace_height
+    (γ : ℝ≥0 → ℂ) (T : ℝ≥0) (H : ℝ)
+    (hγ : ∀ t ∈ Icc 0 T, (γ t).im ≤ H) {z : ℂ}
+    (hz : 0 < z.im) (hH : H < z.im) : z ∈ survivingDomain γ T := by
+  have hf : range (upwardRay z) ⊆ upperHalfPlane \ (γ '' Icc 0 T) := by
+    rintro w ⟨s,rfl⟩
+    have hi : (upwardRay z s).im = z.im+s := by simp [upwardRay]
+    refine ⟨?_,?_⟩
+    · change 0 < (upwardRay z s).im
+      rw [hi]
+      exact add_pos_of_pos_of_nonneg hz s.coe_nonneg
+    · rintro ⟨t,ht,he⟩
+      have hh := hγ t ht
+      rw [he,hi] at hh
+      linarith [s.coe_nonneg]
+  have hh := survives_of_unbounded_free_curve γ T (upwardRay z)
+    (upwardRay_continuous z) hf (upwardRay_unbounded z) (mem_range_self 0)
+  simpa [upwardRay] using hh
+
+lemma IsCapacityTwoWitness.inverse_clearance_bound
+    {U : ℝ≥0 → ℝ} {γ : ℝ≥0 → ℂ} {G F : ℝ≥0 → ℂ → ℂ}
+    (h : IsCapacityTwoWitness U γ G F) (T : ℝ≥0) {w : ℂ}
+    (hw : w ∈ upperHalfPlane) {r : ℝ} (hr : 0 < r)
+    (hball : ball (F T w) r ⊆ survivingDomain γ T) :
+    r ≤ (128*Real.pi)*w.im*‖deriv (F T) w‖ := by
+  have hD := h.2.2.2.2.2.2.1 T hw
+  have hid := h.inverse_derivative_identity T (F T w) hD
+  rw [h.2.2.2.2.2.2.2.2.1 T w hw] at hid
+  have hnorm := congrArg norm hid
+  rw [norm_mul,norm_one] at hnorm
+  have hi : InjOn (G T) (survivingDomain γ T) := by
+    intro z hz v hv he
+    rw [← h.2.2.2.2.2.2.2.1 T z hz,he,h.2.2.2.2.2.2.2.1 T v hv]
+  have hd := HyperbolicGuideCompactness.inverse_chart_derivative_bound hr
+    ((h.2.2.2.1 T).mono hball) (hi.mono hball)
+    (fun z hz => h.2.2.2.2.2.1 T (hball hz))
+  rw [h.2.2.2.2.2.2.2.2.1 T w hw] at hd
+  have hm := mul_le_mul_of_nonneg_right hd (norm_nonneg (deriv (F T) w))
+  have hone : 1 ≤ (128*Real.pi/r)*w.im*‖deriv (F T) w‖ := by
+    simpa only [mul_comm ‖deriv (G T) (F T w)‖,hnorm,mul_assoc] using hm
+  calc
+    r = 1*r := by ring
+    _ ≤ ((128*Real.pi/r)*w.im*‖deriv (F T) w‖)*r :=
+      mul_le_mul_of_nonneg_right hone hr.le
+    _ = (128*Real.pi)*w.im*‖deriv (F T) w‖ := by field_simp
+
+end SLEExactGauge
+
+end
+
+end OAI
diff --git a/lean/OAI/Probability/SLE/Loewner/LoewnerInverseCompactness.lean b/lean/OAI/Probability/SLE/Loewner/LoewnerInverseCompactness.lean
new file mode 100644
index 0000000000000000000000000000000000000000..42fe5ce309df71f4d6c1758d2502dbfd6f18fd3a
--- /dev/null
+++ b/lean/OAI/Probability/SLE/Loewner/LoewnerInverseCompactness.lean
@@ -0,0 +1,62 @@
+import OAI.Probability.SLE.Loewner.LoewnerInverseStability
+import OAI.Probability.SLE.Geometry.HolomorphicFamilyCompactness
+
+namespace OAI
+
+/-! Compactness of inverse maps at a fixed capacity time follows directly
+from their reverse-flow displacement estimate. -/
+noncomputable section
+open Set Filter Metric
+open scoped Topology NNReal
+
+namespace SLEExactGauge
+
+local instance : LocallyCompactSpace upperHalfPlane :=
+  isOpen_upperHalfPlane.locallyCompactSpace
+
+lemma inverse_family_compact_bounds
+    (U : ℕ → ℝ≥0 → ℝ) (γ : ℕ → ℝ≥0 → ℂ) (G F : ℕ → ℝ≥0 → ℂ → ℂ)
+    (h : ∀ n, IsCapacityTwoWitness (U n) (γ n) (G n) (F n)) (T : ℝ≥0)
+    (K : Set ℂ) (hK : IsCompact K) (hKH : K ⊆ upperHalfPlane) :
+    ∃ C : ℝ, ∀ n z, z ∈ K → ‖F n T z‖ ≤ C := by
+  by_cases hne : K.Nonempty
+  · obtain ⟨w,hw,hmin⟩ := hK.exists_isMinOn hne Complex.continuous_im.continuousOn
+    have ha : 0 < w.im := hKH hw
+    obtain ⟨R,_,hR⟩ := hK.isBounded.exists_pos_norm_lt
+    refine ⟨R+(2*w.im⁻¹)*T, fun n z hz => ?_⟩
+    have hb := (h n).inverse_displacement_bound T ha z (hmin hz)
+    have ht := norm_le_norm_sub_add (F n T z) z
+    rw [← dist_eq_norm] at ht
+    exact le_trans ht (add_le_add hb (hR z hz).le) |>.trans_eq (add_comm _ _)
+  · exact ⟨0,fun _ z hz => (hne ⟨z,hz⟩).elim⟩
+
+theorem inverse_family_subsequence
+    (U : ℕ → ℝ≥0 → ℝ) (γ : ℕ → ℝ≥0 → ℂ) (G F : ℕ → ℝ≥0 → ℂ → ℂ)
+    (h : ∀ n, IsCapacityTwoWitness (U n) (γ n) (G n) (F n)) (T : ℝ≥0) :
+    ∃ (σ : ℕ → ℕ) (f : ℂ → ℂ), StrictMono σ ∧
+      DifferentiableOn ℂ f upperHalfPlane ∧
+      TendstoLocallyUniformlyOn (fun n => F (σ n) T) f atTop upperHalfPlane := by
+  classical
+  obtain ⟨g,σ,hσ,hconv⟩ := holomorphic_halfPlane_family_subsequence
+    (fun n => F n T) (fun n => (h n).2.2.2.2.1 T)
+    (inverse_family_compact_bounds U γ G F h T)
+  let f : ℂ → ℂ := fun w => if hw : w ∈ upperHalfPlane then g ⟨w,hw⟩ else 0
+  have hf : TendstoLocallyUniformlyOn (fun n => F (σ n) T) f atTop upperHalfPlane := by
+    rw [tendstoLocallyUniformlyOn_iff_tendstoLocallyUniformly_comp_coe]
+    apply tendstoLocallyUniformly_iff_forall_isCompact.mpr
+    intro K hK
+    have hh := ContinuousMap.tendsto_iff_forall_isCompact_tendstoUniformlyOn.mp hconv K hK
+    change TendstoUniformlyOn (fun n (w : upperHalfPlane) => F (σ n) T w)
+      (fun w : upperHalfPlane => f w) atTop K
+    have he : (fun w : upperHalfPlane => f w) = (g : upperHalfPlane → ℂ) := by
+      funext w
+      exact dite_eq_left w.property
+    rwa [he]
+  exact ⟨σ,f,hσ,hf.differentiableOn
+    (Eventually.of_forall fun n => (h (σ n)).2.2.2.2.1 T) isOpen_upperHalfPlane,hf⟩
+
+end SLEExactGauge
+
+end
+
+end OAI
diff --git a/lean/OAI/Probability/SLE/Loewner/LoewnerInverseDriverContinuity.lean b/lean/OAI/Probability/SLE/Loewner/LoewnerInverseDriverContinuity.lean
new file mode 100644
index 0000000000000000000000000000000000000000..9b3c752eb66aaea8cf3949479c4163671c6e3c4e
--- /dev/null
+++ b/lean/OAI/Probability/SLE/Loewner/LoewnerInverseDriverContinuity.lean
@@ -0,0 +1,56 @@
+import OAI.Probability.SLE.Loewner.LoewnerInverseCompactness
+
+namespace OAI
+
+/-! Uniformly close drivers give locally uniformly close inverse maps at
+every fixed capacity time. This is an interior statement. -/
+noncomputable section
+open Set Filter Metric
+open scoped Topology NNReal
+
+namespace SLEExactGauge
+
+lemma inverse_maps_driver_distance
+    {U V : ℝ≥0 → ℝ} {γ β : ℝ≥0 → ℂ} {G F H J : ℝ≥0 → ℂ → ℂ}
+    (hu : IsCapacityTwoWitness U γ G F) (hv : IsCapacityTwoWitness V β H J)
+    (T : ℝ≥0) {a : ℝ} (ha : 0 < a) (w : ℂ) (haw : a ≤ w.im)
+    (δ : ℝ) (hUV : ∀ t ∈ Icc 0 T, |U t-V t| ≤ δ) :
+    dist (F T w) (J T w) ≤ gronwallBound 0 (4*a⁻¹^2) (2*a⁻¹^2*δ) T := by
+  have hh := hu.inverse_approximation_bound T ha w haw V δ hUV
+    (fun s => H ((T:ℝ)-s).toNNReal (J T w))
+    (by simpa only [sub_zero,Real.toNNReal_coe] using hv.2.2.2.2.2.2.2.2.1 T w (ha.trans_le haw))
+    (fun s hs => hv.reverse_path_derivative T w ha haw s hs)
+  simpa only [sub_self,Real.toNNReal_zero,
+    hv.initial_value _ (hv.2.2.2.2.2.2.1 T (ha.trans_le haw)).1.1] using hh
+
+theorem inverse_maps_locally_uniform_of_drivers
+    (U : ℕ → ℝ≥0 → ℝ) (γ : ℕ → ℝ≥0 → ℂ) (G F : ℕ → ℝ≥0 → ℂ → ℂ)
+    (h : ∀ n, IsCapacityTwoWitness (U n) (γ n) (G n) (F n))
+    {V : ℝ≥0 → ℝ} {β : ℝ≥0 → ℂ} {H J : ℝ≥0 → ℂ → ℂ}
+    (hv : IsCapacityTwoWitness V β H J) (T : ℝ≥0)
+    (δ : ℕ → ℝ) (hδ : Tendsto δ atTop (𝓝 0))
+    (hUV : ∀ n t, t ∈ Icc 0 T → |U n t-V t| ≤ δ n) :
+    TendstoLocallyUniformlyOn (fun n => F n T) (J T) atTop upperHalfPlane := by
+  rw [tendstoLocallyUniformlyOn_iff_forall_isCompact isOpen_upperHalfPlane]
+  intro K hKH hK
+  by_cases hne : K.Nonempty
+  · obtain ⟨w,hw,hmin⟩ := hK.exists_isMinOn hne Complex.continuous_im.continuousOn
+    have ha : 0 < w.im := hKH hw
+    have hz : Tendsto (fun n => gronwallBound 0 (4*w.im⁻¹^2)
+        (2*w.im⁻¹^2*δ n) T) atTop (𝓝 0) := by
+      have hh := (gronwallBound_continuous_ε 0 (4*w.im⁻¹^2) T).continuousAt.tendsto.comp
+        (hδ.const_mul (2*w.im⁻¹^2))
+      simpa only [Function.comp_def,mul_zero,gronwallBound_ε0_δ0] using hh
+    rw [Metric.tendstoUniformlyOn_iff]
+    intro ε hε
+    filter_upwards [hz.eventually (Iio_mem_nhds hε)] with n hn z hzk
+    simpa only [dist_comm] using
+      (inverse_maps_driver_distance (h n) hv T ha z (hmin hzk) (δ n) (hUV n)).trans_lt hn
+  · have hKe : K=∅ := Set.not_nonempty_iff_eq_empty.mp hne
+    simp only [hKe,tendstoUniformlyOn_empty]
+
+end SLEExactGauge
+
+end
+
+end OAI
diff --git a/lean/OAI/Probability/SLE/Loewner/LoewnerInverseStability.lean b/lean/OAI/Probability/SLE/Loewner/LoewnerInverseStability.lean
new file mode 100644
index 0000000000000000000000000000000000000000..4a1098c06cc8750122453b8e959e4c7554495ca2
--- /dev/null
+++ b/lean/OAI/Probability/SLE/Loewner/LoewnerInverseStability.lean
@@ -0,0 +1,95 @@
+import OAI.Probability.SLE.Loewner.LoewnerDriverBounds
+
+namespace OAI
+
+/-! Uniform perturbation estimates for inverse maps above a positive height.
+They require no regularity of a boundary trace beyond the capacity witness. -/
+noncomputable section
+open Set Filter Complex
+open scoped Topology NNReal
+
+namespace SLEExactGauge
+
+lemma reverseField_driver_dist {a : ℝ} (ha : 0 < a) (u v : ℝ) (z : ℂ) :
+    dist (reverseField a u z) (reverseField a v z) ≤ 2 * a⁻¹ ^ 2 * |u-v| := by
+  have hc : reverseCenter a v z - reverseCenter a u z = ((u-v : ℝ) : ℂ) := by
+    apply Complex.ext <;> simp [reverseCenter]
+  have hu : ‖(reverseCenter a u z)⁻¹‖ ≤ a⁻¹ := by
+    rw [norm_inv]
+    exact inv_anti₀ ha (reverseCenter_norm a u z)
+  have hv : ‖(reverseCenter a v z)⁻¹‖ ≤ a⁻¹ := by
+    rw [norm_inv]
+    exact inv_anti₀ ha (reverseCenter_norm a v z)
+  rw [dist_eq_norm,reverseField,reverseField,← mul_sub,norm_mul,norm_neg,norm_ofNat,
+    inv_sub_inv' (reverseCenter_ne_zero ha _ _) (reverseCenter_ne_zero ha _ _),
+    norm_mul,norm_mul,hc,Complex.norm_real,Real.norm_eq_abs]
+  calc
+    2 * (‖(reverseCenter a u z)⁻¹‖ * |u-v| * ‖(reverseCenter a v z)⁻¹‖) ≤
+        2 * (a⁻¹ * |u-v| * a⁻¹) := by gcongr
+    _ = _ := by ring
+
+lemma IsCapacityTwoWitness.inverse_approximation_bound
+    {U : ℝ≥0 → ℝ} {γ : ℝ≥0 → ℂ} {G F : ℝ≥0 → ℂ → ℂ}
+    (h : IsCapacityTwoWitness U γ G F) (T : ℝ≥0) {a : ℝ} (ha : 0 < a)
+    (w : ℂ) (haw : a ≤ w.im) (V : ℝ≥0 → ℝ) (δ : ℝ)
+    (hUV : ∀ t ∈ Icc 0 T, |U t-V t| ≤ δ)
+    (Q : ℝ → ℂ) (hQ0 : Q 0=w)
+    (hQ : ∀ s ∈ Icc 0 (T : ℝ), HasDerivWithinAt Q
+      (reverseField a (V ((T:ℝ)-s).toNNReal) (Q s)) (Icc 0 (T:ℝ)) s) :
+    dist (F T w) (Q T) ≤ gronwallBound 0 (4*a⁻¹^2) (2*a⁻¹^2*δ) T := by
+  let q (s : ℝ) := G ((T:ℝ)-s).toNNReal (F T w)
+  have hq (s : ℝ) (hs : s ∈ Icc 0 (T:ℝ)) :=
+    h.reverse_path_derivative T w ha haw s hs
+  have hq0 : q 0=w := by
+    simp only [q,sub_zero,Real.toNNReal_coe]
+    exact h.2.2.2.2.2.2.2.2.1 T w (ha.trans_le haw)
+  have hqT : q T=F T w := by
+    simp only [q,sub_self,Real.toNNReal_zero]
+    exact h.initial_value _ (h.2.2.2.2.2.2.1 T (ha.trans_le haw)).1.1
+  have he := dist_le_of_approx_trajectories_ODE
+    (K := (⟨4*a⁻¹^2, by positivity⟩ : ℝ≥0))
+    (v := fun s => reverseField a (U ((T:ℝ)-s).toNNReal))
+    (fun _ => reverseField_lipschitz ha _)
+    (f := q) (fun s hs => (hq s hs).continuousWithinAt)
+    (fun s hs => hasDerivWithinAt_Ici_of_Icc hs (hq s ⟨hs.1,hs.2.le⟩))
+    (εf := 0) (fun _ _ => by simp [q])
+    (g := Q) (fun s hs => (hQ s hs).continuousWithinAt)
+    (fun s hs => hasDerivWithinAt_Ici_of_Icc hs (hQ s ⟨hs.1,hs.2.le⟩))
+    (εg := 2*a⁻¹^2*δ) (fun s hs => ?_)
+    (δ := 0) (by rw [hq0,hQ0,dist_self])
+    T ⟨T.coe_nonneg,le_rfl⟩
+  · change dist (q T) (Q T) ≤
+      gronwallBound 0 (4*a⁻¹^2) (0+2*a⁻¹^2*δ) ((T:ℝ)-0) at he
+    simpa only [hqT,zero_add,sub_zero] using he
+  · have ht : ((T:ℝ)-s).toNNReal ∈ Icc 0 T := by
+      refine ⟨zero_le,?_⟩
+      exact_mod_cast (show (((T:ℝ)-s).toNNReal : ℝ) ≤ T by
+        rw [Real.coe_toNNReal _ (by linarith [hs.2])]; linarith [hs.1])
+    rw [dist_comm]
+    exact (reverseField_driver_dist ha _ _ _).trans
+      (mul_le_mul_of_nonneg_left (hUV _ ht) (by positivity))
+
+lemma IsCapacityTwoWitness.inverse_displacement_bound
+    {U : ℝ≥0 → ℝ} {γ : ℝ≥0 → ℂ} {G F : ℝ≥0 → ℂ → ℂ}
+    (h : IsCapacityTwoWitness U γ G F) (T : ℝ≥0) {a : ℝ} (ha : 0 < a)
+    (w : ℂ) (haw : a ≤ w.im) : dist (F T w) w ≤ (2*a⁻¹)*T := by
+  let q (s : ℝ) := G ((T:ℝ)-s).toNNReal (F T w)
+  have hq (s : ℝ) (hs : s ∈ Icc 0 (T:ℝ)) :=
+    h.reverse_path_derivative T w ha haw s hs
+  have hb := norm_image_sub_le_of_norm_deriv_le_segment'
+    (fun s hs => hq s hs) (fun s _ => reverseField_bound ha _ _) T
+    ⟨T.coe_nonneg,le_rfl⟩
+  have hq0 : q 0=w := by
+    simp only [q,sub_zero,Real.toNNReal_coe]
+    exact h.2.2.2.2.2.2.2.2.1 T w (ha.trans_le haw)
+  have hqT : q T=F T w := by
+    simp only [q,sub_self,Real.toNNReal_zero]
+    exact h.initial_value _ (h.2.2.2.2.2.2.1 T (ha.trans_le haw)).1.1
+  change ‖q T-q 0‖ ≤ _ at hb
+  simpa only [hqT,hq0,sub_zero,dist_eq_norm] using hb
+
+end SLEExactGauge
+
+end
+
+end OAI
diff --git a/lean/OAI/Probability/SLE/Loewner/LoewnerKernelContinuity.lean b/lean/OAI/Probability/SLE/Loewner/LoewnerKernelContinuity.lean
new file mode 100644
index 0000000000000000000000000000000000000000..e14e03701cf04b5f12153915932e5855fe9bd05c
--- /dev/null
+++ b/lean/OAI/Probability/SLE/Loewner/LoewnerKernelContinuity.lean
@@ -0,0 +1,88 @@
+import OAI.Probability.SLE.Loewner.LoewnerInverseDriverContinuity
+import OAI.Probability.SLE.Loewner.UnivalentLocallyUniformLimit
+
+namespace OAI
+
+/-! Compact interior regions of a limiting Loewner domain persist under
+uniform perturbations of the driver. -/
+noncomputable section
+open Set Filter Metric Complex
+open scoped Topology NNReal
+
+namespace SLEExactGauge
+
+theorem inverse_image_neighborhood_persists
+    (U : ℕ → ℝ≥0 → ℝ) (γ : ℕ → ℝ≥0 → ℂ) (G F : ℕ → ℝ≥0 → ℂ → ℂ)
+    (h : ∀ n, IsCapacityTwoWitness (U n) (γ n) (G n) (F n))
+    {V : ℝ≥0 → ℝ} {β : ℝ≥0 → ℂ} {H J : ℝ≥0 → ℂ → ℂ}
+    (hv : IsCapacityTwoWitness V β H J) (T : ℝ≥0)
+    (hl : TendstoLocallyUniformlyOn (fun n => F n T) (J T) atTop upperHalfPlane)
+    {w : ℂ} (hw : w ∈ upperHalfPlane) :
+    ∃ r : ℝ, 0 < r ∧ ∀ᶠ n in atTop, ball (J T w) r ⊆ survivingDomain (γ n) T := by
+  let R := w.im/2
+  have hwpos : 0 < w.im := hw
+  have hR : 0 < R := half_pos hw
+  have hKH : closedBall w R ⊆ upperHalfPlane := by
+    intro z hz
+    have hz' : ‖z-w‖ ≤ R := by simpa only [mem_closedBall,dist_eq_norm] using hz
+    have hd := (Complex.abs_im_le_norm (z-w)).trans hz'
+    simp only [Complex.sub_im] at hd
+    change 0 < z.im
+    dsimp [R] at hd
+    linarith [(abs_le.mp hd).1]
+  have hJi : InjOn (J T) upperHalfPlane := by
+    intro z hz v hv' he
+    rw [← hv.2.2.2.2.2.2.2.2.1 T z hz,he,hv.2.2.2.2.2.2.2.2.1 T v hv']
+  have hsep (z : ℂ) (hz : z ∈ sphere w R) : J T z ≠ J T w := by
+    intro he
+    have heq := hJi (hKH (sphere_subset_closedBall hz)) hw he
+    exact (ne_of_mem_sphere hz hR.ne') heq
+  have hc : ContinuousOn (fun z => ‖J T z-J T w‖) (sphere w R) :=
+    (((hv.2.2.2.2.1 T).continuousOn.mono (sphere_subset_closedBall.trans hKH)).sub
+      continuousOn_const).norm
+  obtain ⟨v,hvS,hmin⟩ := (isCompact_sphere w R).exists_isMinOn
+    (NormedSpace.sphere_nonempty.mpr hR.le) hc
+  let d : ℝ := ‖J T v-J T w‖
+  have hd : 0 < d := norm_pos_iff.mpr (sub_ne_zero.mpr (hsep v hvS))
+  have hsmall := (Metric.tendstoUniformlyOn_iff.mp
+    ((tendstoLocallyUniformlyOn_iff_forall_isCompact isOpen_upperHalfPlane).mp hl
+      (closedBall w R) hKH (isCompact_closedBall _ _))) (d/8) (by positivity)
+  refine ⟨d/8,by positivity,?_⟩
+  filter_upwards [hsmall] with n hn
+  have hn' (z : ℂ) (hz : z ∈ closedBall w R) : ‖F n T z-J T z‖ < d/8 := by
+    simpa only [dist_eq_norm,norm_sub_rev] using hn z hz
+  have hcenter := hn' w (mem_closedBall_self hR.le)
+  have hboundary (z : ℂ) (hz : z ∈ sphere w R) : d/2 ≤ ‖F n T z-F n T w‖ := by
+    have herror := hn' z (sphere_subset_closedBall hz)
+    have htri : ‖J T z-J T w‖ ≤ ‖J T z-F n T z‖+
+        ‖F n T z-F n T w‖+‖F n T w-J T w‖ := by
+      calc
+        _ = ‖(J T z-F n T z)+(F n T z-F n T w)+(F n T w-J T w)‖ := by congr 1; ring
+        _ ≤ _ := (norm_add_le _ _).trans (add_le_add (norm_add_le _ _) le_rfl)
+    rw [norm_sub_rev (J T z) (F n T z)] at htri
+    have hdmin : d ≤ ‖J T z-J T w‖ := hmin hz
+    linarith
+  have hFi : InjOn (F n T) upperHalfPlane := by
+    intro z hz v hv' he
+    rw [← (h n).2.2.2.2.2.2.2.2.1 T z hz,he,(h n).2.2.2.2.2.2.2.2.1 T v hv']
+  have hdc : DiffContOnCl ℂ (F n T) (ball w R) :=
+    ⟨((h n).2.2.2.2.1 T).mono (ball_subset_closedBall.trans hKH),by
+      rw [closure_ball w hR.ne']
+      exact ((h n).2.2.2.2.1 T).continuousOn.mono hKH⟩
+  have hnot : ∃ᶠ z in 𝓝 w, F n T z ≠ F n T w :=
+    not_eventually.mp (univalent_not_eventually_constant isOpen_upperHalfPlane hFi hw)
+  intro z hz
+  have hz' : z ∈ ball (F n T w) ((d/2)/2) := by
+    have hdist := dist_triangle z (J T w) (F n T w)
+    rw [mem_ball,dist_eq_norm] at hz ⊢
+    simp only [dist_eq_norm,norm_sub_rev (J T w) (F n T w)] at hdist
+    linarith
+  obtain ⟨x,hx,he⟩ := hdc.ball_subset_image_closedBall hR hboundary hnot hz'
+  rw [← he]
+  exact (h n).2.2.2.2.2.2.1 T (hKH hx)
+
+end SLEExactGauge
+
+end
+
+end OAI
diff --git a/lean/OAI/Probability/SLE/Loewner/LoewnerSmallDriverHeight.lean b/lean/OAI/Probability/SLE/Loewner/LoewnerSmallDriverHeight.lean
new file mode 100644
index 0000000000000000000000000000000000000000..83e1c11535fba887c86f82ad28bb8932f5d6c48b
--- /dev/null
+++ b/lean/OAI/Probability/SLE/Loewner/LoewnerSmallDriverHeight.lean
@@ -0,0 +1,87 @@
+import OAI.Probability.SLE.Loewner.LoewnerInverseCompactness
+import OAI.Probability.SLE.Loewner.VerticalMapDerivative
+import OAI.Probability.SLE.Loewner.LoewnerHeightClearance
+
+namespace OAI
+
+/-! Drivers converging uniformly to zero cannot all generate traces below
+a height strictly smaller than the corresponding vertical slit. -/
+noncomputable section
+open Set Filter Metric Complex
+open scoped Topology NNReal
+
+namespace SLEExactGauge
+
+theorem small_drivers_not_all_height_bounded
+    (U : ℕ → ℝ≥0 → ℝ) (γ : ℕ → ℝ≥0 → ℂ) (G F : ℕ → ℝ≥0 → ℂ → ℂ)
+    (h : ∀ n, IsCapacityTwoWitness (U n) (γ n) (G n) (F n))
+    (T : ℝ≥0) (H : ℝ) (hH : 0 ≤ H) (hHT : H < 2*Real.sqrt T)
+    (δ : ℕ → ℝ) (hδ : Tendsto δ atTop (𝓝 0))
+    (hU : ∀ n t, t ∈ Icc 0 T → |U n t| ≤ δ n) :
+    ¬ ∀ n t, t ∈ Icc 0 T → (γ n t).im ≤ H := by
+  intro hlow
+  obtain ⟨σ,f,hσ,hf,hlim⟩ := inverse_family_subsequence U γ G F h T
+  have haxis (y : ℝ) (hy : 0 < y) : f ((y:ℂ)*I)=verticalReversePath y T := by
+    exact tendsto_nhds_unique
+      (hlim.tendsto_at (by simpa [upperHalfPlane] using hy))
+      ((inverse_vertical_tendsto U γ G F h T δ hδ hU hy).comp hσ.tendsto_atTop)
+  let r : ℝ := (2*Real.sqrt T-H)/4
+  have hr : 0 < r := by dsimp [r]; linarith
+  have hT : 0 < (T:ℝ) := by
+    by_contra hn
+    have he : (T:ℝ)=0 := le_antisymm (le_of_not_gt hn) T.coe_nonneg
+    simp only [he,Real.sqrt_zero,mul_zero] at hHT
+    linarith
+  have hsqrt (y : ℝ) : 2*Real.sqrt T ≤ Real.sqrt (y^2+4*T) := by
+    have h1 := Real.sq_sqrt T.coe_nonneg
+    have h2 := Real.sq_sqrt (show 0 ≤ y^2+4*(T:ℝ) by positivity)
+    nlinarith [Real.sqrt_nonneg (T:ℝ),Real.sqrt_nonneg (y^2+4*(T:ℝ))]
+  have hbound (y : ℝ) (hy : 0 < y) :
+      r ≤ (128*Real.pi)*y*(y/Real.sqrt (y^2+4*T)) := by
+    have hiy : (y:ℂ)*I ∈ upperHalfPlane := by simpa [upperHalfPlane] using hy
+    have hi := Complex.continuous_im.continuousAt.tendsto.comp (hlim.tendsto_at hiy)
+    rw [haxis y hy] at hi
+    have hheight : H+2*r < (verticalReversePath y T).im := by
+      simp only [verticalReversePath,Complex.mul_im,Complex.ofReal_re,Complex.I_im,
+        Complex.ofReal_im,Complex.I_re,mul_one,mul_zero,add_zero]
+      dsimp [r]
+      linarith [hsqrt y]
+    have hev : ∀ᶠ n in atTop, H+2*r < (F (σ n) T ((y:ℂ)*I)).im :=
+      hi.eventually (Ioi_mem_nhds hheight)
+    have hb : ∀ᶠ n in atTop,
+        r ≤ (128*Real.pi)*y*‖deriv (F (σ n) T) ((y:ℂ)*I)‖ := by
+      filter_upwards [hev] with n hn
+      have hball : ball (F (σ n) T ((y:ℂ)*I)) r ⊆ survivingDomain (γ (σ n)) T := by
+        intro z hz
+        have hzdist : ‖z-F (σ n) T ((y:ℂ)*I)‖ < r := by
+          simpa only [mem_ball,dist_eq_norm] using hz
+        have hzheight := (abs_lt.mp ((Complex.abs_im_le_norm
+          (z-F (σ n) T ((y:ℂ)*I))).trans_lt hzdist)).1
+        simp only [Complex.sub_im] at hzheight
+        apply survives_above_trace_height (γ (σ n)) T H (hlow (σ n))
+        · linarith
+        · linarith
+      simpa only [Complex.mul_im,Complex.ofReal_re,Complex.I_im,mul_one,
+        Complex.ofReal_im,Complex.I_re,mul_zero,add_zero] using
+        (h (σ n)).inverse_clearance_bound T hiy hr hball
+    have hd := ((hlim.deriv (Eventually.of_forall fun n => (h (σ n)).2.2.2.2.1 T)
+      isOpen_upperHalfPlane).tendsto_at hiy).norm
+    have hh := ge_of_tendsto (hd.const_mul ((128*Real.pi)*y)) hb
+    rw [vertical_axis_derivative f T hf haxis hy,Complex.norm_real,Real.norm_eq_abs,
+      abs_of_nonneg (div_nonneg hy.le (Real.sqrt_nonneg _))] at hh
+    exact hh
+  let y : ℕ → ℝ := fun n => 1/((n:ℝ)+1)
+  have hy : Tendsto y atTop (𝓝 0) := tendsto_one_div_add_atTop_nhds_zero_nat
+  have hden := ((hy.pow 2).add_const (4*(T:ℝ))).sqrt
+  have hden0 : Real.sqrt (0^2+4*(T:ℝ)) ≠ 0 := (Real.sqrt_pos.mpr (by positivity)).ne'
+  have hl := ((hy.const_mul (128*Real.pi)).mul (hy.div hden hden0))
+  have hzero : r ≤ 0 := by
+    apply ge_of_tendsto (by simpa using hl)
+    exact Eventually.of_forall (fun n => hbound (y n) (by dsimp [y]; positivity))
+  exact (not_le_of_gt hr) hzero
+
+end SLEExactGauge
+
+end
+
+end OAI
diff --git a/lean/OAI/Probability/SLE/Loewner/LoewnerTipHullApproximation.lean b/lean/OAI/Probability/SLE/Loewner/LoewnerTipHullApproximation.lean
new file mode 100644
index 0000000000000000000000000000000000000000..b6f2daf7ce6372f1680cd2d2b957b244a2a5bcaf
--- /dev/null
+++ b/lean/OAI/Probability/SLE/Loewner/LoewnerTipHullApproximation.lean
@@ -0,0 +1,83 @@
+import OAI.Probability.SLE.Geometry.HalfPlaneBoundaryDerivative
+import OAI.Probability.SLE.Loewner.LoewnerHeightClearance
+import OAI.Probability.SLE.Loewner.LoewnerInverseDriverContinuity
+
+namespace OAI
+
+/-! Kernel convergence cannot leave a fixed surviving ball around the
+limiting tip. The boundary derivative estimate gives a quantitative
+contradiction to such a ball. -/
+noncomputable section
+open Set Filter Metric
+open scoped Topology NNReal
+
+namespace SLEExactGauge
+
+theorem inverse_convergence_excludes_common_tip_ball
+    (U : ℕ → ℝ≥0 → ℝ) (γ : ℕ → ℝ≥0 → ℂ) (G F : ℕ → ℝ≥0 → ℂ → ℂ)
+    (h : ∀ n, IsCapacityTwoWitness (U n) (γ n) (G n) (F n))
+    {V : ℝ≥0 → ℝ} {β : ℝ≥0 → ℂ} {H J : ℝ≥0 → ℂ → ℂ}
+    (hv : IsCapacityTwoWitness V β H J) (T : ℝ≥0)
+    (hl : TendstoLocallyUniformlyOn (fun n => F n T) (J T) atTop upperHalfPlane)
+    {r : ℝ} (hr : 0 < r) :
+    ¬ ∀ n, ball (β T) r ⊆ survivingDomain (γ n) T := by
+  intro hballs
+  have hnear : ∀ᶠ y : ℝ in 𝓝[>] 0,
+      dist (J T ((V T : ℂ)+(y : ℂ)*Complex.I)) (β T) < r/4 :=
+    (hv.2.2.2.2.2.2.2.2.2.2.2.2 T).eventually (ball_mem_nhds _ (by positivity))
+  have hbound : ∀ᶠ y : ℝ in 𝓝[>] 0,
+      r/2 ≤ (128*Real.pi)*(y*‖deriv (J T) ((V T : ℂ)+(y : ℂ)*Complex.I)‖) := by
+    filter_upwards [hnear,self_mem_nhdsWithin] with y hy hy0
+    let w : ℂ := (V T : ℂ)+(y : ℂ)*Complex.I
+    have hw : w ∈ upperHalfPlane := by simpa [w,upperHalfPlane] using hy0
+    have hvalue := hl.tendsto_at hw
+    have hd := ((hl.deriv (Eventually.of_forall fun n => (h n).2.2.2.2.1 T)
+      isOpen_upperHalfPlane).tendsto_at hw).norm
+    have hb : ∀ᶠ n in atTop, r/2 ≤ (128*Real.pi)*y*‖deriv (F n T) w‖ := by
+      filter_upwards [hvalue.eventually (ball_mem_nhds _ (by positivity : 0 < r/4))]
+        with n hn
+      have hball : ball (F n T w) (r/2) ⊆ survivingDomain (γ n) T := by
+        intro z hz
+        apply hballs n
+        rw [mem_ball] at hz ⊢
+        have ht := dist_triangle z (F n T w) (β T)
+        have ht' := dist_triangle (F n T w) (J T w) (β T)
+        change dist (F n T w) (J T w) < r/4 at hn
+        change dist (J T w) (β T) < r/4 at hy
+        linarith
+      simpa only [w,Complex.add_im,Complex.ofReal_im,Complex.mul_im,
+        Complex.ofReal_re,Complex.I_re,Complex.I_im,mul_one,mul_zero,
+        zero_add,add_zero] using (h n).inverse_clearance_bound T hw
+          (by positivity : 0 < r/2) hball
+    have hh := ge_of_tendsto (hd.const_mul ((128*Real.pi)*y)) hb
+    simpa only [mul_assoc] using hh
+  have hzero : r/2 ≤ 0 := by
+    have hh := ge_of_tendsto ((hv.inverse_tip_derivative_vanishes T).const_mul
+      (128*Real.pi)) hbound
+    simpa only [mul_zero] using hh
+  linarith
+
+theorem driver_neighborhood_hits_tip_hull
+    {V : ℝ≥0 → ℝ} {β : ℝ≥0 → ℂ} {H J : ℝ≥0 → ℂ → ℂ}
+    (hv : IsCapacityTwoWitness V β H J) (T : ℝ≥0) {r : ℝ} (hr : 0 < r) :
+    ∃ δ : ℝ, 0 < δ ∧ ∀ (U : ℝ≥0 → ℝ) (γ : ℝ≥0 → ℂ)
+      (G F : ℝ≥0 → ℂ → ℂ), IsCapacityTwoWitness U γ G F →
+      (∀ t ∈ Icc 0 T, |U t-V t| ≤ δ) →
+      ¬ ball (β T) r ⊆ survivingDomain γ T := by
+  classical
+  by_contra hn
+  push Not at hn
+  have hc (n : ℕ) := hn ((n+1:ℝ)⁻¹) (by positivity)
+  choose U γ G F hw hclose hball using hc
+  have hδ : Tendsto (fun n : ℕ => (n+1:ℝ)⁻¹) atTop (𝓝 0) :=
+    tendsto_inv_atTop_zero.comp
+      (tendsto_atTop_add_const_right atTop 1 tendsto_natCast_atTop_atTop)
+  have hl := inverse_maps_locally_uniform_of_drivers U γ G F hw hv T
+    (fun n : ℕ => (n+1:ℝ)⁻¹) hδ hclose
+  exact inverse_convergence_excludes_common_tip_ball U γ G F hw hv T hl hr hball
+
+end SLEExactGauge
+
+end
+
+end OAI
diff --git a/lean/OAI/Probability/SLE/Loewner/LoewnerTipVisit.lean b/lean/OAI/Probability/SLE/Loewner/LoewnerTipVisit.lean
new file mode 100644
index 0000000000000000000000000000000000000000..8b046a796c75ab3d40c184abcf81e49730e315a3
--- /dev/null
+++ b/lean/OAI/Probability/SLE/Loewner/LoewnerTipVisit.lean
@@ -0,0 +1,83 @@
+import OAI.Probability.SLE.Loewner.LoewnerTipHullApproximation
+import OAI.Probability.SLE.Loewner.LoewnerCompactDriverNeighborhood
+
+namespace OAI
+
+/-! A perturbed hull near an interior reference tip must be visited by
+the actual trace: a surviving point in the same connected ball rules out
+the possibility that the ball is entirely swallowed. -/
+noncomputable section
+open Set Filter Metric
+open scoped Topology NNReal
+
+namespace SLEExactGauge
+
+lemma trace_meets_connected_region
+    (γ : ℝ≥0 → ℂ) (T : ℝ≥0) {S : Set ℂ}
+    (hS : IsPreconnected S) (hSH : S ⊆ upperHalfPlane)
+    {w : ℂ} (hwS : w ∈ S) (hwD : w ∈ survivingDomain γ T)
+    (hnot : ¬ S ⊆ survivingDomain γ T) :
+    ∃ t ∈ Icc 0 T, γ t ∈ S := by
+  by_contra hn
+  push Not at hn
+  have hf : S ⊆ upperHalfPlane \ (γ '' Icc 0 T) := by
+    intro z hz
+    refine ⟨hSH hz,?_⟩
+    rintro ⟨t,ht,rfl⟩
+    exact hn t ht hz
+  apply hnot
+  intro z hz
+  have hc := hS.subset_connectedComponentIn hwS hf hz
+  refine ⟨hf hz,?_⟩
+  rw [← connectedComponentIn_eq hc]
+  exact hwD.2
+
+lemma ball_subset_halfPlane {q : ℂ} {r : ℝ} (hr : r ≤ q.im) :
+    ball q r ⊆ upperHalfPlane := by
+  intro z hz
+  have hd : ‖z-q‖ < r := by simpa only [mem_ball,dist_eq_norm] using hz
+  have hi := (abs_lt.mp ((Complex.abs_im_le_norm (z-q)).trans_lt hd)).1
+  simp only [Complex.sub_im] at hi
+  change 0 < z.im
+  linarith
+
+theorem driver_neighborhood_visits_tip
+    {V : ℝ≥0 → ℝ} {β : ℝ≥0 → ℂ} {H J : ℝ≥0 → ℂ → ℂ}
+    (hv : IsCapacityTwoWitness V β H J) (T : ℝ≥0)
+    {r : ℝ} (hr : 0 < r) (hrH : r ≤ (β T).im)
+    {K : Set ℂ} (hK : IsCompact K) (hKD : K ⊆ survivingDomain β T) :
+    ∃ δ : ℝ, 0 < δ ∧ ∀ (U : ℝ≥0 → ℝ) (γ : ℝ≥0 → ℂ)
+      (G F : ℝ≥0 → ℂ → ℂ), IsCapacityTwoWitness U γ G F →
+      (∀ t ∈ Icc 0 T, |U t-V t| ≤ δ) →
+      K ⊆ survivingDomain γ T ∧ ∃ t ∈ Icc 0 T, γ t ∈ ball (β T) r := by
+  have he : ∀ᶠ y : ℝ in 𝓝[>] 0, 0 < y ∧
+      J T ((V T : ℂ)+(y : ℂ)*Complex.I) ∈ ball (β T) r := by
+    filter_upwards [self_mem_nhdsWithin,
+      (hv.2.2.2.2.2.2.2.2.2.2.2.2 T).eventually (ball_mem_nhds _ hr)] with y hy hb
+    exact ⟨hy,hb⟩
+  obtain ⟨y,hy,hyw⟩ := he.exists
+  let w := J T ((V T : ℂ)+(y : ℂ)*Complex.I)
+  have hw : w ∈ survivingDomain β T := hv.2.2.2.2.2.2.1 T
+    (by simpa [upperHalfPlane] using hy)
+  obtain ⟨δ₁,hδ₁,hkeep⟩ := driver_neighborhood_preserves_compact hv T hK hKD
+  obtain ⟨δ₂,hδ₂,hwkeep⟩ := driver_neighborhood_preserves_compact hv T
+    (isCompact_singleton : IsCompact ({w} : Set ℂ)) (singleton_subset_iff.mpr hw)
+  obtain ⟨δ₃,hδ₃,hhit⟩ := driver_neighborhood_hits_tip_hull hv T hr
+  refine ⟨min δ₁ (min δ₂ δ₃),lt_min hδ₁ (lt_min hδ₂ hδ₃),?_⟩
+  intro U γ G F h hclose
+  have h₁ : ∀ t ∈ Icc 0 T, |U t-V t| ≤ δ₁ :=
+    fun t ht => (hclose t ht).trans (min_le_left _ _)
+  have h₂ : ∀ t ∈ Icc 0 T, |U t-V t| ≤ δ₂ :=
+    fun t ht => (hclose t ht).trans ((min_le_right _ _).trans (min_le_left _ _))
+  have h₃ : ∀ t ∈ Icc 0 T, |U t-V t| ≤ δ₃ :=
+    fun t ht => (hclose t ht).trans ((min_le_right _ _).trans (min_le_right _ _))
+  refine ⟨hkeep U γ G F h h₁,?_⟩
+  exact trace_meets_connected_region γ T (convex_ball _ _).isPreconnected
+    (ball_subset_halfPlane hrH) hyw
+    ((hwkeep U γ G F h h₂) (mem_singleton w)) (hhit U γ G F h h₃)
+
+end SLEExactGauge
+
+end
+
+end OAI
diff --git a/lean/OAI/Probability/SLE/Loewner/LoewnerTraceHeight.lean b/lean/OAI/Probability/SLE/Loewner/LoewnerTraceHeight.lean
new file mode 100644
index 0000000000000000000000000000000000000000..b75e36ec5874c9c2d32a6b688fa4271b166aadec
--- /dev/null
+++ b/lean/OAI/Probability/SLE/Loewner/LoewnerTraceHeight.lean
@@ -0,0 +1,86 @@
+import OAI.Probability.SLE.Loewner.LoewnerDriverBounds
+
+namespace OAI
+
+/-! The deterministic height bound for a capacity-two trace. -/
+noncomputable section
+open Set Filter Complex
+open scoped Topology NNReal
+
+namespace SLEExactGauge
+
+variable {U : ℝ≥0 → ℝ} {γ : ℝ≥0 → ℂ} {G F : ℝ≥0 → ℂ → ℂ}
+
+lemma IsCapacityTwoWitness.inverse_height_sq_le
+    (h : IsCapacityTwoWitness U γ G F) (T : ℝ≥0) {w : ℂ}
+    (hw : w ∈ upperHalfPlane) : (F T w).im^2 ≤ w.im^2+4*T := by
+  let q (s : ℝ) := G ((T:ℝ)-s).toNNReal (F T w)
+  have hd (s : ℝ) (hs : s ∈ Icc 0 (T:ℝ)) :
+      HasDerivWithinAt (fun t => (q t).im^2)
+        (4*(q s).im^2/normSq (q s-(U ((T:ℝ)-s).toNNReal : ℂ)))
+        (Icc 0 (T:ℝ)) s := by
+    have hi := Complex.imCLM.hasFDerivAt.comp_hasDerivWithinAt s
+      (h.reverse_path_unclipped T hw hs)
+    change HasDerivWithinAt (fun t => (q t).im)
+      ((-2/(q s-(U ((T:ℝ)-s).toNNReal : ℂ))).im) _ _ at hi
+    have hh := hi.pow 2
+    convert! hh using 1
+    simp only [Complex.div_im,Complex.neg_re,Complex.re_ofNat,Complex.neg_im,
+      Complex.im_ofNat,neg_zero,zero_mul,Complex.sub_im,Complex.ofReal_im,sub_zero]
+    ring
+  have hq0 : q 0=w := by
+    simp only [q,sub_zero,Real.toNNReal_coe]
+    exact h.2.2.2.2.2.2.2.2.1 T w hw
+  have hqT : q T=F T w := by
+    simp only [q,sub_self,Real.toNNReal_zero]
+    exact h.initial_value _ (h.2.2.2.2.2.2.1 T hw).1.1
+  have hb := image_le_of_deriv_right_le_deriv_boundary
+    (fun s hs => (hd s hs).continuousWithinAt)
+    (fun s hs => hasDerivWithinAt_Ici_of_Icc hs (hd s ⟨hs.1,hs.2.le⟩))
+    (B := fun s => w.im^2+4*s) (B' := fun _ => 4)
+    (by simp [hq0]) (by fun_prop)
+    (fun s _ => by
+      convert (((hasDerivAt_id s).const_mul 4).const_add (w.im^2)).hasDerivWithinAt using 1 <;> simp)
+    (fun s hs => ?_) (show (T:ℝ) ∈ Icc 0 (T:ℝ) from ⟨T.coe_nonneg,le_rfl⟩)
+  · simpa only [hqT] using hb
+  · apply (div_le_iff₀ ?_).mpr
+    · simp only [Complex.normSq_apply,Complex.sub_re,Complex.ofReal_re,
+        Complex.sub_im,Complex.ofReal_im,sub_zero]
+      nlinarith [sq_nonneg ((q s).re-U ((T:ℝ)-s).toNNReal)]
+    · apply Complex.normSq_pos.mpr
+      have hi := h.imag_ge_terminal T (F T w) (h.2.2.2.2.2.2.1 T hw)
+        ((T:ℝ)-s) ⟨by linarith [hs.2],by linarith [hs.1]⟩
+      rw [h.2.2.2.2.2.2.2.2.1 T w hw] at hi
+      intro he
+      have him := congrArg Complex.im he
+      simp only [Complex.sub_im,Complex.ofReal_im,sub_zero,Complex.zero_im] at him
+      change w.im ≤ (q s).im at hi
+      change 0 < w.im at hw
+      linarith
+
+theorem IsCapacityTwoWitness.trace_height_le
+    (h : IsCapacityTwoWitness U γ G F) (T : ℝ≥0) : (γ T).im ≤ 2*Real.sqrt T := by
+  let y (n : ℕ) : ℝ := 1/((n:ℝ)+1)
+  have hy0 : Tendsto y atTop (𝓝 0) := tendsto_one_div_add_atTop_nhds_zero_nat
+  have hy : Tendsto y atTop (𝓝[>] (0:ℝ)) := tendsto_nhdsWithin_iff.mpr
+    ⟨hy0,Eventually.of_forall (fun n => by change 0 < y n; dsimp [y]; positivity)⟩
+  have hl := (Complex.continuous_im.continuousAt.tendsto.comp
+    ((h.2.2.2.2.2.2.2.2.2.2.2.2 T).comp hy)).pow 2
+  have hr := (hy0.pow 2).add_const (4*(T:ℝ))
+  have hb : (γ T).im^2 ≤ 4*(T:ℝ) := by
+    apply le_of_tendsto_of_tendsto hl (by simpa using hr)
+    apply Eventually.of_forall
+    intro n
+    have hh := h.inverse_height_sq_le T
+      (w := (U T:ℂ)+(y n:ℂ)*I) (by
+        change 0 < ((U T:ℂ)+(y n:ℂ)*I).im
+        simpa using (show 0 < y n by dsimp [y]; positivity))
+    simpa using hh
+  have hs := Real.sq_sqrt T.coe_nonneg
+  nlinarith [Real.sqrt_nonneg (T:ℝ)]
+
+end SLEExactGauge
+
+end
+
+end OAI
diff --git a/lean/OAI/Probability/SLE/Loewner/LoewnerVerticalLimit.lean b/lean/OAI/Probability/SLE/Loewner/LoewnerVerticalLimit.lean
new file mode 100644
index 0000000000000000000000000000000000000000..6a02e1304aaf31ef9691275e38bb7fc1c7075b13
--- /dev/null
+++ b/lean/OAI/Probability/SLE/Loewner/LoewnerVerticalLimit.lean
@@ -0,0 +1,77 @@
+import OAI.Probability.SLE.Loewner.LoewnerInverseStability
+
+namespace OAI
+
+/-! The zero-driver inverse trajectory, and convergence to it on the
+imaginary axis under a uniform perturbation of the driving function. -/
+noncomputable section
+open Set Filter Complex
+open scoped Topology NNReal
+
+namespace SLEExactGauge
+
+def verticalReversePath (y s : ℝ) : ℂ := (Real.sqrt (y^2+4*s) : ℂ)*I
+
+lemma verticalReversePath_zero {y : ℝ} (hy : 0 < y) :
+    verticalReversePath y 0=(y:ℂ)*I := by
+  simp [verticalReversePath,Real.sqrt_sq hy.le]
+
+lemma verticalReversePath_derivative {y s : ℝ} (hy : 0 < y) (hs : 0 ≤ s) :
+    HasDerivAt (verticalReversePath y)
+      (reverseField y 0 (verticalReversePath y s)) s := by
+  have hp : 0 < y^2+4*s := by positivity
+  have hr : 0 < Real.sqrt (y^2+4*s) := Real.sqrt_pos.mpr hp
+  have hle : y ≤ Real.sqrt (y^2+4*s) := by
+    calc
+      y = Real.sqrt (y^2) := (Real.sqrt_sq hy.le).symm
+      _ ≤ Real.sqrt (y^2+4*s) := Real.sqrt_le_sqrt (by linarith)
+  have hd := (((hasDerivAt_const s (y^2)).add
+    ((hasDerivAt_id s).const_mul 4)).sqrt hp.ne').ofReal_comp.mul_const I
+  have hd' : HasDerivAt (verticalReversePath y)
+      ((((4)/(2*Real.sqrt (y^2+4*s)) : ℝ) : ℂ)*I) s := by
+    convert! hd using 1
+    simp only [Pi.add_apply, id_eq, zero_add, mul_one]
+  have he : reverseField y 0 (verticalReversePath y s) =
+      (((4)/(2*Real.sqrt (y^2+4*s)) : ℝ) : ℂ)*I := by
+    have hi : y ≤ (verticalReversePath y s).im := by
+      simpa [verticalReversePath] using hle
+    rw [reverseField,reverseCenter_eq hi,Complex.ofReal_zero,sub_zero]
+    dsimp [verticalReversePath]
+    have hc : (Real.sqrt (y^2+4*s) : ℂ) ≠ 0 := by exact_mod_cast hr.ne'
+    push_cast
+    field_simp [hc]
+    norm_num [Complex.I_sq]
+  exact he ▸ hd'
+
+theorem IsCapacityTwoWitness.inverse_vertical_approximation
+    {U : ℝ≥0 → ℝ} {γ : ℝ≥0 → ℂ} {G F : ℝ≥0 → ℂ → ℂ}
+    (h : IsCapacityTwoWitness U γ G F) (T : ℝ≥0) {y : ℝ} (hy : 0 < y)
+    (δ : ℝ) (hU : ∀ t ∈ Icc 0 T, |U t| ≤ δ) :
+    dist (F T ((y:ℂ)*I)) (verticalReversePath y T) ≤
+      gronwallBound 0 (4*y⁻¹^2) (2*y⁻¹^2*δ) T := by
+  apply h.inverse_approximation_bound T hy ((y:ℂ)*I) (by simp)
+    (fun _ => 0) δ (by simpa only [sub_zero] using hU)
+    (verticalReversePath y) (verticalReversePath_zero hy)
+  intro s hs
+  exact (verticalReversePath_derivative hy hs.1).hasDerivWithinAt
+
+theorem inverse_vertical_tendsto
+    (U : ℕ → ℝ≥0 → ℝ) (γ : ℕ → ℝ≥0 → ℂ)
+    (G F : ℕ → ℝ≥0 → ℂ → ℂ)
+    (h : ∀ n, IsCapacityTwoWitness (U n) (γ n) (G n) (F n))
+    (T : ℝ≥0) (δ : ℕ → ℝ) (hδ : Tendsto δ atTop (𝓝 0))
+    (hU : ∀ n t, t ∈ Icc 0 T → |U n t| ≤ δ n)
+    {y : ℝ} (hy : 0 < y) :
+    Tendsto (fun n => F n T ((y:ℂ)*I)) atTop (𝓝 (verticalReversePath y T)) := by
+  rw [tendsto_iff_dist_tendsto_zero]
+  have hb := fun n => (h n).inverse_vertical_approximation T hy (δ n) (hU n)
+  have ht := (gronwallBound_continuous_ε 0 (4*y⁻¹^2) T).continuousAt.tendsto.comp
+    (hδ.const_mul (2*y⁻¹^2))
+  simp only [mul_zero,gronwallBound_ε0_δ0] at ht
+  exact squeeze_zero (fun _ => dist_nonneg) hb ht
+
+end SLEExactGauge
+
+end
+
+end OAI
diff --git a/lean/OAI/Probability/SLE/Loewner/MappedFutureArc.lean b/lean/OAI/Probability/SLE/Loewner/MappedFutureArc.lean
new file mode 100644
index 0000000000000000000000000000000000000000..7f5731e21f638e38eb00b17b6b9cff3bd472e6b8
--- /dev/null
+++ b/lean/OAI/Probability/SLE/Loewner/MappedFutureArc.lean
@@ -0,0 +1,107 @@
+import OAI.Probability.SLE.Loewner.InitialDrivingLimit
+import OAI.Probability.SLE.Loewner.FillEndpoint
+import OAI.Probability.SLE.Loewner.InitialChartIdentities
+
+namespace OAI
+
+/-! Each finite future subarc becomes a continuous attached arc in the
+current half-plane chart. Its initial value is the proved driving limit. -/
+noncomputable section
+open Set Filter Function Complex
+open scoped Topology
+
+namespace SLEExactGauge
+
+lemma initialForwardChart_continuousAt (p : C(unitInterval,ℂ)) (hi : Injective p)
+    (h0 : p 0=0) (hH : ∀ t : unitInterval, t≠0 → p t∈upperHalfPlane)
+    (s : unitInterval) {z : ℂ} (hz : z∈upperHalfPlane \ range (initialSubarc p s)) :
+    ContinuousAt (initialForwardChart p hi h0 hH s) z := by
+  by_cases hs : s=0
+  · simpa only [hs,initialForwardChart_zero] using continuousAt_id (x := z)
+  · rw [initialForwardChart,dite_eq_right hs]
+    exact ((initialSlitChart p hi h0 hH s hs).forward_differentiable.continuousOn z hz).continuousAt
+      ((initialSlitChart p hi h0 hH s hs).isOpen_domain.mem_nhds hz)
+
+def mappedFutureRaw (p : C(unitInterval,ℂ)) (hi : Injective p)
+    (h0 : p 0=0) (hH : ∀ t : unitInterval, t≠0 → p t∈upperHalfPlane)
+    (s t : unitInterval) (r : ℝ) : ℂ :=
+  initialForwardChart p hi h0 hH s
+    (p (slitFutureParameter s (((t:ℝ)-(s:ℝ))*r)))
+
+lemma future_scaled_offset {s t : unitInterval} (hst : s<t) (ht : t<1)
+    {r : ℝ} (hr : r∈Ioc (0:ℝ) 1) :
+    ((t:ℝ)-(s:ℝ))*r∈Ioo 0 (1-(s:ℝ)) := by
+  have hd : 0<(t:ℝ)-(s:ℝ) := sub_pos.mpr hst
+  refine ⟨mul_pos hd hr.1,?_⟩
+  have hm := mul_le_mul_of_nonneg_left hr.2 hd.le
+  have ht' : (t:ℝ)<1 := ht
+  nlinarith
+
+lemma mappedFutureRaw_continuousAt (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) {r : ℝ} (hr : r∈Ioc (0:ℝ) 1) :
+    ContinuousAt (mappedFutureRaw p hi h0 hH s t) r := by
+  have hz := slitFuturePoint_mem_domain p hi hH s (future_scaled_offset hst ht hr)
+  have hc : Continuous (fun r : ℝ => p (slitFutureParameter s (((t:ℝ)-(s:ℝ))*r))) :=
+    p.continuous.comp ((slitFutureParameter_continuous s).comp
+      (continuous_const.mul continuous_id))
+  change ContinuousAt (fun r : ℝ => initialForwardChart p hi h0 hH s
+    (p (slitFutureParameter s (((t:ℝ)-(s:ℝ))*r)))) r
+  exact (initialForwardChart_continuousAt p hi h0 hH s hz).comp
+    (f := fun r : ℝ => p (slitFutureParameter s (((t:ℝ)-(s:ℝ))*r)))
+    (show ContinuousAt (fun r : ℝ => p (slitFutureParameter s (((t:ℝ)-(s:ℝ))*r))) r from
+      hc.continuousAt)
+
+lemma mappedFutureRaw_tendsto (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) :
+    Tendsto (mappedFutureRaw p hi h0 hH s t) (𝓝[>] (0:ℝ))
+      (𝓝 ((initialDrivingValue p hi h0 hH s (hst.trans ht)):ℂ)) := by
+  have hd : 0<(t:ℝ)-(s:ℝ) := sub_pos.mpr hst
+  have hc : Tendsto (fun r : ℝ => ((t:ℝ)-(s:ℝ))*r) (𝓝[>] (0:ℝ)) (𝓝[>] (0:ℝ)) := by
+    apply tendsto_nhdsWithin_iff.mpr
+    constructor
+    · have hmul : Continuous (fun r : ℝ => ((t:ℝ)-(s:ℝ))*r) :=
+        continuous_const.mul continuous_id
+      have hh : Tendsto (fun r : ℝ => ((t:ℝ)-(s:ℝ))*r) (𝓝 (0:ℝ)) (𝓝 0) := by
+        simpa only [mul_zero] using hmul.tendsto 0
+      exact hh.mono_left nhdsWithin_le_nhds
+    · filter_upwards [self_mem_nhdsWithin] with r hr
+      exact mul_pos hd hr
+  exact (initialDrivingValue_spec p hi h0 hH s (hst.trans ht)).comp hc
+
+noncomputable def mappedFutureArc (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 := if (u:ℝ)=0 then (initialDrivingValue p hi h0 hH s (hst.trans ht):ℂ)
+    else mappedFutureRaw p hi h0 hH s t u
+  continuous_toFun := (continuousOn_fill_endpoint
+    (fun _ hr => mappedFutureRaw_continuousAt p hi h0 hH hst ht hr)
+    (mappedFutureRaw_tendsto p hi h0 hH hst ht)).comp_continuous continuous_subtype_val
+      (fun u => u.property)
+
+@[simp] lemma mappedFutureArc_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) :
+    mappedFutureArc p hi h0 hH hst ht 0=
+      (initialDrivingValue p hi h0 hH s (hst.trans ht):ℂ) := by
+  change (if (0:ℝ)=0 then _ else _)=_
+  exact ite_eq_left rfl
+
+lemma mappedFutureArc_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) :
+    mappedFutureArc p hi h0 hH hst ht u∈upperHalfPlane := by
+  have hp : 0<(u:ℝ) := unitInterval.pos_iff_ne_zero.mpr hu
+  have hc : (u:ℝ)≠0 := ne_of_gt hp
+  change (if (u:ℝ)=0 then _ else _)∈upperHalfPlane
+  rw [ite_eq_right hc]
+  exact initialForwardChart_mem_upper p hi h0 hH s
+    (slitFuturePoint_mem_domain p hi hH s (future_scaled_offset hst ht ⟨hp,u.property.2⟩))
+
+end SLEExactGauge
+
+end
+
+end OAI
diff --git a/lean/OAI/Probability/SLE/Loewner/MappedFutureRange.lean b/lean/OAI/Probability/SLE/Loewner/MappedFutureRange.lean
new file mode 100644
index 0000000000000000000000000000000000000000..78a53cf9645715b44f4629106db0ef3b2e503c99
--- /dev/null
+++ b/lean/OAI/Probability/SLE/Loewner/MappedFutureRange.lean
@@ -0,0 +1,86 @@
+import OAI.Probability.SLE.Geometry.CenteredFutureSlit
+
+namespace OAI
+
+/-! The mapped future arc has exactly the expected physical segment as
+its interior range. -/
+noncomputable section
+open Set Filter Function Complex
+open scoped Topology
+
+namespace SLEExactGauge
+
+lemma point_after_prefix_mem_domain (p : C(unitInterval,ℂ)) (hi : Injective p)
+    (hH : ∀ t : unitInterval, t≠0 → p t∈upperHalfPlane)
+    {s v : unitInterval} (hsv : s<v) : p v∈upperHalfPlane \ range (initialSubarc p s) := by
+  refine ⟨hH v (ne_of_gt (lt_of_le_of_lt bot_le hsv)),?_⟩
+  rw [initialSubarc_range]
+  rintro ⟨u,hu,he⟩
+  exact (not_le_of_gt hsv) (hi he ▸ hu.2)
+
+lemma mappedFutureArc_segment (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) :
+    mappedFutureArc p hi h0 hH hst ht u=
+      initialForwardChart p hi h0 hH s (p (slitSegmentParameter s t hst.le u)) := by
+  rw [mappedFutureArc_of_ne_zero p hi h0 hH hst ht hu]
+  unfold mappedFutureRaw
+  rw [slitSegmentParameter_eq_future hst ht hu]
+
+theorem mappedFutureArc_range_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)
+    {w : ℂ} (hw : w∈upperHalfPlane) :
+    w∈range (mappedFutureArc p hi h0 hH hst ht) ↔
+      ∃ v∈Ioc s t, initialForwardChart p hi h0 hH s (p v)=w := by
+  constructor
+  · rintro ⟨u,hu⟩
+    have hu0 : u≠0 := by
+      intro he
+      subst u
+      rw [mappedFutureArc_zero] at hu
+      rw [← hu] at hw
+      change 0<(_ : ℂ).im at hw
+      simp only [ofReal_im,lt_self_iff_false] at hw
+    exact ⟨slitSegmentParameter s t hst.le u,
+      ⟨slitSegmentParameter_gt hst hu0,slitSegmentParameter_le s t hst.le u⟩,
+      (mappedFutureArc_segment p hi h0 hH hst ht hu0).symm.trans hu⟩
+  · rintro ⟨v,hv,he⟩
+    obtain ⟨u,hu,hparam⟩ := exists_slitSegmentParameter hst hv
+    refine ⟨u,?_⟩
+    rw [mappedFutureArc_segment p hi h0 hH hst ht hu,hparam]
+    exact he
+
+theorem initialForward_avoids_future_iff (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)
+    {z : ℂ} (hz : z∈upperHalfPlane \ range (initialSubarc p s)) :
+    initialForwardChart p hi h0 hH s z∉range (mappedFutureArc p hi h0 hH hst ht) ↔
+      z∉range (initialSubarc p t) := by
+  rw [mappedFutureArc_range_upper p hi h0 hH hst ht
+    (initialForwardChart_mem_upper p hi h0 hH s hz)]
+  constructor
+  · intro hno hzt
+    rw [initialSubarc_range] at hzt
+    obtain ⟨v,hv,he⟩ := hzt
+    have hsv : s<v := by
+      by_contra hn
+      apply hz.2
+      rw [initialSubarc_range]
+      exact ⟨v,⟨bot_le,le_of_not_gt hn⟩,he⟩
+    exact hno ⟨v,⟨hsv,hv.2⟩,congrArg (initialForwardChart p hi h0 hH s) he⟩
+  · rintro hno ⟨v,hv,he⟩
+    have hd := point_after_prefix_mem_domain p hi hH hv.1
+    have hp := congrArg (initialInverseChart p hi h0 hH s) he
+    rw [initialInverse_forward_at p hi h0 hH s hd,
+      initialInverse_forward_at p hi h0 hH s hz] at hp
+    apply hno
+    rw [initialSubarc_range]
+    exact ⟨v,⟨bot_le,hv.2⟩,hp⟩
+
+end SLEExactGauge
+
+end
+
+end OAI
diff --git a/lean/OAI/Probability/SLE/Loewner/MappedFutureSimple.lean b/lean/OAI/Probability/SLE/Loewner/MappedFutureSimple.lean
new file mode 100644
index 0000000000000000000000000000000000000000..50b2b80301b37fbbf782a6a368549745f2d13cee
--- /dev/null
+++ b/lean/OAI/Probability/SLE/Loewner/MappedFutureSimple.lean
@@ -0,0 +1,61 @@
+import OAI.Probability.SLE.Loewner.MappedFutureArc
+
+namespace OAI
+
+/-! The future chart does not identify distinct points of the prescribed
+arc, including its newly filled real endpoint. -/
+noncomputable section
+open Set Filter Function Complex
+open scoped Topology
+
+namespace SLEExactGauge
+
+lemma mappedFutureArc_of_ne_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)
+    {u : unitInterval} (hu : u≠0) :
+    mappedFutureArc p hi h0 hH hst ht u=mappedFutureRaw p hi h0 hH s t u := by
+  have hc : (u:ℝ)≠0 := ne_of_gt (unitInterval.pos_iff_ne_zero.mpr hu)
+  exact ite_eq_right hc
+
+theorem mappedFutureArc_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 (mappedFutureArc p hi h0 hH hst ht) := by
+  intro u v he
+  by_cases hu : u=0
+  · subst u
+    by_contra hv
+    have hpos := mappedFutureArc_upper p hi h0 hH hst ht (Ne.symm hv)
+    rw [← he,mappedFutureArc_zero] at hpos
+    change 0<(_ : ℂ).im at hpos
+    simp only [ofReal_im,lt_self_iff_false] at hpos
+  by_cases hv : v=0
+  · subst v
+    have hpos := mappedFutureArc_upper p hi h0 hH hst ht hu
+    rw [he,mappedFutureArc_zero] at hpos
+    change 0<(_ : ℂ).im at hpos
+    simp only [ofReal_im,lt_self_iff_false] at hpos
+  have hur : (u:ℝ)∈Ioc (0:ℝ) 1 := ⟨unitInterval.pos_iff_ne_zero.mpr hu,u.property.2⟩
+  have hvr : (v:ℝ)∈Ioc (0:ℝ) 1 := ⟨unitInterval.pos_iff_ne_zero.mpr hv,v.property.2⟩
+  have huD := slitFuturePoint_mem_domain p hi hH s (future_scaled_offset hst ht hur)
+  have hvD := slitFuturePoint_mem_domain p hi hH s (future_scaled_offset hst ht hvr)
+  rw [mappedFutureArc_of_ne_zero p hi h0 hH hst ht hu,
+    mappedFutureArc_of_ne_zero p hi h0 hH hst ht hv] at he
+  have hp := congrArg (initialInverseChart p hi h0 hH s) he
+  change initialInverseChart p hi h0 hH s (initialForwardChart p hi h0 hH s _) =
+    initialInverseChart p hi h0 hH s (initialForwardChart p hi h0 hH s _) at hp
+  rw [initialInverse_forward_at p hi h0 hH s huD,
+    initialInverse_forward_at p hi h0 hH s hvD] at hp
+  have hparam := congrArg (fun a : unitInterval => (a:ℝ)) (hi hp)
+  rw [slitFutureParameter_coe s (future_scaled_offset hst ht hur),
+    slitFutureParameter_coe s (future_scaled_offset hst ht hvr)] at hparam
+  apply Subtype.ext
+  have hd : (t:ℝ)-(s:ℝ)≠0 := ne_of_gt (sub_pos.mpr (show (s:ℝ)<(t:ℝ) from hst))
+  exact mul_left_cancel₀ hd (add_left_cancel hparam)
+
+end SLEExactGauge
+
+end
+
+end OAI
diff --git a/lean/OAI/Probability/SLE/Loewner/MovingForwardBoundaryHeight.lean b/lean/OAI/Probability/SLE/Loewner/MovingForwardBoundaryHeight.lean
new file mode 100644
index 0000000000000000000000000000000000000000..709708393bd5828ef0f13e1e056cfa9d4a7aed5f
--- /dev/null
+++ b/lean/OAI/Probability/SLE/Loewner/MovingForwardBoundaryHeight.lean
@@ -0,0 +1,76 @@
+import OAI.Probability.SLE.Loewner.InitialInverseJointContinuity
+import OAI.Probability.SLE.Loewner.SlitUniformForwardBound
+import OAI.Probability.SLE.Loewner.FutureSlitDomain
+
+namespace OAI
+
+/-! Bounded moving forward coordinates can only approach the real line
+when their physical point reaches the limiting slit boundary. -/
+noncomputable section
+open Set Filter Function Complex Metric
+open scoped Topology
+
+namespace SLEExactGauge
+
+lemma initialForward_uniform_near (p : C(unitInterval,ℂ)) (hi : Injective p)
+    (h0 : p 0=0) (hH : ∀ t : unitInterval, t≠0 → p t∈upperHalfPlane)
+    {R : ℝ} (hR : 0<R) (hp : ∀ t : unitInterval, ‖p t‖<R)
+    (s : unitInterval) {z : ℂ} (hz : z∈upperHalfPlane \ range (initialSubarc p s))
+    (hzR : ‖z‖≤2*R) :
+    ‖initialForwardChart p hi h0 hH s z‖≤(512*Real.pi+9)*R := by
+  by_cases hs : s=0
+  · subst s
+    rw [initialForwardChart_zero]
+    change ‖z‖≤_
+    nlinarith [Real.pi_pos]
+  · rw [initialForwardChart,dite_eq_right hs]
+    exact (initialSlitChart p hi h0 hH s hs).forward_uniform_near
+      (initialSubarc_injective hi hs) (by simpa only [initialSubarc_zero] using h0)
+      (initialSubarc_upper hH hs) hR (fun u => hp _) hz hzR
+
+theorem initialForward_boundary_height_zero (p : C(unitInterval,ℂ)) (hi : Injective p)
+    (h0 : p 0=0) (hH : ∀ t : unitInterval, t≠0 → p t∈upperHalfPlane)
+    {t : ℕ → unitInterval} {s : unitInterval} {z : ℕ → ℂ} {b : ℂ}
+    (ht : Tendsto t atTop (𝓝 s)) (hz : Tendsto z atTop (𝓝 b))
+    (hzd : ∀ n, z n∈upperHalfPlane \ range (initialSubarc p (t n)))
+    (hb : b∉upperHalfPlane \ range (initialSubarc p s))
+    {M : ℝ} (hM : ∀ n, ‖initialForwardChart p hi h0 hH (t n) (z n)‖≤M) :
+    Tendsto (fun n => (initialForwardChart p hi h0 hH (t n) (z n)).im) atTop (𝓝 0) := by
+  apply tendsto_of_subseq_tendsto
+  intro φ hφ
+  obtain ⟨w,_,ψ,hψ,hw⟩ := (isCompact_closedBall (0:ℂ) M).tendsto_subseq (fun n => by
+    rw [mem_closedBall_zero_iff]
+    exact hM (φ n))
+  have hwim : 0≤w.im := ge_of_tendsto (continuous_im.continuousAt.tendsto.comp hw)
+    (Eventually.of_forall fun n =>
+      (show 0<(initialForwardChart p hi h0 hH (t (φ (ψ n))) (z (φ (ψ n)))).im from
+        initialForwardChart_mem_upper p hi h0 hH _ (hzd _)).le)
+  have hwzero : w.im=0 := by
+    by_contra hne
+    have hwH : w∈upperHalfPlane := lt_of_le_of_ne hwim (Ne.symm hne)
+    have htu := (ht.comp hφ).comp hψ.tendsto_atTop
+    have hwu : Tendsto (fun n => (⟨initialForwardChart p hi h0 hH (t (φ (ψ n)))
+        (z (φ (ψ n))),initialForwardChart_mem_upper p hi h0 hH _ (hzd _)⟩ : upperHalfPlane))
+        atTop (𝓝 (⟨w,hwH⟩ : upperHalfPlane)) := by
+      apply tendsto_subtype_rng.mpr
+      exact hw
+    have hback := ((initialInverseChart_joint_continuous p hi h0 hH).tendsto
+      (s,(⟨w,hwH⟩ : upperHalfPlane))).comp (htu.prodMk_nhds hwu)
+    have he : initialInverseChart p hi h0 hH s w=b := by
+      apply tendsto_nhds_unique hback
+      have hzu := (hz.comp hφ).comp hψ.tendsto_atTop
+      apply hzu.congr
+      intro n
+      exact (initialInverse_forward_at p hi h0 hH _ (hzd _)).symm
+    exact hb (he ▸ initialInverseChart_mem_domain p hi h0 hH s hwH)
+  refine ⟨ψ,?_⟩
+  have hh := continuous_im.continuousAt.tendsto.comp hw
+  change Tendsto (fun n => (initialForwardChart p hi h0 hH (t (φ (ψ n)))
+    (z (φ (ψ n)))).im) atTop (𝓝 w.im) at hh
+  rwa [hwzero] at hh
+
+end SLEExactGauge
+
+end
+
+end OAI
diff --git a/lean/OAI/Probability/SLE/Loewner/OpenSurvivalLifetime.lean b/lean/OAI/Probability/SLE/Loewner/OpenSurvivalLifetime.lean
new file mode 100644
index 0000000000000000000000000000000000000000..ffa14bcd01fec6314751a915084a36b6c759b377
--- /dev/null
+++ b/lean/OAI/Probability/SLE/Loewner/OpenSurvivalLifetime.lean
@@ -0,0 +1,40 @@
+import Mathlib
+
+namespace OAI
+
+/-! The finite lifetime of a downward-closed survival condition with
+strict continuation at each surviving time. -/
+noncomputable section
+open Set
+
+namespace SLEExactGauge
+
+lemma exists_open_survival_lifetime (p : ℝ → Prop) (hzero : p 0)
+    (hdown : ∀ s t, 0 ≤ s → s ≤ t → p t → p s)
+    (hext : ∀ t, 0 ≤ t → p t → ∃ s, t < s ∧ p s)
+    {T : ℝ} (hT : 0 ≤ T) (hdead : ¬p T) :
+    ∃ τ : ℝ, 0 < τ ∧ τ ≤ T ∧ ∀ t, 0 ≤ t → (p t ↔ t < τ) := by
+  let S : Set ℝ := {t | 0 ≤ t ∧ p t}
+  have hSne : S.Nonempty := ⟨0,le_rfl,hzero⟩
+  have hbound (s : ℝ) (hs : s ∈ S) : s ≤ T := by
+    by_contra hn
+    exact hdead (hdown T s hT (lt_of_not_ge hn).le hs.2)
+  have hSb : BddAbove S := ⟨T,hbound⟩
+  obtain ⟨s,hs,hsp⟩ := hext 0 le_rfl hzero
+  have hsS : s ∈ S := ⟨hs.le,hsp⟩
+  have hτp : 0 < sSup S := hs.trans_le (le_csSup hSb hsS)
+  refine ⟨sSup S,hτp,csSup_le hSne hbound,?_⟩
+  intro t ht
+  constructor
+  · intro hpt
+    obtain ⟨s,hts,hps⟩ := hext t ht hpt
+    exact hts.trans_le (le_csSup hSb ⟨ht.trans hts.le,hps⟩)
+  · intro hlt
+    obtain ⟨s,hsS,hts⟩ := exists_lt_of_lt_csSup hSne hlt
+    exact hdown t s ht hts.le hsS.2
+
+end SLEExactGauge
+
+end
+
+end OAI
diff --git a/lean/OAI/Probability/SLE/Loewner/PositiveReverseUniqueness.lean b/lean/OAI/Probability/SLE/Loewner/PositiveReverseUniqueness.lean
new file mode 100644
index 0000000000000000000000000000000000000000..613459d27da48c255fabd84174b5e7067555f3f1
--- /dev/null
+++ b/lean/OAI/Probability/SLE/Loewner/PositiveReverseUniqueness.lean
@@ -0,0 +1,49 @@
+import OAI.Probability.SLE.LoewnerReflection
+
+namespace OAI
+
+/-! Ordinary uniqueness after both reverse trajectories have positive height. -/
+noncomputable section
+open Set Filter Complex
+open scoped Topology
+
+namespace SLEExactGauge
+
+theorem positive_reverse_unique {a T : ℝ} (haT : a ≤ T)
+    (q r : ℝ → ℂ) (u : ℝ → ℝ)
+    (hqc : ContinuousOn q (Icc a T)) (hrc : ContinuousOn r (Icc a T))
+    (hq : ∀ t ∈ Ico a T, HasDerivWithinAt q
+      (-2/(q t-(u t : ℂ))) (Ici t) t)
+    (hr : ∀ t ∈ Ico a T, HasDerivWithinAt r
+      (-2/(r t-(u t : ℂ))) (Ici t) t)
+    (hqp : ∀ t ∈ Icc a T, 0 < (q t).im)
+    (hrp : ∀ t ∈ Icc a T, 0 < (r t).im)
+    (hinit : q a=r a) : ∀ t ∈ Icc a T, q t=r t := by
+  obtain ⟨s,hs,hsm⟩ := isCompact_Icc.exists_isMinOn (nonempty_Icc.mpr haT)
+    (Complex.continuous_im.comp_continuousOn hqc)
+  obtain ⟨v,hv,hvm⟩ := isCompact_Icc.exists_isMinOn (nonempty_Icc.mpr haT)
+    (Complex.continuous_im.comp_continuousOn hrc)
+  let η : ℝ := min (q s).im (r v).im
+  have hη : 0 < η := lt_min (hqp s hs) (hrp v hv)
+  have hQ (t : ℝ) (ht : t ∈ Icc a T) : η ≤ (q t).im :=
+    (min_le_left _ _).trans (hsm ht)
+  have hR (t : ℝ) (ht : t ∈ Icc a T) : η ≤ (r t).im :=
+    (min_le_right _ _).trans (hvm ht)
+  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 ht
+  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 ht
+  have hh := dist_le_of_trajectories_ODE (fun t => reverseField_lipschitz hη (u t))
+    hqc hdQ hrc hdR (show dist (q a) (r a) ≤ 0 by rw [hinit]; simp)
+  intro t ht
+  exact dist_le_zero.mp (by simpa only [zero_mul] using hh t ht)
+
+end SLEExactGauge
+
+end
+
+end OAI
diff --git a/lean/OAI/Probability/SLE/Loewner/PositiveSlitCapacity.lean b/lean/OAI/Probability/SLE/Loewner/PositiveSlitCapacity.lean
new file mode 100644
index 0000000000000000000000000000000000000000..b87af3f52a55ad09114597f97d7287c868a436d0
--- /dev/null
+++ b/lean/OAI/Probability/SLE/Loewner/PositiveSlitCapacity.lean
@@ -0,0 +1,49 @@
+import OAI.Probability.SLE.Loewner.SlitCapacityChart
+import OAI.Probability.SLE.Mass.HalfPlaneZeroMass
+
+namespace OAI
+
+/-! Every nontrivial simple attached slit has strictly positive capacity.
+The proof rules out a zero-mass inverse displacement. -/
+noncomputable section
+open Set Filter Complex Function Metric
+open scoped Topology
+
+namespace SLEExactGauge
+
+theorem simple_slit_exists_positive_capacity_chart
+    (p : C(unitInterval,ℂ)) (hi : Injective p) (h0 : p 0=0)
+    (hH : ∀ t : unitInterval, t ≠ 0 → p t ∈ upperHalfPlane) :
+    ∃ (G F : ℂ → ℂ) (c : ℝ), 0<c ∧
+      BijOn G (upperHalfPlane \ range p) upperHalfPlane ∧
+      DifferentiableOn ℂ G (upperHalfPlane \ range p) ∧
+      DifferentiableOn ℂ F upperHalfPlane ∧
+      MapsTo F upperHalfPlane (upperHalfPlane \ range p) ∧
+      (∀ z ∈ upperHalfPlane \ range p, F (G z)=z) ∧
+      (∀ z ∈ upperHalfPlane, G (F z)=z) ∧
+      Tendsto (fun z : ℂ => z*(G z-z)) (cocompact ℂ) (𝓝 (c:ℂ)) ∧
+      Tendsto (fun z : ℂ => F z/z) (cocompact ℂ ⊓ 𝓟 upperHalfPlane) (𝓝 1) ∧
+      (∀ z ∈ upperHalfPlane \ range p, (G z).im ≤ z.im) := by
+  obtain ⟨G,F,c,hc,hG,hdG,hdF,hmF,hl,hr,hcoef,hn,hheight⟩ :=
+    simple_slit_exists_nonnegative_capacity_chart p hi h0 hH
+  have hcpos : 0<c := by
+    by_contra hnot
+    have hc0 : c=0 := le_antisymm (le_of_not_gt hnot) hc
+    have hFcoef := inverse_hydrodynamic_coefficient hcoef hn hr
+    rw [hc0,ofReal_zero,neg_zero] at hFcoef
+    have hnonneg (z : ℂ) (hz : z ∈ upperHalfPlane) : 0 ≤ (F z-z).im := by
+      have hh := normalized_halfPlane_height hdF (hmF.mono_right sdiff_subset) hn hz
+      simpa only [sub_im] using sub_nonneg.mpr hh
+    have he := holomorphic_zero_hydrodynamic_mass (hdF.sub differentiableOn_id) hnonneg hFcoef
+    have hp1 : p 1 ∈ upperHalfPlane := hH 1 (by norm_num)
+    have hF1 : F (p 1)=p 1 := sub_eq_zero.mp (he (p 1) hp1)
+    have hm := hmF hp1
+    rw [hF1] at hm
+    exact hm.2 (mem_range_self 1)
+  exact ⟨G,F,c,hcpos,hG,hdG,hdF,hmF,hl,hr,hcoef,hn,hheight⟩
+
+end SLEExactGauge
+
+end
+
+end OAI
diff --git a/lean/OAI/Probability/SLE/Loewner/RadiusHalfPlaneHull.lean b/lean/OAI/Probability/SLE/Loewner/RadiusHalfPlaneHull.lean
new file mode 100644
index 0000000000000000000000000000000000000000..ed6c1839940432670907add550fde324bb304c03
--- /dev/null
+++ b/lean/OAI/Probability/SLE/Loewner/RadiusHalfPlaneHull.lean
@@ -0,0 +1,72 @@
+import OAI.Probability.SLE.Loewner.PositiveSlitCapacity
+
+namespace OAI
+
+/-! The explicit normalized chart of an upper half disk. Comparing with
+this chart bounds the capacity of a small slit. -/
+noncomputable section
+open Set Filter Complex Function Metric
+open scoped Topology
+
+namespace SLEExactGauge
+
+def exteriorUpperRadius (R : ℝ) : Set ℂ := {z | R<‖z‖ ∧ z ∈ upperHalfPlane}
+
+def radiusHullMap (R : ℝ) (z : ℂ) : ℂ := (R:ℂ)*exteriorJoukowski (z/(R:ℂ))
+
+lemma divide_radius_bijOn {R : ℝ} (hR : 0<R) :
+    BijOn (fun z : ℂ => z/(R:ℂ)) (exteriorUpperRadius R) exteriorUpperDisk := by
+  have hR0 : (R:ℂ) ≠ 0 := ofReal_ne_zero.mpr hR.ne'
+  have hnorm : ‖(R:ℂ)‖=R := by simp only [Complex.norm_real,Real.norm_eq_abs,abs_of_pos hR]
+  refine ⟨?_,?_,?_⟩
+  · intro z hz
+    refine ⟨?_,?_⟩
+    · rw [norm_div,hnorm,lt_div_iff₀ hR,one_mul]
+      exact hz.1
+    · change 0 < (z/(R:ℂ)).im
+      rw [div_ofReal_im]
+      exact div_pos hz.2 hR
+  · intro z _ w _ he
+    exact (div_left_inj' hR0).mp he
+  · intro z hz
+    refine ⟨(R:ℂ)*z,⟨?_,?_⟩,?_⟩
+    · rw [norm_mul,hnorm]
+      nlinarith [hz.1]
+    · change 0 < ((R:ℂ)*z).im
+      simpa only [mul_im,ofReal_re,ofReal_im,zero_mul,add_zero] using mul_pos hR hz.2
+    · field_simp
+
+lemma radiusHullMap_bijOn {R : ℝ} (hR : 0<R) :
+    BijOn (radiusHullMap R) (exteriorUpperRadius R) upperHalfPlane := by
+  have hh := (positive_real_affine_halfPlane hR 0).comp
+    (exteriorJoukowski_bijOn.comp (divide_radius_bijOn hR))
+  apply hh.congr
+  intro z _
+  simp only [radiusHullMap,Function.comp_apply,ofReal_zero,sub_zero]
+
+lemma radiusHullMap_formula {R : ℝ} (hR : 0<R) (z : ℂ) :
+    radiusHullMap R z=z+(R:ℂ)^2/z := by
+  by_cases hz : z=0
+  · simp [radiusHullMap,exteriorJoukowski,hz]
+  · dsimp only [radiusHullMap,exteriorJoukowski]
+    field_simp [ofReal_ne_zero.mpr hR.ne',hz]
+
+lemma radiusHullMap_differentiableOn {R : ℝ} (hR : 0<R) :
+    DifferentiableOn ℂ (radiusHullMap R) (exteriorUpperRadius R) := by
+  have hd : DifferentiableOn ℂ (fun z : ℂ => z/(R:ℂ)) (exteriorUpperRadius R) :=
+    differentiableOn_id.div_const _
+  exact (exteriorJoukowski_differentiableOn.comp hd (divide_radius_bijOn hR).mapsTo).const_mul _
+
+lemma radiusHullMap_coefficient {R : ℝ} (hR : 0<R) :
+    Tendsto (fun z : ℂ => z*(radiusHullMap R z-z)) (cocompact ℂ) (𝓝 ((R:ℂ)^2)) := by
+  apply tendsto_const_nhds.congr'
+  filter_upwards [(isCompact_singleton (x := (0:ℂ))).compl_mem_cocompact] with z hz
+  rw [radiusHullMap_formula hR,add_sub_cancel_left]
+  have hz0 : z ≠ 0 := hz
+  field_simp [hz0]
+
+end SLEExactGauge
+
+end
+
+end OAI
diff --git a/lean/OAI/Probability/SLE/Loewner/RadiusHullInverse.lean b/lean/OAI/Probability/SLE/Loewner/RadiusHullInverse.lean
new file mode 100644
index 0000000000000000000000000000000000000000..760f5a29c53903541d222aaa4d91970403be6054
--- /dev/null
+++ b/lean/OAI/Probability/SLE/Loewner/RadiusHullInverse.lean
@@ -0,0 +1,86 @@
+import OAI.Probability.SLE.Loewner.RadiusHalfPlaneHull
+
+namespace OAI
+
+/-! The inverse of the explicit half-disk chart is normalized at infinity
+and stays within the radius of its argument. -/
+noncomputable section
+open Set Filter Complex Function Metric
+open scoped Topology
+
+namespace SLEExactGauge
+
+noncomputable def radiusHullInverse (R : ℝ) : ℂ → ℂ :=
+  invFunOn (radiusHullMap R) (exteriorUpperRadius R)
+
+lemma radiusHullInverse_mapsTo {R : ℝ} (hR : 0<R) :
+    MapsTo (radiusHullInverse R) upperHalfPlane (exteriorUpperRadius R) :=
+  (radiusHullMap_bijOn hR).surjOn.mapsTo_invFunOn
+
+lemma radiusHullMap_inverse {R : ℝ} (hR : 0<R) {z : ℂ} (hz : z ∈ upperHalfPlane) :
+    radiusHullMap R (radiusHullInverse R z)=z :=
+  (radiusHullMap_bijOn hR).surjOn.rightInvOn_invFunOn hz
+
+lemma radiusHullInverse_differentiableOn {R : ℝ} (hR : 0<R) :
+    DifferentiableOn ℂ (radiusHullInverse R) upperHalfPlane := by
+  have ho : IsOpen (exteriorUpperRadius R) :=
+    (isOpen_lt continuous_const continuous_norm).inter isOpen_upperHalfPlane
+  simpa only [radiusHullInverse,(radiusHullMap_bijOn hR).image_eq] using
+    (radiusHullMap_differentiableOn hR).invFunOn ho (radiusHullMap_bijOn hR).injOn
+
+lemma radiusHullInverse_displacement {R : ℝ} (hR : 0<R) {z : ℂ} (hz : z ∈ upperHalfPlane) :
+    ‖radiusHullInverse R z-z‖≤R := by
+  have hm := radiusHullInverse_mapsTo hR hz
+  have hnorm : 0<‖radiusHullInverse R z‖ := hR.trans hm.1
+  have hh := radiusHullMap_inverse hR hz
+  rw [radiusHullMap_formula hR] at hh
+  have he : radiusHullInverse R z-z = -((R:ℂ)^2/radiusHullInverse R z) := by
+    linear_combination hh
+  rw [he,norm_neg,norm_div,norm_pow,Complex.norm_real,Real.norm_eq_abs,abs_of_pos hR]
+  apply (div_le_iff₀ hnorm).mpr
+  nlinarith [hm.1]
+
+lemma ratio_one_of_bounded_displacement {F : ℂ → ℂ} {R : ℝ}
+    (hF : ∀ z ∈ upperHalfPlane, ‖F z-z‖≤R) :
+    Tendsto (fun z : ℂ => F z/z) (cocompact ℂ ⊓ 𝓟 upperHalfPlane) (𝓝 1) := by
+  have hi : Tendsto (fun z : ℂ => z⁻¹) (cocompact ℂ ⊓ 𝓟 upperHalfPlane) (𝓝 0) := by
+    have hh : Tendsto (fun z : ℂ => z⁻¹) (cocompact ℂ) (𝓝 0) := by
+      simpa only [Metric.cobounded_eq_cocompact] using
+        (tendsto_inv₀_cobounded : Tendsto (fun z : ℂ => z⁻¹) (Bornology.cobounded ℂ) (𝓝 0))
+    exact hh.mono_left inf_le_left
+  have hbound : ∀ᶠ z in cocompact ℂ ⊓ 𝓟 upperHalfPlane,
+      ‖(F z-z)/z‖≤R*‖z⁻¹‖ := by
+    rw [eventually_inf_principal]
+    apply Eventually.of_forall
+    intro z hz
+    rw [norm_div,norm_inv,div_eq_mul_inv]
+    exact mul_le_mul_of_nonneg_right (hF z hz) (inv_nonneg.mpr (norm_nonneg _))
+  have hlim : Tendsto (fun z : ℂ => R*‖z⁻¹‖)
+      (cocompact ℂ ⊓ 𝓟 upperHalfPlane) (𝓝 0) := by
+    simpa only [norm_zero,mul_zero] using hi.norm.const_mul R
+  have hn := squeeze_zero' (Eventually.of_forall (fun z : ℂ => norm_nonneg ((F z-z)/z))) hbound hlim
+  have hz : Tendsto (fun z : ℂ => (F z-z)/z)
+      (cocompact ℂ ⊓ 𝓟 upperHalfPlane) (𝓝 0) := tendsto_zero_iff_norm_tendsto_zero.mpr hn
+  have hh := hz.const_add 1
+  simp only [add_zero] at hh
+  apply hh.congr'
+  change ∀ᶠ z in cocompact ℂ ⊓ 𝓟 upperHalfPlane, 1 + (F z-z)/z = F z/z
+  rw [eventually_inf_principal]
+  apply Eventually.of_forall
+  intro z hzH
+  have hz0 : z ≠ 0 := by
+    intro he
+    simp only [upperHalfPlane,mem_ofPred_eq,he,zero_im,lt_self_iff_false] at hzH
+  field_simp [hz0]
+  ring
+
+lemma radiusHullInverse_normalized {R : ℝ} (hR : 0<R) :
+    Tendsto (fun z : ℂ => radiusHullInverse R z/z)
+      (cocompact ℂ ⊓ 𝓟 upperHalfPlane) (𝓝 1) :=
+  ratio_one_of_bounded_displacement (fun _ hz => radiusHullInverse_displacement hR hz)
+
+end SLEExactGauge
+
+end
+
+end OAI
diff --git a/lean/OAI/Probability/SLE/Loewner/RawBoundaryReverseTrace.lean b/lean/OAI/Probability/SLE/Loewner/RawBoundaryReverseTrace.lean
new file mode 100644
index 0000000000000000000000000000000000000000..8082ea32f723a264b1badc92c5eb928bae6e452a
--- /dev/null
+++ b/lean/OAI/Probability/SLE/Loewner/RawBoundaryReverseTrace.lean
@@ -0,0 +1,47 @@
+import OAI.Probability.SLE.Loewner.RawBoundaryTraceIdentification
+import OAI.Probability.SLE.Loewner.InitialConeFromInterval
+
+namespace OAI
+
+/-! Every continuous positive reverse solution issuing from the driver
+ends at the prescribed raw trace. The cone estimate is derived. -/
+noncomputable section
+open Set Filter Complex
+open scoped Topology NNReal
+
+namespace SLEExactGauge.Target
+
+theorem boundary_reverse_eq_trace
+    (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 ∈ Ioc 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 u (s : ℝ) := driverValue b ((T : ℝ)-s)
+  have hreflect (s : ℝ) (hs : s ∈ Icc 0 (T : ℝ)) :
+      (T : ℝ)-s ∈ Icc 0 (T : ℝ) :=
+    ⟨sub_nonneg.mpr hs.2,sub_le_self _ hs.1⟩
+  have hu (s : ℝ) (hs : s ∈ Icc 0 (T : ℝ)) : HasDerivWithinAt u
+      (-b' ((T : ℝ)-s)) (Icc 0 (T : ℝ)) s := by
+    have hi : HasDerivWithinAt (fun t : ℝ => (T : ℝ)-t) (-1) (Icc 0 (T : ℝ)) s := by
+      simpa using ((hasDerivAt_id s).const_sub (T : ℝ)).hasDerivWithinAt
+    convert! (hd _ (hreflect s hs)).comp s hi hreflect using 1
+    simp only [mul_neg,mul_one]
+  have hzero : q 0=(u 0 : ℂ) := by simpa [u,driverValue] using hq0
+  obtain ⟨c,hc,hcT,hcone⟩ := exists_initial_reverse_cone_of_interval_derivative
+    (show 0 < (T : ℝ) from hT) hL q u (fun t => -b' ((T : ℝ)-t)) hqc hu hzero hq hqp
+    (fun t ht => by simpa only [abs_neg] using hb _ (hreflect t ht))
+  obtain ⟨a,ha,hac,hsmall⟩ := exists_smooth_window c hc L
+  exact boundary_reverse_eq_trace_of_cone b T b' hd hL hb ha (hac.trans hcT) hsmall
+    q hqc hq0 hq hqp (fun t ht => hcone t ⟨ht.1,ht.2.trans hac⟩)
+
+end SLEExactGauge.Target
+
+end
+
+end OAI
diff --git a/lean/OAI/Probability/SLE/Loewner/RawBoundaryTraceIdentification.lean b/lean/OAI/Probability/SLE/Loewner/RawBoundaryTraceIdentification.lean
new file mode 100644
index 0000000000000000000000000000000000000000..972b71ea263cce35cbcf7a3e6318eb84249b834a
--- /dev/null
+++ b/lean/OAI/Probability/SLE/Loewner/RawBoundaryTraceIdentification.lean
@@ -0,0 +1,69 @@
+import OAI.Probability.SLE.Geometry.BoundaryRadialDistance
+import OAI.Probability.SLE.Loewner.SmoothRawTrace
+
+namespace OAI
+
+/-! A positive reverse solution that starts at the driver and satisfies
+the local cone estimate ends at the exact raw trace. -/
+noncomputable section
+open Set Filter Complex
+open scoped Topology NNReal
+
+namespace SLEExactGauge.Target
+
+theorem boundary_reverse_eq_trace_of_cone
+    (b : Driver) (T : ℝ≥0) (b' : ℝ → ℝ)
+    (hd : ∀ t ∈ Icc 0 (T : ℝ), HasDerivWithinAt (driverValue b)
+      (b' t) (Icc 0 (T : ℝ)) t)
+    {L a : ℝ} (hL : 0 ≤ L) (hb : ∀ t ∈ Icc 0 (T : ℝ), |b' t| ≤ L)
+    (ha : 0 < a) (haT : a ≤ T) (hsmall : L^2*a ≤ 1)
+    (q : ℝ → ℂ) (hqc : ContinuousOn q (Icc 0 (T : ℝ)))
+    (hq0 : q 0=(b T : ℂ))
+    (hq : ∀ t ∈ Ioc 0 (T : ℝ), HasDerivWithinAt q
+      (-2/(q t-(driverValue b ((T : ℝ)-t) : ℂ))) (Ici t) t)
+    (hqp : ∀ t ∈ Ioc 0 (T : ℝ), 0 < (q t).im)
+    (hcone : ∀ t ∈ Icc 0 a,
+      ((q t).re-driverValue b ((T : ℝ)-t))^2 ≤ t ∧ 3*t ≤ (q t).im^2) :
+    q T=trace 1 b T := by
+  let u (s : ℝ) := driverValue b ((T : ℝ)-s)
+  have hreflect (s : ℝ) (hs : s ∈ Icc 0 (T : ℝ)) :
+      (T : ℝ)-s ∈ Icc 0 (T : ℝ) :=
+    ⟨sub_nonneg.mpr hs.2,sub_le_self _ hs.1⟩
+  have hu (s : ℝ) (hs : s ∈ Icc 0 (T : ℝ)) : HasDerivWithinAt u
+      (-b' ((T : ℝ)-s)) (Icc 0 (T : ℝ)) s := by
+    have hi : HasDerivWithinAt (fun t : ℝ => (T : ℝ)-t) (-1) (Icc 0 (T : ℝ)) s := by
+      simpa using ((hasDerivAt_id s).const_sub (T : ℝ)).hasDerivWithinAt
+    convert! (hd _ (hreflect s hs)).comp s hi hreflect using 1
+    simp only [mul_neg,mul_one]
+  obtain ⟨K,_hK,hbound⟩ := exists_boundary_radial_distance_constant ha haT hL hsmall
+    q u (fun t => -b' ((T : ℝ)-t)) hqc hq hqp hcone hu
+    (fun t ht => by simpa only [abs_neg] using hb _ (hreflect t ht))
+  have hdist (y : ℝ) (hy : 0 < y) :
+      dist (q T) (inverseFlow 1 b T ((b T : ℂ)+(y : ℂ)*I)) ≤ y*K := by
+    let w : ℂ := (b T : ℂ)+(y : ℂ)*I
+    have hw : w ∈ upperHalfPlane := by simpa [w,upperHalfPlane] using hy
+    obtain ⟨r,hr0,hrp,hrd,hrT⟩ := exists_raw_reverse_trajectory b T w hw
+    have he := hbound r (fun t ht => hrd t ht.1)
+      (fun t ht => hy.trans_le (by simpa [w] using hrp t ht.1))
+      (by simp [hr0,w,u,driverValue])
+    have hzero : dist (q 0) (r 0)=y := by
+      rw [hq0,hr0,dist_comm,dist_eq_norm]
+      simp [w,abs_of_pos hy]
+    rw [hzero,← hrT] at he
+    exact he
+  have hlim := tendsto_inverseFlow_smooth_trace b T b' hd hL hb
+  have hdistlim : Tendsto
+      (fun y : ℝ => dist (q T) (inverseFlow 1 b T ((b T : ℂ)+(y : ℂ)*I)))
+      (𝓝[>] 0) (𝓝 (dist (q T) (trace 1 b T))) := tendsto_const_nhds.dist hlim
+  have hzero : Tendsto (fun y : ℝ => y*K) (𝓝[>] 0) (𝓝 (0 : ℝ)) := by
+    simpa only [id_eq,zero_mul] using
+      ((tendsto_id : Tendsto (id : ℝ → ℝ) (𝓝 0) (𝓝 0)).mono_left nhdsWithin_le_nhds).mul_const K
+  apply dist_le_zero.mp
+  exact le_of_tendsto_of_tendsto hdistlim hzero
+    (by filter_upwards [self_mem_nhdsWithin] with y hy; exact hdist y hy)
+
+end SLEExactGauge.Target
+
+end
+
+end OAI
diff --git a/lean/OAI/Probability/SLE/Loewner/RawConstantTailInverse.lean b/lean/OAI/Probability/SLE/Loewner/RawConstantTailInverse.lean
new file mode 100644
index 0000000000000000000000000000000000000000..ca5e45edcf2df8122f9392ed43c170b94f79f31c
--- /dev/null
+++ b/lean/OAI/Probability/SLE/Loewner/RawConstantTailInverse.lean
@@ -0,0 +1,103 @@
+import OAI.Probability.SLE.Loewner.RawSurvivingDerivative
+import OAI.Probability.SLE.Loewner.RawSurvivingMonotone
+import OAI.Probability.SLE.Loewner.SlitTimeGluing
+import OAI.Probability.SLE.Loewner.LinearReverseTrajectory
+
+namespace OAI
+
+/-! The inverse after a constant-driver tail is the translated vertical
+inverse followed by the inverse at the joining time. -/
+noncomputable section
+open Set Filter Function Complex
+open scoped Topology NNReal
+
+namespace SLEExactGauge.Target
+
+theorem inverseFlow_constant_tail (b : Driver) (A S : ℝ≥0) (u : ℝ)
+    (hb : ∀ t : ℝ≥0, A ≤ t → b t=u) {w : ℂ} (hw : w∈upperHalfPlane) :
+    inverseFlow 1 b (A+S) w=
+      inverseFlow 1 b A ((u:ℂ)+inverseFlow 1 (linearDriver 0) S (w-(u:ℂ))) := by
+  let c := linearDriver 0
+  let v := inverseFlow 1 c S (w-(u:ℂ))
+  have hw' : w-(u:ℂ)∈upperHalfPlane := by simpa [upperHalfPlane] using hw
+  have hvS : Surviving 1 c v S := inverseFlow_surviving 1 (by norm_num) c S _ hw'
+  have hvH : v∈upperHalfPlane := surviving_mem_upperHalfPlane 1 c v S S.coe_nonneg hvS
+  have hvend : flow 1 c v S=w-(u:ℂ) := flow_inverseFlow 1 (by norm_num) c S _ hw'
+  let z := inverseFlow 1 b A ((u:ℂ)+v)
+  have hqH : (u:ℂ)+v∈upperHalfPlane := by simpa [upperHalfPlane] using hvH
+  have hzA : Surviving 1 b z A := inverseFlow_surviving 1 (by norm_num) b A _ hqH
+  have hzH : z∈upperHalfPlane := surviving_mem_upperHalfPlane 1 b z A A.coe_nonneg hzA
+  have hzjoin : flow 1 b z A=(u:ℂ)+v := flow_inverseFlow 1 (by norm_num) b A _ hqH
+  let f := flow 1 b z
+  let g := fun t : ℝ => (u:ℂ)+flow 1 c v (t-(A:ℝ))
+  let Y := fun t : ℝ => if t ≤ (A:ℝ) then f t else g t
+  have hjoin : f A=g A := by
+    dsimp [f,g]
+    rw [sub_self,flow_zero 1 c v hvH]
+    exact hzjoin
+  have hleft (t : ℝ) (ht : t ≤ A) : Y t=f t := ite_eq_left ht
+  have hright (t : ℝ) (ht : A ≤ t) : Y t=g t := by
+    by_cases ht' : t ≤ A
+    · have he : t=A := le_antisymm ht' ht
+      simpa only [he,Y,ite_eq_left le_rfl] using hjoin
+    · exact ite_eq_right ht'
+  have hd (t : ℝ) (ht : t∈Icc 0 ((A+S:ℝ≥0):ℝ)) :
+      HasDerivWithinAt Y (2/(Y t-(b t.toNNReal:ℂ))) (Ici 0) t := by
+    apply hasDerivWithinAt_time_splice f g A t _ hjoin
+    · intro htA
+      have hs := surviving_of_le_time 1 b z ht.1 htA hzA
+      have hh := flow_hasDerivWithinAt_of_survival b z ht.1 hs
+      simpa only [←hleft t htA,f] using hh
+    · intro hAt
+      have hts : 0 ≤ t-(A:ℝ) := sub_nonneg.mpr hAt
+      have htsS : t-(A:ℝ) ≤ S := by
+        have hh : t ≤ (A:ℝ)+(S:ℝ) := by simpa only [NNReal.coe_add] using ht.2
+        linarith
+      have hs := surviving_of_le_time 1 c v hts htsS hvS
+      have hh := flow_hasDerivWithinAt_of_survival c v hts hs
+      have hlin : HasDerivWithinAt (fun t : ℝ => t-(A:ℝ)) 1 (Ici (A:ℝ)) t :=
+        ((hasDerivAt_id t).sub_const (A:ℝ)).hasDerivWithinAt
+      have hm : MapsTo (fun t : ℝ => t-(A:ℝ)) (Ici (A:ℝ)) (Ici 0) :=
+        fun t ht => show 0 ≤ t-(A:ℝ) from sub_nonneg.mpr ht
+      have hh' := (hh.scomp t hlin hm).const_add (u:ℂ)
+      have hbt : b t.toNNReal=u := hb _ (by rwa [Real.le_toNNReal_iff_coe_le ht.1])
+      have hct : c (t-(A:ℝ)).toNNReal=0 := by simp [c]
+      simp only [one_smul,hct] at hh'
+      have hhg : HasDerivWithinAt g (2/(flow 1 c v (t-(A:ℝ))-(0:ℂ))) (Ici (A:ℝ)) t := by
+        simpa only [Function.comp_def,ofReal_zero,g] using hh'
+      apply hhg.congr_deriv
+      rw [hright t hAt,hbt]
+      dsimp only [g]
+      ring
+  have hYc : ContinuousOn Y (Icc 0 ((A+S:ℝ≥0):ℝ)) :=
+    fun t ht => ((hd t ht).mono Icc_subset_Ici_self).continuousWithinAt
+  have hYpos (t : ℝ) (ht : t∈Icc 0 ((A+S:ℝ≥0):ℝ)) : 0<(Y t).im := by
+    by_cases htA : t ≤ A
+    · rw [hleft t htA]
+      exact surviving_flow_mem_upperHalfPlane 1 b z t ht.1
+        (surviving_of_le_time 1 b z ht.1 htA hzA)
+    · have hAt : A ≤ t := (le_of_not_ge htA)
+      rw [hright t hAt]
+      have hts : 0 ≤ t-(A:ℝ) := sub_nonneg.mpr hAt
+      have htsS : t-(A:ℝ) ≤ S := by
+        have hh : t ≤ (A:ℝ)+(S:ℝ) := by simpa only [NNReal.coe_add] using ht.2
+        linarith
+      have hp := surviving_flow_mem_upperHalfPlane 1 c v _ hts
+        (surviving_of_le_time 1 c v hts htsS hvS)
+      simpa only [g,add_im,ofReal_im,zero_add] using (show 0<(flow 1 c v (t-(A:ℝ))).im from hp)
+  obtain ⟨r,hr,hrmin⟩ := isCompact_Icc.exists_isMinOn
+    (nonempty_Icc.mpr (A+S).coe_nonneg) (Complex.continuous_im.comp_continuousOn hYc)
+  have hY0 : Y 0=z := by rw [hleft 0 A.coe_nonneg]; exact flow_zero 1 b z hzH
+  have hraw := flow_eq_of_positive_trajectory 1 b z (A+S) (A+S).coe_nonneg Y hYc hY0
+    (Y r).im (hYpos r hr) (fun t ht => hrmin ht) (fun t ht => by
+      simpa only [a,div_one,Complex.ofReal_ofNat,driverValue] using
+        (hd t (Ico_subset_Icc_self ht)).mono (Ici_subset_Ici.mpr ht.1))
+  apply inverseFlow_eq_of_surviving 1 b (A+S) (A+S).coe_nonneg z w hraw.1
+  rw [hraw.2,hright _ (by simp)]
+  simp only [g,add_sub_cancel_left,hvend,add_sub_cancel]
+
+end SLEExactGauge.Target
+
+end
+
+end OAI
diff --git a/lean/OAI/Probability/SLE/Loewner/RawConstantTailTrace.lean b/lean/OAI/Probability/SLE/Loewner/RawConstantTailTrace.lean
new file mode 100644
index 0000000000000000000000000000000000000000..da6acb67ef05122bc16083bbd685978506e8873a
--- /dev/null
+++ b/lean/OAI/Probability/SLE/Loewner/RawConstantTailTrace.lean
@@ -0,0 +1,46 @@
+import OAI.Probability.SLE.Loewner.RawConstantTailInverse
+import OAI.Probability.SLE.Loewner.SmoothRawTraceInterior
+import OAI.Probability.SLE.Loewner.SmoothRawTrace
+
+namespace OAI
+
+/-! A constant driving tail produces the vertical slit transported by
+the inverse chart at its starting time. -/
+noncomputable section
+open Set Filter Function Complex
+open scoped Topology NNReal
+
+namespace SLEExactGauge.Target
+
+theorem trace_constant_tail (b : Driver) (A S : ℝ≥0) (hS : 0<S) (u : ℝ)
+    (hb : ∀ t : ℝ≥0, A ≤ t → b t=u) :
+    trace 1 b (A+S)=inverseFlow 1 b A ((u:ℂ)+trace 1 (linearDriver 0) S) := by
+  have hd : ∀ t∈Icc 0 (S:ℝ), HasDerivWithinAt (driverValue (linearDriver 0)) 0
+      (Icc 0 (S:ℝ)) t := fun t ht => (linearDriver_derivative 0 t ht.1).mono Icc_subset_Ici_self
+  have hlim := tendsto_inverseFlow_smooth_trace (linearDriver 0) S (fun _ => 0) hd
+    (show (0:ℝ) ≤ 0 from le_rfl) (fun _ _ => by simp)
+  have hpos : trace 1 (linearDriver 0) S∈upperHalfPlane :=
+    smooth_raw_trace_mem_upperHalfPlane (linearDriver 0) S hS (fun _ => 0) hd
+      (show (0:ℝ) ≤ 0 from le_rfl) (fun _ _ => by simp)
+  have hq : (u:ℂ)+trace 1 (linearDriver 0) S∈upperHalfPlane := by
+    change 0<((u:ℂ)+trace 1 (linearDriver 0) S).im
+    simpa only [add_im,ofReal_im,zero_add] using
+      (show 0<(trace 1 (linearDriver 0) S).im from hpos)
+  have hF : ContinuousAt (inverseFlow 1 b A) ((u:ℂ)+trace 1 (linearDriver 0) S) :=
+    (continuousOn_inverseFlow 1 (by norm_num) b A).continuousAt (isOpen_upperHalfPlane.mem_nhds hq)
+  have hright := hF.tendsto.comp (tendsto_const_nhds.add hlim)
+  have hleft : Tendsto (fun y : ℝ => inverseFlow 1 b (A+S) ((u:ℂ)+(y:ℂ)*I))
+      (𝓝[>] (0:ℝ)) (𝓝 (inverseFlow 1 b A ((u:ℂ)+trace 1 (linearDriver 0) S))) := by
+    apply hright.congr'
+    filter_upwards [self_mem_nhdsWithin] with y hy
+    have hw : (u:ℂ)+(y:ℂ)*I∈upperHalfPlane := by simpa [upperHalfPlane] using hy
+    rw [inverseFlow_constant_tail b A S u hb hw]
+    simp only [linearDriver_apply,zero_mul,ofReal_zero,zero_add,add_sub_cancel_left,Function.comp_def]
+  have he : b (A+S)=u := hb _ (le_add_of_nonneg_right zero_le)
+  simpa only [trace,one_mul,driverValue,←NNReal.coe_add,Real.toNNReal_coe,he] using hleft.limUnder_eq
+
+end SLEExactGauge.Target
+
+end
+
+end OAI
diff --git a/lean/OAI/Probability/SLE/Loewner/RawDiskAngleTail.lean b/lean/OAI/Probability/SLE/Loewner/RawDiskAngleTail.lean
new file mode 100644
index 0000000000000000000000000000000000000000..6212f745a29c43f1d5c15cd3e7ff8e9881a071a2
--- /dev/null
+++ b/lean/OAI/Probability/SLE/Loewner/RawDiskAngleTail.lean
@@ -0,0 +1,61 @@
+import OAI.Probability.SLE.Loewner.RawDiskRadiusLaw
+
+namespace OAI
+
+/-! The finite centered disk success probability is a measurable function
+of its initial angle, so it can be tested against the actual angle law. -/
+noncomputable section
+open Set _root_.MeasureTheory _root_.OAI.MeasureTheory
+open scoped Topology NNReal ENNReal
+
+namespace SLEExactGauge.Multipoint
+local instance angleTailMeasurable : MeasurableSpace C(ℝ≥0,ℝ) := borel _
+local instance angleTailBorel : BorelSpace C(ℝ≥0,ℝ) := ⟨rfl⟩
+
+def RawCanonicalMass.angleDiskTail (R : RawCanonicalMass)
+    (ν : Measure C(ℝ≥0,ℝ)) (κ b v θ : ℝ) : ℝ≥0∞ :=
+  (ν.withDensity (fun p => canonicalFiniteDensity κ (v,Target.diskMapInv θ 0,p)))
+    {p | b ≤ R.diskAtRadius κ θ v p}
+
+lemma RawCanonicalMass.angleDiskTail_measurable (R : RawCanonicalMass)
+    (ν : Measure C(ℝ≥0,ℝ)) [SFinite ν] (κ b v : ℝ) :
+    Measurable (R.angleDiskTail ν κ b v) := by
+  let E : Set (ℝ × C(ℝ≥0,ℝ)) := {q | b ≤ R.diskAtRadius κ q.1 v q.2}
+  let D : ℝ × C(ℝ≥0,ℝ) → ℝ≥0∞ := fun q =>
+    canonicalFiniteDensity κ (v,Target.diskMapInv q.1 0,q.2)
+  have hE : MeasurableSet E := measurableSet_le measurable_const
+    (R.diskAtRadius_measurable κ Prod.fst (fun _ => v) measurable_fst measurable_const
+      Prod.snd measurable_snd)
+  have hz : Measurable (fun θ => Target.diskMapInv θ 0) := by
+    unfold Target.diskMapInv
+    fun_prop
+  have hD : Measurable D := (canonicalFiniteDensity_measurable κ).comp
+    (measurable_const.prodMk ((hz.comp measurable_fst).prodMk measurable_snd))
+  have hK := (hD.indicator hE).lintegral_prod_right' (ν := ν)
+  have he (θ : ℝ) : (∫⁻ p, E.indicator D (θ,p) ∂ν)=R.angleDiskTail ν κ b v θ := by
+    have hEθ : MeasurableSet {p | b ≤ R.diskAtRadius κ θ v p} :=
+      measurableSet_le measurable_const
+        (R.diskAtRadius_measurable κ (fun _ => θ) (fun _ => v)
+          measurable_const measurable_const id measurable_id)
+    change (∫⁻ p, {p | b ≤ R.diskAtRadius κ θ v p}.indicator
+      (fun p => D (θ,p)) p ∂ν)=_
+    rw [lintegral_indicator hEθ,← withDensity_apply _ hEθ]
+    rfl
+  simpa only [he] using hK
+
+lemma RawCanonicalMass.angleDiskTail_average (R : RawCanonicalMass)
+    (ν : Measure C(ℝ≥0,ℝ)) [SFinite ν] (κ : ℝ) (hκ : 0 < κ) (b v : ℝ) :
+    (∫⁻ θ, R.angleDiskTail ν κ b v θ ∂Target.angleLaw κ)=
+      rawCenteredDiskLaw ν κ v {q | b ≤ R.diskAtRadius κ q.1 v q.2} := by
+  symm
+  exact measure_joint_tail_of_lintegral (rawCenteredDiskLaw ν κ v) (Target.angleLaw κ)
+    (fun θ => ν.withDensity (fun p => canonicalFiniteDensity κ (v,Target.diskMapInv θ 0,p)))
+    (rawCenteredDiskLaw_lintegral ν κ hκ v) _
+    (R.diskAtRadius_measurable κ Prod.fst (fun _ => v) measurable_fst measurable_const
+      Prod.snd measurable_snd) b
+
+end SLEExactGauge.Multipoint
+
+end
+
+end OAI
diff --git a/lean/OAI/Probability/SLE/Loewner/RawDiskRadiusLaw.lean b/lean/OAI/Probability/SLE/Loewner/RawDiskRadiusLaw.lean
new file mode 100644
index 0000000000000000000000000000000000000000..a4849cdc36c2cf088530566deccc599bffbf1377
--- /dev/null
+++ b/lean/OAI/Probability/SLE/Loewner/RawDiskRadiusLaw.lean
@@ -0,0 +1,142 @@
+import OAI.Probability.SLE.Geometry.CanonicalDiskTails
+import OAI.Probability.SLE.Gauge.CanonicalDenseSections
+import OAI.Probability.SLE.Geometry.ProductDensity
+
+namespace OAI
+
+/-! The disk variable on raw driver space has exactly the finite centered
+law used in the prescribed moment coefficients and tail budget. -/
+noncomputable section
+open Set Filter _root_.MeasureTheory _root_.OAI.MeasureTheory ProbabilityTheory
+open scoped Topology NNReal ENNReal
+
+namespace SLEExactGauge.Multipoint
+local instance rawDiskRadiusMeasurable : MeasurableSpace C(ℝ≥0,ℝ) := borel _
+local instance rawDiskRadiusBorel : BorelSpace C(ℝ≥0,ℝ) := ⟨rfl⟩
+
+def RawCanonicalMass.diskAtRadius (R : RawCanonicalMass) (κ θ u : ℝ)
+    (p : C(ℝ≥0,ℝ)) : ℝ :=
+  (diskMassValue κ θ (extendedCanonicalMass R.process R.terminal
+    (canonicalRadiusLevel κ (u,Target.diskMapInv θ 0,p)) p)).toReal
+
+lemma RawCanonicalMass.diskAtRadius_nonneg (R : RawCanonicalMass) (κ θ u : ℝ)
+    (p : C(ℝ≥0,ℝ)) : 0 ≤ R.diskAtRadius κ θ u p := ENNReal.toReal_nonneg
+
+lemma RawCanonicalMass.diskAtRadius_measurable
+    {Ξ : Type*} [MeasurableSpace Ξ] (R : RawCanonicalMass) (κ : ℝ)
+    (θ u : Ξ → ℝ) (hθ : Measurable θ) (hu : Measurable u)
+    (Y : Ξ → C(ℝ≥0,ℝ)) (hY : Measurable Y) :
+    Measurable (fun x => R.diskAtRadius κ (θ x) (u x) (Y x)) := by
+  have hz : Measurable (fun x => Target.diskMapInv (θ x) 0) := by
+    unfold Target.diskMapInv
+    fun_prop
+  exact (R.disk_at_parameter_measurable κ θ hθ Y hY _
+    (measurable_canonicalRadiusLevel_random_state κ hY hu hz)).ennreal_toReal
+
+variable {Ω : Type*} [MeasurableSpace Ω] {P : Measure Ω} {κ : ℝ}
+  {B : ℝ≥0 → Ω → ℝ} {hBm : Measurable (Function.uncurry B)}
+  {γ : Ω → ℝ≥0 → ℂ} {G : Ω → ℝ≥0 → ℂ → ℂ}
+  (C : CanonicalMass P κ B hBm γ G)
+  (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 ω)
+
+include C hc F hw R he in
+lemma CanonicalMass.raw_diskAtRadius_eq :
+    ∀ᵐ ω ∂P, ∀ θ u : ℝ, 0 ≤ u →
+      R.diskAtRadius κ θ u (sourceDriverPath B hc ω)=C.diskAtRadius θ u ω := by
+  filter_upwards [he] with ω hω
+  intro θ u hu
+  unfold RawCanonicalMass.diskAtRadius CanonicalMass.diskAtRadius
+  rw [canonicalRadiusLevel_eq κ (sourceDriverPath B hc ω) (hw ω) u hu]
+  unfold CanonicalMass.atTime extendedCanonicalMass
+  split_ifs <;> simp only [hω.1,hω.2]
+
+include C hc F hw R he in
+lemma CanonicalMass.raw_diskAtRadius_finiteCentered_tail [SFinite P]
+    (θ u b : ℝ) (hu : 0 ≤ u) :
+    ((P.map (sourceDriverPath B hc)).withDensity
+      (fun p => canonicalFiniteDensity κ (u,Target.diskMapInv θ 0,p)))
+      {p | b ≤ R.diskAtRadius κ θ u p} =
+      finiteCenteredLaw P κ B γ G (Target.diskMapInv θ 0) u
+        {ω | b ≤ C.diskAtRadius θ u ω} := by
+  have hm (s : ℝ≥0) : Measurable (B s) := hBm.comp (measurable_const.prodMk measurable_id)
+  rw [← canonical_finiteCenteredLaw_map P κ B hm hc γ G F (Eventually.of_forall hw) u hu]
+  have hA : MeasurableSet {p | b ≤ R.diskAtRadius κ θ u p} := by
+    exact measurableSet_le measurable_const
+      (R.diskAtRadius_measurable κ (fun _ => θ) (fun _ => u)
+        measurable_const measurable_const id measurable_id)
+  rw [Measure.map_apply (source_path_measurable _ hm) hA]
+  apply measure_congr
+  have habs : (finiteCenteredLaw P κ B γ G (Target.diskMapInv θ 0) u).AbsolutelyContinuous P :=
+    withDensity_absolutelyContinuous P _
+  filter_upwards [habs.ae_le (C.raw_diskAtRadius_eq hc F hw R he)] with ω hω
+  exact propext (by rw [mem_preimage,mem_ofPred_eq,hω θ u hu])
+
+end SLEExactGauge.Multipoint
+
+namespace SLEExactGauge
+local instance rawCenteredDiskMeasurable : MeasurableSpace C(ℝ≥0,ℝ) := borel _
+local instance rawCenteredDiskBorel : BorelSpace C(ℝ≥0,ℝ) := ⟨rfl⟩
+
+def rawCenteredDiskLaw (ν : Measure C(ℝ≥0,ℝ)) (κ u : ℝ) : Measure (ℝ × C(ℝ≥0,ℝ)) :=
+  ((Target.angleLaw κ).prod ν).withDensity
+    (fun p => canonicalFiniteDensity κ (u,Target.diskMapInv p.1 0,p.2))
+
+lemma rawCenteredDiskLaw_lintegral
+    (ν : Measure C(ℝ≥0,ℝ)) [SFinite ν] (κ : ℝ) (hκ : 0 < κ) (u : ℝ)
+    (f : ℝ × C(ℝ≥0,ℝ) → ℝ≥0∞) (hf : Measurable f) :
+    (∫⁻ p, f p ∂rawCenteredDiskLaw ν κ u) =
+      ∫⁻ θ, ∫⁻ p, f (θ,p) ∂ν.withDensity
+        (fun p => canonicalFiniteDensity κ (u,Target.diskMapInv θ 0,p)) ∂Target.angleLaw κ := by
+  let : IsProbabilityMeasure (Target.angleLaw κ) := Target.angleLaw_isProbability hκ
+  have hd : Measurable (fun p : ℝ × C(ℝ≥0,ℝ) =>
+      canonicalFiniteDensity κ (u,Target.diskMapInv p.1 0,p.2)) := by
+    apply (canonicalFiniteDensity_measurable κ).comp
+    apply measurable_const.prodMk
+    apply Measurable.prodMk
+    · unfold Target.diskMapInv
+      fun_prop
+    · exact measurable_snd
+  exact product_withDensity_lintegral (Target.angleLaw κ) ν _ hd f hf
+
+
+namespace Multipoint.CanonicalMass
+variable {Ω : Type*} [MeasurableSpace Ω] {P : Measure Ω} [IsProbabilityMeasure P] {κ : ℝ}
+  {B : ℝ≥0 → Ω → ℝ} {hBm : Measurable (Function.uncurry B)}
+  {γ : Ω → ℝ≥0 → ℂ} {G : Ω → ℝ≥0 → ℂ → ℂ}
+
+lemma raw_centeredDiskTail_eq
+    (C : CanonicalMass P κ B hBm γ G)
+    (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 ω)
+    (u b : ℝ) (hu : 0 ≤ u) :
+    rawCenteredDiskLaw (P.map (sourceDriverPath B hc)) κ u
+      {p | b ≤ R.diskAtRadius κ p.1 u p.2} = C.centeredDiskTail hc b u := by
+  have hm (s : ℝ≥0) : Measurable (B s) := hBm.comp (measurable_const.prodMk measurable_id)
+  let : IsProbabilityMeasure (P.map (sourceDriverPath B hc)) :=
+    (Measure.isProbabilityMeasure_map_iff (source_path_measurable _ hm).aemeasurable).mpr inferInstance
+  rw [measure_joint_tail_of_lintegral _ (Target.angleLaw κ)
+    (fun θ => (P.map (sourceDriverPath B hc)).withDensity
+      (fun p => canonicalFiniteDensity κ (u,Target.diskMapInv θ 0,p)))
+    (rawCenteredDiskLaw_lintegral _ κ hκ u) _
+    (R.diskAtRadius_measurable κ Prod.fst (fun _ => u) measurable_fst measurable_const
+      Prod.snd measurable_snd) b,
+    C.centeredDiskTail_eq_integral hc hκ F hw b u hu]
+  apply lintegral_congr
+  intro θ
+  exact C.raw_diskAtRadius_finiteCentered_tail hc F hw R he θ u b hu
+
+end Multipoint.CanonicalMass
+end SLEExactGauge
+
+end
+
+end OAI
diff --git a/lean/OAI/Probability/SLE/Loewner/RawFixedRestart.lean b/lean/OAI/Probability/SLE/Loewner/RawFixedRestart.lean
new file mode 100644
index 0000000000000000000000000000000000000000..5a404632c7319e1325e020f7dfde531f9db1bec4
--- /dev/null
+++ b/lean/OAI/Probability/SLE/Loewner/RawFixedRestart.lean
@@ -0,0 +1,53 @@
+import OAI.Probability.SLE.Mass.PositiveMassContinuity
+import OAI.Probability.SLE.Mass.CanonicalMassRestart
+import OAI.Probability.SLE.Mass.RawScaledMassPaths
+
+namespace OAI
+
+/-! Any fixed raw realization with the full-law path certificate restarts
+through the actual inverse map. This keeps the raw functional used by scaling. -/
+noncomputable section
+open Set Filter _root_.MeasureTheory _root_.OAI.MeasureTheory ProbabilityTheory
+open scoped Topology NNReal ENNReal CompactlySupported
+
+namespace SLEExactGauge.Multipoint
+local instance rawFixedRestartMeasurable : MeasurableSpace C(ℝ≥0,ℝ) := borel _
+local instance rawFixedRestartBorel : BorelSpace C(ℝ≥0,ℝ) := ⟨rfl⟩
+
+lemma CanonicalMass.raw_fixed_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))) :
+    ∀ᵐ ω ∂P, ∀ t, C.process (τ ω+t) ω-C.process (τ ω) ω =
+      stoppedFreshMass B κ γ G F hw τ hc R t ω := by
+  have hm (s : ℝ≥0) : Measurable (B s) := hBm.comp (measurable_const.prodMk measurable_id)
+  have hFresh := fresh_capacity_witness_exists hB hm hc hpublished τ hτ
+  have hfin := C.stoppedFreshTerminalMass_ae_finite_on_compacts hB hc hκ F hw τ hτ R
+    (he.mono fun _ h => h.2) hpublished
+  have hraw := sourceRestart_mem_full_driver_set hB hm hc τ hτ E hE hEf
+  have hp := stoppedFreshMass_paths B κ γ G F hw τ hc R hm hτ hκ
+    (hraw.mono fun _ h => by
+      have hr := hEp _ h
+      exact ⟨hr.zero,hr.monotone,hr.continuous_real_tests,hr.dominated⟩) hfin
+  exact C.stoppedFreshMass_indistinguishable hB hc hκ F hw R he τ hτ hFresh hp
+
+end SLEExactGauge.Multipoint
+
+end
+
+end OAI
diff --git a/lean/OAI/Probability/SLE/Loewner/RawForwardCoordinates.lean b/lean/OAI/Probability/SLE/Loewner/RawForwardCoordinates.lean
new file mode 100644
index 0000000000000000000000000000000000000000..9eabad818e8a54d067aa7cfd01e0d39d1529c9c6
--- /dev/null
+++ b/lean/OAI/Probability/SLE/Loewner/RawForwardCoordinates.lean
@@ -0,0 +1,49 @@
+import OAI.Probability.SLE.Loewner.RawForwardHeight
+
+namespace OAI
+
+/-! Exact real coordinate equations before a raw survival lifetime. -/
+noncomputable section
+open Set Filter Complex
+open scoped Topology
+
+namespace SLEExactGauge.Target
+
+lemma flow_coordinate_derivatives (b : Driver) (z : ℂ) {t S : ℝ}
+    (ht : 0 ≤ t) (htS : t < S) (hs : Surviving 1 b z S) :
+    HasDerivWithinAt (fun s => (flow 1 b z s).re)
+      (2*((flow 1 b z t).re-driverValue b t)/
+        (((flow 1 b z t).re-driverValue b t)^2+(flow 1 b z t).im^2)) (Ici t) t ∧
+    HasDerivWithinAt (fun s => (flow 1 b z s).im)
+      (-2*(flow 1 b z t).im/
+        (((flow 1 b z t).re-driverValue b t)^2+(flow 1 b z t).im^2)) (Ici t) t := by
+  have hd := (flow_hasDerivWithinAt_of_later_survival 1 b z t S ht htS hs).mono
+    (Ici_subset_Ici.mpr ht)
+  have hr := Complex.reCLM.hasFDerivAt.comp_hasDerivWithinAt t hd
+  have hi := Complex.imCLM.hasFDerivAt.comp_hasDerivWithinAt t hd
+  change HasDerivWithinAt (fun s => (flow 1 b z s).re)
+    (((a 1 : ℂ)/(flow 1 b z t-(driverValue b t : ℂ))).re) (Ici t) t at hr
+  change HasDerivWithinAt (fun s => (flow 1 b z s).im)
+    (((a 1 : ℂ)/(flow 1 b z t-(driverValue b t : ℂ))).im) (Ici t) t at hi
+  constructor
+  · convert! hr using 1
+    simp [a,Complex.div_re,Complex.normSq_apply,pow_two]
+  · convert! hi using 1
+    simp [a,Complex.div_im,Complex.normSq_apply,pow_two]
+    ring
+
+lemma flow_continuousOn_before_lifetime (b : Driver) (z : ℂ) {τ : ℝ}
+    (hs : ∀ t ∈ Ico 0 τ, Surviving 1 b z t) :
+    ContinuousOn (flow 1 b z) (Ico 0 τ) := by
+  intro t ht
+  let S : ℝ := (t+τ)/2
+  have htS : t < S := by dsimp [S]; linarith [ht.2]
+  have hSτ : S < τ := by dsimp [S]; linarith [ht.2]
+  exact (flow_hasDerivWithinAt_of_later_survival 1 b z t S ht.1 htS
+    (hs S ⟨ht.1.trans htS.le,hSτ⟩)).continuousWithinAt.mono Ico_subset_Ici_self
+
+end SLEExactGauge.Target
+
+end
+
+end OAI
diff --git a/lean/OAI/Probability/SLE/Loewner/RawForwardHeight.lean b/lean/OAI/Probability/SLE/Loewner/RawForwardHeight.lean
new file mode 100644
index 0000000000000000000000000000000000000000..32e70ff46bdf427293737632be4f6c8ab7779bc3
--- /dev/null
+++ b/lean/OAI/Probability/SLE/Loewner/RawForwardHeight.lean
@@ -0,0 +1,53 @@
+import OAI.Probability.SLE.Angle.TargetFlowEvolution
+import OAI.Probability.SLE.Loewner.RawSurvivingMonotone
+
+namespace OAI
+
+/-! Continuity and height monotonicity of the exact raw forward flow on
+each surviving interval, without a geometric trace witness. -/
+noncomputable section
+open Set Filter Complex
+open scoped Topology
+
+namespace SLEExactGauge.Target
+
+lemma flow_continuousOn_of_survival (κ : ℝ) (b : Driver) (z : ℂ)
+    {T : ℝ} (hT : 0 ≤ T) (hs : Surviving κ b z T) :
+    ContinuousOn (flow κ b z) (Icc 0 T) := by
+  obtain ⟨j,hj,hmin⟩ := hs
+  apply ((cutoffFlow_continuousOn κ b j hj z).mono Icc_subset_Ici_self).congr
+  intro t ht
+  exact flow_eq_cutoff_on_interval κ b z T hT j hj hmin t ht
+
+lemma flow_height_antitone_of_survival (b : Driver) (z : ℂ)
+    {T : ℝ} (hT : 0 ≤ T) (hs : Surviving 1 b z T) :
+    AntitoneOn (fun t => (flow 1 b z t).im) (Icc 0 T) := by
+  have hc := Complex.continuous_im.comp_continuousOn (flow_continuousOn_of_survival 1 b z hT hs)
+  have hd (t : ℝ) (ht : t ∈ interior (Icc 0 T)) :
+      HasDerivWithinAt (fun s => (flow 1 b z s).im)
+        (-2*(flow 1 b z t).im/Complex.normSq (flow 1 b z t-(driverValue b t : ℂ)))
+        (interior (Icc 0 T)) t := by
+    have hti : t ∈ Ioo 0 T := by simpa only [interior_Icc] using ht
+    have hh := Complex.imCLM.hasFDerivAt.comp_hasDerivWithinAt t
+      (flow_hasDerivWithinAt_of_later_survival 1 b z t T hti.1.le hti.2 hs)
+    change HasDerivWithinAt (fun s => (flow 1 b z s).im)
+      (((a 1 : ℂ)/(flow 1 b z t-(driverValue b t : ℂ))).im) (Ici 0) t at hh
+    have he : ((a 1 : ℂ)/(flow 1 b z t-(driverValue b t : ℂ))).im =
+        -2*(flow 1 b z t).im/Complex.normSq (flow 1 b z t-(driverValue b t : ℂ)) := by
+      simp [a,Complex.div_im]
+      ring
+    rw [he] at hh
+    exact hh.mono (interior_subset.trans Icc_subset_Ici_self)
+  apply antitoneOn_of_hasDerivWithinAt_nonpos (convex_Icc _ _) hc hd
+  intro t ht
+  have hti : t ∈ Icc 0 T := interior_subset ht
+  have hp := surviving_flow_mem_upperHalfPlane 1 b z t hti.1
+    (surviving_of_le_time 1 b z hti.1 hti.2 hs)
+  exact div_nonpos_of_nonpos_of_nonneg
+    (mul_nonpos_of_nonpos_of_nonneg (by norm_num) hp.le) (Complex.normSq_nonneg _)
+
+end SLEExactGauge.Target
+
+end
+
+end OAI
diff --git a/lean/OAI/Probability/SLE/Loewner/RawForwardInfinity.lean b/lean/OAI/Probability/SLE/Loewner/RawForwardInfinity.lean
new file mode 100644
index 0000000000000000000000000000000000000000..f1492404842fbe7e1aeb3acd5a231f3f46e8dd75
--- /dev/null
+++ b/lean/OAI/Probability/SLE/Loewner/RawForwardInfinity.lean
@@ -0,0 +1,53 @@
+import OAI.Probability.SLE.Loewner.ForwardCapacityError
+import OAI.Probability.SLE.Loewner.RawForwardHeight
+
+namespace OAI
+
+/-! Hydrodynamic normalization of the raw forward map follows from its
+ODE on surviving trajectories, without a prior geometric witness. -/
+noncomputable section
+open Set Filter Complex
+open scoped Topology NNReal
+
+namespace SLEExactGauge.Target
+
+theorem flow_hydrodynamic_normalization (b : Driver) (T : ℝ≥0) :
+    Tendsto (fun z : ℂ => z*(flow 1 b z T-z))
+      (cocompact ℂ ⊓ 𝓟 {z | Surviving 1 b z T}) (𝓝 (2*(T : ℂ))) := by
+  have hc : Continuous (driverValue b) := b.continuous.comp continuous_real_toNNReal
+  obtain ⟨M,hM,hMb⟩ := (isCompact_Icc.image hc).isBounded.exists_pos_norm_lt
+  have hbound (t : ℝ) (ht : t ∈ Icc 0 (T : ℝ)) : |driverValue b t| ≤ M := by
+    simpa only [Real.norm_eq_abs] using (hMb _ (mem_image_of_mem _ ht)).le
+  have hfar (z : ℂ) (hz : Surviving 1 b z T)
+      (hlarge : 8*(M+(T : ℝ)+1) ≤ ‖z‖) :
+      ‖z*(flow 1 b z T-z)-2*(T : ℂ)‖ ≤ 4*(T : ℝ)*(M+T)/‖z‖ := by
+    have hzH := surviving_mem_upperHalfPlane 1 b z T T.coe_nonneg hz
+    apply forward_far_capacity_error T.coe_nonneg hM.le
+      (flow 1 b z) (driverValue b) z
+      (flow_continuousOn_of_survival 1 b z T.coe_nonneg hz) (flow_zero 1 b z hzH)
+      (fun t ht => ?_) hbound hlarge
+    let S : ℝ := (t+T)/2
+    have htS : t < S := by dsimp [S]; linarith [ht.2]
+    have hST : S ≤ T := by dsimp [S]; linarith [ht.2]
+    have hS : 0 ≤ S := ht.1.trans htS.le
+    have hh := (flow_hasDerivWithinAt_of_later_survival 1 b z t S ht.1 htS
+      (surviving_of_le_time 1 b z hS hST hz)).mono (Ici_subset_Ici.mpr ht.1)
+    simpa only [a,div_one,ofReal_ofNat] using hh
+  let l := cocompact ℂ ⊓ 𝓟 {z | Surviving 1 b z T}
+  have herr : Tendsto (fun z : ℂ => z*(flow 1 b z T-z)-2*(T : ℂ)) l (𝓝 0) := by
+    apply squeeze_zero_norm'
+    · change ∀ᶠ z in cocompact ℂ ⊓ 𝓟 {z | Surviving 1 b z T},
+        ‖z*(flow 1 b z T-z)-2*(T : ℂ)‖ ≤ 4*(T : ℝ)*(M+T)/‖z‖
+      rw [eventually_inf_principal]
+      filter_upwards [tendsto_norm_cocompact_atTop.eventually
+        (eventually_ge_atTop (8*(M+(T : ℝ)+1)))] with z hz
+      exact fun hsurvive => hfar z hsurvive hz
+    · exact tendsto_const_nhds.div_atTop
+        (tendsto_norm_cocompact_atTop.mono_left inf_le_left)
+  simpa only [sub_add_cancel,zero_add] using herr.add_const (2*(T : ℂ))
+
+end SLEExactGauge.Target
+
+end
+
+end OAI
diff --git a/lean/OAI/Probability/SLE/Loewner/RawHeightContinuation.lean b/lean/OAI/Probability/SLE/Loewner/RawHeightContinuation.lean
new file mode 100644
index 0000000000000000000000000000000000000000..cd748d2763a00d4ee7490a1df3f8cfbda2a648c6
--- /dev/null
+++ b/lean/OAI/Probability/SLE/Loewner/RawHeightContinuation.lean
@@ -0,0 +1,72 @@
+import OAI.Probability.SLE.Loewner.RawForwardHeight
+import OAI.Probability.SLE.Geometry.ComplexLipschitzExtension
+
+namespace OAI
+
+/-! A raw forward flow whose height stays uniformly positive survives
+the limiting finite time. -/
+noncomputable section
+open Set Filter Complex
+open scoped Topology
+
+namespace SLEExactGauge.Target
+
+theorem survives_of_uniform_height_before (b : Driver) (z : ℂ) (hz : z ∈ upperHalfPlane)
+    {T m : ℝ} (hT : 0 < T) (hm : 0 < m)
+    (hs : ∀ t ∈ Ico 0 T, Surviving 1 b z t)
+    (hh : ∀ t ∈ Ico 0 T, m ≤ (flow 1 b z t).im) :
+    Surviving 1 b z T := by
+  have hlater (t : ℝ) (ht : t ∈ Ico 0 T) :
+      HasDerivWithinAt (flow 1 b z)
+        ((a 1 : ℂ)/(flow 1 b z t-(driverValue b t : ℂ))) (Ici 0) t := by
+    let S : ℝ := (t+T)/2
+    have htS : t < S := by dsimp [S]; linarith [ht.2]
+    have hST : S < T := by dsimp [S]; linarith [ht.2]
+    exact flow_hasDerivWithinAt_of_later_survival 1 b z t S ht.1 htS
+      (hs S ⟨ht.1.trans htS.le,hST⟩)
+  have hd (t : ℝ) (ht : t ∈ Ico 0 T) : HasDerivWithinAt (flow 1 b z)
+      ((a 1 : ℂ)/(flow 1 b z t-(driverValue b t : ℂ))) (Ico 0 T) t :=
+    (hlater t ht).mono Ico_subset_Ici_self
+  have hnorm (t : ℝ) (ht : t ∈ Ico 0 T) :
+      ‖(a 1 : ℂ)/(flow 1 b z t-(driverValue b t : ℂ))‖ ≤ 2/m := by
+    have hden : m ≤ ‖flow 1 b z t-(driverValue b t : ℂ)‖ := by
+      calc
+        m ≤ (flow 1 b z t).im := hh t ht
+        _ ≤ |(flow 1 b z t-(driverValue b t : ℂ)).im| := by
+          simp only [Complex.sub_im,Complex.ofReal_im,sub_zero]
+          exact le_abs_self _
+        _ ≤ _ := Complex.abs_im_le_norm _
+    calc
+      _ = 2/‖flow 1 b z t-(driverValue b t : ℂ)‖ := by norm_num [norm_div,a]
+      _ ≤ 2/m := div_le_div_of_nonneg_left (by norm_num) hm hden
+  have hLip : LipschitzOnWith ⟨2/m,by positivity⟩ (flow 1 b z) (Ico 0 T) := by
+    apply (convex_Ico (0 : ℝ) T).lipschitzOnWith_of_nnnorm_hasDerivWithin_le hd
+    intro t ht
+    exact_mod_cast hnorm t ht
+  obtain ⟨g,hg,hge⟩ := exists_continuous_complex_extension (flow 1 b z) hLip
+  have hheight : ∀ t ∈ Icc 0 T, m ≤ (g t).im := by
+    have hc : IsClosed {t : ℝ | m ≤ (g t).im} :=
+      isClosed_le continuous_const (Complex.continuous_im.comp hg)
+    have hsub : Ico 0 T ⊆ {t : ℝ | m ≤ (g t).im} := by
+      intro t ht
+      change m ≤ (g t).im
+      rw [hge ht]
+      exact hh t ht
+    have hcsub := closure_minimal hsub hc
+    rw [closure_Ico hT.ne] at hcsub
+    exact fun t ht => hcsub ht
+  have hzero : g 0=z := (hge ⟨le_rfl,hT⟩).trans (flow_zero 1 b z hz)
+  apply surviving_of_positive_trajectory 1 b z T hT.le g hg.continuousOn hzero m hm hheight
+  intro t ht
+  have he : g =ᶠ[𝓝[Ici t] t] flow 1 b z := by
+    filter_upwards [self_mem_nhdsWithin,mem_nhdsWithin_of_mem_nhds (gt_mem_nhds ht.2)] with s hs hsT
+    exact hge ⟨ht.1.trans hs,hsT⟩
+  have hv := hge ht
+  have hh' := ((hlater t ht).mono (Ici_subset_Ici.mpr ht.1)).congr_of_eventuallyEq he hv
+  simpa only [← hv] using hh'
+
+end SLEExactGauge.Target
+
+end
+
+end OAI
diff --git a/lean/OAI/Probability/SLE/Loewner/RawInverseDriverApproximation.lean b/lean/OAI/Probability/SLE/Loewner/RawInverseDriverApproximation.lean
new file mode 100644
index 0000000000000000000000000000000000000000..015f08bb22514c175ab797b1702c809e942dc6f5
--- /dev/null
+++ b/lean/OAI/Probability/SLE/Loewner/RawInverseDriverApproximation.lean
@@ -0,0 +1,52 @@
+import OAI.Probability.SLE.Loewner.SmoothRawInverse
+import OAI.Probability.SLE.Loewner.LoewnerInverseStability
+
+namespace OAI
+
+/-! A geometric inverse witness approaches the raw inverse under a
+uniform driver perturbation. The reference driver needs no trace. -/
+noncomputable section
+open Set Filter Metric Complex
+open scoped Topology NNReal
+
+namespace SLEExactGauge
+
+theorem IsCapacityTwoWitness.raw_inverse_driver_distance
+    {U : ℝ≥0 → ℝ} {γ : ℝ≥0 → ℂ} {G F : ℝ≥0 → ℂ → ℂ}
+    (h : IsCapacityTwoWitness U γ G F) (b : Target.Driver) (T : ℝ≥0)
+    {a : ℝ} (ha : 0 < a) (w : ℂ) (haw : a ≤ w.im)
+    (δ : ℝ) (hUb : ∀ t ∈ Icc 0 T, |U t-b t| ≤ δ) :
+    dist (F T w) (Target.inverseFlow 1 b T w) ≤
+      gronwallBound 0 (4*a⁻¹^2) (2*a⁻¹^2*δ) T := by
+  obtain ⟨q,hq0,hheight,hqd,he⟩ := Target.exists_raw_reverse_trajectory b T w (ha.trans_le haw)
+  rw [he]
+  apply h.inverse_approximation_bound T ha w haw b δ hUb q hq0
+  intro s hs
+  have hh := (hqd s hs.1).mono (show Icc 0 (T : ℝ) ⊆ Ici 0 from Icc_subset_Ici_self)
+  have hr : reverseField a (b ((T : ℝ)-s).toNNReal) (q s) =
+      -2/(q s-(Target.driverValue b ((T : ℝ)-s) : ℂ)) := by
+    rw [reverseField,reverseCenter_eq (haw.trans (hheight s hs.1))]
+    rfl
+  rw [hr]
+  exact hh
+
+theorem raw_inverse_limit_of_witness_drivers
+    (U : ℕ → ℝ≥0 → ℝ) (γ : ℕ → ℝ≥0 → ℂ) (G F : ℕ → ℝ≥0 → ℂ → ℂ)
+    (hw : ∀ n, IsCapacityTwoWitness (U n) (γ n) (G n) (F n))
+    (b : Target.Driver) (T : ℝ≥0) (δ : ℕ → ℝ)
+    (hδ : Tendsto δ atTop (𝓝 0))
+    (hUb : ∀ n t, t ∈ Icc 0 T → |U n t-b t| ≤ δ n)
+    {w : ℂ} (hwH : w ∈ upperHalfPlane) :
+    Tendsto (fun n => F n T w) atTop (𝓝 (Target.inverseFlow 1 b T w)) := by
+  rw [tendsto_iff_dist_tendsto_zero]
+  have hb := fun n => (hw n).raw_inverse_driver_distance b T hwH w le_rfl (δ n) (hUb n)
+  have ht := (gronwallBound_continuous_ε 0 (4*w.im⁻¹^2) T).continuousAt.tendsto.comp
+    (hδ.const_mul (2*w.im⁻¹^2))
+  simp only [Function.comp_def,mul_zero,gronwallBound_ε0_δ0] at ht
+  exact squeeze_zero (fun _ => dist_nonneg) hb ht
+
+end SLEExactGauge
+
+end
+
+end OAI
diff --git a/lean/OAI/Probability/SLE/Loewner/RawInverseHolomorphic.lean b/lean/OAI/Probability/SLE/Loewner/RawInverseHolomorphic.lean
new file mode 100644
index 0000000000000000000000000000000000000000..fc9e4801dcc1020fb43481dc572c2ad7092ca13a
--- /dev/null
+++ b/lean/OAI/Probability/SLE/Loewner/RawInverseHolomorphic.lean
@@ -0,0 +1,68 @@
+import OAI.Probability.SLE.Loewner.RawInverseDriverApproximation
+import OAI.Probability.SLE.Loewner.LoewnerInverseCompactness
+import OAI.Probability.SLE.Geometry.ActualCompactAvoidance
+import OAI.Probability.SLE.Loewner.UnivalentInverseAnalytic
+
+namespace OAI
+
+/-! Holomorphicity of every continuous-driver raw inverse follows from
+interior approximation by actual SLE witnesses. The argument uses the
+finite Brownian driver tubes, not geometric SLE support. -/
+noncomputable section
+open Set Filter _root_.MeasureTheory _root_.OAI.MeasureTheory ProbabilityTheory
+open scoped Topology NNReal
+
+namespace SLEExactGauge
+
+theorem raw_inverse_holomorphic_of_witness_approximation
+    (U : ℕ → ℝ≥0 → ℝ) (γ : ℕ → ℝ≥0 → ℂ) (G F : ℕ → ℝ≥0 → ℂ → ℂ)
+    (hw : ∀ n, IsCapacityTwoWitness (U n) (γ n) (G n) (F n))
+    (b : Target.Driver) (T : ℝ≥0) (δ : ℕ → ℝ)
+    (hδ : Tendsto δ atTop (𝓝 0))
+    (hUb : ∀ n t, t ∈ Icc 0 T → |U n t-b t| ≤ δ n) :
+    DifferentiableOn ℂ (Target.inverseFlow 1 b T) upperHalfPlane := by
+  obtain ⟨σ,f,hσ,hf,hconv⟩ := inverse_family_subsequence U γ G F hw T
+  have he (w : ℂ) (hwH : w ∈ upperHalfPlane) : f w=Target.inverseFlow 1 b T w :=
+    tendsto_nhds_unique (hconv.tendsto_at hwH)
+      ((raw_inverse_limit_of_witness_drivers U γ G F hw b T δ hδ hUb hwH).comp hσ.tendsto_atTop)
+  exact hf.congr (fun w hwH => (he w hwH).symm)
+
+theorem RegularSLEPresentation.raw_inverse_holomorphic
+    {Ω : Type*} [MeasurableSpace Ω] {P : Measure Ω} [IsProbabilityMeasure P]
+    {κ : ℝ} {γ : Ω → ℝ≥0 → ℂ} (a : RegularSLEPresentation P κ γ)
+    (hκ : 0 < κ) (b : Target.Driver) (T : ℝ≥0) :
+    DifferentiableOn ℂ (Target.inverseFlow 1 b T) upperHalfPlane := by
+  let δ (n : ℕ) : ℝ := 1/((n : ℝ)+1)
+  have hδ (n : ℕ) : 0 < δ n := by dsimp [δ]; positivity
+  have hex (n : ℕ) : ∃ ω : a.samples,
+      ∀ t ∈ Icc 0 (T+1), |Real.sqrt κ*a.B t ω-b t| < δ n := by
+    have hp := regular_scaled_driver_tube_positive a hκ b.toContinuousMap
+      (show b.toContinuousMap 0=0 from map_zero b) (T+1) (by positivity) (hδ n)
+    exact nonempty_of_measure_ne_zero hp.ne'
+  choose ω hω using hex
+  exact raw_inverse_holomorphic_of_witness_approximation
+    (fun n t => Real.sqrt κ*a.B t (ω n)) (fun n => γ (ω n))
+    (fun n => a.G (ω n)) (fun n => a.F (ω n)) (fun n => a.witness (ω n)) b T δ
+    tendsto_one_div_add_atTop_nhds_zero_nat (fun n t ht => (hω n t
+      ⟨ht.1,ht.2.trans (le_add_of_nonneg_right zero_le)⟩).le)
+
+lemma Target.inverseFlow_injOn (b : Driver) (T : ℝ≥0) :
+    InjOn (inverseFlow 1 b T) upperHalfPlane := by
+  intro z hz w hw he
+  have hh := congrArg (fun q => flow 1 b q T) he
+  rwa [flow_inverseFlow 1 (by norm_num) b T z hz,
+    flow_inverseFlow 1 (by norm_num) b T w hw] at hh
+
+theorem RegularSLEPresentation.raw_inverse_deriv_ne_zero
+    {Ω : Type*} [MeasurableSpace Ω] {P : Measure Ω} [IsProbabilityMeasure P]
+    {κ : ℝ} {γ : Ω → ℝ≥0 → ℂ} (a : RegularSLEPresentation P κ γ)
+    (hκ : 0 < κ) (b : Target.Driver) (T : ℝ≥0) {z : ℂ} (hz : z ∈ upperHalfPlane) :
+    deriv (Target.inverseFlow 1 b T) z ≠ 0 :=
+  univalent_deriv_ne_zero isOpen_upperHalfPlane (a.raw_inverse_holomorphic hκ b T)
+    (Target.inverseFlow_injOn b T) hz
+
+end SLEExactGauge
+
+end
+
+end OAI
diff --git a/lean/OAI/Probability/SLE/Loewner/RawLifetimeFlowLimit.lean b/lean/OAI/Probability/SLE/Loewner/RawLifetimeFlowLimit.lean
new file mode 100644
index 0000000000000000000000000000000000000000..685a677cb11c0afc681541db165325aa133d114d
--- /dev/null
+++ b/lean/OAI/Probability/SLE/Loewner/RawLifetimeFlowLimit.lean
@@ -0,0 +1,60 @@
+import OAI.Probability.SLE.Loewner.RawLifetimeHeightLimit
+import OAI.Probability.SLE.Loewner.RawForwardCoordinates
+import OAI.Probability.SLE.Loewner.VanishingHeightRealLimit
+
+namespace OAI
+
+/-! Both coordinates of the raw forward flow approach the driver at a
+finite lifetime. Updating the terminal value gives a continuous path. -/
+noncomputable section
+open Set Filter Complex
+open scoped Topology
+
+namespace SLEExactGauge.Target
+
+theorem flow_tendsto_driver_at_lifetime
+    (b : Driver) (z : ℂ) (hz : z ∈ upperHalfPlane) {τ : ℝ} (hτ : 0 < τ)
+    (hs : ∀ t, 0 ≤ t → t < τ → Surviving 1 b z t)
+    (hdead : ¬Surviving 1 b z τ) :
+    Tendsto (flow 1 b z) (𝓝[<] τ) (𝓝 (driverValue b τ : ℂ)) := by
+  have hc := flow_continuousOn_before_lifetime b z (fun t ht => hs t ht.1 ht.2)
+  have hy := flow_height_tendsto_zero_at_lifetime b z hz hτ hs hdead
+  have hd (t : ℝ) (ht : t ∈ Ico 0 τ) :=
+    flow_coordinate_derivatives b z ht.1
+      (show t < (t+τ)/2 by linarith [ht.2])
+      (hs ((t+τ)/2) (by linarith [ht.1,ht.2]) (by linarith [ht.2]))
+  have hx := forward_real_tendsto_driver_of_height_zero hτ
+    (fun t => (flow 1 b z t).re) (fun t => (flow 1 b z t).im) (driverValue b)
+    (Complex.continuous_re.comp_continuousOn hc)
+    (Complex.continuous_im.comp_continuousOn hc)
+    (fun t ht => (hd t ht).1) (fun t ht => (hd t ht).2)
+    (fun t ht => surviving_flow_mem_upperHalfPlane 1 b z t ht.1 (hs t ht.1 ht.2))
+    (b.continuous.comp continuous_real_toNNReal).continuousAt hy
+  have hh := hx.ofReal.add (hy.ofReal.mul_const I)
+  simpa only [ofReal_zero,zero_mul,add_zero,re_add_im] using hh
+
+theorem continuousOn_flow_with_terminal_driver
+    (b : Driver) (z : ℂ) (hz : z ∈ upperHalfPlane) {τ : ℝ} (hτ : 0 < τ)
+    (hs : ∀ t, 0 ≤ t → t < τ → Surviving 1 b z t)
+    (hdead : ¬Surviving 1 b z τ) :
+    ContinuousOn (Function.update (flow 1 b z) τ (driverValue b τ : ℂ)) (Icc 0 τ) := by
+  have heq : Icc 0 τ \ {τ} = Ico 0 τ := by
+    ext t
+    simp only [Set.mem_sdiff,mem_Icc,mem_singleton_iff,mem_Ico]
+    constructor
+    · rintro ⟨⟨ht0,htτ⟩,hne⟩
+      exact ⟨ht0,lt_of_le_of_ne htτ hne⟩
+    · rintro ⟨ht0,htτ⟩
+      exact ⟨⟨ht0,htτ.le⟩,htτ.ne⟩
+  apply continuousOn_update_iff.mpr
+  rw [heq]
+  refine ⟨flow_continuousOn_before_lifetime b z (fun t ht => hs t ht.1 ht.2),?_⟩
+  intro _
+  exact (flow_tendsto_driver_at_lifetime b z hz hτ hs hdead).mono_left
+    (nhdsWithin_mono _ Ico_subset_Iio_self)
+
+end SLEExactGauge.Target
+
+end
+
+end OAI
diff --git a/lean/OAI/Probability/SLE/Loewner/RawLifetimeHeightLimit.lean b/lean/OAI/Probability/SLE/Loewner/RawLifetimeHeightLimit.lean
new file mode 100644
index 0000000000000000000000000000000000000000..5c660b262d3de5decae19761efac85245335af80
--- /dev/null
+++ b/lean/OAI/Probability/SLE/Loewner/RawLifetimeHeightLimit.lean
@@ -0,0 +1,59 @@
+import OAI.Probability.SLE.Loewner.RawHeightContinuation
+
+namespace OAI
+
+/-! The height of a raw point tends to zero at its finite lifetime.
+A positive limiting height would continue the exact cutoff trajectory. -/
+noncomputable section
+open Set Filter Complex
+open scoped Topology
+
+namespace SLEExactGauge.Target
+
+theorem flow_height_tendsto_zero_at_lifetime
+    (b : Driver) (z : ℂ) (hz : z ∈ upperHalfPlane) {τ : ℝ} (hτ : 0 < τ)
+    (hsurvive : ∀ t, 0 ≤ t → t < τ → Surviving 1 b z t)
+    (hdead : ¬Surviving 1 b z τ) :
+    Tendsto (fun t => (flow 1 b z t).im) (𝓝[<] τ) (𝓝 0) := by
+  let f (t : ℝ) := (flow 1 b z t).im
+  have hp (t : ℝ) (ht : t ∈ Ioo 0 τ) : 0 < f t :=
+    surviving_flow_mem_upperHalfPlane 1 b z t ht.1.le (hsurvive t ht.1.le ht.2)
+  have hmono : AntitoneOn f (Ioo 0 τ) := by
+    intro s hs t ht hst
+    exact flow_height_antitone_of_survival b z ht.1.le (hsurvive t ht.1.le ht.2)
+      ⟨hs.1.le,hst⟩ ⟨ht.1.le,le_rfl⟩ hst
+  have hne : (Ioo (0 : ℝ) τ).Nonempty := nonempty_Ioo.mpr hτ
+  have himage : (f '' Ioo 0 τ).Nonempty := hne.image f
+  have hbelow : BddBelow (f '' Ioo 0 τ) := by
+    refine ⟨0,?_⟩
+    rintro y ⟨t,ht,rfl⟩
+    exact (hp t ht).le
+  have hy : 0 ≤ sInf (f '' Ioo 0 τ) := by
+    apply le_csInf himage
+    rintro y ⟨t,ht,rfl⟩
+    exact (hp t ht).le
+  have hmin (t : ℝ) (ht : t ∈ Ioo 0 τ) : sInf (f '' Ioo 0 τ) ≤ f t :=
+    csInf_le hbelow ⟨t,ht,rfl⟩
+  have hzero : sInf (f '' Ioo 0 τ)=0 := by
+    apply le_antisymm _ hy
+    by_contra hn
+    have hyp : 0 < sInf (f '' Ioo 0 τ) := lt_of_not_ge hn
+    apply hdead
+    apply survives_of_uniform_height_before b z hz hτ hyp
+      (fun t ht => hsurvive t ht.1 ht.2)
+    intro t ht
+    by_cases ht0 : t=0
+    · subst t
+      have hhalf : τ/2 ∈ Ioo (0 : ℝ) τ := ⟨half_pos hτ,half_lt_self hτ⟩
+      exact (hmin _ hhalf).trans
+        (flow_height_antitone_of_survival b z (half_pos hτ).le
+          (hsurvive _ (half_pos hτ).le (half_lt_self hτ))
+          ⟨le_rfl,(half_pos hτ).le⟩ ⟨(half_pos hτ).le,le_rfl⟩ (half_pos hτ).le)
+    · exact hmin t ⟨lt_of_le_of_ne ht.1 (Ne.symm ht0),ht.2⟩
+  simpa only [hzero] using hmono.tendsto_nhdsWithin_Ioo_left hne hbelow
+
+end SLEExactGauge.Target
+
+end
+
+end OAI
diff --git a/lean/OAI/Probability/SLE/Loewner/RawLifetimeTrace.lean b/lean/OAI/Probability/SLE/Loewner/RawLifetimeTrace.lean
new file mode 100644
index 0000000000000000000000000000000000000000..f53cacb149f786128c249fc22849299f17729a43
--- /dev/null
+++ b/lean/OAI/Probability/SLE/Loewner/RawLifetimeTrace.lean
@@ -0,0 +1,67 @@
+import OAI.Probability.SLE.Loewner.RawLifetimeFlowLimit
+import OAI.Probability.SLE.Geometry.OpenBoundaryTrace
+
+namespace OAI
+
+/-! A point lost by the smooth raw flow is exactly the trace tip at its
+finite lifetime. The reverse path is the forward path read backwards. -/
+noncomputable section
+open Set Filter Complex
+open scoped Topology NNReal
+
+namespace SLEExactGauge.Target
+
+theorem eq_trace_at_lifetime
+    (b : Driver) (z : ℂ) (hz : z ∈ upperHalfPlane) {τ : ℝ} (hτ : 0 < τ)
+    (hs : ∀ t, 0 ≤ t → t < τ → Surviving 1 b z t)
+    (hdead : ¬Surviving 1 b z τ) (b' : ℝ → ℝ)
+    (hd : ∀ t ∈ Icc 0 τ, HasDerivWithinAt (driverValue b) (b' t) (Icc 0 τ) t)
+    {L : ℝ} (hL : 0 ≤ L) (hb : ∀ t ∈ Icc 0 τ, |b' t| ≤ L) :
+    z=trace 1 b τ := by
+  let f := Function.update (flow 1 b z) τ (driverValue b τ : ℂ)
+  let q (t : ℝ) := f (τ-t)
+  have hqeq (t : ℝ) (ht : 0 < t) : q t=flow 1 b z (τ-t) := by
+    exact Function.update_of_ne (by linarith : τ-t ≠ τ) _ _
+  have hqc : ContinuousOn q (Icc 0 τ) := by
+    apply (continuousOn_flow_with_terminal_driver b z hz hτ hs hdead).comp
+      (continuous_const.sub continuous_id).continuousOn
+    intro t ht
+    exact ⟨sub_nonneg.mpr ht.2,sub_le_self _ ht.1⟩
+  have hq0 : q 0=(b (⟨τ,hτ.le⟩ : ℝ≥0) : ℂ) := by
+    simp only [q,f,sub_zero,Function.update_self]
+    change (b τ.toNNReal : ℂ) = _
+    have ht : τ.toNNReal = (⟨τ,hτ.le⟩ : ℝ≥0) := by
+      apply Subtype.ext
+      exact Real.coe_toNNReal τ hτ.le
+    rw [ht]
+  have hqp (t : ℝ) (ht : t ∈ Ioc 0 τ) : 0 < (q t).im := by
+    rw [hqeq t ht.1]
+    exact surviving_flow_mem_upperHalfPlane 1 b z (τ-t) (sub_nonneg.mpr ht.2)
+      (hs _ (sub_nonneg.mpr ht.2) (by linarith [ht.1]))
+  have hqd (t : ℝ) (ht : t ∈ Ioo 0 τ) : HasDerivWithinAt q
+      (-2/(q t-(driverValue b (τ-t) : ℂ))) (Ici t) t := by
+    have hx : 0 < τ-t := sub_pos.mpr ht.2
+    let S : ℝ := ((τ-t)+τ)/2
+    have hxS : τ-t < S := by dsimp [S]; linarith [ht.1]
+    have hSτ : S < τ := by dsimp [S]; linarith [ht.1]
+    have hflow := (flow_hasDerivWithinAt_of_later_survival 1 b z (τ-t) S hx.le hxS
+      (hs S (hx.le.trans hxS.le) hSτ)).hasDerivAt (Ici_mem_nhds hx)
+    have hh := hflow.scomp t ((hasDerivAt_id t).const_sub τ)
+    have hevent : q =ᶠ[𝓝[Ici t] t] (fun s : ℝ => flow 1 b z (τ-s)) := by
+      filter_upwards [mem_nhdsWithin_of_mem_nhds (lt_mem_nhds ht.1)] with s hs'
+      exact hqeq s hs'
+    have hh' := hh.hasDerivWithinAt.congr_of_eventuallyEq hevent (hqeq t ht.1)
+    convert! hh' using 1
+    rw [hqeq t ht.1]
+    simp [a,neg_div]
+  have hfinal : q τ=z := by
+    rw [hqeq τ hτ,sub_self,flow_zero 1 b z hz]
+  have htip := boundary_reverse_eq_trace_of_open_derivative b ⟨τ,hτ.le⟩ hτ b'
+    hd hL hb q hqc hq0 hqd hqp
+  exact hfinal.symm.trans htip
+
+end SLEExactGauge.Target
+
+end
+
+end OAI
diff --git a/lean/OAI/Probability/SLE/Loewner/RawRadialTipBoundary.lean b/lean/OAI/Probability/SLE/Loewner/RawRadialTipBoundary.lean
new file mode 100644
index 0000000000000000000000000000000000000000..0437986adaf377f75eb9231e152c44e91ac78224
--- /dev/null
+++ b/lean/OAI/Probability/SLE/Loewner/RawRadialTipBoundary.lean
@@ -0,0 +1,44 @@
+import OAI.Probability.SLE.Loewner.RawSurvivingAnalytic
+
+namespace OAI
+
+/-! A radial inverse limit lies outside the open raw survival domain.
+This uses only the stated limit, with no regularity of the driver beyond
+its defining continuity. -/
+noncomputable section
+open Set Filter Complex _root_.MeasureTheory _root_.OAI.MeasureTheory ProbabilityTheory
+open scoped Topology NNReal
+
+namespace SLEExactGauge
+
+theorem RegularSLEPresentation.raw_radial_tip_not_surviving
+    {Ω : Type*} [MeasurableSpace Ω] {P : Measure Ω} [IsProbabilityMeasure P]
+    {κ : ℝ} {γ : Ω → ℝ≥0 → ℂ} (a : RegularSLEPresentation P κ γ) (hκ : 0<κ)
+    (b : Target.Driver) (T : ℝ≥0) (z : ℂ)
+    (hl : Tendsto (fun y : ℝ => Target.inverseFlow 1 b T ((b T:ℂ)+(y:ℂ)*I))
+      (𝓝[>] 0) (𝓝 z)) : ¬Target.Surviving 1 b z T := by
+  intro hs
+  have hc := ((a.raw_forward_holomorphic hκ b T).differentiableAt
+    ((a.raw_surviving_isOpen hκ b T).mem_nhds hs)).continuousAt
+  have ht := hc.tendsto.comp hl
+  have he : (fun y : ℝ => Target.flow 1 b
+      (Target.inverseFlow 1 b T ((b T:ℂ)+(y:ℂ)*I)) T)
+      =ᶠ[𝓝[>] (0:ℝ)] (fun y => (b T:ℂ)+(y:ℂ)*I) := by
+    filter_upwards [self_mem_nhdsWithin] with y hy
+    exact Target.flow_inverseFlow 1 (by norm_num) b T _
+      (by simpa [upperHalfPlane] using hy)
+  have hv : Tendsto (fun y : ℝ => (b T:ℂ)+(y:ℂ)*I)
+      (𝓝[>] 0) (𝓝 (b T:ℂ)) := by
+    have h : Continuous (fun y : ℝ => (b T:ℂ)+(y:ℂ)*I) := by fun_prop
+    simpa only [ofReal_zero,zero_mul,add_zero] using
+      (h.tendsto 0).mono_left nhdsWithin_le_nhds
+  have hval := tendsto_nhds_unique ht (hv.congr' he.symm)
+  have hp := Target.surviving_flow_mem_upperHalfPlane 1 b z T T.coe_nonneg hs
+  rw [hval] at hp
+  simp [upperHalfPlane] at hp
+
+end SLEExactGauge
+
+end
+
+end OAI
diff --git a/lean/OAI/Probability/SLE/Loewner/RawRestartAdaptation.lean b/lean/OAI/Probability/SLE/Loewner/RawRestartAdaptation.lean
new file mode 100644
index 0000000000000000000000000000000000000000..9c0f8b4e3d3075db1c4ed437faf2ab0ccbe1c3e8
--- /dev/null
+++ b/lean/OAI/Probability/SLE/Loewner/RawRestartAdaptation.lean
@@ -0,0 +1,123 @@
+import OAI.Probability.SLE.Mass.RawMassPathLaw
+import OAI.Probability.SLE.Stochastic.ShiftedStoppingFiltration
+
+namespace OAI
+
+/-! The fixed raw mass applied to the fresh driver is progressive in the
+original filtration shifted by the stopping time. Its continuous increasing
+paths are transferred on the explicit measurable good set. -/
+
+noncomputable section
+open Set Filter _root_.MeasureTheory _root_.OAI.MeasureTheory ProbabilityTheory
+open scoped Topology CompactlySupported NNReal ENNReal
+
+namespace SLEExactGauge
+
+local instance rawRestartDriverMeasurable : MeasurableSpace C(ℝ≥0,ℝ) := borel _
+local instance rawRestartDriverBorel : BorelSpace C(ℝ≥0,ℝ) := ⟨rfl⟩
+
+lemma driverPath_measurable_past_of_adapted
+    {Ω : Type*} [mΩ : MeasurableSpace Ω] (ℱ : Filtration ℝ≥0 mΩ)
+    (Y : Ω → C(ℝ≥0,ℝ)) (hY : Adapted ℱ (fun t ω => Y ω t)) (t : ℝ≥0) :
+    Measurable[ℱ t,driverPathFiltration t] Y := by
+  rw [driverPathFiltration,Filtration.natural_eq_comap]
+  let : MeasurableSpace Ω := ℱ t
+  apply measurable_comap_iff.mpr
+  apply measurable_pi_iff.mpr
+  intro s
+  exact (hY s).mono (ℱ.mono s.property) le_rfl
+
+theorem raw_process_comp_progressive
+    {Ω : Type*} [mΩ : MeasurableSpace Ω] (ℱ : Filtration ℝ≥0 mΩ)
+    (Y : Ω → C(ℝ≥0,ℝ)) (hY : Adapted ℱ (fun t ω => Y ω t))
+    (R : ℝ≥0 → C(ℝ≥0,ℝ) → Measure upperHalfPlane)
+    (hR : IsProgressive driverPathFiltration R) :
+    IsProgressive ℱ (fun t ω => R t (Y ω)) := by
+  intro t
+  exact (hR t).comp (measurable_fst.prodMk
+    ((driverPath_measurable_past_of_adapted ℱ Y hY t).comp measurable_snd))
+
+lemma sourceRestartDriverPath_shifted_adapted
+    {Ω : Type*} [mΩ : 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))) :
+    Adapted (shiftedStoppingFiltration hτ)
+      (fun t ω => sourceRestartDriverPath B hc τ ω t) := by
+  have hX := (Filtration.stronglyAdapted_natural (fun t => (hm t).stronglyMeasurable)).isStronglyProgressive_of_continuous hc
+  have hs := shiftedStopping_adapted hτ B hX
+  have h0 : StronglyMeasurable[(shiftedStoppingFiltration hτ) 0]
+      (fun ω => B (τ ω) ω) := by
+    simpa only [add_zero] using hs 0
+  intro t
+  have hd := ((hs t).sub (h0.mono ((shiftedStoppingFiltration hτ).mono (show 0 ≤ t from zero_le)))).measurable
+  exact hd
+
+theorem sourceRestart_raw_process_progressive
+    {Ω : Type*} [mΩ : 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)))
+    (R : ℝ≥0 → C(ℝ≥0,ℝ) → Measure upperHalfPlane)
+    (hR : IsProgressive driverPathFiltration R) :
+    IsProgressive (shiftedStoppingFiltration hτ)
+      (fun t ω => R t (sourceRestartDriverPath B hc τ ω)) :=
+  raw_process_comp_progressive _ _ (sourceRestartDriverPath_shifted_adapted B hm hc τ hτ) R hR
+
+theorem sourceRestart_mem_full_driver_set
+    {Ω : 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 t => (hm t).stronglyMeasurable))
+      (fun ω => (τ ω : WithTop ℝ≥0)))
+    (E : Set C(ℝ≥0,ℝ)) (hE : MeasurableSet E)
+    (hfull : ∀ᵐ p ∂P.map (sourceDriverPath B hc), p ∈ E) :
+    ∀ᵐ ω ∂P, sourceRestartDriverPath B hc τ ω ∈ E := by
+  have hY : Measurable (sourceRestartDriverPath B hc τ) := source_path_measurable _
+    (fun t => (sourceRestartDriverPath_shifted_adapted B hm hc τ hτ).measurable (i := t))
+  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τ (MeasurableSet.univ : MeasurableSet[hτ.measurableSpace] univ)
+  apply (ae_map_iff hY.aemeasurable hE).mp
+  rwa [hlaw]
+
+namespace Multipoint
+
+theorem CanonicalMass.exists_raw_with_restarted_paths
+    {Ω : 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)
+    (hBc : ∀ ω, Continuous (fun t => B t ω)) :
+    ∃ R : ℝ≥0 → C(ℝ≥0,ℝ) → Measure upperHalfPlane,
+      IsProgressive driverPathFiltration R ∧
+      (∀ t p, (R t p).Regular ∧ IsFiniteMeasureOnCompacts (R t p)) ∧
+      (∀ t p r, (∀ s ≤ t, p s=r s) → R t p=R t r) ∧
+      (∀ᵐ ω ∂P, ∀ t, R t (sourceDriverPath B hBc ω)=C.process t ω) ∧
+      ∀ (τ : Ω → ℝ≥0)
+        (hτ : IsStoppingTime (Filtration.natural B (fun t =>
+          (hBm.comp (measurable_const.prodMk measurable_id) : Measurable (B t)).stronglyMeasurable))
+          (fun ω => (τ ω : WithTop ℝ≥0))),
+        IsProgressive (shiftedStoppingFiltration hτ)
+          (fun t ω => R t (sourceRestartDriverPath B hBc τ ω)) ∧
+        ∀ᵐ ω ∂P, R 0 (sourceRestartDriverPath B hBc τ ω)=0 ∧
+          Monotone (fun t => R t (sourceRestartDriverPath B hBc τ ω)) ∧
+          ∀ f : C_c(upperHalfPlane,ℝ),
+            Continuous (fun t => ∫ z, f z ∂(R t (sourceRestartDriverPath B hBc τ ω))) := by
+  obtain ⟨R,E,hRp,hRr,hRn,hE,hfull,hgood,he⟩ := C.exists_raw_nonanticipating_with_good_set hBc
+  refine ⟨R,hRp,hRr,hRn,he,?_⟩
+  intro τ hτ
+  have hm (t : ℝ≥0) : Measurable (B t) := hBm.comp (measurable_const.prodMk measurable_id)
+  refine ⟨sourceRestart_raw_process_progressive B hm hBc τ hτ R hRp,?_⟩
+  filter_upwards [sourceRestart_mem_full_driver_set hB hm hBc τ hτ E hE hfull] with ω hω
+  exact hgood _ hω
+
+end Multipoint
+end SLEExactGauge
+
+end
+
+end OAI
diff --git a/lean/OAI/Probability/SLE/Loewner/RawRestartCanonical.lean b/lean/OAI/Probability/SLE/Loewner/RawRestartCanonical.lean
new file mode 100644
index 0000000000000000000000000000000000000000..1fb026d5365672df862fbf86b1b5330bd192c439
--- /dev/null
+++ b/lean/OAI/Probability/SLE/Loewner/RawRestartCanonical.lean
@@ -0,0 +1,65 @@
+import OAI.Probability.SLE.Loewner.RawRestartAdaptation
+import OAI.Probability.SLE.Loewner.RawTerminalExhaustion
+
+namespace OAI
+
+/-! One fixed raw canonical mass works at every finite Brownian restart.
+The finite process is progressive in the shifted past and locally exhausts
+its own terminal measure on one full event for each restart. -/
+
+noncomputable section
+open Set Filter _root_.MeasureTheory _root_.OAI.MeasureTheory ProbabilityTheory
+open scoped Topology CompactlySupported NNReal ENNReal
+
+namespace SLEExactGauge.Multipoint
+
+local instance rawRestartCanonicalMeasurable : MeasurableSpace C(ℝ≥0,ℝ) := borel _
+local instance rawRestartCanonicalBorel : BorelSpace C(ℝ≥0,ℝ) := ⟨rfl⟩
+
+theorem CanonicalMass.exists_raw_restarted_canonical
+    {Ω : 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)
+    (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 ω) ∧
+      ∀ (τ : Ω → ℝ≥0)
+        (hτ : IsStoppingTime (Filtration.natural B (fun t =>
+          (hBm.comp (measurable_const.prodMk measurable_id) : Measurable (B t)).stronglyMeasurable))
+          (fun ω => (τ ω : WithTop ℝ≥0))),
+        IsProgressive (shiftedStoppingFiltration hτ)
+          (fun t ω => R.process t (sourceRestartDriverPath B hBc τ ω)) ∧
+        ∀ᵐ ω ∂P,
+          R.process 0 (sourceRestartDriverPath B hBc τ ω)=0 ∧
+          Monotone (fun t => R.process t (sourceRestartDriverPath B hBc τ ω)) ∧
+          (∀ f : C_c(upperHalfPlane,ℝ), Continuous
+            (fun t => ∫ z, f z ∂(R.process t (sourceRestartDriverPath B hBc τ ω)))) ∧
+          (∀ t, R.process t (sourceRestartDriverPath B hBc τ ω) ≤
+            R.terminal (sourceRestartDriverPath B hBc τ ω)) ∧
+          ∀ K : Set upperHalfPlane, IsCompact K → Tendsto
+            (fun t : ℝ≥0 => (R.terminal (sourceRestartDriverPath B hBc τ ω)-
+              R.process t (sourceRestartDriverPath B hBc τ ω)) K) atTop (𝓝 0) := by
+  obtain ⟨N,hNp,hNr,hNn,he,hfresh⟩ := C.exists_raw_with_restarted_paths hB hBc
+  let R : RawCanonicalMass := ⟨N,rawTerminalMass N,hNp,hNr,
+    rawTerminalMass_measurable N hNp hNr,rawTerminalMass_radon N,hNn⟩
+  have hterm := C.rawTerminal_realizes hBc N he
+  obtain ⟨hE,hEf,hEg⟩ := C.raw_terminal_good_set hBc N hNp hNr he
+  refine ⟨R,?_,?_⟩
+  · filter_upwards [he,hterm] with ω hf ht
+    exact ⟨hf,ht⟩
+  · intro τ hτ
+    obtain ⟨hprog,hpath⟩ := hfresh τ hτ
+    refine ⟨hprog,?_⟩
+    have hm (t : ℝ≥0) : Measurable (B t) := hBm.comp (measurable_const.prodMk measurable_id)
+    have hset := sourceRestart_mem_full_driver_set hB hm hBc τ hτ _ hE hEf
+    filter_upwards [hpath,hset] with ω hp hs
+    obtain ⟨hdom,hex⟩ := hEg _ hs hp.2.1
+    exact ⟨hp.1,hp.2.1,hp.2.2,hdom,hex⟩
+
+end SLEExactGauge.Multipoint
+
+end
+
+end OAI
diff --git a/lean/OAI/Probability/SLE/Loewner/RawRestartGreenKernel.lean b/lean/OAI/Probability/SLE/Loewner/RawRestartGreenKernel.lean
new file mode 100644
index 0000000000000000000000000000000000000000..696ae6515ecf81e582f3370f327f175914be38b1
--- /dev/null
+++ b/lean/OAI/Probability/SLE/Loewner/RawRestartGreenKernel.lean
@@ -0,0 +1,108 @@
+import OAI.Probability.SLE.Geometry.CanonicalGreenPast
+import OAI.Probability.SLE.Geometry.CanonicalRawTerminal
+import OAI.Probability.SLE.Geometry.RestartContinuationKernel
+
+namespace OAI
+
+/-! The canonical mass's Green decomposition transfers to the full
+original past at every time after a finite restart. -/
+
+noncomputable section
+open Set Filter _root_.MeasureTheory _root_.OAI.MeasureTheory ProbabilityTheory Classical
+open scoped NNReal ENNReal Topology
+
+namespace SLEExactGauge.Multipoint
+
+local instance rawGreenKernelDriverMeasurable : MeasurableSpace C(ℝ≥0,ℝ) := borel _
+local instance rawGreenKernelDriverBorel : BorelSpace C(ℝ≥0,ℝ) := ⟨rfl⟩
+
+lemma bind_kernel_add {Ω : Type*} [MeasurableSpace Ω] (P : Measure Ω)
+    (N M : Ω → Measure upperHalfPlane) (hN : Measurable N) (hM : Measurable M) :
+    P.bind (fun ω => N ω+M ω)=P.bind N+P.bind M := by
+  have hsum : Measurable (fun ω => N ω+M ω) := hN.add hM
+  apply Measure.ext
+  intro A hA
+  rw [Measure.bind_apply hA hsum.aemeasurable,Measure.add_apply,
+    Measure.bind_apply hA hN.aemeasurable,Measure.bind_apply hA hM.aemeasurable]
+  simp only [Measure.add_apply]
+  exact lintegral_add_left ((Measure.measurable_coe hA).comp hN) _
+
+variable {Ω : Type*} [MeasurableSpace Ω] {P : Measure Ω}
+  {κ : ℝ} {B : ℝ≥0 → Ω → ℝ} {hBm : Measurable (Function.uncurry B)}
+  {γ : Ω → ℝ≥0 → ℂ} {G : Ω → ℝ≥0 → ℂ → ℂ}
+  (C : CanonicalMass P κ B hBm γ G)
+  (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 ω)
+
+include C hc F hw R he in
+lemma CanonicalMass.raw_green_kernel (t : ℝ≥0) (A : Set Ω)
+    (hA : MeasurableSet[(Filtration.natural B (fun s =>
+      (hBm.comp (measurable_const.prodMk measurable_id) : Measurable (B s)).stronglyMeasurable)) t] A) :
+    (P.restrict A).bind (fun ω => R.terminal (sourceDriverPath B hc ω)) =
+      (P.restrict A).bind (fun ω => R.process t (sourceDriverPath B hc ω)+
+        canonicalGreenMass κ t (sourceDriverPath B hc ω)) := by
+  have hm (s : ℝ≥0) : Measurable (B s) := hBm.comp (measurable_const.prodMk measurable_id)
+  have hG (ω : Ω) : canonicalGreenMass κ t (sourceDriverPath B hc ω)=
+      halfPlaneGreenMeasure κ B γ G t ω := by
+    simpa only [sourceDriverPath,ContinuousMap.coe_mk,halfPlaneGreenMeasure] using
+      canonicalGreenMass_eq κ (sourceDriverPath B hc ω) (hw ω) t
+  have hleft : (P.restrict A).bind (fun ω => R.terminal (sourceDriverPath B hc ω)) =
+      (P.restrict A).bind C.rational.terminal :=
+    Measure.bind_congr_right (ae_restrict_of_ae (he.mono fun _ h => h.2))
+  have hright : (P.restrict A).bind (fun ω => R.process t (sourceDriverPath B hc ω)+
+        canonicalGreenMass κ t (sourceDriverPath B hc ω)) =
+      (P.restrict A).bind (fun ω => C.process t ω+halfPlaneGreenMeasure κ B γ G t ω) := by
+    apply Measure.bind_congr_right
+    filter_upwards [ae_restrict_of_ae he] with ω hω
+    rw [hω.1 t,hG ω]
+  have hs := isStoppingTime_const (Filtration.natural B (fun s => (hm s).stronglyMeasurable)) t
+  have hAs : MeasurableSet[hs.measurableSpace] A := by
+    have hspace : hs.measurableSpace = (Filtration.natural B
+        (fun s => (hm s).stronglyMeasurable)) t :=
+      IsStoppingTime.measurableSpace_const _ t
+    rw [hspace]
+    exact hA
+  have h := C.kernel (fun _ => (t:WithTop ℝ≥0)) hs A hAs
+  change (P.restrict A).bind C.rational.terminal =
+    (P.restrict A).bind (C.process t) +
+      (P.restrict A).bind (halfPlaneGreenMeasure κ B γ G t) at h
+  calc
+    _ = (P.restrict A).bind C.rational.terminal := hleft
+    _ = (P.restrict A).bind (C.process t) +
+        (P.restrict A).bind (halfPlaneGreenMeasure κ B γ G t) := h
+    _ = (P.restrict A).bind (fun ω => C.process t ω+halfPlaneGreenMeasure κ B γ G t ω) :=
+      (bind_kernel_add _ _ _ (C.progressive.adapted.measurable (i := t))
+        (halfPlaneGreenMeasure_measurable hBm hc κ γ G F hw t)).symm
+    _ = _ := hright.symm
+
+include C hc F hw R he in
+theorem CanonicalMass.raw_restarted_green_kernel [IsProbabilityMeasure P]
+    (hB : IsBrownianReal B P) (τ : Ω → ℝ≥0)
+    (hτ : IsStoppingTime (Filtration.natural B (fun s =>
+      (hBm.comp (measurable_const.prodMk measurable_id) : Measurable (B s)).stronglyMeasurable))
+      (fun ω => (τ ω:WithTop ℝ≥0)))
+    (t : ℝ≥0) (E : Set Ω) (hE : MeasurableSet[shiftedStoppingFiltration hτ t] E) :
+    (P.restrict E).bind (fun ω => R.terminal (sourceRestartDriverPath B hc τ ω)) =
+      (P.restrict E).bind (fun ω => R.process t (sourceRestartDriverPath B hc τ ω))+
+      (P.restrict E).bind (fun ω => canonicalGreenMass κ t (sourceRestartDriverPath B hc τ ω)) := by
+  have hm (s : ℝ≥0) : Measurable (B s) := hBm.comp (measurable_const.prodMk measurable_id)
+  have hK : Measurable[driverPathFiltration t]
+      (fun p => R.process t p+canonicalGreenMass κ t p) :=
+    (R.progressive.adapted t).add (canonicalGreenMass_measurable_past κ t)
+  have h := source_restart_bind_of_original_kernel hB hm hc t R.terminal
+    (fun p => R.process t p+canonicalGreenMass κ t p) R.terminal_measurable hK
+    (fun A hA => C.raw_green_kernel hc F hw R he t A hA) τ hτ E hE
+  rw [h]
+  have hY := sourceRestartDriverPath_measurable B hm hc τ hτ
+  exact bind_kernel_add _ _ _ ((R.progressive.adapted.measurable (i := t)).comp hY)
+    ((canonicalGreenMass_measurable κ t).comp hY)
+
+end SLEExactGauge.Multipoint
+
+end
+
+end OAI
diff --git a/lean/OAI/Probability/SLE/Loewner/RawRestartRandomTests.lean b/lean/OAI/Probability/SLE/Loewner/RawRestartRandomTests.lean
new file mode 100644
index 0000000000000000000000000000000000000000..2256e9509aaeb9323a24b4d053499976fa8fa7b5
--- /dev/null
+++ b/lean/OAI/Probability/SLE/Loewner/RawRestartRandomTests.lean
@@ -0,0 +1,76 @@
+import OAI.Probability.SLE.Loewner.RawRestartGreenKernel
+import OAI.Probability.SLE.Geometry.CanonicalRawMean
+import OAI.Probability.SLE.Mass.ConditionalRadonRandomTests
+
+namespace OAI
+
+/-! The restarted Green kernel accepts arbitrary random spatial tests
+measurable in the full original past at the later time. -/
+
+noncomputable section
+open Set Filter _root_.MeasureTheory _root_.OAI.MeasureTheory ProbabilityTheory Classical
+open scoped NNReal ENNReal Topology
+
+namespace SLEExactGauge.Multipoint
+
+local instance rawRestartTestsDriverMeasurable : MeasurableSpace C(ℝ≥0,ℝ) := borel _
+local instance rawRestartTestsDriverBorel : 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) (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 ω)
+  (τ : Ω → ℝ≥0)
+  (hτ : IsStoppingTime (Filtration.natural B (fun s =>
+    (hBm.comp (measurable_const.prodMk measurable_id) : Measurable (B s)).stronglyMeasurable))
+    (fun ω => (τ ω:WithTop ℝ≥0)))
+
+include C hB hc F hw R he τ hτ in
+theorem CanonicalMass.raw_restarted_random_green_test
+    (t : ℝ≥0) (f : Ω × upperHalfPlane → ℝ≥0∞)
+    (hf : Measurable[(shiftedStoppingFiltration hτ t).prod inferInstance] f) :
+    (∫⁻ ω, ∫⁻ z, f (ω,z) ∂(R.terminal (sourceRestartDriverPath B hc τ ω)) ∂P) =
+      ∫⁻ ω, ∫⁻ z, f (ω,z) ∂(R.process t (sourceRestartDriverPath B hc τ ω)+
+        canonicalGreenMass κ t (sourceRestartDriverPath B hc τ ω)) ∂P := by
+  have hm (s : ℝ≥0) : Measurable (B s) := hBm.comp (measurable_const.prodMk measurable_id)
+  have hY := sourceRestartDriverPath_measurable B hm hc τ hτ
+  let μ (ω : Ω) := R.terminal (sourceRestartDriverPath B hc τ ω)
+  let ν (ω : Ω) := R.process t (sourceRestartDriverPath B hc τ ω)+
+    canonicalGreenMass κ t (sourceRestartDriverPath B hc τ ω)
+  have hμ : Measurable μ := R.terminal_measurable.comp hY
+  have hR : Measurable (fun ω => R.process t (sourceRestartDriverPath B hc τ ω)) :=
+    (R.progressive.adapted.measurable (i := t)).comp hY
+  have hG : Measurable (fun ω => canonicalGreenMass κ t (sourceRestartDriverPath B hc τ ω)) :=
+    (canonicalGreenMass_measurable κ t).comp hY
+  have hν : Measurable ν := hR.add hG
+  have hmean : P.bind μ=initialGreenMeasure κ :=
+    C.restarted_raw_terminal_mean hB hc R (he.mono fun _ h => h.2) τ hτ
+  have hevent (A : Set Ω) (hA : MeasurableSet[shiftedStoppingFiltration hτ t] A) :
+      (P.restrict A).bind μ=(P.restrict A).bind ν := by
+    have h := C.raw_restarted_green_kernel hc F hw R he hB τ hτ t A hA
+    exact h.trans (bind_kernel_add _ _ _ hR hG).symm
+  have htotal : P.bind μ=P.bind ν := by
+    simpa only [Measure.restrict_univ] using hevent univ MeasurableSet.univ
+  let : IsFiniteMeasureOnCompacts (initialGreenMeasure κ) := initialGreenMeasure_finite_on_compacts κ
+  have hμmean (K : Set upperHalfPlane) (hK : IsCompact K) : P.bind μ K < ∞ := by
+    rw [hmean]
+    exact hK.measure_lt_top
+  have hνmean (K : Set upperHalfPlane) (hK : IsCompact K) : P.bind ν K < ∞ := by
+    rw [← htotal]
+    exact hμmean K hK
+  exact conditional_halfPlane_random_test (shiftedStoppingFiltration hτ t)
+    ((shiftedStoppingFiltration hτ).le t) P μ ν hμ hν
+    (ae_of_all _ (fun ω => (R.terminal_radon _).2))
+    (ae_finite_on_compacts_of_compact_mean P ν hν hνmean) hμmean hevent f hf
+
+end SLEExactGauge.Multipoint
+
+end
+
+end OAI
diff --git a/lean/OAI/Probability/SLE/Loewner/RawReverseComposition.lean b/lean/OAI/Probability/SLE/Loewner/RawReverseComposition.lean
new file mode 100644
index 0000000000000000000000000000000000000000..142e9ffe6ca278587e56ffe402b2d39c7794091d
--- /dev/null
+++ b/lean/OAI/Probability/SLE/Loewner/RawReverseComposition.lean
@@ -0,0 +1,61 @@
+import OAI.Probability.SLE.Loewner.SmoothRawInverse
+import OAI.Probability.SLE.Loewner.ReverseLongContraction
+
+namespace OAI
+
+/-! A tail of a reverse trajectory is the raw inverse at the earlier
+capacity time. This identity needs no geometric trace. -/
+noncomputable section
+open Set Filter Complex
+open scoped Topology NNReal
+
+namespace SLEExactGauge
+
+lemma reverse_height_mono_nonneg (q : ℝ → ℂ) (u : ℝ → ℝ)
+    (hd : ∀ t, 0 ≤ t → HasDerivWithinAt q (-2/(q t-(u t : ℂ))) (Ici 0) t)
+    (hp : ∀ t, 0 ≤ t → 0 < (q t).im) :
+    MonotoneOn (fun t => (q t).im) (Ici 0) := by
+  intro s hs t ht hst
+  exact reverse_height_monotone q u
+    (fun v hv => (hd v hv.1).mono Icc_subset_Ici_self) (fun v hv => hp v hv.1)
+    ⟨hs,hst⟩ ⟨ht,le_rfl⟩ hst
+
+namespace Target
+
+lemma raw_reverse_tail_inverse (b : Driver) (T S : ℝ≥0) (hST : S ≤ T)
+    (q : ℝ → ℂ)
+    (hd : ∀ t, 0 ≤ t → HasDerivWithinAt q
+      (-2/(q t-(driverValue b ((T : ℝ)-t) : ℂ))) (Ici 0) t)
+    (hp : ∀ t, 0 ≤ t → 0 < (q t).im) :
+    inverseFlow 1 b S (q ((T : ℝ)-S)) = q T := by
+  let a : ℝ := (T : ℝ)-S
+  have ha : 0 ≤ a := sub_nonneg.mpr hST
+  have hmono := reverse_height_mono_nonneg q (fun t => driverValue b ((T : ℝ)-t)) hd hp
+  let Q (s : ℝ) := q (a+s)
+  let η : ℝ := (q a).im/2
+  have hη : 0 < η := half_pos (hp a ha)
+  have hheight (s : ℝ) (hs : 0 ≤ s) : η ≤ (Q s).im :=
+    (half_le_self (hp a ha).le).trans
+      (hmono ha (add_nonneg ha hs) (le_add_of_nonneg_right hs))
+  have hQ (s : ℝ) (hs : 0 ≤ s) : HasDerivWithinAt Q
+      (reverseField η (driverValue b ((S : ℝ)-1*s)) (Q s)) (Ici 0) s := by
+    have hi : HasDerivWithinAt (fun v : ℝ => a+v) 1 (Ici 0) s := by
+      simpa using ((hasDerivAt_id s).const_add a).hasDerivWithinAt
+    have hmaps : MapsTo (fun v : ℝ => a+v) (Ici 0) (Ici 0) :=
+      fun v hv => add_nonneg ha hv
+    have hh := (hd (a+s) (add_nonneg ha hs)).scomp s hi hmaps
+    have he : (T : ℝ)-(a+s)=(S : ℝ)-1*s := by dsimp [a]; ring
+    rw [reverseField,reverseCenter_eq (hheight s hs)]
+    convert! hh using 1
+    simp only [one_smul,he,Q,div_eq_mul_inv]
+  have hh := inverseFlow_eq_reverse_trajectory 1 (by norm_num) b S (q a)
+    η hη (half_le_self (hp a ha).le) Q (by simp [Q]) hQ
+  convert hh using 1
+  simp only [div_one,Q,a,sub_add_cancel]
+
+end Target
+end SLEExactGauge
+
+end
+
+end OAI
diff --git a/lean/OAI/Probability/SLE/Loewner/RawScaleTests.lean b/lean/OAI/Probability/SLE/Loewner/RawScaleTests.lean
new file mode 100644
index 0000000000000000000000000000000000000000..3c456970af376ec7f44638e260e9365e0a34767e
--- /dev/null
+++ b/lean/OAI/Probability/SLE/Loewner/RawScaleTests.lean
@@ -0,0 +1,64 @@
+import OAI.Probability.SLE.Mass.RandomDilationMass
+import OAI.Probability.SLE.Mass.CanonicalMassScaling
+
+namespace OAI
+
+/-! Fixed-scale covariance of the same raw functional, expressed as
+measurable scalar tests on continuous driver space. -/
+
+noncomputable section
+open Set Filter _root_.MeasureTheory _root_.OAI.MeasureTheory ProbabilityTheory
+open scoped Topology NNReal ENNReal
+
+namespace SLEExactGauge.Multipoint
+
+local instance rawScaleTestsMeasurable : MeasurableSpace C(ℝ≥0,ℝ) := borel _
+local instance rawScaleTestsBorel : BorelSpace C(ℝ≥0,ℝ) := ⟨rfl⟩
+
+lemma RawCanonicalMass.scaled_parameter_measurable {Ω : Type*} [MeasurableSpace Ω]
+    (R : RawCanonicalMass) (c T : Ω → ℝ≥0) (hc : Measurable c) (hT : Measurable T)
+    (Y : Ω → C(ℝ≥0,ℝ)) (hY : Measurable Y) :
+    Measurable (fun ω => R.process ((c ω)^2*T ω) (scaleDriverPath (c ω) (Y ω))) :=
+  _root_.OAI.MeasureTheory.IsProgressive.parameter_time_measurable R.progressive
+    (fun ω => scaleDriverPath (c ω) (Y ω))
+    (measurable_scaleDriverPath.comp (hc.prodMk hY))
+    (fun ω => (c ω)^2*T ω) ((hc.pow_const 2).mul hT)
+
+lemma CanonicalMass.raw_scaled_test_eq
+    {Ω : 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))
+    (c : ℝ≥0) (hpos : 0<c) (t : ℝ≥0)
+    (f : upperHalfPlane → ℝ≥0∞) (hf : Measurable f) :
+    ∀ᵐ p ∂P.map (sourceDriverPath B hc),
+      (∫⁻ z, f z ∂dilationMass κ c hpos (R.process t p)) =
+        ∫⁻ z, f z ∂(R.process (c^2*t) (scaleDriverPath c p)) := by
+  have hm (s) : Measurable (B s) := hBm.comp (measurable_const.prodMk measurable_id)
+  have hleft : Measurable (fun p => ∫⁻ z, f z ∂dilationMass κ c hpos (R.process t p)) :=
+    (Measure.measurable_lintegral hf).comp
+      ((conformalMass_measurable _ _).comp (R.progressive.adapted.measurable (i:=t)))
+  have hright : Measurable (fun p => ∫⁻ z, f z ∂(R.process (c^2*t) (scaleDriverPath c p))) :=
+    (Measure.measurable_lintegral hf).comp
+      ((R.progressive.adapted.measurable (i:=c^2*t)).comp
+        (measurable_scaleDriverPath.comp (measurable_const.prodMk measurable_id)))
+  apply (ae_map_iff (source_path_measurable _ hm).aemeasurable
+    (measurableSet_eq_fun hleft hright)).mpr
+  filter_upwards [he,C.scaled_raw_process_eq hB hc F hw R he E hE hEf hEp c hpos] with ω heω hs
+  rw [heω.1 t,hs t]
+  rfl
+
+end SLEExactGauge.Multipoint
+
+end
+
+end OAI
diff --git a/lean/OAI/Probability/SLE/Loewner/RawScaledGreenKernel.lean b/lean/OAI/Probability/SLE/Loewner/RawScaledGreenKernel.lean
new file mode 100644
index 0000000000000000000000000000000000000000..64b11978d3a9ba4c3dc06d4813c321bb39abeff9
--- /dev/null
+++ b/lean/OAI/Probability/SLE/Loewner/RawScaledGreenKernel.lean
@@ -0,0 +1,53 @@
+import OAI.Probability.SLE.Stochastic.DriverLawKernelTransfer
+import OAI.Probability.SLE.Stochastic.ScaledDriverFiltration
+import OAI.Probability.SLE.Loewner.RawRestartGreenKernel
+
+namespace OAI
+
+/-! The raw canonical mass kernel under Brownian scaling, conditioned on
+the full original past at the corresponding physical time. -/
+
+noncomputable section
+open Set Filter _root_.MeasureTheory _root_.OAI.MeasureTheory ProbabilityTheory
+open scoped Topology NNReal ENNReal
+
+namespace SLEExactGauge.Multipoint
+
+local instance rawScaledGreenMeasurable : MeasurableSpace C(ℝ≥0,ℝ) := borel _
+local instance rawScaledGreenBorel : BorelSpace C(ℝ≥0,ℝ) := ⟨rfl⟩
+
+variable {Ω : Type*} [MeasurableSpace Ω] {P : Measure Ω} [IsProbabilityMeasure P]
+  {κ : ℝ} {B : ℝ≥0 → Ω → ℝ} {hBm : Measurable (Function.uncurry B)}
+  {γ : Ω → ℝ≥0 → ℂ} {G : Ω → ℝ≥0 → ℂ → ℂ}
+
+lemma CanonicalMass.raw_scaled_green_kernel
+    (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 ω)
+    (c : ℝ≥0) (hcp : 0 < c) (t : ℝ≥0) (E : Set Ω)
+    (hE : MeasurableSet[(Filtration.natural B (fun s =>
+      (hBm.comp (measurable_const.prodMk measurable_id) : Measurable (B s)).stronglyMeasurable)) t] E) :
+    let Y := sourceDriverPath (scaledBrownianDriver c B) (scaledBrownianDriver_continuous c B hc)
+    (P.restrict E).bind (fun ω => R.terminal (Y ω))=
+      (P.restrict E).bind (fun ω => R.process (c^2*t) (Y ω)+
+        canonicalGreenMass κ (c^2*t) (Y ω)) := by
+  dsimp only
+  have hm (s : ℝ≥0) : Measurable (B s) := hBm.comp (measurable_const.prodMk measurable_id)
+  apply source_driver_bind_of_same_law_kernel hB (scaledBrownianDriver_brownian c hcp hB)
+    hm (scaledBrownianDriver_measurable c B hm) hc (scaledBrownianDriver_continuous c B hc)
+    (scaledBrownianDriver_path_law c hcp B hB hm hc).symm (c^2*t)
+    R.terminal (fun p => R.process (c^2*t) p+canonicalGreenMass κ (c^2*t) p)
+    R.terminal_measurable
+    ((R.progressive.adapted (c^2*t)).add (canonicalGreenMass_measurable_past κ (c^2*t)))
+    (fun A hA => C.raw_green_kernel hc F hw R he (c^2*t) A hA) E
+  rwa [scaledBrownianDriver_filtration c hcp B hm t]
+
+end SLEExactGauge.Multipoint
+
+end
+
+end OAI
diff --git a/lean/OAI/Probability/SLE/Loewner/RawSurvivingAnalytic.lean b/lean/OAI/Probability/SLE/Loewner/RawSurvivingAnalytic.lean
new file mode 100644
index 0000000000000000000000000000000000000000..50870f5ba4c89a1b47ece417406e306c168e4a9f
--- /dev/null
+++ b/lean/OAI/Probability/SLE/Loewner/RawSurvivingAnalytic.lean
@@ -0,0 +1,74 @@
+import OAI.Probability.SLE.Loewner.RawInverseHolomorphic
+import OAI.Probability.SLE.Loewner.TargetForwardAnalytic
+import OAI.Probability.SLE.Loewner.SmoothRawTrace
+
+namespace OAI
+
+/-! The raw surviving set is an open conformal image of the half-plane.
+For a smooth driver its radial tip lies on the boundary of this set. -/
+noncomputable section
+open Set Filter _root_.MeasureTheory _root_.OAI.MeasureTheory ProbabilityTheory
+open scoped Topology NNReal
+
+namespace SLEExactGauge
+
+lemma Target.surviving_eq_inverse_image (b : Driver) (T : ℝ≥0) :
+    {z | Surviving 1 b z T} = inverseFlow 1 b T '' upperHalfPlane := by
+  ext z
+  constructor
+  · intro hz
+    refine ⟨flow 1 b z T,surviving_flow_mem_upperHalfPlane 1 b z T T.coe_nonneg hz,?_⟩
+    exact inverseFlow_eq_of_surviving 1 b T T.coe_nonneg z _ hz rfl
+  · rintro ⟨w,hw,rfl⟩
+    exact inverseFlow_surviving 1 (by norm_num) b T w hw
+
+variable {Ω : Type*} [MeasurableSpace Ω] {P : Measure Ω} [IsProbabilityMeasure P]
+  {κ : ℝ} {γ : Ω → ℝ≥0 → ℂ}
+
+lemma RegularSLEPresentation.raw_surviving_isOpen (a : RegularSLEPresentation P κ γ)
+    (hκ : 0 < κ) (b : Target.Driver) (T : ℝ≥0) :
+    IsOpen {z | Target.Surviving 1 b z T} := by
+  rw [Target.surviving_eq_inverse_image]
+  apply isOpen_iff_mem_nhds.mpr
+  rintro z ⟨w,hw,rfl⟩
+  exact univalent_nhds_le_map isOpen_upperHalfPlane (a.raw_inverse_holomorphic hκ b T)
+    (Target.inverseFlow_injOn b T) hw (image_mem_map (isOpen_upperHalfPlane.mem_nhds hw))
+
+lemma RegularSLEPresentation.raw_forward_holomorphic (a : RegularSLEPresentation P κ γ)
+    (hκ : 0 < κ) (b : Target.Driver) (T : ℝ≥0) :
+    DifferentiableOn ℂ (fun z => Target.flow 1 b z T) {z | Target.Surviving 1 b z T} :=
+  Target.differentiableOn_flow_of_inverse 1 (by norm_num) b T
+    (a.raw_inverse_holomorphic hκ b T) (fun _ hz => a.raw_inverse_deriv_ne_zero hκ b T hz)
+
+theorem RegularSLEPresentation.smooth_raw_tip_not_surviving
+    (a : RegularSLEPresentation P κ γ) (hκ : 0 < κ)
+    (b : Target.Driver) (T : ℝ≥0) (b' : ℝ → ℝ)
+    (hd : ∀ t ∈ Icc 0 (T : ℝ), HasDerivWithinAt (Target.driverValue b)
+      (b' t) (Icc 0 (T : ℝ)) t)
+    {L : ℝ} (hL : 0 ≤ L) (hb : ∀ t ∈ Icc 0 (T : ℝ), |b' t| ≤ L) :
+    ¬Target.Surviving 1 b (Target.trace 1 b T) T := by
+  intro hs
+  have hc := ((a.raw_forward_holomorphic hκ b T).differentiableAt
+    ((a.raw_surviving_isOpen hκ b T).mem_nhds hs)).continuousAt
+  have ht := hc.tendsto.comp (Target.tendsto_inverseFlow_smooth_trace b T b' hd hL hb)
+  have he : (fun y : ℝ => Target.flow 1 b
+      (Target.inverseFlow 1 b T ((b T : ℂ)+(y : ℂ)*Complex.I)) T)
+      =ᶠ[𝓝[>] (0 : ℝ)] (fun y => (b T : ℂ)+(y : ℂ)*Complex.I) := by
+    filter_upwards [self_mem_nhdsWithin] with y hy
+    exact Target.flow_inverseFlow 1 (by norm_num) b T _
+      (by simpa [upperHalfPlane] using hy)
+  have hv : Tendsto (fun y : ℝ => (b T : ℂ)+(y : ℂ)*Complex.I)
+      (𝓝[>] 0) (𝓝 (b T : ℂ)) := by
+    have hc' : Continuous (fun y : ℝ => (b 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
+  have hval := tendsto_nhds_unique ht (hv.congr' he.symm)
+  have hp := Target.surviving_flow_mem_upperHalfPlane 1 b _ T T.coe_nonneg hs
+  rw [hval] at hp
+  simp [upperHalfPlane] at hp
+
+end SLEExactGauge
+
+end
+
+end OAI
diff --git a/lean/OAI/Probability/SLE/Loewner/RawSurvivingDerivative.lean b/lean/OAI/Probability/SLE/Loewner/RawSurvivingDerivative.lean
new file mode 100644
index 0000000000000000000000000000000000000000..3f25badbd5d796c8125c91d44707e12c6dd96641
--- /dev/null
+++ b/lean/OAI/Probability/SLE/Loewner/RawSurvivingDerivative.lean
@@ -0,0 +1,26 @@
+import OAI.Probability.SLE.Angle.TargetFlowEvolution
+import OAI.Probability.SLE.Loewner.TargetSurvivalExtension
+
+namespace OAI
+
+/-! The raw flow has its ordinary right evolution at every surviving
+time, because the strict cutoff certificate persists a little longer. -/
+noncomputable section
+open Set Filter Complex
+open scoped Topology NNReal
+
+namespace SLEExactGauge.Target
+
+lemma flow_hasDerivWithinAt_of_survival (b : Driver) (z : ℂ) {T : ℝ}
+    (hT : 0 ≤ T) (hs : Surviving 1 b z T) :
+    HasDerivWithinAt (flow 1 b z)
+      (2/(flow 1 b z T-(b T.toNNReal:ℂ))) (Ici 0) T := by
+  obtain ⟨S,hTS,hS⟩ := exists_later_survival 1 b z hT hs
+  simpa only [a,div_one,Complex.ofReal_ofNat,driverValue] using
+    flow_hasDerivWithinAt_of_later_survival 1 b z T S hT hTS hS
+
+end SLEExactGauge.Target
+
+end
+
+end OAI
diff --git a/lean/OAI/Probability/SLE/Loewner/RawSurvivingMonotone.lean b/lean/OAI/Probability/SLE/Loewner/RawSurvivingMonotone.lean
new file mode 100644
index 0000000000000000000000000000000000000000..72db37f299d960491de7b0c3985e9f7c360b5f31
--- /dev/null
+++ b/lean/OAI/Probability/SLE/Loewner/RawSurvivingMonotone.lean
@@ -0,0 +1,27 @@
+import OAI.Probability.SLE.Loewner.TargetCutoffTrajectory
+
+namespace OAI
+
+/-! Raw survival decreases with the time horizon. -/
+noncomputable section
+open Set Filter
+open scoped Topology
+
+namespace SLEExactGauge.Target
+
+lemma surviving_of_le_time (κ : ℝ) (b : Driver) (z : ℂ) {S T : ℝ}
+    (hS : 0 ≤ S) (hST : S ≤ T) (h : Surviving κ b z T) : Surviving κ b z S := by
+  obtain ⟨j,hj,hmin⟩ := h
+  refine ⟨j,hj,hmin.trans_le ?_⟩
+  have hc : IsCompact ((fun t : ℝ => (cutoffFlow κ b j z t).im) '' Icc 0 T) :=
+    isCompact_Icc.image_of_continuousOn (Complex.continuous_im.comp_continuousOn
+      ((cutoffFlow_continuousOn κ b j hj z).mono Icc_subset_Ici_self))
+  apply le_csInf (Set.Nonempty.image _ (nonempty_Icc.mpr hS))
+  rintro y ⟨s,hs,rfl⟩
+  exact csInf_le hc.bddBelow ⟨s,⟨hs.1,hs.2.trans hST⟩,rfl⟩
+
+end SLEExactGauge.Target
+
+end
+
+end OAI
diff --git a/lean/OAI/Probability/SLE/Loewner/RawTerminalExhaustion.lean b/lean/OAI/Probability/SLE/Loewner/RawTerminalExhaustion.lean
new file mode 100644
index 0000000000000000000000000000000000000000..69a7db2ecbd786b27fac683b01c35cdc6b962e15
--- /dev/null
+++ b/lean/OAI/Probability/SLE/Loewner/RawTerminalExhaustion.lean
@@ -0,0 +1,153 @@
+import OAI.Probability.SLE.Geometry.CanonicalRawTerminal
+import OAI.Probability.SLE.Mass.RawMassPathLaw
+
+namespace OAI
+
+/-! A measurable terminal certificate for the raw finite-time mass.
+Together with monotonicity it yields terminal domination and local
+exhaustion at all real times, not just integer times. -/
+
+noncomputable section
+open Set Filter _root_.MeasureTheory _root_.OAI.MeasureTheory
+open scoped Topology NNReal ENNReal CompactlySupported
+
+namespace SLEExactGauge
+
+local instance rawExhaustionDriverMeasurable : MeasurableSpace C(ℝ≥0,ℝ) := borel _
+local instance rawExhaustionDriverBorel : BorelSpace C(ℝ≥0,ℝ) := ⟨rfl⟩
+local instance : LocallyCompactSpace upperHalfPlane := isOpen_upperHalfPlane.locallyCompactSpace
+
+lemma ennreal_antitone_tendsto_zero_of_nat
+    (f : ℝ≥0 → ℝ≥0∞) (hf : Antitone f)
+    (hn : Tendsto (fun n : ℕ => f n) atTop (𝓝 0)) :
+    Tendsto f atTop (𝓝 0) := by
+  have hi : (⨅ t, f t)=0 := by
+    apply le_antisymm ?_ bot_le
+    exact le_of_tendsto_of_tendsto' tendsto_const_nhds hn (fun n => iInf_le f (n:ℝ≥0))
+  simpa only [hi] using tendsto_atTop_iInf hf
+
+def RawTerminalGood (D : LocalTestFamily upperHalfPlane)
+    (N : ℝ≥0 → Measure upperHalfPlane) (ν : Measure upperHalfPlane) : Prop :=
+  (∀ n : ℕ, ∀ j, (∫ z, (D.test j ⊔ 0) z ∂N n) ≤ ∫ z, (D.test j ⊔ 0) z ∂ν) ∧
+  ∀ k, Tendsto (fun n : ℕ => ν (D.compactSet k)-N n (D.compactSet k)) atTop (𝓝 0)
+
+theorem measurableSet_rawTerminalGood
+    {Y : Type*} [MeasurableSpace Y] (D : LocalTestFamily upperHalfPlane)
+    (N : ℝ≥0 → Y → Measure upperHalfPlane) (ν : Y → Measure upperHalfPlane)
+    (hNm : ∀ n : ℕ, Measurable (N n)) (hνm : Measurable ν)
+    (hNr : ∀ n : ℕ, ∀ y, (N n y).Regular) (hνr : ∀ y, (ν y).Regular) :
+    MeasurableSet {y | RawTerminalGood D (fun t => N t y) (ν y)} := by
+  have ho : MeasurableSet {y | ∀ n : ℕ, ∀ j,
+      (∫ z, (D.test j ⊔ 0) z ∂N n y) ≤ ∫ z, (D.test j ⊔ 0) z ∂ν y} := by
+    simp only [Set.ofPred_forall]
+    exact MeasurableSet.iInter fun n => MeasurableSet.iInter fun j =>
+      measurableSet_le
+        (measurable_halfPlane_compact_test_integral (N n) (hNm n) (hNr n) _)
+        (measurable_halfPlane_compact_test_integral ν hνm hνr _)
+  have ht : MeasurableSet {y | ∀ k, Tendsto
+      (fun n : ℕ => ν y (D.compactSet k)-N n y (D.compactSet k)) atTop (𝓝 0)} := by
+    simp only [Set.ofPred_forall]
+    apply MeasurableSet.iInter
+    intro k
+    exact measurableSet_tendsto (𝓝 (0:ℝ≥0∞)) (fun n =>
+      ((Measure.measurable_coe (D.isCompact k).measurableSet).comp hνm).sub
+        ((Measure.measurable_coe (D.isCompact k).measurableSet).comp (hNm n)))
+  simpa only [RawTerminalGood,Set.ofPred_and] using ho.inter ht
+
+theorem RawTerminalGood.domination_exhaustion
+    (D : LocalTestFamily upperHalfPlane)
+    (N : ℝ≥0 → Measure upperHalfPlane) (ν : Measure upperHalfPlane)
+    (hNr : ∀ t, (N t).Regular) (hνr : ν.Regular) (hN : Monotone N)
+    (hg : RawTerminalGood D N ν) :
+    (∀ t, N t ≤ ν) ∧ ∀ K : Set upperHalfPlane, IsCompact K →
+      Tendsto (fun t : ℝ≥0 => (ν-N t) K) atTop (𝓝 0) := by
+  let := hνr
+  have hn (n : ℕ) : N n ≤ ν := by
+    let := hNr n
+    exact D.measure_le_of_positive_tests _ _ (hg.1 n)
+  have hdom (t : ℝ≥0) : N t ≤ ν := by
+    obtain ⟨n,hn'⟩ := exists_nat_ge (t:ℝ)
+    have ht : t ≤ (n:ℝ≥0) := by exact_mod_cast hn'
+    exact (hN ht).trans (hn n)
+  refine ⟨hdom,?_⟩
+  intro K hK
+  obtain ⟨k,hKk⟩ := D.exhaustive K hK
+  have hanti : Antitone (fun t : ℝ≥0 => ν (D.compactSet k)-N t (D.compactSet k)) := by
+    intro s t hst
+    exact tsub_le_tsub_left (hN hst (D.compactSet k)) _
+  have hk := ennreal_antitone_tendsto_zero_of_nat _ hanti (hg.2 k)
+  have he (t : ℝ≥0) : (ν-N t) (D.compactSet k) =
+      ν (D.compactSet k)-N t (D.compactSet k) := by
+    let := hNr t
+    exact sub_apply_of_finite_restriction (hdom t) (D.isCompact k).measurableSet
+      (D.isCompact k).measure_lt_top.ne
+  have hk' : Tendsto (fun t : ℝ≥0 => (ν-N t) (D.compactSet k)) atTop (𝓝 0) := by
+    simpa only [he] using hk
+  exact tendsto_of_tendsto_of_tendsto_of_le_of_le tendsto_const_nhds hk'
+    (fun _ => bot_le) (fun _ => measure_mono hKk)
+
+theorem rawTerminalGood_of_exhaustion
+    (D : LocalTestFamily upperHalfPlane)
+    (N : ℝ≥0 → Measure upperHalfPlane) (ν : Measure upperHalfPlane)
+    (hNr : ∀ t, (N t).Regular) (hνr : ν.Regular)
+    (hdom : ∀ t, N t ≤ ν)
+    (hlim : ∀ K : Set upperHalfPlane, IsCompact K →
+      Tendsto (fun t : ℝ≥0 => (ν-N t) K) atTop (𝓝 0)) :
+    RawTerminalGood D N ν := by
+  let := hνr
+  constructor
+  · intro n j
+    exact integral_mono_measure (hdom n) (ae_of_all _ (fun _ => le_max_right _ _))
+      (D.test j ⊔ 0).integrable
+  · intro k
+    have he (n : ℕ) : (ν-N n) (D.compactSet k) =
+        ν (D.compactSet k)-N n (D.compactSet k) := by
+      let := hNr n
+      exact sub_apply_of_finite_restriction (hdom n) (D.isCompact k).measurableSet
+        (D.isCompact k).measure_lt_top.ne
+    simpa only [Function.comp_def,he] using (hlim _ (D.isCompact k)).comp (tendsto_natCast_atTop_atTop (R := ℝ≥0))
+
+namespace Multipoint
+
+theorem CanonicalMass.raw_terminal_good_set
+    {Ω : Type*} [MeasurableSpace Ω] {P : Measure Ω} {κ : ℝ}
+    {B : ℝ≥0 → Ω → ℝ} {hBm : Measurable (Function.uncurry B)}
+    {γ : Ω → ℝ≥0 → ℂ} {G : Ω → ℝ≥0 → ℂ → ℂ}
+    (C : CanonicalMass P κ B hBm γ G)
+    (hBc : ∀ ω, Continuous (fun t => B t ω))
+    (R : ℝ≥0 → C(ℝ≥0,ℝ) → Measure upperHalfPlane)
+    (hRp : IsProgressive driverPathFiltration R)
+    (hRr : ∀ t p, (R t p).Regular ∧ IsFiniteMeasureOnCompacts (R t p))
+    (he : ∀ᵐ ω ∂P, ∀ t, R t (sourceDriverPath B hBc ω)=C.process t ω) :
+    let D := localTestFamily upperHalfPlane
+    let E : Set C(ℝ≥0,ℝ) := {p | RawTerminalGood D (fun t => R t p) (rawTerminalMass R p)}
+    MeasurableSet E ∧ (∀ᵐ p ∂P.map (sourceDriverPath B hBc), p ∈ E) ∧
+    ∀ p ∈ E, Monotone (fun t => R t p) →
+      (∀ t, R t p ≤ rawTerminalMass R p) ∧
+      ∀ K : Set upperHalfPlane, IsCompact K →
+        Tendsto (fun t : ℝ≥0 => (rawTerminalMass R p-R t p) K) atTop (𝓝 0) := by
+  dsimp only
+  have hE := measurableSet_rawTerminalGood (localTestFamily upperHalfPlane) R (rawTerminalMass R)
+    (fun n => hRp.adapted.measurable (i := (n:ℝ≥0)))
+    (rawTerminalMass_measurable R hRp hRr) (fun n p => (hRr n p).1)
+    (fun p => (rawTerminalMass_radon R p).1)
+  refine ⟨hE,?_,?_⟩
+  · have hp : Measurable (sourceDriverPath B hBc) := source_path_measurable _
+      (fun t => hBm.comp (measurable_const.prodMk measurable_id))
+    apply (ae_map_iff hp.aemeasurable hE).mpr
+    filter_upwards [he,C.rawTerminal_realizes hBc R he,C.paths,C.exhaustion] with ω hω hterm hpath hex
+    simp_rw [hω,hterm]
+    exact rawTerminalGood_of_exhaustion (localTestFamily upperHalfPlane)
+      (fun t => C.process t ω) (C.rational.terminal ω)
+      (fun t => (C.radon t ω).1) (C.rational.terminal_radon ω).1 hpath.dominated hex
+  · intro p hp hm
+    exact RawTerminalGood.domination_exhaustion (localTestFamily upperHalfPlane)
+      (fun t => R t p) (rawTerminalMass R p) (fun t => (hRr t p).1)
+      (rawTerminalMass_radon R p).1 hm hp
+
+end Multipoint
+end SLEExactGauge
+
+end
+
+end OAI
diff --git a/lean/OAI/Probability/SLE/Loewner/RawTipTimeContinuity.lean b/lean/OAI/Probability/SLE/Loewner/RawTipTimeContinuity.lean
new file mode 100644
index 0000000000000000000000000000000000000000..63c67578c2086b1e63d34059b4a3dbc8103b65d1
--- /dev/null
+++ b/lean/OAI/Probability/SLE/Loewner/RawTipTimeContinuity.lean
@@ -0,0 +1,89 @@
+import OAI.Probability.SLE.Loewner.SmoothRawInverse
+import OAI.Probability.SLE.Loewner.ReverseFlowStability
+
+namespace OAI
+
+/-! Interior radial approximations to the raw tip vary continuously with
+time for a Lipschitz driver. The bound is uniform on each finite interval. -/
+noncomputable section
+open Set Filter Metric Complex
+open scoped Topology NNReal
+
+namespace SLEExactGauge
+
+lemma gronwallBound_scale_initial (δ K c t : ℝ) :
+    gronwallBound δ K (c*δ) t = δ*gronwallBound 1 K c t := by
+  unfold gronwallBound
+  split_ifs <;> ring
+
+namespace Target
+
+lemma raw_radial_time_distance (b : Driver) {L : ℝ≥0}
+    (hb : LipschitzWith L (driverValue b)) (R T S : ℝ≥0)
+    (hT : T ≤ R) (_hS : S ≤ R) {y : ℝ} (hy : 0 < y) :
+    dist (inverseFlow 1 b T ((b T : ℂ)+(y : ℂ)*I))
+      (inverseFlow 1 b S ((b S : ℂ)+(y : ℂ)*I)) ≤
+        ((L : ℝ)*gronwallBound 1 (4*y⁻¹^2) (2*y⁻¹^2) R+2*y⁻¹) * dist T S := by
+  obtain ⟨q,hq0,hqy,hqd,heq⟩ := exists_raw_reverse_trajectory b T
+    ((b T : ℂ)+(y : ℂ)*I) (by simpa [upperHalfPlane] using hy)
+  obtain ⟨r,hr0,hry,hrd,her⟩ := exists_raw_reverse_trajectory b S
+    ((b S : ℂ)+(y : ℂ)*I) (by simpa [upperHalfPlane] using hy)
+  have hdQ (t : ℝ) (ht : 0 ≤ t) : HasDerivWithinAt q
+      (reverseField y (driverValue b ((T : ℝ)-t)) (q t)) (Ici 0) t := by
+    rw [reverseField,reverseCenter_eq (by simpa using hqy t ht)]
+    exact hqd t ht
+  have hdR (t : ℝ) (ht : 0 ≤ t) : HasDerivWithinAt r
+      (reverseField y (driverValue b ((S : ℝ)-t)) (r t)) (Ici 0) t := by
+    rw [reverseField,reverseCenter_eq (by simpa using hry t ht)]
+    exact hrd t ht
+  have hinit : dist (q 0) (r 0) ≤ (L : ℝ)*dist T S := by
+    rw [hq0,hr0,dist_add_right]
+    simpa only [driverValue,Real.toNNReal_coe,dist_eq_norm,← Complex.ofReal_sub,
+      Complex.norm_real,Real.norm_eq_abs,NNReal.dist_eq] using
+      hb.dist_le_mul (T : ℝ) (S : ℝ)
+  have hsame := reverse_flow_driver_distance hy
+    (fun t => driverValue b ((T : ℝ)-t)) (fun t => driverValue b ((S : ℝ)-t))
+    q r (T : ℝ) (fun t ht => (hdQ t ht.1).mono Icc_subset_Ici_self)
+    (fun t ht => (hdR t ht.1).mono Icc_subset_Ici_self)
+    ((L : ℝ)*dist T S) hinit (fun t _ => by
+      simpa only [Real.dist_eq,sub_sub_sub_cancel_right,NNReal.dist_eq] using
+        hb.dist_le_mul ((T : ℝ)-t) ((S : ℝ)-t)) T ⟨T.coe_nonneg,le_rfl⟩
+  have hmono := gronwallBound_mono (show 0 ≤ (L : ℝ)*dist T S by positivity)
+    (show 0 ≤ 2*y⁻¹^2*((L : ℝ)*dist T S) by positivity)
+    (show 0 ≤ 4*y⁻¹^2 by positivity) (show (T : ℝ) ≤ R from hT)
+  have htime := (reverse_flow_lipschitz hy _ r hdR).dist_le_mul
+    (T : ℝ) T.coe_nonneg (S : ℝ) S.coe_nonneg
+  change dist (r (T : ℝ)) (r (S : ℝ)) ≤ (2*y⁻¹)*dist (T : ℝ) (S : ℝ) at htime
+  rw [heq,her]
+  calc
+    dist (q T) (r S) ≤ dist (q T) (r T)+dist (r T) (r S) := dist_triangle _ _ _
+    _ ≤ gronwallBound ((L : ℝ)*dist T S) (4*y⁻¹^2)
+        (2*y⁻¹^2*((L : ℝ)*dist T S)) R + (2*y⁻¹)*dist T S := by
+      exact add_le_add (hsame.trans hmono) (by simpa only [NNReal.coe_mk,NNReal.dist_eq,Real.dist_eq] using htime)
+    _ = _ := by rw [gronwallBound_scale_initial]; ring
+
+lemma continuous_raw_radial_time (b : Driver) {L : ℝ≥0}
+    (hb : LipschitzWith L (driverValue b)) {y : ℝ} (hy : 0 < y) :
+    Continuous (fun T : ℝ≥0 => inverseFlow 1 b T ((b T : ℂ)+(y : ℂ)*I)) := by
+  have hlocal (R : ℝ≥0) : ContinuousOn
+      (fun T : ℝ≥0 => inverseFlow 1 b T ((b T : ℂ)+(y : ℂ)*I)) (Iic R) := by
+    have hpos : 0 ≤ (L : ℝ)*gronwallBound 1 (4*y⁻¹^2) (2*y⁻¹^2) R+2*y⁻¹ := by
+      have hg := gronwallBound_mono (by norm_num : (0 : ℝ) ≤ 1)
+        (show 0 ≤ 2*y⁻¹^2 by positivity) (show 0 ≤ 4*y⁻¹^2 by positivity)
+        R.coe_nonneg
+      rw [gronwallBound_x0] at hg
+      positivity
+    apply LipschitzOnWith.continuousOn (K := ⟨_,hpos⟩)
+    apply LipschitzOnWith.of_dist_le_mul
+    intro T hT S hS
+    exact raw_radial_time_distance b hb R T S hT hS hy
+  apply continuous_iff_continuousAt.mpr
+  intro T
+  exact (hlocal (T+1)).continuousAt (Iic_mem_nhds (by simp))
+
+end Target
+end SLEExactGauge
+
+end
+
+end OAI
diff --git a/lean/OAI/Probability/SLE/Loewner/RealBoundaryDriverNeighborhood.lean b/lean/OAI/Probability/SLE/Loewner/RealBoundaryDriverNeighborhood.lean
new file mode 100644
index 0000000000000000000000000000000000000000..6ad28f47669e8b3261550ee97bb14de428621961
--- /dev/null
+++ b/lean/OAI/Probability/SLE/Loewner/RealBoundaryDriverNeighborhood.lean
@@ -0,0 +1,115 @@
+import OAI.Probability.SLE.Loewner.RightFieldDriverStability
+
+namespace OAI
+
+/-! A regular real Loewner trajectory has a whole surviving half-disk
+which persists under small perturbations of the driving function. -/
+noncomputable section
+open Set Filter Complex Metric MeasureTheory
+open scoped Topology NNReal
+
+namespace SLEExactGauge
+
+theorem real_boundary_driver_neighborhood_control
+    (V : ℝ≥0 → ℝ) (T : ℝ≥0) (q : ℝ → ℝ)
+    {m : ℝ} (hm : 0 < m)
+    (hgap : ∀ t ∈ Icc 0 (T : ℝ), m ≤ q t-V t.toNNReal)
+    (hqd : ∀ t ∈ Icc 0 (T : ℝ), HasDerivWithinAt q
+      (2/(q t-V t.toNNReal)) (Icc 0 (T : ℝ)) t) :
+    ∃ δ : ℝ, 0 < δ ∧ ∀ (U : ℝ≥0 → ℝ), Continuous U →
+      ∀ (γ : ℝ≥0 → ℂ) (G F : ℝ≥0 → ℂ → ℂ), IsCapacityTwoWitness U γ G F →
+      (∀ t ∈ Icc 0 T, |U t-V t| ≤ δ) →
+      ∀ z ∈ ball ((q 0 : ℝ) : ℂ) δ ∩ upperHalfPlane,
+        z ∈ survivingDomain γ T ∧ ∀ t : ℝ≥0, t ≤ T →
+          dist (G t z) (q t : ℂ) < m/4 := by
+  let a : ℝ := m/4
+  have ha : 0 < a := by dsimp [a]; positivity
+  let K : ℝ := 4*a⁻¹^2
+  let C : ℝ := 2*a⁻¹^2
+  have hcont : ContinuousAt (fun δ : ℝ => gronwallBound δ K (C*δ) T) 0 := by
+    unfold gronwallBound
+    split_ifs <;> fun_prop
+  obtain ⟨η,hη,hsmall⟩ := Metric.continuousAt_iff.mp hcont (m/4) (by positivity)
+  let δ := min (η/2) (m/4)
+  have hδ : 0 < δ := lt_min (by positivity) (by positivity)
+  have hδη : δ < η := (min_le_left _ _).trans_lt (half_lt_self hη)
+  have hδm : δ ≤ m/4 := min_le_right _ _
+  have hb : gronwallBound δ K (C*δ) T < m/4 := by
+    have hh := hsmall (show dist δ 0 < η by
+      simpa only [Real.dist_eq,sub_zero,abs_of_pos hδ] using hδη)
+    simp only [mul_zero,gronwallBound_ε0_δ0,Real.dist_eq,sub_zero] at hh
+    exact (le_abs_self _).trans_lt hh
+  refine ⟨δ,hδ,?_⟩
+  intro U hU γ G F hw hUV z hz
+  have hu : Continuous (fun t : ℝ => U t.toNNReal) := hU.comp continuous_real_toNNReal
+  obtain ⟨Y,_,hY0,hYd⟩ := exists_measurable_right_flow
+    (fun t (_ : Unit) => U t.toNNReal) (hu.measurable.comp measurable_fst)
+    (fun _ => hu) (fun _ => z) measurable_const ha
+  let Z : ℝ → ℂ := fun t => Y t ()
+  have hZ0 : Z 0=z := hY0 ()
+  have hZ (t : ℝ) (ht : t ∈ Icc 0 (T : ℝ)) : HasDerivWithinAt Z
+      (rightField a (U t.toNNReal) (Z t)) (Icc 0 (T : ℝ)) t :=
+    (hYd () t ht.1).mono Icc_subset_Ici_self
+  have hQ (t : ℝ) (ht : t ∈ Icc 0 (T : ℝ)) : HasDerivWithinAt
+      (fun s => (q s : ℂ)) (rightField a (V t.toNNReal) (q t)) (Icc 0 (T : ℝ)) t := by
+    rw [rightField_eq (show a ≤ (q t : ℂ).re-V t.toNNReal by
+      simp only [Complex.ofReal_re]; dsimp [a]; linarith [hgap t ht])]
+    have hh := Complex.ofRealCLM.hasFDerivAt.comp_hasDerivWithinAt t (hqd t ht)
+    simpa only [Function.comp_def,Complex.ofRealCLM_apply,Complex.ofReal_div,
+      Complex.ofReal_ofNat,Complex.ofReal_sub] using hh
+  have hclose (t : ℝ) (ht : t ∈ Icc 0 (T : ℝ)) : dist (Z t) (q t : ℂ) < m/4 := by
+    have he := right_flow_driver_distance ha (fun s => U s.toNNReal)
+      (fun s => V s.toNNReal) Z (fun s => (q s : ℂ)) T T.coe_nonneg hZ hQ δ
+      (by rw [hZ0]; exact (mem_ball.mp hz.1).le)
+      (fun s hs => hUV s.toNNReal ⟨zero_le,(Real.toNNReal_le_iff_le_coe).mpr hs.2⟩) t ht
+    have hmono := gronwallBound_mono hδ.le
+      (show 0 ≤ C*δ by dsimp [C]; positivity) (show 0 ≤ K by dsimp [K]; positivity) ht.2
+    exact (he.trans hmono).trans_lt hb
+  have hclip (t : ℝ) (ht : t ∈ Icc 0 (T : ℝ)) : a ≤ (Z t).re-U t.toNNReal := by
+    have hr := Complex.abs_re_le_norm (Z t-(q t : ℂ))
+    have he := hclose t ht
+    rw [dist_eq_norm] at he
+    have hreal : |(Z t).re-q t| < m/4 := by
+      simpa only [Complex.sub_re,Complex.ofReal_re] using hr.trans_lt he
+    have hd := hUV t.toNNReal ⟨zero_le,(Real.toNNReal_le_iff_le_coe).mpr ht.2⟩
+    dsimp [a]
+    linarith [(abs_lt.mp hreal).1,(abs_le.mp hd).2,hgap t ht]
+  have hpos (t : ℝ) (ht : t ∈ Icc 0 (T : ℝ)) : 0 < (Z t).im := by
+    apply right_flow_im_pos hu ha ht.1
+    · intro s hs
+      exact (hZ s ⟨hs.1,hs.2.trans ht.2⟩).mono
+        (Icc_subset_Icc le_rfl ht.2)
+    · simpa only [hZ0,upperHalfPlane,mem_ofPred_eq] using hz.2
+  have hode (t : ℝ) (ht : t ∈ Icc 0 (T : ℝ)) : HasDerivWithinAt Z
+      (2/(Z t-(U t.toNNReal : ℂ))) (Icc 0 (T : ℝ)) t := by
+    rw [← rightField_eq (hclip t ht)]
+    exact hZ t ht
+  have hs := (hw.forward_flow_survives T Z hpos hode).1
+  refine ⟨by simpa only [hZ0] using hs,?_⟩
+  intro t ht
+  have hsub : Icc 0 (t : ℝ) ⊆ Icc 0 (T : ℝ) :=
+    Icc_subset_Icc le_rfl (by exact_mod_cast ht)
+  have he := (hw.forward_flow_survives t Z
+    (fun s hs => hpos s (hsub hs))
+    (fun s hs => (hode s (hsub hs)).mono hsub)).2
+  rw [hZ0] at he
+  rw [he]
+  exact hclose t ⟨t.coe_nonneg,by exact_mod_cast ht⟩
+
+theorem real_boundary_driver_neighborhood
+    (V : ℝ≥0 → ℝ) (T : ℝ≥0) (q : ℝ → ℝ) {m : ℝ} (hm : 0 < m)
+    (hgap : ∀ t ∈ Icc 0 (T : ℝ), m ≤ q t-V t.toNNReal)
+    (hqd : ∀ t ∈ Icc 0 (T : ℝ), HasDerivWithinAt q
+      (2/(q t-V t.toNNReal)) (Icc 0 (T : ℝ)) t) :
+    ∃ δ : ℝ, 0 < δ ∧ ∀ (U : ℝ≥0 → ℝ), Continuous U →
+      ∀ (γ : ℝ≥0 → ℂ) (G F : ℝ≥0 → ℂ → ℂ), IsCapacityTwoWitness U γ G F →
+      (∀ t ∈ Icc 0 T, |U t-V t| ≤ δ) →
+      ball ((q 0 : ℝ) : ℂ) δ ∩ upperHalfPlane ⊆ survivingDomain γ T := by
+  obtain ⟨δ,hδ,hh⟩ := real_boundary_driver_neighborhood_control V T q hm hgap hqd
+  exact ⟨δ,hδ,fun U hU γ G F hw hUV z hz => (hh U hU γ G F hw hUV z hz).1⟩
+
+end SLEExactGauge
+
+end
+
+end OAI
diff --git a/lean/OAI/Probability/SLE/Loewner/RealBoundaryTraceAvoidance.lean b/lean/OAI/Probability/SLE/Loewner/RealBoundaryTraceAvoidance.lean
new file mode 100644
index 0000000000000000000000000000000000000000..b746e4050ba3b8939709c9019cfbe32935f7fd1c
--- /dev/null
+++ b/lean/OAI/Probability/SLE/Loewner/RealBoundaryTraceAvoidance.lean
@@ -0,0 +1,60 @@
+import OAI.Probability.SLE.Loewner.RealBoundaryDriverNeighborhood
+
+namespace OAI
+
+/-! A regular real characteristic excludes an entire neighborhood from
+the perturbed trace, including its real boundary points. -/
+noncomputable section
+open Set Filter Complex Metric
+open scoped Topology NNReal
+
+namespace SLEExactGauge
+
+theorem real_boundary_driver_trace_avoidance
+    (V : ℝ≥0 → ℝ) (T : ℝ≥0) (q : ℝ → ℝ) {m : ℝ} (hm : 0 < m)
+    (hgap : ∀ t ∈ Icc 0 (T : ℝ), m ≤ q t-V t.toNNReal)
+    (hqd : ∀ t ∈ Icc 0 (T : ℝ), HasDerivWithinAt q
+      (2/(q t-V t.toNNReal)) (Icc 0 (T : ℝ)) t) :
+    ∃ ε : ℝ, 0 < ε ∧ ∀ (U : ℝ≥0 → ℝ), Continuous U →
+      ∀ (γ : ℝ≥0 → ℂ) (G F : ℝ≥0 → ℂ → ℂ), IsCapacityTwoWitness U γ G F →
+      (∀ t ∈ Icc 0 T, |U t-V t| ≤ ε) →
+      ∀ t ∈ Icc 0 T, γ t ∉ ball ((q 0 : ℝ) : ℂ) ε := by
+  obtain ⟨δ,hδ,hcontrol⟩ := real_boundary_driver_neighborhood_control V T q hm hgap hqd
+  let ε := min δ (m/4)
+  have hε : 0 < ε := lt_min hδ (by positivity)
+  refine ⟨ε,hε,?_⟩
+  intro U hU γ G F hw hUV t ht hball
+  have hUVδ : ∀ s ∈ Icc 0 T, |U s-V s| ≤ δ :=
+    fun s hs => (hUV s hs).trans (min_le_left _ _)
+  have hballδ : γ t ∈ ball ((q 0 : ℝ) : ℂ) δ :=
+    (ball_subset_ball (min_le_left _ _)) hball
+  have hnear : ∀ᶠ y : ℝ in 𝓝[>] 0,
+      F t ((U t : ℂ)+(y : ℂ)*I) ∈ ball ((q 0 : ℝ) : ℂ) δ :=
+    (hw.2.2.2.2.2.2.2.2.2.2.2.2 t).eventually (isOpen_ball.mem_nhds hballδ)
+  have he : ∀ᶠ y : ℝ in 𝓝[>] 0,
+      dist ((U t : ℂ)+(y : ℂ)*I) (q t : ℂ) ≤ m/4 := by
+    filter_upwards [hnear,self_mem_nhdsWithin] with y hy hy0
+    have hwH : (U t : ℂ)+(y : ℂ)*I ∈ upperHalfPlane := by
+      simpa [upperHalfPlane] using hy0
+    have hzH := (hw.2.2.2.2.2.2.1 t hwH).1.1
+    have hh := (hcontrol U hU γ G F hw hUVδ _ ⟨hy,hzH⟩).2 t ht.2
+    rw [hw.2.2.2.2.2.2.2.2.1 t _ hwH] at hh
+    exact hh.le
+  have hd : Tendsto (fun y : ℝ => dist ((U t : ℂ)+(y : ℂ)*I) (q t : ℂ))
+      (𝓝[>] 0) (𝓝 (dist (U t : ℂ) (q t : ℂ))) := by
+    have hc : Continuous (fun y : ℝ => dist ((U t : ℂ)+(y : ℂ)*I) (q t : ℂ)) := by fun_prop
+    simpa only [Complex.ofReal_zero,zero_mul,add_zero] using
+      (hc.tendsto 0).mono_left nhdsWithin_le_nhds
+  have hb := le_of_tendsto hd he
+  have hr : |U t-q t| ≤ m/4 := by
+    simpa only [dist_eq_norm,← Complex.ofReal_sub,Complex.norm_real,Real.norm_eq_abs] using hb
+  have hg : m ≤ q t-V t := by
+    simpa only [Real.toNNReal_coe] using hgap t ⟨t.coe_nonneg,by exact_mod_cast ht.2⟩
+  have hu : |U t-V t| ≤ m/4 := (hUV t ht).trans (min_le_right _ _)
+  linarith [(abs_le.mp hr).1,(abs_le.mp hu).2]
+
+end SLEExactGauge
+
+end
+
+end OAI
diff --git a/lean/OAI/Probability/SLE/Loewner/RealCharacteristicAvoidance.lean b/lean/OAI/Probability/SLE/Loewner/RealCharacteristicAvoidance.lean
new file mode 100644
index 0000000000000000000000000000000000000000..9385328fb87dff448181aa7059fb9f108cd61a79
--- /dev/null
+++ b/lean/OAI/Probability/SLE/Loewner/RealCharacteristicAvoidance.lean
@@ -0,0 +1,85 @@
+import OAI.Probability.SLE.Geometry.StableTraceAvoidance
+
+namespace OAI
+
+/-! Both signs of a noncolliding real characteristic give stable trace
+avoidance. A continuous real characteristic cannot change sides of the
+driver without colliding with it. -/
+noncomputable section
+open Set Filter Metric Complex
+open scoped Topology NNReal
+
+namespace SLEExactGauge
+
+lemma StableTraceAvoidance.of_mirror
+    {V : ℝ≥0 → ℝ} {T : ℝ≥0} {z : ℂ}
+    (h : StableTraceAvoidance (fun t => -V t) T (loewnerMirror z)) :
+    StableTraceAvoidance V T z := by
+  obtain ⟨r,δ,hr,hδ,hh⟩ := h
+  refine ⟨r,δ,hr,hδ,?_⟩
+  intro U hU γ G F hw hUV t ht hb
+  have hneg : ∀ s ∈ Icc 0 T, |-U s-(-V s)| ≤ δ := by
+    intro s hs
+    simpa only [neg_sub_neg,abs_sub_comm] using hUV s hs
+  apply hh (fun t => -U t) hU.neg (loewnerMirror ∘ γ)
+    (fun t z => loewnerMirror (G t (loewnerMirror z)))
+    (fun t z => loewnerMirror (F t (loewnerMirror z))) hw.mirror
+    hneg t ht
+  simpa only [Function.comp_apply,mem_ball,loewnerMirror_dist] using hb
+
+lemma real_characteristic_one_side
+    (V : ℝ≥0 → ℝ) (hV : Continuous V) (T : ℝ≥0) (q : ℝ → ℝ)
+    (hq : ContinuousOn q (Icc 0 (T : ℝ)))
+    (hn : ∀ t ∈ Icc 0 (T : ℝ), q t-V t.toNNReal ≠ 0)
+    (h0 : 0 < q 0-V 0) :
+    ∀ t ∈ Icc 0 (T : ℝ), 0 < q t-V t.toNNReal := by
+  intro t ht
+  by_contra hh
+  have hc : ContinuousOn (fun s => -(q s-V s.toNNReal)) (Icc 0 (T : ℝ)) :=
+    (hq.sub (hV.comp continuous_real_toNNReal).continuousOn).neg
+  obtain ⟨s,hs,he⟩ := intermediate_value_Icc ht.1
+    (hc.mono (Icc_subset_Icc le_rfl ht.2))
+    (show (0 : ℝ) ∈ Icc (-(q 0-V (Real.toNNReal 0))) (-(q t-V t.toNNReal)) by
+      simp only [Real.toNNReal_zero]
+      exact ⟨by linarith,by linarith⟩)
+  exact hn s ⟨hs.1,hs.2.trans ht.2⟩ (neg_eq_zero.mp he)
+
+theorem stableTraceAvoidance_of_real_characteristic
+    (V : ℝ≥0 → ℝ) (hV : Continuous V) (T : ℝ≥0) (q : ℝ → ℝ)
+    (hqd : ∀ t ∈ Icc 0 (T : ℝ), HasDerivWithinAt q
+      (2/(q t-V t.toNNReal)) (Icc 0 (T : ℝ)) t)
+    (hn : ∀ t ∈ Icc 0 (T : ℝ), q t-V t.toNNReal ≠ 0) :
+    StableTraceAvoidance V T (q 0 : ℂ) := by
+  have hq : ContinuousOn q (Icc 0 (T : ℝ)) :=
+    fun t ht => (hqd t ht).continuousWithinAt
+  have h0 : q 0-V 0 ≠ 0 := by simpa only [Real.toNNReal_zero] using hn 0 ⟨le_rfl,T.coe_nonneg⟩
+  rcases lt_or_gt_of_ne h0 with hneg | hpos
+  · have hnd (t : ℝ) (ht : t ∈ Icc 0 (T : ℝ)) : HasDerivWithinAt
+        (fun s => -q s) (2/(-q t-(-V t.toNNReal))) (Icc 0 (T : ℝ)) t := by
+      rw [show -q t-(-V t.toNNReal)=-(q t-V t.toNNReal) by ring,div_neg]
+      exact (hqd t ht).neg
+    have hnn (t : ℝ) (ht : t ∈ Icc 0 (T : ℝ)) : -q t-(-V t.toNNReal) ≠ 0 := by
+      rw [show -q t-(-V t.toNNReal)=-(q t-V t.toNNReal) by ring]
+      exact neg_ne_zero.mpr (hn t ht)
+    have hside := real_characteristic_one_side (fun t => -V t) hV.neg T
+      (fun s => -q s) hq.neg hnn (by linarith)
+    have hc : ContinuousOn (fun s => -q s-(-V s.toNNReal)) (Icc 0 (T : ℝ)) :=
+      hq.neg.sub ((hV.comp continuous_real_toNNReal).neg.continuousOn)
+    obtain ⟨s,hs,hmin⟩ := isCompact_Icc.exists_isMinOn
+      (nonempty_Icc.mpr T.coe_nonneg) hc
+    have hp := stableTraceAvoidance_of_real_trajectory (fun t => -V t) T (fun s => -q s)
+      (hside s hs) hmin hnd
+    apply StableTraceAvoidance.of_mirror
+    simpa only [loewnerMirror_apply,Complex.conj_ofReal,Complex.ofReal_neg] using hp
+  · have hside := real_characteristic_one_side V hV T q hq hn hpos
+    have hc : ContinuousOn (fun s => q s-V s.toNNReal) (Icc 0 (T : ℝ)) :=
+      hq.sub (hV.comp continuous_real_toNNReal).continuousOn
+    obtain ⟨s,hs,hmin⟩ := isCompact_Icc.exists_isMinOn
+      (nonempty_Icc.mpr T.coe_nonneg) hc
+    exact stableTraceAvoidance_of_real_trajectory V T q (hside s hs) hmin hqd
+
+end SLEExactGauge
+
+end
+
+end OAI
diff --git a/lean/OAI/Probability/SLE/Loewner/ReflectedCapacityChart.lean b/lean/OAI/Probability/SLE/Loewner/ReflectedCapacityChart.lean
new file mode 100644
index 0000000000000000000000000000000000000000..ad0fd925a6d90e8878b7652d5b0c6eeb5ae00703
--- /dev/null
+++ b/lean/OAI/Probability/SLE/Loewner/ReflectedCapacityChart.lean
@@ -0,0 +1,94 @@
+import OAI.Probability.SLE.Loewner.SlitChartUniqueness
+
+namespace OAI
+
+/-! Retain the reflected Riemann-map data of a normalized slit chart, so
+that its analytic continuation outside the reflected slit is available
+for the local evolution estimates. -/
+noncomputable section
+open Set Filter Function Complex Metric
+open scoped Topology ComplexConjugate
+
+namespace SLEExactGauge
+
+structure ReflectedCapacityChart (p : C(unitInterval,ℂ)) where
+  chart : SimpleSlitChart p
+  diskMap : ℂ → ℂ
+  slope : ℝ
+  slope_pos : 0<slope
+  disk_bijOn : BijOn diskMap (invertedExterior (reflectedArcSet p)) (ball 0 1)
+  disk_differentiable : DifferentiableOn ℂ diskMap (invertedExterior (reflectedArcSet p))
+  disk_zero : diskMap 0=0
+  disk_derivative : deriv diskMap 0=(slope:ℂ)
+  disk_reflection : ∀ z∈invertedExterior (reflectedArcSet p), diskMap (conj z)=conj (diskMap z)
+  forward_eq : chart.forward=slitHydrodynamicMap diskMap slope
+
+theorem exists_reflectedCapacityChart (p : C(unitInterval,ℂ)) (hi : Injective p)
+    (h0 : p 0=0) (hH : ∀ t : unitInterval, t≠0 → p t∈upperHalfPlane) :
+    Nonempty (ReflectedCapacityChart p) := by
+  obtain ⟨f,a,ha,hb,hf,hf0,hfa,hs,hu⟩ := reflected_slit_exists_normalized_chart p hi h0 hH
+  have hK : IsCompact (reflectedArcSet p) := (isCompact_range p.continuous).union
+    ((isCompact_range p.continuous).image Complex.continuous_conj)
+  have hD : invertedExterior (reflectedArcSet p)∈𝓝 (0:ℂ) :=
+    (invertedExterior_isOpen hK).mem_nhds (zero_mem_invertedExterior _)
+  have hreal := eq_ofReal_re_of_conj_eq (derivative_real_of_reflection hD
+    (slitInfinityFactor_reflection hD hs a))
+  let G := slitHydrodynamicMap f a
+  have hG : BijOn G (upperHalfPlane \ range p) upperHalfPlane := by
+    apply ((positive_real_affine_halfPlane ha (deriv (slitInfinityFactor f a) 0).re).comp
+      (exteriorJoukowski_bijOn.comp (slitExteriorMap_bijOn p h0 hH hs hu))).congr
+    intro z _
+    change (a:ℂ)*exteriorJoukowski (slitExteriorMap f z)-
+      ((deriv (slitInfinityFactor f a) 0).re:ℂ)=
+      (a:ℂ)*exteriorJoukowski (slitExteriorMap f z)-deriv (slitInfinityFactor f a) 0
+    rw [← hreal]
+  have hdG : DifferentiableOn ℂ G (upperHalfPlane \ range p) :=
+    ((exteriorJoukowski_differentiableOn.comp
+      (slitExteriorMap_differentiableOn p h0 hH hf hb.injOn hf0)
+      (slitExteriorMap_bijOn p h0 hH hs hu).mapsTo).const_mul (a:ℂ)).sub_const _
+  let F := invFunOn G (upperHalfPlane \ range p)
+  have ho : IsOpen (upperHalfPlane \ range p) :=
+    isOpen_upperHalfPlane.sdiff (isCompact_range p.continuous).isClosed
+  have hdF : DifferentiableOn ℂ F upperHalfPlane := by
+    simpa only [F,hG.image_eq] using hdG.invFunOn ho hG.injOn
+  have hmF : MapsTo F upperHalfPlane (upperHalfPlane \ range p) := hG.surjOn.mapsTo_invFunOn
+  have hl : ∀ z∈upperHalfPlane \ range p, F (G z)=z := hG.injOn.leftInvOn_invFunOn
+  have hr : ∀ z∈upperHalfPlane, G (F z)=z := hG.surjOn.rightInvOn_invFunOn
+  have hn := slit_inverse_tendsto_ratio p h0 hH ha hf hf0 hfa hs F hl
+  have hheight := normalized_inverse_height hG.mapsTo hdF
+    (hmF.mono_right sdiff_subset) hl hn
+  let c := (deriv (dslope (slitInfinityFactor f a) 0) 0).re
+  have hc : Tendsto (fun z : ℂ => z*(G z-z)) (cocompact ℂ) (𝓝 (c:ℂ)) := by
+    have hh := slitExteriorMap_laurent_limit (hf.analyticAt hD) hf0 ha.ne' hfa
+    have he := eq_ofReal_re_of_conj_eq (derivative_real_of_reflection hD
+      (dslope_reflection hD (slitInfinityFactor_reflection hD hs a)))
+    rw [he] at hh
+    exact hh
+  have hc0 : 0≤c := by
+    apply hydrodynamic_coefficient_nonneg hc
+    rw [eventually_inf_principal]
+    filter_upwards [(isCompact_range p.continuous).compl_mem_cocompact] with z hz
+    exact fun hzH => hheight z ⟨hzH,hz⟩
+  have hcpos : 0<c := by
+    by_contra hnot
+    have hec : c=0 := le_antisymm (le_of_not_gt hnot) hc0
+    have hfcoef := inverse_hydrodynamic_coefficient hc hn hr
+    rw [hec,ofReal_zero,neg_zero] at hfcoef
+    have hh := holomorphic_zero_hydrodynamic_mass (hdF.sub differentiableOn_id)
+      (fun z hz => by
+        change 0≤(F z-z).im
+        simpa only [sub_im] using sub_nonneg.mpr
+          (normalized_halfPlane_height hdF (hmF.mono_right sdiff_subset) hn hz)) hfcoef
+    have hp1 : p 1∈upperHalfPlane := hH 1 (by norm_num)
+    have hFeq : F (p 1)=p 1 := sub_eq_zero.mp (hh (p 1) hp1)
+    have hmem := hmF hp1
+    rw [hFeq] at hmem
+    exact hmem.2 (mem_range_self 1)
+  let Q : SimpleSlitChart p := ⟨G,F,c,hcpos,hG,hdG,hdF,hmF,hl,hr,hc,hn,hheight⟩
+  exact ⟨⟨Q,f,a,ha,hb,hf,hf0,hfa,hs,rfl⟩⟩
+
+end SLEExactGauge
+
+end
+
+end OAI
diff --git a/lean/OAI/Probability/SLE/Loewner/ReflectedChartLocalBound.lean b/lean/OAI/Probability/SLE/Loewner/ReflectedChartLocalBound.lean
new file mode 100644
index 0000000000000000000000000000000000000000..cfbc22d5de17d03162fae32b627c7c95e250cf3c
--- /dev/null
+++ b/lean/OAI/Probability/SLE/Loewner/ReflectedChartLocalBound.lean
@@ -0,0 +1,117 @@
+import OAI.Probability.SLE.Loewner.ReflectedExteriorAnalytic
+import OAI.Probability.SLE.Loewner.UnivalentLocalBound
+import OAI.Probability.SLE.Loewner.SlitCapacityRemainder
+
+namespace OAI
+
+/-! Coarse uniform control of the reflected chart near a small slit.
+Only a fixed numerical constant is needed for driver continuity. -/
+noncomputable section
+open Set Filter Function Complex Metric
+open scoped Topology
+
+namespace SLEExactGauge
+
+lemma reflected_disk_ball_subset {p : C(unitInterval,ℂ)} {L : ℝ} (hL : 0<L)
+    (hp : ∀ t : unitInterval, ‖p t‖<L) :
+    ball (0:ℂ) (1/L) ⊆ invertedExterior (reflectedArcSet p) := by
+  intro w hw
+  by_cases hw0 : w=0
+  · exact Or.inl hw0
+  apply Or.inr
+  intro hmem
+  have hn := norm_pos_iff.mpr hw0
+  have hw' : ‖w‖<1/L := mem_ball_zero_iff.mp hw
+  have hinv : L<‖w⁻¹‖ := by
+    rw [norm_inv,inv_eq_one_div]
+    apply (lt_div_iff₀ hn).mpr
+    have hh := (lt_div_iff₀ hL).mp hw'
+    nlinarith
+  exact (not_lt_of_ge hinv.le) (reflectedArcSet_norm_lt hp hmem)
+
+lemma ReflectedCapacityChart.slope_le_radius {p : C(unitInterval,ℂ)}
+    (Q : ReflectedCapacityChart p) {L : ℝ} (hL : 0<L)
+    (hp : ∀ t : unitInterval, ‖p t‖<L) : Q.slope≤L := by
+  have hsub := reflected_disk_ball_subset hL hp
+  have hm : MapsTo Q.diskMap (ball 0 (1/L)) (closedBall (Q.diskMap 0) 1) := by
+    intro w hw
+    rw [Q.disk_zero]
+    exact ball_subset_closedBall (Q.disk_bijOn.mapsTo (hsub hw))
+  have hh := Complex.norm_deriv_le_div_of_mapsTo_ball (Q.disk_differentiable.mono hsub)
+    hm (one_div_pos.mpr hL)
+  simpa only [Q.disk_derivative,Complex.norm_real,Real.norm_eq_abs,
+    abs_of_pos Q.slope_pos,one_div_one_div] using hh
+
+lemma ReflectedCapacityChart.diskMap_lower {p : C(unitInterval,ℂ)}
+    (Q : ReflectedCapacityChart p) (h0 : p 0=0) {L : ℝ} (hL : 0<L)
+    (hp : ∀ t : unitInterval, ‖p t‖<L) {z : ℂ}
+    (hz : z∉reflectedArcSet p) (hzL : ‖z‖≤L) :
+    (1/L)*Q.slope/(128*Real.pi)≤‖Q.diskMap z⁻¹‖ := by
+  have hsub := reflected_disk_ball_subset hL hp
+  have hd := Q.disk_differentiable.mono hsub
+  have hi := Q.disk_bijOn.injOn.mono hsub
+  have hc := univalent_coarse_ball_subset_image (one_div_pos.mpr hL) hd hi
+  rw [Q.disk_zero,Q.disk_derivative,Complex.norm_real,Real.norm_eq_abs,
+    abs_of_pos Q.slope_pos] at hc
+  by_contra hn
+  have hsmall : Q.diskMap z⁻¹∈ball (0:ℂ) ((1/L)*Q.slope/(128*Real.pi)) :=
+    mem_ball_zero_iff.mpr (lt_of_not_ge hn)
+  obtain ⟨w,hw,he⟩ := hc hsmall
+  have hew : w=z⁻¹ := Q.disk_bijOn.injOn (hsub hw) (Q.inverse_mem hz) he
+  rw [hew] at hw
+  have hz0 : z≠0 := by
+    intro hez
+    subst z
+    exact hz (Or.inl ⟨0,h0⟩)
+  have hzn := norm_pos_iff.mpr hz0
+  have hh : ‖z‖⁻¹<1/L := by simpa only [mem_ball_zero_iff,norm_inv] using hw
+  have hmul := (lt_div_iff₀ hL).mp hh
+  have hmul' := mul_lt_mul_of_pos_right hmul hzn
+  have hid : ‖z‖⁻¹*L*‖z‖=L := by field_simp
+  rw [hid,one_mul] at hmul'
+  exact (not_lt_of_ge hzL) hmul'
+
+lemma ReflectedCapacityChart.exterior_scaled_bound {p : C(unitInterval,ℂ)}
+    (Q : ReflectedCapacityChart p) (h0 : p 0=0) {L : ℝ} (hL : 0<L)
+    (hp : ∀ t : unitInterval, ‖p t‖<L) {z : ℂ}
+    (hz : z∉reflectedArcSet p) (hzL : ‖z‖≤L) :
+    Q.slope*‖slitExteriorMap Q.diskMap z‖≤(128*Real.pi)*L := by
+  have hb := Q.diskMap_lower h0 hL hp hz hzL
+  have hC : 0<128*Real.pi := by positivity
+  have hz0 : z≠0 := fun he => hz (Or.inl ⟨0,h0.trans he.symm⟩)
+  have hf0 : Q.diskMap z⁻¹≠0 := by
+    intro he
+    exact inv_ne_zero hz0 (Q.disk_bijOn.injOn (Q.inverse_mem hz)
+      (zero_mem_invertedExterior _) (he.trans Q.disk_zero.symm))
+  have hfn : 0<‖Q.diskMap z⁻¹‖ := norm_pos_iff.mpr hf0
+  change Q.slope*‖(Q.diskMap z⁻¹)⁻¹‖≤(128*Real.pi)*L
+  rw [norm_inv,←div_eq_mul_inv]
+  apply (div_le_iff₀ hfn).mpr
+  have hmul := mul_le_mul_of_nonneg_right ((div_le_iff₀ hC).mp hb) hL.le
+  have he : (1/L)*Q.slope*L=Q.slope := by field_simp
+  rw [he] at hmul
+  nlinarith
+
+lemma ReflectedCapacityChart.joukowski_scaled_bound {p : C(unitInterval,ℂ)}
+    (Q : ReflectedCapacityChart p) (h0 : p 0=0) {L : ℝ} (hL : 0<L)
+    (hp : ∀ t : unitInterval, ‖p t‖<L) {z : ℂ}
+    (hz : z∉reflectedArcSet p) (hzL : ‖z‖≤L) :
+    ‖(Q.slope:ℂ)*exteriorJoukowski (slitExteriorMap Q.diskMap z)‖≤
+      (128*Real.pi+1)*L := by
+  have hW := Q.exterior_norm h0 hz
+  have hi : ‖(slitExteriorMap Q.diskMap z)⁻¹‖≤1 := by
+    rw [norm_inv,inv_eq_one_div]
+    exact (div_le_one (lt_trans zero_lt_one hW)).mpr hW.le
+  have ht := norm_add_le (slitExteriorMap Q.diskMap z) (slitExteriorMap Q.diskMap z)⁻¹
+  change ‖(Q.slope:ℂ)*(slitExteriorMap Q.diskMap z+(slitExteriorMap Q.diskMap z)⁻¹)‖≤_
+  rw [norm_mul,Complex.norm_real,Real.norm_eq_abs,abs_of_pos Q.slope_pos]
+  have hb := Q.exterior_scaled_bound h0 hL hp hz hzL
+  have ha := Q.slope_le_radius hL hp
+  nlinarith [mul_le_mul_of_nonneg_left ht Q.slope_pos.le,
+    mul_le_mul_of_nonneg_left hi Q.slope_pos.le]
+
+end SLEExactGauge
+
+end
+
+end OAI
diff --git a/lean/OAI/Probability/SLE/Loewner/ReflectedExteriorAnalytic.lean b/lean/OAI/Probability/SLE/Loewner/ReflectedExteriorAnalytic.lean
new file mode 100644
index 0000000000000000000000000000000000000000..f318514d4ff4da41fb856d02299053fa5afe8595
--- /dev/null
+++ b/lean/OAI/Probability/SLE/Loewner/ReflectedExteriorAnalytic.lean
@@ -0,0 +1,81 @@
+import OAI.Probability.SLE.Loewner.ReflectedCapacityChart
+
+namespace OAI
+
+/-! The retained chart is univalent and holomorphic on the full
+complement of the reflected slit, not only on its upper side. -/
+noncomputable section
+open Set Function Filter Complex Metric
+open scoped Topology ComplexConjugate
+
+namespace SLEExactGauge
+
+lemma ReflectedCapacityChart.inverse_mem {p : C(unitInterval,ℂ)} (_R : ReflectedCapacityChart p)
+    {z : ℂ} (hz : z∉reflectedArcSet p) : z⁻¹∈invertedExterior (reflectedArcSet p) := by
+  exact Or.inr (by simpa only [inv_inv] using hz)
+
+lemma ReflectedCapacityChart.exterior_norm {p : C(unitInterval,ℂ)} (R : ReflectedCapacityChart p)
+    (h0 : p 0=0) {z : ℂ} (hz : z∉reflectedArcSet p) :
+    1<‖slitExteriorMap R.diskMap z‖ := by
+  have hz0 : z≠0 := by
+    intro he
+    subst z
+    exact hz (Or.inl ⟨0,h0⟩)
+  have hm := R.inverse_mem hz
+  have hn : ‖R.diskMap z⁻¹‖<1 := by
+    simpa only [mem_ball_zero_iff] using R.disk_bijOn.mapsTo hm
+  have hf0 : R.diskMap z⁻¹≠0 := by
+    intro he
+    have hh := R.disk_bijOn.injOn hm (zero_mem_invertedExterior _) (he.trans R.disk_zero.symm)
+    exact inv_ne_zero hz0 hh
+  change 1<‖(R.diskMap z⁻¹)⁻¹‖
+  rw [norm_inv]
+  exact (one_lt_inv₀ (norm_pos_iff.mpr hf0)).mpr hn
+
+theorem ReflectedCapacityChart.forward_differentiable {p : C(unitInterval,ℂ)}
+    (R : ReflectedCapacityChart p) (h0 : p 0=0) :
+    DifferentiableOn ℂ R.chart.forward (reflectedArcSet p)ᶜ := by
+  intro z hz
+  have hz0 : z≠0 := by
+    intro he
+    subst z
+    exact hz (Or.inl ⟨0,h0⟩)
+  have hK : IsCompact (reflectedArcSet p) := (isCompact_range p.continuous).union
+    ((isCompact_range p.continuous).image Complex.continuous_conj)
+  have hm := R.inverse_mem hz
+  have hf := (R.disk_differentiable.differentiableAt
+    ((invertedExterior_isOpen hK).mem_nhds hm)).comp z (differentiableAt_id.inv hz0)
+  have hf0 : R.diskMap z⁻¹≠0 := by
+    intro he
+    exact inv_ne_zero hz0 (R.disk_bijOn.injOn hm (zero_mem_invertedExterior _)
+      (he.trans R.disk_zero.symm))
+  have hh := (((hf.inv hf0).add hf).const_mul (R.slope:ℂ)).sub_const
+    (deriv (slitInfinityFactor R.diskMap R.slope) 0)
+  change DifferentiableAt ℂ (fun y : ℂ => (R.slope:ℂ)*
+    ((R.diskMap y⁻¹)⁻¹+R.diskMap y⁻¹)-deriv (slitInfinityFactor R.diskMap R.slope) 0) z at hh
+  rw [R.forward_eq]
+  have he : slitHydrodynamicMap R.diskMap R.slope = fun y : ℂ => (R.slope:ℂ)*
+      ((R.diskMap y⁻¹)⁻¹+R.diskMap y⁻¹)-deriv (slitInfinityFactor R.diskMap R.slope) 0 := by
+    funext y
+    simp only [slitHydrodynamicMap,exteriorJoukowski,slitExteriorMap,inv_inv]
+  rw [he]
+  exact hh.differentiableWithinAt
+
+theorem ReflectedCapacityChart.forward_injOn {p : C(unitInterval,ℂ)}
+    (R : ReflectedCapacityChart p) (h0 : p 0=0) :
+    InjOn R.chart.forward (reflectedArcSet p)ᶜ := by
+  intro z hz w hw he
+  rw [R.forward_eq] at he
+  have hj : exteriorJoukowski (slitExteriorMap R.diskMap z)=
+      exteriorJoukowski (slitExteriorMap R.diskMap w) := by
+    apply mul_left_cancel₀ (ofReal_ne_zero.mpr R.slope_pos.ne')
+    exact sub_left_inj.mp he
+  have hW := exteriorJoukowski_injOn (R.exterior_norm h0 hz) (R.exterior_norm h0 hw) hj
+  have hf := inv_injective hW
+  exact inv_injective (R.disk_bijOn.injOn (R.inverse_mem hz) (R.inverse_mem hw) hf)
+
+end SLEExactGauge
+
+end
+
+end OAI
diff --git a/lean/OAI/Probability/SLE/Loewner/ReflectedExteriorHeight.lean b/lean/OAI/Probability/SLE/Loewner/ReflectedExteriorHeight.lean
new file mode 100644
index 0000000000000000000000000000000000000000..998aba1404d91a459fb9eb5baa0465656a129b73
--- /dev/null
+++ b/lean/OAI/Probability/SLE/Loewner/ReflectedExteriorHeight.lean
@@ -0,0 +1,54 @@
+import OAI.Probability.SLE.Loewner.ReflectedExteriorAnalytic
+
+namespace OAI
+
+/-! Reflection supplies the lower-half-plane version of the normalized
+height inequality. -/
+noncomputable section
+open Set Filter Function Complex Metric
+open scoped Topology ComplexConjugate
+
+namespace SLEExactGauge
+
+lemma ReflectedCapacityChart.forward_reflection {p : C(unitInterval,ℂ)}
+    (R : ReflectedCapacityChart p) {z : ℂ} (hz : z∉reflectedArcSet p) :
+    R.chart.forward (conj z)=conj (R.chart.forward z) := by
+  have hK : IsCompact (reflectedArcSet p) := (isCompact_range p.continuous).union
+    ((isCompact_range p.continuous).image Complex.continuous_conj)
+  have hD := (invertedExterior_isOpen hK).mem_nhds (zero_mem_invertedExterior _)
+  have hd := derivative_real_of_reflection hD
+    (slitInfinityFactor_reflection hD R.disk_reflection R.slope)
+  have hf : R.diskMap ((conj z)⁻¹)=conj (R.diskMap z⁻¹) := by
+    simpa only [map_inv₀] using R.disk_reflection z⁻¹ (R.inverse_mem hz)
+  rw [R.forward_eq]
+  simp only [slitHydrodynamicMap,exteriorJoukowski,slitExteriorMap,
+    map_inv₀,inv_inv,map_sub,map_mul,map_add,conj_ofReal,hd,hf]
+
+lemma ReflectedCapacityChart.height_displacement_sign {p : C(unitInterval,ℂ)}
+    (R : ReflectedCapacityChart p) {z : ℂ} (hz : z∉reflectedArcSet p) :
+    z.im*(R.chart.forward z-z).im≤0 := by
+  rcases lt_trichotomy z.im 0 with hneg|heq|hpos
+  · have hcz : conj z∉reflectedArcSet p := by
+      intro hh
+      have hh' := reflectedArcSet_conj p hh
+      exact hz (by simpa only [conj_conj] using hh')
+    have hH : conj z∈upperHalfPlane := by
+      change 0<(conj z).im
+      simpa only [conj_im] using neg_pos.mpr hneg
+    have hn : conj z∉range p := fun hh => hcz (Or.inl hh)
+    have hh := R.chart.height_le (conj z) ⟨hH,hn⟩
+    rw [R.forward_reflection hz] at hh
+    simp only [conj_im] at hh
+    apply mul_nonpos_of_nonpos_of_nonneg hneg.le
+    simp only [sub_im]
+    linarith
+  · simp only [heq,zero_mul,le_refl]
+  · have hn : z∉range p := fun hh => hz (Or.inl hh)
+    exact mul_nonpos_of_nonneg_of_nonpos hpos.le
+      (sub_nonpos.mpr (R.chart.height_le z ⟨hpos,hn⟩))
+
+end SLEExactGauge
+
+end
+
+end OAI
diff --git a/lean/OAI/Probability/SLE/Loewner/ReflectedForwardContinuity.lean b/lean/OAI/Probability/SLE/Loewner/ReflectedForwardContinuity.lean
new file mode 100644
index 0000000000000000000000000000000000000000..2c366f3ce3b675097af3c4f9298a3c0b60aaae8f
--- /dev/null
+++ b/lean/OAI/Probability/SLE/Loewner/ReflectedForwardContinuity.lean
@@ -0,0 +1,82 @@
+import OAI.Probability.SLE.Loewner.InitialReflectedForward
+import OAI.Probability.SLE.Geometry.HalfPlaneBoundaryExtension
+import TauCeti.Analysis.Complex.Conformal.NormalFamilies
+
+namespace OAI
+
+/-! Uniform analytic bounds carry time continuity of the initial slit
+maps from the open half-plane to the surviving real boundary. -/
+noncomputable section
+open Set Filter Function Complex Metric
+open scoped Topology
+
+namespace SLEExactGauge
+
+lemma initialReflectedForward_equicontinuous (p : C(unitInterval,ℂ)) (hi : Injective p)
+    (h0 : p 0=0) (hH : ∀ t : unitInterval, t≠0 → p t∈upperHalfPlane) :
+    EquicontinuousOn (initialReflectedForward p hi h0 hH) (reflectedArcSet p)ᶜ := by
+  have hb : TauCeti.IsLocallyBoundedOn (initialReflectedForward p hi h0 hH)
+      (reflectedArcSet p)ᶜ := by
+    intro K hKD hK
+    obtain ⟨A,hA⟩ := hK.isBounded.exists_norm_le
+    obtain ⟨B,hB⟩ := (isCompact_range p.continuous).isBounded.exists_norm_le
+    let R := |A|+|B|+1
+    have hR : 0<R := by dsimp [R]; positivity
+    have hp (s : unitInterval) : ‖p s‖<R := by
+      have hh := hB _ (mem_range_self s)
+      dsimp [R]
+      linarith [le_abs_self B,abs_nonneg A]
+    refine ⟨(512*Real.pi+9)*R,?_⟩
+    intro s z hz
+    apply initialReflectedForward_uniform_bound p hi h0 hH hR hp s (hKD hz)
+    have hh := hA z hz
+    dsimp [R]
+    linarith [le_abs_self A,abs_nonneg B]
+  exact hb.equicontinuousOn
+    ((isCompact_range p.continuous).union
+      ((isCompact_range p.continuous).image Complex.continuous_conj)).isClosed.isOpen_compl
+    (initialReflectedForward_differentiable p hi h0 hH)
+
+lemma initialReflectedForward_equicontinuousAt_real (p : C(unitInterval,ℂ)) (hi : Injective p)
+    (h0 : p 0=0) (hH : ∀ t : unitInterval, t≠0 → p t∈upperHalfPlane)
+    {x : ℝ} (hx : x≠0) :
+    EquicontinuousAt (initialReflectedForward p hi h0 hH) (x:ℂ) := by
+  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 hh := initialReflectedForward_equicontinuous p hi h0 hH (x:ℂ) hxD
+  simpa only [EquicontinuousWithinAt,EquicontinuousAt,nhdsWithin_eq_nhds.mpr (hD.mem_nhds hxD)] using hh
+
+theorem initialReflectedForward_real_continuous (p : C(unitInterval,ℂ)) (hi : Injective p)
+    (h0 : p 0=0) (hH : ∀ t : unitInterval, t≠0 → p t∈upperHalfPlane)
+    {x : ℝ} (hx : x≠0) :
+    Continuous (fun s => initialReflectedForward p hi h0 hH s (x:ℂ)) := by
+  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
+  apply continuous_iff_continuousAt.mpr
+  intro s
+  apply (initialReflectedForward_equicontinuousAt_real p hi h0 hH hx).tendsto_of_mem_closure
+    (((initialReflectedForward_differentiable p hi h0 hH s).differentiableAt
+      (hD.mem_nhds hxD)).continuousAt.tendsto.mono_left nhdsWithin_le_nhds)
+    (s := upperHalfPlane ∩ (reflectedArcSet p)ᶜ)
+  · intro z hz
+    have hzD (t : unitInterval) : z∈upperHalfPlane \ range (initialSubarc p t) :=
+      ⟨hz.1,fun he => hz.2 (reflected_initial_subset p t (Or.inl he))⟩
+    have hc : Continuous (fun t => initialForwardChart p hi h0 hH t z) := by
+      apply SeqContinuous.continuous
+      intro t r ht
+      exact initialForwardChart_tendsto p hi h0 hH ht tendsto_const_nhds (hzD r) (fun n => hzD (t n))
+    have he : (fun t => initialReflectedForward p hi h0 hH t z)=
+        (fun t => initialForwardChart p hi h0 hH t z) :=
+      funext (fun t => initialReflectedForward_eq p hi h0 hH t (hzD t))
+    simpa only [he,initialReflectedForward_eq p hi h0 hH s (hzD s)] using hc.continuousAt.tendsto
+  · exact hD.closure_inter ⟨closedHalfPlane_subset_closure_upperHalfPlane (by simp),hxD⟩
+
+end SLEExactGauge
+
+end
+
+end OAI
diff --git a/lean/OAI/Probability/SLE/Loewner/ReflectedSlitRiemann.lean b/lean/OAI/Probability/SLE/Loewner/ReflectedSlitRiemann.lean
new file mode 100644
index 0000000000000000000000000000000000000000..0dc2bc2929fdef211d4e6b6b2f0e19322b0145cb
--- /dev/null
+++ b/lean/OAI/Probability/SLE/Loewner/ReflectedSlitRiemann.lean
@@ -0,0 +1,76 @@
+import OAI.Probability.SLE.Geometry.InvertedArcComponents
+import OAI.Probability.SLE.Geometry.SimpleSlitRiemann
+
+namespace OAI
+
+/-! A Riemann chart including infinity for the complement of a reflected
+simple slit. Zero in this domain represents infinity before inversion. -/
+noncomputable section
+open Set Complex Metric Function
+open scoped ComplexConjugate
+
+namespace SLEExactGauge
+
+theorem reflected_slit_inverted_simplyConnected
+    (p : C(unitInterval,ℂ)) (hi : Injective p) (h0 : p 0=0)
+    (hH : ∀ t : unitInterval, t ≠ 0 → p t ∈ upperHalfPlane) :
+    IsSimplyConnected (invertedExterior (reflectedArcSet p)) := by
+  let q : C(unitInterval,ℂ) := ⟨fun t => conj (p t),Complex.continuous_conj.comp p.continuous⟩
+  have hq0 : q 0=0 := by simp [q,h0]
+  have hp : ∀ t : unitInterval, 0 < t → p t ≠ 0 := by
+    intro t ht he
+    have hh := hH t ht.ne'
+    simp only [he,upperHalfPlane,mem_ofPred_eq,zero_im,lt_self_iff_false] at hh
+  have hq : ∀ t : unitInterval, 0 < t → q t ≠ 0 := by
+    intro t ht he
+    apply hp t ht
+    have hh := congrArg conj he
+    simpa [q] using hh
+  have he : reflectedArcSet p=range p ∪ range q := by
+    unfold reflectedArcSet
+    congr 1
+    exact (range_comp conj p).symm
+  have hK : IsCompact (reflectedArcSet p) := by
+    rw [he]
+    exact (isCompact_range p.continuous).union (isCompact_range q.continuous)
+  have hK0 : (0:ℂ) ∈ reflectedArcSet p := Or.inl ⟨0,h0⟩
+  apply TauCeti.isSimplyConnected_of_filledHull_subset (invertedExterior_isOpen hK)
+    (invertedExterior_connected hK.isBounded hK0
+      (reflectedArc_complement_connected p hi h0 hH))
+  intro z hz
+  by_contra hzD
+  have hb : Bornology.IsBounded
+      (connectedComponentIn (invertedExterior (reflectedArcSet p))ᶜ z) := hz
+  rw [he] at hzD hb
+  exact invertedExterior_two_arcs_components_unbounded p q h0 hq0 hp hq hzD hb
+
+theorem reflected_slit_exists_inverted_disk_chart
+    (p : C(unitInterval,ℂ)) (hi : Injective p) (h0 : p 0=0)
+    (hH : ∀ t : unitInterval, t ≠ 0 → p t ∈ upperHalfPlane) :
+    ∃ f : ℂ → ℂ, BijOn f (invertedExterior (reflectedArcSet p)) (ball 0 1) ∧
+      DifferentiableOn ℂ f (invertedExterior (reflectedArcSet p)) ∧
+      DifferentiableOn ℂ (invFunOn f (invertedExterior (reflectedArcSet p))) (ball 0 1) ∧
+      LeftInvOn (invFunOn f (invertedExterior (reflectedArcSet p))) f
+        (invertedExterior (reflectedArcSet p)) ∧
+      RightInvOn (invFunOn f (invertedExterior (reflectedArcSet p))) f (ball 0 1) := by
+  have hK : IsCompact (reflectedArcSet p) := (isCompact_range p.continuous).union
+    ((isCompact_range p.continuous).image Complex.continuous_conj)
+  apply TauCeti.exists_bijOn_ball_differentiableOn_invFunOn (invertedExterior_isOpen hK)
+    (reflected_slit_inverted_simplyConnected p hi h0 hH)
+  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 hz|hz
+  · exact inv_ne_zero hp1 hz
+  · apply hz
+    rw [inv_inv]
+    exact Or.inl (mem_range_self 1)
+
+end SLEExactGauge
+
+end
+
+end OAI
diff --git a/lean/OAI/Probability/SLE/Loewner/RestartDomainEquality.lean b/lean/OAI/Probability/SLE/Loewner/RestartDomainEquality.lean
new file mode 100644
index 0000000000000000000000000000000000000000..3edfe581dd65d64deebf7bc17170ea0cfb50995f
--- /dev/null
+++ b/lean/OAI/Probability/SLE/Loewner/RestartDomainEquality.lean
@@ -0,0 +1,103 @@
+import OAI.Probability.SLE.Geometry.RestartGreenKernel
+import OAI.Probability.SLE.Gauge.DenseRadiusGap
+
+namespace OAI
+
+/-! Surjectivity of the actual restarted surviving domain. Inverse-map
+composition identifies every original future live point with a live fresh
+point, so reaching a deeper radius is equivalent in the two charts. -/
+
+noncomputable section
+open Set Filter
+open scoped Topology NNReal ENNReal
+
+namespace SLEExactGauge
+
+lemma IsCapacityTwoWitness.restart_live_preimage
+    {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 + t)) :
+    G T z - (U T : ℂ) ∈ survivingDomain β t := by
+  let v := G (T + t) z - (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) hz
+  have hvadd : v + (U T : ℂ) = G (T + t) z := sub_add_cancel _ _
+  have hcomp := hw.restart_inverse_composition T hb t v hv
+  rw [hvadd, hw.2.2.2.2.2.2.2.1 (T + t) z hz] at hcomp
+  have hFv : F' t v + (U T : ℂ) ∈ upperHalfPlane := by
+    simpa only [upperHalfPlane, mem_ofPred_eq, Complex.add_im, Complex.ofReal_im, add_zero]
+      using (hb.2.2.2.2.2.2.1 t hv).1.1
+  have he : F' t v + (U T : ℂ) = G T z := by
+    rw [← hw.2.2.2.2.2.2.2.2.1 T _ hFv, ← hcomp]
+  have he' : F' t v = G T z - (U T : ℂ) := by
+    rw [← he, add_sub_cancel_right]
+  rw [← he']
+  exact hb.2.2.2.2.2.2.1 t hv
+
+lemma IsCapacityTwoWitness.restart_domain_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) (w : ℂ) (hwH : w ∈ upperHalfPlane) :
+    F T (w + (U T : ℂ)) ∈ survivingDomain γ (T + t) ↔ w ∈ survivingDomain β t := by
+  constructor
+  · intro hz
+    have hwadd : w + (U T : ℂ) ∈ upperHalfPlane := by
+      simpa only [upperHalfPlane, mem_ofPred_eq, Complex.add_im, Complex.ofReal_im, add_zero]
+        using hwH
+    have h := hw.restart_live_preimage T hb t _ hz
+    rwa [hw.2.2.2.2.2.2.2.2.1 T _ hwadd, add_sub_cancel_right] at h
+  · exact fun ht => (hw.restart_forward_composition T hb t w ht).1
+
+theorem IsCapacityTwoWitness.restart_radius_finite_iff
+    {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')
+    (w : ℂ) (hwH : w ∈ upperHalfPlane) (u v : ℝ) (hu : 0 ≤ u) (hv : 0 < v)
+    (hbase : fullRadius G T (F T (w + (U T : ℂ))) =
+      (2 * (F T (w + (U T : ℂ))).im) * Real.exp (-u)) :
+    radiusLevelTime γ G (F T (w + (U T : ℂ))) (u + v) < ∞ ↔
+      radiusLevelTime β G' w v < ∞ := by
+  have hUp : Continuous (fun t => U (T + t) - U T) :=
+    (hU.comp (continuous_const.add continuous_id)).sub continuous_const
+  have hwadd : w + (U T : ℂ) ∈ upperHalfPlane := by
+    simpa only [upperHalfPlane, mem_ofPred_eq, Complex.add_im, Complex.ofReal_im, add_zero] using hwH
+  constructor
+  · intro hfinite
+    obtain ⟨S, hSlive, hSR⟩ := exists_live_level_of_radiusLevelTime_lt_top γ G _ (u + v) hfinite
+    have hS := radiusLevelTime_eq_of_live_level hU hw _ (u + v) S hSlive hSR
+    have hbefore := hw.before_deeper_radius_level hU _ u v hu hv T
+      (hw.2.2.2.2.2.2.1 T hwadd) hbase
+    rw [hS] at hbefore
+    have hTS : T ≤ S := by exact_mod_cast hbefore.le
+    let t := S - T
+    have htime : T + t = S := add_tsub_cancel_of_le hTS
+    have htlive : w ∈ survivingDomain β t :=
+      (hw.restart_domain_iff T hb t w hwH).mp (htime ▸ hSlive)
+    have hR := hw.restart_radius_composition hU T hb t w htlive
+    rw [htime, hSR] at hR
+    have hR0 := hw.restart_initial_radius hU T hb w hwH
+    rw [hbase] at hR0
+    have hD := hw.restart_inverse_derivative_norm_pos hU T hb w hwH
+    have hsourceR : fullRadius G' t w = (2 * w.im) * Real.exp (-v) := by
+      apply mul_left_cancel₀ hD.ne'
+      calc
+        _ = (2 * (F T (w + (U T : ℂ))).im) * Real.exp (-(u + v)) := hR.symm
+        _ = ((2 * (F T (w + (U T : ℂ))).im) * Real.exp (-u)) * Real.exp (-v) := by
+          rw [neg_add, Real.exp_add]
+          ring
+        _ = _ := by rw [hR0]; ring
+    rw [radiusLevelTime_eq_of_live_level hUp hb w v t htlive hsourceR]
+    exact ENNReal.coe_lt_top
+  · intro hfinite
+    obtain ⟨t, ht, hR⟩ := exists_live_level_of_radiusLevelTime_lt_top β G' w v hfinite
+    rw [(hw.restart_level_of_live_source hU T hb w u v hbase t ht hR).2]
+    exact ENNReal.coe_lt_top
+
+end SLEExactGauge
+
+end
+
+end OAI
diff --git a/lean/OAI/Probability/SLE/Loewner/RestartDriverScaling.lean b/lean/OAI/Probability/SLE/Loewner/RestartDriverScaling.lean
new file mode 100644
index 0000000000000000000000000000000000000000..45a8aeef19cc843fa3c5b0aceb5965255876e510
--- /dev/null
+++ b/lean/OAI/Probability/SLE/Loewner/RestartDriverScaling.lean
@@ -0,0 +1,131 @@
+import OAI.Probability.SLE.Loewner.ScaleTraceLaw
+import OAI.Probability.SLE.Geometry.RandomRestartEvents
+
+namespace OAI
+
+/-! Scaling the fresh Brownian driver by a scale chosen from the stopped
+past preserves its exact restricted path law. -/
+
+noncomputable section
+open Set Filter MeasureTheory ProbabilityTheory
+open scoped Topology NNReal ENNReal
+
+namespace SLEExactGauge
+
+local instance restartScaleDriverRealMeasurable : MeasurableSpace C(ℝ≥0, ℝ) := borel _
+local instance restartScaleDriverRealBorel : BorelSpace C(ℝ≥0, ℝ) := ⟨rfl⟩
+
+def scaleDriverPath (c : ℝ≥0) (p : C(ℝ≥0, ℝ)) : C(ℝ≥0, ℝ) :=
+  ⟨fun t => (c : ℝ) * p (sourceScaleTime c t),
+    continuous_const.mul (p.continuous.comp (continuous_id.div_const (c ^ 2)))⟩
+
+lemma measurable_scaleDriverPath :
+    Measurable (fun x : ℝ≥0 × C(ℝ≥0, ℝ) => scaleDriverPath x.1 x.2) := by
+  apply source_path_measurable
+  intro t
+  change Measurable (fun x : ℝ≥0 × C(ℝ≥0, ℝ) =>
+    (x.1 : ℝ) * x.2 (t / x.1 ^ 2))
+  exact NNReal.continuous_coe.measurable.comp measurable_fst |>.mul
+    (continuous_eval.measurable.comp
+      (measurable_snd.prodMk (measurable_const.div (measurable_fst.pow_const 2))))
+
+lemma brownian_scaled_driver_path_law
+    {Ω : Type*} [MeasurableSpace Ω] (P : Measure Ω)
+    (B : ℝ≥0 → Ω → ℝ) (hB : IsBrownianReal B P)
+    (hm : ∀ t, Measurable (B t)) (hc : ∀ ω, Continuous (fun t => B t ω))
+    (c : ℝ≥0) (hcpos : 0 < c) :
+    (P.map (sourceDriverPath B hc)).map (scaleDriverPath c) =
+      P.map (sourceDriverPath B hc) := by
+  let Bc : ℝ≥0 → Ω → ℝ := fun t ω => (c : ℝ) * B (sourceScaleTime c t) ω
+  have hBc : IsBrownianReal Bc P := by
+    have hh := hB.smul (c := (c ^ 2)⁻¹) (inv_ne_zero (pow_ne_zero 2 hcpos.ne'))
+    simpa only [Bc, sourceScaleTime, NNReal.coe_inv, NNReal.coe_pow, Real.sqrt_inv,
+      Real.sqrt_sq c.coe_nonneg, inv_inv, div_eq_mul_inv, mul_comm] using hh
+  have hmc : ∀ t, Measurable (Bc t) := fun t => measurable_const.mul (hm _)
+  have hcc : ∀ ω, Continuous (fun t => Bc t ω) := fun ω =>
+    continuous_const.mul ((hc ω).comp (continuous_id.div_const (c ^ 2)))
+  have hs : Measurable (scaleDriverPath c) :=
+    measurable_scaleDriverPath.comp measurable_prodMk_left
+  rw [Measure.map_map hs (source_path_measurable _ hm)]
+  exact (ScaleTraceLaw.brownian_continuous_path_law B Bc hB hBc hm hmc hc hcc).symm
+
+/-- A measurable transformation of the fresh path may depend on the stopped
+past if each of its sections preserves the fresh path law. -/
+theorem restart_random_transform_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 • ν)
+    (H : Ω × X → X) (hH : @Measurable (Ω × X) X (m.prod mX) mX H)
+    (hsections : ∀ ω, ν.map (fun x => H (ω, x)) = ν)
+    (A : Set Ω) (hA : MeasurableSet[m] A) :
+    @Measure.map Ω X mΩ mX (fun ω => H (ω, Y ω)) (P.restrict A) = P A • ν := by
+  let : MeasurableSpace Ω := mΩ
+  have hj : @Measurable Ω (Ω × X) mΩ (m.prod mX) (fun ω => (ω, Y ω)) :=
+    (measurable_id'' hm).prodMk hY
+  apply Measure.ext
+  intro D hD
+  let E : Set (Ω × X) := H ⁻¹' D
+  have hE : @MeasurableSet (Ω × X) (m.prod mX) E := hH hD
+  let f : Ω × X → ℝ≥0∞ := (A ×ˢ univ).indicator (E.indicator (fun _ => 1))
+  have hf : @Measurable (Ω × X) ℝ≥0∞ (m.prod mX) _ f :=
+    (measurable_const.indicator hE).indicator (hA.prod MeasurableSet.univ)
+  have he := @restart_lintegral_random_test Ω X mΩ mX P inferInstance ν inferInstance
+    m hm Y hY hlaw f hf
+  have hsec (ω : Ω) : (∫⁻ x, f (ω, x) ∂ν) = A.indicator (fun _ => ν D) ω := by
+    by_cases hω : ω ∈ A
+    · have hHx : Measurable (fun x => H (ω, x)) := hH.comp measurable_prodMk_left
+      have hfun : (fun x => f (ω, x)) =
+          ((fun x => H (ω, x)) ⁻¹' D).indicator (fun _ => 1) := by
+        funext x
+        by_cases hd : H (ω, x) ∈ D <;> simp [f, E, hω, hd]
+      rw [hfun, lintegral_indicator (hHx hD), setLIntegral_const, one_mul,
+        ← Measure.map_apply hHx hD, hsections ω, indicator_of_mem hω]
+    · simp [f, hω]
+  have hfun : (fun ω => f (ω, Y ω)) =
+      A.indicator ((fun ω => H (ω, Y ω)) ⁻¹' D |>.indicator (fun _ => 1)) := by
+    funext ω
+    by_cases hω : ω ∈ A <;> by_cases hd : H (ω, Y ω) ∈ D <;> simp [f, E, hω, hd]
+  rw [hfun] at he
+  simp_rw [hsec] at he
+  rw [lintegral_indicator (hm A hA),
+    lintegral_indicator (hm A hA), setLIntegral_const] at he
+  have hscaled : Measurable (fun ω => H (ω, Y ω)) := hH.comp hj
+  rw [Measure.map_apply hscaled hD, Measure.restrict_apply (hscaled hD),
+    Measure.smul_apply, smul_eq_mul]
+  rw [setLIntegral_indicator (hscaled hD), setLIntegral_const, one_mul] at he
+  simpa only [mul_comm] using he
+
+/-- The normalized fresh driver has the original continuous Brownian law
+on every event in the stopped past, even with a random past-measurable scale. -/
+theorem source_restart_random_scale_driver_law
+    {Ω : 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 t => (hm t).stronglyMeasurable))
+      (fun ω => (τ ω : WithTop ℝ≥0)))
+    (c : Ω → ℝ≥0) (hcm : Measurable[hτ.measurableSpace] c) (hcpos : ∀ ω, 0 < c ω)
+    (A : Set Ω) (hA : MeasurableSet[hτ.measurableSpace] A) :
+    (P.restrict A).map (fun ω => scaleDriverPath (c ω) (sourceRestartDriverPath B hc τ ω)) =
+      P A • P.map (sourceDriverPath B hc) := by
+  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τ)))
+  let ν := P.map (sourceDriverPath B hc)
+  have : IsProbabilityMeasure ν :=
+    (Measure.isProbabilityMeasure_map_iff (source_path_measurable _ hm).aemeasurable).mpr inferInstance
+  apply restart_random_transform_law P ν hτ.measurableSpace hτ.measurableSpace_le
+    (sourceRestartDriverPath B hc τ) hrm
+    (fun A hA => source_restart_continuous_driver_law hB hm hc τ hτ hA)
+    (fun p => scaleDriverPath (c p.1) p.2)
+    (measurable_scaleDriverPath.comp ((hcm.comp measurable_fst).prodMk measurable_snd))
+    (fun ω => brownian_scaled_driver_path_law P B hB hm hc (c ω) (hcpos ω)) A hA
+
+end SLEExactGauge
+
+end
+
+end OAI
diff --git a/lean/OAI/Probability/SLE/Loewner/ReverseBoundaryCone.lean b/lean/OAI/Probability/SLE/Loewner/ReverseBoundaryCone.lean
new file mode 100644
index 0000000000000000000000000000000000000000..1ff42f5cbafd5fc2e394948edfbebad3e6101490
--- /dev/null
+++ b/lean/OAI/Probability/SLE/Loewner/ReverseBoundaryCone.lean
@@ -0,0 +1,56 @@
+import OAI.Probability.SLE.Loewner.ReverseBoundarySquare
+
+namespace OAI
+
+/-! A reverse trajectory starting at the driver enters a vertical cone.
+The squared coordinate removes the singularity at the initial point. -/
+noncomputable section
+open Set Filter Complex
+open scoped Topology
+
+namespace SLEExactGauge
+
+theorem reverse_boundary_cone_of_small_center
+    {T L M : ℝ} (hT : 0 ≤ T) (hL : 0 ≤ L) (hsmall : 2*L*M ≤ 1)
+    (q : ℝ → ℂ) (u u' : ℝ → ℝ)
+    (hc : ContinuousOn q (Icc 0 T)) (huc : ContinuousOn u (Icc 0 T))
+    (hq0 : q 0=(u 0 : ℂ))
+    (hq : ∀ t ∈ Ioc 0 T, HasDerivWithinAt q
+      (-2/(q t-(u t : ℂ))) (Ici t) t)
+    (hu : ∀ t ∈ Ioc 0 T, HasDerivWithinAt u (u' t) (Ici t) t)
+    (hp : ∀ t ∈ Ioc 0 T, 0 < (q t).im)
+    (hb : ∀ t ∈ Ioc 0 T, |u' t| ≤ L)
+    (hM : ∀ t ∈ Ioc 0 T, ‖q t-(u t : ℂ)‖ ≤ M) :
+    ∀ t ∈ Icc 0 T, ((q t).re-u t)^2 ≤ t ∧ 3*t ≤ (q t).im^2 := by
+  have he := reverse_boundary_square_estimate hT q u u' hc huc hq0 hq hu hp hb hM hL
+  intro t ht
+  let z : ℂ := q t-(u t : ℂ)
+  have hnorm : ‖z^2+4*(t : ℂ)‖ ≤ t :=
+    (he t ht).trans (by nlinarith [mul_le_mul_of_nonneg_right hsmall ht.1])
+  have hre : (z^2+4*(t : ℂ)).re ≤ t := (Complex.re_le_norm _).trans hnorm
+  have hz : ‖z^2‖ ≤ 5*t := by
+    calc
+      ‖z^2‖ = ‖(z^2+4*(t : ℂ))-4*(t : ℂ)‖ := by congr 1; ring
+      _ ≤ ‖z^2+4*(t : ℂ)‖+‖4*(t : ℂ)‖ := norm_sub_le _ _
+      _ ≤ t+4*t := by
+        rw [norm_mul,Complex.norm_real,Real.norm_eq_abs,abs_of_nonneg ht.1]
+        norm_num only [norm_ofNat]
+        exact add_le_add hnorm le_rfl
+      _ = 5*t := by ring
+  have hnormsq : ‖z^2‖ = z.re^2+z.im^2 := by
+    rw [norm_pow,← Complex.normSq_eq_norm_sq,Complex.normSq_apply]
+    ring
+  have here : (z^2+4*(t : ℂ)).re=z.re^2-z.im^2+4*t := by
+    simp [pow_two,Complex.mul_re]
+  rw [hnormsq] at hz
+  rw [here] at hre
+  have hx : z.re=(q t).re-u t := by simp [z]
+  have hy : z.im=(q t).im := by simp [z]
+  rw [hx,hy] at hre hz
+  constructor <;> nlinarith
+
+end SLEExactGauge
+
+end
+
+end OAI
diff --git a/lean/OAI/Probability/SLE/Loewner/ReverseBoundarySquare.lean b/lean/OAI/Probability/SLE/Loewner/ReverseBoundarySquare.lean
new file mode 100644
index 0000000000000000000000000000000000000000..7a4f6853929e3458e77e53c2261954da81e0179a
--- /dev/null
+++ b/lean/OAI/Probability/SLE/Loewner/ReverseBoundarySquare.lean
@@ -0,0 +1,66 @@
+import OAI.Probability.SLE.Geometry.EndpointDerivativeBound
+
+namespace OAI
+
+/-! Squared centered reverse coordinates have a regular derivative
+even when the initial point is the boundary tip. -/
+noncomputable section
+open Set Filter Complex
+open scoped Topology
+
+namespace SLEExactGauge
+
+lemma reverse_centered_square_derivative {S : Set ℝ} {t : ℝ}
+    (q : ℝ → ℂ) (u : ℝ → ℝ) (u' : ℝ)
+    (hq : HasDerivWithinAt q (-2/(q t-(u t : ℂ))) S t)
+    (hu : HasDerivWithinAt u u' S t) (hp : 0 < (q t).im) :
+    HasDerivWithinAt (fun s => (q s-(u s : ℂ))^2)
+      (-4-2*(u' : ℂ)*(q t-(u t : ℂ))) S t := by
+  have hn : q t-(u t : ℂ) ≠ 0 := by
+    intro he
+    have hi := congrArg Complex.im he
+    simp only [Complex.sub_im,Complex.ofReal_im,sub_zero,Complex.zero_im] at hi
+    exact hp.ne' hi
+  have huc : HasDerivWithinAt (fun s => (u s : ℂ)) (u' : ℂ) S t := hu.ofReal_comp
+  have h := (hq.sub huc).pow 2
+  simp only [Pi.sub_apply,Nat.cast_ofNat,Nat.reduceSub,pow_one] at h
+  convert! h using 1
+  field_simp [hn]
+  ring
+
+lemma reverse_boundary_square_estimate {T L M : ℝ} (hT : 0 ≤ T)
+    (q : ℝ → ℂ) (u u' : ℝ → ℝ)
+    (hc : ContinuousOn q (Icc 0 T)) (huc : ContinuousOn u (Icc 0 T))
+    (hq0 : q 0=(u 0 : ℂ))
+    (hq : ∀ t ∈ Ioc 0 T, HasDerivWithinAt q
+      (-2/(q t-(u t : ℂ))) (Ici t) t)
+    (hu : ∀ t ∈ Ioc 0 T, HasDerivWithinAt u (u' t) (Ici t) t)
+    (hp : ∀ t ∈ Ioc 0 T, 0 < (q t).im)
+    (hb : ∀ t ∈ Ioc 0 T, |u' t| ≤ L)
+    (hM : ∀ t ∈ Ioc 0 T, ‖q t-(u t : ℂ)‖ ≤ M) (hL : 0 ≤ L) :
+    ∀ t ∈ Icc 0 T, ‖(q t-(u t : ℂ))^2+4*(t : ℂ)‖ ≤ (2*L*M)*t := by
+  let f (t : ℝ) : ℂ := (q t-(u t : ℂ))^2+4*(t : ℂ)
+  have hfc : ContinuousOn f (Icc 0 T) :=
+    ((hc.sub (Complex.continuous_ofReal.comp_continuousOn huc)).pow 2).add
+      (continuous_const.mul Complex.continuous_ofReal).continuousOn
+  have hf0 : f 0=0 := by simp [f,hq0]
+  have hfd (t : ℝ) (ht : t ∈ Ioc 0 T) : HasDerivWithinAt f
+      (-2*(u' t : ℂ)*(q t-(u t : ℂ))) (Ici t) t := by
+    have hid : HasDerivAt (fun s : ℝ => (s : ℂ)) 1 t := by
+      convert! (hasDerivAt_id t).ofReal_comp using 1
+    have h := (reverse_centered_square_derivative q u (u' t) (hq t ht) (hu t ht) (hp t ht)).add
+      ((hid.const_mul 4).hasDerivWithinAt)
+    convert! h using 1
+    ring
+  have hbd (t : ℝ) (ht : t ∈ Ioc 0 T) :
+      ‖-2*(u' t : ℂ)*(q t-(u t : ℂ))‖ ≤ 2*L*M := by
+    rw [norm_mul,norm_mul,norm_neg,norm_ofNat,Complex.norm_real,Real.norm_eq_abs]
+    exact mul_le_mul (mul_le_mul_of_nonneg_left (hb t ht) (by norm_num)) (hM t ht)
+      (norm_nonneg _) (mul_nonneg (by norm_num) hL)
+  simpa only [hf0,sub_zero,f] using norm_sub_initial_le_of_deriv_on_Ioc hT f _ hfc hfd hbd
+
+end SLEExactGauge
+
+end
+
+end OAI
diff --git a/lean/OAI/Probability/SLE/Loewner/ReverseConeContraction.lean b/lean/OAI/Probability/SLE/Loewner/ReverseConeContraction.lean
new file mode 100644
index 0000000000000000000000000000000000000000..dd96f63e903759bf5393c2740db54cabe005f5e3
--- /dev/null
+++ b/lean/OAI/Probability/SLE/Loewner/ReverseConeContraction.lean
@@ -0,0 +1,73 @@
+import OAI.Probability.SLE.Geometry.ComplexDissipation
+import OAI.Probability.SLE.Loewner.LocalReverseCone
+
+namespace OAI
+
+/-! Reverse trajectories in a vertical cone have a dissipative difference
+equation. The contraction includes a boundary initial point. -/
+noncomputable section
+open Set Filter Complex
+open scoped Topology
+
+namespace SLEExactGauge
+
+lemma reverse_coefficient_re_nonpos {q r : ℂ} {u t : ℝ}
+    (ht : 0 ≤ t) (hqp : 0 ≤ q.im) (hrp : 0 ≤ r.im)
+    (hqx : (q.re-u)^2 ≤ t) (hrx : (r.re-u)^2 ≤ t)
+    (hqy : t ≤ q.im^2) (hry : t ≤ r.im^2) :
+    (2/((q-(u : ℂ))*(r-(u : ℂ)))).re ≤ 0 := by
+  have hxx : (q.re-u)*(r.re-u) ≤ t := by
+    nlinarith [sq_nonneg ((q.re-u)-(r.re-u))]
+  have hqroot : Real.sqrt t ≤ q.im := by
+    nlinarith [Real.sq_sqrt ht,Real.sqrt_nonneg t]
+  have hrroot : Real.sqrt t ≤ r.im := by
+    nlinarith [Real.sq_sqrt ht,Real.sqrt_nonneg t]
+  have hyy : t ≤ q.im*r.im := by
+    have hh := mul_le_mul hqroot hrroot (Real.sqrt_nonneg t) hqp
+    nlinarith [Real.sq_sqrt ht]
+  have hreal : ((q-(u : ℂ))*(r-(u : ℂ))).re ≤ 0 := by
+    simp only [Complex.mul_re,Complex.sub_re,Complex.ofReal_re,
+      Complex.sub_im,Complex.ofReal_im,sub_zero]
+    linarith
+  simp only [Complex.div_re,Complex.re_ofNat,Complex.im_ofNat,zero_mul,zero_div,add_zero]
+  exact div_nonpos_of_nonpos_of_nonneg (mul_nonpos_of_nonneg_of_nonpos (by norm_num) hreal)
+    (Complex.normSq_nonneg _)
+
+theorem reverse_trajectories_contract_in_cones {T : ℝ} (hT : 0 ≤ T)
+    (q r : ℝ → ℂ) (u : ℝ → ℝ)
+    (hqc : ContinuousOn q (Icc 0 T)) (hrc : ContinuousOn r (Icc 0 T))
+    (hq : ∀ t ∈ Ioc 0 T, HasDerivWithinAt q
+      (-2/(q t-(u t : ℂ))) (Ici t) t)
+    (hr : ∀ t ∈ Ioc 0 T, HasDerivWithinAt r
+      (-2/(r t-(u t : ℂ))) (Ici t) t)
+    (hqp : ∀ t ∈ Ioc 0 T, 0 < (q t).im)
+    (hrp : ∀ t ∈ Ioc 0 T, 0 < (r t).im)
+    (hqx : ∀ t ∈ Ioc 0 T, ((q t).re-u t)^2 ≤ t)
+    (hrx : ∀ t ∈ Ioc 0 T, ((r t).re-u t)^2 ≤ t)
+    (hqy : ∀ t ∈ Ioc 0 T, t ≤ (q t).im^2)
+    (hry : ∀ t ∈ Ioc 0 T, t ≤ (r t).im^2) :
+    ∀ t ∈ Icc 0 T, dist (q t) (r t) ≤ dist (q 0) (r 0) := by
+  let c (t : ℝ) : ℂ := 2/((q t-(u t : ℂ))*(r t-(u t : ℂ)))
+  have hn (v : ℝ → ℂ) (hp : ∀ t ∈ Ioc 0 T, 0 < (v t).im)
+      (t : ℝ) (ht : t ∈ Ioc 0 T) : v t-(u t : ℂ) ≠ 0 := by
+    intro he
+    have hi := congrArg Complex.im he
+    simp only [Complex.sub_im,Complex.ofReal_im,sub_zero,Complex.zero_im] at hi
+    exact (hp t ht).ne' hi
+  have hd (t : ℝ) (ht : t ∈ Ioc 0 T) :
+      HasDerivWithinAt (fun s => q s-r s) (c t*(q t-r t)) (Ici t) t := by
+    convert! (hq t ht).sub (hr t ht) using 1
+    dsimp [c]
+    field_simp [hn q hqp t ht,hn r hrp t ht]
+    ring
+  have hc (t : ℝ) (ht : t ∈ Ioc 0 T) : (c t).re ≤ 0 :=
+    reverse_coefficient_re_nonpos ht.1.le (hqp t ht).le (hrp t ht).le
+      (hqx t ht) (hrx t ht) (hqy t ht) (hry t ht)
+  simpa only [dist_eq_norm] using
+    complex_linear_endpoint_contraction hT (fun s => q s-r s) c (hqc.sub hrc) hd hc
+
+end SLEExactGauge
+
+end
+
+end OAI
diff --git a/lean/OAI/Probability/SLE/Loewner/ReverseFlowStability.lean b/lean/OAI/Probability/SLE/Loewner/ReverseFlowStability.lean
new file mode 100644
index 0000000000000000000000000000000000000000..4d66eb7a30039053a8dbad21bec1f58888aee303
--- /dev/null
+++ b/lean/OAI/Probability/SLE/Loewner/ReverseFlowStability.lean
@@ -0,0 +1,52 @@
+import OAI.Probability.SLE.Loewner.LoewnerInverseStability
+
+namespace OAI
+
+/-! Stability of raw reverse trajectories, including dependence on their
+initial point. This is used before a geometric trace has been constructed. -/
+noncomputable section
+open Set Filter Complex Metric
+open scoped Topology NNReal
+
+namespace SLEExactGauge
+
+lemma reverse_flow_driver_distance {a : ℝ} (ha : 0 < a)
+    (U V : ℝ → ℝ) (Z Q : ℝ → ℂ) (T : ℝ)
+    (hZ : ∀ t ∈ Icc 0 T, HasDerivWithinAt Z
+      (reverseField a (U t) (Z t)) (Icc 0 T) t)
+    (hQ : ∀ t ∈ Icc 0 T, HasDerivWithinAt Q
+      (reverseField a (V t) (Q t)) (Icc 0 T) t)
+    (δ : ℝ) (hinit : dist (Z 0) (Q 0) ≤ δ)
+    (hUV : ∀ t ∈ Icc 0 T, |U t-V t| ≤ δ) :
+    ∀ t ∈ Icc 0 T, dist (Z t) (Q t) ≤
+      gronwallBound δ (4*a⁻¹^2) (2*a⁻¹^2*δ) t := by
+  intro t ht
+  have he := dist_le_of_approx_trajectories_ODE
+    (K := (⟨4*a⁻¹^2,by positivity⟩ : ℝ≥0))
+    (v := fun s => reverseField a (U s)) (fun _ => reverseField_lipschitz ha _)
+    (f := Z) (fun s hs => (hZ s hs).continuousWithinAt)
+    (fun s hs => hasDerivWithinAt_Ici_of_Icc hs (hZ s ⟨hs.1,hs.2.le⟩))
+    (εf := 0) (fun _ _ => by simp)
+    (g := Q) (fun s hs => (hQ s hs).continuousWithinAt)
+    (fun s hs => hasDerivWithinAt_Ici_of_Icc hs (hQ s ⟨hs.1,hs.2.le⟩))
+    (εg := 2*a⁻¹^2*δ) (fun s hs => ?_) hinit t ht
+  · change dist (Z t) (Q t) ≤ gronwallBound δ (4*a⁻¹^2) (0+2*a⁻¹^2*δ) (t-0) at he
+    simpa only [zero_add,sub_zero] using he
+  · rw [dist_comm]
+    exact (reverseField_driver_dist ha _ _ _).trans
+      (mul_le_mul_of_nonneg_left (hUV s (Ico_subset_Icc_self hs)) (by positivity))
+
+lemma reverse_flow_lipschitz {a : ℝ} (ha : 0 < a)
+    (U : ℝ → ℝ) (Q : ℝ → ℂ)
+    (hQ : ∀ t ∈ Ici (0 : ℝ), HasDerivWithinAt Q
+      (reverseField a (U t) (Q t)) (Ici 0) t) :
+    LipschitzOnWith ⟨2*a⁻¹,by positivity⟩ Q (Ici 0) := by
+  apply (convex_Ici (0 : ℝ)).lipschitzOnWith_of_nnnorm_hasDerivWithin_le hQ
+  intro t ht
+  exact_mod_cast reverseField_bound ha (U t) (Q t)
+
+end SLEExactGauge
+
+end
+
+end OAI
diff --git a/lean/OAI/Probability/SLE/Loewner/ReverseHeightUpper.lean b/lean/OAI/Probability/SLE/Loewner/ReverseHeightUpper.lean
new file mode 100644
index 0000000000000000000000000000000000000000..339b9ef3019d369fdaad40ac5dd5fa55598c21a0
--- /dev/null
+++ b/lean/OAI/Probability/SLE/Loewner/ReverseHeightUpper.lean
@@ -0,0 +1,61 @@
+import OAI.Probability.SLE.Loewner.SmoothRawInverse
+
+namespace OAI
+
+/-! The elementary upper height bound for reverse trajectories applies
+before a trace or a geometric hull is available. -/
+noncomputable section
+open Set Filter Complex
+open scoped Topology NNReal
+
+namespace SLEExactGauge
+
+lemma reverse_height_square_le {T : ℝ} (hT : 0 ≤ T)
+    (q : ℝ → ℂ) (u : ℝ → ℝ)
+    (hd : ∀ s ∈ Icc 0 T, HasDerivWithinAt q (-2/(q s-(u s : ℂ))) (Icc 0 T) s)
+    (hp : ∀ s ∈ Icc 0 T, 0 < (q s).im) :
+    (q T).im^2 ≤ (q 0).im^2+4*T := by
+  have hsq (s : ℝ) (hs : s ∈ Icc 0 T) :
+      HasDerivWithinAt (fun t => (q t).im^2)
+        (4*(q s).im^2/normSq (q s-(u s : ℂ))) (Icc 0 T) s := by
+    have hi := Complex.imCLM.hasFDerivAt.comp_hasDerivWithinAt s (hd s hs)
+    change HasDerivWithinAt (fun t => (q t).im)
+      ((-2/(q s-(u s : ℂ))).im) _ _ at hi
+    convert! hi.pow 2 using 1
+    simp only [Complex.div_im,Complex.neg_re,Complex.re_ofNat,Complex.neg_im,
+      Complex.im_ofNat,neg_zero,zero_mul,Complex.sub_im,Complex.ofReal_im,sub_zero]
+    ring
+  apply image_le_of_deriv_right_le_deriv_boundary
+    (fun s hs => (hsq s hs).continuousWithinAt)
+    (fun s hs => hasDerivWithinAt_Ici_of_Icc hs (hsq s ⟨hs.1,hs.2.le⟩))
+    (B := fun s => (q 0).im^2+4*s) (B' := fun _ => 4)
+    (by simp) (by fun_prop)
+    (fun s _ => by
+      convert (((hasDerivAt_id s).const_mul 4).const_add ((q 0).im^2)).hasDerivWithinAt using 1 <;> simp)
+    (fun s hs => ?_) ⟨hT,le_rfl⟩
+  apply (div_le_iff₀ ?_).mpr
+  · simp only [Complex.normSq_apply,Complex.sub_re,Complex.ofReal_re,
+      Complex.sub_im,Complex.ofReal_im,sub_zero]
+    nlinarith [sq_nonneg ((q s).re-u s)]
+  · apply Complex.normSq_pos.mpr
+    intro he
+    have hi := congrArg Complex.im he
+    simp only [Complex.sub_im,Complex.ofReal_im,sub_zero,Complex.zero_im] at hi
+    exact (hp s (Ico_subset_Icc_self hs)).ne' hi
+
+namespace Target
+
+lemma raw_inverse_height_square_le (b : Driver) (T : ℝ≥0) (w : ℂ)
+    (hw : w ∈ upperHalfPlane) : (inverseFlow 1 b T w).im^2 ≤ w.im^2+4*T := by
+  obtain ⟨q,hq0,hheight,hd,he⟩ := exists_raw_reverse_trajectory b T w hw
+  rw [he,← hq0]
+  exact reverse_height_square_le T.coe_nonneg q (fun s => driverValue b ((T : ℝ)-s))
+    (fun s hs => (hd s hs.1).mono Icc_subset_Ici_self)
+    (fun s hs => hw.trans_le (hheight s hs.1))
+
+end Target
+end SLEExactGauge
+
+end
+
+end OAI
diff --git a/lean/OAI/Probability/SLE/Loewner/ReverseLongContraction.lean b/lean/OAI/Probability/SLE/Loewner/ReverseLongContraction.lean
new file mode 100644
index 0000000000000000000000000000000000000000..bfa59f6c923be71cc3536ca6e049ce7a215d3a86
--- /dev/null
+++ b/lean/OAI/Probability/SLE/Loewner/ReverseLongContraction.lean
@@ -0,0 +1,86 @@
+import OAI.Probability.SLE.Loewner.SmoothReverseContraction
+
+namespace OAI
+
+/-! A short initial contraction, followed by positive-height Grönwall
+control, bounds reverse trajectories on any finite time interval. -/
+noncomputable section
+open Set Filter Complex
+open scoped Topology
+
+namespace SLEExactGauge
+
+lemma reverse_height_monotone {T : ℝ} (q : ℝ → ℂ) (u : ℝ → ℝ)
+    (hq : ∀ t ∈ Icc 0 T, HasDerivWithinAt q (-2/(q t-(u t : ℂ))) (Icc 0 T) t)
+    (hp : ∀ t ∈ Icc 0 T, 0 < (q t).im) :
+    MonotoneOn (fun t => (q t).im) (Icc 0 T) := by
+  have hd (t : ℝ) (ht : t ∈ Icc 0 T) : HasDerivWithinAt (fun s => (q s).im)
+      (2*(q t).im/Complex.normSq (q t-(u t : ℂ))) (Icc 0 T) t := by
+    have hh := Complex.imCLM.hasFDerivAt.comp_hasDerivWithinAt t (hq t ht)
+    change HasDerivWithinAt (fun s => (q s).im)
+      ((-2/(q t-(u t : ℂ))).im) (Icc 0 T) t at hh
+    have he : (-2/(q t-(u t : ℂ))).im =
+        2*(q t).im/Complex.normSq (q t-(u t : ℂ)) := by
+      simp only [Complex.div_im,Complex.neg_re,Complex.re_ofNat,Complex.neg_im,
+        Complex.im_ofNat,neg_zero,zero_mul,Complex.sub_im,Complex.ofReal_im,sub_zero]
+      ring
+    rwa [he] at hh
+  apply monotoneOn_of_hasDerivWithinAt_nonneg (convex_Icc _ _)
+    (fun t ht => (hd t ht).continuousWithinAt)
+    (fun t ht => (hd t (interior_subset ht)).mono interior_subset)
+  intro t ht
+  exact div_nonneg (mul_nonneg (by norm_num) (hp t (interior_subset ht)).le)
+    (Complex.normSq_nonneg _)
+
+theorem smooth_reverse_long_distance {T a L : ℝ} (ha : 0 < a) (haT : a ≤ T) (hL : 0 ≤ L)
+    (q r : ℝ → ℂ) (u u' : ℝ → ℝ)
+    (hq : ∀ t ∈ Icc 0 T, HasDerivWithinAt q (-2/(q t-(u t : ℂ))) (Icc 0 T) t)
+    (hr : ∀ t ∈ Icc 0 T, HasDerivWithinAt r (-2/(r t-(u t : ℂ))) (Icc 0 T) t)
+    (hu : ∀ t ∈ Icc 0 T, HasDerivWithinAt u (u' t) (Icc 0 T) t)
+    (hb : ∀ t ∈ Icc 0 T, |u' t| ≤ L)
+    (hqp : ∀ t ∈ Icc 0 T, 0 < (q t).im)
+    (hrp : ∀ t ∈ Icc 0 T, 0 < (r t).im)
+    (hq0 : (q 0).re=u 0) (hr0 : (r 0).re=u 0)
+    (hsmall : L^2*a ≤ 1) :
+    dist (q T) (r T) ≤ dist (q 0) (r 0)*Real.exp ((4*(Real.sqrt a)⁻¹^2)*(T-a)) := by
+  have hsub : Icc 0 a ⊆ Icc 0 T := Icc_subset_Icc_right haT
+  have hqd := fun t ht => (hq t (hsub ht)).mono hsub
+  have hrd := fun t ht => (hr t (hsub ht)).mono hsub
+  have hud := fun t ht => (hu t (hsub ht)).mono hsub
+  have hb' := fun t ht => hb t (hsub ht)
+  have hqp' := fun t ht => hqp t (hsub ht)
+  have hrp' := fun t ht => hrp t (hsub ht)
+  have hinit := smooth_reverse_trajectories_contract ha.le hL q r u u'
+    hqd hrd hud hb' hqp' hrp' hq0 hr0 hsmall
+  have hqa := reverse_loewner_height_lower hL q u u' hqd hud hb' hqp' hq0 hsmall a ⟨ha.le,le_rfl⟩
+  have hra := reverse_loewner_height_lower hL r u u' hrd hud hb' hrp' hr0 hsmall a ⟨ha.le,le_rfl⟩
+  have hη : 0 < Real.sqrt a := Real.sqrt_pos.mpr ha
+  have hroot : (Real.sqrt a)^2=a := Real.sq_sqrt ha.le
+  have hqa' : Real.sqrt a ≤ (q a).im := by nlinarith [hqp' a ⟨ha.le,le_rfl⟩]
+  have hra' : Real.sqrt a ≤ (r a).im := by nlinarith [hrp' a ⟨ha.le,le_rfl⟩]
+  have hmQ := reverse_height_monotone q u hq hqp
+  have hmR := reverse_height_monotone r u hr hrp
+  have hpost : Icc a T ⊆ Icc 0 T := Icc_subset_Icc_left ha.le
+  have hQ (t : ℝ) (ht : t ∈ Icc a T) : Real.sqrt a ≤ (q t).im :=
+    hqa'.trans (hmQ ⟨ha.le,haT⟩ (hpost ht) ht.1)
+  have hR (t : ℝ) (ht : t ∈ Icc a T) : Real.sqrt a ≤ (r t).im :=
+    hra'.trans (hmR ⟨ha.le,haT⟩ (hpost ht) ht.1)
+  have hdQ (t : ℝ) (ht : t ∈ Ico a T) : HasDerivWithinAt q
+      (reverseField (Real.sqrt a) (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
+      hasDerivWithinAt_Ici_of_Icc ht ((hq t (hpost (Ico_subset_Icc_self ht))).mono hpost)
+  have hdR (t : ℝ) (ht : t ∈ Ico a T) : HasDerivWithinAt r
+      (reverseField (Real.sqrt a) (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
+      hasDerivWithinAt_Ici_of_Icc ht ((hr t (hpost (Ico_subset_Icc_self ht))).mono hpost)
+  exact dist_le_of_trajectories_ODE (fun t => reverseField_lipschitz hη (u t))
+    (fun t ht => (hq t (hpost ht)).continuousWithinAt.mono hpost) hdQ
+    (fun t ht => (hr t (hpost ht)).continuousWithinAt.mono hpost) hdR hinit T ⟨haT,le_rfl⟩
+
+end SLEExactGauge
+
+end
+
+end OAI
diff --git a/lean/OAI/Probability/SLE/Loewner/ReverseSmoothBounds.lean b/lean/OAI/Probability/SLE/Loewner/ReverseSmoothBounds.lean
new file mode 100644
index 0000000000000000000000000000000000000000..7f3c85536e271a85c6e802da6d604aabfc4bc559
--- /dev/null
+++ b/lean/OAI/Probability/SLE/Loewner/ReverseSmoothBounds.lean
@@ -0,0 +1,93 @@
+import OAI.Probability.SLE.Loewner.LoewnerDriverBounds
+
+namespace OAI
+
+/-! Elementary barriers for the reverse Loewner equation with a bounded
+derivative of the driving function. The estimates are uniform in the
+positive starting height. -/
+noncomputable section
+open Set Filter Complex
+open scoped Topology NNReal
+
+namespace SLEExactGauge
+
+lemma damped_real_barrier {T L : ℝ} (hL : 0 ≤ L)
+    (x b D : ℝ → ℝ) (hx0 : x 0=0)
+    (hd : ∀ t ∈ Icc 0 T, HasDerivWithinAt x
+      (-2*x t/D t+b t) (Icc 0 T) t)
+    (hD : ∀ t ∈ Icc 0 T, 0 < D t)
+    (hb : ∀ t ∈ Icc 0 T, b t ≤ L) :
+    ∀ t ∈ Icc 0 T, x t ≤ L*t := by
+  intro t ht
+  apply le_of_forall_pos_le_add
+  intro ε hε
+  apply image_le_of_deriv_right_lt_deriv_boundary
+    (fun s hs => (hd s hs).continuousWithinAt)
+    (fun s hs => hasDerivWithinAt_Ici_of_Icc hs (hd s ⟨hs.1,hs.2.le⟩))
+    (B := fun s => L*s+ε) (B' := fun _ => L)
+    (by simp only [hx0,mul_zero,zero_add]; exact hε.le)
+    (fun s => by simpa using ((hasDerivAt_id s).const_mul L).add_const ε)
+    (fun s hs he => ?_) ht
+  have hxs : 0 < x s := by
+    rw [he]
+    exact add_pos_of_nonneg_of_pos (mul_nonneg hL hs.1) hε
+  have hn : -2*x s/D s < 0 := div_neg_of_neg_of_pos (by linarith) (hD s ⟨hs.1,hs.2.le⟩)
+  linarith [hb s ⟨hs.1,hs.2.le⟩]
+
+lemma damped_real_abs_barrier {T L : ℝ} (hL : 0 ≤ L)
+    (x b D : ℝ → ℝ) (hx0 : x 0=0)
+    (hd : ∀ t ∈ Icc 0 T, HasDerivWithinAt x
+      (-2*x t/D t+b t) (Icc 0 T) t)
+    (hD : ∀ t ∈ Icc 0 T, 0 < D t)
+    (hb : ∀ t ∈ Icc 0 T, |b t| ≤ L) :
+    ∀ t ∈ Icc 0 T, |x t| ≤ L*t := by
+  intro t ht
+  refine abs_le.mpr ⟨?_,damped_real_barrier hL x b D hx0 hd hD
+    (fun s hs => (le_abs_self _).trans (hb s hs)) t ht⟩
+  have hn := damped_real_barrier hL (fun s => -x s) (fun s => -b s) D
+    (by simp [hx0]) (fun s hs => ?_) hD
+    (fun s hs => (neg_le_abs _).trans (hb s hs)) t ht
+  · linarith
+  · convert (hd s hs).neg using 1; ring
+
+lemma reverse_height_square_barrier {T L : ℝ}
+    (x y : ℝ → ℝ)
+    (hy : ∀ t ∈ Icc 0 T, 0 < y t)
+    (hd : ∀ t ∈ Icc 0 T, HasDerivWithinAt y
+      (2*y t/((x t)^2+(y t)^2)) (Icc 0 T) t)
+    (hx : ∀ t ∈ Icc 0 T, |x t| ≤ L*t)
+    (hsmall : ∀ t ∈ Icc 0 T, L^2*t ≤ 1) :
+    ∀ t ∈ Icc 0 T, 2*t ≤ (y t)^2 := by
+  intro t ht
+  have hh := image_le_of_deriv_right_lt_deriv_boundary
+    (f := fun s => -(y s)^2) (f' := fun s => -(4*(y s)^2/((x s)^2+(y s)^2)))
+    (fun s hs => ((hd s hs).pow 2).neg.continuousWithinAt)
+    (fun s hs => hasDerivWithinAt_Ici_of_Icc hs ?_)
+    (B := fun s => -2*s) (B' := fun _ => -2)
+    (by nlinarith [sq_nonneg (y 0)])
+    (fun s => by simpa using (hasDerivAt_id s).const_mul (-2))
+    (fun s hs he => ?_) ht
+  · linarith
+  · convert ((hd s ⟨hs.1,hs.2.le⟩).pow 2).neg using 1; dsimp; ring
+  · have hs' : s ∈ Icc 0 T := ⟨hs.1,hs.2.le⟩
+    have hy2 : (y s)^2=2*s := by linarith
+    have hspos : 0 < s := by nlinarith [sq_pos_of_pos (hy s hs')]
+    have hxx : (x s)^2 ≤ L^2*s^2 := by
+      have ha := hx s hs'
+      have hb : |x s|^2 ≤ (L*s)^2 := pow_le_pow_left₀ (abs_nonneg _) ha 2
+      simpa only [sq_abs,mul_pow] using hb
+    have hyp := hy s hs'
+    have hden : 0 < (x s)^2+(y s)^2 := by positivity
+    have hxs : (x s)^2 ≤ s := by
+      have hh := mul_le_mul_of_nonneg_right (hsmall s hs') hs.1
+      nlinarith
+    have hp : 2 < 4*(y s)^2/((x s)^2+(y s)^2) := by
+      apply (lt_div_iff₀ hden).mpr
+      nlinarith
+    linarith
+
+end SLEExactGauge
+
+end
+
+end OAI
diff --git a/lean/OAI/Probability/SLE/Loewner/ReverseTrajectoryExistence.lean b/lean/OAI/Probability/SLE/Loewner/ReverseTrajectoryExistence.lean
new file mode 100644
index 0000000000000000000000000000000000000000..d52800911d4210c9198124528333a3e3ad312e97
--- /dev/null
+++ b/lean/OAI/Probability/SLE/Loewner/ReverseTrajectoryExistence.lean
@@ -0,0 +1,48 @@
+import OAI.Probability.SLE.Loewner.TargetInverseExistence
+
+namespace OAI
+
+/-! The unclipped reverse equation has a global trajectory from every
+point of the upper half-plane, for every continuous real driver. -/
+noncomputable section
+open Set Filter Complex _root_.MeasureTheory _root_.OAI.MeasureTheory
+open scoped Topology
+
+namespace SLEExactGauge
+
+theorem exists_reverse_trajectory (u : ℝ → ℝ) (hu : Continuous u)
+    (w : ℂ) (hw : 0 < w.im) :
+    ∃ q : ℝ → ℂ, q 0=w ∧
+      (∀ t, 0 ≤ t → w.im ≤ (q t).im) ∧
+      ∀ t, 0 ≤ t → HasDerivWithinAt q (-2/(q t-(u t : ℂ))) (Ici 0) t := by
+  let a : ℝ := w.im/2
+  have ha : 0 < a := half_pos hw
+  obtain ⟨Q,_,hQ0,hQd⟩ := exists_measurable_reverse_flow
+    (fun t (_ : Unit) => u t) (hu.measurable.comp measurable_fst)
+    (fun _ => hu) (fun _ => w) measurable_const ha
+  let q : ℝ → ℂ := fun t => Q t ()
+  have hd (t : ℝ) (ht : 0 ≤ t) : HasDerivWithinAt q
+      (reverseField a (u t) (q t)) (Ici 0) t := hQd () t ht
+  have hqc : ContinuousOn q (Ici 0) := fun t ht => (hd t ht).continuousWithinAt
+  have hm : MonotoneOn (fun t => (q t).im) (Ici 0) := by
+    apply monotoneOn_of_hasDerivWithinAt_nonneg (convex_Ici 0)
+      (Complex.continuous_im.comp_continuousOn hqc)
+      (fun t ht => (Complex.imCLM.hasFDerivAt.comp_hasDerivWithinAt t
+        (hd t (interior_subset ht))).mono interior_subset)
+    intro t ht
+    exact reverseField_im_nonneg ha _ _
+  have hq0 : q 0=w := hQ0 ()
+  have hheight (t : ℝ) (ht : 0 ≤ t) : w.im ≤ (q t).im := by
+    rw [← hq0]
+    exact hm (show 0 ∈ Ici (0 : ℝ) from le_refl (0 : ℝ)) ht ht
+  refine ⟨q,hq0,hheight,?_⟩
+  intro t ht
+  have h := hd t ht
+  rw [reverseField,reverseCenter_eq ((half_le_self hw.le).trans (hheight t ht))] at h
+  simpa only [div_eq_mul_inv] using h
+
+end SLEExactGauge
+
+end
+
+end OAI
diff --git a/lean/OAI/Probability/SLE/Loewner/RightFieldDriverStability.lean b/lean/OAI/Probability/SLE/Loewner/RightFieldDriverStability.lean
new file mode 100644
index 0000000000000000000000000000000000000000..f0d29c645e3665ceddf86403a2da4188e80b7be4
--- /dev/null
+++ b/lean/OAI/Probability/SLE/Loewner/RightFieldDriverStability.lean
@@ -0,0 +1,72 @@
+import OAI.Probability.SLE.NearRealContraction
+
+namespace OAI
+
+/-! Stability of the clipped right-half-plane flow under perturbations of
+the driver. This also applies arbitrarily close to the real boundary. -/
+noncomputable section
+open Set Filter Complex Metric
+open scoped Topology NNReal
+
+namespace SLEExactGauge
+
+lemma rightCenter_driver_dist (a u v : ℝ) (z : ℂ) :
+    dist (rightCenter a u z) (rightCenter a v z) ≤ |u-v| := by
+  have he : rightCenter a u z-rightCenter a v z =
+      ((max a (z.re-u)-max a (z.re-v) : ℝ) : ℂ) := by
+    simp only [rightCenter,Complex.ofReal_sub]
+    ring
+  rw [dist_eq_norm,he,Complex.norm_real,Real.norm_eq_abs]
+  have hh := ((LipschitzWith.id : LipschitzWith 1 (fun x : ℝ => x)).const_max a).dist_le_mul
+    (z.re-u) (z.re-v)
+  simpa only [Real.dist_eq,NNReal.coe_one,one_mul,id_eq,sub_sub_sub_cancel_left,
+    abs_sub_comm v u] using hh
+
+lemma rightField_driver_dist {a : ℝ} (ha : 0 < a) (u v : ℝ) (z : ℂ) :
+    dist (rightField a u z) (rightField a v z) ≤ 2*a⁻¹^2*|u-v| := by
+  have hu : ‖(rightCenter a u z)⁻¹‖ ≤ a⁻¹ := by
+    rw [norm_inv]
+    exact inv_anti₀ ha (rightCenter_norm a u z)
+  have hv : ‖(rightCenter a v z)⁻¹‖ ≤ a⁻¹ := by
+    rw [norm_inv]
+    exact inv_anti₀ ha (rightCenter_norm a v z)
+  rw [dist_eq_norm,rightField,rightField,← mul_sub,norm_mul,norm_ofNat,
+    inv_sub_inv' (rightCenter_ne_zero ha _ _) (rightCenter_ne_zero ha _ _),
+    norm_mul,norm_mul]
+  calc
+    _ ≤ 2*(a⁻¹*|u-v| * a⁻¹) := by
+      gcongr
+      simpa only [← dist_eq_norm,dist_comm] using rightCenter_driver_dist a u v z
+    _ = _ := by ring
+
+lemma right_flow_driver_distance {a : ℝ} (ha : 0 < a)
+    (U V : ℝ → ℝ) (Z Q : ℝ → ℂ) (T : ℝ) (_hT : 0 ≤ T)
+    (hZ : ∀ t ∈ Icc 0 T, HasDerivWithinAt Z
+      (rightField a (U t) (Z t)) (Icc 0 T) t)
+    (hQ : ∀ t ∈ Icc 0 T, HasDerivWithinAt Q
+      (rightField a (V t) (Q t)) (Icc 0 T) t)
+    (δ : ℝ) (hinit : dist (Z 0) (Q 0) ≤ δ)
+    (hUV : ∀ t ∈ Icc 0 T, |U t-V t| ≤ δ) :
+    ∀ t ∈ Icc 0 T, dist (Z t) (Q t) ≤
+      gronwallBound δ (4*a⁻¹^2) (2*a⁻¹^2*δ) t := by
+  intro t ht
+  have he := dist_le_of_approx_trajectories_ODE
+    (K := (⟨4*a⁻¹^2,by positivity⟩ : ℝ≥0))
+    (v := fun s => rightField a (U s)) (fun _ => rightField_lipschitz ha _)
+    (f := Z) (fun s hs => (hZ s hs).continuousWithinAt)
+    (fun s hs => hasDerivWithinAt_Ici_of_Icc hs (hZ s ⟨hs.1,hs.2.le⟩))
+    (εf := 0) (fun _ _ => by simp)
+    (g := Q) (fun s hs => (hQ s hs).continuousWithinAt)
+    (fun s hs => hasDerivWithinAt_Ici_of_Icc hs (hQ s ⟨hs.1,hs.2.le⟩))
+    (εg := 2*a⁻¹^2*δ) (fun s hs => ?_) hinit t ht
+  · change dist (Z t) (Q t) ≤ gronwallBound δ (4*a⁻¹^2) (0+2*a⁻¹^2*δ) (t-0) at he
+    simpa only [zero_add,sub_zero] using he
+  · rw [dist_comm]
+    exact (rightField_driver_dist ha _ _ _).trans
+      (mul_le_mul_of_nonneg_left (hUV s (Ico_subset_Icc_self hs)) (by positivity))
+
+end SLEExactGauge
+
+end
+
+end OAI
diff --git a/lean/OAI/Probability/SLE/Loewner/ScaleTraceLaw.lean b/lean/OAI/Probability/SLE/Loewner/ScaleTraceLaw.lean
new file mode 100644
index 0000000000000000000000000000000000000000..913c0d3ec22029a63a0499e01c092b8aeb66321e
--- /dev/null
+++ b/lean/OAI/Probability/SLE/Loewner/ScaleTraceLaw.lean
@@ -0,0 +1,166 @@
+import OAI.Probability.SLE.StoppedMeasures
+import OAI.Probability.SLE.InteriorDiskProof
+
+namespace OAI
+
+/-!
+Equality of actual continuous SLE trace laws under capacity scaling. The
+Brownian driver laws agree by finite-dimensional uniqueness. Canonical
+reverse-flow approximants transfer the measurable trace factor through that
+law equality, so no scaling law for geometric events is assumed.
+-/
+
+noncomputable section
+open Set Filter MeasureTheory ProbabilityTheory TopologicalSpace
+open scoped Topology NNReal ENNReal
+
+namespace SLEExactGauge.ScaleTraceLaw
+
+local instance : MeasurableSpace C(ℝ≥0, ℝ) := borel _
+local instance : BorelSpace C(ℝ≥0, ℝ) := ⟨rfl⟩
+local instance : MeasurableSpace C(ℝ≥0, ℂ) := borel _
+local instance : BorelSpace C(ℝ≥0, ℂ) := ⟨rfl⟩
+
+theorem brownian_continuous_path_law
+    {Ω : Type*} [MeasurableSpace Ω] {P : Measure Ω}
+    (B B' : ℝ≥0 → Ω → ℝ) (hB : IsBrownianReal B P) (hB' : IsBrownianReal B' P)
+    (hm : ∀ t, Measurable (B t)) (hm' : ∀ t, Measurable (B' t))
+    (hc : ∀ ω, Continuous (fun t => B t ω)) (hc' : ∀ ω, Continuous (fun t => B' t ω)) :
+    P.map (sourceDriverPath B hc) = P.map (sourceDriverPath B' hc') := by
+  have hb : Measurable (fun ω t => B t ω) := Measurable.of_eval hm
+  have hb' : Measurable (fun ω t => B' t ω) := Measurable.of_eval hm'
+  have hleft : IsProjectiveLimit (P.map (fun ω t => B t ω)) BrownianReal.projectiveFamily := by
+    intro I
+    rw [Measure.map_map (Finset.measurable_restrict I) hb]
+    exact (hB.hasLaw I).map_eq
+  have hright : IsProjectiveLimit (P.map (fun ω t => B' t ω)) BrownianReal.projectiveFamily := by
+    intro I
+    rw [Measure.map_map (Finset.measurable_restrict I) hb']
+    exact (hB'.hasLaw I).map_eq
+  have he := congrArg (Measure.map (fun p : ℝ≥0 → ℝ => fun n => p (denseSeq ℝ≥0 n)))
+    (hleft.unique hright)
+  have hem : Measurable (fun p : ℝ≥0 → ℝ => fun n => p (denseSeq ℝ≥0 n)) :=
+    Measurable.of_eval (fun _ => measurable_pi_apply _)
+  rw [Measure.map_map hem hb, Measure.map_map hem hb'] at he
+  apply source_path_evaluation_embedding.map_injective
+  rw [Measure.map_map source_path_evaluation_embedding.measurable
+      (source_path_measurable _ hm),
+    Measure.map_map source_path_evaluation_embedding.measurable (source_path_measurable _ hm')]
+  exact he
+
+/-- Equality of continuous driver laws gives equality of the actual trace
+laws. Reverse-flow approximants identify the trace factor on the common law. -/
+theorem trace_path_law_of_driver_law
+    {Ω : Type*} [MeasurableSpace Ω] {P : Measure Ω}
+    (κ : ℝ) (hκ : 0 < κ) (hκ8 : κ < 8)
+    (B B' : ℝ≥0 → Ω → ℝ) (hB : IsBrownianReal B P)
+    (hm : ∀ t, Measurable (B t)) (hm' : ∀ t, Measurable (B' t))
+    (hc : ∀ ω, Continuous (fun t => B t ω)) (hc' : ∀ ω, Continuous (fun t => B' t ω))
+    (γ γ' : Ω → ℝ≥0 → ℂ) (G F G' F' : Ω → ℝ≥0 → ℂ → ℂ)
+    (hw : ∀ ω, IsCapacityTwoWitness (fun t => Real.sqrt κ * B t ω) (γ ω) (G ω) (F ω))
+    (hw' : ∀ ω, IsCapacityTwoWitness (fun t => Real.sqrt κ * B' t ω) (γ' ω) (G' ω) (F' ω))
+    (hlaw : P.map (sourceDriverPath B hc) = P.map (sourceDriverPath B' hc')) :
+    P.map (sourceTracePath γ (fun ω => (hw ω).1)) =
+      P.map (sourceTracePath γ' (fun ω => (hw' ω).1)) := by
+  obtain ⟨Φ, hΦm, hΦ, _⟩ := sourceStoppedTraceLaw κ hκ hκ8 B hB hm hc γ G F hw
+  let bp := sourceDriverPath B hc
+  let bp' := sourceDriverPath B' hc'
+  let gp := sourceTracePath γ (fun ω => (hw ω).1)
+  let gp' := sourceTracePath γ' (fun ω => (hw' ω).1)
+  have hbm : Measurable bp := source_path_measurable _ hm
+  have hbm' : Measurable bp' := source_path_measurable _ hm'
+  choose Q hQm hQ0 hQd using fun (t : ℝ≥0) (n : ℕ) =>
+    source_canonical_reverse_flow κ t (a := 1 / ((n : ℝ) + 1)) (by positivity)
+  let a (n : ℕ) : ℝ := 1 / ((n : ℝ) + 1)
+  have ha (n : ℕ) : 0 < a n := by dsimp [a]; positivity
+  have hy : Tendsto a atTop (𝓝[>] (0 : ℝ)) :=
+    tendsto_nhdsWithin_iff.mpr ⟨tendsto_one_div_add_atTop_nhds_zero_nat,
+      Eventually.of_forall ha⟩
+  have hlimit (B₀ : ℝ≥0 → Ω → ℝ) (hc₀ : ∀ ω, Continuous (fun t => B₀ t ω))
+      (γ₀ : Ω → ℝ≥0 → ℂ) (G₀ F₀ : Ω → ℝ≥0 → ℂ → ℂ)
+      (hw₀ : ∀ ω, IsCapacityTwoWitness (fun t => Real.sqrt κ * B₀ t ω)
+        (γ₀ ω) (G₀ ω) (F₀ ω)) (ω : Ω) (t : ℝ≥0) :
+      Tendsto (fun n => Q t n t (sourceDriverPath B₀ hc₀ ω)) atTop (𝓝 (γ₀ ω t)) := by
+    have he (n : ℕ) : Q t n t (sourceDriverPath B₀ hc₀ ω) =
+        F₀ ω t ((Real.sqrt κ * B₀ t ω : ℝ) + (a n : ℂ) * Complex.I) := by
+      apply (hw₀ ω).reverse_flow_identifies t
+        ((Real.sqrt κ * B₀ t ω : ℝ) + (a n : ℂ) * Complex.I) (ha n) (by simp)
+        (fun s => Q t n s (sourceDriverPath B₀ hc₀ ω)) (hQ0 t n _)
+      intro s hs
+      exact (hQd t n _ s hs.1).mono Icc_subset_Ici_self
+    have ht := ((hw₀ ω).2.2.2.2.2.2.2.2.2.2.2.2 t).comp hy
+    simpa only [he, Function.comp_def] using ht
+  have hset (t : ℝ≥0) : MeasurableSet
+      {p : C(ℝ≥0, ℝ) | Tendsto (fun n => Q t n t p - Φ p t) atTop (𝓝 0)} :=
+    measurableSet_tendsto (𝓝 (0 : ℂ)) (fun n => (hQm t n t).sub
+      ((continuous_eval_const t).measurable.comp hΦm))
+  have hprime (t : ℝ≥0) : ∀ᵐ ω ∂P, Φ (bp' ω) t = γ' ω t := by
+    have ho : ∀ᵐ p ∂P.map bp, Tendsto (fun n => Q t n t p - Φ p t) atTop (𝓝 0) := by
+      apply (ae_map_iff hbm.aemeasurable (hset t)).mpr
+      exact Eventually.of_forall (fun ω => by
+        have hh := hlimit B hc γ G F hw ω t
+        have he : Φ (bp ω) t = γ ω t := congrArg (fun p : C(ℝ≥0, ℂ) => p t) (hΦ ω)
+        rw [he]
+        exact tendsto_sub_nhds_zero_iff.mpr hh)
+    rw [hlaw] at ho
+    filter_upwards [(ae_map_iff hbm'.aemeasurable (hset t)).mp ho] with ω hω
+    exact tendsto_nhds_unique (tendsto_sub_nhds_zero_iff.mp hω) (hlimit B' hc' γ' G' F' hw' ω t)
+  have hpath : ∀ᵐ ω ∂P, Φ (bp' ω) = gp' ω := by
+    filter_upwards [ae_all_iff.mpr (fun n => hprime (denseSeq ℝ≥0 n))] with ω hω
+    apply DFunLike.coe_injective
+    exact (denseRange_denseSeq ℝ≥0).equalizer (Φ (bp' ω)).continuous (hw' ω).1
+      (funext hω)
+  calc
+    P.map gp = (P.map bp).map Φ := by
+      rw [Measure.map_map hΦm hbm]
+      congr 1
+      exact funext (fun ω => (hΦ ω).symm)
+    _ = (P.map bp').map Φ := by rw [hlaw]
+    _ = P.map (Φ ∘ bp') := Measure.map_map hΦm hbm'
+    _ = P.map gp' := Measure.map_congr hpath
+
+/-- The actual capacity-normalized scaling on continuous trace paths. -/
+def scalePath (c : ℝ≥0) (p : C(ℝ≥0, ℂ)) : C(ℝ≥0, ℂ) :=
+  ⟨sourceScaleTrace c p, continuous_const.mul
+    (p.continuous.comp (continuous_id.div_const (c ^ 2)))⟩
+
+theorem measurable_scalePath (c : ℝ≥0) : Measurable (scalePath c) :=
+  source_path_measurable _ (fun t => measurable_const.mul
+    (continuous_eval_const (sourceScaleTime c t)).measurable)
+
+/-- The scaled actual capacity trace has exactly the original path law. -/
+theorem scaled_trace_path_law
+    {Ω : 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) :
+    P.map (fun ω => scalePath c (sourceTracePath γ (fun ω => (hw ω).1) ω)) =
+      P.map (sourceTracePath γ (fun ω => (hw ω).1)) := by
+  let Bc : ℝ≥0 → Ω → ℝ := fun t ω => (c : ℝ) * B (sourceScaleTime c t) ω
+  have hBc : IsBrownianReal Bc P := by
+    have hh := hB.smul (c := (c ^ 2)⁻¹) (inv_ne_zero (pow_ne_zero 2 hcpos.ne'))
+    simpa only [Bc, sourceScaleTime, NNReal.coe_inv, NNReal.coe_pow, Real.sqrt_inv,
+      Real.sqrt_sq c.coe_nonneg, inv_inv, div_eq_mul_inv, mul_comm] using hh
+  have hmc : ∀ t, Measurable (Bc t) := fun t => measurable_const.mul (hm _)
+  have hcc : ∀ ω, Continuous (fun t => Bc t ω) := fun ω =>
+    continuous_const.mul ((hc ω).comp (continuous_id.div_const (c ^ 2)))
+  have hwc : ∀ ω, IsCapacityTwoWitness (fun t => Real.sqrt κ * Bc t ω)
+      (sourceScaleTrace c (γ ω)) (sourceScaleChart c (G ω)) (sourceScaleChart c (F ω)) := by
+    intro ω
+    have hh := source_scale_witness c hcpos (fun t => Real.sqrt κ * B t ω)
+      (γ ω) (G ω) (F ω) (hw ω)
+    simpa only [Bc, mul_left_comm] using hh
+  have hlaw := brownian_continuous_path_law B Bc hB hBc hm hmc hc hcc
+  have he := trace_path_law_of_driver_law κ hκ hκ8 B Bc hB hm hmc hc hcc
+    γ (fun ω => sourceScaleTrace c (γ ω)) G F (fun ω => sourceScaleChart c (G ω))
+    (fun ω => sourceScaleChart c (F ω)) hw hwc hlaw
+  exact he.symm
+
+end SLEExactGauge.ScaleTraceLaw
+
+end
+
+end OAI
diff --git a/lean/OAI/Probability/SLE/Loewner/ShiftedHydrodynamicComposition.lean b/lean/OAI/Probability/SLE/Loewner/ShiftedHydrodynamicComposition.lean
new file mode 100644
index 0000000000000000000000000000000000000000..eb7377807e69acb3903f49b6d483106bacb36bea
--- /dev/null
+++ b/lean/OAI/Probability/SLE/Loewner/ShiftedHydrodynamicComposition.lean
@@ -0,0 +1,121 @@
+import OAI.Probability.SLE.Loewner.HydrodynamicComposition
+import Mathlib.Topology.Algebra.Group.ContinuousDiv
+
+namespace OAI
+
+/-! Hydrodynamic normalization under the translated chart compositions
+used for a future slit. -/
+noncomputable section
+open Set Filter Function Complex
+open scoped Topology
+
+namespace SLEExactGauge
+
+lemma complex_cocompact_eventually_ne_zero : ∀ᶠ z : ℂ in cocompact ℂ, z≠0 :=
+  (isCompact_singleton (x := (0:ℂ))).compl_mem_cocompact
+
+lemma normalized_ratio_escape {l : Filter ℂ} {F : ℂ → ℂ}
+    (hl : l≤cocompact ℂ) (hF : Tendsto (fun z => F z/z) l (𝓝 1)) :
+    Tendsto F l (cocompact ℂ) := by
+  have hr : Tendsto (fun z => ‖F z/z‖) l (𝓝 1) := by
+    simpa only [norm_one] using hF.norm
+  have hn := Filter.Tendsto.pos_mul_atTop (by norm_num : (0:ℝ)<1) hr
+    (tendsto_norm_cocompact_atTop.mono_left hl)
+  have hnorm : Tendsto (fun z => ‖F z‖) l atTop := by
+    apply hn.congr'
+    filter_upwards [complex_cocompact_eventually_ne_zero.filter_mono hl]
+      with z hz
+    rw [norm_div,div_mul_cancel₀ _ (norm_ne_zero_iff.mpr hz)]
+  simpa only [Metric.cobounded_eq_cocompact] using tendsto_norm_atTop_iff_cobounded.mp hnorm
+
+lemma complex_inv_tendsto_cocompact_zero :
+    Tendsto (fun z : ℂ => z⁻¹) (cocompact ℂ) (𝓝 0) := by
+  simpa only [Metric.cobounded_eq_cocompact] using
+    (tendsto_inv₀_cobounded : Tendsto (fun z : ℂ => z⁻¹) (Bornology.cobounded ℂ) (𝓝 0))
+
+theorem shifted_hydrodynamic_coefficient {G H : ℂ → ℂ} {c d : ℂ} (u : ℝ)
+    (hG : Tendsto (fun z => z*(G z-z)) (cocompact ℂ) (𝓝 c))
+    (hH : Tendsto (fun z => z*(H z-z)) (cocompact ℂ) (𝓝 d)) :
+    Tendsto (fun z => z*((u:ℂ)+H (G z-(u:ℂ))-z)) (cocompact ℂ) (𝓝 (c+d)) := by
+  have hu : Tendsto (fun z : ℂ => (u:ℂ)/z) (cocompact ℂ) (𝓝 0) := by
+    simpa only [div_eq_mul_inv,mul_zero] using complex_inv_tendsto_cocompact_zero.const_mul (u:ℂ)
+  have hs : Tendsto (fun z => (G z-(u:ℂ))/z) (cocompact ℂ) (𝓝 1) := by
+    simpa only [sub_div,sub_zero] using (hydrodynamic_ratio_limit hG).sub hu
+  have he := normalized_ratio_escape le_rfl hs
+  have hq : Tendsto (fun z => z/(G z-(u:ℂ))) (cocompact ℂ) (𝓝 1) := by
+    simpa only [inv_div,inv_one] using hs.inv₀ one_ne_zero
+  have hh := (hq.mul (hH.comp he)).add hG
+  rw [one_mul,add_comm d c] at hh
+  apply hh.congr'
+  filter_upwards [he.eventually ((isCompact_singleton (x := (0:ℂ))).compl_mem_cocompact)]
+    with z hz
+  dsimp only [Function.comp_apply]
+  field_simp [show G z-(u:ℂ)≠0 from hz]
+  ring
+
+lemma upper_translation_tendsto (u : ℝ) :
+    Tendsto (fun z : ℂ => z+(u:ℂ)) (cocompact ℂ ⊓ 𝓟 upperHalfPlane)
+      (cocompact ℂ ⊓ 𝓟 upperHalfPlane) := by
+  apply tendsto_inf.mpr
+  constructor
+  · exact (Homeomorph.addRight (u:ℂ)).isClosedEmbedding.tendsto_cocompact.mono_left inf_le_left
+  · apply tendsto_principal.mpr
+    rw [eventually_inf_principal]
+    exact Eventually.of_forall fun z hz => by
+      change 0<(z+(u:ℂ)).im
+      simpa only [add_im,ofReal_im,add_zero] using (show 0<z.im from hz)
+
+theorem shifted_inverse_normalized {F J : ℂ → ℂ} (u : ℝ)
+    (hF : Tendsto (fun z => F z/z) (cocompact ℂ ⊓ 𝓟 upperHalfPlane) (𝓝 1))
+    (hJ : Tendsto (fun z => J z/z) (cocompact ℂ ⊓ 𝓟 upperHalfPlane) (𝓝 1))
+    (hJm : MapsTo J upperHalfPlane upperHalfPlane) :
+    Tendsto (fun z => F ((u:ℂ)+J (z-(u:ℂ)))/z)
+      (cocompact ℂ ⊓ 𝓟 upperHalfPlane) (𝓝 1) := by
+  have hshift := upper_translation_tendsto (-u)
+  simp only [ofReal_neg,← sub_eq_add_neg] at hshift
+  have hi := complex_inv_tendsto_cocompact_zero.mono_left
+    (show cocompact ℂ ⊓ 𝓟 upperHalfPlane≤cocompact ℂ from inf_le_left)
+  have hu : Tendsto (fun z : ℂ => (u:ℂ)/z)
+      (cocompact ℂ ⊓ 𝓟 upperHalfPlane) (𝓝 0) := by
+    simpa only [div_eq_mul_inv,mul_zero] using hi.const_mul (u:ℂ)
+  have hratio : Tendsto (fun z : ℂ => (z-(u:ℂ))/z)
+      (cocompact ℂ ⊓ 𝓟 upperHalfPlane) (𝓝 1) := by
+    have hh := (tendsto_const_nhds : Tendsto (fun _ : ℂ => (1:ℂ))
+      (cocompact ℂ ⊓ 𝓟 upperHalfPlane) (𝓝 1)).sub hu
+    rw [sub_zero] at hh
+    apply hh.congr'
+    filter_upwards [complex_cocompact_eventually_ne_zero.filter_mono
+      (show cocompact ℂ ⊓ 𝓟 upperHalfPlane≤cocompact ℂ from inf_le_left)] with z hz
+    rw [sub_div,div_self (show z≠0 from hz)]
+  have hJratio := (hJ.comp hshift).mul hratio
+  have hmid : Tendsto (fun z : ℂ => ((u:ℂ)+J (z-(u:ℂ)))/z)
+      (cocompact ℂ ⊓ 𝓟 upperHalfPlane) (𝓝 1) := by
+    have hh := hu.add hJratio
+    simp only [zero_add,mul_one] at hh
+    apply hh.congr'
+    filter_upwards [(hshift.mono_right inf_le_left).eventually
+      ((isCompact_singleton (x := (0:ℂ))).compl_mem_cocompact)] with z hz
+    dsimp only [Function.comp_apply]
+    field_simp [show z-(u:ℂ)≠0 from hz]
+  have hmidEscape := normalized_ratio_escape inf_le_left hmid
+  have hmidUpper : Tendsto (fun z : ℂ => (u:ℂ)+J (z-(u:ℂ)))
+      (cocompact ℂ ⊓ 𝓟 upperHalfPlane) (𝓟 upperHalfPlane) := by
+    apply tendsto_principal.mpr
+    rw [eventually_inf_principal]
+    exact Eventually.of_forall fun z hz => by
+      have hsub : z-(u:ℂ)∈upperHalfPlane := by
+        simpa only [upperHalfPlane,mem_ofPred_eq,sub_im,ofReal_im,sub_zero] using hz
+      simpa only [upperHalfPlane,mem_ofPred_eq,add_im,ofReal_im,zero_add] using hJm hsub
+  have hh := (hF.comp (tendsto_inf.mpr ⟨hmidEscape,hmidUpper⟩)).mul hmid
+  rw [mul_one] at hh
+  apply hh.congr'
+  filter_upwards [hmidEscape.eventually ((isCompact_singleton (x := (0:ℂ))).compl_mem_cocompact)]
+    with z hz
+  dsimp only [Function.comp_apply]
+  field_simp [show (u:ℂ)+J (z-(u:ℂ))≠0 from hz]
+
+end SLEExactGauge
+
+end
+
+end OAI
diff --git a/lean/OAI/Probability/SLE/Loewner/SlitBoundaryBarrier.lean b/lean/OAI/Probability/SLE/Loewner/SlitBoundaryBarrier.lean
new file mode 100644
index 0000000000000000000000000000000000000000..a6566d77e2215375f0233dbd6211a5cd55d5853f
--- /dev/null
+++ b/lean/OAI/Probability/SLE/Loewner/SlitBoundaryBarrier.lean
@@ -0,0 +1,95 @@
+import OAI.Probability.SLE.Loewner.InitialCapacity
+import OAI.Probability.SLE.Loewner.TraceBoundaryBarrier
+
+namespace OAI
+
+/-! Compact, locally path-connected boundary barriers for static attached slits. -/
+noncomputable section
+open Set Filter Metric Function
+open scoped Topology
+
+namespace SLEExactGauge
+
+def slitBoundaryBarrier (p : C(unitInterval,ℂ)) (R : ℝ) : Set ℂ :=
+  range p ∪ (Complex.ofReal '' Icc (-R) R)
+
+lemma slitBoundaryBarrier_compact (p : C(unitInterval,ℂ)) (R : ℝ) :
+    IsCompact (slitBoundaryBarrier p R) :=
+  (isCompact_range p.continuous).union (isCompact_Icc.image Complex.continuous_ofReal)
+
+lemma slitBoundaryBarrier_locallyPathConnected (p : C(unitInterval,ℂ))
+    (R : ℝ) (hR : 0≤R) : LocallyPathConnectedSpace (slitBoundaryBarrier p R) := by
+  have : LocallyPathConnectedSpace unitInterval :=
+    (isQuotientMap_projIcc (a := (0:ℝ)) (b := 1) (h := zero_le_one)).locallyPathConnectedSpace
+  let q : unitInterval → range p := fun t => ⟨p t,mem_range_self t⟩
+  have hq : Continuous q := p.continuous.subtype_mk _
+  have hs : Surjective q := by
+    rintro ⟨_,t,rfl⟩
+    exact ⟨t,rfl⟩
+  have : LocallyPathConnectedSpace (range p) :=
+    (hq.isClosedMap.isQuotientMap hq hs).locallyPathConnectedSpace
+  have : LocallyPathConnectedSpace (Icc (-R) R) :=
+    (isQuotientMap_projIcc (a := -R) (b := R) (h := by linarith)).locallyPathConnectedSpace
+  let r : Icc (-R) R → Complex.ofReal '' Icc (-R) R := fun x => ⟨x,⟨x,x.2,rfl⟩⟩
+  have hr : Continuous r := (Complex.continuous_ofReal.comp continuous_subtype_val).subtype_mk _
+  have hs : Surjective r := by
+    rintro ⟨_,x,hx,rfl⟩
+    exact ⟨⟨x,hx⟩,rfl⟩
+  have : LocallyPathConnectedSpace (Complex.ofReal '' Icc (-R) R) :=
+    (hr.isClosedMap.isQuotientMap hr hs).locallyPathConnectedSpace
+  exact compact_union_locallyPathConnected (isCompact_range p.continuous)
+    (isCompact_Icc.image Complex.continuous_ofReal)
+
+lemma slitBoundaryBarrier_disjoint_domain (p : C(unitInterval,ℂ)) (R : ℝ) :
+    Disjoint (slitBoundaryBarrier p R) (upperHalfPlane \ range p) := by
+  apply disjoint_left.mpr
+  intro z hz hD
+  rcases hz with hz | ⟨x,_,rfl⟩
+  · exact hD.2 hz
+  · have him := hD.1
+    change 0<(x:ℂ).im at him
+    simp at him
+
+lemma frontier_mem_slitBoundaryBarrier (p : C(unitInterval,ℂ)) {R : ℝ} {z : ℂ}
+    (hz : z∈frontier (upperHalfPlane \ range p)) (hR : ‖z‖≤R) :
+    z∈slitBoundaryBarrier p R := by
+  by_cases hp : z∈range p
+  · exact Or.inl hp
+  right
+  have hsub : upperHalfPlane \ range p ⊆ {w : ℂ | 0≤w.im} := by
+    intro w hw
+    exact (show 0<w.im from hw.1).le
+  have hznonneg : 0≤z.im :=
+    (closure_minimal hsub
+      (isClosed_le continuous_const Complex.continuous_im)) hz.1
+  have ho : IsOpen (upperHalfPlane \ range p) :=
+    isOpen_upperHalfPlane.sdiff (isCompact_range p.continuous).isClosed
+  have hznot : z∉upperHalfPlane \ range p := by simpa only [ho.interior_eq] using hz.2
+  have him : z.im=0 := by
+    by_contra he
+    exact hznot ⟨lt_of_le_of_ne hznonneg (Ne.symm he),hp⟩
+  refine ⟨z.re,?_,?_⟩
+  · have hh := (Complex.abs_re_le_norm z).trans hR
+    exact ⟨by linarith [(neg_abs_le z.re)],(le_abs_self z.re).trans hh⟩
+  · apply Complex.ext <;> simp [him]
+
+lemma slitBoundaryBarrier_uniform_paths (p : C(unitInterval,ℂ))
+    (R : ℝ) (hR : 0≤R) (ε : ℝ) (hε : 0<ε) :
+    ∃ δ : ℝ, 0<δ ∧ ∀ x∈slitBoundaryBarrier p R, ∀ y∈slitBoundaryBarrier p R,
+      dist x y<δ → ∃ q : Path x y, (∀ s, q s∈slitBoundaryBarrier p R) ∧
+        ∀ s, dist (q s) x<ε := by
+  have : CompactSpace (slitBoundaryBarrier p R) :=
+    isCompact_iff_compactSpace.mp (slitBoundaryBarrier_compact p R)
+  have : LocallyPathConnectedSpace (slitBoundaryBarrier p R) :=
+    slitBoundaryBarrier_locallyPathConnected p R hR
+  obtain ⟨δ,hδ,hpath⟩ := compact_locallyPathConnected_uniform_path
+    (A := slitBoundaryBarrier p R) ε hε
+  refine ⟨δ,hδ,fun x hx y hy hxy => ?_⟩
+  obtain ⟨q,hq⟩ := hpath ⟨x,hx⟩ ⟨y,hy⟩ hxy
+  exact ⟨q.map continuous_subtype_val,fun s => (q s).property,hq⟩
+
+end SLEExactGauge
+
+end
+
+end OAI
diff --git a/lean/OAI/Probability/SLE/Loewner/SlitBoundaryFiber.lean b/lean/OAI/Probability/SLE/Loewner/SlitBoundaryFiber.lean
new file mode 100644
index 0000000000000000000000000000000000000000..93abd6e517021473a3d656527056bfb237849745
--- /dev/null
+++ b/lean/OAI/Probability/SLE/Loewner/SlitBoundaryFiber.lean
@@ -0,0 +1,62 @@
+import OAI.Probability.SLE.Geometry.HalfPlaneBoundaryIdentity
+import OAI.Probability.SLE.Loewner.SlitChartBoundaryExtension
+
+namespace OAI
+
+/-! No interval of real boundary parameters collapses to a single point
+under the continuous inverse slit chart. -/
+noncomputable section
+open Set Function Complex Metric
+open scoped Topology
+
+namespace SLEExactGauge
+
+lemma vertical_point_mem_ball (x : ℝ) {y r : ℝ} (hy : 0<y) (hyr : y<r) :
+    (x:ℂ)+(y:ℂ)*I∈ball (x:ℂ) r := by
+  simpa only [mem_ball,dist_eq_norm,add_sub_cancel_left,norm_mul,norm_real,
+    Real.norm_eq_abs,abs_of_pos hy,norm_I,mul_one] using hyr
+
+theorem SimpleSlitChart.boundary_not_constant_on_interval {p : C(unitInterval,ℂ)}
+    (P : SimpleSlitChart p) {Fbar : ℂ → ℂ}
+    (hC : ContinuousOn Fbar {z : ℂ | 0≤z.im})
+    (he : ∀ z∈upperHalfPlane, Fbar z=P.inverse z)
+    (x : ℝ) {r : ℝ} (hr : 0<r) (c : ℂ) :
+    ¬ ∀ y∈Ioo (x-r) (x+r), Fbar (y:ℂ)=c := by
+  intro hconst
+  have hd : DifferentiableOn ℂ Fbar upperHalfPlane :=
+    P.inverse_differentiable.congr (fun z hz => he z hz)
+  have hlocal := halfPlane_boundary_identity hC hd x hr c (fun z hz hzi => by
+    have hre : |z.re-x|<r := lt_of_le_of_lt
+      (by simpa only [sub_re,ofReal_re,dist_eq_norm] using Complex.abs_re_le_norm (z-(x:ℂ))) hz
+    have hxr := abs_lt.mp hre
+    have hez : z=(z.re:ℂ) := by apply Complex.ext <;> simp [hzi]
+    rw [hez]
+    exact hconst z.re ⟨by linarith,by linarith⟩)
+  let z₁ : ℂ := (x:ℂ)+((r/2:ℝ):ℂ)*I
+  let z₂ : ℂ := (x:ℂ)+((r/3:ℝ):ℂ)*I
+  have hz₁ : z₁∈upperHalfPlane := by
+    change 0<z₁.im
+    dsimp [z₁]
+    simpa using half_pos hr
+  have hz₂ : z₂∈upperHalfPlane := by
+    change 0<z₂.im
+    dsimp [z₂]
+    simpa using div_pos hr (by norm_num : (0:ℝ)<3)
+  have hb₁ : z₁∈ball (x:ℂ) r := vertical_point_mem_ball x (half_pos hr) (by linarith)
+  have hb₂ : z₂∈ball (x:ℂ) r := vertical_point_mem_ball x
+    (div_pos hr (by norm_num : (0:ℝ)<3)) (by linarith)
+  have hv₁ := hlocal z₁ hb₁ hz₁
+  have hv₂ := hlocal z₂ hb₂ hz₂
+  rw [he z₁ hz₁] at hv₁
+  rw [he z₂ hz₂] at hv₂
+  have heq := P.inverse_injOn hz₁ hz₂ (hv₁.trans hv₂.symm)
+  have him := congrArg Complex.im heq
+  dsimp [z₁,z₂] at him
+  simp only [ofReal_im,mul_im,ofReal_re,I_im,mul_one,I_re,mul_zero,add_zero,zero_add] at him
+  linarith
+
+end SLEExactGauge
+
+end
+
+end OAI
diff --git a/lean/OAI/Probability/SLE/Loewner/SlitBoundaryIntegralLimit.lean b/lean/OAI/Probability/SLE/Loewner/SlitBoundaryIntegralLimit.lean
new file mode 100644
index 0000000000000000000000000000000000000000..a60a8babacbb36073b348f4fe342e71a0eb64e03
--- /dev/null
+++ b/lean/OAI/Probability/SLE/Loewner/SlitBoundaryIntegralLimit.lean
@@ -0,0 +1,104 @@
+import OAI.Probability.SLE.Loewner.SlitReflectedInterior
+
+namespace OAI
+
+/-! The uniformly separated boundary coordinates admit passage through
+the exact interior Loewner integral. -/
+noncomputable section
+open Set Filter Function Complex Metric MeasureTheory
+open scoped Topology NNReal
+
+namespace SLEExactGauge
+
+lemma slitReflectedFlow_real_kernel_continuous (p : C(unitInterval,ℂ)) (hi : Injective p)
+    (h0 : p 0=0) (hH : ∀ t : unitInterval, t≠0 → p t∈upperHalfPlane)
+    {T : unitInterval} (hT : T<1) {x : ℝ} (hx : x≠0) :
+    Continuous (fun t : ℝ => 2/(slitReflectedFlow p hi h0 hH T (x:ℂ) t-
+      (slitCapacityDriver p hi h0 hH hT t.toNNReal:ℂ))) :=
+  continuous_const.div ((slitReflectedFlow_real_continuous p hi h0 hH T hx).sub
+    (Complex.continuous_ofReal.comp
+      ((slitCapacityDriver p hi h0 hH hT).continuous.comp continuous_real_toNNReal)))
+    (slitReflectedFlow_separated p hi h0 hH hT hx)
+
+lemma slitReflectedFlow_near_real_mem (p : C(unitInterval,ℂ))
+    (h0 : p 0=0) (hH : ∀ t : unitInterval, t≠0 → p t∈upperHalfPlane)
+    {x : ℝ} (hx : x≠0) :
+    ∀ᶠ y : ℝ in 𝓝[>] (0:ℝ), (x:ℂ)+(y:ℂ)*I∈upperHalfPlane \ range p := by
+  have hD : IsOpen (range p)ᶜ := (isCompact_range p.continuous).isClosed.isOpen_compl
+  have hxD : (x:ℂ)∈(range p)ᶜ := fun he => real_not_reflected_arc p h0 hH hx (Or.inl he)
+  have hv : Tendsto (fun y : ℝ => (x:ℂ)+(y:ℂ)*I) (𝓝[>] (0:ℝ)) (𝓝 (x:ℂ)) := by
+    have hc : Continuous (fun y : ℝ => (x:ℂ)+(y:ℂ)*I) := by fun_prop
+    simpa only [ofReal_zero,zero_mul,add_zero] using
+      (hc.tendsto 0).mono_left nhdsWithin_le_nhds
+  filter_upwards [self_mem_nhdsWithin,hv.eventually (hD.mem_nhds hxD)] with y hy hyD
+  exact ⟨by simpa [upperHalfPlane] using hy,hyD⟩
+
+lemma slitReflectedFlow_near_real_kernel_bound (p : C(unitInterval,ℂ)) (hi : Injective p)
+    (h0 : p 0=0) (hH : ∀ t : unitInterval, t≠0 → p t∈upperHalfPlane)
+    {T : unitInterval} (hT : T<1) {x : ℝ} (hx : x≠0) :
+    ∃ C : ℝ, ∀ᶠ y : ℝ in 𝓝[>] (0:ℝ),
+      ∀ t∈Icc 0 (slitCapacityHorizon p hi h0 hH T:ℝ),
+      ‖2/(slitReflectedFlow p hi h0 hH T ((x:ℂ)+(y:ℂ)*I) t-
+        (slitCapacityDriver p hi h0 hH hT t.toNNReal:ℂ))‖≤C := by
+  obtain ⟨m,hm,hgap⟩ := slitReflectedFlow_positive_gap p hi h0 hH hT hx
+  have hc := Metric.tendstoUniformly_iff.mp (slitReflectedFlow_uniform_limit p hi h0 hH T hx)
+    (m/2) (half_pos hm)
+  refine ⟨4/m,?_⟩
+  filter_upwards [hc] with y hy t ht
+  let q := slitReflectedFlow p hi h0 hH T ((x:ℂ)+(y:ℂ)*I) t
+  let r := slitReflectedFlow p hi h0 hH T (x:ℂ) t
+  let u : ℂ := (slitCapacityDriver p hi h0 hH hT t.toNNReal:ℂ)
+  have hsmall : ‖r-q‖< m/2 := by simpa only [dist_eq_norm] using hy t
+  have htri := norm_sub_le_norm_sub_add_norm_sub r q u
+  have hlarge : m/2<‖q-u‖ := by linarith [hgap t ht]
+  have hnorm : 0<‖q-u‖ := (half_pos hm).trans hlarge
+  change ‖(2:ℂ)/(q-u)‖≤4/m
+  rw [norm_div,Complex.norm_ofNat]
+  apply (div_le_div_iff₀ hnorm hm).mpr
+  nlinarith
+
+theorem slitReflectedFlow_integral_tendsto (p : C(unitInterval,ℂ)) (hi : Injective p)
+    (h0 : p 0=0) (hH : ∀ t : unitInterval, t≠0 → p t∈upperHalfPlane)
+    {T : unitInterval} (hT : T<1) {x : ℝ} (hx : x≠0)
+    {t : ℝ} (ht : t∈Icc 0 (slitCapacityHorizon p hi h0 hH T:ℝ)) :
+    Tendsto (fun y : ℝ => ∫ u in 0..t,
+      2/(slitReflectedFlow p hi h0 hH T ((x:ℂ)+(y:ℂ)*I) u-
+        (slitCapacityDriver p hi h0 hH hT u.toNNReal:ℂ))) (𝓝[>] (0:ℝ))
+      (𝓝 (∫ u in 0..t, 2/(slitReflectedFlow p hi h0 hH T (x:ℂ) u-
+        (slitCapacityDriver p hi h0 hH hT u.toNNReal:ℂ)))) := by
+  obtain ⟨C,hC⟩ := slitReflectedFlow_near_real_kernel_bound p hi h0 hH hT hx
+  have hmem := slitReflectedFlow_near_real_mem p h0 hH hx
+  simp_rw [intervalIntegral.integral_of_le ht.1]
+  apply tendsto_integral_filter_of_dominated_convergence (fun _ => C)
+  · filter_upwards [hmem] with y hy
+    exact (slitReflectedFlow_interior_kernel_continuous p hi h0 hH hT hy).aestronglyMeasurable
+  · filter_upwards [hC] with y hy
+    filter_upwards [ae_restrict_mem (μ := volume) measurableSet_Ioc] with u hu
+    exact hy u ⟨hu.1.le,hu.2.trans ht.2⟩
+  · exact integrable_const _
+  · filter_upwards [ae_restrict_mem (μ := volume) measurableSet_Ioc] with u _hu
+    exact tendsto_const_nhds.div
+      (((slitReflectedFlow_uniform_limit p hi h0 hH T hx).tendsto_at u).sub_const _)
+      (slitReflectedFlow_separated p hi h0 hH hT hx u)
+
+theorem slitReflectedFlow_boundary_integral (p : C(unitInterval,ℂ)) (hi : Injective p)
+    (h0 : p 0=0) (hH : ∀ t : unitInterval, t≠0 → p t∈upperHalfPlane)
+    {T : unitInterval} (hT : T<1) {x : ℝ} (hx : x≠0)
+    {t : ℝ} (ht : t∈Icc 0 (slitCapacityHorizon p hi h0 hH T:ℝ)) :
+    (∫ u in 0..t, 2/(slitReflectedFlow p hi h0 hH T (x:ℂ) u-
+      (slitCapacityDriver p hi h0 hH hT u.toNNReal:ℂ)))=
+      slitReflectedFlow p hi h0 hH T (x:ℂ) t-(x:ℂ) := by
+  have hv : Tendsto (fun y : ℝ => (x:ℂ)+(y:ℂ)*I) (𝓝[>] (0:ℝ)) (𝓝 (x:ℂ)) := by
+    have hc : Continuous (fun y : ℝ => (x:ℂ)+(y:ℂ)*I) := by fun_prop
+    simpa only [ofReal_zero,zero_mul,add_zero] using
+      (hc.tendsto 0).mono_left nhdsWithin_le_nhds
+  apply tendsto_nhds_unique (slitReflectedFlow_integral_tendsto p hi h0 hH hT hx ht)
+  apply (((slitReflectedFlow_uniform_limit p hi h0 hH T hx).tendsto_at t).sub hv).congr'
+  filter_upwards [slitReflectedFlow_near_real_mem p h0 hH hx] with y hy
+  exact (slitReflectedFlow_interior_integral p hi h0 hH hT hy ht).symm
+
+end SLEExactGauge
+
+end
+
+end OAI
diff --git a/lean/OAI/Probability/SLE/Loewner/SlitBoundaryTip.lean b/lean/OAI/Probability/SLE/Loewner/SlitBoundaryTip.lean
new file mode 100644
index 0000000000000000000000000000000000000000..0cc4f0a2845928542d16217876d8e127cb1e35a8
--- /dev/null
+++ b/lean/OAI/Probability/SLE/Loewner/SlitBoundaryTip.lean
@@ -0,0 +1,47 @@
+import OAI.Probability.SLE.Loewner.InitialDrivingTip
+
+namespace OAI
+
+/-! The static inverse boundary extension takes the actual driver to
+the prescribed tip. -/
+noncomputable section
+open Set Filter Function Complex
+open scoped Topology
+
+namespace SLEExactGauge
+
+theorem exists_initial_inverse_boundary_tip (p : C(unitInterval,ℂ)) (hi : Injective p)
+    (h0 : p 0=0) (hH : ∀ t : unitInterval, t≠0 → p t∈upperHalfPlane)
+    {s : unitInterval} (hs : s<1) :
+    ∃ B : ℂ → ℂ, ContinuousOn B {z : ℂ | 0 ≤ z.im} ∧
+      (∀ z∈upperHalfPlane, B z=initialInverseChart p hi h0 hH s z) ∧
+      B (initialDrivingValue p hi h0 hH s hs:ℂ)=p s := by
+  by_cases hs0 : s=0
+  · subst s
+    refine ⟨id,continuous_id.continuousOn,?_,?_⟩
+    · intro z _
+      simp only [initialInverseChart_zero,id_eq]
+    · simp only [id_eq,initialDrivingValue_zero,ofReal_zero,h0]
+  obtain ⟨B,hB,hBF⟩ := (initialSlitChart p hi h0 hH s hs0).exists_boundary_extension
+  have he (z : ℂ) (hz : z∈upperHalfPlane) : B z=initialInverseChart p hi h0 hH s z := by
+    simpa only [initialInverseChart,dite_eq_right hs0] using hBF z hz
+  refine ⟨B,hB,he,?_⟩
+  let u := initialDrivingValue p hi h0 hH s hs
+  have hc : Continuous (fun y : ℝ => (u:ℂ)+(y:ℂ)*I) := by fun_prop
+  have hv : Tendsto (fun y : ℝ => (u:ℂ)+(y:ℂ)*I) (𝓝[>] (0:ℝ)) (𝓝 (u:ℂ)) := by
+    simpa only [ofReal_zero,zero_mul,add_zero] using
+      (hc.tendsto 0).mono_left (show 𝓝[>] (0:ℝ) ≤ 𝓝 (0:ℝ) from nhdsWithin_le_nhds)
+  have hm : ∀ᶠ y : ℝ in 𝓝[>] (0:ℝ), (u:ℂ)+(y:ℂ)*I∈{z : ℂ | 0 ≤ z.im} := by
+    filter_upwards [self_mem_nhdsWithin] with y hy
+    simpa using hy.le
+  have hb := (hB (u:ℂ) (by simp)).tendsto.comp (tendsto_nhdsWithin_iff.mpr ⟨hv,hm⟩)
+  apply tendsto_nhds_unique hb
+  apply (initialInverse_radial_driver_limit p hi h0 hH hs).congr'
+  filter_upwards [self_mem_nhdsWithin] with y hy
+  exact (he _ (by simpa [upperHalfPlane] using hy)).symm
+
+end SLEExactGauge
+
+end
+
+end OAI
diff --git a/lean/OAI/Probability/SLE/Loewner/SlitCapacityChart.lean b/lean/OAI/Probability/SLE/Loewner/SlitCapacityChart.lean
new file mode 100644
index 0000000000000000000000000000000000000000..6476184977aed22e51a25c1ff43f0c15138546c5
--- /dev/null
+++ b/lean/OAI/Probability/SLE/Loewner/SlitCapacityChart.lean
@@ -0,0 +1,76 @@
+import OAI.Probability.SLE.Loewner.HydrodynamicCoefficient
+
+namespace OAI
+
+/-! Nonnegative capacity and height comparison for the exact normalized
+chart of a finite simple attached slit. -/
+noncomputable section
+open Set Filter Complex Function Metric
+open scoped Topology ComplexConjugate
+
+namespace SLEExactGauge
+
+theorem simple_slit_exists_nonnegative_capacity_chart
+    (p : C(unitInterval,ℂ)) (hi : Injective p) (h0 : p 0=0)
+    (hH : ∀ t : unitInterval, t ≠ 0 → p t ∈ upperHalfPlane) :
+    ∃ (G F : ℂ → ℂ) (c : ℝ), 0≤c ∧
+      BijOn G (upperHalfPlane \ range p) upperHalfPlane ∧
+      DifferentiableOn ℂ G (upperHalfPlane \ range p) ∧
+      DifferentiableOn ℂ F upperHalfPlane ∧
+      MapsTo F upperHalfPlane (upperHalfPlane \ range p) ∧
+      (∀ z ∈ upperHalfPlane \ range p, F (G z)=z) ∧
+      (∀ z ∈ upperHalfPlane, G (F z)=z) ∧
+      Tendsto (fun z : ℂ => z*(G z-z)) (cocompact ℂ) (𝓝 (c:ℂ)) ∧
+      Tendsto (fun z : ℂ => F z/z) (cocompact ℂ ⊓ 𝓟 upperHalfPlane) (𝓝 1) ∧
+      (∀ z ∈ upperHalfPlane \ range p, (G z).im ≤ z.im) := by
+  obtain ⟨f,a,ha,hb,hf,hf0,hfa,hs,hu⟩ :=
+    reflected_slit_exists_normalized_chart p hi h0 hH
+  have hK : IsCompact (reflectedArcSet p) := (isCompact_range p.continuous).union
+    ((isCompact_range p.continuous).image Complex.continuous_conj)
+  have hD : invertedExterior (reflectedArcSet p) ∈ 𝓝 (0:ℂ) :=
+    (invertedExterior_isOpen hK).mem_nhds (zero_mem_invertedExterior _)
+  have hreal := eq_ofReal_re_of_conj_eq (derivative_real_of_reflection hD
+    (slitInfinityFactor_reflection hD hs a))
+  let G := slitHydrodynamicMap f a
+  have hG : BijOn G (upperHalfPlane \ range p) upperHalfPlane := by
+    apply ((positive_real_affine_halfPlane ha (deriv (slitInfinityFactor f a) 0).re).comp
+      (exteriorJoukowski_bijOn.comp (slitExteriorMap_bijOn p h0 hH hs hu))).congr
+    intro z _
+    change (a:ℂ)*exteriorJoukowski (slitExteriorMap f z)-
+      ((deriv (slitInfinityFactor f a) 0).re:ℂ)=
+      (a:ℂ)*exteriorJoukowski (slitExteriorMap f z)-deriv (slitInfinityFactor f a) 0
+    rw [← hreal]
+  have hdG : DifferentiableOn ℂ G (upperHalfPlane \ range p) :=
+    ((exteriorJoukowski_differentiableOn.comp
+      (slitExteriorMap_differentiableOn p h0 hH hf hb.injOn hf0)
+      (slitExteriorMap_bijOn p h0 hH hs hu).mapsTo).const_mul (a:ℂ)).sub_const _
+  let F := invFunOn G (upperHalfPlane \ range p)
+  have ho : IsOpen (upperHalfPlane \ range p) :=
+    isOpen_upperHalfPlane.sdiff (isCompact_range p.continuous).isClosed
+  have hdF : DifferentiableOn ℂ F upperHalfPlane := by
+    simpa only [F,hG.image_eq] using hdG.invFunOn ho hG.injOn
+  have hmF : MapsTo F upperHalfPlane (upperHalfPlane \ range p) := hG.surjOn.mapsTo_invFunOn
+  have hl : ∀ z ∈ upperHalfPlane \ range p, F (G z)=z := hG.injOn.leftInvOn_invFunOn
+  have hr : ∀ z ∈ upperHalfPlane, G (F z)=z := hG.surjOn.rightInvOn_invFunOn
+  have hnorm := slit_inverse_tendsto_ratio p h0 hH ha hf hf0 hfa hs F hl
+  have hheight := normalized_inverse_height hG.mapsTo hdF
+    (hmF.mono_right sdiff_subset) hl hnorm
+  let c := (deriv (dslope (slitInfinityFactor f a) 0) 0).re
+  have hc : Tendsto (fun z : ℂ => z*(G z-z)) (cocompact ℂ) (𝓝 (c:ℂ)) := by
+    have hh := slitExteriorMap_laurent_limit (hf.analyticAt hD) hf0 ha.ne' hfa
+    have he := eq_ofReal_re_of_conj_eq (derivative_real_of_reflection hD
+      (dslope_reflection hD (slitInfinityFactor_reflection hD hs a)))
+    rw [he] at hh
+    exact hh
+  have hc0 : 0≤c := by
+    apply hydrodynamic_coefficient_nonneg hc
+    rw [eventually_inf_principal]
+    filter_upwards [(isCompact_range p.continuous).compl_mem_cocompact] with z hz
+    exact fun hzH => hheight z ⟨hzH,hz⟩
+  exact ⟨G,F,c,hc0,hG,hdG,hdF,hmF,hl,hr,hc,hnorm,hheight⟩
+
+end SLEExactGauge
+
+end
+
+end OAI
diff --git a/lean/OAI/Probability/SLE/Loewner/SlitCapacityQuotient.lean b/lean/OAI/Probability/SLE/Loewner/SlitCapacityQuotient.lean
new file mode 100644
index 0000000000000000000000000000000000000000..3288b8c8c721b6eb620579dadb01bc7227b6ba3d
--- /dev/null
+++ b/lean/OAI/Probability/SLE/Loewner/SlitCapacityQuotient.lean
@@ -0,0 +1,33 @@
+import OAI.Probability.SLE.Loewner.SlitCapacityRemainder
+
+namespace OAI
+
+/-! Dividing by the positive, exact capacity gives the first-order
+Loewner kernel with a radius-controlled error. -/
+noncomputable section
+open Set Filter Function Complex Metric
+open scoped Topology
+
+namespace SLEExactGauge
+
+theorem SimpleSlitChart.forward_quotient_kernel {p : C(unitInterval,ℂ)}
+    (P : SimpleSlitChart p) (hi : Injective p) (h0 : p 0=0)
+    (hH : ∀ t : unitInterval, t≠0 → p t∈upperHalfPlane)
+    {R : ℝ} (hR : 0<R) (hp : ∀ t : unitInterval, ‖p t‖<R)
+    {z : ℂ} (hzH : z∈upperHalfPlane) (hz : 2*R≤‖z‖) :
+    ‖(P.forward z-z)/(P.capacity:ℂ)-1/z‖≤10*R/‖z‖^2 := by
+  have hc : (P.capacity:ℂ)≠0 := ofReal_ne_zero.mpr P.capacity_pos.ne'
+  have he : (P.forward z-z)/(P.capacity:ℂ)-1/z=
+      (P.forward z-z-(P.capacity:ℂ)/z)/(P.capacity:ℂ) := by
+    field_simp [hc]
+  rw [he,norm_div,Complex.norm_real,Real.norm_eq_abs,abs_of_pos P.capacity_pos]
+  have hb := div_le_div_of_nonneg_right
+    (P.forward_kernel_remainder hi h0 hH hR hp hzH hz) P.capacity_pos.le
+  apply hb.trans_eq
+  field_simp [P.capacity_pos.ne']
+
+end SLEExactGauge
+
+end
+
+end OAI
diff --git a/lean/OAI/Probability/SLE/Loewner/SlitCapacityRemainder.lean b/lean/OAI/Probability/SLE/Loewner/SlitCapacityRemainder.lean
new file mode 100644
index 0000000000000000000000000000000000000000..48c0cdba5be2a374bb1db664add48daa35ac710b
--- /dev/null
+++ b/lean/OAI/Probability/SLE/Loewner/SlitCapacityRemainder.lean
@@ -0,0 +1,45 @@
+import OAI.Probability.SLE.Geometry.ExteriorCapacityRemainder
+import OAI.Probability.SLE.Loewner.ReflectedExteriorHeight
+
+namespace OAI
+
+/-! The local Loewner kernel estimate for an arbitrary simple attached
+slit, with error proportional to its exact capacity. -/
+noncomputable section
+open Set Filter Function Complex Metric
+open scoped Topology
+
+namespace SLEExactGauge
+
+lemma reflectedArcSet_norm_lt {p : C(unitInterval,ℂ)} {R : ℝ}
+    (hp : ∀ t : unitInterval, ‖p t‖<R) {z : ℂ} (hz : z∈reflectedArcSet p) : ‖z‖<R := by
+  rcases hz with ⟨t,rfl⟩|⟨w,⟨t,rfl⟩,rfl⟩
+  · exact hp t
+  · simpa only [Complex.norm_conj] using hp t
+
+theorem SimpleSlitChart.forward_kernel_remainder {p : C(unitInterval,ℂ)}
+    (P : SimpleSlitChart p) (hi : Injective p) (h0 : p 0=0)
+    (hH : ∀ t : unitInterval, t≠0 → p t∈upperHalfPlane)
+    {R : ℝ} (hR : 0<R) (hp : ∀ t : unitInterval, ‖p t‖<R)
+    {z : ℂ} (hzH : z∈upperHalfPlane) (hz : 2*R≤‖z‖) :
+    ‖P.forward z-z-(P.capacity:ℂ)/z‖≤10*P.capacity*R/‖z‖^2 := by
+  obtain ⟨Q⟩ := exists_reflectedCapacityChart p hi h0 hH
+  have hK : IsCompact (reflectedArcSet p) := (isCompact_range p.continuous).union
+    ((isCompact_range p.continuous).image Complex.continuous_conj)
+  have hnot (w : ℂ) (hw : R≤‖w‖) : w∉reflectedArcSet p :=
+    fun h => (not_lt_of_ge hw) (reflectedArcSet_norm_lt hp h)
+  have hG (w : ℂ) (hw : R≤‖w‖) : DifferentiableAt ℂ Q.chart.forward w :=
+    (Q.forward_differentiable h0).differentiableAt (hK.isClosed.isOpen_compl.mem_nhds (hnot w hw))
+  have hs (w : ℂ) (hw : R≤‖w‖) : w.im*(Q.chart.forward w-w).im≤0 :=
+    Q.height_displacement_sign (hnot w hw)
+  have hb := exterior_capacity_remainder hR Q.chart.capacity_pos hG Q.chart.coefficient hs hz
+  have hnorm : R≤‖z‖ := by linarith
+  have hzP : z∈upperHalfPlane \ range p := ⟨hzH,fun h => hnot z hnorm (Or.inl h)⟩
+  obtain ⟨he,_,hc⟩ := P.unique_on_domain Q.chart
+  rwa [← he hzP,← hc] at hb
+
+end SLEExactGauge
+
+end
+
+end OAI
diff --git a/lean/OAI/Probability/SLE/Loewner/SlitChartBoundaryBasics.lean b/lean/OAI/Probability/SLE/Loewner/SlitChartBoundaryBasics.lean
new file mode 100644
index 0000000000000000000000000000000000000000..6754925e2be18d430ce8d4e0d27bf9b59b07d7a0
--- /dev/null
+++ b/lean/OAI/Probability/SLE/Loewner/SlitChartBoundaryBasics.lean
@@ -0,0 +1,38 @@
+import OAI.Probability.SLE.Loewner.SlitBoundaryBarrier
+import OAI.Probability.SLE.Loewner.InverseBoundaryBound
+
+namespace OAI
+
+/-! Analytic and compactness facts for the actual normalized static slit charts. -/
+noncomputable section
+open Set Filter Metric Function
+open scoped Topology
+
+namespace SLEExactGauge
+
+lemma SimpleSlitChart.isOpen_domain {p : C(unitInterval,ℂ)} (_P : SimpleSlitChart p) :
+    IsOpen (upperHalfPlane \ range p) :=
+  isOpen_upperHalfPlane.sdiff (isCompact_range p.continuous).isClosed
+
+lemma SimpleSlitChart.inverse_injOn {p : C(unitInterval,ℂ)} (P : SimpleSlitChart p) :
+    InjOn P.inverse upperHalfPlane := by
+  intro z hz w hw he
+  have hh := congrArg P.forward he
+  simpa only [P.right_inverse z hz,P.right_inverse w hw] using hh
+
+lemma SimpleSlitChart.inverse_im_ge {p : C(unitInterval,ℂ)} (P : SimpleSlitChart p)
+    {z : ℂ} (hz : z∈upperHalfPlane) : z.im≤(P.inverse z).im := by
+  have hh := P.height_le (P.inverse z) (P.inverse_mapsTo hz)
+  simpa only [P.right_inverse z hz] using hh
+
+lemma SimpleSlitChart.inverse_bounded_over_ball {p : C(unitInterval,ℂ)}
+    (P : SimpleSlitChart p) (R : ℝ) :
+    ∃ M : ℝ, ∀ w∈upperHalfPlane, ‖w‖≤R → ‖P.inverse w‖≤M :=
+  inverse_bound_of_hydrodynamic P.inverse_mapsTo P.right_inverse
+    (P.coefficient.mono_left inf_le_left) R
+
+end SLEExactGauge
+
+end
+
+end OAI
diff --git a/lean/OAI/Probability/SLE/Loewner/SlitChartBoundaryExtension.lean b/lean/OAI/Probability/SLE/Loewner/SlitChartBoundaryExtension.lean
new file mode 100644
index 0000000000000000000000000000000000000000..b25fcd83f14a9cb5af957083e1d41c42f85a67d4
--- /dev/null
+++ b/lean/OAI/Probability/SLE/Loewner/SlitChartBoundaryExtension.lean
@@ -0,0 +1,46 @@
+import OAI.Probability.SLE.Loewner.SlitChartBoundaryShrink
+import OAI.Probability.SLE.Geometry.HalfPlaneBoundaryExtension
+
+namespace OAI
+
+/-! Continuous finite boundary values of the normalized static slit inverse. -/
+noncomputable section
+open Set Filter Metric Function
+open scoped Topology
+
+namespace SLEExactGauge
+
+lemma SimpleSlitChart.finite_real_boundary_limit
+    {arc : C(unitInterval,ℂ)} (P : SimpleSlitChart arc) (x : ℝ) :
+    ∃ z : ℂ, Tendsto (P.inverse) (𝓝[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⟩ := P.small_boundary_halfdisk x (ε/3) (by positivity)
+  refine ⟨P.inverse '' (upperHalfPlane∩ball (x:ℂ) r),?_,?_⟩
+  · change (P.inverse) ⁻¹' (P.inverse '' (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 (P.inverse u) z (P.inverse v)
+    rw [dist_comm z (P.inverse v)] at htri
+    linarith
+
+theorem SimpleSlitChart.exists_boundary_extension
+    {arc : C(unitInterval,ℂ)} (P : SimpleSlitChart arc) :
+    ∃ Fbar : ℂ → ℂ, ContinuousOn Fbar {z : ℂ | 0≤z.im} ∧
+      ∀ z∈upperHalfPlane, Fbar z=P.inverse z :=
+  exists_halfPlane_boundary_extension P.inverse_differentiable.continuousOn
+    P.finite_real_boundary_limit
+
+end SLEExactGauge
+
+end
+
+end OAI
diff --git a/lean/OAI/Probability/SLE/Loewner/SlitChartBoundaryShrink.lean b/lean/OAI/Probability/SLE/Loewner/SlitChartBoundaryShrink.lean
new file mode 100644
index 0000000000000000000000000000000000000000..c50a2a944a7f5bf8613f9bb26dbed4b5ea0d9645
--- /dev/null
+++ b/lean/OAI/Probability/SLE/Loewner/SlitChartBoundaryShrink.lean
@@ -0,0 +1,75 @@
+import OAI.Probability.SLE.Loewner.SlitChartClosingPath
+import OAI.Probability.SLE.Loewner.InverseBoundaryShrink
+
+namespace OAI
+
+/-! Small inverse half-disks for static slit charts, from the closed boundary arcs. -/
+noncomputable section
+open Set Filter Metric Function
+open scoped Topology
+
+namespace SLEExactGauge
+
+lemma SimpleSlitChart.inverse_arc_traps_radial_point
+    {arc : C(unitInterval,ℂ)} (P : SimpleSlitChart arc)
+    (x r ρ θ : ℝ) (hρ : 0<ρ) (hρr : ρ<r) (hθ : θ∈Ioo 0 Real.pi)
+    (c : ℝ → ℂ) (hc : Continuous c)
+    (he : ∀ a∈Ioo 0 Real.pi, c a=P.inverse ((x:ℂ)+(r:ℂ)*Complex.exp ((a:ℂ)*Complex.I)))
+    (hc0 : c 0∉(upperHalfPlane \ range arc)) (hcπ : c Real.pi∉(upperHalfPlane \ range arc))
+    (q : Path (c Real.pi) (c 0)) (hq : ∀ u, q u∉(upperHalfPlane \ range arc))
+    (w : ℂ) (ε : ℝ) (hε : 0<ε)
+    (hcball : ∀ a∈Icc 0 Real.pi, c a∈ball w ε)
+    (hqball : ∀ u, q u∈ball w ε) :
+    P.inverse ((x:ℂ)+(ρ:ℂ)*Complex.exp ((θ:ℂ)*Complex.I))∈ball w ε := by
+  let E := Complex.exp ((θ:ℂ)*Complex.I)
+  have hE : 0<E.im := exp_strip_halfplane (x := (θ:ℂ)*Complex.I) (by simpa using hθ)
+  obtain ⟨R,hR⟩ := exists_gt (max r ((w.im+ε)/E.im))
+  have hrR : r<R := (le_max_left _ _).trans_lt hR
+  have hRE : w.im+ε<R*E.im :=
+    (div_lt_iff₀ hE).mp ((le_max_right _ _).trans_lt hR)
+  have hRH := univalent_polar_point_mem x R θ ((hρ.trans hρr).trans hrR) hθ
+  have hRout : P.inverse ((x:ℂ)+(R:ℂ)*E)∉ball w ε := by
+    intro hm
+    have him : R*E.im≤(P.inverse ((x:ℂ)+(R:ℂ)*E)).im := by
+      simpa only [Complex.add_im,Complex.ofReal_im,Complex.mul_im,Complex.ofReal_re,
+        zero_mul,add_zero,zero_add] using P.inverse_im_ge hRH
+    have hdist : ‖P.inverse ((x:ℂ)+(R:ℂ)*E)-w‖<ε := by
+      simpa only [mem_ball,dist_eq_norm] using hm
+    have hle := (le_abs_self (P.inverse ((x:ℂ)+(R:ℂ)*E)-w).im).trans
+      (Complex.abs_im_le_norm (P.inverse ((x:ℂ)+(R:ℂ)*E)-w))
+    rw [Complex.sub_im] at hle
+    linarith
+  have hi : InjOn (P.inverse) upperHalfPlane := by
+    intro a ha b hb hab
+    have := congrArg (P.forward) hab
+    simpa only [P.right_inverse a ha,P.right_inverse b hb] using this
+  exact polar_arc_traps_radial_point P.inverse_differentiable hi P.inverse_mapsTo
+    x r ρ R θ hρ hρr hrR hθ c hc he hc0 hcπ q hq w ε hε hcball hqball hRout
+
+lemma SimpleSlitChart.small_boundary_halfdisk
+    {arc : C(unitInterval,ℂ)} (P : SimpleSlitChart arc) (x ε : ℝ) (hε : 0<ε) :
+    ∃ r : ℝ, 0<r ∧ ∃ z : ℂ, ∀ w∈upperHalfPlane,
+      dist w (x:ℂ)<r → dist (P.inverse w) z<ε := by
+  obtain ⟨v,c,q,_,hc,he,hcb,hqb,hc0,hcπ,_,_⟩ :=
+    P.exists_small_inverse_closing_path x 0 ε hε
+  refine ⟨Real.exp v,Real.exp_pos _,c 0,?_⟩
+  intro w hwH hwr
+  obtain ⟨ρ,θ,hρ,hθ,hρeq,hweq⟩ := polar_representation_upperHalfPlane x hwH
+  have hρr : ρ<Real.exp v := by simpa only [hρeq,dist_eq_norm] using hwr
+  rw [hweq]
+  apply P.inverse_arc_traps_radial_point x (Real.exp v) ρ θ hρ hρr hθ c hc
+  · intro a ha
+    rw [he a ha,Complex.exp_add]
+    rw [←Complex.ofReal_exp]
+  · simpa only [P.isOpen_domain.interior_eq] using hc0.2
+  · simpa only [P.isOpen_domain.interior_eq] using hcπ.2
+  · exact fun u => (hqb u).2
+  · exact hε
+  · exact hcb
+  · exact fun u => (hqb u).1
+
+end SLEExactGauge
+
+end
+
+end OAI
diff --git a/lean/OAI/Probability/SLE/Loewner/SlitChartClosingPath.lean b/lean/OAI/Probability/SLE/Loewner/SlitChartClosingPath.lean
new file mode 100644
index 0000000000000000000000000000000000000000..c50decd6d7df553941c31d4a84909f1225172ef5
--- /dev/null
+++ b/lean/OAI/Probability/SLE/Loewner/SlitChartClosingPath.lean
@@ -0,0 +1,75 @@
+import OAI.Probability.SLE.Loewner.SlitChartSmallSemicircles
+
+namespace OAI
+
+/-! A small image semicircle can be closed by a small path outside the
+surviving domain. The closing path lies on the static slit and the real boundary. -/
+noncomputable section
+open Set Filter Metric Function
+open scoped Topology NNReal
+
+namespace SLEExactGauge
+
+lemma SimpleSlitChart.exists_small_inverse_closing_path
+    {arc : C(unitInterval,ℂ)} (P : SimpleSlitChart arc) (x Q ε : ℝ) (hε : 0<ε) :
+    ∃ (v : ℝ) (c : ℝ → ℂ) (p : Path (c Real.pi) (c 0)), v<Q ∧ Continuous c ∧
+      (∀ θ∈Ioo 0 Real.pi, c θ=P.inverse ((x:ℂ)+Complex.exp ((v:ℂ)+(θ:ℂ)*Complex.I))) ∧
+      (∀ θ∈Icc 0 Real.pi, dist (c θ) (c 0)<ε) ∧
+      (∀ s, dist (p s) (c 0)<ε ∧ p s∉(upperHalfPlane \ range arc)) ∧
+      c 0∈frontier ((upperHalfPlane \ range arc)) ∧ c Real.pi∈frontier ((upperHalfPlane \ range arc)) ∧
+      MapsTo c (Ioo 0 Real.pi) ((upperHalfPlane \ range arc)) ∧ InjOn c (Ioo 0 Real.pi) := by
+  obtain ⟨M,hM⟩ := P.inverse_bounded_over_ball (‖(x:ℂ)‖+1)
+  let R := max (M+1) 0
+  obtain ⟨δ,hδ,hpath⟩ := slitBoundaryBarrier_uniform_paths arc R (le_max_right _ _)
+    (ε/2) (half_pos hε)
+  let η := min 1 (min (ε/2) (δ/2))
+  have hη : 0<η := lt_min zero_lt_one (lt_min (half_pos hε) (half_pos hδ))
+  obtain ⟨v,c,hv,hc,he,hdiam,hc0,hcπ,hmap,hinj⟩ :=
+    P.exists_small_inverse_semicircle x (min Q 0) η hη
+  have hv0 : v<0 := hv.trans_le (min_le_right _ _)
+  have hη1 : η≤1 := min_le_left _ _
+  have hηε : η≤ε/2 := (min_le_right _ _).trans (min_le_left _ _)
+  have hηδ : η≤δ/2 := (min_le_right _ _).trans (min_le_right _ _)
+  let a := Real.pi/2
+  have ha : a∈Ioo 0 Real.pi := ⟨half_pos Real.pi_pos,by dsimp [a]; linarith [Real.pi_pos]⟩
+  have hwa : (x:ℂ)+Complex.exp ((v:ℂ)+(a:ℂ)*Complex.I)∈upperHalfPlane := by
+    have he' := exp_strip_halfplane (x := (v:ℂ)+(a:ℂ)*Complex.I) (by simpa using ha)
+    change 0<((x:ℂ)+Complex.exp ((v:ℂ)+(a:ℂ)*Complex.I)).im
+    simpa only [Set.mem_ofPred_eq,Complex.add_im,Complex.ofReal_im,zero_add] using he'
+  have hna : ‖(x:ℂ)+Complex.exp ((v:ℂ)+(a:ℂ)*Complex.I)‖≤‖(x:ℂ)‖+1 := by
+    refine (norm_add_le _ _).trans (add_le_add le_rfl ?_)
+    rw [Complex.norm_exp]
+    simpa using (Real.exp_le_one_iff.mpr hv0.le)
+  have hca : ‖c a‖≤M := by rw [he a ha]; exact hM _ hwa hna
+  have hcb (s : ℝ) (hs : s∈Icc 0 Real.pi) : ‖c s‖≤R := by
+    have hd : ‖c s-c a‖≤η := hdiam s hs a (Ioo_subset_Icc_self ha)
+    calc
+      ‖c s‖ ≤ ‖c s-c a‖+‖c a‖ := by
+        convert norm_add_le (c s-c a) (c a) using 1; simp
+      _ ≤ η+M := add_le_add hd hca
+      _ ≤ 1+M := add_le_add hη1 le_rfl
+      _ = M+1 := add_comm _ _
+      _ ≤ R := le_max_left _ _
+  have h0 : c 0∈slitBoundaryBarrier arc R :=
+    frontier_mem_slitBoundaryBarrier arc hc0 (hcb 0 ⟨le_rfl,Real.pi_pos.le⟩)
+  have hπ : c Real.pi∈slitBoundaryBarrier arc R :=
+    frontier_mem_slitBoundaryBarrier arc hcπ (hcb Real.pi ⟨Real.pi_pos.le,le_rfl⟩)
+  have hdπ : dist (c Real.pi) (c 0)≤η := by
+    simpa only [dist_eq_norm] using hdiam Real.pi ⟨Real.pi_pos.le,le_rfl⟩ 0 ⟨le_rfl,Real.pi_pos.le⟩
+  obtain ⟨p,hpB,hp⟩ := hpath (c Real.pi) hπ (c 0) h0 (hdπ.trans_lt (hηδ.trans_lt (half_lt_self hδ)))
+  refine ⟨v,c,p,hv.trans_le (min_le_left _ _),hc,he,?_,?_,hc0,hcπ,hmap,hinj⟩
+  · intro θ hθ
+    have hdθ : dist (c θ) (c 0)≤η := by
+      simpa only [dist_eq_norm] using hdiam θ hθ 0 ⟨le_rfl,Real.pi_pos.le⟩
+    exact hdθ.trans_lt (hηε.trans_lt (half_lt_self hε))
+  · intro s
+    refine ⟨?_,fun hD => (disjoint_left.mp (slitBoundaryBarrier_disjoint_domain arc R)) (hpB s) hD⟩
+    have htri := dist_triangle (p s) (c Real.pi) (c 0)
+    have hps := hp s
+    linarith
+
+end SLEExactGauge
+
+end
+
+end OAI
diff --git a/lean/OAI/Probability/SLE/Loewner/SlitChartDisplacement.lean b/lean/OAI/Probability/SLE/Loewner/SlitChartDisplacement.lean
new file mode 100644
index 0000000000000000000000000000000000000000..de5f5cab6f14f46a68b50d8bbc78387639355e55
--- /dev/null
+++ b/lean/OAI/Probability/SLE/Loewner/SlitChartDisplacement.lean
@@ -0,0 +1,58 @@
+import OAI.Probability.SLE.Loewner.SlitChartBoundaryBasics
+import OAI.Probability.SLE.Loewner.HalfPlaneDisplacementBound
+
+namespace OAI
+
+/-! Quantitative comparison of the actual normalized inverse slit charts. -/
+noncomputable section
+open Set Filter Function
+open scoped Topology
+
+namespace SLEExactGauge
+
+lemma SimpleSlitChart.inverse_displacement {p : C(unitInterval,ℂ)} (P : SimpleSlitChart p)
+    {z : ℂ} (hz : z∈upperHalfPlane) : ‖P.inverse z-z‖≤P.capacity/z.im := by
+  apply nonnegative_im_hydrodynamic_bound (P.inverse_differentiable.sub differentiableOn_id)
+    (fun w hw => by
+      change 0 ≤ (P.inverse w-w).im
+      simpa only [Complex.sub_im] using sub_nonneg.mpr (P.inverse_im_ge hw))
+    P.capacity_pos.le
+    (inverse_hydrodynamic_coefficient P.coefficient P.inverse_normalized P.right_inverse) hz
+
+lemma SimpleSlitChart.forward_displacement {p : C(unitInterval,ℂ)} (P : SimpleSlitChart p)
+    {z : ℂ} (hz : z∈upperHalfPlane \ range p) :
+    ‖P.forward z-z‖≤P.capacity/(P.forward z).im := by
+  have hh := P.inverse_displacement (P.bijOn.mapsTo hz)
+  simpa only [P.left_inverse z hz,norm_sub_rev] using hh
+
+lemma SimpleSlitChart.inverse_comparison {p q : C(unitInterval,ℂ)}
+    (P : SimpleSlitChart p) (Q : SimpleSlitChart q) (hpq : range p ⊆ range q)
+    {z : ℂ} (hz : z∈upperHalfPlane) :
+    ‖P.forward (Q.inverse z)-z‖≤(Q.capacity-P.capacity)/z.im := by
+  have hdom : upperHalfPlane \ range q ⊆ upperHalfPlane \ range p :=
+    fun _ hw => ⟨hw.1,fun hp => hw.2 (hpq hp)⟩
+  have hm := Q.inverse_mapsTo.mono_right hdom
+  have hd := P.forward_differentiable.comp Q.inverse_differentiable hm
+  have hn := hydrodynamic_composition_ratio P.coefficient Q.inverse_normalized
+  apply nonnegative_im_hydrodynamic_bound (hd.sub differentiableOn_id)
+    (fun w hw => by
+      change 0 ≤ (P.forward (Q.inverse w)-w).im
+      simpa only [Function.comp_apply,Complex.sub_im] using sub_nonneg.mpr
+        (normalized_halfPlane_height hd (P.bijOn.mapsTo.comp hm) hn hw))
+    (sub_nonneg.mpr (P.capacity_le_of_range_subset Q hpq))
+  · have hh := hydrodynamic_composition_coefficient P.coefficient Q.coefficient
+      Q.inverse_normalized Q.right_inverse
+    have he : -((Q.capacity-P.capacity:ℝ):ℂ) = (P.capacity:ℂ)-Q.capacity := by
+      push_cast
+      ring
+    change Tendsto (fun w : ℂ => w*(P.forward (Q.inverse w)-w))
+      (cocompact ℂ ⊓ 𝓟 upperHalfPlane) (𝓝 (-((Q.capacity-P.capacity:ℝ):ℂ)))
+    rw [he]
+    exact hh
+  · exact hz
+
+end SLEExactGauge
+
+end
+
+end OAI
diff --git a/lean/OAI/Probability/SLE/Loewner/SlitChartExteriorComparison.lean b/lean/OAI/Probability/SLE/Loewner/SlitChartExteriorComparison.lean
new file mode 100644
index 0000000000000000000000000000000000000000..7a4422657cc341b71987059e4022a217b32c4f34
--- /dev/null
+++ b/lean/OAI/Probability/SLE/Loewner/SlitChartExteriorComparison.lean
@@ -0,0 +1,61 @@
+import OAI.Probability.SLE.Loewner.SlitChartDisplacement
+import OAI.Probability.SLE.Loewner.CapacityRadiusBound
+
+namespace OAI
+
+/-! A common exterior half-disk controls all normalized charts of slits inside it. -/
+noncomputable section
+open Set Filter Complex Function Metric
+open scoped Topology
+
+namespace SLEExactGauge
+
+lemma radiusHullInverse_map {R : ℝ} (hR : 0<R) {z : ℂ} (hz : z∈exteriorUpperRadius R) :
+    radiusHullInverse R (radiusHullMap R z)=z :=
+  (radiusHullMap_bijOn hR).injOn.leftInvOn_invFunOn hz
+
+lemma SimpleSlitChart.exterior_comparison {p : C(unitInterval,ℂ)} (P : SimpleSlitChart p)
+    {R : ℝ} (hR : 0<R) (hp : ∀ t : unitInterval, ‖p t‖≤R)
+    {z : ℂ} (hz : z∈exteriorUpperRadius R) :
+    (radiusHullMap R z).im≤(P.forward z).im ∧
+      ‖P.forward z-radiusHullMap R z‖≤(R^2-P.capacity)/(radiusHullMap R z).im := by
+  have hmap : MapsTo (radiusHullInverse R) upperHalfPlane (upperHalfPlane \ range p) := by
+    intro w hw
+    have hr := radiusHullInverse_mapsTo hR hw
+    refine ⟨hr.2,?_⟩
+    rintro ⟨t,ht⟩
+    have hh := hp t
+    rw [ht] at hh
+    exact (not_le_of_gt hr.1) hh
+  have hd := P.forward_differentiable.comp (radiusHullInverse_differentiableOn hR) hmap
+  have hm := P.bijOn.mapsTo.comp hmap
+  have hn := hydrodynamic_composition_ratio P.coefficient (radiusHullInverse_normalized hR)
+  have hheight (w : ℂ) (hw : w∈upperHalfPlane) := normalized_halfPlane_height hd hm hn hw
+  have hcoef := hydrodynamic_composition_coefficient P.coefficient (radiusHullMap_coefficient hR)
+    (radiusHullInverse_normalized hR) (fun w hw => radiusHullMap_inverse hR hw)
+  have hc : 0≤R^2-P.capacity := sub_nonneg.mpr (P.capacity_le_radius_sq hR hp)
+  have hh := nonnegative_im_hydrodynamic_bound (hd.sub differentiableOn_id)
+    (fun w hw => by
+      change 0 ≤ (P.forward (radiusHullInverse R w)-w).im
+      simpa only [comp_apply,sub_im] using sub_nonneg.mpr (hheight w hw)) hc
+    (by
+      change Tendsto (fun w : ℂ => w*(P.forward (radiusHullInverse R w)-w))
+        (cocompact ℂ ⊓ 𝓟 upperHalfPlane) (𝓝 (-((R^2-P.capacity:ℝ):ℂ)))
+      have he : -((R^2-P.capacity:ℝ):ℂ) = (P.capacity:ℂ)-(R:ℂ)^2 := by
+        push_cast
+        ring
+      rw [he]
+      exact hcoef)
+    ((radiusHullMap_bijOn hR).mapsTo hz)
+  have hle := hheight _ ((radiusHullMap_bijOn hR).mapsTo hz)
+  change ‖P.forward (radiusHullInverse R (radiusHullMap R z))-radiusHullMap R z‖ ≤
+    (R^2-P.capacity)/(radiusHullMap R z).im at hh
+  change (radiusHullMap R z).im ≤ (P.forward (radiusHullInverse R (radiusHullMap R z))).im at hle
+  rw [radiusHullInverse_map hR hz] at hh hle
+  exact ⟨hle,hh⟩
+
+end SLEExactGauge
+
+end
+
+end OAI
diff --git a/lean/OAI/Probability/SLE/Loewner/SlitChartFarHeight.lean b/lean/OAI/Probability/SLE/Loewner/SlitChartFarHeight.lean
new file mode 100644
index 0000000000000000000000000000000000000000..a377a4413f0fd198e13ac49a5f397ae26840ab7a
--- /dev/null
+++ b/lean/OAI/Probability/SLE/Loewner/SlitChartFarHeight.lean
@@ -0,0 +1,63 @@
+import OAI.Probability.SLE.Loewner.SlitChartExteriorComparison
+
+namespace OAI
+
+/-! A uniform far-field displacement bound for all slits in one fixed disk. -/
+noncomputable section
+open Set Filter Function Complex Metric
+open scoped Topology
+
+namespace SLEExactGauge
+
+lemma radiusHullMap_im_mul_normSq {R : ℝ} (hR : 0<R) {z : ℂ} (hz : z≠0) :
+    (radiusHullMap R z).im*normSq z=z.im*(normSq z-R^2) := by
+  rw [radiusHullMap_formula hR]
+  simp only [add_im,div_im,← ofReal_pow,ofReal_re,ofReal_im,zero_mul]
+  have hn : normSq z≠0 := (normSq_pos.mpr hz).ne'
+  field_simp [hn]
+  ring
+
+lemma radiusHullMap_im_ge_half {R : ℝ} (hR : 0<R) {z : ℂ} (hz : 2*R≤z.im) :
+    z.im/2≤(radiusHullMap R z).im := by
+  have hy : 0<z.im := (mul_pos (by norm_num : (0:ℝ)<2) hR).trans_le hz
+  have hz0 : z≠0 := by intro he; simp [he] at hy
+  have hn : 0<normSq z := normSq_pos.mpr hz0
+  have hs : 2*R^2≤normSq z := by
+    rw [normSq_apply]
+    nlinarith [sq_nonneg z.re]
+  have hm := mul_le_mul_of_nonneg_left hs hy.le
+  have he := radiusHullMap_im_mul_normSq hR hz0
+  exact (mul_le_mul_iff_left₀ hn).mp (by nlinarith)
+
+lemma SimpleSlitChart.far_height_displacement {p : C(unitInterval,ℂ)} (P : SimpleSlitChart p)
+    {R : ℝ} (hR : 0<R) (hp : ∀ u : unitInterval, ‖p u‖≤R)
+    {z : ℂ} (hz : 2*R≤z.im) : ‖P.forward z-z‖≤3*R^2/z.im := by
+  have hy : 0<z.im := (mul_pos (by norm_num : (0:ℝ)<2) hR).trans_le hz
+  have hyn : z.im≤‖z‖ := Complex.im_le_norm z
+  have hn : 0<‖z‖ := hy.trans_le hyn
+  have hzE : z∈exteriorUpperRadius R := ⟨by linarith,hy⟩
+  have hh := P.exterior_comparison hR hp hzE
+  have hlower := radiusHullMap_im_ge_half hR hz
+  have hhpos : 0<(radiusHullMap R z).im := (half_pos hy).trans_le hlower
+  have hdiff : ‖radiusHullMap R z-z‖=R^2/‖z‖ := by
+    rw [radiusHullMap_formula hR,add_sub_cancel_left,norm_div,norm_pow,
+      Complex.norm_real,Real.norm_eq_abs,abs_of_pos hR]
+  have htri := dist_triangle (P.forward z) (radiusHullMap R z) z
+  simp only [dist_eq_norm] at htri
+  calc
+    ‖P.forward z-z‖ ≤ ‖P.forward z-radiusHullMap R z‖+‖radiusHullMap R z-z‖ := htri
+    _ ≤ (R^2-P.capacity)/(radiusHullMap R z).im+R^2/‖z‖ := by
+      rw [hdiff]
+      exact add_le_add hh.2 le_rfl
+    _ ≤ R^2/(z.im/2)+R^2/z.im := by
+      apply add_le_add
+      · exact (div_le_div_of_nonneg_right (sub_le_self _ P.capacity_pos.le) hhpos.le).trans
+          (div_le_div_of_nonneg_left (sq_nonneg R) (half_pos hy) hlower)
+      · exact div_le_div_of_nonneg_left (sq_nonneg R) hy hyn
+    _ = 3*R^2/z.im := by field_simp; ring
+
+end SLEExactGauge
+
+end
+
+end OAI
diff --git a/lean/OAI/Probability/SLE/Loewner/SlitChartLimitUniqueness.lean b/lean/OAI/Probability/SLE/Loewner/SlitChartLimitUniqueness.lean
new file mode 100644
index 0000000000000000000000000000000000000000..8009429af31e1507d2ef42b3ff34d46bdd29f1b1
--- /dev/null
+++ b/lean/OAI/Probability/SLE/Loewner/SlitChartLimitUniqueness.lean
@@ -0,0 +1,108 @@
+import OAI.Probability.SLE.Loewner.InitialLimitInverse
+import OAI.Probability.SLE.Loewner.VerticalDisplacementLimit
+
+namespace OAI
+
+/-! Identification of a terminal inverse-chart limit with the normalized
+static chart. Only the preserved height and far-field bounds are used. -/
+noncomputable section
+open Set Filter Function Complex
+open scoped Topology
+
+namespace SLEExactGauge
+
+lemma SimpleSlitChart.eq_inverse_of_vertical_bounds {p : C(unitInterval,ℂ)}
+    (P : SimpleSlitChart p) {F : ℂ → ℂ}
+    (hF : DifferentiableOn ℂ F upperHalfPlane)
+    (hb : BijOn F upperHalfPlane (upperHalfPlane \ range p))
+    (him : ∀ z∈upperHalfPlane, z.im≤(F z).im)
+    {C R : ℝ} (hR : 0<R) (hp : ∀ u : unitInterval, ‖p u‖≤R)
+    (hbound : ∀ z∈upperHalfPlane, ‖F z-z‖≤C/z.im)
+    (hfar : ∀ z : ℂ, 2*R≤z.im → ‖invFunOn F upperHalfPlane z-z‖≤3*R^2/z.im) :
+    EqOn F P.inverse upperHalfPlane := by
+  let G := invFunOn F upperHalfPlane
+  have hG : DifferentiableOn ℂ G (upperHalfPlane \ range p) := by
+    have hh := hF.invFunOn isOpen_upperHalfPlane hb.injOn
+    rw [hb.image_eq] at hh
+    exact hh
+  have hGm : MapsTo G (upperHalfPlane \ range p) upperHalfPlane := hb.surjOn.mapsTo_invFunOn
+  have hGF : ∀ z∈upperHalfPlane, G (F z)=z := fun _ hz => hb.injOn.leftInvOn_invFunOn hz
+  let A := P.forward ∘ F
+  let B := G ∘ P.inverse
+  have hA : DifferentiableOn ℂ A upperHalfPlane := P.forward_differentiable.comp hF hb.mapsTo
+  have hB : DifferentiableOn ℂ B upperHalfPlane := hG.comp P.inverse_differentiable P.inverse_mapsTo
+  have hAm : MapsTo A upperHalfPlane upperHalfPlane := P.bijOn.mapsTo.comp hb.mapsTo
+  have hBm : MapsTo B upperHalfPlane upperHalfPlane := hGm.comp P.inverse_mapsTo
+  have hBA : ∀ z∈upperHalfPlane, B (A z)=z := by
+    intro z hz
+    dsimp only [A,B,Function.comp_apply]
+    rw [P.left_inverse _ (hb.mapsTo hz),hGF z hz]
+  have hAbound {z : ℂ} (hz : 2*R≤z.im) : ‖A z-z‖≤(3*R^2+C)/z.im := by
+    have hy : 0<z.im := by linarith
+    have hf := him z hy
+    have hfpos : 0<(F z).im := hy.trans_le hf
+    have hpf := P.far_height_displacement hR hp (hz.trans hf)
+    calc
+      ‖A z-z‖ ≤ ‖P.forward (F z)-F z‖+‖F z-z‖ := by
+        simpa only [A,Function.comp_apply,dist_eq_norm] using
+          dist_triangle (P.forward (F z)) (F z) z
+      _ ≤ 3*R^2/(F z).im+C/z.im := add_le_add hpf (hbound z hy)
+      _ ≤ 3*R^2/z.im+C/z.im := add_le_add
+        (div_le_div_of_nonneg_left (by positivity) hy hf) le_rfl
+      _ = (3*R^2+C)/z.im := (add_div _ _ _).symm
+  have hBbound {z : ℂ} (hz : 2*R≤z.im) : ‖B z-z‖≤(3*R^2+P.capacity)/z.im := by
+    have hy : 0<z.im := by linarith
+    have hf := P.inverse_im_ge hy
+    have hgf := hfar (P.inverse z) (hz.trans hf)
+    calc
+      ‖B z-z‖ ≤ ‖G (P.inverse z)-P.inverse z‖+‖P.inverse z-z‖ := by
+        simpa only [B,Function.comp_apply,dist_eq_norm] using
+          dist_triangle (G (P.inverse z)) (P.inverse z) z
+      _ ≤ 3*R^2/(P.inverse z).im+P.capacity/z.im :=
+        add_le_add hgf (P.inverse_displacement hy)
+      _ ≤ 3*R^2/z.im+P.capacity/z.im := add_le_add
+        (div_le_div_of_nonneg_left (by positivity) hy hf) le_rfl
+      _ = (3*R^2+P.capacity)/z.im := (add_div _ _ _).symm
+  have hev : ∀ᶠ n : ℕ in atTop, 2*R≤(verticalInfinity n).im := by
+    simpa only [verticalInfinity,mul_im,ofReal_re,I_im,mul_one,ofReal_im,I_re,mul_zero,add_zero]
+      using verticalHeights_tendsto.eventually (eventually_ge_atTop (2*R))
+  have hA0 : Tendsto (fun n : ℕ => A (verticalInfinity n)-verticalInfinity n) atTop (𝓝 0) := by
+    apply vertical_displacement_zero_of_bound
+    filter_upwards [hev] with n hn
+    simpa only [verticalInfinity,mul_im,ofReal_re,I_im,mul_one,ofReal_im,I_re,mul_zero,add_zero]
+      using hAbound hn
+  have hB0 : Tendsto (fun n : ℕ => B (verticalInfinity n)-verticalInfinity n) atTop (𝓝 0) := by
+    apply vertical_displacement_zero_of_bound
+    filter_upwards [hev] with n hn
+    simpa only [verticalInfinity,mul_im,ofReal_re,I_im,mul_one,ofReal_im,I_re,mul_zero,add_zero]
+      using hBbound hn
+  have hAid := vertical_halfPlane_left_inverse_eq_id hA hB hAm hBm hBA
+    (vertical_normalization_of_displacement hA0) (vertical_normalization_of_displacement hB0) hA0
+  intro z hz
+  have he := P.left_inverse (F z) (hb.mapsTo hz)
+  rw [show P.forward (F z)=z from hAid hz] at he
+  exact he.symm
+
+theorem initialInverse_limit_eq_final (p : C(unitInterval,ℂ)) (hi : Injective p)
+    (h0 : p 0=0) (hH : ∀ t : unitInterval, t ≠ 0 → p t ∈ upperHalfPlane)
+    (P : SimpleSlitChart p) {t : ℕ → unitInterval} {F : ℂ → ℂ}
+    (hF : DifferentiableOn ℂ F upperHalfPlane)
+    (hlim : TendstoLocallyUniformlyOn (fun n => initialInverseChart p hi h0 hH (t n))
+      F atTop upperHalfPlane) (ht : Tendsto t atTop (𝓝 1)) :
+    EqOn F P.inverse upperHalfPlane := by
+  obtain ⟨R0,hR0⟩ := (isCompact_range p.continuous).isBounded.exists_norm_le
+  let R := max R0 1
+  have hR : 0<R := lt_of_lt_of_le zero_lt_one (le_max_right _ _)
+  have hp (u : unitInterval) : ‖p u‖≤R := (hR0 _ (mem_range_self u)).trans (le_max_left _ _)
+  exact P.eq_inverse_of_vertical_bounds hF
+    (initialInverse_limit_bijOn_final p hi h0 hH hF hlim ht)
+    (fun _ hz => initialInverse_limit_im_ge p hi h0 hH hlim hz)
+    hR hp
+    (fun _ hz => initialInverse_limit_uniform_displacement p hi h0 hH hlim hz)
+    (fun _ hz => initialInverse_limit_inverse_far_height p hi h0 hH hF hlim hR hp hz)
+
+end SLEExactGauge
+
+end
+
+end OAI
diff --git a/lean/OAI/Probability/SLE/Loewner/SlitChartProper.lean b/lean/OAI/Probability/SLE/Loewner/SlitChartProper.lean
new file mode 100644
index 0000000000000000000000000000000000000000..18f8e290eaa352faa8989d6d28f0ccce90bac7ee
--- /dev/null
+++ b/lean/OAI/Probability/SLE/Loewner/SlitChartProper.lean
@@ -0,0 +1,37 @@
+import OAI.Probability.SLE.Loewner.SlitChartBoundaryBasics
+
+namespace OAI
+
+/-! Normalization at infinity prevents bounded physical points from having
+unbounded chart coordinates, including when they approach the slit. -/
+noncomputable section
+open Set Filter Metric Function
+open scoped Topology
+
+namespace SLEExactGauge
+
+lemma SimpleSlitChart.forward_bounded_over_ball {p : C(unitInterval,ℂ)}
+    (P : SimpleSlitChart p) (R : ℝ) :
+    ∃ M : ℝ, ∀ z∈upperHalfPlane \ range p, ‖z‖≤R → ‖P.forward z‖≤M := by
+  have he := Metric.tendsto_nhds.mp P.inverse_normalized (1/2) (by norm_num)
+  rw [eventually_inf_principal,← Metric.cobounded_eq_cocompact] at he
+  obtain ⟨N,_,hN⟩ := Filter.hasBasis_cobounded_norm.eventually_iff.mp he
+  refine ⟨max (max N 1) (2*R),fun z hz hzR => ?_⟩
+  by_cases hb : ‖P.forward z‖ ≤ max N 1
+  · exact hb.trans (le_max_left _ _)
+  have hb' := lt_of_not_ge hb
+  have hnorm : 0<‖P.forward z‖ := by linarith [le_max_right N (1:ℝ)]
+  have hsmall := hN ((le_max_left N (1:ℝ)).trans hb'.le) (P.bijOn.mapsTo hz)
+  rw [dist_eq_norm,P.left_inverse z hz] at hsmall
+  have htri := norm_le_norm_sub_add (1:ℂ) (z/P.forward z)
+  rw [norm_one,norm_sub_rev,norm_div] at htri
+  have hprod : (1/2:ℝ)*‖P.forward z‖<‖z‖ := by
+    apply (lt_div_iff₀ hnorm).mp
+    linarith
+  exact (show ‖P.forward z‖≤2*R by linarith).trans (le_max_right _ _)
+
+end SLEExactGauge
+
+end
+
+end OAI
diff --git a/lean/OAI/Probability/SLE/Loewner/SlitChartRangeUniqueness.lean b/lean/OAI/Probability/SLE/Loewner/SlitChartRangeUniqueness.lean
new file mode 100644
index 0000000000000000000000000000000000000000..b75bc7472a2ccc9a6e9a34cdf8404f71f9bc09aa
--- /dev/null
+++ b/lean/OAI/Probability/SLE/Loewner/SlitChartRangeUniqueness.lean
@@ -0,0 +1,38 @@
+import OAI.Probability.SLE.Loewner.SlitChartUniqueness
+
+namespace OAI
+
+/-! Normalized charts depend only on the slit range, including when its
+parameter has been changed. -/
+noncomputable section
+open Set Filter Function
+open scoped Topology
+
+namespace SLEExactGauge
+
+lemma SimpleSlitChart.eq_of_range_eq {p q : C(unitInterval,ℂ)}
+    (P : SimpleSlitChart p) (Q : SimpleSlitChart q) (hr : range p=range q) :
+    P.capacity=Q.capacity ∧ EqOn P.inverse Q.inverse upperHalfPlane ∧
+      EqOn P.forward Q.forward (upperHalfPlane \ range p) := by
+  have hc : P.capacity=Q.capacity := le_antisymm
+    (P.capacity_le_of_range_subset Q hr.le) (Q.capacity_le_of_range_subset P hr.ge)
+  have hcomp (z : ℂ) (hz : z∈upperHalfPlane) : P.forward (Q.inverse z)=z := by
+    have hb := P.inverse_comparison Q hr.le hz
+    rw [hc,sub_self,zero_div] at hb
+    exact sub_eq_zero.mp (norm_le_zero_iff.mp hb)
+  have hi : EqOn P.inverse Q.inverse upperHalfPlane := by
+    intro z hz
+    have hh := P.left_inverse (Q.inverse z) (by simpa only [hr] using Q.inverse_mapsTo hz)
+    rw [hcomp z hz] at hh
+    exact hh
+  refine ⟨hc,hi,?_⟩
+  intro z hz
+  have hzQ : z∈upperHalfPlane \ range q := by simpa only [hr] using hz
+  apply Q.inverse_injOn (P.bijOn.mapsTo hz) (Q.bijOn.mapsTo hzQ)
+  rw [← hi (P.bijOn.mapsTo hz),P.left_inverse z hz,Q.left_inverse z hzQ]
+
+end SLEExactGauge
+
+end
+
+end OAI
diff --git a/lean/OAI/Probability/SLE/Loewner/SlitChartSmallSemicircles.lean b/lean/OAI/Probability/SLE/Loewner/SlitChartSmallSemicircles.lean
new file mode 100644
index 0000000000000000000000000000000000000000..99e2218ebee15367a5d8f8f16d260c588851bbea
--- /dev/null
+++ b/lean/OAI/Probability/SLE/Loewner/SlitChartSmallSemicircles.lean
@@ -0,0 +1,88 @@
+import OAI.Probability.SLE.Loewner.SlitChartStripEnergy
+import OAI.Probability.SLE.Geometry.ShrinkingStripEnergy
+import OAI.Probability.SLE.Loewner.InverseBoundaryArc
+
+namespace OAI
+
+/-! Arbitrarily small closed image semicircles at each real boundary point.
+The endpoint values are obtained from finite energy, not from an assumed
+continuous extension of the inverse map. -/
+noncomputable section
+open Set Filter Metric Function MeasureTheory
+open scoped Topology NNReal ENNReal
+
+namespace SLEExactGauge
+
+lemma SimpleSlitChart.inverse_log_holomorphic
+    {p : C(unitInterval,ℂ)} (P : SimpleSlitChart p) (x : ℝ) :
+    DifferentiableOn ℂ (fun z => P.inverse ((x:ℂ)+Complex.exp z))
+      {z | 0<z.im ∧ z.im<Real.pi} := by
+  apply P.inverse_differentiable.comp
+    ((differentiable_const (x:ℂ)).add Complex.differentiable_exp).differentiableOn
+  intro z hz
+  change 0<((x:ℂ)+Complex.exp z).im
+  simpa only [Set.mem_ofPred_eq,Complex.add_im,Complex.ofReal_im,zero_add] using exp_strip_halfplane hz
+
+lemma SimpleSlitChart.exists_small_inverse_semicircle
+    {p : C(unitInterval,ℂ)} (P : SimpleSlitChart p) (x Q ε : ℝ) (hε : 0<ε) :
+    ∃ (v : ℝ) (c : ℝ → ℂ), v<Q ∧ Continuous c ∧
+      (∀ θ∈Ioo 0 Real.pi, c θ=P.inverse ((x:ℂ)+Complex.exp ((v:ℂ)+(θ:ℂ)*Complex.I))) ∧
+      (∀ θ∈Icc 0 Real.pi, ∀ φ∈Icc 0 Real.pi, ‖c θ-c φ‖≤ε) ∧
+      c 0∈frontier ((upperHalfPlane \ range p)) ∧ c Real.pi∈frontier ((upperHalfPlane \ range p)) ∧
+      MapsTo c (Ioo 0 Real.pi) ((upperHalfPlane \ range p)) ∧ InjOn c (Ioo 0 Real.pi) := by
+  let f : ℂ → ℂ := fun z => P.inverse ((x:ℂ)+Complex.exp z)
+  have hf := P.inverse_log_holomorphic x
+  obtain ⟨v,hv,hd,hsmall⟩ := exists_small_holomorphic_section hf
+    (P.inverse_strip_dirichlet_finite x 0) Q ε hε
+  let w : ℝ → ℂ := fun θ => (x:ℂ)+Complex.exp ((v:ℂ)+(θ:ℂ)*Complex.I)
+  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 hsection (θ : ℝ) (hθ : θ∈Ioo 0 Real.pi) :
+      DifferentiableAt ℝ (fun θ : ℝ => P.inverse (w θ)) θ := by
+    change DifferentiableAt ℝ (f ∘ fun θ : ℝ => (v:ℂ)+(θ:ℂ)*Complex.I) θ
+    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:ℂ))
+  obtain ⟨c,hc,he⟩ := finite_energy_angular_extension hsection hd
+  have hwc : Continuous w := by dsimp [w]; fun_prop
+  have hwin : MapsTo w (Ioo 0 Real.pi) upperHalfPlane := by
+    intro θ hθ
+    change 0<((x:ℂ)+Complex.exp ((v:ℂ)+(θ:ℂ)*Complex.I)).im
+    simpa only [Set.mem_ofPred_eq,Complex.add_im,Complex.ofReal_im,zero_add] using
+      exp_strip_halfplane (x := (v:ℂ)+(θ:ℂ)*Complex.I) (by simpa using hθ)
+  have hwend (s : ℝ) (hs : s=0 ∨ s=Real.pi) : w s∉upperHalfPlane := by
+    rcases hs with rfl | rfl <;>
+      simp [w,upperHalfPlane,Complex.exp_add,Complex.exp_ofReal_mul_I,← Complex.ofReal_exp]
+  have hend (s : ℝ) (hs : s∈Icc 0 Real.pi) (hs' : s=0 ∨ s=Real.pi) :
+      c s∈frontier ((upperHalfPlane \ range p)) :=
+    inverse_arc_endpoint_mem_frontier P.isOpen_domain
+      P.forward_differentiable.continuousOn P.bijOn.mapsTo P.inverse_mapsTo
+      P.right_inverse hwc hc Real.pi_pos hs hwin (hwend s hs') he
+  refine ⟨v,c,hv,hc,he,?_,hend 0 ⟨le_rfl,Real.pi_pos.le⟩ (Or.inl rfl),
+    hend Real.pi ⟨Real.pi_pos.le,le_rfl⟩ (Or.inr rfl),?_,?_⟩
+  · apply continuous_angular_oscillation_on_endpoints hc ε
+    intro θ hθ φ hφ
+    rw [he hθ,he hφ]
+    exact (hsmall θ hθ φ hφ).le
+  · intro θ hθ
+    rw [he hθ]
+    exact P.inverse_mapsTo (hwin hθ)
+  · intro θ hθ φ hφ heq
+    rw [he hθ,he hφ] at heq
+    change P.inverse (w θ)=P.inverse (w φ) at heq
+    have hwθ := P.right_inverse (w θ) (hwin hθ)
+    have hwφ := P.right_inverse (w φ) (hwin hφ)
+    have hww : w θ=w φ := by rw [heq,hwφ] at hwθ; exact hwθ.symm
+    have harg := exp_injective_strip
+      (x₁ := (v:ℂ)+(θ:ℂ)*Complex.I) (x₂ := (v:ℂ)+(φ:ℂ)*Complex.I)
+      (by simpa using hθ) (by simpa using hφ) (add_left_cancel hww)
+    have him := congrArg Complex.im harg
+    simpa using him
+
+end SLEExactGauge
+
+end
+
+end OAI
diff --git a/lean/OAI/Probability/SLE/Loewner/SlitChartStripEnergy.lean b/lean/OAI/Probability/SLE/Loewner/SlitChartStripEnergy.lean
new file mode 100644
index 0000000000000000000000000000000000000000..969cb37272624d9dc3272e11f91a9ab256833623
--- /dev/null
+++ b/lean/OAI/Probability/SLE/Loewner/SlitChartStripEnergy.lean
@@ -0,0 +1,63 @@
+import OAI.Probability.SLE.Loewner.SlitChartBoundaryBasics
+import OAI.Probability.SLE.Loewner.InverseDirichletEnergy
+import OAI.Probability.SLE.DyadicStrips
+
+namespace OAI
+
+/-! Finite boundary-strip energy for static normalized slit charts. -/
+noncomputable section
+open Set Filter Metric Function MeasureTheory
+open scoped Topology NNReal ENNReal
+
+namespace SLEExactGauge
+
+lemma SimpleSlitChart.inverse_strip_dirichlet_finite
+    {p : C(unitInterval,ℂ)} (P : SimpleSlitChart p) (x q : ℝ) :
+    (∫⁻ z in {z : ℂ | z.re<q ∧ 0<z.im ∧ z.im<Real.pi},
+      ENNReal.ofReal (‖deriv (fun w => P.inverse ((x:ℂ)+Complex.exp w)) z‖^2))<∞ := by
+  let S : Set ℂ := {z | z.re<q ∧ 0<z.im ∧ z.im<Real.pi}
+  let A : ℂ → ℂ := fun z => (x:ℂ)+Complex.exp z
+  let f : ℂ → ℂ := fun z => P.inverse (A z)
+  have hS : IsOpen S := (isOpen_lt Complex.continuous_re continuous_const).inter
+    ((isOpen_lt continuous_const Complex.continuous_im).inter
+      (isOpen_lt Complex.continuous_im continuous_const))
+  have hAH : MapsTo A S upperHalfPlane := by
+    intro z hz
+    change 0<((x:ℂ)+Complex.exp z).im
+    have he : 0<(Complex.exp z).im := exp_strip_halfplane hz.2
+    simpa only [Complex.add_im,Complex.ofReal_im,zero_add] using he
+  have hf : DifferentiableOn ℂ f S := P.inverse_differentiable.comp
+    ((differentiable_const (x:ℂ)).add Complex.differentiable_exp).differentiableOn hAH
+  have hi : InjOn f S := by
+    intro z hz w hw' he
+    have hAz := P.right_inverse (A z) (hAH hz)
+    have hAw := P.right_inverse (A w) (hAH hw')
+    have heA : A z=A w := by
+      rw [show P.inverse (A z)=P.inverse (A w) from he,hAw] at hAz
+      exact hAz.symm
+    exact exp_injective_strip hz.2 hw'.2 (add_left_cancel heA)
+  have harea : (∫⁻ z in S, ENNReal.ofReal (‖deriv f z‖^2))=volume (f '' S) := by
+    have hd (z : ℂ) (hz : z∈S) :=
+      (hf.differentiableAt (hS.mem_nhds hz)).hasDerivAt
+    have he := lintegral_abs_det_fderiv_eq_addHaar_image volume hS.measurableSet
+      (fun z hz => ((hd z hz).hasFDerivAt.restrictScalars ℝ).hasFDerivWithinAt) hi
+    simpa only [complex_derivative_real_det,abs_pow,abs_norm] using he
+  obtain ⟨M,hM⟩ := P.inverse_bounded_over_ball (‖(x:ℂ)‖+Real.exp q)
+  have himage : f '' S ⊆ closedBall (0:ℂ) M := by
+    rintro _ ⟨z,hz,rfl⟩
+    rw [mem_closedBall,dist_zero_right]
+    apply hM (A z) (hAH hz)
+    calc
+      ‖A z‖ ≤ ‖(x:ℂ)‖+‖Complex.exp z‖ := norm_add_le _ _
+      _ ≤ ‖(x:ℂ)‖+Real.exp q := by
+        rw [Complex.norm_exp]
+        exact add_le_add le_rfl (Real.exp_le_exp.mpr hz.1.le)
+  change (∫⁻ z in S, ENNReal.ofReal (‖deriv f z‖^2))<∞
+  rw [harea]
+  exact (measure_mono himage).trans_lt (isCompact_closedBall (0:ℂ) M).measure_lt_top
+
+end SLEExactGauge
+
+end
+
+end OAI
diff --git a/lean/OAI/Probability/SLE/Loewner/SlitChartUniqueness.lean b/lean/OAI/Probability/SLE/Loewner/SlitChartUniqueness.lean
new file mode 100644
index 0000000000000000000000000000000000000000..49422ccdfe4e916a2e6230b1fe04e3c76a53648f
--- /dev/null
+++ b/lean/OAI/Probability/SLE/Loewner/SlitChartUniqueness.lean
@@ -0,0 +1,37 @@
+import OAI.Probability.SLE.Loewner.SlitChartDisplacement
+
+namespace OAI
+
+/-! The normalized static slit chart and its capacity do not depend on a choice. -/
+noncomputable section
+open Set Filter Function
+open scoped Topology
+
+namespace SLEExactGauge
+
+lemma SimpleSlitChart.unique_on_domain {p : C(unitInterval,ℂ)}
+    (P Q : SimpleSlitChart p) :
+    EqOn P.forward Q.forward (upperHalfPlane \ range p) ∧
+      EqOn P.inverse Q.inverse upperHalfPlane ∧ P.capacity=Q.capacity := by
+  have hc : P.capacity=Q.capacity := le_antisymm
+    (P.capacity_le_of_range_subset Q Subset.rfl)
+    (Q.capacity_le_of_range_subset P Subset.rfl)
+  have hcomp (z : ℂ) (hz : z∈upperHalfPlane) : P.forward (Q.inverse z)=z := by
+    have hb := P.inverse_comparison Q Subset.rfl hz
+    rw [hc,sub_self,zero_div] at hb
+    exact sub_eq_zero.mp (norm_le_zero_iff.mp hb)
+  have hi : EqOn P.inverse Q.inverse upperHalfPlane := by
+    intro z hz
+    have hh := P.left_inverse (Q.inverse z) (Q.inverse_mapsTo hz)
+    rw [hcomp z hz] at hh
+    exact hh
+  refine ⟨?_,hi,hc⟩
+  intro z hz
+  apply Q.inverse_injOn (P.bijOn.mapsTo hz) (Q.bijOn.mapsTo hz)
+  rw [← hi (P.bijOn.mapsTo hz),P.left_inverse z hz,Q.left_inverse z hz]
+
+end SLEExactGauge
+
+end
+
+end OAI
diff --git a/lean/OAI/Probability/SLE/Loewner/SlitChartVerticalBounds.lean b/lean/OAI/Probability/SLE/Loewner/SlitChartVerticalBounds.lean
new file mode 100644
index 0000000000000000000000000000000000000000..dcc7865c41b343e71ad1b30338622498d17f47fe
--- /dev/null
+++ b/lean/OAI/Probability/SLE/Loewner/SlitChartVerticalBounds.lean
@@ -0,0 +1,49 @@
+import OAI.Probability.SLE.Loewner.SlitChartExteriorComparison
+
+namespace OAI
+
+/-! A common interior base point for normalized forward charts of bounded slits. -/
+noncomputable section
+open Set Filter Complex Function Metric
+open scoped Topology
+
+namespace SLEExactGauge
+
+lemma radiusHullMap_two_radius {R : ℝ} (hR : 0<R) :
+    radiusHullMap R (((2*R:ℝ):ℂ)*I)=((3*R/2:ℝ):ℂ)*I := by
+  rw [radiusHullMap_formula hR]
+  have hr : (R:ℂ) ≠ 0 := ofReal_ne_zero.mpr hR.ne'
+  push_cast
+  field_simp [hr,Complex.I_ne_zero]
+  ring_nf
+  norm_num [Complex.I_sq]
+
+lemma SimpleSlitChart.vertical_base_bounds {p : C(unitInterval,ℂ)} (P : SimpleSlitChart p)
+    {R : ℝ} (hR : 0<R) (hp : ∀ t : unitInterval, ‖p t‖≤R) :
+    3*R/2≤(P.forward (((2*R:ℝ):ℂ)*I)).im ∧
+      ‖P.forward (((2*R:ℝ):ℂ)*I)‖≤3*R := by
+  have hn : ‖((2*R:ℝ):ℂ)*I‖=2*R := by
+    simp [abs_of_pos hR]
+  have hzH : (((2*R:ℝ):ℂ)*I)∈upperHalfPlane := by
+    change 0<(((2*R:ℝ):ℂ)*I).im
+    simpa using mul_pos (by norm_num : (0:ℝ)<2) hR
+  have hz : (((2*R:ℝ):ℂ)*I)∈exteriorUpperRadius R :=
+    ⟨by rw [hn]; linarith,hzH⟩
+  have hh := P.exterior_comparison hR hp hz
+  rw [radiusHullMap_two_radius hR] at hh
+  have him : (((3*R/2:ℝ):ℂ)*I).im=3*R/2 := by simp
+  rw [him] at hh
+  refine ⟨hh.1,?_⟩
+  have hd : 0<3*R/2 := by positivity
+  have he := (le_div_iff₀ hd).mp hh.2
+  have hnorm : ‖((3*R/2:ℝ):ℂ)*I‖=3*R/2 := by simp [abs_of_pos hR]
+  have htri := norm_le_norm_sub_add (P.forward (((2*R:ℝ):ℂ)*I)) (((3*R/2:ℝ):ℂ)*I)
+  rw [hnorm] at htri
+  have hc := P.capacity_pos
+  nlinarith
+
+end SLEExactGauge
+
+end
+
+end OAI
diff --git a/lean/OAI/Probability/SLE/Loewner/SlitClockRestriction.lean b/lean/OAI/Probability/SLE/Loewner/SlitClockRestriction.lean
new file mode 100644
index 0000000000000000000000000000000000000000..b45ca251263c36936ac571bf63311095c5de2489
--- /dev/null
+++ b/lean/OAI/Probability/SLE/Loewner/SlitClockRestriction.lean
@@ -0,0 +1,63 @@
+import OAI.Probability.SLE.Loewner.SlitPhysicalEvolution
+
+namespace OAI
+
+/-! Exact agreement of the capacity-two clocks on nested prefixes. -/
+noncomputable section
+open Set Filter Function Complex
+open scoped Topology NNReal
+
+namespace SLEExactGauge
+
+lemma slitCapacityHorizon_mono (p : C(unitInterval,ℂ)) (hi : Injective p)
+    (h0 : p 0=0) (hH : ∀ t : unitInterval, t≠0 → p t∈upperHalfPlane)
+    {S T : unitInterval} (hST : S ≤ T) :
+    slitCapacityHorizon p hi h0 hH S ≤ slitCapacityHorizon p hi h0 hH T := by
+  change initialCapacity p hi h0 hH S/2 ≤ initialCapacity p hi h0 hH T/2
+  exact div_le_div_of_nonneg_right (initialCapacity_monotone p hi h0 hH hST) (by norm_num)
+
+lemma slitCapacityHorizon_time (p : C(unitInterval,ℂ)) (hi : Injective p)
+    (h0 : p 0=0) (hH : ∀ t : unitInterval, t≠0 → p t∈upperHalfPlane)
+    (T : unitInterval) {t : ℝ≥0} (ht : t ≤ slitCapacityHorizon p hi h0 hH T) :
+    slitCapacityHorizon p hi h0 hH (slitCapacityTime p hi h0 hH T t)=t := by
+  apply NNReal.coe_injective
+  change initialCapacity p hi h0 hH (slitCapacityTime p hi h0 hH T t)/2=(t:ℝ)
+  rw [slitCapacityTime_capacity p hi h0 hH T ht]
+  ring
+
+lemma slitCapacityTime_restrict (p : C(unitInterval,ℂ)) (hi : Injective p)
+    (h0 : p 0=0) (hH : ∀ t : unitInterval, t≠0 → p t∈upperHalfPlane)
+    {S T : unitInterval} (hST : S ≤ T) {t : ℝ≥0}
+    (ht : t ≤ slitCapacityHorizon p hi h0 hH S) :
+    slitCapacityTime p hi h0 hH T t=slitCapacityTime p hi h0 hH S t := by
+  apply (initialCapacity_strictMono p hi h0 hH).injective
+  rw [slitCapacityTime_capacity p hi h0 hH T
+    (ht.trans (slitCapacityHorizon_mono p hi h0 hH hST)),
+    slitCapacityTime_capacity p hi h0 hH S ht]
+
+lemma slitCapacityForward_restrict (p : C(unitInterval,ℂ)) (hi : Injective p)
+    (h0 : p 0=0) (hH : ∀ t : unitInterval, t≠0 → p t∈upperHalfPlane)
+    {S T : unitInterval} (hST : S ≤ T) {t : ℝ≥0}
+    (ht : t ≤ slitCapacityHorizon p hi h0 hH S) :
+    slitCapacityForward p hi h0 hH T t=slitCapacityForward p hi h0 hH S t := by
+  unfold slitCapacityForward
+  rw [slitCapacityTime_restrict p hi h0 hH hST ht]
+
+lemma slitCapacityDriver_restrict (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) {t : ℝ≥0}
+    (ht : t ≤ slitCapacityHorizon p hi h0 hH S) :
+    slitCapacityDriver p hi h0 hH hT t=
+      slitCapacityDriver p hi h0 hH (hST.trans_lt hT) t := by
+  change initialDrivingValue p hi h0 hH (slitCapacityTime p hi h0 hH T t)
+    ((slitCapacityTime_le p hi h0 hH T t).trans_lt hT)=
+    initialDrivingValue p hi h0 hH (slitCapacityTime p hi h0 hH S t)
+      ((slitCapacityTime_le p hi h0 hH S t).trans_lt (hST.trans_lt hT))
+  congr 1
+  exact slitCapacityTime_restrict p hi h0 hH hST ht
+
+end SLEExactGauge
+
+end
+
+end OAI
diff --git a/lean/OAI/Probability/SLE/Loewner/SlitConstantDriverTail.lean b/lean/OAI/Probability/SLE/Loewner/SlitConstantDriverTail.lean
new file mode 100644
index 0000000000000000000000000000000000000000..9367e7a08432f1ff1538a1287f2d6fc9a9a0cc6b
--- /dev/null
+++ b/lean/OAI/Probability/SLE/Loewner/SlitConstantDriverTail.lean
@@ -0,0 +1,38 @@
+import OAI.Probability.SLE.Loewner.SlitRawTrace
+
+namespace OAI
+
+/-! The constructed driver is constant after the chosen finite slit. -/
+noncomputable section
+open Set Filter Function Complex
+open scoped Topology NNReal
+
+namespace SLEExactGauge
+
+lemma slitCapacityTime_after (p : C(unitInterval,ℂ)) (hi : Injective p)
+    (h0 : p 0=0) (hH : ∀ t : unitInterval, t≠0 → p t∈upperHalfPlane)
+    (T : unitInterval) {t : ℝ≥0} (ht : slitCapacityHorizon p hi h0 hH T ≤ t) :
+    slitCapacityTime p hi h0 hH T t=T := by
+  have hright : initialCapacity p hi h0 hH T ≤ 2*(t:ℝ) := by
+    change initialCapacity p hi h0 hH T/2 ≤ (t:ℝ) at ht
+    linarith
+  unfold slitCapacityTime capacityParameterOnPrefix
+  rw [projIcc_of_right_le _ hright]
+  apply (initialCapacity_strictMono p hi h0 hH).injective
+  exact prefixCapacityTime_capacity p hi h0 hH T _
+
+lemma slitCapacityDriver_after (p : C(unitInterval,ℂ)) (hi : Injective p)
+    (h0 : p 0=0) (hH : ∀ t : unitInterval, t≠0 → p t∈upperHalfPlane)
+    {T : unitInterval} (hT : T<1) {t : ℝ≥0}
+    (ht : slitCapacityHorizon p hi h0 hH T ≤ t) :
+    slitCapacityDriver p hi h0 hH hT t=initialDrivingValue p hi h0 hH T hT := by
+  change initialDrivingValue p hi h0 hH (slitCapacityTime p hi h0 hH T t)
+    ((slitCapacityTime_le p hi h0 hH T t).trans_lt hT)=_
+  congr 1
+  exact slitCapacityTime_after p hi h0 hH T ht
+
+end SLEExactGauge
+
+end
+
+end OAI
diff --git a/lean/OAI/Probability/SLE/Loewner/SlitExtendedTrace.lean b/lean/OAI/Probability/SLE/Loewner/SlitExtendedTrace.lean
new file mode 100644
index 0000000000000000000000000000000000000000..ad609893a3efeb4a47495ae1ec9c64922ccff72f
--- /dev/null
+++ b/lean/OAI/Probability/SLE/Loewner/SlitExtendedTrace.lean
@@ -0,0 +1,122 @@
+import OAI.Probability.SLE.Loewner.SlitConstantDriverTail
+import OAI.Probability.SLE.Loewner.SlitBoundaryTip
+import OAI.Probability.SLE.Loewner.RawConstantTailTrace
+import OAI.Probability.SLE.Geometry.ConcatenatedSlitGeometry
+import OAI.Probability.SLE.Loewner.SmoothRawGeometry
+
+namespace OAI
+
+/-! The exact finite slit followed by its vertical image is the raw trace
+of the constructed, globally continuous driver. -/
+noncomputable section
+open Set Filter Function Complex _root_.MeasureTheory _root_.OAI.MeasureTheory ProbabilityTheory
+open scoped Topology NNReal
+
+namespace SLEExactGauge
+
+theorem slitCapacity_raw_trace_concat (p : C(unitInterval,ℂ)) (hi : Injective p)
+    (h0 : p 0=0) (hH : ∀ t : unitInterval, t≠0 → p t∈upperHalfPlane)
+    {T : unitInterval} (hT : T<1) (B : ℂ → ℂ)
+    (hB : ∀ z∈upperHalfPlane, B z=initialInverseChart p hi h0 hH T z) :
+    (fun t : ℝ≥0 => Target.trace 1 (slitCapacityDriver p hi h0 hH hT) t)=
+      concatenateSlit (slitCapacityHorizon p hi h0 hH T)
+        (slitCapacityCurve p hi h0 hH T) (fun t => Target.trace 1 (Target.linearDriver 0) t)
+        B (initialDrivingValue p hi h0 hH T hT) := by
+  funext t
+  let A := slitCapacityHorizon p hi h0 hH T
+  let u := initialDrivingValue p hi h0 hH T hT
+  change Target.trace 1 (slitCapacityDriver p hi h0 hH hT) t=
+    concatenateSlit A (slitCapacityCurve p hi h0 hH T)
+      (fun s => Target.trace 1 (Target.linearDriver 0) s) B u t
+  by_cases ht : t ≤ A
+  · exact (slitCapacity_raw_trace_eq p hi h0 hH hT ht).trans (by
+      simp only [concatenateSlit,ite_eq_left ht])
+  · have hAt : A<t := lt_of_not_ge ht
+    have hS : 0<t-A := tsub_pos_iff_lt.mpr hAt
+    have hη := Target.smooth_raw_trace_mem_upperHalfPlane (Target.linearDriver 0) (t-A) hS
+      (fun _ => 0) (fun s hs => (Target.linearDriver_derivative 0 s hs.1).mono Icc_subset_Ici_self)
+      (show (0:ℝ) ≤ 0 from le_rfl) (fun _ _ => by simp)
+    have hw : (u:ℂ)+Target.trace 1 (Target.linearDriver 0) (t-A : ℝ≥0)∈upperHalfPlane := by
+      simpa only [upperHalfPlane,mem_ofPred_eq,add_im,ofReal_im,zero_add] using hη
+    have he := Target.trace_constant_tail (slitCapacityDriver p hi h0 hH hT) A (t-A) hS u
+      (fun s hs => slitCapacityDriver_after p hi h0 hH hT hs)
+    rw [←NNReal.coe_add,add_tsub_cancel_of_le hAt.le] at he
+    rw [he,concatenateSlit,ite_eq_right ht,hB _ hw]
+    rw [slitCapacityInverse_eq_raw p hi h0 hH hT le_rfl hw]
+    change initialInverseChart p hi h0 hH (slitCapacityTime p hi h0 hH T A) _=_
+    rw [slitCapacityTime_after p hi h0 hH T le_rfl]
+
+variable {Ω : Type*} [MeasurableSpace Ω] {P : Measure Ω} [IsProbabilityMeasure P]
+  {κ : ℝ} {γ : Ω → ℝ≥0 → ℂ}
+
+theorem RegularSLEPresentation.slitCapacity_raw_geometry
+    (a : RegularSLEPresentation P κ γ) (hκ : 0<κ)
+    (p : C(unitInterval,ℂ)) (hi : Injective p) (h0 : p 0=0)
+    (hH : ∀ t : unitInterval, t≠0 → p t∈upperHalfPlane)
+    {T : unitInterval} (hT0 : 0<T) (hT : T<1) :
+    let β := fun t : ℝ≥0 => Target.trace 1 (slitCapacityDriver p hi h0 hH hT) t
+    Continuous β ∧ β 0=0 ∧ Injective β ∧ (∀ t, 0<t → β t∈upperHalfPlane) ∧
+      ∀ t, 0<t → upperHalfPlane \ (β '' Icc 0 t) ⊆ survivingDomain β t := by
+  dsimp only
+  let A := slitCapacityHorizon p hi h0 hH T
+  let u := initialDrivingValue p hi h0 hH T hT
+  let η := fun t : ℝ≥0 => Target.trace 1 (Target.linearDriver 0) t
+  let β := slitCapacityCurve p hi h0 hH T
+  have hd : ∀ t, 0 ≤ t → HasDerivWithinAt (Target.driverValue (Target.linearDriver 0)) 0
+      (Ici 0) t := fun t ht => Target.linearDriver_derivative 0 t ht
+  have hb : ∀ t : ℝ, 0 ≤ t → |(0:ℝ)| ≤ (0:ℝ≥0) := by intros; simp
+  have hηc : Continuous η := Target.continuous_smooth_raw_trace _ (fun _ => 0) 0 hd hb
+  have hη0 : η 0=0 := Target.smooth_trace_zero _ (fun _ => 0) 0 hd hb
+  have hηi : Injective η := a.smooth_raw_trace_injective hκ _ (fun _ => 0) 0 hd hb
+  have hηH (t : ℝ≥0) (ht : 0<t) : η t∈upperHalfPlane :=
+    Target.smooth_raw_trace_mem_upperHalfPlane _ t ht (fun _ => 0)
+      (fun s hs => (hd s hs.1).mono Icc_subset_Ici_self) (show (0:ℝ) ≤ 0 from le_rfl)
+      (fun _ _ => by simp)
+  have hηclosed (t : ℝ≥0) : 0 ≤ (η t).im := by
+    by_cases ht : t=0
+    · simp only [ht,hη0,zero_im,le_refl]
+    · exact (show 0<(η t).im from hηH t (pos_iff_ne_zero.mpr ht)).le
+  obtain ⟨B,hBc,hBF,hBu⟩ := exists_initial_inverse_boundary_tip p hi h0 hH hT
+  have hBc' : ContinuousOn B closedHalfPlane := hBc
+  have hβc : Continuous β := slitCapacityCurve_continuous p hi h0 hH T
+  have hβ0 : β 0=0 := slitCapacityCurve_zero p hi h0 hH T
+  have hβi : InjOn β (Icc 0 A) := slitCapacityCurve_injOn p hi h0 hH T
+  have hβH (t : ℝ≥0) (ht : 0<t) : β t∈upperHalfPlane := by
+    by_cases htA : t ≤ A
+    · exact slitCapacityCurve_positive p hi h0 hH T ⟨ht,htA⟩
+    · change p (slitCapacityTime p hi h0 hH T t)∈upperHalfPlane
+      rw [slitCapacityTime_after p hi h0 hH T (le_of_not_ge htA)]
+      exact hH T (ne_of_gt hT0)
+  have hBA : B (u:ℂ)=β A := by
+    change B (u:ℂ)=p (slitCapacityTime p hi h0 hH T A)
+    rw [slitCapacityTime_after p hi h0 hH T le_rfl]
+    exact hBu
+  have hA : 0<A := div_pos (initialCapacity_pos p hi h0 hH (ne_of_gt hT0)) (by norm_num)
+  have hBi : InjOn B upperHalfPlane := by
+    intro z hz w hw he
+    apply initialInverseChart_injOn p hi h0 hH T hz hw
+    simpa only [hBF z hz,hBF w hw] using he
+  have hBmap : MapsTo B upperHalfPlane (survivingDomain β A) := by
+    intro z hz
+    apply slitCapacityCurve_free_complement p hi h0 hH T le_rfl hA
+    rw [slitCapacityCurve_initial_range p hi h0 hH T le_rfl,
+      slitCapacityTime_after p hi h0 hH T le_rfl,hBF z hz]
+    exact initialInverseChart_mem_domain p hi h0 hH T hz
+  let f := concatenateSlit A β η B u
+  have hf : (fun t : ℝ≥0 => Target.trace 1 (slitCapacityDriver p hi h0 hH hT) t)=f :=
+    slitCapacity_raw_trace_concat p hi h0 hH hT B hBF
+  have hg : Continuous f ∧ f 0=0 ∧ Injective f ∧ (∀ t, 0<t → f t∈upperHalfPlane) ∧
+      ∀ t, 0<t → upperHalfPlane \ (f '' Icc 0 t) ⊆ survivingDomain f t :=
+    ⟨continuous_concatenateSlit A β η B u hβc hηc hη0 hηclosed hBc' hBA,
+    by simp only [f,concatenateSlit,ite_eq_left (show (0:ℝ≥0) ≤ A from zero_le),hβ0],
+    concatenateSlit_injective A β η B u hβi hηi hηH hBi hBmap,
+    concatenateSlit_positive A β η B u hβH hηH (fun _ hz => (hBmap hz).1.1),
+    concatenateSlit_free_complement A β η B u hβc hηc hβ0 hη0 hβi hηi hβH hηH
+      hBc' hBA hBi hBmap⟩
+  simpa only [←hf] using hg
+
+end SLEExactGauge
+
+end
+
+end OAI
diff --git a/lean/OAI/Probability/SLE/Loewner/SlitExteriorChart.lean b/lean/OAI/Probability/SLE/Loewner/SlitExteriorChart.lean
new file mode 100644
index 0000000000000000000000000000000000000000..03e6fede1e02577474266bec48869e5d234c60b4
--- /dev/null
+++ b/lean/OAI/Probability/SLE/Loewner/SlitExteriorChart.lean
@@ -0,0 +1,87 @@
+import OAI.Probability.SLE.Geometry.NormalizedReflectedSlit
+import OAI.Probability.SLE.Geometry.ConjugateInversionChart
+
+namespace OAI
+
+/-! The normalized reflected Riemann chart gives an analytic chart from
+an arbitrary simple attached slit domain onto the upper exterior disk. -/
+noncomputable section
+open Set Complex Function Metric
+open scoped ComplexConjugate
+
+namespace SLEExactGauge
+
+def slitExteriorMap (f : ℂ → ℂ) (z : ℂ) : ℂ := (f z⁻¹)⁻¹
+
+lemma inverse_mem_reflected_inverted
+    (p : C(unitInterval,ℂ)) (h0 : p 0=0)
+    (hH : ∀ t : unitInterval, t ≠ 0 → p t ∈ upperHalfPlane)
+    {z : ℂ} (hz : z ∈ upperHalfPlane \ range p) :
+    z⁻¹ ∈ invertedExterior (reflectedArcSet p) := by
+  have hm := (conjugateInversion_slit_bijOn p h0 hH).mapsTo hz
+  have hc := invertedExterior_conj (reflectedArcSet_conj p) hm.1
+  simpa only [conjugateInversion,map_inv₀,conj_conj] using hc
+
+lemma slitExteriorMap_eq_conjugate
+    (p : C(unitInterval,ℂ)) (h0 : p 0=0)
+    (hH : ∀ t : unitInterval, t ≠ 0 → p t ∈ upperHalfPlane)
+    {f : ℂ → ℂ}
+    (hs : ∀ z ∈ invertedExterior (reflectedArcSet p), f (conj z)=conj (f z)) :
+    EqOn (conjugateInversion ∘ f ∘ conjugateInversion) (slitExteriorMap f)
+      (upperHalfPlane \ range p) := by
+  intro z hz
+  have he := hs z⁻¹ (inverse_mem_reflected_inverted p h0 hH hz)
+  change (conj (f ((conj z)⁻¹)))⁻¹ = (f z⁻¹)⁻¹
+  rw [← map_inv₀ conj z,he,conj_conj]
+
+lemma slitExteriorMap_bijOn
+    (p : C(unitInterval,ℂ)) (h0 : p 0=0)
+    (hH : ∀ t : unitInterval, t ≠ 0 → p t ∈ upperHalfPlane)
+    {f : ℂ → ℂ}
+    (hs : ∀ z ∈ invertedExterior (reflectedArcSet p), f (conj z)=conj (f z))
+    (hb : BijOn f (invertedExterior (reflectedArcSet p) ∩ upperHalfPlane)
+      (ball 0 1 ∩ upperHalfPlane)) :
+    BijOn (slitExteriorMap f) (upperHalfPlane \ range p) exteriorUpperDisk := by
+  exact ((conjugateInversion_disk_upper_bijOn.comp hb).comp
+    (conjugateInversion_slit_bijOn p h0 hH)).congr
+      (slitExteriorMap_eq_conjugate p h0 hH hs)
+
+lemma slitExteriorMap_differentiableOn
+    (p : C(unitInterval,ℂ)) (h0 : p 0=0)
+    (hH : ∀ t : unitInterval, t ≠ 0 → p t ∈ upperHalfPlane)
+    {f : ℂ → ℂ} (hf : DifferentiableOn ℂ f (invertedExterior (reflectedArcSet p)))
+    (hi : InjOn f (invertedExterior (reflectedArcSet p))) (hf0 : f 0=0) :
+    DifferentiableOn ℂ (slitExteriorMap f) (upperHalfPlane \ range p) := by
+  have hK : IsCompact (reflectedArcSet p) := (isCompact_range p.continuous).union
+    ((isCompact_range p.continuous).image Complex.continuous_conj)
+  intro z hz
+  have hz0 : z ≠ 0 := by
+    intro he
+    have hzH := hz.1
+    simp only [upperHalfPlane,mem_ofPred_eq,he,zero_im,lt_self_iff_false] at hzH
+  have hm := inverse_mem_reflected_inverted p h0 hH hz
+  have hdf := hf.differentiableAt ((invertedExterior_isOpen hK).mem_nhds hm)
+  have hfi : f z⁻¹ ≠ 0 := by
+    intro he
+    have heq := hi hm (zero_mem_invertedExterior _) (he.trans hf0.symm)
+    exact inv_ne_zero hz0 heq
+  exact ((hdf.comp z (differentiableAt_id.inv hz0)).inv hfi).differentiableWithinAt
+
+theorem simple_slit_exists_exterior_chart
+    (p : C(unitInterval,ℂ)) (hi : Injective p) (h0 : p 0=0)
+    (hH : ∀ t : unitInterval, t ≠ 0 → p t ∈ upperHalfPlane) :
+    ∃ (f : ℂ → ℂ) (a : ℝ), 0 < a ∧
+      BijOn (slitExteriorMap f) (upperHalfPlane \ range p) exteriorUpperDisk ∧
+      DifferentiableOn ℂ (slitExteriorMap f) (upperHalfPlane \ range p) ∧
+      f 0=0 ∧ deriv f 0=(a:ℂ) ∧
+      DifferentiableOn ℂ f (invertedExterior (reflectedArcSet p)) := by
+  obtain ⟨f,a,ha,hb,hf,hf0,hfa,hs,hu⟩ :=
+    reflected_slit_exists_normalized_chart p hi h0 hH
+  exact ⟨f,a,ha,slitExteriorMap_bijOn p h0 hH hs hu,
+    slitExteriorMap_differentiableOn p h0 hH hf hb.injOn hf0,hf0,hfa,hf⟩
+
+end SLEExactGauge
+
+end
+
+end OAI
diff --git a/lean/OAI/Probability/SLE/Loewner/SlitForwardBoundaryHeight.lean b/lean/OAI/Probability/SLE/Loewner/SlitForwardBoundaryHeight.lean
new file mode 100644
index 0000000000000000000000000000000000000000..49194d7be5fb7eb8a0f6a714743c8ed73f13fdc0
--- /dev/null
+++ b/lean/OAI/Probability/SLE/Loewner/SlitForwardBoundaryHeight.lean
@@ -0,0 +1,74 @@
+import OAI.Probability.SLE.Loewner.SlitChartProper
+import OAI.Probability.SLE.Geometry.ComplexEndpointCluster
+
+namespace OAI
+
+/-! A physical sequence approaching the slit boundary has forward-chart
+height tending to zero. -/
+noncomputable section
+open Set Filter Function Metric Complex
+open scoped Topology
+
+namespace SLEExactGauge
+
+theorem SimpleSlitChart.forward_height_tendsto_zero {p : C(unitInterval,ℂ)}
+    (P : SimpleSlitChart p) {z : ℕ → ℂ} {b : ℂ}
+    (hz : Tendsto z atTop (𝓝 b))
+    (hzD : ∀ n, z n∈upperHalfPlane \ range p) (hb : b∉upperHalfPlane \ range p) :
+    Tendsto (fun n => (P.forward (z n)).im) atTop (𝓝 0) := by
+  obtain ⟨R,hR⟩ := (Metric.isBounded_range_of_tendsto z hz).exists_norm_le
+  obtain ⟨M,hM⟩ := P.forward_bounded_over_ball R
+  apply tendsto_of_subseq_tendsto
+  intro φ hφ
+  obtain ⟨w,_,ψ,hψ,hw⟩ := (isCompact_closedBall (0:ℂ) M).tendsto_subseq (fun n => by
+    rw [mem_closedBall,dist_zero_right]
+    exact hM (z (φ n)) (hzD _) (hR _ (mem_range_self _)))
+  have hwim : 0≤w.im := ge_of_tendsto (continuous_im.continuousAt.tendsto.comp hw)
+    (Eventually.of_forall fun n => (show 0<(P.forward (z (φ (ψ n)))).im from
+      P.bijOn.mapsTo (hzD _)).le)
+  have hezero : w.im=0 := by
+    by_contra hne
+    have hwH : w∈upperHalfPlane := lt_of_le_of_ne hwim (Ne.symm hne)
+    have hback := ((P.inverse_differentiable.continuousOn w hwH).continuousAt
+      (isOpen_upperHalfPlane.mem_nhds hwH)).tendsto.comp hw
+    have he : P.inverse w=b := by
+      apply tendsto_nhds_unique hback
+      have hzb := (hz.comp hφ).comp hψ.tendsto_atTop
+      apply hzb.congr
+      intro n
+      exact (P.left_inverse _ (hzD _)).symm
+    exact hb (he ▸ P.inverse_mapsTo hwH)
+  refine ⟨ψ,?_⟩
+  have hh := continuous_im.continuousAt.tendsto.comp hw
+  change Tendsto (fun n => (P.forward (z (φ (ψ n)))).im) atTop (𝓝 w.im) at hh
+  rwa [hezero] at hh
+
+theorem SimpleSlitChart.forward_height_tendsto_zero_filter {p : C(unitInterval,ℂ)}
+    (P : SimpleSlitChart p) {α : Type*} {l : Filter α} [l.IsCountablyGenerated]
+    {z : α → ℂ} {b : ℂ} (hz : Tendsto z l (𝓝 b))
+    (hzD : ∀ᶠ x in l, z x∈upperHalfPlane \ range p)
+    (hb : b∉upperHalfPlane \ range p) :
+    Tendsto (fun x => (P.forward (z x)).im) l (𝓝 0) := by
+  classical
+  apply tendsto_iff_seq_tendsto.mpr
+  intro u hu
+  let w : ℕ → ℂ := fun n =>
+    if z (u n)∈upperHalfPlane \ range p then z (u n) else P.inverse I
+  have he : w =ᶠ[atTop] fun n => z (u n) := by
+    filter_upwards [hu.eventually hzD] with n hn
+    exact ite_eq_left hn
+  have hw : Tendsto w atTop (𝓝 b) := (hz.comp hu).congr' he.symm
+  have hwD : ∀ n, w n∈upperHalfPlane \ range p := by
+    intro n
+    dsimp only [w]
+    split_ifs with hn
+    · exact hn
+    · exact P.inverse_mapsTo (by change 0<(I:ℂ).im; norm_num)
+  exact (P.forward_height_tendsto_zero hw hwD hb).congr'
+    (he.mono fun n hn => congrArg (fun v => (P.forward v).im) hn)
+
+end SLEExactGauge
+
+end
+
+end OAI
diff --git a/lean/OAI/Probability/SLE/Loewner/SlitForwardEndpoint.lean b/lean/OAI/Probability/SLE/Loewner/SlitForwardEndpoint.lean
new file mode 100644
index 0000000000000000000000000000000000000000..d067765b4e9a38ad07ff3ac55d3ea5a21ad92007
--- /dev/null
+++ b/lean/OAI/Probability/SLE/Loewner/SlitForwardEndpoint.lean
@@ -0,0 +1,54 @@
+import OAI.Probability.SLE.Loewner.SlitForwardBoundaryHeight
+import OAI.Probability.SLE.Geometry.ComplexEndpointLimit
+import OAI.Probability.SLE.Loewner.SlitBoundaryFiber
+
+namespace OAI
+
+/-! A continuous curve in a slit domain approaching its boundary has a
+real forward-chart limit. No uniqueness of arbitrary boundary fibers is
+assumed: the connected cluster set and noncollapse of intervals suffice. -/
+noncomputable section
+open Set Filter Function Metric Complex
+open scoped Topology
+
+namespace SLEExactGauge
+
+theorem SimpleSlitChart.exists_forward_endpoint_limit {p : C(unitInterval,ℂ)}
+    (P : SimpleSlitChart p) {z : ℝ → ℂ} {b : ℂ} {D : ℝ}
+    (hD : 0<D) (hzC : ContinuousOn z (Ioo 0 D))
+    (hz : Tendsto z (𝓝[>] (0:ℝ)) (𝓝 b))
+    (hzD : MapsTo z (Ioo 0 D) (upperHalfPlane \ range p))
+    (hb : b∉upperHalfPlane \ range p) :
+    ∃ a : ℝ, Tendsto (fun t => P.forward (z t)) (𝓝[>] (0:ℝ)) (𝓝 (a:ℂ)) := by
+  have hsmall : ∀ᶠ t : ℝ in 𝓝[>] (0:ℝ), t∈Ioo 0 D :=
+    Ioo_mem_nhdsGT hD
+  have hvalid : ∀ᶠ t : ℝ in 𝓝[>] (0:ℝ), z t∈upperHalfPlane \ range p :=
+    hsmall.mono hzD
+  have hnorm : ∀ᶠ t : ℝ in 𝓝[>] (0:ℝ), ‖z t‖≤‖b‖+1 := by
+    exact (hz.norm.eventually (gt_mem_nhds (by linarith : ‖b‖<‖b‖+1))).mono
+      (fun _ h => h.le)
+  obtain ⟨M,hM⟩ := P.forward_bounded_over_ball (‖b‖+1)
+  have hbound : ∀ᶠ t : ℝ in 𝓝[>] (0:ℝ), ‖P.forward (z t)‖≤M := by
+    filter_upwards [hvalid,hnorm] with t ht htn
+    exact hM _ ht htn
+  obtain ⟨B,hBC,hBe⟩ := P.exists_boundary_extension
+  have himage : Tendsto (fun t => B (P.forward (z t))) (𝓝[>] (0:ℝ)) (𝓝 b) := by
+    apply hz.congr'
+    filter_upwards [hvalid] with t ht
+    exact (hBe _ (P.bijOn.mapsTo ht)).trans (P.left_inverse _ ht) |>.symm
+  obtain ⟨a,ha,_⟩ := exists_complex_endpoint_limit hD
+    (P.forward_differentiable.continuousOn.comp hzC hzD) hbound
+    (hvalid.mono fun _ ht => (show 0<(P.forward _).im from P.bijOn.mapsTo ht).le)
+    (P.forward_height_tendsto_zero_filter hz hvalid hb) hBC himage (by
+      intro a d had hconst
+      apply P.boundary_not_constant_on_interval hBC hBe ((a+d)/2)
+        (show 0<(d-a)/2 by linarith) b
+      intro y hy
+      exact hconst y ⟨by linarith [hy.1],by linarith [hy.2]⟩)
+  exact ⟨a,ha⟩
+
+end SLEExactGauge
+
+end
+
+end OAI
diff --git a/lean/OAI/Probability/SLE/Loewner/SlitHydrodynamicChart.lean b/lean/OAI/Probability/SLE/Loewner/SlitHydrodynamicChart.lean
new file mode 100644
index 0000000000000000000000000000000000000000..b7932f0dc8aae46a3d1d095a77e628f73f55f620
--- /dev/null
+++ b/lean/OAI/Probability/SLE/Loewner/SlitHydrodynamicChart.lean
@@ -0,0 +1,98 @@
+import OAI.Probability.SLE.Geometry.ExteriorLaurent
+
+namespace OAI
+
+/-! Static hydrodynamic normalization for the complement of an arbitrary
+simple attached arc. No time parametrization or Loewner equation is asserted. -/
+noncomputable section
+open Set Filter Complex Function Metric
+open scoped Topology ComplexConjugate
+
+namespace SLEExactGauge
+
+lemma positive_real_affine_halfPlane {a : ℝ} (ha : 0<a) (b : ℝ) :
+    BijOn (fun z : ℂ => (a:ℂ)*z-(b:ℂ)) upperHalfPlane upperHalfPlane := by
+  have ha0 : (a:ℂ) ≠ 0 := ofReal_ne_zero.mpr ha.ne'
+  refine ⟨?_,?_,?_⟩
+  · intro z hz
+    change 0 < ((a:ℂ)*z-(b:ℂ)).im
+    simpa only [sub_im,mul_im,ofReal_re,ofReal_im,zero_mul,add_zero,sub_zero]
+      using mul_pos ha hz
+  · intro z _ w _ he
+    apply mul_left_cancel₀ ha0
+    simpa only [sub_add_cancel] using congrArg (fun x : ℂ => x+(b:ℂ)) he
+  · intro z hz
+    refine ⟨(z+(b:ℂ))/(a:ℂ),?_,?_⟩
+    · change 0 < ((z+(b:ℂ))/(a:ℂ)).im
+      have he : ((z+(b:ℂ))/(a:ℂ)).im=z.im/a := by
+        rw [div_ofReal_im,add_im,ofReal_im,add_zero]
+      rw [he]
+      exact div_pos hz ha
+    · field_simp
+      ring
+
+lemma eq_ofReal_re_of_conj_eq {z : ℂ} (hz : conj z=z) : z=(z.re:ℂ) := by
+  have hi := congrArg Complex.im hz
+  simp only [conj_im] at hi
+  apply Complex.ext
+  · simp
+  · simp only [ofReal_im]
+    linarith
+
+def slitHydrodynamicMap (f : ℂ → ℂ) (a : ℝ) (z : ℂ) : ℂ :=
+  (a:ℂ)*exteriorJoukowski (slitExteriorMap f z)-deriv (slitInfinityFactor f a) 0
+
+theorem simple_slit_exists_hydrodynamic_chart
+    (p : C(unitInterval,ℂ)) (hi : Injective p) (h0 : p 0=0)
+    (hH : ∀ t : unitInterval, t ≠ 0 → p t ∈ upperHalfPlane) :
+    ∃ (G F : ℂ → ℂ) (c : ℝ),
+      BijOn G (upperHalfPlane \ range p) upperHalfPlane ∧
+      DifferentiableOn ℂ G (upperHalfPlane \ range p) ∧
+      DifferentiableOn ℂ F upperHalfPlane ∧
+      (∀ z ∈ upperHalfPlane \ range p, F (G z)=z) ∧
+      (∀ z ∈ upperHalfPlane, G (F z)=z) ∧
+      Tendsto (fun z : ℂ => z*(G z-z)) (cocompact ℂ) (𝓝 (c:ℂ)) := by
+  obtain ⟨f,a,ha,hb,hf,hf0,hfa,hs,hu⟩ :=
+    reflected_slit_exists_normalized_chart p hi h0 hH
+  have hK : IsCompact (reflectedArcSet p) := (isCompact_range p.continuous).union
+    ((isCompact_range p.continuous).image Complex.continuous_conj)
+  have hD : invertedExterior (reflectedArcSet p) ∈ 𝓝 (0:ℂ) :=
+    (invertedExterior_isOpen hK).mem_nhds (zero_mem_invertedExterior _)
+  have hfa' : AnalyticAt ℂ f 0 := hf.analyticAt hD
+  have hsH := slitInfinityFactor_reflection hD hs a
+  have hreal := eq_ofReal_re_of_conj_eq (derivative_real_of_reflection hD hsH)
+  have hsQ := dslope_reflection hD hsH
+  have hc := eq_ofReal_re_of_conj_eq (derivative_real_of_reflection hD hsQ)
+  let G := slitHydrodynamicMap f a
+  have hG : BijOn G (upperHalfPlane \ range p) upperHalfPlane := by
+    have hh := (positive_real_affine_halfPlane ha (deriv (slitInfinityFactor f a) 0).re).comp
+      (exteriorJoukowski_bijOn.comp (slitExteriorMap_bijOn p h0 hH hs hu))
+    apply hh.congr
+    intro z _
+    change (a:ℂ)*exteriorJoukowski (slitExteriorMap f z)-
+      ((deriv (slitInfinityFactor f a) 0).re:ℂ)=
+      (a:ℂ)*exteriorJoukowski (slitExteriorMap f z)-deriv (slitInfinityFactor f a) 0
+    rw [← hreal]
+  have hdiff : DifferentiableOn ℂ G (upperHalfPlane \ range p) := by
+    have he := exteriorJoukowski_differentiableOn.comp
+      (slitExteriorMap_differentiableOn p h0 hH hf hb.injOn hf0)
+      (slitExteriorMap_bijOn p h0 hH hs hu).mapsTo
+    exact (he.const_mul (a:ℂ)).sub_const _
+  have ho : IsOpen (upperHalfPlane \ range p) :=
+    isOpen_upperHalfPlane.sdiff (isCompact_range p.continuous).isClosed
+  let F := invFunOn G (upperHalfPlane \ range p)
+  have hF : DifferentiableOn ℂ F upperHalfPlane := by
+    have hh := hdiff.invFunOn ho hG.injOn
+    simpa only [F,hG.image_eq] using hh
+  refine ⟨G,F,(deriv (dslope (slitInfinityFactor f a) 0) 0).re,hG,hdiff,hF,
+    fun z hz => hG.injOn.leftInvOn_invFunOn hz,
+    fun z hz => hG.surjOn.rightInvOn_invFunOn hz,?_⟩
+  have ht := slitExteriorMap_laurent_limit hfa' hf0 ha.ne' hfa
+  rw [hc] at ht
+  exact ht
+
+end SLEExactGauge
+
+end
+
+end OAI
diff --git a/lean/OAI/Probability/SLE/Loewner/SlitInitialEvolution.lean b/lean/OAI/Probability/SLE/Loewner/SlitInitialEvolution.lean
new file mode 100644
index 0000000000000000000000000000000000000000..3b25825f82a49d3de088dd4a04984e74025a7a54
--- /dev/null
+++ b/lean/OAI/Probability/SLE/Loewner/SlitInitialEvolution.lean
@@ -0,0 +1,45 @@
+import OAI.Probability.SLE.Loewner.SlitClockRestriction
+
+namespace OAI
+
+/-! Every point surviving to a chosen physical time follows the exact
+Loewner equation on the whole interval up to that time. -/
+noncomputable section
+open Set Filter Function Complex
+open scoped Topology NNReal
+
+namespace SLEExactGauge
+
+theorem slitCapacityForward_derivative_upto (p : C(unitInterval,ℂ)) (hi : Injective p)
+    (h0 : p 0=0) (hH : ∀ t : unitInterval, t≠0 → p t∈upperHalfPlane)
+    {T : unitInterval} (hT : T<1) {t : ℝ≥0}
+    (ht : t ≤ slitCapacityHorizon p hi h0 hH T) {z : ℂ}
+    (hz : z∈upperHalfPlane \ range (initialSubarc p (slitCapacityTime p hi h0 hH T t)))
+    {u : ℝ} (hu : u∈Icc 0 (t:ℝ)) :
+    HasDerivWithinAt (fun v : ℝ => slitCapacityForward p hi h0 hH T v.toNNReal z)
+      (2/(slitCapacityForward p hi h0 hH T u.toNNReal z-
+        (slitCapacityDriver p hi h0 hH hT u.toNNReal:ℂ))) (Icc 0 (t:ℝ)) u := by
+  let S := slitCapacityTime p hi h0 hH T t
+  have hST : S ≤ T := slitCapacityTime_le p hi h0 hH T t
+  have hS : S<1 := hST.trans_lt hT
+  have hHS : slitCapacityHorizon p hi h0 hH S=t := slitCapacityHorizon_time p hi h0 hH T ht
+  have hu' : u.toNNReal ≤ slitCapacityHorizon p hi h0 hH S := by
+    rw [hHS]
+    exact Real.toNNReal_le_iff_le_coe.mpr hu.2
+  have hd := slitCapacityForward_prefix_derivative p hi h0 hH hS hz hu'
+  rw [hHS,Real.coe_toNNReal u hu.1] at hd
+  have hG (v : ℝ) (hv : v∈Icc 0 (t:ℝ)) :
+      slitCapacityForward p hi h0 hH T v.toNNReal z=
+        slitCapacityForward p hi h0 hH S v.toNNReal z := by
+    rw [slitCapacityForward_restrict p hi h0 hH hST]
+    rw [hHS]
+    exact Real.toNNReal_le_iff_le_coe.mpr hv.2
+  have hres := hd.congr hG (hG u hu)
+  rw [← hG u hu,← slitCapacityDriver_restrict p hi h0 hH hST hT hu'] at hres
+  exact hres
+
+end SLEExactGauge
+
+end
+
+end OAI
diff --git a/lean/OAI/Probability/SLE/Loewner/SlitInverseAtInfinity.lean b/lean/OAI/Probability/SLE/Loewner/SlitInverseAtInfinity.lean
new file mode 100644
index 0000000000000000000000000000000000000000..8c93eaf4e3ce5c9c4264cc26f7b822cbd01a2ff7
--- /dev/null
+++ b/lean/OAI/Probability/SLE/Loewner/SlitInverseAtInfinity.lean
@@ -0,0 +1,82 @@
+import OAI.Probability.SLE.Geometry.ReciprocalInverseLimit
+
+namespace OAI
+
+/-! Identification of the analytic inverse germ with the physical slit
+inverse for all sufficiently large points of the half-plane. -/
+noncomputable section
+open Set Filter Complex Function Metric
+open scoped Topology ComplexConjugate
+
+namespace SLEExactGauge
+
+lemma slitHydrodynamicMap_conjugateInversion
+    {D : Set ℂ} (hD : D ∈ 𝓝 (0:ℂ)) {f : ℂ → ℂ} (hf0 : f 0=0)
+    (hs : ∀ z ∈ D, f (conj z)=conj (f z)) (a : ℝ)
+    {x : ℂ} (hx : x ∈ D) (hx0 : x ≠ 0) :
+    slitHydrodynamicMap f a (conjugateInversion x)=
+      conjugateInversion (slitReciprocalMap f a x) := by
+  have hh := slitReciprocalMap_identity hf0 a (conjugateInversion_ne_zero hx0)
+  have hq := slitReciprocalMap_reflection hD hs a x hx
+  simp only [conjugateInversion,inv_inv] at hh
+  rw [hq] at hh
+  exact hh.symm
+
+theorem slit_inverse_tendsto_ratio
+    (p : C(unitInterval,ℂ)) (h0 : p 0=0)
+    (hH : ∀ t : unitInterval, t ≠ 0 → p t ∈ upperHalfPlane)
+    {f : ℂ → ℂ} {a : ℝ} (ha : 0<a)
+    (hf : DifferentiableOn ℂ f (invertedExterior (reflectedArcSet p)))
+    (hf0 : f 0=0) (hfa : deriv f 0=(a:ℂ))
+    (hs : ∀ z ∈ invertedExterior (reflectedArcSet p), f (conj z)=conj (f z))
+    (F : ℂ → ℂ)
+    (hleft : ∀ z ∈ upperHalfPlane \ range p, F (slitHydrodynamicMap f a z)=z) :
+    Tendsto (fun z : ℂ => F z/z) (cocompact ℂ ⊓ 𝓟 upperHalfPlane) (𝓝 1) := by
+  have hK : IsCompact (reflectedArcSet p) := (isCompact_range p.continuous).union
+    ((isCompact_range p.continuous).image Complex.continuous_conj)
+  have hD : invertedExterior (reflectedArcSet p) ∈ 𝓝 (0:ℂ) :=
+    (invertedExterior_isOpen hK).mem_nhds (zero_mem_invertedExterior _)
+  obtain ⟨r,ε,hε,hr,hr0,hrd,hupper,hl,hh⟩ :=
+    slitReciprocalMap_exists_upper_inverse hD (hf.analyticAt hD) ha.ne' hfa hs
+  have hrT : Tendsto r (𝓝 (0:ℂ)) (𝓝 0) := by simpa only [hr0] using hr.continuousAt.tendsto
+  have hM := conjugateInversion_tendsto_zero
+  have hrD := (hrT.comp hM).eventually hD
+  have heq := hM.eventually hh
+  have hsmall := hM.eventually (ball_mem_nhds (0:ℂ) hε)
+  have hMb := conjugateInversion_slit_bijOn p h0 hH
+  have he : (fun z : ℂ => F z/z) =ᶠ[cocompact ℂ ⊓ 𝓟 upperHalfPlane]
+      (fun z => conjugateInversion (r (conjugateInversion z))/z) := by
+    change ∀ᶠ z in cocompact ℂ ⊓ 𝓟 upperHalfPlane,
+      F z/z=conjugateInversion (r (conjugateInversion z))/z
+    rw [eventually_inf_principal]
+    filter_upwards [hrD,heq,hsmall] with z hzD hzq hzb
+    intro hzH
+    have hzD' : r (conjugateInversion z) ∈ invertedExterior (reflectedArcSet p) := by
+      simpa only [Function.comp_apply,invertedExterior,mem_ofPred_eq] using hzD
+    have hMz := conjugateInversion_upper hzH
+    have hrH := hupper ⟨hzb,hMz⟩
+    have hrne : r (conjugateInversion z) ≠ 0 := by
+      intro hzero
+      have hi := congrArg Complex.im hzero
+      simp only [zero_im] at hi
+      exact hrH.ne' hi
+    have hx : conjugateInversion (r (conjugateInversion z)) ∈ upperHalfPlane \ range p := by
+      obtain ⟨v,hv,hvr⟩ := hMb.surjOn ⟨hzD',hrH⟩
+      have he : v=conjugateInversion (r (conjugateInversion z)) := by
+        rw [← hvr,conjugateInversion_involutive]
+      exact he ▸ hv
+    have hG := slitHydrodynamicMap_conjugateInversion hD hf0 hs a hzD' hrne
+    rw [hzq,conjugateInversion_involutive] at hG
+    have hF := hleft _ hx
+    rw [hG] at hF
+    rw [hF]
+  have ht := (reciprocal_inverse_tendsto_ratio
+    (by simpa only [hrd] using hr.differentiableAt.hasDerivAt) hr0).mono_left
+      (show cocompact ℂ ⊓ 𝓟 upperHalfPlane ≤ cocompact ℂ from inf_le_left)
+  exact ht.congr' he.symm
+
+end SLEExactGauge
+
+end
+
+end OAI
diff --git a/lean/OAI/Probability/SLE/Loewner/SlitInverseGerm.lean b/lean/OAI/Probability/SLE/Loewner/SlitInverseGerm.lean
new file mode 100644
index 0000000000000000000000000000000000000000..030f86bda545cf44733ce32a8f1dfbfe749e7aa4
--- /dev/null
+++ b/lean/OAI/Probability/SLE/Loewner/SlitInverseGerm.lean
@@ -0,0 +1,49 @@
+import OAI.Probability.SLE.Geometry.StrictRealLocalChart
+
+namespace OAI
+
+/-! The analytic inverse germ at infinity respects reflection and the
+upper side. This is the local branch for the actual slit inverse. -/
+noncomputable section
+open Set Filter Complex Function Metric
+open scoped Topology ComplexConjugate
+
+namespace SLEExactGauge
+
+lemma local_inverse_reflection {q r : ℂ → ℂ}
+    (hr : ContinuousAt r 0) (hr0 : r 0=0)
+    (hs : ∀ᶠ z in 𝓝 (0:ℂ), q (conj z)=conj (q z))
+    (hl : ∀ᶠ z in 𝓝 (0:ℂ), r (q z)=z)
+    (hh : ∀ᶠ z in 𝓝 (0:ℂ), q (r z)=z) :
+    ∀ᶠ z in 𝓝 (0:ℂ), r (conj z)=conj (r z) := by
+  have ht : Tendsto r (𝓝 (0:ℂ)) (𝓝 0) := by simpa only [hr0] using hr.tendsto
+  have hc : Tendsto (fun z => conj (r z)) (𝓝 (0:ℂ)) (𝓝 0) := by
+    convert! (Complex.continuous_conj.tendsto 0).comp ht using 1
+    simp
+  filter_upwards [ht.eventually hs,hc.eventually hl,hh] with z hsz hlz hhz
+  rwa [hsz,hhz] at hlz
+
+theorem slitReciprocalMap_exists_upper_inverse
+    {D : Set ℂ} (hD : D ∈ 𝓝 (0:ℂ)) {f : ℂ → ℂ} {a : ℝ}
+    (hf : AnalyticAt ℂ f 0) (ha : a ≠ 0) (hd : deriv f 0=(a:ℂ))
+    (hs : ∀ z ∈ D, f (conj z)=conj (f z)) :
+    ∃ (r : ℂ → ℂ) (ε : ℝ), 0<ε ∧ AnalyticAt ℂ r 0 ∧ r 0=0 ∧ deriv r 0=1 ∧
+      MapsTo r (ball 0 ε ∩ upperHalfPlane) upperHalfPlane ∧
+      (∀ᶠ z in 𝓝 (0:ℂ), r (slitReciprocalMap f a z)=z) ∧
+      (∀ᶠ z in 𝓝 (0:ℂ), slitReciprocalMap f a (r z)=z) := by
+  obtain ⟨r,hr,hr0,hrd,hl,hh⟩ := slitReciprocalMap_exists_local_inverse hf ha hd
+  have hsym : ∀ᶠ z in 𝓝 (0:ℂ), slitReciprocalMap f a (conj z)=
+      conj (slitReciprocalMap f a z) := by
+    filter_upwards [hD] with z hz
+    exact slitReciprocalMap_reflection hD hs a z hz
+  have hrs := local_inverse_reflection hr.continuousAt hr0 hsym hl hh
+  obtain ⟨S,hS,hsS⟩ := hrs.exists_mem
+  have hstrict : HasStrictDerivAt r 1 0 := by simpa only [hrd] using hr.hasStrictDerivAt
+  obtain ⟨ε,hε,hupper⟩ := strict_real_germ_maps_upper hS hstrict hsS
+  exact ⟨r,ε,hε,hr,hr0,hrd,hupper,hl,hh⟩
+
+end SLEExactGauge
+
+end
+
+end OAI
diff --git a/lean/OAI/Probability/SLE/Loewner/SlitPhysicalClock.lean b/lean/OAI/Probability/SLE/Loewner/SlitPhysicalClock.lean
new file mode 100644
index 0000000000000000000000000000000000000000..d27e3f3e502e517b25916a69162e60cddae83986
--- /dev/null
+++ b/lean/OAI/Probability/SLE/Loewner/SlitPhysicalClock.lean
@@ -0,0 +1,98 @@
+import OAI.Probability.SLE.Loewner.InitialDrivingTip
+import OAI.Probability.SLE.MomentGauge
+
+namespace OAI
+
+/-! The exact capacity-two parametrization of a finite prescribed slit. -/
+noncomputable section
+open Set Filter Function Complex
+open scoped Topology NNReal
+
+namespace SLEExactGauge
+
+noncomputable def slitCapacityHorizon (p : C(unitInterval,ℂ)) (hi : Injective p)
+    (h0 : p 0=0) (hH : ∀ t : unitInterval, t≠0 → p t∈upperHalfPlane)
+    (T : unitInterval) : ℝ≥0 :=
+  ⟨initialCapacity p hi h0 hH T/2,div_nonneg (initialCapacity_nonneg p hi h0 hH T) (by norm_num)⟩
+
+noncomputable def slitCapacityTime (p : C(unitInterval,ℂ)) (hi : Injective p)
+    (h0 : p 0=0) (hH : ∀ t : unitInterval, t≠0 → p t∈upperHalfPlane)
+    (T : unitInterval) (t : ℝ≥0) : unitInterval :=
+  capacityParameterOnPrefix p hi h0 hH T (2*(t:ℝ))
+
+lemma slitCapacityTime_continuous (p : C(unitInterval,ℂ)) (hi : Injective p)
+    (h0 : p 0=0) (hH : ∀ t : unitInterval, t≠0 → p t∈upperHalfPlane)
+    (T : unitInterval) : Continuous (slitCapacityTime p hi h0 hH T) :=
+  (capacityParameterOnPrefix_continuous p hi h0 hH T).comp
+    (continuous_const.mul continuous_subtype_val)
+
+@[simp] lemma slitCapacityTime_zero (p : C(unitInterval,ℂ)) (hi : Injective p)
+    (h0 : p 0=0) (hH : ∀ t : unitInterval, t≠0 → p t∈upperHalfPlane)
+    (T : unitInterval) : slitCapacityTime p hi h0 hH T 0=0 := by
+  have hh := capacityParameterOnPrefix_at_initialCapacity p hi h0 hH T
+    (s := 0) (show (0:unitInterval) ≤ T from T.property.1)
+  simpa only [slitCapacityTime,NNReal.coe_zero,mul_zero,initialCapacity_zero] using hh
+
+lemma slitCapacityTime_le (p : C(unitInterval,ℂ)) (hi : Injective p)
+    (h0 : p 0=0) (hH : ∀ t : unitInterval, t≠0 → p t∈upperHalfPlane)
+    (T : unitInterval) (t : ℝ≥0) : slitCapacityTime p hi h0 hH T t ≤ T :=
+  capacityParameterOnPrefix_le p hi h0 hH T _
+
+lemma slitCapacityTime_capacity (p : C(unitInterval,ℂ)) (hi : Injective p)
+    (h0 : p 0=0) (hH : ∀ t : unitInterval, t≠0 → p t∈upperHalfPlane)
+    (T : unitInterval) {t : ℝ≥0} (ht : t ≤ slitCapacityHorizon p hi h0 hH T) :
+    initialCapacity p hi h0 hH (slitCapacityTime p hi h0 hH T t)=2*(t:ℝ) := by
+  apply capacityParameterOnPrefix_capacity
+  constructor
+  · positivity
+  · change (t:ℝ) ≤ initialCapacity p hi h0 hH T/2 at ht
+    linarith
+
+lemma slitCapacityTime_at_capacity (p : C(unitInterval,ℂ)) (hi : Injective p)
+    (h0 : p 0=0) (hH : ∀ t : unitInterval, t≠0 → p t∈upperHalfPlane)
+    (T : unitInterval) {v : unitInterval} (hv : v ≤ T) :
+    slitCapacityTime p hi h0 hH T
+      ⟨initialCapacity p hi h0 hH v/2,
+        div_nonneg (initialCapacity_nonneg p hi h0 hH v) (by norm_num)⟩=v := by
+  unfold slitCapacityTime
+  change capacityParameterOnPrefix p hi h0 hH T (2*(initialCapacity p hi h0 hH v/2))=v
+  rw [mul_div_cancel₀ _ (by norm_num : (2:ℝ)≠0)]
+  exact capacityParameterOnPrefix_at_initialCapacity p hi h0 hH T hv
+
+lemma slitCapacityTime_image (p : C(unitInterval,ℂ)) (hi : Injective p)
+    (h0 : p 0=0) (hH : ∀ t : unitInterval, t≠0 → p t∈upperHalfPlane)
+    (T : unitInterval) {t : ℝ≥0} (ht : t ≤ slitCapacityHorizon p hi h0 hH T) :
+    slitCapacityTime p hi h0 hH T '' Icc 0 t=Icc 0 (slitCapacityTime p hi h0 hH T t) := by
+  ext v
+  constructor
+  · rintro ⟨u,hu,rfl⟩
+    refine ⟨(slitCapacityTime p hi h0 hH T u).property.1,?_⟩
+    apply (initialCapacity_strictMono p hi h0 hH).le_iff_le.mp
+    rw [slitCapacityTime_capacity p hi h0 hH T (hu.2.trans ht),
+      slitCapacityTime_capacity p hi h0 hH T ht]
+    exact mul_le_mul_of_nonneg_left (NNReal.coe_le_coe.mpr hu.2) (by norm_num)
+  · intro hv
+    let u : ℝ≥0 := ⟨initialCapacity p hi h0 hH v/2,
+      div_nonneg (initialCapacity_nonneg p hi h0 hH v) (by norm_num)⟩
+    refine ⟨u,⟨zero_le,?_⟩,slitCapacityTime_at_capacity p hi h0 hH T
+      (hv.2.trans (slitCapacityTime_le p hi h0 hH T t))⟩
+    have hh := initialCapacity_monotone p hi h0 hH hv.2
+    rw [slitCapacityTime_capacity p hi h0 hH T ht] at hh
+    change initialCapacity p hi h0 hH v/2 ≤ (t:ℝ)
+    linarith
+
+noncomputable def slitCapacityDriver (p : C(unitInterval,ℂ)) (hi : Injective p)
+    (h0 : p 0=0) (hH : ∀ t : unitInterval, t≠0 → p t∈upperHalfPlane)
+    {T : unitInterval} (hT : T<1) : Target.Driver := by
+  refine ⟨⟨fun t => capacityDriverOnPrefix p hi h0 hH T hT (2*(t:ℝ)),
+    (capacityDriverOnPrefix_continuous p hi h0 hH hT).comp
+      (continuous_const.mul continuous_subtype_val)⟩,?_⟩
+  change initialDrivingValue p hi h0 hH (slitCapacityTime p hi h0 hH T 0)
+    ((slitCapacityTime_le p hi h0 hH T 0).trans_lt hT)=0
+  simp only [slitCapacityTime_zero,initialDrivingValue_zero]
+
+end SLEExactGauge
+
+end
+
+end OAI
diff --git a/lean/OAI/Probability/SLE/Loewner/SlitPhysicalEvolution.lean b/lean/OAI/Probability/SLE/Loewner/SlitPhysicalEvolution.lean
new file mode 100644
index 0000000000000000000000000000000000000000..ab36f312772d5c357e698ececa106ef7cfc2acb4
--- /dev/null
+++ b/lean/OAI/Probability/SLE/Loewner/SlitPhysicalEvolution.lean
@@ -0,0 +1,63 @@
+import OAI.Probability.SLE.Loewner.SlitPhysicalClock
+
+namespace OAI
+
+/-! Exact capacity-two forward and inverse maps on a finite physical prefix. -/
+noncomputable section
+open Set Filter Function Complex
+open scoped Topology NNReal
+
+namespace SLEExactGauge
+
+noncomputable def slitCapacityForward (p : C(unitInterval,ℂ)) (hi : Injective p)
+    (h0 : p 0=0) (hH : ∀ t : unitInterval, t≠0 → p t∈upperHalfPlane)
+    (T : unitInterval) (t : ℝ≥0) : ℂ → ℂ :=
+  initialForwardChart p hi h0 hH (slitCapacityTime p hi h0 hH T t)
+
+noncomputable def slitCapacityInverse (p : C(unitInterval,ℂ)) (hi : Injective p)
+    (h0 : p 0=0) (hH : ∀ t : unitInterval, t≠0 → p t∈upperHalfPlane)
+    (T : unitInterval) (t : ℝ≥0) : ℂ → ℂ :=
+  initialInverseChart p hi h0 hH (slitCapacityTime p hi h0 hH T t)
+
+theorem slitCapacityForward_prefix_derivative (p : C(unitInterval,ℂ)) (hi : Injective p)
+    (h0 : p 0=0) (hH : ∀ t : unitInterval, t≠0 → p t∈upperHalfPlane)
+    {T : unitInterval} (hT : T<1) {z : ℂ}
+    (hz : z∈upperHalfPlane \ range (initialSubarc p T))
+    {t : ℝ≥0} (ht : t ≤ slitCapacityHorizon p hi h0 hH T) :
+    HasDerivWithinAt (fun u : ℝ => slitCapacityForward p hi h0 hH T u.toNNReal z)
+      (2/(slitCapacityForward p hi h0 hH T t z-(slitCapacityDriver p hi h0 hH hT t:ℂ)))
+      (Icc 0 (slitCapacityHorizon p hi h0 hH T:ℝ)) (t:ℝ) := by
+  have ht' : 2*(t:ℝ)∈Icc 0 (initialCapacity p hi h0 hH T) := by
+    constructor
+    · positivity
+    · change (t:ℝ) ≤ initialCapacity p hi h0 hH T/2 at ht
+      linarith
+  have hd := capacityForward_hasDerivWithinAt_prefix p hi h0 hH hT hz ht'
+  have hmul : HasDerivWithinAt (fun u : ℝ => 2*u) 2
+      (Icc 0 (slitCapacityHorizon p hi h0 hH T:ℝ)) (t:ℝ) := by
+    simpa using ((hasDerivAt_id (t:ℝ)).const_mul 2).hasDerivWithinAt
+  have hmaps : MapsTo (fun u : ℝ => 2*u)
+      (Icc 0 (slitCapacityHorizon p hi h0 hH T:ℝ))
+      (Icc 0 (initialCapacity p hi h0 hH T)) := by
+    intro u hu
+    constructor
+    · linarith [hu.1]
+    · have hu2 : u ≤ initialCapacity p hi h0 hH T/2 := hu.2
+      linarith
+  have hh := hd.scomp (t:ℝ) hmul hmaps
+  have he (u : ℝ) (hu : 0 ≤ u) :
+      slitCapacityForward p hi h0 hH T u.toNNReal z=
+        capacityForwardOnPrefix p hi h0 hH T z (2*u) := by
+    simp only [slitCapacityForward,slitCapacityTime,Real.coe_toNNReal u hu,
+      capacityForwardOnPrefix,capacityParameterOnPrefix]
+  have hres := hh.congr (fun u hu => he u hu.1) (he t t.coe_nonneg)
+  convert hres using 1
+  change 2/(capacityForwardOnPrefix p hi h0 hH T z (2*(t:ℝ))-
+    (capacityDriverOnPrefix p hi h0 hH T hT (2*(t:ℝ)):ℂ))=2 • _
+  simp only [real_smul,Complex.ofReal_ofNat,mul_one_div]
+
+end SLEExactGauge
+
+end
+
+end OAI
diff --git a/lean/OAI/Probability/SLE/Loewner/SlitPhysicalTrace.lean b/lean/OAI/Probability/SLE/Loewner/SlitPhysicalTrace.lean
new file mode 100644
index 0000000000000000000000000000000000000000..d657a41e6240ad600f7cd99c4e92c94351973d86
--- /dev/null
+++ b/lean/OAI/Probability/SLE/Loewner/SlitPhysicalTrace.lean
@@ -0,0 +1,74 @@
+import OAI.Probability.SLE.Loewner.SlitPhysicalClock
+import OAI.Probability.SLE.Geometry.FiniteSimpleSlit
+
+namespace OAI
+
+/-! The capacity-two curve has exactly the prescribed initial ranges
+and no additional swallowed points. -/
+noncomputable section
+open Set Filter Function Complex
+open scoped Topology NNReal
+
+namespace SLEExactGauge
+
+noncomputable def slitCapacityCurve (p : C(unitInterval,ℂ)) (hi : Injective p)
+    (h0 : p 0=0) (hH : ∀ t : unitInterval, t≠0 → p t∈upperHalfPlane)
+    (T : unitInterval) (t : ℝ≥0) : ℂ := p (slitCapacityTime p hi h0 hH T t)
+
+lemma slitCapacityCurve_continuous (p : C(unitInterval,ℂ)) (hi : Injective p)
+    (h0 : p 0=0) (hH : ∀ t : unitInterval, t≠0 → p t∈upperHalfPlane)
+    (T : unitInterval) : Continuous (slitCapacityCurve p hi h0 hH T) :=
+  p.continuous.comp (slitCapacityTime_continuous p hi h0 hH T)
+
+@[simp] lemma slitCapacityCurve_zero (p : C(unitInterval,ℂ)) (hi : Injective p)
+    (h0 : p 0=0) (hH : ∀ t : unitInterval, t≠0 → p t∈upperHalfPlane)
+    (T : unitInterval) : slitCapacityCurve p hi h0 hH T 0=0 := by
+  simp only [slitCapacityCurve,slitCapacityTime_zero,h0]
+
+lemma slitCapacityCurve_initial_range (p : C(unitInterval,ℂ)) (hi : Injective p)
+    (h0 : p 0=0) (hH : ∀ t : unitInterval, t≠0 → p t∈upperHalfPlane)
+    (T : unitInterval) {t : ℝ≥0} (ht : t ≤ slitCapacityHorizon p hi h0 hH T) :
+    slitCapacityCurve p hi h0 hH T '' Icc 0 t=
+      range (initialSubarc p (slitCapacityTime p hi h0 hH T t)) := by
+  rw [initialSubarc_range]
+  change (p ∘ slitCapacityTime p hi h0 hH T) '' Icc 0 t=p '' _
+  rw [image_comp,slitCapacityTime_image p hi h0 hH T ht]
+
+lemma slitCapacityCurve_injOn (p : C(unitInterval,ℂ)) (hi : Injective p)
+    (h0 : p 0=0) (hH : ∀ t : unitInterval, t≠0 → p t∈upperHalfPlane)
+    (T : unitInterval) :
+    InjOn (slitCapacityCurve p hi h0 hH T) (Icc 0 (slitCapacityHorizon p hi h0 hH T)) := by
+  intro s hs t ht he
+  have hc := congrArg (initialCapacity p hi h0 hH) (hi he)
+  rw [slitCapacityTime_capacity p hi h0 hH T hs.2,
+    slitCapacityTime_capacity p hi h0 hH T ht.2] at hc
+  apply NNReal.coe_injective
+  linarith
+
+lemma slitCapacityCurve_positive (p : C(unitInterval,ℂ)) (hi : Injective p)
+    (h0 : p 0=0) (hH : ∀ t : unitInterval, t≠0 → p t∈upperHalfPlane)
+    (T : unitInterval) {t : ℝ≥0} (ht : t∈Ioc 0 (slitCapacityHorizon p hi h0 hH T)) :
+    slitCapacityCurve p hi h0 hH T t∈upperHalfPlane := by
+  apply hH
+  intro he
+  have hh := slitCapacityTime_capacity p hi h0 hH T ht.2
+  rw [he,initialCapacity_zero] at hh
+  have hp : (0:ℝ)<t := ht.1
+  linarith
+
+theorem slitCapacityCurve_free_complement (p : C(unitInterval,ℂ)) (hi : Injective p)
+    (h0 : p 0=0) (hH : ∀ t : unitInterval, t≠0 → p t∈upperHalfPlane)
+    (T : unitInterval) {t : ℝ≥0} (ht : t ≤ slitCapacityHorizon p hi h0 hH T)
+    (ht0 : 0<t) :
+    upperHalfPlane \ (slitCapacityCurve p hi h0 hH T '' Icc 0 t) ⊆
+      survivingDomain (slitCapacityCurve p hi h0 hH T) t :=
+  finite_simple_slit_free _ (slitCapacityCurve_continuous p hi h0 hH T)
+    (slitCapacityCurve_zero p hi h0 hH T) t ht0
+    ((slitCapacityCurve_injOn p hi h0 hH T).mono (Icc_subset_Icc_right ht))
+    (fun _u hu => slitCapacityCurve_positive p hi h0 hH T ⟨hu.1,hu.2.trans ht⟩)
+
+end SLEExactGauge
+
+end
+
+end OAI
diff --git a/lean/OAI/Probability/SLE/Loewner/SlitRadialLimits.lean b/lean/OAI/Probability/SLE/Loewner/SlitRadialLimits.lean
new file mode 100644
index 0000000000000000000000000000000000000000..5c0b0a88ec1889af93a5bb13216311be01ba7bfe
--- /dev/null
+++ b/lean/OAI/Probability/SLE/Loewner/SlitRadialLimits.lean
@@ -0,0 +1,60 @@
+import OAI.Probability.SLE.Loewner.SlitExtendedTrace
+
+namespace OAI
+
+/-! Radial inverse limits for the entire extended slit, including the
+joining time and every time in its constant-driver tail. -/
+noncomputable section
+open Set Filter Function Complex
+open scoped Topology NNReal
+
+namespace SLEExactGauge
+
+theorem Target.inverseFlow_radial_constant_tail (b : Driver) (A S : ℝ≥0)
+    (hS : 0<S) (u : ℝ) (hb : ∀ t : ℝ≥0, A ≤ t → b t=u) :
+    Tendsto (fun y : ℝ => inverseFlow 1 b (A+S) ((b (A+S):ℂ)+(y:ℂ)*I))
+      (𝓝[>] (0:ℝ)) (𝓝 (trace 1 b (A+S))) := by
+  have hd : ∀ t∈Icc 0 (S:ℝ), HasDerivWithinAt (driverValue (linearDriver 0)) 0
+      (Icc 0 (S:ℝ)) t := fun t ht => (linearDriver_derivative 0 t ht.1).mono Icc_subset_Ici_self
+  have hl := tendsto_inverseFlow_smooth_trace (linearDriver 0) S (fun _ => 0) hd
+    (show (0:ℝ) ≤ 0 from le_rfl) (fun _ _ => by simp)
+  have hpos := smooth_raw_trace_mem_upperHalfPlane (linearDriver 0) S hS (fun _ => 0) hd
+    (show (0:ℝ) ≤ 0 from le_rfl) (fun _ _ => by simp)
+  have hq : (u:ℂ)+trace 1 (linearDriver 0) S∈upperHalfPlane := by
+    simpa only [upperHalfPlane,mem_ofPred_eq,add_im,ofReal_im,zero_add] using hpos
+  have hc := (continuousOn_inverseFlow 1 (by norm_num) b A).continuousAt
+    (isOpen_upperHalfPlane.mem_nhds hq)
+  rw [trace_constant_tail b A S hS u hb]
+  apply (hc.tendsto.comp (tendsto_const_nhds.add hl)).congr'
+  filter_upwards [self_mem_nhdsWithin] with y hy
+  have he := hb (A+S) (le_add_of_nonneg_right zero_le)
+  have hw : (u:ℂ)+(y:ℂ)*I∈upperHalfPlane := by simpa [upperHalfPlane] using hy
+  rw [he,inverseFlow_constant_tail b A S u hb hw]
+  simp only [linearDriver_apply,zero_mul,ofReal_zero,zero_add,add_sub_cancel_left,Function.comp_def]
+
+theorem slitCapacity_radial_limit (p : C(unitInterval,ℂ)) (hi : Injective p)
+    (h0 : p 0=0) (hH : ∀ t : unitInterval, t≠0 → p t∈upperHalfPlane)
+    {T : unitInterval} (hT : T<1) (t : ℝ≥0) :
+    Tendsto (fun y : ℝ => Target.inverseFlow 1 (slitCapacityDriver p hi h0 hH hT) t
+      ((slitCapacityDriver p hi h0 hH hT t:ℂ)+(y:ℂ)*I)) (𝓝[>] (0:ℝ))
+      (𝓝 (Target.trace 1 (slitCapacityDriver p hi h0 hH hT) t)) := by
+  let A := slitCapacityHorizon p hi h0 hH T
+  by_cases ht : t ≤ A
+  · rw [slitCapacity_raw_trace_eq p hi h0 hH hT ht]
+    have hl := initialInverse_radial_driver_limit p hi h0 hH
+      ((slitCapacityTime_le p hi h0 hH T t).trans_lt hT)
+    apply hl.congr'
+    filter_upwards [self_mem_nhdsWithin] with y hy
+    rw [slitCapacityInverse_eq_raw p hi h0 hH hT ht (by simpa [upperHalfPlane] using hy)]
+    rfl
+  · have hAt : A<t := lt_of_not_ge ht
+    have hh := Target.inverseFlow_radial_constant_tail (slitCapacityDriver p hi h0 hH hT)
+      A (t-A) (tsub_pos_iff_lt.mpr hAt) (initialDrivingValue p hi h0 hH T hT)
+      (fun s hs => slitCapacityDriver_after p hi h0 hH hT hs)
+    simpa only [←NNReal.coe_add,add_tsub_cancel_of_le hAt.le] using hh
+
+end SLEExactGauge
+
+end
+
+end OAI
diff --git a/lean/OAI/Probability/SLE/Loewner/SlitRawCapacity.lean b/lean/OAI/Probability/SLE/Loewner/SlitRawCapacity.lean
new file mode 100644
index 0000000000000000000000000000000000000000..558f8b909e771cd3b0d09c4c0919594b6a409df1
--- /dev/null
+++ b/lean/OAI/Probability/SLE/Loewner/SlitRawCapacity.lean
@@ -0,0 +1,67 @@
+import OAI.Probability.SLE.Loewner.SlitTailDomain
+import OAI.Probability.SLE.Loewner.RawForwardInfinity
+
+namespace OAI
+
+/-! Every prescribed simple arc prefix, extended by a vertical image,
+has an actual global capacity-two witness with its exact raw maps. -/
+noncomputable section
+open Set Filter _root_.MeasureTheory _root_.OAI.MeasureTheory ProbabilityTheory
+open scoped Topology NNReal
+
+namespace SLEExactGauge
+
+theorem RegularSLEPresentation.slit_raw_capacity_witness
+    {Ω : Type*} [MeasurableSpace Ω] {P : Measure Ω} [IsProbabilityMeasure P]
+    {κ : ℝ} {γ : Ω → ℝ≥0 → ℂ} (a : RegularSLEPresentation P κ γ) (hκ : 0<κ)
+    (p : C(unitInterval,ℂ)) (hi : Function.Injective p) (h0 : p 0=0)
+    (hH : ∀ t : unitInterval, t≠0 → p t∈upperHalfPlane)
+    {T : unitInterval} (hT0 : 0<T) (hT : T<1) :
+    let b := slitCapacityDriver p hi h0 hH hT
+    IsCapacityTwoWitness b (fun s : ℝ≥0 => Target.trace 1 b s)
+      (fun t z => Target.flow 1 b z t) (fun t => Target.inverseFlow 1 b t) := by
+  dsimp only
+  let b := slitCapacityDriver p hi h0 hH hT
+  have hdom := a.slitCapacity_raw_domains hκ p hi h0 hH hT0 hT
+  obtain ⟨hc,hz,_,hpos,_⟩ := a.slitCapacity_raw_geometry hκ p hi h0 hH hT0 hT
+  refine ⟨hc,hz,?_,?_,a.raw_inverse_holomorphic hκ b,?_,?_,?_,?_,?_,?_,?_,?_⟩
+  · intro t
+    by_cases ht : 0<t
+    · exact (show 0<(Target.trace 1 b t).im from hpos t ht).le
+    · have he : t=0 := le_antisymm (le_of_not_gt ht) zero_le
+      rw [he,hz]
+      exact le_rfl
+  · intro t
+    rw [←hdom t]
+    exact a.raw_forward_holomorphic hκ b t
+  · intro t z hz
+    exact Target.surviving_flow_mem_upperHalfPlane 1 b z t t.coe_nonneg
+      (by simpa only [←hdom t,Set.mem_ofPred_eq] using hz)
+  · intro t z hz
+    rw [←hdom t]
+    exact Target.inverseFlow_surviving 1 (by norm_num) b t z hz
+  · intro t z hz
+    exact Target.inverseFlow_eq_of_surviving 1 b t t.coe_nonneg z _
+      (by simpa only [←hdom t,Set.mem_ofPred_eq] using hz) rfl
+  · intro t z hz
+    exact Target.flow_inverseFlow 1 (by norm_num) b t z hz
+  · intro z hz
+    exact Target.flow_zero 1 b z hz
+  · intro t z hz
+    have hs : Target.Surviving 1 b z t := by simpa only [←hdom t,Set.mem_ofPred_eq] using hz
+    have hd := Target.flow_hasDerivWithinAt_of_survival b z t.coe_nonneg hs
+    have he : (fun u : ℝ => Target.flow 1 b z (u.toNNReal:ℝ))
+        =ᶠ[𝓝[Ici 0] (t:ℝ)] Target.flow 1 b z := by
+      filter_upwards [self_mem_nhdsWithin] with u hu
+      rw [Real.coe_toNNReal u hu]
+    have hh := hd.congr_of_eventuallyEq he (by simp)
+    simpa [Target.driverValue] using hh
+  · intro t
+    simpa only [b,hdom t] using Target.flow_hydrodynamic_normalization b t
+  · exact slitCapacity_radial_limit p hi h0 hH hT
+
+end SLEExactGauge
+
+end
+
+end OAI
diff --git a/lean/OAI/Probability/SLE/Loewner/SlitRawForward.lean b/lean/OAI/Probability/SLE/Loewner/SlitRawForward.lean
new file mode 100644
index 0000000000000000000000000000000000000000..757b21496e8efc47c1289eaaead4329c79a4a511
--- /dev/null
+++ b/lean/OAI/Probability/SLE/Loewner/SlitRawForward.lean
@@ -0,0 +1,50 @@
+import OAI.Probability.SLE.Loewner.SlitInitialEvolution
+import OAI.Probability.SLE.Angle.TargetPositiveFlow
+
+namespace OAI
+
+/-! The raw positive Loewner trajectory agrees exactly with the
+constructed conformal slit evolution on every surviving prefix. -/
+noncomputable section
+open Set Filter Function Complex Metric
+open scoped Topology NNReal
+
+namespace SLEExactGauge
+
+theorem slitCapacityForward_eq_raw (p : C(unitInterval,ℂ)) (hi : Injective p)
+    (h0 : p 0=0) (hH : ∀ t : unitInterval, t≠0 → p t∈upperHalfPlane)
+    {T : unitInterval} (hT : T<1) {t : ℝ≥0}
+    (ht : t ≤ slitCapacityHorizon p hi h0 hH T) {z : ℂ}
+    (hz : z∈upperHalfPlane \ range (initialSubarc p (slitCapacityTime p hi h0 hH T t))) :
+    Target.Surviving 1 (slitCapacityDriver p hi h0 hH hT) z t ∧
+      Target.flow 1 (slitCapacityDriver p hi h0 hH hT) z t=
+        slitCapacityForward p hi h0 hH T t z := by
+  let Y := fun u : ℝ => slitCapacityForward p hi h0 hH T u.toNNReal z
+  have hd := fun u (hu : u∈Icc 0 (t:ℝ)) =>
+    slitCapacityForward_derivative_upto p hi h0 hH hT ht hz hu
+  have hc : ContinuousOn Y (Icc 0 (t:ℝ)) := fun u hu => (hd u hu).continuousWithinAt
+  have hpos (u : ℝ) (hu : u∈Icc 0 (t:ℝ)) : 0<(Y u).im := by
+    have hu' : u.toNNReal ≤ t := Real.toNNReal_le_iff_le_coe.mpr hu.2
+    have hclock : slitCapacityTime p hi h0 hH T u.toNNReal ≤ slitCapacityTime p hi h0 hH T t := by
+      apply (initialCapacity_strictMono p hi h0 hH).le_iff_le.mp
+      rw [slitCapacityTime_capacity p hi h0 hH T (hu'.trans ht),
+        slitCapacityTime_capacity p hi h0 hH T ht,Real.coe_toNNReal u hu.1]
+      linarith [hu.2]
+    exact initialForwardChart_im_pos p hi h0 hH _
+      ⟨hz.1,fun he => hz.2 (initialSubarc_range_mono p hclock he)⟩
+  obtain ⟨v,hv,hmin⟩ := isCompact_Icc.exists_isMinOn (nonempty_Icc.mpr t.coe_nonneg)
+    (Complex.continuous_im.comp_continuousOn hc)
+  have hY0 : Y 0=z := by
+    simp only [Y,Real.toNNReal_zero,slitCapacityForward,slitCapacityTime_zero,
+      initialForwardChart_zero,id_eq]
+  have hh := Target.flow_eq_of_positive_trajectory 1 (slitCapacityDriver p hi h0 hH hT) z t
+    t.coe_nonneg Y hc hY0 (Y v).im (hpos v hv) (fun u hu => hmin hu) (fun u hu => ?_)
+  · simpa only [Y,Real.toNNReal_coe] using hh
+  · have he := hasDerivWithinAt_Ici_of_Icc hu (hd u (Ico_subset_Icc_self hu))
+    simpa only [Target.a,div_one,ofReal_ofNat,Target.driverValue,Y] using he
+
+end SLEExactGauge
+
+end
+
+end OAI
diff --git a/lean/OAI/Probability/SLE/Loewner/SlitRawInverse.lean b/lean/OAI/Probability/SLE/Loewner/SlitRawInverse.lean
new file mode 100644
index 0000000000000000000000000000000000000000..fe342309c6818875809f2106fbca7544d4b5ed06
--- /dev/null
+++ b/lean/OAI/Probability/SLE/Loewner/SlitRawInverse.lean
@@ -0,0 +1,46 @@
+import OAI.Probability.SLE.Loewner.SlitRawForward
+import OAI.Probability.SLE.Loewner.TargetInverseProperties
+
+namespace OAI
+
+/-! Exact raw inverse and surviving set for the constructed finite slit. -/
+noncomputable section
+open Set Filter Function Complex
+open scoped Topology NNReal
+
+namespace SLEExactGauge
+
+theorem slitCapacityInverse_eq_raw (p : C(unitInterval,ℂ)) (hi : Injective p)
+    (h0 : p 0=0) (hH : ∀ t : unitInterval, t≠0 → p t∈upperHalfPlane)
+    {T : unitInterval} (hT : T<1) {t : ℝ≥0}
+    (ht : t ≤ slitCapacityHorizon p hi h0 hH T) {w : ℂ} (hw : w∈upperHalfPlane) :
+    Target.inverseFlow 1 (slitCapacityDriver p hi h0 hH hT) t w=
+      slitCapacityInverse p hi h0 hH T t w := by
+  have hz := initialInverseChart_mem_domain p hi h0 hH (slitCapacityTime p hi h0 hH T t) hw
+  obtain ⟨hs,he⟩ := slitCapacityForward_eq_raw p hi h0 hH hT ht hz
+  apply Target.inverseFlow_eq_of_surviving 1 _ t t.coe_nonneg _ w hs
+  exact he.trans (initialForward_inverse p hi h0 hH _ hw)
+
+theorem slitCapacity_surviving_eq (p : C(unitInterval,ℂ)) (hi : Injective p)
+    (h0 : p 0=0) (hH : ∀ t : unitInterval, t≠0 → p t∈upperHalfPlane)
+    {T : unitInterval} (hT : T<1) {t : ℝ≥0}
+    (ht : t ≤ slitCapacityHorizon p hi h0 hH T) :
+    {z | Target.Surviving 1 (slitCapacityDriver p hi h0 hH hT) z t}=
+      upperHalfPlane \ range (initialSubarc p (slitCapacityTime p hi h0 hH T t)) := by
+  ext z
+  constructor
+  · intro hz
+    have hw := Target.surviving_flow_mem_upperHalfPlane 1 _ z t t.coe_nonneg hz
+    have he := Target.inverseFlow_eq_of_surviving 1 (slitCapacityDriver p hi h0 hH hT)
+      t t.coe_nonneg z _ hz rfl
+    rw [slitCapacityInverse_eq_raw p hi h0 hH hT ht hw] at he
+    rw [← he]
+    exact initialInverseChart_mem_domain p hi h0 hH _ hw
+  · intro hz
+    exact (slitCapacityForward_eq_raw p hi h0 hH hT ht hz).1
+
+end SLEExactGauge
+
+end
+
+end OAI
diff --git a/lean/OAI/Probability/SLE/Loewner/SlitRawTrace.lean b/lean/OAI/Probability/SLE/Loewner/SlitRawTrace.lean
new file mode 100644
index 0000000000000000000000000000000000000000..cb961f78fd8f9ee473c55a043bb24ba4a99a4688
--- /dev/null
+++ b/lean/OAI/Probability/SLE/Loewner/SlitRawTrace.lean
@@ -0,0 +1,39 @@
+import OAI.Probability.SLE.Loewner.SlitRawInverse
+import OAI.Probability.SLE.Loewner.SlitPhysicalTrace
+
+namespace OAI
+
+/-! The exact raw trace of the continuous based driver is the prescribed
+simple slit throughout its capacity-two prefix. -/
+noncomputable section
+open Set Filter Function Complex
+open scoped Topology NNReal
+
+namespace SLEExactGauge
+
+theorem slitCapacity_raw_trace_eq (p : C(unitInterval,ℂ)) (hi : Injective p)
+    (h0 : p 0=0) (hH : ∀ t : unitInterval, t≠0 → p t∈upperHalfPlane)
+    {T : unitInterval} (hT : T<1) {t : ℝ≥0}
+    (ht : t ≤ slitCapacityHorizon p hi h0 hH T) :
+    Target.trace 1 (slitCapacityDriver p hi h0 hH hT) t=
+      slitCapacityCurve p hi h0 hH T t := by
+  let s := slitCapacityTime p hi h0 hH T t
+  have hs : s<1 := (slitCapacityTime_le p hi h0 hH T t).trans_lt hT
+  have htip := initialInverse_radial_driver_limit p hi h0 hH hs
+  have he : slitCapacityDriver p hi h0 hH hT t=initialDrivingValue p hi h0 hH s hs := rfl
+  have hr : Tendsto (fun y : ℝ => Target.inverseFlow 1 (slitCapacityDriver p hi h0 hH hT) t
+      ((slitCapacityDriver p hi h0 hH hT t:ℂ)+(y:ℂ)*I)) (𝓝[>] (0:ℝ)) (𝓝 (p s)) := by
+    apply htip.congr'
+    filter_upwards [self_mem_nhdsWithin] with y hy
+    have hw : (slitCapacityDriver p hi h0 hH hT t:ℂ)+(y:ℂ)*I∈upperHalfPlane := by
+      simpa [upperHalfPlane] using hy
+    rw [slitCapacityInverse_eq_raw p hi h0 hH hT ht hw]
+    rfl
+  simpa only [Target.trace,one_mul,Target.driverValue,Real.toNNReal_coe,slitCapacityCurve,s] using
+    hr.limUnder_eq
+
+end SLEExactGauge
+
+end
+
+end OAI
diff --git a/lean/OAI/Probability/SLE/Loewner/SlitRealBoundaryFlow.lean b/lean/OAI/Probability/SLE/Loewner/SlitRealBoundaryFlow.lean
new file mode 100644
index 0000000000000000000000000000000000000000..e047d5ee21941cb5d81d6a0a6feb6dbd0e10bd03
--- /dev/null
+++ b/lean/OAI/Probability/SLE/Loewner/SlitRealBoundaryFlow.lean
@@ -0,0 +1,77 @@
+import OAI.Probability.SLE.Geometry.ReflectedRealSeparation
+import OAI.Probability.SLE.Loewner.SlitPhysicalClock
+
+namespace OAI
+
+/-! The exact capacity-clock real boundary coordinates are continuous,
+real valued and uniformly separated from the driver on a finite prefix. -/
+noncomputable section
+open Set Filter Function Complex Metric
+open scoped Topology NNReal
+
+namespace SLEExactGauge
+
+noncomputable def slitReflectedFlow (p : C(unitInterval,ℂ)) (hi : Injective p)
+    (h0 : p 0=0) (hH : ∀ t : unitInterval, t≠0 → p t∈upperHalfPlane)
+    (T : unitInterval) (z : ℂ) (t : ℝ) : ℂ :=
+  initialReflectedForward p hi h0 hH (slitCapacityTime p hi h0 hH T t.toNNReal) z
+
+lemma slitReflectedFlow_real_continuous (p : C(unitInterval,ℂ)) (hi : Injective p)
+    (h0 : p 0=0) (hH : ∀ t : unitInterval, t≠0 → p t∈upperHalfPlane)
+    (T : unitInterval) {x : ℝ} (hx : x≠0) :
+    Continuous (slitReflectedFlow p hi h0 hH T (x:ℂ)) :=
+  (initialReflectedForward_real_continuous p hi h0 hH hx).comp
+    ((slitCapacityTime_continuous p hi h0 hH T).comp continuous_real_toNNReal)
+
+lemma slitReflectedFlow_real (p : C(unitInterval,ℂ)) (hi : Injective p)
+    (h0 : p 0=0) (hH : ∀ t : unitInterval, t≠0 → p t∈upperHalfPlane)
+    (T : unitInterval) {x : ℝ} (hx : x≠0) (t : ℝ) :
+    (slitReflectedFlow p hi h0 hH T (x:ℂ) t).im=0 :=
+  initialReflectedForward_real p hi h0 hH _ hx
+
+lemma slitReflectedFlow_separated (p : C(unitInterval,ℂ)) (hi : Injective p)
+    (h0 : p 0=0) (hH : ∀ t : unitInterval, t≠0 → p t∈upperHalfPlane)
+    {T : unitInterval} (hT : T<1) {x : ℝ} (hx : x≠0) (t : ℝ) :
+    slitReflectedFlow p hi h0 hH T (x:ℂ) t-
+      (slitCapacityDriver p hi h0 hH hT t.toNNReal:ℂ)≠0 := by
+  apply sub_ne_zero.mpr
+  exact initialReflectedForward_ne_driver p hi h0 hH
+    ((slitCapacityTime_le p hi h0 hH T t.toNNReal).trans_lt hT) hx
+
+theorem slitReflectedFlow_uniform_limit (p : C(unitInterval,ℂ)) (hi : Injective p)
+    (h0 : p 0=0) (hH : ∀ t : unitInterval, t≠0 → p t∈upperHalfPlane)
+    (T : unitInterval) {x : ℝ} (hx : x≠0) :
+    TendstoUniformly (fun y : ℝ => slitReflectedFlow p hi h0 hH T ((x:ℂ)+(y:ℂ)*I))
+      (slitReflectedFlow p hi h0 hH T (x:ℂ)) (𝓝[>] (0:ℝ)) := by
+  have hv : Tendsto (fun y : ℝ => (x:ℂ)+(y:ℂ)*I) (𝓝[>] (0:ℝ)) (𝓝 (x:ℂ)) := by
+    have hc : Continuous (fun y : ℝ => (x:ℂ)+(y:ℂ)*I) := by fun_prop
+    simpa only [ofReal_zero,zero_mul,add_zero] using
+      (hc.tendsto 0).mono_left nhdsWithin_le_nhds
+  apply Metric.tendstoUniformly_iff.mpr
+  intro ε hε
+  have he := Metric.equicontinuousAt_iff_right.mp
+    (initialReflectedForward_equicontinuousAt_real p hi h0 hH hx) ε hε
+  filter_upwards [hv.eventually he] with y hy t
+  exact hy (slitCapacityTime p hi h0 hH T t.toNNReal)
+
+lemma slitReflectedFlow_positive_gap (p : C(unitInterval,ℂ)) (hi : Injective p)
+    (h0 : p 0=0) (hH : ∀ t : unitInterval, t≠0 → p t∈upperHalfPlane)
+    {T : unitInterval} (hT : T<1) {x : ℝ} (hx : x≠0) :
+    ∃ m : ℝ, 0 < m ∧ ∀ t∈Icc 0 (slitCapacityHorizon p hi h0 hH T:ℝ),
+      m ≤ ‖slitReflectedFlow p hi h0 hH T (x:ℂ) t-
+        (slitCapacityDriver p hi h0 hH hT t.toNNReal:ℂ)‖ := by
+  have hc : Continuous (fun t : ℝ => ‖slitReflectedFlow p hi h0 hH T (x:ℂ) t-
+      (slitCapacityDriver p hi h0 hH hT t.toNNReal:ℂ)‖) :=
+    ((slitReflectedFlow_real_continuous p hi h0 hH T hx).sub
+      (Complex.continuous_ofReal.comp
+        ((slitCapacityDriver p hi h0 hH hT).continuous.comp continuous_real_toNNReal))).norm
+  obtain ⟨t,ht,hmin⟩ := isCompact_Icc.exists_isMinOn
+    (nonempty_Icc.mpr (slitCapacityHorizon p hi h0 hH T).coe_nonneg) hc.continuousOn
+  exact ⟨_,norm_pos_iff.mpr (slitReflectedFlow_separated p hi h0 hH hT hx t),
+    fun u hu => hmin hu⟩
+
+end SLEExactGauge
+
+end
+
+end OAI
diff --git a/lean/OAI/Probability/SLE/Loewner/SlitRealCharacteristics.lean b/lean/OAI/Probability/SLE/Loewner/SlitRealCharacteristics.lean
new file mode 100644
index 0000000000000000000000000000000000000000..acd5cdfc8e4d4220f33f76b74c90c8a40640e890
--- /dev/null
+++ b/lean/OAI/Probability/SLE/Loewner/SlitRealCharacteristics.lean
@@ -0,0 +1,65 @@
+import OAI.Probability.SLE.Loewner.SlitBoundaryIntegralLimit
+import OAI.Probability.SLE.Geometry.RegularSlitTube
+
+namespace OAI
+
+/-! The exact driver of a prescribed simple slit has noncolliding real
+Loewner characteristics throughout every finite capacity prefix. -/
+noncomputable section
+open Set Filter Function Complex _root_.MeasureTheory _root_.OAI.MeasureTheory
+open scoped Topology NNReal
+
+namespace SLEExactGauge
+
+theorem slit_regularRealCharacteristics (p : C(unitInterval,ℂ)) (hi : Injective p)
+    (h0 : p 0=0) (hH : ∀ t : unitInterval, t≠0 → p t∈upperHalfPlane)
+    {T : unitInterval} (hT : T<1) :
+    RegularRealCharacteristics (slitCapacityDriver p hi h0 hH hT)
+      (slitCapacityHorizon p hi h0 hH T) := by
+  intro x hx
+  let X := slitReflectedFlow p hi h0 hH T (x:ℂ)
+  let q := fun t : ℝ => (X t).re
+  let b := slitCapacityDriver p hi h0 hH hT
+  let A := slitCapacityHorizon p hi h0 hH T
+  have hX (t : ℝ) : X t=(q t:ℂ) := by
+    apply Complex.ext
+    · rfl
+    · simpa only [ofReal_im] using slitReflectedFlow_real p hi h0 hH T hx t
+  have hX0 : X 0=(x:ℂ) := by
+    dsimp [X,slitReflectedFlow]
+    simp [slitCapacityTime_zero,initialReflectedForward]
+  have hqgap (t : ℝ) : q t-b t.toNNReal≠0 := by
+    intro he
+    have hh := slitReflectedFlow_separated p hi h0 hH hT hx t
+    change X t-(b t.toNNReal:ℂ)≠0 at hh
+    rw [hX] at hh
+    apply hh
+    exact_mod_cast he
+  refine ⟨q,?_,?_,fun t _ => hqgap t⟩
+  · change (X 0).re=x
+    rw [hX0,ofReal_re]
+  · intro t ht
+    let k := fun u : ℝ => 2/(X u-(b u.toNNReal:ℂ))
+    have hk : Continuous k := slitReflectedFlow_real_kernel_continuous p hi h0 hH hT hx
+    have hI : HasDerivAt (fun u => (x:ℂ)+∫ v in 0..u, k v) (k t) t := by
+      simpa only [zero_add] using (intervalIntegral.integral_hasDerivAt_right
+        (hk.intervalIntegrable 0 t) hk.aestronglyMeasurable.stronglyMeasurableAtFilter
+        hk.continuousAt).const_add (x:ℂ)
+    have hXd : HasDerivWithinAt X (k t) (Icc 0 (A:ℝ)) t := by
+      apply hI.hasDerivWithinAt.congr_of_mem (fun u hu => ?_) ht
+      rw [slitReflectedFlow_boundary_integral p hi h0 hH hT hx hu]
+      dsimp only [X]
+      abel
+    have hqd := Complex.reCLM.hasFDerivAt.comp_hasDerivWithinAt t hXd
+    change HasDerivWithinAt q (k t).re (Icc 0 (A:ℝ)) t at hqd
+    have he : (k t).re=2/(q t-b t.toNNReal) := by
+      dsimp only [k]
+      rw [hX]
+      norm_cast
+    rwa [he] at hqd
+
+end SLEExactGauge
+
+end
+
+end OAI
diff --git a/lean/OAI/Probability/SLE/Loewner/SlitReciprocalChart.lean b/lean/OAI/Probability/SLE/Loewner/SlitReciprocalChart.lean
new file mode 100644
index 0000000000000000000000000000000000000000..1480d1f61fdb551af161d3e1c702b09ea77f3b01
--- /dev/null
+++ b/lean/OAI/Probability/SLE/Loewner/SlitReciprocalChart.lean
@@ -0,0 +1,80 @@
+import OAI.Probability.SLE.Loewner.SlitHydrodynamicChart
+import Mathlib.Analysis.Calculus.InverseFunctionTheorem.Analytic
+
+namespace OAI
+
+/-! In reciprocal coordinates the hydrodynamic chart is analytic across
+infinity and has derivative one. -/
+noncomputable section
+open Set Filter Complex Function Metric
+open scoped Topology ComplexConjugate
+
+namespace SLEExactGauge
+
+def slitReciprocalMap (f : ℂ → ℂ) (a : ℝ) (w : ℂ) : ℂ :=
+  w/(slitInfinityFactor f a w-deriv (slitInfinityFactor f a) 0*w)
+
+@[simp] lemma slitReciprocalMap_zero (f : ℂ → ℂ) (a : ℝ) :
+    slitReciprocalMap f a 0=0 := by simp [slitReciprocalMap]
+
+lemma slitReciprocalMap_analyticAt {f : ℂ → ℂ} {a : ℝ}
+    (hf : AnalyticAt ℂ f 0) (ha : a ≠ 0) (hd : deriv f 0=(a:ℂ)) :
+    AnalyticAt ℂ (slitReciprocalMap f a) 0 := by
+  apply analyticAt_id.div
+    ((slitInfinityFactor_analyticAt hf ha hd).sub (analyticAt_const.mul analyticAt_id))
+  change slitInfinityFactor f a 0-deriv (slitInfinityFactor f a) 0*0 ≠ 0
+  simp only [mul_zero,sub_zero,slitInfinityFactor_zero ha hd,ne_eq,one_ne_zero,not_false_eq_true]
+
+lemma slitReciprocalMap_deriv {f : ℂ → ℂ} {a : ℝ}
+    (hf : AnalyticAt ℂ f 0) (ha : a ≠ 0) (hd : deriv f 0=(a:ℂ)) :
+    deriv (slitReciprocalMap f a) 0=1 := by
+  have hh := ((hasDerivAt_id (0:ℂ)).div
+    (((slitInfinityFactor_analyticAt hf ha hd).differentiableAt.hasDerivAt).sub
+      ((hasDerivAt_id (0:ℂ)).const_mul (deriv (slitInfinityFactor f a) 0))) (by
+        change slitInfinityFactor f a 0-deriv (slitInfinityFactor f a) 0*0 ≠ 0
+        simp only [mul_zero,sub_zero,slitInfinityFactor_zero ha hd,ne_eq,one_ne_zero,
+          not_false_eq_true]))
+  convert! hh.deriv using 1
+  simp only [Pi.sub_apply,id_eq,mul_zero,sub_zero,
+      slitInfinityFactor_zero ha hd,zero_mul,one_pow,div_one,one_mul]
+
+lemma slitReciprocalMap_identity {f : ℂ → ℂ} (hf0 : f 0=0) (a : ℝ)
+    {z : ℂ} (hz : z ≠ 0) :
+    (slitReciprocalMap f a z⁻¹)⁻¹=slitHydrodynamicMap f a z := by
+  rw [slitReciprocalMap,inv_div,div_eq_mul_inv,inv_inv,sub_mul,mul_comm _ z,
+    slitInfinityFactor_identity hf0 a hz]
+  simp only [slitHydrodynamicMap]
+  rw [mul_assoc,inv_mul_cancel₀ hz,mul_one]
+
+lemma slitReciprocalMap_reflection {D : Set ℂ} (hD : D ∈ 𝓝 (0:ℂ))
+    {f : ℂ → ℂ} (hs : ∀ z ∈ D, f (conj z)=conj (f z)) (a : ℝ) :
+    ∀ z ∈ D, slitReciprocalMap f a (conj z)=conj (slitReciprocalMap f a z) := by
+  have hH := slitInfinityFactor_reflection hD hs a
+  have hd := derivative_real_of_reflection hD hH
+  intro z hz
+  simp only [slitReciprocalMap,hH z hz,map_div₀,map_sub,map_mul,hd]
+
+theorem slitReciprocalMap_exists_local_inverse {f : ℂ → ℂ} {a : ℝ}
+    (hf : AnalyticAt ℂ f 0) (ha : a ≠ 0) (hd : deriv f 0=(a:ℂ)) :
+    ∃ r : ℂ → ℂ, AnalyticAt ℂ r 0 ∧ r 0=0 ∧ deriv r 0=1 ∧
+      (∀ᶠ z in 𝓝 (0:ℂ), r (slitReciprocalMap f a z)=z) ∧
+      (∀ᶠ z in 𝓝 (0:ℂ), slitReciprocalMap f a (r z)=z) := by
+  have hq := slitReciprocalMap_analyticAt hf ha hd
+  have hqd := slitReciprocalMap_deriv hf ha hd
+  have hn : deriv (slitReciprocalMap f a) 0 ≠ 0 := by rw [hqd]; exact one_ne_zero
+  let r := hq.hasStrictDerivAt.localInverse _ _ _ hn
+  have hr := hq.analyticAt_localInverse hn
+  have hzero := (hq.hasStrictDerivAt.eventually_left_inverse hn).self_of_nhds
+  have hrd := hq.hasStrictDerivAt.to_localInverse hn
+  refine ⟨r,?_,?_,?_,?_,?_⟩
+  · simpa only [slitReciprocalMap_zero] using hr
+  · simpa only [slitReciprocalMap_zero] using hzero
+  · simpa only [slitReciprocalMap_zero,hqd,inv_one] using hrd.hasDerivAt.deriv
+  · exact hq.hasStrictDerivAt.eventually_left_inverse hn
+  · simpa only [slitReciprocalMap_zero] using hq.hasStrictDerivAt.eventually_right_inverse hn
+
+end SLEExactGauge
+
+end
+
+end OAI
diff --git a/lean/OAI/Probability/SLE/Loewner/SlitReflectedInterior.lean b/lean/OAI/Probability/SLE/Loewner/SlitReflectedInterior.lean
new file mode 100644
index 0000000000000000000000000000000000000000..de6ab449524b9da78e58019a79b3d2f8f5d61363
--- /dev/null
+++ b/lean/OAI/Probability/SLE/Loewner/SlitReflectedInterior.lean
@@ -0,0 +1,102 @@
+import OAI.Probability.SLE.Loewner.SlitRealBoundaryFlow
+import OAI.Probability.SLE.Loewner.SlitPhysicalEvolution
+
+namespace OAI
+
+/-! On surviving interior points the reflected coordinates obey the
+exact physical-time Loewner equation and its integral identity. -/
+noncomputable section
+open Set Filter Function Complex MeasureTheory
+open scoped Topology NNReal
+
+namespace SLEExactGauge
+
+lemma slitReflectedFlow_eq_forward (p : C(unitInterval,ℂ)) (hi : Injective p)
+    (h0 : p 0=0) (hH : ∀ t : unitInterval, t≠0 → p t∈upperHalfPlane)
+    (T : unitInterval) {z : ℂ} (hz : z∈upperHalfPlane \ range p) (t : ℝ) :
+    slitReflectedFlow p hi h0 hH T z t=slitCapacityForward p hi h0 hH T t.toNNReal z :=
+  initialReflectedForward_eq p hi h0 hH _
+    ⟨hz.1,fun he => hz.2 (initialSubarc_range_subset p _ he)⟩
+
+lemma slitReflectedFlow_interior_continuous (p : C(unitInterval,ℂ)) (hi : Injective p)
+    (h0 : p 0=0) (hH : ∀ t : unitInterval, t≠0 → p t∈upperHalfPlane)
+    (T : unitInterval) {z : ℂ} (hz : z∈upperHalfPlane \ range p) :
+    Continuous (slitReflectedFlow p hi h0 hH T z) := by
+  have hzD (s : unitInterval) : z∈upperHalfPlane \ range (initialSubarc p s) :=
+    ⟨hz.1,fun he => hz.2 (initialSubarc_range_subset p s he)⟩
+  have hc : Continuous (fun s => initialForwardChart p hi h0 hH s z) := by
+    apply SeqContinuous.continuous
+    intro s t hs
+    exact initialForwardChart_tendsto p hi h0 hH hs tendsto_const_nhds (hzD t) (fun n => hzD (s n))
+  have he : slitReflectedFlow p hi h0 hH T z=
+      fun t => initialForwardChart p hi h0 hH (slitCapacityTime p hi h0 hH T t.toNNReal) z :=
+    funext (slitReflectedFlow_eq_forward p hi h0 hH T hz)
+  rw [he]
+  exact hc.comp ((slitCapacityTime_continuous p hi h0 hH T).comp continuous_real_toNNReal)
+
+lemma slitReflectedFlow_interior_separated (p : C(unitInterval,ℂ)) (hi : Injective p)
+    (h0 : p 0=0) (hH : ∀ t : unitInterval, t≠0 → p t∈upperHalfPlane)
+    {T : unitInterval} (hT : T<1) {z : ℂ} (hz : z∈upperHalfPlane \ range p) (t : ℝ) :
+    slitReflectedFlow p hi h0 hH T z t-(slitCapacityDriver p hi h0 hH hT t.toNNReal:ℂ)≠0 := by
+  have hp := initialForwardChart_mem_upper p hi h0 hH (slitCapacityTime p hi h0 hH T t.toNNReal)
+    ⟨hz.1,fun he => hz.2 (initialSubarc_range_subset p _ he)⟩
+  rw [slitReflectedFlow_eq_forward p hi h0 hH T hz]
+  intro he
+  have hh := congrArg Complex.im he
+  simp only [sub_im,ofReal_im,sub_zero,zero_im] at hh
+  exact (show 0<(slitCapacityForward p hi h0 hH T t.toNNReal z).im from hp).ne' hh
+
+lemma slitReflectedFlow_interior_kernel_continuous (p : C(unitInterval,ℂ)) (hi : Injective p)
+    (h0 : p 0=0) (hH : ∀ t : unitInterval, t≠0 → p t∈upperHalfPlane)
+    {T : unitInterval} (hT : T<1) {z : ℂ} (hz : z∈upperHalfPlane \ range p) :
+    Continuous (fun t : ℝ => 2/(slitReflectedFlow p hi h0 hH T z t-
+      (slitCapacityDriver p hi h0 hH hT t.toNNReal:ℂ))) :=
+  continuous_const.div ((slitReflectedFlow_interior_continuous p hi h0 hH T hz).sub
+    (Complex.continuous_ofReal.comp
+      ((slitCapacityDriver p hi h0 hH hT).continuous.comp continuous_real_toNNReal)))
+    (slitReflectedFlow_interior_separated p hi h0 hH hT hz)
+
+theorem slitReflectedFlow_interior_derivative (p : C(unitInterval,ℂ)) (hi : Injective p)
+    (h0 : p 0=0) (hH : ∀ t : unitInterval, t≠0 → p t∈upperHalfPlane)
+    {T : unitInterval} (hT : T<1) {z : ℂ} (hz : z∈upperHalfPlane \ range p)
+    {t : ℝ} (ht : t∈Icc 0 (slitCapacityHorizon p hi h0 hH T:ℝ)) :
+    HasDerivWithinAt (slitReflectedFlow p hi h0 hH T z)
+      (2/(slitReflectedFlow p hi h0 hH T z t-
+        (slitCapacityDriver p hi h0 hH hT t.toNNReal:ℂ)))
+      (Icc 0 (slitCapacityHorizon p hi h0 hH T:ℝ)) t := by
+  have hu : t.toNNReal ≤ slitCapacityHorizon p hi h0 hH T := Real.toNNReal_le_iff_le_coe.mpr ht.2
+  have hh := slitCapacityForward_prefix_derivative p hi h0 hH hT
+    ⟨hz.1,fun he => hz.2 (initialSubarc_range_subset p T he)⟩ hu
+  rw [Real.coe_toNNReal t ht.1] at hh
+  have he : slitReflectedFlow p hi h0 hH T z=
+      fun u => slitCapacityForward p hi h0 hH T u.toNNReal z :=
+    funext (slitReflectedFlow_eq_forward p hi h0 hH T hz)
+  simpa only [he] using hh
+
+theorem slitReflectedFlow_interior_integral (p : C(unitInterval,ℂ)) (hi : Injective p)
+    (h0 : p 0=0) (hH : ∀ t : unitInterval, t≠0 → p t∈upperHalfPlane)
+    {T : unitInterval} (hT : T<1) {z : ℂ} (hz : z∈upperHalfPlane \ range p)
+    {t : ℝ} (ht : t∈Icc 0 (slitCapacityHorizon p hi h0 hH T:ℝ)) :
+    (∫ u in 0..t, 2/(slitReflectedFlow p hi h0 hH T z u-
+      (slitCapacityDriver p hi h0 hH hT u.toNNReal:ℂ)))=
+      slitReflectedFlow p hi h0 hH T z t-z := by
+  have hz0 : slitReflectedFlow p hi h0 hH T z 0=z := by
+    rw [slitReflectedFlow_eq_forward p hi h0 hH T hz]
+    simp only [slitCapacityForward,Real.toNNReal_zero,slitCapacityTime_zero,initialForwardChart_zero,id_eq]
+  have hi' : (∫ u in 0..t, 2/(slitReflectedFlow p hi h0 hH T z u-
+      (slitCapacityDriver p hi h0 hH hT u.toNNReal:ℂ)))=
+      slitReflectedFlow p hi h0 hH T z t-slitReflectedFlow p hi h0 hH T z 0 := by
+    apply intervalIntegral.integral_eq_sub_of_hasDerivAt_of_le ht.1
+      (slitReflectedFlow_interior_continuous p hi h0 hH T hz).continuousOn
+    · intro u hu
+      exact (slitReflectedFlow_interior_derivative p hi h0 hH hT hz
+        ⟨hu.1.le,hu.2.le.trans ht.2⟩).hasDerivAt
+        (Icc_mem_nhds hu.1 (hu.2.trans_le ht.2))
+    · exact (slitReflectedFlow_interior_kernel_continuous p hi h0 hH hT hz).intervalIntegrable 0 t
+  simpa only [hz0] using hi'
+
+end SLEExactGauge
+
+end
+
+end OAI
diff --git a/lean/OAI/Probability/SLE/Loewner/SlitSegmentParameter.lean b/lean/OAI/Probability/SLE/Loewner/SlitSegmentParameter.lean
new file mode 100644
index 0000000000000000000000000000000000000000..98a325b75320398abdbccacc91e64f2b5329c880
--- /dev/null
+++ b/lean/OAI/Probability/SLE/Loewner/SlitSegmentParameter.lean
@@ -0,0 +1,73 @@
+import OAI.Probability.SLE.Loewner.InitialSlitFuture
+
+namespace OAI
+
+/-! Exact affine parameters for a segment of a prescribed simple arc. -/
+noncomputable section
+open Set Function
+
+namespace SLEExactGauge
+
+def slitSegmentParameter (s t : unitInterval) (hst : s≤t) (u : unitInterval) : unitInterval :=
+  ⟨(s:ℝ)+((t:ℝ)-(s:ℝ))*(u:ℝ),by
+    have hd : 0≤(t:ℝ)-(s:ℝ) := sub_nonneg.mpr hst
+    constructor
+    · exact add_nonneg s.property.1 (mul_nonneg hd u.property.1)
+    · have hm := mul_le_mul_of_nonneg_left u.property.2 hd
+      linarith [t.property.2]⟩
+
+@[simp] lemma slitSegmentParameter_zero (s t : unitInterval) (hst : s≤t) :
+    slitSegmentParameter s t hst 0=s := by
+  apply Subtype.ext
+  change (s:ℝ)+((t:ℝ)-(s:ℝ))*0=(s:ℝ)
+  ring
+
+@[simp] lemma slitSegmentParameter_one (s t : unitInterval) (hst : s≤t) :
+    slitSegmentParameter s t hst 1=t := by
+  apply Subtype.ext
+  change (s:ℝ)+((t:ℝ)-(s:ℝ))*1=(t:ℝ)
+  ring
+
+lemma slitSegmentParameter_gt {s t : unitInterval} (hst : s<t)
+    {u : unitInterval} (hu : u≠0) : s<slitSegmentParameter s t hst.le u := by
+  change (s:ℝ)<(s:ℝ)+((t:ℝ)-(s:ℝ))*(u:ℝ)
+  exact lt_add_of_pos_right _ (mul_pos (sub_pos.mpr hst) (unitInterval.pos_iff_ne_zero.mpr hu))
+
+lemma slitSegmentParameter_le (s t : unitInterval) (hst : s≤t) (u : unitInterval) :
+    slitSegmentParameter s t hst u≤t := by
+  change (s:ℝ)+((t:ℝ)-(s:ℝ))*(u:ℝ)≤(t:ℝ)
+  have hm := mul_le_mul_of_nonneg_left u.property.2
+    (show 0≤(t:ℝ)-(s:ℝ) from sub_nonneg.mpr hst)
+  linarith
+
+lemma slitSegmentParameter_eq_future {s t : unitInterval} (hst : s<t) (ht : t<1)
+    {u : unitInterval} (hu : u≠0) :
+    slitFutureParameter s (((t:ℝ)-(s:ℝ))*(u:ℝ))=slitSegmentParameter s t hst.le u := by
+  apply Subtype.ext
+  apply slitFutureParameter_coe
+  have hd : 0<(t:ℝ)-(s:ℝ) := sub_pos.mpr hst
+  refine ⟨mul_pos hd (unitInterval.pos_iff_ne_zero.mpr hu),?_⟩
+  have hm := mul_le_mul_of_nonneg_left u.property.2 hd.le
+  have ht' : (t:ℝ)<1 := ht
+  nlinarith
+
+lemma exists_slitSegmentParameter {s t v : unitInterval} (hst : s<t) (hv : v∈Ioc s t) :
+    ∃ u : unitInterval, u≠0 ∧ slitSegmentParameter s t hst.le u=v := by
+  have hd : 0<(t:ℝ)-(s:ℝ) := sub_pos.mpr hst
+  have hvs : 0<(v:ℝ)-(s:ℝ) := sub_pos.mpr (show (s:ℝ)<(v:ℝ) from hv.1)
+  let u : unitInterval := ⟨((v:ℝ)-(s:ℝ))/((t:ℝ)-(s:ℝ)),
+    (div_pos hvs hd).le,
+    (div_le_one hd).mpr (sub_le_sub_right (show (v:ℝ)≤(t:ℝ) from hv.2) _)⟩
+  refine ⟨u,?_,?_⟩
+  · apply unitInterval.pos_iff_ne_zero.mp
+    exact div_pos hvs hd
+  · apply Subtype.ext
+    change (s:ℝ)+((t:ℝ)-(s:ℝ))*(((v:ℝ)-(s:ℝ))/((t:ℝ)-(s:ℝ)))=(v:ℝ)
+    field_simp
+    ring
+
+end SLEExactGauge
+
+end
+
+end OAI
diff --git a/lean/OAI/Probability/SLE/Loewner/SlitSupport.lean b/lean/OAI/Probability/SLE/Loewner/SlitSupport.lean
new file mode 100644
index 0000000000000000000000000000000000000000..9f04742f52ccdfbf488cf69532141df2fb7f0bba
--- /dev/null
+++ b/lean/OAI/Probability/SLE/Loewner/SlitSupport.lean
@@ -0,0 +1,62 @@
+import OAI.Probability.SLE.Geometry.PublishedInputs
+
+namespace OAI
+
+/-! The open-tube consequence of the SLE support theorem.
+
+Tran–Yuan, *A support theorem for SLE curves*, Electron. J. Probab. 25
+(2020), paper 18, Proposition 6.4 (printed page 18), as used in Theorem 1.1
+and Corollary 1.2, DOI 10.1214/20-EJP425. Proposition 6.4 places every
+simple capacity-parametrized curve in the uniform support.
+Only positive probabilities of their uniform neighborhoods are assumed below;
+there is no uniform bound over curves or stopped pasts in this input.
+-/
+
+noncomputable section
+open Set Filter MeasureTheory Metric
+open scoped Topology ENNReal NNReal
+
+namespace SLEExactGauge
+
+/-- The simple-curve inclusion in the published support theorem, restricted
+to finite deterministic capacity intervals. -/
+def PublishedSimpleTraceSupport {Ω : Type*} [MeasurableSpace Ω]
+    (P : Measure Ω) (γ : Ω → ℝ≥0 → ℂ) : Prop :=
+  ∀ (T : ℝ≥0), 0 < T → ∀ (β : ℝ≥0 → ℂ) (U : ℝ≥0 → ℝ),
+    Continuous U → IsCapacityTwoTrace U β →
+    InjOn β (Icc 0 T) → (∀ t ∈ Ioc 0 T, β t ∈ upperHalfPlane) →
+    ∀ ε : ℝ, 0 < ε → 0 < P {ω | ∀ t ∈ Icc 0 T, dist (γ ω t) (β t) < ε}
+
+/-- The pointwise support input yields the exact passage event used in the
+ribbon proof: containment in an open tube and a visit to the terminal target. -/
+theorem slit_tube_support_of_published_support
+    {Ω : Type*} [MeasurableSpace Ω] (P : Measure Ω)
+    (γ : Ω → ℝ≥0 → ℂ) (hpublished : PublishedSimpleTraceSupport P γ)
+    (T : ℝ≥0) (hT : 0 < T) (β : ℝ≥0 → ℂ) (U : ℝ≥0 → ℝ)
+    (hU : Continuous U) (hβ : IsCapacityTwoTrace U β)
+    (hinj : InjOn β (Icc 0 T)) (hinterior : ∀ t ∈ Ioc 0 T, β t ∈ upperHalfPlane)
+    (N V : Set ℂ) (hN : IsOpen N) (hV : IsOpen V)
+    (hsub : β '' Icc 0 T ⊆ N) (hend : β T ∈ V) :
+    0 < P {ω | (∀ t ∈ Icc 0 T, γ ω t ∈ N) ∧ γ ω T ∈ V} := by
+  obtain ⟨G, F, hw⟩ := hβ
+  have hc : IsCompact (β '' Icc 0 T) := isCompact_Icc.image hw.1
+  obtain ⟨ε, hε, hεN⟩ := hc.exists_thickening_subset_open hN hsub
+  obtain ⟨η, hη, hηV⟩ := Metric.isOpen_iff.mp hV (β T) hend
+  have hp := hpublished T hT β U hU ⟨G, F, hw⟩ hinj hinterior
+    (min ε η) (lt_min hε hη)
+  apply hp.trans_le
+  apply measure_mono
+  intro ω hω
+  constructor
+  · intro t ht
+    apply hεN
+    apply mem_thickening_iff.mpr
+    exact ⟨β t, mem_image_of_mem β ht, (hω t ht).trans_le (min_le_left _ _)⟩
+  · apply hηV
+    exact (hω T (mem_Icc.mpr ⟨zero_le, le_rfl⟩)).trans_le (min_le_right _ _)
+
+end SLEExactGauge
+
+end
+
+end OAI
diff --git a/lean/OAI/Probability/SLE/Loewner/SlitTailDomain.lean b/lean/OAI/Probability/SLE/Loewner/SlitTailDomain.lean
new file mode 100644
index 0000000000000000000000000000000000000000..c3dd9e273f05e8c3f0a6f006833ad500faadb641
--- /dev/null
+++ b/lean/OAI/Probability/SLE/Loewner/SlitTailDomain.lean
@@ -0,0 +1,124 @@
+import OAI.Probability.SLE.Loewner.SlitRadialLimits
+import OAI.Probability.SLE.Loewner.RawRadialTipBoundary
+import OAI.Probability.SLE.Loewner.SmoothRawDomain
+
+namespace OAI
+
+/-! The raw survival domain of a finite slit with constant driving tail
+is exactly its geometric slit domain. -/
+noncomputable section
+open Set Filter Function Complex _root_.MeasureTheory _root_.OAI.MeasureTheory ProbabilityTheory
+open scoped Topology NNReal
+
+namespace SLEExactGauge
+
+lemma slitCapacity_raw_initial_range (p : C(unitInterval,ℂ)) (hi : Injective p)
+    (h0 : p 0=0) (hH : ∀ t : unitInterval, t≠0 → p t∈upperHalfPlane)
+    {T : unitInterval} (hT : T<1) {t : ℝ≥0}
+    (ht : t ≤ slitCapacityHorizon p hi h0 hH T) :
+    (fun s : ℝ≥0 => Target.trace 1 (slitCapacityDriver p hi h0 hH hT) s) '' Icc 0 t=
+      slitCapacityCurve p hi h0 hH T '' Icc 0 t := by
+  apply image_congr
+  intro s hs
+  exact slitCapacity_raw_trace_eq p hi h0 hH hT (hs.2.trans ht)
+
+theorem slitCapacity_raw_complement_survives (p : C(unitInterval,ℂ)) (hi : Injective p)
+    (h0 : p 0=0) (hH : ∀ t : unitInterval, t≠0 → p t∈upperHalfPlane)
+    {T : unitInterval} (hT : T<1) (t : ℝ≥0) {z : ℂ}
+    (hz : z∈upperHalfPlane \ ((fun s : ℝ≥0 =>
+      Target.trace 1 (slitCapacityDriver p hi h0 hH hT) s) '' Icc 0 t)) :
+    Target.Surviving 1 (slitCapacityDriver p hi h0 hH hT) z t := by
+  let b := slitCapacityDriver p hi h0 hH hT
+  let A := slitCapacityHorizon p hi h0 hH T
+  let u := initialDrivingValue p hi h0 hH T hT
+  let β := fun s : ℝ≥0 => Target.trace 1 b s
+  change z∈upperHalfPlane \ (β '' Icc 0 t) at hz
+  by_cases ht : t ≤ A
+  · change z∈{z | Target.Surviving 1 b z t}
+    rw [slitCapacity_surviving_eq p hi h0 hH hT ht,
+      ←slitCapacityCurve_initial_range p hi h0 hH T ht,
+      ←slitCapacity_raw_initial_range p hi h0 hH hT ht]
+    exact hz
+  have hAt : A<t := lt_of_not_ge ht
+  have hpre : z∈upperHalfPlane \ (β '' Icc 0 A) :=
+    ⟨hz.1,fun he => hz.2 (image_mono (Icc_subset_Icc_right hAt.le) he)⟩
+  have hsA : Target.Surviving 1 b z A := by
+    change z∈{z | Target.Surviving 1 b z A}
+    rw [slitCapacity_surviving_eq p hi h0 hH hT le_rfl,
+      ←slitCapacityCurve_initial_range p hi h0 hH T le_rfl,
+      ←slitCapacity_raw_initial_range p hi h0 hH hT le_rfl]
+    exact hpre
+  let w := Target.flow 1 b z A-(u:ℂ)
+  have hw : w∈upperHalfPlane := by
+    have hh := Target.surviving_flow_mem_upperHalfPlane 1 b z A A.coe_nonneg hsA
+    simpa only [w,upperHalfPlane,mem_ofPred_eq,sub_im,ofReal_im,sub_zero] using hh
+  have hshift : (u:ℂ)+w=Target.flow 1 b z A := by dsimp [w]; ring
+  have hb : ∀ s : ℝ≥0, A ≤ s → b s=u :=
+    fun s hs => slitCapacityDriver_after p hi h0 hH hT hs
+  have hs : Target.Surviving 1 (Target.linearDriver 0) w (t-A : ℝ≥0) := by
+    by_contra hn
+    obtain ⟨v,hv,hvS,he⟩ := Target.exists_trace_time_of_not_surviving (Target.linearDriver 0)
+      w hw (t-A) hn (fun _ => 0) 0
+      (fun s hs => Target.linearDriver_derivative 0 s hs) (fun _ _ => by simp)
+    have hval : β (A+v)=z := by
+      dsimp only [β]
+      rw [NNReal.coe_add,Target.trace_constant_tail b A v hv u hb,←he,hshift]
+      exact Target.inverseFlow_eq_of_surviving 1 b A A.coe_nonneg z _ hsA rfl
+    apply hz.2
+    refine ⟨A+v,⟨zero_le,?_⟩,hval⟩
+    calc A+v ≤ A+(t-A) := add_le_add le_rfl hvS
+         _ = t := add_tsub_cancel_of_le hAt.le
+  let q := (u:ℂ)+Target.flow 1 (Target.linearDriver 0) w (t-A : ℝ≥0)
+  have hq : q∈upperHalfPlane := by
+    have hh := Target.surviving_flow_mem_upperHalfPlane 1 (Target.linearDriver 0) w
+      (t-A : ℝ≥0) (t-A).coe_nonneg hs
+    simpa only [q,upperHalfPlane,mem_ofPred_eq,add_im,ofReal_im,zero_add] using hh
+  have hF : Target.inverseFlow 1 b t q=z := by
+    have he := Target.inverseFlow_constant_tail b A (t-A) u hb hq
+    rw [←NNReal.coe_add,add_tsub_cancel_of_le hAt.le] at he
+    rw [he]
+    have hqsub : q-(u:ℂ)=Target.flow 1 (Target.linearDriver 0) w (t-A : ℝ≥0) := by
+      dsimp [q]; ring
+    rw [hqsub,Target.inverseFlow_eq_of_surviving 1 (Target.linearDriver 0)
+      (t-A : ℝ≥0) (t-A).coe_nonneg w _ hs rfl,hshift]
+    exact Target.inverseFlow_eq_of_surviving 1 b A A.coe_nonneg z _ hsA rfl
+  rw [←hF]
+  exact Target.inverseFlow_surviving 1 (by norm_num) b t q hq
+
+variable {Ω : Type*} [MeasurableSpace Ω] {P : Measure Ω} [IsProbabilityMeasure P]
+  {κ : ℝ} {γ : Ω → ℝ≥0 → ℂ}
+
+theorem RegularSLEPresentation.slitCapacity_raw_domains
+    (a : RegularSLEPresentation P κ γ) (hκ : 0<κ)
+    (p : C(unitInterval,ℂ)) (hi : Injective p) (h0 : p 0=0)
+    (hH : ∀ t : unitInterval, t≠0 → p t∈upperHalfPlane)
+    {T : unitInterval} (hT0 : 0<T) (hT : T<1) (t : ℝ≥0) :
+    {z | Target.Surviving 1 (slitCapacityDriver p hi h0 hH hT) z t}=
+      survivingDomain (fun s : ℝ≥0 => Target.trace 1 (slitCapacityDriver p hi h0 hH hT) s) t := by
+  let b := slitCapacityDriver p hi h0 hH hT
+  let β := fun s : ℝ≥0 => Target.trace 1 b s
+  obtain ⟨_,_,_,_,hfree⟩ := a.slitCapacity_raw_geometry hκ p hi h0 hH hT0 hT
+  have hsub (t : ℝ≥0) (ht : 0<t) : {z | Target.Surviving 1 b z t} ⊆ survivingDomain β t := by
+    intro z hz
+    apply hfree t ht
+    refine ⟨Target.surviving_mem_upperHalfPlane 1 b z t t.coe_nonneg hz,?_⟩
+    rintro ⟨s,hs,he⟩
+    have hp := Target.surviving_of_le_time 1 b z s.coe_nonneg hs.2 hz
+    change Target.trace 1 b s=z at he
+    rw [←he] at hp
+    exact a.raw_radial_tip_not_surviving hκ b s _
+      (slitCapacity_radial_limit p hi h0 hH hT s) hp
+  apply Subset.antisymm
+  · intro z hz
+    obtain ⟨S,hSt,hSz⟩ := Target.exists_later_survival 1 b z t.coe_nonneg hz
+    let S' : ℝ≥0 := ⟨S,t.coe_nonneg.trans hSt.le⟩
+    exact survivingDomain_antitone β (show t ≤ S' from hSt.le)
+      (hsub S' (t.coe_nonneg.trans_lt hSt) hSz)
+  · intro z hz
+    exact slitCapacity_raw_complement_survives p hi h0 hH hT t hz.1
+
+end SLEExactGauge
+
+end
+
+end OAI
diff --git a/lean/OAI/Probability/SLE/Loewner/SlitTimeGluing.lean b/lean/OAI/Probability/SLE/Loewner/SlitTimeGluing.lean
new file mode 100644
index 0000000000000000000000000000000000000000..7d38381bce523ea5a55571afc8f904d880310471
--- /dev/null
+++ b/lean/OAI/Probability/SLE/Loewner/SlitTimeGluing.lean
@@ -0,0 +1,56 @@
+import OAI.Probability.SLE.LoewnerCharts
+
+namespace OAI
+
+/-! One-sided time derivatives glue at a slit concatenation time. -/
+noncomputable section
+open Set Filter
+open scoped Topology
+
+namespace SLEExactGauge
+
+lemma hasDerivWithinAt_time_splice
+    {E : Type*} [NormedAddCommGroup E] [NormedSpace ℝ E]
+    (f g : ℝ → E) (T t : ℝ) (d : E)
+    (he : f T=g T)
+    (hf : t ≤ T → HasDerivWithinAt f d (Ici 0) t)
+    (hg : T ≤ t → HasDerivWithinAt g d (Ici T) t) :
+    HasDerivWithinAt (fun s => if s ≤ T then f s else g s) d (Ici 0) t := by
+  rcases lt_trichotomy t T with hlt | heq | hgt
+  · apply (hf hlt.le).congr_of_eventuallyEq
+    · filter_upwards [mem_nhdsWithin_of_mem_nhds (gt_mem_nhds hlt)] with s hs
+      exact ite_eq_left hs.le
+    · exact ite_eq_left hlt.le
+  · subst t
+    have hl := (hf le_rfl).mono (show Ici 0 ∩ Iic T ⊆ Ici 0 from inter_subset_left)
+    have hr := (hg le_rfl).mono (show Ici 0 ∩ Ici T ⊆ Ici T from inter_subset_right)
+    have hl' : HasDerivWithinAt (fun s => if s ≤ T then f s else g s) d
+        (Ici 0 ∩ Iic T) T := hl.congr (fun s hs => ite_eq_left hs.2) (ite_eq_left le_rfl)
+    have hr' : HasDerivWithinAt (fun s => if s ≤ T then f s else g s) d
+        (Ici 0 ∩ Ici T) T := by
+      apply hr.congr
+      · intro s hs
+        by_cases h : s ≤ T
+        · have hsT : s=T := le_antisymm h hs.2
+          simpa only [hsT,ite_eq_left le_rfl] using he
+        · exact ite_eq_right h
+      · simpa only [ite_eq_left le_rfl] using he
+    have hu : (Ici 0 ∩ Iic T) ∪ (Ici 0 ∩ Ici T)=Ici 0 := by
+      ext s
+      simp only [mem_union,mem_inter_iff,mem_Ici,mem_Iic]
+      constructor
+      · rintro (h | h) <;> exact h.1
+      · intro h
+        exact (le_total s T).elim (fun hs => Or.inl ⟨h,hs⟩) (fun hs => Or.inr ⟨h,hs⟩)
+    simpa only [hu] using hl'.union hr'
+  · apply ((hg hgt.le).mono_of_mem_nhdsWithin ?_).congr_of_eventuallyEq
+    · filter_upwards [mem_nhdsWithin_of_mem_nhds (lt_mem_nhds hgt)] with s hs
+      exact ite_eq_right (not_le.mpr hs)
+    · exact ite_eq_right (not_le.mpr hgt)
+    · exact mem_nhdsWithin_of_mem_nhds (Ici_mem_nhds hgt)
+
+end SLEExactGauge
+
+end
+
+end OAI
diff --git a/lean/OAI/Probability/SLE/Loewner/SlitUniformForwardBound.lean b/lean/OAI/Probability/SLE/Loewner/SlitUniformForwardBound.lean
new file mode 100644
index 0000000000000000000000000000000000000000..ab7f74b3a2b72f25de61821f778571f81aaefc1c
--- /dev/null
+++ b/lean/OAI/Probability/SLE/Loewner/SlitUniformForwardBound.lean
@@ -0,0 +1,118 @@
+import OAI.Probability.SLE.Loewner.ReflectedChartLocalBound
+import OAI.Probability.SLE.Loewner.CapacityRadiusBound
+
+namespace OAI
+
+/-! A numerical, slit-radius bound on all near-boundary forward
+coordinates. It is independent of the shape of the simple slit. -/
+noncomputable section
+open Set Filter Function Complex Metric
+open scoped Topology ComplexConjugate
+
+namespace SLEExactGauge
+
+lemma SimpleSlitChart.forward_on_two_radius {p : C(unitInterval,ℂ)}
+    (P : SimpleSlitChart p) (hi : Injective p) (h0 : p 0=0)
+    (hH : ∀ t : unitInterval, t≠0 → p t∈upperHalfPlane)
+    {R : ℝ} (hR : 0<R) (hp : ∀ t : unitInterval, ‖p t‖<R)
+    {z : ℂ} (hzH : z∈upperHalfPlane) (hz : ‖z‖=2*R) :
+    ‖P.forward z‖≤5*R := by
+  have hb := P.forward_kernel_remainder hi h0 hH hR hp hzH hz.ge
+  have hc := P.capacity_le_radius_sq hR (fun t => (hp t).le)
+  have hdiv : ‖(P.capacity:ℂ)/z‖=P.capacity/(2*R) := by
+    rw [norm_div,Complex.norm_real,Real.norm_eq_abs,abs_of_pos P.capacity_pos,hz]
+  have htri := norm_sub_le_norm_sub_add_norm_sub (P.forward z-z) ((P.capacity:ℂ)/z) 0
+  simp only [sub_zero] at htri
+  rw [hdiv] at htri
+  rw [hz] at hb
+  have he : 10*P.capacity*R/(2*R)^2+P.capacity/(2*R)=3*P.capacity/R := by
+    field_simp
+    ring
+  have hcost : 10*P.capacity*R/(2*R)^2+P.capacity/(2*R)≤3*R := by
+    rw [he]
+    apply (div_le_iff₀ hR).mpr
+    nlinarith
+  have hdelta : ‖P.forward z-z‖≤3*R := by linarith
+  have hsum := norm_le_norm_sub_add (P.forward z) z
+  rw [hz] at hsum
+  linarith
+
+lemma ReflectedCapacityChart.normalizing_constant_bound {p : C(unitInterval,ℂ)}
+    (Q : ReflectedCapacityChart p) (hi : Injective p) (h0 : p 0=0)
+    (hH : ∀ t : unitInterval, t≠0 → p t∈upperHalfPlane)
+    {R : ℝ} (hR : 0<R) (hp : ∀ t : unitInterval, ‖p t‖<R) :
+    ‖deriv (slitInfinityFactor Q.diskMap Q.slope) 0‖≤(256*Real.pi+7)*R := by
+  let z : ℂ := (2*R:ℝ)*Complex.I
+  have hzn : ‖z‖=2*R := by
+    change ‖((2*R:ℝ):ℂ)*Complex.I‖=2*R
+    rw [norm_mul,norm_I,mul_one,Complex.norm_real,Real.norm_eq_abs]
+    exact abs_of_pos (by positivity : 0<2*R)
+  have hzH : z∈upperHalfPlane := by
+    change 0<z.im
+    simpa only [z,mul_im,ofReal_re,I_im,mul_one,ofReal_im,zero_mul,add_zero] using
+      (by positivity : 0<2*R)
+  have hnot : z∉reflectedArcSet p := by
+    intro hh
+    have hn := reflectedArcSet_norm_lt hp hh
+    rw [hzn] at hn
+    linarith
+  have hJ := Q.joukowski_scaled_bound h0 (by positivity : 0<2*R)
+    (fun t => (hp t).trans (by linarith)) hnot hzn.le
+  have hG := Q.chart.forward_on_two_radius hi h0 hH hR hp hzH hzn
+  have he : deriv (slitInfinityFactor Q.diskMap Q.slope) 0=
+      (Q.slope:ℂ)*exteriorJoukowski (slitExteriorMap Q.diskMap z)-Q.chart.forward z := by
+    rw [Q.forward_eq]
+    simp only [slitHydrodynamicMap]
+    ring
+  rw [he]
+  have ht := norm_sub_le ((Q.slope:ℂ)*exteriorJoukowski (slitExteriorMap Q.diskMap z))
+    (Q.chart.forward z)
+  nlinarith
+
+lemma ReflectedCapacityChart.forward_bounded_in_two_radius {p : C(unitInterval,ℂ)}
+    (Q : ReflectedCapacityChart p) (hi : Injective p) (h0 : p 0=0)
+    (hH : ∀ t : unitInterval, t≠0 → p t∈upperHalfPlane)
+    {R : ℝ} (hR : 0<R) (hp : ∀ t : unitInterval, ‖p t‖<R)
+    {z : ℂ} (hz : z∉reflectedArcSet p) (hzR : ‖z‖≤2*R) :
+    ‖Q.chart.forward z‖≤(512*Real.pi+9)*R := by
+  have hJ := Q.joukowski_scaled_bound h0 (by positivity : 0<2*R)
+    (fun t => (hp t).trans (by linarith)) hz hzR
+  have hb := Q.normalizing_constant_bound hi h0 hH hR hp
+  rw [Q.forward_eq]
+  change ‖(Q.slope:ℂ)*exteriorJoukowski (slitExteriorMap Q.diskMap z)-
+    deriv (slitInfinityFactor Q.diskMap Q.slope) 0‖≤_
+  have ht := norm_sub_le ((Q.slope:ℂ)*exteriorJoukowski (slitExteriorMap Q.diskMap z))
+    (deriv (slitInfinityFactor Q.diskMap Q.slope) 0)
+  nlinarith
+
+lemma not_reflectedArcSet_of_mem_slit_domain {p : C(unitInterval,ℂ)} (h0 : p 0=0)
+    (hH : ∀ t : unitInterval, t≠0 → p t∈upperHalfPlane)
+    {z : ℂ} (hz : z∈upperHalfPlane \ range p) : z∉reflectedArcSet p := by
+  rintro (hp|⟨w,⟨t,rfl⟩,rfl⟩)
+  · exact hz.2 hp
+  · have hn : 0≤(p t).im := by
+      by_cases ht : t=0
+      · simp only [ht,h0,zero_im,le_refl]
+      · exact (hH t ht).le
+    have hh : 0 < -(p t).im := by
+      have hx := hz.1
+      change 0 < (conj (p t)).im at hx
+      simpa only [conj_im] using hx
+    linarith
+
+theorem SimpleSlitChart.forward_uniform_near {p : C(unitInterval,ℂ)}
+    (P : SimpleSlitChart p) (hi : Injective p) (h0 : p 0=0)
+    (hH : ∀ t : unitInterval, t≠0 → p t∈upperHalfPlane)
+    {R : ℝ} (hR : 0<R) (hp : ∀ t : unitInterval, ‖p t‖<R)
+    {z : ℂ} (hz : z∈upperHalfPlane \ range p) (hzR : ‖z‖≤2*R) :
+    ‖P.forward z‖≤(512*Real.pi+9)*R := by
+  obtain ⟨Q⟩ := exists_reflectedCapacityChart p hi h0 hH
+  rw [(P.unique_on_domain Q.chart).1 hz]
+  exact Q.forward_bounded_in_two_radius hi h0 hH hR hp
+    (not_reflectedArcSet_of_mem_slit_domain h0 hH hz) hzR
+
+end SLEExactGauge
+
+end
+
+end OAI
diff --git a/lean/OAI/Probability/SLE/Loewner/SlitUniformInverseBound.lean b/lean/OAI/Probability/SLE/Loewner/SlitUniformInverseBound.lean
new file mode 100644
index 0000000000000000000000000000000000000000..6efac4a1cd8e47e5d033bae834b0ce89319bd9cf
--- /dev/null
+++ b/lean/OAI/Probability/SLE/Loewner/SlitUniformInverseBound.lean
@@ -0,0 +1,71 @@
+import OAI.Probability.SLE.Loewner.SlitUniformForwardBound
+import OAI.Probability.SLE.Loewner.InitialChartIdentities
+
+namespace OAI
+
+/-! A common radius for the physical slit gives a common bound on all
+inverse charts above a bounded coordinate set. -/
+noncomputable section
+open Set Filter Function Complex Metric
+open scoped Topology
+
+namespace SLEExactGauge
+
+lemma SimpleSlitChart.exterior_displacement_le_radius {p : C(unitInterval,ℂ)}
+    (P : SimpleSlitChart p) (hi : Injective p) (h0 : p 0=0)
+    (hH : ∀ t : unitInterval, t≠0 → p t∈upperHalfPlane)
+    {R : ℝ} (hR : 0<R) (hp : ∀ t : unitInterval, ‖p t‖<R)
+    {z : ℂ} (hzH : z∈upperHalfPlane) (hz : 2*R≤‖z‖) :
+    ‖P.forward z-z‖≤3*R := by
+  have hn : 0<‖z‖ := lt_of_lt_of_le (by linarith : 0<2*R) hz
+  have hb := P.forward_kernel_remainder hi h0 hH hR hp hzH hz
+  have hc := P.capacity_le_radius_sq hR (fun t => (hp t).le)
+  have hquad : 4*R^2≤‖z‖^2 := by nlinarith
+  have hfirst : 10*P.capacity*R/‖z‖^2≤5*R/2 := by
+    apply (div_le_iff₀ (sq_pos_of_pos hn)).mpr
+    nlinarith [mul_le_mul_of_nonneg_right hc hR.le,
+      mul_le_mul_of_nonneg_left hquad hR.le]
+  have hsecond : P.capacity/‖z‖≤R/2 := by
+    apply (div_le_iff₀ hn).mpr
+    nlinarith [mul_le_mul_of_nonneg_left hz hR.le]
+  have hdiv : ‖(P.capacity:ℂ)/z‖=P.capacity/‖z‖ := by
+    rw [norm_div,Complex.norm_real,Real.norm_eq_abs,abs_of_pos P.capacity_pos]
+  have htri := norm_sub_le_norm_sub_add_norm_sub (P.forward z-z) ((P.capacity:ℂ)/z) 0
+  simp only [sub_zero] at htri
+  rw [hdiv] at htri
+  linarith
+
+theorem SimpleSlitChart.inverse_uniform_bound {p : C(unitInterval,ℂ)}
+    (P : SimpleSlitChart p) (hi : Injective p) (h0 : p 0=0)
+    (hH : ∀ t : unitInterval, t≠0 → p t∈upperHalfPlane)
+    {R : ℝ} (hR : 0<R) (hp : ∀ t : unitInterval, ‖p t‖<R)
+    {w : ℂ} (hw : w∈upperHalfPlane) : ‖P.inverse w‖≤‖w‖+3*R := by
+  by_cases hz : ‖P.inverse w‖≤2*R
+  · linarith [norm_nonneg w]
+  have hb := P.exterior_displacement_le_radius hi h0 hH hR hp (P.inverse_mapsTo hw).1
+    (le_of_not_ge hz)
+  rw [P.right_inverse w hw] at hb
+  have ht := norm_le_norm_sub_add (P.inverse w) w
+  rw [norm_sub_rev] at hb
+  linarith
+
+theorem initialInverse_uniform_bound (p : C(unitInterval,ℂ)) (hi : Injective p)
+    (h0 : p 0=0) (hH : ∀ t : unitInterval, t≠0 → p t∈upperHalfPlane)
+    {R : ℝ} (hR : 0<R) (hp : ∀ t : unitInterval, ‖p t‖<R)
+    (s : unitInterval) {w : ℂ} (hw : w∈upperHalfPlane) :
+    ‖initialInverseChart p hi h0 hH s w‖≤‖w‖+3*R := by
+  by_cases hs : s=0
+  · subst s
+    rw [initialInverseChart_zero]
+    change ‖w‖≤‖w‖+3*R
+    linarith
+  · rw [initialInverseChart,dite_eq_right hs]
+    exact (initialSlitChart p hi h0 hH s hs).inverse_uniform_bound
+      (initialSubarc_injective hi hs) (by simpa only [initialSubarc_zero] using h0)
+      (initialSubarc_upper hH hs) hR (fun u => hp _) hw
+
+end SLEExactGauge
+
+end
+
+end OAI
diff --git a/lean/OAI/Probability/SLE/Loewner/SmallDriverRise.lean b/lean/OAI/Probability/SLE/Loewner/SmallDriverRise.lean
new file mode 100644
index 0000000000000000000000000000000000000000..322def1f3ad4e020e9d4cb47cf15e0ed288437a4
--- /dev/null
+++ b/lean/OAI/Probability/SLE/Loewner/SmallDriverRise.lean
@@ -0,0 +1,30 @@
+import OAI.Probability.SLE.Loewner.LoewnerSmallDriverHeight
+
+namespace OAI
+
+/-! A fixed small-driver neighborhood forces a vertical rise; the radius
+does not depend on a choice of continuous capacity-two trace. -/
+noncomputable section
+open Set Filter
+open scoped Topology NNReal
+
+namespace SLEExactGauge
+
+theorem exists_small_driver_rise (T : ℝ≥0) (H : ℝ)
+    (hH : 0 ≤ H) (hHT : H < 2*Real.sqrt T) :
+    ∃ ε : ℝ, 0 < ε ∧ ∀ (U : ℝ≥0 → ℝ) (γ : ℝ≥0 → ℂ)
+      (G F : ℝ≥0 → ℂ → ℂ), IsCapacityTwoWitness U γ G F →
+      (∀ t ∈ Icc 0 T, |U t| ≤ ε) → ∃ t ∈ Icc 0 T, H < (γ t).im := by
+  classical
+  by_contra! hbad
+  let δ : ℕ → ℝ := fun n => 1/((n:ℝ)+1)
+  have hδ (n : ℕ) : 0 < δ n := by dsimp [δ]; positivity
+  choose U γ G F hw hU hheight using fun n => hbad (δ n) (hδ n)
+  exact small_drivers_not_all_height_bounded U γ G F hw T H hH hHT δ
+    tendsto_one_div_add_atTop_nhds_zero_nat hU hheight
+
+end SLEExactGauge
+
+end
+
+end OAI
diff --git a/lean/OAI/Probability/SLE/Loewner/SmoothDomainExhaustion.lean b/lean/OAI/Probability/SLE/Loewner/SmoothDomainExhaustion.lean
new file mode 100644
index 0000000000000000000000000000000000000000..a8befdeba298fc0af50baa77289df3962e967ca8
--- /dev/null
+++ b/lean/OAI/Probability/SLE/Loewner/SmoothDomainExhaustion.lean
@@ -0,0 +1,84 @@
+import OAI.Probability.SLE.Geometry.CompactSmoothExtension
+
+namespace OAI
+
+/-! Nested compactly supported smooth cutoffs exhausting an open domain.
+Only their positive sets need to be nested. -/
+noncomputable section
+open Set Filter Function
+open scoped Topology
+
+namespace SLEExactGauge
+
+structure SmoothDomainExhaustion (U : Set (ℝ×ℝ)) (z₀ : ℝ×ℝ) where
+  cutoff : ℕ → ℝ×ℝ → ℝ
+  smooth : ∀ n, ContDiff ℝ (⊤ : ℕ∞) (cutoff n)
+  compact : ∀ n, HasCompactSupport (cutoff n)
+  supported : ∀ n, tsupport (cutoff n) ⊆ U
+  based : ∀ n, cutoff n z₀=1
+  bounds : ∀ n z, cutoff n z∈Icc 0 1
+  increasing : Monotone (fun n => support (cutoff n))
+  exhausts : ∀ K, IsCompact K → K ⊆ U → ∀ᶠ n in atTop, K ⊆ support (cutoff n)
+
+lemma exists_smoothDomainExhaustion (U : Set (ℝ×ℝ)) (hU : IsOpen U)
+    (z₀ : ℝ×ℝ) (hz₀ : z₀∈U) : Nonempty (SmoothDomainExhaustion U z₀) := by
+  classical
+  let : LocallyCompactSpace U := hU.locallyCompactSpace
+  let K := CompactExhaustion.choice U
+  let x₀ : U := ⟨z₀,hz₀⟩
+  obtain ⟨N,hN⟩ := K.exists_mem x₀
+  let V (n : ℕ) : Set (ℝ×ℝ) := Subtype.val '' interior (K (n+N+1))
+  have hVo (n) : IsOpen (V n) := hU.isOpenEmbedding_subtypeVal.isOpenMap _ isOpen_interior
+  have hVK (n) : closure (V n) ⊆ Subtype.val '' K (n+N+1) := by
+    apply closure_minimal (image_mono interior_subset)
+    exact ((K.isCompact _).image continuous_subtype_val).isClosed
+  have hVc (n) : IsCompact (closure (V n)) :=
+    ((K.isCompact _).image continuous_subtype_val).of_isClosed_subset isClosed_closure (hVK n)
+  have hVU (n) : closure (V n) ⊆ U := (hVK n).trans (by
+    rintro z ⟨x,hx,rfl⟩
+    exact x.property)
+  have hV0 (n) : z₀∈V n := by
+    exact ⟨x₀,K.subset_interior (by omega) hN,rfl⟩
+  have hVm : Monotone V := by
+    intro n m hnm
+    exact image_mono (interior_mono (K.subset (by omega)))
+  have hχ (n : ℕ) : ∃ χ : ℝ×ℝ → ℝ, ContDiff ℝ (⊤ : ℕ∞) χ ∧
+      range χ ⊆ Icc 0 1 ∧ support χ=V n ∧ χ z₀=1 := by
+    obtain ⟨χ,hχ,hb,hs,hone⟩ := exists_contDiff_support_eq_eq_one_iff
+      (n := (⊤ : ℕ∞)) (hVo n) (isClosed_singleton (x := z₀)) (singleton_subset_iff.mpr (hV0 n))
+    exact ⟨χ,hχ,hb,hs,(hone z₀).mp (mem_singleton z₀)⟩
+  choose χ hχ hb hs h0 using hχ
+  refine ⟨⟨χ,hχ,?_,?_,h0,?_,?_,?_⟩⟩
+  · intro n
+    change IsCompact (closure (support (χ n)))
+    rw [hs n]
+    exact hVc n
+  · intro n
+    simpa only [tsupport,hs n] using hVU n
+  · intro n z
+    exact hb n (mem_range_self z)
+  · simpa only [hs] using hVm
+  · intro J hJ hJU
+    have him : (Subtype.val : U → ℝ×ℝ) '' ((Subtype.val : U → ℝ×ℝ) ⁻¹' J)=J := by
+      ext z
+      constructor
+      · rintro ⟨x,hx,rfl⟩
+        exact hx
+      · intro hz
+        exact ⟨⟨z,hJU hz⟩,hz,rfl⟩
+    have hJ' : IsCompact ((Subtype.val : U → ℝ×ℝ) ⁻¹' J) := by
+      apply (Topology.IsEmbedding.subtypeVal.isCompact_iff
+        (s := (Subtype.val : U → ℝ×ℝ) ⁻¹' J)).mpr
+      rw [him]
+      exact hJ
+    obtain ⟨m,hm⟩ := K.exists_superset_of_isCompact hJ'
+    filter_upwards [eventually_ge_atTop (m+1)] with n hn
+    intro z hz
+    rw [hs n]
+    exact ⟨⟨z,hJU hz⟩,K.subset_interior (by omega) (hm hz),rfl⟩
+
+end SLEExactGauge
+
+end
+
+end OAI
diff --git a/lean/OAI/Probability/SLE/Loewner/SmoothDriverLipschitz.lean b/lean/OAI/Probability/SLE/Loewner/SmoothDriverLipschitz.lean
new file mode 100644
index 0000000000000000000000000000000000000000..11097bcd5e2d3e3e685703d802eadc1ac321ed31
--- /dev/null
+++ b/lean/OAI/Probability/SLE/Loewner/SmoothDriverLipschitz.lean
@@ -0,0 +1,38 @@
+import OAI.Probability.SLE.Loewner.SmoothRawInverse
+
+namespace OAI
+
+/-! A bounded derivative on nonnegative times gives a global Lipschitz
+bound for the driver's constant extension to negative times. -/
+noncomputable section
+open Set Filter
+open scoped Topology NNReal
+
+namespace SLEExactGauge.Target
+
+theorem lipschitz_driverValue_of_bounded_derivative (b : Driver) (b' : ℝ → ℝ)
+    (L : ℝ≥0)
+    (hd : ∀ t, 0 ≤ t → HasDerivWithinAt (driverValue b) (b' t) (Ici 0) t)
+    (hb : ∀ t, 0 ≤ t → |b' t| ≤ L) :
+    LipschitzWith L (driverValue b) := by
+  have hr : LipschitzOnWith L (driverValue b) (Ici 0) := by
+    apply (convex_Ici (0 : ℝ)).lipschitzOnWith_of_nnnorm_hasDerivWithin_le hd
+    intro t ht
+    exact_mod_cast (show ‖b' t‖ ≤ (L : ℝ) from by simpa only [Real.norm_eq_abs] using hb t ht)
+  have hnn : LipschitzWith L b := by
+    apply LipschitzWith.of_dist_le_mul
+    intro t s
+    simpa only [driverValue,Real.toNNReal_coe,NNReal.dist_eq,Real.dist_eq] using
+      hr.dist_le_mul (t : ℝ) t.coe_nonneg (s : ℝ) s.coe_nonneg
+  apply LipschitzWith.of_dist_le_mul
+  intro s t
+  change dist (b s.toNNReal) (b t.toNNReal) ≤ (L : ℝ)*dist s t
+  exact (hnn.dist_le_mul _ _).trans (by
+    simpa only [NNReal.coe_one,one_mul] using
+      mul_le_mul_of_nonneg_left (Real.lipschitzWith_toNNReal.dist_le_mul s t) L.coe_nonneg)
+
+end SLEExactGauge.Target
+
+end
+
+end OAI
diff --git a/lean/OAI/Probability/SLE/Loewner/SmoothRawDomain.lean b/lean/OAI/Probability/SLE/Loewner/SmoothRawDomain.lean
new file mode 100644
index 0000000000000000000000000000000000000000..e6dfe9a936905afeaec0f42ae52067b39f21fc0a
--- /dev/null
+++ b/lean/OAI/Probability/SLE/Loewner/SmoothRawDomain.lean
@@ -0,0 +1,56 @@
+import OAI.Probability.SLE.Loewner.RawLifetimeTrace
+import OAI.Probability.SLE.Loewner.TargetSurvivalLifetime
+import OAI.Probability.SLE.Loewner.SmoothRawGeometry
+
+namespace OAI
+
+/-! For a smooth driver the raw survival domain is the geometric slit
+domain. Every lost interior point is a tip at its first lifetime. -/
+noncomputable section
+open Set Filter _root_.MeasureTheory _root_.OAI.MeasureTheory ProbabilityTheory
+open scoped Topology NNReal
+
+namespace SLEExactGauge
+
+theorem Target.exists_trace_time_of_not_surviving
+    (b : Driver) (z : ℂ) (hz : z ∈ upperHalfPlane) (T : ℝ≥0)
+    (hdead : ¬Surviving 1 b z T) (b' : ℝ → ℝ) (L : ℝ≥0)
+    (hd : ∀ t, 0 ≤ t → HasDerivWithinAt (driverValue b) (b' t) (Ici 0) t)
+    (hb : ∀ t, 0 ≤ t → |b' t| ≤ L) :
+    ∃ τ : ℝ≥0, 0 < τ ∧ τ ≤ T ∧ z=trace 1 b τ := by
+  obtain ⟨τ,hτ,hτT,hs⟩ := exists_survival_lifetime 1 b z hz T.coe_nonneg hdead
+  refine ⟨⟨τ,hτ.le⟩,hτ,hτT,?_⟩
+  apply eq_trace_at_lifetime b z hz hτ
+    (fun t ht htτ => (hs t ht).mpr htτ)
+    (fun h => lt_irrefl τ ((hs τ hτ.le).mp h))
+    b' (fun t ht => (hd t ht.1).mono Icc_subset_Ici_self) L.coe_nonneg
+    (fun t ht => hb t ht.1)
+
+theorem Target.smooth_geometric_subset_raw_surviving
+    (b : Driver) (b' : ℝ → ℝ) (L : ℝ≥0)
+    (hd : ∀ t, 0 ≤ t → HasDerivWithinAt (driverValue b) (b' t) (Ici 0) t)
+    (hb : ∀ t, 0 ≤ t → |b' t| ≤ L) (T : ℝ≥0) :
+    survivingDomain (fun s : ℝ≥0 => trace 1 b s) T ⊆ {z | Surviving 1 b z T} := by
+  intro z hz
+  by_contra hn
+  obtain ⟨τ,_hτ,hτT,he⟩ := exists_trace_time_of_not_surviving b z hz.1.1 T hn b' L hd hb
+  exact hz.1.2 ⟨τ,⟨zero_le,hτT⟩,he.symm⟩
+
+variable {Ω : Type*} [MeasurableSpace Ω] {P : Measure Ω} [IsProbabilityMeasure P]
+  {κ : ℝ} {γ : Ω → ℝ≥0 → ℂ}
+
+theorem RegularSLEPresentation.smooth_raw_surviving_eq_geometric
+    (a : RegularSLEPresentation P κ γ) (hκ : 0 < κ)
+    (b : Target.Driver) (b' : ℝ → ℝ) (L : ℝ≥0)
+    (hd : ∀ t, 0 ≤ t → HasDerivWithinAt (Target.driverValue b) (b' t) (Ici 0) t)
+    (hb : ∀ t, 0 ≤ t → |b' t| ≤ L) (T : ℝ≥0) (hT : 0 < T) :
+    {z | Target.Surviving 1 b z T} =
+      survivingDomain (fun s : ℝ≥0 => Target.trace 1 b s) T :=
+  Set.Subset.antisymm (a.smooth_raw_surviving_subset_geometric hκ b b' L hd hb T hT)
+    (Target.smooth_geometric_subset_raw_surviving b b' L hd hb T)
+
+end SLEExactGauge
+
+end
+
+end OAI
diff --git a/lean/OAI/Probability/SLE/Loewner/SmoothRawFreshness.lean b/lean/OAI/Probability/SLE/Loewner/SmoothRawFreshness.lean
new file mode 100644
index 0000000000000000000000000000000000000000..3005e3d9414370d3cd28af819c19744913b2be7f
--- /dev/null
+++ b/lean/OAI/Probability/SLE/Loewner/SmoothRawFreshness.lean
@@ -0,0 +1,99 @@
+import OAI.Probability.SLE.Loewner.RawReverseComposition
+import OAI.Probability.SLE.Loewner.RawSurvivingMonotone
+import OAI.Probability.SLE.Loewner.SmoothRawReverseEstimates
+import OAI.Probability.SLE.Loewner.SmoothRawTrace
+import OAI.Probability.SLE.Loewner.ReverseHeightUpper
+
+namespace OAI
+
+/-! The smooth raw tip survives at every earlier time. The proof uses
+compactness of an intermediate reverse image, with a uniform positive
+height, and the raw inverse composition identity. -/
+noncomputable section
+open Set Filter Metric Complex
+open scoped Topology NNReal
+
+namespace SLEExactGauge.Target
+
+theorem smooth_raw_tip_survives_short_past
+    (b : Driver) (T a : ℝ≥0) (ha : a ≤ T) (ha0 : 0 < a) (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)
+    (hsmall : L^2*(a : ℝ) ≤ 1) : Surviving 1 b (trace 1 b T) (T-a : ℝ≥0) := by
+  let y (n : ℕ) : ℝ := 1/((n : ℝ)+1)
+  let w (n : ℕ) : ℂ := (b T : ℂ)+(y n : ℂ)*I
+  have hy (n : ℕ) : 0 < y n := by dsimp [y]; positivity
+  have hy1 (n : ℕ) : y n ≤ 1 := by
+    dsimp [y]
+    apply (div_le_one (by positivity)).mpr
+    linarith [Nat.cast_nonneg (α := ℝ) n]
+  have hw (n : ℕ) : w n ∈ upperHalfPlane := by simpa [w,upperHalfPlane] using hy n
+  choose q hq0 hheight hqd heq using (fun n => exists_raw_reverse_trajectory b T (w n) (hw n))
+  let v (n : ℕ) : ℂ := q n a
+  let z (n : ℕ) : ℂ := q n T
+  have hqp (n : ℕ) (t : ℝ) (ht : 0 ≤ t) : 0 < (q n t).im :=
+    (hw n).trans_le (hheight n t ht)
+  have hqb (n : ℕ) : |(v n).re-b (T-a)| ≤ L*a ∧ 2*(a : ℝ) ≤ (v n).im^2 := by
+    have hh := smooth_raw_reverse_estimates b T b' hd hL hb (q n)
+      (fun t ht => (hqd n t ht.1).mono Icc_subset_Ici_self)
+      (fun t ht => hqp n t ht.1) (by simp [hq0,w]) a ⟨a.coe_nonneg,ha⟩ hsmall
+    simpa only [v,driverValue,show ((T : ℝ)-(a : ℝ)).toNNReal=T-a from rfl] using hh
+  have hvi (n : ℕ) : (v n).im ≤ 1+4*(a : ℝ) := by
+    have hh := reverse_height_square_le a.coe_nonneg (q n)
+      (fun t => driverValue b ((T : ℝ)-t))
+      (fun t ht => (hqd n t ht.1).mono Icc_subset_Ici_self)
+      (fun t ht => hqp n t ht.1)
+    rw [hq0 n] at hh
+    have hwi : (w n).im=y n := by simp [w]
+    rw [hwi] at hh
+    change (v n).im^2 ≤ (y n)^2+4*(a : ℝ) at hh
+    nlinarith [hy n,hy1 n,hqp n a a.coe_nonneg,a.coe_nonneg,sq_nonneg (4*(a : ℝ))]
+  let R : ℝ := L*a+|b (T-a)|+(1+4*(a : ℝ))
+  have hball (n : ℕ) : v n ∈ closedBall 0 R := by
+    rw [mem_closedBall,dist_zero_right]
+    have hre : |(v n).re| ≤ L*a+|b (T-a)| := by
+      calc
+        |(v n).re| = |((v n).re-b (T-a))+b (T-a)| := by congr 1; ring
+        _ ≤ |(v n).re-b (T-a)|+|b (T-a)| := abs_add_le _ _
+        _ ≤ L*a+|b (T-a)| := add_le_add (hqb n).1 le_rfl
+    have hvp : 0 < (v n).im := hqp n a a.coe_nonneg
+    exact (Complex.norm_le_abs_re_add_abs_im (v n)).trans
+      (add_le_add hre (by simpa only [abs_of_pos hvp] using hvi n))
+  obtain ⟨v₀,_,φ,hφ,hlim⟩ := (isCompact_closedBall (0 : ℂ) R).tendsto_subseq hball
+  have him := Complex.continuous_im.continuousAt.tendsto.comp hlim
+  have hnonneg : 0 ≤ v₀.im := ge_of_tendsto him
+    (Eventually.of_forall (fun n => (hqp (φ n) a a.coe_nonneg).le))
+  have hlow : 2*(a : ℝ) ≤ v₀.im^2 := ge_of_tendsto (him.pow 2)
+    (Eventually.of_forall (fun n => (hqb (φ n)).2))
+  have hv₀ : v₀ ∈ upperHalfPlane := by
+    have hap : 0 < (a : ℝ) := ha0
+    change 0 < v₀.im
+    nlinarith
+  have hFv (n : ℕ) : inverseFlow 1 b (T-a : ℝ≥0) (v n)=z n := by
+    have hh := raw_reverse_tail_inverse b T (T-a) tsub_le_self (q n) (hqd n) (hqp n)
+    have hdiff : (T : ℝ)-((T-a : ℝ≥0) : ℝ)=(a : ℝ) := by rw [NNReal.coe_sub ha]; ring
+    simpa only [hdiff,v,z] using hh
+  have hFc : ContinuousAt (inverseFlow 1 b (T-a : ℝ≥0)) v₀ :=
+    (continuousOn_inverseFlow 1 (by norm_num) b (T-a)).continuousAt
+      (isOpen_upperHalfPlane.mem_nhds hv₀)
+  have hFz : Tendsto (fun n => z (φ n)) atTop (𝓝 (inverseFlow 1 b (T-a : ℝ≥0) v₀)) := by
+    have hh := hFc.tendsto.comp hlim
+    convert hh using 1
+    funext n
+    exact (hFv (φ n)).symm
+  have hy0 : Tendsto y atTop (𝓝[>] (0 : ℝ)) := tendsto_nhdsWithin_iff.mpr
+    ⟨tendsto_one_div_add_atTop_nhds_zero_nat,Eventually.of_forall hy⟩
+  have hzlim : Tendsto z atTop (𝓝 (trace 1 b T)) := by
+    have hh := (tendsto_inverseFlow_smooth_trace b T b' hd hL hb).comp hy0
+    convert hh using 1
+    funext n
+    exact (heq n).symm
+  have hfinal := tendsto_nhds_unique hFz (hzlim.comp hφ.tendsto_atTop)
+  exact hfinal ▸ inverseFlow_surviving 1 (by norm_num) b (T-a) v₀ hv₀
+
+end SLEExactGauge.Target
+
+end
+
+end OAI
diff --git a/lean/OAI/Probability/SLE/Loewner/SmoothRawGeometry.lean b/lean/OAI/Probability/SLE/Loewner/SmoothRawGeometry.lean
new file mode 100644
index 0000000000000000000000000000000000000000..d3ea15af4551f32855bfac79a8bd0e2eb66d8ec8
--- /dev/null
+++ b/lean/OAI/Probability/SLE/Loewner/SmoothRawGeometry.lean
@@ -0,0 +1,56 @@
+import OAI.Probability.SLE.Loewner.SmoothRawSimple
+import OAI.Probability.SLE.Loewner.SmoothRawTraceInterior
+import OAI.Probability.SLE.Geometry.FiniteSimpleSlit
+
+namespace OAI
+
+/-! The raw smooth trace has the topology of a simple slit. Its raw
+surviving domain embeds in the geometric unbounded component; equality
+of these domains is treated separately. -/
+noncomputable section
+open Set Filter _root_.MeasureTheory _root_.OAI.MeasureTheory ProbabilityTheory
+open scoped Topology NNReal
+
+namespace SLEExactGauge
+
+variable {Ω : Type*} [MeasurableSpace Ω] {P : Measure Ω} [IsProbabilityMeasure P]
+  {κ : ℝ} {γ : Ω → ℝ≥0 → ℂ}
+
+theorem RegularSLEPresentation.smooth_raw_free_complement
+    (a : RegularSLEPresentation P κ γ) (hκ : 0 < κ)
+    (b : Target.Driver) (b' : ℝ → ℝ) (L : ℝ≥0)
+    (hd : ∀ t, 0 ≤ t → HasDerivWithinAt (Target.driverValue b) (b' t) (Ici 0) t)
+    (hb : ∀ t, 0 ≤ t → |b' t| ≤ L) (T : ℝ≥0) (hT : 0 < T) :
+    upperHalfPlane \ ((fun s : ℝ≥0 => Target.trace 1 b s) '' Icc 0 T) ⊆
+      survivingDomain (fun s : ℝ≥0 => Target.trace 1 b s) T := by
+  apply finite_simple_slit_free (fun s => Target.trace 1 b s)
+    (Target.continuous_smooth_raw_trace b b' L hd hb)
+    (Target.smooth_trace_zero b b' L hd hb) T hT
+    (a.smooth_raw_trace_injective hκ b b' L hd hb).injOn
+  intro t ht
+  exact Target.smooth_raw_trace_mem_upperHalfPlane b t ht.1 b'
+    (fun s hs => (hd s hs.1).mono Icc_subset_Ici_self) L.coe_nonneg (fun s hs => hb s hs.1)
+
+theorem RegularSLEPresentation.smooth_raw_surviving_subset_geometric
+    (a : RegularSLEPresentation P κ γ) (hκ : 0 < κ)
+    (b : Target.Driver) (b' : ℝ → ℝ) (L : ℝ≥0)
+    (hd : ∀ t, 0 ≤ t → HasDerivWithinAt (Target.driverValue b) (b' t) (Ici 0) t)
+    (hb : ∀ t, 0 ≤ t → |b' t| ≤ L) (T : ℝ≥0) (hT : 0 < T) :
+    {z | Target.Surviving 1 b z T} ⊆
+      survivingDomain (fun s : ℝ≥0 => Target.trace 1 b s) T := by
+  intro z hz
+  apply a.smooth_raw_free_complement hκ b b' L hd hb T hT
+  refine ⟨Target.surviving_mem_upperHalfPlane 1 b z T T.coe_nonneg hz,?_⟩
+  rintro ⟨s,hs,he⟩
+  have hp := Target.surviving_of_le_time 1 b z s.coe_nonneg hs.2 hz
+  change Target.trace 1 b s=z at he
+  rw [← he] at hp
+  exact (a.smooth_raw_tip_not_surviving hκ b s b'
+    (fun t ht => (hd t ht.1).mono Icc_subset_Ici_self) L.coe_nonneg
+    (fun t ht => hb t ht.1)) hp
+
+end SLEExactGauge
+
+end
+
+end OAI
diff --git a/lean/OAI/Probability/SLE/Loewner/SmoothRawInverse.lean b/lean/OAI/Probability/SLE/Loewner/SmoothRawInverse.lean
new file mode 100644
index 0000000000000000000000000000000000000000..7e3acd82f5ee6a53edf64075889215d1797b11f4
--- /dev/null
+++ b/lean/OAI/Probability/SLE/Loewner/SmoothRawInverse.lean
@@ -0,0 +1,77 @@
+import OAI.Probability.SLE.Loewner.ReverseTrajectoryExistence
+import OAI.Probability.SLE.Loewner.SmoothReverseContraction
+import OAI.Probability.SLE.Loewner.TargetInverseContinuity
+
+namespace OAI
+
+/-! A boundary Cauchy estimate for the exact raw inverse map, without
+assuming the existence of a capacity trace. -/
+noncomputable section
+open Set Filter Complex
+open scoped Topology NNReal
+
+namespace SLEExactGauge.Target
+
+lemma exists_raw_reverse_trajectory (b : Driver) (T : ℝ≥0) (w : ℂ)
+    (hw : w ∈ upperHalfPlane) :
+    ∃ q : ℝ → ℂ, q 0=w ∧
+      (∀ t, 0 ≤ t → w.im ≤ (q t).im) ∧
+      (∀ t, 0 ≤ t → HasDerivWithinAt q
+        (-2/(q t-(driverValue b ((T : ℝ)-t) : ℂ))) (Ici 0) t) ∧
+      inverseFlow 1 b T w=q T := by
+  have hu : Continuous (fun t : ℝ => driverValue b ((T : ℝ)-t)) :=
+    b.continuous.comp (continuous_real_toNNReal.comp (continuous_const.sub continuous_id))
+  obtain ⟨q,hq0,hheight,hqd⟩ := exists_reverse_trajectory _ hu w hw
+  refine ⟨q,hq0,hheight,hqd,?_⟩
+  have hh := inverseFlow_eq_reverse_trajectory 1 (by norm_num) b T w
+    (w.im/2) (half_pos hw) (half_le_self hw.le) q hq0 (fun t ht => ?_)
+  · simpa only [div_one] using hh
+  · have he : reverseField (w.im/2) (driverValue b ((T : ℝ)-1*t)) (q t) =
+        -2/(q t-(driverValue b ((T : ℝ)-t) : ℂ)) := by
+      rw [one_mul,reverseField,reverseCenter_eq ((half_le_self hw.le).trans (hheight t ht))]
+      rfl
+    rw [he]
+    exact hqd t ht
+
+theorem inverseFlow_vertical_contraction (b : Driver) (T : ℝ≥0) (b' : ℝ → ℝ)
+    (hd : ∀ t ∈ Icc 0 (T : ℝ), HasDerivWithinAt (fun s => b s.toNNReal)
+      (b' t) (Icc 0 (T : ℝ)) t)
+    {L : ℝ} (hL : 0 ≤ L) (hb : ∀ t ∈ Icc 0 (T : ℝ), |b' t| ≤ L)
+    (hsmall : L^2*(T : ℝ) ≤ 1) {y v : ℝ} (hy : 0 < y) (hv : 0 < v) :
+    dist (inverseFlow 1 b T ((b T : ℂ)+(y : ℂ)*I))
+      (inverseFlow 1 b T ((b T : ℂ)+(v : ℂ)*I)) ≤ |y-v| := by
+  obtain ⟨q,hq0,hqy,hqd,heq⟩ := exists_raw_reverse_trajectory b T
+    ((b T : ℂ)+(y : ℂ)*I) (by simpa [upperHalfPlane] using hy)
+  obtain ⟨r,hr0,hry,hrd,her⟩ := exists_raw_reverse_trajectory b T
+    ((b T : ℂ)+(v : ℂ)*I) (by simpa [upperHalfPlane] using hv)
+  let u (s : ℝ) := driverValue b ((T : ℝ)-s)
+  have hreflect (s : ℝ) (hs : s ∈ Icc 0 (T : ℝ)) :
+      (T : ℝ)-s ∈ Icc 0 (T : ℝ) :=
+    ⟨sub_nonneg.mpr hs.2,sub_le_self _ hs.1⟩
+  have hu (s : ℝ) (hs : s ∈ Icc 0 (T : ℝ)) : HasDerivWithinAt u
+      (-b' ((T : ℝ)-s)) (Icc 0 (T : ℝ)) s := by
+    have hi : HasDerivWithinAt (fun t : ℝ => (T : ℝ)-t) (-1) (Icc 0 (T : ℝ)) s := by
+      simpa using ((hasDerivAt_id s).const_sub (T : ℝ)).hasDerivWithinAt
+    convert! (hd _ (hreflect s hs)).comp s hi hreflect using 1
+    simp only [mul_neg,mul_one]
+  have hh := smooth_reverse_trajectories_contract T.coe_nonneg hL q r u
+    (fun s => -b' ((T : ℝ)-s))
+    (fun s hs => (hqd s hs.1).mono Icc_subset_Ici_self)
+    (fun s hs => (hrd s hs.1).mono Icc_subset_Ici_self) hu
+    (fun s hs => by simpa using hb _ (hreflect s hs))
+    (fun s hs => hy.trans_le (by simpa using hqy s hs.1))
+    (fun s hs => hv.trans_le (by simpa using hry s hs.1))
+    (by simp [hq0,u,driverValue]) (by simp [hr0,u,driverValue]) hsmall
+  rw [heq,her]
+  convert hh using 1
+  rw [hq0,hr0,dist_eq_norm]
+  have he : ((b T : ℂ)+(y : ℂ)*I)-((b T : ℂ)+(v : ℂ)*I)=((y-v : ℝ) : ℂ)*I := by
+    push_cast
+    ring
+  rw [he,norm_mul,Complex.norm_real,Real.norm_eq_abs,Complex.norm_I,mul_one]
+
+end SLEExactGauge.Target
+
+end
+
+end OAI
diff --git a/lean/OAI/Probability/SLE/Loewner/SmoothRawReverseEstimates.lean b/lean/OAI/Probability/SLE/Loewner/SmoothRawReverseEstimates.lean
new file mode 100644
index 0000000000000000000000000000000000000000..566901074d868ed296ecf97b2f79736ab40896e4
--- /dev/null
+++ b/lean/OAI/Probability/SLE/Loewner/SmoothRawReverseEstimates.lean
@@ -0,0 +1,47 @@
+import OAI.Probability.SLE.Loewner.SmoothRawInverse
+
+namespace OAI
+
+/-! Intermediate reverse-time estimates for constructing the raw slit. -/
+noncomputable section
+open Set Filter Complex
+open scoped Topology NNReal
+
+namespace SLEExactGauge.Target
+
+lemma smooth_raw_reverse_estimates (b : Driver) (T : ℝ≥0) (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 : ℝ → ℂ)
+    (hq : ∀ t ∈ Icc 0 (T : ℝ), HasDerivWithinAt q
+      (-2/(q t-(driverValue b ((T : ℝ)-t) : ℂ))) (Icc 0 (T : ℝ)) t)
+    (hp : ∀ t ∈ Icc 0 (T : ℝ), 0 < (q t).im) (hq0 : (q 0).re=b T)
+    (a : ℝ) (ha : a ∈ Icc 0 (T : ℝ)) (hsmall : L^2*a ≤ 1) :
+    |(q a).re-driverValue b ((T : ℝ)-a)| ≤ L*a ∧ 2*a ≤ (q a).im^2 := by
+  let u (s : ℝ) := driverValue b ((T : ℝ)-s)
+  have hreflect (s : ℝ) (hs : s ∈ Icc 0 (T : ℝ)) :
+      (T : ℝ)-s ∈ Icc 0 (T : ℝ) :=
+    ⟨sub_nonneg.mpr hs.2,sub_le_self _ hs.1⟩
+  have hu (s : ℝ) (hs : s ∈ Icc 0 (T : ℝ)) : HasDerivWithinAt u
+      (-b' ((T : ℝ)-s)) (Icc 0 (T : ℝ)) s := by
+    have hi : HasDerivWithinAt (fun t : ℝ => (T : ℝ)-t) (-1) (Icc 0 (T : ℝ)) s := by
+      simpa using ((hasDerivAt_id s).const_sub (T : ℝ)).hasDerivWithinAt
+    convert! (hd _ (hreflect s hs)).comp s hi hreflect using 1
+    simp only [mul_neg,mul_one]
+  have hstart : (q 0).re=u 0 := by simpa only [u,sub_zero,driverValue,Real.toNNReal_coe] using hq0
+  have hb' : ∀ t ∈ Icc 0 (T : ℝ), |-b' ((T : ℝ)-t)| ≤ L :=
+    fun t ht => by simpa only [abs_neg] using hb _ (hreflect t ht)
+  refine ⟨(reverse_centered_coordinates hL q u _ hq hu hb' hp hstart).1 a ha,?_⟩
+  have hsub : Icc 0 a ⊆ Icc 0 (T : ℝ) := Icc_subset_Icc_right ha.2
+  exact reverse_loewner_height_lower hL q u _
+    (fun s hs => (hq s (hsub hs)).mono hsub)
+    (fun s hs => (hu s (hsub hs)).mono hsub)
+    (fun s hs => hb' s (hsub hs)) (fun s hs => hp s (hsub hs))
+    hstart hsmall a ⟨ha.1,le_rfl⟩
+
+end SLEExactGauge.Target
+
+end
+
+end OAI
diff --git a/lean/OAI/Probability/SLE/Loewner/SmoothRawSimple.lean b/lean/OAI/Probability/SLE/Loewner/SmoothRawSimple.lean
new file mode 100644
index 0000000000000000000000000000000000000000..8827384c4234c195a6631a9a71b9504227b21e0f
--- /dev/null
+++ b/lean/OAI/Probability/SLE/Loewner/SmoothRawSimple.lean
@@ -0,0 +1,68 @@
+import OAI.Probability.SLE.Loewner.SmoothRawFreshness
+import OAI.Probability.SLE.Loewner.RawSurvivingAnalytic
+import OAI.Probability.SLE.Loewner.SmoothRawTraceContinuous
+
+namespace OAI
+
+/-! Every positive-time raw tip is new: it survives all earlier times
+and fails to survive its own time. Hence the smooth raw trace is simple. -/
+noncomputable section
+open Set Filter _root_.MeasureTheory _root_.OAI.MeasureTheory ProbabilityTheory
+open scoped Topology NNReal
+
+namespace SLEExactGauge
+
+lemma Target.smooth_raw_tip_survives_past (b : Driver) (T S : ℝ≥0) (hST : S<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) :
+    Surviving 1 b (trace 1 b T) S := by
+  let ar : ℝ := min (((T : ℝ)-S)/2) (1/(L^2+1))
+  have har : 0 < ar := lt_min (by exact half_pos (sub_pos.mpr hST)) (by positivity)
+  let a : ℝ≥0 := ⟨ar,har.le⟩
+  have ha0 : 0 < a := har
+  have haT : a ≤ T := by
+    change ar ≤ (T : ℝ)
+    have hh : ar ≤ ((T : ℝ)-S)/2 := min_le_left _ _
+    linarith [S.coe_nonneg,T.coe_nonneg]
+  have hsmall : L^2*(a : ℝ) ≤ 1 := by
+    have hh : ar*(L^2+1) ≤ 1 :=
+      (le_div_iff₀ (show 0 < L^2+1 by positivity)).mp (min_le_right _ _)
+    change L^2*ar ≤ 1
+    nlinarith [har.le]
+  have hpast : S ≤ T-a := by
+    change (S : ℝ) ≤ ((T-a : ℝ≥0) : ℝ)
+    rw [NNReal.coe_sub haT]
+    have hh : ar ≤ ((T : ℝ)-S)/2 := min_le_left _ _
+    change (S : ℝ) ≤ (T : ℝ)-ar
+    linarith [show (S : ℝ)<T from hST]
+  exact surviving_of_le_time 1 b _ S.coe_nonneg hpast
+    (smooth_raw_tip_survives_short_past b T a haT ha0 b' hd hL hb hsmall)
+
+theorem RegularSLEPresentation.smooth_raw_trace_injective
+    {Ω : Type*} [MeasurableSpace Ω] {P : Measure Ω} [IsProbabilityMeasure P]
+    {κ : ℝ} {γ : Ω → ℝ≥0 → ℂ} (a : RegularSLEPresentation P κ γ) (hκ : 0 < κ)
+    (b : Target.Driver) (b' : ℝ → ℝ) (L : ℝ≥0)
+    (hd : ∀ t, 0 ≤ t → HasDerivWithinAt (Target.driverValue b) (b' t) (Ici 0) t)
+    (hb : ∀ t, 0 ≤ t → |b' t| ≤ L) :
+    Function.Injective (fun T : ℝ≥0 => Target.trace 1 b T) := by
+  have hdT (T : ℝ≥0) (t : ℝ) (ht : t ∈ Icc 0 (T : ℝ)) :=
+    (hd t ht.1).mono (show Icc 0 (T : ℝ) ⊆ Ici 0 from Icc_subset_Ici_self)
+  have hbT (T : ℝ≥0) (t : ℝ) (ht : t ∈ Icc 0 (T : ℝ)) := hb t ht.1
+  intro S T he
+  change Target.trace 1 b S=Target.trace 1 b T at he
+  rcases lt_trichotomy S T with hST | heq | hTS
+  · have hp := Target.smooth_raw_tip_survives_past b T S hST b' (hdT T) L.coe_nonneg (hbT T)
+    rw [← he] at hp
+    exact False.elim ((a.smooth_raw_tip_not_surviving hκ b S b' (hdT S) L.coe_nonneg (hbT S)) hp)
+  · exact heq
+  · have hp := Target.smooth_raw_tip_survives_past b S T hTS b' (hdT S) L.coe_nonneg (hbT S)
+    rw [he] at hp
+    exact False.elim ((a.smooth_raw_tip_not_surviving hκ b T b' (hdT T) L.coe_nonneg (hbT T)) hp)
+
+end SLEExactGauge
+
+end
+
+end OAI
diff --git a/lean/OAI/Probability/SLE/Loewner/SmoothRawTipGlobal.lean b/lean/OAI/Probability/SLE/Loewner/SmoothRawTipGlobal.lean
new file mode 100644
index 0000000000000000000000000000000000000000..96fed73231f4aca9547c63483e24e3030627c3e4
--- /dev/null
+++ b/lean/OAI/Probability/SLE/Loewner/SmoothRawTipGlobal.lean
@@ -0,0 +1,97 @@
+import OAI.Probability.SLE.Loewner.SmoothRawTipLimit
+import OAI.Probability.SLE.Loewner.ReverseLongContraction
+
+namespace OAI
+
+/-! A bounded derivative gives a finite radial tip limit at every time.
+The proof first gains a positive height on a short terminal interval,
+then uses ordinary interior stability for the remaining reverse time. -/
+noncomputable section
+open Set Filter Metric Complex
+open scoped Topology NNReal
+
+namespace SLEExactGauge.Target
+
+theorem inverseFlow_vertical_distance_of_smooth_driver
+    (b : Driver) (T : ℝ≥0) (b' : ℝ → ℝ)
+    (hd : ∀ t ∈ Icc 0 (T : ℝ), HasDerivWithinAt (fun s => b s.toNNReal)
+      (b' t) (Icc 0 (T : ℝ)) t)
+    {L a : ℝ} (hL : 0 ≤ L) (ha : 0 < a) (haT : a ≤ T)
+    (hb : ∀ t ∈ Icc 0 (T : ℝ), |b' t| ≤ L) (hsmall : L^2*a ≤ 1)
+    {y v : ℝ} (hy : 0 < y) (hv : 0 < v) :
+    dist (inverseFlow 1 b T ((b T : ℂ)+(y : ℂ)*I))
+      (inverseFlow 1 b T ((b T : ℂ)+(v : ℂ)*I)) ≤
+        |y-v| * Real.exp ((4*(Real.sqrt a)⁻¹^2)*((T : ℝ)-a)) := by
+  obtain ⟨q,hq0,hqy,hqd,heq⟩ := exists_raw_reverse_trajectory b T
+    ((b T : ℂ)+(y : ℂ)*I) (by simpa [upperHalfPlane] using hy)
+  obtain ⟨r,hr0,hry,hrd,her⟩ := exists_raw_reverse_trajectory b T
+    ((b T : ℂ)+(v : ℂ)*I) (by simpa [upperHalfPlane] using hv)
+  let u (s : ℝ) := driverValue b ((T : ℝ)-s)
+  have hreflect (s : ℝ) (hs : s ∈ Icc 0 (T : ℝ)) :
+      (T : ℝ)-s ∈ Icc 0 (T : ℝ) :=
+    ⟨sub_nonneg.mpr hs.2,sub_le_self _ hs.1⟩
+  have hu (s : ℝ) (hs : s ∈ Icc 0 (T : ℝ)) : HasDerivWithinAt u
+      (-b' ((T : ℝ)-s)) (Icc 0 (T : ℝ)) s := by
+    have hi : HasDerivWithinAt (fun t : ℝ => (T : ℝ)-t) (-1) (Icc 0 (T : ℝ)) s := by
+      simpa using ((hasDerivAt_id s).const_sub (T : ℝ)).hasDerivWithinAt
+    convert! (hd _ (hreflect s hs)).comp s hi hreflect using 1
+    simp only [mul_neg,mul_one]
+  have hh := smooth_reverse_long_distance ha haT hL q r u
+    (fun s => -b' ((T : ℝ)-s))
+    (fun s hs => (hqd s hs.1).mono Icc_subset_Ici_self)
+    (fun s hs => (hrd s hs.1).mono Icc_subset_Ici_self) hu
+    (fun s hs => by simpa using hb _ (hreflect s hs))
+    (fun s hs => hy.trans_le (by simpa using hqy s hs.1))
+    (fun s hs => hv.trans_le (by simpa using hry s hs.1))
+    (by simp [hq0,u,driverValue]) (by simp [hr0,u,driverValue]) hsmall
+  rw [heq,her]
+  convert hh using 1
+  rw [hq0,hr0,dist_eq_norm]
+  have he : ((b T : ℂ)+(y : ℂ)*I)-((b T : ℂ)+(v : ℂ)*I)=((y-v : ℝ) : ℂ)*I := by
+    push_cast
+    ring
+  rw [he,norm_mul,Complex.norm_real,Real.norm_eq_abs,Complex.norm_I,mul_one]
+
+theorem inverseFlow_tip_limit_of_smooth_window
+    (b : Driver) (T : ℝ≥0) (b' : ℝ → ℝ)
+    (hd : ∀ t ∈ Icc 0 (T : ℝ), HasDerivWithinAt (fun s => b s.toNNReal)
+      (b' t) (Icc 0 (T : ℝ)) t)
+    {L a : ℝ} (hL : 0 ≤ L) (ha : 0 < a) (haT : a ≤ T)
+    (hb : ∀ t ∈ Icc 0 (T : ℝ), |b' t| ≤ L) (hsmall : L^2*a ≤ 1) :
+    ∃ z : ℂ, Tendsto (fun y : ℝ => inverseFlow 1 b T ((b T : ℂ)+(y : ℂ)*I))
+      (𝓝[>] 0) (𝓝 z) := by
+  let C : ℝ≥0 := ⟨Real.exp ((4*(Real.sqrt a)⁻¹^2)*((T : ℝ)-a)),(Real.exp_pos _).le⟩
+  refine exists_right_limit_of_complex_lipschitz
+    (fun y : ℝ => inverseFlow 1 b T ((b T : ℂ)+(y : ℂ)*I)) C ?_
+  intro y hy v hv
+  exact (inverseFlow_vertical_distance_of_smooth_driver b T b' hd hL ha haT hb hsmall hy hv).trans_eq
+    (mul_comm _ _)
+
+lemma exists_smooth_window (T : ℝ) (hT : 0 < T) (L : ℝ) :
+    ∃ a : ℝ, 0 < a ∧ a ≤ T ∧ L^2*a ≤ 1 := by
+  let a : ℝ := min T (1/(L^2+1))
+  have ha : 0 < a := lt_min hT (by positivity)
+  refine ⟨a,ha,min_le_left _ _,?_⟩
+  have hden : 0 < L^2+1 := by positivity
+  have h : a*(L^2+1) ≤ 1 := (le_div_iff₀ hden).mp (min_le_right T (1/(L^2+1)))
+  nlinarith [ha.le]
+
+theorem inverseFlow_tip_limit_of_smooth_driver
+    (b : Driver) (T : ℝ≥0) (b' : ℝ → ℝ)
+    (hd : ∀ t ∈ Icc 0 (T : ℝ), HasDerivWithinAt (fun s => b s.toNNReal)
+      (b' t) (Icc 0 (T : ℝ)) t)
+    {L : ℝ} (hL : 0 ≤ L) (hb : ∀ t ∈ Icc 0 (T : ℝ), |b' t| ≤ L) :
+    ∃ z : ℂ, Tendsto (fun y : ℝ => inverseFlow 1 b T ((b T : ℂ)+(y : ℂ)*I))
+      (𝓝[>] 0) (𝓝 z) := by
+  by_cases hT : T=0
+  · subst T
+    exact inverseFlow_tip_limit_of_short_smooth_driver b 0 b' hd hL hb (by simp)
+  obtain ⟨a,ha,haT,hsmall⟩ := exists_smooth_window T
+    (by exact_mod_cast (pos_iff_ne_zero.mpr hT)) L
+  exact inverseFlow_tip_limit_of_smooth_window b T b' hd hL ha haT hb hsmall
+
+end SLEExactGauge.Target
+
+end
+
+end OAI
diff --git a/lean/OAI/Probability/SLE/Loewner/SmoothRawTipLimit.lean b/lean/OAI/Probability/SLE/Loewner/SmoothRawTipLimit.lean
new file mode 100644
index 0000000000000000000000000000000000000000..094334993c7519ce8de499afae3dd2298c547c0a
--- /dev/null
+++ b/lean/OAI/Probability/SLE/Loewner/SmoothRawTipLimit.lean
@@ -0,0 +1,64 @@
+import OAI.Probability.SLE.Loewner.SmoothRawInverse
+
+namespace OAI
+
+/-! The exact raw inverse has a finite radial tip limit on a short
+smooth-driver interval. No geometric witness is assumed. -/
+noncomputable section
+open Set Filter Metric Complex
+open scoped Topology NNReal
+
+namespace SLEExactGauge
+
+lemma exists_right_limit_of_complex_lipschitz (f : ℝ → ℂ) (K : ℝ≥0)
+    (hf : ∀ x > 0, ∀ y > 0, dist (f x) (f y) ≤ K*|x-y|) :
+    ∃ z : ℂ, Tendsto f (𝓝[>] (0 : ℝ)) (𝓝 z) := by
+  have hre : LipschitzOnWith K (fun x => (f x).re) (Ioi (0 : ℝ)) := 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*|x-y| := by simpa only [dist_eq_norm] using hf x hx y hy
+      _ = K*dist x y := by simp [Real.dist_eq]
+  have him : LipschitzOnWith K (fun x => (f x).im) (Ioi (0 : ℝ)) := 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*|x-y| := by simpa only [dist_eq_norm] using hf x hx y hy
+      _ = K*dist x y := by simp [Real.dist_eq]
+  obtain ⟨r,hr,her⟩ := hre.extend_real
+  obtain ⟨i,hi,hei⟩ := him.extend_real
+  let g (x : ℝ) : ℂ := (r x : ℂ)+(i x : ℂ)*I
+  have hg : Continuous g :=
+    (Complex.continuous_ofReal.comp hr.continuous).add
+      ((Complex.continuous_ofReal.comp hi.continuous).mul continuous_const)
+  refine ⟨g 0,?_⟩
+  have hh : Tendsto g (𝓝[>] (0 : ℝ)) (𝓝 (g 0)) :=
+    (hg.tendsto 0).mono_left nhdsWithin_le_nhds
+  apply hh.congr'
+  filter_upwards [self_mem_nhdsWithin] with x hx
+  apply Complex.ext <;> simp [g,← her hx,← hei hx]
+
+namespace Target
+
+theorem inverseFlow_tip_limit_of_short_smooth_driver
+    (b : Driver) (T : ℝ≥0) (b' : ℝ → ℝ)
+    (hd : ∀ t ∈ Icc 0 (T : ℝ), HasDerivWithinAt (fun s => b s.toNNReal)
+      (b' t) (Icc 0 (T : ℝ)) t)
+    {L : ℝ} (hL : 0 ≤ L) (hb : ∀ t ∈ Icc 0 (T : ℝ), |b' t| ≤ L)
+    (hsmall : L^2*(T : ℝ) ≤ 1) :
+    ∃ z : ℂ, Tendsto (fun y : ℝ => inverseFlow 1 b T ((b T : ℂ)+(y : ℂ)*I))
+      (𝓝[>] 0) (𝓝 z) :=
+  exists_right_limit_of_complex_lipschitz _ 1 (fun _ hy _ hv => by
+    simpa only [NNReal.coe_one,one_mul] using
+      inverseFlow_vertical_contraction b T b' hd hL hb hsmall hy hv)
+
+end Target
+end SLEExactGauge
+
+end
+
+end OAI
diff --git a/lean/OAI/Probability/SLE/Loewner/SmoothRawTrace.lean b/lean/OAI/Probability/SLE/Loewner/SmoothRawTrace.lean
new file mode 100644
index 0000000000000000000000000000000000000000..ff89ca13c07f8202e55afe30ebd887d4f39976dd
--- /dev/null
+++ b/lean/OAI/Probability/SLE/Loewner/SmoothRawTrace.lean
@@ -0,0 +1,46 @@
+import OAI.Probability.SLE.Loewner.SmoothRawTipGlobal
+
+namespace OAI
+
+/-! The prescribed raw trace is the actual radial limit for smooth
+drivers. A quantitative radial error bound is retained for time continuity. -/
+noncomputable section
+open Set Filter Metric Complex
+open scoped Topology NNReal
+
+namespace SLEExactGauge.Target
+
+theorem tendsto_inverseFlow_smooth_trace (b : Driver) (T : ℝ≥0) (b' : ℝ → ℝ)
+    (hd : ∀ t ∈ Icc 0 (T : ℝ), HasDerivWithinAt (fun s => b s.toNNReal)
+      (b' t) (Icc 0 (T : ℝ)) t)
+    {L : ℝ} (hL : 0 ≤ L) (hb : ∀ t ∈ Icc 0 (T : ℝ), |b' t| ≤ L) :
+    Tendsto (fun y : ℝ => inverseFlow 1 b T ((b T : ℂ)+(y : ℂ)*I))
+      (𝓝[>] 0) (𝓝 (trace 1 b T)) := by
+  have he := inverseFlow_tip_limit_of_smooth_driver b T b' hd hL hb
+  simpa only [trace,one_mul,driverValue,Real.toNNReal_coe] using tendsto_nhds_limUnder he
+
+theorem inverseFlow_smooth_trace_error (b : Driver) (T : ℝ≥0) (b' : ℝ → ℝ)
+    (hd : ∀ t ∈ Icc 0 (T : ℝ), HasDerivWithinAt (fun s => b s.toNNReal)
+      (b' t) (Icc 0 (T : ℝ)) t)
+    {L a : ℝ} (hL : 0 ≤ L) (ha : 0 < a) (haT : a ≤ T)
+    (hb : ∀ t ∈ Icc 0 (T : ℝ), |b' t| ≤ L) (hsmall : L^2*a ≤ 1)
+    {y : ℝ} (hy : 0 < y) :
+    dist (inverseFlow 1 b T ((b T : ℂ)+(y : ℂ)*I)) (trace 1 b T) ≤
+      y*Real.exp ((4*(Real.sqrt a)⁻¹^2)*((T : ℝ)-a)) := by
+  have ht := tendsto_inverseFlow_smooth_trace b T b' hd hL hb
+  have hr : Tendsto (fun v : ℝ => |y-v| *
+      Real.exp ((4*(Real.sqrt a)⁻¹^2)*((T : ℝ)-a))) (𝓝[>] 0)
+      (𝓝 (y*Real.exp ((4*(Real.sqrt a)⁻¹^2)*((T : ℝ)-a)))) := by
+    have hid : Tendsto (fun v : ℝ => v) (𝓝[>] 0) (𝓝 (0 : ℝ)) := nhdsWithin_le_nhds
+    have h := (hid.const_sub y).abs.mul_const
+      (Real.exp ((4*(Real.sqrt a)⁻¹^2)*((T : ℝ)-a)))
+    simpa only [sub_zero,abs_of_pos hy] using h
+  apply le_of_tendsto_of_tendsto (tendsto_const_nhds.dist ht) hr
+  filter_upwards [self_mem_nhdsWithin] with v hv
+  exact inverseFlow_vertical_distance_of_smooth_driver b T b' hd hL ha haT hb hsmall hy hv
+
+end SLEExactGauge.Target
+
+end
+
+end OAI
diff --git a/lean/OAI/Probability/SLE/Loewner/SmoothRawTraceBounds.lean b/lean/OAI/Probability/SLE/Loewner/SmoothRawTraceBounds.lean
new file mode 100644
index 0000000000000000000000000000000000000000..dcd3a55ff44353362a625217d09b0949b9477c46
--- /dev/null
+++ b/lean/OAI/Probability/SLE/Loewner/SmoothRawTraceBounds.lean
@@ -0,0 +1,71 @@
+import OAI.Probability.SLE.Loewner.SmoothRawTrace
+import OAI.Probability.SLE.Loewner.ReverseHeightUpper
+
+namespace OAI
+
+/-! Quantitative position bounds for the raw smooth-driver trace.
+These estimates include time zero and do not assume a capacity witness. -/
+noncomputable section
+open Set Filter Metric Complex
+open scoped Topology NNReal
+
+namespace SLEExactGauge.Target
+
+lemma smooth_raw_inverse_real_bound (b : Driver) (T : ℝ≥0) (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)
+    {y : ℝ} (hy : 0 < y) :
+    |(inverseFlow 1 b T ((b T : ℂ)+(y : ℂ)*I)).re| ≤ L*T := by
+  obtain ⟨q,hq0,hqy,hqd,heq⟩ := exists_raw_reverse_trajectory b T
+    ((b T : ℂ)+(y : ℂ)*I) (by simpa [upperHalfPlane] using hy)
+  let u (s : ℝ) := driverValue b ((T : ℝ)-s)
+  have hreflect (s : ℝ) (hs : s ∈ Icc 0 (T : ℝ)) :
+      (T : ℝ)-s ∈ Icc 0 (T : ℝ) :=
+    ⟨sub_nonneg.mpr hs.2,sub_le_self _ hs.1⟩
+  have hu (s : ℝ) (hs : s ∈ Icc 0 (T : ℝ)) : HasDerivWithinAt u
+      (-b' ((T : ℝ)-s)) (Icc 0 (T : ℝ)) s := by
+    have hi : HasDerivWithinAt (fun t : ℝ => (T : ℝ)-t) (-1) (Icc 0 (T : ℝ)) s := by
+      simpa using ((hasDerivAt_id s).const_sub (T : ℝ)).hasDerivWithinAt
+    convert! (hd _ (hreflect s hs)).comp s hi hreflect using 1
+    simp only [mul_neg,mul_one]
+  have hh := (reverse_centered_coordinates hL q u (fun s => -b' ((T : ℝ)-s))
+    (fun s hs => (hqd s hs.1).mono Icc_subset_Ici_self) hu
+    (fun s hs => by simpa using hb _ (hreflect s hs))
+    (fun s hs => hy.trans_le (by simpa using hqy s hs.1))
+    (by simp [hq0,u,driverValue])).1 T ⟨T.coe_nonneg,le_rfl⟩
+  rw [heq]
+  simpa only [u,sub_self,driverValue,Real.toNNReal_zero,map_zero,sub_zero] using hh
+
+theorem smooth_raw_trace_position_bounds (b : Driver) (T : ℝ≥0) (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) :
+    |(trace 1 b T).re| ≤ L*T ∧ 0 ≤ (trace 1 b T).im ∧
+      (trace 1 b T).im^2 ≤ 4*T := by
+  have ht := tendsto_inverseFlow_smooth_trace b T b' hd hL hb
+  have hid : Tendsto (fun y : ℝ => y) (𝓝[>] 0) (𝓝 (0 : ℝ)) :=
+    nhdsWithin_le_nhds
+  refine ⟨?_,?_,?_⟩
+  · apply le_of_tendsto (Complex.continuous_re.continuousAt.tendsto.comp ht |>.abs)
+    filter_upwards [self_mem_nhdsWithin] with y hy
+    exact smooth_raw_inverse_real_bound b T b' hd hL hb hy
+  · apply ge_of_tendsto (Complex.continuous_im.continuousAt.tendsto.comp ht)
+    filter_upwards [self_mem_nhdsWithin] with y hy
+    exact (inverseFlow_mem_upperHalfPlane 1 (by norm_num) b T
+      ((b T : ℂ)+(y : ℂ)*I) (by simpa [upperHalfPlane] using hy)).le
+  · apply le_of_tendsto_of_tendsto
+      ((Complex.continuous_im.continuousAt.tendsto.comp ht).pow 2)
+      (show Tendsto (fun y : ℝ => y^2+4*(T : ℝ)) (𝓝[>] 0) (𝓝 (4*(T : ℝ))) from
+        by simpa only [zero_pow (by decide : (2:ℕ) ≠ 0),zero_add] using (hid.pow 2).add_const (4*(T : ℝ)))
+    filter_upwards [self_mem_nhdsWithin] with y hy
+    simpa only [Function.comp_apply,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
+      raw_inverse_height_square_le b T ((b T : ℂ)+(y : ℂ)*I)
+        (by simpa [upperHalfPlane] using hy)
+
+end SLEExactGauge.Target
+
+end
+
+end OAI
diff --git a/lean/OAI/Probability/SLE/Loewner/SmoothRawTraceContinuity.lean b/lean/OAI/Probability/SLE/Loewner/SmoothRawTraceContinuity.lean
new file mode 100644
index 0000000000000000000000000000000000000000..e9e887a42bd689a286428cf190961bc74c4b384e
--- /dev/null
+++ b/lean/OAI/Probability/SLE/Loewner/SmoothRawTraceContinuity.lean
@@ -0,0 +1,57 @@
+import OAI.Probability.SLE.Loewner.SmoothRawTrace
+import OAI.Probability.SLE.Loewner.RawTipTimeContinuity
+
+namespace OAI
+
+/-! Radial approximations converge uniformly away from time zero.
+Consequently the raw smooth-driver tip is continuous at positive times. -/
+noncomputable section
+open Set Filter Metric Complex
+open scoped Topology NNReal
+
+namespace SLEExactGauge.Target
+
+theorem smooth_trace_uniform_radial_limit (b : Driver) (b' : ℝ → ℝ)
+    {L : ℝ≥0} (hd : ∀ t, 0 ≤ t → HasDerivWithinAt (driverValue b) (b' t) (Ici 0) t)
+    (hb : ∀ t, 0 ≤ t → |b' t| ≤ L)
+    (a R : ℝ≥0) (ha : 0 < a) (hsmall : (L : ℝ)^2*(a : ℝ) ≤ 1) :
+    TendstoUniformlyOn
+      (fun n : ℕ => fun T : ℝ≥0 => inverseFlow 1 b T
+        ((b T : ℂ)+((1/((n : ℝ)+1) : ℝ) : ℂ)*I))
+      (fun T : ℝ≥0 => trace 1 b T) atTop (Icc a R) := by
+  let C : ℝ := Real.exp ((4*(Real.sqrt a)⁻¹^2)*((R : ℝ)-a))
+  have hzero : Tendsto (fun n : ℕ => (1/((n : ℝ)+1))*C) atTop (𝓝 0) := by
+    simpa only [zero_mul] using tendsto_one_div_add_atTop_nhds_zero_nat.mul_const C
+  rw [Metric.tendstoUniformlyOn_iff]
+  intro ε hε
+  filter_upwards [hzero.eventually (Iio_mem_nhds hε)] with n hn T hT
+  have hy : 0 < 1/((n : ℝ)+1) := by positivity
+  have hdt (t : ℝ) (ht : t ∈ Icc 0 (T : ℝ)) :=
+    (hd t ht.1).mono (show Icc 0 (T : ℝ) ⊆ Ici 0 from Icc_subset_Ici_self)
+  have h := inverseFlow_smooth_trace_error b T b' hdt L.coe_nonneg
+    (show 0 < (a : ℝ) from ha) (show (a : ℝ) ≤ T from hT.1)
+    (fun t ht => hb t ht.1) hsmall hy
+  have hbound : dist (inverseFlow 1 b T
+      ((b T : ℂ)+((1/((n : ℝ)+1) : ℝ) : ℂ)*I)) (trace 1 b T) ≤
+      (1/((n : ℝ)+1))*C := by
+    apply h.trans
+    dsimp [C]
+    gcongr
+    exact hT.2
+  simpa only [dist_comm] using hbound.trans_lt hn
+
+theorem continuousOn_smooth_trace_Icc (b : Driver) (b' : ℝ → ℝ)
+    {L : ℝ≥0} (hLip : LipschitzWith L (driverValue b))
+    (hd : ∀ t, 0 ≤ t → HasDerivWithinAt (driverValue b) (b' t) (Ici 0) t)
+    (hb : ∀ t, 0 ≤ t → |b' t| ≤ L)
+    (a R : ℝ≥0) (ha : 0 < a) (hsmall : (L : ℝ)^2*(a : ℝ) ≤ 1) :
+    ContinuousOn (fun T : ℝ≥0 => trace 1 b T) (Icc a R) := by
+  exact (smooth_trace_uniform_radial_limit b b' hd hb a R ha hsmall).continuousOn
+    (Eventually.frequently (Eventually.of_forall (fun n => (continuous_raw_radial_time b hLip
+      (show 0 < 1/((n : ℝ)+1) by positivity)).continuousOn)))
+
+end SLEExactGauge.Target
+
+end
+
+end OAI
diff --git a/lean/OAI/Probability/SLE/Loewner/SmoothRawTraceContinuous.lean b/lean/OAI/Probability/SLE/Loewner/SmoothRawTraceContinuous.lean
new file mode 100644
index 0000000000000000000000000000000000000000..0d35437196ae987fc11638bdc6f098f968a82522
--- /dev/null
+++ b/lean/OAI/Probability/SLE/Loewner/SmoothRawTraceContinuous.lean
@@ -0,0 +1,64 @@
+import OAI.Probability.SLE.Loewner.SmoothRawTraceContinuity
+import OAI.Probability.SLE.Loewner.SmoothRawTraceBounds
+import OAI.Probability.SLE.Loewner.SmoothDriverLipschitz
+
+namespace OAI
+
+/-! Smooth drivers with bounded derivative generate a continuous raw tip
+at all nonnegative times, including the initial boundary point. -/
+noncomputable section
+open Set Filter Metric Complex
+open scoped Topology NNReal
+
+namespace SLEExactGauge.Target
+
+lemma smooth_trace_zero (b : Driver) (b' : ℝ → ℝ) (L : ℝ≥0)
+    (hd : ∀ t, 0 ≤ t → HasDerivWithinAt (driverValue b) (b' t) (Ici 0) t)
+    (hb : ∀ t, 0 ≤ t → |b' t| ≤ L) : trace 1 b 0=0 := by
+  have hh := smooth_raw_trace_position_bounds b 0 b'
+    (fun t ht => (hd t ht.1).mono Icc_subset_Ici_self) L.coe_nonneg (fun t ht => hb t ht.1)
+  simp only [NNReal.coe_zero,mul_zero] at hh
+  apply Complex.ext
+  · simpa only [Complex.zero_re] using abs_nonpos_iff.mp hh.1
+  · simpa only [Complex.zero_im] using (show (trace 1 b 0).im=0 by nlinarith [sq_nonneg (trace 1 b 0).im])
+
+lemma smooth_trace_norm_le (b : Driver) (b' : ℝ → ℝ) (L : ℝ≥0)
+    (hd : ∀ t, 0 ≤ t → HasDerivWithinAt (driverValue b) (b' t) (Ici 0) t)
+    (hb : ∀ t, 0 ≤ t → |b' t| ≤ L) (T : ℝ≥0) :
+    ‖trace 1 b T‖ ≤ (L : ℝ)*T+2*Real.sqrt T := by
+  have hh := smooth_raw_trace_position_bounds b T b'
+    (fun t ht => (hd t ht.1).mono Icc_subset_Ici_self) L.coe_nonneg (fun t ht => hb t ht.1)
+  have him : (trace 1 b T).im ≤ 2*Real.sqrt T := by
+    nlinarith [Real.sq_sqrt T.coe_nonneg,Real.sqrt_nonneg (T : ℝ)]
+  calc
+    _ ≤ |(trace 1 b T).re|+|(trace 1 b T).im| := Complex.norm_le_abs_re_add_abs_im _
+    _ ≤ (L : ℝ)*T+2*Real.sqrt T := by rw [abs_of_nonneg hh.2.1]; exact add_le_add hh.1 him
+
+theorem continuous_smooth_raw_trace (b : Driver) (b' : ℝ → ℝ) (L : ℝ≥0)
+    (hd : ∀ t, 0 ≤ t → HasDerivWithinAt (driverValue b) (b' t) (Ici 0) t)
+    (hb : ∀ t, 0 ≤ t → |b' t| ≤ L) :
+    Continuous (fun T : ℝ≥0 => trace 1 b T) := by
+  have hLip := lipschitz_driverValue_of_bounded_derivative b b' L hd hb
+  apply continuous_iff_continuousAt.mpr
+  intro T
+  by_cases hT : T=0
+  · subst T
+    change Tendsto (fun T : ℝ≥0 => trace 1 b T) (𝓝 0) (𝓝 (trace 1 b 0))
+    rw [smooth_trace_zero b b' L hd hb]
+    apply tendsto_zero_iff_norm_tendsto_zero.mpr
+    apply squeeze_zero (fun _ => norm_nonneg _) (smooth_trace_norm_le b b' L hd hb)
+    have hc : Continuous (fun T : ℝ≥0 => (L : ℝ)*T+2*Real.sqrt T) := by fun_prop
+    simpa only [NNReal.coe_zero,mul_zero,Real.sqrt_zero,add_zero] using hc.tendsto 0
+  · have hTp : 0 < (T : ℝ) := by exact_mod_cast (pos_iff_ne_zero.mpr hT)
+    obtain ⟨ar,har,harT,hsmall⟩ := exists_smooth_window ((T : ℝ)/2) (half_pos hTp) L
+    let a : ℝ≥0 := ⟨ar,har.le⟩
+    have ha : 0 < a := har
+    have haT : a < T := harT.trans_lt (half_lt_self hTp)
+    exact (continuousOn_smooth_trace_Icc b b' hLip hd hb a (T+1) ha hsmall).continuousAt
+      (Icc_mem_nhds haT (by simp))
+
+end SLEExactGauge.Target
+
+end
+
+end OAI
diff --git a/lean/OAI/Probability/SLE/Loewner/SmoothRawTraceInterior.lean b/lean/OAI/Probability/SLE/Loewner/SmoothRawTraceInterior.lean
new file mode 100644
index 0000000000000000000000000000000000000000..fcc428537edef56907252e681b52747f66c55f9d
--- /dev/null
+++ b/lean/OAI/Probability/SLE/Loewner/SmoothRawTraceInterior.lean
@@ -0,0 +1,77 @@
+import OAI.Probability.SLE.Loewner.SmoothRawTraceBounds
+import OAI.Probability.SLE.Loewner.ReverseLongContraction
+
+namespace OAI
+
+/-! Every positive-time smooth raw tip is in the upper half-plane.
+A short reverse interval gives a height bound independent of the
+positive height used to approximate the tip. -/
+noncomputable section
+open Set Filter Metric Complex
+open scoped Topology NNReal
+
+namespace SLEExactGauge.Target
+
+lemma smooth_raw_inverse_height_lower (b : Driver) (T : ℝ≥0) (b' : ℝ → ℝ)
+    (hd : ∀ t ∈ Icc 0 (T : ℝ), HasDerivWithinAt (driverValue b)
+      (b' t) (Icc 0 (T : ℝ)) t)
+    {L a : ℝ} (hL : 0 ≤ L) (ha : 0 < a) (haT : a ≤ T)
+    (hb : ∀ t ∈ Icc 0 (T : ℝ), |b' t| ≤ L) (hsmall : L^2*a ≤ 1)
+    {y : ℝ} (hy : 0 < y) :
+    2*a ≤ (inverseFlow 1 b T ((b T : ℂ)+(y : ℂ)*I)).im^2 := by
+  obtain ⟨q,hq0,hqy,hqd,heq⟩ := exists_raw_reverse_trajectory b T
+    ((b T : ℂ)+(y : ℂ)*I) (by simpa [upperHalfPlane] using hy)
+  let u (s : ℝ) := driverValue b ((T : ℝ)-s)
+  have hreflect (s : ℝ) (hs : s ∈ Icc 0 (T : ℝ)) :
+      (T : ℝ)-s ∈ Icc 0 (T : ℝ) :=
+    ⟨sub_nonneg.mpr hs.2,sub_le_self _ hs.1⟩
+  have hu (s : ℝ) (hs : s ∈ Icc 0 (T : ℝ)) : HasDerivWithinAt u
+      (-b' ((T : ℝ)-s)) (Icc 0 (T : ℝ)) s := by
+    have hi : HasDerivWithinAt (fun t : ℝ => (T : ℝ)-t) (-1) (Icc 0 (T : ℝ)) s := by
+      simpa using ((hasDerivAt_id s).const_sub (T : ℝ)).hasDerivWithinAt
+    convert! (hd _ (hreflect s hs)).comp s hi hreflect using 1
+    simp only [mul_neg,mul_one]
+  have hQ (s : ℝ) (hs : s ∈ Icc 0 (T : ℝ)) : HasDerivWithinAt q
+      (-2/(q s-(u s : ℂ))) (Icc 0 (T : ℝ)) s :=
+    (hqd s hs.1).mono Icc_subset_Ici_self
+  have hp (s : ℝ) (hs : s ∈ Icc 0 (T : ℝ)) : 0 < (q s).im :=
+    hy.trans_le (by simpa using hqy s hs.1)
+  have hsub : Icc 0 a ⊆ Icc 0 (T : ℝ) := Icc_subset_Icc_right haT
+  have hshort := reverse_loewner_height_lower hL q u (fun s => -b' ((T : ℝ)-s))
+    (fun s hs => (hQ s (hsub hs)).mono hsub)
+    (fun s hs => (hu s (hsub hs)).mono hsub)
+    (fun s hs => by simpa using hb _ (hreflect s (hsub hs)))
+    (fun s hs => hp s (hsub hs)) (by simp [hq0,u,driverValue]) hsmall a ⟨ha.le,le_rfl⟩
+  have hmono := reverse_height_monotone q u hQ hp
+  have hle := hmono ⟨ha.le,haT⟩ ⟨T.coe_nonneg,le_rfl⟩ haT
+  rw [heq]
+  nlinarith [hp a ⟨ha.le,haT⟩,hp T ⟨T.coe_nonneg,le_rfl⟩]
+
+lemma smooth_raw_trace_height_lower (b : Driver) (T : ℝ≥0) (b' : ℝ → ℝ)
+    (hd : ∀ t ∈ Icc 0 (T : ℝ), HasDerivWithinAt (driverValue b)
+      (b' t) (Icc 0 (T : ℝ)) t)
+    {L a : ℝ} (hL : 0 ≤ L) (ha : 0 < a) (haT : a ≤ T)
+    (hb : ∀ t ∈ Icc 0 (T : ℝ), |b' t| ≤ L) (hsmall : L^2*a ≤ 1) :
+    2*a ≤ (trace 1 b T).im^2 := by
+  have ht := tendsto_inverseFlow_smooth_trace b T b' hd hL hb
+  apply ge_of_tendsto ((Complex.continuous_im.continuousAt.tendsto.comp ht).pow 2)
+  filter_upwards [self_mem_nhdsWithin] with y hy
+  exact smooth_raw_inverse_height_lower b T b' hd hL ha haT hb hsmall hy
+
+theorem smooth_raw_trace_mem_upperHalfPlane (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) :
+    trace 1 b T ∈ upperHalfPlane := by
+  obtain ⟨a,ha,haT,hs⟩ := exists_smooth_window T (by exact_mod_cast hT) L
+  have hl := smooth_raw_trace_height_lower b T b' hd hL ha haT hb hs
+  have hn := (smooth_raw_trace_position_bounds b T b' hd hL hb).2.1
+  change 0 < (trace 1 b T).im
+  nlinarith
+
+end SLEExactGauge.Target
+
+end
+
+end OAI
diff --git a/lean/OAI/Probability/SLE/Loewner/SmoothReverseContraction.lean b/lean/OAI/Probability/SLE/Loewner/SmoothReverseContraction.lean
new file mode 100644
index 0000000000000000000000000000000000000000..0a9a6b63b0db92a40bdbcc3211b1767b789ba7a3
--- /dev/null
+++ b/lean/OAI/Probability/SLE/Loewner/SmoothReverseContraction.lean
@@ -0,0 +1,94 @@
+import OAI.Probability.SLE.Loewner.SmoothReverseLoewner
+
+namespace OAI
+
+/-! Short reverse trajectories from the vertical line over a smooth
+driver contract. This gives a uniform Cauchy estimate at zero starting
+height without assuming that a trace already exists. -/
+noncomputable section
+open Set Filter Complex MeasureTheory
+open scoped Topology
+
+namespace SLEExactGauge
+
+theorem smooth_reverse_trajectories_contract {T L : ℝ} (hT : 0 ≤ T) (hL : 0 ≤ L)
+    (q r : ℝ → ℂ) (u u' : ℝ → ℝ)
+    (hq : ∀ t ∈ Icc 0 T, HasDerivWithinAt q (-2/(q t-(u t : ℂ))) (Icc 0 T) t)
+    (hr : ∀ t ∈ Icc 0 T, HasDerivWithinAt r (-2/(r t-(u t : ℂ))) (Icc 0 T) t)
+    (hu : ∀ t ∈ Icc 0 T, HasDerivWithinAt u (u' t) (Icc 0 T) t)
+    (hb : ∀ t ∈ Icc 0 T, |u' t| ≤ L)
+    (hqp : ∀ t ∈ Icc 0 T, 0 < (q t).im)
+    (hrp : ∀ t ∈ Icc 0 T, 0 < (r t).im)
+    (hq0 : (q 0).re=u 0) (hr0 : (r 0).re=u 0)
+    (hsmall : L^2*T ≤ 1) : dist (q T) (r T) ≤ dist (q 0) (r 0) := by
+  have hqc : ContinuousOn q (Icc 0 T) := fun t ht => (hq t ht).continuousWithinAt
+  have hrc : ContinuousOn r (Icc 0 T) := fun t ht => (hr t ht).continuousWithinAt
+  have huc : ContinuousOn u (Icc 0 T) := fun t ht => (hu t ht).continuousWithinAt
+  have hqx := (reverse_centered_coordinates hL q u u' hq hu hb hqp hq0).1
+  have hrx := (reverse_centered_coordinates hL r u u' hr hu hb hrp hr0).1
+  have hqy := reverse_loewner_height_lower hL q u u' hq hu hb hqp hq0 hsmall
+  have hry := reverse_loewner_height_lower hL r u u' hr hu hb hrp hr0 hsmall
+  let c (t : ℝ) : ℂ := 2/((q t-(u t : ℂ))*(r t-(u t : ℂ)))
+  have hqn (t : ℝ) (ht : t ∈ Icc 0 T) : q t-(u t : ℂ) ≠ 0 := by
+    intro he
+    have hh := congrArg Complex.im he
+    simp only [Complex.sub_im,Complex.ofReal_im,sub_zero,Complex.zero_im] at hh
+    exact (hqp t ht).ne' hh
+  have hrn (t : ℝ) (ht : t ∈ Icc 0 T) : r t-(u t : ℂ) ≠ 0 := by
+    intro he
+    have hh := congrArg Complex.im he
+    simp only [Complex.sub_im,Complex.ofReal_im,sub_zero,Complex.zero_im] at hh
+    exact (hrp t ht).ne' hh
+  have hc : ContinuousOn c (Icc 0 T) := continuousOn_const.div
+    ((hqc.sub (Complex.continuous_ofReal.comp_continuousOn huc)).mul
+      (hrc.sub (Complex.continuous_ofReal.comp_continuousOn huc)))
+    (fun t ht => mul_ne_zero (hqn t ht) (hrn t ht))
+  have hcn (t : ℝ) (ht : t ∈ Icc 0 T) : (c t).re ≤ 0 := by
+    have hprod : ((q t).re-u t)*((r t).re-u t) ≤ (L*t)^2 := by
+      calc
+        _ ≤ |((q t).re-u t)*((r t).re-u t)| := le_abs_self _
+        _ = |(q t).re-u t| * |(r t).re-u t| := abs_mul _ _
+        _ ≤ (L*t)*(L*t) := mul_le_mul (hqx t ht) (hrx t ht)
+          (abs_nonneg _) (mul_nonneg hL ht.1)
+        _ = _ := (pow_two _).symm
+    have hroot : (Real.sqrt (2*t))^2=2*t := Real.sq_sqrt (mul_nonneg (by norm_num) ht.1)
+    have hqroot : Real.sqrt (2*t) ≤ (q t).im := by
+      nlinarith [Real.sqrt_nonneg (2*t),hqp t ht,hqy t ht]
+    have hrroot : Real.sqrt (2*t) ≤ (r t).im := by
+      nlinarith [Real.sqrt_nonneg (2*t),hrp t ht,hry t ht]
+    have hyy : 2*t ≤ (q t).im*(r t).im := by
+      nlinarith [mul_le_mul hqroot hrroot (Real.sqrt_nonneg (2*t)) (hqp t ht).le]
+    have hsmallt := (mul_le_mul_of_nonneg_left ht.2 (sq_nonneg L)).trans hsmall
+    have hxx : ((q t).re-u t)*((r t).re-u t) ≤ t := by
+      nlinarith [mul_le_mul_of_nonneg_right hsmallt ht.1]
+    have hreal : ((q t-(u t : ℂ))*(r t-(u t : ℂ))).re ≤ 0 := by
+      simp only [Complex.mul_re,Complex.sub_re,Complex.ofReal_re,
+        Complex.sub_im,Complex.ofReal_im,sub_zero]
+      linarith [ht.1]
+    dsimp [c]
+    simp only [Complex.div_re,Complex.re_ofNat,Complex.im_ofNat,zero_mul,zero_div,add_zero]
+    apply div_nonpos_of_nonpos_of_nonneg
+    · nlinarith
+    · exact Complex.normSq_nonneg _
+  have hd (t : ℝ) (ht : t ∈ Icc 0 T) : HasDerivWithinAt (fun s => q s-r s)
+      (c t*(q t-r t)) (Icc 0 T) t := by
+    convert (hq t ht).sub (hr t ht) using 1
+    dsimp [c]
+    field_simp [hqn t ht,hrn t ht]
+    ring
+  have he := complex_linear_ode_exp T hT (fun t => q t-r t) c hc hd
+  have hi : (∫ t in (0 : ℝ)..T, (c t).re) ≤ 0 := by
+    have hh := intervalIntegral.integral_mono_on hT
+      ((Complex.continuous_re.comp_continuousOn hc).intervalIntegrable_of_Icc hT)
+      (intervalIntegrable_const (μ := volume) (c := (0 : ℝ))) hcn
+    simpa only [intervalIntegral.integral_zero,Function.comp_def] using hh
+  have hir : (∫ t in (0 : ℝ)..T, (c t).re) = (∫ t in (0 : ℝ)..T, c t).re :=
+    Complex.reCLM.intervalIntegral_comp_comm (hc.intervalIntegrable_of_Icc hT)
+  rw [dist_eq_norm,dist_eq_norm,he,norm_mul,Complex.norm_exp,← hir]
+  exact mul_le_of_le_one_right (norm_nonneg _) (Real.exp_le_one_iff.mpr hi)
+
+end SLEExactGauge
+
+end
+
+end OAI
diff --git a/lean/OAI/Probability/SLE/Loewner/SmoothReverseLoewner.lean b/lean/OAI/Probability/SLE/Loewner/SmoothReverseLoewner.lean
new file mode 100644
index 0000000000000000000000000000000000000000..70e8d006d23b378913122f51074a2a979fd368af
--- /dev/null
+++ b/lean/OAI/Probability/SLE/Loewner/SmoothReverseLoewner.lean
@@ -0,0 +1,117 @@
+import OAI.Probability.SLE.Loewner.ReverseSmoothBounds
+
+namespace OAI
+
+/-! Uniform height estimates for reverse Loewner trajectories driven by a
+function with bounded derivative. -/
+noncomputable section
+open Set Filter Complex
+open scoped Topology NNReal
+
+namespace SLEExactGauge
+
+lemma reverse_centered_coordinates {T L : ℝ} (hL : 0 ≤ L)
+    (q : ℝ → ℂ) (u u' : ℝ → ℝ)
+    (hq : ∀ t ∈ Icc 0 T, HasDerivWithinAt q
+      (-2/(q t-(u t : ℂ))) (Icc 0 T) t)
+    (hu : ∀ t ∈ Icc 0 T, HasDerivWithinAt u (u' t) (Icc 0 T) t)
+    (hbound : ∀ t ∈ Icc 0 T, |u' t| ≤ L)
+    (hpos : ∀ t ∈ Icc 0 T, 0 < (q t).im)
+    (hstart : (q 0).re=u 0) :
+    (∀ t ∈ Icc 0 T, |(q t).re-u t| ≤ L*t) ∧
+    (∀ t ∈ Icc 0 T, HasDerivWithinAt (fun s => (q s).im)
+      (2*(q t).im/(((q t).re-u t)^2+(q t).im^2)) (Icc 0 T) t) := by
+  let D (t : ℝ) := ((q t).re-u t)^2+(q t).im^2
+  have hD (t : ℝ) (ht : t ∈ Icc 0 T) : 0 < D t := by
+    have hp := hpos t ht
+    dsimp [D]
+    positivity
+  have hre (t : ℝ) (ht : t ∈ Icc 0 T) : HasDerivWithinAt
+      (fun s => (q s).re-u s) (-2*((q t).re-u t)/D t-u' t) (Icc 0 T) t := by
+    have hd := (Complex.reCLM.hasFDerivAt.comp_hasDerivWithinAt t (hq t ht)).sub (hu t ht)
+    change HasDerivWithinAt (fun s => (q s).re-u s)
+      ((-2/(q t-(u t : ℂ))).re-u' t) (Icc 0 T) t at hd
+    have he : (-2/(q t-(u t : ℂ))).re = -2*((q t).re-u t)/D t := by
+      simp [D,Complex.div_re,Complex.normSq_apply,pow_two]
+    rwa [he] at hd
+  refine ⟨damped_real_abs_barrier hL (fun s => (q s).re-u s) (fun s => -u' s) D
+    (sub_eq_zero.mpr hstart) (fun t ht => ?_) hD (fun t ht => by simpa using hbound t ht),?_⟩
+  · convert hre t ht using 1
+  · intro t ht
+    have hd := Complex.imCLM.hasFDerivAt.comp_hasDerivWithinAt t (hq t ht)
+    change HasDerivWithinAt (fun s => (q s).im)
+      ((-2/(q t-(u t : ℂ))).im) (Icc 0 T) t at hd
+    have he : (-2/(q t-(u t : ℂ))).im =
+        2*(q t).im/(((q t).re-u t)^2+(q t).im^2) := by
+      simp [Complex.div_im,Complex.normSq_apply,pow_two]
+      ring
+    rwa [he] at hd
+
+theorem reverse_loewner_height_lower {T L : ℝ} (hL : 0 ≤ L)
+    (q : ℝ → ℂ) (u u' : ℝ → ℝ)
+    (hq : ∀ t ∈ Icc 0 T, HasDerivWithinAt q
+      (-2/(q t-(u t : ℂ))) (Icc 0 T) t)
+    (hu : ∀ t ∈ Icc 0 T, HasDerivWithinAt u (u' t) (Icc 0 T) t)
+    (hbound : ∀ t ∈ Icc 0 T, |u' t| ≤ L)
+    (hpos : ∀ t ∈ Icc 0 T, 0 < (q t).im)
+    (hstart : (q 0).re=u 0) (hsmall : L^2*T ≤ 1) :
+    ∀ t ∈ Icc 0 T, 2*t ≤ (q t).im^2 := by
+  obtain ⟨hx,hy⟩ := reverse_centered_coordinates hL q u u' hq hu hbound hpos hstart
+  exact reverse_height_square_barrier (fun s => (q s).re-u s) (fun s => (q s).im)
+    hpos hy hx (fun t ht =>
+      (mul_le_mul_of_nonneg_left ht.2 (sq_nonneg L)).trans hsmall)
+
+theorem IsCapacityTwoWitness.inverse_tip_height_lower
+    {U : ℝ≥0 → ℝ} {γ : ℝ≥0 → ℂ} {G F : ℝ≥0 → ℂ → ℂ}
+    (h : IsCapacityTwoWitness U γ G F) (T : ℝ≥0) (U' : ℝ → ℝ)
+    (hd : ∀ t ∈ Icc 0 (T : ℝ), HasDerivWithinAt (fun s => U s.toNNReal)
+      (U' t) (Icc 0 (T : ℝ)) t)
+    {L : ℝ} (hL : 0 ≤ L) (hbound : ∀ t ∈ Icc 0 (T : ℝ), |U' t| ≤ L)
+    (hsmall : L^2*(T : ℝ) ≤ 1) {y : ℝ} (hy : 0 < y) :
+    2*(T : ℝ) ≤ (F T ((U T : ℂ)+(y : ℂ)*I)).im^2 := by
+  let w : ℂ := (U T : ℂ)+(y : ℂ)*I
+  have hw : w ∈ upperHalfPlane := by simpa [w,upperHalfPlane] using hy
+  let q (s : ℝ) := G ((T : ℝ)-s).toNNReal (F T w)
+  let u (s : ℝ) := U ((T : ℝ)-s).toNNReal
+  have hreflect (s : ℝ) (hs : s ∈ Icc 0 (T : ℝ)) :
+      (T : ℝ)-s ∈ Icc 0 (T : ℝ) := ⟨sub_nonneg.mpr hs.2,sub_le_self _ hs.1⟩
+  have hu (s : ℝ) (hs : s ∈ Icc 0 (T : ℝ)) : HasDerivWithinAt u
+      (-U' ((T : ℝ)-s)) (Icc 0 (T : ℝ)) s := by
+    have hi : HasDerivWithinAt (fun r : ℝ => (T : ℝ)-r) (-1)
+        (Icc 0 (T : ℝ)) s := by
+      simpa using ((hasDerivAt_id s).const_sub (T : ℝ)).hasDerivWithinAt
+    simpa only [Function.comp_def,mul_neg,mul_one] using
+      (hd _ (hreflect s hs)).comp s hi hreflect
+  have hq0 : q 0=w := by
+    simp only [q,sub_zero,Real.toNNReal_coe]
+    exact h.2.2.2.2.2.2.2.2.1 T w hw
+  have hqT : q T=F T w := by
+    simp only [q,sub_self,Real.toNNReal_zero]
+    exact h.initial_value _ (h.2.2.2.2.2.2.1 T hw).1.1
+  have hh := reverse_loewner_height_lower hL q u
+    (fun s => -U' ((T : ℝ)-s)) (fun s hs => h.reverse_path_unclipped T hw hs) hu
+    (fun s hs => by simpa using hbound _ (hreflect s hs))
+    (fun s hs => h.imag_positive _ _ (survivingDomain_antitone γ
+      ((Real.toNNReal_le_iff_le_coe).mpr (hreflect s hs).2) (h.2.2.2.2.2.2.1 T hw)))
+    (by simp [hq0,w,u]) hsmall T ⟨T.coe_nonneg,le_rfl⟩
+  simpa only [hqT,w] using hh
+
+theorem IsCapacityTwoWitness.smooth_trace_height_lower
+    {U : ℝ≥0 → ℝ} {γ : ℝ≥0 → ℂ} {G F : ℝ≥0 → ℂ → ℂ}
+    (h : IsCapacityTwoWitness U γ G F) (T : ℝ≥0) (U' : ℝ → ℝ)
+    (hd : ∀ t ∈ Icc 0 (T : ℝ), HasDerivWithinAt (fun s => U s.toNNReal)
+      (U' t) (Icc 0 (T : ℝ)) t)
+    {L : ℝ} (hL : 0 ≤ L) (hbound : ∀ t ∈ Icc 0 (T : ℝ), |U' t| ≤ L)
+    (hsmall : L^2*(T : ℝ) ≤ 1) :
+    2*(T : ℝ) ≤ (γ T).im^2 := by
+  have hl := ((Complex.continuous_im.continuousAt.tendsto.comp
+    (h.2.2.2.2.2.2.2.2.2.2.2.2 T)).pow 2)
+  apply ge_of_tendsto hl
+  filter_upwards [self_mem_nhdsWithin] with y hy
+  exact h.inverse_tip_height_lower T U' hd hL hbound hsmall hy
+
+end SLEExactGauge
+
+end
+
+end OAI
diff --git a/lean/OAI/Probability/SLE/Loewner/StoppedDriverConcatenation.lean b/lean/OAI/Probability/SLE/Loewner/StoppedDriverConcatenation.lean
new file mode 100644
index 0000000000000000000000000000000000000000..bcaa31d8bcfedc81ce6c4ba5b8f7f79ed524f557
--- /dev/null
+++ b/lean/OAI/Probability/SLE/Loewner/StoppedDriverConcatenation.lean
@@ -0,0 +1,152 @@
+import OAI.Probability.SLE.Loewner.RawRestartAdaptation
+
+namespace OAI
+
+/-! Reconstruct the old driver through τ+t from its stopped past at τ
+and the fresh prefix through t. The reconstruction is jointly measurable
+in exactly those two past sigma algebras. -/
+
+noncomputable section
+open Set Filter _root_.MeasureTheory _root_.OAI.MeasureTheory ProbabilityTheory
+open scoped Topology NNReal ENNReal
+
+namespace SLEExactGauge
+
+local instance concatDriverMeasurable : MeasurableSpace C(ℝ≥0,ℝ) := borel _
+local instance concatDriverBorel : BorelSpace C(ℝ≥0,ℝ) := ⟨rfl⟩
+
+def restartDriverPathAt (T : ℝ≥0) (p : C(ℝ≥0,ℝ)) : C(ℝ≥0,ℝ) :=
+  ⟨fun s => p (T+s)-p T,
+    (p.continuous.comp (continuous_const.add continuous_id)).sub continuous_const⟩
+
+def concatenateDriverPath (T : ℝ≥0) (p q : C(ℝ≥0,ℝ)) : C(ℝ≥0,ℝ) where
+  toFun s := if s ≤ T then p s else p T+q (s-T)-q 0
+  continuous_toFun := by
+    change Continuous ((Iic T).piecewise p (fun s => p T+q (s-T)-q 0))
+    apply Continuous.piecewise ?_ p.continuous
+      ((continuous_const.add (q.continuous.comp (continuous_id.sub continuous_const))).sub continuous_const)
+    intro s hs
+    have he : s=T := by simpa only [frontier_Iic,mem_singleton_iff] using hs
+    change p s = p T+q (s-T)-q 0
+    simp only [he,tsub_self,add_sub_cancel_right]
+
+lemma measurable_concatenateDriverPath :
+    Measurable (fun x : ℝ≥0 × (C(ℝ≥0,ℝ) × C(ℝ≥0,ℝ)) =>
+      concatenateDriverPath x.1 x.2.1 x.2.2) := by
+  apply source_path_measurable
+  intro s
+  have hp : Measurable (fun x : ℝ≥0 × (C(ℝ≥0,ℝ) × C(ℝ≥0,ℝ)) => x.2.1 s) :=
+    (continuous_eval_const s).measurable.comp (measurable_fst.comp measurable_snd)
+  have hpT : Measurable (fun x : ℝ≥0 × (C(ℝ≥0,ℝ) × C(ℝ≥0,ℝ)) => x.2.1 x.1) :=
+    continuous_eval.measurable.comp ((measurable_fst.comp measurable_snd).prodMk measurable_fst)
+  have hq : Measurable (fun x : ℝ≥0 × (C(ℝ≥0,ℝ) × C(ℝ≥0,ℝ)) => x.2.2 (s-x.1)) :=
+    continuous_eval.measurable.comp ((measurable_snd.comp measurable_snd).prodMk
+      (measurable_const.sub measurable_fst))
+  have hq0 : Measurable (fun x : ℝ≥0 × (C(ℝ≥0,ℝ) × C(ℝ≥0,ℝ)) => x.2.2 0) :=
+    (continuous_eval_const 0).measurable.comp (measurable_snd.comp measurable_snd)
+  exact hp.ite (measurableSet_le measurable_const measurable_fst) ((hpT.add hq).sub hq0)
+
+theorem stoppedDriverPath_concatenation (p : C(ℝ≥0,ℝ)) (T t : ℝ≥0) :
+    driverPathStopped (T+t) p = concatenateDriverPath T (driverPathStopped T p)
+      (driverPathStopped t (restartDriverPathAt T p)) := by
+  ext s
+  by_cases hs : s ≤ T
+  · have hs' : s ≤ T+t := hs.trans (le_add_of_nonneg_right (show 0 ≤ t from zero_le))
+    simp only [driverPathStopped,concatenateDriverPath,ContinuousMap.coe_mk,ite_eq_left hs,
+      min_eq_left hs,min_eq_left hs']
+  · have hTs : T ≤ s := (lt_of_not_ge hs).le
+    have he : T+min (s-T) t=min s (T+t) := by
+      rw [add_min,add_tsub_cancel_of_le hTs]
+    simp only [driverPathStopped,concatenateDriverPath,restartDriverPathAt,
+      ContinuousMap.coe_mk,ite_eq_right hs,min_self,zero_min,add_zero,he]
+    ring
+
+lemma restartDriverPathAt_add (p : C(ℝ≥0,ℝ)) (T t : ℝ≥0) :
+    restartDriverPathAt t (restartDriverPathAt T p)=restartDriverPathAt (T+t) p := by
+  ext s
+  change (p (T+(t+s))-p T)-(p (T+t)-p T)=p ((T+t)+s)-p (T+t)
+  rw [add_assoc]
+  ring
+
+lemma concatenate_stopped_restart (p : C(ℝ≥0,ℝ)) (t : ℝ≥0) :
+    concatenateDriverPath t (driverPathStopped t p) (restartDriverPathAt t p)=p := by
+  ext s
+  by_cases hs : s ≤ t
+  · simp only [concatenateDriverPath,driverPathStopped,ContinuousMap.coe_mk,
+      ite_eq_left hs,min_eq_left hs]
+  · have hts : t ≤ s := (lt_of_not_ge hs).le
+    simp only [concatenateDriverPath,driverPathStopped,restartDriverPathAt,ContinuousMap.coe_mk,
+      ite_eq_right hs,min_self,add_tsub_cancel_of_le hts,add_zero,sub_self,sub_zero]
+    ring
+
+lemma sourceRestartDriverPath_add
+    {Ω : Type*} (B : ℝ≥0 → Ω → ℝ) (hc : ∀ ω, Continuous (fun t => B t ω))
+    (τ : Ω → ℝ≥0) (t : ℝ≥0) (ω : Ω) :
+    restartDriverPathAt t (sourceRestartDriverPath B hc τ ω)=
+      sourceRestartDriverPath B hc (fun ω => τ ω+t) ω :=
+  restartDriverPathAt_add (sourceDriverPath B hc ω) (τ ω) t
+
+lemma sourceRestartDriverPath_split
+    {Ω : Type*} (B : ℝ≥0 → Ω → ℝ) (hc : ∀ ω, Continuous (fun t => B t ω))
+    (τ : Ω → ℝ≥0) (t : ℝ≥0) (ω : Ω) :
+    sourceRestartDriverPath B hc τ ω =
+      concatenateDriverPath t (driverPathStopped t (sourceRestartDriverPath B hc τ ω))
+        (sourceRestartDriverPath B hc (fun ω => τ ω+t) ω) := by
+  rw [←sourceRestartDriverPath_add]
+  exact (concatenate_stopped_restart _ _).symm
+
+lemma source_stoppedDriverPath_measurable
+    {Ω : Type*} [mΩ : 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[hτ.measurableSpace]
+      (fun ω => driverPathStopped (τ ω) (sourceDriverPath B hc ω)) := by
+  have hprog := (Filtration.stronglyAdapted_natural (fun t => (hm t).stronglyMeasurable)).isStronglyProgressive_of_continuous hc
+  let : MeasurableSpace Ω := hτ.measurableSpace
+  apply source_path_measurable
+  intro t
+  have hh := (measurable_stoppedValue hprog (hτ.min_const t)).mono
+    (IsStoppingTime.measurableSpace_mono (hτ.min_const t) hτ (fun _ => min_le_left _ _)) le_rfl
+  change Measurable[hτ.measurableSpace]
+    (fun ω => B ((min (τ ω : WithTop ℝ≥0) (t : WithTop ℝ≥0)).untopA) ω) at hh
+  change Measurable[hτ.measurableSpace] (fun ω => B (min t (τ ω)) ω)
+  simpa only [← WithTop.coe_min,WithTop.untopA,WithTop.untopD_coe,min_comm] using hh
+
+lemma source_stoppedDriverTime_measurable
+    {Ω : Type*} [mΩ : MeasurableSpace Ω] {ℱ : Filtration ℝ≥0 mΩ}
+    (τ : Ω → ℝ≥0) (hτ : IsStoppingTime ℱ (fun ω => (τ ω : WithTop ℝ≥0))) :
+    Measurable[hτ.measurableSpace] τ := by
+  convert hτ.measurable.untopA using 1
+  funext ω
+  rw [WithTop.untopA_eq_untop WithTop.coe_ne_top]
+  rfl
+
+theorem measurable_past_fresh_prefix_concatenation
+    {Ω : Type*} [mΩ : 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))) (t : ℝ≥0) :
+    Measurable[hτ.measurableSpace.prod (driverPathFiltration t)]
+      (fun x : Ω × C(ℝ≥0,ℝ) => concatenateDriverPath (τ x.1)
+        (driverPathStopped (τ x.1) (sourceDriverPath B hc x.1)) (driverPathStopped t x.2)) := by
+  exact measurable_concatenateDriverPath.comp
+    (((source_stoppedDriverTime_measurable τ hτ).comp measurable_fst).prodMk
+      (((source_stoppedDriverPath_measurable B hm hc τ hτ).comp measurable_fst).prodMk
+        ((driverPathStopped_measurable_past t).comp measurable_snd)))
+
+theorem source_stoppedDriverPath_restart_identity
+    {Ω : Type*} (B : ℝ≥0 → Ω → ℝ) (hc : ∀ ω, Continuous (fun t => B t ω))
+    (τ : Ω → ℝ≥0) (t : ℝ≥0) (ω : Ω) :
+    driverPathStopped (τ ω+t) (sourceDriverPath B hc ω) =
+      concatenateDriverPath (τ ω) (driverPathStopped (τ ω) (sourceDriverPath B hc ω))
+        (driverPathStopped t (sourceRestartDriverPath B hc τ ω)) := by
+  exact stoppedDriverPath_concatenation (sourceDriverPath B hc ω) (τ ω) t
+
+end SLEExactGauge
+
+end
+
+end OAI
diff --git a/lean/OAI/Probability/SLE/Loewner/StoppedInverseExhaustion.lean b/lean/OAI/Probability/SLE/Loewner/StoppedInverseExhaustion.lean
new file mode 100644
index 0000000000000000000000000000000000000000..a40520a95ce75092159b428c796007a829315446
--- /dev/null
+++ b/lean/OAI/Probability/SLE/Loewner/StoppedInverseExhaustion.lean
@@ -0,0 +1,119 @@
+import OAI.Probability.SLE.Loewner.StoppedInversePaths
+
+namespace OAI
+
+/-! Local terminal exhaustion survives the stopped conformal weighting.
+The pulled-back compact need not stay away from the real boundary: finite
+terminal weighted mass is the domination used for the limit. -/
+
+noncomputable section
+open Set Filter _root_.MeasureTheory _root_.OAI.MeasureTheory ProbabilityTheory
+open scoped NNReal ENNReal Topology CompactlySupported
+
+namespace SLEExactGauge
+
+local instance stoppedExhaustionLocallyCompact : LocallyCompactSpace upperHalfPlane :=
+  isOpen_upperHalfPlane.locallyCompactSpace
+
+lemma weightedImageMass_add
+    (J : upperHalfPlane → upperHalfPlane) (hJ : Measurable J)
+    (w : upperHalfPlane → ℝ≥0∞) (μ ν : Measure upperHalfPlane) :
+    weightedImageMass J w (μ+ν) = weightedImageMass J w μ + weightedImageMass J w ν := by
+  simp only [weightedImageMass,withDensity_add_measure]
+  exact Measure.map_add _ _ hJ
+
+lemma weightedImageMass_sub
+    (J : upperHalfPlane → upperHalfPlane) (hJ : Measurable J)
+    (w : upperHalfPlane → ℝ≥0∞) {μ ν : Measure upperHalfPlane}
+    [SigmaFinite μ] (hle : μ ≤ ν)
+    [IsFiniteMeasureOnCompacts (weightedImageMass J w ν)] :
+    weightedImageMass J w (ν-μ) = weightedImageMass J w ν-weightedImageMass J w μ := by
+  let := weightedImageMass_finite_on_compacts J hJ w hle
+  apply (Measure.add_left_inj (weightedImageMass J w μ) _ _).mp
+  calc
+    weightedImageMass J w (ν-μ)+weightedImageMass J w μ = weightedImageMass J w ν := by
+      rw [← weightedImageMass_add J hJ w,sigmaFinite_sub_add_cancel_of_le hle]
+    _ = (weightedImageMass J w ν-weightedImageMass J w μ)+weightedImageMass J w μ :=
+      (sigmaFinite_sub_add_cancel_of_le (weightedImageMass_mono J hJ w hle)).symm
+
+lemma weightedImageMass_terminal_exhaustion
+    (N : ℝ≥0 → Measure upperHalfPlane) (ν : Measure upperHalfPlane) [ν.Regular]
+    (hNr : ∀ t, (N t).Regular) (hdom : ∀ t, N t ≤ ν)
+    (hlim : ∀ K : Set upperHalfPlane, IsCompact K →
+      Tendsto (fun t : ℝ≥0 => (ν-N t) K) atTop (𝓝 0))
+    (J : upperHalfPlane → upperHalfPlane) (hJ : Measurable J)
+    (w : upperHalfPlane → ℝ≥0∞) (hw : Measurable w)
+    [IsFiniteMeasureOnCompacts (weightedImageMass J w ν)] :
+    ∀ K : Set upperHalfPlane, IsCompact K → Tendsto
+      (fun t : ℝ≥0 => (weightedImageMass J w ν-weightedImageMass J w (N t)) K)
+      atTop (𝓝 0) := by
+  intro K hK
+  let g : upperHalfPlane → ℝ≥0∞ := (J ⁻¹' K).indicator w
+  have hg : Measurable g := hw.indicator (hJ hK.measurableSet)
+  have hfin : (∫⁻ z, g z ∂ν) ≠ ∞ := by
+    rw [← weightedImageMass_apply J hJ w ν K hK.measurableSet]
+    exact hK.measure_lt_top.ne
+  have he (t : ℝ≥0) :
+      (weightedImageMass J w ν-weightedImageMass J w (N t)) K =
+        ∫⁻ z, g z ∂(ν-N t) := by
+    let := hNr t
+    rw [← weightedImageMass_sub J hJ w (hdom t),
+      weightedImageMass_apply J hJ w (ν-N t) K hK.measurableSet]
+  simpa only [he] using remaining_lintegral_tendsto_zero ν N hNr hdom hlim g hg hfin
+
+namespace Multipoint
+
+local instance stoppedExhaustionDriverMeasurable : MeasurableSpace C(ℝ≥0,ℝ) := borel _
+local instance stoppedExhaustionDriverBorel : BorelSpace C(ℝ≥0,ℝ) := ⟨rfl⟩
+
+variable {Ω : Type*} [mΩ : MeasurableSpace Ω]
+  (B : ℝ≥0 → Ω → ℝ) (κ : ℝ) (γ : Ω → ℝ≥0 → ℂ)
+  (G F : Ω → ℝ≥0 → ℂ → ℂ)
+  (hw : ∀ ω, IsCapacityTwoWitness (fun t => Real.sqrt κ*B t ω) (γ ω) (G ω) (F ω))
+  (τ : Ω → ℝ≥0) (hc : ∀ ω, Continuous (fun t => B t ω)) (R : RawCanonicalMass)
+  (hm : ∀ t, Measurable (B t))
+  (hτ : IsStoppingTime (Filtration.natural B (fun t => (hm t).stronglyMeasurable))
+    (fun ω => (τ ω : WithTop ℝ≥0)))
+
+include hm hτ in
+theorem stoppedFreshMass_terminal_exhaustion
+    {P : Measure Ω} (hκ : 0 < κ)
+    (hdom : ∀ᵐ ω ∂P, ∀ t, R.process t (sourceRestartDriverPath B hc τ ω) ≤
+      R.terminal (sourceRestartDriverPath B hc τ ω))
+    (hlim : ∀ᵐ ω ∂P, ∀ K : Set upperHalfPlane, IsCompact K → Tendsto
+      (fun t : ℝ≥0 => (R.terminal (sourceRestartDriverPath B hc τ ω)-
+        R.process t (sourceRestartDriverPath B hc τ ω)) K) atTop (𝓝 0))
+    (hfin : ∀ᵐ ω ∂P, IsFiniteMeasureOnCompacts (stoppedFreshTerminalMass B κ γ G F hw τ hc R ω)) :
+    ∀ᵐ ω ∂P, ∀ K : Set upperHalfPlane, IsCompact K → Tendsto
+      (fun t : ℝ≥0 => (stoppedFreshTerminalMass B κ γ G F hw τ hc R ω-
+        stoppedFreshMass B κ γ G F hw τ hc R t ω) K) atTop (𝓝 0) := by
+  have hJ := stoppedMassPoint_measurable B κ γ G F hw τ hm hc hτ
+  have hW := stoppedMassWeight_measurable B κ γ G F hw τ hm hc hτ hκ
+  filter_upwards [hdom,hlim,hfin] with ω hd hl hf
+  let J := stoppedMassPoint B κ γ G F hw τ ω
+  let w := stoppedMassWeight B κ F τ ω
+  have hpair : @Measurable upperHalfPlane (Ω × upperHalfPlane) inferInstance
+      (hτ.measurableSpace.prod inferInstance) (fun z => (ω,z)) :=
+    @measurable_prodMk_left Ω upperHalfPlane hτ.measurableSpace inferInstance ω
+  have hJm : Measurable J :=
+    @Measurable.comp upperHalfPlane (Ω × upperHalfPlane) upperHalfPlane
+      inferInstance (hτ.measurableSpace.prod inferInstance) inferInstance
+      (fun p => stoppedMassPoint B κ γ G F hw τ p.1 p.2) (fun z => (ω,z)) hJ hpair
+  have hwm : Measurable w :=
+    @Measurable.comp upperHalfPlane (Ω × upperHalfPlane) ℝ≥0∞
+      inferInstance (hτ.measurableSpace.prod inferInstance) inferInstance
+      (fun p => stoppedMassWeight B κ F τ p.1 p.2) (fun z => (ω,z)) hW hpair
+  let N := fun t => R.process t (sourceRestartDriverPath B hc τ ω)
+  let ν := R.terminal (sourceRestartDriverPath B hc τ ω)
+  change ∀ K : Set upperHalfPlane, IsCompact K → Tendsto
+    (fun t : ℝ≥0 => (weightedImageMass J w ν-weightedImageMass J w (N t)) K) atTop (𝓝 0)
+  exact @weightedImageMass_terminal_exhaustion N ν
+    (R.terminal_radon (sourceRestartDriverPath B hc τ ω)).1
+    (fun t => (R.radon t _).1) hd hl J hJm w hwm hf
+
+end Multipoint
+end SLEExactGauge
+
+end
+
+end OAI
diff --git a/lean/OAI/Probability/SLE/Loewner/StoppedInverseGreenMean.lean b/lean/OAI/Probability/SLE/Loewner/StoppedInverseGreenMean.lean
new file mode 100644
index 0000000000000000000000000000000000000000..55c169489a6a0a1dc56a11b843a14f6364de052b
--- /dev/null
+++ b/lean/OAI/Probability/SLE/Loewner/StoppedInverseGreenMean.lean
@@ -0,0 +1,110 @@
+import OAI.Probability.SLE.Mass.StoppedInverseMass
+import OAI.Probability.SLE.Geometry.RestartHalfPlaneGreen
+import OAI.Probability.SLE.Loewner.FreshCapacityWitness
+
+namespace OAI
+
+/-! The actual weighted fresh terminal mass has exactly the same stopped
+Green kernel as the remaining original 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⟩
+
+variable {Ω : Type*} [mΩ : MeasurableSpace Ω] {P : Measure Ω} [IsProbabilityMeasure P]
+  {κ : ℝ} {B : ℝ≥0 → Ω → ℝ} {hBm : Measurable (Function.uncurry B)}
+  {γ : Ω → ℝ≥0 → ℂ} {G : Ω → ℝ≥0 → ℂ → ℂ}
+  (C : CanonicalMass P κ B hBm γ G)
+  (hB : IsBrownianReal B P) (hc : ∀ ω, Continuous (fun t => B t ω)) (hκ : 0 < κ)
+  (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) : Measurable (B t)).stronglyMeasurable))
+    (fun ω => (τ ω:WithTop ℝ≥0)))
+  (R : RawCanonicalMass)
+  (he : ∀ᵐ ω ∂P, R.terminal (sourceDriverPath B hc ω)=C.rational.terminal ω)
+  (hFresh : ∀ᵐ ω ∂P, ∃ (β : ℝ≥0 → ℂ) (G' F' : ℝ≥0 → ℂ → ℂ),
+    IsCapacityTwoWitness (fun t => Real.sqrt κ*B (τ ω+t) ω-Real.sqrt κ*B (τ ω) ω) β G' F')
+
+include C hB hc hκ F hw τ hτ R he hFresh in
+theorem CanonicalMass.stoppedFreshTerminalMass_green_test
+    (f : Ω × upperHalfPlane → ℝ≥0∞)
+    (hf : Measurable[hτ.measurableSpace.prod inferInstance] f) :
+    (∫⁻ ω, ∫⁻ x, f (ω,x) ∂(stoppedFreshTerminalMass B κ γ G F hw τ hc R ω) ∂P) =
+      ∫⁻ ω, ∫⁻ x, f (ω,x) ∂halfPlaneGreenMeasure κ B γ G (τ ω) ω ∂P := by
+  rw [C.stoppedFreshTerminalMass_test B κ γ G F hw τ
+    (fun t => hBm.comp (measurable_const.prodMk measurable_id)) hc hτ hB hκ R he f hf]
+  apply lintegral_congr_ae
+  filter_upwards [hFresh] with ω hω
+  obtain ⟨β,G',F',hb⟩ := hω
+  exact restart_halfPlane_green_test (hw ω) ((hc ω).const_mul _) (τ ω) hb hκ
+    (fun x => f (ω,x))
+
+omit [IsProbabilityMeasure P] in
+lemma past_rectangle_lintegral
+    (μ : Ω → Measure upperHalfPlane) (E : Set Ω) (hE : MeasurableSet E)
+    (A : Set upperHalfPlane) (hA : MeasurableSet A) :
+    (∫⁻ ω, ∫⁻ z, (E ×ˢ A).indicator (fun _ => (1:ℝ≥0∞)) (ω,z) ∂μ ω ∂P) =
+      ∫⁻ ω in E, μ ω A ∂P := by
+  rw [← lintegral_indicator hE]
+  apply lintegral_congr
+  intro ω
+  by_cases hω : ω ∈ E
+  · have hsec : (fun z => (E ×ˢ A).indicator (fun _ => (1:ℝ≥0∞)) (ω,z)) =
+        A.indicator (fun _ => 1) := by
+      funext z
+      simp only [Set.indicator,Set.mem_prod,hω,true_and]
+    rw [hsec,lintegral_indicator hA,lintegral_one]
+    simp only [Set.indicator_of_mem hω,Measure.restrict_apply_univ]
+  · have hsec : (fun z => (E ×ˢ A).indicator (fun _ => (1:ℝ≥0∞)) (ω,z)) = 0 := by
+      funext z
+      simp only [Set.indicator,Set.mem_prod,hω,false_and,ite_false,Pi.zero_apply]
+    rw [hsec]
+    change (∫⁻ z, (0:ℝ≥0∞) ∂μ ω) = _
+    simp only [lintegral_zero,Set.indicator_of_notMem hω]
+
+include C hB hc hκ F hw τ hτ R he hFresh in
+theorem CanonicalMass.stoppedFreshTerminalMass_kernel
+    (E : Set Ω) (hE : MeasurableSet[hτ.measurableSpace] E) :
+    (P.restrict E).bind (stoppedFreshTerminalMass B κ γ G F hw τ hc R) =
+      (P.restrict E).bind (fun ω => halfPlaneGreenMeasure κ B γ G (τ ω) ω) := by
+  have hm (t : ℝ≥0) : Measurable (B t) := hBm.comp (measurable_const.prodMk measurable_id)
+  have hμ := stoppedFreshTerminalMass_measurable B κ γ G F hw τ hm hc hτ hκ R
+  have hν : Measurable (fun ω => halfPlaneGreenMeasure κ B γ G (τ ω) ω) := by
+    apply Measure.measurable_of_measurable_coe
+    intro A hA
+    have hAI := (MeasurableEmbedding.subtype_coe isOpen_upperHalfPlane.measurableSet).measurableSet_image.mpr hA
+    simp only [halfPlaneGreenMeasure,comap_subtype_coe_apply isOpen_upperHalfPlane.measurableSet,
+      withDensity_apply _ hAI]
+    exact (actual_greenDensity_random_time_joint_measurable hBm hc κ γ G F hw τ
+      (stopping_time_measurable_nnreal hτ)).ennreal_ofReal.lintegral_prod_right'
+  apply Measure.ext
+  intro A hA
+  rw [Measure.bind_apply hA hμ.aemeasurable,Measure.bind_apply hA hν.aemeasurable]
+  have ht := C.stoppedFreshTerminalMass_green_test hB hc hκ F hw τ hτ R he hFresh
+    ((E ×ˢ A).indicator (fun _ => 1)) (measurable_const.indicator (hE.prod hA))
+  rw [past_rectangle_lintegral _ E (hτ.measurableSpace_le E hE) A hA,
+    past_rectangle_lintegral _ E (hτ.measurableSpace_le E hE) A hA] at ht
+  exact ht
+
+include C hB hc hκ F hw τ hτ R he in
+theorem CanonicalMass.stoppedFreshTerminalMass_published_kernel
+    (hpublished : PublishedTraceGeneration (P.map (sourceDriverPath B hc)) κ (fun t p => p t))
+    (E : Set Ω) (hE : MeasurableSet[hτ.measurableSpace] E) :
+    (P.restrict E).bind (stoppedFreshTerminalMass B κ γ G F hw τ hc R) =
+      (P.restrict E).bind (fun ω => halfPlaneGreenMeasure κ B γ G (τ ω) ω) := by
+  exact C.stoppedFreshTerminalMass_kernel hB hc hκ F hw τ hτ R he
+    (fresh_capacity_witness_exists hB
+      (fun t => hBm.comp (measurable_const.prodMk measurable_id)) hc hpublished τ hτ) E hE
+
+end SLEExactGauge.Multipoint
+
+end
+
+end OAI
diff --git a/lean/OAI/Probability/SLE/Loewner/StoppedInverseKernel.lean b/lean/OAI/Probability/SLE/Loewner/StoppedInverseKernel.lean
new file mode 100644
index 0000000000000000000000000000000000000000..ed80d8bfe94738ea98e05dea0772bca32d79dae7
--- /dev/null
+++ b/lean/OAI/Probability/SLE/Loewner/StoppedInverseKernel.lean
@@ -0,0 +1,137 @@
+import OAI.Probability.SLE.Loewner.RawRestartRandomTests
+import OAI.Probability.SLE.Geometry.StoppedFutureGreen
+import OAI.Probability.SLE.Loewner.StoppedInversePaths
+
+namespace OAI
+
+/-! The actual inverse image of the fresh canonical mass has the original
+Green remainder kernel in the full filtration after the restart. -/
+
+noncomputable section
+open Set Filter _root_.MeasureTheory _root_.OAI.MeasureTheory ProbabilityTheory Classical
+open scoped NNReal ENNReal Topology
+
+namespace SLEExactGauge.Multipoint
+
+lemma weightedImageMass_add (J : upperHalfPlane → upperHalfPlane) (hJ : Measurable J)
+    (w : upperHalfPlane → ℝ≥0∞) (μ ν : Measure upperHalfPlane) :
+    weightedImageMass J w (μ+ν)=weightedImageMass J w μ+weightedImageMass J w ν := by
+  simp only [weightedImageMass,withDensity_add_measure]
+  exact Measure.map_add _ _ hJ
+
+lemma weighted_rectangle_lintegral
+    {Ω : Type*} [MeasurableSpace Ω] (P : Measure Ω)
+    (μ : Ω → Measure upperHalfPlane)
+    (J : Ω → upperHalfPlane → upperHalfPlane) (hJ : ∀ ω, Measurable (J ω))
+    (w : Ω → upperHalfPlane → ℝ≥0∞) (hw : ∀ ω, Measurable (w ω))
+    (E : Set Ω) (hE : MeasurableSet E) (A : Set upperHalfPlane) (hA : MeasurableSet A) :
+    (∫⁻ ω, ∫⁻ z, w ω z * (E ×ˢ A).indicator (fun _ => 1) (ω,J ω z) ∂μ ω ∂P) =
+      ∫⁻ ω in E, weightedImageMass (J ω) (w ω) (μ ω) A ∂P := by
+  have he (ω : Ω) :
+      (∫⁻ z, w ω z * (E ×ˢ A).indicator (fun _ => 1) (ω,J ω z) ∂μ ω) =
+      ∫⁻ x, (E ×ˢ A).indicator (fun _ => 1) (ω,x)
+        ∂weightedImageMass (J ω) (w ω) (μ ω) := by
+    exact (weightedImageMass_lintegral _ (hJ ω) _ (hw ω) _ _
+      ((measurable_const.indicator (hE.prod hA)).comp measurable_prodMk_left)).symm
+  simp_rw [he]
+  exact past_rectangle_lintegral _ E hE A hA
+
+local instance stoppedKernelDriverMeasurable : MeasurableSpace C(ℝ≥0,ℝ) := borel _
+local instance stoppedKernelDriverBorel : BorelSpace C(ℝ≥0,ℝ) := ⟨rfl⟩
+
+variable {Ω : Type*} [mΩ : MeasurableSpace Ω] {P : Measure Ω} [IsProbabilityMeasure P]
+  {κ : ℝ} {B : ℝ≥0 → Ω → ℝ} {hBm : Measurable (Function.uncurry B)}
+  {γ : Ω → ℝ≥0 → ℂ} {G : Ω → ℝ≥0 → ℂ → ℂ}
+  (C : CanonicalMass P κ B hBm γ G) (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 ω)
+  (τ : Ω → ℝ≥0)
+  (hτ : IsStoppingTime (Filtration.natural B (fun s =>
+    (hBm.comp (measurable_const.prodMk measurable_id) : Measurable (B s)).stronglyMeasurable))
+    (fun ω => (τ ω:WithTop ℝ≥0)))
+  (hFresh : ∀ᵐ ω ∂P, ∃ (β : ℝ≥0 → ℂ) (G' F' : ℝ≥0 → ℂ → ℂ),
+    IsCapacityTwoWitness (fun t => Real.sqrt κ*B (τ ω+t) ω-Real.sqrt κ*B (τ ω) ω) β G' F')
+
+include C hB hc hκ F hw R he τ hτ hFresh in
+theorem CanonicalMass.stoppedFreshMass_green_kernel
+    (t : ℝ≥0) (E : Set Ω) (hE : MeasurableSet[shiftedStoppingFiltration hτ t] E) :
+    (P.restrict E).bind (stoppedFreshTerminalMass B κ γ G F hw τ hc R) =
+      (P.restrict E).bind (stoppedFreshMass B κ γ G F hw τ hc R t)+
+      (P.restrict E).bind (fun ω => halfPlaneGreenMeasure κ B γ G (τ ω+t) ω) := by
+  have hm (s : ℝ≥0) : Measurable (B s) := hBm.comp (measurable_const.prodMk measurable_id)
+  have hTm := stoppedFreshTerminalMass_measurable B κ γ G F hw τ hm hc hτ hκ R
+  have hNm := (stoppedFreshMass_adapted B κ γ G F hw τ hc R hm hτ hκ).measurable (i := t)
+  have hGm : Measurable (fun ω => halfPlaneGreenMeasure κ B γ G (τ ω+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 [halfPlaneGreenMeasure,comap_subtype_coe_apply isOpen_upperHalfPlane.measurableSet,
+      withDensity_apply _ hAI]
+    exact (actual_greenDensity_random_time_joint_measurable hBm hc κ γ G F hw
+      (fun ω => τ ω+t) (stopping_time_measurable_nnreal (stopping_time_add_nnreal hτ t))).ennreal_ofReal.lintegral_prod_right'
+  have hle : hτ.measurableSpace ≤ shiftedStoppingFiltration hτ t :=
+    IsStoppingTime.measurableSpace_mono hτ (stopping_time_add_nnreal hτ t)
+      (fun ω => WithTop.coe_le_coe.mpr (le_add_of_nonneg_right (show 0 ≤ t from zero_le)))
+  have hprod : hτ.measurableSpace.prod (inferInstance : MeasurableSpace upperHalfPlane) ≤
+      (shiftedStoppingFiltration hτ t).prod inferInstance :=
+    sup_le_sup (MeasurableSpace.comap_mono hle) le_rfl
+  have hJ := stoppedMassPoint_measurable B κ γ G F hw τ hm hc hτ
+  have hW := stoppedMassWeight_measurable B κ γ G F hw τ hm hc hτ hκ
+  have hpair (ω : Ω) : @Measurable upperHalfPlane (Ω × upperHalfPlane) inferInstance
+      (hτ.measurableSpace.prod inferInstance) (fun z => (ω,z)) :=
+    @measurable_prodMk_left Ω upperHalfPlane hτ.measurableSpace inferInstance ω
+  have hJsec (ω : Ω) : Measurable (stoppedMassPoint B κ γ G F hw τ ω) :=
+    @Measurable.comp upperHalfPlane (Ω × upperHalfPlane) upperHalfPlane
+      inferInstance (hτ.measurableSpace.prod inferInstance) inferInstance
+      (fun p => stoppedMassPoint B κ γ G F hw τ p.1 p.2) (fun z => (ω,z)) hJ (hpair ω)
+  have hWsec (ω : Ω) : Measurable (stoppedMassWeight B κ F τ ω) :=
+    @Measurable.comp upperHalfPlane (Ω × upperHalfPlane) ℝ≥0∞
+      inferInstance (hτ.measurableSpace.prod inferInstance) inferInstance
+      (fun p => stoppedMassWeight B κ F τ p.1 p.2) (fun z => (ω,z)) hW (hpair ω)
+  have hcov := stopped_future_green_covariance B κ γ G F hw τ hm hc hτ hκ hFresh
+  have hE' : MeasurableSet E := (shiftedStoppingFiltration hτ).le t _ hE
+  apply Measure.ext
+  intro A hA
+  rw [Measure.bind_apply hA hTm.aemeasurable,Measure.add_apply,
+    Measure.bind_apply hA hNm.aemeasurable,Measure.bind_apply hA hGm.aemeasurable]
+  let g : Ω × upperHalfPlane → ℝ≥0∞ := fun p => stoppedMassWeight B κ F τ p.1 p.2 *
+    (E ×ˢ A).indicator (fun _ => 1) (p.1,stoppedMassPoint B κ γ G F hw τ p.1 p.2)
+  have hg : Measurable[(shiftedStoppingFiltration hτ t).prod inferInstance] g :=
+    (hW.mono hprod le_rfl).mul
+      ((measurable_const.indicator (hE.prod hA)).comp
+        (measurable_fst.prodMk (hJ.mono hprod le_rfl)))
+  have hh := C.raw_restarted_random_green_test hB hc F hw R he τ hτ t g hg
+  change (∫⁻ ω, ∫⁻ z, stoppedMassWeight B κ F τ ω z *
+      (E ×ˢ A).indicator (fun _ => 1) (ω,stoppedMassPoint B κ γ G F hw τ ω z)
+        ∂(R.terminal (sourceRestartDriverPath B hc τ ω)) ∂P) =
+    (∫⁻ ω, ∫⁻ z, stoppedMassWeight B κ F τ ω z *
+      (E ×ˢ A).indicator (fun _ => 1) (ω,stoppedMassPoint B κ γ G F hw τ ω z)
+        ∂(R.process t (sourceRestartDriverPath B hc τ ω)+
+          canonicalGreenMass κ t (sourceRestartDriverPath B hc τ ω)) ∂P) at hh
+  rw [weighted_rectangle_lintegral P _ _ hJsec
+      _ hWsec E hE' A hA,
+    weighted_rectangle_lintegral P _ _ hJsec
+      _ hWsec E hE' A hA] at hh
+  calc
+    _ = ∫⁻ ω in E, weightedImageMass (stoppedMassPoint B κ γ G F hw τ ω)
+        (stoppedMassWeight B κ F τ ω)
+        (R.process t (sourceRestartDriverPath B hc τ ω)+
+          canonicalGreenMass κ t (sourceRestartDriverPath B hc τ ω)) A ∂P := hh
+    _ = ∫⁻ ω in E, stoppedFreshMass B κ γ G F hw τ hc R t ω A +
+        halfPlaneGreenMeasure κ B γ G (τ ω+t) ω A ∂P := by
+      apply lintegral_congr_ae
+      filter_upwards [ae_restrict_of_ae hcov] with ω hω
+      rw [weightedImageMass_add _ (hJsec ω),Measure.add_apply,hω t]
+      rfl
+    _ = _ := by
+      exact lintegral_add_left ((Measure.measurable_coe hA).comp hNm) _
+
+end SLEExactGauge.Multipoint
+
+end
+
+end OAI
diff --git a/lean/OAI/Probability/SLE/Loewner/StoppedInverseMeans.lean b/lean/OAI/Probability/SLE/Loewner/StoppedInverseMeans.lean
new file mode 100644
index 0000000000000000000000000000000000000000..070a4cb685ba385c5e0c7f682b8653f6458ac7da
--- /dev/null
+++ b/lean/OAI/Probability/SLE/Loewner/StoppedInverseMeans.lean
@@ -0,0 +1,107 @@
+import OAI.Probability.SLE.Loewner.StoppedInverseKernel
+import OAI.Probability.SLE.Mass.OriginalShiftedMass
+import OAI.Probability.SLE.Geometry.PositiveKernelTests
+
+namespace OAI
+
+/-! The two increment candidates have the same remaining conditional
+potential and integrable positive compact tests. -/
+
+noncomputable section
+open Set Filter _root_.MeasureTheory _root_.OAI.MeasureTheory ProbabilityTheory Classical
+open scoped NNReal ENNReal Topology CompactlySupported
+
+namespace SLEExactGauge.Multipoint
+
+variable {Ω : Type*} [mΩ : MeasurableSpace Ω] {P : Measure Ω} [IsProbabilityMeasure P]
+  {κ : ℝ} {B : ℝ≥0 → Ω → ℝ} {hBm : Measurable (Function.uncurry B)}
+  {γ : Ω → ℝ≥0 → ℂ} {G : Ω → ℝ≥0 → ℂ → ℂ}
+  (C : CanonicalMass P κ B hBm γ G) (hB : IsBrownianReal B P)
+  (hc : ∀ ω, Continuous (fun t => B t ω)) (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 ω)
+  (τ : Ω → ℝ≥0)
+  (hτ : IsStoppingTime (Filtration.natural B (fun s =>
+    (hBm.comp (measurable_const.prodMk measurable_id) : Measurable (B s)).stronglyMeasurable))
+    (fun ω => (τ ω:WithTop ℝ≥0)))
+  (hFresh : ∀ᵐ ω ∂P, ∃ (β : ℝ≥0 → ℂ) (G' F' : ℝ≥0 → ℂ → ℂ),
+    IsCapacityTwoWitness (fun t => Real.sqrt κ*B (τ ω+t) ω-Real.sqrt κ*B (τ ω) ω) β G' F')
+
+include C hB hc hκ F hw R he τ hτ hFresh in
+lemma CanonicalMass.stoppedFreshMass_cross_kernel
+    (t : ℝ≥0) (E : Set Ω) (hE : MeasurableSet[shiftedStoppingFiltration hτ t] E) :
+    (P.restrict E).bind C.rational.terminal+
+        (P.restrict E).bind (stoppedFreshMass B κ γ G F hw τ hc R t) =
+      (P.restrict E).bind (stoppedFreshTerminalMass B κ γ G F hw τ hc R)+
+        (P.restrict E).bind (fun ω => C.process (τ ω+t) ω) := by
+  rw [C.original_shifted_green_kernel τ hτ t E hE,
+    C.stoppedFreshMass_green_kernel hB hc hκ F hw R he τ hτ hFresh t E hE]
+  ac_rfl
+
+include C hB hc hκ F hw R he τ hτ hFresh in
+lemma CanonicalMass.stoppedFreshMass_mean_le (t : ℝ≥0) (E : Set Ω) :
+    (P.restrict E).bind (stoppedFreshMass B κ γ G F hw τ hc R t) ≤ initialGreenMeasure κ := by
+  have hm (s : ℝ≥0) : Measurable (B s) := hBm.comp (measurable_const.prodMk measurable_id)
+  have hNm := (stoppedFreshMass_adapted B κ γ G F hw τ hc R hm hτ hκ).measurable (i := t)
+  have hT := C.stoppedFreshTerminalMass_kernel hB hc hκ F hw τ hτ R
+    (he.mono fun _ h => h.2) hFresh univ MeasurableSet.univ
+  have hK := C.stoppedFreshMass_green_kernel hB hc hκ F hw R he τ hτ hFresh
+    t univ MeasurableSet.univ
+  simp only [Measure.restrict_univ] at hT hK
+  have hTmean : P.bind (stoppedFreshTerminalMass B κ γ G F hw τ hc R) ≤ initialGreenMeasure κ := by
+    rw [hT]
+    exact C.green_at_finite_stop_mean_le τ hτ
+  refine (restricted_bind_le_of_ae_le P _ _ hNm hNm (ae_of_all _ (fun _ => le_rfl)) E).trans ?_
+  rw [hK] at hTmean
+  exact (show P.bind (stoppedFreshMass B κ γ G F hw τ hc R t) ≤
+      P.bind (stoppedFreshMass B κ γ G F hw τ hc R t)+
+        P.bind (fun ω => halfPlaneGreenMeasure κ B γ G (τ ω+t) ω) from Measure.le_add_right le_rfl).trans hTmean
+
+include C hB hc hκ F hw R he τ hτ hFresh in
+lemma CanonicalMass.stoppedFreshTerminalMass_mean_le_of_fresh (E : Set Ω) :
+    (P.restrict E).bind (stoppedFreshTerminalMass B κ γ G F hw τ hc R) ≤ initialGreenMeasure κ := by
+  have hm (s : ℝ≥0) : Measurable (B s) := hBm.comp (measurable_const.prodMk measurable_id)
+  have hTm := stoppedFreshTerminalMass_measurable B κ γ G F hw τ hm hc hτ hκ R
+  have hT := C.stoppedFreshTerminalMass_kernel hB hc hκ F hw τ hτ R
+    (he.mono fun _ h => h.2) hFresh univ MeasurableSet.univ
+  simp only [Measure.restrict_univ] at hT
+  refine (restricted_bind_le_of_ae_le P _ _ hTm hTm (ae_of_all _ (fun _ => le_rfl)) E).trans ?_
+  rw [hT]
+  exact C.green_at_finite_stop_mean_le τ hτ
+
+include C hB hc hκ F hw R he τ hτ hFresh in
+lemma CanonicalMass.stoppedFreshMass_test_cross_mean
+    (f : C_c(upperHalfPlane,ℝ)) (hf : ∀ z, 0 ≤ f z)
+    (t : ℝ≥0) (E : Set Ω) (hE : MeasurableSet[shiftedStoppingFiltration hτ t] E) :
+    (∫ ω in E, ∫ z, f z ∂C.rational.terminal ω ∂P)+
+        (∫ ω in E, ∫ z, f z ∂stoppedFreshMass B κ γ G F hw τ hc R t ω ∂P) =
+      (∫ ω in E, ∫ z, f z ∂stoppedFreshTerminalMass B κ γ G F hw τ hc R ω ∂P)+
+        (∫ ω in E, ∫ z, f z ∂C.process (τ ω+t) ω ∂P) := by
+  let : IsFiniteMeasureOnCompacts (initialGreenMeasure κ) := initialGreenMeasure_finite_on_compacts κ
+  have hm (s : ℝ≥0) : Measurable (B s) := hBm.comp (measurable_const.prodMk measurable_id)
+  have hTm := stoppedFreshTerminalMass_measurable B κ γ G F hw τ hm hc hτ hκ R
+  have hNm := (stoppedFreshMass_adapted B κ γ G F hw τ hc R hm hτ hκ).measurable (i := t)
+  have hCm := (C.original_shifted_adapted τ hτ).measurable (i := t)
+  have hCT := C.uniqueness_terminal_mean_le E
+  have hNT := C.stoppedFreshTerminalMass_mean_le_of_fresh hB hc hκ F hw R he τ hτ hFresh E
+  have hN := C.stoppedFreshMass_mean_le hB hc hκ F hw R he τ hτ hFresh t E
+  have hC := C.original_shifted_mean_le τ hτ t E
+  have h := congrArg (fun μ : Measure upperHalfPlane => ∫ z, f z ∂μ)
+    (C.stoppedFreshMass_cross_kernel hB hc hκ F hw R he τ hτ hFresh t E hE)
+  rw [integral_add_measure (f.integrable.mono_measure hCT) (f.integrable.mono_measure hN),
+    integral_add_measure (f.integrable.mono_measure hNT) (f.integrable.mono_measure hC)] at h
+  rw [← positive_kernel_integral_bind (P.restrict E) κ C.rational.terminal
+      C.rational.terminal_measurable hCT f hf,
+    ← positive_kernel_integral_bind (P.restrict E) κ _ hNm hN f hf,
+    ← positive_kernel_integral_bind (P.restrict E) κ _ hTm hNT f hf,
+    ← positive_kernel_integral_bind (P.restrict E) κ _ hCm hC f hf] at h
+  exact h
+
+end SLEExactGauge.Multipoint
+
+end
+
+end OAI
diff --git a/lean/OAI/Probability/SLE/Loewner/StoppedInversePaths.lean b/lean/OAI/Probability/SLE/Loewner/StoppedInversePaths.lean
new file mode 100644
index 0000000000000000000000000000000000000000..70de6ecbcaab6542c7b6126977badef1f9c52609
--- /dev/null
+++ b/lean/OAI/Probability/SLE/Loewner/StoppedInversePaths.lean
@@ -0,0 +1,199 @@
+import OAI.Probability.SLE.Loewner.RawRestartCanonical
+import OAI.Probability.SLE.Loewner.StoppedInverseTerminalBound
+import OAI.Probability.SLE.Mass.DominatedMassTestExhaustion
+
+namespace OAI
+
+/-! The finite fresh mass transported by the actual stopped inverse chart.
+The same raw functional is used for all finite stopping times. -/
+
+noncomputable section
+open Set Filter _root_.MeasureTheory _root_.OAI.MeasureTheory ProbabilityTheory Classical
+open scoped NNReal ENNReal Topology CompactlySupported
+
+namespace SLEExactGauge
+
+local instance stoppedInversePathsLocallyCompact : LocallyCompactSpace upperHalfPlane := isOpen_upperHalfPlane.locallyCompactSpace
+
+lemma weightedImageMass_mono
+    (J : upperHalfPlane → upperHalfPlane) (hJ : Measurable J)
+    (w : upperHalfPlane → ℝ≥0∞) {μ ν : Measure upperHalfPlane} (hle : μ ≤ ν) :
+    weightedImageMass J w μ ≤ weightedImageMass J w ν := by
+  apply Measure.le_iff.mpr
+  intro A hA
+  rw [weightedImageMass_apply J hJ w μ A hA,weightedImageMass_apply J hJ w ν A hA]
+  exact lintegral_mono' hle le_rfl
+
+lemma weightedImageMass_zero (J : upperHalfPlane → upperHalfPlane)
+    (w : upperHalfPlane → ℝ≥0∞) : weightedImageMass J w 0=0 := by
+  simp only [weightedImageMass,withDensity_zero_left,Measure.map_zero]
+
+lemma weightedImageMass_finite_on_compacts
+    (J : upperHalfPlane → upperHalfPlane) (hJ : Measurable J)
+    (w : upperHalfPlane → ℝ≥0∞) {μ ν : Measure upperHalfPlane}
+    (hle : μ ≤ ν) [IsFiniteMeasureOnCompacts (weightedImageMass J w ν)] :
+    IsFiniteMeasureOnCompacts (weightedImageMass J w μ) :=
+  ⟨fun K hK => lt_of_le_of_lt (weightedImageMass_mono J hJ w hle K) hK.measure_lt_top⟩
+
+lemma weightedImageMass_positive_test_continuous
+    (N : ℝ≥0 → Measure upperHalfPlane) (ν : Measure upperHalfPlane) [ν.Regular]
+    (hdom : ∀ t, N t ≤ ν)
+    (hc : ∀ f : C_c(upperHalfPlane,ℝ), Continuous (fun t => ∫ z, f z ∂N t))
+    (J : upperHalfPlane → upperHalfPlane) (hJ : Measurable J)
+    (w : upperHalfPlane → ℝ≥0∞) (hw : Measurable w)
+    [IsFiniteMeasureOnCompacts (weightedImageMass J w ν)]
+    (f : C_c(upperHalfPlane,ℝ)) (hf : ∀ z, 0 ≤ f z) :
+    Continuous (fun t => ∫ z, f z ∂(weightedImageMass J w (N t))) := by
+  let g := fun z => w z * ENNReal.ofReal (f (J z))
+  have hg : Measurable g := hw.mul (f.continuous.measurable.comp hJ).ennreal_ofReal
+  have hν : (∫⁻ z, g z ∂ν) ≠ ∞ := by
+    rw [← weightedImageMass_lintegral J hJ w hw ν (fun z => ENNReal.ofReal (f z))
+      f.continuous.measurable.ennreal_ofReal]
+    rw [← ofReal_integral_eq_lintegral_ofReal f.integrable (ae_of_all _ hf)]
+    exact ENNReal.ofReal_ne_top
+  have hgc := continuous_lintegral_of_radon_domination N ν hdom hc g hg hν
+  have hfinite (t : ℝ≥0) : (∫⁻ z, g z ∂N t) ≠ ∞ :=
+    ne_top_of_le_ne_top hν (lintegral_mono' (hdom t) le_rfl)
+  have hreal : Continuous (fun t => (∫⁻ z, g z ∂N t).toReal) := by
+    apply continuous_iff_continuousAt.mpr
+    intro t
+    have ht : ContinuousAt (fun u : ℝ≥0 => ∫⁻ z, g z ∂N u) t := hgc.continuousAt
+    exact ContinuousAt.comp (f := fun u : ℝ≥0 => ∫⁻ z, g z ∂N u) (x := t)
+      (ENNReal.continuousAt_toReal (hfinite t)) ht
+  have he (t : ℝ≥0) : (∫ z, f z ∂(weightedImageMass J w (N t))) = (∫⁻ z, g z ∂N t).toReal := by
+    rw [integral_eq_lintegral_of_nonneg_ae (ae_of_all _ hf) f.continuous.measurable.aestronglyMeasurable,
+      weightedImageMass_lintegral J hJ w hw (N t) (fun z => ENNReal.ofReal (f z))
+        f.continuous.measurable.ennreal_ofReal]
+  simpa only [he] using hreal
+
+
+lemma positive_test_integral_measurable
+    {Ω : Type*} [MeasurableSpace Ω] (N : Ω → Measure upperHalfPlane) (hN : Measurable N)
+    (f : C_c(upperHalfPlane,ℝ)) (hf : ∀ z, 0 ≤ f z) :
+    Measurable (fun ω => ∫ z, f z ∂N ω) := by
+  have h := ENNReal.measurable_toReal.comp
+    ((Measure.measurable_lintegral f.continuous.measurable.ennreal_ofReal).comp hN)
+  have he (ω : Ω) : (∫ z, f z ∂N ω) = (∫⁻ z, ENNReal.ofReal (f z) ∂N ω).toReal :=
+    integral_eq_lintegral_of_nonneg_ae (ae_of_all _ hf) f.continuous.measurable.aestronglyMeasurable
+  convert h using 1
+  funext ω
+  exact he ω
+
+structure PositiveMassPaths (N : ℝ≥0 → Measure upperHalfPlane) (ν : Measure upperHalfPlane) : Prop where
+  zero : N 0=0
+  monotone : Monotone N
+  dominated : ∀ t, N t ≤ ν
+  radon : ∀ t, (N t).Regular ∧ IsFiniteMeasureOnCompacts (N t)
+  continuous_tests : ∀ f : C_c(upperHalfPlane,ℝ), (∀ z, 0 ≤ f z) →
+    Continuous (fun t => ∫ z, f z ∂N t)
+
+lemma weightedImageMass_positive_paths
+    (N : ℝ≥0 → Measure upperHalfPlane) (ν : Measure upperHalfPlane) [ν.Regular]
+    (hz : N 0=0) (hm : Monotone N) (hdom : ∀ t, N t ≤ ν)
+    (hc : ∀ f : C_c(upperHalfPlane,ℝ), Continuous (fun t => ∫ z, f z ∂N t))
+    (J : upperHalfPlane → upperHalfPlane) (hJ : Measurable J)
+    (w : upperHalfPlane → ℝ≥0∞) (hw : Measurable w)
+    [IsFiniteMeasureOnCompacts (weightedImageMass J w ν)] :
+    PositiveMassPaths (fun t => weightedImageMass J w (N t)) (weightedImageMass J w ν) := by
+  refine ⟨?_,?_,?_,?_,?_⟩
+  · rw [hz,weightedImageMass_zero]
+  · intro s t hst
+    exact weightedImageMass_mono J hJ w (hm hst)
+  · intro t
+    exact weightedImageMass_mono J hJ w (hdom t)
+  · intro t
+    let := weightedImageMass_finite_on_compacts J hJ w (hdom t)
+    exact ⟨inferInstance,inferInstance⟩
+  · intro f hf
+    exact weightedImageMass_positive_test_continuous N ν hdom hc J hJ w hw f hf
+
+namespace Multipoint
+
+local instance stoppedInversePathsDriverMeasurable : MeasurableSpace C(ℝ≥0,ℝ) := borel _
+local instance stoppedInversePathsDriverBorel : BorelSpace C(ℝ≥0,ℝ) := ⟨rfl⟩
+
+variable {Ω : Type*} [mΩ : MeasurableSpace Ω]
+  (B : ℝ≥0 → Ω → ℝ) (κ : ℝ) (γ : Ω → ℝ≥0 → ℂ)
+  (G F : Ω → ℝ≥0 → ℂ → ℂ)
+  (hw : ∀ ω, IsCapacityTwoWitness (fun t => Real.sqrt κ*B t ω) (γ ω) (G ω) (F ω))
+  (τ : Ω → ℝ≥0) (hc : ∀ ω, Continuous (fun t => B t ω)) (R : RawCanonicalMass)
+
+def stoppedFreshMass (t : ℝ≥0) (ω : Ω) : Measure upperHalfPlane :=
+  weightedImageMass (stoppedMassPoint B κ γ G F hw τ ω) (stoppedMassWeight B κ F τ ω)
+    (R.process t (sourceRestartDriverPath B hc τ ω))
+
+variable (hm : ∀ t, Measurable (B t))
+  (hτ : IsStoppingTime (Filtration.natural B (fun t => (hm t).stronglyMeasurable))
+    (fun ω => (τ ω : WithTop ℝ≥0)))
+
+include hm hτ in
+theorem stoppedFreshMass_adapted (hκ : 0 < κ) :
+    Adapted (shiftedStoppingFiltration hτ) (stoppedFreshMass B κ γ G F hw τ hc R) := by
+  have hraw := (sourceRestart_raw_process_progressive B hm hc τ hτ R.process R.progressive).adapted
+  intro t
+  have hle : hτ.measurableSpace ≤ shiftedStoppingFiltration hτ t :=
+    IsStoppingTime.measurableSpace_mono hτ (stopping_time_add_nnreal hτ t)
+      (fun ω => WithTop.coe_le_coe.mpr (le_add_of_nonneg_right (show 0 ≤ t from zero_le)))
+  have hprod : hτ.measurableSpace.prod (inferInstance : MeasurableSpace upperHalfPlane) ≤
+      (shiftedStoppingFiltration hτ t).prod inferInstance :=
+    sup_le_sup (MeasurableSpace.comap_mono hle) le_rfl
+  exact @weightedImageMass_measurable Ω upperHalfPlane (shiftedStoppingFiltration hτ t) inferInstance
+    (fun ω => R.process t (sourceRestartDriverPath B hc τ ω)) (hraw t)
+    (fun ω => (R.radon t _).2)
+    (fun p => stoppedMassPoint B κ γ G F hw τ p.1 p.2)
+    ((stoppedMassPoint_measurable B κ γ G F hw τ hm hc hτ).mono hprod le_rfl)
+    (fun p => stoppedMassWeight B κ F τ p.1 p.2)
+    ((stoppedMassWeight_measurable B κ γ G F hw τ hm hc hτ hκ).mono hprod le_rfl)
+
+include hm hτ in
+theorem stoppedFreshMass_paths
+    {P : Measure Ω} (hκ : 0 < κ)
+    (hpaths : ∀ᵐ ω ∂P,
+      R.process 0 (sourceRestartDriverPath B hc τ ω)=0 ∧
+      Monotone (fun t => R.process t (sourceRestartDriverPath B hc τ ω)) ∧
+      (∀ f : C_c(upperHalfPlane,ℝ), Continuous
+        (fun t => ∫ z, f z ∂(R.process t (sourceRestartDriverPath B hc τ ω)))) ∧
+      ∀ t, R.process t (sourceRestartDriverPath B hc τ ω) ≤
+        R.terminal (sourceRestartDriverPath B hc τ ω))
+    (hfin : ∀ᵐ ω ∂P, IsFiniteMeasureOnCompacts (stoppedFreshTerminalMass B κ γ G F hw τ hc R ω)) :
+    ∀ᵐ ω ∂P, PositiveMassPaths
+      (fun t => stoppedFreshMass B κ γ G F hw τ hc R t ω)
+      (stoppedFreshTerminalMass B κ γ G F hw τ hc R ω) := by
+  have hJ := stoppedMassPoint_measurable B κ γ G F hw τ hm hc hτ
+  have hW := stoppedMassWeight_measurable B κ γ G F hw τ hm hc hτ hκ
+  filter_upwards [hpaths,hfin] with ω hp hf
+  let J := stoppedMassPoint B κ γ G F hw τ ω
+  let w := stoppedMassWeight B κ F τ ω
+  have hpair : @Measurable upperHalfPlane (Ω × upperHalfPlane) inferInstance
+      (hτ.measurableSpace.prod inferInstance) (fun z => (ω,z)) :=
+    @measurable_prodMk_left Ω upperHalfPlane hτ.measurableSpace inferInstance ω
+  have hJm : Measurable J :=
+    @Measurable.comp upperHalfPlane (Ω × upperHalfPlane) upperHalfPlane
+      inferInstance (hτ.measurableSpace.prod inferInstance) inferInstance
+      (fun p => stoppedMassPoint B κ γ G F hw τ p.1 p.2) (fun z => (ω,z)) hJ hpair
+  have hwm : Measurable w :=
+    @Measurable.comp upperHalfPlane (Ω × upperHalfPlane) ℝ≥0∞
+      inferInstance (hτ.measurableSpace.prod inferInstance) inferInstance
+      (fun p => stoppedMassWeight B κ F τ p.1 p.2) (fun z => (ω,z)) hW hpair
+  let N := fun t => R.process t (sourceRestartDriverPath B hc τ ω)
+  let ν := R.terminal (sourceRestartDriverPath B hc τ ω)
+  change PositiveMassPaths (fun t => weightedImageMass J w (N t)) (weightedImageMass J w ν)
+  exact @weightedImageMass_positive_paths N ν
+    (R.terminal_radon (sourceRestartDriverPath B hc τ ω)).1
+    hp.1 hp.2.1 hp.2.2.2 hp.2.2.1 J hJm w hwm hf
+
+include hm hτ in
+theorem stoppedFreshMass_positive_test_adapted (hκ : 0 < κ)
+    (f : C_c(upperHalfPlane,ℝ)) (hf : ∀ z, 0 ≤ f z) :
+    Adapted (shiftedStoppingFiltration hτ)
+      (fun t ω => ∫ z, f z ∂(stoppedFreshMass B κ γ G F hw τ hc R t ω)) := by
+  intro t
+  exact @positive_test_integral_measurable Ω (shiftedStoppingFiltration hτ t) _
+    (stoppedFreshMass_adapted B κ γ G F hw τ hc R hm hτ hκ t) f hf
+
+end Multipoint
+end SLEExactGauge
+
+end
+
+end OAI
diff --git a/lean/OAI/Probability/SLE/Loewner/StoppedInverseTerminalBound.lean b/lean/OAI/Probability/SLE/Loewner/StoppedInverseTerminalBound.lean
new file mode 100644
index 0000000000000000000000000000000000000000..8fd746d8be4fcfec4e8683b24920c008d5de90e7
--- /dev/null
+++ b/lean/OAI/Probability/SLE/Loewner/StoppedInverseTerminalBound.lean
@@ -0,0 +1,92 @@
+import OAI.Probability.SLE.Loewner.StoppedInverseGreenMean
+import OAI.Probability.SLE.Mass.GreenMeasureSupport
+
+namespace OAI
+
+/-! The transported fresh terminal mass is locally integrable. The bound
+comes from the original canonical Green kernel at the stopping time. -/
+
+noncomputable section
+open Set Filter _root_.MeasureTheory _root_.OAI.MeasureTheory ProbabilityTheory Classical
+open scoped NNReal ENNReal Topology
+
+namespace SLEExactGauge.Multipoint
+
+local instance : LocallyCompactSpace upperHalfPlane := isOpen_upperHalfPlane.locallyCompactSpace
+local instance : MeasurableSpace C(ℝ≥0,ℝ) := borel _
+local instance : BorelSpace C(ℝ≥0,ℝ) := ⟨rfl⟩
+
+lemma halfPlaneStoppingGreenMeasure_finite_time
+    {Ω : Type*} (κ : ℝ) (B : ℝ≥0 → Ω → ℝ)
+    (γ : Ω → ℝ≥0 → ℂ) (G : Ω → ℝ≥0 → ℂ → ℂ) (τ : Ω → ℝ≥0) (ω : Ω) :
+    halfPlaneStoppingGreenMeasure κ B γ G (fun ω => (τ ω:ℝ≥0∞)) ω =
+      halfPlaneGreenMeasure κ B γ G (τ ω) ω := by
+  simp only [halfPlaneStoppingGreenMeasure,halfPlaneGreenMeasure,stoppingGreen,
+    ENNReal.coe_lt_top,ite_true,ENNReal.toNNReal_coe]
+
+theorem CanonicalMass.green_at_finite_stop_mean_le
+    {Ω : Type*} [MeasurableSpace Ω] {P : Measure Ω} {κ : ℝ}
+    {B : ℝ≥0 → Ω → ℝ} {hBm : Measurable (Function.uncurry B)}
+    {γ : Ω → ℝ≥0 → ℂ} {G : Ω → ℝ≥0 → ℂ → ℂ}
+    (C : CanonicalMass P κ B hBm γ G) (τ : Ω → ℝ≥0)
+    (hτ : IsStoppingTime (Filtration.natural B (fun t =>
+      (hBm.comp (measurable_const.prodMk measurable_id) : Measurable (B t)).stronglyMeasurable))
+      (fun ω => (τ ω:WithTop ℝ≥0))) :
+    P.bind (fun ω => halfPlaneGreenMeasure κ B γ G (τ ω) ω) ≤ initialGreenMeasure κ := by
+  have hk := C.kernel (fun ω => (τ ω:WithTop ℝ≥0)) hτ univ MeasurableSet.univ
+  simp only [Measure.restrict_univ,C.rational.mean] at hk
+  rw [hk]
+  apply Measure.le_iff.mpr
+  intro A _
+  simp only [Measure.add_apply]
+  exact le_add_left le_rfl
+
+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 ω)) (hκ : 0 < κ)
+  (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) : Measurable (B t)).stronglyMeasurable))
+    (fun ω => (τ ω:WithTop ℝ≥0)))
+  (R : RawCanonicalMass)
+  (he : ∀ᵐ ω ∂P, R.terminal (sourceDriverPath B hc ω)=C.rational.terminal ω)
+  (hpublished : PublishedTraceGeneration (P.map (sourceDriverPath B hc)) κ (fun t p => p t))
+
+include C hB hc hκ F hw τ hτ R he hpublished in
+theorem CanonicalMass.stoppedFreshTerminalMass_mean_le :
+    P.bind (stoppedFreshTerminalMass B κ γ G F hw τ hc R) ≤ initialGreenMeasure κ := by
+  have hk := C.stoppedFreshTerminalMass_published_kernel hB hc hκ F hw τ hτ R he
+    hpublished univ MeasurableSet.univ
+  simp only [Measure.restrict_univ] at hk
+  rw [hk]
+  exact C.green_at_finite_stop_mean_le τ hτ
+
+include C hB hc hκ F hw τ hτ R he hpublished in
+theorem CanonicalMass.stoppedFreshTerminalMass_ae_finite_on_compacts :
+    ∀ᵐ ω ∂P, IsFiniteMeasureOnCompacts (stoppedFreshTerminalMass B κ γ G F hw τ hc R ω) := by
+  let D := localTestFamily upperHalfPlane
+  let M := stoppedFreshTerminalMass B κ γ G F hw τ hc R
+  have hM : Measurable M := stoppedFreshTerminalMass_measurable B κ γ G F hw τ
+    (fun t => hBm.comp (measurable_const.prodMk measurable_id)) hc hτ hκ R
+  let : IsFiniteMeasureOnCompacts (initialGreenMeasure κ) := initialGreenMeasure_finite_on_compacts κ
+  have hbound := C.stoppedFreshTerminalMass_mean_le hB hc hκ F hw τ hτ R he hpublished
+  have hfin (n : ℕ) : ∀ᵐ ω ∂P, M ω (D.compactSet n) < ∞ := by
+    apply ae_lt_top ((Measure.measurable_coe (D.isCompact n).measurableSet).comp hM)
+    change (∫⁻ ω, M ω (D.compactSet n) ∂P) ≠ ∞
+    rw [← Measure.bind_apply (D.isCompact n).measurableSet hM.aemeasurable]
+    exact (lt_of_le_of_lt (hbound (D.compactSet n)) (D.isCompact n).measure_lt_top).ne
+  filter_upwards [ae_all_iff.mpr hfin] with ω hω
+  constructor
+  intro K hK
+  obtain ⟨n,hn⟩ := D.exhaustive K hK
+  exact lt_of_le_of_lt (measure_mono hn) (hω n)
+
+end SLEExactGauge.Multipoint
+
+end
+
+end OAI
diff --git a/lean/OAI/Probability/SLE/Loewner/StoppedInverseTerminalUniqueness.lean b/lean/OAI/Probability/SLE/Loewner/StoppedInverseTerminalUniqueness.lean
new file mode 100644
index 0000000000000000000000000000000000000000..3a7780792c94f3a6a84c5853a75d96e626deb96c
--- /dev/null
+++ b/lean/OAI/Probability/SLE/Loewner/StoppedInverseTerminalUniqueness.lean
@@ -0,0 +1,98 @@
+import OAI.Probability.SLE.Loewner.StoppedInverseTestUniqueness
+import OAI.Probability.SLE.Loewner.StoppedInverseExhaustion
+
+namespace OAI
+
+/-! The finite-time restart identity extends to the locally exhausted
+terminal mass using the same raw fresh functional. -/
+
+noncomputable section
+open Set Filter _root_.MeasureTheory _root_.OAI.MeasureTheory ProbabilityTheory Classical
+open scoped NNReal ENNReal Topology CompactlySupported
+
+namespace SLEExactGauge.Multipoint
+
+local instance stoppedTerminalUniqueLocallyCompact : LocallyCompactSpace upperHalfPlane :=
+  isOpen_upperHalfPlane.locallyCompactSpace
+
+lemma halfPlane_nested_remainder (a b c : Measure upperHalfPlane)
+    [a.Regular] [b.Regular] (hab : a ≤ b) (hbc : b ≤ c) :
+    (c-a)-(b-a)=c-b := by
+  let := halfPlane_sub_finite_on_compacts b a
+  apply (Measure.add_left_inj (b-a) _ _).mp
+  have hle : b-a ≤ c-a := sub_le_sub_right_of_le (hab.trans hbc) hbc
+  rw [sigmaFinite_sub_add_cancel_of_le hle]
+  apply (Measure.add_left_inj a _ _).mp
+  calc
+    (c-a)+a = c := sigmaFinite_sub_add_cancel_of_le (hab.trans hbc)
+    _ = (c-b)+b := (sigmaFinite_sub_add_cancel_of_le hbc).symm
+    _ = ((c-b)+(b-a))+a := by rw [add_assoc,sigmaFinite_sub_add_cancel_of_le hab]
+
+variable {Ω : Type*} [mΩ : MeasurableSpace Ω] {P : Measure Ω} [IsProbabilityMeasure P]
+  {κ : ℝ} {B : ℝ≥0 → Ω → ℝ} {hBm : Measurable (Function.uncurry B)}
+  {γ : Ω → ℝ≥0 → ℂ} {G : Ω → ℝ≥0 → ℂ → ℂ}
+  (C : CanonicalMass P κ B hBm γ G) (hB : IsBrownianReal B P)
+  (hc : ∀ ω, Continuous (fun t => B t ω)) (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 ω)
+  (τ : Ω → ℝ≥0)
+  (hτ : IsStoppingTime (Filtration.natural B (fun s =>
+    (hBm.comp (measurable_const.prodMk measurable_id) : Measurable (B s)).stronglyMeasurable))
+    (fun ω => (τ ω:WithTop ℝ≥0)))
+  (hFresh : ∀ᵐ ω ∂P, ∃ (β : ℝ≥0 → ℂ) (G' F' : ℝ≥0 → ℂ → ℂ),
+    IsCapacityTwoWitness (fun t => Real.sqrt κ*B (τ ω+t) ω-Real.sqrt κ*B (τ ω) ω) β G' F')
+
+
+include C hB hc hκ F hw R he τ hτ hFresh in
+theorem CanonicalMass.stoppedFreshTerminalMass_eq_remainder
+    (hpaths : ∀ᵐ ω ∂P, PositiveMassPaths
+      (fun t => stoppedFreshMass B κ γ G F hw τ hc R t ω)
+      (stoppedFreshTerminalMass B κ γ G F hw τ hc R ω))
+    (hfin : ∀ᵐ ω ∂P,
+      IsFiniteMeasureOnCompacts (stoppedFreshTerminalMass B κ γ G F hw τ hc R ω))
+    (hex : ∀ᵐ ω ∂P, ∀ K : Set upperHalfPlane, IsCompact K → Tendsto
+      (fun t : ℝ≥0 => (stoppedFreshTerminalMass B κ γ G F hw τ hc R ω-
+        stoppedFreshMass B κ γ G F hw τ hc R t ω) K) atTop (𝓝 0)) :
+    ∀ᵐ ω ∂P, C.rational.terminal ω-C.process (τ ω) ω =
+      stoppedFreshTerminalMass B κ γ G F hw τ hc R ω := by
+  filter_upwards [C.paths,C.exhaustion,hpaths,hfin,hex,
+    C.stoppedFreshMass_indistinguishable hB hc hκ F hw R he τ hτ hFresh hpaths]
+    with ω hp hx hq hf heq hid
+  let := (C.rational.terminal_radon ω).1
+  let := (C.radon (τ ω) ω).1
+  let := halfPlane_sub_finite_on_compacts (C.rational.terminal ω) (C.process (τ ω) ω)
+  let := hf
+  apply radon_terminal_eq_of_common_exhaustion
+    (C.rational.terminal ω-C.process (τ ω) ω)
+    (stoppedFreshTerminalMass B κ γ G F hw τ hc R ω)
+    (fun t => stoppedFreshMass B κ γ G F hw τ hc R t ω)
+  · intro t
+    rw [← hid t]
+    exact sub_le_sub_right_of_le (hp.dominated (τ ω)) (hp.dominated (τ ω+t))
+  · exact hq.dominated
+  · intro K hK
+    have htime : Tendsto (fun t : ℝ≥0 => τ ω+t) atTop atTop := by
+      apply tendsto_atTop.mpr
+      intro b
+      filter_upwards [eventually_ge_atTop b] with t ht
+      exact ht.trans (le_add_of_nonneg_left (show 0 ≤ τ ω from zero_le))
+    have hlimit := (hx K hK).comp htime
+    have hrem (t : ℝ≥0) :
+        (C.rational.terminal ω-C.process (τ ω) ω)-
+          stoppedFreshMass B κ γ G F hw τ hc R t ω =
+        C.rational.terminal ω-C.process (τ ω+t) ω := by
+      rw [← hid t]
+      let := (C.radon (τ ω+t) ω).1
+      exact halfPlane_nested_remainder _ _ _
+        (hp.monotone (le_add_of_nonneg_right (show 0 ≤ t from zero_le))) (hp.dominated _)
+    simpa only [hrem,Function.comp_def] using hlimit
+  · exact heq
+
+end SLEExactGauge.Multipoint
+
+end
+
+end OAI
diff --git a/lean/OAI/Probability/SLE/Loewner/StoppedInverseTestUniqueness.lean b/lean/OAI/Probability/SLE/Loewner/StoppedInverseTestUniqueness.lean
new file mode 100644
index 0000000000000000000000000000000000000000..b5f6fe0024ae8b5367a537a4e25f4c23ebb543c5
--- /dev/null
+++ b/lean/OAI/Probability/SLE/Loewner/StoppedInverseTestUniqueness.lean
@@ -0,0 +1,146 @@
+import OAI.Probability.SLE.Loewner.StoppedInverseMeans
+import OAI.Probability.SLE.Mass.RadonProcessAEUniqueness
+
+namespace OAI
+
+/-! The original increment and the transported fresh mass have identical
+positive compact tests simultaneously at every finite future time. -/
+
+noncomputable section
+open Set Filter _root_.MeasureTheory _root_.OAI.MeasureTheory ProbabilityTheory Classical
+open scoped NNReal ENNReal Topology CompactlySupported
+
+namespace SLEExactGauge.Multipoint
+
+local instance stoppedTestUniqueLocallyCompact : LocallyCompactSpace upperHalfPlane :=
+  isOpen_upperHalfPlane.locallyCompactSpace
+
+variable {Ω : Type*} [mΩ : MeasurableSpace Ω] {P : Measure Ω} [IsProbabilityMeasure P]
+  {κ : ℝ} {B : ℝ≥0 → Ω → ℝ} {hBm : Measurable (Function.uncurry B)}
+  {γ : Ω → ℝ≥0 → ℂ} {G : Ω → ℝ≥0 → ℂ → ℂ}
+  (C : CanonicalMass P κ B hBm γ G) (hB : IsBrownianReal B P)
+  (hc : ∀ ω, Continuous (fun t => B t ω)) (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 ω)
+  (τ : Ω → ℝ≥0)
+  (hτ : IsStoppingTime (Filtration.natural B (fun s =>
+    (hBm.comp (measurable_const.prodMk measurable_id) : Measurable (B s)).stronglyMeasurable))
+    (fun ω => (τ ω:WithTop ℝ≥0)))
+  (hFresh : ∀ᵐ ω ∂P, ∃ (β : ℝ≥0 → ℂ) (G' F' : ℝ≥0 → ℂ → ℂ),
+    IsCapacityTwoWitness (fun t => Real.sqrt κ*B (τ ω+t) ω-Real.sqrt κ*B (τ ω) ω) β G' F')
+
+
+include C hB hc hκ F hw R he τ hτ hFresh in
+lemma CanonicalMass.stoppedFreshMass_test_indistinguishable
+    (hpaths : ∀ᵐ ω ∂P, PositiveMassPaths
+      (fun t => stoppedFreshMass B κ γ G F hw τ hc R t ω)
+      (stoppedFreshTerminalMass B κ γ G F hw τ hc R ω))
+    (f : C_c(upperHalfPlane,ℝ)) (hf : ∀ z, 0 ≤ f z) :
+    ∀ᵐ ω ∂P, ∀ t,
+      (∫ z, f z ∂C.process (τ ω+t) ω)-(∫ z, f z ∂C.process (τ ω) ω) =
+        ∫ z, f z ∂stoppedFreshMass B κ γ G F hw τ hc R t ω := by
+  have hm (s : ℝ≥0) : Measurable (B s) := hBm.comp (measurable_const.prodMk measurable_id)
+  have hCm := C.original_shifted_adapted τ hτ
+  have hNm := stoppedFreshMass_adapted B κ γ G F hw τ hc R hm hτ hκ
+  have hTm := stoppedFreshTerminalMass_measurable B κ γ G F hw τ hm hc hτ hκ R
+  have hCI (t : ℝ≥0) : Integrable (fun ω => ∫ z, f z ∂C.process (τ ω+t) ω) P := by
+    apply positive_kernel_test_integrable P κ _ (hCm.measurable (i := t)) _ f hf
+    simpa only [Measure.restrict_univ] using C.original_shifted_mean_le τ hτ t univ
+  have hC0I : Integrable (fun ω => ∫ z, f z ∂C.process (τ ω) ω) P := by
+    simpa only [add_zero] using hCI 0
+  have hNI (t : ℝ≥0) : Integrable
+      (fun ω => ∫ z, f z ∂stoppedFreshMass B κ γ G F hw τ hc R t ω) P := by
+    apply positive_kernel_test_integrable P κ _ (hNm.measurable (i := t)) _ f hf
+    simpa only [Measure.restrict_univ] using
+      C.stoppedFreshMass_mean_le hB hc hκ F hw R he τ hτ hFresh t univ
+  have hTI : Integrable
+      (fun ω => ∫ z, f z ∂stoppedFreshTerminalMass B κ γ G F hw τ hc R ω) P := by
+    apply positive_kernel_test_integrable P κ _ hTm _ f hf
+    simpa only [Measure.restrict_univ] using
+      C.stoppedFreshTerminalMass_mean_le_of_fresh hB hc hκ F hw R he τ hτ hFresh univ
+  have hCA : StronglyAdapted (shiftedStoppingFiltration hτ)
+      (fun t ω => ∫ z, f z ∂C.process (τ ω+t) ω) := by
+    intro t
+    exact (@positive_test_integral_measurable Ω (shiftedStoppingFiltration hτ t)
+      _ (hCm t) f hf).stronglyMeasurable
+  have hC0A : StronglyAdapted (shiftedStoppingFiltration hτ)
+      (fun _ ω => ∫ z, f z ∂C.process (τ ω) ω) := by
+    intro t
+    have h := (hCA 0).mono ((shiftedStoppingFiltration hτ).mono (show 0 ≤ t from zero_le))
+    simpa only [add_zero] using h
+  have hNA : StronglyAdapted (shiftedStoppingFiltration hτ)
+      (fun t ω => ∫ z, f z ∂stoppedFreshMass B κ γ G F hw τ hc R t ω) := by
+    intro t
+    exact (@positive_test_integral_measurable Ω (shiftedStoppingFiltration hτ t)
+      _ (hNm t) f hf).stronglyMeasurable
+  have hAI (t : ℝ≥0) : Integrable (fun ω =>
+      (∫ z, f z ∂C.process (τ ω+t) ω)-(∫ z, f z ∂C.process (τ ω) ω)) P :=
+    (hCI t).sub hC0I
+  have hZI : Integrable (fun ω =>
+      (∫ z, f z ∂C.rational.terminal ω)-(∫ z, f z ∂C.process (τ ω) ω)) P :=
+    (C.uniqueness_terminal_test_integrable f).sub hC0I
+  apply increasing_mass_unique_of_terminal_mean
+    (fun t ω => (∫ z, f z ∂C.process (τ ω+t) ω)-(∫ z, f z ∂C.process (τ ω) ω))
+    (fun t ω => ∫ z, f z ∂stoppedFreshMass B κ γ G F hw τ hc R t ω)
+    (fun ω => (∫ z, f z ∂C.rational.terminal ω)-(∫ z, f z ∂C.process (τ ω) ω)-
+      (∫ z, f z ∂stoppedFreshTerminalMass B κ γ G F hw τ hc R ω))
+    (hZI.sub hTI)
+    (hCA.sub hC0A) hNA hAI hNI
+  · intro t E hE
+    have h := C.stoppedFreshMass_test_cross_mean hB hc hκ F hw R he τ hτ hFresh f hf t E hE
+    rw [integral_sub (hAI t).integrableOn (hNI t).integrableOn,
+      integral_sub (hCI t).integrableOn hC0I.integrableOn,
+      integral_sub hZI.integrableOn hTI.integrableOn,
+      integral_sub (C.uniqueness_terminal_test_integrable f).integrableOn hC0I.integrableOn]
+    linarith
+  · filter_upwards [C.paths] with ω hp
+    intro s t hst
+    apply sub_le_sub_right
+    let := (C.radon (τ ω+t) ω).1
+    exact integral_mono_measure (hp.monotone (add_le_add le_rfl hst)) (ae_of_all _ hf) f.integrable
+  · filter_upwards [hpaths] with ω hp
+    intro s t hst
+    let := (hp.radon t).1
+    exact integral_mono_measure (hp.monotone hst) (ae_of_all _ hf) f.integrable
+  · exact ae_of_all _ (fun ω => by simp only [add_zero,sub_self,Pi.zero_apply])
+  · filter_upwards [hpaths] with ω hp
+    simp only [hp.zero,integral_zero_measure,Pi.zero_apply]
+  · filter_upwards [C.paths,hpaths] with ω hp hq
+    exact (((hp.continuous_tests f).comp (continuous_const.add continuous_id)).sub
+      continuous_const).sub (hq.continuous_tests f hf)
+
+include C hB hc hκ F hw R he τ hτ hFresh in
+/-- Equality of the actual measure increments on one event for every finite
+future time, with the unmodified raw fresh functional. -/
+theorem CanonicalMass.stoppedFreshMass_indistinguishable
+    (hpaths : ∀ᵐ ω ∂P, PositiveMassPaths
+      (fun t => stoppedFreshMass B κ γ G F hw τ hc R t ω)
+      (stoppedFreshTerminalMass B κ γ G F hw τ hc R ω)) :
+    ∀ᵐ ω ∂P, ∀ t,
+      C.process (τ ω+t) ω-C.process (τ ω) ω =
+        stoppedFreshMass B κ γ G F hw τ hc R t ω := by
+  apply random_radon_process_eq_of_positive_tests_ae P (localTestFamily upperHalfPlane)
+  · filter_upwards [] with ω
+    intro t
+    let := (C.radon (τ ω+t) ω).2
+    let := halfPlane_sub_finite_on_compacts (C.process (τ ω+t) ω) (C.process (τ ω) ω)
+    infer_instance
+  · exact hpaths.mono (fun _ h => fun t => (h.radon t).1)
+  · intro f hf
+    filter_upwards [C.paths,
+      C.stoppedFreshMass_test_indistinguishable hB hc hκ F hw R he τ hτ hFresh hpaths f hf]
+      with ω hp ht
+    intro t
+    let := (C.radon (τ ω+t) ω).1
+    let := (C.radon (τ ω) ω).1
+    rw [integral_halfPlane_sub _ _ (hp.monotone (le_add_of_nonneg_right (show 0 ≤ t from zero_le))) f]
+    exact ht t
+
+end SLEExactGauge.Multipoint
+
+end
+
+end OAI
diff --git a/lean/OAI/Probability/SLE/Loewner/TargetBoundaryLimit.lean b/lean/OAI/Probability/SLE/Loewner/TargetBoundaryLimit.lean
new file mode 100644
index 0000000000000000000000000000000000000000..bb5fd76056ad8e25b3a53c42c0c34047fc512021
--- /dev/null
+++ b/lean/OAI/Probability/SLE/Loewner/TargetBoundaryLimit.lean
@@ -0,0 +1,103 @@
+import OAI.Probability.SLE.Loewner.TargetInverseContinuity
+import OAI.Probability.SLE.Loewner.TargetTraceCandidate
+import OAI.Probability.SLE.Geometry.RightLimitMeasurability
+
+namespace OAI
+
+/-! The complete vertical boundary limit of the raw inverse flow has a
+measurable event, without a trace-generation assumption. -/
+noncomputable section
+open Set Filter _root_.MeasureTheory _root_.OAI.MeasureTheory
+open scoped Topology NNReal ENNReal
+
+namespace SLEExactGauge.Target
+
+def rawTipAt (κ : ℝ) (T : ℝ≥0) (y : ℝ) (b : Driver) : ℂ :=
+  inverseFlow κ b (κ.toNNReal*T)
+    ((b (κ.toNNReal*T):ℂ)+(y:ℂ)*Complex.I)
+
+lemma joint_measurable_rawTipAt (κ : ℝ) (y : ℝ) :
+    Measurable (fun q : ℝ≥0 × Driver => rawTipAt κ q.1 y q.2) := by
+  have ht : Measurable (fun q : ℝ≥0 × Driver => κ.toNNReal*q.1) :=
+    measurable_const.mul measurable_fst
+  have hw : Measurable (fun q : ℝ≥0 × Driver =>
+      (q.2 (κ.toNNReal*q.1):ℂ)+(y:ℂ)*Complex.I) :=
+    ((continuous_eval.measurable.comp (measurable_snd.prodMk ht)).complex_ofReal).add_const _
+  exact @Measurable.comp (ℝ≥0 × Driver) (ℝ≥0 × (Driver × ℂ)) ℂ
+    inferInstance inferInstance inferInstance
+    (fun q => inverseFlow κ q.2.1 q.1 q.2.2)
+    (fun q => (κ.toNNReal*q.1,(q.2,(q.2 (κ.toNNReal*q.1):ℂ)+(y:ℂ)*Complex.I)))
+    (measurable_inverseFlow κ) (ht.prodMk (measurable_snd.prodMk hw))
+
+lemma measurable_rawTipAt (κ : ℝ) (T : ℝ≥0) (y : ℝ) :
+    Measurable (rawTipAt κ T y) := by
+  have hw : Measurable (fun b : Driver =>
+      (b (κ.toNNReal*T):ℂ)+(y:ℂ)*Complex.I) :=
+    (continuous_eval_const _).measurable.complex_ofReal.add_const _
+  exact @Measurable.comp Driver (ℝ≥0 × (Driver × ℂ)) ℂ
+    inferInstance inferInstance inferInstance
+    (fun q => inverseFlow κ q.2.1 q.1 q.2.2)
+    (fun b => (κ.toNNReal*T,(b,(b (κ.toNNReal*T):ℂ)+(y:ℂ)*Complex.I)))
+    (measurable_inverseFlow κ) (measurable_const.prodMk (measurable_id.prodMk hw))
+
+lemma continuousOn_rawTipAt (κ : ℝ) (hκ : 0 < κ) (T : ℝ≥0) (b : Driver) :
+    ContinuousOn (fun y => rawTipAt κ T y b) (Ioi 0) := by
+  apply (continuousOn_inverseFlow κ hκ b (κ.toNNReal*T)).comp
+    ((continuous_const.add (Complex.continuous_ofReal.mul continuous_const)).continuousOn)
+  intro y hy
+  change 0 < ((b (κ.toNNReal*T):ℂ)+(y:ℂ)*Complex.I).im
+  simpa using hy
+
+lemma measurableSet_rawTipAt_tendsto (κ : ℝ) (hκ : 0 < κ) (T : ℝ≥0)
+    (g : Driver → ℂ) (hg : Measurable g) :
+    MeasurableSet {b : Driver |
+      Tendsto (fun y => rawTipAt κ T y b) (𝓝[>] 0) (𝓝 (g b))} :=
+  measurableSet_tendsto_right (rawTipAt κ T) g (measurable_rawTipAt κ T) hg
+    (continuousOn_rawTipAt κ hκ T)
+
+lemma joint_measurableSet_rawTipAt_tendsto (κ : ℝ) (hκ : 0 < κ)
+    (g : ℝ≥0 × Driver → ℂ) (hg : Measurable g) :
+    MeasurableSet {q : ℝ≥0 × Driver |
+      Tendsto (fun y => rawTipAt κ q.1 y q.2) (𝓝[>] 0) (𝓝 (g q))} := by
+  have hf : ∀ y : ℝ, Measurable (fun q : ℝ≥0 × Driver => rawTipAt κ q.1 y q.2) :=
+    joint_measurable_rawTipAt κ
+  have hc : ∀ q : ℝ≥0 × Driver,
+      ContinuousOn (fun y : ℝ => rawTipAt κ q.1 y q.2) (Ioi 0) :=
+    fun q => continuousOn_rawTipAt κ hκ q.1 q.2
+  exact @measurableSet_tendsto_right (ℝ≥0 × Driver) inferInstance
+    (fun y q => rawTipAt κ q.1 y q.2) g hf hg hc
+
+lemma rawTipAt_eq_witness
+    (κ : ℝ) (hκ : 0 < κ) (b : Driver) (U : ℝ≥0 → ℝ)
+    (γ : ℝ≥0 → ℂ) (G F : ℝ≥0 → ℂ → ℂ)
+    (hw : IsCapacityTwoWitness U γ G F)
+    (hU : ∀ s : ℝ, 0 ≤ s → U s.toNNReal=driverValue b (κ*s))
+    (T : ℝ≥0) (y : ℝ) (hy : 0 < y) :
+    rawTipAt κ T y b=F T ((U T:ℂ)+(y:ℂ)*Complex.I) := by
+  have heTime : (κ*(T:ℝ)).toNNReal=κ.toNNReal*T := by
+    rw [Real.toNNReal_mul hκ.le,Real.toNNReal_coe]
+  have hb : b (κ.toNNReal*T)=U T := by
+    have h := hU T T.coe_nonneg
+    simpa only [Real.toNNReal_coe,driverValue,heTime] using h.symm
+  unfold rawTipAt
+  rw [Real.coe_toNNReal _ hκ.le,hb]
+  exact inverseFlow_eq_witness κ hκ b U γ G F hw hU T _ (by
+    change 0 < ((U T:ℂ)+(y:ℂ)*Complex.I).im
+    simpa using hy)
+
+lemma rawTipAt_tendsto_witness
+    (κ : ℝ) (hκ : 0 < κ) (b : Driver) (U : ℝ≥0 → ℝ)
+    (γ : ℝ≥0 → ℂ) (G F : ℝ≥0 → ℂ → ℂ)
+    (hw : IsCapacityTwoWitness U γ G F)
+    (hU : ∀ s : ℝ, 0 ≤ s → U s.toNNReal=driverValue b (κ*s))
+    (T : ℝ≥0) :
+    Tendsto (fun y => rawTipAt κ T y b) (𝓝[>] 0) (𝓝 (γ T)) := by
+  apply Tendsto.congr' _ (hw.2.2.2.2.2.2.2.2.2.2.2.2 T)
+  filter_upwards [self_mem_nhdsWithin] with y hy
+  exact (rawTipAt_eq_witness κ hκ b U γ G F hw hU T y hy).symm
+
+end SLEExactGauge.Target
+
+end
+
+end OAI
diff --git a/lean/OAI/Probability/SLE/Loewner/TargetContinuationPullback.lean b/lean/OAI/Probability/SLE/Loewner/TargetContinuationPullback.lean
new file mode 100644
index 0000000000000000000000000000000000000000..522102e7a96092633b1857fec7069a563d0e1686
--- /dev/null
+++ b/lean/OAI/Probability/SLE/Loewner/TargetContinuationPullback.lean
@@ -0,0 +1,99 @@
+import OAI.Probability.SLE.Angle.TargetBrownianNormalization
+import OAI.Probability.SLE.Angle.TargetPotentialIncrement
+
+namespace OAI
+
+/-! The prescribed fresh-driver average pulled back to a regular
+Brownian presentation, retaining its full natural past. -/
+
+noncomputable section
+open Set Filter _root_.MeasureTheory _root_.OAI.MeasureTheory ProbabilityTheory
+open scoped Topology NNReal ENNReal
+
+namespace SLEExactGauge.Target
+
+local instance pullbackPathMeasurable : MeasurableSpace C(ℝ≥0,ℝ) := borel _
+local instance pullbackPathBorel : BorelSpace C(ℝ≥0,ℝ) := ⟨rfl⟩
+
+theorem continuationMean_comp_condLExp
+    {Ω : Type*} [mΩ : MeasurableSpace Ω] {P : Measure Ω} [IsProbabilityMeasure P]
+    (b : Ω → Driver) (hb : Measurable b)
+    (hB : IsBrownianReal (fun t ω => b ω t) P)
+    (W : WienerLaw) (hLaw : HasLaw b W P) (t : ℝ≥0)
+    (f : Driver → ℝ≥0∞) (hf : Measurable f) :
+    (fun ω => continuationMean W t f (b ω)) =ᵐ[P]
+      P⁻[(fun ω => f (b ω)) |
+        (Filtration.natural (fun t ω => b ω t)
+          (fun t => ((continuous_eval_const t).measurable.comp hb).stronglyMeasurable)) t] := by
+  have h := source_driver_continuation_condLExp hB
+    (fun t => (continuous_eval_const t).measurable.comp hb)
+    (fun ω => (b ω).continuous) t (fun p => f (centerDriver p)) (hf.comp measurable_centerDriver)
+  change (fun ω => driverContinuationMean (P.map (fun ω => (b ω).toContinuousMap)) t
+      (fun p => f (centerDriver p)) (b ω).toContinuousMap) =ᵐ[P]
+    P⁻[(fun ω => f (centerDriver (b ω).toContinuousMap)) |
+      (Filtration.natural (fun t ω => b ω t)
+        (fun t => ((continuous_eval_const t).measurable.comp hb).stronglyMeasurable)) t] at h
+  have he : P.map (fun ω => (b ω).toContinuousMap)=W.map (fun p => p.toContinuousMap) := by
+    rw [← hLaw.map_eq,Measure.map_map measurable_driverInclusion hb]
+    rfl
+  rw [he] at h
+  have heq : (fun ω => driverContinuationMean (W.map (fun p => p.toContinuousMap)) t
+      (fun p => f (centerDriver p)) (b ω).toContinuousMap) =
+      (fun ω => continuationMean W t f (b ω)) :=
+    funext (fun ω => continuationMean_eq_pathMean W t f hf (b ω))
+  rw [heq] at h
+  simpa only [centerDriver_inclusion] using h
+
+theorem continuationMean_comp_finite_condExp
+    {Ω : Type*} [mΩ : MeasurableSpace Ω] {P : Measure Ω} [IsProbabilityMeasure P]
+    (b : Ω → Driver) (hb : Measurable b)
+    (hB : IsBrownianReal (fun t ω => b ω t) P)
+    (W : WienerLaw) (hLaw : HasLaw b W P) (t : ℝ≥0)
+    (f : Driver → ℝ≥0∞) (hf : Measurable f)
+    (hfin : (∫⁻ ω, f (b ω) ∂P) ≠ ∞) :
+    (∀ᵐ ω ∂P, continuationMean W t f (b ω)<∞) ∧
+    (fun ω => (continuationMean W t f (b ω)).toReal) =ᵐ[P]
+      P[(fun ω => (f (b ω)).toReal) |
+        (Filtration.natural (fun t ω => b ω t)
+          (fun t => ((continuous_eval_const t).measurable.comp hb).stronglyMeasurable)) t] := by
+  have he := continuationMean_comp_condLExp b hb hB W hLaw t f hf
+  let m := (Filtration.natural (fun t ω => b ω t)
+    (fun t => ((continuous_eval_const t).measurable.comp hb).stronglyMeasurable)) t
+  constructor
+  · filter_upwards [he,condLExp_lt_top (mΩ := m) hfin] with ω hω hh
+    exact hω.symm ▸ hh
+  · exact (he.fun_comp ENNReal.toReal).trans (toReal_condLExp m (hf.comp hb).aemeasurable hfin)
+
+theorem potentialDifference_comp_eq_current_sub_condExp
+    {Ω : Type*} [mΩ : MeasurableSpace Ω] {P : Measure Ω} [IsProbabilityMeasure P]
+    (b : Ω → Driver) (hb : Measurable b)
+    (hB : IsBrownianReal (fun t ω => b ω t) P)
+    (W : WienerLaw) (hLaw : HasLaw b W P) (κ θ : ℝ) (n i : ℕ)
+    (hm : ∀ j, Measurable (fun b => potential κ θ b (compensatorMeshTime n j)))
+    (hfin : ∀ j, (∫⁻ ω, potential κ θ (b ω) (compensatorMeshTime n j) ∂P) ≠ ∞) :
+    (fun ω => potentialDifference κ θ W (b ω) n i) =ᵐ[P]
+      (fun ω => (potential κ θ (b ω) (compensatorMeshTime n i)).toReal -
+        condExp ((Filtration.natural (fun t ω => b ω t)
+          (fun t => ((continuous_eval_const t).measurable.comp hb).stronglyMeasurable))
+            (compensatorMeshTime n i)) P
+          (fun ω => (potential κ θ (b ω) (compensatorMeshTime n (i+1))).toReal) ω) := by
+  have h := continuationMean_comp_finite_condExp b hb hB W hLaw
+    (compensatorMeshTime n i)
+    (fun b => potential κ θ b (compensatorMeshTime n (i+1))) (hm (i+1)) (hfin (i+1))
+  filter_upwards [ae_lt_top ((hm i).comp hb) (hfin i),h.1,h.2] with ω hv hw he
+  have hnext : ((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,hnext]
+  change (if potential κ θ (b ω) (compensatorMeshTime n i)<∞ ∧
+      continuationMean W (compensatorMeshTime n i)
+        (fun b => potential κ θ b (compensatorMeshTime n (i+1))) (b ω)<∞
+      then _ else _)=_
+  rw [ite_eq_left ⟨hv,hw⟩]
+  dsimp only [continuationMean] at he
+  rw [he]
+
+end SLEExactGauge.Target
+
+end
+
+end OAI
diff --git a/lean/OAI/Probability/SLE/Loewner/TargetCutoffField.lean b/lean/OAI/Probability/SLE/Loewner/TargetCutoffField.lean
new file mode 100644
index 0000000000000000000000000000000000000000..21d85a61481ba06453ec6d38f5c9f66d4417d889
--- /dev/null
+++ b/lean/OAI/Probability/SLE/Loewner/TargetCutoffField.lean
@@ -0,0 +1,125 @@
+import OAI.Probability.SLE.MomentGauge
+import OAI.Probability.SLE.ClippedCoordinates
+
+namespace OAI
+
+/-! Global estimates for the exact reciprocal cutoff used in the
+prescribed Euler construction. -/
+
+noncomputable section
+open Set Filter MeasureTheory Metric
+open scoped NNReal ENNReal Topology
+
+namespace SLEExactGauge.Target
+
+private def reciprocalCutoff (c : ℝ) (z : ℂ) : ℂ :=
+  star z / (max (‖z‖ ^ 2) c : ℝ)
+
+private lemma cutoff_denom_lower (c : ℝ) (hc : 0 < c) (z : ℂ) :
+    Real.sqrt c * ‖z‖ ≤ max (‖z‖ ^ 2) c := by
+  have hs := Real.sq_sqrt hc.le
+  have hsq := sq_nonneg (‖z‖-Real.sqrt c)
+  have hz := le_max_left (‖z‖ ^ 2) c
+  have hc' := le_max_right (‖z‖ ^ 2) c
+  nlinarith
+
+private lemma reciprocalCutoff_norm_le (c : ℝ) (hc : 0 < c) (z : ℂ) :
+    ‖reciprocalCutoff c z‖ ≤ (Real.sqrt c)⁻¹ := by
+  have hA : 0 < max (‖z‖ ^ 2) c := hc.trans_le (le_max_right _ _)
+  have hs : 0 < Real.sqrt c := Real.sqrt_pos.2 hc
+  rw [reciprocalCutoff,norm_div,norm_star,Complex.norm_real,Real.norm_eq_abs,abs_of_pos hA]
+  apply (div_le_iff₀ hA).2
+  simpa only [div_eq_mul_inv,mul_comm] using
+    (le_div_iff₀ hs).2 (by simpa only [mul_comm] using cutoff_denom_lower c hc z)
+
+private lemma reciprocalCutoff_dist_le (c : ℝ) (hc : 0 < c) (z w : ℂ) :
+    dist (reciprocalCutoff c z) (reciprocalCutoff c w) ≤ (3/c)*dist z w := by
+  let A : ℝ := max (‖z‖^2) c
+  let B : ℝ := max (‖w‖^2) c
+  have hA : 0 < A := hc.trans_le (le_max_right _ _)
+  have hB : 0 < B := hc.trans_le (le_max_right _ _)
+  have hAB : 0 < A*B := mul_pos hA hB
+  have hcA : c ≤ A := le_max_right _ _
+  have hcB : c ≤ B := le_max_right _ _
+  have hwB : ‖w‖^2 ≤ B := le_max_left _ _
+  have hzw : c*‖z‖*‖w‖ ≤ A*B := by
+    have h := mul_le_mul (cutoff_denom_lower c hc z) (cutoff_denom_lower c hc w)
+      (mul_nonneg (Real.sqrt_nonneg _) (norm_nonneg _)) hA.le
+    nlinarith [Real.sq_sqrt hc.le]
+  have hww : c*‖w‖^2 ≤ A*B := by
+    exact mul_le_mul hcA hwB (sq_nonneg _) hA.le
+  have hdiff : |B-A| ≤ (‖z‖+‖w‖)*dist z w := by
+    have hmax := abs_max_sub_max_le_abs (‖w‖^2) (‖z‖^2) c
+    have hnorm := abs_norm_sub_norm_le w z
+    have he : |‖w‖^2-‖z‖^2| = |‖w‖-‖z‖| *(‖z‖+‖w‖) := by
+      rw [sq_sub_sq,abs_mul,abs_of_nonneg (add_nonneg (norm_nonneg _) (norm_nonneg _))]
+      ring
+    refine hmax.trans ?_
+    rw [he]
+    have hnorm' : |‖w‖-‖z‖| ≤ dist z w := by
+      simpa only [← dist_eq_norm,dist_comm] using hnorm
+    nlinarith [norm_nonneg z,norm_nonneg w]
+  have he : reciprocalCutoff c z-reciprocalCutoff c w =
+      star (z-w)/(A:ℂ)+star w*((B-A:ℝ):ℂ)/((A*B:ℝ):ℂ) := by
+    simp only [reciprocalCutoff,star_sub,Complex.ofReal_sub,Complex.ofReal_mul]
+    change star z/(A:ℂ)-star w/(B:ℂ) = _
+    field_simp [Complex.ofReal_ne_zero.mpr hA.ne',Complex.ofReal_ne_zero.mpr hB.ne']
+    ring
+  rw [dist_eq_norm,he]
+  calc
+    _ ≤ ‖star (z-w)/(A:ℂ)‖+‖star w*((B-A:ℝ):ℂ)/((A*B:ℝ):ℂ)‖ := norm_add_le _ _
+    _ = dist z w/A+‖w‖*|B-A|/(A*B) := by
+      simp only [norm_div,norm_mul,norm_star,Complex.norm_real,Real.norm_eq_abs,abs_of_pos hA,
+        abs_of_pos hB,dist_eq_norm]
+    _ ≤ dist z w/A+‖w‖*((‖z‖+‖w‖)*dist z w)/(A*B) := by
+      gcongr
+    _ ≤ (3/c)*dist z w := by
+      have hcoef : (B+‖w‖*(‖z‖+‖w‖))/(A*B) ≤ 3/c := by
+        apply (div_le_div_iff₀ hAB hc).2
+        have hcb := mul_le_mul_of_nonneg_right hcA hB.le
+        nlinarith
+      calc
+        dist z w/A+‖w‖*((‖z‖+‖w‖)*dist z w)/(A*B) =
+            ((B+‖w‖*(‖z‖+‖w‖))/(A*B))*dist z w := by
+          field_simp [hA.ne',hB.ne']
+        _ ≤ (3/c)*dist z w := mul_le_mul_of_nonneg_right hcoef dist_nonneg
+
+
+lemma cutoffField_bounds (κ : ℝ) (j : ℕ) (hj : 1 ≤ j) :
+    ∃ L K : ℝ≥0, (∀ b t z, ‖cutoffField κ b j t z‖ ≤ L) ∧
+      ∀ b t, LipschitzWith K (cutoffField κ b j t) := by
+  let c : ℝ := (j:ℝ)^(-(4:ℤ))
+  have hc : 0 < c := zpow_pos (by exact_mod_cast (Nat.succ_le_iff.mp hj) : (0:ℝ)<j) _
+  let L : ℝ≥0 := ⟨|a κ| *(Real.sqrt c)⁻¹,by positivity⟩
+  let K : ℝ≥0 := ⟨|a κ| *(3/c),by positivity⟩
+  refine ⟨L,K,?_,?_⟩
+  · intro b t z
+    change ‖(a κ:ℂ)*star (z-driverValue b t)/(max (‖z-driverValue b t‖^2) c:ℝ)‖ ≤ _
+    rw [mul_div_assoc,norm_mul,Complex.norm_real]
+    exact mul_le_mul_of_nonneg_left (reciprocalCutoff_norm_le c hc _) (abs_nonneg _)
+  · intro b t
+    apply LipschitzWith.of_dist_le_mul
+    intro z w
+    have he (z : ℂ) : cutoffField κ b j t z = (a κ:ℂ)*reciprocalCutoff c (z-driverValue b t) := by
+      simp only [cutoffField,reciprocalCutoff,mul_div_assoc,c]
+    rw [he,he,dist_eq_norm,← mul_sub,norm_mul,Complex.norm_real]
+    have h := reciprocalCutoff_dist_le c hc (z-driverValue b t) (w-driverValue b t)
+    rw [dist_sub_right] at h
+    change |a κ| * ‖reciprocalCutoff c (z-driverValue b t)-
+      reciprocalCutoff c (w-driverValue b t)‖ ≤ (|a κ| *(3/c))*dist z w
+    simpa only [dist_eq_norm,mul_assoc] using
+      mul_le_mul_of_nonneg_left h (abs_nonneg (a κ))
+
+lemma continuous_cutoffField (κ : ℝ) (b : Driver) (j : ℕ) (hj : 1 ≤ j) :
+    Continuous (fun p : ℝ × ℂ => cutoffField κ b j p.1 p.2) := by
+  have hc : 0 < (j:ℝ)^(-(4:ℤ)) := zpow_pos (by exact_mod_cast (Nat.succ_le_iff.mp hj) : (0:ℝ)<j) _
+  have hd : Continuous (fun t : ℝ => driverValue b t) :=
+    b.continuous.comp continuous_real_toNNReal
+  unfold cutoffField
+  fun_prop (disch := intro x; exact_mod_cast ne_of_gt (hc.trans_le (le_max_right _ _)))
+
+end SLEExactGauge.Target
+
+end
+
+end OAI
diff --git a/lean/OAI/Probability/SLE/Loewner/TargetCutoffMeasurability.lean b/lean/OAI/Probability/SLE/Loewner/TargetCutoffMeasurability.lean
new file mode 100644
index 0000000000000000000000000000000000000000..0488d33125c895531bfb1ada6f5d2950f02e1190
--- /dev/null
+++ b/lean/OAI/Probability/SLE/Loewner/TargetCutoffMeasurability.lean
@@ -0,0 +1,128 @@
+import OAI.Probability.SLE.Loewner.TargetCutoffTrajectory
+import OAI.Probability.SLE.Loewner.TargetDriverContinuation
+
+namespace OAI
+
+/-! Joint measurability and finite-prefix dependence of the prescribed
+cutoff flow. The variable initial point is encoded as a displacement in
+the already constructed measurable Picard equation. -/
+
+noncomputable section
+open Set Filter _root_.MeasureTheory _root_.OAI.MeasureTheory ProbabilityTheory
+open scoped Topology NNReal ENNReal
+
+namespace SLEExactGauge.Target
+
+lemma measurable_cutoffField (κ : ℝ) (j : ℕ) :
+    Measurable (fun q : (ℝ × Driver) × ℂ => cutoffField κ q.1.2 j q.1.1 q.2) := by
+  have hb : Measurable (fun q : (ℝ × Driver) × ℂ =>
+      q.1.2 q.1.1.toNNReal) :=
+    continuous_eval.measurable.comp ((measurable_snd.comp measurable_fst).prodMk
+      (continuous_real_toNNReal.measurable.comp (measurable_fst.comp measurable_fst)))
+  have hv : Measurable (fun q : (ℝ × Driver) × ℂ =>
+      q.2 - (q.1.2 q.1.1.toNNReal : ℂ)) := measurable_snd.sub hb.complex_ofReal
+  exact (measurable_const.mul (Complex.continuous_conj.measurable.comp hv)).div
+    ((hv.norm.pow_const 2).max measurable_const).complex_ofReal
+
+lemma measurable_cutoffFlow (κ : ℝ) (j : ℕ) (hj : 1 ≤ j) :
+    Measurable (fun q : ℝ≥0 × (Driver × ℂ) => cutoffFlow κ q.2.1 j q.2.2 q.1) := by
+  obtain ⟨L,K,hL,hK⟩ := cutoffField_bounds κ j hj
+  let V (t : ℝ) (x : Driver × ℂ) (v : ℂ) := cutoffField κ x.1 j t (v+x.2)
+  have hV : Measurable (fun q : (ℝ × (Driver × ℂ)) × ℂ => V q.1.1 q.1.2 q.2) := by
+    have hpair : Measurable (fun q : (ℝ × (Driver × ℂ)) × ℂ =>
+        ((q.1.1,q.1.2.1),q.2+q.1.2.2)) :=
+      ((measurable_fst.fst.prodMk measurable_fst.snd.fst).prodMk
+        (measurable_snd.add measurable_fst.snd.snd))
+    exact @Measurable.comp ((ℝ × (Driver × ℂ)) × ℂ) ((ℝ × Driver) × ℂ) ℂ
+      inferInstance inferInstance inferInstance
+      (fun q => cutoffField κ q.1.2 j q.1.1 q.2)
+      (fun q => ((q.1.1,q.1.2.1),q.2+q.1.2.2)) (measurable_cutoffField κ j) hpair
+  have hc (x : Driver × ℂ) (v : ℂ) : Continuous (fun t => V t x v) :=
+    (continuous_cutoffField κ x.1 j hj).comp (continuous_id.prodMk continuous_const)
+  have hl (x : Driver × ℂ) (t : ℝ) : LipschitzWith K (V t x) := by
+    apply LipschitzWith.of_dist_le_mul
+    intro v w
+    simpa only [V,dist_add_right] using (hK x.1 t).dist_le_mul (v+x.2) (w+x.2)
+  obtain ⟨X,hXm,hXl,hX0,hXd,_⟩ := exists_measurable_global_bounded_ode_picard
+    V 0 L K hV hc hl (fun x t v => hL x.1 t (v+x.2))
+  have he (t : ℝ≥0) (x : Driver × ℂ) :
+      cutoffFlow κ x.1 j x.2 t = X t x+x.2 := by
+    apply cutoffFlow_eq_solution κ x.1 j hj x.2 L K (hL x.1) (hK x.1)
+      (fun s => X s x+x.2) ((hXl x).continuous.add continuous_const)
+    · simp only [hX0,zero_add]
+    · intro s hs
+      simpa only [V] using (hXd x s hs).add_const x.2
+    · exact t.coe_nonneg
+  have hm : Measurable (fun q : ℝ≥0 × (Driver × ℂ) => X q.1 q.2+q.2.2) :=
+    (hXm.comp (measurable_fst.coe_nnreal_real.prodMk measurable_snd)).add measurable_snd.snd
+  convert hm using 1
+  exact funext (fun q => he q.1 q.2)
+
+def stopDriver (b : Driver) (T : ℝ≥0) : Driver where
+  toFun t := b (min t T)
+  continuous_toFun := (map_continuous b).comp (continuous_id.min continuous_const)
+  map_zero' := by simp
+
+@[simp] lemma stopDriver_apply (b : Driver) (T t : ℝ≥0) :
+    stopDriver b T t = b (min t T) := rfl
+
+lemma stopDriver_measurable_past (T : ℝ≥0) :
+    Measurable[driverFiltration T] (fun b => stopDriver b T) := by
+  have hm (t : ℝ≥0) : Measurable[driverFiltration T]
+      (fun b : Driver => b (min t T)) :=
+    ((Filtration.stronglyAdapted_natural
+      (fun u => (show Measurable (fun b : Driver => b u) from
+        (continuous_eval_const u).measurable).stronglyMeasurable) (min t T)).measurable).mono
+          (driverFiltration.mono (min_le_right t T)) le_rfl
+  apply ContinuousMapZero.isClosedEmbedding_toContinuousMap.measurableEmbedding.measurable_comp_iff.mp
+  let : MeasurableSpace Driver := driverFiltration T
+  apply source_path_measurable
+  intro t
+  exact hm t
+
+lemma cutoffFlow_eq_of_driver_prefix (κ : ℝ) (b c : Driver) (j : ℕ) (hj : 1 ≤ j)
+    (z : ℂ) (T : ℝ) (hT : 0 ≤ T)
+    (he : ∀ s ∈ Icc 0 T, driverValue b s = driverValue c s) :
+    ∀ t ∈ Icc 0 T, cutoffFlow κ b j z t = cutoffFlow κ c j z t := by
+  apply cutoffFlow_eq_of_trajectory κ b j hj z T hT (cutoffFlow κ c j z)
+    ((cutoffFlow_continuousOn κ c j hj z).mono Icc_subset_Ici_self)
+    (cutoffFlow_zero κ c j hj z)
+  intro s hs
+  have hv : cutoffField κ b j s (cutoffFlow κ c j z s) =
+      cutoffField κ c j s (cutoffFlow κ c j z s) := by
+    simp only [cutoffField,he s (Ico_subset_Icc_self hs)]
+  rw [hv]
+  exact (cutoffFlow_hasDerivWithinAt κ c j hj z s hs.1).mono
+    (Ici_subset_Ici.mpr hs.1)
+
+lemma cutoffFlow_stopDriver (κ : ℝ) (b : Driver) (j : ℕ) (hj : 1 ≤ j)
+    (z : ℂ) (T : ℝ≥0) (t : ℝ) (ht : t ∈ Icc 0 (T : ℝ)) :
+    cutoffFlow κ (stopDriver b T) j z t = cutoffFlow κ b j z t := by
+  apply cutoffFlow_eq_of_driver_prefix κ _ _ j hj z T T.coe_nonneg ?_ t ht
+  intro s hs
+  simp only [driverValue,stopDriver_apply,
+    min_eq_left ((Real.toNNReal_le_iff_le_coe).mpr hs.2)]
+
+lemma cutoffFlow_measurable_past (κ : ℝ) (j : ℕ) (hj : 1 ≤ j) (T t : ℝ≥0)
+    (ht : t ≤ T) :
+    Measurable[(driverFiltration T).prod (borel ℂ)]
+      (fun q : Driver × ℂ => cutoffFlow κ q.1 j q.2 t) := by
+  have hpair : Measurable[(driverFiltration T).prod (borel ℂ)]
+      (fun q : Driver × ℂ => (t,(stopDriver q.1 T,q.2))) :=
+    measurable_const.prodMk (((stopDriver_measurable_past T).comp measurable_fst).prodMk
+      measurable_snd)
+  have hm : Measurable[(driverFiltration T).prod (borel ℂ)]
+      (fun q : Driver × ℂ => cutoffFlow κ (stopDriver q.1 T) j q.2 t) :=
+    @Measurable.comp (Driver × ℂ) (ℝ≥0 × (Driver × ℂ)) ℂ
+      ((driverFiltration T).prod (borel ℂ)) inferInstance inferInstance
+      (fun q => cutoffFlow κ q.2.1 j q.2.2 q.1)
+      (fun q => (t,(stopDriver q.1 T,q.2))) (measurable_cutoffFlow κ j hj) hpair
+  convert hm using 1
+  exact funext (fun q => (cutoffFlow_stopDriver κ q.1 j hj q.2 T t
+    ⟨t.coe_nonneg,show (t : ℝ) ≤ T from ht⟩).symm)
+
+end SLEExactGauge.Target
+
+end
+
+end OAI
diff --git a/lean/OAI/Probability/SLE/Loewner/TargetCutoffTrajectory.lean b/lean/OAI/Probability/SLE/Loewner/TargetCutoffTrajectory.lean
new file mode 100644
index 0000000000000000000000000000000000000000..54d000c589f3a2e0999969d6d5cdf3dd24b90c42
--- /dev/null
+++ b/lean/OAI/Probability/SLE/Loewner/TargetCutoffTrajectory.lean
@@ -0,0 +1,114 @@
+import OAI.Probability.SLE.Loewner.TargetEulerConvergence
+
+namespace OAI
+
+/-! The Euler-defined cutoff agrees with every classical trajectory on a
+compact time interval. Positive height makes the cutoff inactive. -/
+
+noncomputable section
+open Set Filter MeasureTheory Metric
+open scoped NNReal ENNReal Topology
+
+namespace SLEExactGauge.Target
+
+lemma cutoffFlow_eq_of_trajectory
+    (κ : ℝ) (b : Driver) (j : ℕ) (hj : 1 ≤ j) (z : ℂ)
+    (T : ℝ) (_hT : 0 ≤ T) (Y : ℝ → ℂ)
+    (hY : ContinuousOn Y (Icc 0 T)) (hY0 : Y 0=z)
+    (hYd : ∀ t ∈ Ico 0 T, HasDerivWithinAt Y
+      (cutoffField κ b j t (Y t)) (Ici t) t) :
+    ∀ t ∈ Icc 0 T, cutoffFlow κ b j z t=Y t := by
+  obtain ⟨L,K,X,hL,hK,hX,hX0,hXd⟩ := exists_cutoff_solution κ b j hj z
+  have he := dist_le_of_trajectories_ODE hK hX.continuous.continuousOn
+    (fun t ht => (hXd t ht.1).mono (Ici_subset_Ici.mpr ht.1)) hY hYd
+    (show dist (X 0) (Y 0) ≤ 0 by rw [hX0,hY0]; simp)
+  intro t ht
+  rw [cutoffFlow_eq_solution κ b j hj z L K hL hK X hX.continuous hX0 hXd t ht.1]
+  exact dist_le_zero.mp (by simpa only [zero_mul] using he t ht)
+
+lemma cutoffFlow_continuousOn (κ : ℝ) (b : Driver) (j : ℕ) (hj : 1 ≤ j) (z : ℂ) :
+    ContinuousOn (cutoffFlow κ b j z) (Ici 0) := by
+  obtain ⟨L,K,X,hL,hK,hX,hX0,hXd⟩ := exists_cutoff_solution κ b j hj z
+  exact hX.continuous.continuousOn.congr (fun t ht =>
+    cutoffFlow_eq_solution κ b j hj z L K hL hK X hX.continuous hX0 hXd t ht)
+
+lemma cutoffFlow_hasDerivWithinAt (κ : ℝ) (b : Driver) (j : ℕ)
+    (hj : 1 ≤ j) (z : ℂ) (t : ℝ) (ht : 0 ≤ t) :
+    HasDerivWithinAt (cutoffFlow κ b j z)
+      (cutoffField κ b j t (cutoffFlow κ b j z t)) (Ici 0) t := by
+  obtain ⟨L,K,X,hL,hK,hX,hX0,hXd⟩ := exists_cutoff_solution κ b j hj z
+  have he (s : ℝ) (hs : 0 ≤ s) :=
+    cutoffFlow_eq_solution κ b j hj z L K hL hK X hX.continuous hX0 hXd s hs
+  rw [he t ht]
+  exact (hXd t ht).congr_of_eventuallyEq
+    (by filter_upwards [self_mem_nhdsWithin] with s hs; exact he s hs) (he t ht)
+
+lemma cutoffFlow_zero (κ : ℝ) (b : Driver) (j : ℕ) (hj : 1 ≤ j) (z : ℂ) :
+    cutoffFlow κ b j z 0=z := by
+  obtain ⟨L,K,X,hL,hK,hX,hX0,hXd⟩ := exists_cutoff_solution κ b j hj z
+  rw [cutoffFlow_eq_solution κ b j hj z L K hL hK X hX.continuous hX0 hXd 0 le_rfl,hX0]
+
+lemma cutoff_inactive_of_height (j : ℕ) (hj : 1 ≤ j) (x : ℝ) (z : ℂ)
+    (hz : (j:ℝ)⁻¹ ≤ z.im) :
+    (j:ℝ)^(-(4:ℤ)) ≤ ‖z-(x:ℂ)‖^2 := by
+  have hj1 : (1:ℝ) ≤ j := by exact_mod_cast hj
+  have hj0 : (0:ℝ) < j := zero_lt_one.trans_le hj1
+  have hi0 : 0 < (j:ℝ)⁻¹ := inv_pos.mpr hj0
+  have hi1 : (j:ℝ)⁻¹ ≤ 1 := (inv_le_one₀ hj0).2 hj1
+  have hi2 : ((j:ℝ)⁻¹)^2 ≤ 1 := by nlinarith
+  have hi4 : ((j:ℝ)⁻¹)^4 ≤ ((j:ℝ)⁻¹)^2 := by nlinarith [sq_nonneg (((j:ℝ)⁻¹)^2)]
+  have hh : ((j:ℝ)⁻¹)^2 ≤ z.im^2 := by nlinarith
+  have hn := Complex.sq_norm_sub_sq_im (z-(x:ℂ))
+  simp only [Complex.sub_im,Complex.ofReal_im,sub_zero] at hn
+  calc
+    (j:ℝ)^(-(4:ℤ)) = ((j:ℝ)⁻¹)^4 := by simp only [zpow_neg,zpow_ofNat,inv_pow]
+    _ ≤ z.im^2 := hi4.trans hh
+    _ ≤ ‖z-(x:ℂ)‖^2 := by nlinarith [sq_nonneg (z-(x:ℂ)).re]
+
+lemma cutoffFlow_eq_of_positive_trajectory
+    (κ : ℝ) (b : Driver) (j : ℕ) (hj : 1 ≤ j) (z : ℂ)
+    (T : ℝ) (hT : 0 ≤ T) (Y : ℝ → ℂ)
+    (hY : ContinuousOn Y (Icc 0 T)) (hY0 : Y 0=z)
+    (hheight : ∀ t ∈ Icc 0 T, (j:ℝ)⁻¹ ≤ (Y t).im)
+    (hYd : ∀ t ∈ Ico 0 T, HasDerivWithinAt Y
+      ((a κ:ℂ)/(Y t-driverValue b t)) (Ici t) t) :
+    ∀ t ∈ Icc 0 T, cutoffFlow κ b j z t=Y t := by
+  apply cutoffFlow_eq_of_trajectory κ b j hj z T hT Y hY hY0
+  intro t ht
+  rw [cutoffField_eq_reciprocal κ b j t (Y t)
+    (cutoff_inactive_of_height j hj _ _ (hheight t (Ico_subset_Icc_self ht)))]
+  exact hYd t ht
+
+lemma surviving_cutoff_height (κ : ℝ) (b : Driver) (z : ℂ)
+    (T : ℝ) (j : ℕ) (hj : 1 ≤ j)
+    (hmin : (j:ℝ)⁻¹ <
+      sInf ((fun t : ℝ => (cutoffFlow κ b j z t).im) '' Icc 0 T)) :
+    ∀ t ∈ Icc 0 T, (j:ℝ)⁻¹ < (cutoffFlow κ b j z t).im := by
+  have hc : IsCompact ((fun t : ℝ => (cutoffFlow κ b j z t).im) '' Icc 0 T) :=
+    isCompact_Icc.image_of_continuousOn (Complex.continuous_im.comp_continuousOn
+      ((cutoffFlow_continuousOn κ b j hj z).mono Icc_subset_Ici_self))
+  intro t ht
+  exact hmin.trans_le (csInf_le hc.bddBelow ⟨t,ht,rfl⟩)
+
+lemma surviving_of_positive_trajectory
+    (κ : ℝ) (b : Driver) (z : ℂ) (T : ℝ) (hT : 0 ≤ T)
+    (Y : ℝ → ℂ) (hY : ContinuousOn Y (Icc 0 T)) (hY0 : Y 0=z)
+    (m : ℝ) (hm : 0 < m) (hheight : ∀ t ∈ Icc 0 T, m ≤ (Y t).im)
+    (hYd : ∀ t ∈ Ico 0 T, HasDerivWithinAt Y
+      ((a κ:ℂ)/(Y t-driverValue b t)) (Ici t) t) : Surviving κ b z T := by
+  obtain ⟨j,hj0,hjm⟩ := Real.exists_nat_pos_inv_lt hm
+  have hj : 1 ≤ j := hj0
+  have he := cutoffFlow_eq_of_positive_trajectory κ b j hj z T hT Y hY hY0
+    (fun t ht => hjm.le.trans (hheight t ht)) hYd
+  refine ⟨j,hj,lt_of_lt_of_le hjm ?_⟩
+  apply le_csInf (Set.Nonempty.image _ (nonempty_Icc.mpr hT))
+  rintro y ⟨t,ht,rfl⟩
+  change m ≤ (cutoffFlow κ b j z t).im
+  rw [he t ht]
+  exact hheight t ht
+
+end SLEExactGauge.Target
+
+end
+
+end OAI
diff --git a/lean/OAI/Probability/SLE/Loewner/TargetDensityBound.lean b/lean/OAI/Probability/SLE/Loewner/TargetDensityBound.lean
new file mode 100644
index 0000000000000000000000000000000000000000..4af2b68e7fbccd5fe8310f9f8b0a64bdef276989
--- /dev/null
+++ b/lean/OAI/Probability/SLE/Loewner/TargetDensityBound.lean
@@ -0,0 +1,66 @@
+import OAI.Probability.SLE.Mass.DiskMassMomentBound
+import OAI.Probability.SLE.Stochastic.WienerCoefficientLimit
+
+namespace OAI
+
+/-! The exact change-of-law density is supported on the physical center
+hit and bounded by its compensating exponential factor. -/
+
+noncomputable section
+open Set Filter _root_.MeasureTheory _root_.OAI.MeasureTheory ProbabilityTheory
+open scoped NNReal ENNReal
+
+namespace SLEExactGauge.Target
+
+lemma levelDensity_le_centerHit
+    (κ : ℝ) (hκ : 0<κ) (hκ8 : κ<8)
+    (b : Driver) (U : ℝ≥0 → ℝ) (hc : Continuous U)
+    (γ : ℝ≥0 → ℂ) (G F : ℝ≥0 → ℂ → ℂ)
+    (hw : IsCapacityTwoWitness U γ G F)
+    (hU : ∀ s : ℝ, 0 ≤ s → U s.toNNReal=driverValue b (κ*s))
+    (θ : ℝ) (hθ : θ∈Ioo (0:ℝ) Real.pi) (ℓ : ℝ) (hℓ : 0≤ℓ) :
+    levelDensity κ θ b ℓ ≤
+      (Multipoint.diskCenterHit (fun _ : Unit => γ) (fun _ : Unit => G) θ
+        (Real.exp (-(4*ℓ/κ)))).indicator
+        (fun _ => Real.exp ((4*ℓ/κ)*codimension κ)/(Real.sin θ)^greenExponent κ) () := by
+  let z := diskMapInv θ 0
+  let u := 4*ℓ/κ
+  have hz : z∈upperHalfPlane := diskMapInv_maps hθ (by simp)
+  have hR : 0<2*z.im := mul_pos (by norm_num) hz
+  have hs : 0<Real.sin θ := Real.sin_pos_of_pos_of_lt_pi hθ.1 hθ.2
+  have hu : 0≤u := div_nonneg (mul_nonneg (by norm_num) hℓ) hκ.le
+  have he1 : Real.exp (-u)≤1 := Real.exp_le_one_iff.mpr (neg_nonpos.mpr hu)
+  have hlog : Real.log (1/Real.exp (-u))=u := by
+    rw [one_div,← Real.exp_neg,neg_neg,Real.log_exp]
+  rw [levelDensity_eq_stoppedGreen κ hκ b U hc γ G F hw hU θ hθ ℓ hℓ]
+  change stoppedGreen κ U γ G z u/initialGreen κ z ≤ _
+  by_cases hh : ()∈Multipoint.diskCenterHit (fun _ : Unit => γ) (fun _ : Unit => G) θ (Real.exp (-u))
+  · rw [indicator_of_mem hh]
+    have hb := Multipoint.stoppedGreen_level_bound hc hw hκ hκ8 z hz
+      ((2*z.im)*Real.exp (-u)) (mul_pos hR (Real.exp_pos _))
+    rw [Multipoint.common_level_log_target z hz u] at hb
+    apply (div_le_div_of_nonneg_right hb (initialGreen_pos κ z hz).le).trans_eq
+    have hi : initialGreen κ z=(2*z.im)^(-codimension κ)*(Real.sin θ)^greenExponent κ := by
+      rw [initialGreen]
+      exact congrArg (fun s : ℝ => (2*z.im)^(-codimension κ)*s^greenExponent κ)
+        (disk_center_sin_arg θ)
+    rw [hi,Real.mul_rpow hR.le (Real.exp_pos _).le,← Real.exp_mul,neg_mul_neg]
+    field_simp [(Real.rpow_pos_of_pos hR (-codimension κ)).ne',
+      (Real.rpow_pos_of_pos hs (greenExponent κ)).ne']
+    congr 1
+    dsimp only [u]
+    ring
+  · rw [indicator_of_notMem hh]
+    have ht : ¬ radiusLevelTime γ G z u<∞ := by
+      intro ht
+      apply hh
+      apply (physical_radius_hit_iff_finite_level hc hw (diskMap θ) z 1 (Real.exp (-u))
+        zero_lt_one (Real.exp_pos _) he1 (initialRadius_zero hθ).symm).mpr
+      rwa [hlog]
+    simp only [stoppedGreen,ite_eq_right ht,zero_div,le_refl]
+
+end SLEExactGauge.Target
+
+end
+
+end OAI
diff --git a/lean/OAI/Probability/SLE/Loewner/TargetDriverContinuation.lean b/lean/OAI/Probability/SLE/Loewner/TargetDriverContinuation.lean
new file mode 100644
index 0000000000000000000000000000000000000000..2bbd660500adfbffb7b72ea46f07233c50b77e6c
--- /dev/null
+++ b/lean/OAI/Probability/SLE/Loewner/TargetDriverContinuation.lean
@@ -0,0 +1,154 @@
+import OAI.Probability.SLE.MomentGauge
+import OAI.Probability.SLE.Geometry.RestartContinuationKernel
+
+namespace OAI
+
+/-! The prescribed based-driver concatenation is the ordinary Brownian
+continuation kernel, including its finite real-valued conditional mean. -/
+
+noncomputable section
+open Set Filter _root_.MeasureTheory _root_.OAI.MeasureTheory ProbabilityTheory
+open scoped Topology NNReal ENNReal
+
+namespace SLEExactGauge.Target
+
+local instance targetContinuationPathMeasurable : MeasurableSpace C(ℝ≥0, ℝ) := borel _
+local instance targetContinuationPathBorel : BorelSpace C(ℝ≥0, ℝ) := ⟨rfl⟩
+
+def centerDriver (p : C(ℝ≥0, ℝ)) : Driver where
+  toFun t := p t - p 0
+  continuous_toFun := p.continuous.sub continuous_const
+  map_zero' := sub_self _
+
+lemma measurable_centerDriver : Measurable centerDriver := by
+  apply ContinuousMapZero.isClosedEmbedding_toContinuousMap.measurableEmbedding.measurable_comp_iff.mp
+  apply source_path_measurable
+  intro t
+  exact (continuous_eval_const t).measurable.sub (continuous_eval_const 0).measurable
+
+lemma measurable_driverInclusion :
+    Measurable (fun b : Driver => b.toContinuousMap) :=
+  ContinuousMapZero.isClosedEmbedding_toContinuousMap.continuous.measurable
+
+@[simp] lemma centerDriver_inclusion (b : Driver) : centerDriver b.toContinuousMap = b := by
+  ext t
+  change b t - b 0 = b t
+  simp
+
+lemma measurable_concat :
+    Measurable (fun x : ℝ × (Driver × Driver) => concat x.2.1 x.2.2 x.1) := by
+  apply ContinuousMapZero.isClosedEmbedding_toContinuousMap.measurableEmbedding.measurable_comp_iff.mp
+  apply source_path_measurable
+  intro u
+  have ht : Measurable (fun x : ℝ × (Driver × Driver) => x.1.toNNReal) :=
+    continuous_real_toNNReal.measurable.comp measurable_fst
+  have hb : Measurable (fun x : ℝ × (Driver × Driver) => x.2.1 u) :=
+    (continuous_eval_const u).measurable.comp (measurable_fst.comp measurable_snd)
+  have hbt : Measurable (fun x : ℝ × (Driver × Driver) => x.2.1 x.1.toNNReal) :=
+    continuous_eval.measurable.comp ((measurable_fst.comp measurable_snd).prodMk ht)
+  have hc : Measurable (fun x : ℝ × (Driver × Driver) => x.2.2 (u-x.1.toNNReal)) :=
+    continuous_eval.measurable.comp
+      ((measurable_snd.comp measurable_snd).prodMk (measurable_const.sub ht))
+  exact hb.ite (measurableSet_le measurable_const ht) (hbt.add hc)
+
+lemma centerDriver_concatenate (b c : Driver) (t : ℝ≥0) :
+    centerDriver (concatenateDriverPath t (driverPathStopped t b.toContinuousMap)
+      c.toContinuousMap) = concat b c t := by
+  ext u
+  change (if u ≤ t then b (min u t) else b (min t t) + c (u-t) - c 0) -
+    (if 0 ≤ t then b (min 0 t) else b (min t t) + c (0-t) - c 0) =
+    (if u ≤ (t : ℝ).toNNReal then b u else b (t : ℝ).toNNReal + c (u-(t : ℝ).toNNReal))
+  by_cases hu : u ≤ t
+  · simp [hu]
+  · simp [hu]
+
+def driverFiltration : Filtration ℝ≥0 (borel Driver) :=
+  Filtration.natural (fun t (b : Driver) => b t)
+    (fun t => (continuous_eval_const t).measurable.stronglyMeasurable)
+
+def continuationMean (W : WienerLaw) (t : ℝ) (f : Driver → ℝ≥0∞)
+    (b : Driver) : ℝ≥0∞ := ∫⁻ c, f (concat b c t) ∂W
+
+lemma measurable_continuationMean (W : WienerLaw) [SFinite W]
+    (t : ℝ) (f : Driver → ℝ≥0∞) (hf : Measurable f) :
+    Measurable (continuationMean W t f) := by
+  exact (hf.comp (measurable_concat.comp
+    (measurable_const.prodMk (measurable_fst.prodMk measurable_snd)))).lintegral_prod_right'
+
+lemma continuationMean_eq_pathMean (W : WienerLaw) (t : ℝ≥0)
+    (f : Driver → ℝ≥0∞) (hf : Measurable f) (b : Driver) :
+    driverContinuationMean (W.map (fun c : Driver => c.toContinuousMap)) t
+      (fun p => f (centerDriver p)) b.toContinuousMap = continuationMean W t f b := by
+  have hm : Measurable (fun q : C(ℝ≥0, ℝ) =>
+      f (centerDriver (concatenateDriverPath t (driverPathStopped t b.toContinuousMap) q))) :=
+    (hf.comp measurable_centerDriver).comp (measurable_concatenateDriverPath.comp
+      (measurable_const.prodMk (measurable_const.prodMk measurable_id)))
+  unfold driverContinuationMean
+  rw [lintegral_map hm measurable_driverInclusion]
+  simp only [centerDriver_concatenate, continuationMean]
+
+lemma continuationMean_measurable_past (W : WienerLaw) [IsProbabilityMeasure W]
+    (t : ℝ≥0) (f : Driver → ℝ≥0∞) (hf : Measurable f) :
+    Measurable[driverFiltration t] (continuationMean W t f) := by
+  let ν := W.map (fun c : Driver => c.toContinuousMap)
+  let : IsProbabilityMeasure ν :=
+    (Measure.isProbabilityMeasure_map_iff measurable_driverInclusion.aemeasurable).mpr inferInstance
+  have hpath : Measurable[driverFiltration t, driverPathFiltration t]
+      (fun b : Driver => b.toContinuousMap) :=
+    driverPath_measurable_past_of_adapted driverFiltration _
+      (fun s => (Filtration.stronglyAdapted_natural
+        (fun u => (show Measurable (fun b : Driver => b u) from
+          (continuous_eval_const u).measurable).stronglyMeasurable) s).measurable) t
+  have hh := (driverContinuationMean_measurable ν t (fun p => f (centerDriver p))
+    (hf.comp measurable_centerDriver)).comp hpath
+  have he : (fun b : Driver => driverContinuationMean ν t
+      (fun p => f (centerDriver p)) b.toContinuousMap) = continuationMean W t f :=
+    funext (fun b => continuationMean_eq_pathMean W t f hf b)
+  change Measurable[driverFiltration t] (fun b : Driver => driverContinuationMean ν t
+    (fun p => f (centerDriver p)) b.toContinuousMap) at hh
+  rwa [he] at hh
+
+theorem continuationMean_condLExp (W : WienerLaw) (hW : IsWiener W)
+    (t : ℝ≥0) (f : Driver → ℝ≥0∞) (hf : Measurable f) :
+    continuationMean W t f =ᵐ[W] W⁻[f | driverFiltration t] := by
+  let : IsProbabilityMeasure W := hW.isGaussianProcess.isProbabilityMeasure
+  have h := source_driver_continuation_condLExp hW
+    (fun s => (continuous_eval_const s).measurable)
+    (fun b => map_continuous b) t (fun p => f (centerDriver p))
+    (hf.comp measurable_centerDriver)
+  change (fun b : Driver => driverContinuationMean
+      (W.map (fun c : Driver => c.toContinuousMap)) t
+      (fun p => f (centerDriver p)) b.toContinuousMap) =ᵐ[W]
+    W⁻[(fun b : Driver => f (centerDriver b.toContinuousMap)) | driverFiltration t] at h
+  have he : (fun b : Driver => driverContinuationMean
+      (W.map (fun c : Driver => c.toContinuousMap)) t
+      (fun p => f (centerDriver p)) b.toContinuousMap) = continuationMean W t f :=
+    funext (fun b => continuationMean_eq_pathMean W t f hf b)
+  rw [he] at h
+  simpa only [centerDriver_inclusion] using h
+
+theorem continuationMean_setLIntegral (W : WienerLaw) (hW : IsWiener W)
+    (t : ℝ≥0) (f : Driver → ℝ≥0∞) (hf : Measurable f)
+    (A : Set Driver) (hA : MeasurableSet[driverFiltration t] A) :
+    (∫⁻ b in A, continuationMean W t f b ∂W) = ∫⁻ b in A, f b ∂W := by
+  let : IsProbabilityMeasure W := hW.isGaussianProcess.isProbabilityMeasure
+  rw [lintegral_congr_ae (ae_restrict_of_ae (continuationMean_condLExp W hW t f hf))]
+  exact setLIntegral_condLExp (driverFiltration.le t) W f hA
+
+theorem continuationMean_finite_condExp (W : WienerLaw) (hW : IsWiener W)
+    (t : ℝ≥0) (f : Driver → ℝ≥0∞) (hf : Measurable f)
+    (hfin : (∫⁻ b, f b ∂W) ≠ ∞) :
+    (∀ᵐ b ∂W, continuationMean W t f b < ∞) ∧
+    (fun b => (continuationMean W t f b).toReal) =ᵐ[W]
+      W[fun b => (f b).toReal | driverFiltration t] := by
+  have he := continuationMean_condLExp W hW t f hf
+  constructor
+  · filter_upwards [he, condLExp_lt_top (mΩ := driverFiltration t) hfin] with b hb hbfin
+    exact hb.symm ▸ hbfin
+  · exact (he.fun_comp ENNReal.toReal).trans (toReal_condLExp _ hf.aemeasurable hfin)
+
+end SLEExactGauge.Target
+
+end
+
+end OAI
diff --git a/lean/OAI/Probability/SLE/Loewner/TargetEulerBridge.lean b/lean/OAI/Probability/SLE/Loewner/TargetEulerBridge.lean
new file mode 100644
index 0000000000000000000000000000000000000000..ee6561bda84c9a20117f0030ab8d6a0428d3cfb3
--- /dev/null
+++ b/lean/OAI/Probability/SLE/Loewner/TargetEulerBridge.lean
@@ -0,0 +1,50 @@
+import OAI.Probability.SLE.Loewner.TargetCutoffField
+import Mathlib.Analysis.ODE.DiscreteGronwall
+
+namespace OAI
+
+/-! The bounded equation underlying the explicitly prescribed Euler flow.
+The cutoff is inactive on any path whose height stays above its threshold. -/
+
+noncomputable section
+open Set Filter MeasureTheory Metric
+open scoped NNReal ENNReal Topology
+
+namespace SLEExactGauge.Target
+
+lemma cutoffField_eq_reciprocal
+    (κ : ℝ) (b : Driver) (j : ℕ) (t : ℝ) (z : ℂ)
+    (hcut : (j:ℝ)^(-(4:ℤ)) ≤ ‖z-driverValue b t‖^2) :
+    cutoffField κ b j t z = (a κ:ℂ)/(z-driverValue b t) := by
+  rw [cutoffField,max_eq_left hcut,mul_div_assoc]
+  congr 1
+  rw [Complex.inv_def,Complex.normSq_eq_norm_sq]
+  simp only [div_eq_mul_inv,starRingEnd_apply,Complex.ofReal_inv]
+
+lemma exists_cutoff_solution
+    (κ : ℝ) (b : Driver) (j : ℕ) (hj : 1 ≤ j) (z : ℂ) :
+    ∃ (L K : ℝ≥0) (X : ℝ → ℂ),
+      (∀ t w, ‖cutoffField κ b j t w‖ ≤ L) ∧
+      (∀ t, LipschitzWith K (cutoffField κ b j t)) ∧
+      LipschitzWith L X ∧ X 0=z ∧
+      (∀ t, 0 ≤ t → HasDerivWithinAt X (cutoffField κ b j t (X t)) (Ici 0) t) := by
+  obtain ⟨L,K,hL,hK⟩ := cutoffField_bounds κ j hj
+  let V (t : ℝ) (_ : Unit) (w : ℂ) := cutoffField κ b j t w
+  have hF : Measurable (fun p : ℝ × ℂ => cutoffField κ b j p.1 p.2) :=
+    (continuous_cutoffField κ b j hj).measurable
+  have hpair : Measurable (fun q : (ℝ × Unit) × ℂ => (q.1.1,q.2)) :=
+    measurable_fst.fst.prodMk measurable_snd
+  have hm : Measurable (fun q : (ℝ × Unit) × ℂ => V q.1.1 q.1.2 q.2) :=
+    @Measurable.comp ((ℝ × Unit) × ℂ) (ℝ × ℂ) ℂ inferInstance inferInstance inferInstance
+      (fun p => cutoffField κ b j p.1 p.2) (fun q => (q.1.1,q.2)) hF hpair
+  have hc (_ : Unit) (w : ℂ) : Continuous (fun t => V t () w) :=
+    (continuous_cutoffField κ b j hj).comp (continuous_id.prodMk continuous_const)
+  obtain ⟨X,hXm,hXl,hX0,hXd,hXconv⟩ := exists_measurable_global_bounded_ode_picard
+    V z L K hm hc (fun _ t => hK b t) (fun _ t w => hL b t w)
+  exact ⟨L,K,(fun t => X t ()),hL b,hK b,hXl (),hX0 (),fun t ht => hXd () t ht⟩
+
+end SLEExactGauge.Target
+
+end
+
+end OAI
diff --git a/lean/OAI/Probability/SLE/Loewner/TargetEulerConvergence.lean b/lean/OAI/Probability/SLE/Loewner/TargetEulerConvergence.lean
new file mode 100644
index 0000000000000000000000000000000000000000..071b71bae0b9db4fe0a5e30ac0a0b4ee52991d90
--- /dev/null
+++ b/lean/OAI/Probability/SLE/Loewner/TargetEulerConvergence.lean
@@ -0,0 +1,127 @@
+import OAI.Probability.SLE.Loewner.TargetEulerInterpolation
+
+namespace OAI
+
+/-! The prescribed dyadic Euler definition converges to the bounded cutoff ODE.
+Only continuity in time and a global Lipschitz bound in space are used. -/
+
+noncomputable section
+open Set Filter MeasureTheory Metric
+open scoped NNReal ENNReal Topology
+
+namespace SLEExactGauge.Target
+
+private def eulerSlope (κ : ℝ) (b : Driver) (j N : ℕ) (z : ℂ) (t : ℝ) : ℂ :=
+  cutoffField κ b j (((⌊t/mesh N⌋₊:ℕ):ℝ)*mesh N)
+    (eulerSteps κ b j N z ⌊t/mesh N⌋₊)
+
+private lemma euler_pairs_mem (κ : ℝ) (b : Driver) (j N : ℕ) (z : ℂ)
+    (L : ℝ≥0) (hL : ∀ t w, ‖cutoffField κ b j t w‖ ≤ L)
+    (T t : ℝ) (ht : t ∈ Icc 0 T) :
+    (((⌊t/mesh N⌋₊:ℕ):ℝ)*mesh N,
+      eulerSteps κ b j N z ⌊t/mesh N⌋₊) ∈ Icc (0:ℝ) T ×ˢ closedBall z (L*T) ∧
+    (t,eulerFlow κ b j N z t) ∈ Icc (0:ℝ) T ×ˢ closedBall z (L*T) := by
+  let k := ⌊t/mesh N⌋₊
+  have hs0 : 0 ≤ (k:ℝ)*mesh N := mul_nonneg (Nat.cast_nonneg _) (mesh_pos N).le
+  have hst : (k:ℝ)*mesh N ≤ t := (le_div_iff₀ (mesh_pos N)).1
+    (Nat.floor_le (div_nonneg ht.1 (mesh_pos N).le))
+  refine ⟨⟨⟨hs0,hst.trans ht.2⟩,?_⟩,⟨ht,?_⟩⟩
+  · apply (eulerSteps_dist_le κ b j N z L hL k).trans
+    calc
+      (k:ℝ)*mesh N*L = L*((k:ℝ)*mesh N) := by ring
+      _ ≤ L*T := mul_le_mul_of_nonneg_left (hst.trans ht.2) L.coe_nonneg
+  · exact (eulerFlow_dist_initial_le κ b j N z L hL t ht.1).trans
+      (mul_le_mul_of_nonneg_left ht.2 L.coe_nonneg)
+
+private lemma euler_pairs_dist_lt (κ : ℝ) (b : Driver) (j N : ℕ) (z : ℂ)
+    (L : ℝ≥0) (hL : ∀ t w, ‖cutoffField κ b j t w‖ ≤ L)
+    (t δ : ℝ) (ht : 0 ≤ t) (hmesh : mesh N*(L+1)<δ) :
+    dist ((((⌊t/mesh N⌋₊:ℕ):ℝ)*mesh N),
+      eulerSteps κ b j N z ⌊t/mesh N⌋₊) (t,eulerFlow κ b j N z t) < δ := by
+  let k := ⌊t/mesh N⌋₊
+  have hst : (k:ℝ)*mesh N ≤ t := (le_div_iff₀ (mesh_pos N)).1
+    (Nat.floor_le (div_nonneg ht (mesh_pos N).le))
+  have hts : t-(k:ℝ)*mesh N < mesh N := by
+    have hh := (div_lt_iff₀ (mesh_pos N)).1 (Nat.lt_floor_add_one (t/mesh N))
+    change t < ((k:ℝ)+1)*mesh N at hh
+    linarith
+  rw [Prod.dist_eq]
+  apply max_lt
+  · rw [Real.dist_eq,abs_sub_comm,abs_of_nonneg (sub_nonneg.mpr hst)]
+    have hh : mesh N ≤ mesh N*(L+1) := by nlinarith [mesh_pos N,L.coe_nonneg]
+    exact hts.trans_le hh |>.trans hmesh
+  · rw [dist_comm]
+    have hh : L*mesh N < δ := by nlinarith [mesh_pos N]
+    exact (eulerFlow_dist_grid_le κ b j N z L hL t ht).trans_lt hh
+
+lemma eulerSlope_error_tendsto
+    (κ : ℝ) (b : Driver) (j : ℕ) (hj : 1 ≤ j) (z : ℂ)
+    (L : ℝ≥0) (hL : ∀ t w, ‖cutoffField κ b j t w‖ ≤ L)
+    (T : ℝ) (_hT : 0 ≤ T) (ε : ℝ) (hε : 0 < ε) :
+    ∀ᶠ N : ℕ in atTop, ∀ t ∈ Icc 0 T,
+      dist (eulerSlope κ b j N z t) (cutoffField κ b j t (eulerFlow κ b j N z t)) < ε := by
+  let C := Icc (0:ℝ) T ×ˢ closedBall z (L*T)
+  have hC : IsCompact C := isCompact_Icc.prod (isCompact_closedBall z (L*T))
+  obtain ⟨δ,hδ,huniform⟩ := Metric.uniformContinuousOn_iff.mp
+    (hC.uniformContinuousOn_of_continuous (continuous_cutoffField κ b j hj).continuousOn) ε hε
+  have hd : 0 < δ/(L+1) := div_pos hδ (by positivity)
+  have hmesh : ∀ᶠ N : ℕ in atTop, mesh N < δ/(L+1) :=
+    (tendsto_order.1 mesh_tendsto_zero).2 _ hd
+  filter_upwards [hmesh] with N hN
+  intro t ht
+  obtain ⟨hgrid,hflow⟩ := euler_pairs_mem κ b j N z L hL T t ht
+  have hhδ : mesh N*(L+1) < δ := (lt_div_iff₀ (by positivity : (0:ℝ)<L+1)).1 hN
+  exact huniform
+    ((((⌊t/mesh N⌋₊:ℕ):ℝ)*mesh N),eulerSteps κ b j N z ⌊t/mesh N⌋₊) hgrid
+    (t,eulerFlow κ b j N z t) hflow (euler_pairs_dist_lt κ b j N z L hL t δ ht.1 hhδ)
+
+lemma eulerFlow_tendsto_solution
+    (κ : ℝ) (b : Driver) (j : ℕ) (hj : 1 ≤ j) (z : ℂ)
+    (L K : ℝ≥0) (hL : ∀ t w, ‖cutoffField κ b j t w‖ ≤ L)
+    (hK : ∀ t, LipschitzWith K (cutoffField κ b j t))
+    (X : ℝ → ℂ) (hX : Continuous X) (hX0 : X 0=z)
+    (hXd : ∀ t, 0 ≤ t → HasDerivWithinAt X (cutoffField κ b j t (X t)) (Ici 0) t)
+    (T : ℝ) (hT : 0 ≤ T) :
+    Tendsto (fun N : ℕ => eulerFlow κ b j N z T) atTop (𝓝 (X T)) := by
+  apply Metric.tendsto_nhds.mpr
+  intro ε hε
+  have hcont : ContinuousAt (fun ε => gronwallBound 0 K ε T) 0 :=
+    (gronwallBound_continuous_ε 0 K T).continuousAt
+  obtain ⟨δ,hδ,hsmall⟩ := Metric.continuousAt_iff.mp hcont ε hε
+  let η := δ/2
+  have hη : 0 < η := half_pos hδ
+  have hbound : gronwallBound 0 K η T < ε := by
+    have h := hsmall (show dist η 0 < δ by
+      rw [Real.dist_eq,sub_zero,abs_of_pos hη]
+      exact half_lt_self hδ)
+    rw [gronwallBound_ε0_δ0,Real.dist_eq,sub_zero] at h
+    exact (le_abs_self _).trans_lt h
+  filter_upwards [eulerSlope_error_tendsto κ b j hj z L hL T hT η hη] with N hN
+  have hestimate := dist_le_of_approx_trajectories_ODE (v := cutoffField κ b j)
+    (f := eulerFlow κ b j N z) (g := X)
+    (f' := eulerSlope κ b j N z) (g' := fun t => cutoffField κ b j t (X t))
+    (a := 0) (b := T) (δ := 0) (εf := η) (εg := 0) hK
+    (eulerFlow_continuousOn κ b j N z T)
+    (fun t ht => eulerFlow_right_deriv κ b j N z t ht.1)
+    (fun t ht => (hN t (Ico_subset_Icc_self ht)).le)
+    hX.continuousOn
+    (fun t ht => (hXd t ht.1).mono (Ici_subset_Ici.mpr ht.1))
+    (fun _ _ => by simp)
+    (by simp only [eulerFlow_zero,hX0,dist_self]; exact le_rfl) T ⟨hT,le_rfl⟩
+  rw [add_zero,sub_zero] at hestimate
+  exact hestimate.trans_lt hbound
+
+lemma cutoffFlow_eq_solution
+    (κ : ℝ) (b : Driver) (j : ℕ) (hj : 1 ≤ j) (z : ℂ)
+    (L K : ℝ≥0) (hL : ∀ t w, ‖cutoffField κ b j t w‖ ≤ L)
+    (hK : ∀ t, LipschitzWith K (cutoffField κ b j t))
+    (X : ℝ → ℂ) (hX : Continuous X) (hX0 : X 0=z)
+    (hXd : ∀ t, 0 ≤ t → HasDerivWithinAt X (cutoffField κ b j t (X t)) (Ici 0) t)
+    (T : ℝ) (hT : 0 ≤ T) : cutoffFlow κ b j z T = X T := by
+  exact (eulerFlow_tendsto_solution κ b j hj z L K hL hK X hX hX0 hXd T hT).limUnder_eq
+
+end SLEExactGauge.Target
+
+end
+
+end OAI
diff --git a/lean/OAI/Probability/SLE/Loewner/TargetEulerInterpolation.lean b/lean/OAI/Probability/SLE/Loewner/TargetEulerInterpolation.lean
new file mode 100644
index 0000000000000000000000000000000000000000..d437fa56f18dbe2a14d0a6cc36a62a50bb5e86ce
--- /dev/null
+++ b/lean/OAI/Probability/SLE/Loewner/TargetEulerInterpolation.lean
@@ -0,0 +1,165 @@
+import OAI.Probability.SLE.Loewner.TargetEulerBridge
+
+namespace OAI
+
+/-! The prescribed Euler interpolants are continuous piecewise-affine
+paths with the exact right derivative at every nonnegative time. -/
+
+noncomputable section
+open Set Filter MeasureTheory Metric
+open scoped NNReal ENNReal Topology
+
+namespace SLEExactGauge.Target
+
+lemma mesh_pos (N : ℕ) : 0 < mesh N := zpow_pos (by norm_num) _
+
+lemma mesh_tendsto_zero : Tendsto mesh atTop (𝓝 0) := by
+  have he (N : ℕ) : mesh N = ((2:ℝ)⁻¹)^N := by
+    simp only [mesh,zpow_neg,zpow_natCast,inv_pow]
+  have hm : mesh = fun N : ℕ => ((2:ℝ)⁻¹)^N := funext he
+  rw [hm]
+  exact tendsto_pow_atTop_nhds_zero_of_lt_one
+    (by norm_num : (0:ℝ) ≤ (2:ℝ)⁻¹) (by norm_num : (2:ℝ)⁻¹ < 1)
+
+lemma eulerFlow_on_cell (κ : ℝ) (b : Driver) (j N : ℕ) (z : ℂ)
+    (k : ℕ) (t : ℝ)
+    (ht : t ∈ Icc ((k:ℝ)*mesh N) (((k:ℝ)+1)*mesh N)) :
+    eulerFlow κ b j N z t = eulerSteps κ b j N z k +
+      ((t-(k:ℝ)*mesh N : ℝ):ℂ) * cutoffField κ b j ((k:ℝ)*mesh N) (eulerSteps κ b j N z k) := by
+  have hh := mesh_pos N
+  have ht0 : 0 ≤ t := (mul_nonneg (Nat.cast_nonneg k) hh.le).trans ht.1
+  by_cases hu : t=((k:ℝ)+1)*mesh N
+  · have hd : t/mesh N=((k+1:ℕ):ℝ) := by rw [hu,mul_div_cancel_right₀ _ hh.ne']; norm_num
+    simp only [eulerFlow,hd,Nat.floor_natCast,sub_self,Complex.ofReal_zero,zero_mul,
+      sub_zero,add_zero]
+    rw [eulerSteps]
+    have he : t-(k:ℝ)*mesh N=mesh N := by rw [hu]; ring
+    rw [he]
+    simp only [Complex.ofReal_one,one_mul]
+  · have hlt : t<((k:ℝ)+1)*mesh N := lt_of_le_of_ne ht.2 hu
+    have hk : ⌊t/mesh N⌋₊=k := (Nat.floor_eq_iff (div_nonneg ht0 hh.le)).2
+      ⟨(le_div_iff₀ hh).2 ht.1,(div_lt_iff₀ hh).2 hlt⟩
+    simp only [eulerFlow,hk,eulerSteps]
+    push_cast
+    field_simp [Complex.ofReal_ne_zero.mpr hh.ne']
+    ring
+
+lemma eulerFlow_continuousOn_cell (κ : ℝ) (b : Driver) (j N : ℕ) (z : ℂ) (k : ℕ) :
+    ContinuousOn (eulerFlow κ b j N z) (Icc ((k:ℝ)*mesh N) (((k:ℝ)+1)*mesh N)) := by
+  have hc : Continuous (fun t : ℝ => eulerSteps κ b j N z k +
+      ((t-(k:ℝ)*mesh N : ℝ):ℂ) * cutoffField κ b j ((k:ℝ)*mesh N) (eulerSteps κ b j N z k)) := by
+    fun_prop
+  exact hc.continuousOn.congr (fun t ht => eulerFlow_on_cell κ b j N z k t ht)
+
+lemma eulerFlow_continuousOn_grid (κ : ℝ) (b : Driver) (j N : ℕ) (z : ℂ) (k : ℕ) :
+    ContinuousOn (eulerFlow κ b j N z) (Icc 0 ((k:ℝ)*mesh N)) := by
+  induction k with
+  | zero => simpa only [Nat.cast_zero,zero_mul,Icc_self] using
+      (continuousOn_singleton (eulerFlow κ b j N z) 0)
+  | succ k ih =>
+    have hnonneg : 0 ≤ (k:ℝ)*mesh N := mul_nonneg (Nat.cast_nonneg _) (mesh_pos N).le
+    have hle : (k:ℝ)*mesh N ≤ ((k:ℝ)+1)*mesh N := by nlinarith [mesh_pos N]
+    have hu : Icc (0:ℝ) (((k:ℝ)+1)*mesh N) =
+        Icc 0 ((k:ℝ)*mesh N) ∪ Icc ((k:ℝ)*mesh N) (((k:ℝ)+1)*mesh N) := by
+      ext t
+      simp only [mem_Icc,mem_union]
+      constructor
+      · rintro ⟨ht0,ht1⟩
+        rcases le_total t ((k:ℝ)*mesh N) with h|h
+        · exact Or.inl ⟨ht0,h⟩
+        · exact Or.inr ⟨h,ht1⟩
+      · rintro (⟨ht0,ht1⟩|⟨ht0,ht1⟩)
+        · exact ⟨ht0,ht1.trans hle⟩
+        · exact ⟨hnonneg.trans ht0,ht1⟩
+    simp only [Nat.cast_add,Nat.cast_one]
+    rw [hu]
+    exact ih.union_of_isClosed (eulerFlow_continuousOn_cell κ b j N z k) isClosed_Icc isClosed_Icc
+
+lemma eulerFlow_continuousOn (κ : ℝ) (b : Driver) (j N : ℕ) (z : ℂ) (T : ℝ) :
+    ContinuousOn (eulerFlow κ b j N z) (Icc 0 T) := by
+  obtain ⟨k,hk⟩ := exists_nat_ge (T/mesh N)
+  have hT : T ≤ (k:ℝ)*mesh N := (div_le_iff₀ (mesh_pos N)).1 hk
+  exact (eulerFlow_continuousOn_grid κ b j N z k).mono (Icc_subset_Icc le_rfl hT)
+
+lemma eulerFlow_right_deriv (κ : ℝ) (b : Driver) (j N : ℕ) (z : ℂ)
+    (t : ℝ) (ht : 0 ≤ t) :
+    HasDerivWithinAt (eulerFlow κ b j N z)
+      (cutoffField κ b j (((⌊t/mesh N⌋₊:ℕ):ℝ)*mesh N)
+        (eulerSteps κ b j N z ⌊t/mesh N⌋₊)) (Ici t) t := by
+  let k := ⌊t/mesh N⌋₊
+  let v := cutoffField κ b j ((k:ℝ)*mesh N) (eulerSteps κ b j N z k)
+  have hh := mesh_pos N
+  have hk : (k:ℝ)*mesh N ≤ t := (le_div_iff₀ hh).1 (Nat.floor_le (div_nonneg ht hh.le))
+  have hnext : t<((k:ℝ)+1)*mesh N := (div_lt_iff₀ hh).1 (Nat.lt_floor_add_one (t/mesh N))
+  have he : eulerFlow κ b j N z =ᶠ[𝓝[Ici t] t]
+      (fun s => eulerSteps κ b j N z k + ((s-(k:ℝ)*mesh N : ℝ):ℂ)*v) := by
+    filter_upwards [self_mem_nhdsWithin,mem_nhdsWithin_of_mem_nhds (Iio_mem_nhds hnext)] with s hs hu
+    exact eulerFlow_on_cell κ b j N z k s ⟨hk.trans hs,hu.le⟩
+  have hd : HasDerivAt (fun s : ℝ => eulerSteps κ b j N z k + ((s-(k:ℝ)*mesh N : ℝ):ℂ)*v) v t := by
+    convert ((((hasDerivAt_id t).sub_const ((k:ℝ)*mesh N)).ofReal_comp).mul_const v).const_add
+      (eulerSteps κ b j N z k) using 1 <;> simp
+  exact hd.hasDerivWithinAt.congr_of_eventuallyEq he
+    (eulerFlow_on_cell κ b j N z k t ⟨hk,hnext.le⟩)
+
+lemma eulerFlow_zero (κ : ℝ) (b : Driver) (j N : ℕ) (z : ℂ) :
+    eulerFlow κ b j N z 0=z := by
+  simp [eulerFlow,eulerSteps]
+
+lemma eulerSteps_dist_le (κ : ℝ) (b : Driver) (j N : ℕ) (z : ℂ)
+    (L : ℝ≥0) (hL : ∀ t w, ‖cutoffField κ b j t w‖ ≤ L) (k : ℕ) :
+    dist (eulerSteps κ b j N z k) z ≤ (k:ℝ)*mesh N*L := by
+  induction k with
+  | zero => simp [eulerSteps]
+  | succ k ih =>
+    rw [eulerSteps]
+    have hs : dist (eulerSteps κ b j N z k + mesh N *
+        cutoffField κ b j ((k:ℝ)*mesh N) (eulerSteps κ b j N z k))
+        (eulerSteps κ b j N z k) ≤ mesh N*L := by
+      rw [dist_eq_norm,add_sub_cancel_left,norm_mul,Complex.norm_real,Real.norm_eq_abs,abs_of_pos (mesh_pos N)]
+      exact mul_le_mul_of_nonneg_left (hL _ _) (mesh_pos N).le
+    have ht := (dist_triangle (eulerSteps κ b j N z k + mesh N *
+      cutoffField κ b j ((k:ℝ)*mesh N) (eulerSteps κ b j N z k))
+      (eulerSteps κ b j N z k) z).trans (add_le_add hs ih)
+    exact ht.trans_eq (by push_cast; ring)
+
+lemma eulerFlow_dist_grid_le (κ : ℝ) (b : Driver) (j N : ℕ) (z : ℂ)
+    (L : ℝ≥0) (hL : ∀ t w, ‖cutoffField κ b j t w‖ ≤ L)
+    (t : ℝ) (ht : 0 ≤ t) :
+    dist (eulerFlow κ b j N z t) (eulerSteps κ b j N z ⌊t/mesh N⌋₊) ≤ L*mesh N := by
+  let k := ⌊t/mesh N⌋₊
+  have hh := mesh_pos N
+  have hk : (k:ℝ)*mesh N ≤ t := (le_div_iff₀ hh).1 (Nat.floor_le (div_nonneg ht hh.le))
+  have hnext : t<((k:ℝ)+1)*mesh N := (div_lt_iff₀ hh).1 (Nat.lt_floor_add_one (t/mesh N))
+  change dist (eulerFlow κ b j N z t) (eulerSteps κ b j N z k) ≤ L*mesh N
+  rw [eulerFlow_on_cell κ b j N z k t ⟨hk,hnext.le⟩,dist_eq_norm,add_sub_cancel_left,norm_mul,
+    Complex.norm_real,Real.norm_eq_abs,abs_of_nonneg (sub_nonneg.mpr hk)]
+  have hlag : t-(k:ℝ)*mesh N ≤ mesh N := by nlinarith
+  exact (mul_le_mul_of_nonneg_left (hL _ _) (sub_nonneg.mpr hk)).trans
+    (by nlinarith [L.coe_nonneg])
+
+lemma eulerFlow_dist_initial_le (κ : ℝ) (b : Driver) (j N : ℕ) (z : ℂ)
+    (L : ℝ≥0) (hL : ∀ t w, ‖cutoffField κ b j t w‖ ≤ L)
+    (t : ℝ) (ht : 0 ≤ t) :
+    dist (eulerFlow κ b j N z t) z ≤ L*t := by
+  let k := ⌊t/mesh N⌋₊
+  have hh := mesh_pos N
+  have hk : (k:ℝ)*mesh N ≤ t := (le_div_iff₀ hh).1 (Nat.floor_le (div_nonneg ht hh.le))
+  have hnext : t<((k:ℝ)+1)*mesh N := (div_lt_iff₀ hh).1 (Nat.lt_floor_add_one (t/mesh N))
+  have he := eulerFlow_on_cell κ b j N z k t ⟨hk,hnext.le⟩
+  rw [he]
+  have hb : dist (eulerSteps κ b j N z k+((t-(k:ℝ)*mesh N : ℝ):ℂ)*
+      cutoffField κ b j ((k:ℝ)*mesh N) (eulerSteps κ b j N z k))
+      (eulerSteps κ b j N z k) ≤ (t-(k:ℝ)*mesh N)*L := by
+    rw [dist_eq_norm,add_sub_cancel_left,norm_mul,Complex.norm_real,Real.norm_eq_abs,abs_of_nonneg (sub_nonneg.mpr hk)]
+    exact mul_le_mul_of_nonneg_left (hL _ _) (sub_nonneg.mpr hk)
+  have htriangle := (dist_triangle (eulerSteps κ b j N z k+((t-(k:ℝ)*mesh N : ℝ):ℂ)*
+    cutoffField κ b j ((k:ℝ)*mesh N) (eulerSteps κ b j N z k))
+    (eulerSteps κ b j N z k) z).trans
+    (add_le_add hb (eulerSteps_dist_le κ b j N z L hL k))
+  exact htriangle.trans_eq (by ring)
+
+end SLEExactGauge.Target
+
+end
+
+end OAI
diff --git a/lean/OAI/Probability/SLE/Loewner/TargetForwardAnalytic.lean b/lean/OAI/Probability/SLE/Loewner/TargetForwardAnalytic.lean
new file mode 100644
index 0000000000000000000000000000000000000000..29a300ed91343ef8470e4daf9cf11d2136e8a4d7
--- /dev/null
+++ b/lean/OAI/Probability/SLE/Loewner/TargetForwardAnalytic.lean
@@ -0,0 +1,37 @@
+import OAI.Probability.SLE.Loewner.TargetInverseProperties
+import Mathlib.Analysis.Calculus.InverseFunctionTheorem.Deriv
+import Mathlib.Analysis.Calculus.FDeriv.Analytic
+
+namespace OAI
+
+/-! Spatial analyticity of the raw forward map follows from the analytic
+inverse and its nonzero derivative. -/
+noncomputable section
+open Set Filter
+open scoped Topology NNReal
+
+namespace SLEExactGauge.Target
+
+lemma differentiableOn_flow_of_inverse
+    (κ : ℝ) (hκ : 0 < κ) (b : Driver) (T : ℝ≥0)
+    (hF : DifferentiableOn ℂ (inverseFlow κ b T) upperHalfPlane)
+    (hF' : ∀ w ∈ upperHalfPlane, deriv (inverseFlow κ b T) w ≠ 0) :
+    DifferentiableOn ℂ (fun z => flow κ b z T) {z | Surviving κ b z T} := by
+  intro z hz
+  let w := flow κ b z T
+  have hw : w ∈ upperHalfPlane := surviving_flow_mem_upperHalfPlane κ b z T T.coe_nonneg hz
+  have han := hF.analyticAt (isOpen_upperHalfPlane.mem_nhds hw)
+  have hinv : inverseFlow κ b T w=z := inverseFlow_eq_of_surviving κ b T T.coe_nonneg z w hz rfl
+  have hlocal : ∀ᶠ v in 𝓝 w, flow κ b (inverseFlow κ b T v) T=v := by
+    filter_upwards [isOpen_upperHalfPlane.mem_nhds hw] with v hv
+    exact flow_inverseFlow κ hκ b T v hv
+  have hg := han.hasStrictDerivAt.to_local_left_inverse
+    (g := fun z => flow κ b z T) (hF' w hw) hlocal
+  rw [hinv] at hg
+  exact hg.hasDerivAt.differentiableAt.differentiableWithinAt
+
+end SLEExactGauge.Target
+
+end
+
+end OAI
diff --git a/lean/OAI/Probability/SLE/Loewner/TargetInverseContinuity.lean b/lean/OAI/Probability/SLE/Loewner/TargetInverseContinuity.lean
new file mode 100644
index 0000000000000000000000000000000000000000..77148a741bf8efaf02d6b4cd330d5a29fe1f2405
--- /dev/null
+++ b/lean/OAI/Probability/SLE/Loewner/TargetInverseContinuity.lean
@@ -0,0 +1,78 @@
+import OAI.Probability.SLE.Loewner.TargetInverseProperties
+
+namespace OAI
+
+/-! Local stability and continuity of the raw inverse flow, independently of
+the existence of a geometric trace. -/
+noncomputable section
+open Set Filter _root_.MeasureTheory _root_.OAI.MeasureTheory Metric
+open scoped Topology NNReal ENNReal
+
+namespace SLEExactGauge.Target
+
+lemma inverseFlow_eq_reverse_trajectory
+    (κ : ℝ) (hκ : 0 < κ) (b : Driver) (T : ℝ≥0) (w : ℂ)
+    (η : ℝ) (hη : 0 < η) (hηw : η ≤ w.im) (Q : ℝ → ℂ)
+    (hQ0 : Q 0=w)
+    (hQd : ∀ s, 0 ≤ s → HasDerivWithinAt Q
+      (reverseField η (driverValue b ((T:ℝ)-κ*s)) (Q s)) (Ici 0) s) :
+    inverseFlow κ b T w=Q ((T:ℝ)/κ) := by
+  have h := reverse_trajectory_preimage κ hκ b T w η hη hηw Q hQ0 hQd
+  exact inverseFlow_eq_of_surviving κ b T T.coe_nonneg _ w h.1 h.2
+
+lemma inverseFlow_lipschitzOn_height
+    (κ : ℝ) (hκ : 0 < κ) (b : Driver) (T : ℝ≥0)
+    (η : ℝ) (hη : 0 < η) :
+    LipschitzOnWith ⟨Real.exp ((4*η⁻¹^2)*((T:ℝ)/κ)), (Real.exp_pos _).le⟩
+      (inverseFlow κ b T) {w : ℂ | η ≤ w.im} := by
+  let U (s : ℝ) (_ : ℂ) := driverValue b ((T:ℝ)-κ*s)
+  have hUc : Continuous (fun s : ℝ => driverValue b ((T:ℝ)-κ*s)) := by
+    exact b.continuous.comp (continuous_real_toNNReal.comp
+      (continuous_const.sub (continuous_const.mul continuous_id)))
+  have hUm : Measurable (fun q : ℝ × ℂ => U q.1 q.2) :=
+    hUc.measurable.comp measurable_fst
+  obtain ⟨Q,_,hQ0,hQd⟩ := exists_measurable_reverse_flow U hUm
+    (fun _ => hUc) id measurable_id hη
+  have hQc (w : ℂ) : ContinuousOn (fun s => Q s w) (Icc 0 ((T:ℝ)/κ)) :=
+    fun s hs => ((hQd w s hs.1).continuousWithinAt).mono Icc_subset_Ici_self
+  have hQd' (w : ℂ) (s : ℝ) (hs : s ∈ Ico 0 ((T:ℝ)/κ)) :
+      HasDerivWithinAt (fun r => Q r w)
+        (reverseField η (driverValue b ((T:ℝ)-κ*s)) (Q s w)) (Ici s) s :=
+    (hQd w s hs.1).mono (Ici_subset_Ici.mpr hs.1)
+  have he (w : ℂ) (hw : η ≤ w.im) : inverseFlow κ b T w=Q ((T:ℝ)/κ) w :=
+    inverseFlow_eq_reverse_trajectory κ hκ b T w η hη hw
+      (fun s => Q s w) (hQ0 w) (hQd w)
+  apply LipschitzOnWith.of_dist_le_mul
+  intro z hz w hw
+  rw [he z hz,he w hw]
+  have h := dist_le_of_trajectories_ODE
+    (fun s => reverseField_lipschitz hη (driverValue b ((T:ℝ)-κ*s)))
+    (hQc z) (hQd' z) (hQc w) (hQd' w)
+    (show dist (Q 0 z) (Q 0 w) ≤ dist z w by simp only [hQ0,id_eq]; exact le_rfl)
+    ((T:ℝ)/κ) ⟨div_nonneg T.coe_nonneg hκ.le,le_rfl⟩
+  change dist (Q ((T:ℝ)/κ) z) (Q ((T:ℝ)/κ) w) ≤
+    dist z w * Real.exp ((4*η⁻¹^2)*((T:ℝ)/κ-0)) at h
+  change dist (Q ((T:ℝ)/κ) z) (Q ((T:ℝ)/κ) w) ≤
+    Real.exp ((4*η⁻¹^2)*((T:ℝ)/κ)) * dist z w
+  simpa only [sub_zero,mul_comm] using h
+
+lemma continuousOn_inverseFlow
+    (κ : ℝ) (hκ : 0 < κ) (b : Driver) (T : ℝ≥0) :
+    ContinuousOn (inverseFlow κ b T) upperHalfPlane := by
+  intro w hw
+  have hη : 0 < w.im/2 := half_pos hw
+  have hLip := inverseFlow_lipschitzOn_height κ hκ b T (w.im/2) hη
+  have hn : {z : ℂ | w.im/2 ≤ z.im} ∈ 𝓝 w := by
+    have hn0 : {z : ℂ | w.im/2 < z.im} ∈ 𝓝 w :=
+      (isOpen_lt continuous_const Complex.continuous_im).mem_nhds
+        (by change w.im/2 < w.im; exact half_lt_self hw)
+    exact mem_of_superset hn0 (fun z hz => by
+      change w.im/2 ≤ z.im
+      exact (show w.im/2 < z.im from hz).le)
+  exact (hLip.continuousOn.continuousAt hn).continuousWithinAt
+
+end SLEExactGauge.Target
+
+end
+
+end OAI
diff --git a/lean/OAI/Probability/SLE/Loewner/TargetInverseExistence.lean b/lean/OAI/Probability/SLE/Loewner/TargetInverseExistence.lean
new file mode 100644
index 0000000000000000000000000000000000000000..15072f368a7dee2034c36d49dbdff9c21db77406
--- /dev/null
+++ b/lean/OAI/Probability/SLE/Loewner/TargetInverseExistence.lean
@@ -0,0 +1,96 @@
+import OAI.Probability.SLE.Angle.TargetPositiveFlow
+import OAI.Probability.SLE.Loewner.TargetInverseMeasurability
+
+namespace OAI
+
+/-! Reverse flow supplies every point of the upper half-plane as an
+image of the raw surviving flow, for every continuous based driver. -/
+noncomputable section
+open Set Filter _root_.MeasureTheory _root_.OAI.MeasureTheory Metric Complex
+open scoped Topology NNReal ENNReal
+
+namespace SLEExactGauge
+
+lemma reverseField_im_nonneg {a : ℝ} (ha : 0 < a) (u : ℝ) (z : ℂ) :
+    0 ≤ (reverseField a u z).im := by
+  have hm : 0 ≤ max a z.im := ha.le.trans (le_max_left _ _)
+  have hd : 0 ≤ Complex.normSq (reverseCenter a u z) := Complex.normSq_nonneg _
+  have he : (reverseField a u z).im=2*(max a z.im / Complex.normSq (reverseCenter a u z)) := by
+    simp [reverseField,Complex.mul_im,Complex.inv_im,reverseCenter_im]
+    ring
+  rw [he]
+  exact mul_nonneg (by norm_num : (0:ℝ) ≤ 2) (div_nonneg hm hd)
+
+namespace Target
+
+theorem reverse_trajectory_preimage
+    (κ : ℝ) (hκ : 0 < κ) (b : Driver) (T : ℝ≥0) (w : ℂ)
+    (η : ℝ) (hη : 0 < η) (hηw : η ≤ w.im) (Q : ℝ → ℂ)
+    (hQ0 : Q 0=w)
+    (hQd : ∀ s, 0 ≤ s → HasDerivWithinAt Q
+      (reverseField η (driverValue b ((T:ℝ)-κ*s)) (Q s)) (Ici 0) s) :
+    Surviving κ b (Q ((T:ℝ)/κ)) T ∧ flow κ b (Q ((T:ℝ)/κ)) T=w := by
+  have hQc : ContinuousOn Q (Ici 0) :=
+    fun s hs => (hQd s hs).continuousWithinAt
+  have hQi : MonotoneOn (fun s => (Q s).im) (Ici 0) := by
+    apply monotoneOn_of_hasDerivWithinAt_nonneg (convex_Ici 0)
+      (Complex.continuous_im.comp_continuousOn hQc)
+      (fun s hs => (Complex.imCLM.hasFDerivAt.comp_hasDerivWithinAt s (hQd s (interior_subset hs))).mono interior_subset)
+    intro s hs
+    exact reverseField_im_nonneg hη _ _
+  have hheightQ (s : ℝ) (hs : 0 ≤ s) : w.im ≤ (Q s).im := by
+    simpa only [hQ0] using hQi (show (0:ℝ) ∈ Ici (0:ℝ) from le_refl (0:ℝ)) hs hs
+  let Y (s : ℝ) := Q (((T:ℝ)-s)/κ)
+  let z := Y 0
+  have hmaps : MapsTo (fun s : ℝ => ((T:ℝ)-s)/κ) (Icc 0 (T:ℝ)) (Ici 0) :=
+    fun s hs => div_nonneg (sub_nonneg.mpr hs.2) hκ.le
+  have hY : ContinuousOn Y (Icc 0 (T:ℝ)) :=
+    hQc.comp ((continuous_const.sub continuous_id).div_const κ).continuousOn hmaps
+  have hYheight : ∀ s ∈ Icc 0 (T:ℝ), w.im ≤ (Y s).im :=
+    fun s hs => hheightQ _ (hmaps hs)
+  have hYd (s : ℝ) (hs : s ∈ Ico 0 (T:ℝ)) :
+      HasDerivWithinAt Y ((a κ:ℂ)/(Y s-driverValue b s)) (Ici s) s := by
+    have ht : 0 ≤ ((T:ℝ)-s)/κ := hmaps (Ico_subset_Icc_self hs)
+    have hi : HasDerivWithinAt (fun r : ℝ => ((T:ℝ)-r)/κ) (-1/κ) (Icc 0 (T:ℝ)) s := by
+      convert (((hasDerivAt_id s).const_sub (T:ℝ)).div_const κ).hasDerivWithinAt using 1
+      simp
+    have hd := (hQd _ ht).scomp s hi hmaps
+    have he : (T:ℝ)-κ*(((T:ℝ)-s)/κ)=s := by field_simp [hκ.ne']; ring
+    have hh : η ≤ (Y s).im := hηw.trans (hYheight s (Ico_subset_Icc_self hs))
+    have hc : (-1/κ) • reverseField η (driverValue b ((T:ℝ)-κ*(((T:ℝ)-s)/κ))) (Y s) =
+        (a κ:ℂ)/(Y s-driverValue b s) := by
+      have hUt : driverValue b ((T:ℝ)-κ*(((T:ℝ)-s)/κ))=driverValue b s := by rw [he]
+      rw [hUt,reverseField,reverseCenter_eq hh]
+      simp only [Complex.real_smul,a,div_eq_mul_inv]
+      push_cast
+      ring
+    exact hasDerivWithinAt_Ici_of_Icc hs (hd.congr_deriv hc)
+  obtain ⟨hz,hflow⟩ := flow_eq_of_positive_trajectory κ b z T T.coe_nonneg Y hY rfl
+    w.im (hη.trans_le hηw) hYheight hYd
+  constructor
+  · simpa only [z,Y,sub_zero] using hz
+  · simpa only [z,Y,sub_zero,sub_self,zero_div,hQ0] using hflow
+
+theorem exists_surviving_preimage
+    (κ : ℝ) (hκ : 0 < κ) (b : Driver) (T : ℝ≥0) (w : ℂ)
+    (hw : w ∈ upperHalfPlane) :
+    ∃ z, Surviving κ b z T ∧ flow κ b z T=w := by
+  let η := w.im/2
+  have hη : 0 < η := half_pos hw
+  let U (s : ℝ) (_ : Unit) := driverValue b ((T:ℝ)-κ*s)
+  have hUc : Continuous (fun s : ℝ => U s ()) := by
+    exact b.continuous.comp (continuous_real_toNNReal.comp
+      (continuous_const.sub (continuous_const.mul continuous_id)))
+  have hUm : Measurable (fun q : ℝ × Unit => U q.1 q.2) :=
+    hUc.measurable.comp measurable_fst
+  obtain ⟨Q,hQm,hQ0,hQd⟩ := exists_measurable_reverse_flow U hUm
+    (fun _ => hUc) (fun _ => w) measurable_const hη
+  exact ⟨Q ((T:ℝ)/κ) (), reverse_trajectory_preimage κ hκ b T w η hη
+    (half_le_self (show 0 ≤ w.im from hw.le)) (fun s => Q s ()) (hQ0 ()) (hQd ())⟩
+
+end Target
+end SLEExactGauge
+
+end
+
+end OAI
diff --git a/lean/OAI/Probability/SLE/Loewner/TargetInverseMeasurability.lean b/lean/OAI/Probability/SLE/Loewner/TargetInverseMeasurability.lean
new file mode 100644
index 0000000000000000000000000000000000000000..c83be449c24ae7065dc93293206874a0c7213ae2
--- /dev/null
+++ b/lean/OAI/Probability/SLE/Loewner/TargetInverseMeasurability.lean
@@ -0,0 +1,87 @@
+import OAI.Probability.SLE.Angle.TargetFlowInjectivity
+
+namespace OAI
+
+/-! A measurable inverse of the raw surviving flow. The inverse is the
+prescribed `inverseFlow`, including its value zero outside its range. -/
+noncomputable section
+open Set Filter _root_.MeasureTheory _root_.OAI.MeasureTheory
+open scoped Topology NNReal ENNReal
+
+namespace SLEExactGauge.Target
+
+local instance inverseDriverPolish : PolishSpace Driver :=
+  ContinuousMapZero.isClosedEmbedding_toContinuousMap.polishSpace
+
+def survivingState (κ : ℝ) : Set (ℝ≥0 × (Driver × ℂ)) :=
+  {q | Surviving κ q.2.1 q.2.2 q.1}
+
+def survivingStateMap (κ : ℝ) (q : survivingState κ) : ℝ≥0 × (Driver × ℂ) :=
+  (q.1.1,(q.1.2.1,flow κ q.1.2.1 q.1.2.2 q.1.1))
+
+lemma measurable_survivingStateMap (κ : ℝ) : Measurable (survivingStateMap κ) :=
+  measurable_subtype_coe.fst.prodMk (measurable_subtype_coe.snd.fst.prodMk
+    ((measurable_flow κ).comp measurable_subtype_coe))
+
+lemma survivingStateMap_injective (κ : ℝ) : Function.Injective (survivingStateMap κ) := by
+  rintro ⟨⟨t,b,z⟩,hz⟩ ⟨⟨s,c,w⟩,hw⟩ he
+  change (t,(b,flow κ b z t))=(s,(c,flow κ c w s)) at he
+  rcases Prod.mk.inj he with ⟨rfl,he⟩
+  rcases Prod.mk.inj he with ⟨rfl,he⟩
+  have hzw := flow_injOn_surviving κ b t t.coe_nonneg hz hw he
+  change z=w at hzw
+  subst w
+  rfl
+
+lemma measurableEmbedding_survivingStateMap (κ : ℝ) :
+    MeasurableEmbedding (survivingStateMap κ) := by
+  let : StandardBorelSpace (survivingState κ) := (measurableSet_surviving κ).standardBorel
+  exact (measurable_survivingStateMap κ).measurableEmbedding (survivingStateMap_injective κ)
+
+lemma inverseFlow_eq_extend (κ : ℝ) (q : ℝ≥0 × (Driver × ℂ)) :
+    inverseFlow κ q.2.1 q.1 q.2.2 =
+      Function.extend (survivingStateMap κ) (fun p => p.1.2.2) (fun _ => (0:ℂ)) q := by
+  classical
+  by_cases h : ∃ z, Surviving κ q.2.1 z q.1 ∧ flow κ q.2.1 z q.1=q.2.2
+  · let z := Classical.epsilon (fun z => Surviving κ q.2.1 z q.1 ∧ flow κ q.2.1 z q.1=q.2.2)
+    have hz : Surviving κ q.2.1 z q.1 ∧ flow κ q.2.1 z q.1=q.2.2 := Classical.epsilon_spec h
+    let p : survivingState κ := ⟨(q.1,(q.2.1,z)),hz.1⟩
+    have hp : survivingStateMap κ p=q := by
+      rcases q with ⟨t,b,w⟩
+      change (t,(b,flow κ b z t))=(t,(b,w))
+      rw [hz.2]
+    rw [inverseFlow,ite_eq_left h]
+    change z = _
+    calc
+      z = p.1.2.2 := rfl
+      _ = Function.extend (survivingStateMap κ) (fun p => p.1.2.2) (fun _ => (0:ℂ))
+          (survivingStateMap κ p) := ((survivingStateMap_injective κ).extend_apply
+            (fun p => p.1.2.2) (fun _ => (0:ℂ)) p).symm
+      _ = _ := by rw [hp]
+  · have hn : ¬∃ p, survivingStateMap κ p=q := by
+      rintro ⟨p,hp⟩
+      apply h
+      have ht := congrArg Prod.fst hp
+      have hb := congrArg (fun x : ℝ≥0 × (Driver × ℂ) => x.2.1) hp
+      have hf := congrArg (fun x : ℝ≥0 × (Driver × ℂ) => x.2.2) hp
+      change p.1.1=q.1 at ht
+      change p.1.2.1=q.2.1 at hb
+      change flow κ p.1.2.1 p.1.2.2 p.1.1=q.2.2 at hf
+      refine ⟨p.1.2.2,?_,?_⟩
+      · simpa only [ht,hb] using (show Surviving κ p.1.2.1 p.1.2.2 p.1.1 from p.2)
+      · simpa only [ht,hb] using hf
+    rw [inverseFlow,ite_eq_right h,Function.extend_apply' _ _ _ hn]
+
+lemma measurable_inverseFlow (κ : ℝ) :
+    Measurable (fun q : ℝ≥0 × (Driver × ℂ) => inverseFlow κ q.2.1 q.1 q.2.2) := by
+  have hm := (measurableEmbedding_survivingStateMap κ).measurable_extend
+    measurable_subtype_coe.snd.snd (measurable_const (a := (0:ℂ)))
+  convert hm using 1
+  funext q
+  exact inverseFlow_eq_extend κ q
+
+end SLEExactGauge.Target
+
+end
+
+end OAI
diff --git a/lean/OAI/Probability/SLE/Loewner/TargetInverseProperties.lean b/lean/OAI/Probability/SLE/Loewner/TargetInverseProperties.lean
new file mode 100644
index 0000000000000000000000000000000000000000..daa3455503059da7a90897c5afb1c82287947c94
--- /dev/null
+++ b/lean/OAI/Probability/SLE/Loewner/TargetInverseProperties.lean
@@ -0,0 +1,61 @@
+import OAI.Probability.SLE.Loewner.TargetInverseExistence
+
+namespace OAI
+
+/-! Exact inverse identities for the raw flow on its surviving domain. -/
+noncomputable section
+open Set Filter _root_.MeasureTheory _root_.OAI.MeasureTheory
+open scoped Topology NNReal ENNReal
+
+namespace SLEExactGauge.Target
+
+lemma surviving_mem_upperHalfPlane (κ : ℝ) (b : Driver) (z : ℂ)
+    (T : ℝ) (hT : 0 ≤ T) (hs : Surviving κ b z T) : z ∈ upperHalfPlane := by
+  obtain ⟨j,hj,hmin⟩ := hs
+  have hh := surviving_cutoff_height κ b z T j hj hmin 0 ⟨le_rfl,hT⟩
+  rw [cutoffFlow_zero κ b j hj] at hh
+  have hj0 : (0:ℝ)<j := by exact_mod_cast (Nat.succ_le_iff.mp hj)
+  exact (inv_pos.mpr hj0).trans hh
+
+lemma surviving_flow_mem_upperHalfPlane (κ : ℝ) (b : Driver) (z : ℂ)
+    (T : ℝ) (hT : 0 ≤ T) (hs : Surviving κ b z T) :
+    flow κ b z T ∈ upperHalfPlane := by
+  have hj := (Nat.find_spec hs).1
+  have hh := surviving_cutoff_height κ b z T (Nat.find hs) hj (Nat.find_spec hs).2 T ⟨hT,le_rfl⟩
+  have hj0 : (0:ℝ)<Nat.find hs := by exact_mod_cast (Nat.succ_le_iff.mp hj)
+  change 0 < (flow κ b z T).im
+  rw [flow,dite_eq_left hs]
+  exact (inv_pos.mpr hj0).trans hh
+
+lemma inverseFlow_spec (κ : ℝ) (b : Driver) (T : ℝ) (w : ℂ)
+    (hex : ∃ z, Surviving κ b z T ∧ flow κ b z T=w) :
+    Surviving κ b (inverseFlow κ b T w) T ∧ flow κ b (inverseFlow κ b T w) T=w := by
+  classical
+  simpa only [inverseFlow,ite_eq_left hex] using Classical.epsilon_spec hex
+
+lemma inverseFlow_eq_of_surviving (κ : ℝ) (b : Driver) (T : ℝ)
+    (hT : 0 ≤ T) (z w : ℂ) (hz : Surviving κ b z T) (he : flow κ b z T=w) :
+    inverseFlow κ b T w=z := by
+  have hi := inverseFlow_spec κ b T w ⟨z,hz,he⟩
+  exact flow_injOn_surviving κ b T hT hi.1 hz (hi.2.trans he.symm)
+
+lemma inverseFlow_surviving (κ : ℝ) (hκ : 0 < κ) (b : Driver)
+    (T : ℝ≥0) (w : ℂ) (hw : w ∈ upperHalfPlane) :
+    Surviving κ b (inverseFlow κ b T w) T :=
+  (inverseFlow_spec κ b T w (exists_surviving_preimage κ hκ b T w hw)).1
+
+lemma flow_inverseFlow (κ : ℝ) (hκ : 0 < κ) (b : Driver)
+    (T : ℝ≥0) (w : ℂ) (hw : w ∈ upperHalfPlane) :
+    flow κ b (inverseFlow κ b T w) T=w :=
+  (inverseFlow_spec κ b T w (exists_surviving_preimage κ hκ b T w hw)).2
+
+lemma inverseFlow_mem_upperHalfPlane (κ : ℝ) (hκ : 0 < κ) (b : Driver)
+    (T : ℝ≥0) (w : ℂ) (hw : w ∈ upperHalfPlane) :
+    inverseFlow κ b T w ∈ upperHalfPlane :=
+  surviving_mem_upperHalfPlane κ b _ T T.coe_nonneg (inverseFlow_surviving κ hκ b T w hw)
+
+end SLEExactGauge.Target
+
+end
+
+end OAI
diff --git a/lean/OAI/Probability/SLE/Loewner/TargetJointMeasurability.lean b/lean/OAI/Probability/SLE/Loewner/TargetJointMeasurability.lean
new file mode 100644
index 0000000000000000000000000000000000000000..5c4dbd378e4d7624c7da4a80be12b245adbcc11c
--- /dev/null
+++ b/lean/OAI/Probability/SLE/Loewner/TargetJointMeasurability.lean
@@ -0,0 +1,186 @@
+import OAI.Probability.SLE.Angle.TargetPotentialMeasurability
+import OAI.Probability.SLE.Angle.TargetDiskRadius
+
+namespace OAI
+
+/-! Joint measurability in the initial disk angle. The potential is needed
+only on the open angle interval, where the exact initial disk radius is
+`1 - ‖x‖²`; this avoids imposing any regularity at degenerate disk charts. -/
+
+noncomputable section
+open Set Filter _root_.MeasureTheory _root_.OAI.MeasureTheory Metric
+open scoped Topology NNReal ENNReal
+
+namespace SLEExactGauge.Target
+
+lemma measurable_diskMapInv_joint :
+    Measurable (fun q : ℝ × ℂ => diskMapInv q.1 q.2) := by
+  unfold diskMapInv
+  fun_prop
+
+private lemma measurable_joint_clockIntegrand (κ : ℝ) :
+    Measurable (fun q : (ℝ≥0 × (ℝ × (Driver × ℂ))) × ℝ =>
+      (flow κ q.1.2.2.1 (diskMapInv q.1.2.1 q.1.2.2.2) q.2.toNNReal).im ^ 2 /
+        ‖flow κ q.1.2.2.1 (diskMapInv q.1.2.1 q.1.2.2.2) q.2.toNNReal -
+          (driverValue q.1.2.2.1 q.2 : ℂ)‖ ^ 4) := by
+  have hz : Measurable (fun q : (ℝ≥0 × (ℝ × (Driver × ℂ))) × ℝ =>
+      diskMapInv q.1.2.1 q.1.2.2.2) :=
+    @Measurable.comp ((ℝ≥0 × (ℝ × (Driver × ℂ))) × ℝ) (ℝ × ℂ) ℂ
+      inferInstance inferInstance inferInstance (fun q => diskMapInv q.1 q.2)
+      (fun q => (q.1.2.1,q.1.2.2.2)) measurable_diskMapInv_joint
+      (measurable_fst.snd.fst.prodMk measurable_fst.snd.snd.snd)
+  have hp : Measurable (fun q : (ℝ≥0 × (ℝ × (Driver × ℂ))) × ℝ =>
+      (q.2.toNNReal,(q.1.2.2.1,diskMapInv q.1.2.1 q.1.2.2.2))) :=
+    (continuous_real_toNNReal.measurable.comp measurable_snd).prodMk
+      (measurable_fst.snd.snd.fst.prodMk hz)
+  have hF : Measurable (fun q : (ℝ≥0 × (ℝ × (Driver × ℂ))) × ℝ =>
+      flow κ q.1.2.2.1 (diskMapInv q.1.2.1 q.1.2.2.2) q.2.toNNReal) :=
+    @Measurable.comp ((ℝ≥0 × (ℝ × (Driver × ℂ))) × ℝ) (ℝ≥0 × (Driver × ℂ)) ℂ
+      inferInstance inferInstance inferInstance (fun q => flow κ q.2.1 q.2.2 q.1)
+      (fun q => (q.2.toNNReal,(q.1.2.2.1,diskMapInv q.1.2.1 q.1.2.2.2)))
+      (measurable_flow κ) hp
+  have hB : Measurable (fun q : (ℝ≥0 × (ℝ × (Driver × ℂ))) × ℝ =>
+      driverValue q.1.2.2.1 q.2) :=
+    continuous_eval.measurable.comp (measurable_fst.snd.snd.fst.prodMk
+      (continuous_real_toNNReal.measurable.comp measurable_snd))
+  exact ((Complex.measurable_im.comp hF).pow_const 2).div
+    ((hF.sub hB.complex_ofReal).norm.pow_const 4)
+
+lemma measurable_clock_joint (κ : ℝ) :
+    Measurable (fun q : ℝ≥0 × (ℝ × (Driver × ℂ)) =>
+      clock κ q.2.1 q.2.2.1 q.2.2.2 q.1) := by
+  let A : Set ((ℝ≥0 × (ℝ × (Driver × ℂ))) × ℝ) :=
+    {q | 0 ≤ q.2 ∧ q.2 ≤ (q.1.1 : ℝ)}
+  have hA : MeasurableSet A :=
+    (measurableSet_le measurable_const measurable_snd).inter
+      (measurableSet_le measurable_snd measurable_fst.fst.coe_nnreal_real)
+  have hm : StronglyMeasurable (fun q : ℝ≥0 × (ℝ × (Driver × ℂ)) => ∫ u : ℝ,
+      A.indicator (fun p : (ℝ≥0 × (ℝ × (Driver × ℂ))) × ℝ =>
+        (flow κ p.1.2.2.1 (diskMapInv p.1.2.1 p.1.2.2.2) p.2.toNNReal).im ^ 2 /
+          ‖flow κ p.1.2.2.1 (diskMapInv p.1.2.1 p.1.2.2.2) p.2.toNNReal -
+            (driverValue p.1.2.2.1 p.2 : ℂ)‖ ^ 4) (q,u)) :=
+    ((measurable_joint_clockIntegrand κ).indicator hA).stronglyMeasurable.integral_prod_right'
+  convert hm.measurable using 1
+  funext q
+  rw [clock,← integral_indicator measurableSet_Icc]
+  apply integral_congr_ae
+  filter_upwards [] with u
+  by_cases hu : u ∈ Icc 0 (q.1 : ℝ)
+  · have hu' : (q,u) ∈ A := hu
+    simp only [indicator_of_mem hu,indicator_of_mem hu']
+    simp only [Real.toNNReal_of_nonneg hu.1,NNReal.coe_mk,centeredFlow]
+  · have hu' : (q,u) ∉ A := hu
+    simp only [indicator_of_notMem hu,indicator_of_notMem hu']
+
+lemma measurable_angle_joint (κ : ℝ) :
+    Measurable (fun q : ℝ≥0 × (ℝ × (Driver × ℂ)) =>
+      angle κ q.2.1 q.2.2.1 q.2.2.2 q.1) := by
+  have hz : Measurable (fun q : ℝ≥0 × (ℝ × (Driver × ℂ)) =>
+      diskMapInv q.2.1 q.2.2.2) :=
+    @Measurable.comp (ℝ≥0 × (ℝ × (Driver × ℂ))) (ℝ × ℂ) ℂ
+      inferInstance inferInstance inferInstance (fun q => diskMapInv q.1 q.2)
+      (fun q => (q.2.1,q.2.2.2)) measurable_diskMapInv_joint
+      (measurable_snd.fst.prodMk measurable_snd.snd.snd)
+  have hp : Measurable (fun q : ℝ≥0 × (ℝ × (Driver × ℂ)) =>
+      (q.1,(q.2.2.1,diskMapInv q.2.1 q.2.2.2))) :=
+    measurable_fst.prodMk (measurable_snd.snd.fst.prodMk hz)
+  have hF : Measurable (fun q : ℝ≥0 × (ℝ × (Driver × ℂ)) =>
+      flow κ q.2.2.1 (diskMapInv q.2.1 q.2.2.2) q.1) :=
+    @Measurable.comp (ℝ≥0 × (ℝ × (Driver × ℂ))) (ℝ≥0 × (Driver × ℂ)) ℂ
+      inferInstance inferInstance inferInstance (fun q => flow κ q.2.1 q.2.2 q.1)
+      (fun q => (q.1,(q.2.2.1,diskMapInv q.2.1 q.2.2.2))) (measurable_flow κ) hp
+  have hB : Measurable (fun q : ℝ≥0 × (ℝ × (Driver × ℂ)) =>
+      driverValue q.2.2.1 q.1) := by
+    simpa only [driverValue,Real.toNNReal_coe,Function.comp_def] using
+      (continuous_eval.measurable.comp (measurable_snd.snd.fst.prodMk measurable_fst) :
+        Measurable (fun q : ℝ≥0 × (ℝ × (Driver × ℂ)) => q.2.2.1 q.1))
+  exact (hF.sub hB.complex_ofReal).carg
+
+lemma measurableSet_disk_surviving_joint (κ : ℝ) :
+    MeasurableSet {q : ℝ≥0 × (ℝ × (Driver × ℂ)) |
+      Surviving κ q.2.2.1 (diskMapInv q.2.1 q.2.2.2) q.1} := by
+  have hz : Measurable (fun q : ℝ≥0 × (ℝ × (Driver × ℂ)) =>
+      diskMapInv q.2.1 q.2.2.2) :=
+    @Measurable.comp (ℝ≥0 × (ℝ × (Driver × ℂ))) (ℝ × ℂ) ℂ
+      inferInstance inferInstance inferInstance (fun q => diskMapInv q.1 q.2)
+      (fun q => (q.2.1,q.2.2.2)) measurable_diskMapInv_joint
+      (measurable_snd.fst.prodMk measurable_snd.snd.snd)
+  have hp : Measurable (fun q : ℝ≥0 × (ℝ × (Driver × ℂ)) =>
+      (q.1,(q.2.2.1,diskMapInv q.2.1 q.2.2.2))) :=
+    measurable_fst.prodMk (measurable_snd.snd.fst.prodMk hz)
+  exact hp (measurableSet_surviving κ)
+
+private def diskGreenFormula (κ θ : ℝ) (b : Driver) (x : ℂ) (t : ℝ≥0) : ℝ :=
+  if Surviving κ b (diskMapInv θ x) t then
+    ((1-‖x‖^2)*Real.exp (-2*a κ*clock κ θ b x t))^(-α κ) *
+      Real.sin (angle κ θ b x t)^p κ
+  else 0
+
+private lemma measurable_diskGreenFormula (κ : ℝ) :
+    Measurable (fun q : ℝ≥0 × (ℝ × (Driver × ℂ)) =>
+      diskGreenFormula κ q.2.1 q.2.2.1 q.2.2.2 q.1) := by
+  have hR : Measurable (fun q : ℝ≥0 × (ℝ × (Driver × ℂ)) =>
+      (1-‖q.2.2.2‖^2)*Real.exp (-2*a κ*clock κ q.2.1 q.2.2.1 q.2.2.2 q.1)) :=
+    (measurable_const.sub (measurable_snd.snd.snd.norm.pow_const 2)).mul
+      ((measurable_const.mul (measurable_clock_joint κ)).exp)
+  exact ((hR.pow_const (-α κ)).mul
+    ((measurable_angle_joint κ).sin.pow_const (p κ))).ite
+      (measurableSet_disk_surviving_joint κ) measurable_const
+
+private lemma diskGreenFormula_eq {κ θ : ℝ} (hθ : θ ∈ Ioo (0:ℝ) Real.pi)
+    (b : Driver) {x : ℂ} (hx : x ∈ diskK) (t : ℝ≥0) :
+    diskGreenFormula κ θ b x t=green κ θ b x t := by
+  have hx1 : x ∈ ball (0:ℂ) 1 :=
+    (closedBall_subset_ball (by norm_num : (1:ℝ)/4<1)) hx
+  simp only [diskGreenFormula,green,radius,initialRadius_disk hθ hx1]
+
+private lemma measurable_diskPotentialFormula (κ : ℝ) :
+    Measurable (fun q : ℝ≥0 × (ℝ × Driver) =>
+      ∫⁻ x in diskK, ENNReal.ofReal (diskGreenFormula κ q.2.1 q.2.2 x q.1)) := by
+  have hp : Measurable (fun q : (ℝ≥0 × (ℝ × Driver)) × ℂ =>
+      (q.1.1,(q.1.2.1,(q.1.2.2,q.2)))) :=
+    measurable_fst.fst.prodMk (measurable_fst.snd.fst.prodMk
+      (measurable_fst.snd.snd.prodMk measurable_snd))
+  have hm : Measurable (fun q : (ℝ≥0 × (ℝ × Driver)) × ℂ =>
+      ENNReal.ofReal (diskGreenFormula κ q.1.2.1 q.1.2.2 q.2 q.1.1)) :=
+    ((measurable_diskGreenFormula κ).comp hp).ennreal_ofReal
+  exact @Measurable.lintegral_prod_right' _ _ _ _ (volume.restrict diskK) _ _ hm
+
+lemma measurable_potential_angle (κ : ℝ) :
+    Measurable (fun q : ℝ≥0 × ({θ : ℝ // θ ∈ Ioo (0:ℝ) Real.pi} × Driver) =>
+      potential κ q.2.1 q.2.2 q.1) := by
+  have hp : Measurable (fun q : ℝ≥0 × ({θ : ℝ // θ ∈ Ioo (0:ℝ) Real.pi} × Driver) =>
+      (q.1,((q.2.1:ℝ),q.2.2))) :=
+    measurable_fst.prodMk ((measurable_subtype_coe.comp measurable_snd.fst).prodMk
+      measurable_snd.snd)
+  convert (measurable_diskPotentialFormula κ).comp hp using 1
+  funext q
+  apply setLIntegral_congr_fun (isClosed_closedBall.measurableSet)
+  intro x hx
+  exact congrArg ENNReal.ofReal (diskGreenFormula_eq q.2.1.property q.2.2 hx q.1).symm
+
+lemma measurable_potential_restricted_angle (κ : ℝ) :
+    Measurable (fun q : ℝ≥0 × (ℝ × Driver) =>
+      if q.2.1 ∈ Ioo (0:ℝ) Real.pi then potential κ q.2.1 q.2.2 q.1 else 0) := by
+  classical
+  have hA : MeasurableSet {q : ℝ≥0 × (ℝ × Driver) | q.2.1 ∈ Ioo (0:ℝ) Real.pi} :=
+    measurable_snd.fst measurableSet_Ioo
+  have hm : Measurable (fun q : ℝ≥0 × (ℝ × Driver) =>
+      if q.2.1 ∈ Ioo (0:ℝ) Real.pi then
+        ∫⁻ x in diskK, ENNReal.ofReal (diskGreenFormula κ q.2.1 q.2.2 x q.1)
+      else (0:ℝ≥0∞)) :=
+    (measurable_diskPotentialFormula κ).ite hA measurable_const
+  convert hm using 1
+  funext q
+  by_cases hq : q.2.1 ∈ Ioo (0:ℝ) Real.pi
+  · simp only [ite_eq_left hq]
+    apply setLIntegral_congr_fun isClosed_closedBall.measurableSet
+    intro x hx
+    exact congrArg ENNReal.ofReal (diskGreenFormula_eq hq q.2.2 hx q.1).symm
+  · simp only [ite_eq_right hq]
+
+end SLEExactGauge.Target
+
+end
+
+end OAI
diff --git a/lean/OAI/Probability/SLE/Loewner/TargetOuterMeasurability.lean b/lean/OAI/Probability/SLE/Loewner/TargetOuterMeasurability.lean
new file mode 100644
index 0000000000000000000000000000000000000000..cf65a00a9d94be8f0fc45c18e2d25985f53adb3e
--- /dev/null
+++ b/lean/OAI/Probability/SLE/Loewner/TargetOuterMeasurability.lean
@@ -0,0 +1,109 @@
+import OAI.Probability.SLE.Angle.TargetLevelMeasurability
+import OAI.Probability.SLE.Angle.TargetAngleLaw
+
+namespace OAI
+
+/-! Measurability for the outer angle integral in the prescribed moments.
+The exact potential is extended by zero only outside the support of the
+angle law; the original coefficient functions agree almost everywhere. -/
+
+noncomputable section
+open Set Filter _root_.MeasureTheory _root_.OAI.MeasureTheory
+open scoped NNReal ENNReal
+
+namespace SLEExactGauge.Target
+
+lemma measurable_potentialDifference_restricted_angle
+    (κ : ℝ) (W : WienerLaw) [SFinite W] (h i : ℕ) :
+    Measurable (fun p : ℝ × Driver => if p.1 ∈ Ioo (0:ℝ) Real.pi then
+      potentialDifference κ p.1 W p.2 h i else 0) := by
+  classical
+  let t : ℝ≥0 := NNReal.mk ((i:ℝ)*mesh h)
+    (mul_nonneg (Nat.cast_nonneg i) (mesh_pos h).le)
+  let T : ℝ≥0 := NNReal.mk (((i:ℝ)+1)*mesh h)
+    (mul_nonneg (by positivity) (mesh_pos h).le)
+  let v (p : ℝ × Driver) : ℝ≥0∞ :=
+    if p.1 ∈ Ioo (0:ℝ) Real.pi then potential κ p.1 p.2 t else 0
+  let w (p : ℝ × Driver) : ℝ≥0∞ := ∫⁻ c,
+    if p.1 ∈ Ioo (0:ℝ) Real.pi then potential κ p.1 (concat p.2 c t) T else 0 ∂W
+  have hv : Measurable v :=
+    (measurable_potential_restricted_angle κ).comp (measurable_const.prodMk measurable_id)
+  have hc : Measurable (fun p : (ℝ × Driver) × Driver => concat p.1.2 p.2 t) :=
+    measurable_concat.comp
+      (measurable_const.prodMk (measurable_fst.snd.prodMk measurable_snd))
+  have hp : Measurable (fun p : (ℝ × Driver) × Driver =>
+      (T,(p.1.1,concat p.1.2 p.2 t))) :=
+    measurable_const.prodMk (measurable_fst.fst.prodMk hc)
+  have hw : Measurable w :=
+    ((measurable_potential_restricted_angle κ).comp hp).lintegral_prod_right'
+  have hm : Measurable (fun p : ℝ × Driver =>
+      if v p < ∞ ∧ w p < ∞ then (v p).toReal-(w p).toReal else (0:ℝ)) :=
+    (hv.ennreal_toReal.sub hw.ennreal_toReal).ite
+    ((measurableSet_lt hv measurable_const).inter (measurableSet_lt hw measurable_const))
+      measurable_const
+  convert hm using 1
+  funext p
+  by_cases hθ : p.1 ∈ Ioo (0:ℝ) Real.pi
+  · have hθ' : 0 < p.1 ∧ p.1 < Real.pi := hθ
+    simp [v,w,potentialDifference,hθ,hθ',t,T]
+  · have hθ' : ¬ (0 < p.1 ∧ p.1 < Real.pi) := hθ
+    simp [v,w,hθ,hθ',t,T]
+
+lemma measurable_discreteMass_restricted_angle
+    (κ ℓ : ℝ) (W : WienerLaw) [SFinite W] (h : ℕ) :
+    Measurable (fun p : ℝ × Driver => if p.1 ∈ Ioo (0:ℝ) Real.pi then
+      discreteMass κ p.1 W p.2 ℓ h else 0) := by
+  have hm : Measurable (fun p : ℝ × Driver => ∑ i ∈ Finset.range (h*2^h),
+      if ENNReal.ofReal (((i:ℝ)+1)*mesh h) ≤ levelTime κ p.1 p.2 ℓ
+      then (if p.1 ∈ Ioo (0:ℝ) Real.pi then potentialDifference κ p.1 W p.2 h i else 0)
+      else 0) := by
+    apply Finset.measurable_sum
+    intro i _
+    exact (measurable_potentialDifference_restricted_angle κ W h i).ite
+      (measurableSet_le measurable_const (measurable_levelTime_angle κ ℓ)) measurable_const
+  convert hm using 1
+  funext p
+  by_cases hθ : p.1 ∈ Ioo (0:ℝ) Real.pi
+  · simp only [ite_eq_left hθ,discreteMass]
+  · simp only [ite_eq_right hθ,ite_self,Finset.sum_const_zero]
+
+lemma angleLaw_prod_ae_mem (κ : ℝ) (W : WienerLaw) [SFinite W] :
+    ∀ᵐ p ∂(angleLaw κ).prod W, p.1 ∈ Ioo (0:ℝ) Real.pi := by
+  apply (Measure.ae_prod_iff_ae_ae (measurable_fst measurableSet_Ioo)).2
+  filter_upwards [angleLaw_ae_mem κ] with θ hθ
+  exact ae_of_all _ (fun _ => hθ)
+
+lemma aemeasurable_potential_angle (κ : ℝ) (W : WienerLaw) [SFinite W] (t : ℝ≥0) :
+    AEMeasurable (fun p : ℝ × Driver => potential κ p.1 p.2 t) ((angleLaw κ).prod W) := by
+  have hm : AEMeasurable (fun p : ℝ × Driver =>
+      if p.1 ∈ Ioo (0:ℝ) Real.pi then potential κ p.1 p.2 t else 0)
+      ((angleLaw κ).prod W) :=
+    ((measurable_potential_restricted_angle κ).comp
+      ((measurable_const : Measurable (fun _ : ℝ × Driver => t)).prodMk measurable_id)).aemeasurable
+  apply hm.congr
+  filter_upwards [angleLaw_prod_ae_mem κ W] with p hp
+  exact ite_eq_left hp
+
+lemma aemeasurable_discreteMass_angle
+    (κ ℓ : ℝ) (W : WienerLaw) [SFinite W] (h : ℕ) :
+    AEMeasurable (fun p : ℝ × Driver => discreteMass κ p.1 W p.2 ℓ h)
+      ((angleLaw κ).prod W) := by
+  apply (measurable_discreteMass_restricted_angle κ ℓ W h).aemeasurable.congr
+  filter_upwards [angleLaw_prod_ae_mem κ W] with p hp
+  exact ite_eq_left hp
+
+lemma aemeasurable_coefficient_integrand
+    (κ ℓ u : ℝ) (W : WienerLaw) [SFinite W] (h k : ℕ) :
+    AEMeasurable (fun p : ℝ × Driver => levelDensity κ p.1 p.2 ℓ *
+      (clip u (discreteMass κ p.1 W p.2 ℓ h))^k) ((angleLaw κ).prod W) := by
+  have hc : Continuous (fun x : ℝ => (clip u x)^k) := by
+    unfold clip
+    fun_prop
+  exact (measurable_levelDensity_angle κ ℓ).aemeasurable.mul
+    (hc.measurable.comp_aemeasurable (aemeasurable_discreteMass_angle κ ℓ W h))
+
+end SLEExactGauge.Target
+
+end
+
+end OAI
diff --git a/lean/OAI/Probability/SLE/Loewner/TargetSurvivalExtension.lean b/lean/OAI/Probability/SLE/Loewner/TargetSurvivalExtension.lean
new file mode 100644
index 0000000000000000000000000000000000000000..087b358761296b9b44fe4a6f313cca15a495a4ea
--- /dev/null
+++ b/lean/OAI/Probability/SLE/Loewner/TargetSurvivalExtension.lean
@@ -0,0 +1,47 @@
+import OAI.Probability.SLE.Loewner.TargetCutoffTrajectory
+
+namespace OAI
+
+/-! A surviving raw trajectory continues for a strictly longer time.
+This follows directly from the strict cutoff-height certificate. -/
+noncomputable section
+open Set Filter Metric Complex
+open scoped Topology
+
+namespace SLEExactGauge.Target
+
+theorem exists_later_survival (κ : ℝ) (b : Driver) (z : ℂ)
+    {T : ℝ} (hT : 0 ≤ T) (hs : Surviving κ b z T) :
+    ∃ S : ℝ, T < S ∧ Surviving κ b z S := by
+  obtain ⟨j,hj,hmin⟩ := hs
+  have hc := cutoffFlow_continuousOn κ b j hj z
+  have hh := surviving_cutoff_height κ b z T j hj hmin
+  have hTj := hh T ⟨hT,le_rfl⟩
+  have he : ∀ᶠ t in 𝓝[Ici 0] T, (j:ℝ)⁻¹ < (cutoffFlow κ b j z t).im :=
+    (Complex.continuous_im.comp_continuousOn hc T hT).eventually (Ioi_mem_nhds hTj)
+  obtain ⟨δ,hδ,hδb⟩ := Metric.mem_nhdsWithin_iff.mp he
+  let S : ℝ := T+δ/2
+  have hTS : T < S := by dsimp [S]; linarith
+  have hS : 0 ≤ S := hT.trans hTS.le
+  have hpoint (t : ℝ) (ht : t ∈ Icc 0 S) :
+      (j:ℝ)⁻¹ < (cutoffFlow κ b j z t).im := by
+    by_cases htT : t ≤ T
+    · exact hh t ⟨ht.1,htT⟩
+    · apply hδb
+      refine ⟨?_,ht.1⟩
+      rw [mem_ball,Real.dist_eq,abs_of_pos (sub_pos.mpr (lt_of_not_ge htT))]
+      have hts := ht.2
+      dsimp only [S] at hts
+      linarith
+  obtain ⟨t,ht,htmin⟩ := isCompact_Icc.exists_isMinOn (nonempty_Icc.mpr hS)
+    (Complex.continuous_im.comp_continuousOn (hc.mono Icc_subset_Ici_self))
+  refine ⟨S,hTS,j,hj,(hpoint t ht).trans_le ?_⟩
+  apply le_csInf (Set.Nonempty.image _ (nonempty_Icc.mpr hS))
+  rintro y ⟨s,hs,rfl⟩
+  exact htmin hs
+
+end SLEExactGauge.Target
+
+end
+
+end OAI
diff --git a/lean/OAI/Probability/SLE/Loewner/TargetSurvivalLifetime.lean b/lean/OAI/Probability/SLE/Loewner/TargetSurvivalLifetime.lean
new file mode 100644
index 0000000000000000000000000000000000000000..0ec979fc807fe0ef96d13419efcdce6b3d969a9e
--- /dev/null
+++ b/lean/OAI/Probability/SLE/Loewner/TargetSurvivalLifetime.lean
@@ -0,0 +1,33 @@
+import OAI.Probability.SLE.Loewner.TargetSurvivalExtension
+import OAI.Probability.SLE.Loewner.TargetInverseProperties
+import OAI.Probability.SLE.Loewner.RawSurvivingMonotone
+import OAI.Probability.SLE.Loewner.OpenSurvivalLifetime
+
+namespace OAI
+
+/-! Every raw point lost by a finite time has a positive finite lifetime,
+and survives precisely the earlier nonnegative times. -/
+noncomputable section
+open Set Filter Complex
+open scoped Topology
+
+namespace SLEExactGauge.Target
+
+lemma surviving_zero (κ : ℝ) (b : Driver) (z : ℂ) (hz : z ∈ upperHalfPlane) :
+    Surviving κ b z 0 := by
+  obtain ⟨j,hj,hjz⟩ := Real.exists_nat_pos_inv_lt (show 0 < z.im from hz)
+  refine ⟨j,hj,?_⟩
+  simpa only [Icc_self,image_singleton,cutoffFlow_zero κ b j hj,csInf_singleton] using hjz
+
+theorem exists_survival_lifetime (κ : ℝ) (b : Driver) (z : ℂ) (hz : z ∈ upperHalfPlane)
+    {T : ℝ} (hT : 0 ≤ T) (hdead : ¬Surviving κ b z T) :
+    ∃ τ : ℝ, 0 < τ ∧ τ ≤ T ∧ ∀ t, 0 ≤ t → (Surviving κ b z t ↔ t < τ) := by
+  exact exists_open_survival_lifetime (Surviving κ b z) (surviving_zero κ b z hz)
+    (fun s t hs hst h => surviving_of_le_time κ b z hs hst h)
+    (fun _ ht h => exists_later_survival κ b z ht h) hT hdead
+
+end SLEExactGauge.Target
+
+end
+
+end OAI
diff --git a/lean/OAI/Probability/SLE/Loewner/TargetTraceCandidate.lean b/lean/OAI/Probability/SLE/Loewner/TargetTraceCandidate.lean
new file mode 100644
index 0000000000000000000000000000000000000000..55eba50eb1cd4b4a2514f824dffc314519c39385
--- /dev/null
+++ b/lean/OAI/Probability/SLE/Loewner/TargetTraceCandidate.lean
@@ -0,0 +1,85 @@
+import OAI.Probability.SLE.Loewner.TargetInverseMeasurability
+import OAI.Probability.SLE.Angle.TargetFlowIdentification
+
+namespace OAI
+
+/-! A measurable trace candidate from the prescribed inverse flow.
+It equals the actual trace whenever a capacity witness is present. -/
+noncomputable section
+open Set Filter _root_.MeasureTheory _root_.OAI.MeasureTheory
+open scoped Topology NNReal ENNReal
+
+namespace SLEExactGauge.Target
+
+def rawTipApprox (κ : ℝ) (n : ℕ) (T : ℝ≥0) (b : Driver) : ℂ :=
+  inverseFlow κ b (κ.toNNReal*T)
+    ((b (κ.toNNReal*T):ℂ)+((1/((n:ℝ)+1):ℝ):ℂ)*Complex.I)
+
+def traceCandidate (κ : ℝ) (T : ℝ≥0) (b : Driver) : ℂ :=
+  limUnder atTop (fun n => rawTipApprox κ n T b)
+
+lemma measurable_rawTipApprox (κ : ℝ) (n : ℕ) :
+    Measurable (fun q : ℝ≥0 × Driver => rawTipApprox κ n q.1 q.2) := by
+  have ht : Measurable (fun q : ℝ≥0 × Driver => κ.toNNReal*q.1) := measurable_const.mul measurable_fst
+  have hw : Measurable (fun q : ℝ≥0 × Driver =>
+      (q.2 (κ.toNNReal*q.1):ℂ)+((1/((n:ℝ)+1):ℝ):ℂ)*Complex.I) :=
+    ((continuous_eval.measurable.comp (measurable_snd.prodMk ht)).complex_ofReal).add_const _
+  have hq : Measurable (fun q : ℝ≥0 × Driver =>
+      (κ.toNNReal*q.1,(q.2,(q.2 (κ.toNNReal*q.1):ℂ)+((1/((n:ℝ)+1):ℝ):ℂ)*Complex.I))) :=
+    ht.prodMk (measurable_snd.prodMk hw)
+  exact @Measurable.comp (ℝ≥0 × Driver) (ℝ≥0 × (Driver × ℂ)) ℂ
+    inferInstance inferInstance inferInstance
+    (fun q => inverseFlow κ q.2.1 q.1 q.2.2)
+    (fun q => (κ.toNNReal*q.1,(q.2,(q.2 (κ.toNNReal*q.1):ℂ)+((1/((n:ℝ)+1):ℝ):ℂ)*Complex.I)))
+    (measurable_inverseFlow κ) hq
+
+lemma measurable_traceCandidate (κ : ℝ) :
+    Measurable (fun q : ℝ≥0 × Driver => traceCandidate κ q.1 q.2) := by
+  exact (StronglyMeasurable.limUnder
+    (fun n => (measurable_rawTipApprox κ n).stronglyMeasurable)).measurable
+
+lemma rawTipApprox_eq_witness
+    (κ : ℝ) (hκ : 0 < κ) (b : Driver) (U : ℝ≥0 → ℝ)
+    (γ : ℝ≥0 → ℂ) (G F : ℝ≥0 → ℂ → ℂ)
+    (hw : IsCapacityTwoWitness U γ G F)
+    (hU : ∀ s : ℝ, 0 ≤ s → U s.toNNReal=driverValue b (κ*s))
+    (T : ℝ≥0) (n : ℕ) :
+    rawTipApprox κ n T b=F T ((U T:ℂ)+((1/((n:ℝ)+1):ℝ):ℂ)*Complex.I) := by
+  have heTime : (κ*(T:ℝ)).toNNReal=κ.toNNReal*T := by
+    rw [Real.toNNReal_mul hκ.le,Real.toNNReal_coe]
+  have hb : b (κ.toNNReal*T)=U T := by
+    have h := hU T T.coe_nonneg
+    simpa only [Real.toNNReal_coe,driverValue,heTime] using h.symm
+  unfold rawTipApprox
+  rw [Real.coe_toNNReal _ hκ.le,hb]
+  exact inverseFlow_eq_witness κ hκ b U γ G F hw hU T _ (by
+    change 0 < ((U T:ℂ)+((1/((n:ℝ)+1):ℝ):ℂ)*Complex.I).im
+    simp only [Complex.add_im,Complex.ofReal_im,Complex.mul_im,Complex.ofReal_re,
+      Complex.I_im,Complex.I_re,mul_one,mul_zero,zero_add,add_zero]
+    positivity)
+
+lemma rawTipApprox_tendsto_witness
+    (κ : ℝ) (hκ : 0 < κ) (b : Driver) (U : ℝ≥0 → ℝ)
+    (γ : ℝ≥0 → ℂ) (G F : ℝ≥0 → ℂ → ℂ)
+    (hw : IsCapacityTwoWitness U γ G F)
+    (hU : ∀ s : ℝ, 0 ≤ s → U s.toNNReal=driverValue b (κ*s))
+    (T : ℝ≥0) : Tendsto (fun n => rawTipApprox κ n T b) atTop (𝓝 (γ T)) := by
+  have hseq : Tendsto (fun n : ℕ => 1/((n:ℝ)+1)) atTop (𝓝[>] (0:ℝ)) :=
+    tendsto_nhdsWithin_iff.mpr ⟨tendsto_one_div_add_atTop_nhds_zero_nat,
+      Eventually.of_forall (fun n => by change 0 < (1:ℝ)/((n:ℝ)+1); positivity)⟩
+  simpa only [rawTipApprox_eq_witness κ hκ b U γ G F hw hU T,Function.comp_def] using
+    (hw.2.2.2.2.2.2.2.2.2.2.2.2 T).comp hseq
+
+lemma traceCandidate_eq_witness
+    (κ : ℝ) (hκ : 0 < κ) (b : Driver) (U : ℝ≥0 → ℝ)
+    (γ : ℝ≥0 → ℂ) (G F : ℝ≥0 → ℂ → ℂ)
+    (hw : IsCapacityTwoWitness U γ G F)
+    (hU : ∀ s : ℝ, 0 ≤ s → U s.toNNReal=driverValue b (κ*s))
+    (T : ℝ≥0) : traceCandidate κ T b=γ T :=
+  (rawTipApprox_tendsto_witness κ hκ b U γ G F hw hU T).limUnder_eq
+
+end SLEExactGauge.Target
+
+end
+
+end OAI
diff --git a/lean/OAI/Probability/SLE/Loewner/TraceBoundaryBarrier.lean b/lean/OAI/Probability/SLE/Loewner/TraceBoundaryBarrier.lean
new file mode 100644
index 0000000000000000000000000000000000000000..5cee05d23f43035564bb318c7c7182e59ea4dd55
--- /dev/null
+++ b/lean/OAI/Probability/SLE/Loewner/TraceBoundaryBarrier.lean
@@ -0,0 +1,78 @@
+import OAI.Probability.SLE.Geometry.CompactPathNeighborhoods
+import OAI.Probability.SLE.Loewner.TraceDomainBoundary
+
+namespace OAI
+
+/-! A finite trace together with a bounded real interval is a compact
+locally path-connected barrier outside the surviving Loewner domain. -/
+noncomputable section
+open Set Filter Metric Function
+open scoped Topology NNReal
+
+namespace SLEExactGauge
+
+def traceBoundaryBarrier (γ : ℝ≥0 → ℂ) (T : ℝ≥0) (R : ℝ) : Set ℂ :=
+  (γ '' Icc 0 T) ∪ (Complex.ofReal '' Icc (-R) R)
+
+lemma traceBoundaryBarrier_compact {γ : ℝ≥0 → ℂ} (hγ : Continuous γ)
+    (T : ℝ≥0) (R : ℝ) : IsCompact (traceBoundaryBarrier γ T R) :=
+  (finiteTrace_isCompact hγ T).union (isCompact_Icc.image Complex.continuous_ofReal)
+
+lemma traceBoundaryBarrier_locallyPathConnected {γ : ℝ≥0 → ℂ} (hγ : Continuous γ)
+    (T : ℝ≥0) (R : ℝ) (hR : 0≤R) :
+    LocallyPathConnectedSpace (traceBoundaryBarrier γ T R) := by
+  have : LocallyPathConnectedSpace (γ '' Icc 0 T) := finiteTrace_locallyPathConnected hγ T
+  have : LocallyPathConnectedSpace (Icc (-R) R) :=
+    (isQuotientMap_projIcc (a := -R) (b := R) (h := by linarith)).locallyPathConnectedSpace
+  let p : Icc (-R) R → Complex.ofReal '' Icc (-R) R := fun x => ⟨x,⟨x,x.2,rfl⟩⟩
+  have hp : Continuous p := (Complex.continuous_ofReal.comp continuous_subtype_val).subtype_mk _
+  have hs : Surjective p := by
+    rintro ⟨_,x,hx,rfl⟩
+    exact ⟨⟨x,hx⟩,rfl⟩
+  have : LocallyPathConnectedSpace (Complex.ofReal '' Icc (-R) R) :=
+    (hp.isClosedMap.isQuotientMap hp hs).locallyPathConnectedSpace
+  exact compact_union_locallyPathConnected (finiteTrace_isCompact hγ T)
+    (isCompact_Icc.image Complex.continuous_ofReal)
+
+lemma traceBoundaryBarrier_disjoint_domain (γ : ℝ≥0 → ℂ) (T : ℝ≥0) (R : ℝ) :
+    Disjoint (traceBoundaryBarrier γ T R) (survivingDomain γ T) := by
+  apply disjoint_left.mpr
+  intro z hz hD
+  rcases hz with hz | ⟨x,_,rfl⟩
+  · exact hD.1.2 hz
+  · have him := hD.1.1
+    change 0<(x:ℂ).im at him
+    simp at him
+
+lemma frontier_mem_traceBoundaryBarrier {γ : ℝ≥0 → ℂ} (hγ : Continuous γ)
+    {T : ℝ≥0} {R : ℝ} {z : ℂ} (hz : z∈frontier (survivingDomain γ T))
+    (hR : ‖z‖≤R) : z∈traceBoundaryBarrier γ T R := by
+  rcases frontier_survivingDomain_subset hγ T hz with ht | hr
+  · exact Or.inl ht
+  · right
+    change z.im=0 at hr
+    refine ⟨z.re,?_,?_⟩
+    · have h := (Complex.abs_re_le_norm z).trans hR
+      exact ⟨by linarith [(neg_abs_le z.re)],(le_abs_self z.re).trans h⟩
+    · apply Complex.ext <;> simp [hr]
+
+lemma traceBoundaryBarrier_uniform_paths {γ : ℝ≥0 → ℂ} (hγ : Continuous γ)
+    (T : ℝ≥0) (R : ℝ) (hR : 0≤R) (ε : ℝ) (hε : 0<ε) :
+    ∃ δ : ℝ, 0<δ ∧ ∀ x∈traceBoundaryBarrier γ T R, ∀ y∈traceBoundaryBarrier γ T R,
+      dist x y<δ → ∃ p : Path x y, (∀ s, p s∈traceBoundaryBarrier γ T R) ∧
+        ∀ s, dist (p s) x<ε := by
+  have : CompactSpace (traceBoundaryBarrier γ T R) :=
+    isCompact_iff_compactSpace.mp (traceBoundaryBarrier_compact hγ T R)
+  have : LocallyPathConnectedSpace (traceBoundaryBarrier γ T R) :=
+    traceBoundaryBarrier_locallyPathConnected hγ T R hR
+  obtain ⟨δ,hδ,hpath⟩ := compact_locallyPathConnected_uniform_path
+    (A := traceBoundaryBarrier γ T R) ε hε
+  refine ⟨δ,hδ,fun x hx y hy hxy => ?_⟩
+  obtain ⟨p,hp⟩ := hpath ⟨x,hx⟩ ⟨y,hy⟩ hxy
+  exact ⟨p.map continuous_subtype_val,fun s => (p s).property,hp⟩
+
+end SLEExactGauge
+
+end
+
+end OAI
diff --git a/lean/OAI/Probability/SLE/Loewner/TraceDomainBoundary.lean b/lean/OAI/Probability/SLE/Loewner/TraceDomainBoundary.lean
new file mode 100644
index 0000000000000000000000000000000000000000..675c521e5f9d5c2e97f187d574802c28650143f8
--- /dev/null
+++ b/lean/OAI/Probability/SLE/Loewner/TraceDomainBoundary.lean
@@ -0,0 +1,46 @@
+import OAI.Probability.SLE.Geometry.FiniteTraceTopology
+
+namespace OAI
+
+/-! Every finite Loewner-domain boundary point is on the finite trace or
+on the real axis. This identifies the possible inverse cluster points. -/
+noncomputable section
+open Set Filter Metric Function
+open scoped Topology NNReal
+
+namespace SLEExactGauge
+
+lemma frontier_survivingDomain_subset {γ : ℝ≥0 → ℂ} (hγ : Continuous γ) (T : ℝ≥0) :
+    frontier (survivingDomain γ T) ⊆ (γ '' Icc 0 T) ∪ {z : ℂ | z.im=0} := by
+  intro z hz
+  by_cases htrace : z∈γ '' Icc 0 T
+  · exact Or.inl htrace
+  right
+  have hclosed : IsClosed {z : ℂ | 0≤z.im} := isClosed_le continuous_const Complex.continuous_im
+  have hsub : survivingDomain γ T ⊆ {w : ℂ | 0≤w.im} := by
+    intro w hw
+    change 0≤w.im
+    exact hw.1.1.le
+  have hznonneg : 0≤z.im := (closure_minimal hsub hclosed) hz.1
+  by_contra hz0
+  have hzH : z∈upperHalfPlane := lt_of_le_of_ne hznonneg (Ne.symm hz0)
+  let S := upperHalfPlane \ (γ '' Icc 0 T)
+  have hS : IsOpen S := isOpen_upperHalfPlane.sdiff (finiteTrace_isCompact hγ T).isClosed
+  have hzS : z∈S := ⟨hzH,htrace⟩
+  have hznot : z∉survivingDomain γ T := by
+    simpa only [(isOpen_survivingDomain hγ T).interior_eq] using hz.2
+  have hb : Bornology.IsBounded (connectedComponentIn S z) := by
+    by_contra hn
+    exact hznot ⟨hzS,hn⟩
+  have hCn : connectedComponentIn S z∈𝓝 z :=
+    (hS.connectedComponentIn).mem_nhds (mem_connectedComponentIn hzS)
+  obtain ⟨w,hwC,hwD⟩ := mem_closure_iff_nhds.mp hz.1 _ hCn
+  have hwBound : Bornology.IsBounded (connectedComponentIn S w) := by
+    rwa [← connectedComponentIn_eq hwC]
+  exact hwD.2 hwBound
+
+end SLEExactGauge
+
+end
+
+end OAI
diff --git a/lean/OAI/Probability/SLE/Loewner/TraceRestrictionContinuity.lean b/lean/OAI/Probability/SLE/Loewner/TraceRestrictionContinuity.lean
new file mode 100644
index 0000000000000000000000000000000000000000..71d0fd8b82a6fd34ae4006c8fcb1adaace86d28a
--- /dev/null
+++ b/lean/OAI/Probability/SLE/Loewner/TraceRestrictionContinuity.lean
@@ -0,0 +1,87 @@
+import OAI.Probability.SLE.Mass.CanonicalMassContinuity
+
+namespace OAI
+
+/-! Rational first-visit identities extend simultaneously to all finite
+times by local total-variation continuity. -/
+
+noncomputable section
+open Set Filter MeasureTheory Classical
+open scoped NNReal ENNReal Topology CompactlySupported
+
+namespace SLEExactGauge.Multipoint
+
+local instance : LocallyCompactSpace upperHalfPlane := isOpen_upperHalfPlane.locallyCompactSpace
+
+theorem trace_restriction_of_rational_times
+    (γ : ℝ≥0 → ℂ) (hγ : Continuous γ)
+    (μ : ℚ → Measure upperHalfPlane) (ν : Measure upperHalfPlane)
+    [ν.Regular] (N : ℝ≥0 → Measure upperHalfPlane)
+    (hp : ContinuousMassPath γ μ ν N)
+    (hpast : ∀ t, N t {z : upperHalfPlane | (z:ℂ) ∉ γ '' Icc 0 t} = 0)
+    (hq : ∀ q : ℚ, 0 ≤ q → N (q:ℝ).toNNReal =
+      ν.restrict {z : upperHalfPlane | (z:ℂ) ∈ γ '' Icc 0 (q:ℝ).toNNReal}) :
+    ∀ t, N t = ν.restrict {z : upperHalfPlane | (z:ℂ) ∈ γ '' Icc 0 t} := by
+  intro t
+  let A : Set upperHalfPlane := {z | (z:ℂ) ∈ γ '' Icc 0 t}
+  have hA : MeasurableSet A :=
+    ((isCompact_Icc.image hγ).isClosed.preimage continuous_subtype_val).measurableSet
+  have hNpast : (N t).restrict A = N t := by
+    apply Measure.restrict_eq_self_of_ae_mem
+    filter_upwards [measure_eq_zero_iff_ae_notMem.mp (hpast t)] with z hz
+    exact not_not.mp hz
+  let D := localTestFamily upperHalfPlane
+  have hcover : ⋃ n, D.compactSet n = univ := by
+    apply eq_univ_of_forall
+    intro z
+    obtain ⟨n,hn⟩ := D.exhaustive {z} isCompact_singleton
+    exact mem_iUnion.mpr ⟨n,hn (mem_singleton z)⟩
+  apply Measure.ext_of_iUnion_eq_univ hcover
+  intro n
+  apply Measure.ext
+  intro E hE
+  rw [Measure.restrict_apply hE,Measure.restrict_apply hE]
+  have hEK : MeasurableSet (E ∩ D.compactSet n) := hE.inter (D.isCompact n).measurableSet
+  rw [Measure.restrict_apply hEK]
+  have hcut : N t (E ∩ D.compactSet n) = N t ((E ∩ D.compactSet n) ∩ A) := by
+    conv_lhs => rw [← hNpast]
+    rw [Measure.restrict_apply hEK]
+  rw [hcut]
+  let L := (E ∩ D.compactSet n) ∩ A
+  have hL : MeasurableSet L := hEK.inter hA
+  have hLK : L ⊆ D.compactSet n := fun _ hz => hz.1.2
+  have hνfin : ν L ≠ ∞ := (lt_of_le_of_lt (measure_mono hLK) (D.isCompact n).measure_lt_top).ne
+  have hNfin : N t L ≠ ∞ := (lt_of_le_of_lt (hp.dominated t L) (lt_top_iff_ne_top.mpr hνfin)).ne
+  have heReal : (N t L).toReal = (ν L).toReal := by
+    apply eq_of_forall_dist_le
+    intro ε hε
+    obtain ⟨δ,hδ,hvar⟩ := hp.local_variation (D.compactSet n) (D.isCompact n) t ε hε
+    obtain ⟨q,htq,hqt⟩ := exists_rat_btwn (lt_add_of_pos_right (t:ℝ) hδ)
+    have hq0 : 0 ≤ q := Rat.cast_nonneg.mp ((NNReal.coe_nonneg t).trans htq.le)
+    have hqr : ((q:ℝ).toNNReal:ℝ) = q := Real.coe_toNNReal _ (Rat.cast_nonneg.mpr hq0)
+    have htqNN : t ≤ (q:ℝ).toNNReal := by
+      apply NNReal.coe_le_coe.mp
+      rw [hqr]
+      exact htq.le
+    have hnear : dist (((q:ℝ).toNNReal):ℝ) t < δ := by
+      rw [hqr,Real.dist_eq,abs_of_pos (sub_pos.mpr htq)]
+      linarith
+    have hvalues : N (q:ℝ).toNNReal L = ν L := by
+      rw [hq q hq0,Measure.restrict_apply hL]
+      congr 1
+      apply inter_eq_left.mpr
+      intro z hz
+      exact image_mono (Icc_subset_Icc le_rfl htqNN) hz.2
+    have hv := hvar t (q:ℝ).toNNReal (by simpa using hδ) hnear L hL hLK
+    rw [hvalues] at hv
+    exact le_of_lt (by simpa only [Real.dist_eq] using hv)
+  calc
+    N t L = ENNReal.ofReal (N t L).toReal := (ENNReal.ofReal_toReal hNfin).symm
+    _ = ENNReal.ofReal (ν L).toReal := congrArg ENNReal.ofReal heReal
+    _ = ν L := ENNReal.ofReal_toReal hνfin
+
+end SLEExactGauge.Multipoint
+
+end
+
+end OAI
diff --git a/lean/OAI/Probability/SLE/Loewner/TraceWitnessUniqueness.lean b/lean/OAI/Probability/SLE/Loewner/TraceWitnessUniqueness.lean
new file mode 100644
index 0000000000000000000000000000000000000000..95bfeee57e710dc6bfed410b1211f1b7971ece00
--- /dev/null
+++ b/lean/OAI/Probability/SLE/Loewner/TraceWitnessUniqueness.lean
@@ -0,0 +1,57 @@
+import OAI.Probability.SLE.StoppedMeasures
+
+namespace OAI
+
+/-! The reverse Loewner equation determines the inverse maps and hence
+the continuous trace. This is deterministic uniqueness for a fixed driver. -/
+
+noncomputable section
+open Set Filter
+open scoped Topology NNReal
+
+namespace SLEExactGauge
+
+theorem IsCapacityTwoWitness.inverse_unique
+    {U : ℝ≥0 → ℝ} {γ β : ℝ≥0 → ℂ} {G F H J : ℝ≥0 → ℂ → ℂ}
+    (hγ : IsCapacityTwoWitness U γ G F) (hβ : IsCapacityTwoWitness U β H J)
+    (T : ℝ≥0) (z : ℂ) (hz : z ∈ upperHalfPlane) : F T z = J T z := by
+  let Q : ℝ → ℂ := fun t => G ((T : ℝ) - t).toNNReal (F T z)
+  have hQ0 : Q 0 = z := by
+    simp only [Q, sub_zero, Real.toNNReal_coe]
+    exact hγ.2.2.2.2.2.2.2.2.1 T z hz
+  have hQt : Q T = F T z := by
+    simp only [Q, sub_self, Real.toNNReal_zero]
+    exact hγ.initial_value _ (hγ.2.2.2.2.2.2.1 T hz).1.1
+  have he := hβ.reverse_flow_identifies T z hz le_rfl Q hQ0
+    (fun t ht => hγ.reverse_path_derivative T z hz le_rfl t ht)
+  rwa [hQt] at he
+
+theorem IsCapacityTwoWitness.trace_unique
+    {U : ℝ≥0 → ℝ} {γ β : ℝ≥0 → ℂ} {G F H J : ℝ≥0 → ℂ → ℂ}
+    (hγ : IsCapacityTwoWitness U γ G F) (hβ : IsCapacityTwoWitness U β H J) : γ = β := by
+  funext T
+  let y : ℕ → ℝ := fun n => 1 / ((n : ℝ) + 1)
+  have hy : Tendsto y atTop (𝓝[>] (0 : ℝ)) :=
+    tendsto_nhdsWithin_iff.mpr ⟨tendsto_one_div_add_atTop_nhds_zero_nat,
+      Eventually.of_forall (fun n => by change 0 < y n; dsimp only [y]; positivity)⟩
+  have he (n : ℕ) : F T ((U T : ℂ) + (y n : ℂ) * Complex.I) =
+      J T ((U T : ℂ) + (y n : ℂ) * Complex.I) := by
+    apply hγ.inverse_unique hβ
+    change 0 < ((U T : ℂ) + (y n : ℂ) * Complex.I).im
+    simpa 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] using (show 0 < y n by dsimp only [y]; positivity)
+  exact tendsto_nhds_unique (hγ.2.2.2.2.2.2.2.2.2.2.2.2 T |>.comp hy)
+    ((hβ.2.2.2.2.2.2.2.2.2.2.2.2 T |>.comp hy).congr (fun n => (he n).symm))
+
+theorem IsCapacityTwoTrace.unique {U : ℝ≥0 → ℝ} {γ β : ℝ≥0 → ℂ}
+    (hγ : IsCapacityTwoTrace U γ) (hβ : IsCapacityTwoTrace U β) : γ = β := by
+  obtain ⟨G, F, hγ⟩ := hγ
+  obtain ⟨H, J, hβ⟩ := hβ
+  exact hγ.trace_unique hβ
+
+end SLEExactGauge
+
+end
+
+end OAI
diff --git a/lean/OAI/Probability/SLE/Loewner/UnivalentArcRayCrossing.lean b/lean/OAI/Probability/SLE/Loewner/UnivalentArcRayCrossing.lean
new file mode 100644
index 0000000000000000000000000000000000000000..5a5cdf5f981cac158b689a65b59b59b061aceef8
--- /dev/null
+++ b/lean/OAI/Probability/SLE/Loewner/UnivalentArcRayCrossing.lean
@@ -0,0 +1,80 @@
+import OAI.Probability.SLE.Geometry.TransverseCurveDifference
+import OAI.Probability.SLE.Loewner.UnivalentInverseAnalytic
+import OAI.Probability.SLE.DyadicStrips
+
+namespace OAI
+
+/-! Radial and angular image curves cross transversely under an actual
+univalent half-plane map. -/
+noncomputable section
+open Set Filter Metric Function
+open scoped Topology
+
+namespace SLEExactGauge
+
+lemma univalent_polar_point_mem (x r θ : ℝ) (hr : 0<r) (hθ : θ∈Ioo 0 Real.pi) :
+    (x:ℂ)+(r:ℂ)*Complex.exp ((θ:ℂ)*Complex.I)∈upperHalfPlane := by
+  have he := exp_strip_halfplane (x := (θ:ℂ)*Complex.I) (by simpa using hθ)
+  change 0<((x:ℂ)+(r:ℂ)*Complex.exp ((θ:ℂ)*Complex.I)).im
+  simpa only [Set.mem_ofPred_eq,Complex.add_im,Complex.ofReal_im,Complex.mul_im,
+    Complex.ofReal_re,zero_mul,add_zero,zero_add] using mul_pos hr he
+
+lemma holomorphic_polar_arc_strict {F : ℂ → ℂ}
+    (hF : DifferentiableOn ℂ F upperHalfPlane) (x r θ : ℝ) (hr : 0<r)
+    (hθ : θ∈Ioo 0 Real.pi) :
+    HasStrictDerivAt (fun u : ℝ => F ((x:ℂ)+(r:ℂ)*Complex.exp ((u:ℂ)*Complex.I)))
+      (deriv F ((x:ℂ)+(r:ℂ)*Complex.exp ((θ:ℂ)*Complex.I)) *
+        ((r:ℂ)*Complex.exp ((θ:ℂ)*Complex.I)*Complex.I)) θ := by
+  have hd := (hF.analyticAt (isOpen_upperHalfPlane.mem_nhds
+    (univalent_polar_point_mem x r θ hr hθ))).hasStrictDerivAt
+  have hi : HasStrictDerivAt (fun u : ℝ => (u:ℂ)*Complex.I) Complex.I θ := by
+    simpa using (Complex.ofRealCLM.hasStrictDerivAt (x := θ)).mul_const Complex.I
+  have he := ((Complex.hasStrictDerivAt_exp ((θ:ℂ)*Complex.I)).hasStrictFDerivAt.restrictScalars ℝ).comp_hasStrictDerivAt θ hi
+  have ha := (he.const_mul (r:ℂ)).const_add (x:ℂ)
+  have hf := (hd.hasStrictFDerivAt.restrictScalars ℝ).comp_hasStrictDerivAt θ ha
+  simpa [ContinuousLinearMap.toSpanSingleton_apply,smul_eq_mul,mul_assoc,mul_comm,mul_left_comm,
+    Function.comp_def] using hf
+
+lemma holomorphic_polar_ray_strict {F : ℂ → ℂ}
+    (hF : DifferentiableOn ℂ F upperHalfPlane) (x r θ : ℝ) (hr : 0<r)
+    (hθ : θ∈Ioo 0 Real.pi) :
+    HasStrictDerivAt (fun u : ℝ => F ((x:ℂ)+(u:ℂ)*Complex.exp ((θ:ℂ)*Complex.I)))
+      (deriv F ((x:ℂ)+(r:ℂ)*Complex.exp ((θ:ℂ)*Complex.I)) *
+        Complex.exp ((θ:ℂ)*Complex.I)) r := by
+  have hd := (hF.analyticAt (isOpen_upperHalfPlane.mem_nhds
+    (univalent_polar_point_mem x r θ hr hθ))).hasStrictDerivAt
+  have ha : HasStrictDerivAt
+      (fun u : ℝ => (x:ℂ)+(u:ℂ)*Complex.exp ((θ:ℂ)*Complex.I))
+      (Complex.exp ((θ:ℂ)*Complex.I)) r := by
+    simpa using ((Complex.ofRealCLM.hasStrictDerivAt (x := r)).mul_const
+      (Complex.exp ((θ:ℂ)*Complex.I))).const_add (x:ℂ)
+  have hf := (hd.hasStrictFDerivAt.restrictScalars ℝ).comp_hasStrictDerivAt r ha
+  simpa [ContinuousLinearMap.toSpanSingleton_apply,smul_eq_mul,mul_comm,Function.comp_def] using hf
+
+lemma univalent_arc_ray_locally_injective {F : ℂ → ℂ}
+    (hF : DifferentiableOn ℂ F upperHalfPlane) (hi : InjOn F upperHalfPlane)
+    (x r θ : ℝ) (hr : 0<r) (hθ : θ∈Ioo 0 Real.pi) :
+    ∃ δ : ℝ, 0<δ ∧ InjOn (fun z : ℂ =>
+      F ((x:ℂ)+(r:ℂ)*Complex.exp ((z.im:ℂ)*Complex.I))-
+      F ((x:ℂ)+(z.re:ℂ)*Complex.exp ((θ:ℂ)*Complex.I)))
+      (closedBall ((r:ℂ)+(θ:ℂ)*Complex.I) δ) := by
+  apply transverse_difference_locally_injective
+    (holomorphic_polar_arc_strict hF x r θ hr hθ)
+    (holomorphic_polar_ray_strict hF x r θ hr hθ)
+  let q := deriv F ((x:ℂ)+(r:ℂ)*Complex.exp ((θ:ℂ)*Complex.I))*Complex.exp ((θ:ℂ)*Complex.I)
+  have hq : q≠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 hα : deriv F ((x:ℂ)+(r:ℂ)*Complex.exp ((θ:ℂ)*Complex.I)) *
+      ((r:ℂ)*Complex.exp ((θ:ℂ)*Complex.I)*Complex.I)=(r:ℂ)*Complex.I*q := by
+    dsimp [q]
+    ring
+  rw [hα]
+  simpa only [Complex.ofReal_one,one_mul] using
+    transverse_radial_angular r 1 q hr.ne' one_ne_zero hq
+
+end SLEExactGauge
+
+end
+
+end OAI
diff --git a/lean/OAI/Probability/SLE/Loewner/UnivalentFamilyPropagation.lean b/lean/OAI/Probability/SLE/Loewner/UnivalentFamilyPropagation.lean
new file mode 100644
index 0000000000000000000000000000000000000000..b08447232abe6604b379b13cdb8ebd2d3d34edb3
--- /dev/null
+++ b/lean/OAI/Probability/SLE/Loewner/UnivalentFamilyPropagation.lean
@@ -0,0 +1,128 @@
+import OAI.Probability.SLE.Loewner.UnivalentLocalBound
+import OAI.Probability.SLE.Geometry.HolomorphicFamilyCompactness
+
+namespace OAI
+
+/-! A local bound for an injective holomorphic family propagates throughout
+ the half-plane. Only the coarse, proved Bloch bound is used. -/
+noncomputable section
+open Set Filter Metric Function
+open scoped Topology
+
+namespace SLEExactGauge
+
+def familyBoundedLocus (f : ℕ → ℂ → ℂ) : Set ℂ :=
+  {z | ∃ r : ℝ, 0<r ∧ ∃ C : ℝ, ∀ n, ∀ w∈ball z r, ‖f n w‖≤C}
+
+lemma isOpen_familyBoundedLocus (f : ℕ → ℂ → ℂ) : IsOpen (familyBoundedLocus f) := by
+  apply Metric.isOpen_iff.mpr
+  rintro z ⟨r,hr,C,hC⟩
+  refine ⟨r/2,by positivity,?_⟩
+  intro w hw
+  refine ⟨r/2,by positivity,C,fun n v hv => hC n v ?_⟩
+  have h := dist_triangle v w z
+  rw [mem_ball] at hw hv ⊢
+  linarith
+
+lemma univalent_family_enlarged_bound
+    (f : ℕ → ℂ → ℂ) (hf : ∀ n, DifferentiableOn ℂ (f n) upperHalfPlane)
+    (hi : ∀ n, InjOn (f n) upperHalfPlane) {z : ℂ} (hz : z∈upperHalfPlane)
+    (hb : z∈familyBoundedLocus f) :
+    ∃ B : ℝ, ∀ n, ∀ w∈ball z (z.im/(2*(128*Real.pi)^2)), ‖f n w‖≤B := by
+  obtain ⟨r,hr,C,hC⟩ := hb
+  let t := min (r/2) (z.im/2)
+  have ht : 0<t := lt_min (half_pos hr) (half_pos hz)
+  have htr : t<r := (min_le_left _ _).trans_lt (by linarith)
+  have htH : closedBall z t ⊆ upperHalfPlane := by
+    intro w hw
+    have him := Complex.abs_im_le_norm (w-z)
+    have hd : ‖w-z‖≤t := by simpa only [mem_closedBall,dist_eq_norm] using hw
+    have htz : t≤z.im/2 := min_le_right _ _
+    rw [Complex.sub_im] at him
+    change 0<w.im
+    have := (abs_le.mp (him.trans hd)).1
+    linarith
+  have hder (n : ℕ) : ‖deriv (f n) z‖≤C/t := by
+    rw [← Complex.cderiv_eq_deriv isOpen_upperHalfPlane (hf n) ht htH]
+    apply Complex.norm_cderiv_le ht
+    intro w hw
+    apply hC n w
+    exact mem_ball.mpr ((mem_sphere.mp hw).trans_lt htr)
+  let R := z.im/2
+  have hR : 0<R := half_pos hz
+  have hRH : ball z R ⊆ upperHalfPlane := by
+    intro w hw
+    have him := Complex.abs_im_le_norm (w-z)
+    have hd : ‖w-z‖<R := by simpa only [mem_ball,dist_eq_norm] using hw
+    rw [Complex.sub_im] at him
+    change 0<w.im
+    have := (abs_le.mp (him.trans hd.le)).1
+    dsimp [R] at *
+    linarith
+  refine ⟨R*(C/t)/(128*Real.pi)+C,fun n w hw => ?_⟩
+  have hsmall : w∈ball z (R/(128*Real.pi)^2) := by
+    have he : R/(128*Real.pi)^2=z.im/(2*(128*Real.pi)^2) := by dsimp [R]; ring
+    rw [he]
+    exact hw
+  have h := univalent_coarse_local_bound hR ((hf n).mono hRH) ((hi n).mono hRH) hsmall
+  calc
+    ‖f n w‖ ≤ ‖f n w-f n z‖+‖f n z‖ := norm_le_norm_sub_add _ _
+    _ ≤ R*‖deriv (f n) z‖/(128*Real.pi)+C :=
+      add_le_add h.le (hC n z (mem_ball_self hr))
+    _ ≤ R*(C/t)/(128*Real.pi)+C := by gcongr; exact hder n
+
+lemma univalent_family_bound_propagates
+    (f : ℕ → ℂ → ℂ) (hf : ∀ n, DifferentiableOn ℂ (f n) upperHalfPlane)
+    (hi : ∀ n, InjOn (f n) upperHalfPlane)
+    (hseed : (upperHalfPlane ∩ familyBoundedLocus f).Nonempty) :
+    upperHalfPlane ⊆ familyBoundedLocus f := by
+  have hconn : IsPreconnected upperHalfPlane :=
+    (convex_halfSpace_im_gt (0:ℝ)).isPreconnected
+  apply hconn.subset_of_closure_inter_subset (isOpen_familyBoundedLocus f) hseed
+  rintro x ⟨hx,hxH⟩
+  let Q : ℝ := (128*Real.pi)^2
+  have hQ : 1≤Q := by dsimp [Q]; nlinarith [Real.pi_gt_three]
+  have hQpos : 0<Q := lt_of_lt_of_le zero_lt_one hQ
+  let δ := x.im/(8*Q)
+  have hδ : 0<δ := div_pos hxH (by positivity)
+  have hδle : δ≤x.im/8 :=
+    div_le_div_of_nonneg_left hxH.le (by norm_num) (by nlinarith)
+  obtain ⟨y,hy,hxy⟩ := Metric.mem_closure_iff.mp hx δ hδ
+  have him : |y.im-x.im|<δ := by
+    have h := Complex.abs_im_le_norm (y-x)
+    rw [Complex.sub_im] at h
+    exact h.trans_lt (by simpa only [dist_eq_norm,norm_sub_rev] using hxy)
+  have hyH : y∈upperHalfPlane := by
+    change 0<y.im
+    have := (abs_lt.mp him).1
+    linarith
+  obtain ⟨B,hB⟩ := univalent_family_enlarged_bound f hf hi hyH hy
+  have hxy' : dist x y<y.im/(2*Q) := by
+    apply hxy.trans
+    apply (div_lt_div_iff₀ (by positivity : 0<8*Q) (by positivity : 0<2*Q)).mpr
+    have := (abs_lt.mp him).1
+    nlinarith
+  have hrad : 0<y.im/(2*Q)-dist x y := sub_pos.mpr hxy'
+  refine ⟨y.im/(2*Q)-dist x y,hrad,B,fun n w hw => hB n w ?_⟩
+  rw [mem_ball] at hw ⊢
+  have htri := dist_triangle w x y
+  change dist w y<y.im/(2*Q)
+  linarith
+
+lemma familyBoundedLocus_compact_bound (f : ℕ → ℂ → ℂ)
+    {K : Set ℂ} (hK : IsCompact K) (hb : K⊆familyBoundedLocus f) :
+    ∃ C : ℝ, ∀ n, ∀ z∈K, ‖f n z‖≤C := by
+  classical
+  choose r hr C hC using fun z : K => hb z.property
+  obtain ⟨t,ht⟩ := hK.elim_finite_subcover (fun z : K => ball z.1 (r z))
+    (fun _ => isOpen_ball) (fun z hz => mem_iUnion.mpr ⟨⟨z,hz⟩,mem_ball_self (hr ⟨z,hz⟩)⟩)
+  refine ⟨∑ z∈t, max (C z) 0,fun n z hz => ?_⟩
+  obtain ⟨a,ha,hza⟩ := mem_iUnion₂.mp (ht hz)
+  exact (hC a n z hza).trans ((le_max_left _ _).trans
+    (Finset.single_le_sum (fun a _ => le_max_right (C a) 0) ha))
+
+end SLEExactGauge
+
+end
+
+end OAI
diff --git a/lean/OAI/Probability/SLE/Loewner/UnivalentInverseAnalytic.lean b/lean/OAI/Probability/SLE/Loewner/UnivalentInverseAnalytic.lean
new file mode 100644
index 0000000000000000000000000000000000000000..1a65ac0487c6c8be533bffa3fd1bbc70244879e9
--- /dev/null
+++ b/lean/OAI/Probability/SLE/Loewner/UnivalentInverseAnalytic.lean
@@ -0,0 +1,106 @@
+import Mathlib
+
+namespace OAI
+
+/-! The local inverse of an injective holomorphic map is holomorphic.
+The proof uses the open mapping theorem and removes the isolated possible
+singularity of the inverse, without a conformal mapping assumption. -/
+noncomputable section
+open Set Filter Metric Function
+open scoped Topology
+
+namespace SLEExactGauge
+
+lemma univalent_not_eventually_constant {D : Set ℂ} {f : ℂ → ℂ}
+    (hD : IsOpen D) (hi : InjOn f D) {a : ℂ} (ha : a ∈ D) :
+    ¬∀ᶠ z in 𝓝 a, f z=f a := by
+  intro h
+  have he : ∀ᶠ z in 𝓝[≠] a, z=a := by
+    filter_upwards [h.filter_mono nhdsWithin_le_nhds,
+      (show ∀ᶠ z in 𝓝 a, z∈D from hD.mem_nhds ha).filter_mono
+        nhdsWithin_le_nhds] with z hz hDz
+    exact hi hDz ha hz
+  have hn : ∀ᶠ z in 𝓝[≠] a, z≠a := self_mem_nhdsWithin
+  obtain ⟨z,hz,hnz⟩ := (he.and hn).exists
+  exact hnz hz
+
+lemma univalent_nhds_le_map {D : Set ℂ} {f : ℂ → ℂ}
+    (hD : IsOpen D) (hf : DifferentiableOn ℂ f D) (hi : InjOn f D)
+    {a : ℂ} (ha : a ∈ D) : 𝓝 (f a) ≤ map f (𝓝 a) :=
+  ((hf.analyticAt (hD.mem_nhds ha)).eventually_constant_or_nhds_le_map_nhds).resolve_left
+    (univalent_not_eventually_constant hD hi ha)
+
+lemma univalent_inverse_continuousAt {D : Set ℂ} {f : ℂ → ℂ}
+    (hD : IsOpen D) (hf : DifferentiableOn ℂ f D) (hi : InjOn f D)
+    {a : ℂ} (ha : a ∈ D) : ContinuousAt (invFunOn f D) (f a) := by
+  have hleft : (invFunOn f D ∘ f) =ᶠ[𝓝 a] id := by
+    filter_upwards [hD.mem_nhds ha] with z hz
+    exact hi.leftInvOn_invFunOn hz
+  change map (invFunOn f D) (𝓝 (f a)) ≤ 𝓝 (invFunOn f D (f a))
+  rw [hi.leftInvOn_invFunOn ha]
+  calc
+    map (invFunOn f D) (𝓝 (f a)) ≤ map (invFunOn f D) (map f (𝓝 a)) :=
+      Filter.map_mono (univalent_nhds_le_map hD hf hi ha)
+    _ = 𝓝 a := by rw [Filter.map_map,Filter.map_congr hleft,Filter.map_id]
+
+lemma univalent_deriv_eventually_ne {D : Set ℂ} {f : ℂ → ℂ}
+    (hD : IsOpen D) (hf : DifferentiableOn ℂ f D) (hi : InjOn f D)
+    {a : ℂ} (ha : a ∈ D) : ∀ᶠ z in 𝓝[≠] a, deriv f z≠0 := by
+  have han := hf.analyticAt (hD.mem_nhds ha)
+  apply (han.deriv.eventually_eq_or_eventually_ne analyticAt_const).resolve_left
+  intro hz
+  obtain ⟨r,hr,hball⟩ := Metric.nhds_basis_ball.mem_iff.mp (hz.and (hD.mem_nhds ha))
+  have hbD : ball a r ⊆ D := fun z hz => (hball hz).2
+  have he : ∀ᶠ z in 𝓝 a, f z=f a := by
+    filter_upwards [ball_mem_nhds a hr] with z hz
+    exact isOpen_ball.is_const_of_deriv_eq_zero (convex_ball a r).isPreconnected
+      (hf.mono hbD) (fun w hw => (hball hw).1) hz (mem_ball_self hr)
+  exact univalent_not_eventually_constant hD hi ha he
+
+lemma univalent_inverse_analyticAt {D : Set ℂ} {f : ℂ → ℂ}
+    (hD : IsOpen D) (hf : DifferentiableOn ℂ f D) (hi : InjOn f D)
+    {a : ℂ} (ha : a ∈ D) : AnalyticAt ℂ (invFunOn f D) (f a) := by
+  have hc := univalent_inverse_continuousAt hD hf hi ha
+  apply Complex.analyticAt_of_differentiable_on_punctured_nhds_of_continuousAt _ hc
+  have hne : ∀ᶠ z in 𝓝 a, z≠a → deriv f z≠0 :=
+    eventually_nhdsWithin_iff.mp (univalent_deriv_eventually_ne hD hf hi ha)
+  have hpre : ∀ᶠ w in 𝓝 (f a), invFunOn f D w ≠ a → deriv f (invFunOn f D w) ≠ 0 := by
+    have hg : Tendsto (invFunOn f D) (𝓝 (f a)) (𝓝 a) := by
+      simpa only [hi.leftInvOn_invFunOn ha] using hc.tendsto
+    exact hg.eventually hne
+  have himage : f '' D ∈ 𝓝 (f a) :=
+    univalent_nhds_le_map hD hf hi ha (image_mem_map (hD.mem_nhds ha))
+  filter_upwards [hpre.filter_mono nhdsWithin_le_nhds,
+    (show ∀ᶠ w in 𝓝 (f a), w ∈ f '' D from himage).filter_mono nhdsWithin_le_nhds,
+    (show ∀ᶠ w in 𝓝[≠] (f a), w≠f a from self_mem_nhdsWithin)] with w hn hw hwa
+  have hzD := (surjOn_image f D).mapsTo_invFunOn hw
+  have hright := (surjOn_image f D).rightInvOn_invFunOn hw
+  have hz : invFunOn f D w≠a := by
+    intro h
+    exact hwa (hright.symm.trans (congrArg f h))
+  have hleft : ∀ᶠ z in 𝓝 (invFunOn f D w), invFunOn f D (f z)=z := by
+    filter_upwards [hD.mem_nhds hzD] with z hz
+    exact hi.leftInvOn_invFunOn hz
+  have hd := (hf.analyticAt (hD.mem_nhds hzD)).hasStrictDerivAt.to_local_left_inverse
+    (g := invFunOn f D) (hn hz) hleft
+  rw [hright] at hd
+  exact hd.hasDerivAt.differentiableAt
+
+lemma univalent_deriv_ne_zero {D : Set ℂ} {f : ℂ → ℂ}
+    (hD : IsOpen D) (hf : DifferentiableOn ℂ f D) (hi : InjOn f D)
+    {a : ℂ} (ha : a ∈ D) : deriv f a≠0 := by
+  have hg := (univalent_inverse_analyticAt hD hf hi ha).differentiableAt.hasDerivAt
+  have h := hg.comp a (hf.differentiableAt (hD.mem_nhds ha)).hasDerivAt
+  have he : (invFunOn f D ∘ f) =ᶠ[𝓝 a] id := by
+    filter_upwards [hD.mem_nhds ha] with z hz
+    exact hi.leftInvOn_invFunOn hz
+  have hid := (he.hasDerivAt_iff).mp h
+  have hone := hid.unique (hasDerivAt_id a)
+  intro hz
+  exact zero_ne_one (by simpa only [hz,mul_zero] using hone)
+
+end SLEExactGauge
+
+end
+
+end OAI
diff --git a/lean/OAI/Probability/SLE/Loewner/UnivalentKoebeTransform.lean b/lean/OAI/Probability/SLE/Loewner/UnivalentKoebeTransform.lean
new file mode 100644
index 0000000000000000000000000000000000000000..4070126913ad19989ab70d8e3794ed19842da41d
--- /dev/null
+++ b/lean/OAI/Probability/SLE/Loewner/UnivalentKoebeTransform.lean
@@ -0,0 +1,89 @@
+import OAI.Probability.SLE.Geometry.DiskRecentering
+import OAI.Probability.SLE.Loewner.UnivalentOddRoot
+
+namespace OAI
+
+/-! The exact second-derivative calculation for disk recentering.
+A bound on the second coefficient of normalized univalent functions
+therefore controls their logarithmic derivative throughout the disk. -/
+noncomputable section
+open Set Filter Metric Function
+open scoped Topology
+
+namespace SLEExactGauge
+
+lemma diskRecenter_second_deriv_zero {a : ℂ} (ha : ‖a‖<1) :
+    HasDerivAt (deriv (diskRecenter a)) (-2*star a*(1-star a*a)) 0 := by
+  let D (z : ℂ) := (1-star a*a)/(1+star a*z)^2
+  have hd : HasDerivAt D (-2*star a*(1-star a*a)) 0 := by
+    have hh := (hasDerivAt_const (0:ℂ) (1-star a*a)).div
+      ((((hasDerivAt_id (0:ℂ)).const_mul (star a)).const_add 1).pow 2)
+      (by simp : (1+star a*(0:ℂ))^2≠0)
+    change HasDerivAt D _ 0 at hh
+    convert hh using 1
+    simp
+    ring
+  apply hd.congr_of_eventuallyEq
+  filter_upwards [ball_mem_nhds (0:ℂ) zero_lt_one] with z hz
+  exact (diskRecenter_hasDerivAt ha (mem_ball_zero_iff.mp hz)).deriv
+
+lemma deriv_comp_diskRecenter_zero {f : ℂ → ℂ}
+    (hf : DifferentiableOn ℂ f (ball 0 1)) {a : ℂ} (ha : ‖a‖<1) :
+    deriv (f ∘ diskRecenter a) 0=deriv f a*(1-star a*a) := by
+  have hfa := hf.differentiableAt (isOpen_ball.mem_nhds (mem_ball_zero_iff.mpr ha))
+  have hfa' : HasDerivAt f (deriv f a) (diskRecenter a 0) := by simpa using hfa.hasDerivAt
+  have hd := hfa'.comp 0 (diskRecenter_hasDerivAt ha (by simp))
+  simpa using hd.deriv
+
+lemma second_deriv_comp_diskRecenter_zero {f : ℂ → ℂ}
+    (hf : DifferentiableOn ℂ f (ball 0 1)) {a : ℂ} (ha : ‖a‖<1) :
+    deriv (deriv (f ∘ diskRecenter a)) 0 =
+      deriv (deriv f) a*(1-star a*a)^2-2*star a*deriv f a*(1-star a*a) := by
+  have hfa := hf.analyticAt (isOpen_ball.mem_nhds (mem_ball_zero_iff.mpr ha))
+  have hDfa : HasDerivAt (deriv f) (deriv (deriv f) a) (diskRecenter a 0) := by
+    simpa using hfa.deriv.differentiableAt.hasDerivAt
+  have hφ := diskRecenter_hasDerivAt ha (by simp : ‖(0:ℂ)‖<1)
+  have hleft : HasDerivAt (deriv f ∘ diskRecenter a)
+      (deriv (deriv f) a*(1-star a*a)) 0 := by
+    simpa using hDfa.comp 0 hφ
+  have hprod := hleft.mul (diskRecenter_second_deriv_zero ha)
+  have hg : HasDerivAt (deriv (f ∘ diskRecenter a))
+      (deriv (deriv f) a*(1-star a*a)*deriv (diskRecenter a) 0+
+       deriv f (diskRecenter a 0)*(-2*star a*(1-star a*a))) 0 := by
+    apply hprod.congr_of_eventuallyEq
+    filter_upwards [ball_mem_nhds (0:ℂ) zero_lt_one] with z hz
+    exact (deriv_comp z (hf.differentiableAt (isOpen_ball.mem_nhds (diskRecenter_maps ha hz)))
+      (diskRecenter_hasDerivAt ha (mem_ball_zero_iff.mp hz)).differentiableAt)
+  rw [hg.deriv]
+  rw [(diskRecenter_hasDerivAt ha (by simp : ‖(0:ℂ)‖<1)).deriv]
+  simp only [diskRecenter_zero,mul_zero,add_zero,one_pow,div_one]
+  ring
+
+lemma univalent_preSchwarzian_of_second_derivative
+    (hsecond : ∀ f : ℂ → ℂ, DifferentiableOn ℂ f (ball 0 1) →
+      InjOn f (ball 0 1) → ‖deriv (deriv f) 0‖≤4*‖deriv f 0‖)
+    {f : ℂ → ℂ} (hf : DifferentiableOn ℂ f (ball 0 1))
+    (hi : InjOn f (ball 0 1)) {a : ℂ} (ha : ‖a‖<1) :
+    ‖((1-‖a‖^2:ℝ):ℂ)*deriv (deriv f) a/deriv f a-2*star a‖≤4 := by
+  let d : ℝ := 1-‖a‖^2
+  have hd : 0<d := (diskRecenter_det ha).2
+  have hfa : deriv f a≠0 := univalent_deriv_ne_zero isOpen_ball hf hi (mem_ball_zero_iff.mpr ha)
+  have hpos : 0<d*‖deriv f a‖ := mul_pos hd (norm_pos_iff.mpr hfa)
+  have hb := hsecond (f ∘ diskRecenter a)
+    (hf.comp (diskRecenter_differentiable ha) (diskRecenter_maps ha))
+    (hi.comp (diskRecenter_injOn ha) (diskRecenter_maps ha))
+  rw [second_deriv_comp_diskRecenter_zero hf ha,deriv_comp_diskRecenter_zero hf ha,
+    (diskRecenter_det ha).1] at hb
+  have he : deriv (deriv f) a*(d:ℂ)^2-2*star a*deriv f a*(d:ℂ)=
+      ((d:ℂ)*deriv f a)*((d:ℂ)*deriv (deriv f) a/deriv f a-2*star a) := by
+    field_simp
+  change ‖deriv (deriv f) a*(d:ℂ)^2-2*star a*deriv f a*(d:ℂ)‖≤4*‖deriv f a*(d:ℂ)‖ at hb
+  rw [he,norm_mul,norm_mul,norm_mul,Complex.norm_of_nonneg hd.le] at hb
+  apply (mul_le_mul_iff_right₀ hpos).mp
+  nlinarith [hb]
+
+end SLEExactGauge
+
+end
+
+end OAI
diff --git a/lean/OAI/Probability/SLE/Loewner/UnivalentLocalBound.lean b/lean/OAI/Probability/SLE/Loewner/UnivalentLocalBound.lean
new file mode 100644
index 0000000000000000000000000000000000000000..65469ae62fe0fe215928a3477e5514d0f70fa1d7
--- /dev/null
+++ b/lean/OAI/Probability/SLE/Loewner/UnivalentLocalBound.lean
@@ -0,0 +1,77 @@
+import OAI.Probability.SLE.Loewner.UnivalentInverseAnalytic
+import OAI.Probability.SLE.AngularLaws
+
+namespace OAI
+
+/-! A coarse local growth bound from the proved Bloch omitted-value
+estimate. This bound does not use the sharp disk growth input. -/
+noncomputable section
+open Set Filter Metric Function
+open scoped Topology
+
+namespace SLEExactGauge
+
+lemma univalent_inverse_derivative_product {D : Set ℂ} {f : ℂ → ℂ}
+    (hD : IsOpen D) (hf : DifferentiableOn ℂ f D) (hi : InjOn f D)
+    {a : ℂ} (ha : a∈D) : deriv (invFunOn f D) (f a)*deriv f a=1 := by
+  have hg := (univalent_inverse_analyticAt hD hf hi ha).differentiableAt.hasDerivAt
+  have h := hg.comp a (hf.differentiableAt (hD.mem_nhds ha)).hasDerivAt
+  have he : (invFunOn f D ∘ f) =ᶠ[𝓝 a] id := by
+    filter_upwards [hD.mem_nhds ha] with z hz
+    exact hi.leftInvOn_invFunOn hz
+  exact (he.hasDerivAt_iff.mp h).unique (hasDerivAt_id a)
+
+lemma univalent_coarse_ball_subset_image {f : ℂ → ℂ} {a : ℂ} {r : ℝ}
+    (hr : 0<r) (hf : DifferentiableOn ℂ f (ball a r)) (hi : InjOn f (ball a r)) :
+    ball (f a) (r*‖deriv f a‖/(128*Real.pi)) ⊆ f '' ball a r := by
+  intro w hw
+  by_contra hn
+  have h := univalent_omitted_value_bound_ball hr hf hi w hn
+  have hC : 0<128*Real.pi := by positivity
+  have hd : ‖f a-w‖<r*‖deriv f a‖/(128*Real.pi) := by
+    simpa only [mem_ball,dist_eq_norm,norm_sub_rev] using hw
+  have hmul := (lt_div_iff₀ hC).mp hd
+  nlinarith
+
+lemma univalent_coarse_local_bound {f : ℂ → ℂ} {a w : ℂ} {r : ℝ}
+    (hr : 0<r) (hf : DifferentiableOn ℂ f (ball a r)) (hi : InjOn f (ball a r))
+    (hw : w∈ball a (r/(128*Real.pi)^2)) :
+    ‖f w-f a‖<r*‖deriv f a‖/(128*Real.pi) := by
+  let C : ℝ := 128*Real.pi
+  have hC : 0<C := by dsimp [C]; positivity
+  have ha : a∈ball a r := mem_ball_self hr
+  have hfa : 0<‖deriv f a‖ := norm_pos_iff.mpr (univalent_deriv_ne_zero isOpen_ball hf hi ha)
+  let R : ℝ := r*‖deriv f a‖/C
+  have hR : 0<R := div_pos (mul_pos hr hfa) hC
+  let g := invFunOn f (ball a r)
+  have hcover : ball (f a) R ⊆ f '' ball a r := univalent_coarse_ball_subset_image hr hf hi
+  have hgd : DifferentiableOn ℂ g (ball (f a) R) := by
+    intro y hy
+    obtain ⟨z,hz,rfl⟩ := hcover hy
+    exact (univalent_inverse_analyticAt isOpen_ball hf hi hz).differentiableAt.differentiableWithinAt
+  have hgi : InjOn g (ball (f a) R) := (invFunOn_injOn_image f (ball a r)).mono hcover
+  have hbase : g (f a)=a := hi.leftInvOn_invFunOn ha
+  have hprod : ‖deriv g (f a)‖*‖deriv f a‖=1 := by
+    simpa only [norm_mul,norm_one] using congrArg norm
+      (univalent_inverse_derivative_product isOpen_ball hf hi ha)
+  have hrad : R*‖deriv g (f a)‖/C=r/C^2 := by
+    dsimp [R]
+    calc
+      r*‖deriv f a‖/C*‖deriv g (f a)‖/C =
+          r/C^2*(‖deriv g (f a)‖*‖deriv f a‖) := by ring
+      _ = r/C^2 := by rw [hprod,mul_one]
+  have hsmall : w∈ball (g (f a)) (R*‖deriv g (f a)‖/C) := by
+    rw [hbase,hrad]
+    exact hw
+  obtain ⟨v,hv,hvw⟩ := univalent_coarse_ball_subset_image hR hgd hgi hsmall
+  have hright := (surjOn_image f (ball a r)).rightInvOn_invFunOn (hcover hv)
+  change f (g v)=v at hright
+  rw [hvw] at hright
+  rw [hright]
+  simpa only [mem_ball,dist_eq_norm] using hv
+
+end SLEExactGauge
+
+end
+
+end OAI
diff --git a/lean/OAI/Probability/SLE/Loewner/UnivalentLocallyUniformLimit.lean b/lean/OAI/Probability/SLE/Loewner/UnivalentLocallyUniformLimit.lean
new file mode 100644
index 0000000000000000000000000000000000000000..a0fdf1d8cdc5df6d8b008334edcb92efaf93a751
--- /dev/null
+++ b/lean/OAI/Probability/SLE/Loewner/UnivalentLocallyUniformLimit.lean
@@ -0,0 +1,93 @@
+import OAI.Probability.SLE.Loewner.UnivalentInverseAnalytic
+
+namespace OAI
+
+/-! A nonconstant locally uniform limit of injective holomorphic maps is
+injective. Boundary separation and the minimum principle provide the
+local preimages needed for the proof. -/
+noncomputable section
+open Set Filter Metric Function
+open scoped Topology
+
+namespace SLEExactGauge
+
+lemma isolated_level_closedBall {D : Set ℂ} {f : ℂ → ℂ}
+    (hD : IsOpen D) (hconn : IsPreconnected D) (hf : DifferentiableOn ℂ f D)
+    (hnon : ¬∃ c, ∀ z∈D, f z=c) {a b : ℂ} (ha : a∈D) (hab : a≠b) :
+    ∃ r>0, closedBall a r ⊆ D ∧ b∉closedBall a r ∧
+      ∀ z∈sphere a r, f z≠f a := by
+  have hn : ¬∀ᶠ z in 𝓝 a, f z=f a := by
+    intro h
+    exact hnon ⟨f a,fun z hz => (hf.analyticOnNhd hD).eqOn_of_preconnected_of_eventuallyEq
+      analyticOnNhd_const hconn ha h hz⟩
+  have hne := ((hf.analyticAt (hD.mem_nhds ha)).eventually_eq_or_eventually_ne
+    analyticAt_const).resolve_left hn
+  have hh : ∀ᶠ z in 𝓝 a, z∈D ∧ z≠b ∧ (z≠a → f z≠f a) := by
+    filter_upwards [hD.mem_nhds ha,isOpen_ne.mem_nhds hab,
+      eventually_nhdsWithin_iff.mp hne] with z hz hzb hza
+    exact ⟨hz,hzb,hza⟩
+  obtain ⟨r,hr,hball⟩ := Metric.nhds_basis_closedBall.mem_iff.mp hh
+  refine ⟨r,hr,fun z hz => (hball hz).1,?_,?_⟩
+  · intro hb
+    exact (hball hb).2.1 rfl
+  · intro z hz
+    exact (hball (sphere_subset_closedBall hz)).2.2 (ne_of_mem_sphere hz hr.ne')
+
+lemma tendstoLocallyUniformlyOn_injOn
+    {D : Set ℂ} {F : ℕ → ℂ → ℂ} {f : ℂ → ℂ}
+    (hD : IsOpen D) (hconn : IsPreconnected D)
+    (hF : ∀ n, DifferentiableOn ℂ (F n) D) (hi : ∀ n, InjOn (F n) D)
+    (hlim : TendstoLocallyUniformlyOn F f atTop D)
+    (hnon : ¬∃ c, ∀ z∈D, f z=c) : InjOn f D := by
+  have hf := hlim.differentiableOn (Eventually.of_forall hF) hD
+  intro a ha b hb he
+  by_contra hab
+  obtain ⟨r,hr,hKD,hbK,hsep⟩ := isolated_level_closedBall hD hconn hf hnon ha hab
+  have hc : ContinuousOn (fun z => ‖f z-f a‖) (sphere a r) :=
+    ((hf.continuousOn.mono (sphere_subset_closedBall.trans hKD)).sub continuousOn_const).norm
+  obtain ⟨w,hw,hmin⟩ := (isCompact_sphere a r).exists_isMinOn
+    (NormedSpace.sphere_nonempty.mpr hr.le) hc
+  let δ : ℝ := ‖f w-f a‖
+  have hδ : 0<δ := norm_pos_iff.mpr (sub_ne_zero.mpr (hsep w hw))
+  have hlower (z : ℂ) (hz : z∈sphere a r) : δ≤‖f z-f a‖ := hmin hz
+  have hu := (tendstoLocallyUniformlyOn_iff_forall_isCompact hD).mp hlim
+    (closedBall a r) hKD (isCompact_closedBall a r)
+  have hε : 0<δ/8 := by positivity
+  have hk := (Metric.tendstoUniformlyOn_iff.mp hu) (δ/8) hε
+  have hbb := (Metric.tendsto_nhds.mp (hlim.tendsto_at hb)) (δ/8) hε
+  obtain ⟨n,hkn,hbn⟩ := (hk.and hbb).exists
+  have hnear (z : ℂ) (hz : z∈closedBall a r) : ‖F n z-f z‖<δ/8 := by
+    simpa only [dist_eq_norm,norm_sub_rev] using hkn z hz
+  have hnearB : ‖F n b-f b‖<δ/8 := by
+    simpa only [dist_eq_norm,norm_sub_rev] using hbn
+  have hnearA := hnear a (mem_closedBall_self hr.le)
+  have hboundary (z : ℂ) (hz : z∈sphere a r) : δ/2≤‖F n z-F n a‖ := by
+    have htri : ‖f z-f a‖ ≤ ‖f z-F n z‖+‖F n z-F n a‖+‖F n a-f a‖ := by
+      calc
+        _ = ‖(f z-F n z)+(F n z-F n a)+(F n a-f a)‖ := by congr 1; ring
+        _ ≤ _ := (norm_add_le _ _).trans (add_le_add (norm_add_le _ _) le_rfl)
+    rw [norm_sub_rev (f z) (F n z)] at htri
+    have hznear := hnear z (sphere_subset_closedBall hz)
+    linarith [hlower z hz]
+  have hsmall : F n b∈ball (F n a) ((δ/2)/2) := by
+    rw [mem_ball,dist_eq_norm]
+    have htri : ‖F n b-F n a‖≤‖F n b-f b‖+‖F n a-f a‖ := by
+      rw [he]
+      have h := norm_sub_le_norm_sub_add_norm_sub (F n b) (f b) (F n a)
+      simpa only [norm_sub_rev (f b) (F n a)] using h
+    linarith
+  have hdc : DiffContOnCl ℂ (F n) (ball a r) :=
+    ⟨(hF n).mono (ball_subset_closedBall.trans hKD),by
+      rw [closure_ball a hr.ne']
+      exact (hF n).continuousOn.mono hKD⟩
+  have hnot : ∃ᶠ z in 𝓝 a, F n z≠F n a :=
+    not_eventually.mp (univalent_not_eventually_constant hD (hi n) ha)
+  obtain ⟨z,hz,heq⟩ := hdc.ball_subset_image_closedBall hr hboundary hnot hsmall
+  have hzb : z=b := hi n (hKD hz) hb heq
+  exact hbK (hzb ▸ hz)
+
+end SLEExactGauge
+
+end
+
+end OAI
diff --git a/lean/OAI/Probability/SLE/Loewner/UnivalentMovingNormalization.lean b/lean/OAI/Probability/SLE/Loewner/UnivalentMovingNormalization.lean
new file mode 100644
index 0000000000000000000000000000000000000000..e6f4aacb68947a73110af661e242efb00e25a951
--- /dev/null
+++ b/lean/OAI/Probability/SLE/Loewner/UnivalentMovingNormalization.lean
@@ -0,0 +1,72 @@
+import OAI.Probability.SLE.Loewner.UnivalentFamilyPropagation
+
+namespace OAI
+
+/-! Moving normalizations in a compact subset of the half-plane give a
+ locally bounded subsequence, using the coarse Bloch estimate. -/
+noncomputable section
+open Set Filter Metric Function
+open scoped Topology
+
+namespace SLEExactGauge
+
+lemma univalent_moving_normalization_subsequence
+    (f : ℕ → ℂ → ℂ) (z : ℕ → ℂ) (s M : ℝ) (hs : 0<s)
+    (hf : ∀ n, DifferentiableOn ℂ (f n) upperHalfPlane)
+    (hi : ∀ n, InjOn (f n) upperHalfPlane)
+    (hz : ∀ n, ‖z n‖=1 ∧ s≤(z n).im)
+    (hv : ∀ n, ‖f n (z n)‖≤M)
+    (hd : ∀ n, ‖deriv (f n) (z n)‖≤M) :
+    ∃ σ : ℕ → ℕ, StrictMono σ ∧
+      ∀ K : Set ℂ, IsCompact K → K⊆upperHalfPlane →
+        ∃ C : ℝ, ∀ n, ∀ w∈K, ‖f (σ n) w‖≤C := by
+  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 ⟨a,ha,φ,hφ,hlim⟩ := hK.tendsto_subseq hzK
+  let R := s/2
+  let ρ := R/(128*Real.pi)^2
+  have hR : 0<R := half_pos hs
+  have hρ : 0<ρ := div_pos hR (by positivity)
+  obtain ⟨N,hN⟩ := Metric.tendsto_atTop.mp hlim (ρ/2) (by positivity)
+  let σ : ℕ → ℕ := fun n => φ (n+N)
+  have hσ : StrictMono σ := hφ.comp (strictMono_id.add_const N)
+  have hball (n : ℕ) : ball (z (σ n)) R ⊆ upperHalfPlane := by
+    intro w hw
+    have him := Complex.abs_im_le_norm (w-z (σ n))
+    have hdw : ‖w-z (σ n)‖<R := by simpa only [mem_ball,dist_eq_norm] using hw
+    rw [Complex.sub_im] at him
+    have hlower := (abs_lt.mp (him.trans_lt hdw)).1
+    have := (hz (σ n)).2
+    change 0<w.im
+    dsimp [R] at *
+    linarith
+  have hseed : (upperHalfPlane ∩ familyBoundedLocus (fun n => f (σ n))).Nonempty := by
+    refine ⟨a,hKH ha,ρ/2,by positivity,R*M/(128*Real.pi)+M,?_⟩
+    intro n w hw
+    have hcenter : dist a (z (σ n))<ρ/2 := by
+      simpa only [Function.comp_apply,dist_comm] using hN (n+N) (Nat.le_add_left N n)
+    have hnear : w∈ball (z (σ n)) ρ := by
+      rw [mem_ball] at hw ⊢
+      have := dist_triangle w a (z (σ n))
+      linarith
+    have hg := univalent_coarse_local_bound hR ((hf (σ n)).mono (hball n))
+      ((hi (σ n)).mono (hball n)) hnear
+    calc
+      ‖f (σ n) w‖ ≤ ‖f (σ n) w-f (σ n) (z (σ n))‖+‖f (σ n) (z (σ n))‖ :=
+        norm_le_norm_sub_add _ _
+      _ ≤ R*‖deriv (f (σ n)) (z (σ n))‖/(128*Real.pi)+M := add_le_add hg.le (hv (σ n))
+      _ ≤ R*M/(128*Real.pi)+M := by gcongr; exact hd (σ n)
+  have hb := univalent_family_bound_propagates (fun n => f (σ n))
+    (fun n => hf (σ n)) (fun n => hi (σ n)) hseed
+  refine ⟨σ,hσ,fun L hL hLH => ?_⟩
+  exact familyBoundedLocus_compact_bound _ hL (hLH.trans hb)
+
+end SLEExactGauge
+
+end
+
+end OAI
diff --git a/lean/OAI/Probability/SLE/Loewner/UnivalentOddRoot.lean b/lean/OAI/Probability/SLE/Loewner/UnivalentOddRoot.lean
new file mode 100644
index 0000000000000000000000000000000000000000..b989f729adaad9be2f6b2dbcffcd1f211b5b772d
--- /dev/null
+++ b/lean/OAI/Probability/SLE/Loewner/UnivalentOddRoot.lean
@@ -0,0 +1,121 @@
+import OAI.Probability.SLE.Loewner.UnivalentInverseAnalytic
+import Mathlib.Analysis.Complex.BranchLogRoot
+import Mathlib.Analysis.Convex.Contractible
+
+namespace OAI
+
+/-! The normalized odd square-root transform used in the sharp disk
+growth argument. The square root is constructed, not assumed. -/
+noncomputable section
+open Set Filter Metric Function
+open scoped Topology
+
+namespace SLEExactGauge
+
+lemma hasDerivAt_of_continuous_square_root {g q : ℂ → ℂ} {a d : ℂ}
+    (hg : HasDerivAt g d a) (hq : ContinuousAt q a) (hqa : q a≠0)
+    (he : ∀ᶠ z in 𝓝 a, q z^2=g z) :
+    HasDerivAt q (d/(2*q a)) a := by
+  have hea : q a^2=g a := he.self_of_nhds
+  have hn : q a+q a≠0 := by simpa only [←two_mul] using mul_ne_zero (by norm_num) hqa
+  have hsum : Tendsto (fun z => q z+q a) (𝓝[≠] a) (𝓝 (q a+q a)) :=
+    (hq.add_const (q a)).tendsto.mono_left nhdsWithin_le_nhds
+  have ht := hg.tendsto_slope.div hsum hn
+  have heq : (fun z => slope g a z/(q z+q a)) =ᶠ[𝓝[≠] a] slope q a := by
+    filter_upwards [he.filter_mono nhdsWithin_le_nhds,
+      ((hq.add_const (q a)).eventually_ne hn).filter_mono nhdsWithin_le_nhds,
+      self_mem_nhdsWithin] with z hz hsum hza
+    simp only [slope_def_field,←hz,←hea]
+    field_simp
+    ring
+  apply hasDerivAt_iff_tendsto_slope.mpr
+  simpa only [←two_mul] using ht.congr' heq
+
+lemma differentiableOn_continuous_square_root {D : Set ℂ} (hD : IsOpen D)
+    {g q : ℂ → ℂ} (hg : DifferentiableOn ℂ g D) (hq : ContinuousOn q D)
+    (he : ∀ z∈D, q z^2=g z) (hne : ∀ z∈D, g z≠0) :
+    DifferentiableOn ℂ q D := by
+  intro a ha
+  have hqa : q a≠0 := by intro h; apply hne a ha; rw [←he a ha,h,zero_pow (by norm_num)]
+  exact (hasDerivAt_of_continuous_square_root (hg.differentiableAt (hD.mem_nhds ha)).hasDerivAt
+    ((hq a ha).continuousAt (hD.mem_nhds ha)) hqa
+    (by filter_upwards [hD.mem_nhds ha] with z hz; exact he z hz)).differentiableAt.differentiableWithinAt
+
+lemma exists_normalized_analytic_square_root {g : ℂ → ℂ}
+    (hg : DifferentiableOn ℂ g (ball 0 1)) (hne : ∀ z∈ball (0:ℂ) 1, g z≠0)
+    (h0 : g 0=1) :
+    ∃ q : ℂ → ℂ, DifferentiableOn ℂ q (ball 0 1) ∧ q 0=1 ∧
+      ∀ z∈ball (0:ℂ) 1, q z^2=g z := by
+  have hb : (ball (0:ℂ) 1).Nonempty := ⟨0,mem_ball_self zero_lt_one⟩
+  have hcontract : ContractibleSpace ↥(ball (0:ℂ) 1) :=
+    (convex_ball (0:ℂ) 1).contractibleSpace hb
+  have hsimply : IsSimplyConnected (ball (0:ℂ) 1) := by
+    change SimplyConnectedSpace ↥(ball (0:ℂ) 1)
+    infer_instance
+  obtain ⟨s,hsc,hs⟩ := Complex.exists_continuousOn_pow_eq hsimply isOpen_ball hg.continuousOn
+    (by rintro ⟨z,hz,hze⟩; exact hne z hz hze) (n := 2) (by norm_num)
+  have hsD := differentiableOn_continuous_square_root isOpen_ball hg hsc (fun z _ => hs z) hne
+  have hs0 : s 0^2=1 := (hs 0).trans h0
+  refine ⟨fun z => s z*s 0,hsD.mul_const _,by simpa only [pow_two] using hs0,?_⟩
+  intro z hz
+  rw [mul_pow,hs z,hs0,mul_one]
+
+/-- Every normalized disk-univalent map has a normalized odd univalent
+square-root transform on the same disk. -/
+theorem univalent_odd_square_root {f : ℂ → ℂ}
+    (hf : DifferentiableOn ℂ f (ball 0 1)) (hi : InjOn f (ball 0 1))
+    (hf0 : f 0=0) (hd0 : deriv f 0=1) :
+    ∃ h : ℂ → ℂ, DifferentiableOn ℂ h (ball 0 1) ∧ InjOn h (ball 0 1) ∧
+      h 0=0 ∧ deriv h 0=1 ∧
+      (∀ z∈ball (0:ℂ) 1, h z^2=f (z^2)) ∧ (∀ z, h (-z)= -h z) := by
+  have hzero : (0:ℂ)∈ball 0 1 := mem_ball_self zero_lt_one
+  let g := dslope f 0
+  have hg : DifferentiableOn ℂ g (ball 0 1) :=
+    (Complex.differentiableOn_dslope (ball_mem_nhds (0:ℂ) zero_lt_one)).mpr hf
+  have hg0 : g 0=1 := by simpa [g] using hd0
+  have hgne (z : ℂ) (hz : z∈ball (0:ℂ) 1) : g z≠0 := by
+    by_cases hz0 : z=0
+    · simpa only [hz0,hg0] using one_ne_zero
+    · dsimp only [g]
+      rw [dslope_of_ne _ hz0,slope_def_field,hf0,sub_zero,sub_zero]
+      exact div_ne_zero (fun h => hz0 (hi hz hzero (h.trans hf0.symm))) hz0
+  obtain ⟨q,hq,hq0,hq2⟩ := exists_normalized_analytic_square_root hg hgne hg0
+  let h (z : ℂ) := z*q (z^2)
+  have hsq (z : ℂ) (hz : z∈ball (0:ℂ) 1) : z^2∈ball (0:ℂ) 1 := by
+    rw [mem_ball,dist_zero_right,norm_pow]
+    exact pow_lt_one₀ (norm_nonneg z) (by simpa using hz) (by norm_num)
+  have hh : DifferentiableOn ℂ h (ball 0 1) :=
+    differentiableOn_id.mul (hq.comp (differentiable_id.pow 2).differentiableOn hsq)
+  have hh0 : h 0=0 := by simp [h]
+  have hhD : deriv h 0=1 := by
+    have hdq := ((hq.differentiableAt (isOpen_ball.mem_nhds (hsq 0 hzero))).hasDerivAt).comp 0
+      (hasDerivAt_pow 2 (0:ℂ))
+    have hd := (hasDerivAt_id (0:ℂ)).mul hdq
+    change HasDerivAt h _ 0 at hd
+    simpa [hq0] using hd.deriv
+  have hh2 (z : ℂ) (hz : z∈ball (0:ℂ) 1) : h z^2=f (z^2) := by
+    dsimp only [h]
+    rw [mul_pow,hq2 _ (hsq z hz)]
+    have he := sub_smul_dslope f 0 (z^2)
+    simpa only [sub_zero,hf0,smul_eq_mul] using he
+  have hodd (z : ℂ) : h (-z)= -h z := by simp [h]
+  refine ⟨h,hh,?_,hh0,hhD,hh2,hodd⟩
+  intro z hz w hw he
+  have he2 : z^2=w^2 := hi (hsq z hz) (hsq w hw)
+    ((hh2 z hz).symm.trans ((congrArg (fun v : ℂ => v^2) he).trans (hh2 w hw)))
+  rcases (sq_eq_sq_iff_eq_or_eq_neg).mp he2 with hzw | hzw
+  · exact hzw
+  · have hhz : h z=0 := by
+      have he' : h z= -h z := he.trans (by rw [show w= -z by rw [hzw,neg_neg],hodd])
+      linear_combination (1/2:ℂ)*he'
+    have hz2 : z^2=0 := hi (hsq z hz) hzero (by rw [←hh2 z hz,hhz,hf0]; simp)
+    have hz0 : z=0 := (pow_eq_zero_iff (by norm_num : (2:ℕ)≠0)).mp hz2
+    rw [hz0] at hzw
+    rw [hz0]
+    simpa [eq_comm] using hzw
+
+end SLEExactGauge
+
+end
+
+end OAI
diff --git a/lean/OAI/Probability/SLE/Loewner/UnivalentRadialDerivative.lean b/lean/OAI/Probability/SLE/Loewner/UnivalentRadialDerivative.lean
new file mode 100644
index 0000000000000000000000000000000000000000..054f4ed45cd9430ab5e44c4c1d853047b9fcb4ac
--- /dev/null
+++ b/lean/OAI/Probability/SLE/Loewner/UnivalentRadialDerivative.lean
@@ -0,0 +1,127 @@
+import OAI.Probability.SLE.Loewner.UnivalentKoebeTransform
+import OAI.Probability.SLE.LoewnerCharts
+
+namespace OAI
+
+/-! Integrating the exact logarithmic-derivative inequality gives the
+sharp radial derivative majorant. -/
+noncomputable section
+open Set Filter Metric Function MeasureTheory
+open scoped Topology
+
+namespace SLEExactGauge
+
+lemma disk_logarithmic_derivative_re_bound {f : ℂ → ℂ}
+    (hpre : ∀ a : ℂ, ‖a‖<1 →
+      ‖((1-‖a‖^2:ℝ):ℂ)*deriv (deriv f) a/deriv f a-2*star a‖≤4)
+    (u : ℂ) (hu : ‖u‖=1) (t : ℝ) (ht : t∈Ico 0 1) :
+    (u*deriv (deriv f) ((t:ℂ)*u)/deriv f ((t:ℂ)*u)).re≤
+      3/(1-t)+1/(1+t) := by
+  have ha : ‖(t:ℂ)*u‖=t := by simp [hu,abs_of_nonneg ht.1]
+  have hd : 0<1-t^2 := by nlinarith [ht.1,ht.2]
+  have hunit : star u*u=1 := by
+    rw [Complex.star_def,Complex.conj_mul',hu]
+    norm_num
+  have hstarcast : star (t:ℂ)=(t:ℂ) := by apply Complex.ext <;> simp
+  have he :
+      (((1-t^2:ℝ):ℂ)*deriv (deriv f) ((t:ℂ)*u)/deriv f ((t:ℂ)*u)-2*star ((t:ℂ)*u))*u =
+      ((1-t^2:ℝ):ℂ)*(u*deriv (deriv f) ((t:ℂ)*u)/deriv f ((t:ℂ)*u))-((2*t:ℝ):ℂ) := by
+    calc
+      _ = ((1-t^2:ℝ):ℂ)*(u*deriv (deriv f) ((t:ℂ)*u)/deriv f ((t:ℂ)*u))-
+          2*(t:ℂ)*(star u*u) := by simp only [star_mul,hstarcast]; ring
+      _ = _ := by rw [hunit]; push_cast; ring
+  have hn := hpre ((t:ℂ)*u) (by rw [ha]; exact ht.2)
+  rw [ha] at hn
+  have hRe := (Complex.re_le_norm _).trans (show
+      ‖((((1-t^2:ℝ):ℂ)*deriv (deriv f) ((t:ℂ)*u)/deriv f ((t:ℂ)*u)-2*star ((t:ℂ)*u))*u)‖≤4 by
+    rw [norm_mul,hu,mul_one]; exact hn)
+  rw [he] at hRe
+  simp only [Complex.sub_re,Complex.mul_re,Complex.ofReal_re,Complex.ofReal_im,zero_mul,sub_zero] at hRe
+  have hb : (u*deriv (deriv f) ((t:ℂ)*u)/deriv f ((t:ℂ)*u)).re≤(4+2*t)/(1-t^2) :=
+    (le_div_iff₀ hd).mpr (by linarith)
+  have heq : (4+2*t)/(1-t^2)=3/(1-t)+1/(1+t) := by
+    have h1 : 1-t≠0 := by linarith [ht.2]
+    have h2 : 1+t≠0 := by linarith [ht.1]
+    field_simp
+    ring
+  exact hb.trans_eq heq
+
+lemma univalent_radial_derivative_bound {f : ℂ → ℂ}
+    (hf : DifferentiableOn ℂ f (ball 0 1)) (hi : InjOn f (ball 0 1))
+    (hpre : ∀ a : ℂ, ‖a‖<1 →
+      ‖((1-‖a‖^2:ℝ):ℂ)*deriv (deriv f) a/deriv f a-2*star a‖≤4)
+    (u : ℂ) (hu : ‖u‖=1) (r : ℝ) (hr : r∈Ico 0 1) :
+    ‖deriv f ((r:ℂ)*u)‖≤‖deriv f 0‖*(1+r)/(1-r)^3 := by
+  let y (t : ℝ) := deriv f ((t:ℂ)*u)
+  let c (t : ℝ) := u*deriv (deriv f) ((t:ℂ)*u)/y t
+  let q (t : ℝ) := 3/(1-t)+1/(1+t)
+  let Q (t : ℝ) := Real.log (1+t)-3*Real.log (1-t)
+  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 hr.2
+  have hyt (t : ℝ) (ht : t∈Icc 0 r) : y t≠0 :=
+    univalent_deriv_ne_zero isOpen_ball hf hi (hat t ht)
+  have hyd (t : ℝ) (ht : t∈Icc 0 r) :
+      HasDerivAt y (u*deriv (deriv f) ((t:ℂ)*u)) t := by
+    have ha := (hf.analyticAt (isOpen_ball.mem_nhds (hat t ht))).deriv
+    have hd := (ha.differentiableAt.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,y] using hd
+  have hyc : ContinuousOn y (Icc 0 r) := fun t ht => (hyd t ht).continuousAt.continuousWithinAt
+  have hcc : ContinuousOn c (Icc 0 r) := by
+    apply ContinuousOn.div ?_ hyc hyt
+    apply continuousOn_const.mul
+    intro t ht
+    have houter : ContinuousAt (deriv (deriv f)) ((t:ℂ)*u) :=
+      (hf.analyticAt (isOpen_ball.mem_nhds (hat t ht))).deriv.deriv.continuousAt
+    exact (ContinuousAt.comp (g := deriv (deriv f)) (f := fun s : ℝ => (s:ℂ)*u)
+      houter (by fun_prop)).continuousWithinAt
+  have hyode (t : ℝ) (ht : t∈Icc 0 r) : HasDerivWithinAt y (c t*y t) (Icc 0 r) t := by
+    have he : c t*y t=u*deriv (deriv f) ((t:ℂ)*u) := by dsimp only [c]; field_simp [hyt t ht]
+    rw [he]
+    exact (hyd t ht).hasDerivWithinAt
+  have hformula := complex_linear_ode_exp r hr.1 y c hcc hyode
+  have hqc : ContinuousOn q (Icc 0 r) := by
+    apply ContinuousOn.add
+    · exact continuousOn_const.div (by fun_prop) (fun t ht => by linarith [ht.2,hr.2])
+    · exact continuousOn_const.div (by fun_prop) (fun t ht => by linarith [ht.1])
+  have hQ (t : ℝ) (ht : t∈Icc 0 r) : HasDerivAt Q (q t) t := by
+    have hp : 1+t≠0 := by linarith [ht.1]
+    have hm : 1-t≠0 := by linarith [ht.2,hr.2]
+    have h := (((hasDerivAt_id t).const_add 1).log hp).sub
+      ((((hasDerivAt_id t).const_sub 1).log hm).const_mul 3)
+    change HasDerivAt Q _ t at h
+    convert h using 1
+    dsimp [q]
+    ring
+  have hQI : ∫ t in (0:ℝ)..r, q t=Q r := by
+    have h := intervalIntegral.integral_eq_sub_of_hasDerivAt (a := 0) (b := r)
+      (fun t ht => hQ t (by simpa only [uIcc_of_le hr.1] using ht)) (hqc.intervalIntegrable_of_Icc hr.1)
+    simpa [Q] using h
+  have hbound : (∫ t in (0:ℝ)..r, c t).re≤Q r := by
+    have hre : (∫ t in (0:ℝ)..r, c t).re=∫ t in (0:ℝ)..r, (c t).re :=
+      (Complex.reCLM.intervalIntegral_comp_comm (hcc.intervalIntegrable_of_Icc hr.1)).symm
+    rw [←hQI,hre]
+    apply intervalIntegral.integral_mono_on hr.1
+      ((Complex.continuous_re.comp_continuousOn hcc).intervalIntegrable_of_Icc hr.1) (hqc.intervalIntegrable_of_Icc hr.1)
+    intro t ht
+    exact disk_logarithmic_derivative_re_bound hpre u hu t ⟨ht.1,ht.2.trans_lt hr.2⟩
+  have hexp : Real.exp (Q r)=(1+r)/(1-r)^3 := by
+    have hp : 0<1+r := by linarith [hr.1]
+    have hm : 0<1-r := by linarith [hr.2]
+    dsimp [Q]
+    rw [Real.exp_sub,Real.exp_log hp,show 3*Real.log (1-r)=(3:ℕ)*Real.log (1-r) by norm_num,
+      Real.exp_nat_mul,Real.exp_log hm]
+  calc
+    ‖deriv f ((r:ℂ)*u)‖ = ‖y 0‖*Real.exp ((∫ t in (0:ℝ)..r, c t).re) := by
+      change ‖y r‖=_
+      rw [hformula,norm_mul,Complex.norm_exp]
+    _ ≤ ‖y 0‖*Real.exp (Q r) := mul_le_mul_of_nonneg_left (Real.exp_le_exp.mpr hbound) (norm_nonneg _)
+    _ = ‖deriv f 0‖*(1+r)/(1-r)^3 := by simp only [y,Complex.ofReal_zero,zero_mul]; rw [hexp]; ring
+
+end SLEExactGauge
+
+end
+
+end OAI
diff --git a/lean/OAI/Probability/SLE/Loewner/UnivalentRootFactor.lean b/lean/OAI/Probability/SLE/Loewner/UnivalentRootFactor.lean
new file mode 100644
index 0000000000000000000000000000000000000000..8c190e239c9ee5bd94967a0cb5ede6e45ab97c50
--- /dev/null
+++ b/lean/OAI/Probability/SLE/Loewner/UnivalentRootFactor.lean
@@ -0,0 +1,66 @@
+import OAI.Probability.SLE.Loewner.UnivalentOddRoot
+
+namespace OAI
+
+/-! The normalized odd-root construction with its analytic factor kept
+explicit for coefficient extraction. -/
+noncomputable section
+open Set Filter Metric Function
+open scoped Topology
+
+namespace SLEExactGauge
+
+lemma univalent_root_factor {f : ℂ → ℂ}
+    (hf : DifferentiableOn ℂ f (ball 0 1)) (hi : InjOn f (ball 0 1))
+    (hf0 : f 0=0) (hd0 : deriv f 0=1) :
+    ∃ q : ℂ → ℂ, DifferentiableOn ℂ q (ball 0 1) ∧ q 0=1 ∧
+      (∀ z∈ball (0:ℂ) 1, q z^2=dslope f 0 z) ∧
+      (∀ z∈ball (0:ℂ) 1, q z≠0) ∧
+      InjOn (fun z : ℂ => z*q (z^2)) (ball 0 1) := by
+  have hzero : (0:ℂ)∈ball 0 1 := mem_ball_self zero_lt_one
+  let g := dslope f 0
+  have hg : DifferentiableOn ℂ g (ball 0 1) :=
+    (Complex.differentiableOn_dslope (ball_mem_nhds (0:ℂ) zero_lt_one)).mpr hf
+  have hg0 : g 0=1 := by simpa [g] using hd0
+  have hgne (z : ℂ) (hz : z∈ball (0:ℂ) 1) : g z≠0 := by
+    by_cases hz0 : z=0
+    · simpa only [hz0,hg0] using one_ne_zero
+    · dsimp only [g]
+      rw [dslope_of_ne _ hz0,slope_def_field,hf0,sub_zero,sub_zero]
+      exact div_ne_zero (fun h => hz0 (hi hz hzero (h.trans hf0.symm))) hz0
+  obtain ⟨q,hq,hq0,hq2⟩ := exists_normalized_analytic_square_root hg hgne hg0
+  have hqne (z : ℂ) (hz : z∈ball (0:ℂ) 1) : q z≠0 := by
+    intro he
+    apply hgne z hz
+    rw [←hq2 z hz,he,zero_pow (by norm_num : (2:ℕ)≠0)]
+  refine ⟨q,hq,hq0,hq2,hqne,?_⟩
+  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 hh2 (z : ℂ) (hz : z∈ball (0:ℂ) 1) : h z^2=f (z^2) := by
+    dsimp only [h]
+    rw [mul_pow,hq2 _ (hs z hz)]
+    have he := sub_smul_dslope f 0 (z^2)
+    simpa only [sub_zero,hf0,smul_eq_mul] using he
+  have hodd (z : ℂ) : h (-z)= -h z := by simp [h]
+  intro z hz w hw he
+  change h z=h w at he
+  have he2 : z^2=w^2 := hi (hs z hz) (hs w hw)
+    ((hh2 z hz).symm.trans ((congrArg (fun v : ℂ => v^2) he).trans (hh2 w hw)))
+  rcases (sq_eq_sq_iff_eq_or_eq_neg).mp he2 with hzw | hzw
+  · exact hzw
+  · have hhz : h z=0 := by
+      have he' : h z= -h z := he.trans (by rw [show w= -z by rw [hzw,neg_neg],hodd])
+      linear_combination (1/2:ℂ)*he'
+    have hz2 : z^2=0 := hi (hs z hz) hzero (by rw [←hh2 z hz,hhz,hf0]; simp)
+    have hz0 : z=0 := (pow_eq_zero_iff (by norm_num : (2:ℕ)≠0)).mp hz2
+    rw [hz0] at hzw
+    rw [hz0]
+    simpa [eq_comm] using hzw
+
+end SLEExactGauge
+
+end
+
+end OAI
diff --git a/lean/OAI/Probability/SLE/Loewner/UnivalentSecondCoefficient.lean b/lean/OAI/Probability/SLE/Loewner/UnivalentSecondCoefficient.lean
new file mode 100644
index 0000000000000000000000000000000000000000..a6c50bc31ac4b121ff9987221d0b2a17c8a40ec5
--- /dev/null
+++ b/lean/OAI/Probability/SLE/Loewner/UnivalentSecondCoefficient.lean
@@ -0,0 +1,83 @@
+import OAI.Probability.SLE.Loewner.UnivalentRootFactor
+import OAI.Probability.SLE.Geometry.RootCoefficientBound
+
+namespace OAI
+
+/-! The sharp second-coefficient estimate for disk-univalent functions,
+obtained from the actual odd-root exterior map and its area inequality. -/
+noncomputable section
+open Set Filter Metric Function
+open scoped Topology
+
+namespace SLEExactGauge
+
+lemma second_derivative_eq_twice_dslope {f : ℂ → ℂ}
+    (hf : DifferentiableOn ℂ f (ball 0 1)) (hf0 : f 0=0) :
+    deriv (deriv f) 0=2*deriv (dslope f 0) 0 := by
+  let g := dslope f 0
+  have hg : DifferentiableOn ℂ g (ball 0 1) :=
+    (Complex.differentiableOn_dslope (ball_mem_nhds (0:ℂ) zero_lt_one)).mpr hf
+  have he (z : ℂ) : f z=z*g z := by
+    have h := sub_smul_dslope f 0 z
+    simpa only [sub_zero,hf0,smul_eq_mul] using h.symm
+  have hD : deriv f =ᶠ[𝓝 (0:ℂ)] (fun z => g z+z*deriv g z) := by
+    filter_upwards [ball_mem_nhds (0:ℂ) zero_lt_one] with z hz
+    have hd := (hasDerivAt_id z).mul ((hg.differentiableAt (isOpen_ball.mem_nhds hz)).hasDerivAt)
+    have hd' := hd.congr_of_eventuallyEq (Eventually.of_forall he)
+    simpa only [id_eq,one_mul] using hd'.deriv
+  have hga := hg.analyticAt (ball_mem_nhds (0:ℂ) zero_lt_one)
+  have hd := hga.differentiableAt.hasDerivAt.add
+    ((hasDerivAt_id (0:ℂ)).mul hga.deriv.differentiableAt.hasDerivAt)
+  have hh := (hd.congr_of_eventuallyEq hD).deriv
+  simpa only [id_eq,one_mul,zero_mul,add_zero,two_mul,g] using hh
+
+lemma normalized_univalent_second_derivative {f : ℂ → ℂ}
+    (hf : DifferentiableOn ℂ f (ball 0 1)) (hi : InjOn f (ball 0 1))
+    (hf0 : f 0=0) (hd0 : deriv f 0=1) :
+    ‖deriv (deriv f) 0‖≤4 := by
+  obtain ⟨q,hq,hq0,hq2,hqne,hqi⟩ := univalent_root_factor hf hi hf0 hd0
+  have hqb := root_factor_derivative_le_one hq hq0 hqne hqi
+  have hqD := (hq.differentiableAt (ball_mem_nhds (0:ℂ) zero_lt_one)).hasDerivAt
+  have he : dslope f 0 =ᶠ[𝓝 (0:ℂ)] (fun z => q z^2) := by
+    filter_upwards [ball_mem_nhds (0:ℂ) zero_lt_one] with z hz
+    exact (hq2 z hz).symm
+  have hgD := ((hqD.pow 2).congr_of_eventuallyEq he).deriv
+  have hg : deriv (dslope f 0) 0=2*deriv q 0 := by simpa [hq0] using hgD
+  have h4 : deriv (deriv f) 0=4*deriv q 0 := by
+    rw [second_derivative_eq_twice_dslope hf hf0,hg]
+    ring
+  rw [h4,norm_mul]
+  norm_num
+  linarith
+
+theorem univalent_second_derivative_bound {f : ℂ → ℂ}
+    (hf : DifferentiableOn ℂ f (ball 0 1)) (hi : InjOn f (ball 0 1)) :
+    ‖deriv (deriv f) 0‖≤4*‖deriv f 0‖ := by
+  have hzero : (0:ℂ)∈ball 0 1 := mem_ball_self zero_lt_one
+  have hd : deriv f 0≠0 := univalent_deriv_ne_zero isOpen_ball hf hi hzero
+  let P (z : ℂ) := (f z-f 0)/deriv f 0
+  have hP : DifferentiableOn ℂ P (ball 0 1) := (hf.sub_const _).div_const _
+  have hPi : InjOn P (ball 0 1) := by
+    intro z hz w hw he
+    apply hi hz hw
+    have hh := (div_left_inj' hd).mp he
+    linear_combination hh
+  have hP0 : P 0=0 := by simp [P]
+  have hPD (z : ℂ) (hz : z∈ball (0:ℂ) 1) : deriv P z=deriv f z/deriv f 0 := by
+    exact (((hf.differentiableAt (isOpen_ball.mem_nhds hz)).hasDerivAt.sub_const _).div_const _).deriv
+  have hP1 : deriv P 0=1 := by rw [hPD 0 hzero,div_self hd]
+  have hfA := hf.analyticAt (isOpen_ball.mem_nhds hzero)
+  have hP2 : deriv (deriv P) 0=deriv (deriv f) 0/deriv f 0 := by
+    have hh := hfA.deriv.differentiableAt.hasDerivAt.div_const (deriv f 0)
+    exact (hh.congr_of_eventuallyEq (by
+      filter_upwards [ball_mem_nhds (0:ℂ) zero_lt_one] with z hz
+      exact hPD z hz)).deriv
+  have hh := normalized_univalent_second_derivative hP hPi hP0 hP1
+  rw [hP2,norm_div] at hh
+  exact (div_le_iff₀ (norm_pos_iff.mpr hd)).mp hh
+
+end SLEExactGauge
+
+end
+
+end OAI
diff --git a/lean/OAI/Probability/SLE/Loewner/VanishingHeightRealBounds.lean b/lean/OAI/Probability/SLE/Loewner/VanishingHeightRealBounds.lean
new file mode 100644
index 0000000000000000000000000000000000000000..570d488889c8d2878af5aa92c2b8b5dc5a1d9d06
--- /dev/null
+++ b/lean/OAI/Probability/SLE/Loewner/VanishingHeightRealBounds.lean
@@ -0,0 +1,104 @@
+import OAI.Probability.SLE.Geometry.OutwardRealBarrier
+import OAI.Probability.SLE.Stochastic.ScalarExponentialLower
+
+namespace OAI
+
+/-! Vanishing forward height forces the real coordinate to remain
+between the future driver bounds. -/
+noncomputable section
+open Set Filter
+open scoped Topology
+
+namespace SLEExactGauge
+
+lemma forward_height_lower_of_real_gap {a b ε : ℝ} (hε : 0 < ε)
+    (X y u : ℝ → ℝ) (hc : ContinuousOn y (Icc a b))
+    (hd : ∀ t ∈ Ico a b, HasDerivWithinAt y
+      (-2*y t/((X t-u t)^2+(y t)^2)) (Ici t) t)
+    (hy : ∀ t ∈ Icc a b, 0 ≤ y t)
+    (hgap : ∀ t ∈ Ico a b, ε ≤ |X t-u t|) :
+    ∀ t ∈ Icc a b, y a*Real.exp (-(2/ε^2)*(t-a)) ≤ y t := by
+  apply scalar_exponential_lower y _ hc hd
+  intro t ht
+  have hsq := (sq_le_sq₀ hε.le (abs_nonneg (X t-u t))).mpr (hgap t ht)
+  rw [sq_abs] at hsq
+  have hden : ε^2 ≤ (X t-u t)^2+(y t)^2 := by nlinarith [sq_nonneg (y t)]
+  have hdv := div_le_div_of_nonneg_left
+    (mul_nonneg (by norm_num : (0:ℝ) ≤ 2) (hy t (Ico_subset_Icc_self ht)))
+    (sq_pos_of_pos hε) hden
+  calc
+    -(2/ε^2)*y t = -(2*y t/ε^2) := by ring
+    _ ≤ -(2*y t/((X t-u t)^2+(y t)^2)) := neg_le_neg hdv
+    _ = -2*y t/((X t-u t)^2+(y t)^2) := by ring
+
+theorem real_le_future_driver_bound_of_height_zero {a τ c : ℝ} (haτ : a < τ)
+    (X y u : ℝ → ℝ)
+    (hX : ContinuousOn X (Ico a τ)) (hyc : ContinuousOn y (Ico a τ))
+    (hXd : ∀ t ∈ Ico a τ, HasDerivWithinAt X
+      (2*(X t-u t)/((X t-u t)^2+(y t)^2)) (Ici t) t)
+    (hyd : ∀ t ∈ Ico a τ, HasDerivWithinAt y
+      (-2*y t/((X t-u t)^2+(y t)^2)) (Ici t) t)
+    (hyp : ∀ t ∈ Ico a τ, 0 < y t)
+    (hu : ∀ t ∈ Ico a τ, u t ≤ c)
+    (hlim : Tendsto y (𝓝[<] τ) (𝓝 0)) : X a ≤ c := by
+  by_contra hn
+  have hca : c < X a := lt_of_not_ge hn
+  let ε : ℝ := X a-c
+  have hε : 0 < ε := sub_pos.mpr hca
+  have hya : 0 < y a := hyp a ⟨le_rfl,haτ⟩
+  have hpoint (t : ℝ) (ht : t ∈ Ico a τ) :
+      y a*Real.exp (-(2/ε^2)*(τ-a)) ≤ y t := by
+    have hsub : Icc a t ⊆ Ico a τ := fun s hs => ⟨hs.1,hs.2.trans_lt ht.2⟩
+    have hsub' : Ico a t ⊆ Ico a τ := fun s hs => ⟨hs.1,hs.2.trans ht.2⟩
+    have hD (s : ℝ) (hs : s ∈ Ico a t) : 0 < (X s-u s)^2+(y s)^2 := by
+      have hp := hyp s (hsub' hs)
+      positivity
+    have hbar := outward_real_barrier X u (fun s => (X s-u s)^2+(y s)^2)
+      (hX.mono hsub) (fun s hs => hXd s (hsub' hs)) hD
+      (fun s hs => hu s (hsub' hs)) hca
+    have hlower := forward_height_lower_of_real_gap hε X y u (hyc.mono hsub)
+      (fun s hs => hyd s (hsub' hs)) (fun s hs => (hyp s (hsub hs)).le)
+      (fun s hs => ?_) t ⟨ht.1,le_rfl⟩
+    · have hC : 0 ≤ 2/ε^2 := by positivity
+      have hexp : Real.exp (-(2/ε^2)*(τ-a)) ≤ Real.exp (-(2/ε^2)*(t-a)) := by
+        apply Real.exp_le_exp.mpr
+        nlinarith [mul_le_mul_of_nonneg_left ht.2.le hC]
+      exact (mul_le_mul_of_nonneg_left hexp hya.le).trans hlower
+    · have hb := hbar s (Ico_subset_Icc_self hs)
+      have hu' := hu s (hsub' hs)
+      exact (by dsimp [ε]; linarith : ε ≤ X s-u s).trans (le_abs_self _)
+  have hzero : y a*Real.exp (-(2/ε^2)*(τ-a)) ≤ 0 := by
+    apply ge_of_tendsto hlim
+    filter_upwards [self_mem_nhdsWithin,mem_nhdsWithin_of_mem_nhds (Ioi_mem_nhds haτ)] with t ht hta
+    exact hpoint t ⟨hta.le,ht⟩
+  exact not_le_of_gt (mul_pos hya (Real.exp_pos _)) hzero
+
+theorem future_driver_lower_le_real_of_height_zero {a τ c : ℝ} (haτ : a < τ)
+    (X y u : ℝ → ℝ)
+    (hX : ContinuousOn X (Ico a τ)) (hyc : ContinuousOn y (Ico a τ))
+    (hXd : ∀ t ∈ Ico a τ, HasDerivWithinAt X
+      (2*(X t-u t)/((X t-u t)^2+(y t)^2)) (Ici t) t)
+    (hyd : ∀ t ∈ Ico a τ, HasDerivWithinAt y
+      (-2*y t/((X t-u t)^2+(y t)^2)) (Ici t) t)
+    (hyp : ∀ t ∈ Ico a τ, 0 < y t)
+    (hu : ∀ t ∈ Ico a τ, c ≤ u t)
+    (hlim : Tendsto y (𝓝[<] τ) (𝓝 0)) : c ≤ X a := by
+  have hXd' (t : ℝ) (ht : t ∈ Ico a τ) : HasDerivWithinAt (fun s => -X s)
+      (2*((-X t)-(-u t))/(((-X t)-(-u t))^2+(y t)^2)) (Ici t) t := by
+    convert! (hXd t ht).neg using 1
+    ring
+  have hyd' (t : ℝ) (ht : t ∈ Ico a τ) : HasDerivWithinAt y
+      (-2*y t/(((-X t)-(-u t))^2+(y t)^2)) (Ici t) t := by
+    convert! hyd t ht using 1
+    congr 1
+    ring
+  have hh := real_le_future_driver_bound_of_height_zero haτ
+    (fun t => -X t) y (fun t => -u t) hX.neg hyc hXd' hyd' hyp
+    (fun t ht => neg_le_neg (hu t ht)) hlim
+  linarith
+
+end SLEExactGauge
+
+end
+
+end OAI
diff --git a/lean/OAI/Probability/SLE/Loewner/VanishingHeightRealLimit.lean b/lean/OAI/Probability/SLE/Loewner/VanishingHeightRealLimit.lean
new file mode 100644
index 0000000000000000000000000000000000000000..7518dfd7a1d9631d10419523538ea3f323de6b5c
--- /dev/null
+++ b/lean/OAI/Probability/SLE/Loewner/VanishingHeightRealLimit.lean
@@ -0,0 +1,63 @@
+import OAI.Probability.SLE.Loewner.VanishingHeightRealBounds
+
+namespace OAI
+
+/-! At a finite lifetime, vanishing height and continuity of the driver
+force the forward real coordinate to approach the driver. -/
+noncomputable section
+open Set Filter
+open scoped Topology
+
+namespace SLEExactGauge
+
+theorem forward_real_tendsto_driver_of_height_zero {τ : ℝ} (hτ : 0 < τ)
+    (X y u : ℝ → ℝ)
+    (hX : ContinuousOn X (Ico 0 τ)) (hyc : ContinuousOn y (Ico 0 τ))
+    (hXd : ∀ t ∈ Ico 0 τ, HasDerivWithinAt X
+      (2*(X t-u t)/((X t-u t)^2+(y t)^2)) (Ici t) t)
+    (hyd : ∀ t ∈ Ico 0 τ, HasDerivWithinAt y
+      (-2*y t/((X t-u t)^2+(y t)^2)) (Ici t) t)
+    (hyp : ∀ t ∈ Ico 0 τ, 0 < y t)
+    (hu : ContinuousAt u τ)
+    (hlim : Tendsto y (𝓝[<] τ) (𝓝 0)) :
+    Tendsto X (𝓝[<] τ) (𝓝 (u τ)) := by
+  apply tendsto_order.mpr
+  constructor
+  · intro c hc
+    let d : ℝ := (c+u τ)/2
+    have hcd : c < d := by dsimp [d]; linarith
+    have hdu : d < u τ := by dsimp [d]; linarith
+    have he : ∀ᶠ t in 𝓝[<] τ, d < u t :=
+      (hu.tendsto.mono_left nhdsWithin_le_nhds).eventually (lt_mem_nhds hdu)
+    obtain ⟨l,hl,hle⟩ := mem_nhdsLT_iff_exists_Ioo_subset.mp he
+    filter_upwards [Ioo_mem_nhdsLT (max_lt hl hτ)] with a ha
+    have hasub : Ico a τ ⊆ Ico 0 τ :=
+      fun t ht => ⟨(le_max_right l 0).trans (ha.1.le.trans ht.1),ht.2⟩
+    have hh := future_driver_lower_le_real_of_height_zero ha.2 X y u
+      (hX.mono hasub) (hyc.mono hasub)
+      (fun t ht => hXd t (hasub ht)) (fun t ht => hyd t (hasub ht))
+      (fun t ht => hyp t (hasub ht))
+      (fun t ht => (hle ⟨(le_max_left l 0).trans_lt (ha.1.trans_le ht.1),ht.2⟩).le) hlim
+    exact hcd.trans_le hh
+  · intro c hc
+    let d : ℝ := (c+u τ)/2
+    have hdc : d < c := by dsimp [d]; linarith
+    have hud : u τ < d := by dsimp [d]; linarith
+    have he : ∀ᶠ t in 𝓝[<] τ, u t < d :=
+      (hu.tendsto.mono_left nhdsWithin_le_nhds).eventually (gt_mem_nhds hud)
+    obtain ⟨l,hl,hle⟩ := mem_nhdsLT_iff_exists_Ioo_subset.mp he
+    filter_upwards [Ioo_mem_nhdsLT (max_lt hl hτ)] with a ha
+    have hasub : Ico a τ ⊆ Ico 0 τ :=
+      fun t ht => ⟨(le_max_right l 0).trans (ha.1.le.trans ht.1),ht.2⟩
+    have hh := real_le_future_driver_bound_of_height_zero ha.2 X y u
+      (hX.mono hasub) (hyc.mono hasub)
+      (fun t ht => hXd t (hasub ht)) (fun t ht => hyd t (hasub ht))
+      (fun t ht => hyp t (hasub ht))
+      (fun t ht => (hle ⟨(le_max_left l 0).trans_lt (ha.1.trans_le ht.1),ht.2⟩).le) hlim
+    exact hh.trans_lt hdc
+
+end SLEExactGauge
+
+end
+
+end OAI
diff --git a/lean/OAI/Probability/SLE/Loewner/VerticalDisplacementLimit.lean b/lean/OAI/Probability/SLE/Loewner/VerticalDisplacementLimit.lean
new file mode 100644
index 0000000000000000000000000000000000000000..a6adfcad63361ea28a70d71ec4c89f36334a4baf
--- /dev/null
+++ b/lean/OAI/Probability/SLE/Loewner/VerticalDisplacementLimit.lean
@@ -0,0 +1,41 @@
+import OAI.Probability.SLE.Loewner.VerticalHalfPlaneUniqueness
+
+namespace OAI
+
+/-! Vertical displacement bounds imply the normalization used in half-plane
+automorphism uniqueness. -/
+noncomputable section
+open Set Filter Function Complex
+open scoped Topology
+
+namespace SLEExactGauge
+
+lemma vertical_displacement_zero_of_bound {F : ℂ → ℂ} {C : ℝ}
+    (h : ∀ᶠ n : ℕ in atTop, ‖F (verticalInfinity n)-verticalInfinity n‖≤C/((n:ℝ)+1)) :
+    Tendsto (fun n : ℕ => F (verticalInfinity n)-verticalInfinity n) atTop (𝓝 0) := by
+  apply squeeze_zero_norm' h
+  simpa only [div_eq_mul_inv,mul_zero] using
+    (tendsto_const_nhds.mul (tendsto_inv_atTop_zero.comp verticalHeights_tendsto) :
+      Tendsto (fun n : ℕ => C*((n:ℝ)+1)⁻¹) atTop (𝓝 (C*0)))
+
+lemma vertical_normalization_of_displacement {F : ℂ → ℂ}
+    (h : Tendsto (fun n : ℕ => F (verticalInfinity n)-verticalInfinity n) atTop (𝓝 0)) :
+    Tendsto (fun n : ℕ => F (verticalInfinity n)/(((n:ℝ)+1:ℝ):ℂ)) atTop (𝓝 I) := by
+  have hi : Tendsto (fun n : ℕ => ((((n:ℝ)+1)⁻¹:ℝ):ℂ)) atTop (𝓝 0) := by
+    exact_mod_cast continuous_ofReal.continuousAt.tendsto.comp
+      (tendsto_inv_atTop_zero.comp verticalHeights_tendsto)
+  have hh := (h.mul hi).add_const I
+  simp only [zero_mul,zero_add] at hh
+  apply hh.congr
+  intro n
+  have hn : (((n:ℝ)+1:ℝ):ℂ)≠0 := ofReal_ne_zero.mpr (by positivity)
+  dsimp only [verticalInfinity]
+  push_cast
+  field_simp
+  ring
+
+end SLEExactGauge
+
+end
+
+end OAI
diff --git a/lean/OAI/Probability/SLE/Loewner/VerticalHalfPlaneUniqueness.lean b/lean/OAI/Probability/SLE/Loewner/VerticalHalfPlaneUniqueness.lean
new file mode 100644
index 0000000000000000000000000000000000000000..328c9c1c97f2bd218bdf7c4f9c8bc552e9bf3e2f
--- /dev/null
+++ b/lean/OAI/Probability/SLE/Loewner/VerticalHalfPlaneUniqueness.lean
@@ -0,0 +1,51 @@
+import OAI.Probability.SLE.Geometry.HalfPlaneNormalizedUniqueness
+
+namespace OAI
+
+/-! Normalized half-plane uniqueness using only the vertical asymptotics
+preserved by bounded-capacity limits. -/
+noncomputable section
+open Set Filter Complex Function
+open scoped Topology
+
+namespace SLEExactGauge
+
+lemma halfPlane_height_of_vertical_normalization {F : ℂ → ℂ}
+    (hF : DifferentiableOn ℂ F upperHalfPlane) (hm : MapsTo F upperHalfPlane upperHalfPlane)
+    (hn : Tendsto (fun n : ℕ => F (verticalInfinity n)/(((n:ℝ)+1:ℝ):ℂ))
+      atTop (𝓝 I)) {z : ℂ} (hz : z∈upperHalfPlane) : z.im≤(F z).im := by
+  apply halfPlane_julia_at_infinity hF hm (fun n : ℕ => (n:ℝ)+1)
+    (fun n => by positivity) _ hn hz
+  exact tendsto_inv_atTop_zero.comp verticalHeights_tendsto
+
+lemma vertical_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 n : ℕ => G (verticalInfinity n)/(((n:ℝ)+1:ℝ):ℂ)) atTop (𝓝 I))
+    (hFn : Tendsto (fun n : ℕ => F (verticalInfinity n)/(((n:ℝ)+1:ℝ):ℂ)) atTop (𝓝 I))
+    (hG0 : Tendsto (fun n : ℕ => G (verticalInfinity n)-verticalInfinity n) atTop (𝓝 0)) :
+    EqOn G id upperHalfPlane := by
+  have him (z : ℂ) (hz : z∈upperHalfPlane) : (G z-z).im=0 := by
+    have h1 := halfPlane_height_of_vertical_normalization hG hGm hGn hz
+    have h2 := halfPlane_height_of_vertical_normalization 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 := (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.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/Loewner/VerticalIntervalEnergy.lean b/lean/OAI/Probability/SLE/Loewner/VerticalIntervalEnergy.lean
new file mode 100644
index 0000000000000000000000000000000000000000..0ebf7f2ec1c18ecf4f62e7ede1a897e1eaaca535
--- /dev/null
+++ b/lean/OAI/Probability/SLE/Loewner/VerticalIntervalEnergy.lean
@@ -0,0 +1,54 @@
+import OAI.Probability.SLE.Geometry.ComplexAngularEnergy
+
+namespace OAI
+
+/-! A vertical segment's squared oscillation is bounded by its height
+times the one-dimensional derivative energy. -/
+noncomputable section
+open Set Filter Function Complex Metric MeasureTheory
+open scoped Topology ENNReal
+
+namespace SLEExactGauge
+
+lemma integral_norm_le_interval_energy {h : ℝ} (hh : 0<h) {g : ℝ → ℂ}
+    (hg : MemLp g 2 (volume.restrict (Ioc 0 h))) :
+    (∫ y in Ioc 0 h, ‖g y‖)≤
+      Real.sqrt h*Real.sqrt (∫ y in Ioc 0 h, ‖g y‖^2) := by
+  have h1 : MemLp (fun _ : ℝ => (1:ℝ)) 2 (volume.restrict (Ioc 0 h)) := memLp_const 1
+  have hb := integral_mul_le_Lp_mul_Lq_of_nonneg Real.HolderConjugate.two_two
+    (ae_of_all _ (fun y => norm_nonneg (g y))) (ae_of_all _ (fun _ => zero_le_one))
+    (by simpa using hg.norm) (by simpa using h1)
+  simpa only [mul_one,Real.rpow_two,one_pow,integral_const,smul_eq_mul,one_mul,
+    Measure.real,Measure.restrict_apply_univ,Real.volume_Ioc,sub_zero,
+    ENNReal.toReal_ofReal hh.le,Real.sqrt_eq_rpow,mul_comm] using hb
+
+theorem complex_interval_energy_oscillation {h : ℝ} (hh : 0<h)
+    {f : ℝ → ℂ} {x y : ℝ} (hx : x∈Ioc 0 h) (hy : y∈Ioc 0 h)
+    (hf : ∀ t∈uIcc x y, DifferentiableAt ℝ f t)
+    (hd : MemLp (deriv f) 2 (volume.restrict (Ioc 0 h))) :
+    ‖f y-f x‖^2≤h*(∫ t in Ioc 0 h, ‖deriv f t‖^2) := by
+  have hsub : uIoc x y⊆Ioc 0 h := fun t ht =>
+    ordConnected_Ioc.uIcc_subset hx hy (uIoc_subset_uIcc ht)
+  have hi : IntegrableOn (fun t => ‖deriv f t‖) (Ioc 0 h) :=
+    (hd.integrable (by norm_num)).norm
+  have hi' : IntegrableOn (deriv f) (Ioc 0 h) := hd.integrable (by norm_num)
+  have hid : IntervalIntegrable (deriv f) volume x y :=
+    intervalIntegrable_iff.mpr (hi'.mono_set hsub)
+  have hb : ‖f y-f x‖≤Real.sqrt h*Real.sqrt (∫ t in Ioc 0 h, ‖deriv f t‖^2) := by
+    calc
+      ‖f y-f x‖ = ‖∫ t in x..y, deriv f t‖ :=
+        congrArg norm (intervalIntegral.integral_deriv_eq_sub hf hid).symm
+      _ ≤ ∫ t in uIoc x y, ‖deriv f t‖ := intervalIntegral.norm_integral_le_integral_norm_uIoc
+      _ ≤ ∫ t in Ioc 0 h, ‖deriv f t‖ :=
+        setIntegral_mono_set hi (ae_of_all _ (fun _ => norm_nonneg _)) hsub.eventuallySubset
+      _ ≤ _ := integral_norm_le_interval_energy hh hd
+  have hE : 0≤∫ t in Ioc 0 h, ‖deriv f t‖^2 := integral_nonneg (fun _ => sq_nonneg _)
+  have hs := mul_nonneg (Real.sqrt_nonneg h) (Real.sqrt_nonneg (∫ t in Ioc 0 h, ‖deriv f t‖^2))
+  have hsquare := mul_le_mul hb hb (norm_nonneg _) hs
+  simpa only [←pow_two,mul_pow,Real.sq_sqrt hh.le,Real.sq_sqrt hE] using hsquare
+
+end SLEExactGauge
+
+end
+
+end OAI
diff --git a/lean/OAI/Probability/SLE/Loewner/VerticalMapDerivative.lean b/lean/OAI/Probability/SLE/Loewner/VerticalMapDerivative.lean
new file mode 100644
index 0000000000000000000000000000000000000000..153de25fa82b4d342960d2d50196d2e3767e3c04
--- /dev/null
+++ b/lean/OAI/Probability/SLE/Loewner/VerticalMapDerivative.lean
@@ -0,0 +1,48 @@
+import OAI.Probability.SLE.Loewner.LoewnerVerticalLimit
+
+namespace OAI
+
+/-! The derivative of a holomorphic inverse limit is determined by its
+explicit values on the positive imaginary axis. -/
+noncomputable section
+open Set Filter Complex
+open scoped Topology NNReal
+
+namespace SLEExactGauge
+
+lemma vertical_axis_derivative (f : ℂ → ℂ) (T : ℝ≥0)
+    (hf : DifferentiableOn ℂ f upperHalfPlane)
+    (haxis : ∀ y : ℝ, 0 < y → f ((y:ℂ)*I)=verticalReversePath y T)
+    {y : ℝ} (hy : 0 < y) :
+    deriv f ((y:ℂ)*I) = ((y/Real.sqrt (y^2+4*T) : ℝ) : ℂ) := by
+  have hp : 0 < y^2+4*(T:ℝ) := by positivity
+  have hd := (((hasDerivAt_id y).pow 2).add_const (4*(T:ℝ))).sqrt hp.ne'
+  have hreal : HasDerivAt (fun s : ℝ => verticalReversePath s T)
+      (((y/Real.sqrt (y^2+4*T) : ℝ) : ℂ)*I) y := by
+    convert! hd.ofReal_comp.mul_const I using 1
+    congr 2
+    simp only [Pi.pow_apply,id_eq,mul_one]
+    ring
+  have hhol := hf.differentiableAt (isOpen_upperHalfPlane.mem_nhds
+    (show (y:ℂ)*I ∈ upperHalfPlane by simpa [upperHalfPlane] using hy))
+  have harg : HasDerivAt (fun s : ℝ => (s:ℂ)*I) I y := by
+    simpa using (hasDerivAt_id y).ofReal_comp.mul_const I
+  have hc := (hhol.restrictScalars ℝ).hasFDerivAt.comp_hasDerivAt y harg
+  have hval : (fderiv ℝ f ((y:ℂ)*I)) I = I*deriv f ((y:ℂ)*I) := by
+    rw [hhol.fderiv_restrictScalars (𝕜 := ℝ)]
+    change (fderiv ℂ f ((y:ℂ)*I)) I = _
+    rw [fderiv_eq_smul_deriv,smul_eq_mul]
+  rw [hval] at hc
+  have he : (fun s : ℝ => f ((s:ℂ)*I)) =ᶠ[𝓝 y]
+      (fun s : ℝ => verticalReversePath s T) := by
+    filter_upwards [Ioi_mem_nhds hy] with s hs
+    exact haxis s hs
+  have heq := (hc.congr_of_eventuallyEq he.symm).unique hreal
+  rw [mul_comm I] at heq
+  exact mul_right_cancel₀ I_ne_zero heq
+
+end SLEExactGauge
+
+end
+
+end OAI
diff --git a/lean/OAI/Probability/SLE/Mass/CanonicalImageMass.lean b/lean/OAI/Probability/SLE/Mass/CanonicalImageMass.lean
new file mode 100644
index 0000000000000000000000000000000000000000..14bc0da51e60ec082a26fc70eb33612b7c22c73d
--- /dev/null
+++ b/lean/OAI/Probability/SLE/Mass/CanonicalImageMass.lean
@@ -0,0 +1,71 @@
+import OAI.Probability.SLE.Mass.ConformalMassTransport
+
+namespace OAI
+
+/-! The canonical process in a fixed conformal image. The pathwise limit
+event is common to all image maps and compact tests. -/
+
+noncomputable section
+open Set Filter _root_.MeasureTheory _root_.OAI.MeasureTheory ProbabilityTheory Classical
+open scoped NNReal ENNReal Topology CompactlySupported
+
+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) {D : Set ℂ}
+
+def imageProcess (J : upperHalfPlane ≃ₜ D) (w : C(upperHalfPlane,ℝ≥0))
+    (t : ℝ≥0) (ω : Ω) : Measure D := conformalMass J w (C.process t ω)
+
+lemma imageProcess_progressive (J : upperHalfPlane ≃ₜ D) (w : C(upperHalfPlane,ℝ≥0)) :
+    IsProgressive (Filtration.natural B (fun r =>
+      (hBm.comp (measurable_const.prodMk measurable_id) : Measurable (B r)).stronglyMeasurable))
+      (C.imageProcess J w) := by
+  intro t
+  exact (conformalMass_measurable J w).comp (C.progressive t)
+
+lemma imageProcess_radon (J : upperHalfPlane ≃ₜ D) (w : C(upperHalfPlane,ℝ≥0))
+    (t : ℝ≥0) (ω : Ω) :
+    (C.imageProcess J w t ω).Regular ∧ IsFiniteMeasureOnCompacts (C.imageProcess J w t ω) := by
+  let := (C.radon t ω).2
+  exact conformalMass_radon J w (C.process t ω)
+
+lemma imageProcess_paths (J : upperHalfPlane ≃ₜ D) (w : C(upperHalfPlane,ℝ≥0)) :
+    ∀ᵐ ω ∂P, C.imageProcess J w 0 ω = 0 ∧
+      Monotone (fun t => C.imageProcess J w t ω) ∧
+      (∀ t, C.imageProcess J w t ω ≤ conformalMass J w (C.rational.terminal ω)) ∧
+      (∀ f : C_c(D,ℝ), Continuous (fun t => ∫ z, f z ∂C.imageProcess J w t ω)) ∧
+      NullSingletonClass (conformalMass J w (C.rational.terminal ω)) := by
+  filter_upwards [C.paths,C.rational.nonatomic] with ω hp hn
+  let := hn
+  refine ⟨?_,?_,?_,?_,conformalMass_nullSingleton J w _⟩
+  · simp only [imageProcess,hp.zero,conformalMass_zero]
+  · intro s t hst
+    exact conformalMass_mono J w (hp.monotone hst)
+  · intro t
+    exact conformalMass_mono J w (hp.dominated t)
+  · exact conformalMass_test_continuous J w (fun t => C.process t ω) hp.continuous_tests
+
+/-- No image map changes the extraction: one event works for every map,
+every continuous nonnegative weight, all extended times, and all tests. -/
+theorem all_image_limits
+    (hBc : ∀ ω, Continuous (fun t => B t ω)) (hκ : 0 < κ) (hκ8 : κ < 8)
+    (F : Ω → ℝ≥0 → ℂ → ℂ)
+    (hw : ∀ ω, IsCapacityTwoWitness (fun t => Real.sqrt κ * B t ω) (γ ω) (G ω) (F ω)) :
+    ∀ᵐ ω ∂P, ∀ (D : Set ℂ) (J : upperHalfPlane ≃ₜ D)
+      (w : C(upperHalfPlane,ℝ≥0)) (t : ℝ≥0∞) (f : C_c(D,ℝ)),
+      Tendsto (fun n => ∫ z, f z ∂conformalMass J w
+        (convexLevelMeasure κ B γ G (fun n => (n:ℝ)) C.rational.supports C.rational.weights n t ω))
+        atTop (𝓝 (∫ z, f z ∂conformalMass J w (C.atTime t ω))) := by
+  filter_upwards [C.rational.all_extended_times_limit hBc hκ hκ8 F hw
+    C.process C.radon C.paths] with ω hω
+  intro D J w t f
+  exact conformalMass_test_tendsto J w _ _ (hω t) f
+
+end SLEExactGauge.Multipoint.CanonicalMass
+
+end
+
+end OAI
diff --git a/lean/OAI/Probability/SLE/Mass/CanonicalMassAllTimes.lean b/lean/OAI/Probability/SLE/Mass/CanonicalMassAllTimes.lean
new file mode 100644
index 0000000000000000000000000000000000000000..4fcbc87215e078d676236203b3b826bee45fff45
--- /dev/null
+++ b/lean/OAI/Probability/SLE/Mass/CanonicalMassAllTimes.lean
@@ -0,0 +1,78 @@
+import OAI.Probability.SLE.Mass.CanonicalMassContinuity
+import OAI.Probability.SLE.Geometry.MonotoneRationalLimit
+
+namespace OAI
+
+/-! One common convex sequence converges at every finite time, on one
+event of full probability. In particular it can be evaluated at a random time. -/
+
+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 RationalCanonicalMass.all_finite_times_limit
+    {Ω : Type*} [MeasurableSpace Ω] {P : Measure Ω} {κ : ℝ}
+    {B : ℝ≥0 → Ω → ℝ} {hBm : Measurable (Function.uncurry B)}
+    (hBc : ∀ ω, Continuous (fun t => B t ω)) (hκ : 0 < κ) (hκ8 : κ < 8)
+    {γ : Ω → ℝ≥0 → ℂ} {G : Ω → ℝ≥0 → ℂ → ℂ}
+    (F : Ω → ℝ≥0 → ℂ → ℂ)
+    (hw : ∀ ω, IsCapacityTwoWitness (fun t => Real.sqrt κ * B t ω) (γ ω) (G ω) (F ω))
+    (C : RationalCanonicalMass P κ B hBm γ G)
+    (N : ℝ≥0 → Ω → Measure upperHalfPlane)
+    (hNr : ∀ t ω, (N t ω).Regular ∧ IsFiniteMeasureOnCompacts (N t ω))
+    (hpath : ∀ᵐ ω ∂P, ContinuousMassPath (γ ω) (fun q => C.mass q ω)
+      (C.terminal ω) (fun t => N t ω)) :
+    ∀ᵐ ω ∂P, ∀ (t : ℝ≥0) (f : C_c(upperHalfPlane,ℝ)),
+      Tendsto (fun n => ∫ z, f z ∂convexLevelMeasure κ B γ G (fun n => (n:ℝ))
+        C.supports C.weights n t ω) atTop (𝓝 (∫ z, f z ∂N t ω)) := by
+  filter_upwards [C.mass_limit,hpath] with ω hl hp
+  let M (n : ℕ) (t : ℝ≥0) := convexLevelMeasure κ B γ G (fun n => (n:ℝ))
+    C.supports C.weights n t ω
+  let (n : ℕ) (t : ℝ≥0) : IsFiniteMeasureOnCompacts (M n t) :=
+    convexLevelMeasure_finite_on_compacts hκ hκ8 γ G F ω (hBc ω) (hw ω)
+      _ C.supports C.weights n t
+  let (t : ℝ≥0) : IsFiniteMeasureOnCompacts (N t ω) := (hNr t ω).2
+  have hpositive (f : C_c(upperHalfPlane,ℝ)) (hf : ∀ z, 0 ≤ f z) (t : ℝ≥0) :
+      Tendsto (fun n => ∫ z, f z ∂M n t) atTop (𝓝 (∫ z, f z ∂N t ω)) := by
+    have hrat (q : ℚ) :
+        Tendsto (fun n => ∫ z, f z ∂M n (q:ℝ).toNNReal) atTop
+          (𝓝 (∫ z, f z ∂N (q:ℝ).toNNReal ω)) := by
+      by_cases hq : 0 ≤ q
+      · rw [hp.rational q hq]
+        exact hl q f
+      · have he : (q:ℝ).toNNReal = 0 :=
+          Real.toNNReal_eq_zero.mpr (Rat.cast_nonpos.mpr (le_of_not_ge hq))
+        have hzero : N 0 ω = C.mass 0 ω := by
+          simpa only [Rat.cast_zero,Real.toNNReal_zero] using hp.rational 0 le_rfl
+        simpa only [he,hzero,Rat.cast_zero,Real.toNNReal_zero] using hl 0 f
+    have hlim := tendsto_of_monotone_rational_limits
+      (fun n r => ∫ z, f z ∂M n r.toNNReal)
+      (fun r => ∫ z, f z ∂N r.toNNReal ω) (fun n r s hrs =>
+        integral_mono_measure (convexLevelMeasure_mono κ B γ G (fun n => (n:ℝ))
+          C.supports C.weights n ω (ENNReal.coe_le_coe.mpr (Real.toNNReal_mono hrs)))
+          (ae_of_all _ hf) f.integrable)
+      ((hp.continuous_tests f).comp continuous_real_toNNReal) hrat (t:ℝ)
+    simpa only [Real.toNNReal_coe] using hlim
+  intro t f
+  let fp := f ⊔ 0
+  let fm := (-f) ⊔ 0
+  have hsplit (ρ : Measure upperHalfPlane) [IsFiniteMeasureOnCompacts ρ] :
+      (∫ z, f z ∂ρ) = (∫ z, fp z ∂ρ)-(∫ z, fm z ∂ρ) := by
+    rw [← integral_sub fp.integrable fm.integrable]
+    apply integral_congr_ae
+    filter_upwards [] with z
+    change f z = max (f z) 0-max (-f z) 0
+    exact (max_zero_sub_eq_self (f z)).symm
+  simpa only [← hsplit] using
+    (hpositive fp (fun z => le_sup_of_le_right (by rfl)) t).sub
+      (hpositive fm (fun z => le_sup_of_le_right (by rfl)) t)
+
+end SLEExactGauge.Multipoint
+
+end
+
+end OAI
diff --git a/lean/OAI/Probability/SLE/Mass/CanonicalMassAllVisits.lean b/lean/OAI/Probability/SLE/Mass/CanonicalMassAllVisits.lean
new file mode 100644
index 0000000000000000000000000000000000000000..120b7b532cc8f530194716f0966c5a534a9e1e91
--- /dev/null
+++ b/lean/OAI/Probability/SLE/Mass/CanonicalMassAllVisits.lean
@@ -0,0 +1,47 @@
+import OAI.Probability.SLE.Mass.CanonicalMassFirstVisit
+import OAI.Probability.SLE.Loewner.TraceRestrictionContinuity
+
+namespace OAI
+
+/-! The first-visit identity holds on one event simultaneously at every
+finite time. In particular later returns carry no previously assigned mass. -/
+
+noncomputable section
+open Set Filter _root_.MeasureTheory _root_.OAI.MeasureTheory ProbabilityTheory Classical
+open scoped NNReal ENNReal Topology CompactlySupported
+
+namespace SLEExactGauge.Multipoint
+
+local instance : LocallyCompactSpace upperHalfPlane := isOpen_upperHalfPlane.locallyCompactSpace
+
+theorem CanonicalMass.all_times_eq_restrict_past
+    {Ω : Type*} [MeasurableSpace Ω] {P : Measure Ω} {κ : ℝ}
+    {B : ℝ≥0 → Ω → ℝ} (hB : IsBrownianReal B P)
+    (hBm : Measurable (Function.uncurry B))
+    (hBc : ∀ ω, Continuous (fun t => B t ω)) (hB0 : ∀ ω, B 0 ω = 0)
+    (hκ : 0 < κ) (hκ8 : κ < 8)
+    {γ : Ω → ℝ≥0 → ℂ} {G : Ω → ℝ≥0 → ℂ → ℂ}
+    (F : Ω → ℝ≥0 → ℂ → ℂ)
+    (hw : ∀ ω, IsCapacityTwoWitness (fun t => Real.sqrt κ * B t ω) (γ ω) (G ω) (F ω))
+    (C : CanonicalMass P κ B hBm γ G) :
+    ∀ᵐ ω ∂P, ∀ t : ℝ≥0, C.process t ω = (C.rational.terminal ω).restrict
+      {z : upperHalfPlane | (z:ℂ) ∈ γ ω '' Icc 0 t} := by
+  have hq (q : ℚ) := C.atTime_eq_restrict_past hB hBm hBc hB0 hκ hκ8 F hw (q:ℝ).toNNReal
+  have hlim := C.rational.all_finite_times_limit hBc hκ hκ8 F hw C.process C.radon C.paths
+  filter_upwards [ae_all_iff.mpr hq,C.paths,hlim] with ω hq hp hl
+  let : (C.rational.terminal ω).Regular := (C.rational.terminal_radon ω).1
+  have hpast (t : ℝ≥0) : C.process t ω {z : upperHalfPlane | (z:ℂ) ∉ γ ω '' Icc 0 t} = 0 := by
+    let : (C.process t ω).Regular := (C.radon t ω).1
+    exact convex_level_radon_limit_carried_by_past ω (hBc ω) (hw ω) t (fun n => (n:ℝ))
+      tendsto_natCast_atTop_atTop C.rational.supports C.rational.weights (C.process t ω) (hl t)
+  apply trace_restriction_of_rational_times (γ ω) (hw ω).1 (fun q => C.rational.mass q ω)
+    (C.rational.terminal ω) (fun t => C.process t ω) hp hpast
+  intro q _
+  simpa only [CanonicalMass.atTime,extendedCanonicalMass,ENNReal.coe_lt_top,
+    ite_true,ENNReal.toNNReal_coe] using hq q
+
+end SLEExactGauge.Multipoint
+
+end
+
+end OAI
diff --git a/lean/OAI/Probability/SLE/Mass/CanonicalMassCompensator.lean b/lean/OAI/Probability/SLE/Mass/CanonicalMassCompensator.lean
new file mode 100644
index 0000000000000000000000000000000000000000..6e71f7a953a409e41196a84027e40771184513f6
--- /dev/null
+++ b/lean/OAI/Probability/SLE/Mass/CanonicalMassCompensator.lean
@@ -0,0 +1,53 @@
+import OAI.Probability.SLE.Geometry.WeightedCompactTerminal
+
+namespace OAI
+
+/-! Predictable dyadic recovery for the actual compact weighted canonical
+mass. The time argument is the one used by the given filtration. -/
+
+noncomputable section
+open Set Filter _root_.MeasureTheory _root_.OAI.MeasureTheory ProbabilityTheory
+open scoped Topology NNReal ENNReal
+
+namespace SLEExactGauge
+
+def compensatorMeshFiltration {Ω : Type*} [mΩ : MeasurableSpace Ω]
+    (ℱ : Filtration ℝ≥0 mΩ) (n : ℕ) : Filtration ℕ mΩ where
+  seq i := ℱ (compensatorMeshTime n i)
+  mono' := fun _ _ h => ℱ.mono (compensatorMeshTime_mono n h)
+  le' _i := ℱ.le _
+
+namespace 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 compactWeightedMass_compensator_recovery
+    (w : C(upperHalfPlane,ℝ≥0)) (K : Set upperHalfPlane) (hK : IsCompact K)
+    (T : Ω → ℝ≥0∞) (hT : Measurable T) :
+    TendstoInMeasure P
+      (fun n ω => meshMassCompensator P
+        (compensatorMeshFiltration (Filtration.natural B (fun r =>
+          (hBm.comp (measurable_const.prodMk measurable_id) : Measurable (B r)).stronglyMeasurable)))
+        (fun t ω => compactWeightedMass w K (C.process t ω)) n
+        (compensatorStopIndex n (T ω)) ω) atTop
+      (fun ω => massAtExtendedTime (fun t => compactWeightedMass w K (C.process t ω))
+        (compactWeightedMass w K (C.rational.terminal ω)) (T ω)) := by
+  apply meshMassCompensator_stopped_tendstoInMeasure P _ _ _ _ _
+    (C.compactWeightedMass_terminal_memLp w K hK) (C.compactWeightedMass_paths w K hK) T hT
+  · intro t
+    exact (compactWeightedMass_measurable w K hK.measurableSet).comp
+      (C.progressive.adapted.measurable (i := t))
+  · intro n i
+    exact ((compactWeightedMass_measurable w K hK.measurableSet).comp
+      (C.progressive.adapted (compensatorMeshTime n i))).stronglyMeasurable
+
+end Multipoint.CanonicalMass
+end SLEExactGauge
+
+end
+
+end OAI
diff --git a/lean/OAI/Probability/SLE/Mass/CanonicalMassConstruction.lean b/lean/OAI/Probability/SLE/Mass/CanonicalMassConstruction.lean
new file mode 100644
index 0000000000000000000000000000000000000000..c9b1c2ce06ccae3e5329fb9af1e18ca80e0e55cd
--- /dev/null
+++ b/lean/OAI/Probability/SLE/Mass/CanonicalMassConstruction.lean
@@ -0,0 +1,81 @@
+import OAI.Probability.SLE.Mass.CanonicalMassStoppingKernel
+import OAI.Probability.SLE.Mass.CanonicalMassExhaustion
+
+namespace OAI
+
+/-! The first paper's canonical mass construction, including the exact
+conditional kernel at arbitrary stopping times and terminal exhaustion. -/
+
+noncomputable section
+open Set Filter _root_.MeasureTheory _root_.OAI.MeasureTheory ProbabilityTheory Classical
+open scoped NNReal ENNReal Topology CompactlySupported
+
+namespace SLEExactGauge.Multipoint
+
+structure CanonicalMass
+    {Ω : Type*} [MeasurableSpace Ω] (P : Measure Ω) (κ : ℝ)
+    (B : ℝ≥0 → Ω → ℝ) (hBm : Measurable (Function.uncurry B))
+    (γ : Ω → ℝ≥0 → ℂ) (G : Ω → ℝ≥0 → ℂ → ℂ) where
+  rational : RationalCanonicalMass P κ B hBm γ G
+  process : ℝ≥0 → Ω → Measure upperHalfPlane
+  progressive : IsProgressive (Filtration.natural B (fun r =>
+    (hBm.comp (measurable_const.prodMk measurable_id) : Measurable (B r)).stronglyMeasurable)) process
+  radon : ∀ t ω, (process t ω).Regular ∧ IsFiniteMeasureOnCompacts (process t ω)
+  paths : ∀ᵐ ω ∂P, ContinuousMassPath (γ ω) (fun q => rational.mass q ω)
+    (rational.terminal ω) (fun t => process t ω)
+  exhaustion : ∀ᵐ ω ∂P, ∀ K : Set upperHalfPlane, IsCompact K →
+    Tendsto (fun t : ℝ≥0 => (rational.terminal ω-process t ω) K) atTop (𝓝 0)
+  kernel : ∀ S : Ω → WithTop ℝ≥0,
+    ∀ hS : IsStoppingTime (Filtration.natural B (fun r =>
+      (hBm.comp (measurable_const.prodMk measurable_id) : Measurable (B r)).stronglyMeasurable)) S,
+    ∀ E : Set Ω, MeasurableSet[hS.measurableSpace] E →
+      (P.restrict E).bind rational.terminal =
+        (P.restrict E).bind (fun ω => extendedCanonicalMass process rational.terminal (S ω) ω) +
+        (P.restrict E).bind (halfPlaneStoppingGreenMeasure κ B γ G S)
+
+/-- Proposition `mass:construction` of the first manuscript. The sole
+published input is the disk-growth consequence of Duren (1983), §2.3;
+all stochastic estimates and limiting arguments are proved here. -/
+theorem exists_canonicalMass
+    {Ω : Type*} [MeasurableSpace Ω] {P : Measure Ω}
+    {B : ℝ≥0 → Ω → ℝ} (hB : IsBrownianReal B P)
+    (hBm : Measurable (Function.uncurry B)) (hBc : ∀ ω, Continuous (fun t => B t ω))
+    (hB0 : ∀ ω, B 0 ω = 0) {κ : ℝ} (hκ : 0 < κ) (hκ8 : κ < 8)
+    (γ : Ω → ℝ≥0 → ℂ) (G F : Ω → ℝ≥0 → ℂ → ℂ)
+    (hw : ∀ ω, IsCapacityTwoWitness (fun t => Real.sqrt κ * B t ω) (γ ω) (G ω) (F ω))
+    (hgrowth : PublishedDiskUnivalentGrowth) :
+    Nonempty (CanonicalMass P κ B hBm γ G) := by
+  obtain ⟨C⟩ := exists_rationalCanonicalMass hB
+    (fun t => hBm.comp (measurable_const.prodMk measurable_id)) hBm hBc hB0 hκ hκ8 γ G F hw hgrowth
+  obtain ⟨N,hNp,hNr,hpath⟩ := C.exists_continuous_progressive_extension (fun ω => (hw ω).1)
+  exact ⟨{
+    rational := C
+    process := N
+    progressive := hNp
+    radon := hNr
+    paths := hpath
+    exhaustion := C.finite_times_exhaust_terminal hB hBm hBc hB0 hκ hκ8 γ G F hw N hpath
+    kernel := C.stopping_conditional_kernel hB hBm hBc hB0 hκ hκ8 F hw hgrowth N hNp hNr hpath }⟩
+
+end SLEExactGauge.Multipoint
+
+namespace SLEExactGauge
+
+/-- The canonical mass main construction for an ordinary SLE in its
+regular Brownian presentation, on its full-measure sample space. -/
+theorem RegularSLEPresentation.canonical_mass_main
+    {Ω : Type*} [MeasurableSpace Ω] {P : Measure Ω} {κ : ℝ}
+    {γ : Ω → ℝ≥0 → ℂ} (a : RegularSLEPresentation P κ γ)
+    (hκ : 0 < κ) (hκ8 : κ < 8) (hgrowth : PublishedDiskUnivalentGrowth) :
+    Nonempty (Multipoint.CanonicalMass (P.comap (Subtype.val : a.samples → Ω)) κ a.B
+      (measurable_uncurry_of_continuous_of_measurable a.continuous_B a.measurable_B)
+      (fun ω => γ ω) a.G) :=
+  Multipoint.exists_canonicalMass a.brownian
+    (measurable_uncurry_of_continuous_of_measurable a.continuous_B a.measurable_B)
+    a.continuous_B a.zero_B hκ hκ8 (fun ω => γ ω) a.G a.F a.witness hgrowth
+
+end SLEExactGauge
+
+end
+
+end OAI
diff --git a/lean/OAI/Probability/SLE/Mass/CanonicalMassContinuity.lean b/lean/OAI/Probability/SLE/Mass/CanonicalMassContinuity.lean
new file mode 100644
index 0000000000000000000000000000000000000000..ad6a4d91cfd56f76e761266df83c9feb58312127
--- /dev/null
+++ b/lean/OAI/Probability/SLE/Mass/CanonicalMassContinuity.lean
@@ -0,0 +1,115 @@
+import OAI.Probability.SLE.Mass.RationalCanonicalMass
+import OAI.Probability.SLE.Mass.RationalTraceMassSupport
+import OAI.Probability.SLE.Mass.RationalTraceMassLocalVariation
+import OAI.Probability.SLE.Mass.RationalTraceMassProgressiveVersion
+
+namespace OAI
+
+/-! The actual rational construction extends to an adapted, locally
+continuous family, with simultaneous support of every finite increment. -/
+
+noncomputable section
+open Set Filter MeasureTheory ProbabilityTheory Classical
+open scoped NNReal ENNReal Topology CompactlySupported
+
+namespace SLEExactGauge.Multipoint
+
+local instance : LocallyCompactSpace upperHalfPlane := isOpen_upperHalfPlane.locallyCompactSpace
+
+structure ContinuousMassPath (γ : ℝ≥0 → ℂ) (μ : ℚ → Measure upperHalfPlane)
+    (ν : Measure upperHalfPlane) (N : ℝ≥0 → Measure upperHalfPlane) : Prop where
+  zero : N 0 = 0
+  dominated : ∀ t, N t ≤ ν
+  monotone : Monotone N
+  rational : ∀ q : ℚ, 0 ≤ q → N (q:ℝ).toNNReal = μ q
+  continuous_tests : ∀ f : C_c(upperHalfPlane,ℝ), Continuous (fun t => ∫ z, f z ∂N t)
+  increment_support : ∀ s t, s ≤ t →
+    (N t-N s) {z : upperHalfPlane | (z:ℂ) ∉
+      (fun r : ℝ => γ r.toNNReal) '' Icc (s:ℝ) t} = 0
+  local_variation : ∀ K : Set upperHalfPlane, IsCompact K →
+    ∀ t₀ : ℝ≥0, ∀ ε : ℝ, 0 < ε → ∃ δ : ℝ, 0 < δ ∧
+      ∀ s t : ℝ≥0, dist (s:ℝ) t₀ < δ → dist (t:ℝ) t₀ < δ →
+        ∀ A : Set upperHalfPlane, MeasurableSet A → A ⊆ K →
+          |(N s A).toReal-(N t A).toReal| < ε
+
+theorem RationalCanonicalMass.exists_continuous_progressive_extension
+    {Ω : Type*} [mΩ : MeasurableSpace Ω] {P : Measure Ω} {κ : ℝ}
+    {B : ℝ≥0 → Ω → ℝ} {hBm : Measurable (Function.uncurry B)}
+    {γ : Ω → ℝ≥0 → ℂ} {G : Ω → ℝ≥0 → ℂ → ℂ}
+    (C : RationalCanonicalMass P κ B hBm γ G) (hγ : ∀ ω, Continuous (γ ω)) :
+    ∃ N : ℝ≥0 → Ω → Measure upperHalfPlane,
+      IsProgressive (Filtration.natural B (fun r =>
+        (hBm.comp (measurable_const.prodMk measurable_id) : Measurable (B r)).stronglyMeasurable)) N ∧
+      (∀ t ω, (N t ω).Regular ∧ IsFiniteMeasureOnCompacts (N t ω)) ∧
+      ∀ᵐ ω ∂P, ContinuousMassPath (γ ω) (fun q => C.mass q ω) (C.terminal ω) (fun t => N t ω) := by
+  let Good (ω : Ω) : Prop :=
+    HalfPlaneTraceIncrements (fun q => C.mass q ω) (C.terminal ω)
+      (fun r : ℝ => γ ω r.toNNReal) ∧ NullSingletonClass (C.terminal ω)
+  have hex (ω : Ω) : ∃ M : ℝ → Measure upperHalfPlane,
+      (∀ t, (M t).Regular) ∧
+      (∀ f : C_c(upperHalfPlane,ℝ), Continuous (fun t => ∫ z, f z ∂M t)) ∧
+      (Good ω → (∀ t, M t ≤ C.terminal ω) ∧ (∀ q : ℚ, M q = C.mass q ω) ∧
+        Monotone M ∧
+        (∀ K : Set upperHalfPlane, IsCompact K →
+          ∀ t₀ : ℝ, ∀ ε : ℝ, 0 < ε → ∃ δ : ℝ, 0 < δ ∧
+            ∀ s t : ℝ, dist s t₀ < δ → dist t t₀ < δ →
+              ∀ A : Set upperHalfPlane, MeasurableSet A → A ⊆ K →
+                |(M s A).toReal-(M t A).toReal| < ε)) := by
+    by_cases h : Good ω
+    · let : (C.terminal ω).Regular := (C.terminal_radon ω).1
+      let : NullSingletonClass (C.terminal ω) := h.2
+      obtain ⟨M,hr,hd,hq,hm,hc,hv⟩ := h.1.exists_locally_tv_continuous_extension
+        ((hγ ω).comp continuous_real_toNNReal)
+      exact ⟨M,hr,hc,fun _ => ⟨hd,hq,hm,hv⟩⟩
+    · refine ⟨fun _ => 0,fun _ => inferInstance,?_,fun hh => (h hh).elim⟩
+      intro f
+      simpa only [integral_zero_measure] using (continuous_const : Continuous (fun _ : ℝ => (0:ℝ)))
+  choose M hMr hMc hM using hex
+  have hrat : ∀ᵐ ω ∂P, ∀ q : ℚ, M ω q = C.mass q ω := by
+    filter_upwards [C.increments,C.nonatomic] with ω hi hn
+    exact (hM ω ⟨hi,hn⟩).2.1
+  let N := rationalRadonExtension C.mass
+  have hNp : IsProgressive (Filtration.natural B (fun r =>
+      (hBm.comp (measurable_const.prodMk measurable_id) : Measurable (B r)).stronglyMeasurable)) N :=
+    rationalRadonExtension_progressive _ C.mass (fun q ω => (C.mass_radon q ω).1)
+      (fun q _ => C.mass_measurable q)
+  have hNr := rationalRadonExtension_regular C.mass
+  have hNe := rationalRadonExtension_common_version P C.mass (fun t ω => M ω t)
+    (fun t ω => hMr ω t) (Eventually.of_forall hMc) hrat
+  refine ⟨N,hNp,hNr,?_⟩
+  filter_upwards [C.increments,C.nonatomic,C.zero,hNe] with ω hi hn hz he
+  change ∀ t : ℝ≥0, N t ω = M ω t at he
+  obtain ⟨hd,hq,hm,hv⟩ := hM ω ⟨hi,hn⟩
+  refine ⟨?_,?_,?_,?_,?_,?_,?_⟩
+  · rw [he 0]
+    simpa only [NNReal.coe_zero,Rat.cast_zero] using (hq 0).trans hz
+  · intro t
+    rw [he t]
+    exact hd t
+  · intro s t hst
+    change N s ω ≤ N t ω
+    rw [he s,he t]
+    exact hm (NNReal.coe_le_coe.mpr hst)
+  · intro q hq0
+    rw [he _ ,Real.coe_toNNReal _ (Rat.cast_nonneg.mpr hq0)]
+    exact hq q
+  · intro f
+    have hc := (hMc ω f).comp NNReal.continuous_coe
+    simpa only [Function.comp_def,← he] using hc
+  · intro s t hst
+    rw [he s,he t]
+    let : (C.terminal ω).Regular := (C.terminal_radon ω).1
+    exact hi.extension_increment_carried ((hγ ω).comp continuous_real_toNNReal)
+      (M ω) (hMr ω) hq hm (NNReal.coe_le_coe.mpr hst)
+  · intro K hK t₀ ε hε
+    obtain ⟨δ,hδ,hδprop⟩ := hv K hK t₀ ε hε
+    refine ⟨δ,hδ,?_⟩
+    intro s t hs ht A hA hAK
+    rw [he s,he t]
+    exact hδprop s t hs ht A hA hAK
+
+end SLEExactGauge.Multipoint
+
+end
+
+end OAI
diff --git a/lean/OAI/Probability/SLE/Mass/CanonicalMassExhaustion.lean b/lean/OAI/Probability/SLE/Mass/CanonicalMassExhaustion.lean
new file mode 100644
index 0000000000000000000000000000000000000000..624b0b1bec0516150b0702d9929b4ba8f5cef4a0
--- /dev/null
+++ b/lean/OAI/Probability/SLE/Mass/CanonicalMassExhaustion.lean
@@ -0,0 +1,104 @@
+import OAI.Probability.SLE.Mass.CanonicalMassContinuity
+import OAI.Probability.SLE.Geometry.GreenCompactDecay
+import OAI.Probability.SLE.Mass.MonotoneMassExhaustion
+import Mathlib.MeasureTheory.Integral.Lebesgue.Sub
+
+namespace OAI
+
+/-! The actual canonical terminal measure is exhausted by finite times,
+locally in total variation. -/
+
+noncomputable section
+open Set Filter MeasureTheory ProbabilityTheory Classical
+open scoped NNReal ENNReal Topology CompactlySupported
+
+namespace SLEExactGauge.Multipoint
+
+local instance : LocallyCompactSpace upperHalfPlane := isOpen_upperHalfPlane.locallyCompactSpace
+
+lemma RationalCanonicalMass.mass_ambient_measurable
+    {Ω : Type*} [MeasurableSpace Ω] {P : Measure Ω} {κ : ℝ}
+    {B : ℝ≥0 → Ω → ℝ} {hBm : Measurable (Function.uncurry B)}
+    {γ : Ω → ℝ≥0 → ℂ} {G : Ω → ℝ≥0 → ℂ → ℂ}
+    (C : RationalCanonicalMass P κ B hBm γ G) (q : ℚ) : Measurable (C.mass q) :=
+  (C.mass_measurable q).mono (Filtration.le _ _) le_rfl
+
+lemma RationalCanonicalMass.integer_remaining_mean
+    {Ω : Type*} [MeasurableSpace Ω] {P : Measure Ω} {κ : ℝ}
+    {B : ℝ≥0 → Ω → ℝ} {hBm : Measurable (Function.uncurry B)}
+    {γ : Ω → ℝ≥0 → ℂ} {G : Ω → ℝ≥0 → ℂ → ℂ}
+    (C : RationalCanonicalMass P κ B hBm γ G) (K : Set upperHalfPlane) (hK : IsCompact K)
+    (n : ℕ) :
+    (∫⁻ ω, C.terminal ω K-C.mass n ω K ∂P) =
+      P.bind (halfPlaneGreenMeasure κ B γ G n) K := by
+  let : IsFiniteMeasureOnCompacts (initialGreenMeasure κ) := initialGreenMeasure_finite_on_compacts κ
+  have hmm : Measurable (fun ω => C.mass n ω K) :=
+    (Measure.measurable_coe hK.measurableSet).comp (C.mass_ambient_measurable n)
+  have hk := congrArg (fun ρ : Measure upperHalfPlane => ρ K)
+    (C.conditional n univ MeasurableSet.univ)
+  simp only [Measure.restrict_univ,Measure.add_apply,Rat.cast_natCast,
+    Real.toNNReal_natCast] at hk
+  rw [Measure.bind_apply hK.measurableSet C.terminal_measurable.aemeasurable,
+    Measure.bind_apply hK.measurableSet (C.mass_ambient_measurable n).aemeasurable] at hk
+  have htf : (∫⁻ ω, C.terminal ω K ∂P) < ∞ := by
+    rw [← Measure.bind_apply hK.measurableSet C.terminal_measurable.aemeasurable,C.mean]
+    exact hK.measure_lt_top
+  have hmf : (∫⁻ ω, C.mass n ω K ∂P) ≠ ∞ :=
+    (lt_of_le_of_lt (by rw [hk]; exact le_add_right le_rfl) htf).ne
+  have hle : (fun ω => C.mass n ω K) ≤ᵐ[P] (fun ω => C.terminal ω K) :=
+    C.increments.mono (fun _ hω => hω.dominated n K)
+  rw [lintegral_sub hmm hmf hle,hk,ENNReal.add_sub_cancel_left hmf]
+
+theorem RationalCanonicalMass.finite_times_exhaust_terminal
+    {Ω : 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 ω))
+    (C : RationalCanonicalMass P κ B hBm γ G)
+    (N : ℝ≥0 → Ω → Measure upperHalfPlane)
+    (hpath : ∀ᵐ ω ∂P, ContinuousMassPath (γ ω) (fun q => C.mass q ω)
+      (C.terminal ω) (fun t => N t ω)) :
+    ∀ᵐ ω ∂P, ∀ K : Set upperHalfPlane, IsCompact K →
+      Tendsto (fun t : ℝ≥0 => (C.terminal ω-N t ω) K) atTop (𝓝 0) := by
+  let D := localTestFamily upperHalfPlane
+  have hm (n j : ℕ) : Measurable (fun ω => C.terminal ω (D.compactSet j)-C.mass n ω (D.compactSet j)) :=
+    ((Measure.measurable_coe (D.isCompact j).measurableSet).comp C.terminal_measurable).sub
+      ((Measure.measurable_coe (D.isCompact j).measurableSet).comp (C.mass_ambient_measurable n))
+  have ha (j : ℕ) : ∀ᵐ ω ∂P, Antitone (fun n : ℕ => C.terminal ω (D.compactSet j)-C.mass n ω (D.compactSet j)) := by
+    filter_upwards [C.increments] with ω hω
+    intro n m hnm
+    exact tsub_le_tsub_left (hω.monotone (Nat.cast_le.mpr hnm) (D.compactSet j)) _
+  have hmean (j : ℕ) : Tendsto (fun n : ℕ => ∫⁻ ω,
+      C.terminal ω (D.compactSet j)-C.mass n ω (D.compactSet j) ∂P) atTop (𝓝 0) := by
+    simp_rw [C.integer_remaining_mean _ (D.isCompact j)]
+    exact halfPlaneGreenMeasure_compact_mean_tendsto_zero hB hBm hBc hB0 hκ hκ8 γ G F hw _ (D.isCompact j)
+  have hzero (j : ℕ) := ae_tendsto_zero_of_antitone_lintegral P _ (fun n => hm n j) (ha j) (hmean j)
+  filter_upwards [ae_all_iff.mpr hzero,hpath] with ω hz hp
+  let : (C.terminal ω).Regular := (C.terminal_radon ω).1
+  have hD (j : ℕ) : Tendsto (fun t : ℝ≥0 => (C.terminal ω-N t ω) (D.compactSet j))
+      atTop (𝓝 0) := by
+    apply ENNReal.tendsto_atTop_zero.mpr
+    intro ε hε
+    obtain ⟨n,hn⟩ := ENNReal.tendsto_atTop_zero.mp (hz j) ε hε
+    refine ⟨n,fun t ht => ?_⟩
+    have hnat : N n ω = C.mass n ω := by
+      simpa only [Rat.cast_natCast,Real.toNNReal_natCast] using hp.rational n (Nat.cast_nonneg n)
+    have horder : C.mass n ω ≤ N t ω := by rw [← hnat]; exact hp.monotone ht
+    have hdom := hp.dominated t
+    let : IsFiniteMeasureOnCompacts (N t ω) :=
+      ⟨fun K hK => lt_of_le_of_lt (hdom K) hK.measure_lt_top⟩
+    rw [sub_apply_of_finite_restriction hdom (D.isCompact j).measurableSet
+      (D.isCompact j).measure_lt_top.ne]
+    exact (tsub_le_tsub_left (horder _) _).trans (hn n le_rfl)
+  intro K hK
+  obtain ⟨j,hj⟩ := D.exhaustive K hK
+  exact tendsto_of_tendsto_of_tendsto_of_le_of_le tendsto_const_nhds (hD j)
+    (fun _ => zero_le) (fun t => measure_mono hj)
+
+end SLEExactGauge.Multipoint
+
+end
+
+end OAI
diff --git a/lean/OAI/Probability/SLE/Mass/CanonicalMassExtendedRestart.lean b/lean/OAI/Probability/SLE/Mass/CanonicalMassExtendedRestart.lean
new file mode 100644
index 0000000000000000000000000000000000000000..de5f178005a37c33942df5b2c2e5a94178c05bea
--- /dev/null
+++ b/lean/OAI/Probability/SLE/Mass/CanonicalMassExtendedRestart.lean
@@ -0,0 +1,102 @@
+import OAI.Probability.SLE.Mass.CanonicalMassRestart
+import OAI.Probability.SLE.Geometry.ExtendedStopLocalization
+
+namespace OAI
+
+/-! Pathwise canonical restart at every possibly infinite stopping time,
+on its finite event, simultaneously for all finite and terminal later times. -/
+
+noncomputable section
+open Set Filter _root_.MeasureTheory _root_.OAI.MeasureTheory ProbabilityTheory Classical
+open scoped NNReal ENNReal Topology
+
+namespace SLEExactGauge.Multipoint
+
+local instance extendedRestartDriverMeasurable : MeasurableSpace C(ℝ≥0,ℝ) := borel _
+local instance extendedRestartDriverBorel : BorelSpace C(ℝ≥0,ℝ) := ⟨rfl⟩
+
+variable {Ω : Type*} [MeasurableSpace Ω] {P : Measure Ω} [IsProbabilityMeasure P]
+  {κ : ℝ} {B : ℝ≥0 → Ω → ℝ} {hBm : Measurable (Function.uncurry B)}
+  {γ : Ω → ℝ≥0 → ℂ} {G : Ω → ℝ≥0 → ℂ → ℂ}
+
+/-- One raw functional works at every stopping time. The equality is of
+whole measures, hence permits random later times and nonnegative Borel tests. -/
+theorem CanonicalMass.exists_raw_all_stopping_restart
+    (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 ω))
+    (hpublished : PublishedTraceGeneration (P.map (sourceDriverPath B hc)) κ (fun t p => p t)) :
+    ∃ 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
+  obtain ⟨R,he,hr⟩ := C.exists_raw_pathwise_restart hB hc hκ F hw hpublished
+  refine ⟨R,he,?_⟩
+  intro S hS
+  let ℱ := Filtration.natural B (fun s =>
+    (hBm.comp (measurable_const.prodMk measurable_id) : Measurable (B s)).stronglyMeasurable)
+  let Q : Ω → ℝ≥0 → Prop := fun ω T => ∀ u : ℝ≥0∞,
+    extendedCanonicalMass C.process C.rational.terminal ((T:ℝ≥0∞)+u) ω-C.process T ω =
+      weightedImageMass (stoppedMassPoint B κ γ G F hw (fun _ => T) ω)
+        (stoppedMassWeight B κ F (fun _ => T) ω)
+        (extendedCanonicalMass R.process R.terminal u
+          (sourceRestartDriverPath B hc (fun _ => T) ω))
+  have hQ (n : ℕ) : ∀ᵐ ω ∂P, Q ω (cutoffStop S n ω) := by
+    have hτ := cutoffStop_stopping ℱ S hS (n:ℝ≥0)
+    filter_upwards [hr (cutoffStop S n) hτ] with ω hω
+    have hp : stoppedMassPoint B κ γ G F hw (cutoffStop S n) ω =
+        stoppedMassPoint B κ γ G F hw (fun _ => cutoffStop S n ω) ω := by
+      funext z
+      apply Subtype.ext
+      rfl
+    have hv : stoppedMassWeight B κ F (cutoffStop S n) ω =
+        stoppedMassWeight B κ F (fun _ => cutoffStop S n ω) ω := rfl
+    have hy : sourceRestartDriverPath B hc (cutoffStop S n) ω =
+        sourceRestartDriverPath B hc (fun _ => cutoffStop S n ω) ω := by
+      ext t
+      rfl
+    intro u
+    by_cases hu : u=∞
+    · subst u
+      have ht := hω.2
+      unfold stoppedFreshTerminalMass at ht
+      rw [hp,hv,hy] at ht
+      simpa only [Q,add_top,extendedCanonicalMass,lt_self_iff_false,ite_false] using ht
+    · lift u to ℝ≥0 using hu with t
+      have ht := hω.1 t
+      unfold stoppedFreshMass at ht
+      rw [hp,hv,hy] at ht
+      simpa only [Q,← ENNReal.coe_add,extendedCanonicalMass,ENNReal.coe_lt_top,
+        ite_true,ENNReal.toNNReal_coe] using ht
+  filter_upwards [ae_of_cutoffStop S P Q hQ] with ω hω
+  intro hf u
+  have hp : stoppedMassPoint B κ γ G F hw (fun ω => (S ω).untopD (0:ℝ≥0)) ω =
+      stoppedMassPoint B κ γ G F hw (fun _ => (S ω).untopD (0:ℝ≥0)) ω := by
+    funext z
+    apply Subtype.ext
+    rfl
+  have hv : stoppedMassWeight B κ F (fun ω => (S ω).untopD (0:ℝ≥0)) ω =
+      stoppedMassWeight B κ F (fun _ => (S ω).untopD (0:ℝ≥0)) ω := rfl
+  have hy : sourceRestartDriverPath B hc (fun ω => (S ω).untopD (0:ℝ≥0)) ω =
+      sourceRestartDriverPath B hc (fun _ => (S ω).untopD (0:ℝ≥0)) ω := by
+    ext t
+    rfl
+  rw [hp,hv,hy]
+  exact hω hf u
+
+end SLEExactGauge.Multipoint
+
+end
+
+end OAI
diff --git a/lean/OAI/Probability/SLE/Mass/CanonicalMassFirstVisit.lean b/lean/OAI/Probability/SLE/Mass/CanonicalMassFirstVisit.lean
new file mode 100644
index 0000000000000000000000000000000000000000..e6ce47fc61526fdc8f573b80bbd21f1a3afc7ae6
--- /dev/null
+++ b/lean/OAI/Probability/SLE/Mass/CanonicalMassFirstVisit.lean
@@ -0,0 +1,80 @@
+import OAI.Probability.SLE.Mass.CanonicalMassRemaining
+
+namespace OAI
+
+/-! At each fixed time the canonical mass is the terminal measure
+restricted to the already visited trace. -/
+
+noncomputable section
+open Set Filter _root_.MeasureTheory _root_.OAI.MeasureTheory ProbabilityTheory Classical
+open scoped NNReal ENNReal Topology CompactlySupported
+
+namespace SLEExactGauge.Multipoint
+
+local instance : LocallyCompactSpace upperHalfPlane := isOpen_upperHalfPlane.locallyCompactSpace
+
+lemma halfPlaneStoppingGreenMeasure_const
+    {Ω : Type*} (κ : ℝ) (B : ℝ≥0 → Ω → ℝ)
+    (γ : Ω → ℝ≥0 → ℂ) (G : Ω → ℝ≥0 → ℂ → ℂ) (t : ℝ≥0) :
+    halfPlaneStoppingGreenMeasure κ B γ G (fun _ => (t:ℝ≥0∞)) =
+      halfPlaneGreenMeasure κ B γ G t := by
+  funext ω
+  simp only [halfPlaneStoppingGreenMeasure,stoppingGreen,ENNReal.coe_lt_top,
+    ite_true,ENNReal.toNNReal_coe,halfPlaneGreenMeasure]
+
+theorem CanonicalMass.atTime_eq_restrict_past
+    {Ω : Type*} [MeasurableSpace Ω] {P : Measure Ω} {κ : ℝ}
+    {B : ℝ≥0 → Ω → ℝ} (hB : IsBrownianReal B P)
+    (hBm : Measurable (Function.uncurry B))
+    (hBc : ∀ ω, Continuous (fun t => B t ω)) (hB0 : ∀ ω, B 0 ω = 0)
+    (hκ : 0 < κ) (hκ8 : κ < 8)
+    {γ : Ω → ℝ≥0 → ℂ} {G : Ω → ℝ≥0 → ℂ → ℂ}
+    (F : Ω → ℝ≥0 → ℂ → ℂ)
+    (hw : ∀ ω, IsCapacityTwoWitness (fun t => Real.sqrt κ * B t ω) (γ ω) (G ω) (F ω))
+    (C : CanonicalMass P κ B hBm γ G) (t : ℝ≥0) :
+    ∀ᵐ ω ∂P, C.atTime t ω = (C.rational.terminal ω).restrict
+      {z : upperHalfPlane | (z:ℂ) ∈ γ ω '' Icc 0 t} := by
+  let ℱ := Filtration.natural B (fun r =>
+    (hBm.comp (measurable_const.prodMk measurable_id) : Measurable (B r)).stronglyMeasurable)
+  have hstop : IsStoppingTime ℱ (fun _ => (t:WithTop ℝ≥0)) := isStoppingTime_const ℱ t
+  obtain ⟨η,hηm,hηr,hηsum,hηkernel⟩ := C.exists_remaining_kernel _ hstop
+  have hevent (E : Set Ω) (hE : MeasurableSet[ℱ t] E) :
+      (P.restrict E).bind η = (P.restrict E).bind (halfPlaneGreenMeasure κ B γ G t) := by
+    rw [← halfPlaneStoppingGreenMeasure_const κ B γ G t]
+    apply hηkernel E
+    change MeasurableSet[(isStoppingTime_const ℱ t).measurableSpace] E
+    rw [IsStoppingTime.measurableSpace_const]
+    exact hE
+  have hfuture := ae_remainder_carried_by_surviving hB hBm hBc hB0 hκ hκ8 γ G F hw
+    t η hηm (fun ω => (hηr ω).2) hevent
+  have hlim := C.rational.all_finite_times_limit hBc hκ hκ8 F hw C.process C.radon C.paths
+  filter_upwards [hηsum,hfuture,hlim] with ω hsum hfuture hlim
+  let A : Set upperHalfPlane := {z | (z:ℂ) ∈ γ ω '' Icc 0 t}
+  have hA : MeasurableSet A :=
+    ((isCompact_Icc.image (hw ω).1).isClosed.preimage continuous_subtype_val).measurableSet
+  let : (C.atTime t ω).Regular := (C.atTime_radon t ω).1
+  have hpast : C.atTime t ω Aᶜ = 0 := by
+    have hh := convex_level_radon_limit_carried_by_past ω (hBc ω) (hw ω) t (fun n => (n:ℝ))
+      tendsto_natCast_atTop_atTop C.rational.supports C.rational.weights
+      (C.atTime t ω) (by
+        simpa only [CanonicalMass.atTime,extendedCanonicalMass,ENNReal.coe_lt_top,
+          ite_true,ENNReal.toNNReal_coe] using hlim t)
+    exact hh
+  have hηA : η ω A = 0 := by
+    apply le_zero_iff.mp
+    apply (measure_mono (show A ⊆ {z : upperHalfPlane | (z:ℂ) ∉ survivingDomain (γ ω) t} from ?_)).trans_eq hfuture
+    intro z hz hs
+    exact hs.1.2 hz
+  have hrestr : (C.atTime t ω).restrict A = C.atTime t ω := by
+    apply Measure.restrict_eq_self_of_ae_mem
+    filter_upwards [measure_eq_zero_iff_ae_notMem.mp hpast] with z hz
+    exact not_not.mp hz
+  change C.atTime t ω = (C.rational.terminal ω).restrict A
+  rw [← hsum,Measure.restrict_add,Measure.restrict_eq_zero.mpr hηA,zero_add]
+  exact hrestr.symm
+
+end SLEExactGauge.Multipoint
+
+end
+
+end OAI
diff --git a/lean/OAI/Probability/SLE/Mass/CanonicalMassImageRestart.lean b/lean/OAI/Probability/SLE/Mass/CanonicalMassImageRestart.lean
new file mode 100644
index 0000000000000000000000000000000000000000..2e51f22aeddf342667f20ce807877f1b58b6c9c4
--- /dev/null
+++ b/lean/OAI/Probability/SLE/Mass/CanonicalMassImageRestart.lean
@@ -0,0 +1,68 @@
+import OAI.Probability.SLE.Mass.CanonicalMassExtendedRestart
+import OAI.Probability.SLE.Geometry.ConformalRestartTransport
+
+namespace OAI
+
+/-! The same raw functional and the same restart event work in every fixed
+conformal image. No image-dependent extraction or exceptional set is needed. -/
+
+noncomputable section
+open Set Filter _root_.MeasureTheory _root_.OAI.MeasureTheory ProbabilityTheory Classical
+open scoped NNReal ENNReal Topology
+
+namespace SLEExactGauge.Multipoint
+
+local instance imageRestartDriverMeasurable : MeasurableSpace C(ℝ≥0,ℝ) := borel _
+local instance imageRestartDriverBorel : BorelSpace C(ℝ≥0,ℝ) := ⟨rfl⟩
+
+variable {Ω : Type*} [MeasurableSpace Ω] {P : Measure Ω} [IsProbabilityMeasure P]
+  {κ : ℝ} {B : ℝ≥0 → Ω → ℝ} {hBm : Measurable (Function.uncurry B)}
+  {γ : Ω → ℝ≥0 → ℂ} {G : Ω → ℝ≥0 → ℂ → ℂ}
+
+/-- Every fixed conformal image inherits the pathwise restart identity,
+with the same raw functional and one event for all image maps and later times. -/
+theorem CanonicalMass.exists_raw_all_image_restart
+    (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 ω))
+    (hpublished : PublishedTraceGeneration (P.map (sourceDriverPath B hc)) κ (fun t p => p t)) :
+    ∃ 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
+  obtain ⟨R,he,hr⟩ := C.exists_raw_all_stopping_restart hB hc hκ F hw hpublished
+  refine ⟨R,he,?_⟩
+  intro S hS
+  filter_upwards [hr S hS,C.paths] with ω hω hp
+  intro hf D J w u
+  let T := (S ω).untopD (0:ℝ≥0)
+  have hle : C.process T ω ≤ C.atTime ((T:ℝ≥0∞)+u) ω := by
+    by_cases hu : u=∞
+    · subst u
+      simpa only [CanonicalMass.atTime,add_top,extendedCanonicalMass,lt_self_iff_false,ite_false]
+        using hp.dominated T
+    · lift u to ℝ≥0 using hu with t
+      simpa only [CanonicalMass.atTime,← ENNReal.coe_add,extendedCanonicalMass,
+        ENNReal.coe_lt_top,ite_true,ENNReal.toNNReal_coe] using
+          hp.monotone (le_add_of_nonneg_right (show 0 ≤ t from zero_le))
+  let := (C.atTime_radon ((T:ℝ≥0∞)+u) ω).2
+  rw [← conformalMass_sub J w hle]
+  exact congrArg (conformalMass J w) (hω hf u)
+
+end SLEExactGauge.Multipoint
+
+end
+
+end OAI
diff --git a/lean/OAI/Probability/SLE/Mass/CanonicalMassNontrivial.lean b/lean/OAI/Probability/SLE/Mass/CanonicalMassNontrivial.lean
new file mode 100644
index 0000000000000000000000000000000000000000..33f2fd9feeda12dac77accfb464ae7153af8d8a4
--- /dev/null
+++ b/lean/OAI/Probability/SLE/Mass/CanonicalMassNontrivial.lean
@@ -0,0 +1,74 @@
+import OAI.Probability.SLE.Mass.CanonicalMassConstruction
+import OAI.Probability.SLE.Mass.RadonTerminalUniqueness
+import OAI.Probability.SLE.Geometry.RestartInitialGreenIntegral
+
+namespace OAI
+
+/-! Positive initial Green mass and terminal exhaustion give a positive
+probability of nonzero canonical mass at a finite deterministic time. -/
+
+noncomputable section
+open Set Filter _root_.MeasureTheory _root_.OAI.MeasureTheory ProbabilityTheory
+open scoped NNReal ENNReal Topology
+
+namespace SLEExactGauge.Multipoint
+
+lemma initialGreenMeasure_univ_pos (κ : ℝ) : 0 < initialGreenMeasure κ univ := by
+  have hm : Measurable (fun z : ℂ => ENNReal.ofReal (initialGreen κ z)) := by
+    unfold initialGreen
+    fun_prop
+  have he : initialGreenMeasure κ univ =
+      ∫⁻ z in upperHalfPlane, ENNReal.ofReal (initialGreen κ z) ∂volume := by
+    simpa only [lintegral_const,Measure.restrict_univ,one_mul] using
+      initialGreenMeasure_lintegral κ (fun _ => 1)
+  rw [he,lintegral_pos_iff_support hm,Measure.restrict_apply (measurableSet_support hm)]
+  have hs : Function.support (fun z : ℂ => ENNReal.ofReal (initialGreen κ z)) ∩ upperHalfPlane =
+      upperHalfPlane := by
+    ext z
+    constructor
+    · exact fun h => h.2
+    · intro hz
+      exact ⟨(ENNReal.ofReal_pos.mpr (initialGreen_pos κ z hz)).ne',hz⟩
+  rw [hs]
+  exact isOpen_upperHalfPlane.measure_pos (μ:=volume) ⟨Complex.I,by simp [upperHalfPlane]⟩
+
+namespace CanonicalMass
+
+local instance : LocallyCompactSpace upperHalfPlane := isOpen_upperHalfPlane.locallyCompactSpace
+
+variable {Ω : Type*} [MeasurableSpace Ω] {P : Measure Ω} {κ : ℝ}
+  {B : ℝ≥0 → Ω → ℝ} {hBm : Measurable (Function.uncurry B)}
+  {γ : Ω → ℝ≥0 → ℂ} {G : Ω → ℝ≥0 → ℂ → ℂ}
+  (C : CanonicalMass P κ B hBm γ G)
+
+lemma exists_nonzero_finite_time : ∃ n : ℕ, 0<P {ω | C.process n ω≠0} := by
+  by_contra! hzero
+  have hn (n : ℕ) : ∀ᵐ ω ∂P, C.process n ω=0 := by
+    rw [ae_iff]
+    exact le_zero_iff.mp (hzero n)
+  have ht : ∀ᵐ ω ∂P, ∀ t, C.process t ω=0 := by
+    filter_upwards [ae_all_iff.mpr hn,C.paths] with ω hω hp
+    intro t
+    obtain ⟨n,hn⟩ := exists_nat_ge (t:ℝ)
+    have hle := hp.monotone (show t≤(n:ℝ≥0) by exact_mod_cast hn)
+    rw [hω n] at hle
+    exact le_antisymm hle bot_le
+  have hterminal : C.rational.terminal =ᵐ[P] (fun _ => 0) := by
+    filter_upwards [ht,C.paths,C.exhaustion] with ω hω hp he
+    let := (C.rational.terminal_radon ω).1
+    apply radon_terminal_eq_of_common_exhaustion (C.rational.terminal ω) 0
+      (fun t => C.process t ω) hp.dominated (fun t => by rw [hω t]) he
+    intro K hK
+    simp only [Measure.zero_sub,Measure.coe_zero,Pi.zero_apply]
+    exact tendsto_const_nhds
+  have hmean : initialGreenMeasure κ=0 := by
+    rw [← C.rational.mean,Measure.bind_congr_right hterminal,Measure.bind_zero_right']
+  have hp := initialGreenMeasure_univ_pos κ
+  simp only [hmean,Measure.coe_zero,Pi.zero_apply,lt_self_iff_false] at hp
+
+end CanonicalMass
+end SLEExactGauge.Multipoint
+
+end
+
+end OAI
diff --git a/lean/OAI/Probability/SLE/Mass/CanonicalMassPositiveReduction.lean b/lean/OAI/Probability/SLE/Mass/CanonicalMassPositiveReduction.lean
new file mode 100644
index 0000000000000000000000000000000000000000..eeb3328bb676434e3e8f983269603bf96d816c34
--- /dev/null
+++ b/lean/OAI/Probability/SLE/Mass/CanonicalMassPositiveReduction.lean
@@ -0,0 +1,65 @@
+import OAI.Probability.SLE.Mass.PositiveMassGerm
+import OAI.Probability.SLE.Mass.CanonicalMassNontrivial
+
+namespace OAI
+
+/-! The remaining scaling link in positive canonical mass: equal
+nonzero-mass probabilities at positive times suffice, with the Green
+mean and the Brownian germ argument already proved. -/
+
+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)
+
+theorem positive_all_times_of_scaling
+    (hB : IsBrownianReal B P)
+    (hc : ∀ ω, Continuous (fun t => B t ω)) (h0 : ∀ ω, B 0 ω=0)
+    (hscale : ∀ s t : ℝ≥0, 0<s → 0<t →
+      P {ω | C.process s ω≠0}=P {ω | C.process t ω≠0}) :
+    ∀ᵐ ω ∂P, ∀ t : ℝ≥0, 0<t → C.process t ω≠0 := by
+  obtain ⟨n,hn⟩ := C.exists_nonzero_finite_time
+  have hN : 0<P {ω | C.process (n+1) ω≠0} := by
+    apply hn.trans_le
+    apply measure_mono_ae
+    filter_upwards [C.paths] with ω hω
+    intro hp
+    have hle := hω.monotone (show (n:ℝ≥0)≤n+1 from le_add_of_nonneg_right zero_le)
+    intro hz
+    apply hp
+    rw [hz] at hle
+    exact le_antisymm hle bot_le
+  let ε : ℕ → ℝ≥0 := fun j => 1/((j:ℝ≥0)+1)
+  have hεp (j : ℕ) : 0<ε j := by dsimp [ε]; positivity
+  have hεa : Antitone ε := by
+    intro i j hij
+    exact one_div_le_one_div_of_le (by positivity) (by exact_mod_cast Nat.add_le_add_right hij 1)
+  have hε : Tendsto ε atTop (𝓝 0) := tendsto_one_div_add_atTop_nhds_zero_nat
+  have hZa : Adapted (Filtration.natural B (fun r =>
+      (hBm.comp (measurable_const.prodMk measurable_id) : Measurable (B r)).stronglyMeasurable))
+      (fun t ω => C.process t ω univ) := by
+    intro t
+    exact (Measure.measurable_coe MeasurableSet.univ).comp (C.progressive.adapted t)
+  have hZm : ∀ᵐ ω ∂P, Monotone (fun t => C.process t ω univ) :=
+    C.paths.mono (fun _ h => fun _ _ hst => h.monotone hst univ)
+  have hp := positive_mass_all_times_of_uniform_probability hB
+    (fun r => (hBm.comp (measurable_const.prodMk measurable_id) : Measurable (B r))) hc h0
+    (fun t ω => C.process t ω univ) hZa hZm ε hεa hε
+    (P {ω | C.process (n+1) ω≠0}) hN (fun j => by
+      simp only [Measure.measure_univ_pos]
+      exact le_of_eq (hscale (n+1) (ε j) (by positivity) (hεp j)))
+  filter_upwards [hp] with ω hω
+  intro t ht
+  exact Measure.measure_univ_pos.mp (hω t ht)
+
+end SLEExactGauge.Multipoint.CanonicalMass
+
+end
+
+end OAI
diff --git a/lean/OAI/Probability/SLE/Mass/CanonicalMassRandomTime.lean b/lean/OAI/Probability/SLE/Mass/CanonicalMassRandomTime.lean
new file mode 100644
index 0000000000000000000000000000000000000000..d741ea1858fdef24b202f920c60a9e0506bba38c
--- /dev/null
+++ b/lean/OAI/Probability/SLE/Mass/CanonicalMassRandomTime.lean
@@ -0,0 +1,190 @@
+import OAI.Probability.SLE.Mass.CanonicalMassAllTimes
+import OAI.Probability.SLE.Mass.LevelStoppingConvex
+import OAI.Probability.SLE.Mass.NonnegativeL2Passage
+
+namespace OAI
+
+/-! Evaluating the common convex sequence at any measurable extended time
+preserves convergence in mean on every event. -/
+
+noncomputable section
+open Set Filter MeasureTheory ProbabilityTheory Classical
+open scoped NNReal ENNReal Topology CompactlySupported
+
+namespace SLEExactGauge.Multipoint
+
+local instance : LocallyCompactSpace upperHalfPlane := isOpen_upperHalfPlane.locallyCompactSpace
+
+def extendedCanonicalMass {Ω : Type*} (N : ℝ≥0 → Ω → Measure upperHalfPlane)
+    (ν : Ω → Measure upperHalfPlane) (t : ℝ≥0∞) (ω : Ω) : Measure upperHalfPlane :=
+  if t < ∞ then N t.toNNReal ω else ν ω
+
+lemma extendedCanonicalMass_radon
+    {Ω : Type*} (N : ℝ≥0 → Ω → Measure upperHalfPlane) (ν : Ω → Measure upperHalfPlane)
+    (hN : ∀ t ω, (N t ω).Regular ∧ IsFiniteMeasureOnCompacts (N t ω))
+    (hν : ∀ ω, (ν ω).Regular ∧ IsFiniteMeasureOnCompacts (ν ω)) (t : ℝ≥0∞) (ω : Ω) :
+    (extendedCanonicalMass N ν t ω).Regular ∧
+      IsFiniteMeasureOnCompacts (extendedCanonicalMass N ν t ω) := by
+  unfold extendedCanonicalMass
+  split_ifs
+  · exact hN _ _
+  · exact hν _
+
+theorem RationalCanonicalMass.all_extended_times_limit
+    {Ω : Type*} [MeasurableSpace Ω] {P : Measure Ω} {κ : ℝ}
+    {B : ℝ≥0 → Ω → ℝ} {hBm : Measurable (Function.uncurry B)}
+    (hBc : ∀ ω, Continuous (fun t => B t ω)) (hκ : 0 < κ) (hκ8 : κ < 8)
+    {γ : Ω → ℝ≥0 → ℂ} {G : Ω → ℝ≥0 → ℂ → ℂ}
+    (F : Ω → ℝ≥0 → ℂ → ℂ)
+    (hw : ∀ ω, IsCapacityTwoWitness (fun t => Real.sqrt κ * B t ω) (γ ω) (G ω) (F ω))
+    (C : RationalCanonicalMass P κ B hBm γ G)
+    (N : ℝ≥0 → Ω → Measure upperHalfPlane)
+    (hNr : ∀ t ω, (N t ω).Regular ∧ IsFiniteMeasureOnCompacts (N t ω))
+    (hpath : ∀ᵐ ω ∂P, ContinuousMassPath (γ ω) (fun q => C.mass q ω)
+      (C.terminal ω) (fun t => N t ω)) :
+    ∀ᵐ ω ∂P, ∀ (t : ℝ≥0∞) (f : C_c(upperHalfPlane,ℝ)),
+      Tendsto (fun n => ∫ z, f z ∂convexLevelMeasure κ B γ G (fun n => (n:ℝ))
+        C.supports C.weights n t ω) atTop
+        (𝓝 (∫ z, f z ∂extendedCanonicalMass N C.terminal t ω)) := by
+  filter_upwards [C.all_finite_times_limit hBc hκ hκ8 F hw N hNr hpath,C.terminal_limit]
+    with ω hf ht
+  intro t f
+  by_cases h : t < ∞
+  · simpa only [extendedCanonicalMass,ite_eq_left h,ENNReal.coe_toNNReal h.ne] using hf t.toNNReal f
+  · have he : t = ∞ := top_le_iff.mp (le_of_not_gt h)
+    simpa only [he,extendedCanonicalMass,lt_self_iff_false,ite_false] using ht f
+
+theorem RationalCanonicalMass.random_time_nonnegative_mean_tendsto
+    {Ω : Type*} [MeasurableSpace Ω] {P : Measure Ω} {κ : ℝ}
+    {B : ℝ≥0 → Ω → ℝ} (hB : IsBrownianReal B P)
+    (hBm : Measurable (Function.uncurry B))
+    (hBc : ∀ ω, Continuous (fun t => B t ω)) (hB0 : ∀ ω, B 0 ω = 0)
+    (hκ : 0 < κ) (hκ8 : κ < 8)
+    {γ : Ω → ℝ≥0 → ℂ} {G : Ω → ℝ≥0 → ℂ → ℂ}
+    (F : Ω → ℝ≥0 → ℂ → ℂ)
+    (hw : ∀ ω, IsCapacityTwoWitness (fun t => Real.sqrt κ * B t ω) (γ ω) (G ω) (F ω))
+    (hgrowth : PublishedDiskUnivalentGrowth)
+    (C : RationalCanonicalMass P κ B hBm γ G)
+    (N : ℝ≥0 → Ω → Measure upperHalfPlane)
+    (hNr : ∀ t ω, (N t ω).Regular ∧ IsFiniteMeasureOnCompacts (N t ω))
+    (hpath : ∀ᵐ ω ∂P, ContinuousMassPath (γ ω) (fun q => C.mass q ω)
+      (C.terminal ω) (fun t => N t ω))
+    (S : Ω → ℝ≥0∞) (hS : Measurable S) (E : Set Ω)
+    (f : C_c(upperHalfPlane,ℝ)) (hf : ∀ z, 0 ≤ f z) :
+    Integrable (fun ω => ∫ z, f z ∂extendedCanonicalMass N C.terminal (S ω) ω) (P.restrict E) ∧
+      Tendsto (fun n => ∫ ω in E, (∫ z, f z ∂convexLevelMeasure κ B γ G (fun n => (n:ℝ))
+        C.supports C.weights n (S ω) ω) ∂P) atTop
+        (𝓝 (∫ ω in E, (∫ z, f z ∂extendedCanonicalMass N C.terminal (S ω) ω) ∂P)) := by
+  let : IsProbabilityMeasure P := hB.isGaussianProcess.isProbabilityMeasure
+  let hm (t : ℝ≥0) : Measurable (B t) := hBm.comp (measurable_const.prodMk measurable_id)
+  let M (n : ℕ) (t : ℝ≥0∞) (ω : Ω) := convexLevelMeasure κ B γ G (fun n => (n:ℝ))
+    C.supports C.weights n t ω
+  let (n : ℕ) (t : ℝ≥0∞) (ω : Ω) : IsFiniteMeasureOnCompacts (M n t ω) :=
+    convexLevelMeasure_finite_on_compacts hκ hκ8 γ G F ω (hBc ω) (hw ω) _ C.supports C.weights n t
+  let X (n : ℕ) (ω : Ω) := ∫ z, f z ∂M n (S ω) ω
+  let Z (n : ℕ) (ω : Ω) := ∫ z, f z ∂M n ∞ ω
+  have hXm (n : ℕ) : Measurable (X n) :=
+    measurable_halfPlane_compact_test_integral _
+      (convexLevelMeasure_random_time_measurable hm hBc κ γ G F hw _
+        (fun n => Nat.cast_nonneg n) C.supports C.weights n S hS)
+      (fun _ => inferInstance) f
+  have hZm (n : ℕ) : Measurable (Z n) :=
+    convexLevelMeasure_test_measurable hm hBc hκ hκ8 γ G F hw _
+      (fun n => Nat.cast_nonneg n) C.supports C.weights C.weights_nonneg n ∞ f
+  obtain ⟨A,hA,hbound⟩ := uniform_convexLevelMeasure_test_moments hB hm hBm hBc hB0 hκ hκ8
+    γ G F hw hgrowth (fun n => (n:ℝ)) (fun n => Nat.cast_nonneg n)
+    C.supports C.weights C.weights_nonneg C.weights_sum f hf 2
+  have hZ (n : ℕ) := memLp_two_of_nonnegative_square_bound P (Z n) (hZm n)
+    (fun _ => integral_nonneg hf) A hA (hbound n ∞)
+  have hXZ (n : ℕ) (ω : Ω) : X n ω ≤ Z n ω :=
+    integral_mono_measure (convexLevelMeasure_mono κ B γ G (fun n => (n:ℝ))
+      C.supports C.weights n ω le_top) (ae_of_all _ hf) f.integrable
+  apply integral_tendsto_of_nonnegative_L2_domination (P.restrict E) X Z _ hXm
+    (fun _ _ => integral_nonneg hf) hXZ (fun n => (hZ n).1.restrict E) A.toReal
+  · intro n
+    exact (integral_mono_measure Measure.restrict_le_self
+      (ae_of_all _ (fun ω => sq_nonneg (Z n ω))) (hZ n).1.integrable_sq).trans (hZ n).2
+  · filter_upwards [ae_restrict_of_ae (C.all_extended_times_limit hBc hκ hκ8 F hw N hNr hpath)]
+      with ω hω
+    exact hω (S ω) f
+
+lemma convexLevelMeasure_random_time_test_integrable
+    {Ω : Type*} [MeasurableSpace Ω] {P : Measure Ω}
+    {B : ℝ≥0 → Ω → ℝ} (hB : IsBrownianReal B P)
+    (hBm : Measurable (Function.uncurry B))
+    (hBc : ∀ ω, Continuous (fun t => B t ω)) (hB0 : ∀ ω, B 0 ω = 0)
+    {κ : ℝ} (hκ : 0 < κ) (hκ8 : κ < 8)
+    (γ : Ω → ℝ≥0 → ℂ) (G F : Ω → ℝ≥0 → ℂ → ℂ)
+    (hw : ∀ ω, IsCapacityTwoWitness (fun t => Real.sqrt κ * B t ω) (γ ω) (G ω) (F ω))
+    (u : ℕ → ℝ) (hu : ∀ n, 0 ≤ u n) (s : ℕ → Finset ℕ) (w : ℕ → ℕ → ℝ)
+    (hw₀ : ∀ n i, i ∈ s n → 0 ≤ w n i) (hw₁ : ∀ n, ∑ i ∈ s n, w n i = 1)
+    (n : ℕ) (S : Ω → ℝ≥0∞) (hS : Measurable S) (E : Set Ω)
+    (f : C_c(upperHalfPlane,ℝ)) :
+    Integrable (fun ω => ∫ z, f z ∂convexLevelMeasure κ B γ G u s w n (S ω) ω)
+      (P.restrict E) := by
+  let hm (t : ℝ≥0) : Measurable (B t) := hBm.comp (measurable_const.prodMk measurable_id)
+  have hμm := convexLevelMeasure_random_time_measurable hm hBc κ γ G F hw u hu s w n S hS
+  have hνm := convexLevelMeasure_measurable hm hBc κ γ G F hw u hu s w n ∞
+  have hle := restricted_bind_le_of_ae_le P _ _ hμm hνm
+    (ae_of_all _ (fun ω => convexLevelMeasure_mono κ B γ G u s w n ω le_top)) E
+  rw [convexLevelMeasure_terminal_mean hB hm hBm hBc hB0 hκ hκ8 γ G F hw u hu s w hw₀ hw₁] at hle
+  let : IsFiniteMeasureOnCompacts (initialGreenMeasure κ) := initialGreenMeasure_finite_on_compacts κ
+  exact (integrable_integral_bind_of_sections (P.restrict E) _ hμm f f.continuous.measurable
+    (fun ω => by
+      let := convexLevelMeasure_finite_on_compacts hκ hκ8 γ G F ω (hBc ω) (hw ω) u s w n (S ω)
+      exact f.integrable) (f.integrable.mono_measure hle)).1
+
+theorem RationalCanonicalMass.random_time_test_mean_tendsto
+    {Ω : Type*} [MeasurableSpace Ω] {P : Measure Ω} {κ : ℝ}
+    {B : ℝ≥0 → Ω → ℝ} (hB : IsBrownianReal B P)
+    (hBm : Measurable (Function.uncurry B))
+    (hBc : ∀ ω, Continuous (fun t => B t ω)) (hB0 : ∀ ω, B 0 ω = 0)
+    (hκ : 0 < κ) (hκ8 : κ < 8)
+    {γ : Ω → ℝ≥0 → ℂ} {G : Ω → ℝ≥0 → ℂ → ℂ}
+    (F : Ω → ℝ≥0 → ℂ → ℂ)
+    (hw : ∀ ω, IsCapacityTwoWitness (fun t => Real.sqrt κ * B t ω) (γ ω) (G ω) (F ω))
+    (hgrowth : PublishedDiskUnivalentGrowth)
+    (C : RationalCanonicalMass P κ B hBm γ G)
+    (N : ℝ≥0 → Ω → Measure upperHalfPlane)
+    (hNr : ∀ t ω, (N t ω).Regular ∧ IsFiniteMeasureOnCompacts (N t ω))
+    (hpath : ∀ᵐ ω ∂P, ContinuousMassPath (γ ω) (fun q => C.mass q ω)
+      (C.terminal ω) (fun t => N t ω))
+    (S : Ω → ℝ≥0∞) (hS : Measurable S) (E : Set Ω)
+    (f : C_c(upperHalfPlane,ℝ)) :
+    Integrable (fun ω => ∫ z, f z ∂extendedCanonicalMass N C.terminal (S ω) ω) (P.restrict E) ∧
+      Tendsto (fun n => ∫ ω in E, (∫ z, f z ∂convexLevelMeasure κ B γ G (fun n => (n:ℝ))
+        C.supports C.weights n (S ω) ω) ∂P) atTop
+        (𝓝 (∫ ω in E, (∫ z, f z ∂extendedCanonicalMass N C.terminal (S ω) ω) ∂P)) := by
+  let fp := f ⊔ 0
+  let fm := (-f) ⊔ 0
+  have hp := C.random_time_nonnegative_mean_tendsto hB hBm hBc hB0 hκ hκ8 F hw hgrowth
+    N hNr hpath S hS E fp (fun _ => le_sup_of_le_right le_rfl)
+  have hn := C.random_time_nonnegative_mean_tendsto hB hBm hBc hB0 hκ hκ8 F hw hgrowth
+    N hNr hpath S hS E fm (fun _ => le_sup_of_le_right le_rfl)
+  have hsplit (ρ : Measure upperHalfPlane) [IsFiniteMeasureOnCompacts ρ] :
+      (∫ z, f z ∂ρ) = (∫ z, fp z ∂ρ)-(∫ z, fm z ∂ρ) := by
+    rw [← integral_sub fp.integrable fm.integrable]
+    apply integral_congr_ae
+    exact ae_of_all _ (fun z => (max_zero_sub_eq_self (f z)).symm)
+  let (ω : Ω) : IsFiniteMeasureOnCompacts (extendedCanonicalMass N C.terminal (S ω) ω) :=
+    (extendedCanonicalMass_radon N C.terminal hNr C.terminal_radon _ _).2
+  let (n : ℕ) (ω : Ω) : IsFiniteMeasureOnCompacts
+      (convexLevelMeasure κ B γ G (fun n => (n:ℝ)) C.supports C.weights n (S ω) ω) :=
+    convexLevelMeasure_finite_on_compacts hκ hκ8 γ G F ω (hBc ω) (hw ω) _ C.supports C.weights n _
+  refine ⟨?_,?_⟩
+  · apply (hp.1.sub hn.1).congr
+    filter_upwards [] with ω
+    exact (hsplit (extendedCanonicalMass N C.terminal (S ω) ω)).symm
+  · have hi (g : C_c(upperHalfPlane,ℝ)) (n : ℕ) : Integrable (fun ω => ∫ z, g z
+        ∂convexLevelMeasure κ B γ G (fun n => (n:ℝ)) C.supports C.weights n (S ω) ω)
+        (P.restrict E) :=
+      convexLevelMeasure_random_time_test_integrable hB hBm hBc hB0 hκ hκ8 γ G F hw
+        (fun n => (n:ℝ)) (fun n => Nat.cast_nonneg n) C.supports C.weights
+        C.weights_nonneg C.weights_sum n S hS E g
+    simpa only [hsplit,integral_sub (hi fp _) (hi fm _),integral_sub hp.1 hn.1] using hp.2.sub hn.2
+
+end SLEExactGauge.Multipoint
+
+end
+
+end OAI
diff --git a/lean/OAI/Probability/SLE/Mass/CanonicalMassRemaining.lean b/lean/OAI/Probability/SLE/Mass/CanonicalMassRemaining.lean
new file mode 100644
index 0000000000000000000000000000000000000000..349fd1d81ed9aebcedfac161bf21ad76a2ebcaeb
--- /dev/null
+++ b/lean/OAI/Probability/SLE/Mass/CanonicalMassRemaining.lean
@@ -0,0 +1,118 @@
+import OAI.Probability.SLE.Mass.CanonicalMassConstruction
+import OAI.Probability.SLE.Geometry.RandomSpatialTestingAE
+
+namespace OAI
+
+/-! The positive remaining mass and its conditional random spatial tests.
+The stopping-time sigma algebra is the original, uncompleted one. -/
+
+noncomputable section
+open Set Filter _root_.MeasureTheory _root_.OAI.MeasureTheory ProbabilityTheory Classical
+open scoped NNReal ENNReal Topology CompactlySupported
+
+namespace SLEExactGauge.Multipoint
+
+local instance : LocallyCompactSpace upperHalfPlane := isOpen_upperHalfPlane.locallyCompactSpace
+
+namespace CanonicalMass
+
+variable {Ω : Type*} [MeasurableSpace Ω] {P : Measure Ω} {κ : ℝ}
+  {B : ℝ≥0 → Ω → ℝ} {hBm : Measurable (Function.uncurry B)}
+  {γ : Ω → ℝ≥0 → ℂ} {G : Ω → ℝ≥0 → ℂ → ℂ}
+  (C : CanonicalMass P κ B hBm γ G)
+
+def atTime (t : ℝ≥0∞) (ω : Ω) : Measure upperHalfPlane :=
+  extendedCanonicalMass C.process C.rational.terminal t ω
+
+lemma atTime_radon (t : ℝ≥0∞) (ω : Ω) :
+    (C.atTime t ω).Regular ∧ IsFiniteMeasureOnCompacts (C.atTime t ω) :=
+  extendedCanonicalMass_radon C.process C.rational.terminal C.radon C.rational.terminal_radon t ω
+
+lemma atTime_measurable (S : Ω → ℝ≥0∞) (hS : Measurable S) :
+    Measurable (fun ω => C.atTime (S ω) ω) :=
+  extendedCanonicalMass_measurable _ _ _ C.progressive C.rational.terminal_measurable S hS
+
+lemma atTime_le_terminal (S : Ω → ℝ≥0∞) :
+    ∀ᵐ ω ∂P, C.atTime (S ω) ω ≤ C.rational.terminal ω := by
+  filter_upwards [C.paths] with ω hω
+  dsimp only [atTime,extendedCanonicalMass]
+  split_ifs
+  · exact hω.dominated _
+  · exact le_rfl
+
+lemma atTime_mean_le (S : Ω → ℝ≥0∞) (hS : Measurable S) (E : Set Ω) :
+    (P.restrict E).bind (fun ω => C.atTime (S ω) ω) ≤ initialGreenMeasure κ := by
+  have hh := restricted_bind_le_of_ae_le P _ _ (C.atTime_measurable S hS)
+    C.rational.terminal_measurable (C.atTime_le_terminal S) E
+  rwa [C.rational.mean] at hh
+
+theorem exists_remaining_kernel (S : Ω → WithTop ℝ≥0)
+    (hS : IsStoppingTime (Filtration.natural B (fun r =>
+      (hBm.comp (measurable_const.prodMk measurable_id) : Measurable (B r)).stronglyMeasurable)) S) :
+    ∃ η : Ω → Measure upperHalfPlane, Measurable η ∧
+      (∀ ω, (η ω).Regular ∧ IsFiniteMeasureOnCompacts (η ω)) ∧
+      (∀ᵐ ω ∂P, η ω + C.atTime (S ω) ω = C.rational.terminal ω) ∧
+      ∀ E : Set Ω, MeasurableSet[hS.measurableSpace] E →
+        (P.restrict E).bind η = (P.restrict E).bind (halfPlaneStoppingGreenMeasure κ B γ G S) := by
+  obtain ⟨η,hηm,hηr,hηsum⟩ := exists_measurable_halfPlane_difference P C.rational.terminal
+    (fun ω => C.atTime (S ω) ω) C.rational.terminal_measurable (C.atTime_measurable S hS.measurable')
+    (fun ω => (C.rational.terminal_radon ω).1) (fun ω => (C.atTime_radon (S ω) ω).1)
+    (C.atTime_le_terminal S)
+  refine ⟨η,hηm,hηr,hηsum,?_⟩
+  intro E hE
+  let : IsFiniteMeasureOnCompacts (initialGreenMeasure κ) := initialGreenMeasure_finite_on_compacts κ
+  let : IsFiniteMeasureOnCompacts ((P.restrict E).bind (fun ω => C.atTime (S ω) ω)) :=
+    ⟨fun K hK => lt_of_le_of_lt (C.atTime_mean_le S hS.measurable' E K) hK.measure_lt_top⟩
+  exact bind_remainder_eq_of_sum (P.restrict E) _ _ η (C.atTime_measurable S hS.measurable')
+    C.rational.terminal_measurable hηm _ (ae_restrict_of_ae hηsum) (C.kernel S hS E hE)
+
+/-- The kernel permits all nonnegative tests jointly measurable in the
+original stopped past and the spatial point, with arbitrary compact support. -/
+theorem exists_remaining_random_tests
+    (hBc : ∀ ω, Continuous (fun t => B t ω)) (F : Ω → ℝ≥0 → ℂ → ℂ)
+    (hw : ∀ ω, IsCapacityTwoWitness (fun t => Real.sqrt κ * B t ω) (γ ω) (G ω) (F ω))
+    (S : Ω → WithTop ℝ≥0)
+    (hS : IsStoppingTime (Filtration.natural B (fun r =>
+      (hBm.comp (measurable_const.prodMk measurable_id) : Measurable (B r)).stronglyMeasurable)) S) :
+    ∃ η : Ω → Measure upperHalfPlane, Measurable η ∧
+      (∀ ω, (η ω).Regular ∧ IsFiniteMeasureOnCompacts (η ω)) ∧
+      (∀ᵐ ω ∂P, η ω + C.atTime (S ω) ω = C.rational.terminal ω) ∧
+      ∀ K : Set upperHalfPlane, IsCompact K → ∀ f : Ω × upperHalfPlane → ℝ≥0∞,
+        Measurable[hS.measurableSpace.prod inferInstance] f →
+        (∫⁻ ω, (∫⁻ z in K, f (ω,z) ∂η ω) ∂P) =
+        ∫⁻ ω, (∫⁻ z in K, f (ω,z) ∂halfPlaneStoppingGreenMeasure κ B γ G S ω) ∂P := by
+  obtain ⟨η,hηm,hηr,hηsum,hηkernel⟩ := C.exists_remaining_kernel S hS
+  have hηdom : ∀ᵐ ω ∂P, η ω ≤ C.rational.terminal ω := by
+    filter_upwards [hηsum] with ω hω
+    rw [← hω]
+    apply Measure.le_iff.mpr
+    intro A _
+    simp only [Measure.add_apply]
+    exact le_add_right le_rfl
+  have hηmean : P.bind η ≤ initialGreenMeasure κ := by
+    have hh := restricted_bind_le_of_ae_le P η C.rational.terminal hηm
+      C.rational.terminal_measurable hηdom univ
+    simpa only [Measure.restrict_univ,C.rational.mean] using hh
+  have hGm := halfPlaneStoppingGreenMeasure_measurable hBm hBc κ γ G F hw S hS.measurable'
+  have hGeq : P.bind η = P.bind (halfPlaneStoppingGreenMeasure κ B γ G S) := by
+    simpa only [Measure.restrict_univ] using hηkernel univ MeasurableSet.univ
+  let : IsFiniteMeasureOnCompacts (initialGreenMeasure κ) := initialGreenMeasure_finite_on_compacts κ
+  refine ⟨η,hηm,hηr,hηsum,?_⟩
+  intro K hK f hf
+  have hηK : P.bind η K < ∞ := lt_of_le_of_lt (hηmean K) hK.measure_lt_top
+  have hGK : ∀ᵐ ω ∂P, halfPlaneStoppingGreenMeasure κ B γ G S ω K < ∞ := by
+    apply ae_lt_top (μ := P) ((Measure.measurable_coe hK.measurableSet).comp hGm)
+    change (∫⁻ ω, halfPlaneStoppingGreenMeasure κ B γ G S ω K ∂P) ≠ ∞
+    rw [← Measure.bind_apply hK.measurableSet hGm.aemeasurable,← hGeq]
+    exact hηK.ne
+  exact conditional_random_spatial_test_on_ae hS.measurableSpace hS.measurableSpace_le P
+    η (halfPlaneStoppingGreenMeasure κ B γ G S) hηm hGm K hK.measurableSet
+    (ae_of_all _ (fun ω => by let := (hηr ω).2; exact hK.measure_lt_top)) hGK hηK
+    hηkernel f hf
+
+end CanonicalMass
+end SLEExactGauge.Multipoint
+
+end
+
+end OAI
diff --git a/lean/OAI/Probability/SLE/Mass/CanonicalMassRestart.lean b/lean/OAI/Probability/SLE/Mass/CanonicalMassRestart.lean
new file mode 100644
index 0000000000000000000000000000000000000000..b19707460e574ba1724a909d93ac5e250b445a7a
--- /dev/null
+++ b/lean/OAI/Probability/SLE/Mass/CanonicalMassRestart.lean
@@ -0,0 +1,63 @@
+import OAI.Probability.SLE.Loewner.StoppedInverseTerminalUniqueness
+
+namespace OAI
+
+/-! The canonical raw driver functional restarts through the actual inverse
+Loewner chart. The trace-generation input is precisely the published one
+already used for ordinary SLE, and strong Markov provides each fresh path. -/
+
+noncomputable section
+open Set Filter _root_.MeasureTheory _root_.OAI.MeasureTheory ProbabilityTheory Classical
+open scoped NNReal ENNReal Topology CompactlySupported
+
+namespace SLEExactGauge.Multipoint
+
+local instance canonicalRestartDriverMeasurable : MeasurableSpace C(ℝ≥0,ℝ) := borel _
+local instance canonicalRestartDriverBorel : BorelSpace C(ℝ≥0,ℝ) := ⟨rfl⟩
+
+variable {Ω : Type*} [MeasurableSpace Ω] {P : Measure Ω} [IsProbabilityMeasure P]
+  {κ : ℝ} {B : ℝ≥0 → Ω → ℝ} {hBm : Measurable (Function.uncurry B)}
+  {γ : Ω → ℝ≥0 → ℂ} {G : Ω → ℝ≥0 → ℂ → ℂ}
+
+/-- One raw functional realizes the original mass and satisfies the finite
+and terminal pathwise restart identities at every finite stopping time. -/
+theorem CanonicalMass.exists_raw_pathwise_restart
+    (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 ω))
+    (hpublished : PublishedTraceGeneration (P.map (sourceDriverPath B hc)) κ (fun t p => p t)) :
+    ∃ R : RawCanonicalMass,
+      (∀ᵐ ω ∂P, (∀ t, R.process t (sourceDriverPath B hc ω)=C.process t ω) ∧
+        R.terminal (sourceDriverPath B hc ω)=C.rational.terminal ω) ∧
+      ∀ (τ : Ω → ℝ≥0)
+        (_hτ : IsStoppingTime (Filtration.natural B (fun s =>
+          (hBm.comp (measurable_const.prodMk measurable_id) : Measurable (B s)).stronglyMeasurable))
+          (fun ω => (τ ω:WithTop ℝ≥0))),
+        ∀ᵐ ω ∂P,
+          (∀ t : ℝ≥0, C.process (τ ω+t) ω-C.process (τ ω) ω =
+            stoppedFreshMass B κ γ G F hw τ hc R t ω) ∧
+          C.rational.terminal ω-C.process (τ ω) ω =
+            stoppedFreshTerminalMass B κ γ G F hw τ hc R ω := by
+  obtain ⟨R,he,hr⟩ := C.exists_raw_restarted_canonical hB hc
+  refine ⟨R,he,?_⟩
+  intro τ hτ
+  have hm (s : ℝ≥0) : Measurable (B s) := hBm.comp (measurable_const.prodMk measurable_id)
+  have hFresh := fresh_capacity_witness_exists hB hm hc hpublished τ hτ
+  have hfin := C.stoppedFreshTerminalMass_ae_finite_on_compacts hB hc hκ F hw τ hτ R
+    (he.mono fun _ h => h.2) hpublished
+  have hraw := (hr τ hτ).2
+  have hp := stoppedFreshMass_paths B κ γ G F hw τ hc R hm hτ hκ
+    (hraw.mono fun _ h => ⟨h.1,h.2.1,h.2.2.1,h.2.2.2.1⟩) hfin
+  have hx := stoppedFreshMass_terminal_exhaustion B κ γ G F hw τ hc R hm hτ hκ
+    (hraw.mono fun _ h => h.2.2.2.1) (hraw.mono fun _ h => h.2.2.2.2) hfin
+  filter_upwards [C.stoppedFreshMass_indistinguishable hB hc hκ F hw R he τ hτ hFresh hp,
+    C.stoppedFreshTerminalMass_eq_remainder hB hc hκ F hw R he τ hτ hFresh hp hfin hx]
+    with ω hf ht
+  exact ⟨hf,ht⟩
+
+end SLEExactGauge.Multipoint
+
+end
+
+end OAI
diff --git a/lean/OAI/Probability/SLE/Mass/CanonicalMassScaling.lean b/lean/OAI/Probability/SLE/Mass/CanonicalMassScaling.lean
new file mode 100644
index 0000000000000000000000000000000000000000..d6b1826dee2f0d02e530855470c45fe7ebfce538
--- /dev/null
+++ b/lean/OAI/Probability/SLE/Mass/CanonicalMassScaling.lean
@@ -0,0 +1,129 @@
+import OAI.Probability.SLE.Mass.RawScaledMassMeans
+import OAI.Probability.SLE.Mass.CanonicalMassPositiveReduction
+
+namespace OAI
+
+/-! Canonical mass is identified with its dimension-weighted dilation
+by the proved Green kernel and continuous increasing-path uniqueness. -/
+
+noncomputable section
+open Set Filter _root_.MeasureTheory _root_.OAI.MeasureTheory ProbabilityTheory
+open scoped Topology NNReal ENNReal CompactlySupported
+
+namespace SLEExactGauge.Multipoint
+
+local instance canonicalScalingDriverMeasurable : MeasurableSpace C(ℝ≥0,ℝ) := borel _
+local instance canonicalScalingDriverBorel : BorelSpace C(ℝ≥0,ℝ) := ⟨rfl⟩
+local instance canonicalScalingLocallyCompact : LocallyCompactSpace upperHalfPlane :=
+  isOpen_upperHalfPlane.locallyCompactSpace
+
+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 CanonicalMass.scaled_raw_process_eq
+    (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))
+    (c : ℝ≥0) (hcp : 0 < c) :
+    ∀ᵐ ω ∂P, ∀ t, dilationMass κ c hcp (C.process t ω)=scaledRawMass R c B hc t ω := by
+  have hm (s : ℝ≥0) : Measurable (B s) := hBm.comp (measurable_const.prodMk measurable_id)
+  have hd : Measurable (dilationMass κ c hcp) := conformalMass_measurable _ _
+  have hA : Adapted (Filtration.natural B (fun s => (hm s).stronglyMeasurable))
+      (fun t ω => dilationMass κ c hcp (C.process t ω)) :=
+    fun t => hd.comp (C.progressive.adapted t)
+  have hZ : Measurable (scaledRawTerminal R c B hc) := R.terminal_measurable.comp
+    (source_path_measurable _ (scaledBrownianDriver_measurable c B hm))
+  have hAb (t : ℝ≥0) : P.bind (fun ω => dilationMass κ c hcp (C.process t ω)) ≤
+      initialGreenMeasure κ := by
+    rw [dilationMass_bind P κ c hcp _ (C.progressive.adapted.measurable (i:=t))]
+    apply (dilationMass_mono κ c hcp ?_).trans_eq (dilationMass_initialGreen κ c hcp)
+    simpa only [Measure.restrict_univ] using C.uniqueness_process_mean_le t univ
+  have hAT : P.bind (fun ω => dilationMass κ c hcp (C.rational.terminal ω)) ≤
+      initialGreenMeasure κ := by
+    rw [dilationMass_bind P κ c hcp _ C.rational.terminal_measurable,C.rational.mean,
+      dilationMass_initialGreen]
+  have hpaths : ∀ᵐ ω ∂P, PositiveMassPaths
+      (fun t => dilationMass κ c hcp (C.process t ω))
+      (dilationMass κ c hcp (C.rational.terminal ω)) := by
+    filter_upwards [C.paths] with ω hp
+    refine ⟨?_,?_,?_,?_,?_⟩
+    · simp only [hp.zero,dilationMass,conformalMass_zero]
+    · intro s t hst
+      exact dilationMass_mono κ c hcp (hp.monotone hst)
+    · intro t
+      exact dilationMass_mono κ c hcp (hp.dominated t)
+    · intro t
+      let := (C.radon t ω).2
+      exact conformalMass_radon _ _ _
+    · intro f _hf
+      exact conformalMass_test_continuous _ _ _ hp.continuous_tests f
+  exact positive_mass_process_eq_of_cross_kernel _ _ _ _ hA
+    (scaledRawMass_adapted R c hcp B hm hc) (hd.comp C.rational.terminal_measurable) hZ
+    hAb (C.scaledRawMass_mean_le hB hc R he c hcp)
+    hAT (le_of_eq (C.scaledRawTerminal_mean hB hc R he c hcp)) hpaths
+    (scaledRawMass_positive_paths R E hE B hB hm hc hEf hEp c hcp)
+    (C.scaledRawMass_cross_kernel hB hc R he c hcp F hw)
+
+lemma CanonicalMass.nonzero_probability_scaled
+    (hB : IsBrownianReal B P) (hc : ∀ ω, Continuous (fun t => B t ω))
+    (F : Ω → ℝ≥0 → ℂ → ℂ)
+    (hw : ∀ ω, IsCapacityTwoWitness (fun t => Real.sqrt κ*B t ω) (γ ω) (G ω) (F ω))
+    (c : ℝ≥0) (hcp : 0 < c) (t : ℝ≥0) :
+    P {ω | C.process t ω ≠ 0}=P {ω | C.process (c^2*t) ω ≠ 0} := by
+  obtain ⟨R,he,E,hEm,hEf,hEp⟩ := C.exists_raw_positive_paths hc
+  have hs := C.scaled_raw_process_eq hB hc F hw R he E hEm hEf hEp c hcp
+  have hm (s : ℝ≥0) : Measurable (B s) := hBm.comp (measurable_const.prodMk measurable_id)
+  let A : Set C(ℝ≥0,ℝ) := {p | 0 < R.process (c^2*t) p univ}
+  have hAm : MeasurableSet A := measurableSet_lt measurable_const
+    ((Measure.measurable_coe MeasurableSet.univ).comp (R.progressive.adapted.measurable (i:=c^2*t)))
+  let X := sourceDriverPath B hc
+  let Y := sourceDriverPath (scaledBrownianDriver c B) (scaledBrownianDriver_continuous c B hc)
+  have hXm : Measurable X := source_path_measurable _ hm
+  have hYm : Measurable Y := source_path_measurable _ (scaledBrownianDriver_measurable c B hm)
+  calc
+    _ = P (Y ⁻¹' A) := by
+      apply measure_congr
+      filter_upwards [hs] with ω hω
+      apply propext
+      change (C.process t ω ≠ 0) ↔ 0 < scaledRawMass R c B hc t ω univ
+      rw [← hω t,Measure.measure_univ_pos,dilationMass_ne_zero_iff]
+    _ = (P.map Y) A := (Measure.map_apply hYm hAm).symm
+    _ = (P.map X) A := by rw [scaledBrownianDriver_path_law c hcp B hB hm hc]
+    _ = P (X ⁻¹' A) := Measure.map_apply hXm hAm
+    _ = _ := by
+      apply measure_congr
+      filter_upwards [he] with ω hω
+      apply propext
+      change (0 < R.process (c^2*t) (X ω) univ) ↔ C.process (c^2*t) ω ≠ 0
+      rw [hω.1 (c^2*t),Measure.measure_univ_pos]
+
+lemma CanonicalMass.nonzero_probability_eq
+    (hB : IsBrownianReal B P) (hc : ∀ ω, Continuous (fun t => B t ω))
+    (F : Ω → ℝ≥0 → ℂ → ℂ)
+    (hw : ∀ ω, IsCapacityTwoWitness (fun t => Real.sqrt κ*B t ω) (γ ω) (G ω) (F ω))
+    (s t : ℝ≥0) (hs : 0 < s) (ht : 0 < t) :
+    P {ω | C.process s ω ≠ 0}=P {ω | C.process t ω ≠ 0} := by
+  have hscale : 0 < NNReal.sqrt (t/s) := NNReal.sqrt_pos.mpr (div_pos ht hs)
+  have h := C.nonzero_probability_scaled hB hc F hw (NNReal.sqrt (t/s)) hscale s
+  simpa only [NNReal.sq_sqrt,div_mul_cancel₀ _ hs.ne'] using h
+
+lemma CanonicalMass.positive_all_times
+    (hB : IsBrownianReal B P) (hc : ∀ ω, Continuous (fun t => B t ω))
+    (h0 : ∀ ω, B 0 ω=0) (F : Ω → ℝ≥0 → ℂ → ℂ)
+    (hw : ∀ ω, IsCapacityTwoWitness (fun t => Real.sqrt κ*B t ω) (γ ω) (G ω) (F ω)) :
+    ∀ᵐ ω ∂P, ∀ t : ℝ≥0, 0 < t → C.process t ω ≠ 0 :=
+  C.positive_all_times_of_scaling hB hc h0 (C.nonzero_probability_eq hB hc F hw)
+
+end SLEExactGauge.Multipoint
+
+end
+
+end OAI
diff --git a/lean/OAI/Probability/SLE/Mass/CanonicalMassStoppingKernel.lean b/lean/OAI/Probability/SLE/Mass/CanonicalMassStoppingKernel.lean
new file mode 100644
index 0000000000000000000000000000000000000000..3b37d08ef0368af9b6e9a6b7b500f892446f8840
--- /dev/null
+++ b/lean/OAI/Probability/SLE/Mass/CanonicalMassStoppingKernel.lean
@@ -0,0 +1,144 @@
+import OAI.Probability.SLE.Mass.CanonicalMassRandomTime
+import OAI.Probability.SLE.Stochastic.ProgressiveRandomTime
+
+namespace OAI
+
+/-! The canonical mass has the exact conditional Green kernel at every
+possibly infinite stopping time. -/
+
+noncomputable section
+open Set Filter _root_.MeasureTheory _root_.OAI.MeasureTheory ProbabilityTheory Classical
+open scoped NNReal ENNReal Topology CompactlySupported
+
+namespace SLEExactGauge.Multipoint
+
+local instance : LocallyCompactSpace upperHalfPlane := isOpen_upperHalfPlane.locallyCompactSpace
+
+lemma extendedCanonicalMass_measurable
+    {Ω : Type*} [mΩ : MeasurableSpace Ω] (ℱ : Filtration ℝ≥0 mΩ)
+    (N : ℝ≥0 → Ω → Measure upperHalfPlane) (ν : Ω → Measure upperHalfPlane)
+    (hN : IsProgressive ℱ N) (hν : Measurable ν)
+    (S : Ω → ℝ≥0∞) (hS : Measurable S) :
+    Measurable (fun ω => extendedCanonicalMass N ν (S ω) ω) :=
+  Measurable.ite (measurableSet_lt hS measurable_const)
+    (_root_.OAI.MeasureTheory.IsProgressive.extended_random_time_measurable hN S hS) hν
+
+theorem RationalCanonicalMass.stopping_conditional_kernel
+    {Ω : Type*} [MeasurableSpace Ω] {P : Measure Ω} {κ : ℝ}
+    {B : ℝ≥0 → Ω → ℝ} (hB : IsBrownianReal B P)
+    (hBm : Measurable (Function.uncurry B))
+    (hBc : ∀ ω, Continuous (fun t => B t ω)) (hB0 : ∀ ω, B 0 ω = 0)
+    (hκ : 0 < κ) (hκ8 : κ < 8)
+    {γ : Ω → ℝ≥0 → ℂ} {G : Ω → ℝ≥0 → ℂ → ℂ}
+    (F : Ω → ℝ≥0 → ℂ → ℂ)
+    (hw : ∀ ω, IsCapacityTwoWitness (fun t => Real.sqrt κ * B t ω) (γ ω) (G ω) (F ω))
+    (hgrowth : PublishedDiskUnivalentGrowth)
+    (C : RationalCanonicalMass P κ B hBm γ G)
+    (N : ℝ≥0 → Ω → Measure upperHalfPlane)
+    (hNp : IsProgressive (Filtration.natural B (fun r =>
+      (hBm.comp (measurable_const.prodMk measurable_id) : Measurable (B r)).stronglyMeasurable)) N)
+    (hNr : ∀ t ω, (N t ω).Regular ∧ IsFiniteMeasureOnCompacts (N t ω))
+    (hpath : ∀ᵐ ω ∂P, ContinuousMassPath (γ ω) (fun q => C.mass q ω)
+      (C.terminal ω) (fun t => N t ω))
+    (S : Ω → WithTop ℝ≥0)
+    (hS : IsStoppingTime (Filtration.natural B (fun r =>
+      (hBm.comp (measurable_const.prodMk measurable_id) : Measurable (B r)).stronglyMeasurable)) S)
+    (E : Set Ω) (hE : MeasurableSet[hS.measurableSpace] E) :
+    (P.restrict E).bind C.terminal =
+      (P.restrict E).bind (fun ω => extendedCanonicalMass N C.terminal (S ω) ω) +
+      (P.restrict E).bind (halfPlaneStoppingGreenMeasure κ B γ G S) := by
+  let hm (t : ℝ≥0) : Measurable (B t) := hBm.comp (measurable_const.prodMk measurable_id)
+  let V (ω : Ω) := extendedCanonicalMass N C.terminal (S ω) ω
+  have hVm : Measurable V := extendedCanonicalMass_measurable _ N C.terminal hNp
+    C.terminal_measurable S hS.measurable'
+  have hVr (ω : Ω) := extendedCanonicalMass_radon N C.terminal hNr C.terminal_radon (S ω) ω
+  have hVdom : ∀ᵐ ω ∂P, V ω ≤ C.terminal ω := by
+    filter_upwards [hpath] with ω hω
+    dsimp only [V,extendedCanonicalMass]
+    split_ifs
+    · exact hω.dominated _
+    · exact le_rfl
+  have hVmean := restricted_bind_le_of_ae_le P V C.terminal hVm C.terminal_measurable hVdom E
+  rw [C.mean] at hVmean
+  have hTmean := restricted_bind_le_of_ae_le P C.terminal C.terminal
+    C.terminal_measurable C.terminal_measurable (ae_of_all _ (fun _ => le_rfl)) E
+  rw [C.mean] at hTmean
+  have hGmean := halfPlaneStoppingGreenMeasure_mean_le hB hBm hBc hB0 hκ hκ8 γ G F hw S hS E
+  let : IsFiniteMeasureOnCompacts (initialGreenMeasure κ) := initialGreenMeasure_finite_on_compacts κ
+  let : IsFiniteMeasureOnCompacts ((P.restrict E).bind V) :=
+    ⟨fun K hK => lt_of_le_of_lt (hVmean K) hK.measure_lt_top⟩
+  let : IsFiniteMeasureOnCompacts ((P.restrict E).bind C.terminal) :=
+    ⟨fun K hK => lt_of_le_of_lt (hTmean K) hK.measure_lt_top⟩
+  let : IsFiniteMeasureOnCompacts ((P.restrict E).bind (halfPlaneStoppingGreenMeasure κ B γ G S)) :=
+    ⟨fun K hK => lt_of_le_of_lt (hGmean K) hK.measure_lt_top⟩
+  let : IsFiniteMeasureOnCompacts ((P.restrict E).bind V +
+      (P.restrict E).bind (halfPlaneStoppingGreenMeasure κ B γ G S)) := by
+    constructor
+    intro K hK
+    rw [Measure.add_apply]
+    exact ENNReal.add_lt_top.mpr ⟨hK.measure_lt_top,hK.measure_lt_top⟩
+  let M (n : ℕ) (t : ℝ≥0∞) := convexLevelMeasure κ B γ G (fun n => (n:ℝ))
+    C.supports C.weights n t
+  have hMm (n : ℕ) (T : Ω → ℝ≥0∞) (hT : Measurable T) :=
+    convexLevelMeasure_random_time_measurable hm hBc κ γ G F hw (fun n => (n:ℝ))
+      (fun n => Nat.cast_nonneg n) C.supports C.weights n T hT
+  have hMmean (n : ℕ) (T : Ω → ℝ≥0∞) (hT : Measurable T) :
+      (P.restrict E).bind (fun ω => M n (T ω) ω) ≤ initialGreenMeasure κ := by
+    have hh := restricted_bind_le_of_ae_le P _ _ (hMm n T hT)
+      (convexLevelMeasure_measurable hm hBc κ γ G F hw _ (fun n => Nat.cast_nonneg n)
+        C.supports C.weights n ∞)
+      (ae_of_all _ (fun ω => convexLevelMeasure_mono κ B γ G (fun n => (n:ℝ))
+        C.supports C.weights n ω le_top)) E
+    rwa [convexLevelMeasure_terminal_mean hB hm hBm hBc hB0 hκ hκ8 γ G F hw _
+      (fun n => Nat.cast_nonneg n) C.supports C.weights C.weights_nonneg C.weights_sum] at hh
+  let (ω : Ω) : IsFiniteMeasureOnCompacts (V ω) := (hVr ω).2
+  let (ω : Ω) : IsFiniteMeasureOnCompacts (C.terminal ω) := (C.terminal_radon ω).2
+  let (n : ℕ) (t : ℝ≥0∞) (ω : Ω) : IsFiniteMeasureOnCompacts (M n t ω) :=
+    convexLevelMeasure_finite_on_compacts hκ hκ8 γ G F ω (hBc ω) (hw ω) _ C.supports C.weights n t
+  apply (localTestFamily upperHalfPlane).measure_eq_of_test_integrals
+  intro k
+  let f := (localTestFamily upperHalfPlane).test k
+  have heM (n : ℕ) (T : Ω → ℝ≥0∞) (hT : Measurable T) :
+      (∫ ω in E, (∫ z, f z ∂M n (T ω) ω) ∂P) =
+      ∫ z, f z ∂(P.restrict E).bind (fun ω => M n (T ω) ω) :=
+    integral_bind_of_integrable_sections (P.restrict E) _ (hMm n T hT)
+      f f.continuous.measurable (fun _ => f.integrable) (f.integrable.mono_measure (hMmean n T hT))
+  have heV : (∫ ω in E, (∫ z, f z ∂V ω) ∂P) = ∫ z, f z ∂(P.restrict E).bind V :=
+    integral_bind_of_integrable_sections (P.restrict E) V hVm f f.continuous.measurable
+      (fun _ => f.integrable) f.integrable
+  have heT : (∫ ω in E, (∫ z, f z ∂C.terminal ω) ∂P) = ∫ z, f z ∂(P.restrict E).bind C.terminal :=
+    integral_bind_of_integrable_sections (P.restrict E) C.terminal C.terminal_measurable
+      f f.continuous.measurable (fun _ => f.integrable) f.integrable
+  have ht := (C.random_time_test_mean_tendsto hB hBm hBc hB0 hκ hκ8 F hw hgrowth N hNr hpath
+    (fun _ => ∞) measurable_const E f).2
+  simp only [extendedCanonicalMass,lt_self_iff_false,ite_false,heT] at ht
+  change Tendsto (fun n => ∫ ω in E, (∫ z, f z ∂M n ∞ ω) ∂P) atTop
+    (𝓝 (∫ z, f z ∂(P.restrict E).bind C.terminal)) at ht
+  have heInfinity (n : ℕ) := heM n (fun _ => ∞) measurable_const
+  simp only [heInfinity] at ht
+  have hv := (C.random_time_test_mean_tendsto hB hBm hBc hB0 hκ hκ8 F hw hgrowth N hNr hpath
+    S hS.measurable' E f).2
+  change Tendsto (fun n => ∫ ω in E, (∫ z, f z ∂M n (S ω) ω) ∂P) atTop
+    (𝓝 (∫ ω in E, (∫ z, f z ∂V ω) ∂P)) at hv
+  have heS (n : ℕ) := heM n S hS.measurable'
+  simp only [heV,heS] at hv
+  have hg := convexStoppingCurrentMean_test_tendsto hB hBm hBc hB0 hκ hκ8 γ G F hw
+    (fun n => (n:ℝ)) (fun n => Nat.cast_nonneg n) (fun _ _ h => Nat.cast_le.mpr h)
+    tendsto_natCast_atTop_atTop C.supports C.weights C.weights_nonneg C.weights_sum S hS E f
+  have he (n : ℕ) : (∫ z, f z ∂(P.restrict E).bind (M n ∞)) =
+      (∫ z, f z ∂(P.restrict E).bind (fun ω => M n (S ω) ω)) +
+      ∫ z, f z ∂convexStoppingCurrentMean (P.restrict E) κ B γ G
+        (fun n => (n:ℝ)) C.supports C.weights n S := by
+    rw [convexLevelMeasure_stopping_conditional_split hB hBm hBc hB0 hκ hκ8 γ G F hw
+      _ (fun n => Nat.cast_nonneg n) C.supports C.weights n S hS E hE]
+    exact integral_add_measure (f.integrable.mono_measure (hMmean n S hS.measurable'))
+      (f.integrable.mono_measure (convexStoppingCurrentMean_le hB hBm hBc hB0 hκ hκ8 γ G F hw
+        _ (fun n => Nat.cast_nonneg n) C.supports C.weights C.weights_nonneg C.weights_sum n S hS E))
+  rw [integral_add_measure f.integrable f.integrable]
+  exact tendsto_nhds_unique ht ((hv.add hg).congr' (Eventually.of_forall (fun n => (he n).symm)))
+
+end SLEExactGauge.Multipoint
+
+end
+
+end OAI
diff --git a/lean/OAI/Probability/SLE/Mass/CanonicalMassUniqueness.lean b/lean/OAI/Probability/SLE/Mass/CanonicalMassUniqueness.lean
new file mode 100644
index 0000000000000000000000000000000000000000..ffddbcd1de1aef7297f7d1074c74938c723c0c98
--- /dev/null
+++ b/lean/OAI/Probability/SLE/Mass/CanonicalMassUniqueness.lean
@@ -0,0 +1,184 @@
+import OAI.Probability.SLE.Mass.CanonicalMassConstruction
+import OAI.Probability.SLE.Mass.RadonTerminalUniqueness
+
+namespace OAI
+
+/-! The constructed canonical mass does not depend on the convex extraction.
+The uniqueness argument uses only integrable terminal compact tests and the
+conditional remainder kernel, rather than second moments of a competitor. -/
+
+noncomputable section
+open Set Filter _root_.MeasureTheory _root_.OAI.MeasureTheory ProbabilityTheory Classical
+open scoped NNReal ENNReal Topology CompactlySupported
+
+namespace SLEExactGauge.Multipoint
+
+local instance : LocallyCompactSpace upperHalfPlane := isOpen_upperHalfPlane.locallyCompactSpace
+
+namespace CanonicalMass
+
+variable {Ω : Type*} [MeasurableSpace Ω] {P : Measure Ω} {κ : ℝ}
+  {B : ℝ≥0 → Ω → ℝ} {hBm : Measurable (Function.uncurry B)}
+  {γ : Ω → ℝ≥0 → ℂ} {G : Ω → ℝ≥0 → ℂ → ℂ}
+  (C : CanonicalMass P κ B hBm γ G)
+
+lemma uniqueness_process_mean_le (t : ℝ≥0) (E : Set Ω) :
+    (P.restrict E).bind (C.process t) ≤ initialGreenMeasure κ := by
+  have hdom : ∀ᵐ ω ∂P, C.process t ω ≤ C.rational.terminal ω :=
+    C.paths.mono (fun _ h => h.dominated t)
+  have h := restricted_bind_le_of_ae_le P (C.process t) C.rational.terminal
+    (C.progressive.adapted.measurable (i := t)) C.rational.terminal_measurable hdom E
+  rwa [C.rational.mean] at h
+
+lemma uniqueness_terminal_mean_le (E : Set Ω) :
+    (P.restrict E).bind C.rational.terminal ≤ initialGreenMeasure κ := by
+  have h := restricted_bind_le_of_ae_le P C.rational.terminal C.rational.terminal
+    C.rational.terminal_measurable C.rational.terminal_measurable (ae_of_all _ (fun _ => le_rfl)) E
+  rwa [C.rational.mean] at h
+
+lemma uniqueness_test_integrable (t : ℝ≥0) (f : C_c(upperHalfPlane,ℝ)) :
+    Integrable (fun ω => ∫ z, f z ∂C.process t ω) P := by
+  let (ω : Ω) : (C.process t ω).Regular := (C.radon t ω).1
+  let : IsFiniteMeasureOnCompacts (initialGreenMeasure κ) := initialGreenMeasure_finite_on_compacts κ
+  apply (integrable_integral_bind_of_sections P (C.process t)
+    (C.progressive.adapted.measurable (i := t)) f f.continuous.measurable
+    (fun _ => f.integrable) ?_).1
+  have hfI : Integrable f (initialGreenMeasure κ) := f.integrable
+  exact hfI.mono_measure (by
+    simpa only [Measure.restrict_univ] using C.uniqueness_process_mean_le t univ)
+
+lemma uniqueness_terminal_test_integrable (f : C_c(upperHalfPlane,ℝ)) :
+    Integrable (fun ω => ∫ z, f z ∂C.rational.terminal ω) P := by
+  let (ω : Ω) : (C.rational.terminal ω).Regular := (C.rational.terminal_radon ω).1
+  let : IsFiniteMeasureOnCompacts (initialGreenMeasure κ) := initialGreenMeasure_finite_on_compacts κ
+  apply (integrable_integral_bind_of_sections P C.rational.terminal C.rational.terminal_measurable
+    f f.continuous.measurable (fun _ => f.integrable) ?_).1
+  rw [C.rational.mean]
+  exact f.integrable
+
+lemma uniqueness_test_adapted (f : C_c(upperHalfPlane,ℝ)) :
+    StronglyAdapted (Filtration.natural B (fun r =>
+      (hBm.comp (measurable_const.prodMk measurable_id) : Measurable (B r)).stronglyMeasurable))
+      (fun t ω => ∫ z, f z ∂C.process t ω) := by
+  intro t
+  exact (@measurable_halfPlane_compact_test_integral Ω
+    ((Filtration.natural B (fun r =>
+      (hBm.comp (measurable_const.prodMk measurable_id) : Measurable (B r)).stronglyMeasurable)) t)
+    (C.process t)
+    (C.progressive.adapted t) (fun ω => (C.radon t ω).1) f).stronglyMeasurable
+
+lemma uniqueness_cross_mean (D : CanonicalMass P κ B hBm γ G)
+    (t : ℝ≥0) (E : Set Ω)
+    (hE : MeasurableSet[Filtration.natural B (fun r =>
+      (hBm.comp (measurable_const.prodMk measurable_id) : Measurable (B r)).stronglyMeasurable) t] E) :
+    (P.restrict E).bind C.rational.terminal+(P.restrict E).bind (D.process t) =
+      (P.restrict E).bind D.rational.terminal+(P.restrict E).bind (C.process t) := by
+  let ℱ := Filtration.natural B (fun r =>
+    (hBm.comp (measurable_const.prodMk measurable_id) : Measurable (B r)).stronglyMeasurable)
+  have hS : IsStoppingTime ℱ (fun _ : Ω => (t:WithTop ℝ≥0)) := isStoppingTime_const ℱ t
+  have hES : MeasurableSet[hS.measurableSpace] E := by
+    change MeasurableSet[(isStoppingTime_const ℱ t).measurableSpace] E
+    rw [IsStoppingTime.measurableSpace_const]
+    exact hE
+  have hc := C.kernel (fun _ => (t:WithTop ℝ≥0)) hS E hES
+  have hd := D.kernel (fun _ => (t:WithTop ℝ≥0)) hS E hES
+  have hfinite : (t:WithTop ℝ≥0) < ∞ := WithTop.coe_lt_top t
+  have heC : (fun ω => extendedCanonicalMass C.process C.rational.terminal
+      ((t:WithTop ℝ≥0):ℝ≥0∞) ω) = C.process t := by
+    funext ω
+    unfold extendedCanonicalMass
+    split_ifs with ht
+    · congr 1
+    · exact (ht hfinite).elim
+  have heD : (fun ω => extendedCanonicalMass D.process D.rational.terminal
+      ((t:WithTop ℝ≥0):ℝ≥0∞) ω) = D.process t := by
+    funext ω
+    unfold extendedCanonicalMass
+    split_ifs with ht
+    · congr 1
+    · exact (ht hfinite).elim
+  rw [heC] at hc
+  rw [heD] at hd
+  rw [hc,hd]
+  ac_rfl
+
+lemma uniqueness_test_terminal_mean (D : CanonicalMass P κ B hBm γ G)
+    (f : C_c(upperHalfPlane,ℝ)) (t : ℝ≥0) (E : Set Ω)
+    (hE : MeasurableSet[Filtration.natural B (fun r =>
+      (hBm.comp (measurable_const.prodMk measurable_id) : Measurable (B r)).stronglyMeasurable) t] E) :
+    (∫ ω in E, (∫ z, f z ∂C.process t ω)-(∫ z, f z ∂D.process t ω) ∂P) =
+      ∫ ω in E, (∫ z, f z ∂C.rational.terminal ω)-(∫ z, f z ∂D.rational.terminal ω) ∂P := by
+  let : IsFiniteMeasureOnCompacts (initialGreenMeasure κ) := initialGreenMeasure_finite_on_compacts κ
+  let (ω : Ω) : (C.rational.terminal ω).Regular := (C.rational.terminal_radon ω).1
+  let (ω : Ω) : (D.rational.terminal ω).Regular := (D.rational.terminal_radon ω).1
+  let (ω : Ω) : (C.process t ω).Regular := (C.radon t ω).1
+  let (ω : Ω) : (D.process t ω).Regular := (D.radon t ω).1
+  have hiC := f.integrable.mono_measure (C.uniqueness_process_mean_le t E)
+  have hiD := f.integrable.mono_measure (D.uniqueness_process_mean_le t E)
+  have hiCT := f.integrable.mono_measure (C.uniqueness_terminal_mean_le E)
+  have hiDT := f.integrable.mono_measure (D.uniqueness_terminal_mean_le E)
+  have hcross := congrArg (fun μ : Measure upperHalfPlane => ∫ z, f z ∂μ)
+    (C.uniqueness_cross_mean D t E hE)
+  rw [integral_add_measure hiCT hiD,integral_add_measure hiDT hiC] at hcross
+  have heC := integral_bind_of_integrable_sections (P.restrict E) (C.process t)
+    (C.progressive.adapted.measurable (i := t)) f f.continuous.measurable (fun _ => f.integrable) hiC
+  have heD := integral_bind_of_integrable_sections (P.restrict E) (D.process t)
+    (D.progressive.adapted.measurable (i := t)) f f.continuous.measurable (fun _ => f.integrable) hiD
+  have heCT := integral_bind_of_integrable_sections (P.restrict E) C.rational.terminal
+    C.rational.terminal_measurable f f.continuous.measurable (fun _ => f.integrable) hiCT
+  have heDT := integral_bind_of_integrable_sections (P.restrict E) D.rational.terminal
+    D.rational.terminal_measurable f f.continuous.measurable (fun _ => f.integrable) hiDT
+  rw [integral_sub (C.uniqueness_test_integrable t f).integrableOn
+    (D.uniqueness_test_integrable t f).integrableOn,
+    integral_sub (C.uniqueness_terminal_test_integrable f).integrableOn
+      (D.uniqueness_terminal_test_integrable f).integrableOn,heC,heD,heCT,heDT]
+  linarith
+
+variable [IsFiniteMeasure P]
+
+/-- Two canonical mass constructions for the same trace have identical finite
+time measures on one full-measure event. -/
+theorem process_indistinguishable (D : CanonicalMass P κ B hBm γ G) :
+    ∀ᵐ ω ∂P, ∀ t, C.process t ω = D.process t ω := by
+  apply random_radon_process_eq_of_positive_tests P (localTestFamily upperHalfPlane)
+    C.process D.process (fun t ω => (C.radon t ω).1) (fun t ω => (D.radon t ω).1)
+  intro f hf
+  apply increasing_mass_unique_of_terminal_mean
+    (fun t ω => ∫ z, f z ∂C.process t ω) (fun t ω => ∫ z, f z ∂D.process t ω)
+    (fun ω => (∫ z, f z ∂C.rational.terminal ω)-(∫ z, f z ∂D.rational.terminal ω))
+    ((C.uniqueness_terminal_test_integrable f).sub (D.uniqueness_terminal_test_integrable f))
+    (C.uniqueness_test_adapted f) (D.uniqueness_test_adapted f)
+    (fun t => C.uniqueness_test_integrable t f) (fun t => D.uniqueness_test_integrable t f)
+    (C.uniqueness_test_terminal_mean D f)
+  · filter_upwards [C.paths] with ω hω
+    intro s t hst
+    let : (C.process t ω).Regular := (C.radon t ω).1
+    exact integral_mono_measure (hω.monotone hst) (ae_of_all _ hf) f.integrable
+  · filter_upwards [D.paths] with ω hω
+    intro s t hst
+    let : (D.process t ω).Regular := (D.radon t ω).1
+    exact integral_mono_measure (hω.monotone hst) (ae_of_all _ hf) f.integrable
+  · filter_upwards [C.paths] with ω hω
+    simp only [hω.zero,integral_zero_measure,Pi.zero_apply]
+  · filter_upwards [D.paths] with ω hω
+    simp only [hω.zero,integral_zero_measure,Pi.zero_apply]
+  · filter_upwards [C.paths,D.paths] with ω hc hd
+    exact (hc.continuous_tests f).sub (hd.continuous_tests f)
+
+/-- The locally exhausted terminal measures also agree. -/
+theorem terminal_ae_eq (D : CanonicalMass P κ B hBm γ G) :
+    C.rational.terminal =ᵐ[P] D.rational.terminal := by
+  filter_upwards [C.process_indistinguishable D,C.paths,D.paths,C.exhaustion,D.exhaustion]
+    with ω he hc hd hlc hld
+  let := (C.rational.terminal_radon ω).1
+  let := (D.rational.terminal_radon ω).1
+  exact radon_terminal_eq_of_common_exhaustion (C.rational.terminal ω) (D.rational.terminal ω)
+    (fun t => C.process t ω) hc.dominated (fun t => by rw [he t]; exact hd.dominated t)
+    hlc (by simpa only [he] using hld)
+
+end CanonicalMass
+end SLEExactGauge.Multipoint
+
+end
+
+end OAI
diff --git a/lean/OAI/Probability/SLE/Mass/CanonicalPhysicalMass.lean b/lean/OAI/Probability/SLE/Mass/CanonicalPhysicalMass.lean
new file mode 100644
index 0000000000000000000000000000000000000000..d386007956973a6ba46d014f905030731eef3b55
--- /dev/null
+++ b/lean/OAI/Probability/SLE/Mass/CanonicalPhysicalMass.lean
@@ -0,0 +1,52 @@
+import OAI.Probability.SLE.Geometry.BoundedTerminalMean
+
+namespace OAI
+
+/-! The upper cover is charged to the canonical terminal measure on the
+physical plane. Its mean is the initial Green measure, also on sets meeting
+the real boundary. -/
+noncomputable section
+open Set Filter MeasureTheory Metric
+open scoped NNReal ENNReal
+
+namespace SLEExactGauge.Multipoint
+
+variable {Ω : Type*} [MeasurableSpace Ω] {P : Measure Ω} {κ : ℝ}
+  {B : ℝ≥0 → Ω → ℝ} {hBm : Measurable (Function.uncurry B)}
+  {γ : Ω → ℝ≥0 → ℂ} {G : Ω → ℝ≥0 → ℂ → ℂ}
+
+def RationalCanonicalMass.physicalTerminal (C : RationalCanonicalMass P κ B hBm γ G)
+    (ω : Ω) : Measure ℂ := (C.terminal ω).map Subtype.val
+
+lemma RationalCanonicalMass.physicalTerminal_measurable
+    (C : RationalCanonicalMass P κ B hBm γ G) : Measurable C.physicalTerminal :=
+  (Measure.measurable_map Subtype.val measurable_subtype_coe).comp C.terminal_measurable
+
+lemma RationalCanonicalMass.physicalTerminal_apply
+    (C : RationalCanonicalMass P κ B hBm γ G) (ω : Ω) {A : Set ℂ} (hA : MeasurableSet A) :
+    C.physicalTerminal ω A = C.terminal ω (Subtype.val ⁻¹' A) :=
+  Measure.map_apply measurable_subtype_coe hA
+
+lemma RationalCanonicalMass.physicalTerminal_mean
+    (C : RationalCanonicalMass P κ B hBm γ G) :
+    P.bind C.physicalTerminal = (initialGreenMeasure κ).map Subtype.val := by
+  apply Measure.ext
+  intro A hA
+  rw [Measure.bind_apply hA C.physicalTerminal_measurable.aemeasurable,
+    Measure.map_apply measurable_subtype_coe hA,← C.mean,
+    Measure.bind_apply (hA.preimage measurable_subtype_coe) C.terminal_measurable.aemeasurable]
+  apply lintegral_congr
+  intro ω
+  exact C.physicalTerminal_apply ω hA
+
+lemma RationalCanonicalMass.physicalTerminal_bounded_mean_lt_top
+    (C : RationalCanonicalMass P κ B hBm γ G) (hκ : 0<κ) (hκ8 : κ<8) (R : ℝ) :
+    (∫⁻ ω,C.physicalTerminal ω (closedBall 0 R) ∂P) < ∞ := by
+  simp_rw [C.physicalTerminal_apply _ isClosed_closedBall.measurableSet]
+  exact C.terminal_bounded_mean_lt_top hκ hκ8 R
+
+end SLEExactGauge.Multipoint
+
+end
+
+end OAI
diff --git a/lean/OAI/Probability/SLE/Mass/CanonicalRadonLimit.lean b/lean/OAI/Probability/SLE/Mass/CanonicalRadonLimit.lean
new file mode 100644
index 0000000000000000000000000000000000000000..ff6c2eeaebc93bffda96fda854164b00a32cf78b
--- /dev/null
+++ b/lean/OAI/Probability/SLE/Mass/CanonicalRadonLimit.lean
@@ -0,0 +1,86 @@
+import OAI.Probability.SLE.Mass.SubSigmaRadonLimit
+
+namespace OAI
+
+/-! A deterministic choice of the vague limit, with value zero when no
+regular limit exists. The same choice is measurable for every sigma-algebra
+making the approximating compact tests measurable. -/
+
+noncomputable section
+open Set Filter MeasureTheory Classical
+open scoped Topology CompactlySupported
+
+namespace SLEExactGauge
+
+variable {X : Type*} [TopologicalSpace X] [T2Space X] [LocallyCompactSpace X]
+  [SecondCountableTopology X] [MeasurableSpace X] [BorelSpace X]
+
+def HasRegularTestLimit (μ : ℕ → Measure X) (ν : Measure X) : Prop :=
+  ν.Regular ∧ ∀ f : C_c(X,ℝ),
+    Tendsto (fun n => ∫ x, f x ∂μ n) atTop (𝓝 (∫ x, f x ∂ν))
+
+def canonicalRadonLimit (μ : ℕ → Measure X) : Measure X :=
+  if h : ∃ ν, HasRegularTestLimit μ ν then h.choose else 0
+
+omit [T2Space X] [LocallyCompactSpace X] [SecondCountableTopology X] [BorelSpace X] in
+theorem canonicalRadonLimit_regular (μ : ℕ → Measure X) :
+    (canonicalRadonLimit μ).Regular := by
+  classical
+  unfold canonicalRadonLimit
+  split_ifs with h
+  · exact h.choose_spec.1
+  · infer_instance
+
+omit [SecondCountableTopology X] in
+theorem canonicalRadonLimit_identified (μ : ℕ → Measure X) (ν : Measure X)
+    (hν : HasRegularTestLimit μ ν) : canonicalRadonLimit μ = ν := by
+  classical
+  have hex : ∃ η, HasRegularTestLimit μ η := ⟨ν,hν⟩
+  have hspec := hex.choose_spec
+  let := hspec.1
+  let := hν.1
+  rw [canonicalRadonLimit,dite_eq_left hex]
+  exact radon_test_limit_unique μ _ ν hspec.2 hν.2
+
+theorem canonicalRadonLimit_measurable
+    {Ω : Type*} [MeasurableSpace Ω] (μ : ℕ → Ω → Measure X)
+    (hfinite : ∀ n ω, IsFiniteMeasureOnCompacts (μ n ω))
+    (hmeas : ∀ n (f : C_c(X,ℝ)), Measurable (fun ω => ∫ x, f x ∂μ n ω)) :
+    Measurable (fun ω => canonicalRadonLimit (fun n => μ n ω)) := by
+  classical
+  let D := localTestFamily X
+  let G : Set Ω := {ω | ∀ j, ∃ a : ℝ,
+    Tendsto (fun n => ∫ x, D.test j x ∂μ n ω) atTop (𝓝 a)}
+  have hG : MeasurableSet G := by
+    simpa only [G,Set.ofPred_forall] using MeasurableSet.iInter
+      (fun j => measurableSet_exists_tendsto (fun n => hmeas n (D.test j)))
+  have hex (ω : Ω) : ω ∈ G ↔ ∃ ν, HasRegularTestLimit (fun n => μ n ω) ν := by
+    constructor
+    · intro hω
+      let (n : ℕ) : IsFiniteMeasureOnCompacts (μ n ω) := hfinite n ω
+      obtain ⟨ν,hr,_,hl⟩ := D.exists_radon_limit (fun n => μ n ω) hω
+      exact ⟨ν,hr,hl⟩
+    · rintro ⟨ν,_,hl⟩ j
+      exact ⟨∫ x, D.test j x ∂ν,hl (D.test j)⟩
+  apply measurable_radon_of_tests _ (fun ω => canonicalRadonLimit_regular _)
+  intro f
+  apply measurable_of_tendsto_metrizable
+    (f := fun n ω => if ω ∈ G then ∫ x, f x ∂μ n ω else 0)
+  · intro n
+    exact (hmeas n f).ite hG measurable_const
+  · apply tendsto_pi_nhds.mpr
+    intro ω
+    by_cases hω : ω ∈ G
+    · obtain ⟨ν,hν⟩ := (hex ω).mp hω
+      rw [canonicalRadonLimit_identified _ ν hν]
+      simpa only [ite_eq_left hω] using hν.2 f
+    · have he : canonicalRadonLimit (fun n => μ n ω) = 0 := by
+        rw [canonicalRadonLimit,dite_eq_right (mt (hex ω).mpr hω)]
+      simpa only [ite_eq_right hω,he,integral_zero_measure] using
+        (tendsto_const_nhds : Tendsto (fun _ : ℕ => (0:ℝ)) atTop (𝓝 0))
+
+end SLEExactGauge
+
+end
+
+end OAI
diff --git a/lean/OAI/Probability/SLE/Mass/CanonicalRawMass.lean b/lean/OAI/Probability/SLE/Mass/CanonicalRawMass.lean
new file mode 100644
index 0000000000000000000000000000000000000000..f207a9a18b1db93a6e5c94a0ae6d6811ad9cea07
--- /dev/null
+++ b/lean/OAI/Probability/SLE/Mass/CanonicalRawMass.lean
@@ -0,0 +1,39 @@
+import OAI.Probability.SLE.Mass.CanonicalMassConstruction
+import OAI.Probability.SLE.Mass.RawMassFunctional
+
+namespace OAI
+
+/-! The canonical finite-time mass admits one raw nonanticipating functional
+on continuous real driver paths. No future-dependent modification is used. -/
+
+noncomputable section
+open Set Filter _root_.MeasureTheory _root_.OAI.MeasureTheory
+open scoped Topology NNReal CompactlySupported
+
+namespace SLEExactGauge.Multipoint
+
+local instance canonicalRawDriverMeasurable : MeasurableSpace C(ℝ≥0,ℝ) := borel _
+local instance canonicalRawDriverBorel : BorelSpace C(ℝ≥0,ℝ) := ⟨rfl⟩
+
+theorem CanonicalMass.exists_raw_nonanticipating_functional
+    {Ω : 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,
+      IsProgressive driverPathFiltration R ∧
+      (∀ t p, (R t p).Regular ∧ IsFiniteMeasureOnCompacts (R t p)) ∧
+      (∀ t p q, (∀ s ≤ t, p s=q s) → R t p=R t q) ∧
+      ∀ᵐ ω ∂P, ∀ t, R t (sourceDriverPath B hBc ω) = C.process t ω := by
+  apply exists_raw_progressive_radon_factor P B
+    (fun t => hBm.comp (measurable_const.prodMk measurable_id)) hBc C.process
+    C.progressive.adapted (fun t ω => (C.radon t ω).1)
+  filter_upwards [C.paths] with ω hω
+  exact hω.continuous_tests
+
+end SLEExactGauge.Multipoint
+
+end
+
+end OAI
diff --git a/lean/OAI/Probability/SLE/Mass/CellMassComparison.lean b/lean/OAI/Probability/SLE/Mass/CellMassComparison.lean
new file mode 100644
index 0000000000000000000000000000000000000000..1d033fd80ec7964f6494d02e12817ed9c3862d94
--- /dev/null
+++ b/lean/OAI/Probability/SLE/Mass/CellMassComparison.lean
@@ -0,0 +1,87 @@
+import OAI.Probability.SLE.Mass.InverseMassDilation
+import OAI.Probability.SLE.Mass.CanonicalMassContinuity
+
+namespace OAI
+
+/-! At a fixed conformal-radius level the normalized disk mass bounds the
+mass of a small cell and is bounded by the mass of a larger physical ball. -/
+
+noncomputable section
+open Set Filter _root_.MeasureTheory _root_.OAI.MeasureTheory Metric
+open scoped Topology NNReal ENNReal
+
+namespace SLEExactGauge
+open Multipoint
+
+lemma Multipoint.ContinuousMassPath.zero_on_surviving
+    {γ : ℝ≥0 → ℂ} {μ : ℚ → Measure upperHalfPlane} {ν : Measure upperHalfPlane}
+    {N : ℝ≥0 → Measure upperHalfPlane} (hp : ContinuousMassPath γ μ ν N)
+    (t : ℝ≥0) : N t (Subtype.val ⁻¹' survivingDomain γ t)=0 := by
+  have h := hp.increment_support 0 t (show 0 ≤ t from zero_le)
+  rw [hp.zero,Measure.sub_zero] at h
+  apply le_zero_iff.mp
+  apply (measure_mono ?_).trans_eq h
+  intro z hz
+  rintro ⟨s,hs,he⟩
+  apply hz.1.2
+  refine ⟨s.toNNReal,⟨zero_le,?_⟩,he⟩
+  simpa only [Real.toNNReal_coe] using Real.toNNReal_mono hs.2
+
+lemma Multipoint.ContinuousMassPath.zero_on_surviving_subset
+    {γ : ℝ≥0 → ℂ} {μ : ℚ → Measure upperHalfPlane} {ν : Measure upperHalfPlane}
+    {N : ℝ≥0 → Measure upperHalfPlane} (hp : ContinuousMassPath γ μ ν N)
+    (t : ℝ≥0) (A : Set ℂ) (hA : A ⊆ survivingDomain γ t) :
+    N t (Subtype.val ⁻¹' A)=0 :=
+  le_zero_iff.mp ((measure_mono (preimage_mono hA)).trans_eq (hp.zero_on_surviving t))
+
+lemma measure_sub_apply_of_zero
+    {X : Type*} [MeasurableSpace X] (μ ν : Measure X) [SigmaFinite μ]
+    (hle : μ ≤ ν) (A : Set X) (hz : μ A=0) : (ν-μ) A=ν A := by
+  have he := congrArg (fun ρ : Measure X => ρ A) (sigmaFinite_sub_add_cancel_of_le hle)
+  simpa only [Measure.add_apply,hz,add_zero] using he
+
+lemma IsCapacityTwoWitness.cell_mass_comparison
+    {U : ℝ≥0 → ℝ} {γ : ℝ≥0 → ℂ} {G F : ℝ≥0 → ℂ → ℂ}
+    (hw : IsCapacityTwoWitness U γ G F) (hgrowth : PublishedDiskUnivalentGrowth)
+    (κ : ℝ) (hκ : 0<κ) (θ : ℝ) (hθ : θ ∈ Ioo (0:ℝ) Real.pi)
+    (t : ℝ≥0) (z : ℂ) (hz : z ∈ survivingDomain γ t)
+    (r : ℝ) (hr : 0<r) (hR : fullRadius G t z=(2048*Real.pi)*r)
+    (a : ℝ≥0) (ha : 0<a)
+    (he : G t z=(U t:ℂ)+(a:ℂ)*Complex.exp (θ*Complex.I))
+    (μ : Measure upperHalfPlane) [IsFiniteMeasureOnCompacts μ] :
+    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
+  let f := physicalDiskChart id F G t z
+  have hRp : 0<fullRadius G t z := by rw [hR]; positivity
+  obtain ⟨_,hinner,houter,_,_⟩ := hw.quarter_disk_chart_bounds hgrowth t z hz hRp
+  have hb := hw.physical_quarter_mass_bounds hgrowth κ hκ θ hθ t z hz a he μ
+  have hi : fullRadius G t z/(1024*Real.pi)=2*r := by
+    rw [hR]
+    field_simp
+    ring
+  have ho : 2*fullRadius G t z=(4096*Real.pi)*r := by rw [hR]; ring
+  have hl : fullRadius G t z/16=(128*Real.pi)*r := by rw [hR]; ring
+  have hu : 16*fullRadius G t z=(32768*Real.pi)*r := by rw [hR]; ring
+  change ENNReal.ofReal ((fullRadius G t z/16)^dimension κ)*_ ≤ _ ∧
+    _ ≤ ENNReal.ofReal ((16*fullRadius G t z)^dimension κ)*_ at hb
+  rw [hl,hu] at hb
+  rw [hi] at hinner
+  rw [ho] at houter
+  dsimp only
+  rw [hw.inverse_mass_dilation κ hκ t a ha μ]
+  refine ⟨hb.1.trans (measure_mono houter),?_⟩
+  intro A hA
+  exact (measure_mono (hA.trans hinner)).trans hb.2
+
+end SLEExactGauge
+
+end
+
+end OAI
diff --git a/lean/OAI/Probability/SLE/Mass/CompactConformalPassageMass.lean b/lean/OAI/Probability/SLE/Mass/CompactConformalPassageMass.lean
new file mode 100644
index 0000000000000000000000000000000000000000..e9188a288b478b2067c71b4a3527b87af8c26627
--- /dev/null
+++ b/lean/OAI/Probability/SLE/Mass/CompactConformalPassageMass.lean
@@ -0,0 +1,132 @@
+import OAI.Probability.SLE.Gauge.ConformalCompactSausage
+import OAI.Probability.SLE.Gauge.RibbonPassageMass
+import OAI.Probability.SLE.SausageCharge
+import OAI.Probability.SLE.Gauge.RetainedPassageExtraction
+
+namespace OAI
+
+/-! The compact-retention and sausage part of the uniform ribbon step,
+assembled for actual locally convergent conformal maps and actual SLE.
+Only the passage event and its retained intervals are supplied by geometry. -/
+
+noncomputable section
+open Set Filter MeasureTheory
+open scoped Topology ENNReal NNReal
+
+namespace SLEExactGauge
+
+theorem compact_conformal_ribbon_mass
+    {Ω : Type*} [MeasurableSpace Ω] (P : Measure Ω) [IsProbabilityMeasure P]
+    (κ : ℝ) (hκ : 0 < κ) (hκ8 : κ < 8)
+    (γ : Ω → ℝ≥0 → ℂ) (hSLE : IsOrdinaryChordalSLE κ γ P)
+    (Fₙ : ℕ → ℂ → ℂ) (F : ℂ → ℂ)
+    (hFn : ∀ n, DifferentiableOn ℂ (Fₙ n) upperHalfPlane)
+    (hinj : ∀ n, InjOn (Fₙ n) upperHalfPlane)
+    (hF : DifferentiableOn ℂ F upperHalfPlane)
+    (hne : ∀ z ∈ upperHalfPlane, deriv F z ≠ 0)
+    (hconv : TendstoLocallyUniformlyOn Fₙ F atTop upperHalfPlane)
+    (K : Set ℂ) (hK : IsCompact K) (hKn : K.Nonempty) (hKH : K ⊆ upperHalfPlane)
+    (R : Set ℂ) (hR : IsOpen R) (himage : F '' K ⊆ R)
+    (I : Finset (ℝ≥0 × ℝ≥0)) (hI : ∀ J ∈ I, J.1 < J.2)
+    (v : ℕ → ℝ) (hv : ∀ n, 0 < v n) (hlim : Tendsto v atTop (𝓝 0))
+    (G : ℕ → Set Ω) (q : ℝ) (hq : 0 < q)
+    (hG : ∀ᶠ n in atTop, ENNReal.ofReal q ≤ P (G n))
+    (hretain : ∀ᶠ n in atTop, ∀ ω, ω ∈ G n →
+      ∃ J ∈ I, γ ω '' Icc J.1 J.2 ⊆ K) :
+    ∃ a : ℝ, 0 < a ∧ ∀ᶠ n in atTop,
+      ENNReal.ofReal (q / 2) ≤ P {ω | ω ∈ G n ∧ ENNReal.ofReal a ≤
+        wholeSausageCharge κ (fun t => Fₙ n (γ ω t)) (v n) R} := by
+  obtain ⟨c, ell, v₀, hc, hell, hv₀, htransfer⟩ := eventually_compact_sausage_transfer
+    κ Fₙ F hFn hinj hF hne hconv K hK hKn hKH R hR himage
+  have hcoeff : 0 < c ^ 2 * ell ^ codimension κ :=
+    mul_pos (sq_pos_of_pos hc) (Real.rpow_pos_of_pos hell _)
+  have hsmall : ∀ᶠ n in atTop, v n < v₀ := hlim.eventually (gt_mem_nhds hv₀)
+  have hlim' : Tendsto (fun n => ell * v n) atTop (𝓝 0) := by
+    simpa only [mul_zero] using tendsto_const_nhds.mul hlim
+  have htrans : ∀ᶠ n in atTop, ∀ ω, ω ∈ G n → True ∧
+      ∃ J ∈ I, ENNReal.ofReal (c ^ 2 * ell ^ codimension κ) *
+        sourceSausageMass κ (γ ω) J.1 J.2 (ell * v n) ≤
+        wholeSausageCharge κ (fun t => Fₙ n (γ ω t)) (v n) R := by
+    filter_upwards [htransfer, hretain, hsmall] with n hn hr hs
+    intro ω hω
+    obtain ⟨J, hJI, hJK⟩ := hr ω hω
+    refine ⟨trivial, J, hJI, (hn (γ ω) J.1 J.2 hJK (v n) (hv n) hs).trans ?_⟩
+    apply mul_le_mul' le_rfl (measure_mono (inter_subset_inter_right R ?_))
+    rintro z ⟨t, _, hdist⟩
+    exact ⟨t, by simpa only [dist_comm] using hdist⟩
+  obtain ⟨a, ha, hmass⟩ := ribbon_passage_mass_of_eventually_finite_intervals
+    P κ hκ hκ8 γ hSLE I hI (fun n => ell * v n)
+    (fun n => mul_pos hell (hv n)) hlim' G q hq hG
+    (fun n ω => wholeSausageCharge κ (fun t => Fₙ n (γ ω t)) (v n) R)
+    (fun _ _ => True) (c ^ 2 * ell ^ codimension κ) hcoeff htrans
+  exact ⟨a, ha, by simpa only [true_and] using hmass⟩
+
+/-- A countable family of actual retained compact intervals is enough.
+The finite extraction, common mesh, derivative constants, and unconditional
+small-sausage subtraction are all performed here. -/
+theorem countable_compact_conformal_ribbon_mass
+    {Ω : Type*} [MeasurableSpace Ω] (P : Measure Ω) [IsProbabilityMeasure P]
+    (κ : ℝ) (hκ : 0 < κ) (hκ8 : κ < 8)
+    (γ : Ω → ℝ≥0 → ℂ) (hSLE : IsOrdinaryChordalSLE κ γ P)
+    (Fₙ : ℕ → ℂ → ℂ) (F : ℂ → ℂ)
+    (hFn : ∀ n, DifferentiableOn ℂ (Fₙ n) upperHalfPlane)
+    (hinj : ∀ n, InjOn (Fₙ n) upperHalfPlane)
+    (hF : DifferentiableOn ℂ F upperHalfPlane)
+    (hne : ∀ z ∈ upperHalfPlane, deriv F z ≠ 0)
+    (hconv : TendstoLocallyUniformlyOn Fₙ F atTop upperHalfPlane)
+    (K : ℕ → Set ℂ) (hK : ∀ i, IsCompact (K i))
+    (hKH : ∀ i, K i ⊆ upperHalfPlane)
+    (R : Set ℂ) (hR : IsOpen R) (himage : ∀ i, F '' K i ⊆ R)
+    (J : ℕ → ℝ≥0 × ℝ≥0) (hJ : ∀ i, (J i).1 < (J i).2)
+    (E : Set Ω) (D : ℕ → Set Ω)
+    (hE : MeasurableSet E) (hD : ∀ i, MeasurableSet (D i))
+    (hcover : P (E \ ⋃ i, D i) = 0)
+    (hretain : ∀ i ω, ω ∈ D i → γ ω '' Icc (J i).1 (J i).2 ⊆ K i)
+    (v : ℕ → ℝ) (hv : ∀ n, 0 < v n) (hlim : Tendsto v atTop (𝓝 0))
+    (G : ℕ → Set Ω) (q : ℝ) (hq : 0 < q)
+    (hG : ∀ n, ENNReal.ofReal q ≤ P (G n ∩ E)) :
+    ∃ a : ℝ, 0 < a ∧ ∀ᶠ n in atTop,
+      ENNReal.ofReal (q / 4) ≤ P {ω | ω ∈ G n ∩ E ∧ ENNReal.ofReal a ≤
+        wholeSausageCharge κ (fun t => Fₙ n (γ ω t)) (v n) R} := by
+  classical
+  obtain ⟨N, hN⟩ := varying_events_after_finite_retention P E D G hE hD hcover q hq hG
+  let A := ⋃ i ∈ Finset.range N, D i
+  let Q := ⋃ i ∈ Finset.range N, K i
+  let H : ℕ → Set Ω := fun n => G n ∩ E ∩ A
+  have hQ : IsCompact Q := (Finset.range N).isCompact_biUnion (fun i _ => hK i)
+  have hQH : Q ⊆ upperHalfPlane := iUnion₂_subset (fun i _ => hKH i)
+  have hQR : F '' Q ⊆ R := by
+    rintro w ⟨z, hz, rfl⟩
+    obtain ⟨i, _, hi⟩ := mem_iUnion₂.mp hz
+    exact himage i (mem_image_of_mem F hi)
+  have hQn : Q.Nonempty := by
+    have hHpos : 0 < P (H 0) := (ENNReal.ofReal_pos.mpr (by positivity : 0 < q / 2)).trans_le (hN 0)
+    obtain ⟨ω, hω⟩ := nonempty_of_measure_ne_zero hHpos.ne'
+    obtain ⟨i, hi, hDi⟩ := mem_iUnion₂.mp hω.2
+    refine ⟨γ ω (J i).1, mem_iUnion₂.mpr ⟨i, hi, ?_⟩⟩
+    exact hretain i ω hDi (mem_image_of_mem (γ ω) ⟨le_rfl, (hJ i).le⟩)
+  let I := (Finset.range N).image J
+  have hI : ∀ L ∈ I, L.1 < L.2 := by
+    intro L hL
+    obtain ⟨i, _, rfl⟩ := Finset.mem_image.mp hL
+    exact hJ i
+  have hr : ∀ n ω, ω ∈ H n → ∃ L ∈ I, γ ω '' Icc L.1 L.2 ⊆ Q := by
+    intro n ω hω
+    obtain ⟨i, hi, hDi⟩ := mem_iUnion₂.mp hω.2
+    exact ⟨J i, Finset.mem_image.mpr ⟨i, hi, rfl⟩,
+      (hretain i ω hDi).trans (subset_iUnion₂_of_subset i hi Subset.rfl)⟩
+  obtain ⟨a, ha, hmass⟩ := compact_conformal_ribbon_mass P κ hκ hκ8 γ hSLE
+    Fₙ F hFn hinj hF hne hconv Q hQ hQn hQH R hR hQR I hI
+    v hv hlim H (q / 2) (by positivity) (Eventually.of_forall hN)
+    (Eventually.of_forall hr)
+  refine ⟨a, ha, ?_⟩
+  filter_upwards [hmass] with n hn
+  have hqq : q / 2 / 2 = q / 4 := by ring
+  rw [hqq] at hn
+  exact hn.trans (measure_mono (fun _ hω => ⟨hω.1.1, hω.2⟩))
+
+end SLEExactGauge
+
+end
+
+end OAI
diff --git a/lean/OAI/Probability/SLE/Mass/CompactEntryLevels.lean b/lean/OAI/Probability/SLE/Mass/CompactEntryLevels.lean
new file mode 100644
index 0000000000000000000000000000000000000000..86809e29c12ec848584dea812c92b6134bf74c2f
--- /dev/null
+++ b/lean/OAI/Probability/SLE/Mass/CompactEntryLevels.lean
@@ -0,0 +1,52 @@
+import OAI.Probability.SLE.Gauge.PrescribedRadiusLevels
+
+namespace OAI
+
+/-! Uniform control of the prescribed logarithmic levels on a compact
+subset of the open half-plane. -/
+noncomputable section
+open Set Filter
+open scoped Topology
+
+namespace SLEExactGauge.Target
+
+lemma continuous_entryPhysicalLevel (κ : ℝ) (W : WienerLaw) (e : Entry)
+    {A : ℝ} (hA : 0<A) :
+    Continuous (fun z : upperHalfPlane => entryPhysicalLevel κ W e A z) := by
+  have hf : Continuous (fun z : upperHalfPlane => (2*(z:ℂ).im)/A) := by fun_prop
+  have hn (z : upperHalfPlane) : (2*(z:ℂ).im)/A ≠ 0 :=
+    ne_of_gt (div_pos (mul_pos (by norm_num) z.property) hA)
+  exact ((hf.log hn).add continuous_const).add continuous_const
+
+lemma entryPhysicalLevel_bounded_on_compact (κ : ℝ) (W : WienerLaw) (e : Entry)
+    {A : ℝ} (hA : 0<A) (K : Set upperHalfPlane) (hK : IsCompact K) :
+    ∃ M : ℝ, ∀ z∈K, entryPhysicalLevel κ W e A z ≤ M := by
+  obtain ⟨M,hM⟩ := hK.bddAbove_image
+    (continuous_entryPhysicalLevel κ W e hA).continuousOn
+  exact ⟨M,fun z hz => hM ⟨z,hz,rfl⟩⟩
+
+lemma eventually_entryPhysicalLevel_large_on_compact {κ : ℝ} (hκ : 0<κ)
+    (W : WienerLaw) {A : ℝ} (hA : 0<A) (L : ℝ)
+    (K : Set upperHalfPlane) (hK : IsCompact K) :
+    ∃ N : ℕ, ∀ e : GaugeIndex κ W, N≤e.val.1 → ∀ z∈K,
+      L<entryPhysicalLevel κ W e.val A z := by
+  rcases K.eq_empty_or_nonempty with rfl | hne
+  · exact ⟨0,by simp⟩
+  obtain ⟨z₀,hz₀,hmin⟩ := hK.exists_isMinOn hne
+    (Complex.continuous_im.comp continuous_subtype_val).continuousOn
+  have he : Tendsto (fun n : ℕ => Real.exp (-(n:ℝ))) atTop (nhds 0) :=
+    Real.tendsto_exp_neg_atTop_nhds_zero.comp tendsto_natCast_atTop_atTop
+  have hh : ∀ᶠ n : ℕ in atTop, Real.exp (-(n:ℝ)) < (z₀:ℂ).im :=
+    he.eventually (gt_mem_nhds z₀.property)
+  obtain ⟨N,hN⟩ := eventually_atTop.mp
+    (hh.and (eventually_entryPhysicalLevel_large hκ W hA L))
+  refine ⟨N,?_⟩
+  intro e he z hz
+  exact (hN e.val.1 he).2 e.val.2 z
+    ((hN e.val.1 he).1.le.trans (hmin hz))
+
+end SLEExactGauge.Target
+
+end
+
+end OAI
diff --git a/lean/OAI/Probability/SLE/Mass/CompactImageMassBounds.lean b/lean/OAI/Probability/SLE/Mass/CompactImageMassBounds.lean
new file mode 100644
index 0000000000000000000000000000000000000000..1a5513271993e04b4c6714621c132e0dbefa1577
--- /dev/null
+++ b/lean/OAI/Probability/SLE/Mass/CompactImageMassBounds.lean
@@ -0,0 +1,31 @@
+import OAI.Probability.SLE.Mass.WeightedImageRandomMass
+
+namespace OAI
+
+/-! Pointwise conformal weight bounds imply actual image-mass bounds. -/
+
+noncomputable section
+open Set MeasureTheory
+open scoped ENNReal
+
+namespace SLEExactGauge
+
+lemma weightedImageMass_image_bounds
+    {X : Type*} [MeasurableSpace X] (J : upperHalfPlane → X)
+    (hJ : MeasurableEmbedding J) (μ : Measure upperHalfPlane)
+    (w v : upperHalfPlane → ℝ≥0∞) (K : Set upperHalfPlane) (hK : MeasurableSet K)
+    (c C : ℝ≥0∞) (hc : c ≠ ∞) (hC : C ≠ ∞)
+    (hlower : ∀ z∈K, c*v z ≤ w z) (hupper : ∀ z∈K, w z ≤ C*v z) :
+    c*(∫⁻ z in K, v z ∂μ) ≤ weightedImageMass J w μ (J '' K) ∧
+      weightedImageMass J w μ (J '' K) ≤ C*(∫⁻ z in K, v z ∂μ) := by
+  have he : weightedImageMass J w μ (J '' K) = ∫⁻ z in K, w z ∂μ := by
+    rw [weightedImageMass,Measure.map_apply hJ.measurable (hJ.measurableSet_image.mpr hK),
+      Set.preimage_image_eq _ hJ.injective,withDensity_apply _ hK]
+  rw [he,← lintegral_const_mul' _ _ hc,← lintegral_const_mul' _ _ hC]
+  exact ⟨setLIntegral_mono' hK hlower,setLIntegral_mono' hK hupper⟩
+
+end SLEExactGauge
+
+end
+
+end OAI
diff --git a/lean/OAI/Probability/SLE/Mass/CompactLevelMoments.lean b/lean/OAI/Probability/SLE/Mass/CompactLevelMoments.lean
new file mode 100644
index 0000000000000000000000000000000000000000..ec67dc7aa16046edf8cff491d9328611cc12150d
--- /dev/null
+++ b/lean/OAI/Probability/SLE/Mass/CompactLevelMoments.lean
@@ -0,0 +1,201 @@
+import OAI.Probability.SLE.Multipoint.MultipointCenteredWeights
+import OAI.Probability.SLE.Multipoint.MultipointFixedCenterKernel
+
+namespace OAI
+
+/-! Integrating the actual multipoint bound on an interior compact set.
+The bound is independent of the common radius level. -/
+
+noncomputable section
+open Set Filter MeasureTheory ProbabilityTheory
+open scoped NNReal ENNReal
+
+namespace SLEExactGauge.Multipoint
+
+lemma ae_tuple_mem {ι : Type*} [Fintype ι] (K : Set ℂ) (hK : MeasurableSet K) :
+    ∀ᵐ z : ι → ℂ ∂Measure.pi (fun _ : ι => volume.restrict K), ∀ i, z i ∈ K := by
+  apply ae_all_iff.mpr
+  intro i
+  exact MeasureTheory.Measure.tendsto_eval_ae_ae.eventually (ae_restrict_mem hK)
+
+lemma compact_positive_radius_cap {K : Set ℂ} (hK : IsCompact K)
+    (hKH : K ⊆ upperHalfPlane) : ∃ b : ℝ, 0 < b ∧ ∀ z ∈ K, b ≤ 2*z.im := by
+  exact hK.exists_forall_le' (by fun_prop) (fun z hz => mul_pos (by norm_num) (hKH hz))
+
+def compactLevelMomentBound (κ b : ℝ) (K : Set ℂ) (m : ℕ) : ℝ≥0∞ :=
+  ENNReal.ofReal (multipointConstant κ m) *
+    ∫⁻ z : Fin m → ℂ, cappedDistanceKernel (codimension κ) b z
+      ∂Measure.pi (fun _ : Fin m => volume.restrict K)
+
+theorem levelMass_moment_le_cappedKernel
+    {Ω : Type*} [MeasurableSpace Ω]
+    {P : Measure Ω} {B : ℝ≥0 → Ω → ℝ} (hB : IsBrownianReal B P)
+    (hm : ∀ t, Measurable (B t)) (hBm : Measurable (Function.uncurry B))
+    (hBc : ∀ ω, Continuous (fun t => B t ω)) (hB0 : ∀ ω, B 0 ω = 0)
+    {κ : ℝ} (hκ : 0 < κ) (hκ8 : κ < 8)
+    (γ : Ω → ℝ≥0 → ℂ) (G F : Ω → ℝ≥0 → ℂ → ℂ)
+    (hw : ∀ ω, IsCapacityTwoWitness (fun t => Real.sqrt κ*B t ω) (γ ω) (G ω) (F ω))
+    (hgrowth : PublishedDiskUnivalentGrowth)
+    (K : Set ℂ) (hK : MeasurableSet K) (hKH : K ⊆ upperHalfPlane)
+    (b : ℝ) (hb : 0 < b) (hbR : ∀ z ∈ K, b ≤ 2*z.im) (m : ℕ)
+    (u : ℝ) (hu : 0 ≤ u) :
+    (∫⁻ ω, levelMass κ B γ G u K ω ^ m ∂P) ≤ compactLevelMomentBound κ b K m := by
+  let : IsProbabilityMeasure P := hB.isGaussianProcess.isProbabilityMeasure
+  rw [levelMass_moment_identity P hm hBc κ u hu γ G F hw K m]
+  unfold compactLevelMomentBound
+  rw [← lintegral_const_mul _ (measurable_cappedDistanceKernel _ _)]
+  apply lintegral_mono_ae
+  filter_upwards [ae_tuple_mem (ι := Fin m) K hK,ae_tuple_injective (ι := Fin m) K] with z hz hzi
+  have h := stoppedGreen_common_level_product_bound hB hm hBm hBc hB0 hκ hκ8 γ G F hw
+    hgrowth z (fun i => hKH (hz i)) hzi (cappedDistance b z)
+    (fun i => cap_pos hb hzi i)
+    (fun i => (cap_le_fixed b z i).trans (hbR (z i) (hz i)))
+    (fun i j hij => cap_le_dist b z i j hij) u
+  apply h.trans_eq
+  rw [ENNReal.ofReal_mul (by positivity)]
+  congr 1
+  · simp only [multipointConstant,Fintype.card_fin]
+  · exact ENNReal.ofReal_prod_of_nonneg
+      (fun i _ => Real.rpow_nonneg (cap_pos hb hzi i).le _)
+
+lemma compactLevelMomentBound_lt_top {κ : ℝ} (hκ : 0 < κ) (hκ8 : κ < 8)
+    (b : ℝ) (K : Set ℂ) (hK : Bornology.IsBounded K) (m : ℕ) :
+    compactLevelMomentBound κ b K m < ⊤ := by
+  apply ENNReal.mul_lt_top ENNReal.ofReal_lt_top
+  exact cappedDistanceKernel_integral_lt_top (codimension_pos κ hκ8)
+    (by unfold codimension dimension; linarith) b K hK
+
+theorem uniform_levelMass_compact_moments
+    {Ω : Type*} [MeasurableSpace Ω]
+    {P : Measure Ω} {B : ℝ≥0 → Ω → ℝ} (hB : IsBrownianReal B P)
+    (hm : ∀ t, Measurable (B t)) (hBm : Measurable (Function.uncurry B))
+    (hBc : ∀ ω, Continuous (fun t => B t ω)) (hB0 : ∀ ω, B 0 ω = 0)
+    {κ : ℝ} (hκ : 0 < κ) (hκ8 : κ < 8)
+    (γ : Ω → ℝ≥0 → ℂ) (G F : Ω → ℝ≥0 → ℂ → ℂ)
+    (hw : ∀ ω, IsCapacityTwoWitness (fun t => Real.sqrt κ*B t ω) (γ ω) (G ω) (F ω))
+    (hgrowth : PublishedDiskUnivalentGrowth)
+    (K : Set ℂ) (hK : IsCompact K) (hKH : K ⊆ upperHalfPlane) (m : ℕ) :
+    ∃ M : ℝ≥0∞, M < ⊤ ∧ ∀ u : ℝ, 0 ≤ u →
+      (∫⁻ ω, levelMass κ B γ G u K ω ^ m ∂P) ≤ M := by
+  obtain ⟨b,hb,hbR⟩ := compact_positive_radius_cap hK hKH
+  exact ⟨compactLevelMomentBound κ b K m,
+    compactLevelMomentBound_lt_top hκ hκ8 b K hK.isBounded m,
+    fun u hu => levelMass_moment_le_cappedKernel hB hm hBm hBc hB0 hκ hκ8 γ G F hw
+      hgrowth K hK.measurableSet hKH b hb hbR m u hu⟩
+
+theorem uniform_levelApproximation_compact_moments
+    {Ω : Type*} [MeasurableSpace Ω]
+    {P : Measure Ω} {B : ℝ≥0 → Ω → ℝ} (hB : IsBrownianReal B P)
+    (hm : ∀ t, Measurable (B t)) (hBm : Measurable (Function.uncurry B))
+    (hBc : ∀ ω, Continuous (fun t => B t ω)) (hB0 : ∀ ω, B 0 ω = 0)
+    {κ : ℝ} (hκ : 0 < κ) (hκ8 : κ < 8)
+    (γ : Ω → ℝ≥0 → ℂ) (G F : Ω → ℝ≥0 → ℂ → ℂ)
+    (hw : ∀ ω, IsCapacityTwoWitness (fun t => Real.sqrt κ*B t ω) (γ ω) (G ω) (F ω))
+    (hgrowth : PublishedDiskUnivalentGrowth)
+    (K : Set ℂ) (hK : IsCompact K) (hKH : K ⊆ upperHalfPlane) (m : ℕ) :
+    ∃ M : ℝ≥0∞, M < ⊤ ∧ ∀ u : ℝ, 0 ≤ u → ∀ t : ℝ≥0∞,
+      (∫⁻ ω, (levelApproximation κ B γ G u t ω K) ^ m ∂P) ≤ M := by
+  obtain ⟨M,hM,hu⟩ := uniform_levelMass_compact_moments hB hm hBm hBc hB0 hκ hκ8
+    γ G F hw hgrowth K hK hKH m
+  refine ⟨M,hM,fun u hu₀ t => ?_⟩
+  apply le_trans (lintegral_mono (fun ω => ?_)) (hu u hu₀)
+  exact pow_le_pow_left' (levelApproximation_apply_le κ B γ G u t ω hK.measurableSet) m
+
+def centeredLevelMomentBound (κ b : ℝ) (z₀ : ℂ) (K : Set ℂ) (m : ℕ) : ℝ≥0∞ :=
+  ENNReal.ofReal (multipointConstant κ (m+1)) *
+    ∫⁻ z : Fin m → ℂ, cappedDistanceKernel (codimension κ) b (Fin.cons z₀ z)
+      ∂Measure.pi (fun _ : Fin m => volume.restrict K)
+
+theorem levelMass_centered_moment_le_cappedKernel
+    {Ω : Type*} [MeasurableSpace Ω]
+    {P : Measure Ω} {B : ℝ≥0 → Ω → ℝ} (hB : IsBrownianReal B P)
+    (hm : ∀ t, Measurable (B t)) (hBm : Measurable (Function.uncurry B))
+    (hBc : ∀ ω, Continuous (fun t => B t ω)) (hB0 : ∀ ω, B 0 ω = 0)
+    {κ : ℝ} (hκ : 0 < κ) (hκ8 : κ < 8)
+    (γ : Ω → ℝ≥0 → ℂ) (G F : Ω → ℝ≥0 → ℂ → ℂ)
+    (hw : ∀ ω, IsCapacityTwoWitness (fun t => Real.sqrt κ*B t ω) (γ ω) (G ω) (F ω))
+    (hgrowth : PublishedDiskUnivalentGrowth)
+    (K : Set ℂ) (hK : MeasurableSet K) (hKH : K ⊆ upperHalfPlane)
+    (z₀ : ℂ) (hz₀ : z₀ ∈ upperHalfPlane) (e₀ : ℝ) (he₀ : 0 < e₀) (heR : e₀ ≤ 2*z₀.im)
+    (b : ℝ) (hb : 0 < b) (hb₀ : b ≤ 2*z₀.im) (hbR : ∀ z ∈ K, b ≤ 2*z.im) (m : ℕ)
+    (u : ℝ) (hu : 0 ≤ u) :
+    (∫⁻ ω in {ω | ∃ t : ℝ≥0, z₀ ∈ survivingDomain (γ ω) t ∧
+      physicalConformalRadius (fun z : ℂ => z) (G ω) t z₀ ≤ e₀},
+      levelMass κ B γ G u K ω ^ m ∂P) ≤
+      ENNReal.ofReal (e₀^(codimension κ)) * centeredLevelMomentBound κ b z₀ K m := by
+  let : IsProbabilityMeasure P := hB.isGaussianProcess.isProbabilityMeasure
+  let E := {ω | ∃ t : ℝ≥0, z₀ ∈ survivingDomain (γ ω) t ∧
+    physicalConformalRadius (fun z : ℂ => z) (G ω) t z₀ ≤ e₀}
+  have hE : MeasurableSet E := measurableSet_physical_radius_hit hm hBc κ γ G F hw z₀ hz₀ e₀ he₀ heR
+  rw [levelMass_moment_identity (P.restrict E) hm hBc κ u hu γ G F hw K m]
+  have hbound : (∫⁻ z : Fin m → ℂ, ∫⁻ ω in E,
+      ENNReal.ofReal (∏ i, stoppedGreen κ (fun t => Real.sqrt κ*B t ω)
+        (γ ω) (G ω) (z i) u) ∂P ∂Measure.pi (fun _ : Fin m => volume.restrict K)) ≤
+      (ENNReal.ofReal (multipointConstant κ (m+1)) * ENNReal.ofReal (e₀^codimension κ)) *
+        ∫⁻ z : Fin m → ℂ, cappedDistanceKernel (codimension κ) b (Fin.cons z₀ z)
+          ∂Measure.pi (fun _ : Fin m => volume.restrict K) := by
+    have hc : Measurable (fun z : Fin m → ℂ => (Fin.cons z₀ z : Fin (m+1) → ℂ)) := by
+      apply Measurable.of_eval
+      intro i
+      exact Fin.cases measurable_const (fun j => measurable_pi_apply j) i
+    have hk : Measurable (fun z : Fin m → ℂ => cappedDistanceKernel (codimension κ) b
+        (Fin.cons z₀ z)) := by
+      simpa only [Function.comp_def] using
+        (measurable_cappedDistanceKernel (codimension κ) b).comp hc
+    rw [← lintegral_const_mul _ hk]
+    apply lintegral_mono_ae
+    filter_upwards [ae_tuple_mem (ι := Fin m) K hK,ae_tuple_injective (ι := Fin m) K,
+      ae_tuple_avoids (ι := Fin m) K z₀] with z hz hzi havoid
+    let z' : Fin (m+1) → ℂ := Fin.cons z₀ z
+    have hz' : ∀ i, z' i ∈ upperHalfPlane := Fin.cases hz₀ (fun i => hKH (hz i))
+    have hzi' : Function.Injective z' := Fin.cons_injective_of_injective
+      (by rintro ⟨i,hi⟩; exact havoid i hi) hzi
+    have hbR' : ∀ i, b ≤ 2*(z' i).im := Fin.cases hb₀ (fun i => hbR (z i) (hz i))
+    have h := stoppedGreen_centered_common_level_bound hB hm hBm hBc hB0 hκ hκ8 γ G F hw
+      hgrowth m z' hz' hzi' (cappedDistance b z') (fun i => cap_pos hb hzi' i)
+      (fun i => (cap_le_fixed b z' i).trans (hbR' i))
+      (fun i j hij => cap_le_dist b z' i j hij) e₀ he₀ u
+    rw [← lintegral_indicator hE]
+    apply h.trans_eq
+    rw [ENNReal.ofReal_mul (mul_nonneg (multipointConstant_pos κ _).le
+        (Real.rpow_nonneg he₀.le _)),
+      ENNReal.ofReal_mul (multipointConstant_pos κ _).le]
+    congr 1
+    exact ENNReal.ofReal_prod_of_nonneg
+      (fun i _ => Real.rpow_nonneg (cap_pos hb hzi' i).le _)
+  exact hbound.trans_eq (by unfold centeredLevelMomentBound; ring)
+
+theorem uniform_levelMass_centered_compact_moments
+    {Ω : Type*} [MeasurableSpace Ω]
+    {P : Measure Ω} {B : ℝ≥0 → Ω → ℝ} (hB : IsBrownianReal B P)
+    (hm : ∀ t, Measurable (B t)) (hBm : Measurable (Function.uncurry B))
+    (hBc : ∀ ω, Continuous (fun t => B t ω)) (hB0 : ∀ ω, B 0 ω = 0)
+    {κ : ℝ} (hκ : 0 < κ) (hκ8 : κ < 8)
+    (γ : Ω → ℝ≥0 → ℂ) (G F : Ω → ℝ≥0 → ℂ → ℂ)
+    (hw : ∀ ω, IsCapacityTwoWitness (fun t => Real.sqrt κ*B t ω) (γ ω) (G ω) (F ω))
+    (hgrowth : PublishedDiskUnivalentGrowth)
+    (K : Set ℂ) (hK : IsCompact K) (hKH : K ⊆ upperHalfPlane)
+    (b : ℝ) (hb : 0 < b) (hbR : ∀ z ∈ K, b ≤ 2*z.im) (m : ℕ) :
+    ∃ C : ℝ≥0∞, C < ⊤ ∧ ∀ z₀ : ℂ, z₀ ∈ upperHalfPlane → b ≤ 2*z₀.im →
+      ∀ e₀ : ℝ, 0 < e₀ → e₀ ≤ 2*z₀.im → ∀ u : ℝ, 0 ≤ u →
+        (∫⁻ ω in {ω | ∃ t : ℝ≥0, z₀ ∈ survivingDomain (γ ω) t ∧
+          physicalConformalRadius (fun z : ℂ => z) (G ω) t z₀ ≤ e₀},
+          levelMass κ B γ G u K ω ^ m ∂P) ≤ C * ENNReal.ofReal (e₀^codimension κ) := by
+  obtain ⟨D,hD,hbound⟩ := cappedDistanceKernel_fixed_center_bound m
+    (codimension_pos κ hκ8) (by unfold codimension dimension; linarith) b K hK.isBounded
+  refine ⟨ENNReal.ofReal (multipointConstant κ (m+1)) * D,
+    ENNReal.mul_lt_top ENNReal.ofReal_lt_top hD,?_⟩
+  intro z₀ hz₀ hb₀ e₀ he₀ heR u hu
+  apply (levelMass_centered_moment_le_cappedKernel hB hm hBm hBc hB0 hκ hκ8 γ G F hw
+    hgrowth K hK.measurableSet hKH z₀ hz₀ e₀ he₀ heR b hb hb₀ hbR m u hu).trans
+  unfold centeredLevelMomentBound
+  calc
+    _ ≤ ENNReal.ofReal (e₀^codimension κ) *
+        (ENNReal.ofReal (multipointConstant κ (m+1)) * D) := by gcongr; exact hbound z₀
+    _ = _ := mul_comm _ _
+
+end SLEExactGauge.Multipoint
+
+end
+
+end OAI
diff --git a/lean/OAI/Probability/SLE/Mass/CompactSpatialMass.lean b/lean/OAI/Probability/SLE/Mass/CompactSpatialMass.lean
new file mode 100644
index 0000000000000000000000000000000000000000..056d3fe35f8278a295017e4be62f975705118a28
--- /dev/null
+++ b/lean/OAI/Probability/SLE/Mass/CompactSpatialMass.lean
@@ -0,0 +1,77 @@
+import OAI.Probability.SLE.Mass.CanonicalMassConstruction
+
+namespace OAI
+
+/-! Compact restrictions of half-plane measures, viewed as physical measures.
+These preserve measurable dependence and compact finiteness. -/
+
+noncomputable section
+open Set Filter _root_.MeasureTheory _root_.OAI.MeasureTheory ProbabilityTheory Metric
+open scoped Topology NNReal ENNReal
+
+namespace SLEExactGauge
+
+/-- The physical measure carried by a fixed compact part of the half-plane. -/
+def compactSpatialMass (μ : Measure upperHalfPlane) (K : Set upperHalfPlane) : Measure ℂ :=
+  (μ.restrict K).map (Subtype.val : upperHalfPlane → ℂ)
+
+lemma compactSpatialMass_apply (μ : Measure upperHalfPlane) (K : Set upperHalfPlane)
+    (A : Set ℂ) (hA : MeasurableSet A) :
+    compactSpatialMass μ K A = μ (K ∩ Subtype.val ⁻¹' A) := by
+  rw [compactSpatialMass,Measure.map_apply measurable_subtype_coe hA,
+    Measure.restrict_apply (hA.preimage measurable_subtype_coe),inter_comm]
+
+lemma compactSpatialMass_measurable {Ω : Type*} [MeasurableSpace Ω]
+    (μ : Ω → Measure upperHalfPlane) (hμ : Measurable μ)
+    (K : Set upperHalfPlane) (hK : MeasurableSet K) :
+    Measurable (fun ω => compactSpatialMass (μ ω) K) := by
+  apply Measure.measurable_of_measurable_coe
+  intro A hA
+  simp_rw [compactSpatialMass_apply _ _ _ hA]
+  exact (Measure.measurable_coe (hK.inter (hA.preimage measurable_subtype_coe))).comp hμ
+
+lemma compactSpatialMass_finite (μ : Measure upperHalfPlane) [IsFiniteMeasureOnCompacts μ]
+    (K : Set upperHalfPlane) (hK : IsCompact K) : IsFiniteMeasure (compactSpatialMass μ K) := by
+  constructor
+  rw [compactSpatialMass_apply _ _ _ MeasurableSet.univ]
+  simpa only [preimage_univ,inter_univ] using hK.measure_lt_top
+
+lemma compactSpatialMass_compact_cell (K : Set upperHalfPlane) (hK : IsCompact K)
+    (z : ℂ) (r : ℝ) : IsCompact (K ∩ Subtype.val ⁻¹' closedBall z r) :=
+  hK.inter_right (isClosed_closedBall.preimage continuous_subtype_val)
+
+namespace Multipoint.CanonicalMass
+
+variable {Ω : Type*} [MeasurableSpace Ω] {P : Measure Ω}
+  {κ : ℝ} {B : ℝ≥0 → Ω → ℝ} {hBm : Measurable (Function.uncurry B)}
+  {γ : Ω → ℝ≥0 → ℂ} {G : Ω → ℝ≥0 → ℂ → ℂ}
+  (C : CanonicalMass P κ B hBm γ G)
+
+lemma compact_spatial_terminal_measurable (K : Set upperHalfPlane) (hK : IsCompact K) :
+    Measurable (fun ω => compactSpatialMass (C.rational.terminal ω) K) :=
+  compactSpatialMass_measurable _ C.rational.terminal_measurable K hK.measurableSet
+
+lemma compact_spatial_terminal_finite (K : Set upperHalfPlane) (hK : IsCompact K) (ω : Ω) :
+    IsFiniteMeasure (compactSpatialMass (C.rational.terminal ω) K) := by
+  let := (C.rational.terminal_radon ω).2
+  exact compactSpatialMass_finite _ K hK
+
+lemma compact_spatial_initial_finite (K : Set upperHalfPlane) (hK : IsCompact K) :
+    IsFiniteMeasure (compactSpatialMass (initialGreenMeasure κ) K) := by
+  let := initialGreenMeasure_finite_on_compacts κ
+  exact compactSpatialMass_finite _ K hK
+
+lemma compact_spatial_terminal_mean (K : Set upperHalfPlane) (hK : IsCompact K)
+    (A : Set ℂ) (hA : MeasurableSet A) :
+    (∫⁻ ω, compactSpatialMass (C.rational.terminal ω) K A ∂P) =
+      compactSpatialMass (initialGreenMeasure κ) K A := by
+  simp_rw [compactSpatialMass_apply _ _ _ hA]
+  rw [← Measure.bind_apply (hK.measurableSet.inter (hA.preimage measurable_subtype_coe))
+    C.rational.terminal_measurable.aemeasurable,C.rational.mean]
+
+end Multipoint.CanonicalMass
+end SLEExactGauge
+
+end
+
+end OAI
diff --git a/lean/OAI/Probability/SLE/Mass/ConditionalRadonRandomTests.lean b/lean/OAI/Probability/SLE/Mass/ConditionalRadonRandomTests.lean
new file mode 100644
index 0000000000000000000000000000000000000000..76c328c520760f0456d516d15aa1f3b323da5343
--- /dev/null
+++ b/lean/OAI/Probability/SLE/Mass/ConditionalRadonRandomTests.lean
@@ -0,0 +1,123 @@
+import OAI.Probability.SLE.Mass.RadonRandomTesting
+import OAI.Probability.SLE.Mass.RadonTestFamily
+
+namespace OAI
+
+/-! Random spatial testing for conditional kernels of locally finite
+half-plane measures, allowing exceptional non-locally-finite values. -/
+
+noncomputable section
+open Set Filter MeasureTheory Classical
+open scoped ENNReal
+
+namespace SLEExactGauge
+
+local instance conditionalTestLocallyCompact : LocallyCompactSpace upperHalfPlane :=
+  isOpen_upperHalfPlane.locallyCompactSpace
+
+private lemma locallyFiniteKernelVersion
+    {Ω : Type*} [MeasurableSpace Ω] (P : Measure Ω)
+    (μ : Ω → Measure upperHalfPlane) (hμ : Measurable μ)
+    (hfin : ∀ᵐ ω ∂P, IsFiniteMeasureOnCompacts (μ ω)) :
+    ∃ ρ : Ω → Measure upperHalfPlane, Measurable ρ ∧
+      (∀ ω, IsFiniteMeasureOnCompacts (ρ ω)) ∧ ρ =ᵐ[P] μ := by
+  let D := localTestFamily upperHalfPlane
+  let E := {ω | ∀ n, μ ω (D.compactSet n) < ∞}
+  have hE : MeasurableSet E := by
+    simp only [E,Set.ofPred_forall]
+    apply MeasurableSet.iInter
+    intro n
+    simpa only [Function.comp_def] using measurableSet_lt
+      ((Measure.measurable_coe (D.isCompact n).measurableSet).comp hμ)
+      (measurable_const : Measurable (fun _ : Ω => (∞:ℝ≥0∞)))
+  let ρ (ω : Ω) := if ω ∈ E then μ ω else 0
+  refine ⟨ρ,hμ.ite hE measurable_const,?_,?_⟩
+  · intro ω
+    by_cases hω : ω ∈ E
+    · have he : ρ ω=μ ω := ite_eq_left hω
+      rw [he]
+      constructor
+      intro K hK
+      obtain ⟨n,hn⟩ := D.exhaustive K hK
+      exact lt_of_le_of_lt (measure_mono hn) (hω n)
+    · simp only [ρ,ite_eq_right hω]
+      infer_instance
+  · filter_upwards [hfin] with ω hω
+    have : ω ∈ E := fun n => by let := hω; exact (D.isCompact n).measure_lt_top
+    exact ite_eq_left this
+
+lemma ae_finite_on_compacts_of_compact_mean
+    {Ω : Type*} [MeasurableSpace Ω] (P : Measure Ω)
+    (μ : Ω → Measure upperHalfPlane) (hμ : Measurable μ)
+    (hmean : ∀ K : Set upperHalfPlane, IsCompact K → P.bind μ K < ∞) :
+    ∀ᵐ ω ∂P, IsFiniteMeasureOnCompacts (μ ω) := by
+  let D := localTestFamily upperHalfPlane
+  have hfin (n : ℕ) : ∀ᵐ ω ∂P, μ ω (D.compactSet n) < ∞ := by
+    apply ae_lt_top ((Measure.measurable_coe (D.isCompact n).measurableSet).comp hμ)
+    change (∫⁻ ω, μ ω (D.compactSet n) ∂P) ≠ ∞
+    rw [← Measure.bind_apply (D.isCompact n).measurableSet hμ.aemeasurable]
+    exact (hmean _ (D.isCompact n)).ne
+  filter_upwards [ae_all_iff.mpr hfin] with ω hω
+  constructor
+  intro K hK
+  obtain ⟨n,hn⟩ := D.exhaustive K hK
+  exact lt_of_le_of_lt (measure_mono hn) (hω n)
+
+/-- Equality of conditional mean measures gives arbitrary jointly
+past-measurable tests. Only compact mean masses need be finite. -/
+theorem conditional_halfPlane_random_test
+    {Ω : Type*} [mΩ : MeasurableSpace Ω]
+    (m : MeasurableSpace Ω) (hm : m ≤ mΩ) (P : @Measure Ω mΩ)
+    (μ ν : Ω → Measure upperHalfPlane) (hμ : Measurable[mΩ] μ) (hν : Measurable[mΩ] ν)
+    (hμfin : ∀ᵐ ω ∂P, IsFiniteMeasureOnCompacts (μ ω))
+    (hνfin : ∀ᵐ ω ∂P, IsFiniteMeasureOnCompacts (ν ω))
+    (hmean : ∀ K : Set upperHalfPlane, IsCompact K → P.bind μ K < ∞)
+    (hevent : ∀ A : Set Ω, MeasurableSet[m] A →
+      (P.restrict A).bind μ=(P.restrict A).bind ν)
+    (f : Ω × upperHalfPlane → ℝ≥0∞) (hf : Measurable[m.prod inferInstance] f) :
+    (∫⁻ ω, ∫⁻ z, f (ω,z) ∂μ ω ∂P) = ∫⁻ ω, ∫⁻ z, f (ω,z) ∂ν ω ∂P := by
+  let : MeasurableSpace Ω := mΩ
+  obtain ⟨ρ,hρ,hρfin,hρeq⟩ := locallyFiniteKernelVersion P μ hμ hμfin
+  obtain ⟨σ,hσ,hσfin,hσeq⟩ := locallyFiniteKernelVersion P ν hν hνfin
+  let D := localTestFamily upperHalfPlane
+  have hE (A : Set Ω) (hA : MeasurableSet[m] A) :
+      (P.restrict A).bind ρ=(P.restrict A).bind σ := by
+    rw [Measure.bind_congr_right (ae_restrict_of_ae hρeq),
+      Measure.bind_congr_right (ae_restrict_of_ae hσeq),hevent A hA]
+  have hcov : ⋃ n, disjointed D.compactSet n=univ := by
+    rw [iUnion_disjointed]
+    apply eq_univ_iff_forall.mpr
+    intro z
+    obtain ⟨n,hn⟩ := D.exhaustive {z} isCompact_singleton
+    exact mem_iUnion.mpr ⟨n,hn (mem_singleton z)⟩
+  have hρK (n : ℕ) (ω : Ω) : ρ ω (disjointed D.compactSet n) < ∞ := by
+    let := hρfin ω
+    exact lt_of_le_of_lt (measure_mono (disjointed_subset D.compactSet n))
+      (D.isCompact n).measure_lt_top
+  have hσK (n : ℕ) (ω : Ω) : σ ω (disjointed D.compactSet n) < ∞ := by
+    let := hσfin ω
+    exact lt_of_le_of_lt (measure_mono (disjointed_subset D.compactSet n))
+      (D.isCompact n).measure_lt_top
+  have hmeanρ (n : ℕ) : P.bind ρ (disjointed D.compactSet n) < ∞ := by
+    rw [Measure.bind_congr_right hρeq]
+    exact lt_of_le_of_lt (measure_mono (disjointed_subset D.compactSet n))
+      (hmean _ (D.isCompact n))
+  have h := conditional_random_spatial_test m hm P ρ σ hρ hσ
+    (disjointed D.compactSet) (MeasurableSet.disjointed fun n => (D.isCompact n).measurableSet)
+    (disjoint_disjointed D.compactSet) hcov hρK hσK hmeanρ hE f hf
+  calc
+    _ = ∫⁻ ω, ∫⁻ z, f (ω,z) ∂ρ ω ∂P := by
+      apply lintegral_congr_ae
+      filter_upwards [hρeq] with ω hω
+      rw [hω]
+    _ = ∫⁻ ω, ∫⁻ z, f (ω,z) ∂σ ω ∂P := h
+    _ = _ := 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/Mass/ConformalMassTransport.lean b/lean/OAI/Probability/SLE/Mass/ConformalMassTransport.lean
new file mode 100644
index 0000000000000000000000000000000000000000..11f7059c86b0dd19aaff61b54a039a525642745a
--- /dev/null
+++ b/lean/OAI/Probability/SLE/Mass/ConformalMassTransport.lean
@@ -0,0 +1,129 @@
+import OAI.Probability.SLE.Mass.CanonicalMassAllVisits
+import Mathlib.MeasureTheory.Integral.Bochner.ContinuousLinearMap
+
+namespace OAI
+
+/-! The weighted pushforward used for canonical mass in a conformal
+image. Compact tests pull back with the same deterministic convex sequence;
+the construction does not extract a new subsequence for the image domain. -/
+
+noncomputable section
+open Set Filter _root_.MeasureTheory _root_.OAI.MeasureTheory ProbabilityTheory Classical
+open scoped NNReal ENNReal Topology CompactlySupported
+
+namespace SLEExactGauge.Multipoint
+
+local instance : LocallyCompactSpace upperHalfPlane := isOpen_upperHalfPlane.locallyCompactSpace
+
+variable {D : Set ℂ}
+
+/-- For a conformal identification, `w` is the continuous weight `|J'|^d`. -/
+def conformalMass (J : upperHalfPlane ≃ₜ D) (w : C(upperHalfPlane, ℝ≥0))
+    (μ : Measure upperHalfPlane) : Measure D :=
+  (μ.withDensity (fun z => (w z : ℝ≥0∞))).map J
+
+def conformalMassTest (J : upperHalfPlane ≃ₜ D) (w : C(upperHalfPlane, ℝ≥0))
+    (f : C_c(D, ℝ)) : C_c(upperHalfPlane, ℝ) :=
+  (⟨fun z => (w z : ℝ), continuous_subtype_val.comp w.continuous⟩ :
+    C(upperHalfPlane, ℝ)) • f.comp J.toCocompactMap
+
+@[simp] lemma conformalMassTest_apply (J : upperHalfPlane ≃ₜ D)
+    (w : C(upperHalfPlane, ℝ≥0)) (f : C_c(D, ℝ)) (z : upperHalfPlane) :
+    conformalMassTest J w f z = (w z : ℝ) * f (J z) := rfl
+
+lemma conformalMass_integral (J : upperHalfPlane ≃ₜ D)
+    (w : C(upperHalfPlane, ℝ≥0)) (μ : Measure upperHalfPlane) (f : C_c(D, ℝ)) :
+    (∫ z, f z ∂conformalMass J w μ) = ∫ z, conformalMassTest J w f z ∂μ := by
+  rw [conformalMass,integral_map_of_stronglyMeasurable J.continuous.measurable
+    (show StronglyMeasurable (fun z => f z) from f.continuous.stronglyMeasurable),
+    integral_withDensity_eq_integral_smul w.continuous.measurable]
+  rfl
+
+lemma conformalMass_radon (J : upperHalfPlane ≃ₜ D)
+    (w : C(upperHalfPlane, ℝ≥0)) (μ : Measure upperHalfPlane)
+    [IsFiniteMeasureOnCompacts μ] :
+    (conformalMass J w μ).Regular ∧ IsFiniteMeasureOnCompacts (conformalMass J w μ) := by
+  let : IsLocallyFiniteMeasure (μ.withDensity (fun z => (w z : ℝ≥0∞))) :=
+    IsLocallyFiniteMeasure.withDensity_coe w.continuous
+  have : (μ.withDensity (fun z => (w z : ℝ≥0∞))).Regular := inferInstance
+  exact ⟨Measure.Regular.map J,Measure.IsFiniteMeasureOnCompacts.map _ J⟩
+
+lemma conformalMass_measurable (J : upperHalfPlane ≃ₜ D)
+    (w : C(upperHalfPlane, ℝ≥0)) : Measurable (conformalMass J w) := by
+  apply (Measure.measurable_map J J.continuous.measurable).comp
+  apply Measure.measurable_of_measurable_coe
+  intro A hA
+  simp only [withDensity_apply _ hA]
+  simp_rw [← lintegral_indicator hA]
+  exact Measure.measurable_lintegral
+    ((w.continuous.measurable.coe_nnreal_ennreal).indicator hA)
+
+@[simp] lemma conformalMass_zero (J : upperHalfPlane ≃ₜ D)
+    (w : C(upperHalfPlane, ℝ≥0)) : conformalMass J w 0 = 0 := by
+  simp [conformalMass]
+
+lemma conformalMass_add (J : upperHalfPlane ≃ₜ D)
+    (w : C(upperHalfPlane, ℝ≥0)) (μ ν : Measure upperHalfPlane) :
+    conformalMass J w (μ+ν) = conformalMass J w μ + conformalMass J w ν := by
+  simp only [conformalMass,withDensity_add_measure]
+  exact Measure.map_add _ _ J.continuous.measurable
+
+lemma conformalMass_mono (J : upperHalfPlane ≃ₜ D)
+    (w : C(upperHalfPlane, ℝ≥0)) {μ ν : Measure upperHalfPlane} (h : μ ≤ ν) :
+    conformalMass J w μ ≤ conformalMass J w ν := by
+  apply Measure.map_mono ?_ J.continuous.measurable
+  apply Measure.le_iff.mpr
+  intro A hA
+  simp only [withDensity_apply _ hA]
+  exact lintegral_mono' (Measure.restrict_mono le_rfl h) le_rfl
+
+lemma conformalMass_nullSingleton (J : upperHalfPlane ≃ₜ D)
+    (w : C(upperHalfPlane, ℝ≥0)) (μ : Measure upperHalfPlane) [NullSingletonClass μ] :
+    NullSingletonClass (conformalMass J w μ) := by
+  constructor
+  intro z
+  rw [conformalMass,Measure.map_apply J.continuous.measurable (measurableSet_singleton z)]
+  rw [show J ⁻¹' {z} = {J.symm z} by
+    ext x
+    simp only [mem_preimage,mem_singleton_iff]
+    constructor
+    · intro h
+      exact J.injective (h.trans (J.apply_symm_apply z).symm)
+    · intro h
+      rw [h,J.apply_symm_apply]]
+  exact measure_singleton _
+
+lemma conformalMass_carried (J : upperHalfPlane ≃ₜ D)
+    (w : C(upperHalfPlane, ℝ≥0)) (μ : Measure upperHalfPlane)
+    (S : Set upperHalfPlane) (hS : MeasurableSet S) (hμ : μ Sᶜ = 0) :
+    conformalMass J w μ (J '' S)ᶜ = 0 := by
+  rw [conformalMass,Measure.map_apply J.continuous.measurable
+    (J.measurableEmbedding.measurableSet_image.mpr hS).compl]
+  apply withDensity_absolutelyContinuous μ _
+  simpa only [preimage_compl,Set.preimage_image_eq _ J.injective] using hμ
+
+/-- Vague convergence transfers for every image-domain test on the same
+event and with the same sequence. -/
+lemma conformalMass_test_tendsto (J : upperHalfPlane ≃ₜ D)
+    (w : C(upperHalfPlane, ℝ≥0)) (μ : ℕ → Measure upperHalfPlane)
+    (ν : Measure upperHalfPlane)
+    (h : ∀ f : C_c(upperHalfPlane, ℝ),
+      Tendsto (fun n => ∫ z, f z ∂μ n) atTop (𝓝 (∫ z, f z ∂ν)))
+    (f : C_c(D, ℝ)) :
+    Tendsto (fun n => ∫ z, f z ∂conformalMass J w (μ n)) atTop
+      (𝓝 (∫ z, f z ∂conformalMass J w ν)) := by
+  simp only [conformalMass_integral]
+  exact h (conformalMassTest J w f)
+
+lemma conformalMass_test_continuous (J : upperHalfPlane ≃ₜ D)
+    (w : C(upperHalfPlane, ℝ≥0)) (μ : ℝ≥0 → Measure upperHalfPlane)
+    (h : ∀ f : C_c(upperHalfPlane, ℝ), Continuous (fun t => ∫ z, f z ∂μ t))
+    (f : C_c(D, ℝ)) : Continuous (fun t => ∫ z, f z ∂conformalMass J w (μ t)) := by
+  simp only [conformalMass_integral]
+  exact h (conformalMassTest J w f)
+
+end SLEExactGauge.Multipoint
+
+end
+
+end OAI
diff --git a/lean/OAI/Probability/SLE/Mass/ConvexCurrentMean.lean b/lean/OAI/Probability/SLE/Mass/ConvexCurrentMean.lean
new file mode 100644
index 0000000000000000000000000000000000000000..e56c75b9e11530526fed3c5eb70e6f39ca661208
--- /dev/null
+++ b/lean/OAI/Probability/SLE/Mass/ConvexCurrentMean.lean
@@ -0,0 +1,56 @@
+import OAI.Probability.SLE.Mass.LevelConditionalMean
+
+namespace OAI
+
+/-! Convex tail averages of current conditional mean measures have the
+same signed compact-test limit as the original radius levels. -/
+
+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 convexCurrentMean_test_tendsto
+    {Ω : Type*} [MeasurableSpace Ω] {P : Measure Ω}
+    {B : ℝ≥0 → Ω → ℝ} (hB : IsBrownianReal B P)
+    (hBm : Measurable (Function.uncurry B)) (hBc : ∀ ω, Continuous (fun t => B t ω))
+    (hB0 : ∀ ω, B 0 ω = 0) {κ : ℝ} (hκ : 0 < κ) (hκ8 : κ < 8)
+    (γ : Ω → ℝ≥0 → ℂ) (G F : Ω → ℝ≥0 → ℂ → ℂ)
+    (hw : ∀ ω, IsCapacityTwoWitness (fun t => Real.sqrt κ * B t ω) (γ ω) (G ω) (F ω))
+    (u : ℕ → ℝ) (hu : ∀ n, 0 ≤ u n) (hmono : Monotone u)
+    (hlim : Tendsto u atTop atTop) (s : ℕ → Finset ℕ) (w : ℕ → ℕ → ℝ)
+    (hw₀ : ∀ n i, i ∈ s n → 0 ≤ w n i) (hw₁ : ∀ n, ∑ i ∈ s n, w n i = 1)
+    (t : ℝ≥0) (E : Set Ω) (f : C_c(upperHalfPlane,ℝ)) :
+    Tendsto (fun n => ∫ z, f z ∂convexCurrentMean (P.restrict E) κ B γ G u s w n t)
+      atTop (𝓝 (∫ z, f z ∂(P.restrict E).bind (halfPlaneGreenMeasure κ B γ G t))) := by
+  let ρ := initialGreenMeasure κ
+  let : IsFiniteMeasureOnCompacts ρ := initialGreenMeasure_finite_on_compacts κ
+  let μ (j : ℕ) := (P.restrict E).bind (halfPlaneCurrentMeasure κ B γ G (u j) t)
+  have hμ (j : ℕ) : μ j ≤ ρ :=
+    (bind_mono_of_measurable (P.restrict E)
+      (halfPlaneCurrentMeasure_measurable hBm hBc κ (u j) (hu j) γ G F hw t)
+      (halfPlaneGreenMeasure_measurable hBm hBc κ γ G F hw t)
+      (fun ω => halfPlaneCurrentMeasure_le_green ω (hw ω) (u j) t)).trans
+      (halfPlaneGreenMeasure_mean_le hB hBm hBc hB0 hκ hκ8 γ G F hw t E)
+  have hfi (j : ℕ) : Integrable f (μ j) := f.integrable.mono_measure (hμ j)
+  have he (n : ℕ) : (∫ z, f z ∂convexCurrentMean (P.restrict E) κ B γ G u s w n t) =
+      ∑ i ∈ s n, w n i * (∫ z, f z ∂μ (n+i)) := by
+    have hi (i : ℕ) : Integrable f (ENNReal.ofReal (w n i) • μ (n+i)) :=
+      (hfi (n+i)).smul_measure ENNReal.ofReal_ne_top
+    rw [convexCurrentMean,integral_finsetSum_measure (fun i _ => hi i)]
+    apply Finset.sum_congr rfl
+    intro i his
+    rw [integral_smul_measure,ENNReal.toReal_ofReal (hw₀ n i his),smul_eq_mul]
+  simp only [he]
+  exact real_convex_tail_tendsto (fun j => ∫ z, f z ∂μ j)
+    (halfPlaneCurrentMeasure_mean_test_tendsto hB hBm hBc hB0 hκ hκ8 γ G F hw
+      u hu hmono hlim t E f) s w hw₀ hw₁
+
+end SLEExactGauge.Multipoint
+
+end
+
+end OAI
diff --git a/lean/OAI/Probability/SLE/Mass/ConvexMeanMeasure.lean b/lean/OAI/Probability/SLE/Mass/ConvexMeanMeasure.lean
new file mode 100644
index 0000000000000000000000000000000000000000..ffeeba54d362c4cd9c74bc6114d9f812091bd0b7
--- /dev/null
+++ b/lean/OAI/Probability/SLE/Mass/ConvexMeanMeasure.lean
@@ -0,0 +1,86 @@
+import OAI.Probability.SLE.Mass.LevelMeanMeasure
+import OAI.Probability.SLE.Mass.LevelRadonExtraction
+
+namespace OAI
+
+/-! The common convex coefficients preserve the exact terminal mean
+measure, including signed compact tests. -/
+
+noncomputable section
+open Set Filter MeasureTheory ProbabilityTheory Classical
+open scoped NNReal ENNReal Topology CompactlySupported
+
+namespace SLEExactGauge.Multipoint
+
+lemma convexLevelMeasure_measurable
+    {Ω : Type*} [MeasurableSpace Ω] {B : ℝ≥0 → Ω → ℝ}
+    (hm : ∀ t, Measurable (B t)) (hBc : ∀ ω, Continuous (fun t => B t ω))
+    (κ : ℝ) (γ : Ω → ℝ≥0 → ℂ) (G F : Ω → ℝ≥0 → ℂ → ℂ)
+    (hw : ∀ ω, IsCapacityTwoWitness (fun t => Real.sqrt κ * B t ω) (γ ω) (G ω) (F ω))
+    (u : ℕ → ℝ) (hu : ∀ n, 0 ≤ u n) (s : ℕ → Finset ℕ) (w : ℕ → ℕ → ℝ)
+    (n : ℕ) (t : ℝ≥0∞) : Measurable (convexLevelMeasure κ B γ G u s w n t) := by
+  apply Measure.measurable_of_measurable_coe
+  intro A hA
+  simp only [convexLevelMeasure,Measure.finsetSum_apply,Measure.smul_apply,smul_eq_mul]
+  apply Finset.measurable_sum
+  intro i hi
+  exact measurable_const.mul ((Measure.measurable_coe hA).comp
+    (halfPlaneLevelMeasure_measurable hm hBc κ (u (n+i)) (hu _) γ G F hw t))
+
+theorem convexLevelMeasure_terminal_mean
+    {Ω : 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 ω))
+    (u : ℕ → ℝ) (hu : ∀ n, 0 ≤ u n) (s : ℕ → Finset ℕ) (w : ℕ → ℕ → ℝ)
+    (hw₀ : ∀ n i, i ∈ s n → 0 ≤ w n i) (hw₁ : ∀ n, ∑ i ∈ s n, w n i = 1)
+    (n : ℕ) : P.bind (convexLevelMeasure κ B γ G u s w n ∞) = initialGreenMeasure κ := by
+  apply Measure.ext
+  intro A hA
+  rw [Measure.bind_apply hA (convexLevelMeasure_measurable hm hBc κ γ G F hw u hu s w n ∞).aemeasurable]
+  simp only [convexLevelMeasure,Measure.finsetSum_apply,Measure.smul_apply,smul_eq_mul]
+  rw [lintegral_finsetSum (s n) (f := fun i ω => ENNReal.ofReal (w n i) *
+    halfPlaneLevelMeasure κ B γ G (u (n+i)) ∞ ω A)
+    (fun i _ => measurable_const.mul ((Measure.measurable_coe hA).comp
+      (halfPlaneLevelMeasure_measurable hm hBc κ (u (n+i)) (hu _) γ G F hw ∞)))]
+  have he (i : ℕ) : (∫⁻ ω, halfPlaneLevelMeasure κ B γ G (u (n+i)) ∞ ω A ∂P) =
+      initialGreenMeasure κ A := by
+    rw [← Measure.bind_apply hA (halfPlaneLevelMeasure_measurable hm hBc κ (u (n+i)) (hu _) γ G F hw ∞).aemeasurable,
+      halfPlaneLevelMeasure_terminal_mean hB hm hBm hBc hB0 hκ hκ8 γ G F hw (u (n+i)) (hu _)]
+  simp_rw [lintegral_const_mul' _ _ ENNReal.ofReal_ne_top,he]
+  rw [← Finset.sum_mul,← ENNReal.ofReal_sum_of_nonneg (hw₀ n),hw₁ n,ENNReal.ofReal_one,one_mul]
+
+theorem convexLevelMeasure_terminal_test_mean
+    {Ω : 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 ω))
+    (u : ℕ → ℝ) (hu : ∀ n, 0 ≤ u n) (s : ℕ → Finset ℕ) (w : ℕ → ℕ → ℝ)
+    (hw₀ : ∀ n i, i ∈ s n → 0 ≤ w n i) (hw₁ : ∀ n, ∑ i ∈ s n, w n i = 1)
+    (n : ℕ) (f : C_c(upperHalfPlane,ℝ)) :
+    Integrable (fun ω => ∫ z, f z ∂convexLevelMeasure κ B γ G u s w n ∞ ω) P ∧
+      (∫ ω, (∫ z, f z ∂convexLevelMeasure κ B γ G u s w n ∞ ω) ∂P) =
+        ∫ z, f z ∂initialGreenMeasure κ := by
+  have he := convexLevelMeasure_terminal_mean hB hm hBm hBc hB0 hκ hκ8 γ G F hw
+    u hu s w hw₀ hw₁ n
+  have hi (ω : Ω) : Integrable f (convexLevelMeasure κ B γ G u s w n ∞ ω) := by
+    let := convexLevelMeasure_finite_on_compacts hκ hκ8 γ G F ω (hBc ω) (hw ω) u s w n ∞
+    exact f.integrable
+  have hiP : Integrable f (P.bind (convexLevelMeasure κ B γ G u s w n ∞)) := by
+    rw [he]
+    let := initialGreenMeasure_finite_on_compacts κ
+    exact f.integrable
+  simpa only [he] using integrable_integral_bind_of_sections P _
+    (convexLevelMeasure_measurable hm hBc κ γ G F hw u hu s w n ∞) f f.continuous.measurable hi hiP
+
+end SLEExactGauge.Multipoint
+
+end
+
+end OAI
diff --git a/lean/OAI/Probability/SLE/Mass/ConvexMomentLimits.lean b/lean/OAI/Probability/SLE/Mass/ConvexMomentLimits.lean
new file mode 100644
index 0000000000000000000000000000000000000000..806da04ee9413a41a634194550a1ea5b93d86188
--- /dev/null
+++ b/lean/OAI/Probability/SLE/Mass/ConvexMomentLimits.lean
@@ -0,0 +1,71 @@
+import Mathlib.Analysis.MeanInequalitiesPow
+import Mathlib.MeasureTheory.Integral.Lebesgue.Add
+
+namespace OAI
+
+/-! Moment bounds survive finite positive convex combinations and
+almost-sure limits. These two steps preserve the actual level bounds. -/
+
+noncomputable section
+open Set Filter MeasureTheory Classical
+open scoped ENNReal Topology
+
+namespace SLEExactGauge
+
+lemma ofReal_pow_convex_sum_le {ι : Type*} (s : Finset ι)
+    (w a : ι → ℝ) (hw : ∀ i ∈ s, 0 ≤ w i) (hw₁ : ∑ i ∈ s, w i = 1)
+    (ha : ∀ i ∈ s, 0 ≤ a i) (m : ℕ) :
+    ENNReal.ofReal (∑ i ∈ s, w i*a i)^m ≤
+      ∑ i ∈ s, ENNReal.ofReal (w i) * ENNReal.ofReal (a i)^m := by
+  have hs : 0 ≤ ∑ i ∈ s, w i*a i := Finset.sum_nonneg (fun i hi => mul_nonneg (hw i hi) (ha i hi))
+  rw [← ENNReal.ofReal_pow hs]
+  apply (ENNReal.ofReal_le_ofReal (Real.pow_arith_mean_le_arith_mean_pow s w a hw hw₁ ha m)).trans_eq
+  rw [ENNReal.ofReal_sum_of_nonneg (fun i hi => mul_nonneg (hw i hi) (pow_nonneg (ha i hi) m))]
+  apply Finset.sum_congr rfl
+  intro i hi
+  rw [ENNReal.ofReal_mul (hw i hi),ENNReal.ofReal_pow (ha i hi)]
+
+lemma lintegral_pow_convex_sum_le
+    {Ω ι : Type*} [MeasurableSpace Ω] (P : Measure Ω)
+    (s : Finset ι) (w : ι → ℝ) (a : ι → Ω → ℝ)
+    (hw : ∀ i ∈ s, 0 ≤ w i) (hw₁ : ∑ i ∈ s, w i = 1)
+    (ha : ∀ i ∈ s, ∀ ω, 0 ≤ a i ω) (ham : ∀ i ∈ s, Measurable (a i))
+    (m : ℕ) (M : ℝ≥0∞) (hM : ∀ i ∈ s, (∫⁻ ω, ENNReal.ofReal (a i ω)^m ∂P) ≤ M) :
+    (∫⁻ ω, ENNReal.ofReal (∑ i ∈ s, w i*a i ω)^m ∂P) ≤ M := by
+  calc
+    _ ≤ ∫⁻ ω, ∑ i ∈ s, ENNReal.ofReal (w i) * ENNReal.ofReal (a i ω)^m ∂P :=
+      lintegral_mono (fun ω => ofReal_pow_convex_sum_le s w (fun i => a i ω) hw hw₁
+        (fun i hi => ha i hi ω) m)
+    _ = ∑ i ∈ s, ENNReal.ofReal (w i) * ∫⁻ ω, ENNReal.ofReal (a i ω)^m ∂P := by
+      rw [lintegral_finsetSum s (f := fun i ω => ENNReal.ofReal (w i) * ENNReal.ofReal (a i ω)^m)
+        (fun i hi => measurable_const.mul ((ham i hi).ennreal_ofReal.pow_const m))]
+      apply Finset.sum_congr rfl
+      intro i hi
+      exact lintegral_const_mul' _ _ ENNReal.ofReal_ne_top
+    _ ≤ ∑ i ∈ s, ENNReal.ofReal (w i) * M :=
+      Finset.sum_le_sum (fun i hi => mul_le_mul' le_rfl (hM i hi))
+    _ = M := by
+      rw [← Finset.sum_mul,← ENNReal.ofReal_sum_of_nonneg hw,hw₁,ENNReal.ofReal_one,one_mul]
+
+lemma lintegral_le_of_ae_tendsto_bound
+    {Ω : Type*} [MeasurableSpace Ω] (P : Measure Ω)
+    (f : ℕ → Ω → ℝ≥0∞) (F : Ω → ℝ≥0∞)
+    (hf : ∀ n, AEMeasurable (f n) P)
+    (hlim : ∀ᵐ ω ∂P, Tendsto (fun n => f n ω) atTop (𝓝 (F ω)))
+    (M : ℝ≥0∞) (hM : ∀ n, (∫⁻ ω, f n ω ∂P) ≤ M) :
+    (∫⁻ ω, F ω ∂P) ≤ M := by
+  calc
+    _ = ∫⁻ ω, liminf (fun n => f n ω) atTop ∂P := by
+      apply lintegral_congr_ae
+      filter_upwards [hlim] with ω hω
+      exact hω.liminf_eq.symm
+    _ ≤ liminf (fun n => ∫⁻ ω, f n ω ∂P) atTop := lintegral_liminf_le' hf
+    _ ≤ M := by
+      have h : ∀ᶠ n : ℕ in atTop, (∫⁻ ω, f n ω ∂P) ≤ M := Eventually.of_forall hM
+      simpa only [liminf_const] using liminf_le_liminf h
+
+end SLEExactGauge
+
+end
+
+end OAI
diff --git a/lean/OAI/Probability/SLE/Mass/CountableLevelAdapted.lean b/lean/OAI/Probability/SLE/Mass/CountableLevelAdapted.lean
new file mode 100644
index 0000000000000000000000000000000000000000..920571751bc3227b138170dc96ecdbaf1ae8800f
--- /dev/null
+++ b/lean/OAI/Probability/SLE/Mass/CountableLevelAdapted.lean
@@ -0,0 +1,49 @@
+import OAI.Probability.SLE.Mass.LevelApproximationAdapted
+
+namespace OAI
+
+/-! A common family of actual convex limits admits simultaneous versions
+measurable in the original natural past at each prescribed finite time. -/
+
+noncomputable section
+open Set Filter MeasureTheory ProbabilityTheory Classical
+open scoped Topology NNReal ENNReal CompactlySupported
+
+namespace SLEExactGauge.Multipoint
+
+theorem countable_level_limits_have_past_versions
+    {Ω : Type*} [mΩ : MeasurableSpace Ω] (P : Measure Ω)
+    {B : ℝ≥0 → Ω → ℝ}
+    (hm : ∀ t, Measurable (B t)) (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 : ∀ n, 0 ≤ u n) (s : ℕ → Finset ℕ) (w : ℕ → ℕ → ℝ)
+    (hw₀ : ∀ n i, i ∈ s n → 0 ≤ w n i) (t : ℕ → ℝ≥0)
+    (ν : ℕ → Ω → Measure upperHalfPlane)
+    (hν : ∀ᵐ ω ∂P, ∀ j, (ν j ω).Regular)
+    (hlim : ∀ᵐ ω ∂P, ∀ j (f : C_c(upperHalfPlane,ℝ)),
+      Tendsto (fun n => ∫ z, f z ∂convexLevelMeasure κ B γ G u s w n (t j) ω)
+        atTop (𝓝 (∫ z, f z ∂ν j ω))) :
+    ∃ η : ℕ → Ω → Measure upperHalfPlane,
+      (∀ j, Measurable[Filtration.natural B (fun r => (hm r).stronglyMeasurable) (t j)] (η j)) ∧
+      (∀ j ω, (η j ω).Regular ∧ IsFiniteMeasureOnCompacts (η j ω)) ∧
+      ∀ᵐ ω ∂P, ∀ j, η j ω = ν j ω := by
+  have hex (j : ℕ) : ∃ η : Ω → Measure upperHalfPlane,
+      Measurable[Filtration.natural B (fun r => (hm r).stronglyMeasurable) (t j)] η ∧
+      (∀ ω, (η ω).Regular ∧ IsFiniteMeasureOnCompacts (η ω)) ∧ η =ᵐ[P] ν j := by
+    apply level_radon_limit_has_past_measurable_version P hm hc hκ hκ8 γ G F hw
+      u hu s w hw₀ (t j) (ν j)
+    · filter_upwards [hν] with ω hω
+      exact hω j
+    · filter_upwards [hlim] with ω hω
+      exact hω j
+  choose η hηm hηr hηeq using hex
+  exact ⟨η,hηm,hηr,ae_all_iff.mpr hηeq⟩
+
+end SLEExactGauge.Multipoint
+
+end
+
+end OAI
diff --git a/lean/OAI/Probability/SLE/Mass/CountableLevelKernel.lean b/lean/OAI/Probability/SLE/Mass/CountableLevelKernel.lean
new file mode 100644
index 0000000000000000000000000000000000000000..d56874f416eb16fa99ea61d742b304bb32ef6572
--- /dev/null
+++ b/lean/OAI/Probability/SLE/Mass/CountableLevelKernel.lean
@@ -0,0 +1,89 @@
+import OAI.Probability.SLE.Mass.LevelRadonKernel
+import OAI.Probability.SLE.Mass.LevelRadonPairings
+import OAI.Probability.SLE.Mass.LevelRadonMean
+
+namespace OAI
+
+/-! Actual common Radon limits with their exact conditional kernels at
+any prescribed countable set of deterministic times. -/
+
+noncomputable section
+open Set Filter MeasureTheory ProbabilityTheory Classical
+open scoped NNReal ENNReal Topology CompactlySupported
+
+namespace SLEExactGauge.Multipoint
+
+local instance : LocallyCompactSpace upperHalfPlane := isOpen_upperHalfPlane.locallyCompactSpace
+
+def levelMassTimes (t : ℕ → ℝ≥0) : ℕ → ℝ≥0∞
+  | 0 => ∞
+  | n+1 => t n
+
+@[simp] lemma levelMassTimes_zero (t : ℕ → ℝ≥0) : levelMassTimes t 0 = ∞ := rfl
+@[simp] lemma levelMassTimes_succ (t : ℕ → ℝ≥0) (n : ℕ) : levelMassTimes t (n+1) = t n := rfl
+
+theorem exists_countable_level_radon_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 ω))) ∧
+      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 (ν 0) = (P.restrict E).bind (ν (j+1)) +
+          (P.restrict E).bind (halfPlaneGreenMeasure κ B γ G (t j)) := by
+  let : IsProbabilityMeasure P := hB.isGaussianProcess.isProbabilityMeasure
+  let u (n : ℕ) : ℝ := n
+  have hu (n : ℕ) : 0 ≤ u n := Nat.cast_nonneg n
+  have hmono : Monotone u := fun _ _ h => Nat.cast_le.mpr h
+  have huLim : Tendsto u atTop atTop := tendsto_natCast_atTop_atTop
+  obtain ⟨s,w,ν,hw₀,hw₁,hνm,hν,hlim,hpair⟩ := exists_measurable_level_radon_limits_with_pairings
+    hB hm hBm hBc hB0 hκ hκ8 γ G F hw hgrowth u hu (levelMassTimes t)
+  refine ⟨s,w,ν,hw₀,hw₁,hνm,hν,hlim,?_,?_⟩
+  · apply level_radon_terminal_mean hB hm hBm hBc hB0 hκ hκ8 γ G F hw hgrowth
+      u hu s w hw₀ hw₁ (ν 0) (hνm 0) (fun ω => (hν 0 ω).1)
+    · filter_upwards [hlim] with ω hω
+      simpa only [levelMassTimes_zero] using hω 0
+    · intro k
+      simpa only [one_mul,levelMassTimes_zero] using hpair 0 k (fun _ => 1) (memLp_const 1)
+  · intro j E hE
+    let v (i : Fin 2) := if i = 0 then ν (j+1) else ν 0
+    have hvm (i : Fin 2) : Measurable (v i) := by
+      dsimp only [v]; split_ifs <;> exact hνm _
+    have hvr (i : Fin 2) (ω : Ω) : (v i ω).Regular ∧ IsFiniteMeasureOnCompacts (v i ω) := by
+      dsimp only [v]; split_ifs <;> exact hν _ ω
+    have hvl (i : Fin 2) : ∀ᵐ ω ∂P, ∀ f : C_c(upperHalfPlane,ℝ),
+        Tendsto (fun n => ∫ z, f z ∂convexLevelMeasure κ B γ G u s w n
+          (if i = 0 then (t j : ℝ≥0∞) else ∞) ω) atTop (𝓝 (∫ z, f z ∂v i ω)) := by
+      filter_upwards [hlim] with ω hω
+      by_cases hi : i = 0
+      · simpa only [v,ite_eq_left hi,levelMassTimes_succ] using hω (j+1)
+      · simpa only [v,ite_eq_right hi,levelMassTimes_zero] using hω 0
+    have hvp (i : Fin 2) (k : ℕ) (a : Ω → ℝ) (ha : MemLp a 2 P) :
+        Tendsto (fun n => ∫ ω, a ω * (∫ z, (localTestFamily upperHalfPlane).test k z
+          ∂convexLevelMeasure κ B γ G u s w n (if i = 0 then (t j : ℝ≥0∞) else ∞) ω) ∂P)
+          atTop (𝓝 (∫ ω, a ω * (∫ z, (localTestFamily upperHalfPlane).test k z ∂v i ω) ∂P)) := by
+      by_cases hi : i = 0
+      · simpa only [v,ite_eq_left hi,levelMassTimes_succ] using hpair (j+1) k a ha
+      · simpa only [v,ite_eq_right hi,levelMassTimes_zero] using hpair 0 k a ha
+    have hk := level_radon_conditional_kernel hB hm hBm hBc hB0 hκ hκ8 γ G F hw hgrowth
+      u hu hmono huLim s w hw₀ hw₁ (t j) v hvm hvr hvl hvp E hE
+    simpa [v] using hk
+
+end SLEExactGauge.Multipoint
+
+end
+
+end OAI
diff --git a/lean/OAI/Probability/SLE/Mass/DenseCoverMassTests.lean b/lean/OAI/Probability/SLE/Mass/DenseCoverMassTests.lean
new file mode 100644
index 0000000000000000000000000000000000000000..dfbb8b4e6119263b555f0b10c7cf40a9077c25e9
--- /dev/null
+++ b/lean/OAI/Probability/SLE/Mass/DenseCoverMassTests.lean
@@ -0,0 +1,116 @@
+import OAI.Probability.SLE.Gauge.DenseCoverAdaptedTests
+import OAI.Probability.SLE.Geometry.FrontSuccessStopped
+import OAI.Probability.SLE.Gauge.CoverEvents
+
+namespace OAI
+
+/-! Actual sausage tests at successive stopping times.  Their terminal
+candidate implication is deterministic, whereas their failure calculation
+uses only information observable at each test endpoint. -/
+
+noncomputable section
+open Set Filter MeasureTheory ProbabilityTheory
+open scoped Topology NNReal ENNReal
+
+namespace SLEExactGauge
+open FrontSuccessMeasurability
+
+local instance denseMassPathMeasurable : MeasurableSpace C(ℝ≥0, ℂ) := borel _
+local instance denseMassPathBorel : BorelSpace C(ℝ≥0, ℂ) := ⟨rfl⟩
+
+def stoppedWholeSausageCharge (κ : ℝ) (f : C(ℝ≥0, ℂ))
+    (τ : WithTop ℝ≥0) (v : ℝ) (D : Set ℂ) : ℝ≥0∞ :=
+  wholeSausageCharge κ (stoppedAtPath f τ) v D
+
+theorem stoppedWholeSausageCharge_le_whole
+    (κ : ℝ) (f : C(ℝ≥0, ℂ)) (τ : WithTop ℝ≥0) (v : ℝ) (D : Set ℂ) :
+    stoppedWholeSausageCharge κ f τ v D ≤ wholeSausageCharge κ f v D := by
+  apply mul_le_mul' le_rfl
+  apply measure_mono
+  rintro z ⟨hz, t, ht⟩
+  refine ⟨hz, (min τ (t : WithTop ℝ≥0)).untopA, ?_⟩
+  simpa only [stoppedAtPath_apply] using ht
+
+theorem stoppedWholeSausageCharge_finite
+    (κ : ℝ) (f : C(ℝ≥0, ℂ)) (τ : ℝ≥0) (v : ℝ) (D : Set ℂ) :
+    stoppedWholeSausageCharge κ f (τ : WithTop ℝ≥0) v D =
+      segmentSausageCharge κ f 0 τ v D := by
+  simp only [stoppedWholeSausageCharge, stoppedAtPath, WithTop.coe_ne_top, ite_false,
+    WithTop.untopD_coe, segmentSausageCharge, wholeSausageCharge,
+    sourceSausageSet_eq_clamped f 0 τ bot_le]
+
+theorem stoppedWholeSausageCharge_measurable_at_stop
+    {Ω : Type*} [mΩ : MeasurableSpace Ω] (ℱ : Filtration ℝ≥0 mΩ)
+    (γ : Ω → ℝ≥0 → ℂ) (ha : Adapted ℱ (fun t ω => γ ω t))
+    (hc : ∀ ω, Continuous (γ ω))
+    (τ : Ω → WithTop ℝ≥0) (hτ : IsStoppingTime ℱ τ) (κ v : ℝ) (D : Set ℂ) :
+    Measurable[hτ.measurableSpace] (fun ω =>
+      stoppedWholeSausageCharge κ (sourceTracePath γ hc ω) (τ ω) v D) :=
+  (wholeSausageCharge_measurable κ v D).comp
+    (stoppedAtPath_measurable ℱ γ ha hc τ hτ)
+
+def clockStopFiltration
+    {Ω : Type*} [mΩ : MeasurableSpace Ω] (ℱ : Filtration ℝ≥0 mΩ)
+    (τ : ℕ → Ω → WithTop ℝ≥0) (hτ : ∀ j, IsStoppingTime ℱ (τ j))
+    (hmono : ∀ ω, Monotone (fun j => τ j ω)) : Filtration ℕ mΩ :=
+  ⟨fun j => (hτ j).measurableSpace,
+    fun _ _ hij => IsStoppingTime.measurableSpace_mono _ _ (fun ω => hmono ω hij),
+    fun j => (hτ j).measurableSpace_le⟩
+
+def stoppedMassTest
+    {Ω : Type*} (κ v : ℝ) (f : Ω → C(ℝ≥0, ℂ))
+    (τ : Ω → WithTop ℝ≥0) (D : Set ℂ) (b : ℝ) : Set Ω :=
+  {ω | ENNReal.ofReal b ≤ stoppedWholeSausageCharge κ (f ω) (τ ω) v D}
+
+theorem stoppedMassTest_measurable_at_stop
+    {Ω : Type*} [mΩ : MeasurableSpace Ω] (ℱ : Filtration ℝ≥0 mΩ)
+    (γ : Ω → ℝ≥0 → ℂ) (ha : Adapted ℱ (fun t ω => γ ω t))
+    (hc : ∀ ω, Continuous (γ ω))
+    (τ : Ω → WithTop ℝ≥0) (hτ : IsStoppingTime ℱ τ) (κ v b : ℝ) (D : Set ℂ) :
+    MeasurableSet[hτ.measurableSpace]
+      (stoppedMassTest κ v (sourceTracePath γ hc) τ D b) :=
+  measurableSet_le measurable_const
+    (stoppedWholeSausageCharge_measurable_at_stop ℱ γ ha hc τ hτ κ v D)
+
+/-- No terminal candidate forces failure of every earlier adapted test.
+The terminal candidate is never put inside a finite change of measure. -/
+theorem no_terminal_candidate_subset_stopped_failures
+    {Ω : Type*} (κ v : ℝ) (f : Ω → C(ℝ≥0, ℂ))
+    (τ : ℕ → Ω → WithTop ℝ≥0) (D : ℕ → Set ℂ) (b : ℕ → ℝ) (I : Finset ℕ) :
+    {ω | ∀ j ∈ I, wholeSausageCharge κ (f ω) v (D j) < ENNReal.ofReal (b j)} ⊆
+      ⋂ j ∈ I, (stoppedMassTest κ v f (τ (j + 1)) (D j) (b j))ᶜ := by
+  intro ω hω
+  apply mem_iInter₂.mpr
+  intro j hj hsuccess
+  exact (not_le_of_gt (hω j hj))
+    (hsuccess.trans (stoppedWholeSausageCharge_le_whole κ (f ω) _ v (D j)))
+
+/-- The actual successive stopped-sausage tests give the stretched
+exponential missed-candidate bound under their finite stopped law. -/
+theorem stoppedMassTests_cover_failure
+    {Ω : Type*} [mΩ : MeasurableSpace Ω] (μ : Measure Ω) [IsProbabilityMeasure μ]
+    (ℱ : Filtration ℝ≥0 mΩ)
+    (γ : Ω → ℝ≥0 → ℂ) (ha : Adapted ℱ (fun t ω => γ ω t))
+    (hc : ∀ ω, Continuous (γ ω))
+    (τ : ℕ → Ω → WithTop ℝ≥0) (hτ : ∀ j, IsStoppingTime ℱ (τ j))
+    (hmono : ∀ ω, Monotone (fun j => τ j ω))
+    (κ v : ℝ) (D : ℕ → Set ℂ) (b : ℕ → ℝ) (n : ℕ) (hn : 1 ≤ n)
+    (hstep : ∀ j (B : Set Ω), MeasurableSet[(hτ j).measurableSpace] B →
+      ENNReal.ofReal (1 / Real.sqrt (n : ℝ)) * μ B ≤
+        μ (B ∩ stoppedMassTest κ v (sourceTracePath γ hc) (τ (j + 1)) (D j) (b j))) :
+    μ {ω | ∀ j ∈ coverTestWindow n,
+      wholeSausageCharge κ (γ ω) v (D j) < ENNReal.ofReal (b j)} ≤
+        ENNReal.ofReal (Real.exp (-Real.sqrt (n : ℝ) / 4)) := by
+  let f := sourceTracePath γ hc
+  let success := fun j => stoppedMassTest κ v f (τ (j + 1)) (D j) (b j)
+  refine (measure_mono (no_terminal_candidate_subset_stopped_failures
+    κ v f τ D b (coverTestWindow n))).trans ?_
+  exact cover_window_failure_bound μ (clockStopFiltration ℱ τ hτ hmono) success
+    (fun j => stoppedMassTest_measurable_at_stop ℱ γ ha hc (τ (j + 1)) (hτ (j + 1))
+      κ v (b j) (D j)) n hn hstep
+
+end SLEExactGauge
+
+end
+
+end OAI
diff --git a/lean/OAI/Probability/SLE/Mass/DilationMass.lean b/lean/OAI/Probability/SLE/Mass/DilationMass.lean
new file mode 100644
index 0000000000000000000000000000000000000000..7cd51a3e434258192486d5e6764c7c09e527141a
--- /dev/null
+++ b/lean/OAI/Probability/SLE/Mass/DilationMass.lean
@@ -0,0 +1,165 @@
+import OAI.Probability.SLE.Mass.ConformalMassTransport
+import OAI.Probability.SLE.RetainedSeedMoments
+
+namespace OAI
+
+/-! Exact area and measure transport for positive real dilations of the
+half-plane. These are the spatial factors in capacity scaling. -/
+
+noncomputable section
+open Set Filter _root_.MeasureTheory _root_.OAI.MeasureTheory
+open scoped Topology NNReal ENNReal CompactlySupported
+
+namespace SLEExactGauge
+
+lemma source_scale_area_lintegral (c : ℝ≥0) (hc : 0 < c)
+    (f : ℂ → ℝ≥0∞) (K : Set ℂ) :
+    (∫⁻ z in (fun z : ℂ => (c:ℂ)*z) '' K, f z) =
+      ENNReal.ofReal ((c:ℝ)^2) * ∫⁻ z in K, f ((c:ℂ)*z) := by
+  have hcR : 0 < (c:ℝ) := hc
+  have hcC : (c:ℂ) ≠ 0 := by exact_mod_cast hc.ne'
+  let e := Homeomorph.mulLeft₀ (c:ℂ) hcC
+  have hvol (s : Set ℂ) : volume (e ⁻¹' s)=
+      ENNReal.ofReal (((c:ℝ)^2)⁻¹)*volume s := by
+    change volume ((fun z : ℂ => (c:ℂ)*z) ⁻¹' s)=_
+    simpa only [Complex.real_smul,smul_eq_mul,Complex.finrank_real_complex,
+      abs_of_nonneg (inv_nonneg.mpr (sq_nonneg (c:ℝ)))] using
+      (volume : Measure ℂ).addHaar_preimage_smul hcR.ne' s
+  have hp : MeasurePreserving e (ENNReal.ofReal ((c:ℝ)^2) • (volume : Measure ℂ)) volume := by
+    refine ⟨e.continuous.measurable,?_⟩
+    apply Measure.ext
+    intro s hs
+    rw [e.measurableEmbedding.map_apply,Measure.smul_apply,smul_eq_mul,hvol,← mul_assoc,
+      ← ENNReal.ofReal_mul (sq_nonneg (c:ℝ)),mul_inv_cancel₀ (pow_ne_zero 2 hcR.ne'),
+      ENNReal.ofReal_one,one_mul]
+  have h := hp.setLIntegral_comp_emb e.measurableEmbedding f K
+  rw [Measure.restrict_smul,lintegral_smul_measure] at h
+  exact h.symm
+
+def halfPlaneDilation (c : ℝ≥0) (hc : 0 < c) : upperHalfPlane ≃ₜ upperHalfPlane where
+  toFun 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_pos (show 0 < (c:ℝ) from hc) z.property⟩
+  invFun z := ⟨(c:ℂ)⁻¹*(z:ℂ),by
+    change 0 < ((c:ℂ)⁻¹*(z:ℂ)).im
+    rw [← Complex.ofReal_inv]
+    simpa only [Complex.mul_im,Complex.ofReal_re,Complex.ofReal_im,zero_mul,add_zero]
+      using mul_pos (inv_pos.mpr (show 0 < (c:ℝ) from hc)) z.property⟩
+  left_inv z := by
+    apply Subtype.ext
+    change (c:ℂ)⁻¹*((c:ℂ)*(z:ℂ))=(z:ℂ)
+    exact inv_mul_cancel_left₀ (by exact_mod_cast hc.ne') _
+  right_inv z := by
+    apply Subtype.ext
+    change (c:ℂ)*((c:ℂ)⁻¹*(z:ℂ))=(z:ℂ)
+    exact mul_inv_cancel_left₀ (by exact_mod_cast hc.ne') _
+  continuous_toFun := by fun_prop
+  continuous_invFun := by fun_prop
+
+@[simp] lemma halfPlaneDilation_apply (c : ℝ≥0) (hc : 0 < c) (z : upperHalfPlane) :
+    ((halfPlaneDilation c hc z : upperHalfPlane):ℂ)=(c:ℂ)*(z:ℂ) := rfl
+
+namespace Multipoint
+
+def dilationMass (κ : ℝ) (c : ℝ≥0) (hc : 0 < c) (μ : Measure upperHalfPlane) :
+    Measure upperHalfPlane :=
+  conformalMass (halfPlaneDilation c hc) (ContinuousMap.const _ (Real.toNNReal ((c:ℝ)^dimension κ))) μ
+
+lemma dilationMass_apply (κ : ℝ) (c : ℝ≥0) (hc : 0 < c)
+    (μ : Measure upperHalfPlane) (A : Set upperHalfPlane) (hA : MeasurableSet A) :
+    dilationMass κ c hc μ A=ENNReal.ofReal ((c:ℝ)^dimension κ)*
+      μ ((halfPlaneDilation c hc) ⁻¹' A) := by
+  rw [dilationMass,conformalMass,Measure.map_apply (halfPlaneDilation c hc).continuous.measurable hA,
+    withDensity_apply _ ((halfPlaneDilation c hc).continuous.measurable hA)]
+  simp only [ContinuousMap.const_apply]
+  change (∫⁻ _ in (halfPlaneDilation c hc) ⁻¹' A, ENNReal.ofReal ((c:ℝ)^dimension κ) ∂μ)=_
+  exact setLIntegral_const _ _
+
+lemma dilationMass_realDensity (κ : ℝ) (c : ℝ≥0) (hc : 0 < c)
+    (ρ ρ' : ℂ → ℝ)
+    (hρ : ∀ z ∈ upperHalfPlane, ρ' ((c:ℂ)*z)=(c:ℝ)^(-codimension κ)*ρ z) :
+    (volume.withDensity (fun z => ENNReal.ofReal (ρ' z))).comap Subtype.val =
+      dilationMass κ c hc ((volume.withDensity (fun z => ENNReal.ofReal (ρ z))).comap Subtype.val) := by
+  let J := halfPlaneDilation c hc
+  have hpos : 0 < (c:ℝ) := hc
+  have hpower : ENNReal.ofReal ((c:ℝ)^2)*ENNReal.ofReal ((c:ℝ)^(-codimension κ))=
+      ENNReal.ofReal ((c:ℝ)^dimension κ) := by
+    rw [← ENNReal.ofReal_mul (sq_nonneg _),← Real.rpow_natCast (c:ℝ) 2,
+      ← Real.rpow_add hpos]
+    have hexp : (2:ℝ)+ -codimension κ=dimension κ := by unfold codimension; ring
+    norm_num only [Nat.cast_ofNat]
+    rw [hexp]
+  apply Measure.ext
+  intro A hA
+  have hpre : MeasurableSet (J ⁻¹' A) := J.continuous.measurable hA
+  have hAI := (MeasurableEmbedding.subtype_coe isOpen_upperHalfPlane.measurableSet).measurableSet_image.mpr hA
+  have hKI := (MeasurableEmbedding.subtype_coe isOpen_upperHalfPlane.measurableSet).measurableSet_image.mpr hpre
+  have himage : (fun z : ℂ => (c:ℂ)*z) '' ((Subtype.val : upperHalfPlane → ℂ) '' (J ⁻¹' A))=
+      (Subtype.val : upperHalfPlane → ℂ) '' A := by
+    ext z
+    constructor
+    · rintro ⟨_,⟨x,hx,rfl⟩,rfl⟩
+      exact ⟨J x,hx,rfl⟩
+    · rintro ⟨x,hx,rfl⟩
+      refine ⟨(J.symm x:ℂ),⟨J.symm x,?_,rfl⟩,?_⟩
+      · change J (J.symm x) ∈ A
+        simpa only [J.apply_symm_apply] using hx
+      · exact congrArg Subtype.val (J.apply_symm_apply x)
+  rw [dilationMass_apply κ c hc _ A hA,
+    comap_subtype_coe_apply isOpen_upperHalfPlane.measurableSet,
+    comap_subtype_coe_apply isOpen_upperHalfPlane.measurableSet,
+    withDensity_apply _ hAI,withDensity_apply _ hKI,← himage,
+    source_scale_area_lintegral c hc]
+  have hi : (∫⁻ z in (Subtype.val : upperHalfPlane → ℂ) '' (J ⁻¹' A),
+      ENNReal.ofReal (ρ' ((c:ℂ)*z))) =
+      ∫⁻ z in (Subtype.val : upperHalfPlane → ℂ) '' (J ⁻¹' A),
+        ENNReal.ofReal ((c:ℝ)^(-codimension κ))*ENNReal.ofReal (ρ z) := by
+    apply setLIntegral_congr_fun hKI
+    rintro z ⟨x,_hx,rfl⟩
+    dsimp only
+    rw [hρ x x.property,ENNReal.ofReal_mul (Real.rpow_nonneg c.coe_nonneg _)]
+  rw [hi,lintegral_const_mul' _ _ ENNReal.ofReal_ne_top,← mul_assoc,hpower]
+
+lemma dilationMass_initialGreen (κ : ℝ) (c : ℝ≥0) (hc : 0 < c) :
+    dilationMass κ c hc (initialGreenMeasure κ)=initialGreenMeasure κ := by
+  exact (dilationMass_realDensity κ c hc (initialGreen κ) (initialGreen κ)
+    (fun z hz => source_scale_initialGreen κ c hc z hz.le)).symm
+
+lemma dilationMass_bind {Ω : Type*} [MeasurableSpace Ω]
+    (P : Measure Ω) (κ : ℝ) (c : ℝ≥0) (hc : 0 < c)
+    (μ : Ω → Measure upperHalfPlane) (hμ : Measurable μ) :
+    P.bind (fun ω => dilationMass κ c hc (μ ω))=dilationMass κ c hc (P.bind μ) := by
+  have hM : Measurable (fun ω => dilationMass κ c hc (μ ω)) :=
+    (conformalMass_measurable _ _).comp hμ
+  apply Measure.ext
+  intro A hA
+  have hpre : MeasurableSet ((halfPlaneDilation c hc) ⁻¹' A) :=
+    (halfPlaneDilation c hc).continuous.measurable hA
+  rw [Measure.bind_apply hA hM.aemeasurable,dilationMass_apply κ c hc _ A hA]
+  simp_rw [dilationMass_apply κ c hc _ A hA]
+  rw [Measure.bind_apply hpre hμ.aemeasurable,lintegral_const_mul' _ _ ENNReal.ofReal_ne_top]
+
+lemma dilationMass_mono (κ : ℝ) (c : ℝ≥0) (hc : 0 < c)
+    {μ ν : Measure upperHalfPlane} (h : μ ≤ ν) :
+    dilationMass κ c hc μ ≤ dilationMass κ c hc ν := conformalMass_mono _ _ h
+
+lemma dilationMass_ne_zero_iff (κ : ℝ) (c : ℝ≥0) (hc : 0 < c)
+    (μ : Measure upperHalfPlane) : dilationMass κ c hc μ ≠ 0 ↔ μ ≠ 0 := by
+  rw [← Measure.measure_univ_pos,← Measure.measure_univ_pos,dilationMass_apply κ c hc _ univ MeasurableSet.univ]
+  simp only [preimage_univ]
+  constructor
+  · intro h
+    by_contra hn
+    have hzero : μ univ=0 := le_antisymm (le_of_not_gt hn) bot_le
+    simp only [hzero,mul_zero,lt_self_iff_false] at h
+  · intro h
+    exact pos_iff_ne_zero.mpr (mul_ne_zero
+      (ENNReal.ofReal_pos.mpr (Real.rpow_pos_of_pos hc _)).ne' h.ne')
+
+end Multipoint
+end SLEExactGauge
+
+end
+
+end OAI
diff --git a/lean/OAI/Probability/SLE/Mass/DiskChartMass.lean b/lean/OAI/Probability/SLE/Mass/DiskChartMass.lean
new file mode 100644
index 0000000000000000000000000000000000000000..afef2f3fb87fdebc12d4b68290e04b515b9d9e49
--- /dev/null
+++ b/lean/OAI/Probability/SLE/Mass/DiskChartMass.lean
@@ -0,0 +1,113 @@
+import OAI.Probability.SLE.Geometry.DiskQuarterDistortion
+import OAI.Probability.SLE.Angle.TargetDiskMass
+import OAI.Probability.SLE.Mass.CompactImageMassBounds
+
+namespace OAI
+
+/-! Exact disk-coordinate pushforward mass and its two-sided comparison.
+The disk scalar is the same weighted canonical scalar used in the prescribed
+moment coefficients. -/
+
+noncomputable section
+open Set Filter _root_.MeasureTheory _root_.OAI.MeasureTheory Metric
+open scoped Topology NNReal ENNReal
+
+namespace SLEExactGauge
+open Multipoint
+
+lemma Target.mem_diskSourceHalfPlane_iff {θ : ℝ} (hθ : θ ∈ Ioo (0:ℝ) Real.pi)
+    (z : upperHalfPlane) :
+    z ∈ Target.diskSourceHalfPlane θ ↔ Target.diskMap θ z ∈ Target.diskK := by
+  constructor
+  · rintro ⟨w,hw,he⟩
+    have hh := congrArg (Target.diskMap θ) he
+    rw [Target.diskMap_diskMapInv hθ (Target.diskK_subset_unit hw)] at hh
+    rwa [← hh]
+  · intro hz
+    exact ⟨Target.diskMap θ z,hz,Target.diskMapInv_diskMap hθ z.property⟩
+
+lemma Multipoint.ofReal_compactWeightedMass
+    (w : C(upperHalfPlane,ℝ≥0)) (K : Set upperHalfPlane) (hK : IsCompact K)
+    (μ : Measure upperHalfPlane) [IsFiniteMeasureOnCompacts μ] :
+    ENNReal.ofReal (compactWeightedMass w K μ) = ∫⁻ z in K, (w z:ℝ≥0∞) ∂μ := by
+  have hh := ofReal_integral_eq_lintegral_ofReal (compact_weight_integrable w K hK μ)
+    (ae_of_all _ (fun z => (w z).coe_nonneg))
+  simpa only [compactWeightedMass,ENNReal.ofReal_coe_nnreal] using hh
+
+def diskChartMass (κ θ : ℝ) (f : ℂ → ℂ) (μ : Measure upperHalfPlane) : Measure ℂ :=
+  weightedImageMass (fun z : upperHalfPlane => f (Target.diskMap θ z))
+    (fun z : upperHalfPlane => ENNReal.ofReal
+      (‖deriv (f ∘ Target.diskMap θ) z‖^dimension κ)) μ
+
+lemma diskChartMass_quarter_bounds (hgrowth : PublishedDiskUnivalentGrowth)
+    (κ : ℝ) (hκ : 0 < κ) (θ : ℝ) (hθ : θ ∈ Ioo (0:ℝ) Real.pi)
+    (f : ℂ → ℂ) (hd : DifferentiableOn ℂ f (ball 0 1)) (hi : InjOn f (ball 0 1))
+    (μ : Measure upperHalfPlane) [IsFiniteMeasureOnCompacts μ] :
+    ENNReal.ofReal ((‖deriv f 0‖/16)^dimension κ) *
+        ENNReal.ofReal (compactWeightedMass (Target.diskMassWeight κ θ hθ)
+          (Target.diskSourceHalfPlane θ) μ) ≤ diskChartMass κ θ f μ (f '' Target.diskK) ∧
+    diskChartMass κ θ f μ (f '' Target.diskK) ≤
+      ENNReal.ofReal ((16*‖deriv f 0‖)^dimension κ) *
+        ENNReal.ofReal (compactWeightedMass (Target.diskMassWeight κ θ hθ)
+          (Target.diskSourceHalfPlane θ) μ) := by
+  let K := Target.diskSourceHalfPlane θ
+  let J := fun z : upperHalfPlane => f (Target.diskMap θ z)
+  let v := fun z : upperHalfPlane => (Target.diskMassWeight κ θ hθ z:ℝ≥0∞)
+  let w := fun z : upperHalfPlane => ENNReal.ofReal (‖deriv (f ∘ Target.diskMap θ) z‖^dimension κ)
+  have hK : IsCompact K := Target.diskSourceHalfPlane_compact hθ
+  have hmap := Target.diskMap_maps hθ
+  have hJ : Measurable J :=
+    (hd.continuousOn.comp_continuous
+      ((Target.diskHomeomorph θ hθ).continuous_toFun.subtype_val)
+      (fun z => hmap z.property)).measurable
+  have himage : IsCompact (f '' Target.diskK) :=
+    (isCompact_closedBall (0:ℂ) (1/4)).image_of_continuousOn
+      (hd.continuousOn.mono Target.diskK_subset_unit)
+  have hpre : J ⁻¹' (f '' Target.diskK)=K := by
+    ext z
+    rw [Target.mem_diskSourceHalfPlane_iff hθ]
+    constructor
+    · rintro ⟨x,hx,hxe⟩
+      have he : x=Target.diskMap θ z := hi (Target.diskK_subset_unit hx) (hmap z.property) hxe
+      rwa [← he]
+    · intro hz
+      exact ⟨Target.diskMap θ z,hz,rfl⟩
+  have he : diskChartMass κ θ f μ (f '' Target.diskK) = ∫⁻ z in K, w z ∂μ := by
+    change weightedImageMass J w μ _ = _
+    rw [weightedImageMass,Measure.map_apply hJ himage.measurableSet,hpre,withDensity_apply _ hK.measurableSet]
+  have hw (z : upperHalfPlane) : w z =
+      ENNReal.ofReal (‖deriv f (Target.diskMap θ z)‖^dimension κ)*v z := by
+    dsimp only [w,v]
+    rw [Target.diskMassWeight_ennreal]
+    symm
+    rw [mul_comm]
+    exact derivative_dimension_weight_comp κ f (Target.diskMap θ) z
+      (hd.differentiableAt (isOpen_ball.mem_nhds (hmap z.property)))
+      (Target.diskMap_hasDerivAt hθ z.property).differentiableAt
+  have hd0 : 0 ≤ dimension κ := by unfold dimension; linarith
+  have hbounds (z : upperHalfPlane) (hz : z∈K) :
+      ENNReal.ofReal ((‖deriv f 0‖/16)^dimension κ)*v z ≤ w z ∧
+      w z ≤ ENNReal.ofReal ((16*‖deriv f 0‖)^dimension κ)*v z := by
+    have hz' : Target.diskMap θ z ∈ Target.diskK := (Target.mem_diskSourceHalfPlane_iff hθ z).mp hz
+    have hn : ‖Target.diskMap θ z‖ ≤ 1/4 := by
+      simpa only [Target.diskK,mem_closedBall,dist_zero_right] using hz'
+    have hb := univalent_quarter_derivative_bounds hgrowth hd hi hn
+    rw [hw]
+    constructor
+    · apply mul_le_mul' _ le_rfl
+      exact ENNReal.ofReal_le_ofReal (Real.rpow_le_rpow (by positivity) hb.1 hd0)
+    · apply mul_le_mul' _ le_rfl
+      exact ENNReal.ofReal_le_ofReal (Real.rpow_le_rpow (norm_nonneg _) hb.2 hd0)
+  rw [ofReal_compactWeightedMass _ _ hK μ,he]
+  change ENNReal.ofReal ((‖deriv f 0‖/16)^dimension κ)*(∫⁻ z in K, v z ∂μ) ≤ _ ∧
+    _ ≤ ENNReal.ofReal ((16*‖deriv f 0‖)^dimension κ)*(∫⁻ z in K, v z ∂μ)
+  rw [← lintegral_const_mul' _ _ ENNReal.ofReal_ne_top,
+    ← lintegral_const_mul' _ _ ENNReal.ofReal_ne_top]
+  exact ⟨setLIntegral_mono' hK.measurableSet (fun z hz => (hbounds z hz).1),
+    setLIntegral_mono' hK.measurableSet (fun z hz => (hbounds z hz).2)⟩
+
+end SLEExactGauge
+
+end
+
+end OAI
diff --git a/lean/OAI/Probability/SLE/Mass/DiskLevelMoments.lean b/lean/OAI/Probability/SLE/Mass/DiskLevelMoments.lean
new file mode 100644
index 0000000000000000000000000000000000000000..c0e277cd29ede2dc90086a4a07910f6a51451956
--- /dev/null
+++ b/lean/OAI/Probability/SLE/Mass/DiskLevelMoments.lean
@@ -0,0 +1,126 @@
+import OAI.Probability.SLE.Geometry.PhysicalCenteredWeights
+import OAI.Probability.SLE.Mass.CompactLevelMoments
+import OAI.Probability.SLE.Angle.TargetPotentialMeasurability
+
+namespace OAI
+
+/-! Centered level moments in the prescribed physical disk. The radius
+cap and spatial kernel are independent of the chart angle. -/
+
+noncomputable section
+open Set Filter _root_.MeasureTheory _root_.OAI.MeasureTheory ProbabilityTheory Metric
+open scoped NNReal ENNReal
+
+namespace SLEExactGauge.Multipoint
+
+def diskStoppedGreen {Ω : Type*} (κ θ : ℝ) (B : ℝ≥0 → Ω → ℝ)
+    (γ : Ω → ℝ≥0 → ℂ) (G : Ω → ℝ≥0 → ℂ → ℂ)
+    (u : ℝ) (ω : Ω) (x : ℂ) : ℝ :=
+  ‖deriv (Target.diskMap θ) (Target.diskMapInv θ x)‖^(-codimension κ) *
+    stoppedGreen κ (fun t => Real.sqrt κ*B t ω) (γ ω) (G ω) (Target.diskMapInv θ x) u
+
+def diskLevelMass {Ω : Type*} (κ θ : ℝ) (B : ℝ≥0 → Ω → ℝ)
+    (γ : Ω → ℝ≥0 → ℂ) (G : Ω → ℝ≥0 → ℂ → ℂ)
+    (u : ℝ) (K : Set ℂ) (ω : Ω) : ℝ≥0∞ :=
+  ∫⁻ x in K, ENNReal.ofReal (diskStoppedGreen κ θ B γ G u ω x)
+
+def diskCenterHit {Ω : Type*} (γ : Ω → ℝ≥0 → ℂ)
+    (G : Ω → ℝ≥0 → ℂ → ℂ) (θ e : ℝ) : Set Ω :=
+  {ω | ∃ t : ℝ≥0, Target.diskMapInv θ 0 ∈ survivingDomain (γ ω) t ∧
+    physicalConformalRadius (Target.diskMap θ) (G ω) t (Target.diskMapInv θ 0) ≤ e}
+
+lemma diskStoppedGreen_nonneg {Ω : Type*} {κ θ : ℝ} {B : ℝ≥0 → Ω → ℝ}
+    {γ : Ω → ℝ≥0 → ℂ} {G F : Ω → ℝ≥0 → ℂ → ℂ}
+    (hw : ∀ ω, IsCapacityTwoWitness (fun t => Real.sqrt κ*B t ω) (γ ω) (G ω) (F ω))
+    (u : ℝ) (ω : Ω) (x : ℂ) : 0 ≤ diskStoppedGreen κ θ B γ G u ω x :=
+  mul_nonneg (Real.rpow_nonneg (norm_nonneg _) _) (stoppedGreen_nonneg (hw ω) κ _ _)
+
+lemma measurable_diskStoppedGreen
+    {Ω : Type*} [MeasurableSpace Ω] {B : ℝ≥0 → Ω → ℝ}
+    (hm : ∀ t, Measurable (B t)) (hc : ∀ ω, Continuous (fun t => B t ω))
+    (κ θ u : ℝ) (hu : 0 ≤ u)
+    (γ : Ω → ℝ≥0 → ℂ) (G F : Ω → ℝ≥0 → ℂ → ℂ)
+    (hw : ∀ ω, IsCapacityTwoWitness (fun t => Real.sqrt κ*B t ω) (γ ω) (G ω) (F ω)) :
+    Measurable (Function.uncurry (diskStoppedGreen κ θ B γ G u)) := by
+  have hi : Measurable (fun p : Ω × ℂ => Target.diskMapInv θ p.2) :=
+    (Target.measurable_diskMapInv θ).comp measurable_snd
+  have hd : Measurable (fun p : Ω × ℂ =>
+      ‖deriv (Target.diskMap θ) (Target.diskMapInv θ p.2)‖^(-codimension κ)) :=
+    ((measurable_deriv (Target.diskMap θ)).comp hi).norm.pow_const _
+  exact hd.mul ((actual_stoppedGreen_joint_measurable hm hc κ u hu γ G F hw).comp
+    (measurable_fst.prodMk hi))
+
+lemma measurableSet_diskCenterHit
+    {Ω : Type*} [MeasurableSpace Ω] {B : ℝ≥0 → Ω → ℝ}
+    (hm : ∀ t, Measurable (B t)) (hc : ∀ ω, Continuous (fun t => B t ω))
+    (κ θ : ℝ) (hθ : θ ∈ Ioo (0:ℝ) Real.pi)
+    (γ : Ω → ℝ≥0 → ℂ) (G F : Ω → ℝ≥0 → ℂ → ℂ)
+    (hw : ∀ ω, IsCapacityTwoWitness (fun t => Real.sqrt κ*B t ω) (γ ω) (G ω) (F ω))
+    (e : ℝ) (he : 0<e) (he1 : e≤1) : MeasurableSet (diskCenterHit γ G θ e) := by
+  have hu : 0 ≤ Real.log (1/e) := Real.log_nonneg ((one_le_div he).mpr he1)
+  have hτ := (actual_radiusLevel_joint_measurable hm hc κ (Real.log (1/e)) hu γ G F hw).comp
+    (measurable_id.prodMk (measurable_const : Measurable (fun _ : Ω => Target.diskMapInv θ 0)))
+  have heq : diskCenterHit γ G θ e =
+      {ω | radiusLevelTime (γ ω) (G ω) (Target.diskMapInv θ 0) (Real.log (1/e)) < ∞} := by
+    ext ω
+    exact physical_radius_hit_iff_finite_level ((hc ω).const_mul _) (hw ω)
+      (Target.diskMap θ) (Target.diskMapInv θ 0) 1 e zero_lt_one he he1
+      (Target.initialRadius_zero hθ).symm
+  rw [heq]
+  exact measurableSet_lt hτ measurable_const
+
+theorem diskStoppedGreen_centered_product_bound
+    {Ω : Type*} [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)
+    (θ : ℝ) (hθ : θ ∈ Ioo (0:ℝ) Real.pi) (m : ℕ)
+    (x : Fin m → ℂ) (hx : ∀ i, x i ∈ ball 0 1)
+    (hinj : Function.Injective (Fin.cons (0:ℂ) x))
+    (b : ℝ) (hb : 0<b) (hb1 : b≤1) (hbx : ∀ i, b≤1-‖x i‖^2)
+    (e : ℝ) (he : 0<e) (u : ℝ) :
+    (∫⁻ ω, (diskCenterHit γ G θ e).indicator
+      (fun ω => ENNReal.ofReal (∏ i, diskStoppedGreen κ θ B γ G u ω (x i))) ω ∂P) ≤
+      ENNReal.ofReal (multipointConstant κ (m+1)*e^codimension κ) *
+        cappedDistanceKernel (codimension κ) b (Fin.cons 0 x) := by
+  let y : Fin (m+1) → ℂ := Fin.cons (0:ℂ) x
+  let z := fun i => Target.diskMapInv θ (y i)
+  have hy (i) : y i ∈ ball 0 1 := Fin.cases (by change (0:ℂ)∈ball 0 1; simp) hx i
+  have hz (i) : z i ∈ upperHalfPlane := Target.diskMapInv_maps hθ (hy i)
+  have heq (i) : Target.diskMap θ (z i)=y i := Target.diskMap_diskMapInv hθ (hy i)
+  have hzi : Function.Injective z := fun i j h => hinj (by
+    simpa only [heq] using congrArg (Target.diskMap θ) h)
+  have hbR (i) : b≤2*(z i).im*‖deriv (Target.diskMap θ) (z i)‖ := by
+    rw [Target.diskMap_initial_radius hθ (hz i),heq]
+    exact Fin.cases (by simpa only [y,Fin.cons_zero,norm_zero,pow_two,mul_zero,sub_zero] using hb1) hbx i
+  let es : Fin (m+1) → ℝ := Fin.cons e
+    (fun i => (2*(z i.succ).im*‖deriv (Target.diskMap θ) (z i.succ)‖)*Real.exp (-u))
+  have hes (i) : 0<es i := Fin.cases he (fun i =>
+    mul_pos (hb.trans_le (hbR i.succ)) (Real.exp_pos _)) i
+  have hu (i : Fin m) : Real.log
+      (2*(z i.succ).im*‖deriv (Target.diskMap θ) (z i.succ)‖/es i.succ)=u := by
+    change Real.log ((2*(z i.succ).im*‖deriv (Target.diskMap θ) (z i.succ)‖)/
+      ((2*(z i.succ).im*‖deriv (Target.diskMap θ) (z i.succ)‖)*Real.exp (-u)))=u
+    rw [div_mul_eq_div_div,div_self (hb.trans_le (hbR i.succ)).ne',one_div,← Real.exp_neg,
+      neg_neg,Real.log_exp]
+  have hbound := physical_stoppedGreen_centered_product_bound hB hm hBm hc h0 hκ hκ8
+    γ G F hw hgrowth (Target.diskMap θ) (Target.diskMap_differentiableOn hθ)
+    (Target.diskMap_injOn hθ) m z hz hzi (cappedDistance b y) es hes
+    (fun i => cap_pos hb hinj i) (fun i => (cap_le_fixed b y i).trans (hbR i))
+    (fun i j hij => by simpa only [heq] using cap_le_dist b y i j hij)
+  simp only [hu,es,Fin.cons_zero] at hbound
+  apply hbound.trans_eq
+  rw [ENNReal.ofReal_mul (mul_nonneg (multipointConstant_pos _ _).le
+    (Real.rpow_nonneg he.le _))]
+  congr 1
+  exact ENNReal.ofReal_prod_of_nonneg (fun i _ => Real.rpow_nonneg (cap_pos hb hinj i).le _)
+
+end SLEExactGauge.Multipoint
+
+end
+
+end OAI
diff --git a/lean/OAI/Probability/SLE/Mass/DiskLevelTests.lean b/lean/OAI/Probability/SLE/Mass/DiskLevelTests.lean
new file mode 100644
index 0000000000000000000000000000000000000000..3aac025aaa04a7a4d2f9cad38c0ea873f0e824b0
--- /dev/null
+++ b/lean/OAI/Probability/SLE/Mass/DiskLevelTests.lean
@@ -0,0 +1,76 @@
+import OAI.Probability.SLE.Gauge.DiskIntegratedMoments
+import OAI.Probability.SLE.Mass.DiskLevelTransport
+import OAI.Probability.SLE.Mass.CanonicalImageMass
+import OAI.Probability.SLE.Mass.WeightedLevelMoments
+
+namespace OAI
+
+/-! Positive compact disk tests are dominated by physical level mass,
+with the exact conformal derivative weight. -/
+
+noncomputable section
+open Set Filter _root_.MeasureTheory _root_.OAI.MeasureTheory ProbabilityTheory Metric
+open scoped NNReal ENNReal Topology CompactlySupported
+
+namespace SLEExactGauge.Multipoint
+
+lemma ofReal_disk_level_test_le
+    {Ω : Type*} [MeasurableSpace Ω] {B : ℝ≥0 → Ω → ℝ}
+    (hm : ∀ t, Measurable (B t)) (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 ω))
+    (θ : ℝ) (hθ : θ ∈ Ioo (0:ℝ) Real.pi)
+    (K : Set ℂ) (hK : IsCompact K) (hKd : K ⊆ ball 0 1)
+    (f : C_c((ball (0:ℂ) 1),ℝ)) (hf : ∀ x, 0≤f x) (hf1 : ∀ x, f x≤1)
+    (hfs : ∀ x : (ball (0:ℂ) 1), (x:ℂ)∉K → f x=0)
+    (u : ℝ) (hu : 0≤u) (t : ℝ≥0∞) (ω : Ω) :
+    ENNReal.ofReal (∫ x, f x ∂conformalMass (Target.diskHomeomorph θ hθ)
+      (Target.diskMassWeight κ θ hθ) (halfPlaneLevelMeasure κ B γ G u t ω)) ≤
+        diskLevelMass κ θ B γ G u K ω := by
+  let g := conformalMassTest (Target.diskHomeomorph θ hθ) (Target.diskMassWeight κ θ hθ) f
+  let S := Target.diskMapInv θ '' K
+  have hS : IsCompact S := Target.diskCompactPreimage_compact θ hK hKd
+  have hSH : S ⊆ upperHalfPlane := Target.diskCompactPreimage_subset hθ hKd
+  have hg : ∀ z, 0≤g z := fun z => mul_nonneg (NNReal.coe_nonneg _) (hf _)
+  have hgz (z : ℂ) (hz : z∉S) : extendHalfPlaneTest g z=0 := by
+    by_cases hzH : z∈upperHalfPlane
+    · rw [show z=(⟨z,hzH⟩:upperHalfPlane).val from rfl,extendHalfPlaneTest_apply]
+      have hn : ((Target.diskHomeomorph θ hθ ⟨z,hzH⟩):ℂ)∉K := by
+        intro h
+        exact hz ⟨_,h,Target.diskMapInv_diskMap hθ hzH⟩
+      change (Target.diskMassWeight κ θ hθ ⟨z,hzH⟩:ℝ)*
+        f (Target.diskHomeomorph θ hθ ⟨z,hzH⟩)=0
+      rw [hfs _ hn,mul_zero]
+    · exact extendHalfPlaneTest_of_not_mem g z hzH
+  rw [conformalMass_integral]
+  change ENNReal.ofReal (∫ z, g z ∂halfPlaneLevelMeasure κ B γ G u t ω) ≤ _
+  rw [ofReal_integral_halfPlaneLevelMeasure hκ hκ8 γ G F ω (hc ω) (hw ω) u t g hg]
+  apply (levelApproximationTest_le_weightedLevelMass hm hc κ u hu γ G F hw S hS.measurableSet
+    (fun z => ENNReal.ofReal (extendHalfPlaneTest g z))
+    (extendHalfPlaneTest_measurable g g.continuous.measurable).ennreal_ofReal
+    (fun z hz => by rw [hgz z hz,ENNReal.ofReal_zero]) t ω).trans
+  calc
+    weightedLevelMass κ B γ G u S (fun z => ENNReal.ofReal (extendHalfPlaneTest g z)) ω ≤
+        ∫⁻ z in S, ENNReal.ofReal (‖deriv (Target.diskMap θ) z‖^dimension κ)*
+          ENNReal.ofReal (stoppedGreen κ (fun t => Real.sqrt κ*B t ω) (γ ω) (G ω) z u) := by
+      apply setLIntegral_mono' hS.measurableSet
+      intro z hz
+      apply mul_le_mul' ?_ le_rfl
+      apply ENNReal.ofReal_le_ofReal
+      rw [show z=(⟨z,hSH hz⟩:upperHalfPlane).val from rfl,extendHalfPlaneTest_apply]
+      change (Target.diskMassWeight κ θ hθ ⟨z,hSH hz⟩:ℝ)*
+        f (Target.diskHomeomorph θ hθ ⟨z,hSH hz⟩) ≤ _
+      rw [Target.diskMassWeight_coe]
+      exact mul_le_of_le_one_right (Real.rpow_nonneg (norm_nonneg _) _) (hf1 _)
+    _ = diskLevelMass κ θ B γ G u K ω := by
+      rw [← Target.disk_level_integral_transport κ θ hθ K hK hKd]
+      apply setLIntegral_congr_fun hK.measurableSet
+      intro x hx
+      exact (ENNReal.ofReal_mul (Real.rpow_nonneg (norm_nonneg _) _)).symm
+
+end SLEExactGauge.Multipoint
+
+end
+
+end OAI
diff --git a/lean/OAI/Probability/SLE/Mass/DiskLevelTransport.lean b/lean/OAI/Probability/SLE/Mass/DiskLevelTransport.lean
new file mode 100644
index 0000000000000000000000000000000000000000..0a3f24ed91bee4f46145f39163a6acca818a6048
--- /dev/null
+++ b/lean/OAI/Probability/SLE/Mass/DiskLevelTransport.lean
@@ -0,0 +1,69 @@
+import OAI.Probability.SLE.Angle.TargetDiskMass
+
+namespace OAI
+
+/-! Area transport for the disk Green weights at individual radius
+levels. The derivative squared from area cancels the Green codimension
+factor, leaving precisely the canonical mass weight. -/
+
+noncomputable section
+open Set Filter _root_.MeasureTheory _root_.OAI.MeasureTheory Metric
+open scoped Topology NNReal ENNReal
+
+namespace SLEExactGauge.Target
+
+lemma diskCompactPreimage_subset
+    {θ : ℝ} (hθ : θ ∈ Ioo (0:ℝ) Real.pi)
+    {K : Set ℂ} (hK : K ⊆ ball 0 1) :
+    diskMapInv θ '' K ⊆ upperHalfPlane := by
+  rintro z ⟨x,hx,rfl⟩
+  exact diskMapInv_maps hθ (hK hx)
+
+lemma diskCompactPreimage_compact (θ : ℝ)
+    {K : Set ℂ} (hc : IsCompact K) (hK : K ⊆ ball 0 1) :
+    IsCompact (diskMapInv θ '' K) := by
+  apply hc.image_of_continuousOn
+  change ContinuousOn (fun x : ℂ =>
+    (Complex.exp (θ*Complex.I)-x*Complex.exp (-θ*Complex.I))/(1-x)) K
+  exact (continuous_const.continuousOn.sub
+    (continuous_id.mul continuous_const).continuousOn).div
+    (continuous_const.sub continuous_id).continuousOn (fun x hx => disk_denominator_ne (hK hx))
+
+theorem disk_level_integral_transport
+    (κ θ : ℝ) (hθ : θ ∈ Ioo (0:ℝ) Real.pi)
+    (K : Set ℂ) (hc : IsCompact K) (hK : K ⊆ ball 0 1)
+    (g : ℂ → ℝ≥0∞) :
+    (∫⁻ x in K, ENNReal.ofReal
+      (‖deriv (diskMap θ) (diskMapInv θ x)‖^(-codimension κ))*g (diskMapInv θ x)) =
+    ∫⁻ z in diskMapInv θ '' K,
+      ENNReal.ofReal (‖deriv (diskMap θ) z‖^dimension κ)*g z := by
+  have hs := diskCompactPreimage_subset hθ hK
+  have hcomp := diskCompactPreimage_compact θ hc hK
+  have himage : diskMap θ '' (diskMapInv θ '' K)=K := by
+    ext x
+    constructor
+    · rintro ⟨z,⟨y,hy,rfl⟩,rfl⟩
+      simpa only [diskMap_diskMapInv hθ (hK hy)] using hy
+    · intro hx
+      exact ⟨diskMapInv θ x,⟨x,hx,rfl⟩,diskMap_diskMapInv hθ (hK hx)⟩
+  have hd (z : ℂ) (hz : z ∈ diskMapInv θ '' K) := diskMap_hasDerivAt hθ (hs hz)
+  conv_lhs => rw [← himage]
+  rw [lintegral_image_eq_lintegral_abs_det_fderiv_mul volume hcomp.measurableSet
+    (fun z hz => ((hd z hz).hasFDerivAt.restrictScalars ℝ).hasFDerivWithinAt)
+    ((diskMap_injOn hθ).mono hs)]
+  apply setLIntegral_congr_fun hcomp.measurableSet
+  intro z hz
+  dsimp only
+  rw [complex_derivative_real_det,abs_of_nonneg (sq_nonneg _),
+    diskMapInv_diskMap hθ (hs hz),← mul_assoc,← ENNReal.ofReal_mul (sq_nonneg _)]
+  congr 1
+  rw [← (hd z hz).deriv,← Real.rpow_natCast,← Real.rpow_add (diskMap_deriv_pos hθ (hs hz))]
+  congr 1
+  unfold codimension dimension
+  ring_nf
+
+end SLEExactGauge.Target
+
+end
+
+end OAI
diff --git a/lean/OAI/Probability/SLE/Mass/DiskMassMomentBound.lean b/lean/OAI/Probability/SLE/Mass/DiskMassMomentBound.lean
new file mode 100644
index 0000000000000000000000000000000000000000..4c9f1fa7eb67a8b130e9cf128ea407c6d7fac4fa
--- /dev/null
+++ b/lean/OAI/Probability/SLE/Mass/DiskMassMomentBound.lean
@@ -0,0 +1,120 @@
+import OAI.Probability.SLE.Gauge.DiskCanonicalMoments
+import OAI.Probability.SLE.Geometry.CanonicalDiskPotential
+
+namespace OAI
+
+/-! Uniform moments of the exact quarter-disk terminal mass, retaining
+the small centered-target factor before the change of law. -/
+
+noncomputable section
+open Set Filter _root_.MeasureTheory _root_.OAI.MeasureTheory ProbabilityTheory Metric
+open scoped NNReal ENNReal Topology CompactlySupported
+
+namespace SLEExactGauge.Target
+
+local instance : LocallyCompactSpace (ball (0:ℂ) 1) := isOpen_ball.locallyCompactSpace
+
+lemma exists_diskMass_cutoff :
+    ∃ f : C_c((ball (0:ℂ) 1),ℝ), (∀ x, 0≤f x) ∧ (∀ x, f x≤1) ∧
+      (∀ x : (ball (0:ℂ) 1), (x:ℂ)∈diskK → 1≤f x) ∧
+      (∀ x : (ball (0:ℂ) 1), (x:ℂ)∉closedBall 0 (1/2:ℝ) → f x=0) := by
+  let K : Set (ball (0:ℂ) 1) := Subtype.val ⁻¹' diskK
+  let V : Set (ball (0:ℂ) 1) := Subtype.val ⁻¹' ball 0 (1/2:ℝ)
+  have hK : IsCompact K := by
+    apply Topology.IsEmbedding.subtypeVal.isCompact_iff.mpr
+    have he : Subtype.val '' K = diskK := by
+      ext x
+      constructor
+      · rintro ⟨y,hy,rfl⟩
+        exact hy
+      · intro hx
+        exact ⟨⟨x,diskK_subset_unit hx⟩,hx,rfl⟩
+    rw [he]
+    exact isCompact_closedBall _ _
+  have hV : IsOpen V := isOpen_ball.preimage continuous_subtype_val
+  have hKV : K⊆V := by
+    intro x hx
+    have hn : ‖(x:ℂ)‖≤(1/4:ℝ) := mem_closedBall_zero_iff.mp hx
+    exact mem_ball_zero_iff.mpr (hn.trans_lt (by norm_num))
+  obtain ⟨f,hf,hfc,hfs,h01⟩ := exists_continuousMap_one_of_isCompact_subset_isOpen hK hV hKV
+  refine ⟨⟨f,hfc⟩,fun x => (h01 x).1,fun x => (h01 x).2,?_,?_⟩
+  · intro x hx
+    change 1≤f x
+    rw [hf hx]
+    rfl
+  · intro x hx
+    apply image_eq_zero_of_notMem_tsupport
+    intro hs
+    exact hx (mem_closedBall_zero_iff.mpr (mem_ball_zero_iff.mp (hfs hs)).le)
+
+end SLEExactGauge.Target
+
+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 diskTerminalScalar_le_test
+    (θ : ℝ) (hθ : θ∈Ioo (0:ℝ) Real.pi)
+    (f : C_c((ball (0:ℂ) 1),ℝ)) (hf : ∀ x, 0≤f x)
+    (hKf : ∀ x : (ball (0:ℂ) 1), (x:ℂ)∈Target.diskK → 1≤f x) (ω : Ω) :
+    C.diskTerminalScalar θ hθ ω ≤
+      ∫ x, f x ∂conformalMass (Target.diskHomeomorph θ hθ)
+        (Target.diskMassWeight κ θ hθ) (C.rational.terminal ω) := by
+  let : IsFiniteMeasureOnCompacts (C.rational.terminal ω) := (C.rational.terminal_radon ω).2
+  let w := Target.diskMassWeight κ θ hθ
+  let g := conformalMassTest (Target.diskHomeomorph θ hθ) w f
+  have hK := Target.diskSourceHalfPlane_compact hθ
+  rw [conformalMass_integral]
+  change (∫ z in Target.diskSourceHalfPlane θ, (w z:ℝ) ∂C.rational.terminal ω) ≤
+    ∫ z, g z ∂C.rational.terminal ω
+  rw [← integral_indicator hK.measurableSet]
+  apply integral_mono ((integrable_indicator_iff hK.measurableSet).mpr
+    (compact_weight_integrable w _ hK _)) g.integrable
+  intro z
+  by_cases hz : z∈Target.diskSourceHalfPlane θ
+  · rw [indicator_of_mem hz]
+    have hmap : ((Target.diskHomeomorph θ hθ z):ℂ)∈Target.diskK := by
+      obtain ⟨x,hx,he⟩ := hz
+      have heq := congrArg (Target.diskMap θ) he
+      have heq' : x=Target.diskMap θ z := by
+        simpa only [Target.diskMap_diskMapInv hθ (Target.diskK_subset_unit hx)] using heq
+      change Target.diskMap θ z∈Target.diskK
+      rw [← heq']
+      exact hx
+    change (w z:ℝ)≤(w z:ℝ)*f (Target.diskHomeomorph θ hθ z)
+    exact le_mul_of_one_le_right (NNReal.coe_nonneg _) (hKf _ hmap)
+  · rw [indicator_of_notMem hz]
+    exact mul_nonneg (NNReal.coe_nonneg _) (hf _)
+
+theorem uniform_diskTerminalScalar_centered_moments
+    (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 : ℕ) :
+    ∃ M : ℝ≥0∞, M<∞ ∧ ∀ (θ : ℝ) (hθ : θ∈Ioo (0:ℝ) Real.pi), ∀ e : ℝ, 0<e → e≤1 →
+      (∫⁻ ω in diskCenterHit γ G θ e, ENNReal.ofReal (C.diskTerminalScalar θ hθ ω)^m ∂P) ≤
+        M*ENNReal.ofReal (e^codimension κ) := by
+  have hKd : closedBall (0:ℂ) (1/2:ℝ)⊆ball 0 1 := closedBall_subset_ball (by norm_num)
+  have hbK : ∀ x∈closedBall (0:ℂ) (1/2:ℝ), (1/2:ℝ)≤1-‖x‖^2 := by
+    intro x hx
+    have hn := mem_closedBall_zero_iff.mp hx
+    nlinarith [norm_nonneg x]
+  obtain ⟨M,hM,hbound⟩ := C.uniform_disk_terminal_test_centered_moments hB hc h0 hκ hκ8 F hw
+    hgrowth (closedBall 0 (1/2:ℝ)) (isCompact_closedBall _ _) hKd (1/2:ℝ)
+    (by norm_num) (by norm_num) hbK m
+  obtain ⟨f,hf,hf1,hKf,hfs⟩ := Target.exists_diskMass_cutoff
+  refine ⟨M,hM,?_⟩
+  intro θ hθ e he he1
+  apply (lintegral_mono (fun ω => pow_le_pow_left' (ENNReal.ofReal_le_ofReal
+    (C.diskTerminalScalar_le_test θ hθ f hf hKf ω)) m)).trans
+  exact hbound θ hθ f hf hf1 hfs e he he1
+
+end SLEExactGauge.Multipoint.CanonicalMass
+
+end
+
+end OAI
diff --git a/lean/OAI/Probability/SLE/Mass/DominatedMassTestContinuity.lean b/lean/OAI/Probability/SLE/Mass/DominatedMassTestContinuity.lean
new file mode 100644
index 0000000000000000000000000000000000000000..a4e651298cbed5221f3b29cdfad717f8d0ca0f5e
--- /dev/null
+++ b/lean/OAI/Probability/SLE/Mass/DominatedMassTestContinuity.lean
@@ -0,0 +1,76 @@
+import OAI.Probability.SLE.LoewnerCharts
+import Mathlib.MeasureTheory.Function.ContinuousMapDense
+
+namespace OAI
+
+/-! Compact-test continuity extends to every terminal-integrable weight.
+This permits weighted inverse-chart tests whose supports approach the old
+boundary, using domination by the Radon terminal mass. -/
+
+noncomputable section
+open Set Filter MeasureTheory
+open scoped Topology NNReal ENNReal CompactlySupported
+
+namespace SLEExactGauge
+
+local instance dominatedTestLocallyCompact : LocallyCompactSpace upperHalfPlane := isOpen_upperHalfPlane.locallyCompactSpace
+
+lemma integral_test_distance_le_of_domination
+    (μ ν : Measure upperHalfPlane) (hμ : μ ≤ ν)
+    (f g : upperHalfPlane → ℝ) (hf : Integrable f ν) (hg : Integrable g ν) :
+    dist (∫ z, f z ∂μ) (∫ z, g z ∂μ) ≤ ∫ z, ‖f z-g z‖ ∂ν := by
+  rw [Real.dist_eq,← integral_sub (hf.mono_measure hμ) (hg.mono_measure hμ)]
+  calc
+    |∫ z, f z-g z ∂μ| ≤ ∫ z, ‖f z-g z‖ ∂μ := by
+      simpa only [Real.norm_eq_abs] using norm_integral_le_integral_norm (fun z => f z-g z)
+    _ ≤ _ := integral_mono_measure hμ (ae_of_all _ (fun _ => norm_nonneg _)) (hf.sub hg).norm
+
+/-- Monotonicity is not needed: domination and compact-test continuity suffice. -/
+theorem continuous_integral_of_radon_domination
+    (N : ℝ≥0 → Measure upperHalfPlane) (ν : Measure upperHalfPlane) [ν.Regular]
+    (hdom : ∀ t, N t ≤ ν)
+    (hcont : ∀ f : C_c(upperHalfPlane,ℝ), Continuous (fun t => ∫ z, f z ∂N t))
+    (g : upperHalfPlane → ℝ) (hg : Integrable g ν) :
+    Continuous (fun t => ∫ z, g z ∂N t) := by
+  apply continuous_iff_continuousAt.mpr
+  intro t
+  apply Metric.tendsto_nhds.mpr
+  intro ε hε
+  obtain ⟨f,hfs,herr,hfc,hfi⟩ := hg.exists_hasCompactSupport_integral_sub_le
+    (show 0 < ε/3 by positivity)
+  let φ : C_c(upperHalfPlane,ℝ) := ⟨⟨f,hfc⟩,hfs⟩
+  have hct : ContinuousAt (fun u => ∫ z, φ z ∂N u) t := (hcont φ).continuousAt
+  have hnear := (Metric.tendsto_nhds.mp hct) (ε/3)
+    (show 0 < ε/3 by positivity)
+  filter_upwards [hnear] with s hs
+  have hb (u : ℝ≥0) : dist (∫ z, g z ∂N u) (∫ z, f z ∂N u) ≤ ε/3 :=
+    (integral_test_distance_le_of_domination (N u) ν (hdom u) g f hg hfi).trans herr
+  have h1 := dist_triangle (∫ z, g z ∂N s) (∫ z, f z ∂N s) (∫ z, g z ∂N t)
+  have h2 := dist_triangle (∫ z, f z ∂N s) (∫ z, f z ∂N t) (∫ z, g z ∂N t)
+  change dist (∫ z, f z ∂N s) (∫ z, f z ∂N t) < ε/3 at hs
+  rw [dist_comm (∫ z, f z ∂N t) (∫ z, g z ∂N t)] at h2
+  linarith [hb s,hb t]
+
+theorem continuous_lintegral_of_radon_domination
+    (N : ℝ≥0 → Measure upperHalfPlane) (ν : Measure upperHalfPlane) [ν.Regular]
+    (hdom : ∀ t, N t ≤ ν)
+    (hcont : ∀ f : C_c(upperHalfPlane,ℝ), Continuous (fun t => ∫ z, f z ∂N t))
+    (g : upperHalfPlane → ℝ≥0∞) (hg : Measurable g) (hfin : ∫⁻ z, g z ∂ν ≠ ∞) :
+    Continuous (fun t => ∫⁻ z, g z ∂N t) := by
+  have hreal : Integrable (fun z => (g z).toReal) ν :=
+    integrable_toReal_of_lintegral_ne_top hg.aemeasurable hfin
+  have hc := continuous_integral_of_radon_domination N ν hdom hcont _ hreal
+  have he (t : ℝ≥0) : ENNReal.ofReal (∫ z, (g z).toReal ∂N t) = ∫⁻ z, g z ∂N t := by
+    rw [ofReal_integral_eq_lintegral_ofReal (hreal.mono_measure (hdom t))
+      (ae_of_all _ (fun _ => ENNReal.toReal_nonneg))]
+    apply lintegral_congr_ae
+    have hfinite : ∀ᵐ z ∂ν, g z ≠ ∞ := (ae_lt_top hg hfin).mono (fun _ h => h.ne)
+    filter_upwards [ae_mono (hdom t) hfinite] with z hz
+    exact ENNReal.ofReal_toReal hz
+  simpa only [Function.comp_def,he] using ENNReal.continuous_ofReal.comp hc
+
+end SLEExactGauge
+
+end
+
+end OAI
diff --git a/lean/OAI/Probability/SLE/Mass/DominatedMassTestExhaustion.lean b/lean/OAI/Probability/SLE/Mass/DominatedMassTestExhaustion.lean
new file mode 100644
index 0000000000000000000000000000000000000000..9fd77656f48379dec3772f8453f0bf45be098892
--- /dev/null
+++ b/lean/OAI/Probability/SLE/Mass/DominatedMassTestExhaustion.lean
@@ -0,0 +1,88 @@
+import OAI.Probability.SLE.Mass.DominatedMassTestContinuity
+import OAI.Probability.SLE.Mass.TerminalMassTestLimit
+
+namespace OAI
+
+/-! Terminal-integrable weights pass through local exhaustion. This supplies
+terminal exhaustion after conformal weighting, including weights whose
+support approaches the boundary. -/
+
+noncomputable section
+open Set Filter MeasureTheory
+open scoped Topology NNReal ENNReal CompactlySupported
+
+namespace SLEExactGauge
+
+local instance exhaustedTestLocallyCompact : LocallyCompactSpace upperHalfPlane := isOpen_upperHalfPlane.locallyCompactSpace
+
+theorem terminal_integrable_test_tendsto
+    (ν : Measure upperHalfPlane) [ν.Regular]
+    (N : ℝ≥0 → Measure upperHalfPlane) (hNr : ∀ t, (N t).Regular)
+    (hdom : ∀ t, N t ≤ ν)
+    (hlim : ∀ K : Set upperHalfPlane, IsCompact K →
+      Tendsto (fun t : ℝ≥0 => (ν-N t) K) atTop (𝓝 0))
+    (g : upperHalfPlane → ℝ) (hg : Integrable g ν) :
+    Tendsto (fun t : ℝ≥0 => ∫ z, g z ∂N t) atTop (𝓝 (∫ z, g z ∂ν)) := by
+  apply Metric.tendsto_nhds.mpr
+  intro ε hε
+  obtain ⟨f,hfs,herr,hfc,hfi⟩ := hg.exists_hasCompactSupport_integral_sub_le
+    (show 0 < ε/3 by positivity)
+  let φ : C_c(upperHalfPlane,ℝ) := ⟨⟨f,hfc⟩,hfs⟩
+  have hnear := (Metric.tendsto_nhds.mp (terminal_mass_test_tendsto ν N hNr hdom hlim φ))
+    (ε/3) (show 0 < ε/3 by positivity)
+  filter_upwards [hnear] with t ht
+  have ha : dist (∫ z, g z ∂N t) (∫ z, f z ∂N t) ≤ ε/3 :=
+    (integral_test_distance_le_of_domination (N t) ν (hdom t) g f hg hfi).trans herr
+  have hb : dist (∫ z, g z ∂ν) (∫ z, f z ∂ν) ≤ ε/3 :=
+    (integral_test_distance_le_of_domination ν ν le_rfl g f hg hfi).trans herr
+  have h1 := dist_triangle (∫ z, g z ∂N t) (∫ z, f z ∂N t) (∫ z, g z ∂ν)
+  have h2 := dist_triangle (∫ z, f z ∂N t) (∫ z, f z ∂ν) (∫ z, g z ∂ν)
+  change dist (∫ z, f z ∂N t) (∫ z, f z ∂ν) < ε/3 at ht
+  rw [dist_comm (∫ z, f z ∂ν) (∫ z, g z ∂ν)] at h2
+  linarith
+
+theorem remaining_integrable_test_tendsto_zero
+    (ν : Measure upperHalfPlane) [ν.Regular]
+    (N : ℝ≥0 → Measure upperHalfPlane) (hNr : ∀ t, (N t).Regular)
+    (hdom : ∀ t, N t ≤ ν)
+    (hlim : ∀ K : Set upperHalfPlane, IsCompact K →
+      Tendsto (fun t : ℝ≥0 => (ν-N t) K) atTop (𝓝 0))
+    (g : upperHalfPlane → ℝ) (hg : Integrable g ν) :
+    Tendsto (fun t : ℝ≥0 => ∫ z, g z ∂(ν-N t)) atTop (𝓝 0) := by
+  have he (t : ℝ≥0) : (∫ z, g z ∂(ν-N t))=(∫ z, g z ∂ν)-(∫ z, g z ∂N t) := by
+    let := hNr t
+    have hi := integral_add_measure (hg.mono_measure (Measure.sub_le : ν-N t ≤ ν))
+      (hg.mono_measure (hdom t))
+    rw [sigmaFinite_sub_add_cancel_of_le (hdom t)] at hi
+    linarith
+  simpa only [he,sub_self] using
+    (tendsto_const_nhds (x := ∫ z, g z ∂ν)).sub
+      (terminal_integrable_test_tendsto ν N hNr hdom hlim g hg)
+
+theorem remaining_lintegral_tendsto_zero
+    (ν : Measure upperHalfPlane) [ν.Regular]
+    (N : ℝ≥0 → Measure upperHalfPlane) (hNr : ∀ t, (N t).Regular)
+    (hdom : ∀ t, N t ≤ ν)
+    (hlim : ∀ K : Set upperHalfPlane, IsCompact K →
+      Tendsto (fun t : ℝ≥0 => (ν-N t) K) atTop (𝓝 0))
+    (g : upperHalfPlane → ℝ≥0∞) (hg : Measurable g) (hfin : ∫⁻ z, g z ∂ν ≠ ∞) :
+    Tendsto (fun t : ℝ≥0 => ∫⁻ z, g z ∂(ν-N t)) atTop (𝓝 0) := by
+  have hreal : Integrable (fun z => (g z).toReal) ν :=
+    integrable_toReal_of_lintegral_ne_top hg.aemeasurable hfin
+  have hfinite : ∀ᵐ z ∂ν, g z ≠ ∞ := (ae_lt_top hg hfin).mono (fun _ h => h.ne)
+  have he (t : ℝ≥0) : ENNReal.ofReal (∫ z, (g z).toReal ∂(ν-N t)) =
+      ∫⁻ z, g z ∂(ν-N t) := by
+    rw [ofReal_integral_eq_lintegral_ofReal (hreal.mono_measure (Measure.sub_le : ν-N t ≤ ν))
+      (ae_of_all _ (fun _ => ENNReal.toReal_nonneg))]
+    apply lintegral_congr_ae
+    filter_upwards [ae_mono (Measure.sub_le : ν-N t ≤ ν) hfinite] with z hz
+    exact ENNReal.ofReal_toReal hz
+  have h := ENNReal.continuous_ofReal.continuousAt.tendsto.comp
+    (remaining_integrable_test_tendsto_zero ν N hNr hdom hlim _ hreal)
+  simpa only [Function.comp_def,he,ENNReal.ofReal_zero] using h
+
+end SLEExactGauge
+
+end
+
+end OAI
diff --git a/lean/OAI/Probability/SLE/Mass/GreenMassProcessUniqueness.lean b/lean/OAI/Probability/SLE/Mass/GreenMassProcessUniqueness.lean
new file mode 100644
index 0000000000000000000000000000000000000000..45f01fb06ca430caaf490405d713cc91c70773ec
--- /dev/null
+++ b/lean/OAI/Probability/SLE/Mass/GreenMassProcessUniqueness.lean
@@ -0,0 +1,94 @@
+import OAI.Probability.SLE.Geometry.PositiveKernelTests
+import OAI.Probability.SLE.Loewner.StoppedInversePaths
+import OAI.Probability.SLE.Mass.RadonProcessAEUniqueness
+
+namespace OAI
+
+/-! The uniqueness step used to compare canonical mass with its spatial
+and temporal dilation. Only the positive compact tests of the two Green
+remainder kernels are required. -/
+
+noncomputable section
+open Set Filter _root_.MeasureTheory _root_.OAI.MeasureTheory ProbabilityTheory
+open scoped Topology NNReal ENNReal CompactlySupported
+
+namespace SLEExactGauge.Multipoint
+
+local instance greenMassUniqueLocallyCompact : LocallyCompactSpace upperHalfPlane := isOpen_upperHalfPlane.locallyCompactSpace
+
+variable {Ω : Type*} [mΩ : MeasurableSpace Ω] {P : Measure Ω} [IsProbabilityMeasure P]
+  {κ : ℝ} {ℱ : Filtration ℝ≥0 mΩ}
+
+omit [IsProbabilityMeasure P] in
+lemma restricted_kernel_mean_le
+    (μ : Ω → Measure upperHalfPlane) (hm : Measurable μ)
+    (hb : P.bind μ ≤ initialGreenMeasure κ) (E : Set Ω) :
+    (P.restrict E).bind μ ≤ initialGreenMeasure κ :=
+  (restricted_bind_le_of_ae_le P μ μ hm hm (ae_of_all _ (fun _ => le_rfl)) E).trans hb
+
+lemma positive_mass_process_eq_of_cross_kernel
+    (A B : ℝ≥0 → Ω → Measure upperHalfPlane) (ZA ZB : Ω → Measure upperHalfPlane)
+    (hA : Adapted ℱ A) (hB : Adapted ℱ B) (hZA : Measurable ZA) (hZB : Measurable ZB)
+    (hAb : ∀ t, P.bind (A t) ≤ initialGreenMeasure κ)
+    (hBb : ∀ t, P.bind (B t) ≤ initialGreenMeasure κ)
+    (hZAb : P.bind ZA ≤ initialGreenMeasure κ) (hZBb : P.bind ZB ≤ initialGreenMeasure κ)
+    (hpA : ∀ᵐ ω ∂P, PositiveMassPaths (fun t => A t ω) (ZA ω))
+    (hpB : ∀ᵐ ω ∂P, PositiveMassPaths (fun t => B t ω) (ZB ω))
+    (hcross : ∀ t E, MeasurableSet[ℱ t] E →
+      (P.restrict E).bind ZA+(P.restrict E).bind (B t)=
+        (P.restrict E).bind ZB+(P.restrict E).bind (A t)) :
+    ∀ᵐ ω ∂P, ∀ t, A t ω=B t ω := by
+  apply random_radon_process_eq_of_positive_tests_ae P (localTestFamily upperHalfPlane) A B
+    (hpA.mono (fun _ h => fun t => (h.radon t).1))
+    (hpB.mono (fun _ h => fun t => (h.radon t).1))
+  intro f hf
+  have hAm (t : ℝ≥0) := hA.measurable (i:=t)
+  have hBm (t : ℝ≥0) := hB.measurable (i:=t)
+  have hAI (t : ℝ≥0) := positive_kernel_test_integrable P κ (A t) (hAm t) (hAb t) f hf
+  have hBI (t : ℝ≥0) := positive_kernel_test_integrable P κ (B t) (hBm t) (hBb t) f hf
+  have hZAI := positive_kernel_test_integrable P κ ZA hZA hZAb f hf
+  have hZBI := positive_kernel_test_integrable P κ ZB hZB hZBb f hf
+  have hAA : StronglyAdapted ℱ (fun t ω => ∫ z, f z ∂A t ω) := fun t =>
+    (@positive_test_integral_measurable Ω (ℱ t) (A t) (hA t) f hf).stronglyMeasurable
+  have hBA : StronglyAdapted ℱ (fun t ω => ∫ z, f z ∂B t ω) := fun t =>
+    (@positive_test_integral_measurable Ω (ℱ t) (B t) (hB t) f hf).stronglyMeasurable
+  apply increasing_mass_unique_of_terminal_mean
+    (fun t ω => ∫ z, f z ∂A t ω) (fun t ω => ∫ z, f z ∂B t ω)
+    (fun ω => (∫ z, f z ∂ZA ω)-(∫ z, f z ∂ZB ω)) (hZAI.sub hZBI)
+    hAA hBA hAI hBI
+  · intro t E hE
+    let : IsFiniteMeasureOnCompacts (initialGreenMeasure κ) := initialGreenMeasure_finite_on_compacts κ
+    have ha := restricted_kernel_mean_le (A t) (hAm t) (hAb t) E
+    have hb := restricted_kernel_mean_le (B t) (hBm t) (hBb t) E
+    have hza := restricted_kernel_mean_le ZA hZA hZAb E
+    have hzb := restricted_kernel_mean_le ZB hZB hZBb E
+    have h := congrArg (fun μ : Measure upperHalfPlane => ∫ z, f z ∂μ) (hcross t E hE)
+    rw [integral_add_measure (f.integrable.mono_measure hza) (f.integrable.mono_measure hb),
+      integral_add_measure (f.integrable.mono_measure hzb) (f.integrable.mono_measure ha),
+      ← positive_kernel_integral_bind (P.restrict E) κ ZA hZA hza f hf,
+      ← positive_kernel_integral_bind (P.restrict E) κ (B t) (hBm t) hb f hf,
+      ← positive_kernel_integral_bind (P.restrict E) κ ZB hZB hzb f hf,
+      ← positive_kernel_integral_bind (P.restrict E) κ (A t) (hAm t) ha f hf] at h
+    rw [integral_sub (hAI t).integrableOn (hBI t).integrableOn,
+      integral_sub hZAI.integrableOn hZBI.integrableOn]
+    linarith
+  · filter_upwards [hpA] with ω hp
+    intro s t hst
+    let := (hp.radon t).1
+    exact integral_mono_measure (hp.monotone hst) (ae_of_all _ hf) f.integrable
+  · filter_upwards [hpB] with ω hp
+    intro s t hst
+    let := (hp.radon t).1
+    exact integral_mono_measure (hp.monotone hst) (ae_of_all _ hf) f.integrable
+  · filter_upwards [hpA] with ω hp
+    simp only [hp.zero,integral_zero_measure,Pi.zero_apply]
+  · filter_upwards [hpB] with ω hp
+    simp only [hp.zero,integral_zero_measure,Pi.zero_apply]
+  · filter_upwards [hpA,hpB] with ω ha hb
+    exact (ha.continuous_tests f hf).sub (hb.continuous_tests f hf)
+
+end SLEExactGauge.Multipoint
+
+end
+
+end OAI
diff --git a/lean/OAI/Probability/SLE/Mass/GreenMeasureSupport.lean b/lean/OAI/Probability/SLE/Mass/GreenMeasureSupport.lean
new file mode 100644
index 0000000000000000000000000000000000000000..7e12bf24f68b18d1d9afb9f254aa835a90fb24d4
--- /dev/null
+++ b/lean/OAI/Probability/SLE/Mass/GreenMeasureSupport.lean
@@ -0,0 +1,71 @@
+import OAI.Probability.SLE.Mass.LevelCurrentLimit
+import OAI.Probability.SLE.Mass.RadonTestFamily
+import OAI.Probability.SLE.Geometry.SpatialPastKernels
+
+namespace OAI
+
+/-! The actual killed Green measure vanishes off the surviving domain and
+is almost surely locally finite, as follows from its initial-Green mean bound. -/
+
+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_off_surviving
+    {Ω : Type*} {B : ℝ≥0 → Ω → ℝ} {κ : ℝ}
+    {γ : Ω → ℝ≥0 → ℂ} {G F : Ω → ℝ≥0 → ℂ → ℂ}
+    (ω : Ω) (hw : IsCapacityTwoWitness (fun s => Real.sqrt κ * B s ω) (γ ω) (G ω) (F ω))
+    (t : ℝ≥0) :
+    halfPlaneGreenMeasure κ B γ G t ω {z : upperHalfPlane | (z : ℂ) ∉ survivingDomain (γ ω) t} = 0 := by
+  have hA : MeasurableSet {z : upperHalfPlane | (z : ℂ) ∉ survivingDomain (γ ω) t} :=
+    ((isOpen_survivingDomain hw.1 t).preimage continuous_subtype_val).measurableSet.compl
+  have hAI := (MeasurableEmbedding.subtype_coe isOpen_upperHalfPlane.measurableSet).measurableSet_image.mpr hA
+  rw [halfPlaneGreenMeasure,comap_subtype_coe_apply isOpen_upperHalfPlane.measurableSet,
+    withDensity_apply _ hAI]
+  apply setLIntegral_eq_zero hAI
+  rintro z ⟨x,hx,rfl⟩
+  simp only [greenDensity,ite_eq_right hx,ENNReal.ofReal_zero,Pi.zero_apply]
+
+lemma ae_halfPlaneGreenMeasure_compact_finite
+    {Ω : Type*} [MeasurableSpace Ω] {P : Measure Ω}
+    {B : ℝ≥0 → Ω → ℝ} (hB : IsBrownianReal B P)
+    (hBm : Measurable (Function.uncurry B)) (hBc : ∀ ω, Continuous (fun t => B t ω))
+    (hB0 : ∀ ω, B 0 ω = 0) {κ : ℝ} (hκ : 0 < κ) (hκ8 : κ < 8)
+    (γ : Ω → ℝ≥0 → ℂ) (G F : Ω → ℝ≥0 → ℂ → ℂ)
+    (hw : ∀ ω, IsCapacityTwoWitness (fun t => Real.sqrt κ * B t ω) (γ ω) (G ω) (F ω))
+    (t : ℝ≥0) (K : Set upperHalfPlane) (hK : IsCompact K) :
+    ∀ᵐ ω ∂P, halfPlaneGreenMeasure κ B γ G t ω K < ⊤ := by
+  let : IsFiniteMeasureOnCompacts (initialGreenMeasure κ) := initialGreenMeasure_finite_on_compacts κ
+  have hb := halfPlaneGreenMeasure_mean_le hB hBm hBc hB0 hκ hκ8 γ G F hw t univ K
+  rw [Measure.restrict_univ,Measure.bind_apply hK.measurableSet
+    (halfPlaneGreenMeasure_measurable hBm hBc κ γ G F hw t).aemeasurable] at hb
+  exact ae_lt_top ((Measure.measurable_coe hK.measurableSet).comp
+    (halfPlaneGreenMeasure_measurable hBm hBc κ γ G F hw t))
+    (lt_of_le_of_lt hb hK.measure_lt_top).ne
+
+theorem ae_halfPlaneGreenMeasure_finite_on_compacts
+    {Ω : Type*} [MeasurableSpace Ω] {P : Measure Ω}
+    {B : ℝ≥0 → Ω → ℝ} (hB : IsBrownianReal B P)
+    (hBm : Measurable (Function.uncurry B)) (hBc : ∀ ω, Continuous (fun t => B t ω))
+    (hB0 : ∀ ω, B 0 ω = 0) {κ : ℝ} (hκ : 0 < κ) (hκ8 : κ < 8)
+    (γ : Ω → ℝ≥0 → ℂ) (G F : Ω → ℝ≥0 → ℂ → ℂ)
+    (hw : ∀ ω, IsCapacityTwoWitness (fun t => Real.sqrt κ * B t ω) (γ ω) (G ω) (F ω))
+    (t : ℝ≥0) : ∀ᵐ ω ∂P, IsFiniteMeasureOnCompacts (halfPlaneGreenMeasure κ B γ G t ω) := by
+  let D := localTestFamily upperHalfPlane
+  have ha (n : ℕ) := ae_halfPlaneGreenMeasure_compact_finite hB hBm hBc hB0 hκ hκ8 γ G F hw
+    t (D.compactSet n) (D.isCompact n)
+  filter_upwards [ae_all_iff.mpr ha] with ω hω
+  constructor
+  intro K hK
+  obtain ⟨n,hn⟩ := D.exhaustive K hK
+  exact lt_of_le_of_lt (measure_mono hn) (hω n)
+
+end SLEExactGauge.Multipoint
+
+end
+
+end OAI
diff --git a/lean/OAI/Probability/SLE/Mass/GridMassOverlap.lean b/lean/OAI/Probability/SLE/Mass/GridMassOverlap.lean
new file mode 100644
index 0000000000000000000000000000000000000000..620669f8ce45f8be7b37026552cbd646b9811eb6
--- /dev/null
+++ b/lean/OAI/Probability/SLE/Mass/GridMassOverlap.lean
@@ -0,0 +1,57 @@
+import OAI.Probability.SLE.Mass.MassGridOverlap
+
+namespace OAI
+
+/-! Summing physical grid-cell masses costs only the fixed overlap constant,
+independently of the radius and of the containing compact set. -/
+
+noncomputable section
+open Set Filter MeasureTheory Metric
+open scoped Topology NNReal ENNReal
+
+namespace SLEExactGauge
+
+lemma grid_indicator_sum_le {r : ℝ} (hr : 0 < r) (x : ℂ) :
+    (∑' i : ℤ×ℤ, (closedBall (coverGridCenter r i) (2*r)).indicator (fun _ => (1:ℝ≥0∞)) x) ≤ 81 := by
+  classical
+  rw [ENNReal.tsum_eq_iSup_sum]
+  apply iSup_le
+  intro I
+  let f := fun (i : ℤ×ℤ) (z : ℂ) =>
+    (closedBall (coverGridCenter r i) (2*r)).indicator (fun _ => (1:ℝ≥0∞)) z
+  have hbound : ∀ i z, f i z ≤ 1 := by
+    intro i z
+    by_cases hz : z ∈ closedBall (coverGridCenter r i) (2*r) <;> simp [f,hz]
+  have hs : ∀ i z, f i z ≠ 0 → dist z (coverGridCenter r i) ≤ 3*r := by
+    intro i z hz
+    by_cases hm : z ∈ closedBall (coverGridCenter r i) (2*r)
+    · have hh : dist z (coverGridCenter r i) ≤ 2*r := hm
+      linarith
+    · exact (hz (by simp [f,hm])).elim
+  have hh := massGrid_cutoff_product_sum_le hr I f hbound hs x x
+  have hdist : dist x x ≤ 6*r := by simp; positivity
+  rw [ite_eq_left hdist] at hh
+  have he : (∑ i∈I, f i x*f i x) = ∑ i∈I, f i x := by
+    apply Finset.sum_congr rfl
+    intro i hi
+    by_cases hx : x ∈ closedBall (coverGridCenter r i) (2*r) <;> simp [f,hx]
+  rwa [he] at hh
+
+lemma grid_mass_sum_le (μ : Measure ℂ) {r : ℝ} (hr : 0 < r) :
+    (∑' i : ℤ×ℤ, μ (closedBall (coverGridCenter r i) (2*r))) ≤ 81*μ univ := by
+  calc
+    _ = ∫⁻ x, ∑' i : ℤ×ℤ,
+        (closedBall (coverGridCenter r i) (2*r)).indicator (fun _ => (1:ℝ≥0∞)) x ∂μ := by
+      rw [lintegral_tsum (fun i => (measurable_const.indicator measurableSet_closedBall).aemeasurable)]
+      apply tsum_congr
+      intro i
+      rw [lintegral_indicator measurableSet_closedBall]
+      simp
+    _ ≤ ∫⁻ _x, (81:ℝ≥0∞) ∂μ := lintegral_mono (grid_indicator_sum_le hr)
+    _ = _ := by simp
+
+end SLEExactGauge
+
+end
+
+end OAI
diff --git a/lean/OAI/Probability/SLE/Mass/HalfPlaneHerglotzMass.lean b/lean/OAI/Probability/SLE/Mass/HalfPlaneHerglotzMass.lean
new file mode 100644
index 0000000000000000000000000000000000000000..0a24f5c69d95c63bff1c2a522a9311e3ac29a8c2
--- /dev/null
+++ b/lean/OAI/Probability/SLE/Mass/HalfPlaneHerglotzMass.lean
@@ -0,0 +1,68 @@
+import OAI.Probability.SLE.Loewner.HydrodynamicComposition
+
+namespace OAI
+
+/-! The Schwarz–Pick bound for a half-plane map vanishing at infinity.
+Only the total mass coefficient is used; no representation theorem is assumed. -/
+noncomputable section
+open Set Filter Complex Function Metric
+open scoped Topology ComplexConjugate
+
+namespace SLEExactGauge
+
+lemma halfPlane_schwarz_pick_vanishing_scaled {f : ℂ → ℂ}
+    (hf : DifferentiableOn ℂ f upperHalfPlane) (hm : MapsTo f upperHalfPlane upperHalfPlane)
+    {z : ℂ} (hz : z ∈ upperHalfPlane) {y : ℝ} (hy : 0<y) :
+    z.im*normSq (f z-conj (f ((y:ℂ)*I))) ≤
+      (f z).im*(y*(f ((y:ℂ)*I)).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 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 [h2,normSq_div_real]
+  have hi : ((y:ℂ)*I).im=y := by simp
+  rw [hi] at hh
+  apply (mul_le_mul_iff_of_pos_right hy).mp
+  field_simp
+  nlinarith [hh]
+
+theorem halfPlane_vanishing_mass_bound {f : ℂ → ℂ}
+    (hf : DifferentiableOn ℂ f upperHalfPlane) (hm : MapsTo f upperHalfPlane upperHalfPlane)
+    {c : ℝ} (hzero : Tendsto (fun n : ℕ => f (verticalInfinity n)) atTop (𝓝 0))
+    (hc : Tendsto (fun n : ℕ => ((n:ℝ)+1)*(f (verticalInfinity n)).im) atTop (𝓝 c))
+    {z : ℂ} (hz : z ∈ upperHalfPlane) : z.im*normSq (f z) ≤ c*(f z).im := by
+  have hi := tendsto_inv_atTop_zero.comp verticalHeights_tendsto
+  have hsmall : Tendsto (fun n : ℕ => z/(((n:ℝ)+1:ℝ):ℂ)) atTop (𝓝 0) := by
+    have hh := (tendsto_const_nhds (x := z) (f := atTop)).mul
+      (Complex.continuous_ofReal.continuousAt.tendsto.comp hi)
+    simpa only [Function.comp_apply,ofReal_zero,mul_zero,ofReal_inv,div_eq_mul_inv] using hh
+  have hleft := (tendsto_const_nhds (x := z.im) (f := atTop)).mul
+    (continuous_normSq.tendsto (f z-conj 0) |>.comp
+      ((tendsto_const_nhds (x := f z) (f := atTop)).sub
+        (Complex.continuous_conj.tendsto 0 |>.comp hzero)))
+  have hright := ((tendsto_const_nhds (x := (f z).im) (f := atTop)).mul hc).mul
+    (continuous_normSq.tendsto ((0:ℂ)+I) |>.comp (hsmall.add_const I))
+  have hh := le_of_tendsto_of_tendsto hleft hright
+    (Eventually.of_forall (fun n => halfPlane_schwarz_pick_vanishing_scaled hf hm hz
+      (by positivity : 0<(n:ℝ)+1)))
+  simpa only [map_zero,sub_zero,zero_add,normSq_I,mul_one,mul_comm] using hh
+
+lemma norm_le_mass_div_height {w : ℂ} {c y : ℝ} (hy : 0<y) (hc : 0≤c)
+    (hb : y*normSq w ≤ c*w.im) : ‖w‖ ≤ c/y := by
+  by_cases hw : w=0
+  · subst w
+    simpa only [norm_zero] using div_nonneg hc hy.le
+  have hnorm : 0<‖w‖ := norm_pos_iff.mpr hw
+  have hi := Complex.im_le_norm w
+  have hh := mul_le_mul_of_nonneg_left hi hc
+  rw [normSq_eq_norm_sq] at hb
+  apply (le_div_iff₀ hy).mpr
+  nlinarith
+
+end SLEExactGauge
+
+end
+
+end OAI
diff --git a/lean/OAI/Probability/SLE/Mass/HalfPlaneLevelMeasures.lean b/lean/OAI/Probability/SLE/Mass/HalfPlaneLevelMeasures.lean
new file mode 100644
index 0000000000000000000000000000000000000000..b2cf8d421a5e4c6f80db8fa37193ac24631efa4a
--- /dev/null
+++ b/lean/OAI/Probability/SLE/Mass/HalfPlaneLevelMeasures.lean
@@ -0,0 +1,114 @@
+import OAI.Probability.SLE.Mass.SignedLevelTests
+
+namespace OAI
+
+/-! The finite-level approximants as locally finite measures on the open
+half-plane, and their signed compact tests viewed on the ambient plane. -/
+
+noncomputable section
+open Set Filter MeasureTheory ProbabilityTheory Classical
+open scoped NNReal ENNReal Topology CompactlySupported
+
+namespace SLEExactGauge.Multipoint
+
+lemma levelMass_lt_top_of_compact
+    {Ω : Type*} {B : ℝ≥0 → Ω → ℝ} {κ : ℝ} (hκ : 0 < κ) (hκ8 : κ < 8)
+    (γ : Ω → ℝ≥0 → ℂ) (G F : Ω → ℝ≥0 → ℂ → ℂ)
+    (ω : Ω) (hBc : Continuous (fun t => B t ω))
+    (hw : IsCapacityTwoWitness (fun t => Real.sqrt κ * B t ω) (γ ω) (G ω) (F ω))
+    (K : Set ℂ) (hK : IsCompact K) (hKH : K ⊆ upperHalfPlane) (u : ℝ) :
+    levelMass κ B γ G u K ω < ⊤ := by
+  obtain ⟨b,hb,hbK⟩ := compact_positive_radius_cap hK hKH
+  let C := (b * Real.exp (-u)) ^ (-codimension κ)
+  have hW (z : ℂ) (hz : z ∈ K) : stoppedGreen κ (fun t => Real.sqrt κ * B t ω)
+      (γ ω) (G ω) z u ≤ C := by
+    have he : 0 < 2*z.im*Real.exp (-u) := mul_pos (mul_pos (by norm_num) (hKH hz)) (Real.exp_pos _)
+    have hs := stoppedGreen_level_bound (hBc.const_mul _) hw hκ hκ8 z (hKH hz)
+      (2*z.im*Real.exp (-u)) he
+    rw [common_level_log_target z (hKH hz) u] at hs
+    exact hs.trans (Real.rpow_le_rpow_of_nonpos (mul_pos hb (Real.exp_pos _))
+      (mul_le_mul_of_nonneg_right (hbK z hz) (Real.exp_pos _).le)
+      (neg_nonpos.mpr (codimension_pos κ hκ8).le))
+  have hbound : levelMass κ B γ G u K ω ≤ ENNReal.ofReal C * volume K := by
+    apply (setLIntegral_mono' hK.measurableSet (fun z hz => ENNReal.ofReal_le_ofReal (hW z hz))).trans_eq
+    exact setLIntegral_const K (ENNReal.ofReal C)
+  exact hbound.trans_lt (ENNReal.mul_lt_top ENNReal.ofReal_lt_top hK.measure_lt_top)
+
+def halfPlaneLevelMeasure {Ω : Type*} (κ : ℝ) (B : ℝ≥0 → Ω → ℝ)
+    (γ : Ω → ℝ≥0 → ℂ) (G : Ω → ℝ≥0 → ℂ → ℂ)
+    (u : ℝ) (t : ℝ≥0∞) (ω : Ω) : Measure upperHalfPlane :=
+  (levelApproximation κ B γ G u t ω).comap Subtype.val
+
+theorem halfPlaneLevelMeasure_finite_on_compacts
+    {Ω : Type*} {B : ℝ≥0 → Ω → ℝ} {κ : ℝ} (hκ : 0 < κ) (hκ8 : κ < 8)
+    (γ : Ω → ℝ≥0 → ℂ) (G F : Ω → ℝ≥0 → ℂ → ℂ)
+    (ω : Ω) (hBc : Continuous (fun t => B t ω))
+    (hw : IsCapacityTwoWitness (fun t => Real.sqrt κ * B t ω) (γ ω) (G ω) (F ω))
+    (u : ℝ) (t : ℝ≥0∞) : IsFiniteMeasureOnCompacts (halfPlaneLevelMeasure κ B γ G u t ω) := by
+  constructor
+  intro K hK
+  have hKI : IsCompact ((Subtype.val : upperHalfPlane → ℂ) '' K) := hK.image continuous_subtype_val
+  have hKH : (Subtype.val : upperHalfPlane → ℂ) '' K ⊆ upperHalfPlane := by
+    rintro _ ⟨x,_,rfl⟩
+    exact x.property
+  rw [halfPlaneLevelMeasure,comap_subtype_coe_apply isOpen_upperHalfPlane.measurableSet]
+  exact (levelApproximation_apply_le κ B γ G u t ω hKI.measurableSet).trans_lt
+    (levelMass_lt_top_of_compact hκ hκ8 γ G F ω hBc hw _ hKI hKH u)
+
+def extendHalfPlaneTest (f : upperHalfPlane → ℝ) : ℂ → ℝ :=
+  Function.extend (Subtype.val : upperHalfPlane → ℂ) f (fun _ => 0)
+
+lemma extendHalfPlaneTest_apply (f : upperHalfPlane → ℝ) (x : upperHalfPlane) :
+    extendHalfPlaneTest f x = f x := Subtype.val_injective.extend_apply _ _ _
+
+lemma extendHalfPlaneTest_of_not_mem (f : upperHalfPlane → ℝ) (z : ℂ) (hz : z ∉ upperHalfPlane) :
+    extendHalfPlaneTest f z = 0 := by
+  apply Function.extend_apply'
+  rintro ⟨x,rfl⟩
+  exact hz x.property
+
+lemma extendHalfPlaneTest_measurable (f : upperHalfPlane → ℝ) (hf : Measurable f) :
+    Measurable (extendHalfPlaneTest f) :=
+  (MeasurableEmbedding.subtype_coe isOpen_upperHalfPlane.measurableSet).measurable_extend hf measurable_const
+
+lemma extendHalfPlaneTest_support (f : C_c(upperHalfPlane,ℝ)) (z : ℂ)
+    (hz : z ∉ (Subtype.val : upperHalfPlane → ℂ) '' tsupport f) : extendHalfPlaneTest f z = 0 := by
+  by_cases hH : z ∈ upperHalfPlane
+  · let x : upperHalfPlane := ⟨z,hH⟩
+    change extendHalfPlaneTest f x = 0
+    rw [extendHalfPlaneTest_apply]
+    exact image_eq_zero_of_notMem_tsupport (fun hx => hz ⟨x,hx,rfl⟩)
+  · exact extendHalfPlaneTest_of_not_mem f z hH
+
+lemma extendHalfPlaneTest_norm_le (f : C_c(upperHalfPlane,ℝ)) (z : ℂ) :
+    ‖extendHalfPlaneTest f z‖ ≤ ‖f.toBoundedContinuousFunction‖ := by
+  by_cases hH : z ∈ upperHalfPlane
+  · let x : upperHalfPlane := ⟨z,hH⟩
+    change ‖extendHalfPlaneTest f x‖ ≤ _
+    rw [extendHalfPlaneTest_apply]
+    exact f.toBoundedContinuousFunction.norm_coe_le_norm x
+  · rw [extendHalfPlaneTest_of_not_mem f z hH,norm_zero]
+    exact norm_nonneg _
+
+lemma integral_halfPlaneLevelMeasure
+    {Ω : Type*} (κ : ℝ) (B : ℝ≥0 → Ω → ℝ)
+    (γ : Ω → ℝ≥0 → ℂ) (G : Ω → ℝ≥0 → ℂ → ℂ)
+    (u : ℝ) (t : ℝ≥0∞) (ω : Ω) (f : upperHalfPlane → ℝ) :
+    (∫ x, f x ∂halfPlaneLevelMeasure κ B γ G u t ω) =
+      levelApproximationRealTest κ B γ G u t (extendHalfPlaneTest f) ω := by
+  change (∫ x : upperHalfPlane, f x ∂(levelApproximation κ B γ G u t ω).comap Subtype.val) = _
+  calc
+    _ = ∫ x : upperHalfPlane, extendHalfPlaneTest f x
+        ∂(levelApproximation κ B γ G u t ω).comap Subtype.val := by
+      congr 1
+      funext x
+      exact (extendHalfPlaneTest_apply f x).symm
+    _ = ∫ z in upperHalfPlane, extendHalfPlaneTest f z ∂levelApproximation κ B γ G u t ω :=
+      integral_subtype_comap isOpen_upperHalfPlane.measurableSet _
+    _ = _ := setIntegral_eq_integral_of_forall_compl_eq_zero (extendHalfPlaneTest_of_not_mem f)
+
+end SLEExactGauge.Multipoint
+
+end
+
+end OAI
diff --git a/lean/OAI/Probability/SLE/Mass/HalfPlaneZeroMass.lean b/lean/OAI/Probability/SLE/Mass/HalfPlaneZeroMass.lean
new file mode 100644
index 0000000000000000000000000000000000000000..cfb3cf8d3cb45f6b43e99b2cb6cebd75c66ffbd7
--- /dev/null
+++ b/lean/OAI/Probability/SLE/Mass/HalfPlaneZeroMass.lean
@@ -0,0 +1,89 @@
+import OAI.Probability.SLE.Mass.HalfPlaneHerglotzMass
+import Mathlib.Analysis.Complex.OpenMapping
+
+namespace OAI
+
+/-! A holomorphic map with nonnegative imaginary part, vanishing value
+and zero mass at infinity is identically zero. -/
+noncomputable section
+open Set Filter Complex Function Metric
+open scoped Topology
+
+namespace SLEExactGauge
+
+lemma holomorphic_nonnegative_im_dichotomy {f : ℂ → ℂ}
+    (hf : DifferentiableOn ℂ f upperHalfPlane)
+    (hm : ∀ z ∈ upperHalfPlane, 0≤(f z).im) :
+    (∃ c : ℂ, ∀ z ∈ upperHalfPlane, f z=c) ∨ MapsTo f upperHalfPlane upperHalfPlane := by
+  rcases (hf.analyticOnNhd isOpen_upperHalfPlane).is_constant_or_isOpen
+    (convex_halfSpace_im_gt (0:ℝ)).isPreconnected with hc|ho
+  · exact Or.inl hc
+  right
+  intro z hz
+  change 0 < (f z).im
+  by_contra hn
+  have hzero : (f z).im=0 := le_antisymm (le_of_not_gt hn) (hm z hz)
+  have hi := (ho upperHalfPlane Subset.rfl isOpen_upperHalfPlane).mem_nhds
+    (mem_image_of_mem f hz)
+  obtain ⟨ε,hε,hball⟩ := Metric.mem_nhds_iff.mp hi
+  have hw : f z-((ε/2:ℝ):ℂ)*I ∈ ball (f z) ε := by
+    rw [mem_ball,dist_eq_norm,sub_sub_cancel_left,norm_neg,norm_mul,norm_I,mul_one,
+      Complex.norm_real,Real.norm_eq_abs,abs_of_pos (half_pos hε)]
+    linarith
+  obtain ⟨w,hwH,he⟩ := hball hw
+  have him := hm w hwH
+  rw [he] at him
+  simp only [sub_im,mul_im,ofReal_re,I_im,mul_one,ofReal_im,I_re,mul_zero,add_zero,hzero] at him
+  linarith
+
+theorem halfPlane_zero_mass_eq_zero {f : ℂ → ℂ}
+    (hf : DifferentiableOn ℂ f upperHalfPlane)
+    (hm : ∀ z ∈ upperHalfPlane, 0≤(f z).im)
+    (hzero : Tendsto (fun n : ℕ => f (verticalInfinity n)) atTop (𝓝 0))
+    (hc : Tendsto (fun n : ℕ => ((n:ℝ)+1)*(f (verticalInfinity n)).im) atTop (𝓝 0)) :
+    ∀ z ∈ upperHalfPlane, f z=0 := by
+  rcases holomorphic_nonnegative_im_dichotomy hf hm with ⟨c,hc'⟩|hpos
+  · have ht : Tendsto (fun _ : ℕ => c) atTop (𝓝 0) := by
+      apply hzero.congr
+      intro n
+      exact hc' _ (verticalInfinity_mem n)
+    have he : c=0 := tendsto_nhds_unique tendsto_const_nhds ht
+    exact fun z hz => (hc' z hz).trans he
+  · have hi : I ∈ upperHalfPlane := by simp [upperHalfPlane]
+    have hb := halfPlane_vanishing_mass_bound hf hpos hzero hc hi
+    simp only [I_im,one_mul,zero_mul] at hb
+    have he : f I=0 := normSq_eq_zero.mp (le_antisymm hb (normSq_nonneg _))
+    have hp := hpos hi
+    simp only [upperHalfPlane,mem_ofPred_eq,he,zero_im,lt_self_iff_false] at hp
+
+theorem holomorphic_zero_hydrodynamic_mass {f : ℂ → ℂ}
+    (hf : DifferentiableOn ℂ f upperHalfPlane)
+    (hm : ∀ z ∈ upperHalfPlane, 0≤(f z).im)
+    (hcoef : Tendsto (fun z : ℂ => z*f z) (cocompact ℂ ⊓ 𝓟 upperHalfPlane) (𝓝 0)) :
+    ∀ z ∈ upperHalfPlane, f z=0 := by
+  have hp := hcoef.comp verticalInfinity_tendsto
+  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))
+  have hh := hp.mul (hi.comp (verticalInfinity_tendsto.mono_right inf_le_left))
+  have hzero : Tendsto (fun n : ℕ => f (verticalInfinity n)) atTop (𝓝 0) := by
+    simp only [mul_zero] at hh
+    apply hh.congr
+    intro n
+    have hn : verticalInfinity n ≠ 0 := by
+      intro he
+      have hv := verticalInfinity_mem n
+      simp only [upperHalfPlane,mem_ofPred_eq,he,zero_im,lt_self_iff_false] at hv
+    simp only [Function.comp_apply]
+    field_simp
+  have hmass : Tendsto (fun n : ℕ => ((n:ℝ)+1)*(f (verticalInfinity n)).im) atTop (𝓝 0) := by
+    have ht := (Complex.continuous_re.tendsto (0:ℂ) |>.comp hp).neg
+    simpa only [Function.comp_apply,verticalInfinity,mul_re,mul_im,ofReal_re,ofReal_im,
+      I_re,I_im,mul_zero,zero_mul,add_zero,mul_one,zero_re,neg_zero,zero_sub,neg_neg] using ht
+  exact halfPlane_zero_mass_eq_zero hf hm hzero hmass
+
+end SLEExactGauge
+
+end
+
+end OAI
diff --git a/lean/OAI/Probability/SLE/Mass/HilbertConvexTails.lean b/lean/OAI/Probability/SLE/Mass/HilbertConvexTails.lean
new file mode 100644
index 0000000000000000000000000000000000000000..3175a678366ccc134dbad4097d89412418a475b6
--- /dev/null
+++ b/lean/OAI/Probability/SLE/Mass/HilbertConvexTails.lean
@@ -0,0 +1,125 @@
+import Mathlib.Analysis.InnerProductSpace.Projection.Minimal
+import Mathlib.Analysis.Convex.Combination
+import Mathlib.Analysis.Convex.Topology
+import Mathlib.Analysis.Normed.Module.Convex
+import Mathlib.Topology.Order.MonotoneConvergence
+
+namespace OAI
+
+/-! Deterministic convex extraction in a Hilbert space. Nested closed
+convex tail hulls have a common point, and finite convex combinations
+of the original tails converge to that point. -/
+
+noncomputable section
+open Set Filter Metric
+open scoped Topology
+
+namespace SLEExactGauge
+
+variable {E : Type*} [NormedAddCommGroup E] [InnerProductSpace ℝ E] [CompleteSpace E]
+
+lemma nested_closed_convex_intersection (K : ℕ → Set E)
+    (hne : ∀ n, (K n).Nonempty) (hclosed : ∀ n, IsClosed (K n))
+    (hconvex : ∀ n, Convex ℝ (K n)) (hanti : Antitone K)
+    (B : ℝ) (hbound : ∀ n x, x ∈ K n → ‖x‖ ≤ B) :
+    ∃ x, ∀ n, x ∈ K n := by
+  have hex (n : ℕ) := exists_norm_eq_iInf_of_complete_convex (hne n)
+    (hclosed n).isComplete (hconvex n) (0 : E)
+  choose p hp hmin using hex
+  have hleast (n : ℕ) (w : E) (hw : w ∈ K n) : ‖p n‖ ≤ ‖w‖ := by
+    have hm : ‖p n‖ = ⨅ v : K n, ‖(v : E)‖ := by simpa only [zero_sub,norm_neg] using hmin n
+    rw [hm]
+    exact ciInf_le (show BddBelow (range (fun v : K n => ‖(v : E)‖)) from
+      ⟨0,by rintro y ⟨v,rfl⟩; exact norm_nonneg _⟩) (⟨w,hw⟩ : K n)
+  have hnormmono : Monotone (fun n => ‖p n‖^2) := by
+    intro n m hnm
+    exact pow_le_pow_left₀ (norm_nonneg _) (hleast n (p m) (hanti hnm (hp m))) 2
+  have hnormbdd : BddAbove (range (fun n => ‖p n‖^2)) := by
+    refine ⟨B^2,?_⟩
+    rintro _ ⟨n,rfl⟩
+    exact pow_le_pow_left₀ (norm_nonneg _) (hbound n (p n) (hp n)) 2
+  have hsquare : CauchySeq (fun n => ‖p n‖^2) :=
+    (tendsto_atTop_ciSup hnormmono hnormbdd).cauchySeq
+  have hdist (n m : ℕ) (hnm : n ≤ m) :
+      dist (p m) (p n)^2 ≤ ‖p m‖^2-‖p n‖^2 := by
+    have hproj := (norm_eq_iInf_iff_real_inner_le_zero (hconvex n) (hp n)).mp
+      (hmin n) (p m) (hanti hnm (hp m))
+    simp only [zero_sub,inner_neg_left,inner_sub_right,
+      real_inner_self_eq_norm_sq] at hproj
+    rw [dist_eq_norm,norm_sub_sq_real,real_inner_comm]
+    linarith
+  have hcauchy : CauchySeq p := by
+    apply Metric.cauchySeq_iff'.mpr
+    intro ε hε
+    obtain ⟨N,hN⟩ := Metric.cauchySeq_iff.mp hsquare (ε^2) (sq_pos_of_pos hε)
+    refine ⟨N,fun n hn => ?_⟩
+    have hh := hN n hn N le_rfl
+    rw [Real.dist_eq,abs_of_nonneg (sub_nonneg.mpr (hnormmono hn))] at hh
+    have hsq := hdist N n hn
+    nlinarith [dist_nonneg (x := p n) (y := p N)]
+  obtain ⟨x,hx⟩ := cauchySeq_tendsto_of_complete hcauchy
+  refine ⟨x,fun n => ?_⟩
+  apply (hclosed n).mem_of_tendsto hx
+  filter_upwards [eventually_ge_atTop n] with m hm
+  exact hanti hm (hp m)
+
+/-- The combinations use indices `n+i`, so every term is in the `n`-th
+original tail. No weak-convergence or separability hypothesis is needed. -/
+theorem exists_convex_tail_combinations (u : ℕ → E)
+    (B : ℝ) (hB : ∀ n, ‖u n‖ ≤ B) :
+    ∃ x : E, ∃ s : ℕ → Finset ℕ, ∃ w : ℕ → ℕ → ℝ,
+      (∀ n i, i ∈ s n → 0 ≤ w n i) ∧
+      (∀ n, ∑ i ∈ s n, w n i = 1) ∧
+      (∀ n, dist (∑ i ∈ s n, w n i • u (n+i)) x < (1/2:ℝ)^n) ∧
+      Tendsto (fun n => ∑ i ∈ s n, w n i • u (n+i)) atTop (𝓝 x) := by
+  let K : ℕ → Set E := fun n => closedConvexHull ℝ (range (fun i => u (n+i)))
+  have hne (n : ℕ) : (K n).Nonempty :=
+    ⟨u (n+0),subset_closedConvexHull ⟨0,rfl⟩⟩
+  have hclosed (n : ℕ) : IsClosed (K n) := isClosed_closedConvexHull
+  have hconvex (n : ℕ) : Convex ℝ (K n) := convex_closedConvexHull
+  have hanti : Antitone K := by
+    intro n m hnm
+    apply (closedConvexHull ℝ).monotone
+    rintro _ ⟨i,rfl⟩
+    refine ⟨m-n+i,?_⟩
+    exact congrArg u (by omega)
+  have hbound (n : ℕ) (x : E) (hx : x ∈ K n) : ‖x‖ ≤ B := by
+    have hh : K n ⊆ closedBall 0 B := by
+      apply closedConvexHull_min _ (convex_closedBall 0 B) isClosed_closedBall
+      rintro _ ⟨i,rfl⟩
+      simpa only [mem_closedBall,dist_zero_right] using hB (n+i)
+    simpa only [mem_closedBall,dist_zero_right] using hh hx
+  obtain ⟨x,hx⟩ := nested_closed_convex_intersection K hne hclosed hconvex hanti B hbound
+  have happ (n : ℕ) : ∃ y ∈ convexHull ℝ (range (fun i => u (n+i))),
+      dist y x < (1/2:ℝ)^n := by
+    have hmem : x ∈ closure (convexHull ℝ (range (fun i => u (n+i)))) := by
+      simpa only [K,closedConvexHull_eq_closure_convexHull] using hx n
+    obtain ⟨y,hy,hyx⟩ := Metric.mem_closure_iff.mp hmem ((1/2:ℝ)^n) (by positivity)
+    exact ⟨y,hy,by simpa only [dist_comm] using hyx⟩
+  choose y hy hdist using happ
+  have hcomb (n : ℕ) : ∃ s : Finset ℕ, ∃ w : ℕ → ℝ,
+      (∀ i ∈ s, 0 ≤ w i) ∧ (∑ i ∈ s, w i = 1) ∧
+      (∑ i ∈ s, w i • u (n+i)) = y n := by
+    have hn := hy n
+    rw [convexHull_range_eq_exists_affineCombination] at hn
+    obtain ⟨s,w,hw,hs,hv⟩ := hn
+    refine ⟨s,w,hw,hs,?_⟩
+    simpa only [Finset.affineCombination_eq_linear_combination _ _ _ hs] using hv
+  choose s w hw hs hsum using hcomb
+  refine ⟨x,s,w,hw,hs,?_,?_⟩
+  · intro n
+    simpa only [hsum] using hdist n
+  have hyconv : Tendsto y atTop (𝓝 x) := by
+    apply Metric.tendsto_atTop.mpr
+    intro ε hε
+    have he := ((tendsto_pow_atTop_nhds_zero_of_lt_one (by norm_num : (0:ℝ) ≤ 1/2)
+      (by norm_num : (1/2:ℝ) < 1)).eventually (gt_mem_nhds hε))
+    obtain ⟨N,hN⟩ := eventually_atTop.mp he
+    exact ⟨N,fun n hn => (hdist n).trans (hN n hn)⟩
+  simpa only [hsum] using hyconv
+
+end SLEExactGauge
+
+end
+
+end OAI
diff --git a/lean/OAI/Probability/SLE/Mass/InverseMassDilation.lean b/lean/OAI/Probability/SLE/Mass/InverseMassDilation.lean
new file mode 100644
index 0000000000000000000000000000000000000000..b364699ed7ab252c12a8822ca403a359ede63e5e
--- /dev/null
+++ b/lean/OAI/Probability/SLE/Mass/InverseMassDilation.lean
@@ -0,0 +1,73 @@
+import OAI.Probability.SLE.Mass.PhysicalDiskMass
+import OAI.Probability.SLE.Mass.DilationMass
+
+namespace OAI
+
+/-! Compatibility of the actual inverse restart mass with spatial normalization. -/
+
+noncomputable section
+open Set Filter _root_.MeasureTheory _root_.OAI.MeasureTheory Metric
+open scoped Topology NNReal ENNReal
+
+namespace SLEExactGauge
+open Multipoint
+
+lemma IsCapacityTwoWitness.inverse_mass_dilation
+    {U : ℝ≥0 → ℝ} {γ : ℝ≥0 → ℂ} {G F : ℝ≥0 → ℂ → ℂ}
+    (hw : IsCapacityTwoWitness U γ G F)
+    (κ : ℝ) (hκ : 0 < κ) (t : ℝ≥0) (a : ℝ≥0) (ha : 0 < a)
+    (μ : Measure upperHalfPlane) :
+    weightedImageMass (fun z : upperHalfPlane => F t ((z:ℂ)+(U t:ℂ)))
+      (fun z : upperHalfPlane => ENNReal.ofReal
+        (‖deriv (F t) ((z:ℂ)+(U t:ℂ))‖^dimension κ)) (dilationMass κ a ha μ) =
+    weightedImageMass (fun z : upperHalfPlane => F t ((U t:ℂ)+(a:ℂ)*z))
+      (fun z : upperHalfPlane => ENNReal.ofReal
+        (‖deriv (fun v : ℂ => F t ((U t:ℂ)+(a:ℂ)*v)) z‖^dimension κ)) μ := by
+  let J := fun z : upperHalfPlane => F t ((z:ℂ)+(U t:ℂ))
+  let w := fun z : upperHalfPlane => ENNReal.ofReal
+    (‖deriv (F t) ((z:ℂ)+(U t:ℂ))‖^dimension κ)
+  have hshift (z : upperHalfPlane) : (z:ℂ)+(U t:ℂ) ∈ upperHalfPlane := by
+    simpa only [upperHalfPlane,mem_ofPred_eq,Complex.add_im,Complex.ofReal_im,add_zero]
+      using z.property
+  have hJ : Measurable J :=
+    ((hw.2.2.2.2.1 t).continuousOn.comp_continuous
+      (continuous_subtype_val.add continuous_const) hshift).measurable
+  have hwM : Measurable w := by
+    have hh : w=(fun z : upperHalfPlane => (hw.restartMassWeight t κ hκ z:ℝ≥0∞)) := by
+      funext z
+      rw [← ENNReal.ofReal_coe_nnreal]
+      rfl
+    rw [hh]
+    exact (hw.restartMassWeight t κ hκ).continuous.measurable.coe_nnreal_ennreal
+  change weightedImageMass J w (weightedImageMass (halfPlaneDilation a ha)
+    (fun _ : upperHalfPlane => ENNReal.ofReal ((a:ℝ)^dimension κ)) μ)=_
+  rw [weightedImageMass_comp J hJ w hwM _ (halfPlaneDilation a ha).continuous.measurable _
+    measurable_const]
+  have hmap : J ∘ halfPlaneDilation a ha =
+      (fun z : upperHalfPlane => F t ((U t:ℂ)+(a:ℂ)*z)) := by
+    funext z
+    simp only [Function.comp_apply,J,halfPlaneDilation_apply,add_comm]
+  rw [hmap]
+  congr 1
+  funext z
+  change ENNReal.ofReal ((a:ℝ)^dimension κ) *
+    ENNReal.ofReal (‖deriv (F t) ((a:ℂ)*z+(U t:ℂ))‖^dimension κ)=_
+  have haz : (U t:ℂ)+(a:ℂ)*z ∈ upperHalfPlane := by
+    change 0 < ((U t:ℂ)+(a:ℂ)*z).im
+    simpa only [Complex.add_im,Complex.ofReal_im,zero_add,Complex.mul_im,
+      Complex.ofReal_re,zero_mul,add_zero] using mul_pos (show 0<(a:ℝ) from ha) z.property
+  have hFd := (hw.2.2.2.2.1 t).differentiableAt (isOpen_upperHalfPlane.mem_nhds haz)
+  have had : HasDerivAt (fun v : ℂ => (U t:ℂ)+(a:ℂ)*v) (a:ℂ) (z:ℂ) := by
+    convert ((hasDerivAt_id (z:ℂ)).const_mul (a:ℂ)).const_add (U t:ℂ) using 1 <;> simp
+  have hdcomp : deriv (fun v : ℂ => F t ((U t:ℂ)+(a:ℂ)*v)) (z:ℂ)=
+      deriv (F t) ((U t:ℂ)+(a:ℂ)*z)*(a:ℂ) := (hFd.hasDerivAt.comp (z:ℂ) had).deriv
+  rw [hdcomp,norm_mul,Real.mul_rpow (norm_nonneg _) (norm_nonneg _),
+    ENNReal.ofReal_mul (Real.rpow_nonneg (norm_nonneg _) _),Complex.norm_real,
+    Real.norm_eq_abs,abs_of_pos (show 0<(a:ℝ) from ha),add_comm ((a:ℂ)*z) (U t:ℂ)]
+  exact mul_comm _ _
+
+end SLEExactGauge
+
+end
+
+end OAI
diff --git a/lean/OAI/Probability/SLE/Mass/JointDiskMass.lean b/lean/OAI/Probability/SLE/Mass/JointDiskMass.lean
new file mode 100644
index 0000000000000000000000000000000000000000..0e26951478f489b66969ef38cd3cb8c169acf65c
--- /dev/null
+++ b/lean/OAI/Probability/SLE/Mass/JointDiskMass.lean
@@ -0,0 +1,84 @@
+import OAI.Probability.SLE.Mass.DiskChartMass
+import OAI.Probability.SLE.Mass.RadonRandomTesting
+import OAI.Probability.SLE.Stochastic.ProgressiveParameterTime
+import OAI.Probability.SLE.Geometry.CanonicalRawTerminal
+
+namespace OAI
+
+/-! Measurable disk mass for a varying angle and raw path.
+The defining integral agrees with the already constructed compact disk scalar. -/
+
+noncomputable section
+open Set Filter _root_.MeasureTheory _root_.OAI.MeasureTheory ProbabilityTheory Metric
+open scoped Topology NNReal ENNReal
+attribute [local instance] Classical.propDecidable
+
+namespace SLEExactGauge
+
+/-- A formula for the derivative weight which is measurable at every real
+angle and agrees with the disk chart derivative on the natural angle interval. -/
+def diskDerivativeWeight (κ θ : ℝ) (z : upperHalfPlane) : ℝ≥0∞ :=
+  ENNReal.ofReal (‖(Complex.exp (θ*Complex.I)-Complex.exp (-θ*Complex.I))/
+    ((z:ℂ)-Complex.exp (-θ*Complex.I))^2‖^dimension κ)
+
+def diskMassValue (κ θ : ℝ) (μ : Measure upperHalfPlane) : ℝ≥0∞ :=
+  ∫⁻ z, (if Target.diskMap θ z ∈ Target.diskK then diskDerivativeWeight κ θ z else 0) ∂μ
+
+lemma diskMassValue_measurable
+    {Ω : Type*} [MeasurableSpace Ω] (κ : ℝ) (θ : Ω → ℝ) (hθ : Measurable θ)
+    (μ : Ω → Measure upperHalfPlane) (hμ : Measurable μ)
+    (hfin : ∀ ω, IsFiniteMeasureOnCompacts (μ ω)) :
+    Measurable (fun ω => diskMassValue κ (θ ω) (μ ω)) := by
+  unfold diskMassValue
+  apply halfPlane_random_test_measurable μ hμ hfin
+    (fun q => if Target.diskMap (θ q.1) q.2 ∈ Target.diskK then
+      diskDerivativeWeight κ (θ q.1) q.2 else 0)
+  have hm : Measurable (fun q : Ω × upperHalfPlane => Target.diskMap (θ q.1) q.2) := by
+    unfold Target.diskMap
+    fun_prop
+  have hw : Measurable (fun q : Ω × upperHalfPlane => diskDerivativeWeight κ (θ q.1) q.2) := by
+    unfold diskDerivativeWeight
+    fun_prop
+  exact hw.ite ((isClosed_closedBall.measurableSet).preimage hm) measurable_const
+
+lemma diskMassValue_eq (κ θ : ℝ) (hθ : θ ∈ Ioo (0:ℝ) Real.pi)
+    (μ : Measure upperHalfPlane) :
+    diskMassValue κ θ μ = ∫⁻ z in Target.diskSourceHalfPlane θ,
+      (Target.diskMassWeight κ θ hθ z : ℝ≥0∞) ∂μ := by
+  rw [diskMassValue,← lintegral_indicator (Target.diskSourceHalfPlane_compact hθ).measurableSet]
+  apply lintegral_congr
+  intro z
+  by_cases hz : z ∈ Target.diskSourceHalfPlane θ
+  · rw [indicator_of_mem hz,ite_eq_left ((Target.mem_diskSourceHalfPlane_iff hθ z).mp hz),
+      Target.diskMassWeight_ennreal,diskDerivativeWeight,(Target.diskMap_hasDerivAt hθ z.property).deriv]
+  · rw [indicator_of_notMem hz,ite_eq_right (fun h => hz ((Target.mem_diskSourceHalfPlane_iff hθ z).mpr h))]
+
+lemma diskMassValue_toReal_eq (κ θ : ℝ) (hθ : θ ∈ Ioo (0:ℝ) Real.pi)
+    (μ : Measure upperHalfPlane) :
+    (diskMassValue κ θ μ).toReal = Multipoint.compactWeightedMass
+      (Target.diskMassWeight κ θ hθ) (Target.diskSourceHalfPlane θ) μ := by
+  rw [diskMassValue_eq κ θ hθ μ,Multipoint.compactWeightedMass_eq_lintegral]
+
+namespace Multipoint
+
+local instance : MeasurableSpace C(ℝ≥0,ℝ) := borel _
+local instance : BorelSpace C(ℝ≥0,ℝ) := ⟨rfl⟩
+
+lemma RawCanonicalMass.disk_at_parameter_measurable
+    {Ξ : Type*} [MeasurableSpace Ξ] (R : RawCanonicalMass) (κ : ℝ)
+    (θ : Ξ → ℝ) (hθ : Measurable θ) (g : Ξ → C(ℝ≥0,ℝ)) (hg : Measurable g)
+    (T : Ξ → ℝ≥0∞) (hT : Measurable T) :
+    Measurable (fun x => diskMassValue κ (θ x)
+      (extendedCanonicalMass R.process R.terminal (T x) (g x))) := by
+  apply diskMassValue_measurable κ θ hθ
+  · exact ((_root_.OAI.MeasureTheory.IsProgressive.parameter_time_measurable R.progressive g hg _ hT.ennreal_toNNReal).ite
+      (measurableSet_lt hT measurable_const) (R.terminal_measurable.comp hg))
+  · intro x
+    exact (extendedCanonicalMass_radon R.process R.terminal R.radon R.terminal_radon (T x) (g x)).2
+
+end Multipoint
+end SLEExactGauge
+
+end
+
+end OAI
diff --git a/lean/OAI/Probability/SLE/Mass/L2ConvexTails.lean b/lean/OAI/Probability/SLE/Mass/L2ConvexTails.lean
new file mode 100644
index 0000000000000000000000000000000000000000..9741cc7d5581ceadf2ae509fba553370a2a73a9f
--- /dev/null
+++ b/lean/OAI/Probability/SLE/Mass/L2ConvexTails.lean
@@ -0,0 +1,83 @@
+import OAI.Probability.SLE.Mass.SimultaneousConvexTails
+import Mathlib.MeasureTheory.Function.L2Space
+import Mathlib.MeasureTheory.Function.LpSpace.InfiniteSum
+
+namespace OAI
+
+/-! A single deterministic sequence of finite convex tail combinations
+for a countable family of uniformly L²-bounded random variables. Both
+L² convergence and simultaneous almost-sure convergence are obtained. -/
+
+noncomputable section
+open Set Filter MeasureTheory
+open scoped Topology ENNReal
+
+namespace SLEExactGauge
+
+variable {Ω : Type*} [MeasurableSpace Ω] {P : Measure Ω}
+
+lemma ae_tendsto_Lp_of_summable_errors {E : Type*} [NormedAddCommGroup E]
+    {p : ℝ≥0∞} [Fact (1 ≤ p)] (u : ℕ → Lp E p P) (x : Lp E p P)
+    (h : Summable (fun n => ‖u n-x‖)) :
+    ∀ᵐ ω ∂P, Tendsto (fun n => u n ω) atTop (𝓝 (x ω)) := by
+  have hsum : ∑' n, eLpNorm (fun ω => (u n-x) ω) p P ≠ ⊤ := by
+    simpa only [← Lp.enorm_def] using
+      (tsum_enorm_ne_top_iff_summable_norm.mpr h)
+  have hae := summable_norm_of_tsum_eLpNorm_ne_top (show 1 ≤ p from Fact.out) hsum
+  have heq : ∀ᵐ ω ∂P, ∀ n, (u n-x) ω = u n ω-x ω :=
+    ae_all_iff.mpr (fun n => Lp.coeFn_sub (u n) x)
+  filter_upwards [hae,heq] with ω hω heω
+  apply tendsto_iff_norm_sub_tendsto_zero.mpr
+  simpa only [heω] using hω.tendsto_atTop_zero
+
+lemma ae_coeFn_weighted_sum (s : Finset ℕ) (w : ℕ → ℝ) (u : ℕ → Lp ℝ 2 P) :
+    ∀ᵐ ω ∂P, (∑ i ∈ s, w i • u i) ω = ∑ i ∈ s, w i * u i ω := by
+  have hs := (Lp.coeFn_finsetSum s (fun i => w i • u i)).trans
+    (eventuallyEq_sum (fun i _ => Lp.coeFn_smul (w i) (u i)))
+  filter_upwards [hs] with ω hω
+  simpa only [Finset.sum_apply,Pi.smul_apply,smul_eq_mul] using hω
+
+theorem exists_L2_convex_tail_limit (u : ℕ → ℕ → Lp ℝ 2 P)
+    (hbound : ∀ j, ∃ B : ℝ, ∀ n, ‖u n j‖ ≤ B) :
+    ∃ x : ℕ → Lp ℝ 2 P, ∃ s : ℕ → Finset ℕ, ∃ w : ℕ → ℕ → ℝ,
+      (∀ n i, i ∈ s n → 0 ≤ w n i) ∧
+      (∀ n, ∑ i ∈ s n, w n i = 1) ∧
+      (∀ j, Tendsto (fun n => ∑ i ∈ s n, w n i • u (n+i) j) atTop (𝓝 (x j))) ∧
+      (∀ᵐ ω ∂P, ∀ j,
+        Tendsto (fun n => ∑ i ∈ s n, w n i * u (n+i) j ω) atTop (𝓝 (x j ω))) := by
+  obtain ⟨x,s,w,hw,hs,hsum,hconv⟩ :=
+    exists_simultaneous_convex_tail_combinations u hbound
+  refine ⟨x,s,w,hw,hs,hconv,ae_all_iff.mpr (fun j => ?_)⟩
+  have hae := ae_tendsto_Lp_of_summable_errors
+    (fun n => ∑ i ∈ s n, w n i • u (n+i) j) (x j) (hsum j)
+  have heq : ∀ᵐ ω ∂P, ∀ n,
+      (∑ i ∈ s n, w n i • u (n+i) j) ω = ∑ i ∈ s n, w n i * u (n+i) j ω :=
+    ae_all_iff.mpr (fun n => ae_coeFn_weighted_sum (s n) (w n) (fun i => u (n+i) j))
+  filter_upwards [hae,heq] with ω hω heω
+  simpa only [heω] using hω
+
+/-- The same extraction stated for actual random variables, rather than
+chosen representatives of their L² classes. -/
+theorem exists_randomVariable_convex_tail_limit (f : ℕ → ℕ → Ω → ℝ)
+    (hf : ∀ n j, MemLp (f n j) 2 P)
+    (hbound : ∀ j, ∃ B : ℝ, ∀ n, ‖(hf n j).toLp (f n j)‖ ≤ B) :
+    ∃ x : ℕ → Lp ℝ 2 P, ∃ s : ℕ → Finset ℕ, ∃ w : ℕ → ℕ → ℝ,
+      (∀ n i, i ∈ s n → 0 ≤ w n i) ∧
+      (∀ n, ∑ i ∈ s n, w n i = 1) ∧
+      (∀ j, Tendsto (fun n => ∑ i ∈ s n, w n i • (hf (n+i) j).toLp (f (n+i) j))
+        atTop (𝓝 (x j))) ∧
+      (∀ᵐ ω ∂P, ∀ j,
+        Tendsto (fun n => ∑ i ∈ s n, w n i * f (n+i) j ω) atTop (𝓝 (x j ω))) := by
+  let u (n j : ℕ) : Lp ℝ 2 P := (hf n j).toLp (f n j)
+  obtain ⟨x,s,w,hw,hs,hconv,hae⟩ := exists_L2_convex_tail_limit u hbound
+  refine ⟨x,s,w,hw,hs,hconv,?_⟩
+  have heq : ∀ᵐ ω ∂P, ∀ n j, u n j ω = f n j ω :=
+    ae_all_iff.mpr (fun n => ae_all_iff.mpr (fun j => (hf n j).coeFn_toLp))
+  filter_upwards [hae,heq] with ω hω heω
+  simpa only [heω] using hω
+
+end SLEExactGauge
+
+end
+
+end OAI
diff --git a/lean/OAI/Probability/SLE/Mass/L2MeanConvergence.lean b/lean/OAI/Probability/SLE/Mass/L2MeanConvergence.lean
new file mode 100644
index 0000000000000000000000000000000000000000..7b4031368b917e23a1ffbca98a71fb645be2b050
--- /dev/null
+++ b/lean/OAI/Probability/SLE/Mass/L2MeanConvergence.lean
@@ -0,0 +1,79 @@
+import OAI.Probability.SLE.Mass.L2ConvexTails
+
+namespace OAI
+
+/-! Passing expectations through the common L² convex extraction. -/
+
+noncomputable section
+open Set Filter MeasureTheory
+open scoped Topology ENNReal
+
+namespace SLEExactGauge
+
+lemma continuous_L2_integral
+    {Ω : Type*} [MeasurableSpace Ω] (P : Measure Ω) [IsFiniteMeasure P] :
+    Continuous (fun x : Lp ℝ 2 P => ∫ ω, x ω ∂P) := by
+  let h1 : MemLp (fun _ : Ω => (1 : ℝ)) 2 P := memLp_const 1
+  let one : Lp ℝ 2 P := h1.toLp (fun _ => 1)
+  have he (x : Lp ℝ 2 P) : inner ℝ one x = ∫ ω, x ω ∂P := by
+    rw [L2.inner_def]
+    apply integral_congr_ae
+    filter_upwards [h1.coeFn_toLp] with ω hω
+    simp only [Real.inner_apply,one,hω,one_mul]
+  simpa only [he] using (continuous_const.inner continuous_id :
+    Continuous (fun x : Lp ℝ 2 P => inner ℝ one x))
+
+lemma weighted_randomVariable_integral_tendsto
+    {Ω : Type*} [MeasurableSpace Ω] (P : Measure Ω) [IsFiniteMeasure P]
+    (f : ℕ → Ω → ℝ) (hf : ∀ n, MemLp (f n) 2 P)
+    (s : ℕ → Finset ℕ) (w : ℕ → ℕ → ℝ) (x : Lp ℝ 2 P)
+    (h : Tendsto (fun n => ∑ i ∈ s n, w n i • (hf (n+i)).toLp (f (n+i))) atTop (𝓝 x)) :
+    Tendsto (fun n => ∫ ω, ∑ i ∈ s n, w n i * f (n+i) ω ∂P)
+      atTop (𝓝 (∫ ω, x ω ∂P)) := by
+  have he (n : ℕ) : (∫ ω, ∑ i ∈ s n, w n i * f (n+i) ω ∂P) =
+      ∫ ω, (∑ i ∈ s n, w n i • (hf (n+i)).toLp (f (n+i))) ω ∂P := by
+    apply integral_congr_ae
+    have hc := ae_coeFn_weighted_sum (s n) (w n) (fun i => (hf (n+i)).toLp (f (n+i)))
+    have hr : ∀ᵐ ω ∂P, ∀ i, (hf (n+i)).toLp (f (n+i)) ω = f (n+i) ω :=
+      ae_all_iff.mpr (fun i => (hf (n+i)).coeFn_toLp)
+    filter_upwards [hc,hr] with ω hc hr
+    simpa only [hr] using hc.symm
+  simpa only [he,Function.comp_def] using (continuous_L2_integral P).continuousAt.tendsto.comp h
+
+lemma continuous_L2_pairing
+    {Ω : Type*} [MeasurableSpace Ω] (P : Measure Ω)
+    (a : Ω → ℝ) (ha : MemLp a 2 P) :
+    Continuous (fun x : Lp ℝ 2 P => ∫ ω, a ω * x ω ∂P) := by
+  let y : Lp ℝ 2 P := ha.toLp a
+  have he (x : Lp ℝ 2 P) : inner ℝ y x = ∫ ω, a ω * x ω ∂P := by
+    rw [L2.inner_def]
+    apply integral_congr_ae
+    filter_upwards [ha.coeFn_toLp] with ω hω
+    simp only [Real.inner_apply,y,hω]
+  simpa only [he] using (continuous_const.inner continuous_id :
+    Continuous (fun x : Lp ℝ 2 P => inner ℝ y x))
+
+lemma weighted_randomVariable_pairing_tendsto
+    {Ω : Type*} [MeasurableSpace Ω] (P : Measure Ω)
+    (f : ℕ → Ω → ℝ) (hf : ∀ n, MemLp (f n) 2 P)
+    (s : ℕ → Finset ℕ) (w : ℕ → ℕ → ℝ) (x : Lp ℝ 2 P)
+    (h : Tendsto (fun n => ∑ i ∈ s n, w n i • (hf (n+i)).toLp (f (n+i))) atTop (𝓝 x))
+    (a : Ω → ℝ) (ha : MemLp a 2 P) :
+    Tendsto (fun n => ∫ ω, a ω * (∑ i ∈ s n, w n i * f (n+i) ω) ∂P)
+      atTop (𝓝 (∫ ω, a ω * x ω ∂P)) := by
+  have he (n : ℕ) : (∫ ω, a ω * (∑ i ∈ s n, w n i * f (n+i) ω) ∂P) =
+      ∫ ω, a ω * (∑ i ∈ s n, w n i • (hf (n+i)).toLp (f (n+i))) ω ∂P := by
+    apply integral_congr_ae
+    have hc := ae_coeFn_weighted_sum (s n) (w n) (fun i => (hf (n+i)).toLp (f (n+i)))
+    have hr : ∀ᵐ ω ∂P, ∀ i, (hf (n+i)).toLp (f (n+i)) ω = f (n+i) ω :=
+      ae_all_iff.mpr (fun i => (hf (n+i)).coeFn_toLp)
+    filter_upwards [hc,hr] with ω hc hr
+    apply congrArg (fun v : ℝ => a ω * v)
+    simpa only [hr] using hc.symm
+  simpa only [he,Function.comp_def] using (continuous_L2_pairing P a ha).continuousAt.tendsto.comp h
+
+end SLEExactGauge
+
+end
+
+end OAI
diff --git a/lean/OAI/Probability/SLE/Mass/LevelApproximants.lean b/lean/OAI/Probability/SLE/Mass/LevelApproximants.lean
new file mode 100644
index 0000000000000000000000000000000000000000..b2a06b6c0116d4bc6ad6872679a285eaa1597c9a
--- /dev/null
+++ b/lean/OAI/Probability/SLE/Mass/LevelApproximants.lean
@@ -0,0 +1,109 @@
+import OAI.Probability.SLE.Multipoint.MultipointLevelMass
+
+namespace OAI
+
+/-! The actual finite-level random measures used to construct canonical
+trace mass. Time truncation retains precisely levels already attained. -/
+
+noncomputable section
+open Set Filter MeasureTheory ProbabilityTheory
+open scoped NNReal ENNReal
+
+namespace SLEExactGauge.Multipoint
+
+local instance : MeasurableSpace C(ℝ≥0, ℝ) := borel _
+local instance : BorelSpace C(ℝ≥0, ℝ) := ⟨rfl⟩
+
+lemma actual_radiusLevel_joint_measurable
+    {Ω : Type*} [MeasurableSpace Ω] {B : ℝ≥0 → Ω → ℝ}
+    (hm : ∀ t, Measurable (B t)) (hBc : ∀ ω, Continuous (fun t => B t ω))
+    (κ u : ℝ) (hu : 0 ≤ u)
+    (γ : Ω → ℝ≥0 → ℂ) (G F : Ω → ℝ≥0 → ℂ → ℂ)
+    (hw : ∀ ω, IsCapacityTwoWitness (fun t => Real.sqrt κ*B t ω) (γ ω) (G ω) (F ω)) :
+    Measurable (fun q : Ω × ℂ => radiusLevelTime (γ q.1) (G q.1) q.2 u) := by
+  have hp : Measurable (sourceDriverPath B hBc) := source_path_measurable _ hm
+  have h : Measurable (fun q : Ω × ℂ =>
+      canonicalRadiusLevel κ (u,q.2,sourceDriverPath B hBc q.1)) :=
+    (canonicalRadiusLevel_measurable κ).comp
+      (measurable_const.prodMk (measurable_snd.prodMk (hp.comp measurable_fst)))
+  convert h using 1
+  funext q
+  exact (canonicalRadiusLevel_eq κ (sourceDriverPath B hBc q.1) (hw q.1) u hu q.2).symm
+
+def levelApproximationDensity {Ω : Type*} (κ : ℝ) (B : ℝ≥0 → Ω → ℝ)
+    (γ : Ω → ℝ≥0 → ℂ) (G : Ω → ℝ≥0 → ℂ → ℂ)
+    (u : ℝ) (t : ℝ≥0∞) (ω : Ω) (z : ℂ) : ℝ≥0∞ :=
+  if radiusLevelTime (γ ω) (G ω) z u ≤ t then
+    ENNReal.ofReal (stoppedGreen κ (fun s => Real.sqrt κ*B s ω) (γ ω) (G ω) z u)
+  else 0
+
+def levelApproximation {Ω : Type*} (κ : ℝ) (B : ℝ≥0 → Ω → ℝ)
+    (γ : Ω → ℝ≥0 → ℂ) (G : Ω → ℝ≥0 → ℂ → ℂ)
+    (u : ℝ) (t : ℝ≥0∞) (ω : Ω) : Measure ℂ :=
+  volume.withDensity (levelApproximationDensity κ B γ G u t ω)
+
+lemma levelApproximationDensity_joint_measurable
+    {Ω : Type*} [MeasurableSpace Ω] {B : ℝ≥0 → Ω → ℝ}
+    (hm : ∀ t, Measurable (B t)) (hBc : ∀ ω, Continuous (fun t => B t ω))
+    (κ u : ℝ) (hu : 0 ≤ u)
+    (γ : Ω → ℝ≥0 → ℂ) (G F : Ω → ℝ≥0 → ℂ → ℂ)
+    (hw : ∀ ω, IsCapacityTwoWitness (fun t => Real.sqrt κ*B t ω) (γ ω) (G ω) (F ω))
+    (t : ℝ≥0∞) : Measurable (Function.uncurry (levelApproximationDensity κ B γ G u t)) := by
+  exact Measurable.ite
+    (measurableSet_le (actual_radiusLevel_joint_measurable hm hBc κ u hu γ G F hw) measurable_const)
+    (actual_stoppedGreen_joint_measurable hm hBc κ u hu γ G F hw).ennreal_ofReal
+    measurable_const
+
+lemma levelApproximationDensity_mono
+    {Ω : Type*} (κ : ℝ) (B : ℝ≥0 → Ω → ℝ)
+    (γ : Ω → ℝ≥0 → ℂ) (G : Ω → ℝ≥0 → ℂ → ℂ)
+    (u : ℝ) (ω : Ω) (z : ℂ) :
+    Monotone (fun t => levelApproximationDensity κ B γ G u t ω z) := by
+  intro s t hst
+  dsimp only [levelApproximationDensity]
+  split_ifs with hs ht
+  · exact le_rfl
+  · exact False.elim (ht (hs.trans hst))
+  · exact bot_le
+  · exact le_rfl
+
+lemma levelApproximation_mono
+    {Ω : Type*} (κ : ℝ) (B : ℝ≥0 → Ω → ℝ)
+    (γ : Ω → ℝ≥0 → ℂ) (G : Ω → ℝ≥0 → ℂ → ℂ)
+    (u : ℝ) (ω : Ω) : Monotone (fun t => levelApproximation κ B γ G u t ω) := by
+  intro s t hst
+  exact withDensity_mono (Filter.Eventually.of_forall (fun z =>
+    levelApproximationDensity_mono κ B γ G u ω z hst))
+
+lemma levelApproximation_apply_top
+    {Ω : Type*} (κ : ℝ) (B : ℝ≥0 → Ω → ℝ)
+    (γ : Ω → ℝ≥0 → ℂ) (G : Ω → ℝ≥0 → ℂ → ℂ)
+    (u : ℝ) (ω : Ω) {K : Set ℂ} (hK : MeasurableSet K) :
+    levelApproximation κ B γ G u ∞ ω K = levelMass κ B γ G u K ω := by
+  rw [levelApproximation,withDensity_apply _ hK]
+  simp only [levelApproximationDensity,le_top,ite_true,levelMass]
+
+lemma levelApproximation_apply_le
+    {Ω : Type*} (κ : ℝ) (B : ℝ≥0 → Ω → ℝ)
+    (γ : Ω → ℝ≥0 → ℂ) (G : Ω → ℝ≥0 → ℂ → ℂ)
+    (u : ℝ) (t : ℝ≥0∞) (ω : Ω) {K : Set ℂ} (hK : MeasurableSet K) :
+    levelApproximation κ B γ G u t ω K ≤ levelMass κ B γ G u K ω := by
+  rw [← levelApproximation_apply_top κ B γ G u ω hK]
+  exact levelApproximation_mono κ B γ G u ω le_top K
+
+lemma levelApproximation_measurable_apply
+    {Ω : Type*} [MeasurableSpace Ω] {B : ℝ≥0 → Ω → ℝ}
+    (hm : ∀ t, Measurable (B t)) (hBc : ∀ ω, Continuous (fun t => B t ω))
+    (κ u : ℝ) (hu : 0 ≤ u)
+    (γ : Ω → ℝ≥0 → ℂ) (G F : Ω → ℝ≥0 → ℂ → ℂ)
+    (hw : ∀ ω, IsCapacityTwoWitness (fun t => Real.sqrt κ*B t ω) (γ ω) (G ω) (F ω))
+    (t : ℝ≥0∞) {K : Set ℂ} (hK : MeasurableSet K) :
+    Measurable (fun ω => levelApproximation κ B γ G u t ω K) := by
+  simp only [levelApproximation,withDensity_apply _ hK]
+  exact (levelApproximationDensity_joint_measurable hm hBc κ u hu γ G F hw t).lintegral_prod_right'
+
+end SLEExactGauge.Multipoint
+
+end
+
+end OAI
diff --git a/lean/OAI/Probability/SLE/Mass/LevelApproximationAdapted.lean b/lean/OAI/Probability/SLE/Mass/LevelApproximationAdapted.lean
new file mode 100644
index 0000000000000000000000000000000000000000..2bddc3d4e7141a7dd535dbd70ea6615f65ac2b73
--- /dev/null
+++ b/lean/OAI/Probability/SLE/Mass/LevelApproximationAdapted.lean
@@ -0,0 +1,307 @@
+import OAI.Probability.SLE.Geometry.SpatialPastKernels
+import OAI.Probability.SLE.Mass.LevelRandomRadon
+import OAI.Probability.SLE.Mass.SubSigmaRadonLimit
+
+namespace OAI
+
+/-! The finite-level mass accumulated by a deterministic time is measurable
+in the natural driver filtration. All spatial variables are retained in the
+past-measurable kernel before integration. -/
+
+noncomputable section
+open Set Filter MeasureTheory ProbabilityTheory TopologicalSpace Classical
+open scoped Topology NNReal ENNReal CompactlySupported
+
+namespace SLEExactGauge
+
+lemma radiusLevelTime_le_iff_prefix
+    {U : ℝ≥0 → ℝ} {γ : ℝ≥0 → ℂ} {G F : ℝ≥0 → ℂ → ℂ}
+    (hU : Continuous U) (hw : IsCapacityTwoWitness U γ G F)
+    (z : ℂ) (u : ℝ) (hu : 0 ≤ u) (T : ℝ≥0) :
+    radiusLevelTime γ G z u ≤ (T : ℝ≥0∞) ↔
+      (z ∈ survivingDomain γ T ∧ fullRadius G T z ≤ (2*z.im)*Real.exp (-u)) ∨
+      radiusLevelTime γ G z u < (T : ℝ≥0∞) := by
+  constructor
+  · intro h
+    rcases h.eq_or_lt with he | ht
+    · left
+      obtain ⟨s,hs,hR⟩ := exists_live_level_of_radiusLevelTime_lt_top γ G z u
+        (h.trans_lt (by simp))
+      have hτ := radiusLevelTime_eq_of_live_level hU hw z u s hs hR
+      have hsT : s = T := by exact_mod_cast hτ.symm.trans he
+      subst s
+      exact ⟨hs,hR.le⟩
+    · exact Or.inr ht
+  · rintro (⟨hT,hR⟩ | ht)
+    · rcases hR.eq_or_lt with he | ht
+      · rw [radiusLevelTime_eq_of_live_level hU hw z u T hT he]
+      · exact (radiusLevelTime_lt_of_live_radius_lt hU hw z u hu T hT ht).le
+    · exact ht.le
+
+lemma capped_radiusLevelTime_dense
+    {U : ℝ≥0 → ℝ} {γ : ℝ≥0 → ℂ} {G F : ℝ≥0 → ℂ → ℂ}
+    (hU : Continuous U) (hw : IsCapacityTwoWitness U γ G F)
+    (z : ℂ) (u : ℝ) (hu : 0 ≤ u) (T : ℝ≥0) :
+    min (radiusLevelTime γ G z u) (T : ℝ≥0∞) =
+      ⨅ n : ℕ, if denseSeq ℝ≥0 n < T ∧
+        z ∈ survivingDomain γ (denseSeq ℝ≥0 n) ∧
+        fullRadius G (denseSeq ℝ≥0 n) z < (2*z.im)*Real.exp (-u)
+        then (denseSeq ℝ≥0 n : ℝ≥0∞) else T := by
+  apply eq_of_forall_gt_iff
+  intro x
+  by_cases hTx : (T : ℝ≥0∞) < x
+  · have hl : min (radiusLevelTime γ G z u) (T : ℝ≥0∞) < x :=
+      (min_le_right _ _).trans_lt hTx
+    have hr : (⨅ n : ℕ, if denseSeq ℝ≥0 n < T ∧
+        z ∈ survivingDomain γ (denseSeq ℝ≥0 n) ∧
+        fullRadius G (denseSeq ℝ≥0 n) z < (2*z.im)*Real.exp (-u)
+        then (denseSeq ℝ≥0 n : ℝ≥0∞) else T) < x := by
+      apply (iInf_le_of_le 0 ?_).trans_lt hTx
+      split_ifs with h
+      · exact_mod_cast h.1.le
+      · exact le_rfl
+    exact iff_of_true hl hr
+  · rw [min_lt_iff, or_iff_left hTx, iInf_lt_iff,
+      radiusLevelTime_lt_iff_dense hU hw z u hu x]
+    constructor
+    · rintro ⟨n,hnx,hn,hR⟩
+      have hnT : denseSeq ℝ≥0 n < T := by
+        exact_mod_cast hnx.trans_le (le_of_not_gt hTx)
+      refine ⟨n,?_⟩
+      have hh : denseSeq ℝ≥0 n < T ∧ z ∈ survivingDomain γ (denseSeq ℝ≥0 n) ∧
+          fullRadius G (denseSeq ℝ≥0 n) z < (2*z.im)*Real.exp (-u) := ⟨hnT,hn,hR⟩
+      rwa [ite_eq_left hh]
+    · rintro ⟨n,hn⟩
+      split_ifs at hn with h
+      · exact ⟨n,hn,h.2.1,h.2.2⟩
+      · exact False.elim (hTx hn)
+
+private lemma prefix_time_measurable
+    {Y : Type*} [MeasurableSpace Y] (τ : Y → ℝ≥0∞) (T : ℝ≥0)
+    (D : ℕ → Y → Prop) (hD : ∀ n, MeasurableSet {p | D n p})
+    (E : Y → Prop) (hE : MeasurableSet {p | E p})
+    (hcap : ∀ p, min (τ p) (T : ℝ≥0∞) =
+      ⨅ n : ℕ, if D n p then (denseSeq ℝ≥0 n : ℝ≥0∞) else T)
+    (hlt : ∀ p, τ p < (T : ℝ≥0∞) ↔ ∃ n, D n p)
+    (hle : ∀ p, τ p ≤ (T : ℝ≥0∞) ↔ E p ∨ τ p < (T : ℝ≥0∞)) :
+    Measurable (fun p => min (τ p) (T : ℝ≥0∞)) ∧
+      MeasurableSet {p | τ p ≤ (T : ℝ≥0∞)} := by
+  classical
+  have hmLess : MeasurableSet {p | τ p < (T : ℝ≥0∞)} := by
+    have he : {p | τ p < (T : ℝ≥0∞)} = ⋃ n, {p | D n p} := by
+      ext p
+      simpa only [mem_iUnion,mem_ofPred_eq] using hlt p
+    rw [he]
+    exact MeasurableSet.iUnion hD
+  constructor
+  · have hh : Measurable (fun p => ⨅ n : ℕ,
+        if D n p then (denseSeq ℝ≥0 n : ℝ≥0∞) else T) :=
+      Measurable.iInf fun n => Measurable.ite (hD n) measurable_const measurable_const
+    convert hh using 1
+    exact funext hcap
+  · convert hE.union hmLess using 1
+    ext p
+    exact hle p
+
+private lemma prefix_level_time_measurable
+    {Y : Type*} [MeasurableSpace Y] (τ : Y → ℝ≥0∞) (T : ℝ≥0)
+    (R : ℝ≥0 → Y → ℝ) (L : ℝ≥0 → Y → Prop) (a : Y → ℝ)
+    (hR : Measurable (fun p : Iic T × Y => if L p.1 p.2 then R p.1 p.2 else 0))
+    (hL : MeasurableSet {p : Iic T × Y | L p.1 p.2}) (ha : Measurable a)
+    (hcap : ∀ p, min (τ p) (T : ℝ≥0∞) =
+      ⨅ n : ℕ, if denseSeq ℝ≥0 n < T ∧ L (denseSeq ℝ≥0 n) p ∧
+        R (denseSeq ℝ≥0 n) p < a p then (denseSeq ℝ≥0 n : ℝ≥0∞) else T)
+    (hlt : ∀ p, τ p < (T : ℝ≥0∞) ↔ ∃ n, denseSeq ℝ≥0 n < T ∧
+      L (denseSeq ℝ≥0 n) p ∧ R (denseSeq ℝ≥0 n) p < a p)
+    (hle : ∀ p, τ p ≤ (T : ℝ≥0∞) ↔
+      (L T p ∧ R T p ≤ a p) ∨ τ p < (T : ℝ≥0∞)) :
+    Measurable (fun p => min (τ p) (T : ℝ≥0∞)) ∧
+      MeasurableSet {p | τ p ≤ (T : ℝ≥0∞)} := by
+  classical
+  have hmR (s : Iic T) : Measurable (fun p => if L s p then R s p else 0) :=
+    hR.comp (measurable_const.prodMk measurable_id)
+  have hmL (s : Iic T) : MeasurableSet {p | L s p} :=
+    hL.preimage (measurable_const.prodMk measurable_id)
+  have hmD (n : ℕ) : MeasurableSet {p : Y |
+      denseSeq ℝ≥0 n < T ∧ L (denseSeq ℝ≥0 n) p ∧ R (denseSeq ℝ≥0 n) p < a p} := by
+    by_cases hn : denseSeq ℝ≥0 n < T
+    · let s : Iic T := ⟨denseSeq ℝ≥0 n,hn.le⟩
+      convert (hmL s).inter (measurableSet_lt (hmR s) ha) using 1
+      ext p
+      simp only [mem_ofPred_eq,mem_inter_iff,s]
+      by_cases hl : L (denseSeq ℝ≥0 n) p <;> simp [hl,hn]
+    · simp only [hn,false_and,ofPred_false,MeasurableSet.empty]
+  have hEnd : MeasurableSet {p : Y | L T p ∧ R T p ≤ a p} := by
+    let s : Iic T := ⟨T,by simp⟩
+    convert (hmL s).inter (measurableSet_le (hmR s) ha) using 1
+    ext p
+    simp only [mem_inter_iff,mem_ofPred_eq,s]
+    by_cases hl : L T p <;> simp [hl]
+  apply prefix_time_measurable τ T _ hmD _ hEnd ?_ hlt hle
+  intro p
+  rw [hcap p]
+  apply iInf_congr
+  intro n
+  split_ifs <;> rfl
+
+theorem actual_radius_prefix_measurable
+    {Ω : Type*} [mΩ : MeasurableSpace Ω] {B : ℝ≥0 → Ω → ℝ}
+    (hm : ∀ t, Measurable (B t)) (hc : ∀ ω, Continuous (fun t => B t ω))
+    (κ u : ℝ) (hu : 0 ≤ u)
+    (γ : Ω → ℝ≥0 → ℂ) (G F : Ω → ℝ≥0 → ℂ → ℂ)
+    (hw : ∀ ω, IsCapacityTwoWitness (fun t => Real.sqrt κ * B t ω)
+      (γ ω) (G ω) (F ω)) (T : ℝ≥0) :
+    let mT := (borel ℂ).prod (Filtration.natural B (fun t => (hm t).stronglyMeasurable) T)
+    @Measurable (ℂ × Ω) ℝ≥0∞ mT (borel ℝ≥0∞)
+      (fun p => min (radiusLevelTime (γ p.2) (G p.2) p.1 u) (T : ℝ≥0∞)) ∧
+    @MeasurableSet (ℂ × Ω) mT
+      {p | radiusLevelTime (γ p.2) (G p.2) p.1 u ≤ (T : ℝ≥0∞)} := by
+  classical
+  obtain ⟨_,hR,hL⟩ := actual_spatial_past_kernels hm hc κ γ G F hw T
+  let : MeasurableSpace Ω := Filtration.natural B (fun t => (hm t).stronglyMeasurable) T
+  have htarget : Measurable (fun p : ℂ × Ω => (2*p.1.im)*Real.exp (-u)) :=
+    (Complex.measurable_im.comp measurable_fst).const_mul 2 |>.mul_const _
+  apply prefix_level_time_measurable
+    (fun p : ℂ × Ω => radiusLevelTime (γ p.2) (G p.2) p.1 u) T
+    (fun t p => fullRadius (G p.2) t p.1)
+    (fun t p => p.1 ∈ survivingDomain (γ p.2) t)
+    (fun p => (2*p.1.im)*Real.exp (-u)) hR hL htarget
+  · intro p
+    exact capped_radiusLevelTime_dense ((hc p.2).const_mul _) (hw p.2) p.1 u hu T
+  · intro p
+    simpa only [ENNReal.coe_lt_coe] using
+      radiusLevelTime_lt_iff_dense ((hc p.2).const_mul _) (hw p.2) p.1 u hu (T : ℝ≥0∞)
+  · intro p
+    exact radiusLevelTime_le_iff_prefix ((hc p.2).const_mul _) (hw p.2) p.1 u hu T
+
+namespace Multipoint
+
+private lemma measurable_capped_green
+    {Y : Type*} [MeasurableSpace Y] (τ : Y → ℝ≥0∞) (T : ℝ≥0)
+    (g : Iic T × Y → ℝ)
+    (hτ : Measurable (fun p => min (τ p) (T : ℝ≥0∞)))
+    (hA : MeasurableSet {p | τ p ≤ (T : ℝ≥0∞)}) (hg : Measurable g) :
+    Measurable (fun p => if τ p ≤ (T : ℝ≥0∞) then ENNReal.ofReal
+      (g (⟨(min (τ p) (T : ℝ≥0∞)).toNNReal, by
+        exact_mod_cast ENNReal.toNNReal_mono
+          (by simp : (T : ℝ≥0∞) ≠ ∞) (min_le_right (τ p) (T : ℝ≥0∞))⟩,p)) else 0) := by
+  classical
+  have hb (p : Y) : (min (τ p) (T : ℝ≥0∞)).toNNReal ∈ Iic T := by
+    exact_mod_cast ENNReal.toNNReal_mono
+      (by simp : (T : ℝ≥0∞) ≠ ∞) (min_le_right (τ p) (T : ℝ≥0∞))
+  have hm := (ENNReal.measurable_toNNReal.comp hτ).subtype_mk (h := hb)
+  exact Measurable.ite hA (hg.comp (hm.prodMk measurable_id)).ennreal_ofReal measurable_const
+
+lemma levelApproximationDensity_eq_cappedGreen
+    {Ω : Type*} (κ : ℝ) (B : ℝ≥0 → Ω → ℝ)
+    (γ : Ω → ℝ≥0 → ℂ) (G : Ω → ℝ≥0 → ℂ → ℂ)
+    (u : ℝ) (T : ℝ≥0) (ω : Ω) (z : ℂ) :
+    levelApproximationDensity κ B γ G u T ω z =
+      if radiusLevelTime (γ ω) (G ω) z u ≤ (T : ℝ≥0∞) then
+        ENNReal.ofReal (greenDensity κ (fun s => Real.sqrt κ * B s ω) (γ ω) (G ω)
+          (min (radiusLevelTime (γ ω) (G ω) z u) (T : ℝ≥0∞)).toNNReal z) else 0 := by
+  unfold levelApproximationDensity
+  by_cases h : radiusLevelTime (γ ω) (G ω) z u ≤ (T : ℝ≥0∞)
+  · have hf : radiusLevelTime (γ ω) (G ω) z u < ∞ := h.trans_lt (by simp)
+    simp only [ite_eq_left h,min_eq_left h,stoppedGreen,ite_eq_left hf]
+  · simp only [ite_eq_right h]
+
+theorem levelApproximationDensity_past_measurable
+    {Ω : Type*} [mΩ : MeasurableSpace Ω] {B : ℝ≥0 → Ω → ℝ}
+    (hm : ∀ t, Measurable (B t)) (hc : ∀ ω, Continuous (fun t => B t ω))
+    (κ u : ℝ) (hu : 0 ≤ u)
+    (γ : Ω → ℝ≥0 → ℂ) (G F : Ω → ℝ≥0 → ℂ → ℂ)
+    (hw : ∀ ω, IsCapacityTwoWitness (fun t => Real.sqrt κ * B t ω)
+      (γ ω) (G ω) (F ω)) (T : ℝ≥0) :
+    @Measurable (Ω × ℂ) ℝ≥0∞
+      ((Filtration.natural B (fun t => (hm t).stronglyMeasurable) T).prod (borel ℂ))
+      (borel ℝ≥0∞) (fun p => levelApproximationDensity κ B γ G u T p.1 p.2) := by
+  classical
+  obtain ⟨hρ,hA⟩ := actual_radius_prefix_measurable hm hc κ u hu γ G F hw T
+  obtain ⟨hG,_,_⟩ := actual_spatial_past_kernels hm hc κ γ G F hw T
+  let : MeasurableSpace Ω := Filtration.natural B (fun t => (hm t).stronglyMeasurable) T
+  have hd := measurable_capped_green
+    (fun p : ℂ × Ω => radiusLevelTime (γ p.2) (G p.2) p.1 u) T
+    (fun p : Iic T × (ℂ × Ω) => greenDensity κ
+      (fun s => Real.sqrt κ * B s p.2.2) (γ p.2.2) (G p.2.2) p.1 p.2.1) hρ hA hG
+  simpa only [levelApproximationDensity_eq_cappedGreen,Function.comp_def,
+    Prod.fst_swap,Prod.snd_swap] using
+    hd.comp measurable_swap
+
+lemma levelApproximationRealTest_past_measurable
+    {Ω : Type*} [mΩ : MeasurableSpace Ω] {B : ℝ≥0 → Ω → ℝ}
+    (hm : ∀ t, Measurable (B t)) (hc : ∀ ω, Continuous (fun t => B t ω))
+    (κ u : ℝ) (hu : 0 ≤ u)
+    (γ : Ω → ℝ≥0 → ℂ) (G F : Ω → ℝ≥0 → ℂ → ℂ)
+    (hw : ∀ ω, IsCapacityTwoWitness (fun t => Real.sqrt κ * B t ω)
+      (γ ω) (G ω) (F ω)) (T : ℝ≥0) (f : ℂ → ℝ) (hf : Measurable f) :
+    Measurable[Filtration.natural B (fun t => (hm t).stronglyMeasurable) T]
+      (levelApproximationRealTest κ B γ G u T f) := by
+  have hd := levelApproximationDensity_past_measurable hm hc κ u hu γ G F hw T
+  let : MeasurableSpace Ω := Filtration.natural B (fun t => (hm t).stronglyMeasurable) T
+  have he (ω : Ω) : levelApproximationRealTest κ B γ G u T f ω =
+      ∫ z, (levelApproximationDensity κ B γ G u T ω z).toReal * f z := by
+    apply integral_withDensity_eq_integral_toReal_smul hd.of_uncurry_left
+    filter_upwards [] with z
+    unfold levelApproximationDensity
+    split_ifs <;> simp
+  simp_rw [show levelApproximationRealTest κ B γ G u T f =
+    (fun ω => ∫ z, (levelApproximationDensity κ B γ G u T ω z).toReal * f z)
+    from funext he]
+  exact (hd.ennreal_toReal.mul (hf.comp measurable_snd)).stronglyMeasurable.integral_prod_right'.measurable
+
+lemma convexLevelMeasure_test_past_measurable
+    {Ω : Type*} [mΩ : MeasurableSpace Ω] {B : ℝ≥0 → Ω → ℝ}
+    (hm : ∀ t, Measurable (B t)) (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 : ∀ n, 0 ≤ u n) (s : ℕ → Finset ℕ) (w : ℕ → ℕ → ℝ)
+    (hw₀ : ∀ n i, i ∈ s n → 0 ≤ w n i) (n : ℕ) (T : ℝ≥0)
+    (f : C_c(upperHalfPlane,ℝ)) :
+    Measurable[Filtration.natural B (fun t => (hm t).stronglyMeasurable) T]
+      (fun ω => ∫ z, f z ∂convexLevelMeasure κ B γ G u s w n T ω) := by
+  have he (ω : Ω) := integral_convexLevelMeasure hκ hκ8 γ G F ω (hc ω) (hw ω)
+    u s w n T (hw₀ n) f
+  simp_rw [he]
+  apply Finset.measurable_sum
+  intro i hi
+  exact measurable_const.mul (levelApproximationRealTest_past_measurable hm hc κ
+    (u (n+i)) (hu (n+i)) γ G F hw T (extendHalfPlaneTest f)
+    (extendHalfPlaneTest_measurable f f.continuous.measurable))
+
+/-- Every actual vague limit at a fixed time has a version measurable in
+that time's uncompleted natural filtration. The convex sequence is unchanged. -/
+theorem level_radon_limit_has_past_measurable_version
+    {Ω : Type*} [mΩ : MeasurableSpace Ω] (P : Measure Ω)
+    {B : ℝ≥0 → Ω → ℝ}
+    (hm : ∀ t, Measurable (B t)) (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 : ∀ n, 0 ≤ u n) (s : ℕ → Finset ℕ) (w : ℕ → ℕ → ℝ)
+    (hw₀ : ∀ n i, i ∈ s n → 0 ≤ w n i) (T : ℝ≥0)
+    (ν : Ω → Measure upperHalfPlane)
+    (hν : ∀ᵐ ω ∂P, (ν ω).Regular)
+    (hlim : ∀ᵐ ω ∂P, ∀ f : C_c(upperHalfPlane,ℝ),
+      Tendsto (fun n => ∫ z, f z ∂convexLevelMeasure κ B γ G u s w n T ω)
+        atTop (𝓝 (∫ z, f z ∂ν ω))) :
+    ∃ η : Ω → Measure upperHalfPlane,
+      Measurable[Filtration.natural B (fun t => (hm t).stronglyMeasurable) T] η ∧
+      (∀ ω, (η ω).Regular ∧ IsFiniteMeasureOnCompacts (η ω)) ∧ η =ᵐ[P] ν := by
+  let : LocallyCompactSpace upperHalfPlane := isOpen_upperHalfPlane.locallyCompactSpace
+  exact exists_subsigma_radon_version
+    (Filtration.natural B (fun t => (hm t).stronglyMeasurable) T) P _ ν
+    (fun n ω => convexLevelMeasure_finite_on_compacts hκ hκ8 γ G F ω (hc ω) (hw ω)
+      u s w n T)
+    (fun n f => convexLevelMeasure_test_past_measurable hm hc hκ hκ8 γ G F hw
+      u hu s w hw₀ n T f) hν hlim
+
+end Multipoint
+end SLEExactGauge
+
+end
+
+end OAI
diff --git a/lean/OAI/Probability/SLE/Mass/LevelApproximationKernel.lean b/lean/OAI/Probability/SLE/Mass/LevelApproximationKernel.lean
new file mode 100644
index 0000000000000000000000000000000000000000..ae889c711298f87970c9377e88da97af8f412409
--- /dev/null
+++ b/lean/OAI/Probability/SLE/Mass/LevelApproximationKernel.lean
@@ -0,0 +1,241 @@
+import OAI.Probability.SLE.Mass.LevelApproximants
+import OAI.Probability.SLE.Loewner.ActualRadiusStops
+
+namespace OAI
+
+/-! The conditional Green kernel of the part of a level measure still to
+come. The level hit is represented by an actual Brownian stopping time;
+no measurability of a geometrically defined filtration is assumed. -/
+
+noncomputable section
+open Set Filter MeasureTheory ProbabilityTheory Classical
+open scoped NNReal ENNReal
+
+namespace SLEExactGauge.Multipoint
+
+def levelRemainderGreen {Ω : Type*} (κ : ℝ) (B : ℝ≥0 → Ω → ℝ)
+    (γ : Ω → ℝ≥0 → ℂ) (G : Ω → ℝ≥0 → ℂ → ℂ)
+    (u : ℝ) (t : ℝ≥0) (z : ℂ) (ω : Ω) : ℝ :=
+  if (t : ℝ≥0∞) < radiusLevelTime (γ ω) (G ω) z u then
+    stoppedGreen κ (fun s => Real.sqrt κ * B s ω) (γ ω) (G ω) z u else 0
+
+def levelCurrentGreen {Ω : Type*} (κ : ℝ) (B : ℝ≥0 → Ω → ℝ)
+    (γ : Ω → ℝ≥0 → ℂ) (G : Ω → ℝ≥0 → ℂ → ℂ)
+    (u : ℝ) (t : ℝ≥0) (z : ℂ) (ω : Ω) : ℝ :=
+  if (t : ℝ≥0∞) < radiusLevelTime (γ ω) (G ω) z u then
+    greenDensity κ (fun s => Real.sqrt κ * B s ω) (γ ω) (G ω) t z else 0
+
+lemma levelRemainderGreen_nonneg
+    {Ω : Type*} {κ : ℝ} {B : ℝ≥0 → Ω → ℝ} {γ : Ω → ℝ≥0 → ℂ}
+    {G F : Ω → ℝ≥0 → ℂ → ℂ} (ω : Ω)
+    (hw : IsCapacityTwoWitness (fun s => Real.sqrt κ * B s ω) (γ ω) (G ω) (F ω))
+    (u : ℝ) (t : ℝ≥0) (z : ℂ) : 0 ≤ levelRemainderGreen κ B γ G u t z ω := by
+  unfold levelRemainderGreen
+  split_ifs
+  · exact stoppedGreen_nonneg hw κ z u
+  · exact le_rfl
+
+lemma levelCurrentGreen_nonneg
+    {Ω : Type*} {κ : ℝ} {B : ℝ≥0 → Ω → ℝ} {γ : Ω → ℝ≥0 → ℂ}
+    {G F : Ω → ℝ≥0 → ℂ → ℂ} (ω : Ω)
+    (hw : IsCapacityTwoWitness (fun s => Real.sqrt κ * B s ω) (γ ω) (G ω) (F ω))
+    (u : ℝ) (t : ℝ≥0) (z : ℂ) : 0 ≤ levelCurrentGreen κ B γ G u t z ω := by
+  unfold levelCurrentGreen
+  split_ifs
+  · exact greenDensity_nonneg hw κ t z
+  · exact le_rfl
+
+lemma actual_greenDensity_joint_measurable
+    {Ω : Type*} [MeasurableSpace Ω] {B : ℝ≥0 → Ω → ℝ}
+    (hBm : Measurable (Function.uncurry B))
+    (hBc : ∀ ω, Continuous (fun t => B t ω)) (κ : ℝ)
+    (γ : Ω → ℝ≥0 → ℂ) (G F : Ω → ℝ≥0 → ℂ → ℂ)
+    (hw : ∀ ω, IsCapacityTwoWitness (fun s => Real.sqrt κ * B s ω) (γ ω) (G ω) (F ω))
+    (t : ℝ≥0) : Measurable (fun q : Ω × ℂ =>
+      greenDensity κ (fun s => Real.sqrt κ * B s q.1) (γ q.1) (G q.1) t q.2) := by
+  let U (s : ℝ≥0) (ω : Ω) := Real.sqrt κ * B s ω
+  let c := spatialClippedFamily U (hBm.const_mul _) (fun ω => (hBc ω).const_mul _)
+  have hj := c.jointGreen_measurable κ B hBm
+  have hp : Measurable (fun q : Ω × ℂ => (t, q.2, q.1)) :=
+    measurable_const.prodMk (measurable_snd.prodMk measurable_fst)
+  have hh := hj.comp hp
+  have he (q : Ω × ℂ) : c.jointGreen κ B (t,q.2,q.1) =
+      greenDensity κ (fun s => Real.sqrt κ * B s q.1) (γ q.1) (G q.1) t q.2 :=
+    c.jointGreen_eq κ B q.1 ((hBc q.1).const_mul _) (fun _ => rfl) (hw q.1) t q.2
+  simpa only [Function.comp_def, he] using hh
+
+lemma levelRemainderGreen_joint_measurable
+    {Ω : Type*} [MeasurableSpace Ω] {B : ℝ≥0 → Ω → ℝ}
+    (hm : ∀ t, Measurable (B t)) (hBc : ∀ ω, Continuous (fun t => B t ω))
+    (κ u : ℝ) (hu : 0 ≤ u)
+    (γ : Ω → ℝ≥0 → ℂ) (G F : Ω → ℝ≥0 → ℂ → ℂ)
+    (hw : ∀ ω, IsCapacityTwoWitness (fun s => Real.sqrt κ * B s ω) (γ ω) (G ω) (F ω))
+    (t : ℝ≥0) : Measurable (fun q : Ω × ℂ => levelRemainderGreen κ B γ G u t q.2 q.1) := by
+  exact Measurable.ite
+    (measurableSet_lt measurable_const (actual_radiusLevel_joint_measurable hm hBc κ u hu γ G F hw))
+    (actual_stoppedGreen_joint_measurable hm hBc κ u hu γ G F hw) measurable_const
+
+lemma levelCurrentGreen_joint_measurable
+    {Ω : Type*} [MeasurableSpace Ω] {B : ℝ≥0 → Ω → ℝ}
+    (hBm : Measurable (Function.uncurry B)) (hBc : ∀ ω, Continuous (fun t => B t ω))
+    (κ u : ℝ) (hu : 0 ≤ u)
+    (γ : Ω → ℝ≥0 → ℂ) (G F : Ω → ℝ≥0 → ℂ → ℂ)
+    (hw : ∀ ω, IsCapacityTwoWitness (fun s => Real.sqrt κ * B s ω) (γ ω) (G ω) (F ω))
+    (t : ℝ≥0) : Measurable (fun q : Ω × ℂ => levelCurrentGreen κ B γ G u t q.2 q.1) := by
+  let hm (s : ℝ≥0) : Measurable (B s) := hBm.comp (measurable_const.prodMk measurable_id)
+  exact Measurable.ite
+    (measurableSet_lt measurable_const (actual_radiusLevel_joint_measurable hm hBc κ u hu γ G F hw))
+    (actual_greenDensity_joint_measurable hBm hBc κ γ G F hw t) measurable_const
+
+theorem levelRemainderGreen_condExp
+    {Ω : Type*} [mΩ : MeasurableSpace Ω] {P : Measure Ω}
+    {B : ℝ≥0 → Ω → ℝ} (hB : IsBrownianReal B P)
+    (hBm : Measurable (Function.uncurry B))
+    (hBc : ∀ ω, Continuous (fun t => B t ω)) (hB0 : ∀ ω, B 0 ω = 0)
+    {κ : ℝ} (hκ : 0 < κ) (hκ8 : κ < 8)
+    (γ : Ω → ℝ≥0 → ℂ) (G F : Ω → ℝ≥0 → ℂ → ℂ)
+    (hw : ∀ᵐ ω ∂P, IsCapacityTwoWitness
+      (fun s => Real.sqrt κ * B s ω) (γ ω) (G ω) (F ω))
+    (z : ℂ) (hz : z ∈ upperHalfPlane) (u : ℝ) (hu : 0 ≤ u) (t : ℝ≥0) :
+    let hm (s : ℝ≥0) : Measurable (B s) :=
+      hBm.comp (measurable_const.prodMk measurable_id)
+    let ℱ := Filtration.natural B (fun s => (hm s).stronglyMeasurable)
+    Integrable (levelRemainderGreen κ B γ G u t z) P ∧
+      Integrable (levelCurrentGreen κ B γ G u t z) P ∧
+      P[levelRemainderGreen κ B γ G u t z | ℱ t] =ᵐ[P]
+        levelCurrentGreen κ B γ G u t z := by
+  let : IsProbabilityMeasure P := hB.isGaussianProcess.isProbabilityMeasure
+  let hm (s : ℝ≥0) : Measurable (B s) :=
+    hBm.comp (measurable_const.prodMk measurable_id)
+  let ℱ := Filtration.natural B (fun s => (hm s).stronglyMeasurable)
+  obtain ⟨M, Z, _, hZ, _, _, hClosed, _, heq, _⟩ :=
+    exists_physical_green_stopping_regular hB hBm hBc hB0 κ hκ hκ8 γ G F hw z hz u hu
+  obtain ⟨τ, hτ, _, hτeq⟩ := exists_monotone_radiusLevel_stops hB hm hBm hBc hB0
+    κ hκ hκ8 γ G F hw z hz (fun _ => u) (fun _ => hu) (fun _ _ _ => le_rfl)
+  let A : Set Ω := {ω | ¬ τ 0 ω ≤ (t : WithTop ℝ≥0)}
+  have hA : MeasurableSet[ℱ t] A := (hτ 0 t).compl
+  have hAg : MeasurableSet A := ℱ.le t _ hA
+  have hR : levelRemainderGreen κ B γ G u t z =ᵐ[P] A.indicator Z := by
+    filter_upwards [heq, hτeq] with ω he hte
+    have htest : (t : ℝ≥0∞) < radiusLevelTime (γ ω) (G ω) z u ↔ ω ∈ A := by
+      change (t : ℝ≥0∞) < radiusLevelTime (γ ω) (G ω) z u ↔ ¬ τ 0 ω ≤ (t : ℝ≥0∞)
+      rw [hte 0]
+      exact lt_iff_not_ge
+    by_cases ha : ω ∈ A
+    · rw [levelRemainderGreen, ite_eq_left (htest.mpr ha), indicator_of_mem ha, he.2]
+    · rw [levelRemainderGreen, ite_eq_right (mt htest.mp ha), indicator_of_notMem ha]
+  have hC : levelCurrentGreen κ B γ G u t z =ᵐ[P] A.indicator (M t) := by
+    filter_upwards [heq, hτeq] with ω he hte
+    have htest : (t : ℝ≥0∞) < radiusLevelTime (γ ω) (G ω) z u ↔ ω ∈ A := by
+      change (t : ℝ≥0∞) < radiusLevelTime (γ ω) (G ω) z u ↔ ¬ τ 0 ω ≤ (t : ℝ≥0∞)
+      rw [hte 0]
+      exact lt_iff_not_ge
+    by_cases ha : ω ∈ A
+    · rw [levelCurrentGreen, ite_eq_left (htest.mpr ha), indicator_of_mem ha,
+        he.1 t, physicalStoppedGreen, ite_eq_right (not_le.mpr (htest.mpr ha))]
+    · rw [levelCurrentGreen, ite_eq_right (mt htest.mp ha), indicator_of_notMem ha]
+  refine ⟨(hZ.indicator hAg).congr hR.symm,
+    ((integrable_condExp.congr (hClosed t).symm).indicator hAg).congr hC.symm, ?_⟩
+  apply (condExp_congr_ae hR).trans
+  apply (condExp_indicator hZ hA).trans
+  apply EventuallyEq.trans _ hC.symm
+  filter_upwards [hClosed t] with ω he
+  by_cases ha : ω ∈ A
+  · simpa only [indicator_of_mem ha,ℱ,hm] using he.symm
+  · simp only [indicator_of_notMem ha]
+
+theorem levelRemainderGreen_setIntegral
+    {Ω : Type*} [mΩ : MeasurableSpace Ω] {P : Measure Ω}
+    {B : ℝ≥0 → Ω → ℝ} (hB : IsBrownianReal B P)
+    (hBm : Measurable (Function.uncurry B))
+    (hBc : ∀ ω, Continuous (fun t => B t ω)) (hB0 : ∀ ω, B 0 ω = 0)
+    {κ : ℝ} (hκ : 0 < κ) (hκ8 : κ < 8)
+    (γ : Ω → ℝ≥0 → ℂ) (G F : Ω → ℝ≥0 → ℂ → ℂ)
+    (hw : ∀ᵐ ω ∂P, IsCapacityTwoWitness
+      (fun s => Real.sqrt κ * B s ω) (γ ω) (G ω) (F ω))
+    (z : ℂ) (hz : z ∈ upperHalfPlane) (u : ℝ) (hu : 0 ≤ u) (t : ℝ≥0)
+    (A : Set Ω)
+    (hA : MeasurableSet[Filtration.natural B (fun s =>
+      (hBm.comp (measurable_const.prodMk measurable_id) : Measurable (B s)).stronglyMeasurable) t] A) :
+    (∫ ω in A, levelRemainderGreen κ B γ G u t z ω ∂P) =
+      ∫ ω in A, levelCurrentGreen κ B γ G u t z ω ∂P := by
+  let : IsProbabilityMeasure P := hB.isGaussianProcess.isProbabilityMeasure
+  let ℱ := Filtration.natural B (fun s =>
+    (hBm.comp (measurable_const.prodMk measurable_id) : Measurable (B s)).stronglyMeasurable)
+  obtain ⟨hR, _, he⟩ := levelRemainderGreen_condExp hB hBm hBc hB0 hκ hκ8
+    γ G F hw z hz u hu t
+  have : IsFiniteMeasure (P.trim (ℱ.le t)) := isFiniteMeasure_trim (ℱ.le t)
+  exact (setIntegral_condExp (ℱ.le t) hR hA).symm.trans
+    (integral_congr_ae (ae_restrict_of_ae he))
+
+theorem levelRemainderGreen_setLIntegral
+    {Ω : Type*} [mΩ : MeasurableSpace Ω] {P : Measure Ω}
+    {B : ℝ≥0 → Ω → ℝ} (hB : IsBrownianReal B P)
+    (hBm : Measurable (Function.uncurry B))
+    (hBc : ∀ ω, Continuous (fun t => B t ω)) (hB0 : ∀ ω, B 0 ω = 0)
+    {κ : ℝ} (hκ : 0 < κ) (hκ8 : κ < 8)
+    (γ : Ω → ℝ≥0 → ℂ) (G F : Ω → ℝ≥0 → ℂ → ℂ)
+    (hw : ∀ᵐ ω ∂P, IsCapacityTwoWitness
+      (fun s => Real.sqrt κ * B s ω) (γ ω) (G ω) (F ω))
+    (z : ℂ) (hz : z ∈ upperHalfPlane) (u : ℝ) (hu : 0 ≤ u) (t : ℝ≥0)
+    (A : Set Ω)
+    (hA : MeasurableSet[Filtration.natural B (fun s =>
+      (hBm.comp (measurable_const.prodMk measurable_id) : Measurable (B s)).stronglyMeasurable) t] A) :
+    (∫⁻ ω in A, ENNReal.ofReal (levelRemainderGreen κ B γ G u t z ω) ∂P) =
+      ∫⁻ ω in A, ENNReal.ofReal (levelCurrentGreen κ B γ G u t z ω) ∂P := by
+  obtain ⟨hR,hC,_⟩ := levelRemainderGreen_condExp hB hBm hBc hB0 hκ hκ8 γ G F hw z hz u hu t
+  have hRn : ∀ᵐ ω ∂P.restrict A, 0 ≤ levelRemainderGreen κ B γ G u t z ω :=
+    ae_restrict_of_ae (hw.mono (fun ω hω => levelRemainderGreen_nonneg ω hω u t z))
+  have hCn : ∀ᵐ ω ∂P.restrict A, 0 ≤ levelCurrentGreen κ B γ G u t z ω :=
+    ae_restrict_of_ae (hw.mono (fun ω hω => levelCurrentGreen_nonneg ω hω u t z))
+  rw [← ofReal_integral_eq_lintegral_ofReal hR.integrableOn hRn,
+    ← ofReal_integral_eq_lintegral_ofReal hC.integrableOn hCn]
+  rw [levelRemainderGreen_setIntegral hB hBm hBc hB0 hκ hκ8 γ G F hw z hz u hu t A hA]
+
+/-- The finite-level kernel identity against every nonnegative spatial
+test, on every event known at time `t`. -/
+theorem levelRemainderGreen_spatial_kernel
+    {Ω : Type*} [mΩ : MeasurableSpace Ω] {P : Measure Ω}
+    {B : ℝ≥0 → Ω → ℝ} (hB : IsBrownianReal B P)
+    (hBm : Measurable (Function.uncurry B))
+    (hBc : ∀ ω, Continuous (fun t => B t ω)) (hB0 : ∀ ω, B 0 ω = 0)
+    {κ : ℝ} (hκ : 0 < κ) (hκ8 : κ < 8)
+    (γ : Ω → ℝ≥0 → ℂ) (G F : Ω → ℝ≥0 → ℂ → ℂ)
+    (hw : ∀ ω, IsCapacityTwoWitness
+      (fun s => Real.sqrt κ * B s ω) (γ ω) (G ω) (F ω))
+    (u : ℝ) (hu : 0 ≤ u) (t : ℝ≥0) (K : Set ℂ)
+    (hK : MeasurableSet K) (hKH : K ⊆ upperHalfPlane)
+    (f : ℂ → ℝ≥0∞) (hf : Measurable f) (A : Set Ω)
+    (hA : MeasurableSet[Filtration.natural B (fun s =>
+      (hBm.comp (measurable_const.prodMk measurable_id) : Measurable (B s)).stronglyMeasurable) t] A) :
+    (∫⁻ ω in A, (∫⁻ z in K, f z * ENNReal.ofReal (levelRemainderGreen κ B γ G u t z ω) ∂volume) ∂P) =
+      ∫⁻ ω in A, (∫⁻ z in K, f z * ENNReal.ofReal (levelCurrentGreen κ B γ G u t z ω) ∂volume) ∂P := by
+  let : IsProbabilityMeasure P := hB.isGaussianProcess.isProbabilityMeasure
+  let hm (s : ℝ≥0) : Measurable (B s) := hBm.comp (measurable_const.prodMk measurable_id)
+  have hmR := levelRemainderGreen_joint_measurable hm hBc κ u hu γ G F hw t
+  have hmC := levelCurrentGreen_joint_measurable hBm hBc κ u hu γ G F hw t
+  have hR := (hf.comp measurable_snd).mul hmR.ennreal_ofReal
+  have hC := (hf.comp measurable_snd).mul hmC.ennreal_ofReal
+  conv_lhs => rw [lintegral_lintegral_swap hR.aemeasurable]
+  conv_rhs => rw [lintegral_lintegral_swap hC.aemeasurable]
+  apply setLIntegral_congr_fun hK
+  intro z hz
+  dsimp only
+  have hpz : Measurable (fun ω : Ω => (ω,z)) := measurable_id.prodMk measurable_const
+  have hmRz : Measurable (fun ω => ENNReal.ofReal (levelRemainderGreen κ B γ G u t z ω)) :=
+    by
+      have hh := hmR.ennreal_ofReal.comp hpz
+      simpa only [Function.comp_def] using hh
+  have hmCz : Measurable (fun ω => ENNReal.ofReal (levelCurrentGreen κ B γ G u t z ω)) :=
+    by
+      have hh := hmC.ennreal_ofReal.comp hpz
+      simpa only [Function.comp_def] using hh
+  rw [lintegral_const_mul _ hmRz, lintegral_const_mul _ hmCz]
+  rw [levelRemainderGreen_setLIntegral hB hBm hBc hB0 hκ hκ8 γ G F (ae_of_all _ hw)
+    z (hKH hz) u hu t A hA]
+
+end SLEExactGauge.Multipoint
+
+end
+
+end OAI
diff --git a/lean/OAI/Probability/SLE/Mass/LevelApproximationL2.lean b/lean/OAI/Probability/SLE/Mass/LevelApproximationL2.lean
new file mode 100644
index 0000000000000000000000000000000000000000..4bdf549c8ac2ea4c7c8f1251892a1ce235f43d4c
--- /dev/null
+++ b/lean/OAI/Probability/SLE/Mass/LevelApproximationL2.lean
@@ -0,0 +1,87 @@
+import OAI.Probability.SLE.Mass.LevelApproximationTests
+import OAI.Probability.SLE.Mass.L2ConvexTails
+
+namespace OAI
+
+/-! Uniform Hilbert bounds and one common deterministic convex extraction
+for the actual finite-level measure tests. -/
+
+noncomputable section
+open Set Filter MeasureTheory ProbabilityTheory
+open scoped NNReal ENNReal Topology
+
+namespace SLEExactGauge.Multipoint
+
+lemma eLpNorm_toReal_two_le
+    {Ω : Type*} [MeasurableSpace Ω] (P : Measure Ω)
+    (A : Ω → ℝ≥0∞) (hA : Measurable A) (M : ℝ≥0∞)
+    (hM : (∫⁻ ω, A ω ^ 2 ∂P) ≤ M) :
+    eLpNorm (fun ω => (A ω).toReal) 2 P ≤ M ^ (1/2 : ℝ) := by
+  have hn (ω : Ω) : ‖(A ω).toReal‖ₑ ≤ A ω := by
+    rw [← ofReal_norm,Real.norm_eq_abs,abs_of_nonneg ENNReal.toReal_nonneg]
+    exact ENNReal.ofReal_toReal_le
+  have hi : (∫⁻ ω, ‖(A ω).toReal‖ₑ ^ 2 ∂P) ≤ M :=
+    (lintegral_mono (fun ω => pow_le_pow_left' (hn ω) 2)).trans hM
+  rw [eLpNorm_eq_lintegral_rpow_enorm_toReal (by norm_num : (2 : ℝ≥0∞) ≠ 0)
+    ENNReal.ofNat_ne_top hA.ennreal_toReal.aestronglyMeasurable]
+  simpa only [ENNReal.toReal_ofNat,ENNReal.rpow_two] using
+    ENNReal.rpow_le_rpow hi (by norm_num : (0 : ℝ) ≤ 1/2)
+
+lemma memLp_toReal_two
+    {Ω : Type*} [MeasurableSpace Ω] (P : Measure Ω)
+    (A : Ω → ℝ≥0∞) (hA : Measurable A) (M : ℝ≥0∞) (hM : M < ⊤)
+    (hAM : (∫⁻ ω, A ω ^ 2 ∂P) ≤ M) :
+    MemLp (fun ω => (A ω).toReal) 2 P := by
+  apply lt_of_le_of_lt (eLpNorm_toReal_two_le P A hA M hAM)
+  exact ENNReal.rpow_lt_top_of_nonneg (by norm_num) hM.ne
+
+lemma norm_toLp_toReal_two_le
+    {Ω : Type*} [MeasurableSpace Ω] (P : Measure Ω)
+    (A : Ω → ℝ≥0∞) (hA : Measurable A) (M : ℝ≥0∞) (hM : M < ⊤)
+    (hAM : (∫⁻ ω, A ω ^ 2 ∂P) ≤ M)
+    (hLp : MemLp (fun ω => (A ω).toReal) 2 P) :
+    ‖hLp.toLp (fun ω => (A ω).toReal)‖ ≤ (M ^ (1/2 : ℝ)).toReal := by
+  rw [Lp.norm_toLp]
+  exact ENNReal.toReal_mono (ENNReal.rpow_ne_top_of_nonneg (by norm_num) hM.ne)
+    (eLpNorm_toReal_two_le P A hA M hAM)
+
+theorem exists_common_levelApproximation_test_limits
+    {Ω : Type*} [MeasurableSpace Ω]
+    {P : Measure Ω} {B : ℝ≥0 → Ω → ℝ} (hB : IsBrownianReal B P)
+    (hm : ∀ t, Measurable (B t)) (hBm : Measurable (Function.uncurry B))
+    (hBc : ∀ ω, Continuous (fun t => B t ω)) (hB0 : ∀ ω, B 0 ω = 0)
+    {κ : ℝ} (hκ : 0 < κ) (hκ8 : κ < 8)
+    (γ : Ω → ℝ≥0 → ℂ) (G F : Ω → ℝ≥0 → ℂ → ℂ)
+    (hw : ∀ ω, IsCapacityTwoWitness (fun t => Real.sqrt κ*B t ω) (γ ω) (G ω) (F ω))
+    (hgrowth : PublishedDiskUnivalentGrowth)
+    (K : ℕ → Set ℂ) (hK : ∀ j, IsCompact (K j)) (hKH : ∀ j, K j ⊆ upperHalfPlane)
+    (f : ℕ → ℂ → ℝ≥0∞) (hfm : ∀ j, Measurable (f j))
+    (C : ℕ → ℝ≥0∞) (hC : ∀ j, C j < ⊤)
+    (hf : ∀ j z, z ∈ K j → f j z ≤ C j) (hz : ∀ j z, z ∉ K j → f j z = 0)
+    (u : ℕ → ℝ) (hu : ∀ n, 0 ≤ u n) (t : ℕ → ℝ≥0∞) :
+    ∃ x : ℕ → Lp ℝ 2 P, ∃ s : ℕ → Finset ℕ, ∃ w : ℕ → ℕ → ℝ,
+      (∀ n i, i ∈ s n → 0 ≤ w n i) ∧
+      (∀ n, ∑ i ∈ s n, w n i = 1) ∧
+      (∀ᵐ ω ∂P, ∀ j, Tendsto (fun n => ∑ i ∈ s n, w n i *
+        (levelApproximationTest κ B γ G (u (n+i)) (t j) (f j) ω).toReal)
+        atTop (𝓝 (x j ω))) := by
+  let A (n j : ℕ) (ω : Ω) := levelApproximationTest κ B γ G (u n) (t j) (f j) ω
+  have hAm (n j : ℕ) : Measurable (A n j) :=
+    levelApproximationTest_measurable hm hBc κ (u n) (hu n) γ G F hw (t j) (f j) (hfm j)
+  choose M hM hbound using fun j => uniform_levelApproximationTest_moments hB hm hBm hBc hB0
+    hκ hκ8 γ G F hw hgrowth (K j) (hK j) (hKH j) (f j) (C j) (hC j) (hf j) (hz j) 2
+  have hLp (n j : ℕ) : MemLp (fun ω => (A n j ω).toReal) 2 P :=
+    memLp_toReal_two P (A n j) (hAm n j) (M j) (hM j) (hbound j (u n) (hu n) (t j))
+  have hnorm (j : ℕ) : ∃ D : ℝ, ∀ n, ‖(hLp n j).toLp (fun ω => (A n j ω).toReal)‖ ≤ D := by
+    refine ⟨(M j ^ (1/2 : ℝ)).toReal,fun n => ?_⟩
+    exact norm_toLp_toReal_two_le P (A n j) (hAm n j) (M j) (hM j)
+      (hbound j (u n) (hu n) (t j)) (hLp n j)
+  obtain ⟨x,s,w,hw₀,hw₁,_,hconv⟩ := exists_randomVariable_convex_tail_limit
+    (fun n j ω => (A n j ω).toReal) hLp hnorm
+  exact ⟨x,s,w,hw₀,hw₁,hconv⟩
+
+end SLEExactGauge.Multipoint
+
+end
+
+end OAI
diff --git a/lean/OAI/Probability/SLE/Mass/LevelApproximationMean.lean b/lean/OAI/Probability/SLE/Mass/LevelApproximationMean.lean
new file mode 100644
index 0000000000000000000000000000000000000000..05cc1c935d15e2f2a124a2fff88239643ce8174f
--- /dev/null
+++ b/lean/OAI/Probability/SLE/Mass/LevelApproximationMean.lean
@@ -0,0 +1,56 @@
+import OAI.Probability.SLE.Mass.LevelApproximants
+
+namespace OAI
+
+/-! Mean measure of the actual finite-level approximants. This identity
+uses the proved one-point stopped law and needs no univalence input. -/
+
+noncomputable section
+open Set Filter MeasureTheory ProbabilityTheory
+open scoped NNReal ENNReal
+
+namespace SLEExactGauge.Multipoint
+
+theorem levelMass_mean
+    {Ω : 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 ω))
+    (K : Set ℂ) (hK : MeasurableSet K) (hKH : K ⊆ upperHalfPlane)
+    (u : ℝ) (hu : 0 ≤ u) :
+    (∫⁻ ω, levelMass κ B γ G u K ω ∂P) = ∫⁻ z in K, ENNReal.ofReal (initialGreen κ z) := by
+  let : IsProbabilityMeasure P := hB.isGaussianProcess.isProbabilityMeasure
+  unfold levelMass
+  rw [lintegral_lintegral_swap
+    (actual_stoppedGreen_joint_measurable hm hBc κ u hu γ G F hw).ennreal_ofReal.aemeasurable]
+  apply setLIntegral_congr_fun hK
+  intro z hz
+  obtain ⟨hi,he⟩ := finite_stopped_green_regular hB hBm hBc hB0 κ hκ hκ8 γ G F
+    (ae_of_all _ hw) z (hKH hz) u hu
+  dsimp only
+  rw [← ofReal_integral_eq_lintegral_ofReal hi (ae_of_all _ (fun ω =>
+    stoppedGreen_nonneg (hw ω) κ z u)),he]
+
+theorem levelApproximation_terminal_mean
+    {Ω : 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 ω))
+    (K : Set ℂ) (hK : MeasurableSet K) (hKH : K ⊆ upperHalfPlane)
+    (u : ℝ) (hu : 0 ≤ u) :
+    (∫⁻ ω, levelApproximation κ B γ G u ∞ ω K ∂P) =
+      ∫⁻ z in K, ENNReal.ofReal (initialGreen κ z) := by
+  simp only [levelApproximation_apply_top κ B γ G u _ hK]
+  exact levelMass_mean hB hm hBm hBc hB0 hκ hκ8 γ G F hw K hK hKH u hu
+
+end SLEExactGauge.Multipoint
+
+end
+
+end OAI
diff --git a/lean/OAI/Probability/SLE/Mass/LevelApproximationSupport.lean b/lean/OAI/Probability/SLE/Mass/LevelApproximationSupport.lean
new file mode 100644
index 0000000000000000000000000000000000000000..9b401888e8c5458544fba5cc6c63c0036ac06a55
--- /dev/null
+++ b/lean/OAI/Probability/SLE/Mass/LevelApproximationSupport.lean
@@ -0,0 +1,40 @@
+import OAI.Probability.SLE.Mass.LevelApproximants
+
+namespace OAI
+
+/-! Finite-level mass is carried near the actual past trace. On an
+interior compact, the neighborhood shrinks as the level tends to infinity. -/
+
+noncomputable section
+open Set Filter MeasureTheory ProbabilityTheory
+open scoped NNReal ENNReal
+
+namespace SLEExactGauge.Multipoint
+
+lemma levelApproximationDensity_eq_zero_of_avoidance
+    {Ω : Type*} {κ : ℝ} {B : ℝ≥0 → Ω → ℝ}
+    {γ : Ω → ℝ≥0 → ℂ} {G F : Ω → ℝ≥0 → ℂ → ℂ} (ω : Ω)
+    (hU : Continuous (fun s => Real.sqrt κ*B s ω))
+    (hw : IsCapacityTwoWitness (fun s => Real.sqrt κ*B s ω) (γ ω) (G ω) (F ω))
+    (z : ℂ) (r : ℝ) (hr : 0 < r) (hy : r ≤ z.im)
+    (u : ℝ) (hlevel : (2*z.im)*Real.exp (-u) < r) (t : ℝ≥0)
+    (havoid : ∀ s ∈ Icc 0 t, r ≤ dist (γ ω s) z) :
+    levelApproximationDensity κ B γ G u t ω z = 0 := by
+  by_contra hn
+  have hτ : radiusLevelTime (γ ω) (G ω) z u ≤ (t : ℝ≥0∞) := by
+    by_contra h
+    exact hn (by simp only [levelApproximationDensity,ite_eq_right h])
+  obtain ⟨a,ha,hR⟩ := exists_live_level_of_radiusLevelTime_lt_top (γ ω) (G ω) z u
+    (hτ.trans_lt ENNReal.coe_lt_top)
+  have hat : a ≤ t := by
+    rw [radiusLevelTime_eq_of_live_level hU hw z u a ha hR] at hτ
+    exact ENNReal.coe_le_coe.mp hτ
+  have hbound := hw.radius_ge_of_no_trace_approach hU a z ha hr hy
+    (fun s hs => havoid s ⟨hs.1,hs.2.trans hat⟩)
+  exact (not_lt_of_ge hbound) (hR.trans_lt hlevel)
+
+end SLEExactGauge.Multipoint
+
+end
+
+end OAI
diff --git a/lean/OAI/Probability/SLE/Mass/LevelApproximationTests.lean b/lean/OAI/Probability/SLE/Mass/LevelApproximationTests.lean
new file mode 100644
index 0000000000000000000000000000000000000000..4bbdd7507866252f39de4e2e58a683641a668e24
--- /dev/null
+++ b/lean/OAI/Probability/SLE/Mass/LevelApproximationTests.lean
@@ -0,0 +1,88 @@
+import OAI.Probability.SLE.Mass.CompactLevelMoments
+
+namespace OAI
+
+/-! Bounded nonnegative tests of the actual finite-level measures inherit
+the compact moment bounds used for simultaneous convex extraction. -/
+
+noncomputable section
+open Set Filter MeasureTheory ProbabilityTheory
+open scoped NNReal ENNReal
+
+namespace SLEExactGauge.Multipoint
+
+def levelApproximationTest {Ω : Type*} (κ : ℝ) (B : ℝ≥0 → Ω → ℝ)
+    (γ : Ω → ℝ≥0 → ℂ) (G : Ω → ℝ≥0 → ℂ → ℂ)
+    (u : ℝ) (t : ℝ≥0∞) (f : ℂ → ℝ≥0∞) (ω : Ω) : ℝ≥0∞ :=
+  ∫⁻ z, f z ∂levelApproximation κ B γ G u t ω
+
+lemma lintegral_le_const_mul_measure_of_support
+    (μ : Measure ℂ) (K : Set ℂ) (hK : MeasurableSet K)
+    (f : ℂ → ℝ≥0∞) (C : ℝ≥0∞) (hf : ∀ z ∈ K, f z ≤ C)
+    (hz : ∀ z ∉ K, f z = 0) : (∫⁻ z, f z ∂μ) ≤ C * μ K := by
+  classical
+  apply (lintegral_mono (fun z => ?_)).trans (lintegral_indicator_const hK C).le
+  by_cases h : z ∈ K
+  · simpa only [indicator_of_mem h] using hf z h
+  · simp only [hz z h,indicator_of_notMem h,le_refl]
+
+lemma levelApproximationTest_le
+    {Ω : Type*} (κ : ℝ) (B : ℝ≥0 → Ω → ℝ)
+    (γ : Ω → ℝ≥0 → ℂ) (G : Ω → ℝ≥0 → ℂ → ℂ)
+    (u : ℝ) (t : ℝ≥0∞) (f : ℂ → ℝ≥0∞) (ω : Ω)
+    (K : Set ℂ) (hK : MeasurableSet K) (C : ℝ≥0∞)
+    (hf : ∀ z ∈ K, f z ≤ C) (hz : ∀ z ∉ K, f z = 0) :
+    levelApproximationTest κ B γ G u t f ω ≤ C * levelMass κ B γ G u K ω := by
+  apply (lintegral_le_const_mul_measure_of_support
+    (levelApproximation κ B γ G u t ω) K hK f C hf hz).trans
+  gcongr
+  exact levelApproximation_apply_le κ B γ G u t ω hK
+
+lemma levelApproximationTest_measurable
+    {Ω : Type*} [MeasurableSpace Ω] {B : ℝ≥0 → Ω → ℝ}
+    (hm : ∀ t, Measurable (B t)) (hBc : ∀ ω, Continuous (fun t => B t ω))
+    (κ u : ℝ) (hu : 0 ≤ u)
+    (γ : Ω → ℝ≥0 → ℂ) (G F : Ω → ℝ≥0 → ℂ → ℂ)
+    (hw : ∀ ω, IsCapacityTwoWitness (fun t => Real.sqrt κ*B t ω) (γ ω) (G ω) (F ω))
+    (t : ℝ≥0∞) (f : ℂ → ℝ≥0∞) (hf : Measurable f) :
+    Measurable (levelApproximationTest κ B γ G u t f) := by
+  have hd := levelApproximationDensity_joint_measurable hm hBc κ u hu γ G F hw t
+  have he (ω : Ω) : levelApproximationTest κ B γ G u t f ω =
+      ∫⁻ z, levelApproximationDensity κ B γ G u t ω z * f z := by
+    exact lintegral_withDensity_eq_lintegral_mul volume hd.of_uncurry_left hf
+  simp_rw [show levelApproximationTest κ B γ G u t f =
+    (fun ω => ∫⁻ z, levelApproximationDensity κ B γ G u t ω z * f z) from funext he]
+  exact (hd.mul (hf.comp measurable_snd)).lintegral_prod_right'
+
+theorem uniform_levelApproximationTest_moments
+    {Ω : Type*} [MeasurableSpace Ω]
+    {P : Measure Ω} {B : ℝ≥0 → Ω → ℝ} (hB : IsBrownianReal B P)
+    (hm : ∀ t, Measurable (B t)) (hBm : Measurable (Function.uncurry B))
+    (hBc : ∀ ω, Continuous (fun t => B t ω)) (hB0 : ∀ ω, B 0 ω = 0)
+    {κ : ℝ} (hκ : 0 < κ) (hκ8 : κ < 8)
+    (γ : Ω → ℝ≥0 → ℂ) (G F : Ω → ℝ≥0 → ℂ → ℂ)
+    (hw : ∀ ω, IsCapacityTwoWitness (fun t => Real.sqrt κ*B t ω) (γ ω) (G ω) (F ω))
+    (hgrowth : PublishedDiskUnivalentGrowth)
+    (K : Set ℂ) (hK : IsCompact K) (hKH : K ⊆ upperHalfPlane)
+    (f : ℂ → ℝ≥0∞) (C : ℝ≥0∞) (hC : C < ⊤)
+    (hf : ∀ z ∈ K, f z ≤ C) (hz : ∀ z ∉ K, f z = 0) (m : ℕ) :
+    ∃ M : ℝ≥0∞, M < ⊤ ∧ ∀ u : ℝ, 0 ≤ u → ∀ t : ℝ≥0∞,
+      (∫⁻ ω, levelApproximationTest κ B γ G u t f ω ^ m ∂P) ≤ M := by
+  obtain ⟨M,hM,hbound⟩ := uniform_levelMass_compact_moments hB hm hBm hBc hB0 hκ hκ8
+    γ G F hw hgrowth K hK hKH m
+  refine ⟨C^m*M,ENNReal.mul_lt_top (ENNReal.pow_lt_top hC) hM,?_⟩
+  intro u hu t
+  calc
+    _ ≤ ∫⁻ ω, (C*levelMass κ B γ G u K ω)^m ∂P :=
+      lintegral_mono (fun ω => pow_le_pow_left'
+        (levelApproximationTest_le κ B γ G u t f ω K hK.measurableSet C hf hz) m)
+    _ = C^m*(∫⁻ ω, levelMass κ B γ G u K ω ^ m ∂P) := by
+      simp_rw [mul_pow]
+      exact lintegral_const_mul' _ _ (ENNReal.pow_ne_top hC.ne)
+    _ ≤ _ := by gcongr; exact hbound u hu
+
+end SLEExactGauge.Multipoint
+
+end
+
+end OAI
diff --git a/lean/OAI/Probability/SLE/Mass/LevelConditionalMean.lean b/lean/OAI/Probability/SLE/Mass/LevelConditionalMean.lean
new file mode 100644
index 0000000000000000000000000000000000000000..431dde4eda947ddbd976423efa58356f75fda6d4
--- /dev/null
+++ b/lean/OAI/Probability/SLE/Mass/LevelConditionalMean.lean
@@ -0,0 +1,146 @@
+import OAI.Probability.SLE.Mass.LevelCurrentTests
+import OAI.Probability.SLE.Mass.ConvexMeanMeasure
+import OAI.Probability.SLE.Mass.LevelRandomRadon
+
+namespace OAI
+
+/-! The exact conditional decomposition is preserved by the common
+finite convex combinations. -/
+
+noncomputable section
+open Set Filter MeasureTheory ProbabilityTheory Classical
+open scoped NNReal ENNReal Topology CompactlySupported
+
+namespace SLEExactGauge
+
+lemma bind_mono_of_measurable {Ω X : Type*} [MeasurableSpace Ω] [MeasurableSpace X]
+    (P : Measure Ω) {μ ν : Ω → Measure X} (hμ : Measurable μ) (hν : Measurable ν)
+    (h : ∀ ω, μ ω ≤ ν ω) : P.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 (fun ω => h ω A)
+
+lemma bind_finset_smul {Ω X : Type*} [MeasurableSpace Ω] [MeasurableSpace X]
+    (P : Measure Ω) (s : Finset ℕ) (w : ℕ → ℝ≥0∞) (hw : ∀ i, w i ≠ ⊤)
+    (μ : ℕ → Ω → Measure X) (hμ : ∀ i, Measurable (μ i)) :
+    P.bind (fun ω => ∑ i ∈ s, w i • μ i ω) = ∑ i ∈ s, w i • P.bind (μ i) := by
+  have hm : Measurable (fun ω => ∑ i ∈ s, w i • μ i ω) := by
+    apply Measure.measurable_of_measurable_coe
+    intro A hA
+    simp only [Measure.finsetSum_apply,Measure.smul_apply,smul_eq_mul]
+    exact Finset.measurable_sum _ (fun i _ => measurable_const.mul ((Measure.measurable_coe hA).comp (hμ i)))
+  apply Measure.ext
+  intro A hA
+  rw [Measure.bind_apply hA hm.aemeasurable]
+  simp only [Measure.finsetSum_apply,Measure.smul_apply,smul_eq_mul]
+  rw [lintegral_finsetSum s (f := fun i ω => w i * μ i ω A)
+    (fun i _ => measurable_const.mul ((Measure.measurable_coe hA).comp (hμ i)))]
+  apply Finset.sum_congr rfl
+  intro i _
+  rw [lintegral_const_mul' _ _ (hw i),Measure.bind_apply hA (hμ i).aemeasurable]
+
+namespace Multipoint
+
+lemma halfPlaneLevelMeasure_conditional_split
+    {Ω : Type*} [MeasurableSpace Ω] {P : Measure Ω}
+    {B : ℝ≥0 → Ω → ℝ} (hB : IsBrownianReal B P)
+    (hBm : Measurable (Function.uncurry B)) (hBc : ∀ ω, Continuous (fun t => B t ω))
+    (hB0 : ∀ ω, B 0 ω = 0) {κ : ℝ} (hκ : 0 < κ) (hκ8 : κ < 8)
+    (γ : Ω → ℝ≥0 → ℂ) (G F : Ω → ℝ≥0 → ℂ → ℂ)
+    (hw : ∀ ω, IsCapacityTwoWitness (fun t => Real.sqrt κ * B t ω) (γ ω) (G ω) (F ω))
+    (u : ℝ) (hu : 0 ≤ u) (t : ℝ≥0) (E : Set Ω)
+    (hE : MeasurableSet[Filtration.natural B (fun s =>
+      (hBm.comp (measurable_const.prodMk measurable_id) : Measurable (B s)).stronglyMeasurable) t] E) :
+    (P.restrict E).bind (halfPlaneLevelMeasure κ B γ G u ∞) =
+      (P.restrict E).bind (halfPlaneLevelMeasure κ B γ G u t) +
+      (P.restrict E).bind (halfPlaneCurrentMeasure κ B γ G u t) := by
+  let hm (s : ℝ≥0) : Measurable (B s) := hBm.comp (measurable_const.prodMk measurable_id)
+  rw [← halfPlaneRemainderMeasure_conditional_mean hB hBm hBc hB0 hκ hκ8 γ G F hw u hu t E hE]
+  apply Measure.ext
+  intro A hA
+  rw [Measure.add_apply,
+    Measure.bind_apply hA (halfPlaneLevelMeasure_measurable hm hBc κ u hu γ G F hw ∞).aemeasurable,
+    Measure.bind_apply hA (halfPlaneLevelMeasure_measurable hm hBc κ u hu γ G F hw t).aemeasurable,
+    Measure.bind_apply hA (halfPlaneRemainderMeasure_measurable hm hBc κ u hu γ G F hw t).aemeasurable]
+  simp_rw [halfPlaneLevelMeasure_split hm hBc κ u hu γ G F hw t,Measure.add_apply]
+  exact lintegral_add_left (((Measure.measurable_coe hA).comp
+    (halfPlaneLevelMeasure_measurable hm hBc κ u hu γ G F hw t))) _
+
+def convexCurrentMean {Ω : Type*} [MeasurableSpace Ω] (P : Measure Ω)
+    (κ : ℝ) (B : ℝ≥0 → Ω → ℝ) (γ : Ω → ℝ≥0 → ℂ) (G : Ω → ℝ≥0 → ℂ → ℂ)
+    (u : ℕ → ℝ) (s : ℕ → Finset ℕ) (w : ℕ → ℕ → ℝ) (n : ℕ) (t : ℝ≥0) :
+    Measure upperHalfPlane :=
+  ∑ i ∈ s n, ENNReal.ofReal (w n i) • P.bind (halfPlaneCurrentMeasure κ B γ G (u (n+i)) t)
+
+lemma convexLevelMeasure_conditional_split
+    {Ω : Type*} [MeasurableSpace Ω] {P : Measure Ω}
+    {B : ℝ≥0 → Ω → ℝ} (hB : IsBrownianReal B P)
+    (hBm : Measurable (Function.uncurry B)) (hBc : ∀ ω, Continuous (fun t => B t ω))
+    (hB0 : ∀ ω, B 0 ω = 0) {κ : ℝ} (hκ : 0 < κ) (hκ8 : κ < 8)
+    (γ : Ω → ℝ≥0 → ℂ) (G F : Ω → ℝ≥0 → ℂ → ℂ)
+    (hw : ∀ ω, IsCapacityTwoWitness (fun t => Real.sqrt κ * B t ω) (γ ω) (G ω) (F ω))
+    (u : ℕ → ℝ) (hu : ∀ n, 0 ≤ u n) (s : ℕ → Finset ℕ) (w : ℕ → ℕ → ℝ)
+    (n : ℕ) (t : ℝ≥0) (E : Set Ω)
+    (hE : MeasurableSet[Filtration.natural B (fun s =>
+      (hBm.comp (measurable_const.prodMk measurable_id) : Measurable (B s)).stronglyMeasurable) t] E) :
+    (P.restrict E).bind (convexLevelMeasure κ B γ G u s w n ∞) =
+      (P.restrict E).bind (convexLevelMeasure κ B γ G u s w n t) +
+        convexCurrentMean (P.restrict E) κ B γ G u s w n t := by
+  let hm (s : ℝ≥0) : Measurable (B s) := hBm.comp (measurable_const.prodMk measurable_id)
+  unfold convexLevelMeasure convexCurrentMean
+  rw [bind_finset_smul _ _ _ (fun _ => ENNReal.ofReal_ne_top) _
+      (fun i => halfPlaneLevelMeasure_measurable hm hBc κ (u (n+i)) (hu _) γ G F hw ∞),
+    bind_finset_smul _ _ _ (fun _ => ENNReal.ofReal_ne_top) _
+      (fun i => halfPlaneLevelMeasure_measurable hm hBc κ (u (n+i)) (hu _) γ G F hw t)]
+  simp_rw [halfPlaneLevelMeasure_conditional_split hB hBm hBc hB0 hκ hκ8 γ G F hw
+    _ (hu _) t E hE,smul_add,Finset.sum_add_distrib]
+
+
+lemma convexLevelMeasure_mean_le
+    {Ω : Type*} [MeasurableSpace Ω] {P : Measure Ω}
+    {B : ℝ≥0 → Ω → ℝ} (hB : IsBrownianReal B P)
+    (hBm : Measurable (Function.uncurry B)) (hBc : ∀ ω, Continuous (fun t => B t ω))
+    (hB0 : ∀ ω, B 0 ω = 0) {κ : ℝ} (hκ : 0 < κ) (hκ8 : κ < 8)
+    (γ : Ω → ℝ≥0 → ℂ) (G F : Ω → ℝ≥0 → ℂ → ℂ)
+    (hw : ∀ ω, IsCapacityTwoWitness (fun t => Real.sqrt κ * B t ω) (γ ω) (G ω) (F ω))
+    (u : ℕ → ℝ) (hu : ∀ n, 0 ≤ u n) (s : ℕ → Finset ℕ) (w : ℕ → ℕ → ℝ)
+    (hw₀ : ∀ n i, i ∈ s n → 0 ≤ w n i) (hw₁ : ∀ n, ∑ i ∈ s n, w n i = 1)
+    (n : ℕ) (t : ℝ≥0∞) (E : Set Ω) :
+    (P.restrict E).bind (convexLevelMeasure κ B γ G u s w n t) ≤ initialGreenMeasure κ := by
+  let hm (s : ℝ≥0) : Measurable (B s) := hBm.comp (measurable_const.prodMk measurable_id)
+  rw [← convexLevelMeasure_terminal_mean hB hm hBm hBc hB0 hκ hκ8 γ G F hw u hu s w hw₀ hw₁ n]
+  apply Measure.le_iff.mpr
+  intro A hA
+  rw [Measure.bind_apply hA (convexLevelMeasure_measurable hm hBc κ γ G F hw u hu s w n t).aemeasurable,
+    Measure.bind_apply hA (convexLevelMeasure_measurable hm hBc κ γ G F hw u hu s w n ∞).aemeasurable]
+  exact lintegral_mono' Measure.restrict_le_self (fun ω =>
+    convexLevelMeasure_mono κ B γ G u s w n ω le_top A)
+
+lemma convexCurrentMean_le
+    {Ω : Type*} [MeasurableSpace Ω] {P : Measure Ω}
+    {B : ℝ≥0 → Ω → ℝ} (hB : IsBrownianReal B P)
+    (hBm : Measurable (Function.uncurry B)) (hBc : ∀ ω, Continuous (fun t => B t ω))
+    (hB0 : ∀ ω, B 0 ω = 0) {κ : ℝ} (hκ : 0 < κ) (hκ8 : κ < 8)
+    (γ : Ω → ℝ≥0 → ℂ) (G F : Ω → ℝ≥0 → ℂ → ℂ)
+    (hw : ∀ ω, IsCapacityTwoWitness (fun t => Real.sqrt κ * B t ω) (γ ω) (G ω) (F ω))
+    (u : ℕ → ℝ) (hu : ∀ n, 0 ≤ u n) (s : ℕ → Finset ℕ) (w : ℕ → ℕ → ℝ)
+    (hw₀ : ∀ n i, i ∈ s n → 0 ≤ w n i) (hw₁ : ∀ n, ∑ i ∈ s n, w n i = 1)
+    (n : ℕ) (t : ℝ≥0) (E : Set Ω) :
+    convexCurrentMean (P.restrict E) κ B γ G u s w n t ≤ initialGreenMeasure κ := by
+  apply Measure.le_iff.mpr
+  intro A _
+  simp only [convexCurrentMean,Measure.finsetSum_apply,Measure.smul_apply,smul_eq_mul]
+  calc
+    _ ≤ ∑ i ∈ s n, ENNReal.ofReal (w n i) * initialGreenMeasure κ A :=
+      Finset.sum_le_sum (fun i _ => mul_le_mul' le_rfl
+        (halfPlaneCurrentMeasure_mean_le hB hBm hBc hB0 hκ hκ8 γ G F hw (u (n+i)) (hu _) t E A))
+    _ = _ := by
+      rw [← Finset.sum_mul,← ENNReal.ofReal_sum_of_nonneg (hw₀ n),hw₁ n,ENNReal.ofReal_one,one_mul]
+
+end Multipoint
+end SLEExactGauge
+
+end
+
+end OAI
diff --git a/lean/OAI/Probability/SLE/Mass/LevelCurrentLimit.lean b/lean/OAI/Probability/SLE/Mass/LevelCurrentLimit.lean
new file mode 100644
index 0000000000000000000000000000000000000000..a659b6f8b1e81b651228bc8077382fd09f9bcbe1
--- /dev/null
+++ b/lean/OAI/Probability/SLE/Mass/LevelCurrentLimit.lean
@@ -0,0 +1,146 @@
+import OAI.Probability.SLE.Mass.LevelRemainderMeasure
+import OAI.Probability.SLE.Mass.LevelGreenLimit
+
+namespace OAI
+
+/-! Increasing finite-level remaining kernels converge to the actual killed
+Green kernel, also after averaging on an arbitrary event. -/
+
+noncomputable section
+open Set Filter MeasureTheory ProbabilityTheory Classical
+open scoped NNReal ENNReal Topology
+
+namespace SLEExactGauge.Multipoint
+
+def halfPlaneGreenMeasure {Ω : Type*} (κ : ℝ) (B : ℝ≥0 → Ω → ℝ)
+    (γ : Ω → ℝ≥0 → ℂ) (G : Ω → ℝ≥0 → ℂ → ℂ)
+    (t : ℝ≥0) (ω : Ω) : Measure upperHalfPlane :=
+  (volume.withDensity (fun z => ENNReal.ofReal
+    (greenDensity κ (fun s => Real.sqrt κ * B s ω) (γ ω) (G ω) t z))).comap Subtype.val
+
+lemma halfPlaneGreenMeasure_measurable
+    {Ω : Type*} [MeasurableSpace Ω] {B : ℝ≥0 → Ω → ℝ}
+    (hBm : Measurable (Function.uncurry B)) (hBc : ∀ ω, Continuous (fun t => B t ω))
+    (κ : ℝ) (γ : Ω → ℝ≥0 → ℂ) (G F : Ω → ℝ≥0 → ℂ → ℂ)
+    (hw : ∀ ω, IsCapacityTwoWitness (fun t => Real.sqrt κ * B t ω) (γ ω) (G ω) (F ω))
+    (t : ℝ≥0) : Measurable (halfPlaneGreenMeasure κ B γ G 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 [halfPlaneGreenMeasure,comap_subtype_coe_apply isOpen_upperHalfPlane.measurableSet,
+    withDensity_apply _ hAI]
+  exact (actual_greenDensity_joint_measurable hBm hBc κ γ G F hw t).ennreal_ofReal.lintegral_prod_right'
+
+lemma levelCurrentGreen_le_green
+    {Ω : Type*} {B : ℝ≥0 → Ω → ℝ} {κ : ℝ}
+    {γ : Ω → ℝ≥0 → ℂ} {G F : Ω → ℝ≥0 → ℂ → ℂ}
+    (ω : Ω) (hw : IsCapacityTwoWitness
+      (fun s => Real.sqrt κ * B s ω) (γ ω) (G ω) (F ω))
+    (u : ℝ) (t : ℝ≥0) (z : ℂ) :
+    levelCurrentGreen κ B γ G u t z ω ≤
+      greenDensity κ (fun s => Real.sqrt κ * B s ω) (γ ω) (G ω) t z := by
+  unfold levelCurrentGreen
+  split_ifs
+  · exact le_rfl
+  · exact greenDensity_nonneg hw κ t z
+
+lemma halfPlaneCurrentMeasure_le_green
+    {Ω : Type*} {B : ℝ≥0 → Ω → ℝ} {κ : ℝ}
+    {γ : Ω → ℝ≥0 → ℂ} {G F : Ω → ℝ≥0 → ℂ → ℂ}
+    (ω : Ω) (hw : IsCapacityTwoWitness
+      (fun s => Real.sqrt κ * B s ω) (γ ω) (G ω) (F ω)) (u : ℝ) (t : ℝ≥0) :
+    halfPlaneCurrentMeasure κ B γ G u t ω ≤ halfPlaneGreenMeasure κ B γ G t ω := by
+  apply Measure.le_iff.mpr
+  intro A hA
+  have hAI := (MeasurableEmbedding.subtype_coe isOpen_upperHalfPlane.measurableSet).measurableSet_image.mpr hA
+  simp only [halfPlaneCurrentMeasure,halfPlaneGreenMeasure,
+    comap_subtype_coe_apply isOpen_upperHalfPlane.measurableSet,withDensity_apply _ hAI]
+  exact lintegral_mono (fun z => ENNReal.ofReal_le_ofReal (levelCurrentGreen_le_green ω hw u t z))
+
+theorem currentGreen_spatial_mean_tendsto
+    {Ω : Type*} [MeasurableSpace Ω] (P : Measure Ω)
+    {B : ℝ≥0 → Ω → ℝ} (hBm : Measurable (Function.uncurry B))
+    (hBc : ∀ ω, Continuous (fun t => B t ω)) (κ : ℝ)
+    (γ : Ω → ℝ≥0 → ℂ) (G F : Ω → ℝ≥0 → ℂ → ℂ)
+    (hw : ∀ ω, IsCapacityTwoWitness (fun t => Real.sqrt κ * B t ω) (γ ω) (G ω) (F ω))
+    (u : ℕ → ℝ) (hu : ∀ n, 0 ≤ u n) (hmono : Monotone u)
+    (hlim : Tendsto u atTop atTop) (t : ℝ≥0) (K : Set ℂ)
+    (f : ℂ → ℝ≥0∞) (hf : Measurable f) (E : Set Ω) :
+    Tendsto (fun n => ∫⁻ ω in E, (∫⁻ z in K,
+      f z * ENNReal.ofReal (levelCurrentGreen κ B γ G (u n) t z ω) ∂volume) ∂P)
+      atTop (𝓝 (∫⁻ ω in E, (∫⁻ z in K, f z * ENNReal.ofReal
+        (greenDensity κ (fun s => Real.sqrt κ * B s ω) (γ ω) (G ω) t z) ∂volume) ∂P)) := by
+  let a (n : ℕ) (q : Ω × ℂ) :=
+    f q.2 * ENNReal.ofReal (levelCurrentGreen κ B γ G (u n) t q.2 q.1)
+  have ha (n : ℕ) : Measurable (a n) :=
+    (hf.comp measurable_snd).mul
+      (levelCurrentGreen_joint_measurable hBm hBc κ (u n) (hu n) γ G F hw t).ennreal_ofReal
+  have ham (ω : Ω) : Monotone (fun n => fun z => a n (ω,z)) := by
+    intro n m hnm z
+    exact mul_le_mul' le_rfl (ENNReal.ofReal_le_ofReal
+      (levelCurrentGreen_mono ω (hBc ω) (hw ω) z t (hu n) (hmono hnm)))
+  have hal (ω : Ω) : Tendsto (fun n => ∫⁻ z in K, a n (ω,z)) atTop
+      (𝓝 (∫⁻ z in K, f z * ENNReal.ofReal
+        (greenDensity κ (fun s => Real.sqrt κ * B s ω) (γ ω) (G ω) t z))) := by
+    apply lintegral_tendsto_of_tendsto_of_monotone (μ := volume.restrict K)
+      (f := fun n z => a n (ω,z))
+      (fun n => ((ha n).comp (measurable_const.prodMk measurable_id)).aemeasurable)
+      (Eventually.of_forall (fun z n m hnm => ham ω hnm z))
+    filter_upwards [] with z
+    apply tendsto_const_nhds.congr'
+    exact (levelCurrentGreen_eventually_eq ω (hBc ω) (hw ω) z t u hu hlim).mono
+      (fun n hn => congrArg (fun x : ℝ => f z * ENNReal.ofReal x) hn.symm)
+  exact lintegral_tendsto_of_tendsto_of_monotone
+    (fun n => (ha n).lintegral_prod_right'.aemeasurable)
+    (Eventually.of_forall (fun ω n m hnm => lintegral_mono (ham ω hnm)))
+    (Eventually.of_forall hal)
+
+theorem halfPlaneCurrentMeasure_mean_tendsto
+    {Ω : Type*} [MeasurableSpace Ω] (P : Measure Ω)
+    {B : ℝ≥0 → Ω → ℝ} (hBm : Measurable (Function.uncurry B))
+    (hBc : ∀ ω, Continuous (fun t => B t ω)) (κ : ℝ)
+    (γ : Ω → ℝ≥0 → ℂ) (G F : Ω → ℝ≥0 → ℂ → ℂ)
+    (hw : ∀ ω, IsCapacityTwoWitness (fun t => Real.sqrt κ * B t ω) (γ ω) (G ω) (F ω))
+    (u : ℕ → ℝ) (hu : ∀ n, 0 ≤ u n) (hmono : Monotone u)
+    (hlim : Tendsto u atTop atTop) (t : ℝ≥0) (E : Set Ω)
+    (A : Set upperHalfPlane) (hA : MeasurableSet A) :
+    Tendsto (fun n => (P.restrict E).bind (halfPlaneCurrentMeasure κ B γ G (u n) t) A)
+      atTop (𝓝 ((P.restrict E).bind (halfPlaneGreenMeasure κ B γ G t) A)) := by
+  have hAI := (MeasurableEmbedding.subtype_coe isOpen_upperHalfPlane.measurableSet).measurableSet_image.mpr hA
+  simp only [Measure.bind_apply hA
+    (halfPlaneCurrentMeasure_measurable hBm hBc κ (u _) (hu _) γ G F hw t).aemeasurable,
+    Measure.bind_apply hA (halfPlaneGreenMeasure_measurable hBm hBc κ γ G F hw t).aemeasurable,
+    halfPlaneCurrentMeasure,halfPlaneGreenMeasure,
+    comap_subtype_coe_apply isOpen_upperHalfPlane.measurableSet,withDensity_apply _ hAI]
+  simpa only [one_mul] using currentGreen_spatial_mean_tendsto P hBm hBc κ γ G F hw
+    u hu hmono hlim t _ (fun _ => 1) measurable_const E
+
+theorem halfPlaneGreenMeasure_mean_le
+    {Ω : Type*} [MeasurableSpace Ω] {P : Measure Ω}
+    {B : ℝ≥0 → Ω → ℝ} (hB : IsBrownianReal B P)
+    (hBm : Measurable (Function.uncurry B)) (hBc : ∀ ω, Continuous (fun t => B t ω))
+    (hB0 : ∀ ω, B 0 ω = 0) {κ : ℝ} (hκ : 0 < κ) (hκ8 : κ < 8)
+    (γ : Ω → ℝ≥0 → ℂ) (G F : Ω → ℝ≥0 → ℂ → ℂ)
+    (hw : ∀ ω, IsCapacityTwoWitness (fun t => Real.sqrt κ * B t ω) (γ ω) (G ω) (F ω))
+    (t : ℝ≥0) (E : Set Ω) :
+    (P.restrict E).bind (halfPlaneGreenMeasure κ B γ G t) ≤ initialGreenMeasure κ := by
+  let : IsProbabilityMeasure P := hB.isGaussianProcess.isProbabilityMeasure
+  apply Measure.le_iff.mpr
+  intro A hA
+  have hAI := (MeasurableEmbedding.subtype_coe isOpen_upperHalfPlane.measurableSet).measurableSet_image.mpr hA
+  have hAH : (Subtype.val : upperHalfPlane → ℂ) '' A ⊆ upperHalfPlane := by
+    rintro _ ⟨x,_,rfl⟩; exact x.property
+  rw [Measure.bind_apply hA (halfPlaneGreenMeasure_measurable hBm hBc κ γ G F hw t).aemeasurable]
+  simp only [halfPlaneGreenMeasure,initialGreenMeasure,
+    comap_subtype_coe_apply isOpen_upperHalfPlane.measurableSet,withDensity_apply _ hAI]
+  apply (lintegral_mono' Measure.restrict_le_self (le_refl _)).trans
+  rw [lintegral_lintegral_swap
+    (actual_greenDensity_joint_measurable hBm hBc κ γ G F hw t).ennreal_ofReal.aemeasurable]
+  exact setLIntegral_mono' hAI (fun z hz =>
+    greenDensity_mean_le hB hBm hBc hB0 hκ hκ8 γ G F hw z (hAH hz) t)
+
+end SLEExactGauge.Multipoint
+
+end
+
+end OAI
diff --git a/lean/OAI/Probability/SLE/Mass/LevelCurrentTests.lean b/lean/OAI/Probability/SLE/Mass/LevelCurrentTests.lean
new file mode 100644
index 0000000000000000000000000000000000000000..89896d4e6d0200ac70974c2fad2525eb8c96f05c
--- /dev/null
+++ b/lean/OAI/Probability/SLE/Mass/LevelCurrentTests.lean
@@ -0,0 +1,151 @@
+import OAI.Probability.SLE.Mass.LevelCurrentLimit
+import OAI.Probability.SLE.Mass.SignedMeasureConvergence
+
+namespace OAI
+
+/-! Signed compact tests of the current Green mean pass through the
+increasing radius levels. -/
+
+noncomputable section
+open Set Filter MeasureTheory ProbabilityTheory Classical
+open scoped NNReal ENNReal Topology CompactlySupported
+
+namespace SLEExactGauge.Multipoint
+
+local instance : LocallyCompactSpace upperHalfPlane := isOpen_upperHalfPlane.locallyCompactSpace
+
+lemma lintegral_halfPlane_density_test (ρ : ℂ → ℝ≥0∞) (hρ : Measurable ρ)
+    (f : upperHalfPlane → ℝ) (hf : Measurable f) :
+    (∫⁻ z : upperHalfPlane, ENNReal.ofReal (f z)
+      ∂(volume.withDensity ρ).comap Subtype.val) =
+      ∫⁻ z, ENNReal.ofReal (extendHalfPlaneTest f z) * ρ z ∂volume := by
+  calc
+    _ = ∫⁻ z : upperHalfPlane, ENNReal.ofReal (extendHalfPlaneTest f z)
+        ∂(volume.withDensity ρ).comap Subtype.val := by
+      congr 1
+      funext z
+      rw [extendHalfPlaneTest_apply]
+    _ = ∫⁻ z in upperHalfPlane, ENNReal.ofReal (extendHalfPlaneTest f z)
+        ∂volume.withDensity ρ :=
+      lintegral_subtype_comap (μ := volume.withDensity ρ) isOpen_upperHalfPlane.measurableSet
+        (fun z => ENNReal.ofReal (extendHalfPlaneTest f z))
+    _ = ∫⁻ z, ENNReal.ofReal (extendHalfPlaneTest f z) ∂volume.withDensity ρ := by
+      apply setLIntegral_eq_of_support_subset
+      intro z hz
+      by_contra hn
+      exact hz (by
+        dsimp only
+        rw [extendHalfPlaneTest_of_not_mem f z hn,ENNReal.ofReal_zero])
+    _ = _ := by
+      rw [lintegral_withDensity_eq_lintegral_mul _ hρ
+        (extendHalfPlaneTest_measurable f hf).ennreal_ofReal]
+      apply lintegral_congr
+      intro z
+      exact mul_comm _ _
+
+lemma lintegral_density_kernel_test
+    {Ω : Type*} [MeasurableSpace Ω] (P : Measure Ω)
+    (μ : Ω → Measure upperHalfPlane) (hμ : Measurable μ)
+    (ρ : Ω × ℂ → ℝ≥0∞) (hρ : Measurable ρ)
+    (he : ∀ ω, μ ω = (volume.withDensity (fun z => ρ (ω,z))).comap Subtype.val)
+    (f : upperHalfPlane → ℝ) (hf : Measurable f) :
+    (∫⁻ z, ENNReal.ofReal (f z) ∂P.bind μ) =
+      ∫⁻ ω, (∫⁻ z, ENNReal.ofReal (extendHalfPlaneTest f z) * ρ (ω,z) ∂volume) ∂P := by
+  rw [Measure.lintegral_bind hμ.aemeasurable hf.ennreal_ofReal.aemeasurable]
+  apply lintegral_congr
+  intro ω
+  rw [he ω]
+  exact lintegral_halfPlane_density_test _
+    (hρ.comp (measurable_const.prodMk measurable_id)) f hf
+
+lemma halfPlaneCurrentMeasure_mean_lintegral_test
+    {Ω : Type*} [MeasurableSpace Ω] (P : Measure Ω)
+    {B : ℝ≥0 → Ω → ℝ} (hBm : Measurable (Function.uncurry B))
+    (hBc : ∀ ω, Continuous (fun t => B t ω)) (κ u : ℝ) (hu : 0 ≤ u)
+    (γ : Ω → ℝ≥0 → ℂ) (G F : Ω → ℝ≥0 → ℂ → ℂ)
+    (hw : ∀ ω, IsCapacityTwoWitness (fun t => Real.sqrt κ * B t ω) (γ ω) (G ω) (F ω))
+    (t : ℝ≥0) (f : upperHalfPlane → ℝ) (hf : Measurable f) :
+    (∫⁻ z, ENNReal.ofReal (f z) ∂P.bind (halfPlaneCurrentMeasure κ B γ G u t)) =
+      ∫⁻ ω, (∫⁻ z, ENNReal.ofReal (extendHalfPlaneTest f z) *
+        ENNReal.ofReal (levelCurrentGreen κ B γ G u t z ω) ∂volume) ∂P :=
+  lintegral_density_kernel_test P _
+    (halfPlaneCurrentMeasure_measurable hBm hBc κ u hu γ G F hw t) _
+    (levelCurrentGreen_joint_measurable hBm hBc κ u hu γ G F hw t).ennreal_ofReal
+    (fun _ => rfl) f hf
+
+lemma halfPlaneGreenMeasure_mean_lintegral_test
+    {Ω : Type*} [MeasurableSpace Ω] (P : Measure Ω)
+    {B : ℝ≥0 → Ω → ℝ} (hBm : Measurable (Function.uncurry B))
+    (hBc : ∀ ω, Continuous (fun t => B t ω)) (κ : ℝ)
+    (γ : Ω → ℝ≥0 → ℂ) (G F : Ω → ℝ≥0 → ℂ → ℂ)
+    (hw : ∀ ω, IsCapacityTwoWitness (fun t => Real.sqrt κ * B t ω) (γ ω) (G ω) (F ω))
+    (t : ℝ≥0) (f : upperHalfPlane → ℝ) (hf : Measurable f) :
+    (∫⁻ z, ENNReal.ofReal (f z) ∂P.bind (halfPlaneGreenMeasure κ B γ G t)) =
+      ∫⁻ ω, (∫⁻ z, ENNReal.ofReal (extendHalfPlaneTest f z) * ENNReal.ofReal
+        (greenDensity κ (fun s => Real.sqrt κ * B s ω) (γ ω) (G ω) t z) ∂volume) ∂P :=
+  lintegral_density_kernel_test P _ (halfPlaneGreenMeasure_measurable hBm hBc κ γ G F hw t) _
+    (actual_greenDensity_joint_measurable hBm hBc κ γ G F hw t).ennreal_ofReal
+    (fun _ => rfl) f hf
+
+lemma halfPlaneCurrentMeasure_mean_lintegral_test_tendsto
+    {Ω : Type*} [MeasurableSpace Ω] (P : Measure Ω)
+    {B : ℝ≥0 → Ω → ℝ} (hBm : Measurable (Function.uncurry B))
+    (hBc : ∀ ω, Continuous (fun t => B t ω)) (κ : ℝ)
+    (γ : Ω → ℝ≥0 → ℂ) (G F : Ω → ℝ≥0 → ℂ → ℂ)
+    (hw : ∀ ω, IsCapacityTwoWitness (fun t => Real.sqrt κ * B t ω) (γ ω) (G ω) (F ω))
+    (u : ℕ → ℝ) (hu : ∀ n, 0 ≤ u n) (hmono : Monotone u)
+    (hlim : Tendsto u atTop atTop) (t : ℝ≥0) (E : Set Ω)
+    (f : upperHalfPlane → ℝ) (hf : Measurable f) :
+    Tendsto (fun n => ∫⁻ z, ENNReal.ofReal (f z)
+      ∂(P.restrict E).bind (halfPlaneCurrentMeasure κ B γ G (u n) t)) atTop
+      (𝓝 (∫⁻ z, ENNReal.ofReal (f z) ∂(P.restrict E).bind (halfPlaneGreenMeasure κ B γ G t))) := by
+  simp_rw [halfPlaneCurrentMeasure_mean_lintegral_test _ hBm hBc κ _ (hu _) γ G F hw t f hf,
+    halfPlaneGreenMeasure_mean_lintegral_test _ hBm hBc κ γ G F hw t f hf]
+  simpa only [Measure.restrict_univ] using currentGreen_spatial_mean_tendsto P hBm hBc κ γ G F hw
+    u hu hmono hlim t univ (fun z => ENNReal.ofReal (extendHalfPlaneTest f z))
+    (extendHalfPlaneTest_measurable f hf).ennreal_ofReal E
+
+lemma halfPlaneCurrentMeasure_mean_le
+    {Ω : Type*} [MeasurableSpace Ω] {P : Measure Ω}
+    {B : ℝ≥0 → Ω → ℝ} (hB : IsBrownianReal B P)
+    (hBm : Measurable (Function.uncurry B)) (hBc : ∀ ω, Continuous (fun t => B t ω))
+    (hB0 : ∀ ω, B 0 ω = 0) {κ : ℝ} (hκ : 0 < κ) (hκ8 : κ < 8)
+    (γ : Ω → ℝ≥0 → ℂ) (G F : Ω → ℝ≥0 → ℂ → ℂ)
+    (hw : ∀ ω, IsCapacityTwoWitness (fun t => Real.sqrt κ * B t ω) (γ ω) (G ω) (F ω))
+    (u : ℝ) (hu : 0 ≤ u) (t : ℝ≥0) (E : Set Ω) :
+    (P.restrict E).bind (halfPlaneCurrentMeasure κ B γ G u t) ≤ initialGreenMeasure κ := by
+  apply le_trans ?_ (halfPlaneGreenMeasure_mean_le hB hBm hBc hB0 hκ hκ8 γ G F hw t E)
+  apply Measure.le_iff.mpr
+  intro A hA
+  rw [Measure.bind_apply hA (halfPlaneCurrentMeasure_measurable hBm hBc κ u hu γ G F hw t).aemeasurable,
+    Measure.bind_apply hA (halfPlaneGreenMeasure_measurable hBm hBc κ γ G F hw t).aemeasurable]
+  exact lintegral_mono (fun ω => halfPlaneCurrentMeasure_le_green ω (hw ω) u t A)
+
+theorem halfPlaneCurrentMeasure_mean_test_tendsto
+    {Ω : Type*} [MeasurableSpace Ω] {P : Measure Ω}
+    {B : ℝ≥0 → Ω → ℝ} (hB : IsBrownianReal B P)
+    (hBm : Measurable (Function.uncurry B)) (hBc : ∀ ω, Continuous (fun t => B t ω))
+    (hB0 : ∀ ω, B 0 ω = 0) {κ : ℝ} (hκ : 0 < κ) (hκ8 : κ < 8)
+    (γ : Ω → ℝ≥0 → ℂ) (G F : Ω → ℝ≥0 → ℂ → ℂ)
+    (hw : ∀ ω, IsCapacityTwoWitness (fun t => Real.sqrt κ * B t ω) (γ ω) (G ω) (F ω))
+    (u : ℕ → ℝ) (hu : ∀ n, 0 ≤ u n) (hmono : Monotone u)
+    (hlim : Tendsto u atTop atTop) (t : ℝ≥0) (E : Set Ω)
+    (f : C_c(upperHalfPlane,ℝ)) :
+    Tendsto (fun n => ∫ z, f z ∂(P.restrict E).bind (halfPlaneCurrentMeasure κ B γ G (u n) t))
+      atTop (𝓝 (∫ z, f z ∂(P.restrict E).bind (halfPlaneGreenMeasure κ B γ G t))) := by
+  let : IsFiniteMeasureOnCompacts (initialGreenMeasure κ) := initialGreenMeasure_finite_on_compacts κ
+  have hfi : Integrable f (initialGreenMeasure κ) := f.integrable
+  apply integral_tendsto_of_lintegral_pos_neg
+  · exact fun n => hfi.mono_measure (halfPlaneCurrentMeasure_mean_le hB hBm hBc hB0 hκ hκ8
+      γ G F hw (u n) (hu n) t E)
+  · exact hfi.mono_measure (halfPlaneGreenMeasure_mean_le hB hBm hBc hB0 hκ hκ8 γ G F hw t E)
+  · exact halfPlaneCurrentMeasure_mean_lintegral_test_tendsto P hBm hBc κ γ G F hw
+      u hu hmono hlim t E f f.continuous.measurable
+  · exact halfPlaneCurrentMeasure_mean_lintegral_test_tendsto P hBm hBc κ γ G F hw
+      u hu hmono hlim t E (fun z => -f z) f.continuous.measurable.neg
+
+end SLEExactGauge.Multipoint
+
+end
+
+end OAI
diff --git a/lean/OAI/Probability/SLE/Mass/LevelGreenLimit.lean b/lean/OAI/Probability/SLE/Mass/LevelGreenLimit.lean
new file mode 100644
index 0000000000000000000000000000000000000000..bbe3ec72a67dce92d5a8caf38e4fdab69ef80b85
--- /dev/null
+++ b/lean/OAI/Probability/SLE/Mass/LevelGreenLimit.lean
@@ -0,0 +1,120 @@
+import OAI.Probability.SLE.Mass.LevelApproximationKernel
+import OAI.Probability.SLE.Multipoint.MultipointRadiusStatus
+
+namespace OAI
+
+/-! As the radius level tends to infinity, the remaining finite-level
+kernel increases to the killed Green potential. -/
+
+noncomputable section
+open Set Filter MeasureTheory ProbabilityTheory Classical
+open scoped NNReal ENNReal Topology
+
+namespace SLEExactGauge.Multipoint
+
+lemma levelCurrentGreen_mono
+    {Ω : Type*} {B : ℝ≥0 → Ω → ℝ} {κ : ℝ}
+    {γ : Ω → ℝ≥0 → ℂ} {G F : Ω → ℝ≥0 → ℂ → ℂ}
+    (ω : Ω) (hBc : Continuous (fun s => B s ω))
+    (hw : IsCapacityTwoWitness (fun s => Real.sqrt κ * B s ω) (γ ω) (G ω) (F ω))
+    (z : ℂ) (t : ℝ≥0) {u v : ℝ} (hu : 0 ≤ u) (huv : u ≤ v) :
+    levelCurrentGreen κ B γ G u t z ω ≤ levelCurrentGreen κ B γ G v t z ω := by
+  have hτ := radiusLevelTime_mono (hBc.const_mul _) hw z hu huv
+  unfold levelCurrentGreen
+  split_ifs with h₁ h₂
+  · exact le_rfl
+  · exact False.elim (h₂ (h₁.trans_le hτ))
+  · exact greenDensity_nonneg hw κ t z
+  · exact le_rfl
+
+lemma levelCurrentGreen_eventually_eq
+    {Ω : Type*} {B : ℝ≥0 → Ω → ℝ} {κ : ℝ}
+    {γ : Ω → ℝ≥0 → ℂ} {G F : Ω → ℝ≥0 → ℂ → ℂ}
+    (ω : Ω) (hBc : Continuous (fun s => B s ω))
+    (hw : IsCapacityTwoWitness (fun s => Real.sqrt κ * B s ω) (γ ω) (G ω) (F ω))
+    (z : ℂ) (t : ℝ≥0) (u : ℕ → ℝ) (hu : ∀ n, 0 ≤ u n)
+    (hlim : Tendsto u atTop atTop) :
+    ∀ᶠ n in atTop, levelCurrentGreen κ B γ G (u n) t z ω =
+      greenDensity κ (fun s => Real.sqrt κ * B s ω) (γ ω) (G ω) t z := by
+  by_cases hz : z ∈ survivingDomain (γ ω) t
+  · filter_upwards [hlim.eventually (eventually_gt_atTop
+      (logRadiusClock (Real.log z.im) (logLoewnerCoordinates (G ω) z t)))] with n hn
+    have hτ : (t : ℝ≥0∞) < radiusLevelTime (γ ω) (G ω) z (u n) := by
+      apply lt_of_not_ge
+      rw [radiusLevelTime_le_iff_clock (hBc.const_mul _) hw z (u n) (hu n) t hz]
+      exact not_le.mpr hn
+    exact ite_eq_left hτ
+  · filter_upwards [] with n
+    unfold levelCurrentGreen greenDensity
+    simp only [ite_eq_right hz,ite_self]
+
+theorem levelCurrentGreen_mean_le
+    {Ω : Type*} [mΩ : 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) := by
+  let : IsProbabilityMeasure P := hB.isGaussianProcess.isProbabilityMeasure
+  have he := levelRemainderGreen_setLIntegral hB hBm hBc hB0 hκ hκ8 γ G F
+    (ae_of_all _ hw) z hz u hu t univ MeasurableSet.univ
+  simp only [Measure.restrict_univ] at he
+  rw [← he]
+  calc
+    _ ≤ ∫⁻ ω, ENNReal.ofReal (stoppedGreen κ (fun s => Real.sqrt κ * B s ω)
+        (γ ω) (G ω) z u) ∂P := by
+      apply lintegral_mono
+      intro ω
+      unfold levelRemainderGreen
+      dsimp only
+      split_ifs
+      · exact le_rfl
+      · rw [ENNReal.ofReal_zero]
+        positivity
+    _ = _ := by
+      obtain ⟨hi,he⟩ := finite_stopped_green_regular hB hBm hBc hB0 κ hκ hκ8 γ G F
+        (ae_of_all _ hw) z hz u hu
+      rw [← ofReal_integral_eq_lintegral_ofReal hi
+        (ae_of_all _ (fun ω => stoppedGreen_nonneg (hw ω) κ z u)),he]
+
+theorem greenDensity_mean_le
+    {Ω : Type*} [mΩ : 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) (t : ℝ≥0) :
+    (∫⁻ ω, ENNReal.ofReal (greenDensity κ (fun s => Real.sqrt κ * B s ω)
+      (γ ω) (G ω) t z) ∂P) ≤ ENNReal.ofReal (initialGreen κ z) := by
+  have hm (n : ℕ) : Measurable (fun ω => ENNReal.ofReal (levelCurrentGreen κ B γ G n t z ω)) := by
+    have hj := (levelCurrentGreen_joint_measurable hBm hBc κ n (Nat.cast_nonneg n) γ G F hw t).ennreal_ofReal
+    have hp : Measurable (fun ω : Ω => (ω,z)) := measurable_id.prodMk measurable_const
+    have hh := hj.comp hp
+    simpa only [Function.comp_def] using hh
+  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 (fun n => levelCurrentGreen_mean_le hB hBm hBc hB0 hκ hκ8 γ G F hw z hz
+      n (Nat.cast_nonneg n) t))
+
+end SLEExactGauge.Multipoint
+
+end
+
+end OAI
diff --git a/lean/OAI/Probability/SLE/Mass/LevelMeanMeasure.lean b/lean/OAI/Probability/SLE/Mass/LevelMeanMeasure.lean
new file mode 100644
index 0000000000000000000000000000000000000000..b8e23585d020f67994337172667867ce68db91b9
--- /dev/null
+++ b/lean/OAI/Probability/SLE/Mass/LevelMeanMeasure.lean
@@ -0,0 +1,94 @@
+import OAI.Probability.SLE.Mass.HalfPlaneLevelMeasures
+import OAI.Probability.SLE.Mass.LevelApproximationMean
+import OAI.Probability.SLE.Mass.RadonKernelIntegral
+
+namespace OAI
+
+/-! The exact mean measure of every terminal level approximation. -/
+
+noncomputable section
+open Set Filter MeasureTheory ProbabilityTheory Classical
+open scoped NNReal ENNReal Topology CompactlySupported
+
+namespace SLEExactGauge.Multipoint
+
+def initialGreenMeasure (κ : ℝ) : Measure upperHalfPlane :=
+  (volume.withDensity (fun z => ENNReal.ofReal (initialGreen κ z))).comap Subtype.val
+
+lemma initialGreenMeasure_finite_on_compacts (κ : ℝ) :
+    IsFiniteMeasureOnCompacts (initialGreenMeasure κ) := by
+  constructor
+  intro K hK
+  let L := (Subtype.val : upperHalfPlane → ℂ) '' K
+  have hL : IsCompact L := hK.image continuous_subtype_val
+  have hLH : L ⊆ upperHalfPlane := by rintro _ ⟨x,_,rfl⟩; exact x.property
+  obtain ⟨C,hC⟩ := hL.bddAbove_image ((initialGreen_continuousOn κ).mono hLH)
+  rw [initialGreenMeasure,comap_subtype_coe_apply isOpen_upperHalfPlane.measurableSet,
+    withDensity_apply _ hL.measurableSet]
+  apply lt_of_le_of_lt (setLIntegral_mono' hL.measurableSet (fun z hz =>
+    ENNReal.ofReal_le_ofReal (hC ⟨z,hz,rfl⟩)))
+  rw [setLIntegral_const]
+  exact ENNReal.mul_lt_top ENNReal.ofReal_lt_top hL.measure_lt_top
+
+lemma halfPlaneLevelMeasure_measurable
+    {Ω : Type*} [MeasurableSpace Ω] {B : ℝ≥0 → Ω → ℝ}
+    (hm : ∀ t, Measurable (B t)) (hBc : ∀ ω, Continuous (fun t => B t ω))
+    (κ u : ℝ) (hu : 0 ≤ u)
+    (γ : Ω → ℝ≥0 → ℂ) (G F : Ω → ℝ≥0 → ℂ → ℂ)
+    (hw : ∀ ω, IsCapacityTwoWitness (fun t => Real.sqrt κ * B t ω) (γ ω) (G ω) (F ω))
+    (t : ℝ≥0∞) : Measurable (halfPlaneLevelMeasure κ B γ G u t) := by
+  apply Measure.measurable_of_measurable_coe
+  intro A hA
+  have hAI := (MeasurableEmbedding.subtype_coe isOpen_upperHalfPlane.measurableSet).measurableSet_image.mpr hA
+  simp only [halfPlaneLevelMeasure,comap_subtype_coe_apply isOpen_upperHalfPlane.measurableSet]
+  exact levelApproximation_measurable_apply hm hBc κ u hu γ G F hw t hAI
+
+theorem halfPlaneLevelMeasure_terminal_mean
+    {Ω : 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 ω))
+    (u : ℝ) (hu : 0 ≤ u) :
+    P.bind (halfPlaneLevelMeasure κ B γ G u ∞) = initialGreenMeasure κ := by
+  apply Measure.ext
+  intro A hA
+  have hAI := (MeasurableEmbedding.subtype_coe isOpen_upperHalfPlane.measurableSet).measurableSet_image.mpr hA
+  have hAH : (Subtype.val : upperHalfPlane → ℂ) '' A ⊆ upperHalfPlane := by
+    rintro _ ⟨x,_,rfl⟩; exact x.property
+  rw [Measure.bind_apply hA (halfPlaneLevelMeasure_measurable hm hBc κ u hu γ G F hw ∞).aemeasurable]
+  simp only [halfPlaneLevelMeasure,comap_subtype_coe_apply isOpen_upperHalfPlane.measurableSet,
+    levelApproximation_apply_top κ B γ G u _ hAI]
+  rw [initialGreenMeasure,comap_subtype_coe_apply isOpen_upperHalfPlane.measurableSet,
+    withDensity_apply _ hAI]
+  exact levelMass_mean hB hm hBm hBc hB0 hκ hκ8 γ G F hw _ hAI hAH u hu
+
+theorem halfPlaneLevelMeasure_terminal_test_mean
+    {Ω : 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 ω))
+    (u : ℝ) (hu : 0 ≤ u) (f : C_c(upperHalfPlane,ℝ)) :
+    (∫ ω, (∫ z, f z ∂halfPlaneLevelMeasure κ B γ G u ∞ ω) ∂P) =
+      ∫ z, f z ∂initialGreenMeasure κ := by
+  have he := halfPlaneLevelMeasure_terminal_mean hB hm hBm hBc hB0 hκ hκ8 γ G F hw u hu
+  rw [← he]
+  apply integral_bind_of_integrable_sections P _
+    (halfPlaneLevelMeasure_measurable hm hBc κ u hu γ G F hw ∞) f f.continuous.measurable
+  · intro ω
+    let := halfPlaneLevelMeasure_finite_on_compacts hκ hκ8 γ G F ω (hBc ω) (hw ω) u ∞
+    exact f.integrable
+  · rw [he]
+    let := initialGreenMeasure_finite_on_compacts κ
+    exact f.integrable
+
+end SLEExactGauge.Multipoint
+
+end
+
+end OAI
diff --git a/lean/OAI/Probability/SLE/Mass/LevelRadonExtraction.lean b/lean/OAI/Probability/SLE/Mass/LevelRadonExtraction.lean
new file mode 100644
index 0000000000000000000000000000000000000000..a5af8df967af92a4ad7163d658d002d6f09f68ce
--- /dev/null
+++ b/lean/OAI/Probability/SLE/Mass/LevelRadonExtraction.lean
@@ -0,0 +1,188 @@
+import OAI.Probability.SLE.Mass.HalfPlaneLevelMeasures
+import OAI.Probability.SLE.Mass.RadonTestFamily
+import OAI.Probability.SLE.Mass.L2MeanConvergence
+
+namespace OAI
+
+/-! One sequence of convex level measures converges vaguely at every
+prescribed countable time, on one event of probability one. -/
+
+noncomputable section
+open Set Filter MeasureTheory ProbabilityTheory Classical
+open scoped NNReal ENNReal Topology CompactlySupported
+
+namespace SLEExactGauge.Multipoint
+
+local instance : LocallyCompactSpace upperHalfPlane := isOpen_upperHalfPlane.locallyCompactSpace
+
+def convexLevelMeasure {Ω : Type*} (κ : ℝ) (B : ℝ≥0 → Ω → ℝ)
+    (γ : Ω → ℝ≥0 → ℂ) (G : Ω → ℝ≥0 → ℂ → ℂ) (u : ℕ → ℝ)
+    (s : ℕ → Finset ℕ) (w : ℕ → ℕ → ℝ) (n : ℕ) (t : ℝ≥0∞) (ω : Ω) :
+    Measure upperHalfPlane :=
+  ∑ i ∈ s n, ENNReal.ofReal (w n i) • halfPlaneLevelMeasure κ B γ G (u (n+i)) t ω
+
+lemma convexLevelMeasure_finite_on_compacts
+    {Ω : Type*} {B : ℝ≥0 → Ω → ℝ} {κ : ℝ} (hκ : 0 < κ) (hκ8 : κ < 8)
+    (γ : Ω → ℝ≥0 → ℂ) (G F : Ω → ℝ≥0 → ℂ → ℂ)
+    (ω : Ω) (hBc : Continuous (fun t => B t ω))
+    (hw : IsCapacityTwoWitness (fun t => Real.sqrt κ * B t ω) (γ ω) (G ω) (F ω))
+    (u : ℕ → ℝ) (s : ℕ → Finset ℕ) (w : ℕ → ℕ → ℝ) (n : ℕ) (t : ℝ≥0∞) :
+    IsFiniteMeasureOnCompacts (convexLevelMeasure κ B γ G u s w n t ω) := by
+  constructor
+  intro K hK
+  rw [convexLevelMeasure,Measure.finsetSum_apply]
+  apply ENNReal.sum_lt_top.mpr
+  intro i hi
+  rw [Measure.smul_apply,smul_eq_mul]
+  let := halfPlaneLevelMeasure_finite_on_compacts hκ hκ8 γ G F ω hBc hw (u (n+i)) t
+  exact ENNReal.mul_lt_top ENNReal.ofReal_lt_top hK.measure_lt_top
+
+lemma integral_convexLevelMeasure
+    {Ω : Type*} {B : ℝ≥0 → Ω → ℝ} {κ : ℝ} (hκ : 0 < κ) (hκ8 : κ < 8)
+    (γ : Ω → ℝ≥0 → ℂ) (G F : Ω → ℝ≥0 → ℂ → ℂ)
+    (ω : Ω) (hBc : Continuous (fun t => B t ω))
+    (hw : IsCapacityTwoWitness (fun t => Real.sqrt κ * B t ω) (γ ω) (G ω) (F ω))
+    (u : ℕ → ℝ) (s : ℕ → Finset ℕ) (w : ℕ → ℕ → ℝ) (n : ℕ) (t : ℝ≥0∞)
+    (hw₀ : ∀ i ∈ s n, 0 ≤ w n i) (f : C_c(upperHalfPlane,ℝ)) :
+    (∫ z, f z ∂convexLevelMeasure κ B γ G u s w n t ω) =
+      ∑ i ∈ s n, w n i * levelApproximationRealTest κ B γ G (u (n+i)) t (extendHalfPlaneTest f) ω := by
+  have hi (i : ℕ) : Integrable f
+      (ENNReal.ofReal (w n i) • halfPlaneLevelMeasure κ B γ G (u (n+i)) t ω) := by
+    let := halfPlaneLevelMeasure_finite_on_compacts hκ hκ8 γ G F ω hBc hw (u (n+i)) t
+    let : IsFiniteMeasureOnCompacts
+        (ENNReal.ofReal (w n i) • halfPlaneLevelMeasure κ B γ G (u (n+i)) t ω) :=
+      IsFiniteMeasureOnCompacts.smul
+        (halfPlaneLevelMeasure κ B γ G (u (n+i)) t ω) ENNReal.ofReal_ne_top
+    exact f.integrable
+  rw [convexLevelMeasure,integral_finsetSum_measure (fun i _ => hi i)]
+  apply Finset.sum_congr rfl
+  intro i his
+  rw [integral_smul_measure,ENNReal.toReal_ofReal (hw₀ i his),smul_eq_mul,
+    integral_halfPlaneLevelMeasure]
+
+theorem exists_common_halfPlane_test_limits_with_pairings
+    {Ω : 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)
+    (f : ℕ → C_c(upperHalfPlane,ℝ)) (u : ℕ → ℝ) (hu : ∀ n, 0 ≤ u n)
+    (t : ℕ → ℝ≥0∞) :
+    ∃ x : ℕ → Lp ℝ 2 P, ∃ s : ℕ → Finset ℕ, ∃ w : ℕ → ℕ → ℝ,
+      (∀ n i, i ∈ s n → 0 ≤ w n i) ∧ (∀ n, ∑ i ∈ s n, w n i = 1) ∧
+      (∀ j, Tendsto (fun n => ∫ ω, (∫ z, f j z ∂convexLevelMeasure κ B γ G u s w n (t j) ω) ∂P)
+        atTop (𝓝 (∫ ω, x j ω ∂P))) ∧
+      (∀ j (a : Ω → ℝ), MemLp a 2 P →
+        Tendsto (fun n => ∫ ω, a ω * (∫ z, f j z ∂convexLevelMeasure κ B γ G u s w n (t j) ω) ∂P)
+          atTop (𝓝 (∫ ω, a ω * x j ω ∂P))) ∧
+      (∀ᵐ ω ∂P, ∀ j, Tendsto (fun n => ∫ z, f j z ∂convexLevelMeasure κ B γ G u s w n (t j) ω)
+        atTop (𝓝 (x j ω))) := by
+  let φ (j : ℕ) := extendHalfPlaneTest (f j)
+  let K (j : ℕ) := (Subtype.val : upperHalfPlane → ℂ) '' tsupport (f j)
+  have hK (j : ℕ) : IsCompact (K j) := (f j).hasCompactSupport.image continuous_subtype_val
+  have hKH (j : ℕ) : K j ⊆ upperHalfPlane := by
+    rintro _ ⟨x,_,rfl⟩
+    exact x.property
+  have hφ (j : ℕ) : Measurable (φ j) := extendHalfPlaneTest_measurable _ (f j).continuous.measurable
+  have info (j : ℕ) := uniform_signed_levelTest_L2 hB hm hBm hBc hB0 hκ hκ8 γ G F hw hgrowth
+    (K j) (hK j) (hKH j) (φ j) (hφ j) ‖(f j).toBoundedContinuousFunction‖
+    (fun z _ => extendHalfPlaneTest_norm_le _ z) (extendHalfPlaneTest_support (f j))
+  let A (n j : ℕ) := levelApproximationRealTest κ B γ G (u n) (t j) (φ j)
+  have hLp (n j : ℕ) : MemLp (A n j) 2 P := (info j).1 (u n) (hu n) (t j)
+  have hbound (j : ℕ) : ∃ D : ℝ, ∀ n, ‖(hLp n j).toLp (A n j)‖ ≤ D := by
+    obtain ⟨D,hD⟩ := (info j).2
+    exact ⟨D,fun n => hD (u n) (hu n) (t j) (hLp n j)⟩
+  obtain ⟨x,s,w,hw₀,hw₁,hL2,hc⟩ := exists_randomVariable_convex_tail_limit A hLp hbound
+  refine ⟨x,s,w,hw₀,hw₁,?_,?_,?_⟩
+  · intro j
+    let : IsProbabilityMeasure P := hB.isGaussianProcess.isProbabilityMeasure
+    have hmean := weighted_randomVariable_integral_tendsto P (fun n => A n j)
+      (fun n => hLp n j) s w (x j) (hL2 j)
+    convert hmean using 1
+    funext n
+    apply integral_congr_ae
+    filter_upwards [] with ω
+    exact integral_convexLevelMeasure hκ hκ8 γ G F ω (hBc ω) (hw ω) u s w n (t j)
+      (hw₀ n) (f j)
+  · intro j a ha
+    have hmean := weighted_randomVariable_pairing_tendsto P (fun n => A n j)
+      (fun n => hLp n j) s w (x j) (hL2 j) a ha
+    convert hmean using 1
+    funext n
+    apply integral_congr_ae
+    filter_upwards [] with ω
+    apply congrArg (fun v : ℝ => a ω * v)
+    exact integral_convexLevelMeasure hκ hκ8 γ G F ω (hBc ω) (hw ω) u s w n (t j)
+      (hw₀ n) (f j)
+  · filter_upwards [hc] with ω hω
+    intro j
+    simpa only [integral_convexLevelMeasure hκ hκ8 γ G F ω (hBc ω) (hw ω) u s w _ _
+      (hw₀ _) (f j),A,φ] using hω j
+
+theorem exists_common_halfPlane_test_limits
+    {Ω : Type*} [MeasurableSpace Ω]
+    {P : Measure Ω} {B : ℝ≥0 → Ω → ℝ} (hB : IsBrownianReal B P)
+    (hm : ∀ t, Measurable (B t)) (hBm : Measurable (Function.uncurry B))
+    (hBc : ∀ ω, Continuous (fun t => B t ω)) (hB0 : ∀ ω, B 0 ω = 0)
+    {κ : ℝ} (hκ : 0 < κ) (hκ8 : κ < 8)
+    (γ : Ω → ℝ≥0 → ℂ) (G F : Ω → ℝ≥0 → ℂ → ℂ)
+    (hw : ∀ ω, IsCapacityTwoWitness (fun t => Real.sqrt κ * B t ω) (γ ω) (G ω) (F ω))
+    (hgrowth : PublishedDiskUnivalentGrowth)
+    (f : ℕ → C_c(upperHalfPlane,ℝ)) (u : ℕ → ℝ) (hu : ∀ n, 0 ≤ u n)
+    (t : ℕ → ℝ≥0∞) :
+    ∃ x : ℕ → Lp ℝ 2 P, ∃ s : ℕ → Finset ℕ, ∃ w : ℕ → ℕ → ℝ,
+      (∀ n i, i ∈ s n → 0 ≤ w n i) ∧ (∀ n, ∑ i ∈ s n, w n i = 1) ∧
+      (∀ j, Tendsto (fun n => ∫ ω, (∫ z, f j z ∂convexLevelMeasure κ B γ G u s w n (t j) ω) ∂P)
+        atTop (𝓝 (∫ ω, x j ω ∂P))) ∧
+      (∀ᵐ ω ∂P, ∀ j, Tendsto (fun n => ∫ z, f j z ∂convexLevelMeasure κ B γ G u s w n (t j) ω)
+        atTop (𝓝 (x j ω))) := by
+  obtain ⟨x,s,w,hw₀,hw₁,hm,_,ha⟩ := exists_common_halfPlane_test_limits_with_pairings
+    hB hm hBm hBc hB0 hκ hκ8 γ G F hw hgrowth f u hu t
+  exact ⟨x,s,w,hw₀,hw₁,hm,ha⟩
+
+/-- The same convex level measures have one Radon limit at all times in
+an arbitrary countable list. The spatial determining family is constructed,
+and is not an additional input. -/
+theorem exists_common_level_radon_limits
+    {Ω : Type*} [MeasurableSpace Ω]
+    {P : Measure Ω} {B : ℝ≥0 → Ω → ℝ} (hB : IsBrownianReal B P)
+    (hm : ∀ t, Measurable (B t)) (hBm : Measurable (Function.uncurry B))
+    (hBc : ∀ ω, Continuous (fun t => B t ω)) (hB0 : ∀ ω, B 0 ω = 0)
+    {κ : ℝ} (hκ : 0 < κ) (hκ8 : κ < 8)
+    (γ : Ω → ℝ≥0 → ℂ) (G F : Ω → ℝ≥0 → ℂ → ℂ)
+    (hw : ∀ ω, IsCapacityTwoWitness (fun t => Real.sqrt κ * B t ω) (γ ω) (G ω) (F ω))
+    (hgrowth : PublishedDiskUnivalentGrowth)
+    (u : ℕ → ℝ) (hu : ∀ n, 0 ≤ u n) (t : ℕ → ℝ≥0∞) :
+    ∃ s : ℕ → Finset ℕ, ∃ w : ℕ → ℕ → ℝ,
+      (∀ n i, i ∈ s n → 0 ≤ w n i) ∧ (∀ n, ∑ i ∈ s n, w n i = 1) ∧
+      (∀ᵐ ω ∂P, ∃ ν : ℕ → Measure upperHalfPlane,
+        (∀ j, (ν j).Regular ∧ IsFiniteMeasureOnCompacts (ν j)) ∧
+        ∀ j (f : C_c(upperHalfPlane,ℝ)),
+          Tendsto (fun n => ∫ z, f z ∂convexLevelMeasure κ B γ G u s w n (t j) ω)
+            atTop (𝓝 (∫ z, f z ∂ν j))) := by
+  let D := localTestFamily upperHalfPlane
+  obtain ⟨x,s,w,hw₀,hw₁,_,hconv⟩ := exists_common_halfPlane_test_limits hB hm hBm hBc hB0 hκ hκ8
+    γ G F hw hgrowth (fun j => D.test (Nat.unpair j).2) u hu (fun j => t (Nat.unpair j).1)
+  refine ⟨s,w,hw₀,hw₁,?_⟩
+  filter_upwards [hconv] with ω hω
+  have hex (j : ℕ) : ∃ ν : Measure upperHalfPlane, ν.Regular ∧ IsFiniteMeasureOnCompacts ν ∧
+      ∀ f : C_c(upperHalfPlane,ℝ),
+        Tendsto (fun n => ∫ z, f z ∂convexLevelMeasure κ B γ G u s w n (t j) ω)
+          atTop (𝓝 (∫ z, f z ∂ν)) := by
+    let (n : ℕ) : IsFiniteMeasureOnCompacts (convexLevelMeasure κ B γ G u s w n (t j) ω) :=
+      convexLevelMeasure_finite_on_compacts hκ hκ8 γ G F ω (hBc ω) (hw ω) u s w n (t j)
+    apply D.exists_radon_limit
+    intro k
+    refine ⟨x (Nat.pair j k) ω,?_⟩
+    simpa only [Nat.unpair_pair] using hω (Nat.pair j k)
+  choose ν hν using hex
+  exact ⟨ν,fun j => ⟨(hν j).1,(hν j).2.1⟩,fun j => (hν j).2.2⟩
+
+end SLEExactGauge.Multipoint
+
+end
+
+end OAI
diff --git a/lean/OAI/Probability/SLE/Mass/LevelRadonKernel.lean b/lean/OAI/Probability/SLE/Mass/LevelRadonKernel.lean
new file mode 100644
index 0000000000000000000000000000000000000000..601fb8b18cf22a8567d336a2596165c954f038cc
--- /dev/null
+++ b/lean/OAI/Probability/SLE/Mass/LevelRadonKernel.lean
@@ -0,0 +1,129 @@
+import OAI.Probability.SLE.Mass.ConvexCurrentMean
+import OAI.Probability.SLE.Mass.LevelRadonMoments
+import OAI.Probability.SLE.Mass.RadonTestDetermines
+
+namespace OAI
+
+/-! Passage of the conditional Green kernel to the actual common Radon
+limits. The hypotheses on the limits are exactly those furnished by the
+common convex extraction, including its retained L² pairings. -/
+
+noncomputable section
+open Set Filter MeasureTheory ProbabilityTheory Classical
+open scoped NNReal ENNReal Topology CompactlySupported
+
+namespace SLEExactGauge.Multipoint
+
+local instance : LocallyCompactSpace upperHalfPlane := isOpen_upperHalfPlane.locallyCompactSpace
+
+lemma level_radon_mean_finite_on_compacts
+    {Ω : Type*} [MeasurableSpace Ω] {P : Measure Ω}
+    {B : ℝ≥0 → Ω → ℝ} (hB : IsBrownianReal B P)
+    (hm : ∀ t, Measurable (B t)) (hBm : Measurable (Function.uncurry B))
+    (hBc : ∀ ω, Continuous (fun t => B t ω)) (hB0 : ∀ ω, B 0 ω = 0)
+    {κ : ℝ} (hκ : 0 < κ) (hκ8 : κ < 8)
+    (γ : Ω → ℝ≥0 → ℂ) (G F : Ω → ℝ≥0 → ℂ → ℂ)
+    (hw : ∀ ω, IsCapacityTwoWitness (fun t => Real.sqrt κ * B t ω) (γ ω) (G ω) (F ω))
+    (hgrowth : PublishedDiskUnivalentGrowth)
+    (u : ℕ → ℝ) (hu : ∀ n, 0 ≤ u n) (s : ℕ → Finset ℕ) (w : ℕ → ℕ → ℝ)
+    (hw₀ : ∀ n i, i ∈ s n → 0 ≤ w n i) (hw₁ : ∀ n, ∑ i ∈ s n, w n i = 1)
+    (t : ℝ≥0∞) (ν : Ω → Measure upperHalfPlane) (hνm : Measurable ν)
+    (hν : ∀ ω, IsFiniteMeasureOnCompacts (ν ω))
+    (hlim : ∀ᵐ ω ∂P, ∀ f : C_c(upperHalfPlane,ℝ),
+      Tendsto (fun n => ∫ z, f z ∂convexLevelMeasure κ B γ G u s w n t ω)
+        atTop (𝓝 (∫ z, f z ∂ν ω))) (E : Set Ω) :
+    IsFiniteMeasureOnCompacts ((P.restrict E).bind ν) := by
+  constructor
+  intro K hK
+  rw [Measure.bind_apply hK.measurableSet hνm.aemeasurable]
+  apply lt_of_le_of_lt (lintegral_mono' Measure.restrict_le_self (le_refl _))
+  simpa only [pow_one] using level_radon_limit_compact_moments hB hm hBm hBc hB0 hκ hκ8
+    γ G F hw hgrowth u hu s w hw₀ hw₁ t ν hν hlim K hK 1
+
+theorem level_radon_conditional_kernel
+    {Ω : Type*} [MeasurableSpace Ω] {P : Measure Ω}
+    {B : ℝ≥0 → Ω → ℝ} (hB : IsBrownianReal B P)
+    (hm : ∀ t, Measurable (B t)) (hBm : Measurable (Function.uncurry B))
+    (hBc : ∀ ω, Continuous (fun t => B t ω)) (hB0 : ∀ ω, B 0 ω = 0)
+    {κ : ℝ} (hκ : 0 < κ) (hκ8 : κ < 8)
+    (γ : Ω → ℝ≥0 → ℂ) (G F : Ω → ℝ≥0 → ℂ → ℂ)
+    (hw : ∀ ω, IsCapacityTwoWitness (fun t => Real.sqrt κ * B t ω) (γ ω) (G ω) (F ω))
+    (hgrowth : PublishedDiskUnivalentGrowth)
+    (u : ℕ → ℝ) (hu : ∀ n, 0 ≤ u n) (hmono : Monotone u) (huLim : Tendsto u atTop atTop)
+    (s : ℕ → Finset ℕ) (w : ℕ → ℕ → ℝ)
+    (hw₀ : ∀ n i, i ∈ s n → 0 ≤ w n i) (hw₁ : ∀ n, ∑ i ∈ s n, w n i = 1)
+    (t : ℝ≥0) (ν : Fin 2 → Ω → Measure upperHalfPlane)
+    (hνm : ∀ j, Measurable (ν j))
+    (hν : ∀ j ω, (ν j ω).Regular ∧ IsFiniteMeasureOnCompacts (ν j ω))
+    (hlim : ∀ j, ∀ᵐ ω ∂P, ∀ f : C_c(upperHalfPlane,ℝ),
+      Tendsto (fun n => ∫ z, f z ∂convexLevelMeasure κ B γ G u s w n
+        (if j = 0 then (t : ℝ≥0∞) else ∞) ω) atTop (𝓝 (∫ z, f z ∂ν j ω)))
+    (hpair : ∀ j k (a : Ω → ℝ), MemLp a 2 P →
+      Tendsto (fun n => ∫ ω, a ω * (∫ z, (localTestFamily upperHalfPlane).test k z
+        ∂convexLevelMeasure κ B γ G u s w n (if j = 0 then (t : ℝ≥0∞) else ∞) ω) ∂P)
+        atTop (𝓝 (∫ ω, a ω * (∫ z, (localTestFamily upperHalfPlane).test k z ∂ν j ω) ∂P)))
+    (E : Set Ω)
+    (hE : MeasurableSet[Filtration.natural B (fun s =>
+      (hBm.comp (measurable_const.prodMk measurable_id) : Measurable (B s)).stronglyMeasurable) t] E) :
+    (P.restrict E).bind (ν 1) = (P.restrict E).bind (ν 0) +
+      (P.restrict E).bind (halfPlaneGreenMeasure κ B γ G t) := by
+  let : IsProbabilityMeasure P := hB.isGaussianProcess.isProbabilityMeasure
+  let τ (j : Fin 2) : ℝ≥0∞ := if j = 0 then t else ∞
+  let (j : Fin 2) (ω : Ω) : IsFiniteMeasureOnCompacts (ν j ω) := (hν j ω).2
+  let (j : Fin 2) : IsFiniteMeasureOnCompacts ((P.restrict E).bind (ν j)) :=
+    level_radon_mean_finite_on_compacts hB hm hBm hBc hB0 hκ hκ8 γ G F hw hgrowth
+      u hu s w hw₀ hw₁ (τ j) (ν j) (hνm j) (fun _ => inferInstance) (hlim j) E
+  let : IsFiniteMeasureOnCompacts (initialGreenMeasure κ) := initialGreenMeasure_finite_on_compacts κ
+  have hgreen := halfPlaneGreenMeasure_mean_le hB hBm hBc hB0 hκ hκ8 γ G F hw t E
+  let : IsFiniteMeasureOnCompacts ((P.restrict E).bind (halfPlaneGreenMeasure κ B γ G t)) :=
+    ⟨fun K hK => lt_of_le_of_lt (hgreen K) hK.measure_lt_top⟩
+  let : IsFiniteMeasureOnCompacts ((P.restrict E).bind (ν 0) +
+      (P.restrict E).bind (halfPlaneGreenMeasure κ B γ G t)) := by
+    constructor
+    intro K hK
+    rw [Measure.add_apply]
+    exact ENNReal.add_lt_top.mpr ⟨hK.measure_lt_top,hK.measure_lt_top⟩
+  have hEg : MeasurableSet E := (Filtration.natural B (fun s =>
+    (hBm.comp (measurable_const.prodMk measurable_id) : Measurable (B s)).stronglyMeasurable)).le t E hE
+  apply (localTestFamily upperHalfPlane).measure_eq_of_test_integrals
+  intro k
+  let f := (localTestFamily upperHalfPlane).test k
+  have hc (j : Fin 2) : Tendsto (fun n => ∫ z, f z
+      ∂(P.restrict E).bind (convexLevelMeasure κ B γ G u s w n (τ j))) atTop
+      (𝓝 (∫ z, f z ∂(P.restrict E).bind (ν j))) := by
+    apply mean_test_tendsto_of_L2_pairings P _ (ν j)
+      (fun n => convexLevelMeasure_measurable hm hBc κ γ G F hw u hu s w n (τ j))
+      (hνm j) f f.continuous.measurable
+    · intro n ω
+      let := convexLevelMeasure_finite_on_compacts hκ hκ8 γ G F ω (hBc ω) (hw ω) u s w n (τ j)
+      exact f.integrable
+    · exact fun _ => f.integrable
+    · exact hEg
+    · intro n
+      exact f.integrable.mono_measure (convexLevelMeasure_mean_le hB hBm hBc hB0 hκ hκ8
+        γ G F hw u hu s w hw₀ hw₁ n (τ j) E)
+    · exact f.integrable
+    · exact hpair j k
+  have ht := hc 0
+  have hi := hc 1
+  have hg := convexCurrentMean_test_tendsto hB hBm hBc hB0 hκ hκ8 γ G F hw
+    u hu hmono huLim s w hw₀ hw₁ t E f
+  simp [τ] at ht hi
+  have he (n : ℕ) : (∫ z, f z ∂(P.restrict E).bind (convexLevelMeasure κ B γ G u s w n ∞)) =
+      (∫ z, f z ∂(P.restrict E).bind (convexLevelMeasure κ B γ G u s w n t)) +
+        ∫ z, f z ∂convexCurrentMean (P.restrict E) κ B γ G u s w n t := by
+    rw [convexLevelMeasure_conditional_split hB hBm hBc hB0 hκ hκ8 γ G F hw u hu s w n t E hE]
+    exact integral_add_measure
+      (f.integrable.mono_measure (convexLevelMeasure_mean_le hB hBm hBc hB0 hκ hκ8
+        γ G F hw u hu s w hw₀ hw₁ n t E))
+      (f.integrable.mono_measure (convexCurrentMean_le hB hBm hBc hB0 hκ hκ8
+        γ G F hw u hu s w hw₀ hw₁ n t E))
+  rw [integral_add_measure f.integrable f.integrable]
+  apply tendsto_nhds_unique hi
+  exact (ht.add hg).congr' (Eventually.of_forall (fun n => (he n).symm))
+
+end SLEExactGauge.Multipoint
+
+end
+
+end OAI
diff --git a/lean/OAI/Probability/SLE/Mass/LevelRadonMean.lean b/lean/OAI/Probability/SLE/Mass/LevelRadonMean.lean
new file mode 100644
index 0000000000000000000000000000000000000000..af299573c336a25210fa75e770a8a9f28f9274f8
--- /dev/null
+++ b/lean/OAI/Probability/SLE/Mass/LevelRadonMean.lean
@@ -0,0 +1,64 @@
+import OAI.Probability.SLE.Mass.ConvexMeanMeasure
+import OAI.Probability.SLE.Mass.LevelRadonMoments
+import OAI.Probability.SLE.Mass.RadonTestDetermines
+
+namespace OAI
+
+/-! The actual terminal Radon limit has exactly the initial Green mean
+measure. Local moment bounds justify signed compact tests of that mean. -/
+
+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 level_radon_terminal_mean
+    {Ω : Type*} [MeasurableSpace Ω]
+    {P : Measure Ω} {B : ℝ≥0 → Ω → ℝ} (hB : IsBrownianReal B P)
+    (hm : ∀ t, Measurable (B t)) (hBm : Measurable (Function.uncurry B))
+    (hBc : ∀ ω, Continuous (fun t => B t ω)) (hB0 : ∀ ω, B 0 ω = 0)
+    {κ : ℝ} (hκ : 0 < κ) (hκ8 : κ < 8)
+    (γ : Ω → ℝ≥0 → ℂ) (G F : Ω → ℝ≥0 → ℂ → ℂ)
+    (hw : ∀ ω, IsCapacityTwoWitness (fun t => Real.sqrt κ * B t ω) (γ ω) (G ω) (F ω))
+    (hgrowth : PublishedDiskUnivalentGrowth)
+    (u : ℕ → ℝ) (hu : ∀ n, 0 ≤ u n) (s : ℕ → Finset ℕ) (w : ℕ → ℕ → ℝ)
+    (hw₀ : ∀ n i, i ∈ s n → 0 ≤ w n i) (hw₁ : ∀ n, ∑ i ∈ s n, w n i = 1)
+    (ν : Ω → Measure upperHalfPlane) (hνm : Measurable ν)
+    (hν : ∀ ω, (ν ω).Regular)
+    (hlim : ∀ᵐ ω ∂P, ∀ f : C_c(upperHalfPlane,ℝ),
+      Tendsto (fun n => ∫ z, f z ∂convexLevelMeasure κ B γ G u s w n ∞ ω)
+        atTop (𝓝 (∫ z, f z ∂ν ω)))
+    (hmeanlim : ∀ k, Tendsto (fun n => ∫ ω, (∫ z, (localTestFamily upperHalfPlane).test k z
+        ∂convexLevelMeasure κ B γ G u s w n ∞ ω) ∂P)
+      atTop (𝓝 (∫ ω, (∫ z, (localTestFamily upperHalfPlane).test k z ∂ν ω) ∂P))) :
+    P.bind ν = initialGreenMeasure κ := by
+  let (ω : Ω) : (ν ω).Regular := hν ω
+  let : IsFiniteMeasureOnCompacts (P.bind ν) := by
+    constructor
+    intro K hK
+    rw [Measure.bind_apply hK.measurableSet hνm.aemeasurable]
+    simpa only [pow_one] using level_radon_limit_compact_moments hB hm hBm hBc hB0 hκ hκ8
+      γ G F hw hgrowth u hu s w hw₀ hw₁ ∞ ν (fun _ => inferInstance) hlim K hK 1
+  let := initialGreenMeasure_finite_on_compacts κ
+  apply (localTestFamily upperHalfPlane).measure_eq_of_test_integrals
+  intro k
+  let f := (localTestFamily upperHalfPlane).test k
+  have hmconst (n : ℕ) : (∫ ω, (∫ z, f z ∂convexLevelMeasure κ B γ G u s w n ∞ ω) ∂P) =
+      ∫ z, f z ∂initialGreenMeasure κ :=
+    (convexLevelMeasure_terminal_test_mean hB hm hBm hBc hB0 hκ hκ8 γ G F hw u hu s w hw₀ hw₁ n f).2
+  have he : (∫ ω, (∫ z, f z ∂ν ω) ∂P) = ∫ z, f z ∂initialGreenMeasure κ := by
+    apply tendsto_nhds_unique (hmeanlim k)
+    apply tendsto_const_nhds.congr'
+    exact Eventually.of_forall (fun n => (hmconst n).symm)
+  rw [← he]
+  exact (integral_bind_of_integrable_sections P ν hνm f f.continuous.measurable
+    (fun _ => f.integrable) f.integrable).symm
+
+end SLEExactGauge.Multipoint
+
+end
+
+end OAI
diff --git a/lean/OAI/Probability/SLE/Mass/LevelRadonMoments.lean b/lean/OAI/Probability/SLE/Mass/LevelRadonMoments.lean
new file mode 100644
index 0000000000000000000000000000000000000000..eaa8298dc9c62afbccfb8ced406a8f5d16bd7e91
--- /dev/null
+++ b/lean/OAI/Probability/SLE/Mass/LevelRadonMoments.lean
@@ -0,0 +1,166 @@
+import OAI.Probability.SLE.Mass.LevelRandomRadon
+import OAI.Probability.SLE.Mass.ConvexMomentLimits
+
+namespace OAI
+
+/-! Every compact moment bound passes from the actual level measures to
+any of their common convex Radon limits. -/
+
+noncomputable section
+open Set Filter MeasureTheory ProbabilityTheory Classical
+open scoped NNReal ENNReal Topology CompactlySupported
+
+namespace SLEExactGauge.Multipoint
+
+local instance : LocallyCompactSpace upperHalfPlane := isOpen_upperHalfPlane.locallyCompactSpace
+
+lemma extendHalfPlaneTest_nonneg (f : upperHalfPlane → ℝ) (hf : ∀ z, 0 ≤ f z) :
+    ∀ z, 0 ≤ extendHalfPlaneTest f z := by
+  intro z
+  by_cases hz : z ∈ upperHalfPlane
+  · exact (extendHalfPlaneTest_apply f ⟨z,hz⟩).symm ▸ hf ⟨z,hz⟩
+  · rw [extendHalfPlaneTest_of_not_mem f z hz]
+
+lemma ofReal_integral_halfPlaneLevelMeasure
+    {Ω : Type*} {B : ℝ≥0 → Ω → ℝ} {κ : ℝ} (hκ : 0 < κ) (hκ8 : κ < 8)
+    (γ : Ω → ℝ≥0 → ℂ) (G F : Ω → ℝ≥0 → ℂ → ℂ)
+    (ω : Ω) (hBc : Continuous (fun t => B t ω))
+    (hw : IsCapacityTwoWitness (fun t => Real.sqrt κ * B t ω) (γ ω) (G ω) (F ω))
+    (u : ℝ) (t : ℝ≥0∞) (f : C_c(upperHalfPlane,ℝ)) (hf : ∀ z, 0 ≤ f z) :
+    ENNReal.ofReal (∫ z, f z ∂halfPlaneLevelMeasure κ B γ G u t ω) =
+      levelApproximationTest κ B γ G u t (fun z => ENNReal.ofReal (extendHalfPlaneTest f z)) ω := by
+  let K := (Subtype.val : upperHalfPlane → ℂ) '' tsupport f
+  have hK : IsCompact K := f.hasCompactSupport.image continuous_subtype_val
+  have hKH : K ⊆ upperHalfPlane := by rintro _ ⟨x,_,rfl⟩; exact x.property
+  have hfin := (levelApproximation_apply_le κ B γ G u t ω hK.measurableSet).trans_lt
+    (levelMass_lt_top_of_compact hκ hκ8 γ G F ω hBc hw K hK hKH u)
+  rw [integral_halfPlaneLevelMeasure]
+  exact ofReal_integral_eq_lintegral_ofReal
+    (integrable_of_bounded_support _ K hK.measurableSet hfin _
+      (extendHalfPlaneTest_measurable f f.continuous.measurable) _
+      (fun z _ => extendHalfPlaneTest_norm_le f z) (extendHalfPlaneTest_support f))
+    (Eventually.of_forall (extendHalfPlaneTest_nonneg f hf))
+
+theorem uniform_halfPlaneLevelMeasure_test_moments
+    {Ω : 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)
+    (f : C_c(upperHalfPlane,ℝ)) (hf : ∀ z, 0 ≤ f z) (m : ℕ) :
+    ∃ M : ℝ≥0∞, M < ⊤ ∧ ∀ u : ℝ, 0 ≤ u → ∀ t : ℝ≥0∞,
+      (∫⁻ ω, ENNReal.ofReal (∫ z, f z ∂halfPlaneLevelMeasure κ B γ G u t ω)^m ∂P) ≤ M := by
+  let K := (Subtype.val : upperHalfPlane → ℂ) '' tsupport f
+  have hK : IsCompact K := f.hasCompactSupport.image continuous_subtype_val
+  have hKH : K ⊆ upperHalfPlane := by rintro _ ⟨x,_,rfl⟩; exact x.property
+  obtain ⟨M,hM,hbound⟩ := uniform_levelApproximationTest_moments hB hm hBm hBc hB0 hκ hκ8
+    γ G F hw hgrowth K hK hKH (fun z => ENNReal.ofReal (extendHalfPlaneTest f z))
+    (ENNReal.ofReal ‖f.toBoundedContinuousFunction‖) ENNReal.ofReal_lt_top
+    (fun z _ => ENNReal.ofReal_le_ofReal ((le_abs_self _).trans (extendHalfPlaneTest_norm_le f z)))
+    (fun z hz => by rw [extendHalfPlaneTest_support f z hz,ENNReal.ofReal_zero]) m
+  refine ⟨M,hM,fun u hu t => ?_⟩
+  simpa only [ofReal_integral_halfPlaneLevelMeasure hκ hκ8 γ G F _ (hBc _) (hw _) u t f hf]
+    using hbound u hu t
+
+theorem uniform_convexLevelMeasure_test_moments
+    {Ω : Type*} [MeasurableSpace Ω]
+    {P : Measure Ω} {B : ℝ≥0 → Ω → ℝ} (hB : IsBrownianReal B P)
+    (hm : ∀ t, Measurable (B t)) (hBm : Measurable (Function.uncurry B))
+    (hBc : ∀ ω, Continuous (fun t => B t ω)) (hB0 : ∀ ω, B 0 ω = 0)
+    {κ : ℝ} (hκ : 0 < κ) (hκ8 : κ < 8)
+    (γ : Ω → ℝ≥0 → ℂ) (G F : Ω → ℝ≥0 → ℂ → ℂ)
+    (hw : ∀ ω, IsCapacityTwoWitness (fun t => Real.sqrt κ * B t ω) (γ ω) (G ω) (F ω))
+    (hgrowth : PublishedDiskUnivalentGrowth)
+    (u : ℕ → ℝ) (hu : ∀ n, 0 ≤ u n) (s : ℕ → Finset ℕ) (w : ℕ → ℕ → ℝ)
+    (hw₀ : ∀ n i, i ∈ s n → 0 ≤ w n i) (hw₁ : ∀ n, ∑ i ∈ s n, w n i = 1)
+    (f : C_c(upperHalfPlane,ℝ)) (hf : ∀ z, 0 ≤ f z) (m : ℕ) :
+    ∃ M : ℝ≥0∞, M < ⊤ ∧ ∀ n (t : ℝ≥0∞),
+      (∫⁻ ω, ENNReal.ofReal (∫ z, f z ∂convexLevelMeasure κ B γ G u s w n t ω)^m ∂P) ≤ M := by
+  obtain ⟨M,hM,hbound⟩ := uniform_halfPlaneLevelMeasure_test_moments hB hm hBm hBc hB0 hκ hκ8
+    γ G F hw hgrowth f hf m
+  refine ⟨M,hM,fun n t => ?_⟩
+  have hb := lintegral_pow_convex_sum_le P (s n) (w n)
+    (fun i ω => ∫ z, f z ∂halfPlaneLevelMeasure κ B γ G (u (n+i)) t ω)
+    (hw₀ n) (hw₁ n) (fun i _ ω => integral_nonneg hf)
+    (fun i _ => by
+      simp_rw [integral_halfPlaneLevelMeasure]
+      exact levelApproximationRealTest_measurable hm hBc κ (u (n+i)) (hu _) γ G F hw t
+        _ (extendHalfPlaneTest_measurable f f.continuous.measurable))
+    m M (fun i _ => hbound (u (n+i)) (hu _) t)
+  simpa only [integral_convexLevelMeasure hκ hκ8 γ G F _ (hBc _) (hw _) u s w n t (hw₀ n) f,
+    integral_halfPlaneLevelMeasure] using hb
+
+theorem level_radon_limit_test_moments
+    {Ω : Type*} [MeasurableSpace Ω]
+    {P : Measure Ω} {B : ℝ≥0 → Ω → ℝ} (hB : IsBrownianReal B P)
+    (hm : ∀ t, Measurable (B t)) (hBm : Measurable (Function.uncurry B))
+    (hBc : ∀ ω, Continuous (fun t => B t ω)) (hB0 : ∀ ω, B 0 ω = 0)
+    {κ : ℝ} (hκ : 0 < κ) (hκ8 : κ < 8)
+    (γ : Ω → ℝ≥0 → ℂ) (G F : Ω → ℝ≥0 → ℂ → ℂ)
+    (hw : ∀ ω, IsCapacityTwoWitness (fun t => Real.sqrt κ * B t ω) (γ ω) (G ω) (F ω))
+    (hgrowth : PublishedDiskUnivalentGrowth)
+    (u : ℕ → ℝ) (hu : ∀ n, 0 ≤ u n) (s : ℕ → Finset ℕ) (w : ℕ → ℕ → ℝ)
+    (hw₀ : ∀ n i, i ∈ s n → 0 ≤ w n i) (hw₁ : ∀ n, ∑ i ∈ s n, w n i = 1)
+    (t : ℝ≥0∞) (ν : Ω → Measure upperHalfPlane)
+    (hlim : ∀ᵐ ω ∂P, ∀ f : C_c(upperHalfPlane,ℝ),
+      Tendsto (fun n => ∫ z, f z ∂convexLevelMeasure κ B γ G u s w n t ω)
+        atTop (𝓝 (∫ z, f z ∂ν ω)))
+    (f : C_c(upperHalfPlane,ℝ)) (hf : ∀ z, 0 ≤ f z) (m : ℕ) :
+    (∫⁻ ω, ENNReal.ofReal (∫ z, f z ∂ν ω)^m ∂P) < ⊤ := by
+  obtain ⟨M,hM,hbound⟩ := uniform_convexLevelMeasure_test_moments hB hm hBm hBc hB0 hκ hκ8
+    γ G F hw hgrowth u hu s w hw₀ hw₁ f hf m
+  apply lt_of_le_of_lt (lintegral_le_of_ae_tendsto_bound P _ _ (fun n =>
+    ((convexLevelMeasure_test_measurable hm hBc hκ hκ8 γ G F hw u hu s w hw₀ n t f).ennreal_ofReal.pow_const m).aemeasurable)
+    ?_ M (fun n => hbound n t)) hM
+  filter_upwards [hlim] with ω hω
+  exact (ENNReal.continuous_pow m).continuousAt.tendsto.comp
+    ((ENNReal.continuous_ofReal.tendsto _).comp (hω f))
+
+lemma measure_compact_le_nonneg_test (ν : Measure upperHalfPlane)
+    [IsFiniteMeasureOnCompacts ν] (K : Set upperHalfPlane) (hK : IsCompact K)
+    (f : C_c(upperHalfPlane,ℝ)) (hf : ∀ z, 0 ≤ f z) (hKf : ∀ z ∈ K, 1 ≤ f z) :
+    ν K ≤ ENNReal.ofReal (∫ z, f z ∂ν) := by
+  rw [ofReal_integral_eq_lintegral_ofReal f.integrable (Eventually.of_forall hf)]
+  calc
+    _ = ∫⁻ z, K.indicator (fun _ => (1 : ℝ≥0∞)) z ∂ν := by
+      rw [lintegral_indicator_const hK.measurableSet,one_mul]
+    _ ≤ _ := by
+      apply lintegral_mono
+      intro z
+      by_cases hz : z ∈ K
+      · simpa only [indicator_of_mem hz,ENNReal.one_le_ofReal] using hKf z hz
+      · simp only [indicator_of_notMem hz,zero_le]
+
+theorem level_radon_limit_compact_moments
+    {Ω : Type*} [MeasurableSpace Ω]
+    {P : Measure Ω} {B : ℝ≥0 → Ω → ℝ} (hB : IsBrownianReal B P)
+    (hm : ∀ t, Measurable (B t)) (hBm : Measurable (Function.uncurry B))
+    (hBc : ∀ ω, Continuous (fun t => B t ω)) (hB0 : ∀ ω, B 0 ω = 0)
+    {κ : ℝ} (hκ : 0 < κ) (hκ8 : κ < 8)
+    (γ : Ω → ℝ≥0 → ℂ) (G F : Ω → ℝ≥0 → ℂ → ℂ)
+    (hw : ∀ ω, IsCapacityTwoWitness (fun t => Real.sqrt κ * B t ω) (γ ω) (G ω) (F ω))
+    (hgrowth : PublishedDiskUnivalentGrowth)
+    (u : ℕ → ℝ) (hu : ∀ n, 0 ≤ u n) (s : ℕ → Finset ℕ) (w : ℕ → ℕ → ℝ)
+    (hw₀ : ∀ n i, i ∈ s n → 0 ≤ w n i) (hw₁ : ∀ n, ∑ i ∈ s n, w n i = 1)
+    (t : ℝ≥0∞) (ν : Ω → Measure upperHalfPlane)
+    (hν : ∀ ω, IsFiniteMeasureOnCompacts (ν ω))
+    (hlim : ∀ᵐ ω ∂P, ∀ f : C_c(upperHalfPlane,ℝ),
+      Tendsto (fun n => ∫ z, f z ∂convexLevelMeasure κ B γ G u s w n t ω)
+        atTop (𝓝 (∫ z, f z ∂ν ω)))
+    (K : Set upperHalfPlane) (hK : IsCompact K) (m : ℕ) :
+    (∫⁻ ω, (ν ω K)^m ∂P) < ⊤ := by
+  obtain ⟨f,hf,hKf⟩ := exists_compact_test_cutoff K hK
+  apply lt_of_le_of_lt (lintegral_mono (fun ω => ?_))
+    (level_radon_limit_test_moments hB hm hBm hBc hB0 hκ hκ8 γ G F hw hgrowth
+      u hu s w hw₀ hw₁ t ν hlim f hf m)
+  let := hν ω
+  exact pow_le_pow_left' (measure_compact_le_nonneg_test (ν ω) K hK f hf hKf) m
+
+end SLEExactGauge.Multipoint
+
+end
+
+end OAI
diff --git a/lean/OAI/Probability/SLE/Mass/LevelRadonNonatomic.lean b/lean/OAI/Probability/SLE/Mass/LevelRadonNonatomic.lean
new file mode 100644
index 0000000000000000000000000000000000000000..3a64fc5a80f94f258fca775a7dac7aeb19f0cd6d
--- /dev/null
+++ b/lean/OAI/Probability/SLE/Mass/LevelRadonNonatomic.lean
@@ -0,0 +1,124 @@
+import OAI.Probability.SLE.Mass.LevelRadonTwoPoint
+import OAI.Probability.SLE.Mass.MassGridCutoffs
+import OAI.Probability.SLE.Gauge.ShrinkingCoverAtoms
+
+namespace OAI
+
+/-! Nonatomicity of every actual convex Radon limit, from the two-point
+bound and one deterministic family of shrinking grid cutoffs. -/
+
+noncomputable section
+open Set Metric Filter MeasureTheory ProbabilityTheory Classical
+open scoped NNReal ENNReal Topology CompactlySupported
+
+namespace SLEExactGauge.Multipoint
+
+local instance : LocallyCompactSpace upperHalfPlane := isOpen_upperHalfPlane.locallyCompactSpace
+
+theorem level_radon_limit_compact_null_singletons
+    {Ω : Type*} [MeasurableSpace Ω]
+    {P : Measure Ω} {B : ℝ≥0 → Ω → ℝ} (hB : IsBrownianReal B P)
+    (hm : ∀ t, Measurable (B t)) (hBm : Measurable (Function.uncurry B))
+    (hBc : ∀ ω, Continuous (fun t => B t ω)) (hB0 : ∀ ω, B 0 ω = 0)
+    {κ : ℝ} (hκ : 0 < κ) (hκ8 : κ < 8)
+    (γ : Ω → ℝ≥0 → ℂ) (G F : Ω → ℝ≥0 → ℂ → ℂ)
+    (hw : ∀ ω, IsCapacityTwoWitness (fun t => Real.sqrt κ * B t ω) (γ ω) (G ω) (F ω))
+    (hgrowth : PublishedDiskUnivalentGrowth)
+    (u : ℕ → ℝ) (hu : ∀ n, 0 ≤ u n) (s : ℕ → Finset ℕ) (w : ℕ → ℕ → ℝ)
+    (hw₀ : ∀ n i, i ∈ s n → 0 ≤ w n i) (hw₁ : ∀ n, ∑ i ∈ s n, w n i = 1)
+    (t : ℝ≥0∞) (ν : Ω → Measure upperHalfPlane) (hνm : Measurable ν)
+    (hν : ∀ ω, IsFiniteMeasureOnCompacts (ν ω))
+    (hlim : ∀ᵐ ω ∂P, ∀ f : C_c(upperHalfPlane,ℝ),
+      Tendsto (fun n => ∫ z, f z ∂convexLevelMeasure κ B γ G u s w n t ω)
+        atTop (𝓝 (∫ z, f z ∂ν ω)))
+    (K : Set upperHalfPlane) (hK : IsCompact K) :
+    ∀ᵐ ω ∂P, ∀ x ∈ K, ν ω {x}=0 := by
+  obtain ⟨χ,hχ,hχK⟩ := exists_unit_compact_test_cutoff K hK
+  let L := (Subtype.val : upperHalfPlane → ℂ) '' tsupport χ
+  have hL : IsCompact L := χ.hasCompactSupport.image continuous_subtype_val
+  have hLH : L ⊆ upperHalfPlane := by rintro _ ⟨x,_,rfl⟩; exact x.property
+  obtain ⟨b,hb,hbL⟩ := compact_positive_radius_cap hL hLH
+  have hKI := hK.image (continuous_subtype_val : Continuous (Subtype.val : upperHalfPlane → ℂ))
+  obtain ⟨R,hR,hRK⟩ := hKI.isBounded.exists_pos_norm_le
+  let r : ℕ → ℝ := fun n => 1/((n:ℝ)+1)
+  have hr (n : ℕ) : 0 < r n := by dsimp [r]; positivity
+  let I (n : ℕ) := coverGridIndex R (r n)
+  let f (n : ℕ) (i : ℤ×ℤ) := massGridCutoff χ (r n) i
+  have hf (n : ℕ) (i : ℤ×ℤ) (z : upperHalfPlane) : 0 ≤ f n i z :=
+    (massGridCutoff_bounds χ hχ (r n) i z).1
+  let A (n : ℕ) (ω : Ω) := ∑ i ∈ I n, ENNReal.ofReal (∫ z, f n i z ∂ν ω)^2
+  have hA (n : ℕ) : Measurable (A n) := by
+    apply Finset.measurable_sum
+    intro i hi
+    have he (ω : Ω) : ENNReal.ofReal (∫ z, f n i z ∂ν ω) =
+        ∫⁻ z, ENNReal.ofReal (f n i z) ∂ν ω := by
+      let := hν ω
+      exact ofReal_integral_eq_lintegral_ofReal (f n i).integrable (Eventually.of_forall (hf n i))
+    simp_rw [he]
+    exact ((Measure.measurable_lintegral (f n i).continuous.measurable.ennreal_ofReal).comp hνm).pow_const 2
+  apply ae_null_singletons_on_of_square_bounds P ν K A hA
+  · intro ω x hx n
+    have hxR : (x:ℂ) ∈ closedBall (0:ℂ) R := by
+      simpa only [mem_closedBall,dist_zero_right] using hRK x ⟨x,hx,rfl⟩
+    obtain ⟨i,hi,hxi⟩ := mem_iUnion₂.mp (coverGrid_covers_disk hR.le (hr n) hxR)
+    have hfx : f n i x = 1 := massGridCutoff_eq_one χ (hr n) i x (hχK x hx) hxi
+    let := hν ω
+    have hμ : ν ω {x} ≤ ENNReal.ofReal (∫ z, f n i z ∂ν ω) :=
+      measure_compact_le_nonneg_test (ν ω) {x} isCompact_singleton (f n i) (hf n i)
+        (by intro z hz; simpa only [mem_singleton_iff.mp hz,hfx] using (le_refl (1:ℝ)))
+    exact (pow_le_pow_left' hμ 2).trans
+      (Finset.single_le_sum (f := fun j => ENNReal.ofReal (∫ z, f n j z ∂ν ω)^2)
+        (fun _ _ => zero_le) hi)
+  · have hbound (n : ℕ) : (∫⁻ ω, A n ω ∂P) ≤
+        ENNReal.ofReal (multipointConstant κ 2) * (81 *
+          ∫⁻ z : Fin 2 → ℂ, nearDiagonalKernel (codimension κ) b (6*r n) z
+            ∂Measure.pi (fun _ : Fin 2 => volume.restrict L)) := by
+      exact level_radon_cutoff_square_sum_le hB hm hBm hBc hB0 hκ hκ8 γ G F hw hgrowth
+        u hu s w hw₀ hw₁ t ν hνm hν hlim L hL.measurableSet hLH b hb hbL (I n) (f n)
+        (hf n) (fun i z hz => massGridCutoff_common_support χ (r n) i z hz)
+        (6*r n) 81 (massGridCutoff_sum_bound χ hχ (hr n) (I n))
+    have hr0 : Tendsto (fun n => 6*r n) atTop (𝓝 0) := by
+      simpa only [mul_zero] using
+        (tendsto_one_div_add_atTop_nhds_zero_nat (𝕜 := ℝ)).const_mul 6
+    have hnear := nearDiagonalKernel_integral_tendsto_zero (codimension_pos κ hκ8)
+      (by unfold codimension dimension; linarith) b L hL.isBounded (fun n => 6*r n) hr0
+    have hupper : Tendsto (fun n => ENNReal.ofReal (multipointConstant κ 2) * (81 *
+          ∫⁻ z : Fin 2 → ℂ, nearDiagonalKernel (codimension κ) b (6*r n) z
+            ∂Measure.pi (fun _ : Fin 2 => volume.restrict L))) atTop (𝓝 0) := by
+      simpa only [mul_zero] using ENNReal.Tendsto.const_mul
+        (ENNReal.Tendsto.const_mul hnear (Or.inr (by norm_num : (81:ℝ≥0∞)≠⊤)))
+        (Or.inr ENNReal.ofReal_ne_top)
+    exact tendsto_of_tendsto_of_tendsto_of_le_of_le tendsto_const_nhds hupper
+      (fun _ => zero_le) hbound
+
+theorem level_radon_limit_nonatomic
+    {Ω : Type*} [MeasurableSpace Ω]
+    {P : Measure Ω} {B : ℝ≥0 → Ω → ℝ} (hB : IsBrownianReal B P)
+    (hm : ∀ t, Measurable (B t)) (hBm : Measurable (Function.uncurry B))
+    (hBc : ∀ ω, Continuous (fun t => B t ω)) (hB0 : ∀ ω, B 0 ω = 0)
+    {κ : ℝ} (hκ : 0 < κ) (hκ8 : κ < 8)
+    (γ : Ω → ℝ≥0 → ℂ) (G F : Ω → ℝ≥0 → ℂ → ℂ)
+    (hw : ∀ ω, IsCapacityTwoWitness (fun t => Real.sqrt κ * B t ω) (γ ω) (G ω) (F ω))
+    (hgrowth : PublishedDiskUnivalentGrowth)
+    (u : ℕ → ℝ) (hu : ∀ n, 0 ≤ u n) (s : ℕ → Finset ℕ) (w : ℕ → ℕ → ℝ)
+    (hw₀ : ∀ n i, i ∈ s n → 0 ≤ w n i) (hw₁ : ∀ n, ∑ i ∈ s n, w n i = 1)
+    (t : ℝ≥0∞) (ν : Ω → Measure upperHalfPlane) (hνm : Measurable ν)
+    (hν : ∀ ω, IsFiniteMeasureOnCompacts (ν ω))
+    (hlim : ∀ᵐ ω ∂P, ∀ f : C_c(upperHalfPlane,ℝ),
+      Tendsto (fun n => ∫ z, f z ∂convexLevelMeasure κ B γ G u s w n t ω)
+        atTop (𝓝 (∫ z, f z ∂ν ω))) :
+    ∀ᵐ ω ∂P, NullSingletonClass (ν ω) := by
+  let D := localTestFamily upperHalfPlane
+  apply ae_nullSingletonClass_of_exhaustion P ν D.compactSet
+  · intro x
+    obtain ⟨j,hj⟩ := D.exhaustive {x} isCompact_singleton
+    exact ⟨j,hj (mem_singleton x)⟩
+  · intro j
+    exact level_radon_limit_compact_null_singletons hB hm hBm hBc hB0 hκ hκ8 γ G F hw hgrowth
+      u hu s w hw₀ hw₁ t ν hνm hν hlim (D.compactSet j) (D.isCompact j)
+
+end SLEExactGauge.Multipoint
+
+end
+
+end OAI
diff --git a/lean/OAI/Probability/SLE/Mass/LevelRadonPairings.lean b/lean/OAI/Probability/SLE/Mass/LevelRadonPairings.lean
new file mode 100644
index 0000000000000000000000000000000000000000..ff2a2700224d20b66d710ce6e4a8cb003ddc46ce
--- /dev/null
+++ b/lean/OAI/Probability/SLE/Mass/LevelRadonPairings.lean
@@ -0,0 +1,81 @@
+import OAI.Probability.SLE.Mass.LevelRandomRadon
+
+namespace OAI
+
+/-! The measurable common Radon versions retain the L² pairings. In
+particular expectations on any past event pass through the same limits. -/
+
+noncomputable section
+open Set Filter MeasureTheory ProbabilityTheory Classical
+open scoped NNReal ENNReal Topology CompactlySupported
+
+namespace SLEExactGauge.Multipoint
+
+local instance : LocallyCompactSpace upperHalfPlane := isOpen_upperHalfPlane.locallyCompactSpace
+
+theorem exists_measurable_level_radon_limits_with_pairings
+    {Ω : Type*} [MeasurableSpace Ω]
+    {P : Measure Ω} {B : ℝ≥0 → Ω → ℝ} (hB : IsBrownianReal B P)
+    (hm : ∀ t, Measurable (B t)) (hBm : Measurable (Function.uncurry B))
+    (hBc : ∀ ω, Continuous (fun t => B t ω)) (hB0 : ∀ ω, B 0 ω = 0)
+    {κ : ℝ} (hκ : 0 < κ) (hκ8 : κ < 8)
+    (γ : Ω → ℝ≥0 → ℂ) (G F : Ω → ℝ≥0 → ℂ → ℂ)
+    (hw : ∀ ω, IsCapacityTwoWitness (fun t => Real.sqrt κ * B t ω) (γ ω) (G ω) (F ω))
+    (hgrowth : PublishedDiskUnivalentGrowth)
+    (u : ℕ → ℝ) (hu : ∀ n, 0 ≤ u n) (t : ℕ → ℝ≥0∞) :
+    ∃ s : ℕ → Finset ℕ, ∃ w : ℕ → ℕ → ℝ, ∃ ν : ℕ → Ω → Measure upperHalfPlane,
+      (∀ n i, i ∈ s n → 0 ≤ w n i) ∧ (∀ n, ∑ i ∈ s n, w n i = 1) ∧
+      (∀ j, Measurable (ν j)) ∧
+      (∀ j ω, (ν j ω).Regular ∧ IsFiniteMeasureOnCompacts (ν j ω)) ∧
+      (∀ᵐ ω ∂P, ∀ j (f : C_c(upperHalfPlane,ℝ)),
+        Tendsto (fun n => ∫ z, f z ∂convexLevelMeasure κ B γ G u s w n (t j) ω)
+          atTop (𝓝 (∫ z, f z ∂ν j ω))) ∧
+      ∀ j k (a : Ω → ℝ), MemLp a 2 P →
+        Tendsto (fun n => ∫ ω, a ω * (∫ z, (localTestFamily upperHalfPlane).test k z
+          ∂convexLevelMeasure κ B γ G u s w n (t j) ω) ∂P)
+          atTop (𝓝 (∫ ω, a ω * (∫ z, (localTestFamily upperHalfPlane).test k z ∂ν j ω) ∂P)) := by
+  let D := localTestFamily upperHalfPlane
+  obtain ⟨x,s,w,hw₀,hw₁,_,hp,hconv⟩ := exists_common_halfPlane_test_limits_with_pairings
+    hB hm hBm hBc hB0 hκ hκ8 γ G F hw hgrowth
+    (fun j => D.test (Nat.unpair j).2) u hu (fun j => t (Nat.unpair j).1)
+  have hex : ∀ᵐ ω ∂P, ∃ ν : ℕ → Measure upperHalfPlane, (∀ j, (ν j).Regular) ∧
+      ∀ j (f : C_c(upperHalfPlane,ℝ)),
+        Tendsto (fun n => ∫ z, f z ∂convexLevelMeasure κ B γ G u s w n (t j) ω)
+          atTop (𝓝 (∫ z, f z ∂ν j)) := by
+    filter_upwards [hconv] with ω hω
+    have hj (j : ℕ) : ∃ ν : Measure upperHalfPlane, ν.Regular ∧ IsFiniteMeasureOnCompacts ν ∧
+        ∀ f : C_c(upperHalfPlane,ℝ),
+          Tendsto (fun n => ∫ z, f z ∂convexLevelMeasure κ B γ G u s w n (t j) ω)
+            atTop (𝓝 (∫ z, f z ∂ν)) := by
+      let (n : ℕ) : IsFiniteMeasureOnCompacts (convexLevelMeasure κ B γ G u s w n (t j) ω) :=
+        convexLevelMeasure_finite_on_compacts hκ hκ8 γ G F ω (hBc ω) (hw ω) u s w n (t j)
+      apply D.exists_radon_limit
+      intro k
+      refine ⟨x (Nat.pair j k) ω,?_⟩
+      simpa only [Nat.unpair_pair] using hω (Nat.pair j k)
+    choose ν hν using hj
+    exact ⟨ν,fun j => (hν j).1,fun j => (hν j).2.2⟩
+  obtain ⟨ν,hνm,hνr,hlim⟩ := exists_measurable_countable_radon_limits P
+    (fun n j ω => convexLevelMeasure κ B γ G u s w n (t j) ω)
+    (fun n j f => convexLevelMeasure_test_measurable hm hBc hκ hκ8 γ G F hw u hu s w hw₀ n (t j) f) hex
+  refine ⟨s,w,ν,hw₀,hw₁,hνm,hνr,hlim,?_⟩
+  intro j k a ha
+  have heq : (fun ω => x (Nat.pair j k) ω) =ᵐ[P]
+      (fun ω => ∫ z, D.test k z ∂ν j ω) := by
+    filter_upwards [hconv,hlim] with ω hc hl
+    have hc' := hc (Nat.pair j k)
+    simp only [Nat.unpair_pair] at hc'
+    exact tendsto_nhds_unique hc' (hl j (D.test k))
+  have ht := hp (Nat.pair j k) a ha
+  simp only [Nat.unpair_pair] at ht
+  convert ht using 1
+  apply congrArg (fun v : ℝ => 𝓝 v)
+  apply integral_congr_ae
+  filter_upwards [heq] with ω hω
+  exact congrArg (fun v : ℝ => a ω * v) hω.symm
+
+end SLEExactGauge.Multipoint
+
+end
+
+end OAI
diff --git a/lean/OAI/Probability/SLE/Mass/LevelRadonSupport.lean b/lean/OAI/Probability/SLE/Mass/LevelRadonSupport.lean
new file mode 100644
index 0000000000000000000000000000000000000000..922ec052bfcdba92a361541d6909e16939b3e2f5
--- /dev/null
+++ b/lean/OAI/Probability/SLE/Mass/LevelRadonSupport.lean
@@ -0,0 +1,220 @@
+import OAI.Probability.SLE.Mass.LevelApproximationSupport
+import OAI.Probability.SLE.Mass.LevelRadonExtraction
+import OAI.Probability.SLE.Mass.RadonTestLimitProperties
+
+namespace OAI
+
+/-! Actual past support of every convex-tail Radon limit.  Compact tests
+separated from the past trace vanish at all sufficiently high levels. -/
+
+noncomputable section
+open Set Filter MeasureTheory ProbabilityTheory Classical
+open scoped NNReal ENNReal Topology CompactlySupported
+
+namespace SLEExactGauge.Multipoint
+
+local instance : LocallyCompactSpace upperHalfPlane := isOpen_upperHalfPlane.locallyCompactSpace
+
+lemma level_density_eventually_zero_on_compact
+    {Ω : Type*} {κ : ℝ} {B : ℝ≥0 → Ω → ℝ}
+    {γ : Ω → ℝ≥0 → ℂ} {G F : Ω → ℝ≥0 → ℂ → ℂ} (ω : Ω)
+    (hBc : Continuous (fun s => B s ω))
+    (hw : IsCapacityTwoWitness (fun s => Real.sqrt κ * B s ω) (γ ω) (G ω) (F ω))
+    (t : ℝ≥0) (K : Set ℂ) (hK : IsCompact K) (hKH : K ⊆ upperHalfPlane)
+    (hdis : Disjoint K (γ ω '' Icc 0 t))
+    (u : ℕ → ℝ) (hu : Tendsto u atTop atTop) :
+    ∀ᶠ n in atTop, ∀ z ∈ K,
+      levelApproximationDensity κ B γ G (u n) t ω z = 0 := by
+  let S := γ ω '' Icc 0 t
+  have hS : IsClosed S := (isCompact_Icc.image hw.1).isClosed
+  have hSne : S.Nonempty := ⟨γ ω 0,0,⟨le_rfl,bot_le⟩,rfl⟩
+  obtain ⟨r,hr,hrK⟩ := hK.exists_forall_le'
+    (Complex.continuous_im.min (Metric.continuous_infDist_pt (s := S))).continuousOn
+    (fun z hz => lt_min (hKH hz)
+      ((hS.notMem_iff_infDist_pos hSne).mp (fun hs => Set.disjoint_left.mp hdis hz hs)))
+  obtain ⟨M,hM⟩ := hK.bddAbove_image Complex.continuous_im.continuousOn
+  have hlim : Tendsto (fun n => (2*M)*Real.exp (-u n)) atTop (𝓝 0) := by
+    simpa only [mul_zero,Function.comp_def] using
+      (Real.tendsto_exp_atBot.comp (tendsto_neg_atTop_atBot.comp hu)).const_mul (2*M)
+  filter_upwards [hlim.eventually (eventually_lt_nhds hr)] with n hn z hz
+  apply levelApproximationDensity_eq_zero_of_avoidance ω (hBc.const_mul _) hw z r hr
+    ((hrK z hz).trans (min_le_left _ _)) (u n)
+    ((mul_le_mul_of_nonneg_right (mul_le_mul_of_nonneg_left (hM ⟨z,hz,rfl⟩)
+      (by norm_num : (0:ℝ) ≤ 2)) (Real.exp_pos _).le).trans_lt hn) t
+  intro s hs
+  exact ((hrK z hz).trans (min_le_right _ _)).trans
+    ((Metric.infDist_le_dist_of_mem (show γ ω s ∈ S from ⟨s,hs,rfl⟩)).trans_eq (dist_comm _ _))
+
+lemma halfPlane_level_test_eventually_zero_off_past
+    {Ω : Type*} {κ : ℝ} {B : ℝ≥0 → Ω → ℝ}
+    {γ : Ω → ℝ≥0 → ℂ} {G F : Ω → ℝ≥0 → ℂ → ℂ} (ω : Ω)
+    (hBc : Continuous (fun s => B s ω))
+    (hw : IsCapacityTwoWitness (fun s => Real.sqrt κ * B s ω) (γ ω) (G ω) (F ω))
+    (t : ℝ≥0) (f : C_c(upperHalfPlane,ℝ))
+    (hf : ∀ z ∈ tsupport f, (z : ℂ) ∉ γ ω '' Icc 0 t)
+    (u : ℕ → ℝ) (hu : Tendsto u atTop atTop) :
+    ∀ᶠ n in atTop, ∫ z, f z ∂halfPlaneLevelMeasure κ B γ G (u n) t ω = 0 := by
+  let K := (Subtype.val : upperHalfPlane → ℂ) '' tsupport f
+  have hK : IsCompact K := f.hasCompactSupport.image continuous_subtype_val
+  have hKH : K ⊆ upperHalfPlane := by rintro _ ⟨z,_,rfl⟩; exact z.property
+  have hdis : Disjoint K (γ ω '' Icc 0 t) := by
+    apply Set.disjoint_left.mpr
+    rintro _ ⟨z,hz,rfl⟩ hs
+    exact hf z hz hs
+  filter_upwards [level_density_eventually_zero_on_compact ω hBc hw t K hK hKH hdis u hu]
+    with n hn
+  have hzero : halfPlaneLevelMeasure κ B γ G (u n) t ω (tsupport f) = 0 := by
+    rw [halfPlaneLevelMeasure,comap_subtype_coe_apply isOpen_upperHalfPlane.measurableSet,
+      levelApproximation,withDensity_apply _ hK.measurableSet]
+    apply le_antisymm ?_ bot_le
+    apply (setLIntegral_mono' hK.measurableSet (fun z hz => le_of_eq (hn z hz))).trans_eq
+    simp
+  apply integral_eq_zero_of_ae
+  filter_upwards [measure_eq_zero_iff_ae_notMem.mp hzero] with z hz
+  exact image_eq_zero_of_notMem_tsupport hz
+
+/-- Every compact test away from the actual past vanishes on every late
+convex tail.  The coefficients may be arbitrary: no normalization is used. -/
+lemma convex_level_test_eventually_zero_off_past
+    {Ω : Type*} {κ : ℝ} {B : ℝ≥0 → Ω → ℝ}
+    {γ : Ω → ℝ≥0 → ℂ} {G F : Ω → ℝ≥0 → ℂ → ℂ} (ω : Ω)
+    (hBc : Continuous (fun s => B s ω))
+    (hw : IsCapacityTwoWitness (fun s => Real.sqrt κ * B s ω) (γ ω) (G ω) (F ω))
+    (t : ℝ≥0) (f : C_c(upperHalfPlane,ℝ))
+    (hf : ∀ z ∈ tsupport f, (z : ℂ) ∉ γ ω '' Icc 0 t)
+    (u : ℕ → ℝ) (hu : Tendsto u atTop atTop)
+    (s : ℕ → Finset ℕ) (w : ℕ → ℕ → ℝ) :
+    ∀ᶠ n in atTop, ∫ z, f z ∂convexLevelMeasure κ B γ G u s w n t ω = 0 := by
+  let K := (Subtype.val : upperHalfPlane → ℂ) '' tsupport f
+  have hK : IsCompact K := f.hasCompactSupport.image continuous_subtype_val
+  have hKH : K ⊆ upperHalfPlane := by rintro _ ⟨z,_,rfl⟩; exact z.property
+  have hdis : Disjoint K (γ ω '' Icc 0 t) := by
+    apply Set.disjoint_left.mpr
+    rintro _ ⟨z,hz,rfl⟩ hs
+    exact hf z hz hs
+  obtain ⟨N,hN⟩ := eventually_atTop.mp
+    (level_density_eventually_zero_on_compact ω hBc hw t K hK hKH hdis u hu)
+  filter_upwards [eventually_ge_atTop N] with n hn
+  have hzero : convexLevelMeasure κ B γ G u s w n t ω (tsupport f) = 0 := by
+    rw [convexLevelMeasure,Measure.finsetSum_apply]
+    apply Finset.sum_eq_zero
+    intro i _
+    rw [Measure.smul_apply]
+    suffices he : halfPlaneLevelMeasure κ B γ G (u (n+i)) t ω (tsupport f) = 0 by
+      simp only [he,smul_zero]
+    rw [halfPlaneLevelMeasure,comap_subtype_coe_apply isOpen_upperHalfPlane.measurableSet,
+      levelApproximation,withDensity_apply _ hK.measurableSet]
+    apply le_antisymm ?_ bot_le
+    apply (setLIntegral_mono' hK.measurableSet
+      (fun z hz => le_of_eq (hN (n+i) (hn.trans (Nat.le_add_right n i)) z hz))).trans_eq
+    simp
+  apply integral_eq_zero_of_ae
+  filter_upwards [measure_eq_zero_iff_ae_notMem.mp hzero] with z hz
+  exact image_eq_zero_of_notMem_tsupport hz
+
+/-- Any vague limit of the actual convex level measures at a finite time
+is carried by the actual trace up to that time. -/
+theorem convex_level_radon_limit_carried_by_past
+    {Ω : Type*} {κ : ℝ} {B : ℝ≥0 → Ω → ℝ}
+    {γ : Ω → ℝ≥0 → ℂ} {G F : Ω → ℝ≥0 → ℂ → ℂ} (ω : Ω)
+    (hBc : Continuous (fun s => B s ω))
+    (hw : IsCapacityTwoWitness (fun s => Real.sqrt κ * B s ω) (γ ω) (G ω) (F ω))
+    (t : ℝ≥0) (u : ℕ → ℝ) (hu : Tendsto u atTop atTop)
+    (s : ℕ → Finset ℕ) (w : ℕ → ℕ → ℝ) (ν : Measure upperHalfPlane) [ν.Regular]
+    (hlim : ∀ f : C_c(upperHalfPlane,ℝ),
+      Tendsto (fun n => ∫ z, f z ∂convexLevelMeasure κ B γ G u s w n t ω)
+        atTop (𝓝 (∫ z, f z ∂ν))) :
+    ν {z : upperHalfPlane | (z : ℂ) ∉ γ ω '' Icc 0 t} = 0 := by
+  let S : Set upperHalfPlane := {z | (z : ℂ) ∈ γ ω '' Icc 0 t}
+  apply radon_limit_carried_by_closed _ ν hlim S
+    (((isCompact_Icc.image hw.1).isClosed).preimage continuous_subtype_val)
+  intro f hf
+  exact convex_level_test_eventually_zero_off_past ω hBc hw t f hf u hu s w
+
+theorem convex_level_radon_limit_zero_at_zero
+    {Ω : Type*} {κ : ℝ} {B : ℝ≥0 → Ω → ℝ}
+    {γ : Ω → ℝ≥0 → ℂ} {G F : Ω → ℝ≥0 → ℂ → ℂ} (ω : Ω)
+    (hBc : Continuous (fun s => B s ω))
+    (hw : IsCapacityTwoWitness (fun s => Real.sqrt κ * B s ω) (γ ω) (G ω) (F ω))
+    (u : ℕ → ℝ) (hu : Tendsto u atTop atTop)
+    (s : ℕ → Finset ℕ) (w : ℕ → ℕ → ℝ) (ν : Measure upperHalfPlane) [ν.Regular]
+    (hlim : ∀ f : C_c(upperHalfPlane,ℝ),
+      Tendsto (fun n => ∫ z, f z ∂convexLevelMeasure κ B γ G u s w n 0 ω)
+        atTop (𝓝 (∫ z, f z ∂ν))) : ν = 0 := by
+  have h := convex_level_radon_limit_carried_by_past ω hBc hw 0 u hu s w ν hlim
+  have he : {z : upperHalfPlane | (z : ℂ) ∉ γ ω '' Icc 0 0} = univ := by
+    apply Set.eq_univ_of_forall
+    intro z hz
+    obtain ⟨a,ha,haz⟩ := hz
+    have ha0 : a = 0 := le_antisymm ha.2 ha.1
+    subst a
+    have hz0 : (z : ℂ) = 0 := haz.symm.trans hw.2.1
+    have hpos := z.property
+    change 0 < (z : ℂ).im at hpos
+    simp only [hz0,Complex.zero_im,lt_self_iff_false] at hpos
+  rw [he] at h
+  exact Measure.measure_univ_eq_zero.mp h
+
+/-- The support conclusion holds simultaneously for the prescribed
+countable list of finite times on the same vague-convergence event. -/
+theorem ae_common_level_radon_limits_carried_by_past
+    {Ω : Type*} [MeasurableSpace Ω] (P : Measure Ω)
+    {κ : ℝ} {B : ℝ≥0 → Ω → ℝ}
+    {γ : Ω → ℝ≥0 → ℂ} {G F : Ω → ℝ≥0 → ℂ → ℂ}
+    (hBc : ∀ ω, Continuous (fun s => B s ω))
+    (hw : ∀ ω, IsCapacityTwoWitness
+      (fun s => Real.sqrt κ * B s ω) (γ ω) (G ω) (F ω))
+    (t : ℕ → ℝ≥0) (u : ℕ → ℝ) (hu : Tendsto u atTop atTop)
+    (s : ℕ → Finset ℕ) (w : ℕ → ℕ → ℝ) (ν : ℕ → Ω → Measure upperHalfPlane)
+    (hν : ∀ j ω, (ν j ω).Regular)
+    (hlim : ∀ᵐ ω ∂P, ∀ j (f : C_c(upperHalfPlane,ℝ)),
+      Tendsto (fun n => ∫ z, f z ∂convexLevelMeasure κ B γ G u s w n (t j) ω)
+        atTop (𝓝 (∫ z, f z ∂ν j ω))) :
+    ∀ᵐ ω ∂P, ∀ j, ν j ω {z : upperHalfPlane | (z : ℂ) ∉ γ ω '' Icc 0 (t j)} = 0 := by
+  filter_upwards [hlim] with ω hω
+  intro j
+  let := hν j ω
+  exact convex_level_radon_limit_carried_by_past ω (hBc ω) (hw ω) (t j) u hu
+    s w (ν j ω) (hω j)
+
+lemma past_inter_surviving_subset_segment (γ : ℝ≥0 → ℂ) (s t : ℝ≥0) :
+    (γ '' Icc 0 t) ∩ survivingDomain γ s ⊆ γ '' Icc s t := by
+  rintro z ⟨⟨a,ha,rfl⟩,hlive⟩
+  have hsa : s ≤ a := by
+    by_contra h
+    exact hlive.1.2 ⟨a,⟨ha.1,(lt_of_not_ge h).le⟩,rfl⟩
+  exact ⟨a,⟨hsa,ha.2⟩,rfl⟩
+
+/-- A positive increment dominated by the past mass and by the remaining
+mass is carried by the new segment. This is the deterministic consequence
+of past support and the conditional-kernel future support. -/
+theorem increment_le_restrict_trace_segment
+    (γ : ℝ≥0 → ℂ) (s t : ℝ≥0) (η μpast μfuture ν : Measure upperHalfPlane)
+    (hηpast : η ≤ μpast) (hηfuture : η ≤ μfuture) (hην : η ≤ ν)
+    (hpast : μpast {z : upperHalfPlane | (z : ℂ) ∉ γ '' Icc 0 t} = 0)
+    (hfuture : μfuture {z : upperHalfPlane | (z : ℂ) ∉ survivingDomain γ s} = 0) :
+    η ≤ ν.restrict {z : upperHalfPlane | (z : ℂ) ∈ γ '' Icc s t} := by
+  have hp : ∀ᵐ z : upperHalfPlane ∂η, (z : ℂ) ∈ γ '' Icc 0 t := by
+    have hz : η {z : upperHalfPlane | (z : ℂ) ∉ γ '' Icc 0 t} = 0 :=
+      le_zero_iff.mp ((hηpast {z : upperHalfPlane | (z : ℂ) ∉ γ '' Icc 0 t}).trans_eq hpast)
+    filter_upwards [measure_eq_zero_iff_ae_notMem.mp hz] with z hz
+    exact not_not.mp hz
+  have hf : ∀ᵐ z : upperHalfPlane ∂η, (z : ℂ) ∈ survivingDomain γ s := by
+    have hz : η {z : upperHalfPlane | (z : ℂ) ∉ survivingDomain γ s} = 0 :=
+      le_zero_iff.mp ((hηfuture {z : upperHalfPlane | (z : ℂ) ∉ survivingDomain γ s}).trans_eq hfuture)
+    filter_upwards [measure_eq_zero_iff_ae_notMem.mp hz] with z hz
+    exact not_not.mp hz
+  have hm : ∀ᵐ z ∂η, z ∈ {z : upperHalfPlane | (z : ℂ) ∈ γ '' Icc s t} := by
+    filter_upwards [hp,hf] with z hzp hzf
+    exact past_inter_surviving_subset_segment γ s t ⟨hzp,hzf⟩
+  calc
+    η = η.restrict {z : upperHalfPlane | (z : ℂ) ∈ γ '' Icc s t} :=
+      (Measure.restrict_eq_self_of_ae_mem hm).symm
+    _ ≤ ν.restrict {z : upperHalfPlane | (z : ℂ) ∈ γ '' Icc s t} :=
+      Measure.restrict_mono le_rfl hην
+
+end SLEExactGauge.Multipoint
+
+end
+
+end OAI
diff --git a/lean/OAI/Probability/SLE/Mass/LevelRadonTwoPoint.lean b/lean/OAI/Probability/SLE/Mass/LevelRadonTwoPoint.lean
new file mode 100644
index 0000000000000000000000000000000000000000..af8cdcda1bc3134aa3dc8a0270a68ba582c29a21
--- /dev/null
+++ b/lean/OAI/Probability/SLE/Mass/LevelRadonTwoPoint.lean
@@ -0,0 +1,97 @@
+import OAI.Probability.SLE.Mass.WeightedLevelMoments
+import OAI.Probability.SLE.Multipoint.NearDiagonalKernel
+
+namespace OAI
+
+/-! Weighted two-point control of the actual limiting Radon measure.
+Finite spatial cutoff sums are bounded by the near-diagonal kernel. -/
+
+noncomputable section
+open Set Filter MeasureTheory ProbabilityTheory Classical
+open scoped NNReal ENNReal Topology CompactlySupported
+
+namespace SLEExactGauge.Multipoint
+
+theorem level_radon_limit_test_moment_le_cappedKernel
+    {Ω : Type*} [MeasurableSpace Ω]
+    {P : Measure Ω} {B : ℝ≥0 → Ω → ℝ} (hB : IsBrownianReal B P)
+    (hm : ∀ t, Measurable (B t)) (hBm : Measurable (Function.uncurry B))
+    (hBc : ∀ ω, Continuous (fun t => B t ω)) (hB0 : ∀ ω, B 0 ω = 0)
+    {κ : ℝ} (hκ : 0 < κ) (hκ8 : κ < 8)
+    (γ : Ω → ℝ≥0 → ℂ) (G F : Ω → ℝ≥0 → ℂ → ℂ)
+    (hw : ∀ ω, IsCapacityTwoWitness (fun t => Real.sqrt κ * B t ω) (γ ω) (G ω) (F ω))
+    (hgrowth : PublishedDiskUnivalentGrowth)
+    (u : ℕ → ℝ) (hu : ∀ n, 0 ≤ u n) (s : ℕ → Finset ℕ) (w : ℕ → ℕ → ℝ)
+    (hw₀ : ∀ n i, i ∈ s n → 0 ≤ w n i) (hw₁ : ∀ n, ∑ i ∈ s n, w n i = 1)
+    (t : ℝ≥0∞) (ν : Ω → Measure upperHalfPlane)
+    (hlim : ∀ᵐ ω ∂P, ∀ f : C_c(upperHalfPlane,ℝ),
+      Tendsto (fun n => ∫ z, f z ∂convexLevelMeasure κ B γ G u s w n t ω)
+        atTop (𝓝 (∫ z, f z ∂ν ω)))
+    (K : Set ℂ) (hK : MeasurableSet K) (hKH : K ⊆ upperHalfPlane)
+    (b : ℝ) (hb : 0 < b) (hbR : ∀ z ∈ K, b ≤ 2*z.im)
+    (f : C_c(upperHalfPlane,ℝ)) (hf : ∀ z, 0 ≤ f z)
+    (hz : ∀ z ∉ K, extendHalfPlaneTest f z = 0) (m : ℕ) :
+    (∫⁻ ω, ENNReal.ofReal (∫ z, f z ∂ν ω)^m ∂P) ≤
+      ENNReal.ofReal (multipointConstant κ m) *
+        ∫⁻ z : Fin m → ℂ, (∏ i, ENNReal.ofReal (extendHalfPlaneTest f (z i))) *
+          cappedDistanceKernel (codimension κ) b z
+          ∂Measure.pi (fun _ : Fin m => volume.restrict K) := by
+  apply level_radon_limit_test_moment_le hm hBc hκ hκ8 γ G F hw u hu s w hw₀ hw₁
+    t ν hlim f hf m
+  intro n
+  simp_rw [ofReal_integral_halfPlaneLevelMeasure hκ hκ8 γ G F _ (hBc _) (hw _) (u n) t f hf]
+  exact levelApproximationTest_moment_le_cappedKernel hB hm hBm hBc hB0 hκ hκ8 γ G F hw
+    hgrowth K hK hKH (fun z => ENNReal.ofReal (extendHalfPlaneTest f z))
+    (extendHalfPlaneTest_measurable f f.continuous.measurable).ennreal_ofReal
+    (fun z hzK => by rw [hz z hzK,ENNReal.ofReal_zero]) b hb hbR m (u n) (hu n) t
+
+theorem level_radon_cutoff_square_sum_le
+    {Ω ι : Type*} [MeasurableSpace Ω]
+    {P : Measure Ω} {B : ℝ≥0 → Ω → ℝ} (hB : IsBrownianReal B P)
+    (hm : ∀ t, Measurable (B t)) (hBm : Measurable (Function.uncurry B))
+    (hBc : ∀ ω, Continuous (fun t => B t ω)) (hB0 : ∀ ω, B 0 ω = 0)
+    {κ : ℝ} (hκ : 0 < κ) (hκ8 : κ < 8)
+    (γ : Ω → ℝ≥0 → ℂ) (G F : Ω → ℝ≥0 → ℂ → ℂ)
+    (hw : ∀ ω, IsCapacityTwoWitness (fun t => Real.sqrt κ * B t ω) (γ ω) (G ω) (F ω))
+    (hgrowth : PublishedDiskUnivalentGrowth)
+    (u : ℕ → ℝ) (hu : ∀ n, 0 ≤ u n) (s : ℕ → Finset ℕ) (w : ℕ → ℕ → ℝ)
+    (hw₀ : ∀ n i, i ∈ s n → 0 ≤ w n i) (hw₁ : ∀ n, ∑ i ∈ s n, w n i = 1)
+    (t : ℝ≥0∞) (ν : Ω → Measure upperHalfPlane) (hνm : Measurable ν)
+    (hν : ∀ ω, IsFiniteMeasureOnCompacts (ν ω))
+    (hlim : ∀ᵐ ω ∂P, ∀ f : C_c(upperHalfPlane,ℝ),
+      Tendsto (fun n => ∫ z, f z ∂convexLevelMeasure κ B γ G u s w n t ω)
+        atTop (𝓝 (∫ z, f z ∂ν ω)))
+    (K : Set ℂ) (hK : MeasurableSet K) (hKH : K ⊆ upperHalfPlane)
+    (b : ℝ) (hb : 0 < b) (hbR : ∀ z ∈ K, b ≤ 2*z.im)
+    (I : Finset ι) (f : ι → C_c(upperHalfPlane,ℝ)) (hf : ∀ i z, 0 ≤ f i z)
+    (hz : ∀ i z, z ∉ K → extendHalfPlaneTest (f i) z = 0)
+    (r : ℝ) (N : ℝ≥0∞)
+    (hoverlap : ∀ x y, (∑ i ∈ I, ENNReal.ofReal (extendHalfPlaneTest (f i) x) *
+      ENNReal.ofReal (extendHalfPlaneTest (f i) y)) ≤ if dist x y ≤ r then N else 0) :
+    (∫⁻ ω, ∑ i ∈ I, ENNReal.ofReal (∫ z, f i z ∂ν ω)^2 ∂P) ≤
+      ENNReal.ofReal (multipointConstant κ 2) * (N *
+        ∫⁻ z : Fin 2 → ℂ, nearDiagonalKernel (codimension κ) b r z
+          ∂Measure.pi (fun _ : Fin 2 => volume.restrict K)) := by
+  have hfm (i : ι) : Measurable (fun ω => ENNReal.ofReal (∫ z, f i z ∂ν ω)) := by
+    have he (ω : Ω) : ENNReal.ofReal (∫ z, f i z ∂ν ω) =
+        ∫⁻ z, ENNReal.ofReal (f i z) ∂ν ω := by
+      let := hν ω
+      exact ofReal_integral_eq_lintegral_ofReal (f i).integrable (Eventually.of_forall (hf i))
+    simp_rw [he]
+    exact (Measure.measurable_lintegral (f i).continuous.measurable.ennreal_ofReal).comp hνm
+  rw [lintegral_finsetSum I (f := fun i ω => ENNReal.ofReal (∫ z, f i z ∂ν ω)^2)
+    (fun i _ => (hfm i).pow_const 2)]
+  apply (Finset.sum_le_sum (fun i _ => level_radon_limit_test_moment_le_cappedKernel
+    hB hm hBm hBc hB0 hκ hκ8 γ G F hw hgrowth u hu s w hw₀ hw₁ t ν hlim K hK hKH
+    b hb hbR (f i) (hf i) (hz i) 2)).trans
+  rw [← Finset.mul_sum]
+  exact mul_le_mul' le_rfl (sum_weighted_pair_kernel_le I
+    (fun i z => ENNReal.ofReal (extendHalfPlaneTest (f i) z))
+    (fun i _ => (extendHalfPlaneTest_measurable (f i) (f i).continuous.measurable).ennreal_ofReal)
+    (codimension κ) b r N hoverlap K)
+
+end SLEExactGauge.Multipoint
+
+end
+
+end OAI