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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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