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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

lean/OAI/Probability/SLE/Gauge/SerpentineActualAngleReflection.lean

@@ -0,0 +1,81 @@
+import OAI.Probability.SLE.Gauge.SerpentineActualAngle
+import OAI.Probability.SLE.Geometry.MarkedWitnessReflection
+
+namespace OAI
+
+/-! Reflection removes the sign restriction on the marked point, with
+exactly the same uniform angle constant as the right-hand experiment. -/
+
+noncomputable section
+open Set Filter Metric ComplexConjugate
+open scoped Topology NNReal ENNReal
+
+namespace SLEExactGauge.Serpentine
+open RibbonCoordinates FirstFrontPassage Target
+
+theorem uniform_serpentine_actual_angle
+    (hopen : PublishedPlanarDiskOpenness)
+    (hstraight : PublishedHalfPlaneCrosscutStraightening)
+    (hexit : PublishedHalfPlaneConformalExitLaw)
+    (hsupport : PublishedPlanarWienerUnitSupport) (W : WienerLaw) (hW : IsWiener W)
+    {s : ℝ} (hs : 0 < s) (hs1 : s ≤ 1) :
+    ∃ s₀ : ℝ, 0 < s₀ ∧ ∀ (U : ℝ≥0 → ℝ) (γ : ℝ≥0 → ℂ)
+      (G F : ℝ≥0 → ℂ → ℂ), IsCapacityTwoWitness U γ G F → Continuous U →
+      ∀ w : ℂ, ‖w‖ ≤ 1 → s ≤ w.im →
+      ∀ m : ℕ, 0 < m → ∀ g : C(ℂ, ℝ),
+      (∀ z ∈ closedRibbon, g (physicalExperimentChart s w m z) = z.re) →
+      ∀ ε : ℝ, ε ≤ 1 / 8 →
+      () ∈ GoodRibbonPrefix (fun _ : Unit => γ)
+        (fun _ => firstFrontTime (fun t => g (γ t)) (fitCompletion s w m))
+        (physicalExperimentChart s w m) ε →
+      let T := (firstFrontTime (fun t => g (γ t)) (fitCompletion s w m)).untopD 0
+      s₀ ≤ (G T w - (U T : ℂ)).im / ‖G T w - (U T : ℂ)‖ := by
+  obtain ⟨s₀, hs₀, hangle⟩ :=
+    uniform_serpentine_actual_angle_nonneg hopen hstraight hexit hsupport W hW hs hs1
+  refine ⟨s₀, hs₀, ?_⟩
+  intro U γ G F hw hU w hwn hwy m hm g hg ε hε hpref
+  by_cases hwr : 0 ≤ w.re
+  · have hchart : physicalExperimentChart s w m = physicalFitChart s w m := by
+      funext z
+      simp only [physicalExperimentChart, ite_eq_left hwr]
+    exact hangle U γ G F hw hU w hwn hwy hwr m hm g
+      (by simpa only [hchart] using hg) ε hε (by simpa only [hchart] using hpref)
+  · have hwneg : w.re < 0 := lt_of_not_ge hwr
+    let γ' : ℝ≥0 → ℂ := loewnerMirror ∘ γ
+    let U' : ℝ≥0 → ℝ := fun t => -U t
+    let G' : ℝ≥0 → ℂ → ℂ := fun t z => loewnerMirror (G t (loewnerMirror z))
+    let F' : ℝ≥0 → ℂ → ℂ := fun t z => loewnerMirror (F t (loewnerMirror z))
+    let g' := mirroredProgress g
+    have hg' : ∀ z ∈ closedRibbon,
+        g' (physicalFitChart s (loewnerMirror w) m z) = z.re := by
+      intro z hz
+      have hh := hg (conj z) (conj_mem_closedRibbon hz)
+      rw [physicalExperimentChart_negative hwneg m] at hh
+      simpa only [g', mirroredProgress, ContinuousMap.coe_mk, reflectedChart,
+        Complex.conj_conj, Complex.conj_re] using hh
+    have hclock : firstFrontTime (fun t => g' (γ' t))
+        (fitCompletion s (loewnerMirror w) m) =
+        firstFrontTime (fun t => g (γ t)) (fitCompletion s w m) := by
+      rw [fitCompletion_mirror]
+      exact mirroredProgress_firstFrontTime g γ _
+    have hpref' : () ∈ GoodRibbonPrefix (fun _ : Unit => γ')
+        (fun _ => firstFrontTime (fun t => g' (γ' t))
+          (fitCompletion s (loewnerMirror w) m))
+        (physicalFitChart s (loewnerMirror w) m) ε := by
+      rw [hclock]
+      rw [goodRibbonPrefix_physical_negative _ _ hwneg m ε] at hpref
+      simpa only [γ', Function.comp_def] using hpref
+    have hh := hangle U' γ' G' F' hw.mirror hU.neg (loewnerMirror w)
+      (by simpa only [loewnerMirror_norm] using hwn)
+      (by simpa only [loewnerMirror_im] using hwy)
+      (by simp only [loewnerMirror_re]; linarith)
+      m hm g' hg' ε hε hpref'
+    dsimp only at hh ⊢
+    rw [hclock] at hh
+    simpa only [U', G', loewnerMirror_twice, mirrored_centered_sine] using hh
+
+end SLEExactGauge.Serpentine
+
+end
+
+end OAI

lean/OAI/Probability/SLE/Gauge/SerpentineActualGuide.lean

@@ -0,0 +1,80 @@
+import OAI.Probability.SLE.Gauge.SerpentinePhysicalGeometry
+import OAI.Probability.SLE.Gauge.SerpentineMarkedRouteClearance
+import OAI.Probability.SLE.Geometry.ActualWaypointStraightening
+
+namespace OAI
+
+/-! The concrete terminal access guide lies in the actual surviving
+component of a successful stopped serpentine trace. -/
+
+noncomputable section
+open Set Filter Metric
+open scoped Topology NNReal
+
+namespace SLEExactGauge.Serpentine
+open RibbonCoordinates
+
+lemma physicalFit_prefix_low_right {s : ℝ} (hs : 0 < s) (w : ℂ) (hw : s ≤ w.im)
+    (hwr : 0 ≤ w.re) {m : ℕ} (hm : 0 < m)
+    (γ xp : ℝ≥0 → ℂ) (T : ℝ≥0)
+    (hcoords : MapsTo xp (Icc 0 T) closedRibbon)
+    (hγ : EqOn γ (physicalFitChart s w m ∘ xp) (Icc 0 T)) :
+    ∀ q ∈ γ '' Icc 0 T, q.im ≤ w.im - 2 * (s / 20) ∨ w.re + 2 * (s / 20) ≤ q.re := by
+  rintro q ⟨t, ht, rfl⟩
+  rw [hγ ht]
+  rcases physicalFitChart_low_or_right hs w hw hm (hcoords ht).2 with hlo | hright
+  · left
+    change (physicalFitChart s w m (xp t)).im ≤ _
+    linarith
+  · right
+    rw [abs_of_nonneg hwr] at hright
+    change _ ≤ (physicalFitChart s w m (xp t)).re
+    linarith
+
+theorem completeMarkedAccess_survives {s : ℝ} (hs : 0 < s) (hs1 : s ≤ 1)
+    (w : ℂ) (hw : s ≤ w.im) (hw1 : ‖w‖ ≤ 1) (hwr : 0 ≤ w.re)
+    {m : ℕ} (hm : 0 < m) {x : ℝ} (hx : |x| ≤ 1 / 4)
+    (γ xp : ℝ≥0 → ℂ) (T : ℝ≥0)
+    (hcoords : MapsTo xp (Icc 0 T) closedRibbon)
+    (hγ : EqOn γ (physicalFitChart s w m ∘ xp) (Icc 0 T))
+    (hfront : ∀ t ∈ Icc 0 T, (xp t).re ≤ fitCompletion s w m) :
+    ∀ u : ℝ≥0, 0 < u → completeMarkedAccess s w m x u ∈ survivingDomain γ T := by
+  obtain ⟨hP, hi, hH, hescape⟩ := physicalFitChart_geometry hs w hw hm
+  have hpast : γ '' Icc 0 T ⊆ physicalFitChart s w m ''
+      {z ∈ closedRibbon | z.re ≤ fitCompletion s w m} := by
+    rintro q ⟨t, ht, rfl⟩
+    exact ⟨xp t, ⟨hcoords ht, hfront t ht⟩, (hγ ht).symm⟩
+  have hfuture := futureRibbon_survives _ hP.continuousOn hi
+    (Nat.cast_nonneg (fitCompletion s w m)) hH γ T hpast
+    (futureRibbon_unbounded_of_centerline_escape _ (fitCompletion s w m) hescape)
+  have hwi := (Complex.im_le_norm w).trans hw1
+  have hR : w.re < fitTerminalX s w := by
+    unfold fitTerminalX
+    rw [abs_of_nonneg hwr]
+    linarith
+  have hhook := markedHook_survives γ T w (lt_of_lt_of_le hs hw) hR
+    (show w.im < 2 by linarith) (show 0 < s / 20 by positivity) (by
+      rintro q ⟨t, ht, rfl⟩
+      rw [hγ ht]
+      refine ⟨physicalFitChart_finite_height_lt_two hs hs1 w hw hw1 hm (hcoords ht) (hfront t ht), ?_⟩
+      rcases physicalFitChart_low_or_right hs w hw hm (hcoords ht).2 with hlo | hright
+      · left
+        change (physicalFitChart s w m (xp t)).im < w.im
+        linarith
+      · right
+        rw [abs_of_nonneg hwr] at hright
+        change w.re < (physicalFitChart s w m (xp t)).re
+        linarith)
+  intro u hu
+  by_cases huT : (u : ℝ) ≤ fitHighTime s w m
+  · rw [completeMarkedAccess, appendMarkedHook, curveJoin_of_le huT]
+    apply hfuture
+    exact mem_image_of_mem _ (guideCoordinate_mem_future hx (by exact_mod_cast hu))
+  · rw [completeMarkedAccess, appendMarkedHook, curveJoin_of_gt (lt_of_not_ge huT)]
+    exact hhook ⟨⟨(u : ℝ) - fitHighTime s w m, by linarith⟩, rfl⟩
+
+end SLEExactGauge.Serpentine
+
+end
+
+end OAI

lean/OAI/Probability/SLE/Gauge/SerpentineActualRadius.lean

@@ -0,0 +1,103 @@
+import OAI.Probability.SLE.Gauge.SerpentineActualGuide
+import OAI.Probability.SLE.Gauge.SerpentineMarkedReflection
+import OAI.Probability.SLE.Gauge.ExperimentClearance
+import OAI.Probability.SLE.Geometry.MarkedSurvivingBall
+
+namespace OAI
+
+/-! Successful physical prefixes leave a definite ball around the marked
+point in the actual surviving domain, hence finish before a fixed radius level. -/
+
+noncomputable section
+open Set Filter Metric
+open scoped Topology NNReal ENNReal
+
+namespace SLEExactGauge.Serpentine
+open RibbonCoordinates
+
+lemma good_physicalFit_ball_survives {s : ℝ} (hs : 0 < s) (w : ℂ)
+    (hwy : s ≤ w.im) (hwr : 0 ≤ w.re) {m : ℕ} (hm : 0 < m)
+    (γ : ℝ≥0 → ℂ) (τ : WithTop ℝ≥0) (ε : ℝ)
+    (hpref : () ∈ GoodRibbonPrefix (fun _ : Unit => γ) (fun _ => τ)
+      (physicalFitChart s w m) ε) :
+    ball w (s / 20) ⊆ survivingDomain γ (τ.untopD 0) := by
+  apply marked_ball_survives γ (τ.untopD 0) w (by positivity) (by linarith)
+  rintro q ⟨t, ht, rfl⟩
+  obtain ⟨z, ⟨hz, _⟩, he⟩ := hpref.2.1 ht
+  change physicalFitChart s w m z = γ t at he
+  rw [← he]
+  rcases physicalFitChart_low_or_right hs w hwy hm hz.2 with hlo | hright
+  · left
+    linarith
+  · right
+    rw [abs_of_nonneg hwr] at hright
+    linarith
+
+theorem good_physicalExperiment_ball_survives {s : ℝ} (hs : 0 < s) (w : ℂ)
+    (hwy : s ≤ w.im) {m : ℕ} (hm : 0 < m)
+    (γ : ℝ≥0 → ℂ) (τ : WithTop ℝ≥0) (ε : ℝ)
+    (hpref : () ∈ GoodRibbonPrefix (fun _ : Unit => γ) (fun _ => τ)
+      (physicalExperimentChart s w m) ε) :
+    ball w (s / 20) ⊆ survivingDomain γ (τ.untopD 0) := by
+  by_cases hwr : 0 ≤ w.re
+  · have hchart : physicalExperimentChart s w m = physicalFitChart s w m := by
+      funext z
+      simp only [physicalExperimentChart, ite_eq_left hwr]
+    apply good_physicalFit_ball_survives hs w hwy hwr hm γ τ ε
+    simpa only [hchart] using hpref
+  · have hneg : w.re < 0 := lt_of_not_ge hwr
+    have hp : () ∈ GoodRibbonPrefix (fun _ : Unit => (loewnerMirror ∘ γ)) (fun _ => τ)
+        (physicalFitChart s (loewnerMirror w) m) ε := by
+      rw [goodRibbonPrefix_physical_negative _ _ hneg m ε] at hpref
+      simpa only [Function.comp_def] using hpref
+    have hb := good_physicalFit_ball_survives hs (loewnerMirror w)
+      (by simpa only [loewnerMirror_im] using hwy)
+      (by simp only [loewnerMirror_re]; linarith) hm (loewnerMirror ∘ γ) τ ε hp
+    intro z hz
+    apply (loewnerMirror_surviving γ (τ.untopD 0) z).mp
+    apply hb
+    simpa only [mem_ball, loewnerMirror_dist] using hz
+
+def experimentRadiusLevel (s : ℝ) : ℝ := -Real.log (s / 80)
+
+lemma experimentRadiusLevel_nonneg {s : ℝ} (hs : 0 < s) (hs1 : s ≤ 1) :
+    0 ≤ experimentRadiusLevel s := by
+  unfold experimentRadiusLevel
+  exact neg_nonneg.mpr (Real.log_nonpos (by positivity) (by linarith))
+
+lemma experimentRadiusLevel_cutoff {s : ℝ} (hs : 0 < s) (w : ℂ) (hw : ‖w‖ ≤ 1) :
+    (2 * w.im) * Real.exp (-experimentRadiusLevel s) < s / 20 := by
+  have hy := (Complex.im_le_norm w).trans hw
+  rw [experimentRadiusLevel, neg_neg, Real.exp_log (by positivity : 0 < s / 80)]
+  nlinarith
+
+theorem good_physicalExperiment_before_radius
+    {U : ℝ≥0 → ℝ} {γ : ℝ≥0 → ℂ} {G F : ℝ≥0 → ℂ → ℂ}
+    (hU : Continuous U) (hw : IsCapacityTwoWitness U γ G F)
+    {s : ℝ} (hs : 0 < s) (w : ℂ) (hwn : ‖w‖ ≤ 1) (hwy : s ≤ w.im)
+    {m : ℕ} (hm : 0 < m) (τ : WithTop ℝ≥0) (ε : ℝ)
+    (hpref : () ∈ GoodRibbonPrefix (fun _ : Unit => γ) (fun _ => τ)
+      (physicalExperimentChart s w m) ε) :
+    τ < radiusLevelTime γ G w (experimentRadiusLevel s) ∧
+      w ∈ survivingDomain γ (τ.untopD 0) := by
+  have hb := good_physicalExperiment_ball_survives hs w hwy hm γ τ ε hpref
+  have hlive := hb (mem_ball_self (by positivity : 0 < s / 20))
+  refine ⟨?_, hlive⟩
+  have hh := completion_before_radiusLevelTime_of_prefix_lower hU hw (τ.untopD 0) w
+    (experimentRadiusLevel s) (s / 20) (fun t ht => by
+      have hbt := hb.trans (survivingDomain_antitone γ ht)
+      exact ⟨hbt (mem_ball_self (by positivity)),
+        fullRadius_lower_of_surviving_ball hU hw t w (by positivity) hbt⟩)
+    (experimentRadiusLevel_cutoff hs w hwn)
+  cases he : τ with
+  | top => exact (hpref.1 he).elim
+  | coe T =>
+    have hh' : (T : ℝ≥0∞) < radiusLevelTime γ G w (experimentRadiusLevel s) := by
+      simpa only [he, WithTop.untopD_coe] using hh
+    exact_mod_cast hh'
+
+end SLEExactGauge.Serpentine
+
+end
+
+end OAI

lean/OAI/Probability/SLE/Gauge/SerpentineArrayEmbedding.lean

@@ -0,0 +1,198 @@
+import OAI.Probability.SLE.Gauge.SerpentineCurve
+import OAI.Probability.SLE.Gauge.SerpentineEmbedding
+
+namespace OAI
+
+/-! Global normal coordinates for the actual finite serpentine array.
+Every parameter belongs to a straight or circular piece, and the only
+possible normal-band contacts are the prescribed common end sections. -/
+
+noncomputable section
+open Set Metric
+
+namespace SLEExactGauge.Serpentine
+
+def arrayEnd (m j : ℕ) : ℝ := columnEntry 0 m j + 200 * m
+
+lemma array_pieces (m j : ℕ) {t : ℝ} (ht : t ∈ Icc 0 (arrayEnd m j)) :
+    (∃ i ≤ j, ∃ u ∈ Icc (0 : ℝ) (200 * m),
+      t = columnEntry 0 m i + u ∧
+      arraySpine m j t = straightPiece m i u ∧ arrayTangent m j t = straightTangent i) ∨
+    (∃ i < j, ∃ u ∈ Icc (0 : ℝ) (50 * Real.pi),
+      t = columnEntry 0 m i + 200 * m + u ∧
+      arraySpine m j t = circularPiece m i u ∧ arrayTangent m j t = circularTangent i u) := by
+  induction j with
+  | zero =>
+    exact Or.inl ⟨0, le_rfl, t, ⟨ht.1, by simpa only [arrayEnd, columnEntry, Nat.cast_zero, zero_mul, add_zero, zero_add] using ht.2⟩,
+      by simp [columnEntry], rfl, rfl⟩
+  | succ j ih =>
+    have ha : arrayEnd m j < columnEntry 0 m (j + 1) := by
+      rw [arrayEnd, columnEntry_succ]
+      linarith [Real.pi_pos]
+    by_cases hta : t ≤ arrayEnd m j
+    · change t ≤ columnEntry 0 m j + 200 * m at hta
+      rcases ih ⟨ht.1, hta⟩ with ⟨i, hi, u, hu, htu, hs, hT⟩ | ⟨i, hi, u, hu, htu, hs, hT⟩
+      · refine Or.inl ⟨i, hi.trans (Nat.le_succ j), u, hu, htu, ?_, ?_⟩
+        · simpa only [arraySpine, curveJoin_of_le (hta.trans ha.le), curveJoin_of_le hta] using hs
+        · simpa only [arrayTangent, curveJoin_of_le (hta.trans ha.le), curveJoin_of_le hta] using hT
+      · refine Or.inr ⟨i, hi.trans_le (Nat.le_succ j), u, hu, htu, ?_, ?_⟩
+        · simpa only [arraySpine, curveJoin_of_le (hta.trans ha.le), curveJoin_of_le hta] using hs
+        · simpa only [arrayTangent, curveJoin_of_le (hta.trans ha.le), curveJoin_of_le hta] using hT
+    · have hat : columnEntry 0 m j + 200 * m < t := lt_of_not_ge hta
+      by_cases htb : t ≤ columnEntry 0 m (j + 1)
+      · refine Or.inr ⟨j, Nat.lt_succ_self j, t - arrayEnd m j, ?_, ?_, ?_, ?_⟩
+        · constructor
+          · linarith
+          · rw [columnEntry_succ] at htb
+            dsimp [arrayEnd]
+            linarith
+        · dsimp [arrayEnd]; ring
+        · simp only [arraySpine, curveJoin_of_le htb, curveJoin_of_gt hat, arrayEnd]
+        · simp only [arrayTangent, curveJoin_of_le htb, curveJoin_of_gt hat, arrayEnd]
+      · have hbt : columnEntry 0 m (j + 1) < t := lt_of_not_ge htb
+        refine Or.inl ⟨j + 1, le_rfl, t - columnEntry 0 m (j + 1), ?_, by ring, ?_, ?_⟩
+        · constructor
+          · linarith
+          · dsimp only [arrayEnd] at ht
+            linarith [ht.2]
+        · exact arraySpine_tail m (j + 1) hbt.le
+        · exact arrayTangent_tail m (j + 1) hbt.le
+
+lemma normalized_width {m : ℕ} (hm : 0 < m) : ribbonWidth (100 * m) m = 1 := by
+  unfold ribbonWidth
+  have hm' : (m : ℝ) ≠ 0 := by exact_mod_cast hm.ne'
+  field_simp
+
+lemma normalized_spacing {m : ℕ} (hm : 0 < m) : spacing (100 * m) m = 100 := by
+  rw [spacing_eq_width, normalized_width hm, mul_one]
+
+lemma normalized_radius {m : ℕ} (hm : 0 < m) : turnRadius (100 * m) m = 50 := by
+  rw [turnRadius_eq_width, normalized_width hm, mul_one]
+
+lemma normal_straight_eq {m : ℕ} (hm : 0 < m) (j : ℕ) (u a : ℝ) :
+    straightPiece m j u + (a : ℂ) * Complex.I * straightTangent j =
+      columnPoint 0 (100 * m) m j (side j * (-100 * m + u)) a := by
+  apply Complex.ext <;>
+    simp only [straightPiece, straightTangent, columnPoint, columnOffset,
+      normalized_spacing hm, normalized_width hm, Complex.add_re, Complex.add_im,
+      Complex.mul_re, Complex.mul_im, Complex.ofReal_re, Complex.ofReal_im,
+      Complex.I_re, Complex.I_im, Complex.zero_re, Complex.zero_im] <;> ring
+
+lemma normal_circular_eq {m : ℕ} (hm : 0 < m) (j : ℕ) (u a : ℝ) :
+    circularPiece m j u + (a : ℂ) * Complex.I * circularTangent j u =
+      turnPoint 0 (100 * m) m j (u / 50) a := by
+  apply Complex.ext
+  · simp only [circularPiece, circularTangent, turnPoint, columnOffset,
+      normalized_spacing hm, normalized_radius hm, normalized_width hm,
+      Complex.add_re, Complex.add_im, Complex.mul_re, Complex.mul_im,
+      Complex.ofReal_re, Complex.ofReal_im, Complex.I_re, Complex.I_im,
+      Complex.zero_re]
+    ring
+  · simp only [circularPiece, circularTangent, turnPoint, columnOffset,
+      normalized_spacing hm, normalized_radius hm, normalized_width hm,
+      Complex.add_re, Complex.add_im, Complex.mul_re, Complex.mul_im,
+      Complex.ofReal_re, Complex.ofReal_im, Complex.I_re, Complex.I_im,
+      Complex.zero_im]
+    ring_nf
+    rw [side_sq]
+    ring
+
+lemma straight_height_bound (m j : ℕ) {u : ℝ} (hu : u ∈ Icc (0 : ℝ) (200 * m)) :
+    |side j * (-100 * m + u)| ≤ 100 * m := by
+  rw [abs_mul, side_abs, one_mul]
+  exact abs_le.mpr ⟨by linarith [hu.1], by linarith [hu.2]⟩
+
+lemma circular_angle_bound {u : ℝ} (hu : u ∈ Icc (0 : ℝ) (50 * Real.pi)) :
+    u / 50 ∈ Icc (0 : ℝ) Real.pi := by
+  constructor <;> linarith [hu.1, hu.2]
+
+lemma turn_column_time {m : ℕ} (hm : 0 < m) (j k : ℕ) {θ y a b : ℝ}
+    (hθ : θ ∈ Icc (0 : ℝ) Real.pi) (hy : |y| ≤ 100 * m)
+    (ha : |a| ≤ 1) (hb : |b| ≤ 1)
+    (he : turnPoint 0 (100 * m) m j θ a = columnPoint 0 (100 * m) m k y b) :
+    columnEntry 0 m j + 200 * m + 50 * θ =
+      columnEntry 0 m k + (side k * y + 100 * m) ∧ a = b := by
+  have hh : (0 : ℝ) < 100 * m := by positivity
+  rcases turnPoint_column_gluing hh hm 0 hθ hy ha hb he with
+    ⟨hθ, hk, hy, hab⟩ | ⟨hθ, hk, hy, hab⟩
+  · subst θ
+    subst k
+    subst y
+    refine ⟨?_, hab⟩
+    have hs : side j * (side j * (100 * (m : ℝ))) = 100 * m := by
+      rw [← mul_assoc, ← pow_two, side_sq, one_mul]
+    rw [hs]
+    ring
+  · subst θ
+    subst k
+    subst y
+    refine ⟨?_, hab⟩
+    have hs : side (j + 1) * (side j * (100 * (m : ℝ))) = -(100 * m) := by
+      rw [side_succ, neg_mul, ← mul_assoc, ← pow_two, side_sq, one_mul]
+    rw [hs, columnEntry_succ]
+    ring
+
+/-- Normal coordinates over the complete finite array are injective,
+including the endpoints shared by adjacent straight and circular pieces. -/
+theorem array_normal_injective {m : ℕ} (hm : 0 < m) (last : ℕ) :
+    InjOn (normalRibbon (arraySpine m last) (arrayTangent m last))
+      {z : ℂ | z.re ∈ Icc (0 : ℝ) (arrayEnd m last) ∧ |z.im| ≤ 1} := by
+  intro z hz w hw he
+  have hh : (0 : ℝ) < 100 * m := by positivity
+  rcases array_pieces m last hz.1 with ⟨i, _, u, hu, hzu, hzs, hzT⟩ |
+    ⟨i, _, u, hu, hzu, hzs, hzT⟩ <;>
+  rcases array_pieces m last hw.1 with ⟨j, _, v, hv, hwv, hws, hwT⟩ |
+    ⟨j, _, v, hv, hwv, hws, hwT⟩
+  · simp only [normalRibbon] at he
+    rw [hzs, hzT, hws, hwT,
+      normal_straight_eq hm, normal_straight_eq hm] at he
+    have hij := columnPoint_equal_forces_index hh hm 0 _ _ hz.2 hw.2 he
+    subst j
+    obtain ⟨hy, hab⟩ := columnPoint_injective hh hm 0 i he
+    have hs : side i ≠ 0 := by
+      intro h
+      have hh := side_abs i
+      rw [h, abs_zero] at hh
+      norm_num at hh
+    have huv : u = v := by
+      have h := mul_left_cancel₀ hs hy
+      linarith
+    exact Complex.ext (by rw [hzu, hwv, huv]) hab
+  · simp only [normalRibbon] at he
+    rw [hzs, hzT, hws, hwT,
+      normal_straight_eq hm, normal_circular_eq hm] at he
+    obtain ⟨ht, hab⟩ := turn_column_time hm j i (circular_angle_bound hv)
+      (straight_height_bound m i hu) hw.2 hz.2 he.symm
+    have hs : side i * (side i * (-100 * (m : ℝ) + u)) = -100 * m + u := by
+      rw [← mul_assoc, ← pow_two, side_sq, one_mul]
+    rw [hs] at ht
+    exact Complex.ext (by rw [hzu, hwv]; linarith) hab.symm
+  · simp only [normalRibbon] at he
+    rw [hzs, hzT, hws, hwT,
+      normal_circular_eq hm, normal_straight_eq hm] at he
+    obtain ⟨ht, hab⟩ := turn_column_time hm i j (circular_angle_bound hu)
+      (straight_height_bound m j hv) hz.2 hw.2 he
+    have hs : side j * (side j * (-100 * (m : ℝ) + v)) = -100 * m + v := by
+      rw [← mul_assoc, ← pow_two, side_sq, one_mul]
+    rw [hs] at ht
+    exact Complex.ext (by rw [hzu, hwv]; linarith) hab
+  · simp only [normalRibbon] at he
+    rw [hzs, hzT, hws, hwT,
+      normal_circular_eq hm, normal_circular_eq hm] at he
+    have hij : i = j := by
+      by_contra hij
+      rcases lt_or_gt_of_ne hij with hij | hji
+      · exact turnPoint_ne hh hm hij 0 (circular_angle_bound hu) (circular_angle_bound hv)
+          hz.2 hw.2 he
+      · exact turnPoint_ne hh hm hji 0 (circular_angle_bound hv) (circular_angle_bound hu)
+          hw.2 hz.2 he.symm
+    subst j
+    obtain ⟨ht, hab⟩ := turnPoint_injective hh hm 0 i (circular_angle_bound hu)
+      (circular_angle_bound hv) hz.2 hw.2 he
+    exact Complex.ext (by rw [hzu, hwv]; linarith) hab
+
+end SLEExactGauge.Serpentine
+
+end
+
+end OAI

lean/OAI/Probability/SLE/Gauge/SerpentineArrayRegion.lean

@@ -0,0 +1,50 @@
+import OAI.Probability.SLE.Gauge.SerpentineAttachments
+
+namespace OAI
+
+/-! Horizontal confinement of the whole infinite array. This keeps
+every part of the completed experiment away from the marked-point shadow. -/
+
+noncomputable section
+open Set Metric
+
+namespace SLEExactGauge.Serpentine
+
+lemma array_normal_re_lower {m : ℕ} (hm : 0 < m) {z : ℂ}
+    (hz : 0 ≤ z.re ∧ |z.im| ≤ 1) :
+    -(400 * (m : ℝ)) ≤ (normalRibbon (arraySpine m (2 * m)) (arrayTangent m (2 * m)) z).re := by
+  have hh : (0 : ℝ) < 100 * m := by positivity
+  by_cases he : z.re ≤ arrayEnd m (2 * m)
+  · rcases array_pieces m (2 * m) ⟨hz.1, he⟩ with ⟨i, hi, u, hu, _, hs, hT⟩ |
+      ⟨i, hi, u, hu, _, hs, hT⟩
+    · simp only [normalRibbon]
+      rw [hs, hT, normal_straight_eq hm]
+      have hb := columnPoint_bound hh hm hi 0 (straight_height_bound m i hu) hz.2
+      rw [dist_zero_right] at hb
+      have hi := Complex.abs_re_le_norm (columnPoint 0 (100 * m) m i (side i * (-100 * m + u)) z.im)
+      have hl := neg_abs_le (columnPoint 0 (100 * m) m i (side i * (-100 * m + u)) z.im).re
+      linarith
+    · simp only [normalRibbon]
+      rw [hs, hT, normal_circular_eq hm]
+      have hb := turnPoint_bound hh hm (show i + 1 ≤ 2 * m by omega) 0 (u / 50) hz.2
+      rw [dist_zero_right] at hb
+      have hi := Complex.abs_re_le_norm (turnPoint 0 (100 * m) m i (u / 50) z.im)
+      have hl := neg_abs_le (turnPoint 0 (100 * m) m i (u / 50) z.im).re
+      linarith
+  · have hE : columnEntry 0 m (2 * m) ≤ z.re := by
+      have h := lt_of_not_ge he
+      dsimp only [arrayEnd] at h
+      linarith [Nat.cast_nonneg (α := ℝ) m]
+    have ht := array_normal_terminal hm (a := z.im) hE
+    rw [Complex.re_add_im z] at ht
+    rw [ht, columnPoint_re]
+    simp only [columnOffset, normalized_spacing hm, normalized_width hm, side_even,
+      one_mul, Complex.zero_re, zero_add, Nat.cast_mul, Nat.cast_ofNat]
+    have hm' : (1 : ℝ) ≤ m := by exact_mod_cast hm
+    linarith [(abs_le.mp hz.2).2]
+
+end SLEExactGauge.Serpentine
+
+end
+
+end OAI

lean/OAI/Probability/SLE/Gauge/SerpentineAttachments.lean

@@ -0,0 +1,92 @@
+import OAI.Probability.SLE.Gauge.SerpentineInfiniteArray
+
+namespace OAI
+
+/-! Clearance below the array and the unique attachment to its first
+column. These facts separate the low connector from the array. -/
+
+noncomputable section
+open Set Metric
+
+namespace SLEExactGauge.Serpentine
+
+lemma array_normal_im_lower {m : ℕ} (hm : 0 < m) {z : ℂ}
+    (hz : 0 ≤ z.re ∧ |z.im| ≤ 1) :
+    -(400 * (m : ℝ)) ≤ (normalRibbon (arraySpine m (2 * m)) (arrayTangent m (2 * m)) z).im := by
+  have hh : (0 : ℝ) < 100 * m := by positivity
+  by_cases he : z.re ≤ arrayEnd m (2 * m)
+  · rcases array_pieces m (2 * m) ⟨hz.1, he⟩ with ⟨i, hi, u, hu, _, hs, hT⟩ |
+      ⟨i, hi, u, hu, _, hs, hT⟩
+    · simp only [normalRibbon]
+      rw [hs, hT, normal_straight_eq hm]
+      have hb := columnPoint_bound hh hm hi 0 (straight_height_bound m i hu) hz.2
+      rw [dist_zero_right] at hb
+      have hi := Complex.abs_im_le_norm (columnPoint 0 (100 * m) m i (side i * (-100 * m + u)) z.im)
+      have hl := neg_abs_le (columnPoint 0 (100 * m) m i (side i * (-100 * m + u)) z.im).im
+      linarith
+    · simp only [normalRibbon]
+      rw [hs, hT, normal_circular_eq hm]
+      have hb := turnPoint_bound hh hm (show i + 1 ≤ 2 * m by omega) 0 (u / 50) hz.2
+      rw [dist_zero_right] at hb
+      have hi := Complex.abs_im_le_norm (turnPoint 0 (100 * m) m i (u / 50) z.im)
+      have hl := neg_abs_le (turnPoint 0 (100 * m) m i (u / 50) z.im).im
+      linarith
+  · have hE : columnEntry 0 m (2 * m) ≤ z.re := by
+      have h := lt_of_not_ge he
+      dsimp only [arrayEnd] at h
+      linarith [Nat.cast_nonneg (α := ℝ) m]
+    have ht := array_normal_terminal hm (a := z.im) hE
+    rw [Complex.re_add_im z] at ht
+    rw [ht, columnPoint_im]
+    have h := lt_of_not_ge he
+    dsimp only [arrayEnd] at h
+    simp only [Complex.zero_im, zero_add]
+    linarith
+
+/-- The downward extension of the first column meets the array only at
+its initial cross-section, with identical normal coordinate. -/
+theorem array_downward_attachment {m : ℕ} (hm : 0 < m) {z : ℂ}
+    (hz : 0 ≤ z.re ∧ |z.im| ≤ 1) {y a : ℝ} (hy : y ≤ -(100 * (m : ℝ)))
+    (ha : |a| ≤ 1)
+    (he : normalRibbon (arraySpine m (2 * m)) (arrayTangent m (2 * m)) z =
+      columnPoint 0 (100 * m) m 0 y a) :
+    z.re = 0 ∧ y = -(100 * (m : ℝ)) ∧ z.im = a := by
+  have hh : (0 : ℝ) < 100 * m := by positivity
+  have hs0 : side 0 = 1 := by simp [side]
+  by_cases hE : z.re ≤ arrayEnd m (2 * m)
+  · rcases array_pieces m (2 * m) ⟨hz.1, hE⟩ with ⟨i, _, u, hu, hzu, hs, hT⟩ |
+      ⟨i, hi, u, hu, _, hs, hT⟩
+    · simp only [normalRibbon] at he
+      rw [hs, hT, normal_straight_eq hm] at he
+      have hii := columnPoint_equal_forces_index hh hm 0 _ _ hz.2 ha he
+      subst i
+      obtain ⟨hy', ha'⟩ := columnPoint_injective hh hm 0 0 he
+      rw [hs0, one_mul] at hy'
+      have hu0 : u = 0 := by linarith [hu.1]
+      subst u
+      exact ⟨by simpa [columnEntry] using hzu, by linarith, ha'⟩
+    · simp only [normalRibbon] at he
+      rw [hs, hT, normal_circular_eq hm] at he
+      by_cases hi0 : i = 0
+      · subst i
+        have him := turn_oriented_height hh hm 0 0 (circular_angle_bound hu) hz.2
+        rw [hs0, one_mul, he, columnPoint_im] at him
+        simp only [Complex.zero_im, zero_add] at him
+        linarith
+      · exact (turnPoint_column_ne_nonadjacent hh hm (Or.inl (Nat.pos_of_ne_zero hi0))
+          0 (u / 50) y hz.2 ha he).elim
+  · have hze : columnEntry 0 m (2 * m) ≤ z.re := by
+      have h := lt_of_not_ge hE
+      dsimp only [arrayEnd] at h
+      linarith [Nat.cast_nonneg (α := ℝ) m]
+    have ht := array_normal_terminal hm (a := z.im) hze
+    rw [Complex.re_add_im z] at ht
+    rw [ht] at he
+    have hii := columnPoint_equal_forces_index hh hm 0 _ _ hz.2 ha he
+    omega
+
+end SLEExactGauge.Serpentine
+
+end
+
+end OAI

lean/OAI/Probability/SLE/Gauge/SerpentineCenteredMass.lean

@@ -0,0 +1,132 @@
+import OAI.Probability.SLE.Gauge.SerpentineActualRadius
+import OAI.Probability.SLE.Gauge.SerpentineActualAngleReflection
+import OAI.Probability.SLE.Gauge.ExtendedExperimentStop
+
+namespace OAI
+
+/-! The stopped physical experiment under the actual finite centered law.
+Both its mass and its successful completion are observable at the front. -/
+
+noncomputable section
+open Set Filter MeasureTheory ProbabilityTheory Metric
+open scoped Topology NNReal ENNReal
+
+namespace SLEExactGauge.Serpentine
+open RibbonCoordinates Target FirstFrontPassage
+
+lemma experimentSteps_add_one {s : ℝ} (hs : 0 < s) (w : ℂ) (hw : s ≤ w.im)
+    {m : ℕ} (hm : 0 < m) : experimentSteps s w m + 1 = fitCompletion s w m := by
+  have hbound := (fitCompletion_bounds hs w hw hm).1
+  have hEntry : 0 ≤ fitEntry s w m :=
+    (by unfold fitHeight; positivity : (0 : ℝ) ≤ fitHeight m).trans (fit_entry_lower hs w hw hm)
+  have hcol : 0 ≤ columnEntry 0 m (2 * m) := columnEntry_nonneg le_rfl _ _
+  have hmR : (0 : ℝ) < m := by exact_mod_cast hm
+  have hk : (0 : ℝ) < fitCompletion s w m := by linarith
+  have hkN : 0 < fitCompletion s w m := by exact_mod_cast hk
+  change fitCompletion s w m - 1 + 1 = fitCompletion s w m
+  omega
+
+lemma experiment_front_eq {Ω : Type*} {s : ℝ} (hs : 0 < s) (w : ℂ) (hw : s ≤ w.im)
+    {m : ℕ} (hm : 0 < m) (g : C(ℂ, ℝ)) (γ : Ω → ℝ≥0 → ℂ) :
+    ribbonIntegerFront g γ (experimentSteps s w m) =
+      ribbonFrontStop g γ (fitCompletion s w m) := by
+  have hh : (experimentSteps s w m : ℝ) + 1 = fitCompletion s w m := by
+    exact_mod_cast experimentSteps_add_one hs w hw hm
+  simp only [ribbonIntegerFront, hh]
+
+lemma exponential_prefactor_quadratic_cost {p C : ℝ} (hp : 0 < p) (hC : 0 < C) :
+    ∃ D : ℝ, 0 < D ∧ ∀ m : ℕ, 0 < m →
+      Real.exp (-D * (m : ℝ) ^ 2) ≤ p * Real.exp (-C * (m : ℝ) ^ 2) := by
+  refine ⟨C + |Real.log p| + 1, by positivity, fun m hm => ?_⟩
+  have hm1 : (1 : ℝ) ≤ m := by exact_mod_cast hm
+  have hlog : -|Real.log p| ≤ Real.log p := neg_abs_le _
+  have hmul := mul_nonneg (abs_nonneg (Real.log p))
+    (show 0 ≤ (m : ℝ) ^ 2 - 1 by nlinarith)
+  calc
+    _ ≤ Real.exp (Real.log p + -C * (m : ℝ) ^ 2) := by
+      apply Real.exp_le_exp.mpr
+      nlinarith [abs_nonneg (Real.log p)]
+    _ = _ := by rw [Real.exp_add, Real.exp_log hp]
+
+theorem uniform_serpentine_centered_stopped_mass
+    {Ω : Type} [mΩ : MeasurableSpace Ω] (μ : Measure Ω) [IsProbabilityMeasure μ]
+    (κ : ℝ) (hκ : 0 < κ) (hκ8 : κ < 8)
+    (B : ℝ≥0 → Ω → ℝ) (hB : IsBrownianReal B μ)
+    (hBm : Measurable (fun p : ℝ≥0 × Ω => B p.1 p.2))
+    (hc : ∀ ω, Continuous (fun t => B t ω)) (hB0 : ∀ ω, B 0 ω = 0)
+    (γ : Ω → ℝ≥0 → ℂ) (G F : Ω → ℝ≥0 → ℂ → ℂ)
+    (hw : ∀ ω, IsCapacityTwoWitness (fun t => Real.sqrt κ * B t ω) (γ ω) (G ω) (F ω))
+    (hcompact : PublishedHalfPlaneUnivalentCompactness)
+    (hboundary : PublishedFiniteLoewnerBoundaryExtension)
+    (hsupport : PublishedGeometricTubeSupport μ γ)
+    (hplanar : PublishedPlanarDiskOpenness)
+    (hstraight : PublishedHalfPlaneCrosscutStraightening)
+    (hexit : PublishedHalfPlaneConformalExitLaw)
+    (hwiener : PublishedPlanarWienerUnitSupport)
+    (W : WienerLaw) (hW : IsWiener W)
+    (ε : ℝ) (hε : 0 < ε) (hεsmall : ε ≤ 1 / 8) :
+    ∃ c v₀ : ℝ, 0 < c ∧ 0 < v₀ ∧ ∀ s : ℝ, 0 < s → s ≤ 1 →
+      ∃ C : ℝ, 0 < C ∧ ∀ w : ℂ, ‖w‖ ≤ 1 → s ≤ w.im → ∀ m : ℕ, 0 < m →
+      ∀ v : ℝ, 0 < v → v < ribbonWidth (halfHeight s) m * v₀ → ∀ g : C(ℂ, ℝ),
+      (∀ z ∈ closedRibbon, g (physicalExperimentChart s w m z) = z.re) →
+      ENNReal.ofReal (Real.exp (-C * (m : ℝ) ^ 2)) ≤
+        finiteCenteredLaw μ κ B γ G w (experimentRadiusLevel s)
+          (RibbonStepSuccess γ (fun _ => 0) (ribbonFrontStop g γ (fitCompletion s w m))
+            (physicalExperimentChart s w m) ε κ v
+            (c * (s / 20000) ^ dimension κ * (m : ℝ) ^ codimension κ)
+            (closedBall (center s w) (s / 20))) := by
+  have hm (t : ℝ≥0) : Measurable (B t) :=
+    hBm.comp (measurable_const.prodMk measurable_id)
+  obtain ⟨c, v₀, hcm, hv₀, hprob⟩ := uniform_serpentine_physical_stopped_mass μ κ hκ hκ8
+    B hB hm hc γ G F hw hcompact hboundary hsupport hplanar hstraight hexit hwiener W hW ε hε hεsmall
+  refine ⟨c, v₀, hcm, hv₀, fun s hs hs1 => ?_⟩
+  obtain ⟨C, hC, hprob⟩ := hprob s hs
+  obtain ⟨s₀, hs₀, hangle⟩ := uniform_serpentine_actual_angle hplanar hstraight hexit hwiener W hW hs hs1
+  obtain ⟨D, hD, hcost⟩ := exponential_prefactor_quadratic_cost
+    (Real.rpow_pos_of_pos hs₀ (greenExponent κ)) hC
+  refine ⟨D, hD, fun w hwn hwy m hmp v hv hvcut g hg => ?_⟩
+  let τ := ribbonFrontStop g γ (fitCompletion s w m)
+  let E := RibbonStepSuccess γ (fun _ => 0) τ (physicalExperimentChart s w m) ε κ v
+    (c * (s / 20000) ^ dimension κ * (m : ℝ) ^ codimension κ)
+    (closedBall (center s w) (s / 20))
+  let ℱ := Filtration.natural B
+    (fun _t => (hBm.comp (measurable_const.prodMk measurable_id)).stronglyMeasurable)
+  have ha : Adapted ℱ (fun t ω => γ ω t) :=
+    brownian_capacity_trace_adapted B hm hc κ γ G F hw
+  have hγc : ∀ ω, Continuous (γ ω) := fun ω => (hw ω).1
+  have hτ : IsStoppingTime ℱ τ := ribbonFrontStop_stopping ℱ g γ ha hγc _
+  have hE : MeasurableSet[hτ.measurableSpace] E :=
+    ribbonStepSuccess_measurable ℱ γ ha hγc (fun _ => 0) τ
+      (isStoppingTime_const ℱ 0) hτ (fun _ => bot_le) _
+      (physicalExperimentChart_closedEmbedding hs w hwy hmp) ε κ v _ _
+  have hordinary : ENNReal.ofReal (Real.exp (-C * (m : ℝ) ^ 2)) ≤ μ E := by
+    have hh := hprob w hwn hwy m hmp v hv hvcut g hg
+    rw [experiment_front_eq hs w hwy hmp g γ] at hh
+    simpa only [E, τ, RibbonStepSuccess, Set.ofPred_and, Set.ofPred_mem_eq,
+      WithTop.untopD_zero] using hh
+  have hcentered := finiteCenteredLaw_completed_experiment_lower_bound hB hBm hc hB0 κ hκ hκ8
+    γ G F (Eventually.of_forall hw) w (show w ∈ upperHalfPlane from lt_of_lt_of_le hs hwy)
+    (experimentRadiusLevel s) (experimentRadiusLevel_nonneg hs hs1) τ hτ E hE s₀ hs₀.le (by
+      apply Eventually.of_forall
+      intro ω hω
+      have hpref : () ∈ GoodRibbonPrefix (fun _ : Unit => γ ω) (fun _ => τ ω)
+          (physicalExperimentChart s w m) ε := hω.1
+      have hbefore := good_physicalExperiment_before_radius ((hc ω).const_mul _) (hw ω)
+        hs w hwn hwy hmp (τ ω) ε hpref
+      refine ⟨hpref.1, hbefore.1, hbefore.2, ?_⟩
+      rw [Complex.sin_arg]
+      simpa only [τ, ribbonFrontStop, Complex.ofReal_mul] using
+        hangle _ _ _ _ (hw ω) ((hc ω).const_mul _) w hwn hwy m hmp g hg ε hεsmall hpref)
+  calc
+    _ ≤ ENNReal.ofReal (s₀ ^ greenExponent κ) *
+        ENNReal.ofReal (Real.exp (-C * (m : ℝ) ^ 2)) := by
+      rw [← ENNReal.ofReal_mul (Real.rpow_nonneg hs₀.le _)]
+      exact ENNReal.ofReal_le_ofReal (hcost m hmp)
+    _ ≤ ENNReal.ofReal (s₀ ^ greenExponent κ) * μ E := mul_le_mul' le_rfl hordinary
+    _ ≤ _ := hcentered
+
+end SLEExactGauge.Serpentine
+
+end
+
+end OAI

lean/OAI/Probability/SLE/Gauge/SerpentineCompleteCurve.lean

@@ -0,0 +1,112 @@
+import OAI.Probability.SLE.Gauge.SerpentineInfiniteArray
+import OAI.Probability.SLE.Geometry.RoundedConnectorGeometry
+
+namespace OAI
+
+/-! Arclength gluing of the low rounded connector and the upward-continued
+serpentine array. -/
+
+noncomputable section
+open Set Metric
+open scoped NNReal
+
+namespace SLEExactGauge.Serpentine
+
+lemma arraySpine_zero (m j : ℕ) :
+    arraySpine m j 0 = ((-100 * (m : ℝ) : ℝ) : ℂ) +
+      ((-100 * (m : ℝ) : ℝ) : ℂ) * Complex.I := by
+  induction j with
+  | zero => simp [arraySpine, straightPiece, side]
+  | succ j ih =>
+    have hb : (0 : ℝ) ≤ columnEntry 0 m (j + 1) := by unfold columnEntry; positivity
+    have ha : (0 : ℝ) ≤ columnEntry 0 m j + 200 * m := by unfold columnEntry; positivity
+    simpa only [arraySpine, curveJoin_of_le hb, curveJoin_of_le ha] using ih
+
+lemma arrayTangent_zero (m j : ℕ) : arrayTangent m j 0 = Complex.I := by
+  induction j with
+  | zero => simp [arrayTangent, straightTangent, side]
+  | succ j ih =>
+    have hb : (0 : ℝ) ≤ columnEntry 0 m (j + 1) := by unfold columnEntry; positivity
+    have ha : (0 : ℝ) ≤ columnEntry 0 m j + 200 * m := by unfold columnEntry; positivity
+    simpa only [arrayTangent, curveJoin_of_le hb, curveJoin_of_le ha] using ih
+
+lemma lowConnector_after {H r X t : ℝ}
+    (ht : connectorFourth H r X < t) :
+    lowConnector H r X t = connectorTail H r X t ∧
+      lowConnectorTangent H r X t = Complex.I := by
+  simp only [lowConnector, lowConnectorTangent, curveJoin_of_gt ht, and_self]
+
+def connectorEntry (H r X Y : ℝ) : ℝ := connectorFourth H r X + Y - H - 2 * r
+
+def arrayCenter (m : ℕ) (X Y : ℝ) : ℂ :=
+  ((X + 100 * m : ℝ) : ℂ) + ((Y + 100 * m : ℝ) : ℂ) * Complex.I
+
+def completeSpine (m : ℕ) (H r X Y : ℝ) : ℝ → ℂ :=
+  curveJoin (connectorEntry H r X Y) (lowConnector H r X)
+    (fun t => arrayCenter m X Y + arraySpine m (2 * m) (t - connectorEntry H r X Y))
+
+def completeTangent (m : ℕ) (H r X Y : ℝ) : ℝ → ℂ :=
+  curveJoin (connectorEntry H r X Y) (lowConnectorTangent H r X)
+    (fun t => arrayTangent m (2 * m) (t - connectorEntry H r X Y))
+
+lemma completeSpine_hasDerivAt {H r X Y : ℝ} (m : ℕ) (hr : 0 < r)
+    (hX : 2 * r < X) (hY : H + 2 * r < Y) (t : ℝ) :
+    HasDerivAt (completeSpine m H r X Y) (completeTangent m H r X Y t) t := by
+  have hentry : connectorFourth H r X < connectorEntry H r X Y := by
+    unfold connectorEntry
+    linarith
+  have hp : lowConnector H r X (connectorEntry H r X Y) =
+      arrayCenter m X Y + arraySpine m (2 * m)
+        (connectorEntry H r X Y - connectorEntry H r X Y) := by
+    rw [(lowConnector_after hentry).1, sub_self, arraySpine_zero]
+    simp only [connectorTail, connectorEntry, arrayCenter]
+    push_cast
+    ring
+  have hT : lowConnectorTangent H r X (connectorEntry H r X Y) =
+      arrayTangent m (2 * m) (connectorEntry H r X Y - connectorEntry H r X Y) := by
+    rw [(lowConnector_after hentry).2, sub_self, arrayTangent_zero]
+  exact curveJoin_hasDerivAt _ _ _ _ _ (lowConnector_hasDerivAt hr hX)
+    (translate_curve_hasDerivAt _ _ (arraySpine_hasDerivAt m (2 * m)) _ _) hp hT t
+
+lemma completeTangent_norm (m : ℕ) (H r X Y t : ℝ) : ‖completeTangent m H r X Y t‖ = 1 := by
+  unfold completeTangent curveJoin
+  split
+  · exact lowConnectorTangent_norm _ _ _ _
+  · exact arrayTangent_norm _ _ _
+
+lemma completeTangent_lipschitz {H r X Y : ℝ} (m : ℕ) (hr : 50 ≤ r)
+    (hX : 2 * r < X) (hY : H + 2 * r < Y) :
+    LipschitzWith (1 / 50) (completeTangent m H r X Y) := by
+  have hr0 : 0 < r := by linarith
+  have hentry : connectorFourth H r X < connectorEntry H r X Y := by
+    unfold connectorEntry
+    linarith
+  apply curveJoin_lipschitz (lowConnectorTangent_lipschitz hr hX)
+    (shifted_lipschitz (arrayTangent_lipschitz m (2 * m)) _)
+  rw [(lowConnector_after hentry).2, sub_self, arrayTangent_zero]
+
+lemma complete_normal_patch_bounds {H r X Y : ℝ} (m : ℕ) (hr : 50 ≤ r)
+    (hX : 2 * r < X) (hY : H + 2 * r < Y) (k : ℝ) :
+    LipschitzOnWith 2 (normalRibbon (completeSpine m H r X Y) (completeTangent m H r X Y))
+      (RibbonCoordinates.ribbonStepPatch k) ∧
+    ∀ z ∈ RibbonCoordinates.ribbonStepPatch k,
+      ∀ w ∈ RibbonCoordinates.ribbonStepPatch k,
+        dist z w ≤ 2 * dist (normalRibbon (completeSpine m H r X Y) (completeTangent m H r X Y) z)
+          (normalRibbon (completeSpine m H r X Y) (completeTangent m H r X Y) w) := by
+  have hr0 : 0 < r := by linarith
+  have hbound z (hz : z ∈ RibbonCoordinates.ribbonStepPatch k)
+      w (hw : w ∈ RibbonCoordinates.ribbonStepPatch k) :=
+    normalRibbon_patch_bounds (completeSpine m H r X Y) (completeTangent m H r X Y) (k - 1) (k + 3)
+      (by ring_nf; norm_num)
+      (fun t _ => (completeSpine_hasDerivAt m hr0 hX hY t).hasDerivWithinAt)
+      (fun t _ => completeTangent_norm m H r X Y t)
+      (completeTangent_lipschitz m hr hX hY).lipschitzOnWith
+      z w ⟨⟨hz.1, hz.2.1⟩, hz.2.2⟩ ⟨⟨hw.1, hw.2.1⟩, hw.2.2⟩
+  exact ⟨lipschitzOnWith_iff_dist_le_mul.mpr (fun z hz w hw => (hbound z hz w hw).1),
+    fun z hz w hw => (hbound z hz w hw).2⟩
+
+end SLEExactGauge.Serpentine
+
+end
+
+end OAI

lean/OAI/Probability/SLE/Gauge/SerpentineCompleteEmbedding.lean

@@ -0,0 +1,110 @@
+import OAI.Probability.SLE.Gauge.SerpentineCompleteCurve
+import OAI.Probability.SLE.Gauge.SerpentineAttachments
+import OAI.Probability.SLE.Geometry.RoundedConnectorRegion
+
+namespace OAI
+
+/-! The low connector and the complete infinite array have one common
+normal cross-section. Hence the entire prescribed ribbon is embedded. -/
+
+noncomputable section
+open Set Metric
+
+namespace SLEExactGauge.Serpentine
+
+lemma complete_normal_of_le (m : ℕ) (H r X Y : ℝ) {z : ℂ}
+    (hz : z.re ≤ connectorEntry H r X Y) :
+    normalRibbon (completeSpine m H r X Y) (completeTangent m H r X Y) z =
+      normalRibbon (lowConnector H r X) (lowConnectorTangent H r X) z := by
+  simp only [normalRibbon, completeSpine, completeTangent, curveJoin_of_le hz]
+
+lemma complete_normal_of_gt (m : ℕ) (H r X Y : ℝ) {z : ℂ}
+    (hz : connectorEntry H r X Y < z.re) :
+    normalRibbon (completeSpine m H r X Y) (completeTangent m H r X Y) z =
+      arrayCenter m X Y + normalRibbon (arraySpine m (2 * m)) (arrayTangent m (2 * m))
+        (z - (connectorEntry H r X Y : ℂ)) := by
+  simp only [normalRibbon, completeSpine, completeTangent, curveJoin_of_gt hz,
+    Complex.sub_re, Complex.sub_im, Complex.ofReal_re, Complex.ofReal_im, sub_zero]
+  abel
+
+lemma complete_normal_cross_disjoint {m : ℕ} (hm : 0 < m) {H r X Y : ℝ}
+    (hr : 50 ≤ r) (hX : 2 * r < X) (hY : H + 2 * r + 1 + 300 * m < Y)
+    {z w : ℂ} (hz : 0 ≤ z.re ∧ |z.im| ≤ 1) (hwa : |w.im| ≤ 1)
+    (hzA : z.re ≤ connectorEntry H r X Y) (hwA : connectorEntry H r X Y < w.re) :
+    normalRibbon (completeSpine m H r X Y) (completeTangent m H r X Y) z ≠
+      normalRibbon (completeSpine m H r X Y) (completeTangent m H r X Y) w := by
+  intro he
+  rw [complete_normal_of_le m H r X Y hzA, complete_normal_of_gt m H r X Y hwA] at he
+  let w' := w - (connectorEntry H r X Y : ℂ)
+  have hw' : 0 ≤ w'.re ∧ |w'.im| ≤ 1 := by
+    dsimp [w']
+    simp only [sub_zero]
+    exact ⟨by linarith, hwa⟩
+  have hr1 : 1 < r := by linarith
+  by_cases hz4 : z.re ≤ connectorFourth H r X
+  · have hlo := lowConnector_normal_im_upper hr1 hX hz4 hz.2
+    have hhi := array_normal_im_lower hm hw'
+    have him := congrArg Complex.im he
+    simp only [arrayCenter, Complex.add_im, Complex.ofReal_im, Complex.mul_im,
+      Complex.ofReal_re, Complex.I_re, Complex.I_im, mul_one, mul_zero, add_zero, zero_add] at him
+    change -(400 * (m : ℝ)) ≤ (normalRibbon (arraySpine m (2 * m)) (arrayTangent m (2 * m)) w').im at hhi
+    change (normalRibbon (lowConnector H r X) (lowConnectorTangent H r X) z).im =
+      Y + 100 * m + (normalRibbon (arraySpine m (2 * m)) (arrayTangent m (2 * m)) w').im at him
+    linarith
+  · have hz4' : connectorFourth H r X < z.re := lt_of_not_ge hz4
+    let y := H + 2 * r + (z.re - connectorFourth H r X) - Y - 100 * m
+    have hy : y ≤ -(100 * (m : ℝ)) := by
+      dsimp [y]
+      dsimp only [connectorEntry] at hzA
+      linarith
+    have hpoint : normalRibbon (arraySpine m (2 * m)) (arrayTangent m (2 * m)) w' =
+        columnPoint 0 (100 * m) m 0 y z.im := by
+      have hs := congrArg (fun q : ℂ => q - arrayCenter m X Y) he
+      simp only [add_sub_cancel_left] at hs
+      rw [normalRibbon, (lowConnector_after hz4').1, (lowConnector_after hz4').2] at hs
+      have heq : normalRibbon (arraySpine m (2 * m)) (arrayTangent m (2 * m)) w' =
+          connectorTail H r X z.re + (z.im : ℂ) * Complex.I * Complex.I - arrayCenter m X Y := by
+        exact hs.symm
+      rw [heq]
+      have hs0 : side 0 = 1 := by simp [side]
+      apply Complex.ext <;>
+        simp only [connectorTail, arrayCenter, columnPoint, columnOffset, Nat.cast_zero,
+          zero_mul, hs0, one_mul, normalized_width hm, Complex.add_re, Complex.add_im,
+          Complex.sub_re, Complex.sub_im, Complex.mul_re, Complex.mul_im, Complex.ofReal_re,
+          Complex.ofReal_im, Complex.zero_re, Complex.zero_im, Complex.I_re, Complex.I_im, y] <;> ring
+    have hzero := (array_downward_attachment hm hw' hy hz.2 hpoint).1
+    dsimp [w'] at hzero
+    linarith
+
+/-- Global embedding of the whole explicit normal ribbon, including its
+real-boundary connector and infinite final vertical continuation. -/
+theorem complete_normal_injective {m : ℕ} (hm : 0 < m) {H r X Y : ℝ}
+    (hr : 50 ≤ r) (hX : 2 * r < X) (hY : H + 2 * r + 1 + 300 * m < Y) :
+    InjOn (normalRibbon (completeSpine m H r X Y) (completeTangent m H r X Y))
+      {z : ℂ | 0 ≤ z.re ∧ |z.im| ≤ 1} := by
+  intro z hz w hw he
+  by_cases hzA : z.re ≤ connectorEntry H r X Y
+  · by_cases hwA : w.re ≤ connectorEntry H r X Y
+    · rw [complete_normal_of_le m H r X Y hzA, complete_normal_of_le m H r X Y hwA] at he
+      exact lowConnector_normal_injective hr hX hz hw he
+    · exact (complete_normal_cross_disjoint hm hr hX hY hz hw.2 hzA (lt_of_not_ge hwA) he).elim
+  · by_cases hwA : w.re ≤ connectorEntry H r X Y
+    · exact (complete_normal_cross_disjoint hm hr hX hY hw hz.2 hwA (lt_of_not_ge hzA) he.symm).elim
+    · rw [complete_normal_of_gt m H r X Y (lt_of_not_ge hzA),
+        complete_normal_of_gt m H r X Y (lt_of_not_ge hwA)] at he
+      have he' := add_left_cancel he
+      have hz' : 0 ≤ (z - (connectorEntry H r X Y : ℂ)).re ∧
+          |(z - (connectorEntry H r X Y : ℂ)).im| ≤ 1 := by
+        simp only [Complex.sub_re, Complex.sub_im, Complex.ofReal_re, Complex.ofReal_im, sub_zero]
+        exact ⟨by linarith, hz.2⟩
+      have hw' : 0 ≤ (w - (connectorEntry H r X Y : ℂ)).re ∧
+          |(w - (connectorEntry H r X Y : ℂ)).im| ≤ 1 := by
+        simp only [Complex.sub_re, Complex.sub_im, Complex.ofReal_re, Complex.ofReal_im, sub_zero]
+        exact ⟨by linarith, hw.2⟩
+      exact sub_left_injective (array_normal_injective_infinite hm hz' hw' he')
+
+end SLEExactGauge.Serpentine
+
+end
+
+end OAI

lean/OAI/Probability/SLE/Gauge/SerpentineConformalGeometry.lean

@@ -0,0 +1,170 @@
+import OAI.Probability.SLE.Gauge.RestrictedConformalSausage
+import OAI.Probability.SLE.Geometry.NormalizedConformalBounds
+import OAI.Probability.SLE.Gauge.SerpentineLayout
+
+namespace OAI
+
+/-! A common small displaced experiment disk in normalized half-plane
+coordinates. Its nearby trace witnesses stay in a controlled conformal
+patch, and its image stays in one physical conformal-radius disk. -/
+
+noncomputable section
+open Set Filter MeasureTheory Metric
+open scoped Topology ENNReal NNReal
+
+namespace SLEExactGauge.Serpentine
+
+def conformalExperimentScale (s C : ℝ) : ℝ := min (s / 10) (s / (100 * C))
+
+lemma conformalExperimentScale_bounds {s C : ℝ} (hs : 0 < s) (hC : 0 < C) :
+    0 < conformalExperimentScale s C ∧ conformalExperimentScale s C ≤ s / 10 ∧
+      C * conformalExperimentScale s C ≤ s / 100 := by
+  refine ⟨lt_min (by positivity) (by positivity), min_le_left _ _, ?_⟩
+  have hh := (le_div_iff₀ (by positivity : 0 < 100 * C)).mp
+    (min_le_right (s / 10) (s / (100 * C)))
+  dsimp only [conformalExperimentScale]
+  nlinarith
+
+lemma experiment_patch_subset_compact {s h : ℝ} (hs : 0 < s) (hs1 : s ≤ 1)
+    (hh : h ≤ s / 10) (w : ℂ) (hwn : ‖w‖ = 1) (hwy : s ≤ w.im) :
+    closedBall w h ⊆ normalizedInteriorCompact s := by
+  intro z hz
+  have hn := norm_le_norm_add_const_of_dist_le hz
+  have hi := Complex.im_le_norm (w - z)
+  have hd : ‖w - z‖ ≤ h := by
+    simpa only [mem_closedBall, ← dist_eq_norm, dist_comm] using hz
+  rw [Complex.sub_im] at hi
+  change ‖z‖ ≤ 2 ∧ s / 2 ≤ z.im
+  rw [hwn] at hn
+  constructor <;> linarith
+
+lemma displaced_experiment_dist {h : ℝ} (hh : 0 ≤ h) (w z : ℂ)
+    (hz : z ∈ closedBall (center h w) (h / 20)) :
+    dist z w ≤ 3 * h / 10 := by
+  have hd := (dist_triangle z (center h w) w).trans
+    (add_le_add hz (center_dist hh w).le)
+  linarith
+
+lemma displaced_experiment_subset_patch {h : ℝ} (hh : 0 ≤ h) (w : ℂ) :
+    closedBall (center h w) (h / 20) ⊆ closedBall w h := by
+  intro z hz
+  exact (displaced_experiment_dist hh w z hz).trans (by linarith)
+
+lemma displaced_experiment_near_patch {h u : ℝ} (hh : 0 < h) (hu : u < h / 20)
+    (w z y : ℂ) (hz : z ∈ closedBall (center h w) (h / 20)) (hzy : dist z y < u) :
+    y ∈ closedBall w h := by
+  have hd := dist_triangle y z w
+  rw [dist_comm y z] at hd
+  have hz' := displaced_experiment_dist hh.le w z hz
+  change dist y w ≤ h
+  linarith
+
+/-- Converting any positive deterministic parameter cutoff into a
+cutoff proportional to the physical conformal radius. -/
+lemma conformal_experiment_mesh_cutoff {C a q v : ℝ}
+    (hC : 0 < C) (ha : 0 < a) (hq : 0 < q) (w : ℂ) (hwi : w.im ≤ 1)
+    (hv : v < (C * q / 2) * (2 * w.im * a)) :
+    v / (C * a) < q := by
+  apply (div_lt_iff₀ (mul_pos hC ha)).mpr
+  have hm := mul_le_mul_of_nonneg_left hwi (show 0 ≤ C * q * a by positivity)
+  nlinarith
+
+theorem conformal_experiment_image_subset
+    {s h c C : ℝ} (hs : 0 < s) (hs1 : s ≤ 1) (hh : 0 < h)
+    (hhs : h ≤ s / 10) (hCh : C * h ≤ s / 100) (hC : 0 < C)
+    (F : ℂ → ℂ) (w : ℂ) (hwn : ‖w‖ = 1) (hwy : s ≤ w.im)
+    (hF : DifferentiableOn ℂ F upperHalfPlane)
+    (hbound : ∀ z ∈ normalizedInteriorCompact s,
+      c * ‖deriv F w‖ ≤ ‖deriv F z‖ ∧ ‖deriv F z‖ ≤ C * ‖deriv F w‖) :
+    F '' closedBall (center h w) (h / 20) ⊆
+      closedBall (F w) (2 * w.im * ‖deriv F w‖) := by
+  let B : ℝ≥0 := ⟨C * ‖deriv F w‖, mul_nonneg hC.le (norm_nonneg _)⟩
+  have hK := experiment_patch_subset_compact hs hs1 hhs w hwn hwy
+  have hKH := hK.trans (normalizedInteriorCompact_subset_halfPlane hs)
+  have hLip : LipschitzOnWith B F (closedBall w h) :=
+    (convex_closedBall w h).lipschitzOnWith_of_nnnorm_hasDerivWithin_le
+      (fun z hz => ((hF.differentiableAt (isOpen_upperHalfPlane.mem_nhds (hKH hz))).hasDerivAt).hasDerivWithinAt)
+      (fun z hz => by exact_mod_cast (hbound z (hK hz)).2)
+  rintro _ ⟨z, hz, rfl⟩
+  have hzK := displaced_experiment_subset_patch hh.le w hz
+  have hd := hLip.dist_le_mul z hzK w (mem_closedBall_self hh.le)
+  have hzdist := displaced_experiment_dist hh.le w z hz
+  have hnonneg := norm_nonneg (deriv F w)
+  have hmul := mul_le_mul_of_nonneg_right hCh hnonneg
+  have hdist := mul_le_mul_of_nonneg_left hzdist (show 0 ≤ C * ‖deriv F w‖ by positivity)
+  change dist (F z) (F w) ≤ 2 * w.im * ‖deriv F w‖
+  change dist (F z) (F w) ≤ (C * ‖deriv F w‖) * dist z w at hd
+  nlinarith
+
+theorem conformal_experiment_restricted_transfer
+    (κ : ℝ) {s h c C : ℝ} (hs : 0 < s) (hs1 : s ≤ 1)
+    (hh : 0 < h) (hhs : h ≤ s / 10) (hCh : C * h ≤ s / 100)
+    (hc : 0 < c) (hC : 0 < C)
+    (F : ℂ → ℂ) (w : ℂ) (hwn : ‖w‖ = 1) (hwy : s ≤ w.im)
+    (hF : DifferentiableOn ℂ F upperHalfPlane) (hi : InjOn F upperHalfPlane)
+    (hne : deriv F w ≠ 0)
+    (hbound : ∀ z ∈ normalizedInteriorCompact s,
+      c * ‖deriv F w‖ ≤ ‖deriv F z‖ ∧ ‖deriv F z‖ ≤ C * ‖deriv F w‖)
+    (γ η : ℝ≥0 → ℂ) (a b : ℝ≥0)
+    (heq : ∀ u ∈ Icc a b, γ u ∈ closedBall w h → η u = F (γ u))
+    {v : ℝ} (hv : 0 < v)
+    (hvc : v < (C * h / 40) * (2 * w.im * ‖deriv F w‖)) :
+    ENNReal.ofReal ((c ^ 2 * (1 / C) ^ codimension κ) * ‖deriv F w‖ ^ dimension κ) *
+        segmentSausageCharge κ γ a b (v / (C * ‖deriv F w‖))
+          (closedBall (center h w) (h / 20)) ≤
+      segmentSausageCharge κ η a b v (closedBall (F w) (2 * w.im * ‖deriv F w‖)) := by
+  have hnorm : 0 < ‖deriv F w‖ := norm_pos_iff.mpr hne
+  have hCa : 0 < C * ‖deriv F w‖ := mul_pos hC hnorm
+  have hwi : w.im ≤ 1 := by simpa only [hwn] using Complex.im_le_norm w
+  have hmesh : v / (C * ‖deriv F w‖) < h / 20 := by
+    apply conformal_experiment_mesh_cutoff hC hnorm (by positivity) w hwi
+    convert hvc using 1
+    ring
+  have hK := experiment_patch_subset_compact hs hs1 hhs w hwn hwy
+  have hKH := hK.trans (normalizedInteriorCompact_subset_halfPlane hs)
+  let B : ℝ≥0 := ⟨C * ‖deriv F w‖, hCa.le⟩
+  have hstep : (1 / (C * ‖deriv F w‖)) * v = v / (C * ‖deriv F w‖) := by ring
+  have ht := restricted_segment_sausage_conformal_transfer κ F (deriv F) γ η a b
+    (closedBall (center h w) (h / 20)) (closedBall w h)
+    (closedBall (F w) (2 * w.im * ‖deriv F w‖)) isClosed_closedBall.measurableSet
+    (displaced_experiment_subset_patch hh.le w) (convex_closedBall w h)
+    (hi.mono hKH)
+    (fun z hz => (hF.differentiableAt (isOpen_upperHalfPlane.mem_nhds (hKH hz))).hasDerivAt)
+    (mul_pos hc hnorm).le hv (one_div_pos.mpr hCa)
+    (fun z hz => (hbound z (hK (displaced_experiment_subset_patch hh.le w hz))).1)
+    B (fun z hz => by exact_mod_cast (hbound z (hK hz)).2)
+    (by change (C * ‖deriv F w‖) * (1 / (C * ‖deriv F w‖)) ≤ 1; rw [mul_one_div_cancel hCa.ne'])
+    (fun z hz y hd => displaced_experiment_near_patch hh hmesh w z y hz (by simpa only [hstep] using hd))
+    heq (conformal_experiment_image_subset hs hs1 hh hhs hCh hC F w hwn hwy hF hbound)
+  rw [conformal_transfer_coefficient κ hC hnorm, hstep] at ht
+  exact ht
+
+theorem uniform_conformal_experiment_restricted_transfer
+    (κ : ℝ) (hcompact : PublishedHalfPlaneUnivalentCompactness)
+    {s : ℝ} (hs : 0 < s) (hs1 : s ≤ 1) :
+    ∃ h A C δ : ℝ, 0 < h ∧ h ≤ s ∧ 0 < A ∧ 0 < C ∧ 0 < δ ∧
+      ∀ (F : ℂ → ℂ) (w : ℂ), DifferentiableOn ℂ F upperHalfPlane →
+        InjOn F upperHalfPlane → ‖w‖ = 1 → s ≤ w.im → deriv F w ≠ 0 →
+        ∀ (γ η : ℝ≥0 → ℂ) (a b : ℝ≥0),
+        (∀ u ∈ Icc a b, γ u ∈ closedBall w h → η u = F (γ u)) →
+        ∀ v : ℝ, 0 < v → v < δ * (2 * w.im * ‖deriv F w‖) →
+          ENNReal.ofReal (A * ‖deriv F w‖ ^ dimension κ) *
+              segmentSausageCharge κ γ a b (v / (C * ‖deriv F w‖))
+                (closedBall (center h w) (h / 20)) ≤
+            segmentSausageCharge κ η a b v
+              (closedBall (F w) (2 * w.im * ‖deriv F w‖)) := by
+  obtain ⟨c, C, hc, hC, hbounds⟩ := uniform_waypoint_derivative_ratios hcompact hs hs1
+  let h := conformalExperimentScale s C
+  obtain ⟨hh, hhs, hCh⟩ := conformalExperimentScale_bounds hs hC
+  refine ⟨h, c ^ 2 * (1 / C) ^ codimension κ, C, C * h / 40, hh,
+    hhs.trans (by linarith), by positivity, hC, by positivity, ?_⟩
+  intro F w hF hi hwn hwy hne γ η a b heq v hv hvc
+  exact conformal_experiment_restricted_transfer κ hs hs1 hh hhs hCh hc hC
+    F w hwn hwy hF hi hne (fun z hz => hbounds F w hF hi hwn hwy hne z hz.1 hz.2)
+    γ η a b heq hv hvc
+
+end SLEExactGauge.Serpentine
+
+end
+
+end OAI

lean/OAI/Probability/SLE/Gauge/SerpentineCurve.lean

@@ -0,0 +1,163 @@
+import OAI.Probability.SLE.Gauge.SerpentinePieces
+import OAI.Probability.SLE.Gauge.SerpentineStepCount
+
+namespace OAI
+
+/-! Explicit arclength parametrization of the finite serpentine array,
+continued vertically along its last column. -/
+
+noncomputable section
+open Set Metric
+open scoped NNReal
+
+namespace SLEExactGauge.Serpentine
+
+lemma columnEntry_succ (A : ℝ) (m j : ℕ) :
+    columnEntry A m (j + 1) = columnEntry A m j + 200 * m + 50 * Real.pi := by
+  simp only [columnEntry, Nat.cast_add, Nat.cast_one]
+  ring
+
+def arraySpine (m : ℕ) : ℕ → ℝ → ℂ
+  | 0 => straightPiece m 0
+  | j + 1 => curveJoin (columnEntry 0 m (j + 1))
+      (curveJoin (columnEntry 0 m j + 200 * m) (arraySpine m j)
+        (fun t => circularPiece m j (t - (columnEntry 0 m j + 200 * m))))
+      (fun t => straightPiece m (j + 1) (t - columnEntry 0 m (j + 1)))
+
+def arrayTangent (m : ℕ) : ℕ → ℝ → ℂ
+  | 0 => fun _ => straightTangent 0
+  | j + 1 => curveJoin (columnEntry 0 m (j + 1))
+      (curveJoin (columnEntry 0 m j + 200 * m) (arrayTangent m j)
+        (fun t => circularTangent j (t - (columnEntry 0 m j + 200 * m))))
+      (fun _ => straightTangent (j + 1))
+
+lemma arraySpine_tail (m j : ℕ) {t : ℝ} (ht : columnEntry 0 m j ≤ t) :
+    arraySpine m j t = straightPiece m j (t - columnEntry 0 m j) := by
+  cases j with
+  | zero => simp [arraySpine, columnEntry]
+  | succ j =>
+    by_cases hlt : columnEntry 0 m (j + 1) < t
+    · simp only [arraySpine, curveJoin_of_gt hlt]
+    · have he : t = columnEntry 0 m (j + 1) := le_antisymm (le_of_not_gt hlt) ht
+      subst t
+      have hcut : columnEntry 0 m j + 200 * m < columnEntry 0 m (j + 1) := by
+        rw [columnEntry_succ]
+        linarith [Real.pi_pos]
+      simp only [arraySpine, curveJoin_of_le le_rfl, curveJoin_of_gt hcut, sub_self]
+      rw [columnEntry_succ]
+      have he : columnEntry 0 m j + 200 * m + 50 * Real.pi -
+          (columnEntry 0 m j + 200 * m) = 50 * Real.pi := by ring
+      rw [he, circular_straight_position_match]
+
+lemma arrayTangent_tail (m j : ℕ) {t : ℝ} (ht : columnEntry 0 m j ≤ t) :
+    arrayTangent m j t = straightTangent j := by
+  cases j with
+  | zero => rfl
+  | succ j =>
+    by_cases hlt : columnEntry 0 m (j + 1) < t
+    · simp only [arrayTangent, curveJoin_of_gt hlt]
+    · have he : t = columnEntry 0 m (j + 1) := le_antisymm (le_of_not_gt hlt) ht
+      subst t
+      have hcut : columnEntry 0 m j + 200 * m < columnEntry 0 m (j + 1) := by
+        rw [columnEntry_succ]
+        linarith [Real.pi_pos]
+      simp only [arrayTangent, curveJoin_of_le le_rfl, curveJoin_of_gt hcut]
+      rw [columnEntry_succ]
+      have he : columnEntry 0 m j + 200 * m + 50 * Real.pi -
+          (columnEntry 0 m j + 200 * m) = 50 * Real.pi := by ring
+      rw [he, circular_straight_tangent_match]
+
+lemma arrayTangent_norm (m j : ℕ) (t : ℝ) : ‖arrayTangent m j t‖ = 1 := by
+  induction j with
+  | zero => exact straightTangent_norm 0
+  | succ j ih =>
+    unfold arrayTangent curveJoin
+    split
+    · split
+      · exact ih
+      · exact circularTangent_norm _ _
+    · exact straightTangent_norm _
+
+lemma arraySpine_hasDerivAt (m j : ℕ) (t : ℝ) :
+    HasDerivAt (arraySpine m j) (arrayTangent m j t) t := by
+  induction j generalizing t with
+  | zero => exact straightPiece_hasDerivAt m 0 t
+  | succ j ih =>
+    let a := columnEntry 0 m j + 200 * m
+    let b := columnEntry 0 m (j + 1)
+    have hc (t : ℝ) : HasDerivAt (fun t => circularPiece m j (t - a))
+        (circularTangent j (t - a)) t := by
+      convert (circularPiece_hasDerivAt m j (t - a)).scomp t
+        ((hasDerivAt_id t).sub_const a) using 1 <;> first | rfl | simp only [one_smul]
+    have hs (t : ℝ) : HasDerivAt (fun t => straightPiece m (j + 1) (t - b))
+        (straightTangent (j + 1)) t := by
+      convert (straightPiece_hasDerivAt m (j + 1) (t - b)).scomp t
+        ((hasDerivAt_id t).sub_const b) using 1 <;> first | rfl | simp only [one_smul]
+    have ha0 : columnEntry 0 m j ≤ a := by dsimp [a]; linarith [Nat.cast_nonneg (α := ℝ) m]
+    have hab : a < b := by dsimp [a, b]; rw [columnEntry_succ]; linarith [Real.pi_pos]
+    have habv : b - a = 50 * Real.pi := by dsimp [a, b]; rw [columnEntry_succ]; ring
+    have he₁ : arraySpine m j a = circularPiece m j (a - a) := by
+      rw [arraySpine_tail m j ha0]
+      have he : a - columnEntry 0 m j = 200 * m := by dsimp [a]; ring
+      rw [he, sub_self, straight_circular_position_match]
+    have hd₁ : arrayTangent m j a = circularTangent j (a - a) := by
+      rw [arrayTangent_tail m j ha0, sub_self, straight_circular_tangent_match]
+    have hfirst := curveJoin_hasDerivAt a (arraySpine m j)
+      (fun t => circularPiece m j (t - a)) (arrayTangent m j)
+      (fun t => circularTangent j (t - a)) ih hc he₁ hd₁
+    have he₂ : curveJoin a (arraySpine m j) (fun t => circularPiece m j (t - a)) b =
+        straightPiece m (j + 1) (b - b) := by
+      rw [curveJoin_of_gt hab, habv, sub_self, circular_straight_position_match]
+    have hd₂ : curveJoin a (arrayTangent m j) (fun t => circularTangent j (t - a)) b =
+        straightTangent (j + 1) := by
+      rw [curveJoin_of_gt hab, habv, circular_straight_tangent_match]
+    exact curveJoin_hasDerivAt b _ _ _ _ hfirst hs he₂ hd₂ t
+
+lemma arrayTangent_lipschitz (m j : ℕ) : LipschitzWith (1 / 50) (arrayTangent m j) := by
+  induction j with
+  | zero => exact (LipschitzWith.const _).weaken (by norm_num)
+  | succ j ih =>
+    let a := columnEntry 0 m j + 200 * m
+    let b := columnEntry 0 m (j + 1)
+    have hc : LipschitzWith (1 / 50) (fun t => circularTangent j (t - a)) := by
+      apply lipschitzWith_iff_dist_le_mul.mpr
+      intro u v
+      simpa only [dist_sub_right] using (circularTangent_lipschitz j).dist_le_mul (u - a) (v - a)
+    have hs : LipschitzWith (1 / 50) (fun _ : ℝ => straightTangent (j + 1)) :=
+      (LipschitzWith.const _).weaken (by norm_num)
+    have ha0 : columnEntry 0 m j ≤ a := by dsimp [a]; linarith [Nat.cast_nonneg (α := ℝ) m]
+    have hab : a < b := by dsimp [a, b]; rw [columnEntry_succ]; linarith [Real.pi_pos]
+    have habv : b - a = 50 * Real.pi := by dsimp [a, b]; rw [columnEntry_succ]; ring
+    have hd₁ : arrayTangent m j a = circularTangent j (a - a) := by
+      rw [arrayTangent_tail m j ha0, sub_self, straight_circular_tangent_match]
+    have hfirst := curveJoin_lipschitz ih hc hd₁
+    have hd₂ : curveJoin a (arrayTangent m j) (fun t => circularTangent j (t - a)) b =
+        straightTangent (j + 1) := by
+      rw [curveJoin_of_gt hab, habv, circular_straight_tangent_match]
+    exact curveJoin_lipschitz hfirst hs hd₂
+
+/-- Every length-four normal coordinate patch of the explicit array has
+uniform upper and inverse Lipschitz constants equal to two. -/
+theorem array_normal_patch_bounds (m j : ℕ) (k : ℝ) :
+    LipschitzOnWith 2 (normalRibbon (arraySpine m j) (arrayTangent m j))
+      (RibbonCoordinates.ribbonStepPatch k) ∧
+    ∀ z ∈ RibbonCoordinates.ribbonStepPatch k,
+      ∀ w ∈ RibbonCoordinates.ribbonStepPatch k,
+        dist z w ≤ 2 * dist (normalRibbon (arraySpine m j) (arrayTangent m j) z)
+          (normalRibbon (arraySpine m j) (arrayTangent m j) w) := by
+  have hbound z (hz : z ∈ RibbonCoordinates.ribbonStepPatch k)
+      w (hw : w ∈ RibbonCoordinates.ribbonStepPatch k) :=
+    normalRibbon_patch_bounds (arraySpine m j) (arrayTangent m j) (k - 1) (k + 3)
+      (by ring_nf; norm_num)
+      (fun t _ => (arraySpine_hasDerivAt m j t).hasDerivWithinAt)
+      (fun t _ => arrayTangent_norm m j t) (arrayTangent_lipschitz m j).lipschitzOnWith
+      z w ⟨⟨hz.1, hz.2.1⟩, hz.2.2⟩ ⟨⟨hw.1, hw.2.1⟩, hw.2.2⟩
+  exact ⟨lipschitzOnWith_iff_dist_le_mul.mpr (fun z hz w hw => (hbound z hz w hw).1),
+    fun z hz w hw => (hbound z hz w hw).2⟩
+
+
+end SLEExactGauge.Serpentine
+
+end
+
+end OAI

lean/OAI/Probability/SLE/Gauge/SerpentineEmbedding.lean

@@ -0,0 +1,160 @@
+import OAI.Probability.SLE.Gauge.SerpentineLayout
+
+namespace OAI
+
+/-! The only contacts between the straight and circular normal bands are
+their prescribed common end sections. These geometric statements support
+the global embedding of the concatenated serpentine. -/
+
+noncomputable section
+open Set
+
+namespace SLEExactGauge.Serpentine
+
+@[simp] lemma turnPoint_im (c : ℂ) (h : ℝ) (m j : ℕ) (t a : ℝ) :
+    (turnPoint c h m j t a).im = c.im + side j * h +
+      (turnRadius h m + side j * ribbonWidth h m * a) * (side j * Real.sin t) := by
+  simp only [turnPoint, Complex.add_re, Complex.add_im, Complex.ofReal_re,
+    Complex.ofReal_im, Complex.mul_re, Complex.mul_im, Complex.I_re, Complex.I_im,
+    mul_zero, zero_mul, sub_zero, mul_one, add_zero, zero_add]
+
+lemma turnPoint_oriented_im (c : ℂ) (h : ℝ) (m j : ℕ) (t a : ℝ) :
+    side j * ((turnPoint c h m j t a).im - c.im) =
+      h + (turnRadius h m + side j * ribbonWidth h m * a) * Real.sin t := by
+  rw [turnPoint_im]
+  let R := turnRadius h m + side j * ribbonWidth h m * a
+  change side j * (c.im + side j * h + R * (side j * Real.sin t) - c.im) = h + R * Real.sin t
+  calc
+    _ = side j ^ 2 * (h + R * Real.sin t) := by ring
+    _ = _ := by rw [side_sq, one_mul]
+
+lemma columnPoint_equal_forces_index {h : ℝ} (hh : 0 < h) {m i j : ℕ} (hm : 0 < m)
+    (c : ℂ) (y y' : ℝ) {a b : ℝ} (ha : |a| ≤ 1) (hb : |b| ≤ 1)
+    (he : columnPoint c h m i y a = columnPoint c h m j y' b) : i = j := by
+  by_contra hn
+  rcases lt_or_gt_of_ne hn with hij | hji
+  · exact columnPoint_ne hh hm hij c y y' ha hb he
+  · exact columnPoint_ne hh hm hji c y' y hb ha he.symm
+
+lemma columnPoint_injective {h : ℝ} (hh : 0 < h) {m : ℕ} (hm : 0 < m)
+    (c : ℂ) (j : ℕ) {y y' a b : ℝ}
+    (he : columnPoint c h m j y a = columnPoint c h m j y' b) : y = y' ∧ a = b := by
+  have hy := congrArg Complex.im he
+  simp only [columnPoint_im] at hy
+  have ha := congrArg Complex.re he
+  simp only [columnPoint_re] at ha
+  have hs : side j ≠ 0 := by
+    intro hz
+    have hh := side_abs j
+    rw [hz, abs_zero] at hh
+    norm_num at hh
+  refine ⟨by linarith, ?_⟩
+  apply mul_left_cancel₀ (mul_ne_zero hs (ribbonWidth_pos hh hm).ne')
+  nlinarith
+
+/-- A circular normal band can meet a straight band only at angle zero
+or pi; its interior lies strictly above or below all straight passes. -/
+theorem turnPoint_column_contact {h : ℝ} (hh : 0 < h) {m j k : ℕ} (hm : 0 < m)
+    (c : ℂ) {t y a b : ℝ} (ht : t ∈ Icc 0 Real.pi) (hy : |y| ≤ h)
+    (ha : |a| ≤ 1) (he : turnPoint c h m j t a = columnPoint c h m k y b) :
+    t = 0 ∨ t = Real.pi := by
+  by_contra hn
+  push Not at hn
+  have hsin : 0 < Real.sin t := Real.sin_pos_of_pos_of_lt_pi
+    (lt_of_le_of_ne ht.1 (Ne.symm hn.1)) (lt_of_le_of_ne ht.2 hn.2)
+  have hor := turnPoint_oriented_im c h m j t a
+  have hcoeff := turn_radial_coefficient_pos hh hm j ha
+  have hy' : |(turnPoint c h m j t a).im - c.im| ≤ h := by
+    rw [he, columnPoint_im, add_sub_cancel_left]
+    exact hy
+  have hu : side j * ((turnPoint c h m j t a).im - c.im) ≤ h := by
+    calc
+      _ ≤ |side j * ((turnPoint c h m j t a).im - c.im)| := le_abs_self _
+      _ = |(turnPoint c h m j t a).im - c.im| := by rw [abs_mul, side_abs, one_mul]
+      _ ≤ h := hy'
+  nlinarith [mul_pos hcoeff hsin]
+
+/-- Exact gluing sections, including the matching normal coordinate. -/
+theorem turnPoint_column_gluing {h : ℝ} (hh : 0 < h) {m j k : ℕ} (hm : 0 < m)
+    (c : ℂ) {t y a b : ℝ} (ht : t ∈ Icc 0 Real.pi) (hy : |y| ≤ h)
+    (ha : |a| ≤ 1) (hb : |b| ≤ 1)
+    (he : turnPoint c h m j t a = columnPoint c h m k y b) :
+    (t = 0 ∧ k = j ∧ y = side j * h ∧ a = b) ∨
+      (t = Real.pi ∧ k = j + 1 ∧ y = side j * h ∧ a = b) := by
+  rcases turnPoint_column_contact hh hm c ht hy ha he with rfl | rfl
+  · rw [turnPoint_zero] at he
+    have hk := columnPoint_equal_forces_index hh hm c (side j * h) y ha hb he
+    subst k
+    obtain ⟨hy', ha'⟩ := columnPoint_injective hh hm c j he
+    exact Or.inl ⟨rfl, rfl, hy'.symm, ha'⟩
+  · rw [turnPoint_pi] at he
+    have hk := columnPoint_equal_forces_index hh hm c (side j * h) y ha hb he
+    subst k
+    obtain ⟨hy', ha'⟩ := columnPoint_injective hh hm c (j + 1) he
+    exact Or.inr ⟨rfl, rfl, hy'.symm, ha'⟩
+
+@[simp] lemma turnPoint_re (c : ℂ) (h : ℝ) (m j : ℕ) (t a : ℝ) :
+    (turnPoint c h m j t a).re = c.re + columnOffset h m j + turnRadius h m -
+      (turnRadius h m + side j * ribbonWidth h m * a) * Real.cos t := by
+  simp only [turnPoint, Complex.add_re, Complex.add_im, Complex.ofReal_re,
+    Complex.ofReal_im, Complex.mul_re, Complex.mul_im, Complex.I_re, Complex.I_im,
+    mul_zero, zero_mul, sub_zero, mul_one, add_zero, zero_add]
+  ring
+
+lemma turn_horizontal_bound {h : ℝ} (hh : 0 < h) {m : ℕ} (hm : 0 < m)
+    (c : ℂ) (j : ℕ) (t : ℝ) {a : ℝ} (ha : |a| ≤ 1) :
+    |(turnPoint c h m j t a).re - (c.re + columnOffset h m j + turnRadius h m)| ≤
+      turnRadius h m + ribbonWidth h m := by
+  have hr := (turnRadius_pos hh hm).le
+  have hw := (ribbonWidth_pos hh hm).le
+  have hb : |side j * ribbonWidth h m * a| ≤ ribbonWidth h m := by
+    rw [abs_mul, abs_mul, side_abs, one_mul, abs_of_nonneg hw]
+    exact mul_le_of_le_one_right hw ha
+  have ha' := abs_add_le (turnRadius h m) (side j * ribbonWidth h m * a)
+  rw [abs_of_nonneg hr] at ha'
+  rw [turnPoint_re]
+  have he : c.re + columnOffset h m j + turnRadius h m -
+      (turnRadius h m + side j * ribbonWidth h m * a) * Real.cos t -
+      (c.re + columnOffset h m j + turnRadius h m) =
+      -((turnRadius h m + side j * ribbonWidth h m * a) * Real.cos t) := by ring
+  rw [he, abs_neg, abs_mul]
+  exact (mul_le_of_le_one_right (abs_nonneg _) (Real.abs_cos_le_one t)).trans (ha'.trans (by linarith))
+
+lemma turn_oriented_height {h : ℝ} (hh : 0 < h) {m : ℕ} (hm : 0 < m)
+    (c : ℂ) (j : ℕ) {t a : ℝ} (ht : t ∈ Icc 0 Real.pi) (ha : |a| ≤ 1) :
+    h ≤ side j * ((turnPoint c h m j t a).im - c.im) := by
+  rw [turnPoint_oriented_im]
+  exact le_add_of_nonneg_right (mul_nonneg (turn_radial_coefficient_pos hh hm j ha).le
+    (Real.sin_nonneg_of_mem_Icc ht))
+
+/-- Different circular turns have disjoint full normal bands. Neighboring
+turns lie on opposite sides; all other turn pairs have horizontal clearance. -/
+theorem turnPoint_ne {h : ℝ} (hh : 0 < h) {m i j : ℕ} (hm : 0 < m)
+    (hij : i < j) (c : ℂ) {t u a b : ℝ} (ht : t ∈ Icc 0 Real.pi)
+    (hu : u ∈ Icc 0 Real.pi) (ha : |a| ≤ 1) (hb : |b| ≤ 1) :
+    turnPoint c h m i t a ≠ turnPoint c h m j u b := by
+  intro he
+  by_cases hnext : j = i + 1
+  · subst j
+    have h₁ := turn_oriented_height hh hm c i ht ha
+    have h₂ := turn_oriented_height hh hm c (i + 1) hu hb
+    rw [← he, side_succ] at h₂
+    nlinarith
+  · have hfar : i + 2 ≤ j := by omega
+    have hfar' : (i : ℝ) + 2 ≤ j := by exact_mod_cast hfar
+    have hstep := mul_le_mul_of_nonneg_right hfar' (spacing_pos hh hm).le
+    have h₁ := abs_le.mp (turn_horizontal_bound hh hm c i t ha)
+    have h₂ := abs_le.mp (turn_horizontal_bound hh hm c j u hb)
+    rw [← he] at h₂
+    simp only [columnOffset] at h₁ h₂
+    rw [spacing_eq_width] at hstep h₁ h₂
+    rw [turnRadius_eq_width] at h₁ h₂
+    have hw := ribbonWidth_pos hh hm
+    nlinarith
+
+
+end SLEExactGauge.Serpentine
+
+end
+
+end OAI

lean/OAI/Probability/SLE/Gauge/SerpentineEscape.lean

@@ -0,0 +1,90 @@
+import OAI.Probability.SLE.Gauge.SerpentineCompleteCurve
+
+namespace OAI
+
+/-! The final linear tail and bounded normal displacement of the
+complete serpentine. These supply properness of the ribbon chart. -/
+
+noncomputable section
+open Set Filter Metric
+open scoped Topology NNReal
+
+namespace SLEExactGauge.Serpentine
+
+lemma complete_linear_tail (m : ℕ) (H r X Y : ℝ) {t : ℝ}
+    (ht : connectorEntry H r X Y + columnEntry 0 m (2 * m) + 1 ≤ t) :
+    completeSpine m H r X Y t = ((X + 200 * m : ℝ) : ℂ) +
+      ((Y + t - connectorEntry H r X Y - columnEntry 0 m (2 * m) : ℝ) : ℂ) * Complex.I ∧
+    completeTangent m H r X Y t = Complex.I := by
+  have hc : 0 ≤ columnEntry 0 m (2 * m) := by unfold columnEntry; positivity
+  have htA : connectorEntry H r X Y < t := by linarith
+  have htC : columnEntry 0 m (2 * m) ≤ t - connectorEntry H r X Y := by linarith
+  simp only [completeSpine, completeTangent, curveJoin_of_gt htA]
+  rw [arraySpine_tail m (2 * m) htC, arrayTangent_tail m (2 * m) htC]
+  constructor
+  · apply Complex.ext <;>
+      simp only [arrayCenter, straightPiece, side_even, one_mul, Nat.cast_mul, Nat.cast_ofNat,
+        Complex.add_re, Complex.add_im, Complex.mul_re, Complex.mul_im, Complex.ofReal_re,
+        Complex.ofReal_im, Complex.I_re, Complex.I_im] <;> ring
+  · simp only [straightTangent, side_even, Complex.ofReal_one, one_mul]
+
+lemma complete_eventually_ray (m : ℕ) (H r X Y : ℝ) :
+    ∃ T : ℝ, 0 ≤ T ∧ ∀ t : ℝ, T ≤ t →
+      completeSpine m H r X Y t = completeSpine m H r X Y T + ((t - T : ℝ) : ℂ) * Complex.I := by
+  let T := max 0 (connectorEntry H r X Y + columnEntry 0 m (2 * m) + 1)
+  have hT : connectorEntry H r X Y + columnEntry 0 m (2 * m) + 1 ≤ T := le_max_right _ _
+  refine ⟨T, le_max_left _ _, fun t ht => ?_⟩
+  rw [(complete_linear_tail m H r X Y (hT.trans ht)).1,
+    (complete_linear_tail m H r X Y hT).1]
+  push_cast
+  ring
+
+lemma completeSpine_escape (m : ℕ) (H r X Y : ℝ) :
+    Tendsto (completeSpine m H r X Y) atTop (cocompact ℂ) := by
+  have him : Tendsto (fun t => (completeSpine m H r X Y t).im) atTop atTop := by
+    have hh : Tendsto (fun t : ℝ => Y + t - connectorEntry H r X Y - columnEntry 0 m (2 * m))
+        atTop atTop := by
+      simpa only [sub_eq_add_neg, id_eq] using
+        tendsto_atTop_add_const_right atTop (-columnEntry 0 m (2 * m))
+          (tendsto_atTop_add_const_right atTop (-connectorEntry H r X Y)
+            (tendsto_atTop_add_const_left atTop Y tendsto_id))
+    apply hh.congr'
+    filter_upwards [eventually_ge_atTop
+      (connectorEntry H r X Y + columnEntry 0 m (2 * m) + 1)] with t ht
+    rw [(complete_linear_tail m H r X Y ht).1]
+    simp
+  have hn : Tendsto (fun t => ‖completeSpine m H r X Y t‖) atTop atTop := by
+    apply tendsto_atTop_mono (fun t => ?_) him
+    exact (le_abs_self _).trans (Complex.abs_im_le_norm _)
+  apply tendsto_cocompact_of_tendsto_dist_comp_atTop 0
+  simpa only [dist_zero_right] using hn
+
+lemma complete_normal_displacement (m : ℕ) (H r X Y : ℝ) {z : ℂ} (hz : |z.im| ≤ 1) :
+    dist (normalRibbon (completeSpine m H r X Y) (completeTangent m H r X Y) z)
+      (completeSpine m H r X Y z.re) ≤ 1 := by
+  rw [normalRibbon, dist_self_add_left, norm_mul, norm_mul, Complex.norm_real,
+    Real.norm_eq_abs, Complex.norm_I, completeTangent_norm, mul_one, mul_one]
+  exact hz
+
+lemma complete_normal_width (m : ℕ) (H r X Y : ℝ) {z : ℂ} (hz : |z.im| ≤ 1) :
+    ‖normalRibbon (completeSpine m H r X Y) (completeTangent m H r X Y) z -
+      completeSpine m H r X Y z.re‖ ≤ 1 := by
+  simpa only [dist_eq_norm] using complete_normal_displacement m H r X Y hz
+
+lemma complete_normal_continuous {H r X Y : ℝ} (m : ℕ) (hr : 50 ≤ r)
+    (hX : 2 * r < X) (hY : H + 2 * r < Y) :
+    Continuous (normalRibbon (completeSpine m H r X Y) (completeTangent m H r X Y)) := by
+  have hr0 : 0 < r := by linarith
+  have hσ : Continuous (completeSpine m H r X Y) :=
+    continuous_iff_continuousAt.mpr (fun t => (completeSpine_hasDerivAt m hr0 hX hY t).continuousAt)
+  have hT : Continuous (completeTangent m H r X Y) :=
+    (completeTangent_lipschitz m hr hX hY).continuous
+  exact (hσ.comp Complex.continuous_re).add
+    (((Complex.continuous_ofReal.comp Complex.continuous_im).mul continuous_const).mul
+      (hT.comp Complex.continuous_re))
+
+end SLEExactGauge.Serpentine
+
+end
+
+end OAI

lean/OAI/Probability/SLE/Gauge/SerpentineExperimentGeometry.lean

@@ -0,0 +1,179 @@
+import OAI.Probability.SLE.Gauge.SerpentineFittedShadow
+import OAI.Probability.SLE.Gauge.SerpentineReflection
+import OAI.Probability.SLE.Gauge.ProperRibbonCoordinates
+
+namespace OAI
+
+/-! The actual left-or-right displaced serpentine. Reflection is applied
+to both the physical image and the normal coordinate, so the initial chart
+is still `z ↦ I*z`. -/
+
+noncomputable section
+open Set Filter Metric ComplexConjugate
+open scoped NNReal
+
+namespace SLEExactGauge.Serpentine
+open RibbonCoordinates
+
+def experimentChart (s : ℝ) (w : ℂ) (m : ℕ) : ℂ → ℂ :=
+  if 0 ≤ w.re then fitChart s w m else reflectedChart (fitChart s w m)
+
+def experimentSpine (s : ℝ) (w : ℂ) (m : ℕ) (t : ℝ) : ℂ :=
+  if 0 ≤ w.re then fitSpine s w m t else loewnerMirror (fitSpine s w m t)
+
+def physicalExperimentChart (s : ℝ) (w : ℂ) (m : ℕ) (z : ℂ) : ℂ :=
+  if 0 ≤ w.re then physicalFitChart s w m z else loewnerMirror (physicalFitChart s w m (conj z))
+
+lemma loewnerMirror_real_mul (c : ℝ) (z : ℂ) :
+    loewnerMirror ((c : ℂ) * z) = (c : ℂ) * loewnerMirror z := by
+  simp [loewnerMirror, mul_neg]
+
+lemma physicalExperimentChart_eq (s : ℝ) (w : ℂ) (m : ℕ) (z : ℂ) :
+    physicalExperimentChart s w m z = (ribbonWidth (halfHeight s) m : ℂ) * experimentChart s w m z := by
+  by_cases hw : 0 ≤ w.re
+  · simp only [physicalExperimentChart, experimentChart, ite_eq_left hw, physicalFitChart]
+  · simp only [physicalExperimentChart, experimentChart, ite_eq_right hw, physicalFitChart,
+      reflectedChart, loewnerMirror_real_mul]
+
+theorem experimentChart_geometry {s : ℝ} (hs : 0 < s) (w : ℂ) (hw : s ≤ w.im)
+    {m : ℕ} (hm : 0 < m) :
+    Continuous (experimentChart s w m) ∧ InjOn (experimentChart s w m) closedRibbon ∧
+    (∀ k : ℝ, LipschitzOnWith 2 (experimentChart s w m) (ribbonStepPatch k) ∧
+      ∀ z ∈ ribbonStepPatch k, ∀ z' ∈ ribbonStepPatch k,
+        dist z z' ≤ 2 * dist (experimentChart s w m z) (experimentChart s w m z')) ∧
+    (∀ z ∈ closedRibbon, 0 < z.re → experimentChart s w m z ∈ upperHalfPlane) ∧
+    (∀ z ∈ closedRibbon, z.re ≤ 4 → experimentChart s w m z = Complex.I * z) := by
+  have hcont := fitChart_continuous hs w hw hm
+  have hinj := fitChart_injective hs w hw hm
+  have hpatch := fitChart_patch_bounds hs w hw hm
+  have hu := fitChart_upper hs w hw hm
+  have hi : ∀ z ∈ closedRibbon, z.re ≤ 4 → fitChart s w m z = Complex.I * z := by
+    intro z _ hz
+    exact fitChart_initial hs w hw hm (hz.trans (fit_parameters hs w hw hm).2.2.2)
+  by_cases hwr : 0 ≤ w.re
+  · simpa only [experimentChart, ite_eq_left hwr] using ⟨hcont, hinj, hpatch, hu, hi⟩
+  · simp only [experimentChart, ite_eq_right hwr]
+    exact ⟨reflectedChart_continuous hcont, reflectedChart_injective hinj,
+      fun k => ⟨reflectedChart_patch_upper (hpatch k).1,
+        reflectedChart_patch_lower (hpatch k).2⟩,
+      reflectedChart_upper hu, reflectedChart_initial hi⟩
+
+lemma experimentChart_width (s : ℝ) (w : ℂ) (m : ℕ) {z : ℂ} (hz : z ∈ closedRibbon) :
+    ‖experimentChart s w m z - experimentSpine s w m z.re‖ ≤ 1 := by
+  by_cases hwr : 0 ≤ w.re
+  · simpa only [experimentChart, experimentSpine, ite_eq_left hwr] using fitChart_width s w m hz
+  · simpa only [experimentChart, experimentSpine, ite_eq_right hwr] using
+      reflectedChart_width (P := fitChart s w m) (σ := fitSpine s w m)
+        (fun _ hz => fitChart_width s w m hz) z hz
+
+lemma experimentSpine_eventually_ray (s : ℝ) (w : ℂ) (m : ℕ) :
+    ∃ T : ℝ, 0 ≤ T ∧ ∀ t : ℝ, T ≤ t →
+      experimentSpine s w m t = experimentSpine s w m T + ((t - T : ℝ) : ℂ) * Complex.I := by
+  obtain ⟨T, hT, htail⟩ := fitSpine_eventually_ray s w m
+  refine ⟨T, hT, fun t ht => ?_⟩
+  by_cases hwr : 0 ≤ w.re
+  · simpa only [experimentSpine, ite_eq_left hwr] using htail t ht
+  · simp only [experimentSpine, ite_eq_right hwr]
+    rw [htail t ht]
+    simp [loewnerMirror, mul_neg, add_comm]
+
+lemma experimentChart_real_norm (s : ℝ) (w : ℂ) (m : ℕ) (t : ℝ) :
+    ‖experimentChart s w m (t : ℂ)‖ = ‖fitSpine s w m t‖ := by
+  by_cases hwr : 0 ≤ w.re <;>
+    simp [experimentChart, hwr, reflectedChart, fitChart, normalRibbon]
+
+theorem experimentChart_escape (s : ℝ) (w : ℂ) (m : ℕ) :
+    Tendsto (fun t : ℝ => ‖experimentChart s w m (t : ℂ)‖) atTop atTop := by
+  simp only [experimentChart_real_norm]
+  exact tendsto_norm_cocompact_atTop.comp
+    (completeSpine_escape m (fitHeight m) (fitRadius m) (fitX s w m) (fitY s w m))
+
+theorem experimentChart_zero {s : ℝ} (hs : 0 < s) (w : ℂ) (hw : s ≤ w.im)
+    {m : ℕ} (hm : 0 < m) : experimentChart s w m 0 = 0 := by
+  have hh := (experimentChart_geometry hs w hw hm).2.2.2.2 0
+    (by simp [closedRibbon]) (by norm_num)
+  simpa only [mul_zero] using hh
+
+theorem experimentChart_closedEmbedding {s : ℝ} (hs : 0 < s) (w : ℂ) (hw : s ≤ w.im)
+    {m : ℕ} (hm : 0 < m) :
+    Topology.IsClosedEmbedding (fun z : closedRibbon => experimentChart s w m z) := by
+  obtain ⟨hc, hi, _⟩ := experimentChart_geometry hs w hw hm
+  obtain ⟨T, hT, htail⟩ := experimentSpine_eventually_ray s w m
+  exact ribbon_closedEmbedding_of_linear_tail _ hc.continuousOn hi _ T hT
+    (experimentSpine s w m T) htail (fun _ hz => experimentChart_width s w m hz)
+
+theorem experimentChart_global_progress {s : ℝ} (hs : 0 < s) (w : ℂ) (hw : s ≤ w.im)
+    {m : ℕ} (hm : 0 < m) :
+    ∃ g : C(ℂ, ℝ), ∀ z ∈ closedRibbon, g (experimentChart s w m z) = z.re :=
+  exists_global_ribbon_progress _ (experimentChart_closedEmbedding hs w hw hm)
+
+lemma reflected_positiveCenter {s : ℝ} {w : ℂ} (hw : w.re < 0) :
+    loewnerMirror (positiveCenter s w) = center s w := by
+  have hn : ¬ 0 ≤ w.re := not_le.mpr hw
+  apply Complex.ext
+  · simp only [loewnerMirror_re, positiveCenter, center, Complex.add_re, Complex.mul_re,
+      Complex.ofReal_re, Complex.ofReal_im, Complex.I_re, Complex.I_im,
+      mul_zero, zero_mul, sub_zero, add_zero]
+    rw [abs_of_neg hw]
+    simp only [displacementSign, ite_eq_right hn]
+    ring
+  · simp only [loewnerMirror_im, positiveCenter, center, Complex.add_im, Complex.mul_im,
+      Complex.ofReal_re, Complex.ofReal_im, Complex.I_re, Complex.I_im,
+      mul_zero, mul_one, add_zero, zero_add]
+
+theorem physicalExperimentChart_retained_disk {s : ℝ} (hs : 0 < s) (w : ℂ) (hw : s ≤ w.im)
+    {m j i : ℕ} (hm : 0 < m) (hj : j < m) (hi : i < m) {z : ℂ}
+    (hz : z.re ∈ Icc
+      ((retainedStep (connectorEntry (fitHeight m) (fitRadius m) (fitX s w m) (fitY s w m)) m j i : ℝ) + 1 / 3)
+      ((retainedStep (connectorEntry (fitHeight m) (fitRadius m) (fitX s w m) (fitY s w m)) m j i : ℝ) + 2 / 3))
+    (ha : |z.im| ≤ 1) :
+    physicalExperimentChart s w m z ∈ closedBall (center s w) (s / 20) := by
+  by_cases hwr : 0 ≤ w.re
+  · simpa only [physicalExperimentChart, ite_eq_left hwr] using
+      physicalFitChart_retained_disk hs w hw hwr hm hj hi hz ha
+  · have hzc : (conj z).re ∈ Icc
+        ((retainedStep (connectorEntry (fitHeight m) (fitRadius m) (fitX s w m) (fitY s w m)) m j i : ℝ) + 1 / 3)
+        ((retainedStep (connectorEntry (fitHeight m) (fitRadius m) (fitX s w m) (fitY s w m)) m j i : ℝ) + 2 / 3) := by
+      simpa only [Complex.conj_re] using hz
+    have hac : |(conj z).im| ≤ 1 := by simpa only [Complex.conj_im, abs_neg] using ha
+    have hd := physicalFitChart_retained_distance hs w hw hm hj hi hzc hac
+    change dist _ _ ≤ _
+    rw [physicalExperimentChart, ite_eq_right hwr, ← reflected_positiveCenter (lt_of_not_ge hwr),
+      loewnerMirror_dist]
+    linarith
+
+theorem physicalExperimentChart_avoids_shadow {s : ℝ} (hs : 0 < s) (w : ℂ) (hw : s ≤ w.im)
+    {m : ℕ} (hm : 0 < m) {z : ℂ} (ha : |z.im| ≤ 1) :
+    ¬ (|(physicalExperimentChart s w m z).re - w.re| < s / 100 ∧
+      w.im - s / 100 < (physicalExperimentChart s w m z).im) := by
+  by_cases hwr : 0 ≤ w.re
+  · simpa only [physicalExperimentChart, ite_eq_left hwr, abs_of_nonneg hwr] using
+      physicalFitChart_avoids_shadow hs w hw hm ha
+  · have hneg : w.re < 0 := lt_of_not_ge hwr
+    have hac : |(conj z).im| ≤ 1 := by simpa only [Complex.conj_im, abs_neg] using ha
+    have hn := physicalFitChart_avoids_shadow hs w hw hm hac
+    have he : abs (-(physicalFitChart s w m (conj z)).re - w.re) =
+        abs ((physicalFitChart s w m (conj z)).re - |w.re|) := by
+      rw [abs_of_neg hneg]
+      have hh : -(physicalFitChart s w m (conj z)).re - w.re =
+          -((physicalFitChart s w m (conj z)).re - -w.re) := by ring
+      rw [hh, abs_neg]
+    simpa only [physicalExperimentChart, ite_eq_right hwr, loewnerMirror_re, loewnerMirror_im, he] using hn
+
+theorem selected_middle_regions_inside {s : ℝ} (hs : 0 < s) (w : ℂ) (hw : s ≤ w.im)
+    {m : ℕ} (hm : 0 < m) {ε : ℝ} (hε : ε ≤ 1) :
+    ∀ k ∈ retainedSteps (connectorEntry (fitHeight m) (fitRadius m) (fitX s w m) (fitY s w m)) m,
+      physicalMiddleRegion (physicalExperimentChart s w m) closedRibbon k ε ⊆
+        closedBall (center s w) (s / 20) := by
+  intro k hk
+  obtain ⟨⟨j, i⟩, _, rfl⟩ := Finset.mem_image.mp hk
+  rw [physicalMiddleRegion_eq_image_middleStrip _ (Nat.cast_nonneg _) hε]
+  rintro y ⟨z, hz, rfl⟩
+  exact physicalExperimentChart_retained_disk hs w hw hm j.isLt i.isLt
+    ⟨by linarith [hz.1], by linarith [hz.2.1]⟩ (hz.2.2.le.trans hε)
+
+end SLEExactGauge.Serpentine
+
+end
+
+end OAI

lean/OAI/Probability/SLE/Gauge/SerpentineExponentialMass.lean

@@ -0,0 +1,63 @@
+import OAI.Probability.SLE.Gauge.SerpentineNormalizedMass
+import OAI.Probability.SLE.Gauge.DenseRibbonNumerics
+
+namespace OAI
+
+/-! The concrete stopped dense experiment costs at most exponentially
+in m²; the constants are independent of the marked point and mesh. -/
+
+noncomputable section
+open Set Filter MeasureTheory ProbabilityTheory Metric
+open scoped Topology NNReal ENNReal
+
+namespace SLEExactGauge.Serpentine
+open RibbonCoordinates Target
+
+theorem uniform_serpentine_exponential_stopped_mass
+    {Ω : Type} [mΩ : MeasurableSpace Ω] (μ : Measure Ω) [IsProbabilityMeasure μ]
+    (κ : ℝ) (hκ : 0 < κ) (hκ8 : κ < 8)
+    (B : ℝ≥0 → Ω → ℝ) (hB : IsBrownianReal B μ)
+    (hm : ∀ t, Measurable (B t)) (hc : ∀ ω, Continuous (fun t => B t ω))
+    (γ : Ω → ℝ≥0 → ℂ) (G F : Ω → ℝ≥0 → ℂ → ℂ)
+    (hw : ∀ ω, IsCapacityTwoWitness (fun t => Real.sqrt κ * B t ω) (γ ω) (G ω) (F ω))
+    (hcompact : PublishedHalfPlaneUnivalentCompactness)
+    (hboundary : PublishedFiniteLoewnerBoundaryExtension)
+    (hsupport : PublishedGeometricTubeSupport μ γ)
+    (hplanar : PublishedPlanarDiskOpenness)
+    (hstraight : PublishedHalfPlaneCrosscutStraightening)
+    (hexit : PublishedHalfPlaneConformalExitLaw)
+    (hwiener : PublishedPlanarWienerUnitSupport)
+    (W : WienerLaw) (hW : IsWiener W)
+    (ε : ℝ) (hε : 0 < ε) (hεsmall : ε ≤ 1 / 8) :
+    ∃ c v₀ : ℝ, 0 < c ∧ 0 < v₀ ∧ ∀ s : ℝ, 0 < s →
+      ∃ C : ℝ, 0 < C ∧ ∀ v : ℝ, 0 < v → v < v₀ →
+      ∀ w : ℂ, ‖w‖ ≤ 1 → s ≤ w.im → ∀ m : ℕ, 0 < m → ∀ g : C(ℂ, ℝ),
+      (∀ z ∈ closedRibbon, g (experimentChart s w m z) = z.re) →
+      ENNReal.ofReal (Real.exp (-C * (m : ℝ) ^ 2)) ≤ μ {ω |
+        ω ∈ GoodRibbonPrefix γ (ribbonIntegerFront g γ (experimentSteps s w m)) (experimentChart s w m) ε ∧
+        ((m ^ 2 : ℕ) : ℝ≥0∞) * ENNReal.ofReal c ≤ segmentSausageCharge κ (γ ω) 0
+          ((ribbonIntegerFront g γ (experimentSteps s w m) ω).untopD 0) v (normalizedExperimentDisk s w m)} := by
+  obtain ⟨q₀, q, c, v₀, hq₀, hq₀1, hq, hq1, hcm, hv₀, hprob⟩ :=
+    uniform_serpentine_normalized_stopped_mass μ κ hκ hκ8 B hB hm hc γ G F hw
+      hcompact hboundary hsupport hplanar hstraight hexit hwiener W hW ε hε hεsmall
+  have hq₀fin : q₀ ≠ ⊤ := ne_top_of_le_ne_top (by norm_num : (1 : ℝ≥0∞) ≠ ⊤) hq₀1
+  have hp : 0 < q₀.toReal := ENNReal.toReal_pos hq₀.ne' hq₀fin
+  refine ⟨c, v₀, hcm, hv₀, fun s hs => ?_⟩
+  let D := fitEntryBound s + 601 + 100 * Real.pi
+  have hD : 0 ≤ D := by dsimp only [D]; linarith [fitEntryBound_pos hs, Real.pi_pos]
+  obtain ⟨C, hC, hcost⟩ := ribbon_initial_and_steps_quadratic_cost hq hq1 hp hD
+  refine ⟨C, hC, fun v hv hvcut w hwn hwy m hmp g hg => ?_⟩
+  have hcount : (experimentSteps s w m : ℝ) ≤ D * (m : ℝ) ^ 2 := by
+    apply le_trans (Nat.cast_le.mpr (Nat.sub_le _ 1))
+    exact fit_completion_quadratic hs w hwn hwy hmp
+  have hreal := hcost m (experimentSteps s w m) hmp hcount
+  have hENN := ENNReal.ofReal_le_ofReal hreal
+  rw [ENNReal.ofReal_mul (pow_nonneg hq.le _), ENNReal.ofReal_pow hq.le,
+    ENNReal.ofReal_toReal hq₀fin] at hENN
+  exact hENN.trans (hprob v hv hvcut s hs w hwy m hmp g hg)
+
+end SLEExactGauge.Serpentine
+
+end
+
+end OAI

lean/OAI/Probability/SLE/Gauge/SerpentineExteriorBounds.lean

@@ -0,0 +1,60 @@
+import OAI.Probability.SLE.Gauge.SerpentineHorizontalBound
+
+namespace OAI
+
+/-! The physical experiment lies strictly between two fixed exterior
+vertical lines. These lines provide unobstructed real-boundary exits. -/
+
+noncomputable section
+open Set Metric
+
+namespace SLEExactGauge.Serpentine
+open RibbonCoordinates
+
+lemma physicalFitChart_re_bounds {s : ℝ} (hs : 0 < s) (hs1 : s ≤ 1)
+    (w : ℂ) (hw : s ≤ w.im) (hw1 : ‖w‖ ≤ 1) {m : ℕ} (hm : 0 < m)
+    {z : ℂ} (hz : z ∈ closedRibbon) :
+    -2 ≤ (physicalFitChart s w m z).re ∧ (physicalFitChart s w m z).re ≤ 2 := by
+  obtain ⟨hr, hx, _, _⟩ := fit_parameters hs w hw hm
+  have hH : 0 ≤ fitHeight m := by unfold fitHeight; positivity
+  have hℓ := (fit_width_pos hs hm).le
+  have hℓ1 := fit_width_le hs hm
+  have hX := fit_scaledX hs w hm
+  have hwr := (Complex.abs_re_le_norm w).trans hw1
+  let A := connectorEntry (fitHeight m) (fitRadius m) (fitX s w m) (fitY s w m)
+  by_cases hA : z.re ≤ A
+  · have hb := lowConnector_normal_re_bounds hH (by linarith : 0 < fitRadius m) hx hz
+    have hlo := mul_le_mul_of_nonneg_left hb.1 hℓ
+    have hhi := mul_le_mul_of_nonneg_left hb.2 hℓ
+    change -2 ≤ ((ribbonWidth (halfHeight s) m : ℂ) *
+      normalRibbon (completeSpine m _ _ _ _) (completeTangent m _ _ _ _) z).re ∧
+      ((ribbonWidth (halfHeight s) m : ℂ) *
+      normalRibbon (completeSpine m _ _ _ _) (completeTangent m _ _ _ _) z).re ≤ 2
+    rw [complete_normal_of_le m _ _ _ _ hA]
+    simp only [Complex.mul_re, Complex.ofReal_re, Complex.ofReal_im, zero_mul, sub_zero]
+    constructor <;> nlinarith
+  · have hz' : 0 ≤ (z - (A : ℂ)).re ∧ |(z - (A : ℂ)).im| ≤ 1 := by
+      simp only [Complex.sub_re, Complex.sub_im, Complex.ofReal_re, Complex.ofReal_im, sub_zero]
+      exact ⟨by linarith, hz.2⟩
+    have hlo := mul_le_mul_of_nonneg_left (array_normal_re_lower hm hz') hℓ
+    have hhi := mul_le_mul_of_nonneg_left (array_normal_re_upper hm hz') hℓ
+    have hcenter := congrArg Complex.re (fit_scaled_arrayCenter hs w hm)
+    simp only [Complex.mul_re, Complex.ofReal_re, Complex.ofReal_im, zero_mul, sub_zero,
+      positiveCenter, Complex.add_re, Complex.mul_re, Complex.I_re, Complex.I_im,
+      mul_zero, sub_zero, add_zero] at hcenter
+    have hmℓ := fit_width_mul hs hm
+    change -2 ≤ ((ribbonWidth (halfHeight s) m : ℂ) *
+      normalRibbon (completeSpine m _ _ _ _) (completeTangent m _ _ _ _) z).re ∧
+      ((ribbonWidth (halfHeight s) m : ℂ) *
+      normalRibbon (completeSpine m _ _ _ _) (completeTangent m _ _ _ _) z).re ≤ 2
+    rw [complete_normal_of_gt m _ _ _ _ (lt_of_not_ge hA)]
+    simp only [Complex.mul_re, Complex.ofReal_re, Complex.ofReal_im, zero_mul, sub_zero,
+      Complex.add_re]
+    dsimp only [A] at hlo hhi
+    constructor <;> nlinarith [abs_nonneg w.re]
+
+end SLEExactGauge.Serpentine
+
+end
+
+end OAI

lean/OAI/Probability/SLE/Gauge/SerpentineFiniteHeight.lean

@@ -0,0 +1,122 @@
+import OAI.Probability.SLE.Gauge.SerpentineTerminalGuide
+
+namespace OAI
+
+/-! Every point in the finite experiment, before its final integer front,
+is below the height used to attach the marked hook. -/
+
+noncomputable section
+open Set Metric
+
+namespace SLEExactGauge.Serpentine
+open RibbonCoordinates
+
+lemma array_normal_im_upper_before_end {m : ℕ} (hm : 0 < m) {z : ℂ}
+    (hz : 0 ≤ z.re ∧ |z.im| ≤ 1) (hze : z.re ≤ arrayEnd m (2 * m) + 1) :
+    (normalRibbon (arraySpine m (2 * m)) (arrayTangent m (2 * m)) z).im ≤ 401 * m := by
+  have hh : (0 : ℝ) < 100 * m := by positivity
+  by_cases he : z.re ≤ arrayEnd m (2 * m)
+  · rcases array_pieces m (2 * m) ⟨hz.1, he⟩ with ⟨i, hi, u, hu, _, hs, hT⟩ |
+      ⟨i, hi, u, hu, _, hs, hT⟩
+    · simp only [normalRibbon]
+      rw [hs, hT, normal_straight_eq hm]
+      have hb := columnPoint_bound hh hm hi 0 (straight_height_bound m i hu) hz.2
+      rw [dist_zero_right] at hb
+      exact (Complex.im_le_norm _).trans (by linarith)
+    · simp only [normalRibbon]
+      rw [hs, hT, normal_circular_eq hm]
+      have hb := turnPoint_bound hh hm (show i + 1 ≤ 2 * m by omega) 0 (u / 50) hz.2
+      rw [dist_zero_right] at hb
+      exact (Complex.im_le_norm _).trans (by linarith)
+  · have hE : columnEntry 0 m (2 * m) ≤ z.re := by
+      have h := lt_of_not_ge he
+      dsimp only [arrayEnd] at h
+      linarith [Nat.cast_nonneg (α := ℝ) m]
+    have ht := array_normal_terminal hm (a := z.im) hE
+    rw [Complex.re_add_im z] at ht
+    rw [ht, columnPoint_im]
+    have hmr : (1 : ℝ) ≤ m := by exact_mod_cast hm
+    dsimp only [arrayEnd] at hze
+    simp only [Complex.zero_im, zero_add]
+    linarith
+
+lemma lowConnector_im_mono {r X : ℝ} (hr : 0 < r) (hX : 2 * r < X) (H : ℝ) :
+    Monotone (fun t => (lowConnector H r X t).im) :=
+  monotone_of_hasDerivAt_nonneg
+    (fun t => Complex.imCLM.hasFDerivAt.comp_hasDerivAt t (lowConnector_hasDerivAt hr hX t))
+    (fun t => (lowConnectorTangent_nonneg (H := H) hr hX t).2)
+
+lemma physicalFitChart_before_entry_height {s : ℝ} (hs : 0 < s) (w : ℂ) (hw : s ≤ w.im)
+    {m : ℕ} (hm : 0 < m) {z : ℂ} (ha : |z.im| ≤ 1) (hz : z.re ≤ fitEntry s w m) :
+    (physicalFitChart s w m z).im ≤ w.im := by
+  obtain ⟨hr, hx, hy, _⟩ := fit_parameters hs w hw hm
+  have hA4 : connectorFourth (fitHeight m) (fitRadius m) (fitX s w m) < fitEntry s w m := by
+    unfold fitEntry connectorEntry
+    linarith [Nat.cast_nonneg (α := ℝ) m]
+  have hcenter := lowConnector_im_mono (by linarith : 0 < fitRadius m) hx (fitHeight m) hz
+  dsimp only at hcenter
+  rw [(lowConnector_after hA4).1] at hcenter
+  simp only [connectorTail, Complex.add_im, Complex.mul_im, Complex.ofReal_re,
+    Complex.ofReal_im, Complex.I_re, Complex.I_im, mul_one, mul_zero, zero_add] at hcenter
+  have hAeq : fitHeight m + 2 * fitRadius m +
+      (fitEntry s w m - connectorFourth (fitHeight m) (fitRadius m) (fitX s w m)) = fitY s w m := by
+    unfold fitEntry connectorEntry
+    ring
+  rw [hAeq] at hcenter
+  have hnormal : (normalRibbon (lowConnector (fitHeight m) (fitRadius m) (fitX s w m))
+      (lowConnectorTangent (fitHeight m) (fitRadius m) (fitX s w m)) z).im ≤ fitY s w m + 1 := by
+    have hb : ‖normalRibbon (lowConnector (fitHeight m) (fitRadius m) (fitX s w m))
+      (lowConnectorTangent (fitHeight m) (fitRadius m) (fitX s w m)) z -
+        lowConnector (fitHeight m) (fitRadius m) (fitX s w m) z.re‖ ≤ 1 := by
+      simp only [normalRibbon, add_sub_cancel_left, norm_mul, Complex.norm_real,
+        Real.norm_eq_abs, Complex.norm_I, lowConnectorTangent_norm, mul_one]
+      exact ha
+    have hi := (Complex.abs_im_le_norm _).trans hb
+    rw [Complex.sub_im] at hi
+    linarith [le_abs_self ((normalRibbon (lowConnector (fitHeight m) (fitRadius m) (fitX s w m))
+      (lowConnectorTangent (fitHeight m) (fitRadius m) (fitX s w m)) z).im -
+        (lowConnector (fitHeight m) (fitRadius m) (fitX s w m) z.re).im)]
+  have hh := mul_le_mul_of_nonneg_left hnormal (fit_width_pos hs hm).le
+  have hY := fit_scaledY hs w hm
+  have hwidth := fit_width_le hs hm
+  change ((ribbonWidth (halfHeight s) m : ℂ) *
+    normalRibbon (completeSpine m _ _ _ _) (completeTangent m _ _ _ _) z).im ≤ _
+  rw [complete_normal_of_le m _ _ _ _ hz]
+  simp only [Complex.mul_im, Complex.ofReal_re, Complex.ofReal_im, zero_mul, add_zero]
+  nlinarith
+
+lemma physicalFitChart_finite_height_lt_two {s : ℝ} (hs : 0 < s) (hs1 : s ≤ 1)
+    (w : ℂ) (hw : s ≤ w.im) (hw1 : ‖w‖ ≤ 1) {m : ℕ} (hm : 0 < m)
+    {z : ℂ} (hz : z ∈ closedRibbon) (hzK : z.re ≤ fitCompletion s w m) :
+    (physicalFitChart s w m z).im < 2 := by
+  have hwi := (Complex.im_le_norm w).trans hw1
+  by_cases hA : z.re ≤ fitEntry s w m
+  · exact (physicalFitChart_before_entry_height hs w hw hm hz.2 hA).trans_lt (by linarith)
+  · have hz' : 0 ≤ (z - (fitEntry s w m : ℂ)).re ∧
+        |(z - (fitEntry s w m : ℂ)).im| ≤ 1 := by
+      simp only [Complex.sub_re, Complex.sub_im, Complex.ofReal_re, Complex.ofReal_im, sub_zero]
+      exact ⟨by linarith, hz.2⟩
+    have hze : (z - (fitEntry s w m : ℂ)).re ≤ arrayEnd m (2 * m) + 1 := by
+      have hh := (fitCompletion_bounds hs w hw hm).2
+      simp only [Complex.sub_re, Complex.ofReal_re, arrayEnd]
+      linarith
+    have hb := mul_le_mul_of_nonneg_left (array_normal_im_upper_before_end hm hz' hze)
+      (fit_width_pos hs hm).le
+    have hmℓ := fit_width_mul hs hm
+    have hcenter := congrArg Complex.im (fit_scaled_arrayCenter hs w hm)
+    simp only [Complex.mul_im, Complex.ofReal_re, Complex.ofReal_im, zero_mul, add_zero,
+      positiveCenter, Complex.add_im, Complex.mul_im, Complex.I_re, Complex.I_im,
+      mul_one, mul_zero, zero_add] at hcenter
+    change ((ribbonWidth (halfHeight s) m : ℂ) *
+      normalRibbon (completeSpine m _ _ _ _) (completeTangent m _ _ _ _) z).im < _
+    rw [complete_normal_of_gt m _ _ _ _ (lt_of_not_ge hA)]
+    simp only [Complex.mul_im, Complex.ofReal_re, Complex.ofReal_im, zero_mul, add_zero,
+      Complex.add_im]
+    unfold fitEntry at hb
+    nlinarith
+
+end SLEExactGauge.Serpentine
+
+end
+
+end OAI

lean/OAI/Probability/SLE/Gauge/SerpentineFittedChart.lean

@@ -0,0 +1,100 @@
+import OAI.Probability.SLE.Gauge.SerpentineParameters
+import OAI.Probability.SLE.Gauge.SerpentineUpperHalfPlane
+import OAI.Probability.SLE.Gauge.SerpentineRetainedStrips
+
+namespace OAI
+
+/-! The concrete normalized chart, with the universal local constants
+used by the ribbon iteration. The physical width is recorded separately. -/
+
+noncomputable section
+open Set Metric
+open scoped NNReal
+
+namespace SLEExactGauge.Serpentine
+open RibbonCoordinates
+
+def fitSpine (s : ℝ) (w : ℂ) (m : ℕ) : ℝ → ℂ :=
+  completeSpine m (fitHeight m) (fitRadius m) (fitX s w m) (fitY s w m)
+
+def fitTangent (s : ℝ) (w : ℂ) (m : ℕ) : ℝ → ℂ :=
+  completeTangent m (fitHeight m) (fitRadius m) (fitX s w m) (fitY s w m)
+
+def fitChart (s : ℝ) (w : ℂ) (m : ℕ) : ℂ → ℂ :=
+  normalRibbon (fitSpine s w m) (fitTangent s w m)
+
+def positiveCenter (s : ℝ) (w : ℂ) : ℂ :=
+  ((|w.re| + s / 4 : ℝ) : ℂ) + (w.im : ℂ) * Complex.I
+
+lemma fitChart_continuous {s : ℝ} (hs : 0 < s) (w : ℂ) (hw : s ≤ w.im)
+    {m : ℕ} (hm : 0 < m) : Continuous (fitChart s w m) := by
+  obtain ⟨hr, hx, hy, _⟩ := fit_parameters hs w hw hm
+  exact complete_normal_continuous m hr hx (by linarith [Nat.cast_nonneg (α := ℝ) m])
+
+lemma fitChart_injective {s : ℝ} (hs : 0 < s) (w : ℂ) (hw : s ≤ w.im)
+    {m : ℕ} (hm : 0 < m) : InjOn (fitChart s w m) closedRibbon := by
+  obtain ⟨hr, hx, hy, _⟩ := fit_parameters hs w hw hm
+  exact complete_normal_injective hm hr hx hy
+
+lemma fitChart_patch_bounds {s : ℝ} (hs : 0 < s) (w : ℂ) (hw : s ≤ w.im)
+    {m : ℕ} (hm : 0 < m) (k : ℝ) :
+    LipschitzOnWith 2 (fitChart s w m) (ribbonStepPatch k) ∧
+      ∀ z ∈ ribbonStepPatch k, ∀ z' ∈ ribbonStepPatch k,
+        dist z z' ≤ 2 * dist (fitChart s w m z) (fitChart s w m z') := by
+  obtain ⟨hr, hx, hy, _⟩ := fit_parameters hs w hw hm
+  exact complete_normal_patch_bounds m hr hx (by linarith [Nat.cast_nonneg (α := ℝ) m]) k
+
+lemma fitChart_upper {s : ℝ} (hs : 0 < s) (w : ℂ) (hw : s ≤ w.im)
+    {m : ℕ} (hm : 0 < m) :
+    ∀ z ∈ closedRibbon, 0 < z.re → fitChart s w m z ∈ upperHalfPlane := by
+  obtain ⟨hr, hx, hy, hH⟩ := fit_parameters hs w hw hm
+  intro z hz hz0
+  exact complete_normal_upper hm (by linarith) (by linarith) hx
+    (by linarith [Nat.cast_nonneg (α := ℝ) m]) hz0 hz.2
+
+lemma fitChart_initial {s : ℝ} (hs : 0 < s) (w : ℂ) (hw : s ≤ w.im)
+    {m : ℕ} (hm : 0 < m) {z : ℂ} (hz : z.re ≤ fitHeight m) :
+    fitChart s w m z = Complex.I * z := by
+  obtain ⟨hr, hx, _, _⟩ := fit_parameters hs w hw hm
+  have hA := fit_entry_lower hs w hw hm
+  change normalRibbon (completeSpine m (fitHeight m) (fitRadius m) (fitX s w m) (fitY s w m))
+    (completeTangent m (fitHeight m) (fitRadius m) (fitX s w m) (fitY s w m)) z = _
+  rw [complete_normal_of_le m _ _ _ _ (hz.trans hA)]
+  obtain ⟨hσ, hT⟩ := lowConnector_initial (by linarith : 0 < fitRadius m) hx hz
+  rw [normalRibbon, hσ, hT]
+  apply Complex.ext <;>
+    simp only [Complex.add_re, Complex.add_im, Complex.mul_re, Complex.mul_im,
+      Complex.ofReal_re, Complex.ofReal_im, Complex.I_re, Complex.I_im] <;> ring
+
+lemma fitChart_width (s : ℝ) (w : ℂ) (m : ℕ) {z : ℂ} (hz : z ∈ closedRibbon) :
+    ‖fitChart s w m z - fitSpine s w m z.re‖ ≤ 1 :=
+  complete_normal_width m _ _ _ _ hz.2
+
+lemma fitSpine_eventually_ray (s : ℝ) (w : ℂ) (m : ℕ) :
+    ∃ T : ℝ, 0 ≤ T ∧ ∀ t : ℝ, T ≤ t →
+      fitSpine s w m t = fitSpine s w m T + ((t - T : ℝ) : ℂ) * Complex.I :=
+  complete_eventually_ray m _ _ _ _
+
+lemma fit_scaled_arrayCenter {s : ℝ} (hs : 0 < s) (w : ℂ) {m : ℕ} (hm : 0 < m) :
+    (ribbonWidth (halfHeight s) m : ℂ) * arrayCenter m (fitX s w m) (fitY s w m) =
+      positiveCenter s w := by
+  have hℓ := (fit_width_pos hs hm).ne'
+  have hmul := fit_width_mul hs hm
+  apply Complex.ext <;>
+    simp only [arrayCenter, positiveCenter, Complex.add_re, Complex.add_im,
+      Complex.mul_re, Complex.mul_im, Complex.ofReal_re, Complex.ofReal_im,
+      Complex.I_re, Complex.I_im, mul_zero, mul_one, sub_zero, add_zero, zero_add]
+  · unfold fitX
+    rw [mul_add, mul_div_cancel₀ _ hℓ]
+    unfold halfHeight at *
+    nlinarith
+  · unfold fitY
+    rw [mul_add, mul_div_cancel₀ _ hℓ]
+    unfold halfHeight at *
+    nlinarith
+
+end SLEExactGauge.Serpentine
+
+end
+
+end OAI

lean/OAI/Probability/SLE/Gauge/SerpentineFittedRegion.lean

@@ -0,0 +1,78 @@
+import OAI.Probability.SLE.Gauge.SerpentineFittedChart
+import OAI.Probability.SLE.Gauge.SerpentineArrayRegion
+
+namespace OAI
+
+/-! The retained integer strips lie in the prescribed displaced disk
+after multiplication by the physical width. -/
+
+noncomputable section
+open Set Metric
+
+namespace SLEExactGauge.Serpentine
+
+def physicalFitChart (s : ℝ) (w : ℂ) (m : ℕ) (z : ℂ) : ℂ :=
+  (ribbonWidth (halfHeight s) m : ℂ) * fitChart s w m z
+
+lemma fitChart_retained_distance {s : ℝ} (hs : 0 < s) (w : ℂ) (hw : s ≤ w.im)
+    {m j i : ℕ} (hm : 0 < m) (hj : j < m) (hi : i < m) {z : ℂ}
+    (hz : z.re ∈ Icc
+      ((retainedStep (connectorEntry (fitHeight m) (fitRadius m) (fitX s w m) (fitY s w m)) m j i : ℝ) + 1 / 3)
+      ((retainedStep (connectorEntry (fitHeight m) (fitRadius m) (fitX s w m) (fitY s w m)) m j i : ℝ) + 2 / 3))
+    (ha : |z.im| ≤ 1) :
+    dist (fitChart s w m z) (arrayCenter m (fitX s w m) (fitY s w m)) ≤ 300 * m := by
+  have hA : 0 ≤ connectorEntry (fitHeight m) (fitRadius m) (fitX s w m) (fitY s w m) :=
+    (by unfold fitHeight; positivity : (0 : ℝ) ≤ fitHeight m).trans (fit_entry_lower hs w hw hm)
+  have hmid := retained_middle_in_straight hA hi hz
+  have he : columnEntry (connectorEntry (fitHeight m) (fitRadius m) (fitX s w m) (fitY s w m)) m j =
+      connectorEntry (fitHeight m) (fitRadius m) (fitX s w m) (fitY s w m) + columnEntry 0 m j := by
+    unfold columnEntry
+    ring
+  rw [he] at hmid
+  have hu : z.re - connectorEntry (fitHeight m) (fitRadius m) (fitX s w m) (fitY s w m) -
+      columnEntry 0 m j ∈ Icc (0 : ℝ) (200 * m) := ⟨by linarith [hmid.1], by linarith [hmid.2]⟩
+  unfold fitChart fitSpine fitTangent
+  rw [retained_strip_on_column hm hj hi _ _ _ _ hA hz, dist_self_add_left]
+  have hb := columnPoint_bound (j := j) (by positivity : (0 : ℝ) < 100 * m) hm (by omega) 0
+      (straight_height_bound m j hu) ha
+  rw [dist_zero_right] at hb
+  linarith
+
+lemma physicalFitChart_retained_distance {s : ℝ} (hs : 0 < s) (w : ℂ) (hw : s ≤ w.im)
+    {m j i : ℕ} (hm : 0 < m) (hj : j < m) (hi : i < m) {z : ℂ}
+    (hz : z.re ∈ Icc
+      ((retainedStep (connectorEntry (fitHeight m) (fitRadius m) (fitX s w m) (fitY s w m)) m j i : ℝ) + 1 / 3)
+      ((retainedStep (connectorEntry (fitHeight m) (fitRadius m) (fitX s w m) (fitY s w m)) m j i : ℝ) + 2 / 3))
+    (ha : |z.im| ≤ 1) :
+    dist (physicalFitChart s w m z) (positiveCenter s w) ≤ 3 * s / 200 := by
+  have hd := fitChart_retained_distance hs w hw hm hj hi hz ha
+  have hℓ := fit_width_pos hs hm
+  have hmul := fit_width_mul hs hm
+  rw [physicalFitChart, ← fit_scaled_arrayCenter hs w hm, dist_eq_norm, ← mul_sub, norm_mul,
+    Complex.norm_real, Real.norm_eq_abs, abs_of_pos hℓ]
+  have h := mul_le_mul_of_nonneg_left hd hℓ.le
+  rw [dist_eq_norm] at h
+  nlinarith
+
+lemma positiveCenter_eq_center {s : ℝ} {w : ℂ} (hw : 0 ≤ w.re) :
+    positiveCenter s w = center s w := by
+  apply Complex.ext <;>
+    simp [positiveCenter, center, displacementSign, hw, abs_of_nonneg hw]
+
+lemma physicalFitChart_retained_disk {s : ℝ} (hs : 0 < s) (w : ℂ) (hw : s ≤ w.im)
+    (hwr : 0 ≤ w.re) {m j i : ℕ} (hm : 0 < m) (hj : j < m) (hi : i < m) {z : ℂ}
+    (hz : z.re ∈ Icc
+      ((retainedStep (connectorEntry (fitHeight m) (fitRadius m) (fitX s w m) (fitY s w m)) m j i : ℝ) + 1 / 3)
+      ((retainedStep (connectorEntry (fitHeight m) (fitRadius m) (fitX s w m) (fitY s w m)) m j i : ℝ) + 2 / 3))
+    (ha : |z.im| ≤ 1) :
+    physicalFitChart s w m z ∈ closedBall (center s w) (s / 20) := by
+  have hd := physicalFitChart_retained_distance hs w hw hm hj hi hz ha
+  rw [positiveCenter_eq_center hwr] at hd
+  change dist _ _ ≤ _
+  linarith
+
+end SLEExactGauge.Serpentine
+
+end
+
+end OAI

lean/OAI/Probability/SLE/Gauge/SerpentineFittedShadow.lean

@@ -0,0 +1,108 @@
+import OAI.Probability.SLE.Gauge.SerpentineFittedRegion
+
+namespace OAI
+
+/-! The complete fitted ribbon avoids a fixed upward shadow of the
+marked point, including the connector and the infinite final tail. -/
+
+noncomputable section
+open Set Metric
+
+namespace SLEExactGauge.Serpentine
+
+lemma fit_width_le {s : ℝ} (hs : 0 < s) {m : ℕ} (hm : 0 < m) :
+    ribbonWidth (halfHeight s) m ≤ s / 20000 := by
+  have hmul := fit_width_mul hs hm
+  have hp := (fit_width_pos hs hm).le
+  have hm' : (1 : ℝ) ≤ m := by exact_mod_cast hm
+  nlinarith
+
+lemma fit_scaledX {s : ℝ} (hs : 0 < s) (w : ℂ) {m : ℕ} (hm : 0 < m) :
+    ribbonWidth (halfHeight s) m * fitX s w m = |w.re| + s / 4 - s / 200 := by
+  unfold fitX halfHeight
+  exact mul_div_cancel₀ _ (fit_width_pos hs hm).ne'
+
+lemma physicalFitChart_low {s : ℝ} (hs : 0 < s) (w : ℂ) (hw : s ≤ w.im)
+    {m : ℕ} (hm : 0 < m) {z : ℂ} (ha : |z.im| ≤ 1)
+    (hz : z.re ≤ connectorFourth (fitHeight m) (fitRadius m) (fitX s w m)) :
+    (physicalFitChart s w m z).im ≤ s / 2 := by
+  obtain ⟨hr, hx, hy, _⟩ := fit_parameters hs w hw hm
+  have hA : z.re ≤ connectorEntry (fitHeight m) (fitRadius m) (fitX s w m) (fitY s w m) := by
+    have hY : fitHeight m + 2 * fitRadius m < fitY s w m := by
+      linarith [Nat.cast_nonneg (α := ℝ) m]
+    unfold connectorEntry
+    linarith
+  have hlow := lowConnector_normal_im_upper (by linarith : 1 < fitRadius m) hx hz ha
+  have hℓ := (fit_width_pos hs hm).le
+  have hmul := fit_width_mul hs hm
+  have hle := fit_width_le hs hm
+  have hscaled := mul_le_mul_of_nonneg_left hlow hℓ
+  change ((ribbonWidth (halfHeight s) m : ℂ) *
+    normalRibbon (completeSpine m _ _ _ _) (completeTangent m _ _ _ _) z).im ≤ _
+  rw [complete_normal_of_le m _ _ _ _ hA]
+  simp only [Complex.mul_im, Complex.ofReal_re, Complex.ofReal_im, zero_mul, add_zero]
+  dsimp only [fitHeight, fitRadius] at hscaled ⊢
+  nlinarith
+
+lemma physicalFitChart_tail_right {s : ℝ} (hs : 0 < s) (w : ℂ) (_hw : s ≤ w.im)
+    {m : ℕ} (hm : 0 < m) {z : ℂ} (ha : |z.im| ≤ 1)
+    (hz : connectorFourth (fitHeight m) (fitRadius m) (fitX s w m) < z.re)
+    (hA : z.re ≤ connectorEntry (fitHeight m) (fitRadius m) (fitX s w m) (fitY s w m)) :
+    s / 5 ≤ (physicalFitChart s w m z).re - |w.re| := by
+  have hℓ := (fit_width_pos hs hm).le
+  have hx := fit_scaledX hs w hm
+  have hle := fit_width_le hs hm
+  have hza := mul_le_mul_of_nonneg_left (abs_le.mp ha).2 hℓ
+  change ((ribbonWidth (halfHeight s) m : ℂ) *
+    normalRibbon (completeSpine m _ _ _ _) (completeTangent m _ _ _ _) z).re - _ ≥ _
+  rw [complete_normal_of_le m _ _ _ _ hA, normalRibbon,
+    (lowConnector_after hz).1, (lowConnector_after hz).2]
+  simp only [connectorTail, Complex.mul_re, Complex.mul_im, Complex.add_re, Complex.add_im,
+    Complex.ofReal_re, Complex.ofReal_im, Complex.I_re, Complex.I_im,
+    mul_zero, zero_mul, mul_one, sub_zero, add_zero, zero_add]
+  nlinarith
+
+lemma physicalFitChart_array_right {s : ℝ} (hs : 0 < s) (w : ℂ)
+    {m : ℕ} (hm : 0 < m) {z : ℂ} (ha : |z.im| ≤ 1)
+    (hA : connectorEntry (fitHeight m) (fitRadius m) (fitX s w m) (fitY s w m) < z.re) :
+    s / 5 ≤ (physicalFitChart s w m z).re - |w.re| := by
+  have hℓ := (fit_width_pos hs hm).le
+  have hmul := fit_width_mul hs hm
+  let A := connectorEntry (fitHeight m) (fitRadius m) (fitX s w m) (fitY s w m)
+  have hz' : 0 ≤ (z - (A : ℂ)).re ∧ |(z - (A : ℂ)).im| ≤ 1 := by
+    simp only [Complex.sub_re, Complex.sub_im, Complex.ofReal_re, Complex.ofReal_im, sub_zero]
+    exact ⟨by dsimp [A]; linarith, ha⟩
+  have hbound := mul_le_mul_of_nonneg_left (array_normal_re_lower hm hz') hℓ
+  have hcenter := congrArg Complex.re (fit_scaled_arrayCenter hs w hm)
+  simp only [Complex.mul_re, Complex.ofReal_re, Complex.ofReal_im, zero_mul, sub_zero,
+    positiveCenter, Complex.add_re, Complex.mul_re, Complex.I_re, Complex.I_im,
+    mul_zero, sub_zero, add_zero] at hcenter
+  change ((ribbonWidth (halfHeight s) m : ℂ) *
+    normalRibbon (completeSpine m _ _ _ _) (completeTangent m _ _ _ _) z).re - _ ≥ _
+  rw [complete_normal_of_gt m _ _ _ _ hA]
+  simp only [Complex.mul_re, Complex.ofReal_re, Complex.ofReal_im, zero_mul, sub_zero,
+    Complex.add_re]
+  dsimp [A] at hbound
+  nlinarith
+
+theorem physicalFitChart_avoids_shadow {s : ℝ} (hs : 0 < s) (w : ℂ) (hw : s ≤ w.im)
+    {m : ℕ} (hm : 0 < m) {z : ℂ} (ha : |z.im| ≤ 1) :
+    ¬ (abs ((physicalFitChart s w m z).re - |w.re|) < s / 100 ∧
+      w.im - s / 100 < (physicalFitChart s w m z).im) := by
+  intro h
+  by_cases h4 : z.re ≤ connectorFourth (fitHeight m) (fitRadius m) (fitX s w m)
+  · have hh := physicalFitChart_low hs w hw hm ha h4
+    linarith [h.2]
+  · by_cases hA : z.re ≤ connectorEntry (fitHeight m) (fitRadius m) (fitX s w m) (fitY s w m)
+    · have hh := physicalFitChart_tail_right hs w hw hm ha (lt_of_not_ge h4) hA
+      have hl := le_abs_self ((physicalFitChart s w m z).re - |w.re|)
+      linarith [h.1]
+    · have hh := physicalFitChart_array_right hs w hm ha (lt_of_not_ge hA)
+      have hl := le_abs_self ((physicalFitChart s w m z).re - |w.re|)
+      linarith [h.1]
+
+end SLEExactGauge.Serpentine
+
+end
+
+end OAI

lean/OAI/Probability/SLE/Gauge/SerpentineHorizontalBound.lean

@@ -0,0 +1,85 @@
+import OAI.Probability.SLE.Gauge.SerpentineExperimentGeometry
+
+namespace OAI
+
+/-! The whole completed physical ribbon stays between the exterior
+vertical lines x=-2 and x=2. -/
+
+noncomputable section
+open Set Metric
+
+namespace SLEExactGauge.Serpentine
+
+lemma array_normal_re_upper {m : ℕ} (hm : 0 < m) {z : ℂ}
+    (hz : 0 ≤ z.re ∧ |z.im| ≤ 1) :
+    (normalRibbon (arraySpine m (2 * m)) (arrayTangent m (2 * m)) z).re ≤ 400 * m := by
+  have hh : (0 : ℝ) < 100 * m := by positivity
+  by_cases he : z.re ≤ arrayEnd m (2 * m)
+  · rcases array_pieces m (2 * m) ⟨hz.1, he⟩ with ⟨i, hi, u, hu, _, hs, hT⟩ |
+      ⟨i, hi, u, hu, _, hs, hT⟩
+    · simp only [normalRibbon]
+      rw [hs, hT, normal_straight_eq hm]
+      have hb := columnPoint_bound hh hm hi 0 (straight_height_bound m i hu) hz.2
+      rw [dist_zero_right] at hb
+      have hi := Complex.re_le_norm (columnPoint 0 (100 * m) m i (side i * (-100 * m + u)) z.im)
+      linarith
+    · simp only [normalRibbon]
+      rw [hs, hT, normal_circular_eq hm]
+      have hb := turnPoint_bound hh hm (show i + 1 ≤ 2 * m by omega) 0 (u / 50) hz.2
+      rw [dist_zero_right] at hb
+      exact (Complex.re_le_norm _).trans (by linarith)
+  · have hE : columnEntry 0 m (2 * m) ≤ z.re := by
+      have h := lt_of_not_ge he
+      dsimp only [arrayEnd] at h
+      linarith [Nat.cast_nonneg (α := ℝ) m]
+    have ht := array_normal_terminal hm (a := z.im) hE
+    rw [Complex.re_add_im z] at ht
+    rw [ht, columnPoint_re]
+    simp only [columnOffset, normalized_spacing hm, normalized_width hm, side_even,
+      one_mul, Complex.zero_re, zero_add, Nat.cast_mul, Nat.cast_ofNat]
+    have hm' : (1 : ℝ) ≤ m := by exact_mod_cast hm
+    linarith [(abs_le.mp hz.2).1]
+
+lemma lowConnector_re_bounds {H r X : ℝ} (hH : 0 ≤ H) (hr : 0 < r) (hX : 2 * r < X)
+    {t : ℝ} (ht : 0 ≤ t) :
+    0 ≤ (lowConnector H r X t).re ∧ (lowConnector H r X t).re ≤ X := by
+  have hmono : Monotone (fun t => (lowConnector H r X t).re) :=
+    monotone_of_hasDerivAt_nonneg
+      (fun t => Complex.reCLM.hasFDerivAt.comp_hasDerivAt t (lowConnector_hasDerivAt hr hX t))
+      (fun t => (lowConnectorTangent_nonneg (H := H) hr hX t).1)
+  have hzero := hmono ht
+  dsimp only at hzero
+  rw [(lowConnector_initial hr hX hH).1] at hzero
+  simp only [Complex.ofReal_zero, zero_mul, Complex.zero_re] at hzero
+  let u := max t (connectorFourth H r X + 1)
+  have hu : connectorFourth H r X < u := by
+    have h := le_max_right t (connectorFourth H r X + 1)
+    dsimp only [u]
+    linarith
+  have hup := hmono (le_max_left t (connectorFourth H r X + 1))
+  dsimp only at hup
+  rw [(lowConnector_after hu).1] at hup
+  have hup' : (lowConnector H r X t).re ≤ X := by
+    simpa only [connectorTail, Complex.add_re, Complex.mul_re, Complex.ofReal_re,
+      Complex.ofReal_im, Complex.I_re, Complex.I_im, mul_zero, zero_mul, sub_zero, add_zero] using hup
+  exact ⟨hzero, hup'⟩
+
+lemma lowConnector_normal_re_bounds {H r X : ℝ} (hH : 0 ≤ H) (hr : 0 < r) (hX : 2 * r < X)
+    {z : ℂ} (hz : 0 ≤ z.re ∧ |z.im| ≤ 1) :
+    -1 ≤ (normalRibbon (lowConnector H r X) (lowConnectorTangent H r X) z).re ∧
+      (normalRibbon (lowConnector H r X) (lowConnectorTangent H r X) z).re ≤ X + 1 := by
+  have hcenter := lowConnector_re_bounds hH hr hX hz.1
+  have hdist : ‖normalRibbon (lowConnector H r X) (lowConnectorTangent H r X) z -
+      lowConnector H r X z.re‖ ≤ 1 := by
+    simp only [normalRibbon, add_sub_cancel_left, norm_mul, Complex.norm_real,
+      Real.norm_eq_abs, Complex.norm_I, lowConnectorTangent_norm, mul_one]
+    exact hz.2
+  have hab := (Complex.abs_re_le_norm _).trans hdist
+  rw [Complex.sub_re, abs_le] at hab
+  constructor <;> linarith
+
+end SLEExactGauge.Serpentine
+
+end
+
+end OAI

lean/OAI/Probability/SLE/Gauge/SerpentineInfiniteArray.lean

@@ -0,0 +1,90 @@
+import OAI.Probability.SLE.Gauge.SerpentineArrayEmbedding
+import OAI.Probability.SLE.Gauge.SerpentineTerminal
+
+namespace OAI
+
+/-! The finite serpentine remains embedded after continuing its last
+column vertically to infinity. -/
+
+noncomputable section
+open Set Metric
+
+namespace SLEExactGauge.Serpentine
+
+lemma array_normal_terminal {m : ℕ} (hm : 0 < m) {t a : ℝ}
+    (ht : columnEntry 0 m (2 * m) ≤ t) :
+    normalRibbon (arraySpine m (2 * m)) (arrayTangent m (2 * m)) (t + a * Complex.I) =
+      columnPoint 0 (100 * m) m (2 * m) (-100 * m + (t - columnEntry 0 m (2 * m))) a := by
+  simp only [normalRibbon, Complex.add_re, Complex.add_im, Complex.ofReal_re,
+    Complex.ofReal_im, Complex.mul_re, Complex.mul_im, Complex.I_re, Complex.I_im,
+    mul_zero, sub_zero, mul_one, zero_add, add_zero]
+  rw [arraySpine_tail m (2 * m) ht, arrayTangent_tail m (2 * m) ht, normal_straight_eq hm,
+    side_even, one_mul]
+
+lemma array_normal_finite_terminal_disjoint {m : ℕ} (hm : 0 < m) {z w : ℂ}
+    (hz : z.re ∈ Icc (0 : ℝ) (arrayEnd m (2 * m)) ∧ |z.im| ≤ 1)
+    (hw : arrayEnd m (2 * m) < w.re) (hwa : |w.im| ≤ 1) :
+    normalRibbon (arraySpine m (2 * m)) (arrayTangent m (2 * m)) z ≠
+      normalRibbon (arraySpine m (2 * m)) (arrayTangent m (2 * m)) w := by
+  intro he
+  have hh : (0 : ℝ) < 100 * m := by positivity
+  have hwe : columnEntry 0 m (2 * m) ≤ w.re := by
+    dsimp only [arrayEnd] at hw
+    linarith [Nat.cast_nonneg (α := ℝ) m]
+  have hwy : 100 * (m : ℝ) < -100 * m + (w.re - columnEntry 0 m (2 * m)) := by
+    dsimp only [arrayEnd] at hw
+    linarith
+  have htw := array_normal_terminal hm (a := w.im) hwe
+  rw [Complex.re_add_im w] at htw
+  rw [htw] at he
+  rcases array_pieces m (2 * m) hz.1 with ⟨i, _, u, hu, _, hs, hT⟩ |
+    ⟨i, hi, u, hu, _, hs, hT⟩
+  · simp only [normalRibbon] at he
+    rw [hs, hT, normal_straight_eq hm] at he
+    have hii := columnPoint_equal_forces_index hh hm 0 _ _ hz.2 hwa he
+    subst i
+    have hy := congrArg Complex.im he
+    simp only [columnPoint_im, side_even, one_mul] at hy
+    have hsmall := (abs_le.mp (straight_height_bound m (2 * m) hu)).2
+    rw [side_even, one_mul] at hsmall
+    linarith
+  · simp only [normalRibbon] at he
+    rw [hs, hT, normal_circular_eq hm] at he
+    exact turnPoint_terminal_column_ne hh hm hi 0 (circular_angle_bound hu) hwy hz.2 hwa he
+
+/-- The complete upward-continued array is embedded on the whole closed
+width-one normal strip. -/
+theorem array_normal_injective_infinite {m : ℕ} (hm : 0 < m) :
+    InjOn (normalRibbon (arraySpine m (2 * m)) (arrayTangent m (2 * m)))
+      {z : ℂ | 0 ≤ z.re ∧ |z.im| ≤ 1} := by
+  intro z hz w hw he
+  by_cases hzE : z.re ≤ arrayEnd m (2 * m)
+  · by_cases hwE : w.re ≤ arrayEnd m (2 * m)
+    · exact array_normal_injective hm (2 * m) ⟨⟨hz.1, hzE⟩, hz.2⟩ ⟨⟨hw.1, hwE⟩, hw.2⟩ he
+    · exact (array_normal_finite_terminal_disjoint hm ⟨⟨hz.1, hzE⟩, hz.2⟩
+        (lt_of_not_ge hwE) hw.2 he).elim
+  · by_cases hwE : w.re ≤ arrayEnd m (2 * m)
+    · exact (array_normal_finite_terminal_disjoint hm ⟨⟨hw.1, hwE⟩, hw.2⟩
+        (lt_of_not_ge hzE) hz.2 he.symm).elim
+    · have hze : columnEntry 0 m (2 * m) ≤ z.re := by
+        have h := lt_of_not_ge hzE
+        dsimp only [arrayEnd] at h
+        linarith [Nat.cast_nonneg (α := ℝ) m]
+      have hwe : columnEntry 0 m (2 * m) ≤ w.re := by
+        have h := lt_of_not_ge hwE
+        dsimp only [arrayEnd] at h
+        linarith [Nat.cast_nonneg (α := ℝ) m]
+      have htz := array_normal_terminal hm (a := z.im) hze
+      have htw := array_normal_terminal hm (a := w.im) hwe
+      rw [Complex.re_add_im z] at htz
+      rw [Complex.re_add_im w] at htw
+      rw [htz, htw] at he
+      have hh : (0 : ℝ) < 100 * m := by positivity
+      obtain ⟨hy, ha⟩ := columnPoint_injective hh hm 0 (2 * m) he
+      exact Complex.ext (by linarith) ha
+
+end SLEExactGauge.Serpentine
+
+end
+
+end OAI

lean/OAI/Probability/SLE/Gauge/SerpentineInitialPrefix.lean

@@ -0,0 +1,149 @@
+import OAI.Probability.SLE.Geometry.FirstHeightSupport
+import OAI.Probability.SLE.Gauge.RibbonGoodPrefix
+import OAI.Probability.SLE.Gauge.SerpentineExperimentGeometry
+
+namespace OAI
+
+/-! A single vertical support event starts every fitted serpentine at
+integer front one. Its probability is independent of the marked point
+and of the multiplicity. -/
+
+noncomputable section
+open Set Filter MeasureTheory ProbabilityTheory Metric
+open scoped Topology NNReal ENNReal unitInterval
+
+namespace SLEExactGauge.Serpentine
+open RibbonCoordinates FirstFrontPassage FirstHeightSupport
+
+def initialRiseStrip (ε : ℝ) : Set ℂ := {z | |z.re| < ε / 4}
+
+def initialRiseTarget : Set ℂ := {z | 1 < z.im}
+
+def InitialRise {Ω : Type*} (γ : Ω → ℝ≥0 → ℂ) (ε : ℝ) : Set Ω :=
+  {ω | ∃ T : ℝ≥0, 0 < T ∧ MapsTo (γ ω) (Icc 0 T) (initialRiseStrip ε) ∧
+    γ ω T ∈ initialRiseTarget}
+
+lemma initialRise_positive {Ω : Type*} [MeasurableSpace Ω] (P : Measure Ω)
+    (γ : Ω → ℝ≥0 → ℂ) (hsupport : PublishedGeometricTubeSupport P γ)
+    {ε : ℝ} (hε : 0 < ε) : 0 < P (InitialRise γ ε) := by
+  apply hsupport _ (verticalPath 4) (verticalPath_injective (by norm_num))
+  · intro t ht
+    change 0 < (verticalPath 4 t).im
+    simp only [verticalPath_apply, Complex.mul_im, Complex.ofReal_re, Complex.ofReal_im,
+      Complex.I_im, Complex.I_re, mul_one, mul_zero, add_zero]
+    have ht0 : 0 < (t : ℝ) := by
+      by_contra hn
+      exact ht (Subtype.ext (le_antisymm (le_of_not_gt hn) t.property.1))
+    linarith
+  · exact isOpen_lt Complex.continuous_re.abs continuous_const
+  · exact isOpen_lt continuous_const Complex.continuous_im
+  · rintro z ⟨t, rfl⟩
+    change |(verticalPath 4 t).re| < ε / 4
+    simpa only [verticalPath_apply, Complex.mul_re, Complex.ofReal_re, Complex.ofReal_im,
+      Complex.I_re, Complex.I_im, mul_zero, zero_mul, sub_zero, abs_zero] using
+      (show (0 : ℝ) < ε / 4 by positivity)
+  · change 1 < (((4 / 2 : ℝ) : ℂ) * Complex.I).im
+    norm_num
+
+lemma initial_prefix_coordinates (γ : ℝ≥0 → ℂ) (P : ℂ → ℂ)
+    {ε : ℝ} (hε : ε ≤ 1)
+    (hP : ∀ z ∈ closedRibbon, z.re ≤ 4 → P z = Complex.I * z)
+    {t : ℝ≥0} (hheight : 0 ≤ (γ t).im ∧ (γ t).im ≤ 1)
+    (hstrip : |(γ t).re| < ε / 4) :
+    ∃ z ∈ closedRibbon, |z.im| ≤ ε / 4 ∧ z.re = (γ t).im ∧ P z = γ t := by
+  let z := -Complex.I * γ t
+  have hzre : z.re = (γ t).im := by simp [z]
+  have hzim : z.im = -(γ t).re := by simp [z]
+  have hz : z ∈ closedRibbon := by
+    change 0 ≤ z.re ∧ |z.im| ≤ 1
+    rw [hzre, hzim, abs_neg]
+    exact ⟨hheight.1, by linarith⟩
+  refine ⟨z, hz, ?_, hzre, ?_⟩
+  · rw [hzim, abs_neg]
+    exact hstrip.le
+  · rw [hP z hz (by rw [hzre]; linarith)]
+    dsimp [z]
+    rw [← mul_assoc]
+    norm_num
+
+theorem initialRise_gives_goodPrefix
+    (γ : ℝ≥0 → ℂ) (hγ : Continuous γ) (hγ0 : γ 0 = 0)
+    (hγH : ∀ t, 0 ≤ (γ t).im)
+    (P : ℂ → ℂ) (g : C(ℂ, ℝ)) (hg : ∀ z ∈ closedRibbon, g (P z) = z.re)
+    {ε : ℝ} (hε : 0 < ε) (hε1 : ε ≤ 1)
+    (hP : ∀ z ∈ closedRibbon, z.re ≤ 4 → P z = Complex.I * z)
+    (hrise : () ∈ InitialRise (fun _ : Unit => γ) ε) :
+    () ∈ GoodRibbonPrefix (fun _ : Unit => γ)
+      (fun _ => firstFrontTime (fun t => g (γ t)) 1) P ε := by
+  obtain ⟨T, _, hstrip, htarget⟩ := hrise
+  obtain ⟨τ, _, _, hτT, hhit, hprior⟩ :=
+    exists_first_height γ hγ hγ0 zero_lt_one htarget
+  have hheight (t : ℝ≥0) (ht : t ≤ τ) : 0 ≤ (γ t).im ∧ (γ t).im ≤ 1 := by
+    refine ⟨hγH t, ?_⟩
+    rcases eq_or_lt_of_le ht with rfl | ht
+    · exact hhit.le
+    · exact (hprior t ht).le
+  have hcoord (t : ℝ≥0) (ht : t ≤ τ) := initial_prefix_coordinates γ P hε1 hP
+    (hheight t ht) (hstrip ⟨bot_le, ht.trans hτT.le⟩)
+  have hgheight (t : ℝ≥0) (ht : t ≤ τ) : g (γ t) = (γ t).im := by
+    obtain ⟨z, hz, _, hzre, he⟩ := hcoord t ht
+    exact (congrArg g he.symm).trans ((hg z hz).trans hzre)
+  have hleast : IsLeast {t : ℝ≥0 | 0 ≤ t ∧ g (γ t) - 1 ∈ ({0} : Set ℝ)} τ := by
+    refine ⟨⟨bot_le, ?_⟩, ?_⟩
+    · simp only [hgheight τ le_rfl, hhit, sub_self, mem_singleton_iff]
+    · intro t ht
+      by_contra hn
+      have htτ : t < τ := lt_of_not_ge hn
+      have he : g (γ t) = 1 := sub_eq_zero.mp ht.2
+      rw [hgheight t htτ.le] at he
+      exact (ne_of_lt (hprior t htτ)) he
+  have hfront : firstFrontTime (fun t => g (γ t)) 1 = (τ : WithTop ℝ≥0) := by
+    unfold firstFrontTime hittingAfter
+    rw [ite_eq_left ⟨τ, hleast.1⟩, hleast.csInf_eq]
+  change firstFrontTime (fun t => g (γ t)) 1 ≠ ⊤ ∧ _
+  rw [hfront]
+  refine ⟨WithTop.coe_ne_top, ?_, ?_⟩
+  · intro t ht
+    obtain ⟨z, hz, hzi, _, he⟩ := hcoord t ht.2
+    exact ⟨z, ⟨hz, hzi.trans (by linarith)⟩, he⟩
+  · obtain ⟨z, hz, hzi, _, he⟩ := hcoord τ le_rfl
+    exact ⟨z, ⟨hz, hzi⟩, he⟩
+
+/-- The same positive lower bound works for every chart which is the
+initial vertical strip, and for every global extension of its progress. -/
+theorem uniform_initial_goodPrefix_probability
+    {Ω : Type*} [MeasurableSpace Ω] (μ : Measure Ω)
+    (κ : ℝ) (γ : Ω → ℝ≥0 → ℂ) (hSLE : IsOrdinaryChordalSLE κ γ μ)
+    (hsupport : PublishedGeometricTubeSupport μ γ)
+    {ε : ℝ} (hε : 0 < ε) (hε1 : ε ≤ 1) :
+    ∃ q : ℝ≥0∞, 0 < q ∧ ∀ P : ℂ → ℂ, ∀ g : C(ℂ, ℝ),
+      (∀ z ∈ closedRibbon, g (P z) = z.re) →
+      (∀ z ∈ closedRibbon, z.re ≤ 4 → P z = Complex.I * z) →
+      q ≤ μ (GoodRibbonPrefix γ (ribbonFrontStop g γ 1) P ε) := by
+  refine ⟨μ (InitialRise γ ε), initialRise_positive μ γ hsupport hε, ?_⟩
+  intro P g hg hP
+  apply measure_mono_ae
+  obtain ⟨_, _, htrace⟩ := hSLE.2
+  filter_upwards [htrace] with ω hω
+  intro hrise
+  obtain ⟨G, F, hw⟩ := hω
+  exact initialRise_gives_goodPrefix (γ ω) hw.1 hw.2.1 hw.2.2.1 P g hg hε hε1 hP hrise
+
+theorem uniform_experiment_initial_goodPrefix_probability
+    {Ω : Type*} [MeasurableSpace Ω] (μ : Measure Ω)
+    (κ : ℝ) (γ : Ω → ℝ≥0 → ℂ) (hSLE : IsOrdinaryChordalSLE κ γ μ)
+    (hsupport : PublishedGeometricTubeSupport μ γ)
+    {ε : ℝ} (hε : 0 < ε) (hε1 : ε ≤ 1) :
+    ∃ q : ℝ≥0∞, 0 < q ∧ ∀ s : ℝ, 0 < s → ∀ w : ℂ, s ≤ w.im →
+      ∀ m : ℕ, 0 < m → ∀ g : C(ℂ, ℝ),
+        (∀ z ∈ closedRibbon, g (experimentChart s w m z) = z.re) →
+        q ≤ μ (GoodRibbonPrefix γ (ribbonFrontStop g γ 1) (experimentChart s w m) ε) := by
+  obtain ⟨q, hq, hp⟩ := uniform_initial_goodPrefix_probability μ κ γ hSLE hsupport hε hε1
+  refine ⟨q, hq, fun s hs w hw m hm g hg => ?_⟩
+  exact hp _ g hg (experimentChart_geometry hs w hw hm).2.2.2.2
+
+end SLEExactGauge.Serpentine
+
+end
+
+end OAI

lean/OAI/Probability/SLE/Gauge/SerpentineLayout.lean

@@ -0,0 +1,326 @@
+import OAI.Probability.SLE.Gauge.RibbonMiddleMass
+import Mathlib.Analysis.SpecialFunctions.Trigonometric.Deriv
+
+namespace OAI
+
+/-! Explicit columns and circular turns for the dense-visit serpentine.
+The array and its normal bands fit in the displaced disk and stay a fixed
+distance from the marked point. -/
+
+noncomputable section
+open Set Filter MeasureTheory Metric
+open scoped Topology NNReal
+
+namespace SLEExactGauge.Serpentine
+
+def side (j : ℕ) : ℝ := if Even j then 1 else -1
+
+lemma side_abs (j : ℕ) : |side j| = 1 := by
+  unfold side
+  split <;> norm_num
+
+lemma side_sq (j : ℕ) : side j ^ 2 = 1 := by
+  unfold side
+  split <;> norm_num
+
+def displacementSign (w : ℂ) : ℝ := if 0 ≤ w.re then 1 else -1
+
+def center (s : ℝ) (w : ℂ) : ℂ := w + ((displacementSign w * (s / 4) : ℝ) : ℂ)
+
+def halfHeight (s : ℝ) : ℝ := s / 200
+
+def spacing (h : ℝ) (m : ℕ) : ℝ := h / m
+
+def turnRadius (h : ℝ) (m : ℕ) : ℝ := h / (2 * m)
+
+def ribbonWidth (h : ℝ) (m : ℕ) : ℝ := h / (100 * m)
+
+def columnOffset (h : ℝ) (m j : ℕ) : ℝ := -h + j * spacing h m
+
+/-- The closed width-one band over one straight pass, in physical scale. -/
+def columnPoint (c : ℂ) (h : ℝ) (m j : ℕ) (y a : ℝ) : ℂ :=
+  c + ((columnOffset h m j - side j * ribbonWidth h m * a : ℝ) : ℂ) +
+    (y : ℂ) * Complex.I
+
+/-- A circular connector, with its actual normal ribbon coordinate `a`.
+The parameter runs from zero to pi, alternating above and below. -/
+def turnPoint (c : ℂ) (h : ℝ) (m j : ℕ) (t a : ℝ) : ℂ :=
+  c + ((columnOffset h m j + turnRadius h m : ℝ) : ℂ) +
+    (side j * h : ℂ) * Complex.I +
+    ((turnRadius h m + side j * ribbonWidth h m * a : ℝ) : ℂ) *
+      ((-Real.cos t : ℝ) + (side j * Real.sin t : ℂ) * Complex.I)
+
+lemma center_dist {s : ℝ} (hs : 0 ≤ s) (w : ℂ) : dist (center s w) w = s / 4 := by
+  rw [center, dist_self_add_left, Complex.norm_real, Real.norm_eq_abs, abs_mul,
+    abs_of_nonneg (div_nonneg hs (by norm_num))]
+  have hh : |displacementSign w| = 1 := by unfold displacementSign; split <;> norm_num
+  rw [hh, one_mul]
+
+lemma center_im (s : ℝ) (w : ℂ) : (center s w).im = w.im := by
+  simp [center]
+
+lemma displaced_disk_inside
+    {s : ℝ} (hs : 0 < s) (w : ℂ) (hw : s ≤ w.im) :
+    closedBall (center s w) (s / 20) ⊆ ball w (w.im / 2) := by
+  intro z hz
+  have hd := (dist_triangle z (center s w) w).trans
+    (add_le_add hz (le_of_eq (center_dist hs.le w)))
+  change dist z w < w.im / 2
+  linarith
+
+lemma displaced_disk_separated
+    {s : ℝ} (hs : 0 < s) (w z : ℂ) (hz : z ∈ closedBall (center s w) (s / 20)) :
+    s / 5 ≤ dist z w := by
+  have hh := dist_triangle (center s w) z w
+  rw [center_dist hs.le w, dist_comm (center s w) z] at hh
+  change dist z (center s w) ≤ s / 20 at hz
+  linarith
+
+lemma spacing_pos {h : ℝ} (hh : 0 < h) {m : ℕ} (hm : 0 < m) : 0 < spacing h m := by
+  exact div_pos hh (by exact_mod_cast hm)
+
+lemma turnRadius_pos {h : ℝ} (hh : 0 < h) {m : ℕ} (hm : 0 < m) : 0 < turnRadius h m := by
+  unfold turnRadius
+  positivity
+
+lemma ribbonWidth_pos {h : ℝ} (hh : 0 < h) {m : ℕ} (hm : 0 < m) : 0 < ribbonWidth h m := by
+  unfold ribbonWidth
+  positivity
+
+lemma spacing_eq_width (h : ℝ) (m : ℕ) : spacing h m = 100 * ribbonWidth h m := by
+  unfold spacing ribbonWidth
+  by_cases hm : m = 0
+  · simp [hm]
+  · have hmr : (m : ℝ) ≠ 0 := by exact_mod_cast hm
+    field_simp
+
+lemma turnRadius_eq_width (h : ℝ) (m : ℕ) : turnRadius h m = 50 * ribbonWidth h m := by
+  unfold turnRadius ribbonWidth
+  by_cases hm : m = 0
+  · simp [hm]
+  · have hmr : (m : ℝ) ≠ 0 := by exact_mod_cast hm
+    field_simp
+    ring
+
+lemma columnOffset_bounds {h : ℝ} (hh : 0 < h) {m j : ℕ} (hm : 0 < m)
+    (hj : j ≤ 2 * m) : |columnOffset h m j| ≤ h := by
+  have hmr : (0 : ℝ) < m := by exact_mod_cast hm
+  have hjr : (j : ℝ) ≤ 2 * m := by exact_mod_cast hj
+  have hj0 : (0 : ℝ) ≤ j := Nat.cast_nonneg j
+  have hq := spacing_pos hh hm
+  have hmul : (j : ℝ) * spacing h m ≤ 2 * h := by
+    unfold spacing
+    rw [← mul_div_assoc]
+    exact (div_le_iff₀ hmr).mpr (by nlinarith)
+  rw [columnOffset]
+  exact abs_le.mpr ⟨by nlinarith [mul_nonneg hj0 hq.le], by linarith⟩
+
+lemma width_le_halfHeight {h : ℝ} (hh : 0 < h) {m : ℕ} (hm : 0 < m) :
+    ribbonWidth h m ≤ h / 100 := by
+  have hmr : (1 : ℝ) ≤ m := by exact_mod_cast hm
+  unfold ribbonWidth
+  apply div_le_div_of_nonneg_left hh.le (by norm_num)
+  nlinarith
+
+lemma radius_le_halfHeight {h : ℝ} (hh : 0 < h) {m : ℕ} (hm : 0 < m) :
+    turnRadius h m ≤ h / 2 := by
+  have hmr : (1 : ℝ) ≤ m := by exact_mod_cast hm
+  unfold turnRadius
+  apply div_le_div_of_nonneg_left hh.le (by norm_num)
+  nlinarith
+
+lemma columnPoint_bound {h : ℝ} (hh : 0 < h) {m j : ℕ} (hm : 0 < m)
+    (hj : j ≤ 2 * m) (c : ℂ) {y a : ℝ} (hy : |y| ≤ h) (ha : |a| ≤ 1) :
+    dist (columnPoint c h m j y a) c ≤ 3 * h := by
+  have ho := columnOffset_bounds hh hm hj
+  have he := width_le_halfHeight hh hm
+  have hwp := (ribbonWidth_pos hh hm).le
+  have hprod : |side j * ribbonWidth h m * a| ≤ ribbonWidth h m := by
+    rw [abs_mul, abs_mul, side_abs, one_mul, abs_of_nonneg hwp]
+    exact mul_le_of_le_one_right hwp ha
+  have hx : |columnOffset h m j - side j * ribbonWidth h m * a| ≤
+      |columnOffset h m j| + |side j * ribbonWidth h m * a| := by
+    simpa only [sub_eq_add_neg, abs_neg] using
+      abs_add_le (columnOffset h m j) (-(side j * ribbonWidth h m * a))
+  have hn := Complex.norm_le_abs_re_add_abs_im
+    (((columnOffset h m j - side j * ribbonWidth h m * a : ℝ) : ℂ) +
+      (y : ℂ) * Complex.I)
+  simp only [Complex.add_re, Complex.ofReal_re, Complex.mul_re, Complex.ofReal_im,
+    Complex.I_re, Complex.I_im, mul_zero, sub_zero, add_zero, Complex.add_im,
+    Complex.mul_im, mul_one, zero_add] at hn
+  rw [columnPoint, add_assoc, dist_self_add_left]
+  linarith
+
+lemma turnPoint_zero (c : ℂ) (h : ℝ) (m j : ℕ) (a : ℝ) :
+    turnPoint c h m j 0 a = columnPoint c h m j (side j * h) a := by
+  apply Complex.ext
+  · simp [turnPoint, columnPoint]
+    ring
+  · simp [turnPoint, columnPoint]
+
+lemma side_succ (j : ℕ) : side (j + 1) = -side j := by
+  by_cases h : Even j <;> simp [side, Nat.even_add_one, h]
+
+lemma turnPoint_pi (c : ℂ) (h : ℝ) (m j : ℕ) (a : ℝ) :
+    turnPoint c h m j Real.pi a = columnPoint c h m (j + 1) (side j * h) a := by
+  have he : spacing h m = 2 * turnRadius h m := by
+    rw [spacing_eq_width, turnRadius_eq_width]
+    ring
+  apply Complex.ext
+  · simp [turnPoint, columnPoint, columnOffset, side_succ, Nat.cast_add, Nat.cast_one]
+    nlinarith
+  · simp [turnPoint, columnPoint, columnOffset, side_succ, Nat.cast_add, Nat.cast_one]
+
+lemma turn_direction_norm (j : ℕ) (t : ℝ) :
+    ‖((-Real.cos t : ℝ) : ℂ) + (side j * Real.sin t : ℂ) * Complex.I‖ = 1 := by
+  apply (sq_eq_sq₀ (norm_nonneg _) zero_le_one).mp
+  rw [Complex.sq_norm, Complex.normSq_apply]
+  simp only [Complex.add_re, Complex.ofReal_re, Complex.mul_re, Complex.ofReal_im,
+    Complex.I_re, Complex.I_im, mul_zero, sub_zero, add_zero, Complex.add_im,
+    Complex.mul_im, mul_one, zero_add]
+  calc
+    _ = Real.cos t ^ 2 + side j ^ 2 * Real.sin t ^ 2 := by ring
+    _ = 1 ^ 2 := by rw [side_sq, one_mul]; nlinarith [Real.sin_sq_add_cos_sq t]
+
+lemma turnPoint_bound {h : ℝ} (hh : 0 < h) {m j : ℕ} (hm : 0 < m)
+    (hj : j + 1 ≤ 2 * m) (c : ℂ) (t : ℝ) {a : ℝ} (ha : |a| ≤ 1) :
+    dist (turnPoint c h m j t a) c ≤ 4 * h := by
+  have ho := columnOffset_bounds hh hm (show j ≤ 2 * m by omega)
+  have hr := radius_le_halfHeight hh hm
+  have hw := width_le_halfHeight hh hm
+  have hrp := (turnRadius_pos hh hm).le
+  have hwp := (ribbonWidth_pos hh hm).le
+  have hprod : |side j * ribbonWidth h m * a| ≤ ribbonWidth h m := by
+    rw [abs_mul, abs_mul, side_abs, one_mul, abs_of_nonneg hwp]
+    exact mul_le_of_le_one_right hwp ha
+  have hadd := abs_add_le (turnRadius h m) (side j * ribbonWidth h m * a)
+  rw [abs_of_nonneg hrp] at hadd
+  have hcen := abs_add_le (columnOffset h m j) (turnRadius h m)
+  rw [abs_of_nonneg hrp] at hcen
+  have hn : ‖((columnOffset h m j + turnRadius h m : ℝ) : ℂ) +
+      (side j * h : ℂ) * Complex.I +
+      ((turnRadius h m + side j * ribbonWidth h m * a : ℝ) : ℂ) *
+        ((-Real.cos t : ℝ) + (side j * Real.sin t : ℂ) * Complex.I)‖ ≤
+      |columnOffset h m j + turnRadius h m| + h +
+        |turnRadius h m + side j * ribbonWidth h m * a| := by
+    calc
+      _ ≤ (‖((columnOffset h m j + turnRadius h m : ℝ) : ℂ)‖ +
+        ‖(side j * h : ℂ) * Complex.I‖) +
+        ‖((turnRadius h m + side j * ribbonWidth h m * a : ℝ) : ℂ) *
+          ((-Real.cos t : ℝ) + (side j * Real.sin t : ℂ) * Complex.I)‖ :=
+        (norm_add_le _ _).trans (add_le_add (norm_add_le _ _) le_rfl)
+      _ = _ := by
+        simp only [norm_mul, Complex.norm_real, Real.norm_eq_abs, Complex.norm_I,
+          mul_one, side_abs, one_mul, abs_of_pos hh, turn_direction_norm]
+  have he : turnPoint c h m j t a - c =
+      ((columnOffset h m j + turnRadius h m : ℝ) : ℂ) +
+      (side j * h : ℂ) * Complex.I +
+      ((turnRadius h m + side j * ribbonWidth h m * a : ℝ) : ℂ) *
+        ((-Real.cos t : ℝ) + (side j * Real.sin t : ℂ) * Complex.I) := by
+    unfold turnPoint
+    ring
+  rw [dist_eq_norm, he]
+  linarith
+
+lemma column_inside_displaced_disk {s : ℝ} (hs : 0 < s) (w : ℂ)
+    {m j : ℕ} (hm : 0 < m) (hj : j ≤ 2 * m) {y a : ℝ}
+    (hy : |y| ≤ halfHeight s) (ha : |a| ≤ 1) :
+    columnPoint (center s w) (halfHeight s) m j y a ∈ closedBall (center s w) (s / 20) := by
+  have hh : 0 < halfHeight s := by unfold halfHeight; positivity
+  have hb := columnPoint_bound hh hm hj (center s w) hy ha
+  change dist _ _ ≤ s / 20
+  dsimp only [halfHeight] at hb ⊢
+  linarith
+
+
+@[simp] lemma columnPoint_re (c : ℂ) (h : ℝ) (m j : ℕ) (y a : ℝ) :
+    (columnPoint c h m j y a).re = c.re + columnOffset h m j - side j * ribbonWidth h m * a := by
+  simp [columnPoint]
+  ring
+
+@[simp] lemma columnPoint_im (c : ℂ) (h : ℝ) (m j : ℕ) (y a : ℝ) :
+    (columnPoint c h m j y a).im = c.im + y := by simp [columnPoint]
+
+lemma column_separation {h : ℝ} (hh : 0 < h) {m i j : ℕ} (hm : 0 < m)
+    (hij : i < j) (c : ℂ) (y y' : ℝ) {a b : ℝ} (ha : |a| ≤ 1) (hb : |b| ≤ 1) :
+    98 * ribbonWidth h m ≤
+      dist (columnPoint c h m i y a) (columnPoint c h m j y' b) := by
+  have hepos := (ribbonWidth_pos hh hm).le
+  have hnoise (n : ℕ) (u : ℝ) (hu : |u| ≤ 1) :
+      |side n * ribbonWidth h m * u| ≤ ribbonWidth h m := by
+    rw [abs_mul, abs_mul, side_abs, one_mul, abs_of_nonneg hepos]
+    exact mul_le_of_le_one_right hepos hu
+  have hai := abs_le.mp (hnoise i a ha)
+  have hbj := abs_le.mp (hnoise j b hb)
+  have hijr : (i : ℝ) + 1 ≤ j := by exact_mod_cast Nat.succ_le_of_lt hij
+  have hmul := mul_le_mul_of_nonneg_right hijr (spacing_pos hh hm).le
+  have hre : 98 * ribbonWidth h m ≤
+      (columnPoint c h m j y' b).re - (columnPoint c h m i y a).re := by
+    simp only [columnPoint_re, columnOffset] at *
+    rw [spacing_eq_width] at hmul ⊢
+    nlinarith
+  calc
+    _ ≤ (columnPoint c h m j y' b).re - (columnPoint c h m i y a).re := hre
+    _ ≤ |(columnPoint c h m j y' b).re - (columnPoint c h m i y a).re| := le_abs_self _
+    _ ≤ dist (columnPoint c h m i y a) (columnPoint c h m j y' b) := by
+      simpa only [dist_eq_norm, Complex.sub_re, abs_sub_comm] using
+        Complex.abs_re_le_norm (columnPoint c h m i y a - columnPoint c h m j y' b)
+
+lemma columnPoint_ne {h : ℝ} (hh : 0 < h) {m i j : ℕ} (hm : 0 < m)
+    (hij : i < j) (c : ℂ) (y y' : ℝ) {a b : ℝ} (ha : |a| ≤ 1) (hb : |b| ≤ 1) :
+    columnPoint c h m i y a ≠ columnPoint c h m j y' b := by
+  intro he
+  have hd := column_separation hh hm hij c y y' ha hb
+  rw [he, dist_self] at hd
+  have hp := ribbonWidth_pos hh hm
+  linarith
+
+
+lemma turn_radial_coefficient_pos {h : ℝ} (hh : 0 < h) {m : ℕ} (hm : 0 < m)
+    (j : ℕ) {a : ℝ} (ha : |a| ≤ 1) :
+    0 < turnRadius h m + side j * ribbonWidth h m * a := by
+  have he := ribbonWidth_pos hh hm
+  have hb : |side j * ribbonWidth h m * a| ≤ ribbonWidth h m := by
+    rw [abs_mul, abs_mul, side_abs, one_mul, abs_of_pos he]
+    exact mul_le_of_le_one_right he.le ha
+  rw [turnRadius_eq_width]
+  linarith [(abs_le.mp hb).1]
+
+/-- Each circular turn, with its full normal band, is embedded. -/
+theorem turnPoint_injective {h : ℝ} (hh : 0 < h) {m : ℕ} (hm : 0 < m)
+    (c : ℂ) (j : ℕ) {t u a b : ℝ} (ht : t ∈ Icc 0 Real.pi)
+    (hu : u ∈ Icc 0 Real.pi) (ha : |a| ≤ 1) (hb : |b| ≤ 1)
+    (he : turnPoint c h m j t a = turnPoint c h m j u b) : t = u ∧ a = b := by
+  let z := c + ((columnOffset h m j + turnRadius h m : ℝ) : ℂ) +
+    (side j * h : ℂ) * Complex.I
+  have hn (v q : ℝ) (hq : |q| ≤ 1) : dist (turnPoint c h m j v q) z =
+      turnRadius h m + side j * ribbonWidth h m * q := by
+    change dist (z + _) z = _
+    rw [dist_self_add_left, norm_mul, Complex.norm_real, Real.norm_eq_abs,
+      turn_direction_norm, mul_one, abs_of_pos (turn_radial_coefficient_pos hh hm j hq)]
+  have hcoef := congrArg (fun w => dist w z) he
+  rw [hn t a ha, hn u b hb] at hcoef
+  have hs : side j ≠ 0 := by
+    intro hz
+    have hn := side_abs j
+    rw [hz, abs_zero] at hn
+    norm_num at hn
+  have hab : a = b := by
+    apply mul_left_cancel₀ (ribbonWidth_pos hh hm).ne'
+    apply mul_left_cancel₀ hs
+    nlinarith [hcoef]
+  subst b
+  have hre := congrArg Complex.re he
+  simp only [turnPoint, Complex.add_re, Complex.ofReal_re, Complex.mul_re,
+    Complex.ofReal_im, Complex.I_re, Complex.I_im, mul_zero, sub_zero,
+    zero_sub, add_zero, Complex.add_im, Complex.mul_im, mul_one, zero_add] at hre
+  have hcos : Real.cos t = Real.cos u := by
+    nlinarith [turn_radial_coefficient_pos hh hm j ha]
+  exact ⟨Real.injOn_cos ht hu hcos, rfl⟩
+
+
+end SLEExactGauge.Serpentine
+
+end
+
+end OAI

lean/OAI/Probability/SLE/Gauge/SerpentineMarkedClearance.lean

@@ -0,0 +1,37 @@
+import OAI.Probability.SLE.Gauge.SerpentineExteriorBounds
+import OAI.Probability.SLE.Gauge.SerpentineMarkedRegion
+import OAI.Probability.SLE.Geometry.MarkedRouteClearance
+
+namespace OAI
+
+/-! Actual fitted ribbon points satisfy the geometric separation
+conditions for the two marked-point exit routes. -/
+
+noncomputable section
+open Set Metric
+
+namespace SLEExactGauge.Serpentine
+open RibbonCoordinates
+
+theorem physicalFitChart_markedRoutes_clearance {s : ℝ} (hs : 0 < s) (hs1 : s ≤ 1)
+    (w : ℂ) (hw : s ≤ w.im) (hw1 : ‖w‖ ≤ 1) (hwr : 0 ≤ w.re)
+    {m : ℕ} (hm : 0 < m) {z : ℂ} (hz : z ∈ closedRibbon)
+    (hheight : (physicalFitChart s w m z).im ≤ 2) (t : ℝ) :
+    s / 20 ≤ dist (markedLeftRoute w (s / 20) t) (physicalFitChart s w m z) ∧
+    s / 20 ≤ dist (markedRightRoute w (s / 20) t) (physicalFitChart s w m z) := by
+  apply markedRoutes_past_clearance (by linarith)
+    ((Complex.re_le_norm w).trans hw1) ((Complex.im_le_norm w).trans hw1)
+    (by positivity) (by linarith)
+    (physicalFitChart_re_bounds hs hs1 w hw hw1 hm hz) hheight
+  rcases physicalFitChart_low_or_right hs w hw hm hz.2 with hlo | hright
+  · left
+    linarith
+  · right
+    rw [abs_of_nonneg hwr] at hright
+    linarith
+
+end SLEExactGauge.Serpentine
+
+end
+
+end OAI

lean/OAI/Probability/SLE/Gauge/SerpentineMarkedGuide.lean

@@ -0,0 +1,125 @@
+import OAI.Probability.SLE.Gauge.SerpentineFiniteHeight
+import OAI.Probability.SLE.Geometry.MarkedHookLocal
+
+namespace OAI
+
+/-! The explicit complete physical access guide from the final ribbon
+tip, through the marked point, and then vertically to infinity. -/
+
+noncomputable section
+open Set Filter Metric
+open scoped Topology NNReal
+
+namespace SLEExactGauge.Serpentine
+open RibbonCoordinates
+
+def terminalAccess (s : ℝ) (w : ℂ) (m : ℕ) (x : ℝ) (t : ℝ) : ℂ :=
+  physicalFitChart s w m (guideCoordinate (fitCompletion s w m) x t)
+
+def completeMarkedAccess (s : ℝ) (w : ℂ) (m : ℕ) (x : ℝ) : ℝ → ℂ :=
+  appendMarkedHook (terminalAccess s w m x) (fitHighTime s w m) w
+    (fitTerminalX s w) 2 (s / 20)
+
+lemma terminalAccess_continuous {s : ℝ} (hs : 0 < s) (w : ℂ) (hw : s ≤ w.im)
+    {m : ℕ} (hm : 0 < m) (x : ℝ) : Continuous (terminalAccess s w m x) := by
+  have hp : Continuous (physicalFitChart s w m) :=
+    continuous_const.mul (fitChart_continuous hs w hw hm)
+  exact hp.comp (guideCoordinate_continuous _ _)
+
+lemma terminalAccess_right {s : ℝ} (hs : 0 < s) (w : ℂ) (hw : s ≤ w.im)
+    (hwr : 0 ≤ w.re) {m : ℕ} (hm : 0 < m) {x t : ℝ} (hx : |x| ≤ 1) (ht : 0 ≤ t) :
+    w.re + s / 5 ≤ (terminalAccess s w m x t).re := by
+  have hc := (fitCompletion_bounds hs w hw hm).1
+  have hentry : 0 ≤ columnEntry 0 m (2 * m) := columnEntry_nonneg le_rfl _ _
+  have hmr : (1 : ℝ) ≤ m := by exact_mod_cast hm
+  have hA : fitEntry s w m < (guideCoordinate (fitCompletion s w m) x t).re := by
+    rw [guideCoordinate_re]
+    linarith
+  have him := (guideCoordinate_im_bound (k := (fitCompletion s w m : ℝ)) (x := x) ht).trans hx
+  have hh := physicalFitChart_array_right hs w hm him hA
+  rw [abs_of_nonneg hwr] at hh
+  exact by dsimp [terminalAccess]; linarith
+
+lemma completeMarkedAccess_continuous {s : ℝ} (hs : 0 < s) (hs1 : s ≤ 1)
+    (w : ℂ) (hw : s ≤ w.im) (hw1 : ‖w‖ ≤ 1) (hwr : 0 ≤ w.re)
+    {m : ℕ} (hm : 0 < m) (x : ℝ) : Continuous (completeMarkedAccess s w m x) := by
+  have hwi := (Complex.im_le_norm w).trans hw1
+  apply appendMarkedHook_continuous _ (terminalAccess_continuous hs w hw hm x)
+  · unfold fitTerminalX
+    rw [abs_of_nonneg hwr]
+    linarith
+  · linarith
+  · positivity
+  · exact physicalFitChart_terminal_guide_endpoint hs hs1 w hw hw1 hm x
+
+lemma completeMarkedAccess_injective {s : ℝ} (hs : 0 < s) (hs1 : s ≤ 1)
+    (w : ℂ) (hw : s ≤ w.im) (hw1 : ‖w‖ ≤ 1) (hwr : 0 ≤ w.re)
+    {m : ℕ} (hm : 0 < m) {x : ℝ} (hx : |x| ≤ 1) :
+    InjOn (completeMarkedAccess s w m x) (Ici 0) := by
+  have hT := fitHighTime_large hs hs1 w hw hw1 hm
+  have hwi := (Complex.im_le_norm w).trans hw1
+  have hR : w.re < fitTerminalX s w := by
+    unfold fitTerminalX
+    rw [abs_of_nonneg hwr]
+    linarith
+  apply appendMarkedHook_injective _ (by linarith)
+    ((physicalFitChart_terminal_guide_injective hs w hw hm x).mono Icc_subset_Ici_self)
+    w hR (show w.im < (2 : ℝ) by linarith) (by positivity)
+    (physicalFitChart_terminal_guide_endpoint hs hs1 w hw hw1 hm x)
+  intro t ht
+  refine ⟨physicalFitChart_terminal_guide_strict_height hs w hw hm x ht, Or.inr ?_⟩
+  have hr := terminalAccess_right hs w hw hwr hm hx ht.1
+  dsimp only [terminalAccess] at hr
+  linarith
+
+lemma completeMarkedAccess_zero {s : ℝ} (hs : 0 < s) (hs1 : s ≤ 1)
+    (w : ℂ) (hw : s ≤ w.im) (hw1 : ‖w‖ ≤ 1) {m : ℕ} (hm : 0 < m) (x : ℝ) :
+    completeMarkedAccess s w m x 0 = physicalFitChart s w m ((fitCompletion s w m : ℂ) + (x : ℂ) * Complex.I) := by
+  have hT := fitHighTime_large hs hs1 w hw hw1 hm
+  rw [completeMarkedAccess, appendMarkedHook, curveJoin_of_le (by linarith)]
+  simp [terminalAccess, guideCoordinate]
+
+lemma completeMarkedAccess_hits_marked {s : ℝ} (hs : 0 < s) (hs1 : s ≤ 1)
+    (w : ℂ) (hw : s ≤ w.im) (hw1 : ‖w‖ ≤ 1) (hwr : 0 ≤ w.re)
+    {m : ℕ} (hm : 0 < m) (x : ℝ) :
+    ∃ t : ℝ, 0 < t ∧ completeMarkedAccess s w m x t = w := by
+  have hT := fitHighTime_large hs hs1 w hw hw1 hm
+  have hwi := (Complex.im_le_norm w).trans hw1
+  have hR : w.re < fitTerminalX s w := by
+    unfold fitTerminalX
+    rw [abs_of_nonneg hwr]
+    linarith
+  refine ⟨fitHighTime s w m + ((fitTerminalX s w - w.re) + (2 - w.im)), by linarith, ?_⟩
+  exact appendMarkedHook_passes_marked _ _ w hR (by linarith)
+
+lemma completeMarkedAccess_norm_tendsto {s : ℝ} (hs : 0 < s)
+    (w : ℂ) (hw1 : ‖w‖ ≤ 1) (hwr : 0 ≤ w.re) (m : ℕ) (x : ℝ) :
+    Tendsto (fun t : ℝ => ‖completeMarkedAccess s w m x t‖) atTop atTop := by
+  have hwi : w.im < 2 := lt_of_le_of_lt ((Complex.im_le_norm w).trans hw1) (by norm_num)
+  have hR : w.re < fitTerminalX s w := by
+    unfold fitTerminalX
+    rw [abs_of_nonneg hwr]
+    linarith
+  let D := fitHighTime s w m + ((fitTerminalX s w - w.re) + (2 - w.im) + s / 20)
+  have hlin : Tendsto (fun t : ℝ => t - D + w.im) atTop atTop := by
+    simpa only [sub_eq_add_neg, add_assoc, id_eq] using
+      tendsto_atTop_add_const_right atTop (-D + w.im) tendsto_id
+  have him : Tendsto (fun t : ℝ => (completeMarkedAccess s w m x t).im) atTop atTop := by
+    apply hlin.congr'
+    filter_upwards [eventually_ge_atTop (D + 1)] with t ht
+    have ht' : fitHighTime s w m < t := by dsimp only [D] at ht; linarith
+    have hc : (fitTerminalX s w - w.re) + (2 - w.im) + s / 20 <
+        t - fitHighTime s w m := by dsimp only [D] at ht; linarith
+    rw [completeMarkedAccess, appendMarkedHook, curveJoin_of_gt ht',
+      markedHook_tail w hwi (by positivity) hc]
+    simp only [hookUp, Complex.add_im, Complex.mul_im, Complex.ofReal_re,
+      Complex.ofReal_im, Complex.I_re, Complex.I_im, mul_one, mul_zero, zero_add]
+    dsimp only [D]
+    ring
+  exact tendsto_atTop_mono (fun t => Complex.im_le_norm _) him
+
+end SLEExactGauge.Serpentine
+
+end
+
+end OAI

lean/OAI/Probability/SLE/Gauge/SerpentineMarkedLocal.lean

@@ -0,0 +1,104 @@
+import OAI.Probability.SLE.Gauge.SerpentineMarkedGuide
+
+namespace OAI
+
+/-! The explicit marked access guide meets a small corner-chart disk
+exactly along its real diameter. The distant terminal prefix is excluded
+quantitatively, so there are no nonlocal intersections. -/
+
+noncomputable section
+open Set Metric
+open scoped Topology NNReal
+
+namespace SLEExactGauge.Serpentine
+open RibbonCoordinates
+
+lemma terminalAccess_distance {s : ℝ} (hs : 0 < s) (w : ℂ) (hw : s ≤ w.im)
+    (hwr : 0 ≤ w.re) {m : ℕ} (hm : 0 < m) {x t : ℝ} (hx : |x| ≤ 1) (ht : 0 ≤ t) :
+    s / 5 ≤ dist (terminalAccess s w m x t) w := by
+  have hr := terminalAccess_right hs w hw hwr hm hx ht
+  have hb := Complex.abs_re_le_norm (terminalAccess s w m x t - w)
+  rw [Complex.sub_re, ← dist_eq_norm] at hb
+  linarith [le_abs_self ((terminalAccess s w m x t).re - w.re)]
+
+theorem completeMarkedAccess_corner_iff {s : ℝ} (hs : 0 < s) (hs1 : s ≤ 1)
+    (w : ℂ) (hw : s ≤ w.im) (hw1 : ‖w‖ ≤ 1) (hwr : 0 ≤ w.re)
+    {m : ℕ} (hm : 0 < m) {x : ℝ} (hx : |x| ≤ 1) {z : ℂ}
+    (hz : z ∈ ball (0 : ℂ) ((s / 20) / 12)) :
+    (∃ t : ℝ, 0 < t ∧ completeMarkedAccess s w m x t = markedCornerChart w z) ↔ z.im = 0 := by
+  have hn : ‖z‖ < (s / 20) / 12 := by simpa only [mem_ball, dist_zero_right] using hz
+  have hwi : w.im ≤ 1 := (Complex.im_le_norm w).trans hw1
+  have hR : w.re < fitTerminalX s w := by
+    unfold fitTerminalX
+    rw [abs_of_nonneg hwr]
+    linarith
+  have hT := fitHighTime_large hs hs1 w hw hw1 hm
+  have hcorner := markedHook_small_corner_iff (w := w) (z := z) hR
+    (show w.im < 2 by linarith) (show 0 < s / 20 by positivity)
+    (show 0 < (s / 20) / 12 by positivity)
+    (show 3 * ((s / 20) / 12) < 2 - w.im by linarith)
+    (show 3 * ((s / 20) / 12) < s / 20 by linarith) hn
+  constructor
+  · rintro ⟨t, ht, he⟩
+    by_cases htT : t ≤ fitHighTime s w m
+    · rw [completeMarkedAccess, appendMarkedHook, curveJoin_of_le htT] at he
+      have hd := terminalAccess_distance hs w hw hwr hm hx ht.le
+      rw [he] at hd
+      have hb := markedCornerChart_norm w z
+      linarith
+    · rw [completeMarkedAccess, appendMarkedHook, curveJoin_of_gt (lt_of_not_ge htT)] at he
+      exact hcorner.mp ⟨t - fitHighTime s w m, by linarith, he⟩
+  · intro him
+    obtain ⟨u, hu, he⟩ := hcorner.mpr him
+    refine ⟨fitHighTime s w m + u, by linarith, ?_⟩
+    by_cases hu0 : u = 0
+    · subst u
+      rw [add_zero, completeMarkedAccess, appendMarkedHook, curveJoin_of_le le_rfl]
+      change physicalFitChart s w m (guideCoordinate (fitCompletion s w m) x (fitHighTime s w m)) = _
+      rw [physicalFitChart_terminal_guide_endpoint hs hs1 w hw hw1 hm x]
+      simpa [markedHook_zero w hR] using he
+    · have hup : 0 < u := lt_of_le_of_ne hu (Ne.symm hu0)
+      rw [completeMarkedAccess, appendMarkedHook, curveJoin_of_gt (by linarith), add_sub_cancel_left]
+      exact he
+
+theorem completeMarkedAccess_corner_nnreal_iff {s : ℝ} (hs : 0 < s) (hs1 : s ≤ 1)
+    (w : ℂ) (hw : s ≤ w.im) (hw1 : ‖w‖ ≤ 1) (hwr : 0 ≤ w.re)
+    {m : ℕ} (hm : 0 < m) {x : ℝ} (hx : |x| ≤ 1) {z : ℂ}
+    (hz : z ∈ ball (0 : ℂ) ((s / 20) / 12)) :
+    (∃ t : ℝ≥0, 0 < t ∧ completeMarkedAccess s w m x t = markedCornerChart w z) ↔ z.im = 0 := by
+  rw [← completeMarkedAccess_corner_iff hs hs1 w hw hw1 hwr hm hx hz]
+  constructor
+  · rintro ⟨t, ht, he⟩
+    exact ⟨t, by exact_mod_cast ht, he⟩
+  · rintro ⟨t, ht, he⟩
+    exact ⟨⟨t, ht.le⟩, by exact_mod_cast ht, he⟩
+
+lemma completeMarkedAccess_upper {s : ℝ} (hs : 0 < s)
+    (w : ℂ) (hw : s ≤ w.im) (hw1 : ‖w‖ ≤ 1) (hwr : 0 ≤ w.re)
+    {m : ℕ} (hm : 0 < m) {x u : ℝ} (hu : 0 ≤ u) :
+    completeMarkedAccess s w m x u ∈ upperHalfPlane := by
+  have hwi := (Complex.im_le_norm w).trans hw1
+  change 0 < (completeMarkedAccess s w m x u).im
+  by_cases huT : u ≤ fitHighTime s w m
+  · rw [completeMarkedAccess, appendMarkedHook, curveJoin_of_le huT]
+    change 0 < (physicalFitChart s w m (guideCoordinate (fitCompletion s w m) x u)).im
+    rw [physicalFitChart_terminal_guide hs w hw hm x hu]
+    simp only [Complex.add_im, Complex.ofReal_im, Complex.mul_im, Complex.ofReal_re,
+      Complex.I_re, Complex.I_im, mul_one, mul_zero, add_zero, zero_add]
+    have hb := (fitTerminalHeight_bounds hs w hw hm).1
+    have hp := mul_nonneg (fit_width_pos hs hm).le hu
+    linarith
+  · rw [completeMarkedAccess, appendMarkedHook, curveJoin_of_gt (lt_of_not_ge huT)]
+    have hR : w.re < fitTerminalX s w := by
+      unfold fitTerminalX
+      rw [abs_of_nonneg hwr]
+      linarith
+    have hh := markedHook_im_lower hR (show w.im < 2 by linarith)
+      (show 0 < s / 20 by positivity) (show 0 ≤ u - fitHighTime s w m by linarith)
+    linarith
+
+end SLEExactGauge.Serpentine
+
+end
+
+end OAI

lean/OAI/Probability/SLE/Gauge/SerpentineMarkedReflection.lean

@@ -0,0 +1,129 @@
+import OAI.Probability.SLE.Gauge.SerpentineMarkedRouteClearance
+import OAI.Probability.SLE.Gauge.RibbonGoodPrefix
+
+namespace OAI
+
+/-! Reflection of the concrete experiment and its actual narrow-prefix
+certificate. It reduces a marked point on the left to the right-hand layout. -/
+
+noncomputable section
+open Set Metric ComplexConjugate
+open scoped Topology NNReal
+
+namespace SLEExactGauge.Serpentine
+open RibbonCoordinates
+
+@[simp] lemma fitX_mirror (s : ℝ) (w : ℂ) (m : ℕ) :
+    fitX s (loewnerMirror w) m = fitX s w m := by simp [fitX]
+
+@[simp] lemma fitY_mirror (s : ℝ) (w : ℂ) (m : ℕ) :
+    fitY s (loewnerMirror w) m = fitY s w m := by simp [fitY]
+
+@[simp] lemma fitChart_mirror (s : ℝ) (w : ℂ) (m : ℕ) (z : ℂ) :
+    fitChart s (loewnerMirror w) m z = fitChart s w m z := by
+  simp only [fitChart, fitSpine, fitTangent, fitX_mirror, fitY_mirror]
+
+@[simp] lemma physicalFitChart_mirror (s : ℝ) (w : ℂ) (m : ℕ) (z : ℂ) :
+    physicalFitChart s (loewnerMirror w) m z = physicalFitChart s w m z := by
+  simp only [physicalFitChart, fitChart_mirror]
+
+@[simp] lemma fitEntry_mirror (s : ℝ) (w : ℂ) (m : ℕ) :
+    fitEntry s (loewnerMirror w) m = fitEntry s w m := by
+  simp only [fitEntry, fitX_mirror, fitY_mirror]
+
+@[simp] lemma fitCompletion_mirror (s : ℝ) (w : ℂ) (m : ℕ) :
+    fitCompletion s (loewnerMirror w) m = fitCompletion s w m := by
+  simp only [fitCompletion, fitEntry_mirror]
+
+@[simp] lemma fitTerminalX_mirror (s : ℝ) (w : ℂ) :
+    fitTerminalX s (loewnerMirror w) = fitTerminalX s w := by simp [fitTerminalX]
+
+@[simp] lemma fitTerminalHeight_mirror (s : ℝ) (w : ℂ) (m : ℕ) :
+    fitTerminalHeight s (loewnerMirror w) m = fitTerminalHeight s w m := by
+  simp only [fitTerminalHeight, fitY_mirror, fitCompletion_mirror, fitEntry_mirror]
+
+@[simp] lemma fitHighTime_mirror (s : ℝ) (w : ℂ) (m : ℕ) :
+    fitHighTime s (loewnerMirror w) m = fitHighTime s w m := by
+  simp only [fitHighTime, fitTerminalHeight_mirror]
+
+lemma physicalExperimentChart_negative {s : ℝ} {w : ℂ} (hw : w.re < 0) (m : ℕ) :
+    physicalExperimentChart s w m = reflectedChart (physicalFitChart s (loewnerMirror w) m) := by
+  funext z
+  simp only [physicalExperimentChart, ite_eq_right (not_le_of_gt hw), reflectedChart,
+    physicalFitChart_mirror]
+
+lemma experimentChart_negative {s : ℝ} {w : ℂ} (hw : w.re < 0) (m : ℕ) :
+    experimentChart s w m = reflectedChart (fitChart s (loewnerMirror w) m) := by
+  funext z
+  simp only [experimentChart, ite_eq_right (not_le_of_gt hw), reflectedChart, fitChart_mirror]
+
+lemma ribbonCore_reflected_iff (P : ℂ → ℂ) (ε : ℝ) (z : ℂ) :
+    z ∈ ribbonCore (reflectedChart P) ε ↔ loewnerMirror z ∈ ribbonCore P ε := by
+  constructor
+  · rintro ⟨u, ⟨hu, hε⟩, he⟩
+    refine ⟨conj u, ⟨conj_mem_closedRibbon hu, ?_⟩, ?_⟩
+    · simpa only [Complex.conj_im, abs_neg] using hε
+    · rw [← he]
+      simp only [reflectedChart, loewnerMirror_twice]
+  · rintro ⟨u, ⟨hu, hε⟩, he⟩
+    refine ⟨conj u, ⟨conj_mem_closedRibbon hu, ?_⟩, ?_⟩
+    · simpa only [Complex.conj_im, abs_neg] using hε
+    · simpa only [reflectedChart, Complex.conj_conj, loewnerMirror_twice] using
+        congrArg loewnerMirror he
+
+lemma goodRibbonPrefix_reflected {Ω : Type*} (γ : Ω → ℝ≥0 → ℂ)
+    (τ : Ω → WithTop ℝ≥0) (P : ℂ → ℂ) (ε : ℝ) :
+    GoodRibbonPrefix γ τ (reflectedChart P) ε =
+      GoodRibbonPrefix (fun ω t => loewnerMirror (γ ω t)) τ P ε := by
+  ext ω
+  change (_ ∧ _ ∧ _) ↔ (_ ∧ _ ∧ _)
+  constructor
+  · rintro ⟨hτ, hp, he⟩
+    exact ⟨hτ, fun t ht => (ribbonCore_reflected_iff P ε _).mp (hp ht),
+      (ribbonCore_reflected_iff P (ε / 4) _).mp he⟩
+  · rintro ⟨hτ, hp, he⟩
+    exact ⟨hτ, fun t ht => (ribbonCore_reflected_iff P ε _).mpr (hp ht),
+      (ribbonCore_reflected_iff P (ε / 4) _).mpr he⟩
+
+lemma goodRibbonPrefix_physical_negative {Ω : Type*} (γ : Ω → ℝ≥0 → ℂ)
+    (τ : Ω → WithTop ℝ≥0) {s : ℝ} {w : ℂ} (hw : w.re < 0) (m : ℕ) (ε : ℝ) :
+    GoodRibbonPrefix γ τ (physicalExperimentChart s w m) ε =
+      GoodRibbonPrefix (fun ω t => loewnerMirror (γ ω t)) τ
+        (physicalFitChart s (loewnerMirror w) m) ε := by
+  rw [physicalExperimentChart_negative hw m]
+  exact goodRibbonPrefix_reflected γ τ _ ε
+
+lemma physicalExperimentChart_reflect_point {s : ℝ} {w : ℂ} (hw : w.re < 0)
+    (m : ℕ) (z : ℂ) :
+    loewnerMirror (physicalExperimentChart s w m z) =
+      physicalFitChart s (loewnerMirror w) m (conj z) := by
+  rw [physicalExperimentChart_negative hw m]
+  simp only [reflectedChart, loewnerMirror_twice]
+
+def mirroredProgress (g : C(ℂ, ℝ)) : C(ℂ, ℝ) :=
+  ⟨fun z => g (loewnerMirror z), g.continuous.comp loewnerMirror.continuous⟩
+
+lemma mirroredProgress_trace (g : C(ℂ, ℝ)) (γ : ℝ≥0 → ℂ) (t : ℝ≥0) :
+    mirroredProgress g ((loewnerMirror ∘ γ) t) = g (γ t) := by
+  simp [mirroredProgress]
+
+lemma mirroredProgress_chart (g : C(ℂ, ℝ)) (P : ℂ → ℂ)
+    (hg : ∀ z ∈ closedRibbon, g (P z) = z.re) :
+    ∀ z ∈ closedRibbon, mirroredProgress g (reflectedChart P z) = z.re := by
+  intro z hz
+  change g (loewnerMirror (loewnerMirror (P (conj z)))) = z.re
+  rw [loewnerMirror_twice]
+  simpa only [Complex.conj_re] using hg (conj z) (conj_mem_closedRibbon hz)
+
+lemma mirroredProgress_firstFrontTime (g : C(ℂ, ℝ)) (γ : ℝ≥0 → ℂ) (k : ℝ) :
+    FirstFrontPassage.firstFrontTime (fun t => mirroredProgress g ((loewnerMirror ∘ γ) t)) k =
+      FirstFrontPassage.firstFrontTime (fun t => g (γ t)) k := by
+  congr 1
+  funext t
+  exact mirroredProgress_trace g γ t
+
+end SLEExactGauge.Serpentine
+
+end
+
+end OAI

lean/OAI/Probability/SLE/Gauge/SerpentineMarkedRegion.lean

@@ -0,0 +1,56 @@
+import OAI.Probability.SLE.Gauge.SerpentineFittedShadow
+
+namespace OAI
+
+/-! The connector lies below the marked point, and every later part of
+the rightward serpentine lies strictly to its right. This is the geometric
+separation used to append the marked-point access hook. -/
+
+noncomputable section
+open Set Metric
+
+namespace SLEExactGauge.Serpentine
+
+theorem physicalFitChart_low_or_right {s : ℝ} (hs : 0 < s) (w : ℂ) (hw : s ≤ w.im)
+    {m : ℕ} (hm : 0 < m) {z : ℂ} (ha : |z.im| ≤ 1) :
+    (physicalFitChart s w m z).im ≤ s / 2 ∨
+      |w.re| + s / 5 ≤ (physicalFitChart s w m z).re := by
+  by_cases h4 : z.re ≤ connectorFourth (fitHeight m) (fitRadius m) (fitX s w m)
+  · exact Or.inl (physicalFitChart_low hs w hw hm ha h4)
+  · right
+    by_cases hA : z.re ≤ connectorEntry (fitHeight m) (fitRadius m) (fitX s w m) (fitY s w m)
+    · have hh := physicalFitChart_tail_right hs w hw hm ha (lt_of_not_ge h4) hA
+      linarith
+    · have hh := physicalFitChart_array_right hs w hm ha (lt_of_not_ge hA)
+      linarith
+
+theorem physicalFitChart_marked_distance {s : ℝ} (hs : 0 < s) (w : ℂ) (hw : s ≤ w.im)
+    (hwr : 0 ≤ w.re) {m : ℕ} (hm : 0 < m) {z : ℂ} (ha : |z.im| ≤ 1) :
+    s / 5 ≤ dist (physicalFitChart s w m z) w := by
+  rw [dist_eq_norm]
+  rcases physicalFitChart_low_or_right hs w hw hm ha with hlow | hright
+  · have hh := Complex.abs_im_le_norm (physicalFitChart s w m z - w)
+    rw [Complex.sub_im] at hh
+    have hl := neg_le_abs ((physicalFitChart s w m z).im - w.im)
+    linarith
+  · rw [abs_of_nonneg hwr] at hright
+    have hh := Complex.abs_re_le_norm (physicalFitChart s w m z - w)
+    rw [Complex.sub_re] at hh
+    have hl := le_abs_self ((physicalFitChart s w m z).re - w.re)
+    linarith
+
+theorem physicalFitChart_hook_region {s : ℝ} (hs : 0 < s) (w : ℂ) (hw : s ≤ w.im)
+    (hwr : 0 ≤ w.re) {m : ℕ} (hm : 0 < m) {z : ℂ} (ha : |z.im| ≤ 1) :
+    (physicalFitChart s w m z).im < w.im ∨ w.re < (physicalFitChart s w m z).re := by
+  rcases physicalFitChart_low_or_right hs w hw hm ha with hh | hh
+  · left
+    linarith
+  · right
+    rw [abs_of_nonneg hwr] at hh
+    linarith
+
+end SLEExactGauge.Serpentine
+
+end
+
+end OAI

lean/OAI/Probability/SLE/Gauge/SerpentineMarkedRouteClearance.lean

@@ -0,0 +1,63 @@
+import OAI.Probability.SLE.Gauge.SerpentineMarkedLocal
+import OAI.Probability.SLE.Geometry.MarkedRouteEarlyClearance
+
+namespace OAI
+
+/-! The two exit routes avoid every point of the complete marked access
+guide by one uniform margin, including its distant initial prefix. -/
+
+noncomputable section
+open Set Metric
+
+namespace SLEExactGauge.Serpentine
+open RibbonCoordinates
+
+lemma terminalAccess_bounds {s : ℝ} (hs : 0 < s) (hs1 : s ≤ 1)
+    (w : ℂ) (hw : s ≤ w.im) (hw1 : ‖w‖ ≤ 1) (hwr : 0 ≤ w.re)
+    {m : ℕ} (hm : 0 < m) {x u : ℝ} (hx : |x| ≤ 1)
+    (hu : u ∈ Icc (0 : ℝ) (fitHighTime s w m)) :
+    -2 ≤ (terminalAccess s w m x u).re ∧ (terminalAccess s w m x u).re ≤ 2 ∧
+    (terminalAccess s w m x u).im ≤ 2 ∧ w.re + s / 5 ≤ (terminalAccess s w m x u).re := by
+  have hz : guideCoordinate (fitCompletion s w m) x u ∈ closedRibbon := by
+    refine ⟨?_, (guideCoordinate_im_bound hu.1).trans hx⟩
+    rw [guideCoordinate_re]
+    exact add_nonneg (Nat.cast_nonneg _) hu.1
+  have hre := physicalFitChart_re_bounds hs hs1 w hw hw1 hm hz
+  exact ⟨hre.1, hre.2, physicalFitChart_terminal_guide_height hs w hw hm x hu,
+    terminalAccess_right hs w hw hwr hm hx hu.1⟩
+
+/-- A margin independent of the number of serpentine columns. -/
+theorem completeMarkedAccess_route_clearance {s : ℝ} (hs : 0 < s) (hs1 : s ≤ 1)
+    (w : ℂ) (hw : s ≤ w.im) (hw1 : ‖w‖ ≤ 1) (hwr : 0 ≤ w.re)
+    {m : ℕ} (hm : 0 < m) {x t u : ℝ} (hx : |x| ≤ 1) (ht : 1 / 64 ≤ t) (hu : 0 ≤ u) :
+    (s / 20) / 1000 ≤ dist (markedLeftRoute w (s / 20) t) (completeMarkedAccess s w m x u) ∧
+    (s / 20) / 1000 ≤ dist (markedRightRoute w (s / 20) t) (completeMarkedAccess s w m x u) := by
+  have hwr1 := (Complex.re_le_norm w).trans hw1
+  have hwi1 := (Complex.im_le_norm w).trans hw1
+  have ha : 0 < s / 20 := by positivity
+  have ha1 : s / 20 ≤ 1 := by linarith
+  by_cases huT : u ≤ fitHighTime s w m
+  · rw [completeMarkedAccess, appendMarkedHook, curveJoin_of_le huT]
+    have hb := terminalAccess_bounds hs hs1 w hw hw1 hwr hm hx ⟨hu, huT⟩
+    have hq : w.re + 2 * (s / 20) ≤ (terminalAccess s w m x u).re := by linarith [hb.2.2.2]
+    have hh := markedRoutes_past_clearance (w := w) (q := terminalAccess s w m x u)
+      (t := t) (by linarith) hwr1 hwi1 ha.le ha1 ⟨hb.1, hb.2.1⟩ hb.2.2.1 (Or.inr hq)
+    constructor <;> linarith [hh.1, hh.2]
+  · rw [completeMarkedAccess, appendMarkedHook, curveJoin_of_gt (lt_of_not_ge huT)]
+    have hR : w.re < fitTerminalX s w := by
+      unfold fitTerminalX
+      rw [abs_of_nonneg hwr]
+      linarith
+    have hR2 : fitTerminalX s w ≤ 2 := by
+      unfold fitTerminalX
+      rw [abs_of_nonneg hwr]
+      linarith
+    have hh := markedRoutes_hook_clearance_early hwr hwr1 hwi1 hR hR2 ha ha1 ht
+      (show 0 ≤ u - fitHighTime s w m by linarith)
+    constructor <;> linarith [hh.1, hh.2]
+
+end SLEExactGauge.Serpentine
+
+end
+
+end OAI

lean/OAI/Probability/SLE/Gauge/SerpentineNormalizedMass.lean

@@ -0,0 +1,111 @@
+import OAI.Probability.SLE.Gauge.ActualRibbonStoppedMass
+import OAI.Probability.SLE.Gauge.SerpentineInitialPrefix
+import OAI.Probability.SLE.Gauge.SerpentineRetentionCount
+
+namespace OAI
+
+/-! The concrete connector and serpentine instantiate the actual stopped
+iteration. All m² selected strip masses are present by completion, with
+one positive initial probability and universal one-step constants. -/
+
+noncomputable section
+open Set Filter MeasureTheory ProbabilityTheory Metric
+open scoped Topology NNReal ENNReal
+
+namespace SLEExactGauge.Serpentine
+open RibbonCoordinates Target
+
+def experimentEntry (s : ℝ) (w : ℂ) (m : ℕ) : ℝ :=
+  connectorEntry (fitHeight m) (fitRadius m) (fitX s w m) (fitY s w m)
+
+def experimentSteps (s : ℝ) (w : ℂ) (m : ℕ) : ℕ := completionStep (experimentEntry s w m) m - 1
+
+def normalizedExperimentDisk (s : ℝ) (w : ℂ) (m : ℕ) : Set ℂ :=
+  (fun z : ℂ => (ribbonWidth (halfHeight s) m : ℂ) * z) ⁻¹' closedBall (center s w) (s / 20)
+
+lemma retained_middle_in_normalized_disk {s : ℝ} (hs : 0 < s) (w : ℂ) (hw : s ≤ w.im)
+    {m : ℕ} (hm : 0 < m) {ε : ℝ} (hε : ε ≤ 1) :
+    ∀ k ∈ retainedSteps (experimentEntry s w m) m,
+      physicalMiddleRegion (experimentChart s w m) closedRibbon k ε ⊆ normalizedExperimentDisk s w m := by
+  intro k hk z hz
+  obtain ⟨⟨j, i⟩, _, rfl⟩ := Finset.mem_image.mp hk
+  obtain ⟨a, ⟨ha, hl, hu, hi⟩, rfl⟩ := hz
+  change (ribbonWidth (halfHeight s) m : ℂ) * experimentChart s w m a ∈ closedBall (center s w) (s / 20)
+  rw [← physicalExperimentChart_eq]
+  dsimp only [experimentEntry] at hl hu
+  exact physicalExperimentChart_retained_disk hs w hw hm j.isLt i.isLt
+    ⟨by linarith, by linarith⟩ (hi.le.trans hε)
+
+/-- The actual normalized dense experiment, conditional only on the
+recorded published inputs. Completion is finite on success and all mass
+belongs to the stopped prefix at the prescribed common mesh. -/
+theorem uniform_serpentine_normalized_stopped_mass
+    {Ω : Type} [mΩ : MeasurableSpace Ω] (μ : Measure Ω) [IsProbabilityMeasure μ]
+    (κ : ℝ) (hκ : 0 < κ) (hκ8 : κ < 8)
+    (B : ℝ≥0 → Ω → ℝ) (hB : IsBrownianReal B μ)
+    (hm : ∀ t, Measurable (B t)) (hc : ∀ ω, Continuous (fun t => B t ω))
+    (γ : Ω → ℝ≥0 → ℂ) (G F : Ω → ℝ≥0 → ℂ → ℂ)
+    (hw : ∀ ω, IsCapacityTwoWitness (fun t => Real.sqrt κ * B t ω) (γ ω) (G ω) (F ω))
+    (hcompact : PublishedHalfPlaneUnivalentCompactness)
+    (hboundary : PublishedFiniteLoewnerBoundaryExtension)
+    (hsupport : PublishedGeometricTubeSupport μ γ)
+    (hplanar : PublishedPlanarDiskOpenness)
+    (hstraight : PublishedHalfPlaneCrosscutStraightening)
+    (hexit : PublishedHalfPlaneConformalExitLaw)
+    (hwiener : PublishedPlanarWienerUnitSupport)
+    (W : WienerLaw) (hW : IsWiener W)
+    (ε : ℝ) (hε : 0 < ε) (hεsmall : ε ≤ 1 / 8) :
+    ∃ q₀ : ℝ≥0∞, ∃ q c v₀ : ℝ, 0 < q₀ ∧ q₀ ≤ 1 ∧ 0 < q ∧ q ≤ 1 ∧ 0 < c ∧ 0 < v₀ ∧
+      ∀ v : ℝ, 0 < v → v < v₀ → ∀ s : ℝ, 0 < s → ∀ w : ℂ, s ≤ w.im →
+      ∀ m : ℕ, 0 < m → ∀ g : C(ℂ, ℝ),
+      (∀ z ∈ closedRibbon, g (experimentChart s w m z) = z.re) →
+      ENNReal.ofReal q ^ experimentSteps s w m * q₀ ≤ μ {ω |
+        ω ∈ GoodRibbonPrefix γ (ribbonIntegerFront g γ (experimentSteps s w m)) (experimentChart s w m) ε ∧
+        ((m ^ 2 : ℕ) : ℝ≥0∞) * ENNReal.ofReal c ≤ segmentSausageCharge κ (γ ω) 0
+          ((ribbonIntegerFront g γ (experimentSteps s w m) ω).untopD 0) v (normalizedExperimentDisk s w m)} := by
+  obtain ⟨q, c, v₀, hq, hq1, hcm, hv₀, hiter⟩ := uniform_actual_ribbon_iteration μ κ hκ hκ8
+    B hB hm hc γ G F hw hcompact hboundary hsupport hplanar hstraight hexit hwiener W hW
+    2 2 (by norm_num) (by norm_num) ε hε hεsmall
+  have ha := brownian_capacity_trace_adapted B hm hc κ γ G F hw
+  have hγc : ∀ ω, Continuous (γ ω) := fun ω => (hw ω).1
+  have hSLE : IsOrdinaryChordalSLE κ γ μ :=
+    ⟨fun t => (ha t).mono (Filtration.le _ t) le_rfl, B, hB,
+      Filter.Eventually.of_forall (fun ω => ⟨G ω, F ω, hw ω⟩)⟩
+  have hε1 : ε ≤ 1 := by linarith
+  obtain ⟨q₀, hq₀, hinit⟩ := uniform_experiment_initial_goodPrefix_probability μ κ γ hSLE hsupport hε hε1
+  refine ⟨min q₀ 1, q, c, v₀, lt_min hq₀ (by norm_num), min_le_right _ _, hq, hq1, hcm, hv₀, ?_⟩
+  intro v hv hvcut s hs w hwy m hmp g hg
+  obtain ⟨hP, hi, hpatch, hH, hinitial⟩ := experimentChart_geometry hs w hwy hmp
+  have hemb := experimentChart_closedEmbedding hs w hwy hmp
+  have hP0 : experimentChart s w m 0 = 0 := by
+    simpa only [mul_zero] using hinitial 0 (by constructor <;> norm_num) (by norm_num)
+  have hg0 (ω : Ω) : g (γ ω 0) = 0 := by
+    rw [(hw ω).2.1, ← hP0]
+    exact hg 0 (by constructor <;> norm_num)
+  have hA : 0 ≤ experimentEntry s w m :=
+    (by unfold fitHeight; positivity : (0 : ℝ) ≤ fitHeight m).trans (fit_entry_lower hs w hwy hmp)
+  have hb := hiter v hv hvcut _ hemb hP.continuousOn hi hP0 hH
+    (experimentChart_escape s w m) (fun k => (hpatch k).1) (fun k => (hpatch k).2)
+    g hg (experimentSteps s w m)
+  calc
+    _ ≤ ENNReal.ofReal q ^ experimentSteps s w m *
+        μ (GoodRibbonPrefix γ (ribbonIntegerFront g γ 0) (experimentChart s w m) ε) := by
+      apply mul_le_mul' le_rfl
+      apply (min_le_left q₀ 1).trans
+      simpa only [ribbonIntegerFront, Nat.cast_zero, zero_add] using hinit s hs w hwy m hmp g hg
+    _ ≤ _ := hb.trans (measure_mono (by
+      intro ω hω
+      have hI : ∀ i ∈ retainedSteps (experimentEntry s w m) m, 0 < i ∧ i ≤ experimentSteps s w m := by
+        intro i hiI
+        obtain ⟨hi0, hic⟩ := retainedSteps_bounds hA hmp i hiI
+        exact ⟨hi0, by dsimp only [experimentSteps]; omega⟩
+      have hh := actual_successes_force_stopped_mass γ hγc g hg0 _ hplanar hP.continuousOn hi
+        ε κ v c hε1 (experimentSteps s w m) (retainedSteps (experimentEntry s w m) m) hI _
+        (retained_middle_in_normalized_disk hs w hwy hmp hε1) ω hω
+      simpa only [mem_ofPred_eq, retainedSteps_card hA hmp] using hh))
+
+end SLEExactGauge.Serpentine
+
+end
+
+end OAI

lean/OAI/Probability/SLE/Gauge/SerpentineParameters.lean

@@ -0,0 +1,150 @@
+import OAI.Probability.SLE.Gauge.SerpentineEscape
+import OAI.Probability.SLE.Gauge.SerpentineShadow
+
+namespace OAI
+
+/-! Concrete normalized connector parameters for the dense-visit layout.
+All constants depend only on the fixed positive angle lower bound. -/
+
+noncomputable section
+open Set Metric
+
+namespace SLEExactGauge.Serpentine
+
+def fitHeight (m : ℕ) : ℝ := 2500 * m
+
+def fitRadius (m : ℕ) : ℝ := 625 * m
+
+def fitX (s : ℝ) (w : ℂ) (m : ℕ) : ℝ :=
+  (|w.re| + s / 4 - halfHeight s) / ribbonWidth (halfHeight s) m
+
+def fitY (s : ℝ) (w : ℂ) (m : ℕ) : ℝ :=
+  (w.im - halfHeight s) / ribbonWidth (halfHeight s) m
+
+def fitEntryBound (s : ℝ) : ℝ := 40000 / s + 10000 + 1000 * Real.pi
+
+lemma fit_width_pos {s : ℝ} (hs : 0 < s) {m : ℕ} (hm : 0 < m) :
+    0 < ribbonWidth (halfHeight s) m := by
+  apply ribbonWidth_pos (by unfold halfHeight; positivity) hm
+
+lemma fit_width_eq (s : ℝ) (m : ℕ) :
+    ribbonWidth (halfHeight s) m = s / (20000 * m) := by
+  unfold ribbonWidth halfHeight
+  ring
+
+lemma fit_width_mul {s : ℝ} (_hs : 0 < s) {m : ℕ} (hm : 0 < m) :
+    ribbonWidth (halfHeight s) m * m = s / 20000 := by
+  rw [fit_width_eq]
+  have hm' : (m : ℝ) ≠ 0 := by exact_mod_cast hm.ne'
+  field_simp
+
+lemma fitX_eq {s : ℝ} (hs : 0 < s) (w : ℂ) {m : ℕ} (hm : 0 < m) :
+    fitX s w m = (20000 * |w.re| / s + 4900) * m := by
+  unfold fitX
+  rw [fit_width_eq]
+  unfold halfHeight
+  have hm' : (m : ℝ) ≠ 0 := by exact_mod_cast hm.ne'
+  field_simp [hs.ne', hm']
+  ring
+
+lemma fitY_eq {s : ℝ} (hs : 0 < s) (w : ℂ) {m : ℕ} (hm : 0 < m) :
+    fitY s w m = (20000 * w.im / s - 100) * m := by
+  unfold fitY
+  rw [fit_width_eq]
+  unfold halfHeight
+  have hm' : (m : ℝ) ≠ 0 := by exact_mod_cast hm.ne'
+  field_simp [hs.ne', hm']
+  ring
+
+lemma fitX_lower {s : ℝ} (hs : 0 < s) (w : ℂ) {m : ℕ} (hm : 0 < m) :
+    4900 * (m : ℝ) ≤ fitX s w m := by
+  rw [fitX_eq hs w hm]
+  have h := div_nonneg (mul_nonneg (by norm_num : (0 : ℝ) ≤ 20000) (abs_nonneg w.re)) hs.le
+  nlinarith [Nat.cast_nonneg (α := ℝ) m]
+
+lemma fitY_lower {s : ℝ} (hs : 0 < s) (w : ℂ) (hw : s ≤ w.im) {m : ℕ} (hm : 0 < m) :
+    19900 * (m : ℝ) ≤ fitY s w m := by
+  rw [fitY_eq hs w hm]
+  have h : (20000 : ℝ) ≤ 20000 * w.im / s := (le_div_iff₀ hs).mpr (by nlinarith)
+  nlinarith [Nat.cast_nonneg (α := ℝ) m]
+
+lemma fitX_upper {s : ℝ} (hs : 0 < s) (w : ℂ) (hw : ‖w‖ ≤ 1) {m : ℕ} (hm : 0 < m) :
+    fitX s w m ≤ (20000 / s + 4900) * m := by
+  rw [fitX_eq hs w hm]
+  have hre : |w.re| ≤ 1 := (Complex.abs_re_le_norm w).trans hw
+  have h : 20000 * |w.re| / s ≤ 20000 / s := by
+    apply div_le_div_of_nonneg_right _ hs.le
+    nlinarith
+  exact mul_le_mul_of_nonneg_right (by linarith) (Nat.cast_nonneg m)
+
+lemma fitY_upper {s : ℝ} (hs : 0 < s) (w : ℂ) (hw : ‖w‖ ≤ 1) {m : ℕ} (hm : 0 < m) :
+    fitY s w m ≤ (20000 / s) * m := by
+  rw [fitY_eq hs w hm]
+  have him : w.im ≤ 1 := (Complex.im_le_norm w).trans hw
+  have h : 20000 * w.im / s ≤ 20000 / s := by
+    apply div_le_div_of_nonneg_right _ hs.le
+    nlinarith
+  exact mul_le_mul_of_nonneg_right (by linarith) (Nat.cast_nonneg m)
+
+/-- The fixed numerical parameters satisfy all proved global embedding
+and local ribbon estimates, with ample strict separation. -/
+theorem fit_parameters {s : ℝ} (hs : 0 < s) (w : ℂ) (hw : s ≤ w.im)
+    {m : ℕ} (hm : 0 < m) :
+    50 ≤ fitRadius m ∧ 2 * fitRadius m < fitX s w m ∧
+      fitHeight m + 2 * fitRadius m + 1 + 300 * m < fitY s w m ∧
+      4 ≤ fitHeight m := by
+  have hm' : (1 : ℝ) ≤ m := by exact_mod_cast hm
+  have hx := fitX_lower hs w hm
+  have hy := fitY_lower hs w hw hm
+  dsimp only [fitRadius, fitHeight]
+  constructor
+  · nlinarith
+  constructor
+  · nlinarith
+  constructor <;> nlinarith
+
+lemma fitEntryBound_pos {s : ℝ} (hs : 0 < s) : 0 < fitEntryBound s := by
+  unfold fitEntryBound
+  positivity
+
+lemma connectorEntry_eq (H r X Y : ℝ) :
+    connectorEntry H r X Y = Real.pi * r + X + Y - 4 * r := by
+  unfold connectorEntry connectorFourth connectorThird connectorSecond quarterLength
+  ring
+
+lemma fit_entry_upper {s : ℝ} (hs : 0 < s) (w : ℂ) (hw : ‖w‖ ≤ 1)
+    {m : ℕ} (hm : 0 < m) :
+    connectorEntry (fitHeight m) (fitRadius m) (fitX s w m) (fitY s w m) ≤ fitEntryBound s * m := by
+  have hx := fitX_upper hs w hw hm
+  have hy := fitY_upper hs w hw hm
+  rw [connectorEntry_eq]
+  dsimp only [fitRadius, fitEntryBound]
+  have hdiv : 40000 / s = 2 * (20000 / s) := by ring
+  rw [hdiv]
+  nlinarith [mul_nonneg Real.pi_pos.le (Nat.cast_nonneg (α := ℝ) m)]
+
+lemma fit_entry_lower {s : ℝ} (hs : 0 < s) (w : ℂ) (hw : s ≤ w.im)
+    {m : ℕ} (hm : 0 < m) :
+    fitHeight m ≤ connectorEntry (fitHeight m) (fitRadius m) (fitX s w m) (fitY s w m) := by
+  have hx := fitX_lower hs w hm
+  have hy := fitY_lower hs w hw hm
+  have hm' : (0 : ℝ) ≤ m := Nat.cast_nonneg m
+  rw [connectorEntry_eq]
+  dsimp only [fitHeight, fitRadius]
+  nlinarith [Real.pi_pos]
+
+lemma fit_completion_quadratic {s : ℝ} (hs : 0 < s) (w : ℂ) (hw : ‖w‖ ≤ 1)
+    (hwy : s ≤ w.im) {m : ℕ} (hm : 0 < m) :
+    (completionStep (connectorEntry (fitHeight m) (fitRadius m) (fitX s w m) (fitY s w m)) m : ℝ) ≤
+      (fitEntryBound s + 601 + 100 * Real.pi) * (m : ℝ) ^ 2 := by
+  apply completionStep_quadratic_bound
+  · exact (by unfold fitHeight; positivity : (0 : ℝ) ≤ fitHeight m).trans (fit_entry_lower hs w hwy hm)
+  · exact (fitEntryBound_pos hs).le
+  · exact hm
+  · exact fit_entry_upper hs w hw hm
+
+end SLEExactGauge.Serpentine
+
+end
+
+end OAI