Sync from openai/math@faee2cf485a8 (part 18)

lean/OAI/Probability/SLE/Loewner/ForwardHeightSquareIncrement.lean

@@ -1,55 +1,55 @@
-import OAI.Probability.SLE.Loewner.CapacityPointwiseLoewner
-import OAI.Probability.SLE.Geometry.EndpointMonotonicity
-
-namespace OAI
-
-/-! The squared height can decrease by at most twice elapsed capacity.
-The proof uses pointwise right derivatives and includes both endpoints. -/
-noncomputable section
-open Set Filter Function Complex
-open scoped Topology
-
-namespace SLEExactGauge
-
-lemma height_kernel_square_bound (z : ℂ) (u : ℝ) :
-    2*z.im^2/Complex.normSq (z-(u:ℂ))-2≤0 := by
-  have hsq : z.im^2≤Complex.normSq (z-(u:ℂ)) := by
-    simp only [Complex.normSq_apply,sub_im,ofReal_im,sub_zero]
-    nlinarith [sq_nonneg (z-(u:ℂ)).re]
-  by_cases hn : Complex.normSq (z-(u:ℂ))=0
-  · simp only [hn,div_zero,zero_sub]
-    norm_num
-  · have hpos := lt_of_le_of_ne (Complex.normSq_nonneg (z-(u:ℂ))) (Ne.symm hn)
-    have hb : 2*z.im^2/Complex.normSq (z-(u:ℂ))≤2 :=
-      (div_le_iff₀ hpos).mpr (by nlinarith)
-    linarith
-
-theorem height_square_increment {f : ℝ → ℂ} {u : ℝ → ℝ} {a b : ℝ}
-    (hab : a≤b) (hf : ContinuousOn f (Icc a b))
-    (hd : ∀ c∈Ico a b, HasDerivWithinAt f (1/(f c-(u c:ℂ))) (Ici c) c) :
-    (f a).im^2≤(f b).im^2+2*(b-a) := by
-  let g (c : ℝ) := -(f c).im^2-2*c
-  let v (c : ℝ) := 2*(f c).im^2/Complex.normSq (f c-(u c:ℂ))-2
-  have hg : ContinuousOn g (Icc a b) :=
-    ((Complex.continuous_im.comp_continuousOn hf).pow 2).neg.sub
-      (continuousOn_const.mul continuousOn_id)
-  have hgd (c : ℝ) (hc : c∈Ico a b) : HasDerivWithinAt g (v c) (Ici c) c := by
-    have hi := Complex.imCLM.hasFDerivAt.comp_hasDerivWithinAt c (hd c hc)
-    change HasDerivWithinAt (fun x => (f x).im) (1/(f c-(u c:ℂ))).im (Ici c) c at hi
-    have hh := (hi.pow 2).neg.sub ((hasDerivWithinAt_id c (Ici c)).const_mul 2)
-    convert! hh using 1
-    dsimp only [v]
-    simp only [Complex.div_im,one_im,one_re,zero_mul,one_mul,sub_im,ofReal_im,sub_zero]
-    ring
-  have hb := image_le_of_deriv_right_le_deriv_boundary hg hgd
-    (B := fun _ => g a) (B' := fun _ => 0) le_rfl continuousOn_const
-    (fun c _ => hasDerivWithinAt_const c (Ici c) (g a))
-    (fun c _ => height_kernel_square_bound (f c) (u c)) (show b∈Icc a b from ⟨hab,le_rfl⟩)
-  dsimp only [g] at hb
-  linarith
-
-end SLEExactGauge
-
-end
-
-end OAI
+import OAI.Probability.SLE.Loewner.CapacityPointwiseLoewner
+import OAI.Probability.SLE.Geometry.EndpointMonotonicity
+
+namespace OAI
+
+/-! The squared height can decrease by at most twice elapsed capacity.
+The proof uses pointwise right derivatives and includes both endpoints. -/
+noncomputable section
+open Set Filter Function Complex
+open scoped Topology
+
+namespace SLEExactGauge
+
+lemma height_kernel_square_bound (z : ℂ) (u : ℝ) :
+    2*z.im^2/Complex.normSq (z-(u:ℂ))-2≤0 := by
+  have hsq : z.im^2≤Complex.normSq (z-(u:ℂ)) := by
+    simp only [Complex.normSq_apply,sub_im,ofReal_im,sub_zero]
+    nlinarith [sq_nonneg (z-(u:ℂ)).re]
+  by_cases hn : Complex.normSq (z-(u:ℂ))=0
+  · simp only [hn,div_zero,zero_sub]
+    norm_num
+  · have hpos := lt_of_le_of_ne (Complex.normSq_nonneg (z-(u:ℂ))) (Ne.symm hn)
+    have hb : 2*z.im^2/Complex.normSq (z-(u:ℂ))≤2 :=
+      (div_le_iff₀ hpos).mpr (by nlinarith)
+    linarith
+
+theorem height_square_increment {f : ℝ → ℂ} {u : ℝ → ℝ} {a b : ℝ}
+    (hab : a≤b) (hf : ContinuousOn f (Icc a b))
+    (hd : ∀ c∈Ico a b, HasDerivWithinAt f (1/(f c-(u c:ℂ))) (Ici c) c) :
+    (f a).im^2≤(f b).im^2+2*(b-a) := by
+  let g (c : ℝ) := -(f c).im^2-2*c
+  let v (c : ℝ) := 2*(f c).im^2/Complex.normSq (f c-(u c:ℂ))-2
+  have hg : ContinuousOn g (Icc a b) :=
+    ((Complex.continuous_im.comp_continuousOn hf).pow 2).neg.sub
+      (continuousOn_const.mul continuousOn_id)
+  have hgd (c : ℝ) (hc : c∈Ico a b) : HasDerivWithinAt g (v c) (Ici c) c := by
+    have hi := Complex.imCLM.hasFDerivAt.comp_hasDerivWithinAt c (hd c hc)
+    change HasDerivWithinAt (fun x => (f x).im) (1/(f c-(u c:ℂ))).im (Ici c) c at hi
+    have hh := (hi.pow 2).neg.sub ((hasDerivWithinAt_id c (Ici c)).const_mul 2)
+    convert! hh using 1
+    dsimp only [v]
+    simp only [Complex.div_im,one_im,one_re,zero_mul,one_mul,sub_im,ofReal_im,sub_zero]
+    ring
+  have hb := image_le_of_deriv_right_le_deriv_boundary hg hgd
+    (B := fun _ => g a) (B' := fun _ => 0) le_rfl continuousOn_const
+    (fun c _ => hasDerivWithinAt_const c (Ici c) (g a))
+    (fun c _ => height_kernel_square_bound (f c) (u c)) (show b∈Icc a b from ⟨hab,le_rfl⟩)
+  dsimp only [g] at hb
+  linarith
+
+end SLEExactGauge
+
+end
+
+end OAI

lean/OAI/Probability/SLE/Loewner/ForwardInfinityBounds.lean

@@ -1,79 +1,79 @@
-import Mathlib
-
-namespace OAI
-
-/-! Uniform bounds for forward Loewner trajectories far from the origin.
-Only the bounded driver on the fixed time interval is used. -/
-noncomputable section
-open Set Filter Complex
-open scoped Topology
-
-namespace SLEExactGauge
-
-lemma forward_far_center_lower {q z : ℂ} {u M A r : ℝ}
-    (hr : r=‖z‖) (hu : |u| ≤ M) (hq : ‖q-z‖ ≤ A)
-    (hsize : 2*(M+A) ≤ r) : r/2 ≤ ‖q-(u : ℂ)‖ := by
-  have h1 := norm_le_norm_sub_add z q
-  have h2 := norm_le_norm_sub_add q (u : ℂ)
-  rw [norm_sub_rev z q] at h1
-  rw [Complex.norm_real,Real.norm_eq_abs] at h2
-  linarith
-
-theorem forward_far_displacement {T M : ℝ} (hT : 0 ≤ T) (hM : 0 ≤ M)
-    (q : ℝ → ℂ) (u : ℝ → ℝ) (z : ℂ)
-    (hc : ContinuousOn q (Icc 0 T)) (hq0 : q 0=z)
-    (hd : ∀ t ∈ Ico 0 T, HasDerivWithinAt q
-      (2/(q t-(u t : ℂ))) (Ici t) t)
-    (hu : ∀ t ∈ Icc 0 T, |u t| ≤ M)
-    (hlarge : 8*(M+T+1) ≤ ‖z‖) :
-    (∀ t ∈ Icc 0 T, ‖q t-z‖ ≤ (4/‖z‖)*t) ∧
-      ∀ t ∈ Icc 0 T, ‖z‖/2 ≤ ‖q t-(u t : ℂ)‖ := by
-  let r : ℝ := ‖z‖
-  have hr : 0 < r := by dsimp [r]; nlinarith
-  have hr8 : 8 ≤ r := by dsimp [r]; nlinarith
-  have hfac : 8/r ≤ 1 := (div_le_one hr).mpr hr8
-  have hbnd (t : ℝ) (ht : t ∈ Icc 0 T) : 1+(8/r)*t ≤ 1+T := by
-    have hh := mul_le_mul_of_nonneg_right hfac ht.1
-    nlinarith [ht.2]
-  have hsize : 2*(M+(1+T)) ≤ r := by dsimp [r]; nlinarith
-  have hrough : ∀ t ∈ Icc 0 T, ‖q t-z‖ ≤ 1+(8/r)*t := by
-    apply image_norm_le_of_norm_deriv_right_lt_deriv_boundary
-      (hc.sub continuousOn_const) (fun t ht => (hd t ht).sub_const z)
-      (B := fun t => 1+(8/r)*t) (B' := fun _ => 8/r)
-    · simp [hq0]
-    · intro t
-      convert! ((hasDerivAt_id t).const_mul (8/r)).const_add 1 using 1
-      simp
-    · intro t ht he
-      have hcenter := forward_far_center_lower (q := q t) (z := z)
-        (u := u t) (M := M) (A := 1+T) rfl (hu t (Ico_subset_Icc_self ht))
-        (he.le.trans (hbnd t (Ico_subset_Icc_self ht))) hsize
-      have hnorm : ‖2/(q t-(u t : ℂ))‖ ≤ 4/r := by
-        rw [norm_div]
-        norm_num only [norm_ofNat]
-        have hh := div_le_div_of_nonneg_left (by norm_num : (0:ℝ) ≤ 2)
-          (half_pos hr) hcenter
-        convert! hh using 1
-        field_simp
-        ring
-      exact hnorm.trans_lt (div_lt_div_of_pos_right (by norm_num) hr)
-  have hcenter (t : ℝ) (ht : t ∈ Icc 0 T) : r/2 ≤ ‖q t-(u t : ℂ)‖ :=
-    forward_far_center_lower rfl (hu t ht) ((hrough t ht).trans (hbnd t ht)) hsize
-  refine ⟨?_,hcenter⟩
-  have hderiv (t : ℝ) (ht : t ∈ Ico 0 T) : ‖2/(q t-(u t : ℂ))‖ ≤ 4/r := by
-    rw [norm_div]
-    norm_num only [norm_ofNat]
-    have hh := div_le_div_of_nonneg_left (by norm_num : (0:ℝ) ≤ 2)
-      (half_pos hr) (hcenter t (Ico_subset_Icc_self ht))
-    convert! hh using 1
-    field_simp
-    ring
-  intro t ht
-  simpa only [hq0,sub_zero] using
-    norm_image_sub_le_of_norm_deriv_right_le_segment hc hd hderiv t ht
-
-end SLEExactGauge
-
-end
-
-end OAI
+import Mathlib
+
+namespace OAI
+
+/-! Uniform bounds for forward Loewner trajectories far from the origin.
+Only the bounded driver on the fixed time interval is used. -/
+noncomputable section
+open Set Filter Complex
+open scoped Topology
+
+namespace SLEExactGauge
+
+lemma forward_far_center_lower {q z : ℂ} {u M A r : ℝ}
+    (hr : r=‖z‖) (hu : |u| ≤ M) (hq : ‖q-z‖ ≤ A)
+    (hsize : 2*(M+A) ≤ r) : r/2 ≤ ‖q-(u : ℂ)‖ := by
+  have h1 := norm_le_norm_sub_add z q
+  have h2 := norm_le_norm_sub_add q (u : ℂ)
+  rw [norm_sub_rev z q] at h1
+  rw [Complex.norm_real,Real.norm_eq_abs] at h2
+  linarith
+
+theorem forward_far_displacement {T M : ℝ} (hT : 0 ≤ T) (hM : 0 ≤ M)
+    (q : ℝ → ℂ) (u : ℝ → ℝ) (z : ℂ)
+    (hc : ContinuousOn q (Icc 0 T)) (hq0 : q 0=z)
+    (hd : ∀ t ∈ Ico 0 T, HasDerivWithinAt q
+      (2/(q t-(u t : ℂ))) (Ici t) t)
+    (hu : ∀ t ∈ Icc 0 T, |u t| ≤ M)
+    (hlarge : 8*(M+T+1) ≤ ‖z‖) :
+    (∀ t ∈ Icc 0 T, ‖q t-z‖ ≤ (4/‖z‖)*t) ∧
+      ∀ t ∈ Icc 0 T, ‖z‖/2 ≤ ‖q t-(u t : ℂ)‖ := by
+  let r : ℝ := ‖z‖
+  have hr : 0 < r := by dsimp [r]; nlinarith
+  have hr8 : 8 ≤ r := by dsimp [r]; nlinarith
+  have hfac : 8/r ≤ 1 := (div_le_one hr).mpr hr8
+  have hbnd (t : ℝ) (ht : t ∈ Icc 0 T) : 1+(8/r)*t ≤ 1+T := by
+    have hh := mul_le_mul_of_nonneg_right hfac ht.1
+    nlinarith [ht.2]
+  have hsize : 2*(M+(1+T)) ≤ r := by dsimp [r]; nlinarith
+  have hrough : ∀ t ∈ Icc 0 T, ‖q t-z‖ ≤ 1+(8/r)*t := by
+    apply image_norm_le_of_norm_deriv_right_lt_deriv_boundary
+      (hc.sub continuousOn_const) (fun t ht => (hd t ht).sub_const z)
+      (B := fun t => 1+(8/r)*t) (B' := fun _ => 8/r)
+    · simp [hq0]
+    · intro t
+      convert! ((hasDerivAt_id t).const_mul (8/r)).const_add 1 using 1
+      simp
+    · intro t ht he
+      have hcenter := forward_far_center_lower (q := q t) (z := z)
+        (u := u t) (M := M) (A := 1+T) rfl (hu t (Ico_subset_Icc_self ht))
+        (he.le.trans (hbnd t (Ico_subset_Icc_self ht))) hsize
+      have hnorm : ‖2/(q t-(u t : ℂ))‖ ≤ 4/r := by
+        rw [norm_div]
+        norm_num only [norm_ofNat]
+        have hh := div_le_div_of_nonneg_left (by norm_num : (0:ℝ) ≤ 2)
+          (half_pos hr) hcenter
+        convert! hh using 1
+        field_simp
+        ring
+      exact hnorm.trans_lt (div_lt_div_of_pos_right (by norm_num) hr)
+  have hcenter (t : ℝ) (ht : t ∈ Icc 0 T) : r/2 ≤ ‖q t-(u t : ℂ)‖ :=
+    forward_far_center_lower rfl (hu t ht) ((hrough t ht).trans (hbnd t ht)) hsize
+  refine ⟨?_,hcenter⟩
+  have hderiv (t : ℝ) (ht : t ∈ Ico 0 T) : ‖2/(q t-(u t : ℂ))‖ ≤ 4/r := by
+    rw [norm_div]
+    norm_num only [norm_ofNat]
+    have hh := div_le_div_of_nonneg_left (by norm_num : (0:ℝ) ≤ 2)
+      (half_pos hr) (hcenter t (Ico_subset_Icc_self ht))
+    convert! hh using 1
+    field_simp
+    ring
+  intro t ht
+  simpa only [hq0,sub_zero] using
+    norm_image_sub_le_of_norm_deriv_right_le_segment hc hd hderiv t ht
+
+end SLEExactGauge
+
+end
+
+end OAI

lean/OAI/Probability/SLE/Loewner/FreshCapacityWitness.lean

@@ -1,48 +1,48 @@
-import OAI.Probability.SLE.Geometry.CanonicalRestartWitness
-
-namespace OAI
-
-/-! The published trace-generation input is used only on the single
-continuous Brownian path law. Strong Markov supplies the fresh witness. -/
-
-noncomputable section
-open Set Filter MeasureTheory ProbabilityTheory Classical
-open scoped NNReal ENNReal Topology
-
-namespace SLEExactGauge
-
-local instance : MeasurableSpace C(ℝ≥0,ℝ) := borel _
-local instance : BorelSpace C(ℝ≥0,ℝ) := ⟨rfl⟩
-
-theorem fresh_capacity_witness_exists
-    {Ω : Type*} [MeasurableSpace Ω] {P : Measure Ω} [IsProbabilityMeasure P]
-    {κ : ℝ} {B : ℝ≥0 → Ω → ℝ} (hB : IsBrownianReal B P)
-    (hm : ∀ t, Measurable (B t)) (hc : ∀ ω, Continuous (fun t => B t ω))
-    (hpublished : PublishedTraceGeneration (P.map (sourceDriverPath B hc)) κ (fun t p => p t))
-    (τ : Ω → ℝ≥0)
-    (hτ : IsStoppingTime (Filtration.natural B (fun t => (hm t).stronglyMeasurable))
-      (fun ω => (τ ω:WithTop ℝ≥0))) :
-    ∀ᵐ ω ∂P, ∃ (β : ℝ≥0 → ℂ) (G' F' : ℝ≥0 → ℂ → ℂ),
-      IsCapacityTwoWitness (fun t => Real.sqrt κ*B (τ ω+t) ω-Real.sqrt κ*B (τ ω) ω)
-        β G' F' := by
-  obtain ⟨Φ,Gc,Fc,_,hW⟩ := exists_measurable_canonical_witness _ κ hpublished
-  have hY : Measurable (sourceRestartDriverPath B hc τ) := source_path_measurable _
-    (fun t => (measurable_pi_apply t).comp
-      (brownianRestart_measurable hm hc (stopping_time_measurable_nnreal hτ)))
-  have hLaw : P.map (sourceRestartDriverPath B hc τ)=P.map (sourceDriverPath B hc) := by
-    simpa only [Measure.restrict_univ,measure_univ,one_smul] using
-      source_restart_continuous_driver_law hB hm hc τ hτ (A := univ) MeasurableSet.univ
-  filter_upwards [canonical_witness_pullback hW _ hY hLaw] with ω hω
-  refine ⟨Φ (sourceRestartDriverPath B hc τ ω),Gc (sourceRestartDriverPath B hc τ ω),
-    Fc (sourceRestartDriverPath B hc τ ω),?_⟩
-  convert hω using 1
-  funext t
-  change Real.sqrt κ*B (τ ω+t) ω-Real.sqrt κ*B (τ ω) ω =
-    Real.sqrt κ*(B (τ ω+t) ω-B (τ ω) ω)
-  ring
-
-end SLEExactGauge
-
-end
-
-end OAI
+import OAI.Probability.SLE.Geometry.CanonicalRestartWitness
+
+namespace OAI
+
+/-! The published trace-generation input is used only on the single
+continuous Brownian path law. Strong Markov supplies the fresh witness. -/
+
+noncomputable section
+open Set Filter MeasureTheory ProbabilityTheory Classical
+open scoped NNReal ENNReal Topology
+
+namespace SLEExactGauge
+
+local instance : MeasurableSpace C(ℝ≥0,ℝ) := borel _
+local instance : BorelSpace C(ℝ≥0,ℝ) := ⟨rfl⟩
+
+theorem fresh_capacity_witness_exists
+    {Ω : Type*} [MeasurableSpace Ω] {P : Measure Ω} [IsProbabilityMeasure P]
+    {κ : ℝ} {B : ℝ≥0 → Ω → ℝ} (hB : IsBrownianReal B P)
+    (hm : ∀ t, Measurable (B t)) (hc : ∀ ω, Continuous (fun t => B t ω))
+    (hpublished : PublishedTraceGeneration (P.map (sourceDriverPath B hc)) κ (fun t p => p t))
+    (τ : Ω → ℝ≥0)
+    (hτ : IsStoppingTime (Filtration.natural B (fun t => (hm t).stronglyMeasurable))
+      (fun ω => (τ ω:WithTop ℝ≥0))) :
+    ∀ᵐ ω ∂P, ∃ (β : ℝ≥0 → ℂ) (G' F' : ℝ≥0 → ℂ → ℂ),
+      IsCapacityTwoWitness (fun t => Real.sqrt κ*B (τ ω+t) ω-Real.sqrt κ*B (τ ω) ω)
+        β G' F' := by
+  obtain ⟨Φ,Gc,Fc,_,hW⟩ := exists_measurable_canonical_witness _ κ hpublished
+  have hY : Measurable (sourceRestartDriverPath B hc τ) := source_path_measurable _
+    (fun t => (measurable_pi_apply t).comp
+      (brownianRestart_measurable hm hc (stopping_time_measurable_nnreal hτ)))
+  have hLaw : P.map (sourceRestartDriverPath B hc τ)=P.map (sourceDriverPath B hc) := by
+    simpa only [Measure.restrict_univ,measure_univ,one_smul] using
+      source_restart_continuous_driver_law hB hm hc τ hτ (A := univ) MeasurableSet.univ
+  filter_upwards [canonical_witness_pullback hW _ hY hLaw] with ω hω
+  refine ⟨Φ (sourceRestartDriverPath B hc τ ω),Gc (sourceRestartDriverPath B hc τ ω),
+    Fc (sourceRestartDriverPath B hc τ ω),?_⟩
+  convert hω using 1
+  funext t
+  change Real.sqrt κ*B (τ ω+t) ω-Real.sqrt κ*B (τ ω) ω =
+    Real.sqrt κ*(B (τ ω+t) ω-B (τ ω) ω)
+  ring
+
+end SLEExactGauge
+
+end
+
+end OAI

lean/OAI/Probability/SLE/Loewner/FreshTipMapOut.lean

@@ -1,139 +1,139 @@
-import OAI.Probability.SLE.PhysicalTransport
-import OAI.Probability.SLE.Gauge.RibbonSurvival
-
-namespace OAI
-
-/-! Mapping the actual geometric continuation into the restarted half-plane.
-At a first height crossing the tip is fresh. The fresh-tip chart limit then maps a simple access path continuously to a simple path
-starting at the restarted driving point. -/
-
-noncomputable section
-open Set Filter MeasureTheory Metric
-open scoped Topology NNReal unitInterval
-
-namespace SLEExactGauge
-
-theorem tip_survives_prior_of_strict_height
-    (γ : ℝ≥0 → ℂ) (T : ℝ≥0) (hheight : 0 < (γ T).im)
-    (hfirst : ∀ u : ℝ≥0, u < T → (γ u).im < (γ T).im) :
-    ∀ s : ℝ≥0, s < T → γ T ∈ survivingDomain γ s := by
-  intro s hs
-  have hfree : range (upwardRay (γ T)) ⊆ upperHalfPlane \ (γ '' Icc 0 s) := by
-    rintro z ⟨u, rfl⟩
-    have him : (upwardRay (γ T) u).im = (γ T).im + (u : ℝ) := by simp [upwardRay]
-    refine ⟨by change 0 < (upwardRay (γ T) u).im; rw [him]; positivity, ?_⟩
-    rintro ⟨v, hv, he⟩
-    have hh := hfirst v (hv.2.trans_lt hs)
-    have he' := congrArg Complex.im he
-    rw [him] at he'
-    linarith [u.coe_nonneg]
-  have hh := survives_of_unbounded_free_curve γ s (upwardRay (γ T))
-    (upwardRay_continuous _) hfree (upwardRay_unbounded _) (mem_range_self 0)
-  simpa only [upwardRay, NNReal.coe_zero, Complex.ofReal_zero, zero_mul, add_zero] using hh
-
-/-- Extend the map only at the accessible tip. This is sufficient to map
-the entire simple continuation Path, and does not require a boundary
-extension of the forward conformal map at other hull points. -/
-theorem map_out_simple_access_path
-    (D : Set ℂ) (_hD : IsOpen D) (g : ℂ → ℂ)
-    (hg : ContinuousOn g D) (hgi : InjOn g D) (hgH : MapsTo g D upperHalfPlane)
-    (ζ w : ℂ) (u : ℝ) (hζ : ζ ∉ D)
-    (hlim : Tendsto g (𝓝[D] ζ) (𝓝 (u : ℂ)))
-    (p : Path ζ w) (hp : Function.Injective p)
-    (hpD : ∀ t, t ≠ 0 → p t ∈ D) :
-    ∃ q : Path (0 : ℂ) (g w - (u : ℂ)), Function.Injective q ∧
-      (∀ t, t ≠ 0 → q t ∈ upperHalfPlane) ∧
-      (∀ t, t ≠ 0 → q t = g (p t) - (u : ℂ)) := by
-  classical
-  let gb := Function.update g ζ (u : ℂ)
-  have hs : insert ζ D \ {ζ} = D := by
-    ext z
-    simp only [Set.mem_sdiff, mem_insert_iff, mem_singleton_iff]
-    constructor
-    · rintro ⟨rfl | hz, hn⟩
-      · exact False.elim (hn rfl)
-      · exact hz
-    · intro hz
-      exact ⟨Or.inr hz, fun he => hζ (he ▸ hz)⟩
-  have hgb : ContinuousOn gb (insert ζ D) := by
-    rw [continuousOn_update_iff, hs]
-    exact ⟨hg, fun _ => hlim⟩
-  have hpS : range p ⊆ insert ζ D := by
-    rintro z ⟨t, rfl⟩
-    by_cases ht : t = 0
-    · simpa only [ht, p.source] using mem_insert ζ D
-    · exact mem_insert_of_mem ζ (hpD t ht)
-  have hne (t : unitInterval) (ht : t ≠ 0) : p t ≠ ζ :=
-    fun he => hζ (he ▸ hpD t ht)
-  have heval (t : unitInterval) (ht : t ≠ 0) : gb (p t) = g (p t) :=
-    Function.update_of_ne (hne t ht) _ _
-  have hw : gb w = g w := by
-    simpa only [p.target] using heval 1 one_ne_zero
-  let q : Path (0 : ℂ) (g w - (u : ℂ)) := {
-    toFun := fun t => gb (p t) - (u : ℂ)
-    continuous_toFun := ((hgb.mono hpS).comp_continuous p.continuous
-      (fun t => mem_range_self t)).sub continuous_const
-    source' := by simp [gb]
-    target' := by simp only [p.target, hw] }
-  have hqH (t : unitInterval) (ht : t ≠ 0) : q t ∈ upperHalfPlane := by
-    change 0 < (gb (p t) - (u : ℂ)).im
-    rw [heval t ht]
-    simpa only [upperHalfPlane, mem_ofPred_eq, Complex.sub_im, Complex.ofReal_im,
-      sub_zero] using hgH (hpD t ht)
-  refine ⟨q, ?_, hqH, fun t ht => by change gb (p t) - _ = _; rw [heval t ht]⟩
-  intro s t he
-  by_cases hs0 : s = 0
-  · subst s
-    by_contra ht0
-    have hh := hqH t (Ne.symm ht0)
-    rw [← he, q.source] at hh
-    simp only [upperHalfPlane, mem_ofPred_eq, Complex.zero_im, lt_self_iff_false] at hh
-  by_cases ht0 : t = 0
-  · subst t
-    have hh := hqH s hs0
-    rw [he, q.source] at hh
-    simp only [upperHalfPlane, mem_ofPred_eq, Complex.zero_im, lt_self_iff_false] at hh
-  apply hp
-  apply hgi (hpD s hs0) (hpD t ht0)
-  have he' : gb (p s) - (u : ℂ) = gb (p t) - (u : ℂ) := he
-  rw [heval s hs0, heval t ht0] at he'
-  exact sub_left_injective he'
-
-/-- Actual capacity charts at a first height crossing map the physical
-simple continuation to a supported simple path in the restarted half-plane,
-with the conformal map-back identity at every positive path time. -/
-theorem IsCapacityTwoWitness.map_out_access_at_first_height
-    {U : ℝ≥0 → ℝ} {γ : ℝ≥0 → ℂ} {G F : ℝ≥0 → ℂ → ℂ}
-    (hw : IsCapacityTwoWitness U γ G F) (hU : Continuous U)
-    (T : ℝ≥0) (hT : 0 < T) (hheight : 0 < (γ T).im)
-    (hfirst : ∀ u : ℝ≥0, u < T → (γ u).im < (γ T).im)
-    (w : ℂ) (p : Path (γ T) w) (hp : Function.Injective p)
-    (hpD : ∀ t, t ≠ 0 → p t ∈ survivingDomain γ T) :
-    ∃ q : Path (0 : ℂ) (G T w - (U T : ℂ)), Function.Injective q ∧
-      (∀ t, t ≠ 0 → q t ∈ upperHalfPlane) ∧
-      (∀ t, t ≠ 0 → F T (q t + (U T : ℂ)) = p t) := by
-  have hgi : InjOn (G T) (survivingDomain γ T) := by
-    intro z hz v hv he
-    calc
-      z = F T (G T z) := (hw.2.2.2.2.2.2.2.1 T z hz).symm
-      _ = F T (G T v) := congrArg (F T) he
-      _ = v := hw.2.2.2.2.2.2.2.1 T v hv
-  have htip : γ T ∉ survivingDomain γ T := by
-    intro hh
-    exact hh.1.2 (mem_image_of_mem γ ⟨zero_le, le_rfl⟩)
-  obtain ⟨q, hq, hqH, hqeq⟩ := map_out_simple_access_path
-    (survivingDomain γ T) (isOpen_survivingDomain hw.1 T) (G T)
-    (hw.2.2.2.1 T).continuousOn hgi (hw.2.2.2.2.2.1 T)
-    (γ T) w (U T) htip
-    (hw.fresh_tip_chart_tendsto hU hT
-      (tip_survives_prior_of_strict_height γ T hheight hfirst)) p hp hpD
-  refine ⟨q, hq, hqH, ?_⟩
-  intro t ht
-  rw [hqeq t ht, sub_add_cancel]
-  exact hw.2.2.2.2.2.2.2.1 T (p t) (hpD t ht)
-
-end SLEExactGauge
-
-end
-
-end OAI
+import OAI.Probability.SLE.PhysicalTransport
+import OAI.Probability.SLE.Gauge.RibbonSurvival
+
+namespace OAI
+
+/-! Mapping the actual geometric continuation into the restarted half-plane.
+At a first height crossing the tip is fresh. The fresh-tip chart limit then maps a simple access path continuously to a simple path
+starting at the restarted driving point. -/
+
+noncomputable section
+open Set Filter MeasureTheory Metric
+open scoped Topology NNReal unitInterval
+
+namespace SLEExactGauge
+
+theorem tip_survives_prior_of_strict_height
+    (γ : ℝ≥0 → ℂ) (T : ℝ≥0) (hheight : 0 < (γ T).im)
+    (hfirst : ∀ u : ℝ≥0, u < T → (γ u).im < (γ T).im) :
+    ∀ s : ℝ≥0, s < T → γ T ∈ survivingDomain γ s := by
+  intro s hs
+  have hfree : range (upwardRay (γ T)) ⊆ upperHalfPlane \ (γ '' Icc 0 s) := by
+    rintro z ⟨u, rfl⟩
+    have him : (upwardRay (γ T) u).im = (γ T).im + (u : ℝ) := by simp [upwardRay]
+    refine ⟨by change 0 < (upwardRay (γ T) u).im; rw [him]; positivity, ?_⟩
+    rintro ⟨v, hv, he⟩
+    have hh := hfirst v (hv.2.trans_lt hs)
+    have he' := congrArg Complex.im he
+    rw [him] at he'
+    linarith [u.coe_nonneg]
+  have hh := survives_of_unbounded_free_curve γ s (upwardRay (γ T))
+    (upwardRay_continuous _) hfree (upwardRay_unbounded _) (mem_range_self 0)
+  simpa only [upwardRay, NNReal.coe_zero, Complex.ofReal_zero, zero_mul, add_zero] using hh
+
+/-- Extend the map only at the accessible tip. This is sufficient to map
+the entire simple continuation Path, and does not require a boundary
+extension of the forward conformal map at other hull points. -/
+theorem map_out_simple_access_path
+    (D : Set ℂ) (_hD : IsOpen D) (g : ℂ → ℂ)
+    (hg : ContinuousOn g D) (hgi : InjOn g D) (hgH : MapsTo g D upperHalfPlane)
+    (ζ w : ℂ) (u : ℝ) (hζ : ζ ∉ D)
+    (hlim : Tendsto g (𝓝[D] ζ) (𝓝 (u : ℂ)))
+    (p : Path ζ w) (hp : Function.Injective p)
+    (hpD : ∀ t, t ≠ 0 → p t ∈ D) :
+    ∃ q : Path (0 : ℂ) (g w - (u : ℂ)), Function.Injective q ∧
+      (∀ t, t ≠ 0 → q t ∈ upperHalfPlane) ∧
+      (∀ t, t ≠ 0 → q t = g (p t) - (u : ℂ)) := by
+  classical
+  let gb := Function.update g ζ (u : ℂ)
+  have hs : insert ζ D \ {ζ} = D := by
+    ext z
+    simp only [Set.mem_sdiff, mem_insert_iff, mem_singleton_iff]
+    constructor
+    · rintro ⟨rfl | hz, hn⟩
+      · exact False.elim (hn rfl)
+      · exact hz
+    · intro hz
+      exact ⟨Or.inr hz, fun he => hζ (he ▸ hz)⟩
+  have hgb : ContinuousOn gb (insert ζ D) := by
+    rw [continuousOn_update_iff, hs]
+    exact ⟨hg, fun _ => hlim⟩
+  have hpS : range p ⊆ insert ζ D := by
+    rintro z ⟨t, rfl⟩
+    by_cases ht : t = 0
+    · simpa only [ht, p.source] using mem_insert ζ D
+    · exact mem_insert_of_mem ζ (hpD t ht)
+  have hne (t : unitInterval) (ht : t ≠ 0) : p t ≠ ζ :=
+    fun he => hζ (he ▸ hpD t ht)
+  have heval (t : unitInterval) (ht : t ≠ 0) : gb (p t) = g (p t) :=
+    Function.update_of_ne (hne t ht) _ _
+  have hw : gb w = g w := by
+    simpa only [p.target] using heval 1 one_ne_zero
+  let q : Path (0 : ℂ) (g w - (u : ℂ)) := {
+    toFun := fun t => gb (p t) - (u : ℂ)
+    continuous_toFun := ((hgb.mono hpS).comp_continuous p.continuous
+      (fun t => mem_range_self t)).sub continuous_const
+    source' := by simp [gb]
+    target' := by simp only [p.target, hw] }
+  have hqH (t : unitInterval) (ht : t ≠ 0) : q t ∈ upperHalfPlane := by
+    change 0 < (gb (p t) - (u : ℂ)).im
+    rw [heval t ht]
+    simpa only [upperHalfPlane, mem_ofPred_eq, Complex.sub_im, Complex.ofReal_im,
+      sub_zero] using hgH (hpD t ht)
+  refine ⟨q, ?_, hqH, fun t ht => by change gb (p t) - _ = _; rw [heval t ht]⟩
+  intro s t he
+  by_cases hs0 : s = 0
+  · subst s
+    by_contra ht0
+    have hh := hqH t (Ne.symm ht0)
+    rw [← he, q.source] at hh
+    simp only [upperHalfPlane, mem_ofPred_eq, Complex.zero_im, lt_self_iff_false] at hh
+  by_cases ht0 : t = 0
+  · subst t
+    have hh := hqH s hs0
+    rw [he, q.source] at hh
+    simp only [upperHalfPlane, mem_ofPred_eq, Complex.zero_im, lt_self_iff_false] at hh
+  apply hp
+  apply hgi (hpD s hs0) (hpD t ht0)
+  have he' : gb (p s) - (u : ℂ) = gb (p t) - (u : ℂ) := he
+  rw [heval s hs0, heval t ht0] at he'
+  exact sub_left_injective he'
+
+/-- Actual capacity charts at a first height crossing map the physical
+simple continuation to a supported simple path in the restarted half-plane,
+with the conformal map-back identity at every positive path time. -/
+theorem IsCapacityTwoWitness.map_out_access_at_first_height
+    {U : ℝ≥0 → ℝ} {γ : ℝ≥0 → ℂ} {G F : ℝ≥0 → ℂ → ℂ}
+    (hw : IsCapacityTwoWitness U γ G F) (hU : Continuous U)
+    (T : ℝ≥0) (hT : 0 < T) (hheight : 0 < (γ T).im)
+    (hfirst : ∀ u : ℝ≥0, u < T → (γ u).im < (γ T).im)
+    (w : ℂ) (p : Path (γ T) w) (hp : Function.Injective p)
+    (hpD : ∀ t, t ≠ 0 → p t ∈ survivingDomain γ T) :
+    ∃ q : Path (0 : ℂ) (G T w - (U T : ℂ)), Function.Injective q ∧
+      (∀ t, t ≠ 0 → q t ∈ upperHalfPlane) ∧
+      (∀ t, t ≠ 0 → F T (q t + (U T : ℂ)) = p t) := by
+  have hgi : InjOn (G T) (survivingDomain γ T) := by
+    intro z hz v hv he
+    calc
+      z = F T (G T z) := (hw.2.2.2.2.2.2.2.1 T z hz).symm
+      _ = F T (G T v) := congrArg (F T) he
+      _ = v := hw.2.2.2.2.2.2.2.1 T v hv
+  have htip : γ T ∉ survivingDomain γ T := by
+    intro hh
+    exact hh.1.2 (mem_image_of_mem γ ⟨zero_le, le_rfl⟩)
+  obtain ⟨q, hq, hqH, hqeq⟩ := map_out_simple_access_path
+    (survivingDomain γ T) (isOpen_survivingDomain hw.1 T) (G T)
+    (hw.2.2.2.1 T).continuousOn hgi (hw.2.2.2.2.2.1 T)
+    (γ T) w (U T) htip
+    (hw.fresh_tip_chart_tendsto hU hT
+      (tip_survives_prior_of_strict_height γ T hheight hfirst)) p hp hpD
+  refine ⟨q, hq, hqH, ?_⟩
+  intro t ht
+  rw [hqeq t ht, sub_add_cancel]
+  exact hw.2.2.2.2.2.2.2.1 T (p t) (hpD t ht)
+
+end SLEExactGauge
+
+end
+
+end OAI

lean/OAI/Probability/SLE/Loewner/FutureArcThinCrossing.lean

@@ -1,66 +1,66 @@
-import OAI.Probability.SLE.Loewner.InverseThinCollapse
-import OAI.Probability.SLE.Loewner.FutureSlitHeight
-import OAI.Probability.SLE.Loewner.MappedFutureRange
-
-namespace OAI
-
-/-! A real crossing of the actual mapped future supplies the small
-inverse values required by the Dirichlet-energy criterion. -/
-noncomputable section
-open Set Filter Function Complex Metric MeasureTheory
-open scoped Topology
-
-namespace SLEExactGauge
-
-theorem mappedFutureArc_thin_crossing (p : C(unitInterval,ℂ)) (hi : Injective p)
-    (h0 : p 0=0) (hH : ∀ t : unitInterval, t≠0 → p t∈upperHalfPlane)
-    {s t : unitInterval} (hst : s<t) (ht : t<1) {x ε : ℝ} (c : ℂ)
-    (hx : x∈Ioo (initialDrivingValue p hi h0 hH s (hst.trans ht))
-        (initialForwardChart p hi h0 hH s (p t)).re ∨
-      x∈Ioo (initialForwardChart p hi h0 hH s (p t)).re
-        (initialDrivingValue p hi h0 hH s (hst.trans ht)))
-    (hp : ∀ v∈Ioc s t, ‖p v-c‖≤ε) :
-    ∃ y∈Ioc 0 (Real.sqrt (2*(initialCapacity p hi h0 hH t-initialCapacity p hi h0 hH s))),
-      ‖initialInverseChart p hi h0 hH s ((x:ℂ)+(y:ℂ)*I)-c‖≤ε := by
-  let q := mappedFutureArc p hi h0 hH hst ht
-  have hq0 : (q 0).re=initialDrivingValue p hi h0 hH s (hst.trans ht) := by
-    simp [q]
-  have hq1 : q 1=initialForwardChart p hi h0 hH s (p t) := by
-    rw [mappedFutureArc_segment p hi h0 hH hst ht one_ne_zero,slitSegmentParameter_one]
-  have hcont : ContinuousOn (fun u => (q u).re) (Icc (0:unitInterval) 1) :=
-    (Complex.continuous_re.comp q.continuous).continuousOn
-  have hex : ∃ u∈Icc (0:unitInterval) 1, (q u).re=x := by
-    rcases hx with hx | hx
-    · apply intermediate_value_Icc (show (0:unitInterval)≤1 from zero_le_one) hcont
-      simpa only [hq0,hq1] using ⟨hx.1.le,hx.2.le⟩
-    · apply intermediate_value_Icc' (show (0:unitInterval)≤1 from zero_le_one) hcont
-      simpa only [hq0,hq1] using ⟨hx.1.le,hx.2.le⟩
-  obtain ⟨u,_,hux⟩ := hex
-  have hu : u≠0 := by
-    intro he
-    subst u
-    rw [hq0] at hux
-    rcases hx with hx | hx <;> linarith [hx.1,hx.2]
-  have hpos : 0<(q u).im := mappedFutureArc_upper p hi h0 hH hst ht hu
-  have him : (centeredFutureArc p hi h0 hH hst ht u).im=(q u).im := by
-    change (q u-(_ : ℂ)).im=(q u).im
-    simp only [sub_im,ofReal_im,sub_zero]
-  have hsq := centeredFutureArc_height_sq_le p hi h0 hH hst ht u
-  rw [him] at hsq
-  have hcap : 0≤2*(initialCapacity p hi h0 hH t-initialCapacity p hi h0 hH s) :=
-    mul_nonneg (by norm_num) (sub_nonneg.mpr (initialCapacity_monotone p hi h0 hH hst.le))
-  have hheight : (q u).im≤Real.sqrt (2*(initialCapacity p hi h0 hH t-initialCapacity p hi h0 hH s)) :=
-    (Real.le_sqrt hpos.le hcap).mpr hsq
-  have hcoord : (x:ℂ)+((q u).im:ℂ)*I=q u := by
-    apply Complex.ext <;> simp [hux]
-  refine ⟨(q u).im,⟨hpos,hheight⟩,?_⟩
-  rw [hcoord,mappedFutureArc_segment p hi h0 hH hst ht hu,
-    initialInverse_forward_at p hi h0 hH s
-      (point_after_prefix_mem_domain p hi hH (slitSegmentParameter_gt hst hu))]
-  exact hp _ ⟨slitSegmentParameter_gt hst hu,slitSegmentParameter_le s t hst.le u⟩
-
-end SLEExactGauge
-
-end
-
-end OAI
+import OAI.Probability.SLE.Loewner.InverseThinCollapse
+import OAI.Probability.SLE.Loewner.FutureSlitHeight
+import OAI.Probability.SLE.Loewner.MappedFutureRange
+
+namespace OAI
+
+/-! A real crossing of the actual mapped future supplies the small
+inverse values required by the Dirichlet-energy criterion. -/
+noncomputable section
+open Set Filter Function Complex Metric MeasureTheory
+open scoped Topology
+
+namespace SLEExactGauge
+
+theorem mappedFutureArc_thin_crossing (p : C(unitInterval,ℂ)) (hi : Injective p)
+    (h0 : p 0=0) (hH : ∀ t : unitInterval, t≠0 → p t∈upperHalfPlane)
+    {s t : unitInterval} (hst : s<t) (ht : t<1) {x ε : ℝ} (c : ℂ)
+    (hx : x∈Ioo (initialDrivingValue p hi h0 hH s (hst.trans ht))
+        (initialForwardChart p hi h0 hH s (p t)).re ∨
+      x∈Ioo (initialForwardChart p hi h0 hH s (p t)).re
+        (initialDrivingValue p hi h0 hH s (hst.trans ht)))
+    (hp : ∀ v∈Ioc s t, ‖p v-c‖≤ε) :
+    ∃ y∈Ioc 0 (Real.sqrt (2*(initialCapacity p hi h0 hH t-initialCapacity p hi h0 hH s))),
+      ‖initialInverseChart p hi h0 hH s ((x:ℂ)+(y:ℂ)*I)-c‖≤ε := by
+  let q := mappedFutureArc p hi h0 hH hst ht
+  have hq0 : (q 0).re=initialDrivingValue p hi h0 hH s (hst.trans ht) := by
+    simp [q]
+  have hq1 : q 1=initialForwardChart p hi h0 hH s (p t) := by
+    rw [mappedFutureArc_segment p hi h0 hH hst ht one_ne_zero,slitSegmentParameter_one]
+  have hcont : ContinuousOn (fun u => (q u).re) (Icc (0:unitInterval) 1) :=
+    (Complex.continuous_re.comp q.continuous).continuousOn
+  have hex : ∃ u∈Icc (0:unitInterval) 1, (q u).re=x := by
+    rcases hx with hx | hx
+    · apply intermediate_value_Icc (show (0:unitInterval)≤1 from zero_le_one) hcont
+      simpa only [hq0,hq1] using ⟨hx.1.le,hx.2.le⟩
+    · apply intermediate_value_Icc' (show (0:unitInterval)≤1 from zero_le_one) hcont
+      simpa only [hq0,hq1] using ⟨hx.1.le,hx.2.le⟩
+  obtain ⟨u,_,hux⟩ := hex
+  have hu : u≠0 := by
+    intro he
+    subst u
+    rw [hq0] at hux
+    rcases hx with hx | hx <;> linarith [hx.1,hx.2]
+  have hpos : 0<(q u).im := mappedFutureArc_upper p hi h0 hH hst ht hu
+  have him : (centeredFutureArc p hi h0 hH hst ht u).im=(q u).im := by
+    change (q u-(_ : ℂ)).im=(q u).im
+    simp only [sub_im,ofReal_im,sub_zero]
+  have hsq := centeredFutureArc_height_sq_le p hi h0 hH hst ht u
+  rw [him] at hsq
+  have hcap : 0≤2*(initialCapacity p hi h0 hH t-initialCapacity p hi h0 hH s) :=
+    mul_nonneg (by norm_num) (sub_nonneg.mpr (initialCapacity_monotone p hi h0 hH hst.le))
+  have hheight : (q u).im≤Real.sqrt (2*(initialCapacity p hi h0 hH t-initialCapacity p hi h0 hH s)) :=
+    (Real.le_sqrt hpos.le hcap).mpr hsq
+  have hcoord : (x:ℂ)+((q u).im:ℂ)*I=q u := by
+    apply Complex.ext <;> simp [hux]
+  refine ⟨(q u).im,⟨hpos,hheight⟩,?_⟩
+  rw [hcoord,mappedFutureArc_segment p hi h0 hH hst ht hu,
+    initialInverse_forward_at p hi h0 hH s
+      (point_after_prefix_mem_domain p hi hH (slitSegmentParameter_gt hst hu))]
+  exact hp _ ⟨slitSegmentParameter_gt hst hu,slitSegmentParameter_le s t hst.le u⟩
+
+end SLEExactGauge
+
+end
+
+end OAI

lean/OAI/Probability/SLE/Loewner/FutureCapacityAdditive.lean

@@ -1,86 +1,86 @@
-import OAI.Probability.SLE.Loewner.FutureComposedCharts
-import OAI.Probability.SLE.Loewner.ShiftedHydrodynamicComposition
-import OAI.Probability.SLE.Loewner.SlitChartUniqueness
-
-namespace OAI
-
-/-! Removing an initial slit and its exact mapped future adds the two
-hydrodynamic capacities. The composed chart is the later normalized
-chart, including when the initial time is zero. -/
-noncomputable section
-open Set Filter Function Complex
-open scoped Topology
-
-namespace SLEExactGauge
-
-variable (p : C(unitInterval,ℂ)) (hi : Injective p) (h0 : p 0=0)
-  (hH : ∀ t : unitInterval, t≠0 → p t∈upperHalfPlane)
-  {s t : unitInterval} (hst : s<t) (ht : t<1)
-
-noncomputable def composedFutureSlitChart : SimpleSlitChart (initialSubarc p t) := by
-  have h := future_composed_chart_properties p hi h0 hH hst ht
-  have hG := h.1
-  have hF := h.2.1
-  have hGm := h.2.2.1
-  have hFm := h.2.2.2.1
-  have hl := h.2.2.2.2.1
-  have hr := h.2.2.2.2.2
-  let Q := futureSlitChart p hi h0 hH hst ht
-  let U := initialDrivingValue p hi h0 hH s (hst.trans ht)
-  refine ⟨futureComposedForward p hi h0 hH hst ht,
-    futureComposedInverse p hi h0 hH hst ht,initialCapacity p hi h0 hH s+Q.capacity,
-    add_pos_of_nonneg_of_pos (initialCapacity_nonneg p hi h0 hH s) Q.capacity_pos,
-    ?_,hG,hF,hFm,hl,hr,?_,?_,?_⟩
-  · refine ⟨hGm,?_,?_⟩
-    · intro z hz w hw he
-      have hh := congrArg (futureComposedInverse p hi h0 hH hst ht) he
-      simpa only [hl z hz,hl w hw] using hh
-    · intro w hw
-      exact ⟨_,hFm hw,hr w hw⟩
-  · simpa only [futureComposedForward,ofReal_add] using
-      shifted_hydrodynamic_coefficient U (initialForwardChart_coefficient p hi h0 hH s) Q.coefficient
-  · exact shifted_inverse_normalized U (initialInverseChart_normalized p hi h0 hH s)
-      Q.inverse_normalized (fun _ hz => (Q.inverse_mapsTo hz).1)
-  · intro z hz
-    have hsub : z∈upperHalfPlane \ range (initialSubarc p s) :=
-      ⟨hz.1,fun he => hz.2 (initialSubarc_range_mono p hst.le he)⟩
-    have hd := (initialForward_centered_bijOn p hi h0 hH hst ht).mapsTo hz
-    have hh := Q.height_le _ hd
-    change (Q.forward (initialForwardChart p hi h0 hH s z-(U:ℂ))).im≤
-      (initialForwardChart p hi h0 hH s z-(U:ℂ)).im at hh
-    simp only [sub_im,ofReal_im,sub_zero] at hh
-    change ((U:ℂ)+Q.forward (initialForwardChart p hi h0 hH s z-(U:ℂ))).im≤z.im
-    simpa only [add_im,ofReal_im,zero_add] using
-      hh.trans (initialForwardChart_height_le p hi h0 hH s hsub)
-
-theorem futureSlitChart_capacity_eq :
-    (futureSlitChart p hi h0 hH hst ht).capacity=
-      initialCapacity p hi h0 hH t-initialCapacity p hi h0 hH s := by
-  have ht0 : t≠0 := ne_of_gt (lt_of_le_of_lt bot_le hst)
-  have hh := ((composedFutureSlitChart p hi h0 hH hst ht).unique_on_domain
-    (initialSlitChart p hi h0 hH t ht0)).2.2
-  change initialCapacity p hi h0 hH s+(futureSlitChart p hi h0 hH hst ht).capacity=
-    (initialSlitChart p hi h0 hH t ht0).capacity at hh
-  rw [initialCapacity,dite_eq_right ht0]
-  linarith
-
-theorem futureComposedForward_eq {z : ℂ}
-    (hz : z∈upperHalfPlane \ range (initialSubarc p t)) :
-    futureComposedForward p hi h0 hH hst ht z=initialForwardChart p hi h0 hH t z := by
-  have ht0 : t≠0 := ne_of_gt (lt_of_le_of_lt bot_le hst)
-  have hh := ((composedFutureSlitChart p hi h0 hH hst ht).unique_on_domain
-    (initialSlitChart p hi h0 hH t ht0)).1 hz
-  simpa only [composedFutureSlitChart,initialForwardChart,dite_eq_right ht0] using hh
-
-theorem futureComposedInverse_eq {z : ℂ} (hz : z∈upperHalfPlane) :
-    futureComposedInverse p hi h0 hH hst ht z=initialInverseChart p hi h0 hH t z := by
-  have ht0 : t≠0 := ne_of_gt (lt_of_le_of_lt bot_le hst)
-  have hh := ((composedFutureSlitChart p hi h0 hH hst ht).unique_on_domain
-    (initialSlitChart p hi h0 hH t ht0)).2.1 hz
-  simpa only [composedFutureSlitChart,initialInverseChart,dite_eq_right ht0] using hh
-
-end SLEExactGauge
-
-end
-
-end OAI
+import OAI.Probability.SLE.Loewner.FutureComposedCharts
+import OAI.Probability.SLE.Loewner.ShiftedHydrodynamicComposition
+import OAI.Probability.SLE.Loewner.SlitChartUniqueness
+
+namespace OAI
+
+/-! Removing an initial slit and its exact mapped future adds the two
+hydrodynamic capacities. The composed chart is the later normalized
+chart, including when the initial time is zero. -/
+noncomputable section
+open Set Filter Function Complex
+open scoped Topology
+
+namespace SLEExactGauge
+
+variable (p : C(unitInterval,ℂ)) (hi : Injective p) (h0 : p 0=0)
+  (hH : ∀ t : unitInterval, t≠0 → p t∈upperHalfPlane)
+  {s t : unitInterval} (hst : s<t) (ht : t<1)
+
+noncomputable def composedFutureSlitChart : SimpleSlitChart (initialSubarc p t) := by
+  have h := future_composed_chart_properties p hi h0 hH hst ht
+  have hG := h.1
+  have hF := h.2.1
+  have hGm := h.2.2.1
+  have hFm := h.2.2.2.1
+  have hl := h.2.2.2.2.1
+  have hr := h.2.2.2.2.2
+  let Q := futureSlitChart p hi h0 hH hst ht
+  let U := initialDrivingValue p hi h0 hH s (hst.trans ht)
+  refine ⟨futureComposedForward p hi h0 hH hst ht,
+    futureComposedInverse p hi h0 hH hst ht,initialCapacity p hi h0 hH s+Q.capacity,
+    add_pos_of_nonneg_of_pos (initialCapacity_nonneg p hi h0 hH s) Q.capacity_pos,
+    ?_,hG,hF,hFm,hl,hr,?_,?_,?_⟩
+  · refine ⟨hGm,?_,?_⟩
+    · intro z hz w hw he
+      have hh := congrArg (futureComposedInverse p hi h0 hH hst ht) he
+      simpa only [hl z hz,hl w hw] using hh
+    · intro w hw
+      exact ⟨_,hFm hw,hr w hw⟩
+  · simpa only [futureComposedForward,ofReal_add] using
+      shifted_hydrodynamic_coefficient U (initialForwardChart_coefficient p hi h0 hH s) Q.coefficient
+  · exact shifted_inverse_normalized U (initialInverseChart_normalized p hi h0 hH s)
+      Q.inverse_normalized (fun _ hz => (Q.inverse_mapsTo hz).1)
+  · intro z hz
+    have hsub : z∈upperHalfPlane \ range (initialSubarc p s) :=
+      ⟨hz.1,fun he => hz.2 (initialSubarc_range_mono p hst.le he)⟩
+    have hd := (initialForward_centered_bijOn p hi h0 hH hst ht).mapsTo hz
+    have hh := Q.height_le _ hd
+    change (Q.forward (initialForwardChart p hi h0 hH s z-(U:ℂ))).im≤
+      (initialForwardChart p hi h0 hH s z-(U:ℂ)).im at hh
+    simp only [sub_im,ofReal_im,sub_zero] at hh
+    change ((U:ℂ)+Q.forward (initialForwardChart p hi h0 hH s z-(U:ℂ))).im≤z.im
+    simpa only [add_im,ofReal_im,zero_add] using
+      hh.trans (initialForwardChart_height_le p hi h0 hH s hsub)
+
+theorem futureSlitChart_capacity_eq :
+    (futureSlitChart p hi h0 hH hst ht).capacity=
+      initialCapacity p hi h0 hH t-initialCapacity p hi h0 hH s := by
+  have ht0 : t≠0 := ne_of_gt (lt_of_le_of_lt bot_le hst)
+  have hh := ((composedFutureSlitChart p hi h0 hH hst ht).unique_on_domain
+    (initialSlitChart p hi h0 hH t ht0)).2.2
+  change initialCapacity p hi h0 hH s+(futureSlitChart p hi h0 hH hst ht).capacity=
+    (initialSlitChart p hi h0 hH t ht0).capacity at hh
+  rw [initialCapacity,dite_eq_right ht0]
+  linarith
+
+theorem futureComposedForward_eq {z : ℂ}
+    (hz : z∈upperHalfPlane \ range (initialSubarc p t)) :
+    futureComposedForward p hi h0 hH hst ht z=initialForwardChart p hi h0 hH t z := by
+  have ht0 : t≠0 := ne_of_gt (lt_of_le_of_lt bot_le hst)
+  have hh := ((composedFutureSlitChart p hi h0 hH hst ht).unique_on_domain
+    (initialSlitChart p hi h0 hH t ht0)).1 hz
+  simpa only [composedFutureSlitChart,initialForwardChart,dite_eq_right ht0] using hh
+
+theorem futureComposedInverse_eq {z : ℂ} (hz : z∈upperHalfPlane) :
+    futureComposedInverse p hi h0 hH hst ht z=initialInverseChart p hi h0 hH t z := by
+  have ht0 : t≠0 := ne_of_gt (lt_of_le_of_lt bot_le hst)
+  have hh := ((composedFutureSlitChart p hi h0 hH hst ht).unique_on_domain
+    (initialSlitChart p hi h0 hH t ht0)).2.1 hz
+  simpa only [composedFutureSlitChart,initialInverseChart,dite_eq_right ht0] using hh
+
+end SLEExactGauge
+
+end
+
+end OAI

lean/OAI/Probability/SLE/Loewner/FutureComposedCharts.lean

@@ -1,94 +1,94 @@
-import OAI.Probability.SLE.Loewner.FutureSlitDomain
-import OAI.Probability.SLE.Loewner.InitialChartNormalization
-
-namespace OAI
-
-/-! Forward and inverse charts obtained by removing a future segment
-after an initial slit. The real translation keeps their normalization. -/
-noncomputable section
-open Set Filter Function Complex
-open scoped Topology
-
-namespace SLEExactGauge
-
-variable (p : C(unitInterval,ℂ)) (hi : Injective p) (h0 : p 0=0)
-  (hH : ∀ t : unitInterval, t≠0 → p t∈upperHalfPlane)
-  {s t : unitInterval} (hst : s<t) (ht : t<1)
-
-noncomputable def futureComposedForward (z : ℂ) : ℂ :=
-  (initialDrivingValue p hi h0 hH s (hst.trans ht):ℂ)+
-    (futureSlitChart p hi h0 hH hst ht).forward
-      (initialForwardChart p hi h0 hH s z-
-        (initialDrivingValue p hi h0 hH s (hst.trans ht):ℂ))
-
-noncomputable def futureComposedInverse (z : ℂ) : ℂ :=
-  initialInverseChart p hi h0 hH s
-    ((initialDrivingValue p hi h0 hH s (hst.trans ht):ℂ)+
-      (futureSlitChart p hi h0 hH hst ht).inverse
-        (z-(initialDrivingValue p hi h0 hH s (hst.trans ht):ℂ)))
-
-theorem future_composed_chart_properties :
-    DifferentiableOn ℂ (futureComposedForward p hi h0 hH hst ht)
-      (upperHalfPlane \ range (initialSubarc p t)) ∧
-    DifferentiableOn ℂ (futureComposedInverse p hi h0 hH hst ht) upperHalfPlane ∧
-    MapsTo (futureComposedForward p hi h0 hH hst ht)
-      (upperHalfPlane \ range (initialSubarc p t)) upperHalfPlane ∧
-    MapsTo (futureComposedInverse p hi h0 hH hst ht)
-      upperHalfPlane (upperHalfPlane \ range (initialSubarc p t)) ∧
-    (∀ z∈upperHalfPlane \ range (initialSubarc p t),
-      futureComposedInverse p hi h0 hH hst ht (futureComposedForward p hi h0 hH hst ht z)=z) ∧
-    ∀ z∈upperHalfPlane,
-      futureComposedForward p hi h0 hH hst ht (futureComposedInverse p hi h0 hH hst ht z)=z := by
-  let U : ℝ := initialDrivingValue p hi h0 hH s (hst.trans ht)
-  let Q := futureSlitChart p hi h0 hH hst ht
-  have hshift : MapsTo (fun z : ℂ => z-(U:ℂ)) upperHalfPlane upperHalfPlane := by
-    intro z hz
-    change 0<(z-(U:ℂ)).im
-    simpa only [sub_im,ofReal_im,sub_zero] using (show 0<z.im from hz)
-  have hadd : MapsTo (fun z : ℂ => (U:ℂ)+z) upperHalfPlane upperHalfPlane := by
-    intro z hz
-    change 0<((U:ℂ)+z).im
-    simpa only [add_im,ofReal_im,zero_add] using (show 0<z.im from hz)
-  have hsub : upperHalfPlane \ range (initialSubarc p t) ⊆
-      upperHalfPlane \ range (initialSubarc p s) := by
-    intro z hz
-    exact ⟨hz.1,fun he => hz.2 (initialSubarc_range_mono p hst.le he)⟩
-  have hA := initialForward_centered_bijOn p hi h0 hH hst ht
-  have hJH : MapsTo Q.inverse upperHalfPlane upperHalfPlane :=
-    fun _ hz => (Q.inverse_mapsTo hz).1
-  have hinner : MapsTo (fun z : ℂ => (U:ℂ)+Q.inverse (z-(U:ℂ)))
-      upperHalfPlane upperHalfPlane := hadd.comp (hJH.comp hshift)
-  have hFin : MapsTo (futureComposedInverse p hi h0 hH hst ht)
-      upperHalfPlane (upperHalfPlane \ range (initialSubarc p t)) := by
-    intro z hz
-    have hb := initialInverseChart_mem_domain p hi h0 hH s (hinner hz)
-    apply (initialForward_centered_mem_domain_iff p hi h0 hH hst ht hb).mp
-    change initialForwardChart p hi h0 hH s
-      (initialInverseChart p hi h0 hH s ((U:ℂ)+Q.inverse (z-(U:ℂ))))-(U:ℂ)∈
-        upperHalfPlane \ range (centeredFutureArc p hi h0 hH hst ht)
-    rw [initialForward_inverse p hi h0 hH s (hinner hz),add_sub_cancel_left]
-    exact Q.inverse_mapsTo (hshift hz)
-  refine ⟨?_,?_,?_,hFin,?_,?_⟩
-  · apply DifferentiableOn.const_add
-    exact Q.forward_differentiable.comp
-      (((initialForwardChart_differentiableOn_current p hi h0 hH s).mono hsub).sub_const _) hA.mapsTo
-  · exact (initialInverseChart_differentiableOn p hi h0 hH s).comp
-      ((Q.inverse_differentiable.comp (differentiableOn_id.sub_const _) hshift).const_add _) hinner
-  · intro z hz
-    exact hadd (Q.bijOn.mapsTo (hA.mapsTo hz))
-  · intro z hz
-    change initialInverseChart p hi h0 hH s ((U:ℂ)+Q.inverse
-      (((U:ℂ)+Q.forward (initialForwardChart p hi h0 hH s z-(U:ℂ)))-(U:ℂ)))=z
-    rw [add_sub_cancel_left,Q.left_inverse _ (hA.mapsTo hz),add_sub_cancel,
-      initialInverse_forward_at p hi h0 hH s (hsub hz)]
-  · intro z hz
-    change (U:ℂ)+Q.forward (initialForwardChart p hi h0 hH s
-      (initialInverseChart p hi h0 hH s ((U:ℂ)+Q.inverse (z-(U:ℂ))))-(U:ℂ))=z
-    rw [initialForward_inverse p hi h0 hH s (hinner hz),add_sub_cancel_left,
-      Q.right_inverse _ (hshift hz),add_sub_cancel]
-
-end SLEExactGauge
-
-end
-
-end OAI
+import OAI.Probability.SLE.Loewner.FutureSlitDomain
+import OAI.Probability.SLE.Loewner.InitialChartNormalization
+
+namespace OAI
+
+/-! Forward and inverse charts obtained by removing a future segment
+after an initial slit. The real translation keeps their normalization. -/
+noncomputable section
+open Set Filter Function Complex
+open scoped Topology
+
+namespace SLEExactGauge
+
+variable (p : C(unitInterval,ℂ)) (hi : Injective p) (h0 : p 0=0)
+  (hH : ∀ t : unitInterval, t≠0 → p t∈upperHalfPlane)
+  {s t : unitInterval} (hst : s<t) (ht : t<1)
+
+noncomputable def futureComposedForward (z : ℂ) : ℂ :=
+  (initialDrivingValue p hi h0 hH s (hst.trans ht):ℂ)+
+    (futureSlitChart p hi h0 hH hst ht).forward
+      (initialForwardChart p hi h0 hH s z-
+        (initialDrivingValue p hi h0 hH s (hst.trans ht):ℂ))
+
+noncomputable def futureComposedInverse (z : ℂ) : ℂ :=
+  initialInverseChart p hi h0 hH s
+    ((initialDrivingValue p hi h0 hH s (hst.trans ht):ℂ)+
+      (futureSlitChart p hi h0 hH hst ht).inverse
+        (z-(initialDrivingValue p hi h0 hH s (hst.trans ht):ℂ)))
+
+theorem future_composed_chart_properties :
+    DifferentiableOn ℂ (futureComposedForward p hi h0 hH hst ht)
+      (upperHalfPlane \ range (initialSubarc p t)) ∧
+    DifferentiableOn ℂ (futureComposedInverse p hi h0 hH hst ht) upperHalfPlane ∧
+    MapsTo (futureComposedForward p hi h0 hH hst ht)
+      (upperHalfPlane \ range (initialSubarc p t)) upperHalfPlane ∧
+    MapsTo (futureComposedInverse p hi h0 hH hst ht)
+      upperHalfPlane (upperHalfPlane \ range (initialSubarc p t)) ∧
+    (∀ z∈upperHalfPlane \ range (initialSubarc p t),
+      futureComposedInverse p hi h0 hH hst ht (futureComposedForward p hi h0 hH hst ht z)=z) ∧
+    ∀ z∈upperHalfPlane,
+      futureComposedForward p hi h0 hH hst ht (futureComposedInverse p hi h0 hH hst ht z)=z := by
+  let U : ℝ := initialDrivingValue p hi h0 hH s (hst.trans ht)
+  let Q := futureSlitChart p hi h0 hH hst ht
+  have hshift : MapsTo (fun z : ℂ => z-(U:ℂ)) upperHalfPlane upperHalfPlane := by
+    intro z hz
+    change 0<(z-(U:ℂ)).im
+    simpa only [sub_im,ofReal_im,sub_zero] using (show 0<z.im from hz)
+  have hadd : MapsTo (fun z : ℂ => (U:ℂ)+z) upperHalfPlane upperHalfPlane := by
+    intro z hz
+    change 0<((U:ℂ)+z).im
+    simpa only [add_im,ofReal_im,zero_add] using (show 0<z.im from hz)
+  have hsub : upperHalfPlane \ range (initialSubarc p t) ⊆
+      upperHalfPlane \ range (initialSubarc p s) := by
+    intro z hz
+    exact ⟨hz.1,fun he => hz.2 (initialSubarc_range_mono p hst.le he)⟩
+  have hA := initialForward_centered_bijOn p hi h0 hH hst ht
+  have hJH : MapsTo Q.inverse upperHalfPlane upperHalfPlane :=
+    fun _ hz => (Q.inverse_mapsTo hz).1
+  have hinner : MapsTo (fun z : ℂ => (U:ℂ)+Q.inverse (z-(U:ℂ)))
+      upperHalfPlane upperHalfPlane := hadd.comp (hJH.comp hshift)
+  have hFin : MapsTo (futureComposedInverse p hi h0 hH hst ht)
+      upperHalfPlane (upperHalfPlane \ range (initialSubarc p t)) := by
+    intro z hz
+    have hb := initialInverseChart_mem_domain p hi h0 hH s (hinner hz)
+    apply (initialForward_centered_mem_domain_iff p hi h0 hH hst ht hb).mp
+    change initialForwardChart p hi h0 hH s
+      (initialInverseChart p hi h0 hH s ((U:ℂ)+Q.inverse (z-(U:ℂ))))-(U:ℂ)∈
+        upperHalfPlane \ range (centeredFutureArc p hi h0 hH hst ht)
+    rw [initialForward_inverse p hi h0 hH s (hinner hz),add_sub_cancel_left]
+    exact Q.inverse_mapsTo (hshift hz)
+  refine ⟨?_,?_,?_,hFin,?_,?_⟩
+  · apply DifferentiableOn.const_add
+    exact Q.forward_differentiable.comp
+      (((initialForwardChart_differentiableOn_current p hi h0 hH s).mono hsub).sub_const _) hA.mapsTo
+  · exact (initialInverseChart_differentiableOn p hi h0 hH s).comp
+      ((Q.inverse_differentiable.comp (differentiableOn_id.sub_const _) hshift).const_add _) hinner
+  · intro z hz
+    exact hadd (Q.bijOn.mapsTo (hA.mapsTo hz))
+  · intro z hz
+    change initialInverseChart p hi h0 hH s ((U:ℂ)+Q.inverse
+      (((U:ℂ)+Q.forward (initialForwardChart p hi h0 hH s z-(U:ℂ)))-(U:ℂ)))=z
+    rw [add_sub_cancel_left,Q.left_inverse _ (hA.mapsTo hz),add_sub_cancel,
+      initialInverse_forward_at p hi h0 hH s (hsub hz)]
+  · intro z hz
+    change (U:ℂ)+Q.forward (initialForwardChart p hi h0 hH s
+      (initialInverseChart p hi h0 hH s ((U:ℂ)+Q.inverse (z-(U:ℂ))))-(U:ℂ))=z
+    rw [initialForward_inverse p hi h0 hH s (hinner hz),add_sub_cancel_left,
+      Q.right_inverse _ (hshift hz),add_sub_cancel]
+
+end SLEExactGauge
+
+end
+
+end OAI

lean/OAI/Probability/SLE/Loewner/FutureSlitDomain.lean

@@ -1,94 +1,94 @@
-import OAI.Probability.SLE.Loewner.MappedFutureRange
-
-namespace OAI
-
-/-! Exact transport of the later slit complement to the centered future
-slit complement. -/
-noncomputable section
-open Set Filter Function Complex
-open scoped Topology
-
-namespace SLEExactGauge
-
-lemma initialInverseChart_mem_domain (p : C(unitInterval,ℂ)) (hi : Injective p)
-    (h0 : p 0=0) (hH : ∀ t : unitInterval, t≠0 → p t∈upperHalfPlane)
-    (s : unitInterval) {w : ℂ} (hw : w∈upperHalfPlane) :
-    initialInverseChart p hi h0 hH s w∈upperHalfPlane \ range (initialSubarc p s) := by
-  by_cases hs : s=0
-  · subst s
-    simp only [initialInverseChart_zero,id_eq]
-    refine ⟨hw,?_⟩
-    rintro ⟨u,hu⟩
-    have hw0 : w=0 := by simpa only [initialSubarc_apply,zero_mul,h0] using hu.symm
-    rw [hw0] at hw
-    exact (lt_irrefl (0:ℝ)) hw
-  · rw [initialInverseChart,dite_eq_right hs]
-    exact (initialSlitChart p hi h0 hH s hs).inverse_mapsTo hw
-
-lemma centeredFutureArc_range_iff (p : C(unitInterval,ℂ)) (hi : Injective p)
-    (h0 : p 0=0) (hH : ∀ t : unitInterval, t≠0 → p t∈upperHalfPlane)
-    {s t : unitInterval} (hst : s<t) (ht : t<1) (w : ℂ) :
-    w-(initialDrivingValue p hi h0 hH s (hst.trans ht):ℂ)∈
-        range (centeredFutureArc p hi h0 hH hst ht) ↔
-      w∈range (mappedFutureArc p hi h0 hH hst ht) := by
-  constructor
-  · rintro ⟨u,hu⟩
-    exact ⟨u,sub_left_inj.mp hu⟩
-  · rintro ⟨u,hu⟩
-    exact ⟨u,congrArg (fun z : ℂ => z-_) hu⟩
-
-lemma initialForward_centered_mem_domain_iff (p : C(unitInterval,ℂ)) (hi : Injective p)
-    (h0 : p 0=0) (hH : ∀ t : unitInterval, t≠0 → p t∈upperHalfPlane)
-    {s t : unitInterval} (hst : s<t) (ht : t<1)
-    {z : ℂ} (hz : z∈upperHalfPlane \ range (initialSubarc p s)) :
-    initialForwardChart p hi h0 hH s z-
-        (initialDrivingValue p hi h0 hH s (hst.trans ht):ℂ)∈
-      upperHalfPlane \ range (centeredFutureArc p hi h0 hH hst ht) ↔
-      z∈upperHalfPlane \ range (initialSubarc p t) := by
-  have hw := initialForwardChart_mem_upper p hi h0 hH s hz
-  have hshift : initialForwardChart p hi h0 hH s z-
-      (initialDrivingValue p hi h0 hH s (hst.trans ht):ℂ)∈upperHalfPlane := by
-    change 0<(_-(_ : ℂ)).im
-    change 0<(initialForwardChart p hi h0 hH s z).im at hw
-    simpa only [sub_im,ofReal_im,sub_zero] using hw
-  simp only [Set.mem_sdiff,hshift,hz.1,true_and,
-    centeredFutureArc_range_iff,initialForward_avoids_future_iff p hi h0 hH hst ht hz]
-
-theorem initialForward_centered_bijOn (p : C(unitInterval,ℂ)) (hi : Injective p)
-    (h0 : p 0=0) (hH : ∀ t : unitInterval, t≠0 → p t∈upperHalfPlane)
-    {s t : unitInterval} (hst : s<t) (ht : t<1) :
-    BijOn (fun z => initialForwardChart p hi h0 hH s z-
-      (initialDrivingValue p hi h0 hH s (hst.trans ht):ℂ))
-      (upperHalfPlane \ range (initialSubarc p t))
-      (upperHalfPlane \ range (centeredFutureArc p hi h0 hH hst ht)) := by
-  have hsub : upperHalfPlane \ range (initialSubarc p t) ⊆
-      upperHalfPlane \ range (initialSubarc p s) := by
-    intro z hz
-    exact ⟨hz.1,fun h => hz.2 (initialSubarc_range_mono p hst.le h)⟩
-  refine ⟨fun z hz => (initialForward_centered_mem_domain_iff p hi h0 hH hst ht
-    (hsub hz)).mpr hz,?_,?_⟩
-  · intro z hz w hw he
-    have hEq := congrArg (initialInverseChart p hi h0 hH s) (sub_left_inj.mp he)
-    simpa only [initialInverse_forward_at p hi h0 hH s (hsub hz),
-      initialInverse_forward_at p hi h0 hH s (hsub hw)] using hEq
-  · intro w hw
-    let U : ℝ := initialDrivingValue p hi h0 hH s (hst.trans ht)
-    have hwH : w+(U:ℂ)∈upperHalfPlane := by
-      change 0<(w+(U:ℂ)).im
-      simpa only [add_im,ofReal_im,add_zero] using (show 0<w.im from hw.1)
-    let z := initialInverseChart p hi h0 hH s (w+(U:ℂ))
-    have hz := initialInverseChart_mem_domain p hi h0 hH s hwH
-    have he : initialForwardChart p hi h0 hH s z-(U:ℂ)=w := by
-      rw [initialForward_inverse p hi h0 hH s hwH,add_sub_cancel_right]
-    refine ⟨z,?_,he⟩
-    apply (initialForward_centered_mem_domain_iff p hi h0 hH hst ht hz).mp
-    change initialForwardChart p hi h0 hH s z-(U:ℂ)∈
-      upperHalfPlane \ range (centeredFutureArc p hi h0 hH hst ht)
-    rw [he]
-    exact hw
-
-end SLEExactGauge
-
-end
-
-end OAI
+import OAI.Probability.SLE.Loewner.MappedFutureRange
+
+namespace OAI
+
+/-! Exact transport of the later slit complement to the centered future
+slit complement. -/
+noncomputable section
+open Set Filter Function Complex
+open scoped Topology
+
+namespace SLEExactGauge
+
+lemma initialInverseChart_mem_domain (p : C(unitInterval,ℂ)) (hi : Injective p)
+    (h0 : p 0=0) (hH : ∀ t : unitInterval, t≠0 → p t∈upperHalfPlane)
+    (s : unitInterval) {w : ℂ} (hw : w∈upperHalfPlane) :
+    initialInverseChart p hi h0 hH s w∈upperHalfPlane \ range (initialSubarc p s) := by
+  by_cases hs : s=0
+  · subst s
+    simp only [initialInverseChart_zero,id_eq]
+    refine ⟨hw,?_⟩
+    rintro ⟨u,hu⟩
+    have hw0 : w=0 := by simpa only [initialSubarc_apply,zero_mul,h0] using hu.symm
+    rw [hw0] at hw
+    exact (lt_irrefl (0:ℝ)) hw
+  · rw [initialInverseChart,dite_eq_right hs]
+    exact (initialSlitChart p hi h0 hH s hs).inverse_mapsTo hw
+
+lemma centeredFutureArc_range_iff (p : C(unitInterval,ℂ)) (hi : Injective p)
+    (h0 : p 0=0) (hH : ∀ t : unitInterval, t≠0 → p t∈upperHalfPlane)
+    {s t : unitInterval} (hst : s<t) (ht : t<1) (w : ℂ) :
+    w-(initialDrivingValue p hi h0 hH s (hst.trans ht):ℂ)∈
+        range (centeredFutureArc p hi h0 hH hst ht) ↔
+      w∈range (mappedFutureArc p hi h0 hH hst ht) := by
+  constructor
+  · rintro ⟨u,hu⟩
+    exact ⟨u,sub_left_inj.mp hu⟩
+  · rintro ⟨u,hu⟩
+    exact ⟨u,congrArg (fun z : ℂ => z-_) hu⟩
+
+lemma initialForward_centered_mem_domain_iff (p : C(unitInterval,ℂ)) (hi : Injective p)
+    (h0 : p 0=0) (hH : ∀ t : unitInterval, t≠0 → p t∈upperHalfPlane)
+    {s t : unitInterval} (hst : s<t) (ht : t<1)
+    {z : ℂ} (hz : z∈upperHalfPlane \ range (initialSubarc p s)) :
+    initialForwardChart p hi h0 hH s z-
+        (initialDrivingValue p hi h0 hH s (hst.trans ht):ℂ)∈
+      upperHalfPlane \ range (centeredFutureArc p hi h0 hH hst ht) ↔
+      z∈upperHalfPlane \ range (initialSubarc p t) := by
+  have hw := initialForwardChart_mem_upper p hi h0 hH s hz
+  have hshift : initialForwardChart p hi h0 hH s z-
+      (initialDrivingValue p hi h0 hH s (hst.trans ht):ℂ)∈upperHalfPlane := by
+    change 0<(_-(_ : ℂ)).im
+    change 0<(initialForwardChart p hi h0 hH s z).im at hw
+    simpa only [sub_im,ofReal_im,sub_zero] using hw
+  simp only [Set.mem_sdiff,hshift,hz.1,true_and,
+    centeredFutureArc_range_iff,initialForward_avoids_future_iff p hi h0 hH hst ht hz]
+
+theorem initialForward_centered_bijOn (p : C(unitInterval,ℂ)) (hi : Injective p)
+    (h0 : p 0=0) (hH : ∀ t : unitInterval, t≠0 → p t∈upperHalfPlane)
+    {s t : unitInterval} (hst : s<t) (ht : t<1) :
+    BijOn (fun z => initialForwardChart p hi h0 hH s z-
+      (initialDrivingValue p hi h0 hH s (hst.trans ht):ℂ))
+      (upperHalfPlane \ range (initialSubarc p t))
+      (upperHalfPlane \ range (centeredFutureArc p hi h0 hH hst ht)) := by
+  have hsub : upperHalfPlane \ range (initialSubarc p t) ⊆
+      upperHalfPlane \ range (initialSubarc p s) := by
+    intro z hz
+    exact ⟨hz.1,fun h => hz.2 (initialSubarc_range_mono p hst.le h)⟩
+  refine ⟨fun z hz => (initialForward_centered_mem_domain_iff p hi h0 hH hst ht
+    (hsub hz)).mpr hz,?_,?_⟩
+  · intro z hz w hw he
+    have hEq := congrArg (initialInverseChart p hi h0 hH s) (sub_left_inj.mp he)
+    simpa only [initialInverse_forward_at p hi h0 hH s (hsub hz),
+      initialInverse_forward_at p hi h0 hH s (hsub hw)] using hEq
+  · intro w hw
+    let U : ℝ := initialDrivingValue p hi h0 hH s (hst.trans ht)
+    have hwH : w+(U:ℂ)∈upperHalfPlane := by
+      change 0<(w+(U:ℂ)).im
+      simpa only [add_im,ofReal_im,add_zero] using (show 0<w.im from hw.1)
+    let z := initialInverseChart p hi h0 hH s (w+(U:ℂ))
+    have hz := initialInverseChart_mem_domain p hi h0 hH s hwH
+    have he : initialForwardChart p hi h0 hH s z-(U:ℂ)=w := by
+      rw [initialForward_inverse p hi h0 hH s hwH,add_sub_cancel_right]
+    refine ⟨z,?_,he⟩
+    apply (initialForward_centered_mem_domain_iff p hi h0 hH hst ht hz).mp
+    change initialForwardChart p hi h0 hH s z-(U:ℂ)∈
+      upperHalfPlane \ range (centeredFutureArc p hi h0 hH hst ht)
+    rw [he]
+    exact hw
+
+end SLEExactGauge
+
+end
+
+end OAI

lean/OAI/Probability/SLE/Loewner/FutureSlitHeight.lean

@@ -1,37 +1,37 @@
-import OAI.Probability.SLE.Loewner.InitialTipHeightBound
-import OAI.Probability.SLE.Loewner.FutureSlitRadius
-
-namespace OAI
-
-/-! Every point of a mapped future segment lies in a strip whose squared
-height is at most twice the exact remaining capacity. -/
-noncomputable section
-open Set Filter Function Complex
-open scoped Topology
-
-namespace SLEExactGauge
-
-theorem centeredFutureArc_height_sq_le (p : C(unitInterval,ℂ)) (hi : Injective p)
-    (h0 : p 0=0) (hH : ∀ t : unitInterval, t≠0 → p t∈upperHalfPlane)
-    {s t : unitInterval} (hst : s<t) (ht : t<1) (u : unitInterval) :
-    (centeredFutureArc p hi h0 hH hst ht u).im^2≤
-      2*(initialCapacity p hi h0 hH t-initialCapacity p hi h0 hH s) := by
-  by_cases hu : u=0
-  · subst u
-    simp only [centeredFutureArc_zero,zero_im,zero_pow two_ne_zero]
-    exact mul_nonneg (by norm_num) (sub_nonneg.mpr (initialCapacity_monotone p hi h0 hH hst.le))
-  have hv := slitSegmentParameter_le s t hst.le u
-  have hh := initialForward_tip_height_bound p hi h0 hH (slitSegmentParameter_gt hst hu)
-    (hv.trans_lt ht)
-  have he : (centeredFutureArc p hi h0 hH hst ht u).im=
-      (initialForwardChart p hi h0 hH s (p (slitSegmentParameter s t hst.le u))).im := by
-    change (mappedFutureArc p hi h0 hH hst ht u-(_ : ℂ)).im=_
-    rw [sub_im,ofReal_im,sub_zero,mappedFutureArc_segment p hi h0 hH hst ht hu]
-  rw [he]
-  exact hh.trans (by linarith [initialCapacity_monotone p hi h0 hH hv])
-
-end SLEExactGauge
-
-end
-
-end OAI
+import OAI.Probability.SLE.Loewner.InitialTipHeightBound
+import OAI.Probability.SLE.Loewner.FutureSlitRadius
+
+namespace OAI
+
+/-! Every point of a mapped future segment lies in a strip whose squared
+height is at most twice the exact remaining capacity. -/
+noncomputable section
+open Set Filter Function Complex
+open scoped Topology
+
+namespace SLEExactGauge
+
+theorem centeredFutureArc_height_sq_le (p : C(unitInterval,ℂ)) (hi : Injective p)
+    (h0 : p 0=0) (hH : ∀ t : unitInterval, t≠0 → p t∈upperHalfPlane)
+    {s t : unitInterval} (hst : s<t) (ht : t<1) (u : unitInterval) :
+    (centeredFutureArc p hi h0 hH hst ht u).im^2≤
+      2*(initialCapacity p hi h0 hH t-initialCapacity p hi h0 hH s) := by
+  by_cases hu : u=0
+  · subst u
+    simp only [centeredFutureArc_zero,zero_im,zero_pow two_ne_zero]
+    exact mul_nonneg (by norm_num) (sub_nonneg.mpr (initialCapacity_monotone p hi h0 hH hst.le))
+  have hv := slitSegmentParameter_le s t hst.le u
+  have hh := initialForward_tip_height_bound p hi h0 hH (slitSegmentParameter_gt hst hu)
+    (hv.trans_lt ht)
+  have he : (centeredFutureArc p hi h0 hH hst ht u).im=
+      (initialForwardChart p hi h0 hH s (p (slitSegmentParameter s t hst.le u))).im := by
+    change (mappedFutureArc p hi h0 hH hst ht u-(_ : ℂ)).im=_
+    rw [sub_im,ofReal_im,sub_zero,mappedFutureArc_segment p hi h0 hH hst ht hu]
+  rw [he]
+  exact hh.trans (by linarith [initialCapacity_monotone p hi h0 hH hv])
+
+end SLEExactGauge
+
+end
+
+end OAI

lean/OAI/Probability/SLE/Loewner/FutureSlitRadius.lean

@@ -1,55 +1,55 @@
-import OAI.Probability.SLE.Geometry.CenteredFutureSlit
-import OAI.Probability.SLE.Loewner.CapacityRadiusBound
-
-namespace OAI
-
-/-! The complete mapped future slit shrinks to the driving value as its
-terminal time decreases to the current time. -/
-noncomputable section
-open Set Filter Function Metric Complex
-open scoped Topology
-
-namespace SLEExactGauge
-
-theorem centeredFutureArc_small (p : C(unitInterval,ℂ)) (hi : Injective p)
-    (h0 : p 0=0) (hH : ∀ t : unitInterval, t≠0 → p t∈upperHalfPlane)
-    (s : unitInterval) (hs : s<1) {ε : ℝ} (hε : 0<ε) :
-    ∃ δ : ℝ, 0<δ ∧ ∀ (t : unitInterval) (hst : s<t) (ht : t<1),
-      (t:ℝ)-(s:ℝ)<δ → ∀ u : unitInterval,
-        ‖centeredFutureArc p hi h0 hH hst ht u‖<ε := by
-  have hn := Metric.tendsto_nhds.mp (initialDrivingValue_spec p hi h0 hH s hs) ε hε
-  obtain ⟨δ,hδ,hnear⟩ := Metric.mem_nhdsWithin_iff.mp hn
-  refine ⟨δ,hδ,fun t hst ht htd u => ?_⟩
-  by_cases hu : u=0
-  · subst u
-    simpa only [centeredFutureArc_zero,norm_zero] using hε
-  have hp : 0<(u:ℝ) := unitInterval.pos_iff_ne_zero.mpr hu
-  have hd : 0<(t:ℝ)-(s:ℝ) := sub_pos.mpr hst
-  have hrpos : 0<((t:ℝ)-(s:ℝ))*(u:ℝ) := mul_pos hd hp
-  have hrlt : ((t:ℝ)-(s:ℝ))*(u:ℝ)<δ := by
-    have hm := mul_le_mul_of_nonneg_left u.property.2 hd.le
-    linarith
-  have he := hnear (show ((t:ℝ)-(s:ℝ))*(u:ℝ)∈ball (0:ℝ) δ ∩ Ioi 0 from
-    ⟨by simpa only [mem_ball,Real.dist_eq,sub_zero,abs_of_pos hrpos] using hrlt,hrpos⟩)
-  change ‖mappedFutureArc p hi h0 hH hst ht u-(_ : ℂ)‖<ε
-  rw [mappedFutureArc_of_ne_zero p hi h0 hH hst ht hu]
-  change dist (initialForwardChart p hi h0 hH s
-    (p (slitFutureParameter s (((t:ℝ)-(s:ℝ))*(u:ℝ)))))
-      (initialDrivingValue p hi h0 hH s hs:ℂ)<ε at he
-  simpa only [mappedFutureRaw,dist_eq_norm] using he
-
-theorem futureSlitChart_capacity_small (p : C(unitInterval,ℂ)) (hi : Injective p)
-    (h0 : p 0=0) (hH : ∀ t : unitInterval, t≠0 → p t∈upperHalfPlane)
-    (s : unitInterval) (hs : s<1) {ε : ℝ} (hε : 0<ε) :
-    ∃ δ : ℝ, 0<δ ∧ ∀ (t : unitInterval) (hst : s<t) (ht : t<1),
-      (t:ℝ)-(s:ℝ)<δ → (futureSlitChart p hi h0 hH hst ht).capacity≤ε^2 := by
-  obtain ⟨δ,hδ,hm⟩ := centeredFutureArc_small p hi h0 hH s hs hε
-  exact ⟨δ,hδ,fun t hst ht htd =>
-    (futureSlitChart p hi h0 hH hst ht).capacity_le_radius_sq hε
-      (fun u => (hm t hst ht htd u).le)⟩
-
-end SLEExactGauge
-
-end
-
-end OAI
+import OAI.Probability.SLE.Geometry.CenteredFutureSlit
+import OAI.Probability.SLE.Loewner.CapacityRadiusBound
+
+namespace OAI
+
+/-! The complete mapped future slit shrinks to the driving value as its
+terminal time decreases to the current time. -/
+noncomputable section
+open Set Filter Function Metric Complex
+open scoped Topology
+
+namespace SLEExactGauge
+
+theorem centeredFutureArc_small (p : C(unitInterval,ℂ)) (hi : Injective p)
+    (h0 : p 0=0) (hH : ∀ t : unitInterval, t≠0 → p t∈upperHalfPlane)
+    (s : unitInterval) (hs : s<1) {ε : ℝ} (hε : 0<ε) :
+    ∃ δ : ℝ, 0<δ ∧ ∀ (t : unitInterval) (hst : s<t) (ht : t<1),
+      (t:ℝ)-(s:ℝ)<δ → ∀ u : unitInterval,
+        ‖centeredFutureArc p hi h0 hH hst ht u‖<ε := by
+  have hn := Metric.tendsto_nhds.mp (initialDrivingValue_spec p hi h0 hH s hs) ε hε
+  obtain ⟨δ,hδ,hnear⟩ := Metric.mem_nhdsWithin_iff.mp hn
+  refine ⟨δ,hδ,fun t hst ht htd u => ?_⟩
+  by_cases hu : u=0
+  · subst u
+    simpa only [centeredFutureArc_zero,norm_zero] using hε
+  have hp : 0<(u:ℝ) := unitInterval.pos_iff_ne_zero.mpr hu
+  have hd : 0<(t:ℝ)-(s:ℝ) := sub_pos.mpr hst
+  have hrpos : 0<((t:ℝ)-(s:ℝ))*(u:ℝ) := mul_pos hd hp
+  have hrlt : ((t:ℝ)-(s:ℝ))*(u:ℝ)<δ := by
+    have hm := mul_le_mul_of_nonneg_left u.property.2 hd.le
+    linarith
+  have he := hnear (show ((t:ℝ)-(s:ℝ))*(u:ℝ)∈ball (0:ℝ) δ ∩ Ioi 0 from
+    ⟨by simpa only [mem_ball,Real.dist_eq,sub_zero,abs_of_pos hrpos] using hrlt,hrpos⟩)
+  change ‖mappedFutureArc p hi h0 hH hst ht u-(_ : ℂ)‖<ε
+  rw [mappedFutureArc_of_ne_zero p hi h0 hH hst ht hu]
+  change dist (initialForwardChart p hi h0 hH s
+    (p (slitFutureParameter s (((t:ℝ)-(s:ℝ))*(u:ℝ)))))
+      (initialDrivingValue p hi h0 hH s hs:ℂ)<ε at he
+  simpa only [mappedFutureRaw,dist_eq_norm] using he
+
+theorem futureSlitChart_capacity_small (p : C(unitInterval,ℂ)) (hi : Injective p)
+    (h0 : p 0=0) (hH : ∀ t : unitInterval, t≠0 → p t∈upperHalfPlane)
+    (s : unitInterval) (hs : s<1) {ε : ℝ} (hε : 0<ε) :
+    ∃ δ : ℝ, 0<δ ∧ ∀ (t : unitInterval) (hst : s<t) (ht : t<1),
+      (t:ℝ)-(s:ℝ)<δ → (futureSlitChart p hi h0 hH hst ht).capacity≤ε^2 := by
+  obtain ⟨δ,hδ,hm⟩ := centeredFutureArc_small p hi h0 hH s hs hε
+  exact ⟨δ,hδ,fun t hst ht htd =>
+    (futureSlitChart p hi h0 hH hst ht).capacity_le_radius_sq hε
+      (fun u => (hm t hst ht htd u).le)⟩
+
+end SLEExactGauge
+
+end
+
+end OAI

lean/OAI/Probability/SLE/Loewner/HalfPlaneDisplacementBound.lean

@@ -1,56 +1,56 @@
-import OAI.Probability.SLE.Mass.HalfPlaneZeroMass
-
-namespace OAI
-
-/-! The total hydrodynamic mass bounds a nonnegative-imaginary displacement. -/
-noncomputable section
-open Set Filter Complex Function Metric
-open scoped Topology
-
-namespace SLEExactGauge
-
-lemma hydrodynamic_vertical_limits {f : ℂ → ℂ} {c : ℝ}
-    (hcoef : Tendsto (fun z : ℂ => z*f z)
-      (cocompact ℂ ⊓ 𝓟 upperHalfPlane) (𝓝 (-c:ℂ))) :
-    Tendsto (fun n : ℕ => f (verticalInfinity n)) atTop (𝓝 0) ∧
-      Tendsto (fun n : ℕ => ((n:ℝ)+1)*(f (verticalInfinity n)).im) atTop (𝓝 c) := by
-  have hp := hcoef.comp verticalInfinity_tendsto
-  have hi : Tendsto (fun z : ℂ => z⁻¹) (cocompact ℂ) (𝓝 0) := by
-    simpa only [Metric.cobounded_eq_cocompact] using
-      (tendsto_inv₀_cobounded : Tendsto (fun z : ℂ => z⁻¹) (Bornology.cobounded ℂ) (𝓝 0))
-  have hh := hp.mul (hi.comp (verticalInfinity_tendsto.mono_right inf_le_left))
-  have hzero : Tendsto (fun n : ℕ => f (verticalInfinity n)) atTop (𝓝 0) := by
-    simp only [mul_zero] at hh
-    apply hh.congr
-    intro n
-    have hn : verticalInfinity n ≠ 0 := by
-      intro he
-      have hv := verticalInfinity_mem n
-      simp only [upperHalfPlane,mem_ofPred_eq,he,zero_im,lt_self_iff_false] at hv
-    simp only [Function.comp_apply]
-    field_simp [hn]
-  refine ⟨hzero,?_⟩
-  have ht := (Complex.continuous_re.tendsto (-c:ℂ) |>.comp hp).neg
-  simpa only [Function.comp_apply,verticalInfinity,mul_re,mul_im,ofReal_re,ofReal_im,
-    I_re,I_im,mul_zero,zero_mul,add_zero,mul_one,neg_re,neg_neg,neg_zero,zero_sub] using ht
-
-lemma nonnegative_im_hydrodynamic_bound {f : ℂ → ℂ} {c : ℝ}
-    (hf : DifferentiableOn ℂ f upperHalfPlane)
-    (hm : ∀ z∈upperHalfPlane, 0≤(f z).im) (hc : 0≤c)
-    (hcoef : Tendsto (fun z : ℂ => z*f z)
-      (cocompact ℂ ⊓ 𝓟 upperHalfPlane) (𝓝 (-c:ℂ)))
-    {z : ℂ} (hz : z∈upperHalfPlane) : ‖f z‖≤c/z.im := by
-  obtain ⟨hzero,hmass⟩ := hydrodynamic_vertical_limits hcoef
-  rcases holomorphic_nonnegative_im_dichotomy hf hm with ⟨a,ha⟩ | hpos
-  · have ht : Tendsto (fun _ : ℕ => a) atTop (𝓝 0) :=
-      hzero.congr (fun n => ha _ (verticalInfinity_mem n))
-    have ha0 : a=0 := tendsto_nhds_unique tendsto_const_nhds ht
-    rw [ha z hz,ha0,norm_zero]
-    exact div_nonneg hc (show 0<z.im from hz).le
-  · exact norm_le_mass_div_height hz hc (halfPlane_vanishing_mass_bound hf hpos hzero hmass hz)
-
-end SLEExactGauge
-
-end
-
-end OAI
+import OAI.Probability.SLE.Mass.HalfPlaneZeroMass
+
+namespace OAI
+
+/-! The total hydrodynamic mass bounds a nonnegative-imaginary displacement. -/
+noncomputable section
+open Set Filter Complex Function Metric
+open scoped Topology
+
+namespace SLEExactGauge
+
+lemma hydrodynamic_vertical_limits {f : ℂ → ℂ} {c : ℝ}
+    (hcoef : Tendsto (fun z : ℂ => z*f z)
+      (cocompact ℂ ⊓ 𝓟 upperHalfPlane) (𝓝 (-c:ℂ))) :
+    Tendsto (fun n : ℕ => f (verticalInfinity n)) atTop (𝓝 0) ∧
+      Tendsto (fun n : ℕ => ((n:ℝ)+1)*(f (verticalInfinity n)).im) atTop (𝓝 c) := by
+  have hp := hcoef.comp verticalInfinity_tendsto
+  have hi : Tendsto (fun z : ℂ => z⁻¹) (cocompact ℂ) (𝓝 0) := by
+    simpa only [Metric.cobounded_eq_cocompact] using
+      (tendsto_inv₀_cobounded : Tendsto (fun z : ℂ => z⁻¹) (Bornology.cobounded ℂ) (𝓝 0))
+  have hh := hp.mul (hi.comp (verticalInfinity_tendsto.mono_right inf_le_left))
+  have hzero : Tendsto (fun n : ℕ => f (verticalInfinity n)) atTop (𝓝 0) := by
+    simp only [mul_zero] at hh
+    apply hh.congr
+    intro n
+    have hn : verticalInfinity n ≠ 0 := by
+      intro he
+      have hv := verticalInfinity_mem n
+      simp only [upperHalfPlane,mem_ofPred_eq,he,zero_im,lt_self_iff_false] at hv
+    simp only [Function.comp_apply]
+    field_simp [hn]
+  refine ⟨hzero,?_⟩
+  have ht := (Complex.continuous_re.tendsto (-c:ℂ) |>.comp hp).neg
+  simpa only [Function.comp_apply,verticalInfinity,mul_re,mul_im,ofReal_re,ofReal_im,
+    I_re,I_im,mul_zero,zero_mul,add_zero,mul_one,neg_re,neg_neg,neg_zero,zero_sub] using ht
+
+lemma nonnegative_im_hydrodynamic_bound {f : ℂ → ℂ} {c : ℝ}
+    (hf : DifferentiableOn ℂ f upperHalfPlane)
+    (hm : ∀ z∈upperHalfPlane, 0≤(f z).im) (hc : 0≤c)
+    (hcoef : Tendsto (fun z : ℂ => z*f z)
+      (cocompact ℂ ⊓ 𝓟 upperHalfPlane) (𝓝 (-c:ℂ)))
+    {z : ℂ} (hz : z∈upperHalfPlane) : ‖f z‖≤c/z.im := by
+  obtain ⟨hzero,hmass⟩ := hydrodynamic_vertical_limits hcoef
+  rcases holomorphic_nonnegative_im_dichotomy hf hm with ⟨a,ha⟩ | hpos
+  · have ht : Tendsto (fun _ : ℕ => a) atTop (𝓝 0) :=
+      hzero.congr (fun n => ha _ (verticalInfinity_mem n))
+    have ha0 : a=0 := tendsto_nhds_unique tendsto_const_nhds ht
+    rw [ha z hz,ha0,norm_zero]
+    exact div_nonneg hc (show 0<z.im from hz).le
+  · exact norm_le_mass_div_height hz hc (halfPlane_vanishing_mass_bound hf hpos hzero hmass hz)
+
+end SLEExactGauge
+
+end
+
+end OAI

lean/OAI/Probability/SLE/Loewner/HalfPlaneExitBounds.lean

@@ -1,55 +1,55 @@
-import OAI.Probability.SLE.Loewner.HalfPlaneExitWeights
-import OAI.Probability.SLE.Geometry.HarmonicExitProbability
-
-namespace OAI
-
-/-! The two half-plane angular upper bounds for finite physical exits. -/
-noncomputable section
-open Set Filter MeasureTheory ProbabilityTheory
-open scoped Topology NNReal ENNReal
-
-namespace SLEExactGauge
-open Target
-
-def planarHalfPlaneExitArc (D : Set ℂ) (g : ℂ → ℂ) (w : ℂ) (T : ℝ≥0) (positive : Bool) :
-    Set (Driver×Driver) :=
-  {b | ∃ τ : ℝ≥0, 0 < τ ∧ τ ≤ T ∧
-    (∀ t<τ, w+Complex.equivRealProdCLM.symm (planarWiener t b)∈D) ∧
-    w+Complex.equivRealProdCLM.symm (planarWiener τ b)∉D ∧
-    ∃ x : ℝ, (if positive then 0<x else x<0) ∧
-      Tendsto (fun t => g (w+Complex.equivRealProdCLM.symm (planarWiener t b))) (𝓝[<] τ) (𝓝 (x:ℂ))}
-
-theorem planarHalfPlaneExitArc_bound
-    (W : WienerLaw) (hW : IsWiener W) {D : Set ℂ} (hD : IsOpen D)
-    (w : ℂ) (hw : w∈D) {g : ℂ → ℂ} (hg : DifferentiableOn ℂ g D)
-    (hgH : MapsTo g D upperHalfPlane) (T : ℝ≥0) (positive : Bool) :
-    (W.prod W) (planarHalfPlaneExitArc D g w T positive) ≤
-      ENNReal.ofReal (halfPlaneExitWeight positive (g w)) := by
-  have hU := planarTranslatedDomain_open hD w
-  have h0 : (0:ℝ×ℝ)∈planarTranslatedDomain D w := by simpa [planarTranslatedDomain] using hw
-  let e := Classical.choice (exists_smoothDomainExhaustion _ hU 0 h0)
-  let u (z : ℝ×ℝ) := halfPlaneExitWeight positive (g (w+Complex.equivRealProdCLM.symm z))
-  obtain ⟨hu,hhar⟩ := halfPlaneExitWeight_planar positive hD hg hgH w
-  have hub (z) (hz : z∈planarTranslatedDomain D w) : |u z|≤(1:ℝ≥0) := by
-    have hh := halfPlaneExitWeight_bounds positive (hgH hz)
-    rw [abs_of_nonneg hh.1]
-    exact hh.2
-  have hup (z) (hz : z∈planarTranslatedDomain D w) : 0 ≤ u z :=
-    (halfPlaneExitWeight_bounds positive (hgH hz)).1
-  have hh := e.nonnegative_harmonic_exit_bound W hW T hU u hu hhar 1 hub hup
-    (planarHalfPlaneExitArc D g w T positive) 1 (by norm_num) (by
-      rintro b ⟨τ,hτ,hτT,hp,hx,x,hs,hlim⟩
-      refine ⟨τ,hτ,hτT,hp,hx,?_⟩
-      cases positive
-      · have him : ∀ᶠ t in 𝓝[<] τ, 0 ≤ (g (w+Complex.equivRealProdCLM.symm (planarWiener t b))).im :=
-          (show ∀ᶠ t in 𝓝[<] τ, t<τ from self_mem_nhdsWithin).mono
-            (fun t ht => (hgH (hp t ht)).le)
-        exact halfPlaneExitWeight_negative_limit hs him hlim
-      · exact halfPlaneExitWeight_positive_limit hs hlim)
-  simpa [u] using hh
-
-end SLEExactGauge
-
-end
-
-end OAI
+import OAI.Probability.SLE.Loewner.HalfPlaneExitWeights
+import OAI.Probability.SLE.Geometry.HarmonicExitProbability
+
+namespace OAI
+
+/-! The two half-plane angular upper bounds for finite physical exits. -/
+noncomputable section
+open Set Filter MeasureTheory ProbabilityTheory
+open scoped Topology NNReal ENNReal
+
+namespace SLEExactGauge
+open Target
+
+def planarHalfPlaneExitArc (D : Set ℂ) (g : ℂ → ℂ) (w : ℂ) (T : ℝ≥0) (positive : Bool) :
+    Set (Driver×Driver) :=
+  {b | ∃ τ : ℝ≥0, 0 < τ ∧ τ ≤ T ∧
+    (∀ t<τ, w+Complex.equivRealProdCLM.symm (planarWiener t b)∈D) ∧
+    w+Complex.equivRealProdCLM.symm (planarWiener τ b)∉D ∧
+    ∃ x : ℝ, (if positive then 0<x else x<0) ∧
+      Tendsto (fun t => g (w+Complex.equivRealProdCLM.symm (planarWiener t b))) (𝓝[<] τ) (𝓝 (x:ℂ))}
+
+theorem planarHalfPlaneExitArc_bound
+    (W : WienerLaw) (hW : IsWiener W) {D : Set ℂ} (hD : IsOpen D)
+    (w : ℂ) (hw : w∈D) {g : ℂ → ℂ} (hg : DifferentiableOn ℂ g D)
+    (hgH : MapsTo g D upperHalfPlane) (T : ℝ≥0) (positive : Bool) :
+    (W.prod W) (planarHalfPlaneExitArc D g w T positive) ≤
+      ENNReal.ofReal (halfPlaneExitWeight positive (g w)) := by
+  have hU := planarTranslatedDomain_open hD w
+  have h0 : (0:ℝ×ℝ)∈planarTranslatedDomain D w := by simpa [planarTranslatedDomain] using hw
+  let e := Classical.choice (exists_smoothDomainExhaustion _ hU 0 h0)
+  let u (z : ℝ×ℝ) := halfPlaneExitWeight positive (g (w+Complex.equivRealProdCLM.symm z))
+  obtain ⟨hu,hhar⟩ := halfPlaneExitWeight_planar positive hD hg hgH w
+  have hub (z) (hz : z∈planarTranslatedDomain D w) : |u z|≤(1:ℝ≥0) := by
+    have hh := halfPlaneExitWeight_bounds positive (hgH hz)
+    rw [abs_of_nonneg hh.1]
+    exact hh.2
+  have hup (z) (hz : z∈planarTranslatedDomain D w) : 0 ≤ u z :=
+    (halfPlaneExitWeight_bounds positive (hgH hz)).1
+  have hh := e.nonnegative_harmonic_exit_bound W hW T hU u hu hhar 1 hub hup
+    (planarHalfPlaneExitArc D g w T positive) 1 (by norm_num) (by
+      rintro b ⟨τ,hτ,hτT,hp,hx,x,hs,hlim⟩
+      refine ⟨τ,hτ,hτT,hp,hx,?_⟩
+      cases positive
+      · have him : ∀ᶠ t in 𝓝[<] τ, 0 ≤ (g (w+Complex.equivRealProdCLM.symm (planarWiener t b))).im :=
+          (show ∀ᶠ t in 𝓝[<] τ, t<τ from self_mem_nhdsWithin).mono
+            (fun t ht => (hgH (hp t ht)).le)
+        exact halfPlaneExitWeight_negative_limit hs him hlim
+      · exact halfPlaneExitWeight_positive_limit hs hlim)
+  simpa [u] using hh
+
+end SLEExactGauge
+
+end
+
+end OAI

lean/OAI/Probability/SLE/Loewner/HalfPlaneExitWeights.lean

@@ -1,66 +1,66 @@
-import OAI.Probability.SLE.Stochastic.PlanarHolomorphicTests
-import Mathlib.Analysis.SpecialFunctions.Complex.LogDeriv
-
-namespace OAI
-
-/-! The bounded angular harmonic functions for the two sides of the
-real boundary, together with their one-sided boundary limits. -/
-noncomputable section
-open Set Filter MeasureTheory ProbabilityTheory
-open scoped Topology NNReal ENNReal
-
-namespace SLEExactGauge
-
-def halfPlaneExitWeight (positive : Bool) (z : ℂ) : ℝ :=
-  if positive then 1-z.arg/Real.pi else z.arg/Real.pi
-
-lemma halfPlaneExitWeight_bounds (s : Bool) {z : ℂ} (hz : 0 < z.im) :
-    halfPlaneExitWeight s z∈Icc (0:ℝ) 1 := by
-  have h0 : 0 ≤ z.arg/Real.pi := div_nonneg (Complex.arg_nonneg_iff.mpr hz.le) Real.pi_pos.le
-  have h1 : z.arg/Real.pi ≤ 1 := (div_le_one Real.pi_pos).mpr (Complex.arg_le_pi z)
-  cases s <;> simp only [halfPlaneExitWeight,Bool.false_eq_true,↓reduceIte,mem_Icc] <;>
-    constructor <;> linarith
-
-lemma halfPlaneExitWeight_planar (s : Bool) {D : Set ℂ} (hD : IsOpen D)
-    {g : ℂ → ℂ} (hg : DifferentiableOn ℂ g D) (hgH : MapsTo g D upperHalfPlane) (w : ℂ) :
-    ContDiffOn ℝ (⊤ : ℕ∞)
-      (fun z => halfPlaneExitWeight s (g (w+Complex.equivRealProdCLM.symm z))) (planarTranslatedDomain D w) ∧
-    ∀ z∈planarTranslatedDomain D w,
-      planarGenerator (fun z => halfPlaneExitWeight s (g (w+Complex.equivRealProdCLM.symm z))) z=0 := by
-  have hlog : DifferentiableOn ℂ Complex.log upperHalfPlane := by
-    intro z hz
-    exact (Complex.differentiableAt_log (Complex.mem_slitPlane_iff.mpr (Or.inr (ne_of_gt hz)))).differentiableWithinAt
-  let Q (z : ℂ) := Complex.log (g z)/(Real.pi:ℂ)
-  have hQ : DifferentiableOn ℂ Q D := (hlog.comp hg hgH).div_const _
-  cases s
-  · have hh := (holomorphic_planar_components hD hQ w).2
-    simpa only [halfPlaneExitWeight,Bool.false_eq_true,↓reduceIte,Q,Complex.div_ofReal_im,Complex.log_im] using hh
-  · have hQc : DifferentiableOn ℂ (fun z => Complex.I-Q z) D := (differentiableOn_const Complex.I).sub hQ
-    have hh := (holomorphic_planar_components hD hQc w).2
-    simpa only [halfPlaneExitWeight,↓reduceIte,Q,Complex.sub_im,Complex.I_im,
-      Complex.div_ofReal_im,Complex.log_im] using hh
-
-lemma halfPlaneExitWeight_negative_limit {A : Type*} {l : Filter A}
-    {ζ : A → ℂ} {x : ℝ} (hx : x<0) (hζ : ∀ᶠ t in l, 0 ≤ (ζ t).im)
-    (hlim : Tendsto ζ l (𝓝 (x:ℂ))) :
-    Tendsto (fun t => halfPlaneExitWeight false (ζ t)) l (𝓝 1) := by
-  have hh := (Complex.tendsto_arg_nhdsWithin_im_nonneg_of_re_neg_of_im_zero
-    (z := (x:ℂ)) (by simpa using hx) (by simp)).comp
-      (tendsto_nhdsWithin_iff.mpr ⟨hlim,hζ⟩)
-  simpa only [halfPlaneExitWeight,Bool.false_eq_true,↓reduceIte,Function.comp_apply,
-    div_self Real.pi_ne_zero] using hh.div_const Real.pi
-
-lemma halfPlaneExitWeight_positive_limit {A : Type*} {l : Filter A}
-    {ζ : A → ℂ} {x : ℝ} (hx : 0<x) (hlim : Tendsto ζ l (𝓝 (x:ℂ))) :
-    Tendsto (fun t => halfPlaneExitWeight true (ζ t)) l (𝓝 1) := by
-  have hh := (Complex.continuousAt_arg (Complex.mem_slitPlane_iff.mpr
-    (Or.inl (by simpa using hx)))).tendsto.comp hlim
-  have hq := hh.div_const Real.pi
-  simpa only [halfPlaneExitWeight,↓reduceIte,Function.comp_apply,
-    Complex.arg_ofReal_of_nonneg hx.le,zero_div,sub_zero] using tendsto_const_nhds.sub hq
-
-end SLEExactGauge
-
-end
-
-end OAI
+import OAI.Probability.SLE.Stochastic.PlanarHolomorphicTests
+import Mathlib.Analysis.SpecialFunctions.Complex.LogDeriv
+
+namespace OAI
+
+/-! The bounded angular harmonic functions for the two sides of the
+real boundary, together with their one-sided boundary limits. -/
+noncomputable section
+open Set Filter MeasureTheory ProbabilityTheory
+open scoped Topology NNReal ENNReal
+
+namespace SLEExactGauge
+
+def halfPlaneExitWeight (positive : Bool) (z : ℂ) : ℝ :=
+  if positive then 1-z.arg/Real.pi else z.arg/Real.pi
+
+lemma halfPlaneExitWeight_bounds (s : Bool) {z : ℂ} (hz : 0 < z.im) :
+    halfPlaneExitWeight s z∈Icc (0:ℝ) 1 := by
+  have h0 : 0 ≤ z.arg/Real.pi := div_nonneg (Complex.arg_nonneg_iff.mpr hz.le) Real.pi_pos.le
+  have h1 : z.arg/Real.pi ≤ 1 := (div_le_one Real.pi_pos).mpr (Complex.arg_le_pi z)
+  cases s <;> simp only [halfPlaneExitWeight,Bool.false_eq_true,↓reduceIte,mem_Icc] <;>
+    constructor <;> linarith
+
+lemma halfPlaneExitWeight_planar (s : Bool) {D : Set ℂ} (hD : IsOpen D)
+    {g : ℂ → ℂ} (hg : DifferentiableOn ℂ g D) (hgH : MapsTo g D upperHalfPlane) (w : ℂ) :
+    ContDiffOn ℝ (⊤ : ℕ∞)
+      (fun z => halfPlaneExitWeight s (g (w+Complex.equivRealProdCLM.symm z))) (planarTranslatedDomain D w) ∧
+    ∀ z∈planarTranslatedDomain D w,
+      planarGenerator (fun z => halfPlaneExitWeight s (g (w+Complex.equivRealProdCLM.symm z))) z=0 := by
+  have hlog : DifferentiableOn ℂ Complex.log upperHalfPlane := by
+    intro z hz
+    exact (Complex.differentiableAt_log (Complex.mem_slitPlane_iff.mpr (Or.inr (ne_of_gt hz)))).differentiableWithinAt
+  let Q (z : ℂ) := Complex.log (g z)/(Real.pi:ℂ)
+  have hQ : DifferentiableOn ℂ Q D := (hlog.comp hg hgH).div_const _
+  cases s
+  · have hh := (holomorphic_planar_components hD hQ w).2
+    simpa only [halfPlaneExitWeight,Bool.false_eq_true,↓reduceIte,Q,Complex.div_ofReal_im,Complex.log_im] using hh
+  · have hQc : DifferentiableOn ℂ (fun z => Complex.I-Q z) D := (differentiableOn_const Complex.I).sub hQ
+    have hh := (holomorphic_planar_components hD hQc w).2
+    simpa only [halfPlaneExitWeight,↓reduceIte,Q,Complex.sub_im,Complex.I_im,
+      Complex.div_ofReal_im,Complex.log_im] using hh
+
+lemma halfPlaneExitWeight_negative_limit {A : Type*} {l : Filter A}
+    {ζ : A → ℂ} {x : ℝ} (hx : x<0) (hζ : ∀ᶠ t in l, 0 ≤ (ζ t).im)
+    (hlim : Tendsto ζ l (𝓝 (x:ℂ))) :
+    Tendsto (fun t => halfPlaneExitWeight false (ζ t)) l (𝓝 1) := by
+  have hh := (Complex.tendsto_arg_nhdsWithin_im_nonneg_of_re_neg_of_im_zero
+    (z := (x:ℂ)) (by simpa using hx) (by simp)).comp
+      (tendsto_nhdsWithin_iff.mpr ⟨hlim,hζ⟩)
+  simpa only [halfPlaneExitWeight,Bool.false_eq_true,↓reduceIte,Function.comp_apply,
+    div_self Real.pi_ne_zero] using hh.div_const Real.pi
+
+lemma halfPlaneExitWeight_positive_limit {A : Type*} {l : Filter A}
+    {ζ : A → ℂ} {x : ℝ} (hx : 0<x) (hlim : Tendsto ζ l (𝓝 (x:ℂ))) :
+    Tendsto (fun t => halfPlaneExitWeight true (ζ t)) l (𝓝 1) := by
+  have hh := (Complex.continuousAt_arg (Complex.mem_slitPlane_iff.mpr
+    (Or.inl (by simpa using hx)))).tendsto.comp hlim
+  have hq := hh.div_const Real.pi
+  simpa only [halfPlaneExitWeight,↓reduceIte,Function.comp_apply,
+    Complex.arg_ofReal_of_nonneg hx.le,zero_div,sub_zero] using tendsto_const_nhds.sub hq
+
+end SLEExactGauge
+
+end
+
+end OAI

lean/OAI/Probability/SLE/Loewner/HalfPlaneFiniteExit.lean

@@ -1,79 +1,79 @@
-import OAI.Probability.SLE.Geometry.NoBoundaryAtoms
-import OAI.Probability.SLE.Geometry.HalfPlaneChartBoundary
-
-namespace OAI
-
-/-! Finite nonzero real limits of conformal half-plane maps at actual
-finite physical Brownian exits. -/
-noncomputable section
-open Set Filter MeasureTheory ProbabilityTheory Metric
-open scoped Topology NNReal ENNReal
-
-namespace SLEExactGauge
-open Target
-
-theorem halfPlane_finite_exit_limit
-    (W : WienerLaw) (hW : IsWiener W) {D : Set ℂ} (hD : IsOpen D)
-    {g f : ℂ → ℂ} (hg : DifferentiableOn ℂ g D)
-    (hf : DifferentiableOn ℂ f upperHalfPlane)
-    (hgH : MapsTo g D upperHalfPlane) (hfD : MapsTo f upperHalfPlane D)
-    (hinv : ∀ z∈D, f (g z)=z) (w : ℂ) (hw : w∈D) (T : ℝ≥0) :
-    ∀ᵐ b ∂W.prod W, ∀ τ : ℝ≥0, 0 < τ → τ ≤ T →
-      (∀ t<τ, w+Complex.equivRealProdCLM.symm (planarWiener t b)∈D) →
-      w+Complex.equivRealProdCLM.symm (planarWiener τ b)∉D →
-      ∃ x : ℝ, x≠0 ∧
-        Tendsto (fun t => g (w+Complex.equivRealProdCLM.symm (planarWiener t b)))
-          (𝓝[<] τ) (𝓝 (x:ℂ)) := by
-  let v := g w
-  have hv : 0 < v.im := hgH hw
-  let F := halfPlaneToDisk v ∘ g
-  let H := f ∘ diskToHalfPlane v
-  have hF : DifferentiableOn ℂ F D := (halfPlaneToDisk_differentiable hv).comp hg hgH
-  have hFD : MapsTo F D (ball 0 1) := (halfPlaneToDisk_maps hv).comp hgH
-  have hH : ContinuousOn H (ball 0 1) := hf.continuousOn.comp
-    (diskToHalfPlane_differentiable v).continuousOn (diskToHalfPlane_maps hv)
-  have hHD : MapsTo H (ball 0 1) D := hfD.comp (diskToHalfPlane_maps hv)
-  have hFG (z) (hz : z∈D) : diskToHalfPlane v (F z)=g z :=
-    diskToHalfPlane_halfPlaneToDisk hv (hgH hz)
-  have hHF (z) (hz : z∈D) : H (F z)=z := by
-    change f (diskToHalfPlane v (F z))=z
-    rw [hFG z hz,hinv z hz]
-  have hF0 : F w=0 := by simp [F,v,halfPlaneToDisk]
-  have hlim := conformal_disk_finite_exit_limit W hW hD w hw hF hFD hH hHD hHF T
-  have hnull1 := planarDiskExitAtom_null W hW hD w hw hF hFD hF0 1 (by simp) T
-  have hnull0 := planarDiskExitAtom_null W hW hD w hw hF hFD hF0
-    (halfPlaneToDisk v 0) (halfPlaneToDisk_zero_norm hv) T
-  have hno1 : ∀ᵐ b ∂W.prod W, b∉planarDiskExitAtom D F w 1 T := by
-    simpa only [ae_iff,not_not,ofPred_mem_eq] using hnull1
-  have hno0 : ∀ᵐ b ∂W.prod W, b∉planarDiskExitAtom D F w (halfPlaneToDisk v 0) T := by
-    simpa only [ae_iff,not_not,ofPred_mem_eq] using hnull0
-  filter_upwards [hlim,hno1,hno0] with b hb hb1 hb0
-  intro τ hτ hτT hp hx
-  obtain ⟨c,hcn,hc⟩ := hb τ hτ hτT hp hx
-  have hc1 : c≠1 := by
-    intro he
-    exact hb1 ⟨τ,hτ,hτT,hp,hx,he ▸ hc⟩
-  have hc0 : c≠halfPlaneToDisk v 0 := by
-    intro he
-    exact hb0 ⟨τ,hτ,hτT,hp,hx,he ▸ hc⟩
-  have hgconv := (diskToHalfPlane_continuousAt (v := v) hc1).tendsto.comp hc
-  have heq : (fun t => diskToHalfPlane v (F (w+Complex.equivRealProdCLM.symm (planarWiener t b))))
-      =ᶠ[𝓝[<] τ] (fun t => g (w+Complex.equivRealProdCLM.symm (planarWiener t b))) := by
-    filter_upwards [self_mem_nhdsWithin] with t ht
-    exact hFG _ (hp t ht)
-  have hgconv' := hgconv.congr' heq
-  let z := diskToHalfPlane v c
-  have hzI : z.im=0 := diskToHalfPlane_boundary_im hcn
-  have hz0 : z≠0 := diskToHalfPlane_boundary_ne_zero hv hc1 hc0
-  have hzreal : z=(z.re:ℂ) := by apply Complex.ext <;> simp [hzI]
-  refine ⟨z.re,?_,?_⟩
-  · intro he
-    exact hz0 (by rw [hzreal,he,Complex.ofReal_zero])
-  · change Tendsto _ (𝓝[<] τ) (𝓝 z) at hgconv'
-    rwa [hzreal] at hgconv'
-
-end SLEExactGauge
-
-end
-
-end OAI
+import OAI.Probability.SLE.Geometry.NoBoundaryAtoms
+import OAI.Probability.SLE.Geometry.HalfPlaneChartBoundary
+
+namespace OAI
+
+/-! Finite nonzero real limits of conformal half-plane maps at actual
+finite physical Brownian exits. -/
+noncomputable section
+open Set Filter MeasureTheory ProbabilityTheory Metric
+open scoped Topology NNReal ENNReal
+
+namespace SLEExactGauge
+open Target
+
+theorem halfPlane_finite_exit_limit
+    (W : WienerLaw) (hW : IsWiener W) {D : Set ℂ} (hD : IsOpen D)
+    {g f : ℂ → ℂ} (hg : DifferentiableOn ℂ g D)
+    (hf : DifferentiableOn ℂ f upperHalfPlane)
+    (hgH : MapsTo g D upperHalfPlane) (hfD : MapsTo f upperHalfPlane D)
+    (hinv : ∀ z∈D, f (g z)=z) (w : ℂ) (hw : w∈D) (T : ℝ≥0) :
+    ∀ᵐ b ∂W.prod W, ∀ τ : ℝ≥0, 0 < τ → τ ≤ T →
+      (∀ t<τ, w+Complex.equivRealProdCLM.symm (planarWiener t b)∈D) →
+      w+Complex.equivRealProdCLM.symm (planarWiener τ b)∉D →
+      ∃ x : ℝ, x≠0 ∧
+        Tendsto (fun t => g (w+Complex.equivRealProdCLM.symm (planarWiener t b)))
+          (𝓝[<] τ) (𝓝 (x:ℂ)) := by
+  let v := g w
+  have hv : 0 < v.im := hgH hw
+  let F := halfPlaneToDisk v ∘ g
+  let H := f ∘ diskToHalfPlane v
+  have hF : DifferentiableOn ℂ F D := (halfPlaneToDisk_differentiable hv).comp hg hgH
+  have hFD : MapsTo F D (ball 0 1) := (halfPlaneToDisk_maps hv).comp hgH
+  have hH : ContinuousOn H (ball 0 1) := hf.continuousOn.comp
+    (diskToHalfPlane_differentiable v).continuousOn (diskToHalfPlane_maps hv)
+  have hHD : MapsTo H (ball 0 1) D := hfD.comp (diskToHalfPlane_maps hv)
+  have hFG (z) (hz : z∈D) : diskToHalfPlane v (F z)=g z :=
+    diskToHalfPlane_halfPlaneToDisk hv (hgH hz)
+  have hHF (z) (hz : z∈D) : H (F z)=z := by
+    change f (diskToHalfPlane v (F z))=z
+    rw [hFG z hz,hinv z hz]
+  have hF0 : F w=0 := by simp [F,v,halfPlaneToDisk]
+  have hlim := conformal_disk_finite_exit_limit W hW hD w hw hF hFD hH hHD hHF T
+  have hnull1 := planarDiskExitAtom_null W hW hD w hw hF hFD hF0 1 (by simp) T
+  have hnull0 := planarDiskExitAtom_null W hW hD w hw hF hFD hF0
+    (halfPlaneToDisk v 0) (halfPlaneToDisk_zero_norm hv) T
+  have hno1 : ∀ᵐ b ∂W.prod W, b∉planarDiskExitAtom D F w 1 T := by
+    simpa only [ae_iff,not_not,ofPred_mem_eq] using hnull1
+  have hno0 : ∀ᵐ b ∂W.prod W, b∉planarDiskExitAtom D F w (halfPlaneToDisk v 0) T := by
+    simpa only [ae_iff,not_not,ofPred_mem_eq] using hnull0
+  filter_upwards [hlim,hno1,hno0] with b hb hb1 hb0
+  intro τ hτ hτT hp hx
+  obtain ⟨c,hcn,hc⟩ := hb τ hτ hτT hp hx
+  have hc1 : c≠1 := by
+    intro he
+    exact hb1 ⟨τ,hτ,hτT,hp,hx,he ▸ hc⟩
+  have hc0 : c≠halfPlaneToDisk v 0 := by
+    intro he
+    exact hb0 ⟨τ,hτ,hτT,hp,hx,he ▸ hc⟩
+  have hgconv := (diskToHalfPlane_continuousAt (v := v) hc1).tendsto.comp hc
+  have heq : (fun t => diskToHalfPlane v (F (w+Complex.equivRealProdCLM.symm (planarWiener t b))))
+      =ᶠ[𝓝[<] τ] (fun t => g (w+Complex.equivRealProdCLM.symm (planarWiener t b))) := by
+    filter_upwards [self_mem_nhdsWithin] with t ht
+    exact hFG _ (hp t ht)
+  have hgconv' := hgconv.congr' heq
+  let z := diskToHalfPlane v c
+  have hzI : z.im=0 := diskToHalfPlane_boundary_im hcn
+  have hz0 : z≠0 := diskToHalfPlane_boundary_ne_zero hv hc1 hc0
+  have hzreal : z=(z.re:ℂ) := by apply Complex.ext <;> simp [hzI]
+  refine ⟨z.re,?_,?_⟩
+  · intro he
+    exact hz0 (by rw [hzreal,he,Complex.ofReal_zero])
+  · change Tendsto _ (𝓝[<] τ) (𝓝 z) at hgconv'
+    rwa [hzreal] at hgconv'
+
+end SLEExactGauge
+
+end
+
+end OAI

lean/OAI/Probability/SLE/Loewner/HydrodynamicAsymptotics.lean

@@ -1,52 +1,52 @@
-import OAI.Probability.SLE.Loewner.HydrodynamicCoefficient
-
-namespace OAI
-
-/-! Elementary consequences of hydrodynamic normalization, including
-the inverse coefficient and escape of the normalized inverse to infinity. -/
-noncomputable section
-open Set Filter Complex Function Metric
-open scoped Topology
-
-namespace SLEExactGauge
-
-lemma normalized_ratio_tendsto_cocompact {F : ℂ → ℂ}
-    (hF : Tendsto (fun z : ℂ => F z/z) (cocompact ℂ ⊓ 𝓟 upperHalfPlane) (𝓝 1)) :
-    Tendsto F (cocompact ℂ ⊓ 𝓟 upperHalfPlane) (cocompact ℂ) := by
-  have hr : Tendsto (fun z : ℂ => ‖F z/z‖) (cocompact ℂ ⊓ 𝓟 upperHalfPlane) (𝓝 1) := by
-    simpa only [norm_one] using hF.norm
-  have hn := Filter.Tendsto.pos_mul_atTop (by norm_num : (0:ℝ)<1) hr
-    (tendsto_norm_cocompact_atTop.mono_left (show cocompact ℂ ⊓ 𝓟 upperHalfPlane ≤ cocompact ℂ from inf_le_left))
-  have hnorm : Tendsto (fun z : ℂ => ‖F z‖) (cocompact ℂ ⊓ 𝓟 upperHalfPlane) atTop := by
-    apply hn.congr'
-    filter_upwards [(show ∀ᶠ z : ℂ in cocompact ℂ, z ≠ 0 from
-      (isCompact_singleton (x := (0:ℂ))).compl_mem_cocompact).filter_mono
-      (show cocompact ℂ ⊓ 𝓟 upperHalfPlane ≤ cocompact ℂ from inf_le_left)] with z hz
-    rw [norm_div,div_mul_cancel₀ _ (norm_ne_zero_iff.mpr hz)]
-  have hb := tendsto_norm_atTop_iff_cobounded.mp hnorm
-  simpa only [Metric.cobounded_eq_cocompact] using hb
-
-lemma inverse_hydrodynamic_coefficient {G F : ℂ → ℂ} {c : ℂ}
-    (hG : Tendsto (fun z : ℂ => z*(G z-z)) (cocompact ℂ) (𝓝 c))
-    (hF : Tendsto (fun z : ℂ => F z/z) (cocompact ℂ ⊓ 𝓟 upperHalfPlane) (𝓝 1))
-    (hGF : ∀ z ∈ upperHalfPlane, G (F z)=z) :
-    Tendsto (fun z : ℂ => z*(F z-z)) (cocompact ℂ ⊓ 𝓟 upperHalfPlane) (𝓝 (-c)) := by
-  have he := normalized_ratio_tendsto_cocompact hF
-  have hq : Tendsto (fun z : ℂ => z/F z) (cocompact ℂ ⊓ 𝓟 upperHalfPlane) (𝓝 1) := by
-    simpa only [inv_div,inv_one] using hF.inv₀ one_ne_zero
-  have ht := (hq.mul (hG.comp he)).neg
-  simp only [one_mul] at ht
-  apply ht.congr'
-  filter_upwards [he.eventually ((isCompact_singleton (x := (0:ℂ))).compl_mem_cocompact),
-    (show ∀ᶠ z in cocompact ℂ ⊓ 𝓟 upperHalfPlane, z∈upperHalfPlane from
-      eventually_inf_principal.mpr (Eventually.of_forall (fun _ h => h)))] with z hz hzH
-  simp only [Function.comp_apply,hGF z hzH]
-  have hz0 : F z ≠ 0 := hz
-  field_simp [hz0]
-  ring
-
-end SLEExactGauge
-
-end
-
-end OAI
+import OAI.Probability.SLE.Loewner.HydrodynamicCoefficient
+
+namespace OAI
+
+/-! Elementary consequences of hydrodynamic normalization, including
+the inverse coefficient and escape of the normalized inverse to infinity. -/
+noncomputable section
+open Set Filter Complex Function Metric
+open scoped Topology
+
+namespace SLEExactGauge
+
+lemma normalized_ratio_tendsto_cocompact {F : ℂ → ℂ}
+    (hF : Tendsto (fun z : ℂ => F z/z) (cocompact ℂ ⊓ 𝓟 upperHalfPlane) (𝓝 1)) :
+    Tendsto F (cocompact ℂ ⊓ 𝓟 upperHalfPlane) (cocompact ℂ) := by
+  have hr : Tendsto (fun z : ℂ => ‖F z/z‖) (cocompact ℂ ⊓ 𝓟 upperHalfPlane) (𝓝 1) := by
+    simpa only [norm_one] using hF.norm
+  have hn := Filter.Tendsto.pos_mul_atTop (by norm_num : (0:ℝ)<1) hr
+    (tendsto_norm_cocompact_atTop.mono_left (show cocompact ℂ ⊓ 𝓟 upperHalfPlane ≤ cocompact ℂ from inf_le_left))
+  have hnorm : Tendsto (fun z : ℂ => ‖F z‖) (cocompact ℂ ⊓ 𝓟 upperHalfPlane) atTop := by
+    apply hn.congr'
+    filter_upwards [(show ∀ᶠ z : ℂ in cocompact ℂ, z ≠ 0 from
+      (isCompact_singleton (x := (0:ℂ))).compl_mem_cocompact).filter_mono
+      (show cocompact ℂ ⊓ 𝓟 upperHalfPlane ≤ cocompact ℂ from inf_le_left)] with z hz
+    rw [norm_div,div_mul_cancel₀ _ (norm_ne_zero_iff.mpr hz)]
+  have hb := tendsto_norm_atTop_iff_cobounded.mp hnorm
+  simpa only [Metric.cobounded_eq_cocompact] using hb
+
+lemma inverse_hydrodynamic_coefficient {G F : ℂ → ℂ} {c : ℂ}
+    (hG : Tendsto (fun z : ℂ => z*(G z-z)) (cocompact ℂ) (𝓝 c))
+    (hF : Tendsto (fun z : ℂ => F z/z) (cocompact ℂ ⊓ 𝓟 upperHalfPlane) (𝓝 1))
+    (hGF : ∀ z ∈ upperHalfPlane, G (F z)=z) :
+    Tendsto (fun z : ℂ => z*(F z-z)) (cocompact ℂ ⊓ 𝓟 upperHalfPlane) (𝓝 (-c)) := by
+  have he := normalized_ratio_tendsto_cocompact hF
+  have hq : Tendsto (fun z : ℂ => z/F z) (cocompact ℂ ⊓ 𝓟 upperHalfPlane) (𝓝 1) := by
+    simpa only [inv_div,inv_one] using hF.inv₀ one_ne_zero
+  have ht := (hq.mul (hG.comp he)).neg
+  simp only [one_mul] at ht
+  apply ht.congr'
+  filter_upwards [he.eventually ((isCompact_singleton (x := (0:ℂ))).compl_mem_cocompact),
+    (show ∀ᶠ z in cocompact ℂ ⊓ 𝓟 upperHalfPlane, z∈upperHalfPlane from
+      eventually_inf_principal.mpr (Eventually.of_forall (fun _ h => h)))] with z hz hzH
+  simp only [Function.comp_apply,hGF z hzH]
+  have hz0 : F z ≠ 0 := hz
+  field_simp [hz0]
+  ring
+
+end SLEExactGauge
+
+end
+
+end OAI

lean/OAI/Probability/SLE/Loewner/HydrodynamicCoefficient.lean

@@ -1,43 +1,43 @@
-import OAI.Probability.SLE.Loewner.HydrodynamicHeight
-
-namespace OAI
-
-/-! A height-decreasing half-plane chart has nonnegative hydrodynamic
-coefficient. The argument uses the actual Laurent limit on the imaginary axis. -/
-noncomputable section
-open Set Filter Complex Function Metric
-open scoped Topology
-
-namespace SLEExactGauge
-
-lemma hydrodynamic_coefficient_nonneg {G : ℂ → ℂ} {c : ℝ}
-    (hc : Tendsto (fun z : ℂ => z*(G z-z)) (cocompact ℂ) (𝓝 (c:ℂ)))
-    (hheight : ∀ᶠ z in cocompact ℂ ⊓ 𝓟 upperHalfPlane, (G z).im ≤ z.im) : 0≤c := by
-  have hv := verticalInfinity_tendsto
-  have hr := Complex.continuous_re.tendsto (c:ℂ) |>.comp (hc.comp (hv.mono_right inf_le_left))
-  have hn : ∀ᶠ n in atTop, 0 ≤ (verticalInfinity n*(G (verticalInfinity n)-verticalInfinity n)).re := by
-    filter_upwards [hv.eventually hheight] with n hn
-    have hy : 0 < (n:ℝ)+1 := by positivity
-    simp only [verticalInfinity,mul_im,mul_re,ofReal_re,ofReal_im,I_re,I_im,mul_zero,
-      add_zero,mul_one,sub_im,sub_re,zero_sub] at hn ⊢
-    nlinarith
-  have hh : 0 ≤ (c:ℂ).re := ge_of_tendsto hr (by
-    simpa only [Function.comp_apply] using hn)
-  simpa only [ofReal_re] using hh
-
-lemma normalized_inverse_height
-    {D : Set ℂ} {G F : ℂ → ℂ}
-    (hG : MapsTo G D upperHalfPlane)
-    (hF : DifferentiableOn ℂ F upperHalfPlane) (hmap : MapsTo F upperHalfPlane upperHalfPlane)
-    (hleft : ∀ z ∈ D, F (G z)=z)
-    (hn : Tendsto (fun z : ℂ => F z/z) (cocompact ℂ ⊓ 𝓟 upperHalfPlane) (𝓝 1)) :
-    ∀ z ∈ D, (G z).im ≤ z.im := by
-  intro z hz
-  have hh := normalized_halfPlane_height hF hmap hn (hG hz)
-  rwa [hleft z hz] at hh
-
-end SLEExactGauge
-
-end
-
-end OAI
+import OAI.Probability.SLE.Loewner.HydrodynamicHeight
+
+namespace OAI
+
+/-! A height-decreasing half-plane chart has nonnegative hydrodynamic
+coefficient. The argument uses the actual Laurent limit on the imaginary axis. -/
+noncomputable section
+open Set Filter Complex Function Metric
+open scoped Topology
+
+namespace SLEExactGauge
+
+lemma hydrodynamic_coefficient_nonneg {G : ℂ → ℂ} {c : ℝ}
+    (hc : Tendsto (fun z : ℂ => z*(G z-z)) (cocompact ℂ) (𝓝 (c:ℂ)))
+    (hheight : ∀ᶠ z in cocompact ℂ ⊓ 𝓟 upperHalfPlane, (G z).im ≤ z.im) : 0≤c := by
+  have hv := verticalInfinity_tendsto
+  have hr := Complex.continuous_re.tendsto (c:ℂ) |>.comp (hc.comp (hv.mono_right inf_le_left))
+  have hn : ∀ᶠ n in atTop, 0 ≤ (verticalInfinity n*(G (verticalInfinity n)-verticalInfinity n)).re := by
+    filter_upwards [hv.eventually hheight] with n hn
+    have hy : 0 < (n:ℝ)+1 := by positivity
+    simp only [verticalInfinity,mul_im,mul_re,ofReal_re,ofReal_im,I_re,I_im,mul_zero,
+      add_zero,mul_one,sub_im,sub_re,zero_sub] at hn ⊢
+    nlinarith
+  have hh : 0 ≤ (c:ℂ).re := ge_of_tendsto hr (by
+    simpa only [Function.comp_apply] using hn)
+  simpa only [ofReal_re] using hh
+
+lemma normalized_inverse_height
+    {D : Set ℂ} {G F : ℂ → ℂ}
+    (hG : MapsTo G D upperHalfPlane)
+    (hF : DifferentiableOn ℂ F upperHalfPlane) (hmap : MapsTo F upperHalfPlane upperHalfPlane)
+    (hleft : ∀ z ∈ D, F (G z)=z)
+    (hn : Tendsto (fun z : ℂ => F z/z) (cocompact ℂ ⊓ 𝓟 upperHalfPlane) (𝓝 1)) :
+    ∀ z ∈ D, (G z).im ≤ z.im := by
+  intro z hz
+  have hh := normalized_halfPlane_height hF hmap hn (hG hz)
+  rwa [hleft z hz] at hh
+
+end SLEExactGauge
+
+end
+
+end OAI

lean/OAI/Probability/SLE/Loewner/HydrodynamicComposition.lean

@@ -1,97 +1,97 @@
-import OAI.Probability.SLE.Loewner.HydrodynamicAsymptotics
-
-namespace OAI
-
-/-! The coefficient of a normalized composition subtracts capacities.
-Schwarz–Pick then makes capacity monotone under inclusion of slit domains. -/
-noncomputable section
-open Set Filter Complex Function Metric
-open scoped Topology
-
-namespace SLEExactGauge
-
-lemma hydrodynamic_ratio_limit {G : ℂ → ℂ} {c : ℂ}
-    (hG : Tendsto (fun z : ℂ => z*(G z-z)) (cocompact ℂ) (𝓝 c)) :
-    Tendsto (fun z : ℂ => G z/z) (cocompact ℂ) (𝓝 1) := by
-  have hi : Tendsto (fun z : ℂ => z⁻¹) (cocompact ℂ) (𝓝 0) := by
-    simpa only [Metric.cobounded_eq_cocompact] using
-      (tendsto_inv₀_cobounded : Tendsto (fun z : ℂ => z⁻¹) (Bornology.cobounded ℂ) (𝓝 0))
-  have hh := (hG.mul (hi.pow 2)).const_add 1
-  simp only [zero_pow two_ne_zero,mul_zero,add_zero] at hh
-  apply hh.congr'
-  filter_upwards [(isCompact_singleton (x := (0:ℂ))).compl_mem_cocompact] with z hz
-  have hz0 : z ≠ 0 := hz
-  field_simp [hz0]
-  ring
-
-lemma hydrodynamic_composition_coefficient {G H F : ℂ → ℂ} {c d : ℂ}
-    (hG : Tendsto (fun z : ℂ => z*(G z-z)) (cocompact ℂ) (𝓝 c))
-    (hH : Tendsto (fun z : ℂ => z*(H z-z)) (cocompact ℂ) (𝓝 d))
-    (hF : Tendsto (fun z : ℂ => F z/z) (cocompact ℂ ⊓ 𝓟 upperHalfPlane) (𝓝 1))
-    (hHF : ∀ z ∈ upperHalfPlane, H (F z)=z) :
-    Tendsto (fun z : ℂ => z*(G (F z)-z)) (cocompact ℂ ⊓ 𝓟 upperHalfPlane) (𝓝 (c-d)) := by
-  have hescape := normalized_ratio_tendsto_cocompact hF
-  have hquot : Tendsto (fun z : ℂ => z/F z) (cocompact ℂ ⊓ 𝓟 upperHalfPlane) (𝓝 1) := by
-    simpa only [inv_div,inv_one] using hF.inv₀ one_ne_zero
-  have hh := (hquot.mul (hG.comp hescape)).add (inverse_hydrodynamic_coefficient hH hF hHF)
-  simp only [one_mul,sub_eq_add_neg] at hh ⊢
-  apply hh.congr'
-  filter_upwards [hescape.eventually ((isCompact_singleton (x := (0:ℂ))).compl_mem_cocompact)] with z hz
-  simp only [Function.comp_apply]
-  have hz0 : F z ≠ 0 := hz
-  field_simp [hz0]
-  ring
-
-lemma hydrodynamic_composition_ratio {G F : ℂ → ℂ} {c : ℂ}
-    (hG : Tendsto (fun z : ℂ => z*(G z-z)) (cocompact ℂ) (𝓝 c))
-    (hF : Tendsto (fun z : ℂ => F z/z) (cocompact ℂ ⊓ 𝓟 upperHalfPlane) (𝓝 1)) :
-    Tendsto (fun z : ℂ => G (F z)/z) (cocompact ℂ ⊓ 𝓟 upperHalfPlane) (𝓝 1) := by
-  have he := normalized_ratio_tendsto_cocompact hF
-  have hh := ((hydrodynamic_ratio_limit hG).comp he).mul hF
-  simp only [mul_one] at hh
-  apply hh.congr'
-  filter_upwards [he.eventually ((isCompact_singleton (x := (0:ℂ))).compl_mem_cocompact)] with z hz
-  simp only [Function.comp_apply]
-  have hz0 : F z ≠ 0 := hz
-  field_simp [hz0]
-
-
-lemma normalized_selfMap_coefficient_nonpos {G : ℂ → ℂ} {c : ℝ}
-    (hd : DifferentiableOn ℂ G upperHalfPlane) (hm : MapsTo G upperHalfPlane upperHalfPlane)
-    (hc : Tendsto (fun z : ℂ => z*(G z-z)) (cocompact ℂ ⊓ 𝓟 upperHalfPlane) (𝓝 (c:ℂ)))
-    (hn : Tendsto (fun z : ℂ => G z/z) (cocompact ℂ ⊓ 𝓟 upperHalfPlane) (𝓝 1)) : c≤0 := by
-  have hr := Complex.continuous_re.tendsto (c:ℂ) |>.comp (hc.comp verticalInfinity_tendsto)
-  have hh : ∀ᶠ n in atTop, (verticalInfinity n*(G (verticalInfinity n)-verticalInfinity n)).re ≤ 0 := by
-    apply Eventually.of_forall
-    intro n
-    have hheight := normalized_halfPlane_height hd hm hn (verticalInfinity_mem n)
-    have hy : 0 < (n:ℝ)+1 := by positivity
-    simp only [verticalInfinity,mul_im,mul_re,ofReal_re,ofReal_im,I_re,I_im,mul_zero,
-      add_zero,mul_one,sub_im,sub_re,zero_sub] at hheight ⊢
-    nlinarith
-  have hle : (c:ℂ).re ≤ 0 := le_of_tendsto hr (by
-    simpa only [Function.comp_apply] using hh)
-  simpa only [ofReal_re] using hle
-
-theorem nested_hydrodynamic_coefficient_le
-    {D : Set ℂ} {G H F : ℂ → ℂ} {c d : ℝ}
-    (hG : DifferentiableOn ℂ G D) (hGm : MapsTo G D upperHalfPlane)
-    (hF : DifferentiableOn ℂ F upperHalfPlane) (hFm : MapsTo F upperHalfPlane D)
-    (hc : Tendsto (fun z : ℂ => z*(G z-z)) (cocompact ℂ) (𝓝 (c:ℂ)))
-    (hd : Tendsto (fun z : ℂ => z*(H z-z)) (cocompact ℂ) (𝓝 (d:ℂ)))
-    (hn : Tendsto (fun z : ℂ => F z/z) (cocompact ℂ ⊓ 𝓟 upperHalfPlane) (𝓝 1))
-    (hHF : ∀ z ∈ upperHalfPlane, H (F z)=z) : c≤d := by
-  have hcomp := hydrodynamic_composition_coefficient hc hd hn hHF
-  have hnorm := hydrodynamic_composition_ratio hc hn
-  have hle := normalized_selfMap_coefficient_nonpos (hG.comp hF hFm)
-    (hGm.comp hFm) (c := c-d) (by
-      convert! hcomp using 1
-      simp only [ofReal_sub])
-    (by convert! hnorm using 1)
-  linarith
-
-end SLEExactGauge
-
-end
-
-end OAI
+import OAI.Probability.SLE.Loewner.HydrodynamicAsymptotics
+
+namespace OAI
+
+/-! The coefficient of a normalized composition subtracts capacities.
+Schwarz–Pick then makes capacity monotone under inclusion of slit domains. -/
+noncomputable section
+open Set Filter Complex Function Metric
+open scoped Topology
+
+namespace SLEExactGauge
+
+lemma hydrodynamic_ratio_limit {G : ℂ → ℂ} {c : ℂ}
+    (hG : Tendsto (fun z : ℂ => z*(G z-z)) (cocompact ℂ) (𝓝 c)) :
+    Tendsto (fun z : ℂ => G z/z) (cocompact ℂ) (𝓝 1) := by
+  have hi : Tendsto (fun z : ℂ => z⁻¹) (cocompact ℂ) (𝓝 0) := by
+    simpa only [Metric.cobounded_eq_cocompact] using
+      (tendsto_inv₀_cobounded : Tendsto (fun z : ℂ => z⁻¹) (Bornology.cobounded ℂ) (𝓝 0))
+  have hh := (hG.mul (hi.pow 2)).const_add 1
+  simp only [zero_pow two_ne_zero,mul_zero,add_zero] at hh
+  apply hh.congr'
+  filter_upwards [(isCompact_singleton (x := (0:ℂ))).compl_mem_cocompact] with z hz
+  have hz0 : z ≠ 0 := hz
+  field_simp [hz0]
+  ring
+
+lemma hydrodynamic_composition_coefficient {G H F : ℂ → ℂ} {c d : ℂ}
+    (hG : Tendsto (fun z : ℂ => z*(G z-z)) (cocompact ℂ) (𝓝 c))
+    (hH : Tendsto (fun z : ℂ => z*(H z-z)) (cocompact ℂ) (𝓝 d))
+    (hF : Tendsto (fun z : ℂ => F z/z) (cocompact ℂ ⊓ 𝓟 upperHalfPlane) (𝓝 1))
+    (hHF : ∀ z ∈ upperHalfPlane, H (F z)=z) :
+    Tendsto (fun z : ℂ => z*(G (F z)-z)) (cocompact ℂ ⊓ 𝓟 upperHalfPlane) (𝓝 (c-d)) := by
+  have hescape := normalized_ratio_tendsto_cocompact hF
+  have hquot : Tendsto (fun z : ℂ => z/F z) (cocompact ℂ ⊓ 𝓟 upperHalfPlane) (𝓝 1) := by
+    simpa only [inv_div,inv_one] using hF.inv₀ one_ne_zero
+  have hh := (hquot.mul (hG.comp hescape)).add (inverse_hydrodynamic_coefficient hH hF hHF)
+  simp only [one_mul,sub_eq_add_neg] at hh ⊢
+  apply hh.congr'
+  filter_upwards [hescape.eventually ((isCompact_singleton (x := (0:ℂ))).compl_mem_cocompact)] with z hz
+  simp only [Function.comp_apply]
+  have hz0 : F z ≠ 0 := hz
+  field_simp [hz0]
+  ring
+
+lemma hydrodynamic_composition_ratio {G F : ℂ → ℂ} {c : ℂ}
+    (hG : Tendsto (fun z : ℂ => z*(G z-z)) (cocompact ℂ) (𝓝 c))
+    (hF : Tendsto (fun z : ℂ => F z/z) (cocompact ℂ ⊓ 𝓟 upperHalfPlane) (𝓝 1)) :
+    Tendsto (fun z : ℂ => G (F z)/z) (cocompact ℂ ⊓ 𝓟 upperHalfPlane) (𝓝 1) := by
+  have he := normalized_ratio_tendsto_cocompact hF
+  have hh := ((hydrodynamic_ratio_limit hG).comp he).mul hF
+  simp only [mul_one] at hh
+  apply hh.congr'
+  filter_upwards [he.eventually ((isCompact_singleton (x := (0:ℂ))).compl_mem_cocompact)] with z hz
+  simp only [Function.comp_apply]
+  have hz0 : F z ≠ 0 := hz
+  field_simp [hz0]
+
+
+lemma normalized_selfMap_coefficient_nonpos {G : ℂ → ℂ} {c : ℝ}
+    (hd : DifferentiableOn ℂ G upperHalfPlane) (hm : MapsTo G upperHalfPlane upperHalfPlane)
+    (hc : Tendsto (fun z : ℂ => z*(G z-z)) (cocompact ℂ ⊓ 𝓟 upperHalfPlane) (𝓝 (c:ℂ)))
+    (hn : Tendsto (fun z : ℂ => G z/z) (cocompact ℂ ⊓ 𝓟 upperHalfPlane) (𝓝 1)) : c≤0 := by
+  have hr := Complex.continuous_re.tendsto (c:ℂ) |>.comp (hc.comp verticalInfinity_tendsto)
+  have hh : ∀ᶠ n in atTop, (verticalInfinity n*(G (verticalInfinity n)-verticalInfinity n)).re ≤ 0 := by
+    apply Eventually.of_forall
+    intro n
+    have hheight := normalized_halfPlane_height hd hm hn (verticalInfinity_mem n)
+    have hy : 0 < (n:ℝ)+1 := by positivity
+    simp only [verticalInfinity,mul_im,mul_re,ofReal_re,ofReal_im,I_re,I_im,mul_zero,
+      add_zero,mul_one,sub_im,sub_re,zero_sub] at hheight ⊢
+    nlinarith
+  have hle : (c:ℂ).re ≤ 0 := le_of_tendsto hr (by
+    simpa only [Function.comp_apply] using hh)
+  simpa only [ofReal_re] using hle
+
+theorem nested_hydrodynamic_coefficient_le
+    {D : Set ℂ} {G H F : ℂ → ℂ} {c d : ℝ}
+    (hG : DifferentiableOn ℂ G D) (hGm : MapsTo G D upperHalfPlane)
+    (hF : DifferentiableOn ℂ F upperHalfPlane) (hFm : MapsTo F upperHalfPlane D)
+    (hc : Tendsto (fun z : ℂ => z*(G z-z)) (cocompact ℂ) (𝓝 (c:ℂ)))
+    (hd : Tendsto (fun z : ℂ => z*(H z-z)) (cocompact ℂ) (𝓝 (d:ℂ)))
+    (hn : Tendsto (fun z : ℂ => F z/z) (cocompact ℂ ⊓ 𝓟 upperHalfPlane) (𝓝 1))
+    (hHF : ∀ z ∈ upperHalfPlane, H (F z)=z) : c≤d := by
+  have hcomp := hydrodynamic_composition_coefficient hc hd hn hHF
+  have hnorm := hydrodynamic_composition_ratio hc hn
+  have hle := normalized_selfMap_coefficient_nonpos (hG.comp hF hFm)
+    (hGm.comp hFm) (c := c-d) (by
+      convert! hcomp using 1
+      simp only [ofReal_sub])
+    (by convert! hnorm using 1)
+  linarith
+
+end SLEExactGauge
+
+end
+
+end OAI

lean/OAI/Probability/SLE/Loewner/HydrodynamicHeight.lean

@@ -1,61 +1,61 @@
-import OAI.Probability.SLE.Geometry.HalfPlaneJulia
-import OAI.Probability.SLE.Loewner.SlitInverseAtInfinity
-
-namespace OAI
-
-/-! Normalization at infinity forces a half-plane self-map to increase
-height. This compares the inverse maps of nested slit domains. -/
-noncomputable section
-open Set Filter Complex Function Metric
-open scoped Topology
-
-namespace SLEExactGauge
-
-def verticalInfinity (n : ℕ) : ℂ := (((n:ℝ)+1:ℝ):ℂ)*I
-
-lemma verticalHeights_tendsto : Tendsto (fun n : ℕ => (n:ℝ)+1) atTop atTop := by
-  convert! (tendsto_natCast_atTop_atTop (R := ℝ)).comp (tendsto_add_atTop_nat 1) using 1
-  ext n
-  simp only [Function.comp_apply,Nat.cast_add,Nat.cast_one]
-
-lemma verticalInfinity_mem (n : ℕ) : verticalInfinity n ∈ upperHalfPlane := by
-  simp only [verticalInfinity,upperHalfPlane,mem_ofPred_eq,mul_im,ofReal_re,I_im,mul_one,
-    ofReal_im,I_re,mul_zero,add_zero]
-  positivity
-
-lemma verticalInfinity_tendsto :
-    Tendsto verticalInfinity atTop (cocompact ℂ ⊓ 𝓟 upperHalfPlane) := by
-  apply tendsto_inf.mpr
-  constructor
-  · rw [← Metric.cobounded_eq_cocompact,← tendsto_norm_atTop_iff_cobounded]
-    have hh : Tendsto (fun n : ℕ => (n:ℝ)+1) atTop atTop :=
-      verticalHeights_tendsto
-    have hnorm : (fun n : ℕ => ‖verticalInfinity n‖)=(fun n : ℕ => (n:ℝ)+1) := by
-      funext n
-      simp only [verticalInfinity,norm_mul,Complex.norm_real,Real.norm_eq_abs,norm_I,
-        mul_one,abs_of_pos (by positivity : 0<(n:ℝ)+1)]
-    rw [hnorm]
-    exact hh
-  · exact tendsto_principal.mpr (Eventually.of_forall verticalInfinity_mem)
-
-theorem normalized_halfPlane_height {F : ℂ → ℂ}
-    (hF : DifferentiableOn ℂ F upperHalfPlane) (hmap : MapsTo F upperHalfPlane upperHalfPlane)
-    (hn : Tendsto (fun z : ℂ => F z/z) (cocompact ℂ ⊓ 𝓟 upperHalfPlane) (𝓝 1))
-    {z : ℂ} (hz : z ∈ upperHalfPlane) : z.im ≤ (F z).im := by
-  have hr := hn.comp verticalInfinity_tendsto
-  have he (n : ℕ) : F (verticalInfinity n)/(((n:ℝ)+1:ℝ):ℂ) =
-      (F (verticalInfinity n)/verticalInfinity n)*I := by
-    have hne : (((n:ℝ)+1:ℝ):ℂ) ≠ 0 := ofReal_ne_zero.mpr (by positivity)
-    simp only [verticalInfinity]
-    field_simp
-  have hlim : Tendsto (fun n : ℕ => F (verticalInfinity n)/(((n:ℝ)+1:ℝ):ℂ)) atTop (𝓝 I) := by
-    simpa only [Function.comp_apply,he,one_mul] using hr.mul_const I
-  exact halfPlane_julia_at_infinity hF hmap (fun n => (n:ℝ)+1)
-    (fun n => by positivity)
-    (tendsto_inv_atTop_zero.comp (verticalHeights_tendsto)) hlim hz
-
-end SLEExactGauge
-
-end
-
-end OAI
+import OAI.Probability.SLE.Geometry.HalfPlaneJulia
+import OAI.Probability.SLE.Loewner.SlitInverseAtInfinity
+
+namespace OAI
+
+/-! Normalization at infinity forces a half-plane self-map to increase
+height. This compares the inverse maps of nested slit domains. -/
+noncomputable section
+open Set Filter Complex Function Metric
+open scoped Topology
+
+namespace SLEExactGauge
+
+def verticalInfinity (n : ℕ) : ℂ := (((n:ℝ)+1:ℝ):ℂ)*I
+
+lemma verticalHeights_tendsto : Tendsto (fun n : ℕ => (n:ℝ)+1) atTop atTop := by
+  convert! (tendsto_natCast_atTop_atTop (R := ℝ)).comp (tendsto_add_atTop_nat 1) using 1
+  ext n
+  simp only [Function.comp_apply,Nat.cast_add,Nat.cast_one]
+
+lemma verticalInfinity_mem (n : ℕ) : verticalInfinity n ∈ upperHalfPlane := by
+  simp only [verticalInfinity,upperHalfPlane,mem_ofPred_eq,mul_im,ofReal_re,I_im,mul_one,
+    ofReal_im,I_re,mul_zero,add_zero]
+  positivity
+
+lemma verticalInfinity_tendsto :
+    Tendsto verticalInfinity atTop (cocompact ℂ ⊓ 𝓟 upperHalfPlane) := by
+  apply tendsto_inf.mpr
+  constructor
+  · rw [← Metric.cobounded_eq_cocompact,← tendsto_norm_atTop_iff_cobounded]
+    have hh : Tendsto (fun n : ℕ => (n:ℝ)+1) atTop atTop :=
+      verticalHeights_tendsto
+    have hnorm : (fun n : ℕ => ‖verticalInfinity n‖)=(fun n : ℕ => (n:ℝ)+1) := by
+      funext n
+      simp only [verticalInfinity,norm_mul,Complex.norm_real,Real.norm_eq_abs,norm_I,
+        mul_one,abs_of_pos (by positivity : 0<(n:ℝ)+1)]
+    rw [hnorm]
+    exact hh
+  · exact tendsto_principal.mpr (Eventually.of_forall verticalInfinity_mem)
+
+theorem normalized_halfPlane_height {F : ℂ → ℂ}
+    (hF : DifferentiableOn ℂ F upperHalfPlane) (hmap : MapsTo F upperHalfPlane upperHalfPlane)
+    (hn : Tendsto (fun z : ℂ => F z/z) (cocompact ℂ ⊓ 𝓟 upperHalfPlane) (𝓝 1))
+    {z : ℂ} (hz : z ∈ upperHalfPlane) : z.im ≤ (F z).im := by
+  have hr := hn.comp verticalInfinity_tendsto
+  have he (n : ℕ) : F (verticalInfinity n)/(((n:ℝ)+1:ℝ):ℂ) =
+      (F (verticalInfinity n)/verticalInfinity n)*I := by
+    have hne : (((n:ℝ)+1:ℝ):ℂ) ≠ 0 := ofReal_ne_zero.mpr (by positivity)
+    simp only [verticalInfinity]
+    field_simp
+  have hlim : Tendsto (fun n : ℕ => F (verticalInfinity n)/(((n:ℝ)+1:ℝ):ℂ)) atTop (𝓝 I) := by
+    simpa only [Function.comp_apply,he,one_mul] using hr.mul_const I
+  exact halfPlane_julia_at_infinity hF hmap (fun n => (n:ℝ)+1)
+    (fun n => by positivity)
+    (tendsto_inv_atTop_zero.comp (verticalHeights_tendsto)) hlim hz
+
+end SLEExactGauge
+
+end
+
+end OAI

lean/OAI/Probability/SLE/Loewner/InitialCapacity.lean

@@ -1,88 +1,88 @@
-import OAI.Probability.SLE.Loewner.InitialSubarc
-
-namespace OAI
-
-/-! A monotone positive capacity parameter on the exact initial subarcs. -/
-noncomputable section
-open Set Filter Function
-open scoped Topology
-
-namespace SLEExactGauge
-
-structure SimpleSlitChart (p : C(unitInterval,ℂ)) where
-  forward : ℂ → ℂ
-  inverse : ℂ → ℂ
-  capacity : ℝ
-  capacity_pos : 0<capacity
-  bijOn : BijOn forward (upperHalfPlane \ range p) upperHalfPlane
-  forward_differentiable : DifferentiableOn ℂ forward (upperHalfPlane \ range p)
-  inverse_differentiable : DifferentiableOn ℂ inverse upperHalfPlane
-  inverse_mapsTo : MapsTo inverse upperHalfPlane (upperHalfPlane \ range p)
-  left_inverse : ∀ z ∈ upperHalfPlane \ range p, inverse (forward z)=z
-  right_inverse : ∀ z ∈ upperHalfPlane, forward (inverse z)=z
-  coefficient : Tendsto (fun z : ℂ => z*(forward z-z)) (cocompact ℂ) (𝓝 (capacity:ℂ))
-  inverse_normalized : Tendsto (fun z : ℂ => inverse z/z)
-    (cocompact ℂ ⊓ 𝓟 upperHalfPlane) (𝓝 1)
-  height_le : ∀ z ∈ upperHalfPlane \ range p, (forward z).im≤z.im
-
-lemma exists_simpleSlitChart (p : C(unitInterval,ℂ)) (hi : Injective p) (h0 : p 0=0)
-    (hH : ∀ t : unitInterval, t ≠ 0 → p t ∈ upperHalfPlane) : Nonempty (SimpleSlitChart p) := by
-  obtain ⟨G,F,c,hc,hb,hdG,hdF,hm,hl,hr,hlim,hn,hh⟩ :=
-    simple_slit_exists_positive_capacity_chart p hi h0 hH
-  exact ⟨⟨G,F,c,hc,hb,hdG,hdF,hm,hl,hr,hlim,hn,hh⟩⟩
-
-noncomputable def initialSlitChart (p : C(unitInterval,ℂ)) (hi : Injective p) (h0 : p 0=0)
-    (hH : ∀ t : unitInterval, t ≠ 0 → p t ∈ upperHalfPlane)
-    (t : unitInterval) (ht : t ≠ 0) : SimpleSlitChart (initialSubarc p t) :=
-  Classical.choice (exists_simpleSlitChart _ (initialSubarc_injective hi ht)
-    (by simpa only [initialSubarc_zero] using h0) (initialSubarc_upper hH ht))
-
-lemma SimpleSlitChart.capacity_le_of_range_subset
-    {p q : C(unitInterval,ℂ)} (P : SimpleSlitChart p) (Q : SimpleSlitChart q)
-    (hpq : range p ⊆ range q) : P.capacity≤Q.capacity := by
-  have hdom : upperHalfPlane \ range q ⊆ upperHalfPlane \ range p := by
-    intro z hz
-    exact ⟨hz.1,fun hp => hz.2 (hpq hp)⟩
-  exact nested_hydrodynamic_coefficient_le P.forward_differentiable P.bijOn.mapsTo
-    Q.inverse_differentiable (Q.inverse_mapsTo.mono_right hdom)
-    P.coefficient Q.coefficient Q.inverse_normalized Q.right_inverse
-
-noncomputable def initialCapacity (p : C(unitInterval,ℂ)) (hi : Injective p) (h0 : p 0=0)
-    (hH : ∀ t : unitInterval, t ≠ 0 → p t ∈ upperHalfPlane) (t : unitInterval) : ℝ :=
-  if ht : t=0 then 0 else (initialSlitChart p hi h0 hH t ht).capacity
-
-@[simp] lemma initialCapacity_zero (p : C(unitInterval,ℂ)) (hi : Injective p) (h0 : p 0=0)
-    (hH : ∀ t : unitInterval, t ≠ 0 → p t ∈ upperHalfPlane) : initialCapacity p hi h0 hH 0=0 := by
-  simp [initialCapacity]
-
-lemma initialCapacity_pos (p : C(unitInterval,ℂ)) (hi : Injective p) (h0 : p 0=0)
-    (hH : ∀ t : unitInterval, t ≠ 0 → p t ∈ upperHalfPlane)
-    {t : unitInterval} (ht : t ≠ 0) : 0 < initialCapacity p hi h0 hH t := by
-  rw [initialCapacity,dite_eq_right ht]
-  exact (initialSlitChart p hi h0 hH t ht).capacity_pos
-
-lemma initialCapacity_nonneg (p : C(unitInterval,ℂ)) (hi : Injective p) (h0 : p 0=0)
-    (hH : ∀ t : unitInterval, t ≠ 0 → p t ∈ upperHalfPlane) (t : unitInterval) :
-    0 ≤ initialCapacity p hi h0 hH t := by
-  by_cases ht : t=0
-  · simp only [ht,initialCapacity_zero,le_refl]
-  · exact (initialCapacity_pos p hi h0 hH ht).le
-
-theorem initialCapacity_monotone (p : C(unitInterval,ℂ)) (hi : Injective p) (h0 : p 0=0)
-    (hH : ∀ t : unitInterval, t ≠ 0 → p t ∈ upperHalfPlane) :
-    Monotone (initialCapacity p hi h0 hH) := by
-  intro s t hst
-  by_cases hs : s=0
-  · rw [hs,initialCapacity_zero]
-    exact initialCapacity_nonneg p hi h0 hH t
-  have ht : t≠0 := by
-    intro ht
-    exact hs (le_antisymm (ht ▸ hst) bot_le)
-  rw [initialCapacity,dite_eq_right hs,initialCapacity,dite_eq_right ht]
-  exact SimpleSlitChart.capacity_le_of_range_subset _ _ (initialSubarc_range_mono p hst)
-
-end SLEExactGauge
-
-end
-
-end OAI
+import OAI.Probability.SLE.Loewner.InitialSubarc
+
+namespace OAI
+
+/-! A monotone positive capacity parameter on the exact initial subarcs. -/
+noncomputable section
+open Set Filter Function
+open scoped Topology
+
+namespace SLEExactGauge
+
+structure SimpleSlitChart (p : C(unitInterval,ℂ)) where
+  forward : ℂ → ℂ
+  inverse : ℂ → ℂ
+  capacity : ℝ
+  capacity_pos : 0<capacity
+  bijOn : BijOn forward (upperHalfPlane \ range p) upperHalfPlane
+  forward_differentiable : DifferentiableOn ℂ forward (upperHalfPlane \ range p)
+  inverse_differentiable : DifferentiableOn ℂ inverse upperHalfPlane
+  inverse_mapsTo : MapsTo inverse upperHalfPlane (upperHalfPlane \ range p)
+  left_inverse : ∀ z ∈ upperHalfPlane \ range p, inverse (forward z)=z
+  right_inverse : ∀ z ∈ upperHalfPlane, forward (inverse z)=z
+  coefficient : Tendsto (fun z : ℂ => z*(forward z-z)) (cocompact ℂ) (𝓝 (capacity:ℂ))
+  inverse_normalized : Tendsto (fun z : ℂ => inverse z/z)
+    (cocompact ℂ ⊓ 𝓟 upperHalfPlane) (𝓝 1)
+  height_le : ∀ z ∈ upperHalfPlane \ range p, (forward z).im≤z.im
+
+lemma exists_simpleSlitChart (p : C(unitInterval,ℂ)) (hi : Injective p) (h0 : p 0=0)
+    (hH : ∀ t : unitInterval, t ≠ 0 → p t ∈ upperHalfPlane) : Nonempty (SimpleSlitChart p) := by
+  obtain ⟨G,F,c,hc,hb,hdG,hdF,hm,hl,hr,hlim,hn,hh⟩ :=
+    simple_slit_exists_positive_capacity_chart p hi h0 hH
+  exact ⟨⟨G,F,c,hc,hb,hdG,hdF,hm,hl,hr,hlim,hn,hh⟩⟩
+
+noncomputable def initialSlitChart (p : C(unitInterval,ℂ)) (hi : Injective p) (h0 : p 0=0)
+    (hH : ∀ t : unitInterval, t ≠ 0 → p t ∈ upperHalfPlane)
+    (t : unitInterval) (ht : t ≠ 0) : SimpleSlitChart (initialSubarc p t) :=
+  Classical.choice (exists_simpleSlitChart _ (initialSubarc_injective hi ht)
+    (by simpa only [initialSubarc_zero] using h0) (initialSubarc_upper hH ht))
+
+lemma SimpleSlitChart.capacity_le_of_range_subset
+    {p q : C(unitInterval,ℂ)} (P : SimpleSlitChart p) (Q : SimpleSlitChart q)
+    (hpq : range p ⊆ range q) : P.capacity≤Q.capacity := by
+  have hdom : upperHalfPlane \ range q ⊆ upperHalfPlane \ range p := by
+    intro z hz
+    exact ⟨hz.1,fun hp => hz.2 (hpq hp)⟩
+  exact nested_hydrodynamic_coefficient_le P.forward_differentiable P.bijOn.mapsTo
+    Q.inverse_differentiable (Q.inverse_mapsTo.mono_right hdom)
+    P.coefficient Q.coefficient Q.inverse_normalized Q.right_inverse
+
+noncomputable def initialCapacity (p : C(unitInterval,ℂ)) (hi : Injective p) (h0 : p 0=0)
+    (hH : ∀ t : unitInterval, t ≠ 0 → p t ∈ upperHalfPlane) (t : unitInterval) : ℝ :=
+  if ht : t=0 then 0 else (initialSlitChart p hi h0 hH t ht).capacity
+
+@[simp] lemma initialCapacity_zero (p : C(unitInterval,ℂ)) (hi : Injective p) (h0 : p 0=0)
+    (hH : ∀ t : unitInterval, t ≠ 0 → p t ∈ upperHalfPlane) : initialCapacity p hi h0 hH 0=0 := by
+  simp [initialCapacity]
+
+lemma initialCapacity_pos (p : C(unitInterval,ℂ)) (hi : Injective p) (h0 : p 0=0)
+    (hH : ∀ t : unitInterval, t ≠ 0 → p t ∈ upperHalfPlane)
+    {t : unitInterval} (ht : t ≠ 0) : 0 < initialCapacity p hi h0 hH t := by
+  rw [initialCapacity,dite_eq_right ht]
+  exact (initialSlitChart p hi h0 hH t ht).capacity_pos
+
+lemma initialCapacity_nonneg (p : C(unitInterval,ℂ)) (hi : Injective p) (h0 : p 0=0)
+    (hH : ∀ t : unitInterval, t ≠ 0 → p t ∈ upperHalfPlane) (t : unitInterval) :
+    0 ≤ initialCapacity p hi h0 hH t := by
+  by_cases ht : t=0
+  · simp only [ht,initialCapacity_zero,le_refl]
+  · exact (initialCapacity_pos p hi h0 hH ht).le
+
+theorem initialCapacity_monotone (p : C(unitInterval,ℂ)) (hi : Injective p) (h0 : p 0=0)
+    (hH : ∀ t : unitInterval, t ≠ 0 → p t ∈ upperHalfPlane) :
+    Monotone (initialCapacity p hi h0 hH) := by
+  intro s t hst
+  by_cases hs : s=0
+  · rw [hs,initialCapacity_zero]
+    exact initialCapacity_nonneg p hi h0 hH t
+  have ht : t≠0 := by
+    intro ht
+    exact hs (le_antisymm (ht ▸ hst) bot_le)
+  rw [initialCapacity,dite_eq_right hs,initialCapacity,dite_eq_right ht]
+  exact SimpleSlitChart.capacity_le_of_range_subset _ _ (initialSubarc_range_mono p hst)
+
+end SLEExactGauge
+
+end
+
+end OAI

lean/OAI/Probability/SLE/Loewner/InitialCapacityAtZero.lean

@@ -1,46 +1,46 @@
-import OAI.Probability.SLE.Loewner.CapacityRadiusBound
-
-namespace OAI
-
-/-! The capacity of initial subarcs tends to zero at the starting point,
-by the explicit half-disk capacity bound. -/
-noncomputable section
-open Set Filter Complex Function Metric
-open scoped Topology
-
-namespace SLEExactGauge
-
-theorem initialCapacity_continuousAt_zero (p : C(unitInterval,ℂ)) (hi : Injective p)
-    (h0 : p 0=0) (hH : ∀ t : unitInterval, t ≠ 0 → p t ∈ upperHalfPlane) :
-    ContinuousAt (initialCapacity p hi h0 hH) 0 := by
-  rw [Metric.continuousAt_iff]
-  intro ε hε
-  let R : ℝ := Real.sqrt ε/2
-  have hR : 0<R := div_pos (Real.sqrt_pos.mpr hε) (by norm_num)
-  have hR2 : R^2<ε := by
-    dsimp only [R]
-    nlinarith [Real.sq_sqrt hε.le,Real.sqrt_nonneg ε]
-  have hp := p.continuous.continuousAt.preimage_mem_nhds (ball_mem_nhds (p 0) hR)
-  obtain ⟨δ,hδ,hδp⟩ := Metric.mem_nhds_iff.mp hp
-  refine ⟨δ,hδ,?_⟩
-  intro t ht
-  have hbound : ∀ u ∈ Icc (0:unitInterval) t, ‖p u‖≤R := by
-    intro u hu
-    have hdist : dist u (0:unitInterval) ≤ dist t (0:unitInterval) := by
-      change |(u:ℝ)-0|≤|(t:ℝ)-0|
-      simp only [sub_zero,abs_of_nonneg u.property.1,abs_of_nonneg t.property.1]
-      exact_mod_cast hu.2
-    have hpu := hδp (hdist.trans_lt ht)
-    have hlt : ‖p u‖<R := by
-      simpa only [mem_preimage,mem_ball,h0,dist_zero_right] using hpu
-    exact hlt.le
-  have hc := initialCapacity_le_radius_sq p hi h0 hH hR t hbound
-  rw [initialCapacity_zero,Real.dist_eq,sub_zero,
-    abs_of_nonneg (initialCapacity_nonneg p hi h0 hH t)]
-  exact hc.trans_lt hR2
-
-end SLEExactGauge
-
-end
-
-end OAI
+import OAI.Probability.SLE.Loewner.CapacityRadiusBound
+
+namespace OAI
+
+/-! The capacity of initial subarcs tends to zero at the starting point,
+by the explicit half-disk capacity bound. -/
+noncomputable section
+open Set Filter Complex Function Metric
+open scoped Topology
+
+namespace SLEExactGauge
+
+theorem initialCapacity_continuousAt_zero (p : C(unitInterval,ℂ)) (hi : Injective p)
+    (h0 : p 0=0) (hH : ∀ t : unitInterval, t ≠ 0 → p t ∈ upperHalfPlane) :
+    ContinuousAt (initialCapacity p hi h0 hH) 0 := by
+  rw [Metric.continuousAt_iff]
+  intro ε hε
+  let R : ℝ := Real.sqrt ε/2
+  have hR : 0<R := div_pos (Real.sqrt_pos.mpr hε) (by norm_num)
+  have hR2 : R^2<ε := by
+    dsimp only [R]
+    nlinarith [Real.sq_sqrt hε.le,Real.sqrt_nonneg ε]
+  have hp := p.continuous.continuousAt.preimage_mem_nhds (ball_mem_nhds (p 0) hR)
+  obtain ⟨δ,hδ,hδp⟩ := Metric.mem_nhds_iff.mp hp
+  refine ⟨δ,hδ,?_⟩
+  intro t ht
+  have hbound : ∀ u ∈ Icc (0:unitInterval) t, ‖p u‖≤R := by
+    intro u hu
+    have hdist : dist u (0:unitInterval) ≤ dist t (0:unitInterval) := by
+      change |(u:ℝ)-0|≤|(t:ℝ)-0|
+      simp only [sub_zero,abs_of_nonneg u.property.1,abs_of_nonneg t.property.1]
+      exact_mod_cast hu.2
+    have hpu := hδp (hdist.trans_lt ht)
+    have hlt : ‖p u‖<R := by
+      simpa only [mem_preimage,mem_ball,h0,dist_zero_right] using hpu
+    exact hlt.le
+  have hc := initialCapacity_le_radius_sq p hi h0 hH hR t hbound
+  rw [initialCapacity_zero,Real.dist_eq,sub_zero,
+    abs_of_nonneg (initialCapacity_nonneg p hi h0 hH t)]
+  exact hc.trans_lt hR2
+
+end SLEExactGauge
+
+end
+
+end OAI

lean/OAI/Probability/SLE/Loewner/InitialCapacityClock.lean

@@ -1,51 +1,51 @@
-import OAI.Probability.SLE.Loewner.InitialCapacityContinuity
-import OAI.Probability.SLE.Loewner.InitialCapacityStrict
-import Mathlib.Topology.Order.IntermediateValue
-import Mathlib.Order.Hom.Set
-
-namespace OAI
-
-/-! The capacity of a simple attached slit is a genuine continuous clock,
-with an exact continuous inverse on its full range. -/
-noncomputable section
-open Set Function
-open scoped Topology
-
-namespace SLEExactGauge
-
-lemma initialCapacity_range (p : C(unitInterval,ℂ)) (hi : Injective p)
-    (h0 : p 0=0) (hH : ∀ t : unitInterval, t ≠ 0 → p t ∈ upperHalfPlane) :
-    range (initialCapacity p hi h0 hH)=Icc 0 (initialCapacity p hi h0 hH 1) := by
-  have hh := (initialCapacity_continuous p hi h0 hH).image_Icc_of_strictMono
-    (initialCapacity_strictMono p hi h0 hH) (a := 0) (b := 1)
-  have hIcc : Icc (0:unitInterval) 1=univ := by
-    ext x
-    simp only [mem_Icc,mem_univ,iff_true]
-    exact ⟨bot_le,le_top⟩
-  simpa only [hIcc,image_univ,initialCapacity_zero] using hh
-
-noncomputable def initialCapacityHomeomorph (p : C(unitInterval,ℂ)) (hi : Injective p)
-    (h0 : p 0=0) (hH : ∀ t : unitInterval, t ≠ 0 → p t ∈ upperHalfPlane) :
-    unitInterval ≃ₜ Icc 0 (initialCapacity p hi h0 hH 1) :=
-  (((initialCapacity_strictMono p hi h0 hH).orderIso (initialCapacity p hi h0 hH)).trans
-    (Set.orderIsoOfEq _ _ (initialCapacity_range p hi h0 hH))).toHomeomorph
-
-@[simp] lemma initialCapacityHomeomorph_apply (p : C(unitInterval,ℂ)) (hi : Injective p)
-    (h0 : p 0=0) (hH : ∀ t : unitInterval, t ≠ 0 → p t ∈ upperHalfPlane)
-    (t : unitInterval) :
-    ((initialCapacityHomeomorph p hi h0 hH t : Icc 0 (initialCapacity p hi h0 hH 1)):ℝ)=
-      initialCapacity p hi h0 hH t := rfl
-
-@[simp] lemma initialCapacityHomeomorph_symm_capacity (p : C(unitInterval,ℂ)) (hi : Injective p)
-    (h0 : p 0=0) (hH : ∀ t : unitInterval, t ≠ 0 → p t ∈ upperHalfPlane)
-    (c : Icc 0 (initialCapacity p hi h0 hH 1)) :
-    initialCapacity p hi h0 hH ((initialCapacityHomeomorph p hi h0 hH).symm c)=(c:ℝ) := by
-  have hh := congrArg (fun x : Icc 0 (initialCapacity p hi h0 hH 1) => (x:ℝ))
-    ((initialCapacityHomeomorph p hi h0 hH).apply_symm_apply c)
-  exact hh
-
-end SLEExactGauge
-
-end
-
-end OAI
+import OAI.Probability.SLE.Loewner.InitialCapacityContinuity
+import OAI.Probability.SLE.Loewner.InitialCapacityStrict
+import Mathlib.Topology.Order.IntermediateValue
+import Mathlib.Order.Hom.Set
+
+namespace OAI
+
+/-! The capacity of a simple attached slit is a genuine continuous clock,
+with an exact continuous inverse on its full range. -/
+noncomputable section
+open Set Function
+open scoped Topology
+
+namespace SLEExactGauge
+
+lemma initialCapacity_range (p : C(unitInterval,ℂ)) (hi : Injective p)
+    (h0 : p 0=0) (hH : ∀ t : unitInterval, t ≠ 0 → p t ∈ upperHalfPlane) :
+    range (initialCapacity p hi h0 hH)=Icc 0 (initialCapacity p hi h0 hH 1) := by
+  have hh := (initialCapacity_continuous p hi h0 hH).image_Icc_of_strictMono
+    (initialCapacity_strictMono p hi h0 hH) (a := 0) (b := 1)
+  have hIcc : Icc (0:unitInterval) 1=univ := by
+    ext x
+    simp only [mem_Icc,mem_univ,iff_true]
+    exact ⟨bot_le,le_top⟩
+  simpa only [hIcc,image_univ,initialCapacity_zero] using hh
+
+noncomputable def initialCapacityHomeomorph (p : C(unitInterval,ℂ)) (hi : Injective p)
+    (h0 : p 0=0) (hH : ∀ t : unitInterval, t ≠ 0 → p t ∈ upperHalfPlane) :
+    unitInterval ≃ₜ Icc 0 (initialCapacity p hi h0 hH 1) :=
+  (((initialCapacity_strictMono p hi h0 hH).orderIso (initialCapacity p hi h0 hH)).trans
+    (Set.orderIsoOfEq _ _ (initialCapacity_range p hi h0 hH))).toHomeomorph
+
+@[simp] lemma initialCapacityHomeomorph_apply (p : C(unitInterval,ℂ)) (hi : Injective p)
+    (h0 : p 0=0) (hH : ∀ t : unitInterval, t ≠ 0 → p t ∈ upperHalfPlane)
+    (t : unitInterval) :
+    ((initialCapacityHomeomorph p hi h0 hH t : Icc 0 (initialCapacity p hi h0 hH 1)):ℝ)=
+      initialCapacity p hi h0 hH t := rfl
+
+@[simp] lemma initialCapacityHomeomorph_symm_capacity (p : C(unitInterval,ℂ)) (hi : Injective p)
+    (h0 : p 0=0) (hH : ∀ t : unitInterval, t ≠ 0 → p t ∈ upperHalfPlane)
+    (c : Icc 0 (initialCapacity p hi h0 hH 1)) :
+    initialCapacity p hi h0 hH ((initialCapacityHomeomorph p hi h0 hH).symm c)=(c:ℝ) := by
+  have hh := congrArg (fun x : Icc 0 (initialCapacity p hi h0 hH 1) => (x:ℝ))
+    ((initialCapacityHomeomorph p hi h0 hH).apply_symm_apply c)
+  exact hh
+
+end SLEExactGauge
+
+end
+
+end OAI

lean/OAI/Probability/SLE/Loewner/InitialCapacityContinuity.lean

@@ -1,88 +1,88 @@
-import OAI.Probability.SLE.Loewner.InitialCapacityTerminal
-import OAI.Probability.SLE.Loewner.InitialForwardComparison
-import OAI.Probability.SLE.Mass.VerticalDisplacementMass
-
-namespace OAI
-
-/-! Continuity of the full capacity parameter. The capacity of the initial
-slit and its complementary capacity relative to the final slit give the two
-inequalities for every subsequential limit. -/
-noncomputable section
-open Set Filter Function Complex
-open scoped Topology
-
-namespace SLEExactGauge
-
-lemma initialCapacity_limit_value_at (p : C(unitInterval,ℂ)) (hi : Injective p)
-    (h0 : p 0=0) (hH : ∀ t : unitInterval, t ≠ 0 → p t ∈ upperHalfPlane)
-    {t : ℕ → unitInterval} {F : ℂ → ℂ} {c : ℝ}
-    (hF : DifferentiableOn ℂ F upperHalfPlane)
-    (hlim : TendstoLocallyUniformlyOn (fun n => initialInverseChart p hi h0 hH (t n))
-      F atTop upperHalfPlane) {s : unitInterval} (hs : s≠0) (ht : Tendsto t atTop (𝓝 s))
-    (hcap : Tendsto (fun n => initialCapacity p hi h0 hH (t n)) atTop (𝓝 c)) :
-    c=initialCapacity p hi h0 hH s := by
-  let P := initialSlitChart p hi h0 hH s hs
-  have heF : EqOn F P.inverse upperHalfPlane := by
-    simpa only [initialInverseChart,dite_eq_right hs] using
-      initialInverse_limit_eq_at p hi h0 hH hF hlim hs ht
-  have hlow : P.capacity≤c := by
-    apply hydrodynamic_mass_le_of_displacement
-      (inverse_hydrodynamic_coefficient P.coefficient P.inverse_normalized P.right_inverse)
-    intro z hz
-    rw [← heF hz]
-    exact initialInverse_limit_displacement p hi h0 hH hlim hcap hz
-  obtain ⟨Q⟩ := exists_simpleSlitChart p hi h0 hH
-  obtain ⟨φ,hφ,hforward⟩ := initialInverse_limit_forward_on_final p hi h0 hH hF hlim hs ht
-  have hbound (z : ℂ) (hz : z∈upperHalfPlane) :
-      ‖P.forward (Q.inverse z)-z‖≤(Q.capacity-c)/z.im := by
-    have hleft := ((hforward (Q.inverse z) (Q.inverse_mapsTo hz)).sub_const z).norm
-    have hright := ((tendsto_const_nhds (x := Q.capacity)).sub
-      (hcap.comp hφ.tendsto_atTop)).div_const z.im
-    exact le_of_tendsto_of_tendsto hleft hright
-      (Eventually.of_forall fun n => initialForward_comparison_to_final p hi h0 hH Q _ hz)
-  have hcomp : Tendsto (fun z : ℂ => z*(P.forward (Q.inverse z)-z))
-      (cocompact ℂ ⊓ 𝓟 upperHalfPlane) (𝓝 (-((Q.capacity-P.capacity:ℝ):ℂ))) := by
-    have he : -((Q.capacity-P.capacity:ℝ):ℂ)=(P.capacity:ℂ)-Q.capacity := by
-      push_cast
-      ring
-    rw [he]
-    exact hydrodynamic_composition_coefficient P.coefficient Q.coefficient
-      Q.inverse_normalized Q.right_inverse
-  have hupper := hydrodynamic_mass_le_of_displacement hcomp hbound
-  rw [initialCapacity,dite_eq_right hs]
-  change c=P.capacity
-  exact le_antisymm (by linarith) hlow
-
-theorem initialCapacity_continuousAt (p : C(unitInterval,ℂ)) (hi : Injective p)
-    (h0 : p 0=0) (hH : ∀ t : unitInterval, t ≠ 0 → p t ∈ upperHalfPlane)
-    (s : unitInterval) : ContinuousAt (initialCapacity p hi h0 hH) s := by
-  by_cases hs : s=0
-  · subst s
-    exact initialCapacity_continuousAt_zero p hi h0 hH
-  apply tendsto_of_subseq_tendsto
-  intro t ht
-  have hb (n : ℕ) : initialCapacity p hi h0 hH (t n)∈
-      Icc 0 (initialCapacity p hi h0 hH 1) :=
-    ⟨initialCapacity_nonneg p hi h0 hH _,initialCapacity_monotone p hi h0 hH le_top⟩
-  obtain ⟨c,_,φ,hφ,hcap⟩ := isCompact_Icc.tendsto_subseq hb
-  obtain ⟨ψ,F,hψ,hF,hFlim⟩ := initialInverseChart_subsequence p hi h0 hH (t ∘ φ)
-  have ht' : Tendsto (fun n => t (φ (ψ n))) atTop (𝓝 s) :=
-    (ht.comp hφ.tendsto_atTop).comp hψ.tendsto_atTop
-  have hc' := hcap.comp hψ.tendsto_atTop
-  have he := initialCapacity_limit_value_at p hi h0 hH hF hFlim hs ht' hc'
-  refine ⟨φ ∘ ψ,?_⟩
-  change Tendsto (fun n => initialCapacity p hi h0 hH (t (φ (ψ n))))
-    atTop (𝓝 (initialCapacity p hi h0 hH s))
-  change Tendsto (fun n => initialCapacity p hi h0 hH (t (φ (ψ n)))) atTop (𝓝 c) at hc'
-  rwa [he] at hc'
-
-theorem initialCapacity_continuous (p : C(unitInterval,ℂ)) (hi : Injective p)
-    (h0 : p 0=0) (hH : ∀ t : unitInterval, t ≠ 0 → p t ∈ upperHalfPlane) :
-    Continuous (initialCapacity p hi h0 hH) :=
-  continuous_iff_continuousAt.mpr (initialCapacity_continuousAt p hi h0 hH)
-
-end SLEExactGauge
-
-end
-
-end OAI
+import OAI.Probability.SLE.Loewner.InitialCapacityTerminal
+import OAI.Probability.SLE.Loewner.InitialForwardComparison
+import OAI.Probability.SLE.Mass.VerticalDisplacementMass
+
+namespace OAI
+
+/-! Continuity of the full capacity parameter. The capacity of the initial
+slit and its complementary capacity relative to the final slit give the two
+inequalities for every subsequential limit. -/
+noncomputable section
+open Set Filter Function Complex
+open scoped Topology
+
+namespace SLEExactGauge
+
+lemma initialCapacity_limit_value_at (p : C(unitInterval,ℂ)) (hi : Injective p)
+    (h0 : p 0=0) (hH : ∀ t : unitInterval, t ≠ 0 → p t ∈ upperHalfPlane)
+    {t : ℕ → unitInterval} {F : ℂ → ℂ} {c : ℝ}
+    (hF : DifferentiableOn ℂ F upperHalfPlane)
+    (hlim : TendstoLocallyUniformlyOn (fun n => initialInverseChart p hi h0 hH (t n))
+      F atTop upperHalfPlane) {s : unitInterval} (hs : s≠0) (ht : Tendsto t atTop (𝓝 s))
+    (hcap : Tendsto (fun n => initialCapacity p hi h0 hH (t n)) atTop (𝓝 c)) :
+    c=initialCapacity p hi h0 hH s := by
+  let P := initialSlitChart p hi h0 hH s hs
+  have heF : EqOn F P.inverse upperHalfPlane := by
+    simpa only [initialInverseChart,dite_eq_right hs] using
+      initialInverse_limit_eq_at p hi h0 hH hF hlim hs ht
+  have hlow : P.capacity≤c := by
+    apply hydrodynamic_mass_le_of_displacement
+      (inverse_hydrodynamic_coefficient P.coefficient P.inverse_normalized P.right_inverse)
+    intro z hz
+    rw [← heF hz]
+    exact initialInverse_limit_displacement p hi h0 hH hlim hcap hz
+  obtain ⟨Q⟩ := exists_simpleSlitChart p hi h0 hH
+  obtain ⟨φ,hφ,hforward⟩ := initialInverse_limit_forward_on_final p hi h0 hH hF hlim hs ht
+  have hbound (z : ℂ) (hz : z∈upperHalfPlane) :
+      ‖P.forward (Q.inverse z)-z‖≤(Q.capacity-c)/z.im := by
+    have hleft := ((hforward (Q.inverse z) (Q.inverse_mapsTo hz)).sub_const z).norm
+    have hright := ((tendsto_const_nhds (x := Q.capacity)).sub
+      (hcap.comp hφ.tendsto_atTop)).div_const z.im
+    exact le_of_tendsto_of_tendsto hleft hright
+      (Eventually.of_forall fun n => initialForward_comparison_to_final p hi h0 hH Q _ hz)
+  have hcomp : Tendsto (fun z : ℂ => z*(P.forward (Q.inverse z)-z))
+      (cocompact ℂ ⊓ 𝓟 upperHalfPlane) (𝓝 (-((Q.capacity-P.capacity:ℝ):ℂ))) := by
+    have he : -((Q.capacity-P.capacity:ℝ):ℂ)=(P.capacity:ℂ)-Q.capacity := by
+      push_cast
+      ring
+    rw [he]
+    exact hydrodynamic_composition_coefficient P.coefficient Q.coefficient
+      Q.inverse_normalized Q.right_inverse
+  have hupper := hydrodynamic_mass_le_of_displacement hcomp hbound
+  rw [initialCapacity,dite_eq_right hs]
+  change c=P.capacity
+  exact le_antisymm (by linarith) hlow
+
+theorem initialCapacity_continuousAt (p : C(unitInterval,ℂ)) (hi : Injective p)
+    (h0 : p 0=0) (hH : ∀ t : unitInterval, t ≠ 0 → p t ∈ upperHalfPlane)
+    (s : unitInterval) : ContinuousAt (initialCapacity p hi h0 hH) s := by
+  by_cases hs : s=0
+  · subst s
+    exact initialCapacity_continuousAt_zero p hi h0 hH
+  apply tendsto_of_subseq_tendsto
+  intro t ht
+  have hb (n : ℕ) : initialCapacity p hi h0 hH (t n)∈
+      Icc 0 (initialCapacity p hi h0 hH 1) :=
+    ⟨initialCapacity_nonneg p hi h0 hH _,initialCapacity_monotone p hi h0 hH le_top⟩
+  obtain ⟨c,_,φ,hφ,hcap⟩ := isCompact_Icc.tendsto_subseq hb
+  obtain ⟨ψ,F,hψ,hF,hFlim⟩ := initialInverseChart_subsequence p hi h0 hH (t ∘ φ)
+  have ht' : Tendsto (fun n => t (φ (ψ n))) atTop (𝓝 s) :=
+    (ht.comp hφ.tendsto_atTop).comp hψ.tendsto_atTop
+  have hc' := hcap.comp hψ.tendsto_atTop
+  have he := initialCapacity_limit_value_at p hi h0 hH hF hFlim hs ht' hc'
+  refine ⟨φ ∘ ψ,?_⟩
+  change Tendsto (fun n => initialCapacity p hi h0 hH (t (φ (ψ n))))
+    atTop (𝓝 (initialCapacity p hi h0 hH s))
+  change Tendsto (fun n => initialCapacity p hi h0 hH (t (φ (ψ n)))) atTop (𝓝 c) at hc'
+  rwa [he] at hc'
+
+theorem initialCapacity_continuous (p : C(unitInterval,ℂ)) (hi : Injective p)
+    (h0 : p 0=0) (hH : ∀ t : unitInterval, t ≠ 0 → p t ∈ upperHalfPlane) :
+    Continuous (initialCapacity p hi h0 hH) :=
+  continuous_iff_continuousAt.mpr (initialCapacity_continuousAt p hi h0 hH)
+
+end SLEExactGauge
+
+end
+
+end OAI

lean/OAI/Probability/SLE/Loewner/InitialCapacityStrict.lean

@@ -1,64 +1,64 @@
-import OAI.Probability.SLE.Loewner.InitialCapacityAtZero
-
-namespace OAI
-
-/-! Capacity strictly increases when a simple attached slit is extended. -/
-noncomputable section
-open Set Filter Function
-open scoped Topology
-
-namespace SLEExactGauge
-
-lemma SimpleSlitChart.capacity_lt_of_domain_difference
-    {p q : C(unitInterval,ℂ)} (P : SimpleSlitChart p) (Q : SimpleSlitChart q)
-    (hpq : range p ⊆ range q) {z : ℂ}
-    (hz : z∈upperHalfPlane \ range p) (hzq : z∈range q) :
-    P.capacity<Q.capacity := by
-  have hle := P.capacity_le_of_range_subset Q hpq
-  apply lt_of_le_of_ne hle
-  intro he
-  have hdom : upperHalfPlane \ range q ⊆ upperHalfPlane \ range p :=
-    fun _ hw => ⟨hw.1,fun hp => hw.2 (hpq hp)⟩
-  have hm := Q.inverse_mapsTo.mono_right hdom
-  have hd := P.forward_differentiable.comp Q.inverse_differentiable hm
-  have hh := hydrodynamic_composition_coefficient P.coefficient Q.coefficient
-    Q.inverse_normalized Q.right_inverse
-  have hcoef : Tendsto (fun w : ℂ => w*(P.forward (Q.inverse w)-w))
-      (cocompact ℂ ⊓ 𝓟 upperHalfPlane) (𝓝 0) := by
-    simpa only [he,sub_self] using hh
-  have hn := hydrodynamic_composition_ratio P.coefficient Q.inverse_normalized
-  have heq := holomorphic_zero_hydrodynamic_mass (hd.sub differentiableOn_id)
-    (fun w hw => by
-      have hb := normalized_halfPlane_height hd (P.bijOn.mapsTo.comp hm) hn hw
-      change 0 ≤ (P.forward (Q.inverse w)-w).im
-      simpa only [Function.comp_apply,Complex.sub_im] using sub_nonneg.mpr hb) hcoef
-  have hwH := P.bijOn.mapsTo hz
-  have hsame : Q.inverse (P.forward z)=z := by
-    apply P.bijOn.injOn (hm hwH) hz
-    exact sub_eq_zero.mp (heq (P.forward z) hwH)
-  exact (Q.inverse_mapsTo hwH).2 (hsame.symm ▸ hzq)
-
-theorem initialCapacity_strictMono (p : C(unitInterval,ℂ)) (hi : Injective p)
-    (h0 : p 0=0) (hH : ∀ t : unitInterval, t ≠ 0 → p t ∈ upperHalfPlane) :
-    StrictMono (initialCapacity p hi h0 hH) := by
-  intro s t hst
-  have ht : t≠0 := ne_of_gt (bot_le.trans_lt hst)
-  by_cases hs : s=0
-  · rw [hs,initialCapacity_zero]
-    exact initialCapacity_pos p hi h0 hH ht
-  rw [initialCapacity,dite_eq_right hs,initialCapacity,dite_eq_right ht]
-  apply SimpleSlitChart.capacity_lt_of_domain_difference _ _
-    (initialSubarc_range_mono p hst.le) (z := p t)
-  · refine ⟨hH t ht,?_⟩
-    rw [initialSubarc_range]
-    rintro ⟨u,hu,he⟩
-    have hut := hi he
-    exact (not_le_of_gt hst) (hut ▸ hu.2)
-  · rw [initialSubarc_range]
-    exact mem_image_of_mem p ⟨bot_le,le_rfl⟩
-
-end SLEExactGauge
-
-end
-
-end OAI
+import OAI.Probability.SLE.Loewner.InitialCapacityAtZero
+
+namespace OAI
+
+/-! Capacity strictly increases when a simple attached slit is extended. -/
+noncomputable section
+open Set Filter Function
+open scoped Topology
+
+namespace SLEExactGauge
+
+lemma SimpleSlitChart.capacity_lt_of_domain_difference
+    {p q : C(unitInterval,ℂ)} (P : SimpleSlitChart p) (Q : SimpleSlitChart q)
+    (hpq : range p ⊆ range q) {z : ℂ}
+    (hz : z∈upperHalfPlane \ range p) (hzq : z∈range q) :
+    P.capacity<Q.capacity := by
+  have hle := P.capacity_le_of_range_subset Q hpq
+  apply lt_of_le_of_ne hle
+  intro he
+  have hdom : upperHalfPlane \ range q ⊆ upperHalfPlane \ range p :=
+    fun _ hw => ⟨hw.1,fun hp => hw.2 (hpq hp)⟩
+  have hm := Q.inverse_mapsTo.mono_right hdom
+  have hd := P.forward_differentiable.comp Q.inverse_differentiable hm
+  have hh := hydrodynamic_composition_coefficient P.coefficient Q.coefficient
+    Q.inverse_normalized Q.right_inverse
+  have hcoef : Tendsto (fun w : ℂ => w*(P.forward (Q.inverse w)-w))
+      (cocompact ℂ ⊓ 𝓟 upperHalfPlane) (𝓝 0) := by
+    simpa only [he,sub_self] using hh
+  have hn := hydrodynamic_composition_ratio P.coefficient Q.inverse_normalized
+  have heq := holomorphic_zero_hydrodynamic_mass (hd.sub differentiableOn_id)
+    (fun w hw => by
+      have hb := normalized_halfPlane_height hd (P.bijOn.mapsTo.comp hm) hn hw
+      change 0 ≤ (P.forward (Q.inverse w)-w).im
+      simpa only [Function.comp_apply,Complex.sub_im] using sub_nonneg.mpr hb) hcoef
+  have hwH := P.bijOn.mapsTo hz
+  have hsame : Q.inverse (P.forward z)=z := by
+    apply P.bijOn.injOn (hm hwH) hz
+    exact sub_eq_zero.mp (heq (P.forward z) hwH)
+  exact (Q.inverse_mapsTo hwH).2 (hsame.symm ▸ hzq)
+
+theorem initialCapacity_strictMono (p : C(unitInterval,ℂ)) (hi : Injective p)
+    (h0 : p 0=0) (hH : ∀ t : unitInterval, t ≠ 0 → p t ∈ upperHalfPlane) :
+    StrictMono (initialCapacity p hi h0 hH) := by
+  intro s t hst
+  have ht : t≠0 := ne_of_gt (bot_le.trans_lt hst)
+  by_cases hs : s=0
+  · rw [hs,initialCapacity_zero]
+    exact initialCapacity_pos p hi h0 hH ht
+  rw [initialCapacity,dite_eq_right hs,initialCapacity,dite_eq_right ht]
+  apply SimpleSlitChart.capacity_lt_of_domain_difference _ _
+    (initialSubarc_range_mono p hst.le) (z := p t)
+  · refine ⟨hH t ht,?_⟩
+    rw [initialSubarc_range]
+    rintro ⟨u,hu,he⟩
+    have hut := hi he
+    exact (not_le_of_gt hst) (hut ▸ hu.2)
+  · rw [initialSubarc_range]
+    exact mem_image_of_mem p ⟨bot_le,le_rfl⟩
+
+end SLEExactGauge
+
+end
+
+end OAI

lean/OAI/Probability/SLE/Loewner/InitialCapacityTerminal.lean

@@ -1,82 +1,82 @@
-import OAI.Probability.SLE.Loewner.SlitChartLimitUniqueness
-
-namespace OAI
-
-/-! Continuity of initial-subarc capacity at its terminal time. Compactness
-of the actual inverse charts identifies every scalar subsequential limit. -/
-noncomputable section
-open Set Filter Function Complex
-open scoped Topology
-
-namespace SLEExactGauge
-
-lemma SimpleSlitChart.capacity_eq_initial_final {p : C(unitInterval,ℂ)}
-    (P : SimpleSlitChart p) (hi : Injective p) (h0 : p 0=0)
-    (hH : ∀ t : unitInterval, t ≠ 0 → p t ∈ upperHalfPlane) :
-    P.capacity = initialCapacity p hi h0 hH 1 := by
-  have h1 : (1:unitInterval)≠0 := by norm_num
-  rw [initialCapacity,dite_eq_right h1]
-  have hr : range (initialSubarc p 1)=range p := by
-    ext z
-    simp only [mem_range,initialSubarc_apply,one_mul]
-  exact le_antisymm
-    (P.capacity_le_of_range_subset (initialSlitChart p hi h0 hH 1 h1) hr.ge)
-    ((initialSlitChart p hi h0 hH 1 h1).capacity_le_of_range_subset P hr.le)
-
-lemma initialCapacity_terminal_limit_value (p : C(unitInterval,ℂ)) (hi : Injective p)
-    (h0 : p 0=0) (hH : ∀ t : unitInterval, t ≠ 0 → p t ∈ upperHalfPlane)
-    {t : ℕ → unitInterval} {F : ℂ → ℂ} {c : ℝ}
-    (hF : DifferentiableOn ℂ F upperHalfPlane)
-    (hlim : TendstoLocallyUniformlyOn (fun n => initialInverseChart p hi h0 hH (t n))
-      F atTop upperHalfPlane) (ht : Tendsto t atTop (𝓝 1))
-    (hcap : Tendsto (fun n => initialCapacity p hi h0 hH (t n)) atTop (𝓝 c)) :
-    c = initialCapacity p hi h0 hH 1 := by
-  obtain ⟨P⟩ := exists_simpleSlitChart p hi h0 hH
-  have heq := initialInverse_limit_eq_final p hi h0 hH P hF hlim ht
-  have hcoef := inverse_hydrodynamic_coefficient P.coefficient P.inverse_normalized P.right_inverse
-  have hmass := (hydrodynamic_vertical_limits (c := P.capacity) hcoef).2
-  have hle : P.capacity≤c := by
-    apply le_of_tendsto hmass
-    apply Eventually.of_forall
-    intro n
-    have hb := initialInverse_limit_displacement p hi h0 hH hlim hcap (verticalInfinity_mem n)
-    rw [heq (verticalInfinity_mem n)] at hb
-    have him := (Complex.im_le_norm (P.inverse (verticalInfinity n)-verticalInfinity n)).trans hb
-    have hy : 0<(n:ℝ)+1 := by positivity
-    have hbound := (le_div_iff₀ hy).mp (show
-      (P.inverse (verticalInfinity n)-verticalInfinity n).im≤c/((n:ℝ)+1) from by
-        simpa only [verticalInfinity,mul_im,ofReal_re,I_im,mul_one,ofReal_im,I_re,mul_zero,add_zero]
-          using him)
-    nlinarith
-  have hge : c ≤ initialCapacity p hi h0 hH 1 := by
-    apply le_of_tendsto hcap
-    exact Eventually.of_forall fun n => initialCapacity_monotone p hi h0 hH
-      (show t n≤1 from le_top)
-  rw [P.capacity_eq_initial_final hi h0 hH] at hle
-  exact le_antisymm hge hle
-
-theorem initialCapacity_continuousAt_one (p : C(unitInterval,ℂ)) (hi : Injective p)
-    (h0 : p 0=0) (hH : ∀ t : unitInterval, t ≠ 0 → p t ∈ upperHalfPlane) :
-    ContinuousAt (initialCapacity p hi h0 hH) 1 := by
-  apply tendsto_of_subseq_tendsto
-  intro t ht
-  have hb (n : ℕ) : initialCapacity p hi h0 hH (t n)∈
-      Icc 0 (initialCapacity p hi h0 hH 1) :=
-    ⟨initialCapacity_nonneg p hi h0 hH _,initialCapacity_monotone p hi h0 hH le_top⟩
-  obtain ⟨c,_,φ,hφ,hcap⟩ := isCompact_Icc.tendsto_subseq hb
-  obtain ⟨ψ,F,hψ,hF,hFlim⟩ := initialInverseChart_subsequence p hi h0 hH (t ∘ φ)
-  have ht' : Tendsto (fun n => t (φ (ψ n))) atTop (𝓝 1) :=
-    (ht.comp hφ.tendsto_atTop).comp hψ.tendsto_atTop
-  have hc' := hcap.comp hψ.tendsto_atTop
-  have he := initialCapacity_terminal_limit_value p hi h0 hH hF hFlim ht' hc'
-  refine ⟨φ ∘ ψ,?_⟩
-  change Tendsto (fun n => initialCapacity p hi h0 hH (t (φ (ψ n))))
-    atTop (𝓝 (initialCapacity p hi h0 hH 1))
-  change Tendsto (fun n => initialCapacity p hi h0 hH (t (φ (ψ n)))) atTop (𝓝 c) at hc'
-  rwa [he] at hc'
-
-end SLEExactGauge
-
-end
-
-end OAI
+import OAI.Probability.SLE.Loewner.SlitChartLimitUniqueness
+
+namespace OAI
+
+/-! Continuity of initial-subarc capacity at its terminal time. Compactness
+of the actual inverse charts identifies every scalar subsequential limit. -/
+noncomputable section
+open Set Filter Function Complex
+open scoped Topology
+
+namespace SLEExactGauge
+
+lemma SimpleSlitChart.capacity_eq_initial_final {p : C(unitInterval,ℂ)}
+    (P : SimpleSlitChart p) (hi : Injective p) (h0 : p 0=0)
+    (hH : ∀ t : unitInterval, t ≠ 0 → p t ∈ upperHalfPlane) :
+    P.capacity = initialCapacity p hi h0 hH 1 := by
+  have h1 : (1:unitInterval)≠0 := by norm_num
+  rw [initialCapacity,dite_eq_right h1]
+  have hr : range (initialSubarc p 1)=range p := by
+    ext z
+    simp only [mem_range,initialSubarc_apply,one_mul]
+  exact le_antisymm
+    (P.capacity_le_of_range_subset (initialSlitChart p hi h0 hH 1 h1) hr.ge)
+    ((initialSlitChart p hi h0 hH 1 h1).capacity_le_of_range_subset P hr.le)
+
+lemma initialCapacity_terminal_limit_value (p : C(unitInterval,ℂ)) (hi : Injective p)
+    (h0 : p 0=0) (hH : ∀ t : unitInterval, t ≠ 0 → p t ∈ upperHalfPlane)
+    {t : ℕ → unitInterval} {F : ℂ → ℂ} {c : ℝ}
+    (hF : DifferentiableOn ℂ F upperHalfPlane)
+    (hlim : TendstoLocallyUniformlyOn (fun n => initialInverseChart p hi h0 hH (t n))
+      F atTop upperHalfPlane) (ht : Tendsto t atTop (𝓝 1))
+    (hcap : Tendsto (fun n => initialCapacity p hi h0 hH (t n)) atTop (𝓝 c)) :
+    c = initialCapacity p hi h0 hH 1 := by
+  obtain ⟨P⟩ := exists_simpleSlitChart p hi h0 hH
+  have heq := initialInverse_limit_eq_final p hi h0 hH P hF hlim ht
+  have hcoef := inverse_hydrodynamic_coefficient P.coefficient P.inverse_normalized P.right_inverse
+  have hmass := (hydrodynamic_vertical_limits (c := P.capacity) hcoef).2
+  have hle : P.capacity≤c := by
+    apply le_of_tendsto hmass
+    apply Eventually.of_forall
+    intro n
+    have hb := initialInverse_limit_displacement p hi h0 hH hlim hcap (verticalInfinity_mem n)
+    rw [heq (verticalInfinity_mem n)] at hb
+    have him := (Complex.im_le_norm (P.inverse (verticalInfinity n)-verticalInfinity n)).trans hb
+    have hy : 0<(n:ℝ)+1 := by positivity
+    have hbound := (le_div_iff₀ hy).mp (show
+      (P.inverse (verticalInfinity n)-verticalInfinity n).im≤c/((n:ℝ)+1) from by
+        simpa only [verticalInfinity,mul_im,ofReal_re,I_im,mul_one,ofReal_im,I_re,mul_zero,add_zero]
+          using him)
+    nlinarith
+  have hge : c ≤ initialCapacity p hi h0 hH 1 := by
+    apply le_of_tendsto hcap
+    exact Eventually.of_forall fun n => initialCapacity_monotone p hi h0 hH
+      (show t n≤1 from le_top)
+  rw [P.capacity_eq_initial_final hi h0 hH] at hle
+  exact le_antisymm hge hle
+
+theorem initialCapacity_continuousAt_one (p : C(unitInterval,ℂ)) (hi : Injective p)
+    (h0 : p 0=0) (hH : ∀ t : unitInterval, t ≠ 0 → p t ∈ upperHalfPlane) :
+    ContinuousAt (initialCapacity p hi h0 hH) 1 := by
+  apply tendsto_of_subseq_tendsto
+  intro t ht
+  have hb (n : ℕ) : initialCapacity p hi h0 hH (t n)∈
+      Icc 0 (initialCapacity p hi h0 hH 1) :=
+    ⟨initialCapacity_nonneg p hi h0 hH _,initialCapacity_monotone p hi h0 hH le_top⟩
+  obtain ⟨c,_,φ,hφ,hcap⟩ := isCompact_Icc.tendsto_subseq hb
+  obtain ⟨ψ,F,hψ,hF,hFlim⟩ := initialInverseChart_subsequence p hi h0 hH (t ∘ φ)
+  have ht' : Tendsto (fun n => t (φ (ψ n))) atTop (𝓝 1) :=
+    (ht.comp hφ.tendsto_atTop).comp hψ.tendsto_atTop
+  have hc' := hcap.comp hψ.tendsto_atTop
+  have he := initialCapacity_terminal_limit_value p hi h0 hH hF hFlim ht' hc'
+  refine ⟨φ ∘ ψ,?_⟩
+  change Tendsto (fun n => initialCapacity p hi h0 hH (t (φ (ψ n))))
+    atTop (𝓝 (initialCapacity p hi h0 hH 1))
+  change Tendsto (fun n => initialCapacity p hi h0 hH (t (φ (ψ n)))) atTop (𝓝 c) at hc'
+  rwa [he] at hc'
+
+end SLEExactGauge
+
+end
+
+end OAI

lean/OAI/Probability/SLE/Loewner/InitialChartIdentities.lean

@@ -1,34 +1,34 @@
-import OAI.Probability.SLE.Loewner.InitialForwardChart
-
-namespace OAI
-
-/-! Forward identities on the domain at the current time, rather than
-only on the common final domain. -/
-noncomputable section
-open Set Function
-
-namespace SLEExactGauge
-
-lemma initialForwardChart_mem_upper (p : C(unitInterval,ℂ)) (hi : Injective p)
-    (h0 : p 0=0) (hH : ∀ t : unitInterval, t ≠ 0 → p t ∈ upperHalfPlane)
-    (s : unitInterval) {z : ℂ} (hz : z∈upperHalfPlane \ range (initialSubarc p s)) :
-    initialForwardChart p hi h0 hH s z∈upperHalfPlane := by
-  by_cases hs : s=0
-  · simpa only [hs,initialForwardChart_zero,id_eq] using hz.1
-  · rw [initialForwardChart,dite_eq_right hs]
-    exact (initialSlitChart p hi h0 hH s hs).bijOn.mapsTo hz
-
-lemma initialInverse_forward_at (p : C(unitInterval,ℂ)) (hi : Injective p)
-    (h0 : p 0=0) (hH : ∀ t : unitInterval, t ≠ 0 → p t ∈ upperHalfPlane)
-    (s : unitInterval) {z : ℂ} (hz : z∈upperHalfPlane \ range (initialSubarc p s)) :
-    initialInverseChart p hi h0 hH s (initialForwardChart p hi h0 hH s z)=z := by
-  by_cases hs : s=0
-  · simp only [hs,initialForwardChart_zero,initialInverseChart_zero,id_eq]
-  · rw [initialForwardChart,dite_eq_right hs,initialInverseChart,dite_eq_right hs]
-    exact (initialSlitChart p hi h0 hH s hs).left_inverse z hz
-
-end SLEExactGauge
-
-end
-
-end OAI
+import OAI.Probability.SLE.Loewner.InitialForwardChart
+
+namespace OAI
+
+/-! Forward identities on the domain at the current time, rather than
+only on the common final domain. -/
+noncomputable section
+open Set Function
+
+namespace SLEExactGauge
+
+lemma initialForwardChart_mem_upper (p : C(unitInterval,ℂ)) (hi : Injective p)
+    (h0 : p 0=0) (hH : ∀ t : unitInterval, t ≠ 0 → p t ∈ upperHalfPlane)
+    (s : unitInterval) {z : ℂ} (hz : z∈upperHalfPlane \ range (initialSubarc p s)) :
+    initialForwardChart p hi h0 hH s z∈upperHalfPlane := by
+  by_cases hs : s=0
+  · simpa only [hs,initialForwardChart_zero,id_eq] using hz.1
+  · rw [initialForwardChart,dite_eq_right hs]
+    exact (initialSlitChart p hi h0 hH s hs).bijOn.mapsTo hz
+
+lemma initialInverse_forward_at (p : C(unitInterval,ℂ)) (hi : Injective p)
+    (h0 : p 0=0) (hH : ∀ t : unitInterval, t ≠ 0 → p t ∈ upperHalfPlane)
+    (s : unitInterval) {z : ℂ} (hz : z∈upperHalfPlane \ range (initialSubarc p s)) :
+    initialInverseChart p hi h0 hH s (initialForwardChart p hi h0 hH s z)=z := by
+  by_cases hs : s=0
+  · simp only [hs,initialForwardChart_zero,initialInverseChart_zero,id_eq]
+  · rw [initialForwardChart,dite_eq_right hs,initialInverseChart,dite_eq_right hs]
+    exact (initialSlitChart p hi h0 hH s hs).left_inverse z hz
+
+end SLEExactGauge
+
+end
+
+end OAI

lean/OAI/Probability/SLE/Loewner/InitialChartNormalization.lean

@@ -1,61 +1,61 @@
-import OAI.Probability.SLE.Loewner.InitialChartIdentities
-import OAI.Probability.SLE.Loewner.RadiusHullInverse
-
-namespace OAI
-
-/-! Normalization and height of the initial chart family, including its
-identity chart at time zero. -/
-noncomputable section
-open Set Filter Function Complex
-open scoped Topology
-
-namespace SLEExactGauge
-
-lemma initialForwardChart_differentiableOn_current (p : C(unitInterval,ℂ)) (hi : Injective p)
-    (h0 : p 0=0) (hH : ∀ t : unitInterval, t≠0 → p t∈upperHalfPlane)
-    (s : unitInterval) :
-    DifferentiableOn ℂ (initialForwardChart p hi h0 hH s)
-      (upperHalfPlane \ range (initialSubarc p s)) := by
-  by_cases hs : s=0
-  · simp only [hs,initialForwardChart_zero]
-    exact differentiableOn_id
-  · simpa only [initialForwardChart,dite_eq_right hs] using
-      (initialSlitChart p hi h0 hH s hs).forward_differentiable
-
-lemma initialForwardChart_coefficient (p : C(unitInterval,ℂ)) (hi : Injective p)
-    (h0 : p 0=0) (hH : ∀ t : unitInterval, t≠0 → p t∈upperHalfPlane)
-    (s : unitInterval) :
-    Tendsto (fun z : ℂ => z*(initialForwardChart p hi h0 hH s z-z)) (cocompact ℂ)
-      (𝓝 (initialCapacity p hi h0 hH s:ℂ)) := by
-  by_cases hs : s=0
-  · simp only [hs,initialForwardChart_zero,id_eq,sub_self,mul_zero,initialCapacity_zero,ofReal_zero]
-    exact tendsto_const_nhds
-  · simpa only [initialForwardChart,initialCapacity,dite_eq_right hs] using
-      (initialSlitChart p hi h0 hH s hs).coefficient
-
-lemma initialInverseChart_normalized (p : C(unitInterval,ℂ)) (hi : Injective p)
-    (h0 : p 0=0) (hH : ∀ t : unitInterval, t≠0 → p t∈upperHalfPlane)
-    (s : unitInterval) :
-    Tendsto (fun z : ℂ => initialInverseChart p hi h0 hH s z/z)
-      (cocompact ℂ ⊓ 𝓟 upperHalfPlane) (𝓝 1) := by
-  by_cases hs : s=0
-  · apply ratio_one_of_bounded_displacement (R := 0)
-    intro z _
-    simp only [hs,initialInverseChart_zero,id_eq,sub_self,norm_zero,le_refl]
-  · simpa only [initialInverseChart,dite_eq_right hs] using
-      (initialSlitChart p hi h0 hH s hs).inverse_normalized
-
-lemma initialForwardChart_height_le (p : C(unitInterval,ℂ)) (hi : Injective p)
-    (h0 : p 0=0) (hH : ∀ t : unitInterval, t≠0 → p t∈upperHalfPlane)
-    (s : unitInterval) {z : ℂ} (hz : z∈upperHalfPlane \ range (initialSubarc p s)) :
-    (initialForwardChart p hi h0 hH s z).im≤z.im := by
-  by_cases hs : s=0
-  · simp only [hs,initialForwardChart_zero,id_eq,le_refl]
-  · simpa only [initialForwardChart,dite_eq_right hs] using
-      (initialSlitChart p hi h0 hH s hs).height_le z hz
-
-end SLEExactGauge
-
-end
-
-end OAI
+import OAI.Probability.SLE.Loewner.InitialChartIdentities
+import OAI.Probability.SLE.Loewner.RadiusHullInverse
+
+namespace OAI
+
+/-! Normalization and height of the initial chart family, including its
+identity chart at time zero. -/
+noncomputable section
+open Set Filter Function Complex
+open scoped Topology
+
+namespace SLEExactGauge
+
+lemma initialForwardChart_differentiableOn_current (p : C(unitInterval,ℂ)) (hi : Injective p)
+    (h0 : p 0=0) (hH : ∀ t : unitInterval, t≠0 → p t∈upperHalfPlane)
+    (s : unitInterval) :
+    DifferentiableOn ℂ (initialForwardChart p hi h0 hH s)
+      (upperHalfPlane \ range (initialSubarc p s)) := by
+  by_cases hs : s=0
+  · simp only [hs,initialForwardChart_zero]
+    exact differentiableOn_id
+  · simpa only [initialForwardChart,dite_eq_right hs] using
+      (initialSlitChart p hi h0 hH s hs).forward_differentiable
+
+lemma initialForwardChart_coefficient (p : C(unitInterval,ℂ)) (hi : Injective p)
+    (h0 : p 0=0) (hH : ∀ t : unitInterval, t≠0 → p t∈upperHalfPlane)
+    (s : unitInterval) :
+    Tendsto (fun z : ℂ => z*(initialForwardChart p hi h0 hH s z-z)) (cocompact ℂ)
+      (𝓝 (initialCapacity p hi h0 hH s:ℂ)) := by
+  by_cases hs : s=0
+  · simp only [hs,initialForwardChart_zero,id_eq,sub_self,mul_zero,initialCapacity_zero,ofReal_zero]
+    exact tendsto_const_nhds
+  · simpa only [initialForwardChart,initialCapacity,dite_eq_right hs] using
+      (initialSlitChart p hi h0 hH s hs).coefficient
+
+lemma initialInverseChart_normalized (p : C(unitInterval,ℂ)) (hi : Injective p)
+    (h0 : p 0=0) (hH : ∀ t : unitInterval, t≠0 → p t∈upperHalfPlane)
+    (s : unitInterval) :
+    Tendsto (fun z : ℂ => initialInverseChart p hi h0 hH s z/z)
+      (cocompact ℂ ⊓ 𝓟 upperHalfPlane) (𝓝 1) := by
+  by_cases hs : s=0
+  · apply ratio_one_of_bounded_displacement (R := 0)
+    intro z _
+    simp only [hs,initialInverseChart_zero,id_eq,sub_self,norm_zero,le_refl]
+  · simpa only [initialInverseChart,dite_eq_right hs] using
+      (initialSlitChart p hi h0 hH s hs).inverse_normalized
+
+lemma initialForwardChart_height_le (p : C(unitInterval,ℂ)) (hi : Injective p)
+    (h0 : p 0=0) (hH : ∀ t : unitInterval, t≠0 → p t∈upperHalfPlane)
+    (s : unitInterval) {z : ℂ} (hz : z∈upperHalfPlane \ range (initialSubarc p s)) :
+    (initialForwardChart p hi h0 hH s z).im≤z.im := by
+  by_cases hs : s=0
+  · simp only [hs,initialForwardChart_zero,id_eq,le_refl]
+  · simpa only [initialForwardChart,dite_eq_right hs] using
+      (initialSlitChart p hi h0 hH s hs).height_le z hz
+
+end SLEExactGauge
+
+end
+
+end OAI

lean/OAI/Probability/SLE/Loewner/InitialConeFromInterval.lean

@@ -1,41 +1,41 @@
-import OAI.Probability.SLE.Loewner.LocalReverseCone
-import OAI.Probability.SLE.LoewnerCharts
-
-namespace OAI
-
-/-! The initial cone only uses the driving derivative inside its interval;
-no continuation of that derivative beyond the terminal time is needed. -/
-noncomputable section
-open Set Filter Complex
-open scoped Topology
-
-namespace SLEExactGauge
-
-lemma exists_initial_reverse_cone_of_interval_derivative {T L : ℝ}
-    (hT : 0 < T) (hL : 0 ≤ L) (q : ℝ → ℂ) (u u' : ℝ → ℝ)
-    (hqc : ContinuousOn q (Icc 0 T))
-    (hu : ∀ t ∈ Icc 0 T, HasDerivWithinAt u (u' t) (Icc 0 T) t)
-    (hq0 : q 0=(u 0 : ℂ))
-    (hq : ∀ t ∈ Ioc 0 T, HasDerivWithinAt q
-      (-2/(q t-(u t : ℂ))) (Ici t) t)
-    (hqp : ∀ t ∈ Ioc 0 T, 0 < (q t).im)
-    (hb : ∀ t ∈ Icc 0 T, |u' t| ≤ L) :
-    ∃ a : ℝ, 0 < a ∧ a ≤ T ∧
-      ∀ t ∈ Icc 0 a, ((q t).re-u t)^2 ≤ t ∧ 3*t ≤ (q t).im^2 := by
-  have hhalf : T/2 < T := half_lt_self hT
-  have hsub : Icc 0 (T/2) ⊆ Icc 0 T := Icc_subset_Icc_right hhalf.le
-  have hpos (t : ℝ) (ht : t ∈ Ioc 0 (T/2)) : t ∈ Ioc 0 T :=
-    ⟨ht.1,ht.2.trans hhalf.le⟩
-  obtain ⟨a,ha,haT,hcone⟩ := exists_initial_reverse_cone (half_pos hT) hL q u u'
-    (hqc.mono hsub) (fun t ht => (hu t (hsub ht)).continuousWithinAt.mono hsub) hq0
-    (fun t ht => hq t (hpos t ht))
-    (fun t ht => hasDerivWithinAt_Ici_of_Icc ⟨ht.1.le,ht.2.trans_lt hhalf⟩
-      (hu t ⟨ht.1.le,ht.2.trans hhalf.le⟩))
-    (fun t ht => hqp t (hpos t ht)) (fun t ht => hb t ⟨ht.1.le,ht.2.trans hhalf.le⟩)
-  exact ⟨a,ha,haT.trans hhalf.le,hcone⟩
-
-end SLEExactGauge
-
-end
-
-end OAI
+import OAI.Probability.SLE.Loewner.LocalReverseCone
+import OAI.Probability.SLE.LoewnerCharts
+
+namespace OAI
+
+/-! The initial cone only uses the driving derivative inside its interval;
+no continuation of that derivative beyond the terminal time is needed. -/
+noncomputable section
+open Set Filter Complex
+open scoped Topology
+
+namespace SLEExactGauge
+
+lemma exists_initial_reverse_cone_of_interval_derivative {T L : ℝ}
+    (hT : 0 < T) (hL : 0 ≤ L) (q : ℝ → ℂ) (u u' : ℝ → ℝ)
+    (hqc : ContinuousOn q (Icc 0 T))
+    (hu : ∀ t ∈ Icc 0 T, HasDerivWithinAt u (u' t) (Icc 0 T) t)
+    (hq0 : q 0=(u 0 : ℂ))
+    (hq : ∀ t ∈ Ioc 0 T, HasDerivWithinAt q
+      (-2/(q t-(u t : ℂ))) (Ici t) t)
+    (hqp : ∀ t ∈ Ioc 0 T, 0 < (q t).im)
+    (hb : ∀ t ∈ Icc 0 T, |u' t| ≤ L) :
+    ∃ a : ℝ, 0 < a ∧ a ≤ T ∧
+      ∀ t ∈ Icc 0 a, ((q t).re-u t)^2 ≤ t ∧ 3*t ≤ (q t).im^2 := by
+  have hhalf : T/2 < T := half_lt_self hT
+  have hsub : Icc 0 (T/2) ⊆ Icc 0 T := Icc_subset_Icc_right hhalf.le
+  have hpos (t : ℝ) (ht : t ∈ Ioc 0 (T/2)) : t ∈ Ioc 0 T :=
+    ⟨ht.1,ht.2.trans hhalf.le⟩
+  obtain ⟨a,ha,haT,hcone⟩ := exists_initial_reverse_cone (half_pos hT) hL q u u'
+    (hqc.mono hsub) (fun t ht => (hu t (hsub ht)).continuousWithinAt.mono hsub) hq0
+    (fun t ht => hq t (hpos t ht))
+    (fun t ht => hasDerivWithinAt_Ici_of_Icc ⟨ht.1.le,ht.2.trans_lt hhalf⟩
+      (hu t ⟨ht.1.le,ht.2.trans hhalf.le⟩))
+    (fun t ht => hqp t (hpos t ht)) (fun t ht => hb t ⟨ht.1.le,ht.2.trans hhalf.le⟩)
+  exact ⟨a,ha,haT.trans hhalf.le,hcone⟩
+
+end SLEExactGauge
+
+end
+
+end OAI

lean/OAI/Probability/SLE/Loewner/InitialDrivingBound.lean

@@ -1,42 +1,42 @@
-import OAI.Probability.SLE.Loewner.SlitUniformForwardBound
-import OAI.Probability.SLE.Loewner.InitialDrivingLimit
-
-namespace OAI
-
-/-! Every simple slit in a fixed disk has uniformly bounded driving
-coordinates, including when the tip approaches either end. -/
-noncomputable section
-open Set Filter Function Complex
-open scoped Topology
-
-namespace SLEExactGauge
-
-theorem initialDrivingValue_bound (p : C(unitInterval,ℂ)) (hi : Injective p)
-    (h0 : p 0=0) (hH : ∀ t : unitInterval, t≠0 → p t∈upperHalfPlane)
-    {R : ℝ} (hR : 0<R) (hp : ∀ t : unitInterval, ‖p t‖<R)
-    (s : unitInterval) (hs : s<1) :
-    |initialDrivingValue p hi h0 hH s hs|≤(512*Real.pi+9)*R := by
-  by_cases hs0 : s=0
-  · subst s
-    rw [initialDrivingValue_zero,abs_zero]
-    positivity
-  have hl := (initialDrivingValue_spec p hi h0 hH s hs).norm
-  rw [Complex.norm_real,Real.norm_eq_abs] at hl
-  apply le_of_tendsto hl
-  have hd : 0<1-(s:ℝ) := sub_pos.mpr hs
-  filter_upwards [self_mem_nhdsWithin,
-    Filter.Eventually.filter_mono inf_le_left (gt_mem_nhds hd)] with r hr hrd
-  have hz := slitFuturePoint_mem_domain p hi hH s (show r∈Ioo 0 (1-(s:ℝ)) from ⟨hr,hrd⟩)
-  rw [initialForwardChart,dite_eq_right hs0]
-  change ‖(initialSlitChart p hi h0 hH s hs0).forward
-    (p (slitFutureParameter s r))‖≤_
-  exact (initialSlitChart p hi h0 hH s hs0).forward_uniform_near
-    (initialSubarc_injective hi hs0) (by simpa only [initialSubarc_zero] using h0)
-    (initialSubarc_upper hH hs0) hR
-    (fun u => hp _) hz ((hp _).le.trans (by linarith))
-
-end SLEExactGauge
-
-end
-
-end OAI
+import OAI.Probability.SLE.Loewner.SlitUniformForwardBound
+import OAI.Probability.SLE.Loewner.InitialDrivingLimit
+
+namespace OAI
+
+/-! Every simple slit in a fixed disk has uniformly bounded driving
+coordinates, including when the tip approaches either end. -/
+noncomputable section
+open Set Filter Function Complex
+open scoped Topology
+
+namespace SLEExactGauge
+
+theorem initialDrivingValue_bound (p : C(unitInterval,ℂ)) (hi : Injective p)
+    (h0 : p 0=0) (hH : ∀ t : unitInterval, t≠0 → p t∈upperHalfPlane)
+    {R : ℝ} (hR : 0<R) (hp : ∀ t : unitInterval, ‖p t‖<R)
+    (s : unitInterval) (hs : s<1) :
+    |initialDrivingValue p hi h0 hH s hs|≤(512*Real.pi+9)*R := by
+  by_cases hs0 : s=0
+  · subst s
+    rw [initialDrivingValue_zero,abs_zero]
+    positivity
+  have hl := (initialDrivingValue_spec p hi h0 hH s hs).norm
+  rw [Complex.norm_real,Real.norm_eq_abs] at hl
+  apply le_of_tendsto hl
+  have hd : 0<1-(s:ℝ) := sub_pos.mpr hs
+  filter_upwards [self_mem_nhdsWithin,
+    Filter.Eventually.filter_mono inf_le_left (gt_mem_nhds hd)] with r hr hrd
+  have hz := slitFuturePoint_mem_domain p hi hH s (show r∈Ioo 0 (1-(s:ℝ)) from ⟨hr,hrd⟩)
+  rw [initialForwardChart,dite_eq_right hs0]
+  change ‖(initialSlitChart p hi h0 hH s hs0).forward
+    (p (slitFutureParameter s r))‖≤_
+  exact (initialSlitChart p hi h0 hH s hs0).forward_uniform_near
+    (initialSubarc_injective hi hs0) (by simpa only [initialSubarc_zero] using h0)
+    (initialSubarc_upper hH hs0) hR
+    (fun u => hp _) hz ((hp _).le.trans (by linarith))
+
+end SLEExactGauge
+
+end
+
+end OAI

lean/OAI/Probability/SLE/Loewner/InitialDrivingContinuity.lean

@@ -1,71 +1,71 @@
-import OAI.Probability.SLE.Stochastic.DrivingLeftCluster
-
-namespace OAI
-
-/-! Full continuity of the actual slit driving value before the final
-parameter, derived from the inverse energy and boundary noncollapse. -/
-noncomputable section
-open Set Filter Function Complex Metric
-open scoped Topology
-
-namespace SLEExactGauge
-
-theorem initialDriving_tendsto_from_left (p : C(unitInterval,ℂ)) (hi : Injective p)
-    (h0 : p 0=0) (hH : ∀ t : unitInterval, t≠0 → p t∈upperHalfPlane)
-    {R : ℝ} (hR : 0<R) (hp : ∀ t : unitInterval, ‖p t‖<R)
-    {s : unitInterval} (hs0 : s≠0) (hs : s<1)
-    {t : ℕ → unitInterval} (hts : ∀ n, t n<s) (ht : Tendsto t atTop (𝓝 s)) :
-    Tendsto (fun n => initialDriving p hi h0 hH (t n)) atTop
-      (𝓝 (initialDriving p hi h0 hH s)) := by
-  apply tendsto_of_subseq_tendsto
-  intro ns hns
-  let M := (512*Real.pi+9)*R
-  have hbound (n : ℕ) : initialDriving p hi h0 hH (t (ns n))∈Icc (-M) M := by
-    rw [initialDriving_of_lt p hi h0 hH ((hts (ns n)).trans hs)]
-    exact abs_le.mp (initialDrivingValue_bound p hi h0 hH hR hp _ _)
-  obtain ⟨a,_,φ,hφ,hlim⟩ := isCompact_Icc.tendsto_subseq hbound
-  have he := initialDriving_left_cluster p hi h0 hH hR hp hs0 hs
-    (fun n => hts (ns (φ n))) ((ht.comp hns).comp hφ.tendsto_atTop) hlim
-  exact ⟨φ,by simpa only [Function.comp_def,he] using hlim⟩
-
-theorem initialDriving_continuousWithinAt_left (p : C(unitInterval,ℂ)) (hi : Injective p)
-    (h0 : p 0=0) (hH : ∀ t : unitInterval, t≠0 → p t∈upperHalfPlane)
-    {s : unitInterval} (hs : s<1) :
-    ContinuousWithinAt (initialDriving p hi h0 hH) (Iio s) s := by
-  by_cases hs0 : s=0
-  · subst s
-    have hem : Iio (0:unitInterval)=∅ := by
-      ext x
-      simp only [mem_Iio,mem_empty_iff_false,iff_false]
-      exact not_lt_of_ge (show (0:unitInterval)≤x from x.property.1)
-    rw [hem]
-    exact continuousWithinAt_of_notMem_closure (by simp)
-  obtain ⟨R0,hRp⟩ := (isCompact_range p.continuous).isBounded.exists_norm_le
-  let R := max R0 0+1
-  have hR : 0<R := by dsimp [R]; positivity
-  have hpR (u : unitInterval) : ‖p u‖<R :=
-    (hRp _ (mem_range_self u)).trans_lt (by dsimp [R]; linarith [le_max_left R0 0])
-  apply tendsto_of_seq_tendsto
-  intro t ht
-  have hts : ∀ᶠ n in atTop, t n<s := (tendsto_nhdsWithin_iff.mp ht).2
-  obtain ⟨N,hN⟩ := eventually_atTop.mp hts
-  have ht' : Tendsto (fun n => t (n+N)) atTop (𝓝 s) :=
-    (ht.mono_right nhdsWithin_le_nhds).comp (tendsto_add_atTop_nat N)
-  have hres := initialDriving_tendsto_from_left p hi h0 hH hR
-    hpR hs0 hs
-    (fun n => hN (n+N) (by omega)) ht'
-  exact (tendsto_add_atTop_iff_nat N).mp hres
-
-theorem initialDriving_continuousAt (p : C(unitInterval,ℂ)) (hi : Injective p)
-    (h0 : p 0=0) (hH : ∀ t : unitInterval, t≠0 → p t∈upperHalfPlane)
-    {s : unitInterval} (hs : s<1) :
-    ContinuousAt (initialDriving p hi h0 hH) s := by
-  exact continuousAt_iff_continuous_left'_right'.mpr
-    ⟨initialDriving_continuousWithinAt_left p hi h0 hH hs,
-      initialDriving_continuousWithinAt_right p hi h0 hH hs⟩
-
-end SLEExactGauge
-
-end
-
-end OAI
+import OAI.Probability.SLE.Stochastic.DrivingLeftCluster
+
+namespace OAI
+
+/-! Full continuity of the actual slit driving value before the final
+parameter, derived from the inverse energy and boundary noncollapse. -/
+noncomputable section
+open Set Filter Function Complex Metric
+open scoped Topology
+
+namespace SLEExactGauge
+
+theorem initialDriving_tendsto_from_left (p : C(unitInterval,ℂ)) (hi : Injective p)
+    (h0 : p 0=0) (hH : ∀ t : unitInterval, t≠0 → p t∈upperHalfPlane)
+    {R : ℝ} (hR : 0<R) (hp : ∀ t : unitInterval, ‖p t‖<R)
+    {s : unitInterval} (hs0 : s≠0) (hs : s<1)
+    {t : ℕ → unitInterval} (hts : ∀ n, t n<s) (ht : Tendsto t atTop (𝓝 s)) :
+    Tendsto (fun n => initialDriving p hi h0 hH (t n)) atTop
+      (𝓝 (initialDriving p hi h0 hH s)) := by
+  apply tendsto_of_subseq_tendsto
+  intro ns hns
+  let M := (512*Real.pi+9)*R
+  have hbound (n : ℕ) : initialDriving p hi h0 hH (t (ns n))∈Icc (-M) M := by
+    rw [initialDriving_of_lt p hi h0 hH ((hts (ns n)).trans hs)]
+    exact abs_le.mp (initialDrivingValue_bound p hi h0 hH hR hp _ _)
+  obtain ⟨a,_,φ,hφ,hlim⟩ := isCompact_Icc.tendsto_subseq hbound
+  have he := initialDriving_left_cluster p hi h0 hH hR hp hs0 hs
+    (fun n => hts (ns (φ n))) ((ht.comp hns).comp hφ.tendsto_atTop) hlim
+  exact ⟨φ,by simpa only [Function.comp_def,he] using hlim⟩
+
+theorem initialDriving_continuousWithinAt_left (p : C(unitInterval,ℂ)) (hi : Injective p)
+    (h0 : p 0=0) (hH : ∀ t : unitInterval, t≠0 → p t∈upperHalfPlane)
+    {s : unitInterval} (hs : s<1) :
+    ContinuousWithinAt (initialDriving p hi h0 hH) (Iio s) s := by
+  by_cases hs0 : s=0
+  · subst s
+    have hem : Iio (0:unitInterval)=∅ := by
+      ext x
+      simp only [mem_Iio,mem_empty_iff_false,iff_false]
+      exact not_lt_of_ge (show (0:unitInterval)≤x from x.property.1)
+    rw [hem]
+    exact continuousWithinAt_of_notMem_closure (by simp)
+  obtain ⟨R0,hRp⟩ := (isCompact_range p.continuous).isBounded.exists_norm_le
+  let R := max R0 0+1
+  have hR : 0<R := by dsimp [R]; positivity
+  have hpR (u : unitInterval) : ‖p u‖<R :=
+    (hRp _ (mem_range_self u)).trans_lt (by dsimp [R]; linarith [le_max_left R0 0])
+  apply tendsto_of_seq_tendsto
+  intro t ht
+  have hts : ∀ᶠ n in atTop, t n<s := (tendsto_nhdsWithin_iff.mp ht).2
+  obtain ⟨N,hN⟩ := eventually_atTop.mp hts
+  have ht' : Tendsto (fun n => t (n+N)) atTop (𝓝 s) :=
+    (ht.mono_right nhdsWithin_le_nhds).comp (tendsto_add_atTop_nat N)
+  have hres := initialDriving_tendsto_from_left p hi h0 hH hR
+    hpR hs0 hs
+    (fun n => hN (n+N) (by omega)) ht'
+  exact (tendsto_add_atTop_iff_nat N).mp hres
+
+theorem initialDriving_continuousAt (p : C(unitInterval,ℂ)) (hi : Injective p)
+    (h0 : p 0=0) (hH : ∀ t : unitInterval, t≠0 → p t∈upperHalfPlane)
+    {s : unitInterval} (hs : s<1) :
+    ContinuousAt (initialDriving p hi h0 hH) s := by
+  exact continuousAt_iff_continuous_left'_right'.mpr
+    ⟨initialDriving_continuousWithinAt_left p hi h0 hH hs,
+      initialDriving_continuousWithinAt_right p hi h0 hH hs⟩
+
+end SLEExactGauge
+
+end
+
+end OAI

lean/OAI/Probability/SLE/Loewner/InitialDrivingIncrement.lean

@@ -1,66 +1,66 @@
-import OAI.Probability.SLE.Loewner.InitialDrivingBound
-import OAI.Probability.SLE.Loewner.FutureCapacityAdditive
-
-namespace OAI
-
-/-! A small mapped future slit forces its two driving values to be
-close, without any assumed continuity of the driver. -/
-noncomputable section
-open Set Filter Function Complex
-open scoped Topology
-
-namespace SLEExactGauge
-
-theorem initialDriving_increment_bound (p : C(unitInterval,ℂ)) (hi : Injective p)
-    (h0 : p 0=0) (hH : ∀ t : unitInterval, t≠0 → p t∈upperHalfPlane)
-    {s t : unitInterval} (hst : s<t) (ht : t<1) {R : ℝ} (hR : 0<R)
-    (hp : ∀ u : unitInterval, ‖centeredFutureArc p hi h0 hH hst ht u‖<R) :
-    |initialDrivingValue p hi h0 hH t ht-
-      initialDrivingValue p hi h0 hH s (hst.trans ht)|≤(512*Real.pi+9)*R := by
-  let U := initialDrivingValue p hi h0 hH s (hst.trans ht)
-  let Q := futureSlitChart p hi h0 hH hst ht
-  let w (r : ℝ) := initialForwardChart p hi h0 hH s (p (slitFutureParameter t r))-(U:ℂ)
-  have hpt := point_after_prefix_mem_domain p hi hH hst
-  have hopen : IsOpen (upperHalfPlane \ range (initialSubarc p s)) :=
-    isOpen_upperHalfPlane.sdiff (isCompact_range (initialSubarc p s).continuous).isClosed
-  have hG := ((initialForwardChart_differentiableOn_current p hi h0 hH s).differentiableAt
-    (hopen.mem_nhds hpt)).continuousAt
-  have hf : Tendsto (fun r : ℝ => p (slitFutureParameter t r)) (𝓝 0) (𝓝 (p t)) := by
-    have hcont : Continuous (fun r : ℝ => p (slitFutureParameter t r)) :=
-      p.continuous.comp (slitFutureParameter_continuous t)
-    simpa only [slitFutureParameter_zero] using hcont.tendsto 0
-  have hwlim : Tendsto w (𝓝 0) (𝓝 (centeredFutureArc p hi h0 hH hst ht 1)) := by
-    have hh := (hG.tendsto.comp hf).sub_const (U:ℂ)
-    have he : centeredFutureArc p hi h0 hH hst ht 1=
-        initialForwardChart p hi h0 hH s (p t)-(U:ℂ) := by
-      change mappedFutureArc p hi h0 hH hst ht 1-(U:ℂ)=_
-      rw [mappedFutureArc_segment p hi h0 hH hst ht one_ne_zero,slitSegmentParameter_one]
-    rwa [he]
-  have hnorm : ∀ᶠ r : ℝ in 𝓝[>] 0, ‖w r‖<2*R := by
-    exact (hwlim.norm.eventually (gt_mem_nhds ((hp 1).trans (by linarith)))).filter_mono inf_le_left
-  have hl := ((initialDrivingValue_spec p hi h0 hH t ht).sub_const (U:ℂ)).norm
-  have hl' : Tendsto (fun r : ℝ => ‖initialForwardChart p hi h0 hH t
-      (p (slitFutureParameter t r))-(U:ℂ)‖) (𝓝[>] 0)
-      (𝓝 |initialDrivingValue p hi h0 hH t ht-U|) := by
-    simpa only [←ofReal_sub,Complex.norm_real,Real.norm_eq_abs] using hl
-  apply le_of_tendsto hl'
-  have hd : 0<1-(t:ℝ) := sub_pos.mpr ht
-  filter_upwards [self_mem_nhdsWithin,hnorm,
-    Filter.Eventually.filter_mono inf_le_left (gt_mem_nhds hd)] with r hr hwr hrd
-  have hz := slitFuturePoint_mem_domain p hi hH t (show r∈Ioo 0 (1-(t:ℝ)) from ⟨hr,hrd⟩)
-  have hw := (initialForward_centered_bijOn p hi h0 hH hst ht).mapsTo hz
-  have hb := Q.forward_uniform_near
-    (centeredFutureArc_injective p hi h0 hH hst ht)
-    (centeredFutureArc_zero p hi h0 hH hst ht)
-    (fun _ hu => centeredFutureArc_upper p hi h0 hH hst ht hu) hR hp hw hwr.le
-  have he : (U:ℂ)+Q.forward (w r)=initialForwardChart p hi h0 hH t
-      (p (slitFutureParameter t r)) := futureComposedForward_eq p hi h0 hH hst ht hz
-  have he' : Q.forward (w r)=initialForwardChart p hi h0 hH t
-      (p (slitFutureParameter t r))-(U:ℂ) := by linear_combination he
-  rwa [he'] at hb
-
-end SLEExactGauge
-
-end
-
-end OAI
+import OAI.Probability.SLE.Loewner.InitialDrivingBound
+import OAI.Probability.SLE.Loewner.FutureCapacityAdditive
+
+namespace OAI
+
+/-! A small mapped future slit forces its two driving values to be
+close, without any assumed continuity of the driver. -/
+noncomputable section
+open Set Filter Function Complex
+open scoped Topology
+
+namespace SLEExactGauge
+
+theorem initialDriving_increment_bound (p : C(unitInterval,ℂ)) (hi : Injective p)
+    (h0 : p 0=0) (hH : ∀ t : unitInterval, t≠0 → p t∈upperHalfPlane)
+    {s t : unitInterval} (hst : s<t) (ht : t<1) {R : ℝ} (hR : 0<R)
+    (hp : ∀ u : unitInterval, ‖centeredFutureArc p hi h0 hH hst ht u‖<R) :
+    |initialDrivingValue p hi h0 hH t ht-
+      initialDrivingValue p hi h0 hH s (hst.trans ht)|≤(512*Real.pi+9)*R := by
+  let U := initialDrivingValue p hi h0 hH s (hst.trans ht)
+  let Q := futureSlitChart p hi h0 hH hst ht
+  let w (r : ℝ) := initialForwardChart p hi h0 hH s (p (slitFutureParameter t r))-(U:ℂ)
+  have hpt := point_after_prefix_mem_domain p hi hH hst
+  have hopen : IsOpen (upperHalfPlane \ range (initialSubarc p s)) :=
+    isOpen_upperHalfPlane.sdiff (isCompact_range (initialSubarc p s).continuous).isClosed
+  have hG := ((initialForwardChart_differentiableOn_current p hi h0 hH s).differentiableAt
+    (hopen.mem_nhds hpt)).continuousAt
+  have hf : Tendsto (fun r : ℝ => p (slitFutureParameter t r)) (𝓝 0) (𝓝 (p t)) := by
+    have hcont : Continuous (fun r : ℝ => p (slitFutureParameter t r)) :=
+      p.continuous.comp (slitFutureParameter_continuous t)
+    simpa only [slitFutureParameter_zero] using hcont.tendsto 0
+  have hwlim : Tendsto w (𝓝 0) (𝓝 (centeredFutureArc p hi h0 hH hst ht 1)) := by
+    have hh := (hG.tendsto.comp hf).sub_const (U:ℂ)
+    have he : centeredFutureArc p hi h0 hH hst ht 1=
+        initialForwardChart p hi h0 hH s (p t)-(U:ℂ) := by
+      change mappedFutureArc p hi h0 hH hst ht 1-(U:ℂ)=_
+      rw [mappedFutureArc_segment p hi h0 hH hst ht one_ne_zero,slitSegmentParameter_one]
+    rwa [he]
+  have hnorm : ∀ᶠ r : ℝ in 𝓝[>] 0, ‖w r‖<2*R := by
+    exact (hwlim.norm.eventually (gt_mem_nhds ((hp 1).trans (by linarith)))).filter_mono inf_le_left
+  have hl := ((initialDrivingValue_spec p hi h0 hH t ht).sub_const (U:ℂ)).norm
+  have hl' : Tendsto (fun r : ℝ => ‖initialForwardChart p hi h0 hH t
+      (p (slitFutureParameter t r))-(U:ℂ)‖) (𝓝[>] 0)
+      (𝓝 |initialDrivingValue p hi h0 hH t ht-U|) := by
+    simpa only [←ofReal_sub,Complex.norm_real,Real.norm_eq_abs] using hl
+  apply le_of_tendsto hl'
+  have hd : 0<1-(t:ℝ) := sub_pos.mpr ht
+  filter_upwards [self_mem_nhdsWithin,hnorm,
+    Filter.Eventually.filter_mono inf_le_left (gt_mem_nhds hd)] with r hr hwr hrd
+  have hz := slitFuturePoint_mem_domain p hi hH t (show r∈Ioo 0 (1-(t:ℝ)) from ⟨hr,hrd⟩)
+  have hw := (initialForward_centered_bijOn p hi h0 hH hst ht).mapsTo hz
+  have hb := Q.forward_uniform_near
+    (centeredFutureArc_injective p hi h0 hH hst ht)
+    (centeredFutureArc_zero p hi h0 hH hst ht)
+    (fun _ hu => centeredFutureArc_upper p hi h0 hH hst ht hu) hR hp hw hwr.le
+  have he : (U:ℂ)+Q.forward (w r)=initialForwardChart p hi h0 hH t
+      (p (slitFutureParameter t r)) := futureComposedForward_eq p hi h0 hH hst ht hz
+  have he' : Q.forward (w r)=initialForwardChart p hi h0 hH t
+      (p (slitFutureParameter t r))-(U:ℂ) := by linear_combination he
+  rwa [he'] at hb
+
+end SLEExactGauge
+
+end
+
+end OAI

lean/OAI/Probability/SLE/Loewner/InitialDrivingLimit.lean

@@ -1,65 +1,65 @@
-import OAI.Probability.SLE.Loewner.InitialSlitFuture
-import OAI.Probability.SLE.Loewner.SlitForwardEndpoint
-
-namespace OAI
-
-/-! The mapped future of a simple slit approaches a real boundary point.
-This supplies the driving value directly from the prescribed arc. -/
-noncomputable section
-open Set Filter Function Complex
-open scoped Topology
-
-namespace SLEExactGauge
-
-theorem exists_initial_driving_limit (p : C(unitInterval,ℂ)) (hi : Injective p)
-    (h0 : p 0=0) (hH : ∀ t : unitInterval, t≠0 → p t∈upperHalfPlane)
-    (s : unitInterval) (hs : s<1) :
-    ∃ a : ℝ, Tendsto
-      (fun r : ℝ => initialForwardChart p hi h0 hH s (p (slitFutureParameter s r)))
-      (𝓝[>] (0:ℝ)) (𝓝 (a:ℂ)) := by
-  have hD : 0<1-(s:ℝ) := sub_pos.mpr (show (s:ℝ)<1 from hs)
-  have hC : Continuous (fun r : ℝ => p (slitFutureParameter s r)) :=
-    p.continuous.comp (slitFutureParameter_continuous s)
-  have hz : Tendsto (fun r : ℝ => p (slitFutureParameter s r))
-      (𝓝[>] (0:ℝ)) (𝓝 (p s)) := by
-    have hc : Tendsto (fun r : ℝ => p (slitFutureParameter s r))
-        (𝓝 (0:ℝ)) (𝓝 (p s)) := by
-      simpa only [slitFutureParameter_zero] using hC.tendsto 0
-    exact hc.mono_left nhdsWithin_le_nhds
-  by_cases hs0 : s=0
-  · refine ⟨0,?_⟩
-    simpa only [hs0,initialForwardChart_zero,id_eq,h0,ofReal_zero] using hz
-  · simpa only [initialForwardChart,dite_eq_right hs0] using
-      (initialSlitChart p hi h0 hH s hs0).exists_forward_endpoint_limit hD hC.continuousOn
-      hz (fun _ hr => slitFuturePoint_mem_domain p hi hH s hr) (slit_tip_not_mem_domain p s)
-
-noncomputable def initialDrivingValue (p : C(unitInterval,ℂ)) (hi : Injective p)
-    (h0 : p 0=0) (hH : ∀ t : unitInterval, t≠0 → p t∈upperHalfPlane)
-    (s : unitInterval) (hs : s<1) : ℝ :=
-  Classical.choose (exists_initial_driving_limit p hi h0 hH s hs)
-
-theorem initialDrivingValue_spec (p : C(unitInterval,ℂ)) (hi : Injective p)
-    (h0 : p 0=0) (hH : ∀ t : unitInterval, t≠0 → p t∈upperHalfPlane)
-    (s : unitInterval) (hs : s<1) :
-    Tendsto (fun r : ℝ => initialForwardChart p hi h0 hH s (p (slitFutureParameter s r)))
-      (𝓝[>] (0:ℝ)) (𝓝 ((initialDrivingValue p hi h0 hH s hs):ℂ)) :=
-  Classical.choose_spec (exists_initial_driving_limit p hi h0 hH s hs)
-
-@[simp] theorem initialDrivingValue_zero (p : C(unitInterval,ℂ)) (hi : Injective p)
-    (h0 : p 0=0) (hH : ∀ t : unitInterval, t≠0 → p t∈upperHalfPlane) :
-    initialDrivingValue p hi h0 hH 0 zero_lt_one=0 := by
-  have hz := initialDrivingValue_spec p hi h0 hH 0 zero_lt_one
-  have hC := (p.continuous.comp (slitFutureParameter_continuous 0)).tendsto 0
-    |>.mono_left (show 𝓝[>] (0:ℝ)≤𝓝 (0:ℝ) from inf_le_left)
-  simp only [initialForwardChart_zero,id_eq] at hz
-  change Tendsto (fun r => p (slitFutureParameter 0 r)) (𝓝[>] (0:ℝ))
-    (𝓝 (p (slitFutureParameter 0 0))) at hC
-  have he := tendsto_nhds_unique hz hC
-  simpa only [slitFutureParameter_zero,h0,ofReal_zero,initialForwardChart_zero,id_eq,
-    ofReal_eq_zero] using he
-
-end SLEExactGauge
-
-end
-
-end OAI
+import OAI.Probability.SLE.Loewner.InitialSlitFuture
+import OAI.Probability.SLE.Loewner.SlitForwardEndpoint
+
+namespace OAI
+
+/-! The mapped future of a simple slit approaches a real boundary point.
+This supplies the driving value directly from the prescribed arc. -/
+noncomputable section
+open Set Filter Function Complex
+open scoped Topology
+
+namespace SLEExactGauge
+
+theorem exists_initial_driving_limit (p : C(unitInterval,ℂ)) (hi : Injective p)
+    (h0 : p 0=0) (hH : ∀ t : unitInterval, t≠0 → p t∈upperHalfPlane)
+    (s : unitInterval) (hs : s<1) :
+    ∃ a : ℝ, Tendsto
+      (fun r : ℝ => initialForwardChart p hi h0 hH s (p (slitFutureParameter s r)))
+      (𝓝[>] (0:ℝ)) (𝓝 (a:ℂ)) := by
+  have hD : 0<1-(s:ℝ) := sub_pos.mpr (show (s:ℝ)<1 from hs)
+  have hC : Continuous (fun r : ℝ => p (slitFutureParameter s r)) :=
+    p.continuous.comp (slitFutureParameter_continuous s)
+  have hz : Tendsto (fun r : ℝ => p (slitFutureParameter s r))
+      (𝓝[>] (0:ℝ)) (𝓝 (p s)) := by
+    have hc : Tendsto (fun r : ℝ => p (slitFutureParameter s r))
+        (𝓝 (0:ℝ)) (𝓝 (p s)) := by
+      simpa only [slitFutureParameter_zero] using hC.tendsto 0
+    exact hc.mono_left nhdsWithin_le_nhds
+  by_cases hs0 : s=0
+  · refine ⟨0,?_⟩
+    simpa only [hs0,initialForwardChart_zero,id_eq,h0,ofReal_zero] using hz
+  · simpa only [initialForwardChart,dite_eq_right hs0] using
+      (initialSlitChart p hi h0 hH s hs0).exists_forward_endpoint_limit hD hC.continuousOn
+      hz (fun _ hr => slitFuturePoint_mem_domain p hi hH s hr) (slit_tip_not_mem_domain p s)
+
+noncomputable def initialDrivingValue (p : C(unitInterval,ℂ)) (hi : Injective p)
+    (h0 : p 0=0) (hH : ∀ t : unitInterval, t≠0 → p t∈upperHalfPlane)
+    (s : unitInterval) (hs : s<1) : ℝ :=
+  Classical.choose (exists_initial_driving_limit p hi h0 hH s hs)
+
+theorem initialDrivingValue_spec (p : C(unitInterval,ℂ)) (hi : Injective p)
+    (h0 : p 0=0) (hH : ∀ t : unitInterval, t≠0 → p t∈upperHalfPlane)
+    (s : unitInterval) (hs : s<1) :
+    Tendsto (fun r : ℝ => initialForwardChart p hi h0 hH s (p (slitFutureParameter s r)))
+      (𝓝[>] (0:ℝ)) (𝓝 ((initialDrivingValue p hi h0 hH s hs):ℂ)) :=
+  Classical.choose_spec (exists_initial_driving_limit p hi h0 hH s hs)
+
+@[simp] theorem initialDrivingValue_zero (p : C(unitInterval,ℂ)) (hi : Injective p)
+    (h0 : p 0=0) (hH : ∀ t : unitInterval, t≠0 → p t∈upperHalfPlane) :
+    initialDrivingValue p hi h0 hH 0 zero_lt_one=0 := by
+  have hz := initialDrivingValue_spec p hi h0 hH 0 zero_lt_one
+  have hC := (p.continuous.comp (slitFutureParameter_continuous 0)).tendsto 0
+    |>.mono_left (show 𝓝[>] (0:ℝ)≤𝓝 (0:ℝ) from inf_le_left)
+  simp only [initialForwardChart_zero,id_eq] at hz
+  change Tendsto (fun r => p (slitFutureParameter 0 r)) (𝓝[>] (0:ℝ))
+    (𝓝 (p (slitFutureParameter 0 0))) at hC
+  have he := tendsto_nhds_unique hz hC
+  simpa only [slitFutureParameter_zero,h0,ofReal_zero,initialForwardChart_zero,id_eq,
+    ofReal_eq_zero] using he
+
+end SLEExactGauge
+
+end
+
+end OAI

lean/OAI/Probability/SLE/Loewner/InitialDrivingRightContinuity.lean

@@ -1,55 +1,55 @@
-import OAI.Probability.SLE.Loewner.InitialDrivingIncrement
-import OAI.Probability.SLE.Loewner.FutureSlitRadius
-
-namespace OAI
-
-/-! Right continuity of the actual driving value follows from shrinking
-mapped future slits and the uniform boundary-coordinate estimate. -/
-noncomputable section
-open Set Filter Function Complex Metric
-open scoped Topology
-
-namespace SLEExactGauge
-
-noncomputable def initialDriving (p : C(unitInterval,ℂ)) (hi : Injective p)
-    (h0 : p 0=0) (hH : ∀ t : unitInterval, t≠0 → p t∈upperHalfPlane)
-    (s : unitInterval) : ℝ :=
-  if hs : s<1 then initialDrivingValue p hi h0 hH s hs else 0
-
-lemma initialDriving_of_lt (p : C(unitInterval,ℂ)) (hi : Injective p)
-    (h0 : p 0=0) (hH : ∀ t : unitInterval, t≠0 → p t∈upperHalfPlane)
-    {s : unitInterval} (hs : s<1) :
-    initialDriving p hi h0 hH s=initialDrivingValue p hi h0 hH s hs := dite_eq_left hs
-
-theorem initialDriving_continuousWithinAt_right (p : C(unitInterval,ℂ)) (hi : Injective p)
-    (h0 : p 0=0) (hH : ∀ t : unitInterval, t≠0 → p t∈upperHalfPlane)
-    {s : unitInterval} (hs : s<1) :
-    ContinuousWithinAt (initialDriving p hi h0 hH) (Ioi s) s := by
-  apply Metric.tendsto_nhds.mpr
-  intro ε hε
-  let C : ℝ := 512*Real.pi+9
-  have hC : 0<C := by dsimp only [C]; positivity
-  let R : ℝ := ε/(2*C)
-  have hR : 0<R := div_pos hε (mul_pos (by norm_num) hC)
-  obtain ⟨δ,hδ,hsmall⟩ := centeredFutureArc_small p hi h0 hH s hs hR
-  have htime : Tendsto (fun t : unitInterval => (t:ℝ)-(s:ℝ)) (𝓝[>] s) (𝓝 0) := by
-    have hc : Continuous (fun t : unitInterval => (t:ℝ)-(s:ℝ)) :=
-      continuous_subtype_val.sub continuous_const
-    have hh := (hc.tendsto s).mono_left (show 𝓝[>] s≤𝓝 s from inf_le_left)
-    simpa only [sub_self] using hh
-  filter_upwards [self_mem_nhdsWithin,htime.eventually (gt_mem_nhds hδ),
-    Filter.Eventually.filter_mono inf_le_left (gt_mem_nhds hs)] with t hst htd ht
-  rw [Real.dist_eq,initialDriving_of_lt p hi h0 hH ht,initialDriving_of_lt p hi h0 hH hs]
-  have hb := initialDriving_increment_bound p hi h0 hH hst ht hR (hsmall t hst ht htd)
-  apply hb.trans_lt
-  change C*R<ε
-  dsimp only [R]
-  have he : C*(ε/(2*C))=ε/2 := by field_simp
-  rw [he]
-  linarith
-
-end SLEExactGauge
-
-end
-
-end OAI
+import OAI.Probability.SLE.Loewner.InitialDrivingIncrement
+import OAI.Probability.SLE.Loewner.FutureSlitRadius
+
+namespace OAI
+
+/-! Right continuity of the actual driving value follows from shrinking
+mapped future slits and the uniform boundary-coordinate estimate. -/
+noncomputable section
+open Set Filter Function Complex Metric
+open scoped Topology
+
+namespace SLEExactGauge
+
+noncomputable def initialDriving (p : C(unitInterval,ℂ)) (hi : Injective p)
+    (h0 : p 0=0) (hH : ∀ t : unitInterval, t≠0 → p t∈upperHalfPlane)
+    (s : unitInterval) : ℝ :=
+  if hs : s<1 then initialDrivingValue p hi h0 hH s hs else 0
+
+lemma initialDriving_of_lt (p : C(unitInterval,ℂ)) (hi : Injective p)
+    (h0 : p 0=0) (hH : ∀ t : unitInterval, t≠0 → p t∈upperHalfPlane)
+    {s : unitInterval} (hs : s<1) :
+    initialDriving p hi h0 hH s=initialDrivingValue p hi h0 hH s hs := dite_eq_left hs
+
+theorem initialDriving_continuousWithinAt_right (p : C(unitInterval,ℂ)) (hi : Injective p)
+    (h0 : p 0=0) (hH : ∀ t : unitInterval, t≠0 → p t∈upperHalfPlane)
+    {s : unitInterval} (hs : s<1) :
+    ContinuousWithinAt (initialDriving p hi h0 hH) (Ioi s) s := by
+  apply Metric.tendsto_nhds.mpr
+  intro ε hε
+  let C : ℝ := 512*Real.pi+9
+  have hC : 0<C := by dsimp only [C]; positivity
+  let R : ℝ := ε/(2*C)
+  have hR : 0<R := div_pos hε (mul_pos (by norm_num) hC)
+  obtain ⟨δ,hδ,hsmall⟩ := centeredFutureArc_small p hi h0 hH s hs hR
+  have htime : Tendsto (fun t : unitInterval => (t:ℝ)-(s:ℝ)) (𝓝[>] s) (𝓝 0) := by
+    have hc : Continuous (fun t : unitInterval => (t:ℝ)-(s:ℝ)) :=
+      continuous_subtype_val.sub continuous_const
+    have hh := (hc.tendsto s).mono_left (show 𝓝[>] s≤𝓝 s from inf_le_left)
+    simpa only [sub_self] using hh
+  filter_upwards [self_mem_nhdsWithin,htime.eventually (gt_mem_nhds hδ),
+    Filter.Eventually.filter_mono inf_le_left (gt_mem_nhds hs)] with t hst htd ht
+  rw [Real.dist_eq,initialDriving_of_lt p hi h0 hH ht,initialDriving_of_lt p hi h0 hH hs]
+  have hb := initialDriving_increment_bound p hi h0 hH hst ht hR (hsmall t hst ht htd)
+  apply hb.trans_lt
+  change C*R<ε
+  dsimp only [R]
+  have he : C*(ε/(2*C))=ε/2 := by field_simp
+  rw [he]
+  linarith
+
+end SLEExactGauge
+
+end
+
+end OAI

lean/OAI/Probability/SLE/Loewner/InitialDrivingTip.lean

@@ -1,75 +1,75 @@
-import OAI.Probability.SLE.Loewner.CapacityLoewnerIntegral
-import OAI.Probability.SLE.Loewner.SlitChartBoundaryExtension
-
-namespace OAI
-
-/-! The radial inverse limit at the proved driving value is the prescribed
-simple-arc tip. -/
-noncomputable section
-open Set Filter Function Complex
-open scoped Topology
-
-namespace SLEExactGauge
-
-theorem initialInverse_radial_driver_limit (p : C(unitInterval,ℂ)) (hi : Injective p)
-    (h0 : p 0=0) (hH : ∀ t : unitInterval, t≠0 → p t∈upperHalfPlane)
-    {s : unitInterval} (hs : s<1) :
-    Tendsto (fun y : ℝ => initialInverseChart p hi h0 hH s
-      ((initialDrivingValue p hi h0 hH s hs:ℂ)+(y:ℂ)*I))
-      (𝓝[>] (0:ℝ)) (𝓝 (p s)) := by
-  by_cases hs0 : s=0
-  · subst s
-    simp only [initialInverseChart_zero,initialDrivingValue_zero,ofReal_zero,zero_add,h0,id_eq]
-    have hh := (Complex.continuous_ofReal.tendsto 0).mul_const I
-    simpa only [ofReal_zero,zero_mul] using hh.mono_left nhdsWithin_le_nhds
-  obtain ⟨B,hB,hBF⟩ := (initialSlitChart p hi h0 hH s hs0).exists_boundary_extension
-  have hBe : ∀ z∈upperHalfPlane, B z=initialInverseChart p hi h0 hH s z := by
-    intro z hz
-    simpa only [initialInverseChart,dite_eq_right hs0] using hBF z hz
-  let u := initialDrivingValue p hi h0 hH s hs
-  have hG := initialDrivingValue_spec p hi h0 hH s hs
-  have hGmem : ∀ᶠ r : ℝ in 𝓝[>] (0:ℝ),
-      initialForwardChart p hi h0 hH s (p (slitFutureParameter s r))∈{z : ℂ | 0≤z.im} := by
-    filter_upwards [self_mem_nhdsWithin,mem_nhdsWithin_of_mem_nhds
-      (gt_mem_nhds (sub_pos.mpr (show (s:ℝ)<1 from hs)))] with r hr hrd
-    exact (show 0<(initialForwardChart p hi h0 hH s
-      (p (slitFutureParameter s r))).im from initialForwardChart_mem_upper p hi h0 hH s
-        (slitFuturePoint_mem_domain p hi hH s ⟨hr,hrd⟩)).le
-  have hBg := (hB (u:ℂ) (by simp)).tendsto.comp
-    (tendsto_nhdsWithin_iff.mpr ⟨hG,hGmem⟩)
-  have hphysical : Tendsto (fun r : ℝ => p (slitFutureParameter s r))
-      (𝓝[>] (0:ℝ)) (𝓝 (p s)) := by
-    have hc : Continuous (fun r : ℝ => p (slitFutureParameter s r)) :=
-      p.continuous.comp (slitFutureParameter_continuous s)
-    simpa only [slitFutureParameter_zero] using
-      (hc.tendsto 0).mono_left (show 𝓝[>] (0:ℝ)≤𝓝 (0:ℝ) from nhdsWithin_le_nhds)
-  have heq : B (u:ℂ)=p s := by
-    apply tendsto_nhds_unique hBg
-    apply hphysical.congr'
-    filter_upwards [self_mem_nhdsWithin,mem_nhdsWithin_of_mem_nhds
-      (gt_mem_nhds (sub_pos.mpr (show (s:ℝ)<1 from hs)))] with r hr hrd
-    have hd := slitFuturePoint_mem_domain p hi hH s (show r∈Ioo 0 (1-(s:ℝ)) from ⟨hr,hrd⟩)
-    symm
-    change B (initialForwardChart p hi h0 hH s (p (slitFutureParameter s r)))=
-      p (slitFutureParameter s r)
-    rw [hBe _ (initialForwardChart_mem_upper p hi h0 hH s hd),initialInverse_forward_at p hi h0 hH s hd]
-  have hzlim : Tendsto (fun y : ℝ => (u:ℂ)+(y:ℂ)*I) (𝓝[>] (0:ℝ)) (𝓝 (u:ℂ)) := by
-    have hc : Continuous (fun y : ℝ => (u:ℂ)+(y:ℂ)*I) :=
-      continuous_const.add (Complex.continuous_ofReal.mul continuous_const)
-    simpa only [ofReal_zero,zero_mul,add_zero] using
-      (hc.tendsto 0).mono_left
-        (show 𝓝[>] (0:ℝ)≤𝓝 (0:ℝ) from nhdsWithin_le_nhds)
-  have hzmem : ∀ᶠ y : ℝ in 𝓝[>] (0:ℝ), (u:ℂ)+(y:ℂ)*I∈{z : ℂ | 0≤z.im} := by
-    filter_upwards [self_mem_nhdsWithin] with y hy
-    simpa using hy.le
-  have hh := (hB (u:ℂ) (by simp)).tendsto.comp (tendsto_nhdsWithin_iff.mpr ⟨hzlim,hzmem⟩)
-  rw [heq] at hh
-  apply hh.congr'
-  filter_upwards [self_mem_nhdsWithin] with y hy
-  exact hBe _ (by simpa [upperHalfPlane] using hy)
-
-end SLEExactGauge
-
-end
-
-end OAI
+import OAI.Probability.SLE.Loewner.CapacityLoewnerIntegral
+import OAI.Probability.SLE.Loewner.SlitChartBoundaryExtension
+
+namespace OAI
+
+/-! The radial inverse limit at the proved driving value is the prescribed
+simple-arc tip. -/
+noncomputable section
+open Set Filter Function Complex
+open scoped Topology
+
+namespace SLEExactGauge
+
+theorem initialInverse_radial_driver_limit (p : C(unitInterval,ℂ)) (hi : Injective p)
+    (h0 : p 0=0) (hH : ∀ t : unitInterval, t≠0 → p t∈upperHalfPlane)
+    {s : unitInterval} (hs : s<1) :
+    Tendsto (fun y : ℝ => initialInverseChart p hi h0 hH s
+      ((initialDrivingValue p hi h0 hH s hs:ℂ)+(y:ℂ)*I))
+      (𝓝[>] (0:ℝ)) (𝓝 (p s)) := by
+  by_cases hs0 : s=0
+  · subst s
+    simp only [initialInverseChart_zero,initialDrivingValue_zero,ofReal_zero,zero_add,h0,id_eq]
+    have hh := (Complex.continuous_ofReal.tendsto 0).mul_const I
+    simpa only [ofReal_zero,zero_mul] using hh.mono_left nhdsWithin_le_nhds
+  obtain ⟨B,hB,hBF⟩ := (initialSlitChart p hi h0 hH s hs0).exists_boundary_extension
+  have hBe : ∀ z∈upperHalfPlane, B z=initialInverseChart p hi h0 hH s z := by
+    intro z hz
+    simpa only [initialInverseChart,dite_eq_right hs0] using hBF z hz
+  let u := initialDrivingValue p hi h0 hH s hs
+  have hG := initialDrivingValue_spec p hi h0 hH s hs
+  have hGmem : ∀ᶠ r : ℝ in 𝓝[>] (0:ℝ),
+      initialForwardChart p hi h0 hH s (p (slitFutureParameter s r))∈{z : ℂ | 0≤z.im} := by
+    filter_upwards [self_mem_nhdsWithin,mem_nhdsWithin_of_mem_nhds
+      (gt_mem_nhds (sub_pos.mpr (show (s:ℝ)<1 from hs)))] with r hr hrd
+    exact (show 0<(initialForwardChart p hi h0 hH s
+      (p (slitFutureParameter s r))).im from initialForwardChart_mem_upper p hi h0 hH s
+        (slitFuturePoint_mem_domain p hi hH s ⟨hr,hrd⟩)).le
+  have hBg := (hB (u:ℂ) (by simp)).tendsto.comp
+    (tendsto_nhdsWithin_iff.mpr ⟨hG,hGmem⟩)
+  have hphysical : Tendsto (fun r : ℝ => p (slitFutureParameter s r))
+      (𝓝[>] (0:ℝ)) (𝓝 (p s)) := by
+    have hc : Continuous (fun r : ℝ => p (slitFutureParameter s r)) :=
+      p.continuous.comp (slitFutureParameter_continuous s)
+    simpa only [slitFutureParameter_zero] using
+      (hc.tendsto 0).mono_left (show 𝓝[>] (0:ℝ)≤𝓝 (0:ℝ) from nhdsWithin_le_nhds)
+  have heq : B (u:ℂ)=p s := by
+    apply tendsto_nhds_unique hBg
+    apply hphysical.congr'
+    filter_upwards [self_mem_nhdsWithin,mem_nhdsWithin_of_mem_nhds
+      (gt_mem_nhds (sub_pos.mpr (show (s:ℝ)<1 from hs)))] with r hr hrd
+    have hd := slitFuturePoint_mem_domain p hi hH s (show r∈Ioo 0 (1-(s:ℝ)) from ⟨hr,hrd⟩)
+    symm
+    change B (initialForwardChart p hi h0 hH s (p (slitFutureParameter s r)))=
+      p (slitFutureParameter s r)
+    rw [hBe _ (initialForwardChart_mem_upper p hi h0 hH s hd),initialInverse_forward_at p hi h0 hH s hd]
+  have hzlim : Tendsto (fun y : ℝ => (u:ℂ)+(y:ℂ)*I) (𝓝[>] (0:ℝ)) (𝓝 (u:ℂ)) := by
+    have hc : Continuous (fun y : ℝ => (u:ℂ)+(y:ℂ)*I) :=
+      continuous_const.add (Complex.continuous_ofReal.mul continuous_const)
+    simpa only [ofReal_zero,zero_mul,add_zero] using
+      (hc.tendsto 0).mono_left
+        (show 𝓝[>] (0:ℝ)≤𝓝 (0:ℝ) from nhdsWithin_le_nhds)
+  have hzmem : ∀ᶠ y : ℝ in 𝓝[>] (0:ℝ), (u:ℂ)+(y:ℂ)*I∈{z : ℂ | 0≤z.im} := by
+    filter_upwards [self_mem_nhdsWithin] with y hy
+    simpa using hy.le
+  have hh := (hB (u:ℂ) (by simp)).tendsto.comp (tendsto_nhdsWithin_iff.mpr ⟨hzlim,hzmem⟩)
+  rw [heq] at hh
+  apply hh.congr'
+  filter_upwards [self_mem_nhdsWithin] with y hy
+  exact hBe _ (by simpa [upperHalfPlane] using hy)
+
+end SLEExactGauge
+
+end
+
+end OAI

lean/OAI/Probability/SLE/Loewner/InitialForwardBaseBounds.lean

@@ -1,47 +1,47 @@
-import OAI.Probability.SLE.Loewner.InitialForwardChart
-import OAI.Probability.SLE.Loewner.SlitChartVerticalBounds
-
-namespace OAI
-
-/-! Uniform interior control at a single exterior base point for every initial chart. -/
-noncomputable section
-open Set Filter Function Complex Metric
-open scoped Topology
-
-namespace SLEExactGauge
-
-lemma initialForwardChart_base_bounds (p : C(unitInterval,ℂ)) (hi : Injective p)
-    (h0 : p 0=0) (hH : ∀ t : unitInterval, t ≠ 0 → p t ∈ upperHalfPlane)
-    {R : ℝ} (hR : 0<R) (hp : ∀ u : unitInterval, ‖p u‖≤R) (t : unitInterval) :
-    3*R/2≤(initialForwardChart p hi h0 hH t (((2*R:ℝ):ℂ)*I)).im ∧
-      ‖initialForwardChart p hi h0 hH t (((2*R:ℝ):ℂ)*I)‖≤3*R := by
-  by_cases ht : t=0
-  · simp only [ht,initialForwardChart_zero,id_eq]
-    have hn : ‖((2*R:ℝ):ℂ)*I‖=2*R := by
-      simp [abs_of_pos hR]
-    rw [hn]
-    simp only [mul_im,ofReal_re,I_im,mul_one,ofReal_im,I_re,mul_zero,add_zero]
-    constructor <;> linarith
-  · rw [initialForwardChart,dite_eq_right ht]
-    apply (initialSlitChart p hi h0 hH t ht).vertical_base_bounds hR
-    intro u
-    exact hp (t*u)
-
-lemma initialForward_base_mem_domain (p : C(unitInterval,ℂ)) {R : ℝ}
-    (hR : 0<R) (hp : ∀ u : unitInterval, ‖p u‖≤R) :
-    (((2*R:ℝ):ℂ)*I)∈upperHalfPlane \ range p := by
-  have hn : ‖((2*R:ℝ):ℂ)*I‖=2*R := by
-    simp [abs_of_pos hR]
-  refine ⟨?_,?_⟩
-  · change 0<(((2*R:ℝ):ℂ)*I).im
-    simpa using mul_pos (by norm_num : (0:ℝ)<2) hR
-  · rintro ⟨u,hu⟩
-    have hh := hp u
-    rw [hu,hn] at hh
-    linarith
-
-end SLEExactGauge
-
-end
-
-end OAI
+import OAI.Probability.SLE.Loewner.InitialForwardChart
+import OAI.Probability.SLE.Loewner.SlitChartVerticalBounds
+
+namespace OAI
+
+/-! Uniform interior control at a single exterior base point for every initial chart. -/
+noncomputable section
+open Set Filter Function Complex Metric
+open scoped Topology
+
+namespace SLEExactGauge
+
+lemma initialForwardChart_base_bounds (p : C(unitInterval,ℂ)) (hi : Injective p)
+    (h0 : p 0=0) (hH : ∀ t : unitInterval, t ≠ 0 → p t ∈ upperHalfPlane)
+    {R : ℝ} (hR : 0<R) (hp : ∀ u : unitInterval, ‖p u‖≤R) (t : unitInterval) :
+    3*R/2≤(initialForwardChart p hi h0 hH t (((2*R:ℝ):ℂ)*I)).im ∧
+      ‖initialForwardChart p hi h0 hH t (((2*R:ℝ):ℂ)*I)‖≤3*R := by
+  by_cases ht : t=0
+  · simp only [ht,initialForwardChart_zero,id_eq]
+    have hn : ‖((2*R:ℝ):ℂ)*I‖=2*R := by
+      simp [abs_of_pos hR]
+    rw [hn]
+    simp only [mul_im,ofReal_re,I_im,mul_one,ofReal_im,I_re,mul_zero,add_zero]
+    constructor <;> linarith
+  · rw [initialForwardChart,dite_eq_right ht]
+    apply (initialSlitChart p hi h0 hH t ht).vertical_base_bounds hR
+    intro u
+    exact hp (t*u)
+
+lemma initialForward_base_mem_domain (p : C(unitInterval,ℂ)) {R : ℝ}
+    (hR : 0<R) (hp : ∀ u : unitInterval, ‖p u‖≤R) :
+    (((2*R:ℝ):ℂ)*I)∈upperHalfPlane \ range p := by
+  have hn : ‖((2*R:ℝ):ℂ)*I‖=2*R := by
+    simp [abs_of_pos hR]
+  refine ⟨?_,?_⟩
+  · change 0<(((2*R:ℝ):ℂ)*I).im
+    simpa using mul_pos (by norm_num : (0:ℝ)<2) hR
+  · rintro ⟨u,hu⟩
+    have hh := hp u
+    rw [hu,hn] at hh
+    linarith
+
+end SLEExactGauge
+
+end
+
+end OAI

lean/OAI/Probability/SLE/Loewner/InitialForwardChart.lean

@@ -1,76 +1,76 @@
-import OAI.Probability.SLE.Loewner.InitialInverseChart
-import OAI.Probability.SLE.Geometry.HalfPlaneCayleyInverse
-
-namespace OAI
-
-/-! Forward maps for initial slits, all defined analytically on the final slit complement. -/
-noncomputable section
-open Set Filter Function Complex
-open scoped Topology
-
-namespace SLEExactGauge
-
-noncomputable def initialForwardChart (p : C(unitInterval,ℂ)) (hi : Injective p)
-    (h0 : p 0=0) (hH : ∀ t : unitInterval, t ≠ 0 → p t ∈ upperHalfPlane)
-    (t : unitInterval) : ℂ → ℂ :=
-  if ht : t=0 then id else (initialSlitChart p hi h0 hH t ht).forward
-
-@[simp] lemma initialForwardChart_zero (p : C(unitInterval,ℂ)) (hi : Injective p)
-    (h0 : p 0=0) (hH : ∀ t : unitInterval, t ≠ 0 → p t ∈ upperHalfPlane) :
-    initialForwardChart p hi h0 hH 0=id := by simp [initialForwardChart]
-
-lemma initialSubarc_range_subset (p : C(unitInterval,ℂ)) (t : unitInterval) :
-    range (initialSubarc p t) ⊆ range p := by
-  rintro _ ⟨u,rfl⟩
-  exact mem_range_self (t*u)
-
-lemma initialForwardChart_mapsTo (p : C(unitInterval,ℂ)) (hi : Injective p)
-    (h0 : p 0=0) (hH : ∀ t : unitInterval, t ≠ 0 → p t ∈ upperHalfPlane)
-    (t : unitInterval) :
-    MapsTo (initialForwardChart p hi h0 hH t) (upperHalfPlane \ range p) upperHalfPlane := by
-  intro z hz
-  by_cases ht : t=0
-  · simpa only [ht,initialForwardChart_zero,id_eq] using hz.1
-  · rw [initialForwardChart,dite_eq_right ht]
-    exact (initialSlitChart p hi h0 hH t ht).bijOn.mapsTo
-      ⟨hz.1,fun h => hz.2 (initialSubarc_range_subset p t h)⟩
-
-lemma initialForwardChart_differentiableOn (p : C(unitInterval,ℂ)) (hi : Injective p)
-    (h0 : p 0=0) (hH : ∀ t : unitInterval, t ≠ 0 → p t ∈ upperHalfPlane)
-    (t : unitInterval) :
-    DifferentiableOn ℂ (initialForwardChart p hi h0 hH t) (upperHalfPlane \ range p) := by
-  by_cases ht : t=0
-  · simp only [ht,initialForwardChart_zero]
-    exact differentiableOn_id
-  · rw [initialForwardChart,dite_eq_right ht]
-    exact (initialSlitChart p hi h0 hH t ht).forward_differentiable.mono
-      (fun _ hz => ⟨hz.1,fun h => hz.2 (initialSubarc_range_subset p t h)⟩)
-
-lemma initialInverse_forward_on_final (p : C(unitInterval,ℂ)) (hi : Injective p)
-    (h0 : p 0=0) (hH : ∀ t : unitInterval, t ≠ 0 → p t ∈ upperHalfPlane)
-    (t : unitInterval) {z : ℂ} (hz : z∈upperHalfPlane \ range p) :
-    initialInverseChart p hi h0 hH t (initialForwardChart p hi h0 hH t z)=z := by
-  by_cases ht : t=0
-  · simp [ht]
-  · rw [initialInverseChart,dite_eq_right ht,initialForwardChart,dite_eq_right ht]
-    exact (initialSlitChart p hi h0 hH t ht).left_inverse _
-      ⟨hz.1,fun h => hz.2 (initialSubarc_range_subset p t h)⟩
-
-lemma initialForward_inverse (p : C(unitInterval,ℂ)) (hi : Injective p)
-    (h0 : p 0=0) (hH : ∀ t : unitInterval, t ≠ 0 → p t ∈ upperHalfPlane)
-    (t : unitInterval) {z : ℂ} (hz : z∈upperHalfPlane) :
-    initialForwardChart p hi h0 hH t (initialInverseChart p hi h0 hH t z)=z := by
-  by_cases ht : t=0
-  · simp [ht]
-  · rw [initialForwardChart,dite_eq_right ht,initialInverseChart,dite_eq_right ht]
-    exact (initialSlitChart p hi h0 hH t ht).right_inverse _ hz
-
-lemma halfPlaneCayley_differentiableOn : DifferentiableOn ℂ halfPlaneCayley upperHalfPlane := by
-  apply (differentiableOn_id.sub_const I).div (differentiableOn_id.add_const I)
-  exact fun z hz => halfPlaneCayley_den_ne (show 0<z.im from hz).le
-
-end SLEExactGauge
-
-end
-
-end OAI
+import OAI.Probability.SLE.Loewner.InitialInverseChart
+import OAI.Probability.SLE.Geometry.HalfPlaneCayleyInverse
+
+namespace OAI
+
+/-! Forward maps for initial slits, all defined analytically on the final slit complement. -/
+noncomputable section
+open Set Filter Function Complex
+open scoped Topology
+
+namespace SLEExactGauge
+
+noncomputable def initialForwardChart (p : C(unitInterval,ℂ)) (hi : Injective p)
+    (h0 : p 0=0) (hH : ∀ t : unitInterval, t ≠ 0 → p t ∈ upperHalfPlane)
+    (t : unitInterval) : ℂ → ℂ :=
+  if ht : t=0 then id else (initialSlitChart p hi h0 hH t ht).forward
+
+@[simp] lemma initialForwardChart_zero (p : C(unitInterval,ℂ)) (hi : Injective p)
+    (h0 : p 0=0) (hH : ∀ t : unitInterval, t ≠ 0 → p t ∈ upperHalfPlane) :
+    initialForwardChart p hi h0 hH 0=id := by simp [initialForwardChart]
+
+lemma initialSubarc_range_subset (p : C(unitInterval,ℂ)) (t : unitInterval) :
+    range (initialSubarc p t) ⊆ range p := by
+  rintro _ ⟨u,rfl⟩
+  exact mem_range_self (t*u)
+
+lemma initialForwardChart_mapsTo (p : C(unitInterval,ℂ)) (hi : Injective p)
+    (h0 : p 0=0) (hH : ∀ t : unitInterval, t ≠ 0 → p t ∈ upperHalfPlane)
+    (t : unitInterval) :
+    MapsTo (initialForwardChart p hi h0 hH t) (upperHalfPlane \ range p) upperHalfPlane := by
+  intro z hz
+  by_cases ht : t=0
+  · simpa only [ht,initialForwardChart_zero,id_eq] using hz.1
+  · rw [initialForwardChart,dite_eq_right ht]
+    exact (initialSlitChart p hi h0 hH t ht).bijOn.mapsTo
+      ⟨hz.1,fun h => hz.2 (initialSubarc_range_subset p t h)⟩
+
+lemma initialForwardChart_differentiableOn (p : C(unitInterval,ℂ)) (hi : Injective p)
+    (h0 : p 0=0) (hH : ∀ t : unitInterval, t ≠ 0 → p t ∈ upperHalfPlane)
+    (t : unitInterval) :
+    DifferentiableOn ℂ (initialForwardChart p hi h0 hH t) (upperHalfPlane \ range p) := by
+  by_cases ht : t=0
+  · simp only [ht,initialForwardChart_zero]
+    exact differentiableOn_id
+  · rw [initialForwardChart,dite_eq_right ht]
+    exact (initialSlitChart p hi h0 hH t ht).forward_differentiable.mono
+      (fun _ hz => ⟨hz.1,fun h => hz.2 (initialSubarc_range_subset p t h)⟩)
+
+lemma initialInverse_forward_on_final (p : C(unitInterval,ℂ)) (hi : Injective p)
+    (h0 : p 0=0) (hH : ∀ t : unitInterval, t ≠ 0 → p t ∈ upperHalfPlane)
+    (t : unitInterval) {z : ℂ} (hz : z∈upperHalfPlane \ range p) :
+    initialInverseChart p hi h0 hH t (initialForwardChart p hi h0 hH t z)=z := by
+  by_cases ht : t=0
+  · simp [ht]
+  · rw [initialInverseChart,dite_eq_right ht,initialForwardChart,dite_eq_right ht]
+    exact (initialSlitChart p hi h0 hH t ht).left_inverse _
+      ⟨hz.1,fun h => hz.2 (initialSubarc_range_subset p t h)⟩
+
+lemma initialForward_inverse (p : C(unitInterval,ℂ)) (hi : Injective p)
+    (h0 : p 0=0) (hH : ∀ t : unitInterval, t ≠ 0 → p t ∈ upperHalfPlane)
+    (t : unitInterval) {z : ℂ} (hz : z∈upperHalfPlane) :
+    initialForwardChart p hi h0 hH t (initialInverseChart p hi h0 hH t z)=z := by
+  by_cases ht : t=0
+  · simp [ht]
+  · rw [initialForwardChart,dite_eq_right ht,initialInverseChart,dite_eq_right ht]
+    exact (initialSlitChart p hi h0 hH t ht).right_inverse _ hz
+
+lemma halfPlaneCayley_differentiableOn : DifferentiableOn ℂ halfPlaneCayley upperHalfPlane := by
+  apply (differentiableOn_id.sub_const I).div (differentiableOn_id.add_const I)
+  exact fun z hz => halfPlaneCayley_den_ne (show 0<z.im from hz).le
+
+end SLEExactGauge
+
+end
+
+end OAI

lean/OAI/Probability/SLE/Loewner/InitialForwardComparison.lean

@@ -1,54 +1,54 @@
-import OAI.Probability.SLE.Loewner.InitialInverseLimitAt
-
-namespace OAI
-
-/-! The complementary hydrodynamic mass, measured from the common final
-domain to each initial domain. -/
-noncomputable section
-open Set Filter Function
-open scoped Topology
-
-namespace SLEExactGauge
-
-lemma initialForward_comparison_to_final (p : C(unitInterval,ℂ)) (hi : Injective p)
-    (h0 : p 0=0) (hH : ∀ t : unitInterval, t ≠ 0 → p t ∈ upperHalfPlane)
-    (Q : SimpleSlitChart p) (t : unitInterval) {z : ℂ} (hz : z∈upperHalfPlane) :
-    ‖initialForwardChart p hi h0 hH t (Q.inverse z)-z‖≤
-      (Q.capacity-initialCapacity p hi h0 hH t)/z.im := by
-  by_cases ht : t=0
-  · simpa only [ht,initialForwardChart_zero,initialCapacity_zero,id_eq,sub_zero] using
-      Q.inverse_displacement hz
-  · rw [initialForwardChart,dite_eq_right ht,initialCapacity,dite_eq_right ht]
-    exact (initialSlitChart p hi h0 hH t ht).inverse_comparison Q
-      (initialSubarc_range_subset p t) hz
-
-lemma initialInverse_limit_forward_on_final (p : C(unitInterval,ℂ)) (hi : Injective p)
-    (h0 : p 0=0) (hH : ∀ t : unitInterval, t ≠ 0 → p t ∈ upperHalfPlane)
-    {t : ℕ → unitInterval} {F : ℂ → ℂ} (hF : DifferentiableOn ℂ F upperHalfPlane)
-    (hlim : TendstoLocallyUniformlyOn (fun n => initialInverseChart p hi h0 hH (t n))
-      F atTop upperHalfPlane) {s : unitInterval} (hs : s≠0) (ht : Tendsto t atTop (𝓝 s)) :
-    ∃ φ : ℕ → ℕ, StrictMono φ ∧ ∀ z∈upperHalfPlane \ range p,
-      Tendsto (fun n => initialForwardChart p hi h0 hH (t (φ n)) z)
-        atTop (𝓝 ((initialSlitChart p hi h0 hH s hs).forward z)) := by
-  let P := initialSlitChart p hi h0 hH s hs
-  have heF := initialInverse_limit_eq_at p hi h0 hH hF hlim hs ht
-  have hPinv : EqOn F P.inverse upperHalfPlane := by
-    simpa only [initialInverseChart,dite_eq_right hs] using heF
-  obtain ⟨φ,hφ,hforward⟩ := initialInverse_limit_forward_subsequence p hi h0 hH hF hlim
-  refine ⟨φ,hφ,fun z hz => ?_⟩
-  have hzP : z∈upperHalfPlane \ range (initialSubarc p s) :=
-    ⟨hz.1,fun hh => hz.2 (initialSubarc_range_subset p s hh)⟩
-  have hcov : SurjOn F upperHalfPlane (upperHalfPlane \ range p) :=
-    initialInverse_limit_covers_final_domain p hi h0 hH hF hlim
-  have he : invFunOn F upperHalfPlane z=P.forward z := by
-    apply initialInverse_limit_injOn p hi h0 hH hlim
-      (hcov.mapsTo_invFunOn hz) (P.bijOn.mapsTo hzP)
-    rw [hcov.rightInvOn_invFunOn hz,hPinv (P.bijOn.mapsTo hzP),P.left_inverse z hzP]
-  rw [← he]
-  exact hforward z hz
-
-end SLEExactGauge
-
-end
-
-end OAI
+import OAI.Probability.SLE.Loewner.InitialInverseLimitAt
+
+namespace OAI
+
+/-! The complementary hydrodynamic mass, measured from the common final
+domain to each initial domain. -/
+noncomputable section
+open Set Filter Function
+open scoped Topology
+
+namespace SLEExactGauge
+
+lemma initialForward_comparison_to_final (p : C(unitInterval,ℂ)) (hi : Injective p)
+    (h0 : p 0=0) (hH : ∀ t : unitInterval, t ≠ 0 → p t ∈ upperHalfPlane)
+    (Q : SimpleSlitChart p) (t : unitInterval) {z : ℂ} (hz : z∈upperHalfPlane) :
+    ‖initialForwardChart p hi h0 hH t (Q.inverse z)-z‖≤
+      (Q.capacity-initialCapacity p hi h0 hH t)/z.im := by
+  by_cases ht : t=0
+  · simpa only [ht,initialForwardChart_zero,initialCapacity_zero,id_eq,sub_zero] using
+      Q.inverse_displacement hz
+  · rw [initialForwardChart,dite_eq_right ht,initialCapacity,dite_eq_right ht]
+    exact (initialSlitChart p hi h0 hH t ht).inverse_comparison Q
+      (initialSubarc_range_subset p t) hz
+
+lemma initialInverse_limit_forward_on_final (p : C(unitInterval,ℂ)) (hi : Injective p)
+    (h0 : p 0=0) (hH : ∀ t : unitInterval, t ≠ 0 → p t ∈ upperHalfPlane)
+    {t : ℕ → unitInterval} {F : ℂ → ℂ} (hF : DifferentiableOn ℂ F upperHalfPlane)
+    (hlim : TendstoLocallyUniformlyOn (fun n => initialInverseChart p hi h0 hH (t n))
+      F atTop upperHalfPlane) {s : unitInterval} (hs : s≠0) (ht : Tendsto t atTop (𝓝 s)) :
+    ∃ φ : ℕ → ℕ, StrictMono φ ∧ ∀ z∈upperHalfPlane \ range p,
+      Tendsto (fun n => initialForwardChart p hi h0 hH (t (φ n)) z)
+        atTop (𝓝 ((initialSlitChart p hi h0 hH s hs).forward z)) := by
+  let P := initialSlitChart p hi h0 hH s hs
+  have heF := initialInverse_limit_eq_at p hi h0 hH hF hlim hs ht
+  have hPinv : EqOn F P.inverse upperHalfPlane := by
+    simpa only [initialInverseChart,dite_eq_right hs] using heF
+  obtain ⟨φ,hφ,hforward⟩ := initialInverse_limit_forward_subsequence p hi h0 hH hF hlim
+  refine ⟨φ,hφ,fun z hz => ?_⟩
+  have hzP : z∈upperHalfPlane \ range (initialSubarc p s) :=
+    ⟨hz.1,fun hh => hz.2 (initialSubarc_range_subset p s hh)⟩
+  have hcov : SurjOn F upperHalfPlane (upperHalfPlane \ range p) :=
+    initialInverse_limit_covers_final_domain p hi h0 hH hF hlim
+  have he : invFunOn F upperHalfPlane z=P.forward z := by
+    apply initialInverse_limit_injOn p hi h0 hH hlim
+      (hcov.mapsTo_invFunOn hz) (P.bijOn.mapsTo hzP)
+    rw [hcov.rightInvOn_invFunOn hz,hPinv (P.bijOn.mapsTo hzP),P.left_inverse z hzP]
+  rw [← he]
+  exact hforward z hz
+
+end SLEExactGauge
+
+end
+
+end OAI

lean/OAI/Probability/SLE/Loewner/InitialForwardIncrement.lean

@@ -1,59 +1,59 @@
-import OAI.Probability.SLE.Loewner.FutureCapacityAdditive
-
-namespace OAI
-
-/-! Exact capacity increments control forward-map motion on the common
-surviving domain. -/
-noncomputable section
-open Set Filter Function Complex
-open scoped Topology
-
-namespace SLEExactGauge
-
-theorem initialForward_increment_bound (p : C(unitInterval,ℂ)) (hi : Injective p)
-    (h0 : p 0=0) (hH : ∀ t : unitInterval, t≠0 → p t∈upperHalfPlane)
-    {s t : unitInterval} (hst : s<t) (ht : t<1)
-    {z : ℂ} (hz : z∈upperHalfPlane \ range (initialSubarc p t)) :
-    ‖initialForwardChart p hi h0 hH t z-initialForwardChart p hi h0 hH s z‖≤
-      (initialCapacity p hi h0 hH t-initialCapacity p hi h0 hH s)/
-        (initialForwardChart p hi h0 hH t z).im := by
-  let Q := futureSlitChart p hi h0 hH hst ht
-  let U := initialDrivingValue p hi h0 hH s (hst.trans ht)
-  let w := initialForwardChart p hi h0 hH s z-(U:ℂ)
-  have hw : w∈upperHalfPlane \ range (centeredFutureArc p hi h0 hH hst ht) :=
-    (initialForward_centered_bijOn p hi h0 hH hst ht).mapsTo hz
-  have hc : Q.capacity=initialCapacity p hi h0 hH t-initialCapacity p hi h0 hH s :=
-    futureSlitChart_capacity_eq p hi h0 hH hst ht
-  have he : (U:ℂ)+Q.forward w=initialForwardChart p hi h0 hH t z :=
-    futureComposedForward_eq p hi h0 hH hst ht hz
-  have him : (Q.forward w).im=(initialForwardChart p hi h0 hH t z).im := by
-    simpa only [add_im,ofReal_im,zero_add] using congrArg Complex.im he
-  have hd : Q.forward w-w=
-      initialForwardChart p hi h0 hH t z-initialForwardChart p hi h0 hH s z := by
-    dsimp only [w] at he ⊢
-    linear_combination he
-  have hb := Q.forward_displacement hw
-  rwa [hc,him,hd] at hb
-
-theorem initialForward_height_antitone (p : C(unitInterval,ℂ)) (hi : Injective p)
-    (h0 : p 0=0) (hH : ∀ t : unitInterval, t≠0 → p t∈upperHalfPlane)
-    {s t : unitInterval} (hst : s≤t) (ht : t<1)
-    {z : ℂ} (hz : z∈upperHalfPlane \ range (initialSubarc p t)) :
-    (initialForwardChart p hi h0 hH t z).im≤(initialForwardChart p hi h0 hH s z).im := by
-  obtain rfl | hst := hst.eq_or_lt
-  · exact le_rfl
-  let Q := futureSlitChart p hi h0 hH hst ht
-  let U := initialDrivingValue p hi h0 hH s (hst.trans ht)
-  have hw := (initialForward_centered_bijOn p hi h0 hH hst ht).mapsTo hz
-  have hb := Q.height_le _ hw
-  have he : (U:ℂ)+Q.forward (initialForwardChart p hi h0 hH s z-(U:ℂ))=
-      initialForwardChart p hi h0 hH t z := futureComposedForward_eq p hi h0 hH hst ht hz
-  have him := congrArg Complex.im he
-  simp only [add_im,ofReal_im,zero_add,sub_im,sub_zero] at hb him
-  rwa [← him]
-
-end SLEExactGauge
-
-end
-
-end OAI
+import OAI.Probability.SLE.Loewner.FutureCapacityAdditive
+
+namespace OAI
+
+/-! Exact capacity increments control forward-map motion on the common
+surviving domain. -/
+noncomputable section
+open Set Filter Function Complex
+open scoped Topology
+
+namespace SLEExactGauge
+
+theorem initialForward_increment_bound (p : C(unitInterval,ℂ)) (hi : Injective p)
+    (h0 : p 0=0) (hH : ∀ t : unitInterval, t≠0 → p t∈upperHalfPlane)
+    {s t : unitInterval} (hst : s<t) (ht : t<1)
+    {z : ℂ} (hz : z∈upperHalfPlane \ range (initialSubarc p t)) :
+    ‖initialForwardChart p hi h0 hH t z-initialForwardChart p hi h0 hH s z‖≤
+      (initialCapacity p hi h0 hH t-initialCapacity p hi h0 hH s)/
+        (initialForwardChart p hi h0 hH t z).im := by
+  let Q := futureSlitChart p hi h0 hH hst ht
+  let U := initialDrivingValue p hi h0 hH s (hst.trans ht)
+  let w := initialForwardChart p hi h0 hH s z-(U:ℂ)
+  have hw : w∈upperHalfPlane \ range (centeredFutureArc p hi h0 hH hst ht) :=
+    (initialForward_centered_bijOn p hi h0 hH hst ht).mapsTo hz
+  have hc : Q.capacity=initialCapacity p hi h0 hH t-initialCapacity p hi h0 hH s :=
+    futureSlitChart_capacity_eq p hi h0 hH hst ht
+  have he : (U:ℂ)+Q.forward w=initialForwardChart p hi h0 hH t z :=
+    futureComposedForward_eq p hi h0 hH hst ht hz
+  have him : (Q.forward w).im=(initialForwardChart p hi h0 hH t z).im := by
+    simpa only [add_im,ofReal_im,zero_add] using congrArg Complex.im he
+  have hd : Q.forward w-w=
+      initialForwardChart p hi h0 hH t z-initialForwardChart p hi h0 hH s z := by
+    dsimp only [w] at he ⊢
+    linear_combination he
+  have hb := Q.forward_displacement hw
+  rwa [hc,him,hd] at hb
+
+theorem initialForward_height_antitone (p : C(unitInterval,ℂ)) (hi : Injective p)
+    (h0 : p 0=0) (hH : ∀ t : unitInterval, t≠0 → p t∈upperHalfPlane)
+    {s t : unitInterval} (hst : s≤t) (ht : t<1)
+    {z : ℂ} (hz : z∈upperHalfPlane \ range (initialSubarc p t)) :
+    (initialForwardChart p hi h0 hH t z).im≤(initialForwardChart p hi h0 hH s z).im := by
+  obtain rfl | hst := hst.eq_or_lt
+  · exact le_rfl
+  let Q := futureSlitChart p hi h0 hH hst ht
+  let U := initialDrivingValue p hi h0 hH s (hst.trans ht)
+  have hw := (initialForward_centered_bijOn p hi h0 hH hst ht).mapsTo hz
+  have hb := Q.height_le _ hw
+  have he : (U:ℂ)+Q.forward (initialForwardChart p hi h0 hH s z-(U:ℂ))=
+      initialForwardChart p hi h0 hH t z := futureComposedForward_eq p hi h0 hH hst ht hz
+  have him := congrArg Complex.im he
+  simp only [add_im,ofReal_im,zero_add,sub_im,sub_zero] at hb him
+  rwa [← him]
+
+end SLEExactGauge
+
+end
+
+end OAI

lean/OAI/Probability/SLE/Loewner/InitialForwardJointContinuity.lean

@@ -1,48 +1,48 @@
-import OAI.Probability.SLE.Loewner.InitialForwardTimeContinuity
-
-namespace OAI
-
-/-! The moving slit domain is open, and its actual forward coordinates
-depend continuously on both time and the surviving point. -/
-noncomputable section
-open Set Filter Function
-open scoped Topology
-
-namespace SLEExactGauge
-
-lemma isOpen_initialSlitDomain (p : C(unitInterval,ℂ)) :
-    IsOpen {a : unitInterval × ℂ | a.2∈upperHalfPlane \ range (initialSubarc p a.1)} := by
-  have hc : Continuous (fun a : unitInterval × unitInterval => (a.1,p (a.1*a.2))) :=
-    continuous_fst.prodMk (p.continuous.comp (continuous_fst.mul continuous_snd))
-  have hr : {a : unitInterval × ℂ | a.2∈range (initialSubarc p a.1)}=
-      range (fun a : unitInterval × unitInterval => (a.1,p (a.1*a.2))) := by
-    ext a
-    constructor
-    · rintro ⟨u,hu⟩
-      exact ⟨(a.1,u),Prod.ext rfl hu⟩
-    · rintro ⟨⟨s,u⟩,he⟩
-      obtain ⟨hs,hz⟩ := Prod.mk.inj he
-      dsimp only at hs hz
-      subst s
-      exact ⟨u,hz⟩
-  have hclosed : IsClosed {a : unitInterval × ℂ | a.2∈range (initialSubarc p a.1)} := by
-    rw [hr]
-    exact (isCompact_range hc).isClosed
-  exact (isOpen_upperHalfPlane.preimage continuous_snd).sdiff hclosed
-
-theorem initialForwardChart_joint_continuous (p : C(unitInterval,ℂ)) (hi : Injective p)
-    (h0 : p 0=0) (hH : ∀ t : unitInterval, t ≠ 0 → p t ∈ upperHalfPlane) :
-    Continuous (fun a : {a : unitInterval × ℂ |
-      a.2∈upperHalfPlane \ range (initialSubarc p a.1)} =>
-        initialForwardChart p hi h0 hH a.1.1 a.1.2) := by
-  apply SeqContinuous.continuous
-  intro v a hv
-  have ht := ((continuous_fst.comp continuous_subtype_val).tendsto a).comp hv
-  have hz := ((continuous_snd.comp continuous_subtype_val).tendsto a).comp hv
-  exact initialForwardChart_tendsto p hi h0 hH ht hz a.property (fun n => (v n).property)
-
-end SLEExactGauge
-
-end
-
-end OAI
+import OAI.Probability.SLE.Loewner.InitialForwardTimeContinuity
+
+namespace OAI
+
+/-! The moving slit domain is open, and its actual forward coordinates
+depend continuously on both time and the surviving point. -/
+noncomputable section
+open Set Filter Function
+open scoped Topology
+
+namespace SLEExactGauge
+
+lemma isOpen_initialSlitDomain (p : C(unitInterval,ℂ)) :
+    IsOpen {a : unitInterval × ℂ | a.2∈upperHalfPlane \ range (initialSubarc p a.1)} := by
+  have hc : Continuous (fun a : unitInterval × unitInterval => (a.1,p (a.1*a.2))) :=
+    continuous_fst.prodMk (p.continuous.comp (continuous_fst.mul continuous_snd))
+  have hr : {a : unitInterval × ℂ | a.2∈range (initialSubarc p a.1)}=
+      range (fun a : unitInterval × unitInterval => (a.1,p (a.1*a.2))) := by
+    ext a
+    constructor
+    · rintro ⟨u,hu⟩
+      exact ⟨(a.1,u),Prod.ext rfl hu⟩
+    · rintro ⟨⟨s,u⟩,he⟩
+      obtain ⟨hs,hz⟩ := Prod.mk.inj he
+      dsimp only at hs hz
+      subst s
+      exact ⟨u,hz⟩
+  have hclosed : IsClosed {a : unitInterval × ℂ | a.2∈range (initialSubarc p a.1)} := by
+    rw [hr]
+    exact (isCompact_range hc).isClosed
+  exact (isOpen_upperHalfPlane.preimage continuous_snd).sdiff hclosed
+
+theorem initialForwardChart_joint_continuous (p : C(unitInterval,ℂ)) (hi : Injective p)
+    (h0 : p 0=0) (hH : ∀ t : unitInterval, t ≠ 0 → p t ∈ upperHalfPlane) :
+    Continuous (fun a : {a : unitInterval × ℂ |
+      a.2∈upperHalfPlane \ range (initialSubarc p a.1)} =>
+        initialForwardChart p hi h0 hH a.1.1 a.1.2) := by
+  apply SeqContinuous.continuous
+  intro v a hv
+  have ht := ((continuous_fst.comp continuous_subtype_val).tendsto a).comp hv
+  have hz := ((continuous_snd.comp continuous_subtype_val).tendsto a).comp hv
+  exact initialForwardChart_tendsto p hi h0 hH ht hz a.property (fun n => (v n).property)
+
+end SLEExactGauge
+
+end
+
+end OAI

lean/OAI/Probability/SLE/Loewner/InitialForwardKernel.lean

@@ -1,50 +1,50 @@
-import OAI.Probability.SLE.Loewner.SlitCapacityQuotient
-import OAI.Probability.SLE.Loewner.InitialForwardIncrement
-import OAI.Probability.SLE.Loewner.FutureSlitRadius
-
-namespace OAI
-
-/-! The exact chart composition turns the static small-slit estimate
-into an estimate for the evolving map's capacity difference quotient. -/
-noncomputable section
-open Set Filter Function Complex Metric
-open scoped Topology
-
-namespace SLEExactGauge
-
-theorem initialForward_quotient_kernel (p : C(unitInterval,ℂ)) (hi : Injective p)
-    (h0 : p 0=0) (hH : ∀ t : unitInterval, t≠0 → p t∈upperHalfPlane)
-    {s t : unitInterval} (hst : s<t) (ht : t<1)
-    {z : ℂ} (hz : z∈upperHalfPlane \ range (initialSubarc p t))
-    {R : ℝ} (hR : 0<R)
-    (hp : ∀ u : unitInterval, ‖centeredFutureArc p hi h0 hH hst ht u‖<R)
-    (hn : 2*R≤‖initialForwardChart p hi h0 hH s z-
-      (initialDrivingValue p hi h0 hH s (hst.trans ht):ℂ)‖) :
-    ‖(initialForwardChart p hi h0 hH t z-initialForwardChart p hi h0 hH s z)/
-        ((initialCapacity p hi h0 hH t-initialCapacity p hi h0 hH s:ℝ):ℂ)-
-      1/(initialForwardChart p hi h0 hH s z-
-        (initialDrivingValue p hi h0 hH s (hst.trans ht):ℂ))‖≤
-      10*R/‖initialForwardChart p hi h0 hH s z-
-        (initialDrivingValue p hi h0 hH s (hst.trans ht):ℂ)‖^2 := by
-  let Q := futureSlitChart p hi h0 hH hst ht
-  let U := initialDrivingValue p hi h0 hH s (hst.trans ht)
-  let w := initialForwardChart p hi h0 hH s z-(U:ℂ)
-  have hw : w∈upperHalfPlane \ range (centeredFutureArc p hi h0 hH hst ht) :=
-    (initialForward_centered_bijOn p hi h0 hH hst ht).mapsTo hz
-  have hb := Q.forward_quotient_kernel
-    (centeredFutureArc_injective p hi h0 hH hst ht)
-    (centeredFutureArc_zero p hi h0 hH hst ht)
-    (fun _ hu => centeredFutureArc_upper p hi h0 hH hst ht hu) hR hp hw.1 hn
-  have he : (U:ℂ)+Q.forward w=initialForwardChart p hi h0 hH t z :=
-    futureComposedForward_eq p hi h0 hH hst ht hz
-  have hd : Q.forward w-w=
-      initialForwardChart p hi h0 hH t z-initialForwardChart p hi h0 hH s z := by
-    dsimp only [w] at he ⊢
-    linear_combination he
-  rwa [hd,show Q.capacity=_ from futureSlitChart_capacity_eq p hi h0 hH hst ht] at hb
-
-end SLEExactGauge
-
-end
-
-end OAI
+import OAI.Probability.SLE.Loewner.SlitCapacityQuotient
+import OAI.Probability.SLE.Loewner.InitialForwardIncrement
+import OAI.Probability.SLE.Loewner.FutureSlitRadius
+
+namespace OAI
+
+/-! The exact chart composition turns the static small-slit estimate
+into an estimate for the evolving map's capacity difference quotient. -/
+noncomputable section
+open Set Filter Function Complex Metric
+open scoped Topology
+
+namespace SLEExactGauge
+
+theorem initialForward_quotient_kernel (p : C(unitInterval,ℂ)) (hi : Injective p)
+    (h0 : p 0=0) (hH : ∀ t : unitInterval, t≠0 → p t∈upperHalfPlane)
+    {s t : unitInterval} (hst : s<t) (ht : t<1)
+    {z : ℂ} (hz : z∈upperHalfPlane \ range (initialSubarc p t))
+    {R : ℝ} (hR : 0<R)
+    (hp : ∀ u : unitInterval, ‖centeredFutureArc p hi h0 hH hst ht u‖<R)
+    (hn : 2*R≤‖initialForwardChart p hi h0 hH s z-
+      (initialDrivingValue p hi h0 hH s (hst.trans ht):ℂ)‖) :
+    ‖(initialForwardChart p hi h0 hH t z-initialForwardChart p hi h0 hH s z)/
+        ((initialCapacity p hi h0 hH t-initialCapacity p hi h0 hH s:ℝ):ℂ)-
+      1/(initialForwardChart p hi h0 hH s z-
+        (initialDrivingValue p hi h0 hH s (hst.trans ht):ℂ))‖≤
+      10*R/‖initialForwardChart p hi h0 hH s z-
+        (initialDrivingValue p hi h0 hH s (hst.trans ht):ℂ)‖^2 := by
+  let Q := futureSlitChart p hi h0 hH hst ht
+  let U := initialDrivingValue p hi h0 hH s (hst.trans ht)
+  let w := initialForwardChart p hi h0 hH s z-(U:ℂ)
+  have hw : w∈upperHalfPlane \ range (centeredFutureArc p hi h0 hH hst ht) :=
+    (initialForward_centered_bijOn p hi h0 hH hst ht).mapsTo hz
+  have hb := Q.forward_quotient_kernel
+    (centeredFutureArc_injective p hi h0 hH hst ht)
+    (centeredFutureArc_zero p hi h0 hH hst ht)
+    (fun _ hu => centeredFutureArc_upper p hi h0 hH hst ht hu) hR hp hw.1 hn
+  have he : (U:ℂ)+Q.forward w=initialForwardChart p hi h0 hH t z :=
+    futureComposedForward_eq p hi h0 hH hst ht hz
+  have hd : Q.forward w-w=
+      initialForwardChart p hi h0 hH t z-initialForwardChart p hi h0 hH s z := by
+    dsimp only [w] at he ⊢
+    linear_combination he
+  rwa [hd,show Q.capacity=_ from futureSlitChart_capacity_eq p hi h0 hH hst ht] at hb
+
+end SLEExactGauge
+
+end
+
+end OAI

lean/OAI/Probability/SLE/Loewner/InitialForwardKernelLimit.lean

@@ -1,65 +1,65 @@
-import OAI.Probability.SLE.Loewner.InitialForwardKernel
-import OAI.Probability.SLE.Loewner.CapacityForwardDerivative
-
-namespace OAI
-
-/-! The exact capacity difference quotient tends to the Loewner
-kernel as the future slit shrinks to its driving point. -/
-noncomputable section
-open Set Filter Function Complex Metric
-open scoped Topology
-
-namespace SLEExactGauge
-
-theorem initialForward_quotient_tendsto (p : C(unitInterval,ℂ)) (hi : Injective p)
-    (h0 : p 0=0) (hH : ∀ t : unitInterval, t≠0 → p t∈upperHalfPlane)
-    {s T : unitInterval} (hsT : s<T) (hT : T<1)
-    {z : ℂ} (hz : z∈upperHalfPlane \ range (initialSubarc p T)) :
-    Tendsto (fun t : unitInterval =>
-      (initialForwardChart p hi h0 hH t z-initialForwardChart p hi h0 hH s z)/
-        ((initialCapacity p hi h0 hH t-initialCapacity p hi h0 hH s:ℝ):ℂ))
-      (𝓝[Ioc s T] s) (𝓝 (1/(initialForwardChart p hi h0 hH s z-
-        (initialDrivingValue p hi h0 hH s (hsT.trans hT):ℂ)))) := by
-  let w := initialForwardChart p hi h0 hH s z-
-    (initialDrivingValue p hi h0 hH s (hsT.trans hT):ℂ)
-  have hzS : z∈upperHalfPlane \ range (initialSubarc p s) :=
-    ⟨hz.1,fun hh => hz.2 (initialSubarc_range_mono p hsT.le hh)⟩
-  have hwim : 0<w.im := by
-    simpa only [w,sub_im,ofReal_im,sub_zero] using
-      initialForwardChart_im_pos p hi h0 hH s hzS
-  have hwn : 0<‖w‖ := hwim.trans_le ((le_abs_self w.im).trans (abs_im_le_norm w))
-  have hw2 : 0<‖w‖^2 := sq_pos_of_pos hwn
-  apply Metric.tendsto_nhds.mpr
-  intro ε hε
-  let R := min (‖w‖/4) (ε*‖w‖^2/20)
-  have hR : 0<R := lt_min (by positivity) (by positivity)
-  have hRn : 2*R≤‖w‖ := by
-    have hh := min_le_left (‖w‖/4) (ε*‖w‖^2/20)
-    change R≤‖w‖/4 at hh
-    linarith
-  have hRe : 10*R/‖w‖^2<ε := by
-    have hh := min_le_right (‖w‖/4) (ε*‖w‖^2/20)
-    change R≤ε*‖w‖^2/20 at hh
-    apply (div_lt_iff₀ hw2).mpr
-    nlinarith [mul_pos hε hw2]
-  obtain ⟨δ,hδ,hsmall⟩ := centeredFutureArc_small p hi h0 hH s (hsT.trans hT) hR
-  have htime : Tendsto (fun t : unitInterval => (t:ℝ)-(s:ℝ)) (𝓝[Ioc s T] s) (𝓝 0) := by
-    have hcont : Continuous (fun t : unitInterval => (t:ℝ)-(s:ℝ)) :=
-      continuous_subtype_val.sub continuous_const
-    have hh := (hcont.tendsto s).mono_left
-      (show 𝓝[Ioc s T] s≤𝓝 s from inf_le_left)
-    simpa only [sub_self] using hh
-  filter_upwards [self_mem_nhdsWithin,htime.eventually (gt_mem_nhds hδ)] with t ht htd
-  have htt : t<1 := ht.2.trans_lt hT
-  have hzt : z∈upperHalfPlane \ range (initialSubarc p t) :=
-    ⟨hz.1,fun hh => hz.2 (initialSubarc_range_mono p ht.2 hh)⟩
-  have hb := initialForward_quotient_kernel p hi h0 hH ht.1 htt hzt hR
-    (hsmall t ht.1 htt htd) hRn
-  rw [dist_eq_norm]
-  exact hb.trans_lt hRe
-
-end SLEExactGauge
-
-end
-
-end OAI
+import OAI.Probability.SLE.Loewner.InitialForwardKernel
+import OAI.Probability.SLE.Loewner.CapacityForwardDerivative
+
+namespace OAI
+
+/-! The exact capacity difference quotient tends to the Loewner
+kernel as the future slit shrinks to its driving point. -/
+noncomputable section
+open Set Filter Function Complex Metric
+open scoped Topology
+
+namespace SLEExactGauge
+
+theorem initialForward_quotient_tendsto (p : C(unitInterval,ℂ)) (hi : Injective p)
+    (h0 : p 0=0) (hH : ∀ t : unitInterval, t≠0 → p t∈upperHalfPlane)
+    {s T : unitInterval} (hsT : s<T) (hT : T<1)
+    {z : ℂ} (hz : z∈upperHalfPlane \ range (initialSubarc p T)) :
+    Tendsto (fun t : unitInterval =>
+      (initialForwardChart p hi h0 hH t z-initialForwardChart p hi h0 hH s z)/
+        ((initialCapacity p hi h0 hH t-initialCapacity p hi h0 hH s:ℝ):ℂ))
+      (𝓝[Ioc s T] s) (𝓝 (1/(initialForwardChart p hi h0 hH s z-
+        (initialDrivingValue p hi h0 hH s (hsT.trans hT):ℂ)))) := by
+  let w := initialForwardChart p hi h0 hH s z-
+    (initialDrivingValue p hi h0 hH s (hsT.trans hT):ℂ)
+  have hzS : z∈upperHalfPlane \ range (initialSubarc p s) :=
+    ⟨hz.1,fun hh => hz.2 (initialSubarc_range_mono p hsT.le hh)⟩
+  have hwim : 0<w.im := by
+    simpa only [w,sub_im,ofReal_im,sub_zero] using
+      initialForwardChart_im_pos p hi h0 hH s hzS
+  have hwn : 0<‖w‖ := hwim.trans_le ((le_abs_self w.im).trans (abs_im_le_norm w))
+  have hw2 : 0<‖w‖^2 := sq_pos_of_pos hwn
+  apply Metric.tendsto_nhds.mpr
+  intro ε hε
+  let R := min (‖w‖/4) (ε*‖w‖^2/20)
+  have hR : 0<R := lt_min (by positivity) (by positivity)
+  have hRn : 2*R≤‖w‖ := by
+    have hh := min_le_left (‖w‖/4) (ε*‖w‖^2/20)
+    change R≤‖w‖/4 at hh
+    linarith
+  have hRe : 10*R/‖w‖^2<ε := by
+    have hh := min_le_right (‖w‖/4) (ε*‖w‖^2/20)
+    change R≤ε*‖w‖^2/20 at hh
+    apply (div_lt_iff₀ hw2).mpr
+    nlinarith [mul_pos hε hw2]
+  obtain ⟨δ,hδ,hsmall⟩ := centeredFutureArc_small p hi h0 hH s (hsT.trans hT) hR
+  have htime : Tendsto (fun t : unitInterval => (t:ℝ)-(s:ℝ)) (𝓝[Ioc s T] s) (𝓝 0) := by
+    have hcont : Continuous (fun t : unitInterval => (t:ℝ)-(s:ℝ)) :=
+      continuous_subtype_val.sub continuous_const
+    have hh := (hcont.tendsto s).mono_left
+      (show 𝓝[Ioc s T] s≤𝓝 s from inf_le_left)
+    simpa only [sub_self] using hh
+  filter_upwards [self_mem_nhdsWithin,htime.eventually (gt_mem_nhds hδ)] with t ht htd
+  have htt : t<1 := ht.2.trans_lt hT
+  have hzt : z∈upperHalfPlane \ range (initialSubarc p t) :=
+    ⟨hz.1,fun hh => hz.2 (initialSubarc_range_mono p ht.2 hh)⟩
+  have hb := initialForward_quotient_kernel p hi h0 hH ht.1 htt hzt hR
+    (hsmall t ht.1 htt htd) hRn
+  rw [dist_eq_norm]
+  exact hb.trans_lt hRe
+
+end SLEExactGauge
+
+end
+
+end OAI

lean/OAI/Probability/SLE/Loewner/InitialForwardLimit.lean

@@ -1,53 +1,53 @@
-import OAI.Probability.SLE.Loewner.InitialForwardNormalFamily
-import OAI.Probability.SLE.Loewner.InitialForwardBaseBounds
-import OAI.Probability.SLE.Geometry.HolomorphicDiskInterior
-
-namespace OAI
-
-/-! Limits of the compactified forward charts stay in the open disk. -/
-noncomputable section
-open Set Filter Function Complex Metric
-open scoped Topology
-
-namespace SLEExactGauge
-
-lemma initialForwardCayley_limit_interior (p : C(unitInterval,ℂ)) (hi : Injective p)
-    (h0 : p 0=0) (hH : ∀ t : unitInterval, t ≠ 0 → p t ∈ upperHalfPlane)
-    {t : ℕ → unitInterval} {A : ℂ → ℂ}
-    (hA : DifferentiableOn ℂ A (upperHalfPlane \ range p))
-    (hlim : TendstoLocallyUniformlyOn
-      (fun n z => halfPlaneCayley (initialForwardChart p hi h0 hH (t n) z))
-      A atTop (upperHalfPlane \ range p)) :
-    ∀ z∈upperHalfPlane \ range p, ‖A z‖<1 := by
-  obtain ⟨R0,hR0⟩ := (isCompact_range p.continuous).isBounded.exists_norm_le
-  let R := max R0 1
-  have hR : 0<R := lt_of_lt_of_le zero_lt_one (le_max_right _ _)
-  have hp (u : unitInterval) : ‖p u‖≤R := (hR0 _ (mem_range_self u)).trans (le_max_left _ _)
-  let b : ℂ := ((2*R:ℝ):ℂ)*I
-  have hb : b∈upperHalfPlane \ range p := initialForward_base_mem_domain p hR hp
-  have hbound (n : ℕ) := initialForwardChart_base_bounds p hi h0 hH hR hp (t n)
-  obtain ⟨v,_,φ,hφ,hv⟩ := (isCompact_closedBall (0:ℂ) (3*R)).tendsto_subseq (fun n => by
-    rw [mem_closedBall,dist_zero_right]
-    exact (hbound n).2)
-  have hvim : 3*R/2≤v.im := ge_of_tendsto (continuous_im.continuousAt.tendsto.comp hv)
-    (Eventually.of_forall fun n => (hbound (φ n)).1)
-  have hvH : v∈upperHalfPlane := lt_of_lt_of_le (by positivity : 0<3*R/2) hvim
-  have he : A b=halfPlaneCayley v := by
-    apply tendsto_nhds_unique ((hlim.tendsto_at hb).comp hφ.tendsto_atTop)
-    exact (halfPlaneCayley_differentiableOn.continuousOn v hvH).continuousAt
-      (isOpen_upperHalfPlane.mem_nhds hvH) |>.tendsto.comp hv
-  have hAb : ‖A b‖<1 := by rw [he]; exact halfPlaneCayley_norm_lt hvH
-  have hnorm : ∀ z∈upperHalfPlane \ range p, ‖A z‖≤1 := by
-    intro z hz
-    apply le_of_tendsto (hlim.tendsto_at hz).norm
-    exact Eventually.of_forall fun n => (halfPlaneCayley_norm_lt
-      (initialForwardChart_mapsTo p hi h0 hH (t n) hz)).le
-  exact holomorphic_disk_strict_of_point
-    (isOpen_upperHalfPlane.sdiff (isCompact_range p.continuous).isClosed)
-    (simple_arc_halfPlane_complement_connected p hi h0 hH).isPreconnected hA hnorm hb hAb
-
-end SLEExactGauge
-
-end
-
-end OAI
+import OAI.Probability.SLE.Loewner.InitialForwardNormalFamily
+import OAI.Probability.SLE.Loewner.InitialForwardBaseBounds
+import OAI.Probability.SLE.Geometry.HolomorphicDiskInterior
+
+namespace OAI
+
+/-! Limits of the compactified forward charts stay in the open disk. -/
+noncomputable section
+open Set Filter Function Complex Metric
+open scoped Topology
+
+namespace SLEExactGauge
+
+lemma initialForwardCayley_limit_interior (p : C(unitInterval,ℂ)) (hi : Injective p)
+    (h0 : p 0=0) (hH : ∀ t : unitInterval, t ≠ 0 → p t ∈ upperHalfPlane)
+    {t : ℕ → unitInterval} {A : ℂ → ℂ}
+    (hA : DifferentiableOn ℂ A (upperHalfPlane \ range p))
+    (hlim : TendstoLocallyUniformlyOn
+      (fun n z => halfPlaneCayley (initialForwardChart p hi h0 hH (t n) z))
+      A atTop (upperHalfPlane \ range p)) :
+    ∀ z∈upperHalfPlane \ range p, ‖A z‖<1 := by
+  obtain ⟨R0,hR0⟩ := (isCompact_range p.continuous).isBounded.exists_norm_le
+  let R := max R0 1
+  have hR : 0<R := lt_of_lt_of_le zero_lt_one (le_max_right _ _)
+  have hp (u : unitInterval) : ‖p u‖≤R := (hR0 _ (mem_range_self u)).trans (le_max_left _ _)
+  let b : ℂ := ((2*R:ℝ):ℂ)*I
+  have hb : b∈upperHalfPlane \ range p := initialForward_base_mem_domain p hR hp
+  have hbound (n : ℕ) := initialForwardChart_base_bounds p hi h0 hH hR hp (t n)
+  obtain ⟨v,_,φ,hφ,hv⟩ := (isCompact_closedBall (0:ℂ) (3*R)).tendsto_subseq (fun n => by
+    rw [mem_closedBall,dist_zero_right]
+    exact (hbound n).2)
+  have hvim : 3*R/2≤v.im := ge_of_tendsto (continuous_im.continuousAt.tendsto.comp hv)
+    (Eventually.of_forall fun n => (hbound (φ n)).1)
+  have hvH : v∈upperHalfPlane := lt_of_lt_of_le (by positivity : 0<3*R/2) hvim
+  have he : A b=halfPlaneCayley v := by
+    apply tendsto_nhds_unique ((hlim.tendsto_at hb).comp hφ.tendsto_atTop)
+    exact (halfPlaneCayley_differentiableOn.continuousOn v hvH).continuousAt
+      (isOpen_upperHalfPlane.mem_nhds hvH) |>.tendsto.comp hv
+  have hAb : ‖A b‖<1 := by rw [he]; exact halfPlaneCayley_norm_lt hvH
+  have hnorm : ∀ z∈upperHalfPlane \ range p, ‖A z‖≤1 := by
+    intro z hz
+    apply le_of_tendsto (hlim.tendsto_at hz).norm
+    exact Eventually.of_forall fun n => (halfPlaneCayley_norm_lt
+      (initialForwardChart_mapsTo p hi h0 hH (t n) hz)).le
+  exact holomorphic_disk_strict_of_point
+    (isOpen_upperHalfPlane.sdiff (isCompact_range p.continuous).isClosed)
+    (simple_arc_halfPlane_complement_connected p hi h0 hH).isPreconnected hA hnorm hb hAb
+
+end SLEExactGauge
+
+end
+
+end OAI

lean/OAI/Probability/SLE/Loewner/InitialForwardNormalFamily.lean

@@ -1,37 +1,37 @@
-import OAI.Probability.SLE.Loewner.InitialForwardChart
-import OAI.Probability.SLE.Loewner.InitialInverseNormalFamily
-
-namespace OAI
-
-/-! The compactified forward charts form a bounded normal family on the final domain. -/
-noncomputable section
-open Set Filter Function
-open scoped Topology
-
-namespace SLEExactGauge
-
-theorem initialForwardCayley_subsequence (p : C(unitInterval,ℂ)) (hi : Injective p)
-    (h0 : p 0=0) (hH : ∀ t : unitInterval, t ≠ 0 → p t ∈ upperHalfPlane)
-    (t : ℕ → unitInterval) :
-    ∃ (φ : ℕ → ℕ) (F : ℂ → ℂ), StrictMono φ ∧
-      DifferentiableOn ℂ F (upperHalfPlane \ range p) ∧
-      TendstoLocallyUniformlyOn
-        (fun n z => halfPlaneCayley (initialForwardChart p hi h0 hH (t (φ n)) z))
-        F atTop (upperHalfPlane \ range p) := by
-  have hD : IsOpen (upperHalfPlane \ range p) :=
-    isOpen_upperHalfPlane.sdiff (isCompact_range p.continuous).isClosed
-  apply TauCeti.montel (F := fun n z => halfPlaneCayley (initialForwardChart p hi h0 hH (t n) z)) hD
-  · intro n
-    exact halfPlaneCayley_differentiableOn.comp
-      (initialForwardChart_differentiableOn p hi h0 hH (t n))
-      (initialForwardChart_mapsTo p hi h0 hH (t n))
-  · apply TauCeti.isLocallyBoundedOn_of_forall_norm_le (C := 1)
-    intro n z hz
-    exact (halfPlaneCayley_norm_lt
-      (initialForwardChart_mapsTo p hi h0 hH (t n) hz)).le
-
-end SLEExactGauge
-
-end
-
-end OAI
+import OAI.Probability.SLE.Loewner.InitialForwardChart
+import OAI.Probability.SLE.Loewner.InitialInverseNormalFamily
+
+namespace OAI
+
+/-! The compactified forward charts form a bounded normal family on the final domain. -/
+noncomputable section
+open Set Filter Function
+open scoped Topology
+
+namespace SLEExactGauge
+
+theorem initialForwardCayley_subsequence (p : C(unitInterval,ℂ)) (hi : Injective p)
+    (h0 : p 0=0) (hH : ∀ t : unitInterval, t ≠ 0 → p t ∈ upperHalfPlane)
+    (t : ℕ → unitInterval) :
+    ∃ (φ : ℕ → ℕ) (F : ℂ → ℂ), StrictMono φ ∧
+      DifferentiableOn ℂ F (upperHalfPlane \ range p) ∧
+      TendstoLocallyUniformlyOn
+        (fun n z => halfPlaneCayley (initialForwardChart p hi h0 hH (t (φ n)) z))
+        F atTop (upperHalfPlane \ range p) := by
+  have hD : IsOpen (upperHalfPlane \ range p) :=
+    isOpen_upperHalfPlane.sdiff (isCompact_range p.continuous).isClosed
+  apply TauCeti.montel (F := fun n z => halfPlaneCayley (initialForwardChart p hi h0 hH (t n) z)) hD
+  · intro n
+    exact halfPlaneCayley_differentiableOn.comp
+      (initialForwardChart_differentiableOn p hi h0 hH (t n))
+      (initialForwardChart_mapsTo p hi h0 hH (t n))
+  · apply TauCeti.isLocallyBoundedOn_of_forall_norm_le (C := 1)
+    intro n z hz
+    exact (halfPlaneCayley_norm_lt
+      (initialForwardChart_mapsTo p hi h0 hH (t n) hz)).le
+
+end SLEExactGauge
+
+end
+
+end OAI

lean/OAI/Probability/SLE/Loewner/InitialForwardRecovery.lean

@@ -1,41 +1,41 @@
-import OAI.Probability.SLE.Loewner.InitialForwardLimit
-
-namespace OAI
-
-/-! Recover actual forward coordinates from their compactified limits. -/
-noncomputable section
-open Set Filter Function Complex
-open scoped Topology
-
-namespace SLEExactGauge
-
-lemma initialForward_limit_tendsto (p : C(unitInterval,ℂ)) (hi : Injective p)
-    (h0 : p 0=0) (hH : ∀ t : unitInterval, t ≠ 0 → p t ∈ upperHalfPlane)
-    {t : ℕ → unitInterval} {A : ℂ → ℂ}
-    (hA : DifferentiableOn ℂ A (upperHalfPlane \ range p))
-    (hlim : TendstoLocallyUniformlyOn
-      (fun n z => halfPlaneCayley (initialForwardChart p hi h0 hH (t n) z))
-      A atTop (upperHalfPlane \ range p)) {z : ℂ} (hz : z∈upperHalfPlane \ range p) :
-    Tendsto (fun n => initialForwardChart p hi h0 hH (t n) z)
-      atTop (𝓝 (halfPlaneCayleyInv (A z))) := by
-  have hn := initialForwardCayley_limit_interior p hi h0 hH hA hlim z hz
-  have hne : A z≠1 := by
-    intro he
-    simp only [he,norm_one,lt_self_iff_false] at hn
-  have hc : ContinuousAt halfPlaneCayleyInv (A z) := by
-    apply (continuousAt_const.mul (continuousAt_const.add continuousAt_id)).div
-      (continuousAt_const.sub continuousAt_id)
-    exact sub_ne_zero.mpr hne.symm
-  have ht := hc.tendsto.comp (hlim.tendsto_at hz)
-  apply ht.congr
-  intro n
-  exact halfPlaneCayleyInv_cayley
-    (show 0≤(initialForwardChart p hi h0 hH (t n) z).im from
-      (show 0<(initialForwardChart p hi h0 hH (t n) z).im from
-        initialForwardChart_mapsTo p hi h0 hH (t n) hz).le)
-
-end SLEExactGauge
-
-end
-
-end OAI
+import OAI.Probability.SLE.Loewner.InitialForwardLimit
+
+namespace OAI
+
+/-! Recover actual forward coordinates from their compactified limits. -/
+noncomputable section
+open Set Filter Function Complex
+open scoped Topology
+
+namespace SLEExactGauge
+
+lemma initialForward_limit_tendsto (p : C(unitInterval,ℂ)) (hi : Injective p)
+    (h0 : p 0=0) (hH : ∀ t : unitInterval, t ≠ 0 → p t ∈ upperHalfPlane)
+    {t : ℕ → unitInterval} {A : ℂ → ℂ}
+    (hA : DifferentiableOn ℂ A (upperHalfPlane \ range p))
+    (hlim : TendstoLocallyUniformlyOn
+      (fun n z => halfPlaneCayley (initialForwardChart p hi h0 hH (t n) z))
+      A atTop (upperHalfPlane \ range p)) {z : ℂ} (hz : z∈upperHalfPlane \ range p) :
+    Tendsto (fun n => initialForwardChart p hi h0 hH (t n) z)
+      atTop (𝓝 (halfPlaneCayleyInv (A z))) := by
+  have hn := initialForwardCayley_limit_interior p hi h0 hH hA hlim z hz
+  have hne : A z≠1 := by
+    intro he
+    simp only [he,norm_one,lt_self_iff_false] at hn
+  have hc : ContinuousAt halfPlaneCayleyInv (A z) := by
+    apply (continuousAt_const.mul (continuousAt_const.add continuousAt_id)).div
+      (continuousAt_const.sub continuousAt_id)
+    exact sub_ne_zero.mpr hne.symm
+  have ht := hc.tendsto.comp (hlim.tendsto_at hz)
+  apply ht.congr
+  intro n
+  exact halfPlaneCayleyInv_cayley
+    (show 0≤(initialForwardChart p hi h0 hH (t n) z).im from
+      (show 0<(initialForwardChart p hi h0 hH (t n) z).im from
+        initialForwardChart_mapsTo p hi h0 hH (t n) hz).le)
+
+end SLEExactGauge
+
+end
+
+end OAI

lean/OAI/Probability/SLE/Loewner/InitialForwardTimeContinuity.lean

@@ -1,53 +1,53 @@
-import OAI.Probability.SLE.Loewner.InitialInverseTimeContinuity
-import OAI.Probability.SLE.Loewner.InitialChartIdentities
-
-namespace OAI
-
-/-! Continuity of the forward coordinates along any sequence of surviving
-points, using the actual inverse charts and Hurwitz's theorem. -/
-noncomputable section
-open Set Filter Function Metric
-open scoped Topology
-
-namespace SLEExactGauge
-
-theorem initialForwardChart_tendsto (p : C(unitInterval,ℂ)) (hi : Injective p)
-    (h0 : p 0=0) (hH : ∀ t : unitInterval, t ≠ 0 → p t ∈ upperHalfPlane)
-    {t : ℕ → unitInterval} {s : unitInterval} (ht : Tendsto t atTop (𝓝 s))
-    {z : ℕ → ℂ} {a : ℂ} (hz : Tendsto z atTop (𝓝 a))
-    (ha : a∈upperHalfPlane \ range (initialSubarc p s))
-    (hzD : ∀ n, z n∈upperHalfPlane \ range (initialSubarc p (t n))) :
-    Tendsto (fun n => initialForwardChart p hi h0 hH (t n) (z n))
-      atTop (𝓝 (initialForwardChart p hi h0 hH s a)) := by
-  have hbase := initialInverseChart_locallyUniform_continuous p hi h0 hH s
-  have hconv : TendstoLocallyUniformlyOn (fun n => initialInverseChart p hi h0 hH (t n))
-      (initialInverseChart p hi h0 hH s) atTop upperHalfPlane := by
-    intro U hU w hw
-    obtain ⟨V,hV,hN⟩ := hbase U hU w hw
-    exact ⟨V,hV,ht.eventually hN⟩
-  have hconst := hz.tendstoUniformlyOn_const upperHalfPlane |>.tendstoLocallyUniformlyOn
-  have hdiff := hconv.sub hconst
-  have hnc : ¬ ∀ w∈upperHalfPlane, initialInverseChart p hi h0 hH s w-a=0 := by
-    intro h
-    exact initialInverse_limit_not_constant p hi h0 hH hconv a
-      (fun w hw => sub_eq_zero.mp (h w hw))
-  apply Metric.tendsto_nhds.mpr
-  intro ε hε
-  have hevent := TauCeti.hurwitz_eventually_exists_eq_zero isOpen_upperHalfPlane
-    (convex_halfSpace_im_gt (0:ℝ)).isPreconnected
-    (Eventually.of_forall fun n => (initialInverseChart_differentiableOn p hi h0 hH (t n)).sub_const (z n))
-    hdiff (initialForwardChart_mem_upper p hi h0 hH s ha)
-    (sub_eq_zero.mpr (initialInverse_forward_at p hi h0 hH s ha)) hnc hε
-  filter_upwards [hevent] with n hn
-  obtain ⟨w,hw,hew⟩ := hn
-  have he : w=initialForwardChart p hi h0 hH (t n) (z n) := by
-    apply initialInverseChart_injOn p hi h0 hH (t n) hw.1
-      (initialForwardChart_mem_upper p hi h0 hH (t n) (hzD n))
-    exact (sub_eq_zero.mp hew).trans (initialInverse_forward_at p hi h0 hH (t n) (hzD n)).symm
-  simpa only [← he,mem_ball] using hw.2
-
-end SLEExactGauge
-
-end
-
-end OAI
+import OAI.Probability.SLE.Loewner.InitialInverseTimeContinuity
+import OAI.Probability.SLE.Loewner.InitialChartIdentities
+
+namespace OAI
+
+/-! Continuity of the forward coordinates along any sequence of surviving
+points, using the actual inverse charts and Hurwitz's theorem. -/
+noncomputable section
+open Set Filter Function Metric
+open scoped Topology
+
+namespace SLEExactGauge
+
+theorem initialForwardChart_tendsto (p : C(unitInterval,ℂ)) (hi : Injective p)
+    (h0 : p 0=0) (hH : ∀ t : unitInterval, t ≠ 0 → p t ∈ upperHalfPlane)
+    {t : ℕ → unitInterval} {s : unitInterval} (ht : Tendsto t atTop (𝓝 s))
+    {z : ℕ → ℂ} {a : ℂ} (hz : Tendsto z atTop (𝓝 a))
+    (ha : a∈upperHalfPlane \ range (initialSubarc p s))
+    (hzD : ∀ n, z n∈upperHalfPlane \ range (initialSubarc p (t n))) :
+    Tendsto (fun n => initialForwardChart p hi h0 hH (t n) (z n))
+      atTop (𝓝 (initialForwardChart p hi h0 hH s a)) := by
+  have hbase := initialInverseChart_locallyUniform_continuous p hi h0 hH s
+  have hconv : TendstoLocallyUniformlyOn (fun n => initialInverseChart p hi h0 hH (t n))
+      (initialInverseChart p hi h0 hH s) atTop upperHalfPlane := by
+    intro U hU w hw
+    obtain ⟨V,hV,hN⟩ := hbase U hU w hw
+    exact ⟨V,hV,ht.eventually hN⟩
+  have hconst := hz.tendstoUniformlyOn_const upperHalfPlane |>.tendstoLocallyUniformlyOn
+  have hdiff := hconv.sub hconst
+  have hnc : ¬ ∀ w∈upperHalfPlane, initialInverseChart p hi h0 hH s w-a=0 := by
+    intro h
+    exact initialInverse_limit_not_constant p hi h0 hH hconv a
+      (fun w hw => sub_eq_zero.mp (h w hw))
+  apply Metric.tendsto_nhds.mpr
+  intro ε hε
+  have hevent := TauCeti.hurwitz_eventually_exists_eq_zero isOpen_upperHalfPlane
+    (convex_halfSpace_im_gt (0:ℝ)).isPreconnected
+    (Eventually.of_forall fun n => (initialInverseChart_differentiableOn p hi h0 hH (t n)).sub_const (z n))
+    hdiff (initialForwardChart_mem_upper p hi h0 hH s ha)
+    (sub_eq_zero.mpr (initialInverse_forward_at p hi h0 hH s ha)) hnc hε
+  filter_upwards [hevent] with n hn
+  obtain ⟨w,hw,hew⟩ := hn
+  have he : w=initialForwardChart p hi h0 hH (t n) (z n) := by
+    apply initialInverseChart_injOn p hi h0 hH (t n) hw.1
+      (initialForwardChart_mem_upper p hi h0 hH (t n) (hzD n))
+    exact (sub_eq_zero.mp hew).trans (initialInverse_forward_at p hi h0 hH (t n) (hzD n)).symm
+  simpa only [← he,mem_ball] using hw.2
+
+end SLEExactGauge
+
+end
+
+end OAI

lean/OAI/Probability/SLE/Loewner/InitialHeightCapacityIncrement.lean

@@ -1,41 +1,41 @@
-import OAI.Probability.SLE.Loewner.ForwardHeightSquareIncrement
-
-namespace OAI
-
-/-! Height loss on a surviving initial-slit prefix is bounded by twice
-the exact capacity increment. -/
-noncomputable section
-open Set Filter Function Complex
-open scoped Topology
-
-namespace SLEExactGauge
-
-theorem initialForward_height_capacity_increment (p : C(unitInterval,ℂ)) (hi : Injective p)
-    (h0 : p 0=0) (hH : ∀ t : unitInterval, t≠0 → p t∈upperHalfPlane)
-    {s r T : unitInterval} (hsr : s≤r) (hrT : r≤T) (hT : T<1)
-    {z : ℂ} (hz : z∈upperHalfPlane \ range (initialSubarc p T)) :
-    (initialForwardChart p hi h0 hH s z).im^2≤
-      (initialForwardChart p hi h0 hH r z).im^2+
-        2*(initialCapacity p hi h0 hH r-initialCapacity p hi h0 hH s) := by
-  have ha := initialCapacity_nonneg p hi h0 hH s
-  have hsr' := initialCapacity_monotone p hi h0 hH hsr
-  have hrT' := initialCapacity_monotone p hi h0 hH hrT
-  have hc : ContinuousOn (capacityForwardOnPrefix p hi h0 hH T z)
-      (Icc (initialCapacity p hi h0 hH s) (initialCapacity p hi h0 hH r)) :=
-    (capacityForwardOnPrefix_lipschitz p hi h0 hH hT hz).continuous.continuousOn
-  have hd (c : ℝ) (hcc : c∈Ico (initialCapacity p hi h0 hH s)
-      (initialCapacity p hi h0 hH r)) :
-      HasDerivWithinAt (capacityForwardOnPrefix p hi h0 hH T z)
-        (1/(capacityForwardOnPrefix p hi h0 hH T z c-
-          (capacityDriverOnPrefix p hi h0 hH T hT c:ℂ))) (Ici c) c :=
-    capacityForward_hasDerivWithinAt_Ici p hi h0 hH hT hz
-      ⟨ha.trans hcc.1,hcc.2.trans_le hrT'⟩
-  have hh := height_square_increment hsr' hc hd
-  simpa only [capacityForwardOnPrefix_at_initialCapacity p hi h0 hH T z (hsr.trans hrT),
-    capacityForwardOnPrefix_at_initialCapacity p hi h0 hH T z hrT] using hh
-
-end SLEExactGauge
-
-end
-
-end OAI
+import OAI.Probability.SLE.Loewner.ForwardHeightSquareIncrement
+
+namespace OAI
+
+/-! Height loss on a surviving initial-slit prefix is bounded by twice
+the exact capacity increment. -/
+noncomputable section
+open Set Filter Function Complex
+open scoped Topology
+
+namespace SLEExactGauge
+
+theorem initialForward_height_capacity_increment (p : C(unitInterval,ℂ)) (hi : Injective p)
+    (h0 : p 0=0) (hH : ∀ t : unitInterval, t≠0 → p t∈upperHalfPlane)
+    {s r T : unitInterval} (hsr : s≤r) (hrT : r≤T) (hT : T<1)
+    {z : ℂ} (hz : z∈upperHalfPlane \ range (initialSubarc p T)) :
+    (initialForwardChart p hi h0 hH s z).im^2≤
+      (initialForwardChart p hi h0 hH r z).im^2+
+        2*(initialCapacity p hi h0 hH r-initialCapacity p hi h0 hH s) := by
+  have ha := initialCapacity_nonneg p hi h0 hH s
+  have hsr' := initialCapacity_monotone p hi h0 hH hsr
+  have hrT' := initialCapacity_monotone p hi h0 hH hrT
+  have hc : ContinuousOn (capacityForwardOnPrefix p hi h0 hH T z)
+      (Icc (initialCapacity p hi h0 hH s) (initialCapacity p hi h0 hH r)) :=
+    (capacityForwardOnPrefix_lipschitz p hi h0 hH hT hz).continuous.continuousOn
+  have hd (c : ℝ) (hcc : c∈Ico (initialCapacity p hi h0 hH s)
+      (initialCapacity p hi h0 hH r)) :
+      HasDerivWithinAt (capacityForwardOnPrefix p hi h0 hH T z)
+        (1/(capacityForwardOnPrefix p hi h0 hH T z c-
+          (capacityDriverOnPrefix p hi h0 hH T hT c:ℂ))) (Ici c) c :=
+    capacityForward_hasDerivWithinAt_Ici p hi h0 hH hT hz
+      ⟨ha.trans hcc.1,hcc.2.trans_le hrT'⟩
+  have hh := height_square_increment hsr' hc hd
+  simpa only [capacityForwardOnPrefix_at_initialCapacity p hi h0 hH T z (hsr.trans hrT),
+    capacityForwardOnPrefix_at_initialCapacity p hi h0 hH T z hrT] using hh
+
+end SLEExactGauge
+
+end
+
+end OAI

lean/OAI/Probability/SLE/Loewner/InitialInverseChart.lean

@@ -1,71 +1,71 @@
-import OAI.Probability.SLE.Loewner.SlitChartDisplacement
-import OAI.Probability.SLE.Loewner.InitialCapacityAtZero
-
-namespace OAI
-
-/-! The actual normalized inverse charts of initial subarcs start at the identity. -/
-noncomputable section
-open Set Filter Function Metric
-open scoped Topology
-
-namespace SLEExactGauge
-
-noncomputable def initialInverseChart (p : C(unitInterval,ℂ)) (hi : Injective p)
-    (h0 : p 0=0) (hH : ∀ t : unitInterval, t ≠ 0 → p t ∈ upperHalfPlane)
-    (t : unitInterval) : ℂ → ℂ :=
-  if ht : t=0 then id else (initialSlitChart p hi h0 hH t ht).inverse
-
-@[simp] lemma initialInverseChart_zero (p : C(unitInterval,ℂ)) (hi : Injective p)
-    (h0 : p 0=0) (hH : ∀ t : unitInterval, t ≠ 0 → p t ∈ upperHalfPlane) :
-    initialInverseChart p hi h0 hH 0=id := by simp [initialInverseChart]
-
-lemma initialInverseChart_differentiableOn (p : C(unitInterval,ℂ)) (hi : Injective p)
-    (h0 : p 0=0) (hH : ∀ t : unitInterval, t ≠ 0 → p t ∈ upperHalfPlane)
-    (t : unitInterval) : DifferentiableOn ℂ (initialInverseChart p hi h0 hH t) upperHalfPlane := by
-  by_cases ht : t=0
-  · simp only [ht,initialInverseChart_zero]
-    exact differentiableOn_id
-  · rw [initialInverseChart,dite_eq_right ht]
-    exact (initialSlitChart p hi h0 hH t ht).inverse_differentiable
-
-lemma initialInverseChart_displacement (p : C(unitInterval,ℂ)) (hi : Injective p)
-    (h0 : p 0=0) (hH : ∀ t : unitInterval, t ≠ 0 → p t ∈ upperHalfPlane)
-    (t : unitInterval) {z : ℂ} (hz : z∈upperHalfPlane) :
-    ‖initialInverseChart p hi h0 hH t z-z‖≤ initialCapacity p hi h0 hH t/z.im := by
-  by_cases ht : t=0
-  · simp [ht]
-  · rw [initialInverseChart,dite_eq_right ht,initialCapacity,dite_eq_right ht]
-    exact (initialSlitChart p hi h0 hH t ht).inverse_displacement hz
-
-lemma compact_upperHalfPlane_min_height {K : Set ℂ} (hK : IsCompact K)
-    (hKH : K ⊆ upperHalfPlane) (hne : K.Nonempty) :
-    ∃ m : ℝ, 0< m ∧ ∀ z∈K, m≤ z.im := by
-  obtain ⟨z,hz,hmin⟩ := hK.exists_isMinOn hne Complex.continuous_im.continuousOn
-  exact ⟨z.im,hKH hz,fun w hw => hmin hw⟩
-
-theorem initialInverseChart_tendsto_identity (p : C(unitInterval,ℂ)) (hi : Injective p)
-    (h0 : p 0=0) (hH : ∀ t : unitInterval, t ≠ 0 → p t ∈ upperHalfPlane) :
-    TendstoLocallyUniformlyOn (initialInverseChart p hi h0 hH) id (𝓝 0) upperHalfPlane := by
-  rw [tendstoLocallyUniformlyOn_iff_forall_isCompact isOpen_upperHalfPlane]
-  intro K hKH hK
-  by_cases hne : K.Nonempty
-  · obtain ⟨m,hm,hmin⟩ := compact_upperHalfPlane_min_height hK hKH hne
-    have hcap : Tendsto (initialCapacity p hi h0 hH) (𝓝 0) (𝓝 0) := by
-      simpa only [initialCapacity_zero] using (initialCapacity_continuousAt_zero p hi h0 hH).tendsto
-    have hsmall : Tendsto (fun t => initialCapacity p hi h0 hH t/m) (𝓝 0) (𝓝 0) := by
-      simpa only [zero_div] using hcap.div_const m
-    rw [Metric.tendstoUniformlyOn_iff]
-    intro ε hε
-    filter_upwards [hsmall.eventually (gt_mem_nhds hε)] with t ht
-    intro z hz
-    rw [dist_eq_norm,show id z=z from rfl,norm_sub_rev]
-    exact ((initialInverseChart_displacement p hi h0 hH t (hKH hz)).trans
-      (div_le_div_of_nonneg_left (initialCapacity_nonneg p hi h0 hH t) hm (hmin z hz))).trans_lt ht
-  · simpa only [not_nonempty_iff_eq_empty.mp hne] using
-      (tendstoUniformlyOn_empty : TendstoUniformlyOn (initialInverseChart p hi h0 hH) id (𝓝 0) ∅)
-
-end SLEExactGauge
-
-end
-
-end OAI
+import OAI.Probability.SLE.Loewner.SlitChartDisplacement
+import OAI.Probability.SLE.Loewner.InitialCapacityAtZero
+
+namespace OAI
+
+/-! The actual normalized inverse charts of initial subarcs start at the identity. -/
+noncomputable section
+open Set Filter Function Metric
+open scoped Topology
+
+namespace SLEExactGauge
+
+noncomputable def initialInverseChart (p : C(unitInterval,ℂ)) (hi : Injective p)
+    (h0 : p 0=0) (hH : ∀ t : unitInterval, t ≠ 0 → p t ∈ upperHalfPlane)
+    (t : unitInterval) : ℂ → ℂ :=
+  if ht : t=0 then id else (initialSlitChart p hi h0 hH t ht).inverse
+
+@[simp] lemma initialInverseChart_zero (p : C(unitInterval,ℂ)) (hi : Injective p)
+    (h0 : p 0=0) (hH : ∀ t : unitInterval, t ≠ 0 → p t ∈ upperHalfPlane) :
+    initialInverseChart p hi h0 hH 0=id := by simp [initialInverseChart]
+
+lemma initialInverseChart_differentiableOn (p : C(unitInterval,ℂ)) (hi : Injective p)
+    (h0 : p 0=0) (hH : ∀ t : unitInterval, t ≠ 0 → p t ∈ upperHalfPlane)
+    (t : unitInterval) : DifferentiableOn ℂ (initialInverseChart p hi h0 hH t) upperHalfPlane := by
+  by_cases ht : t=0
+  · simp only [ht,initialInverseChart_zero]
+    exact differentiableOn_id
+  · rw [initialInverseChart,dite_eq_right ht]
+    exact (initialSlitChart p hi h0 hH t ht).inverse_differentiable
+
+lemma initialInverseChart_displacement (p : C(unitInterval,ℂ)) (hi : Injective p)
+    (h0 : p 0=0) (hH : ∀ t : unitInterval, t ≠ 0 → p t ∈ upperHalfPlane)
+    (t : unitInterval) {z : ℂ} (hz : z∈upperHalfPlane) :
+    ‖initialInverseChart p hi h0 hH t z-z‖≤ initialCapacity p hi h0 hH t/z.im := by
+  by_cases ht : t=0
+  · simp [ht]
+  · rw [initialInverseChart,dite_eq_right ht,initialCapacity,dite_eq_right ht]
+    exact (initialSlitChart p hi h0 hH t ht).inverse_displacement hz
+
+lemma compact_upperHalfPlane_min_height {K : Set ℂ} (hK : IsCompact K)
+    (hKH : K ⊆ upperHalfPlane) (hne : K.Nonempty) :
+    ∃ m : ℝ, 0< m ∧ ∀ z∈K, m≤ z.im := by
+  obtain ⟨z,hz,hmin⟩ := hK.exists_isMinOn hne Complex.continuous_im.continuousOn
+  exact ⟨z.im,hKH hz,fun w hw => hmin hw⟩
+
+theorem initialInverseChart_tendsto_identity (p : C(unitInterval,ℂ)) (hi : Injective p)
+    (h0 : p 0=0) (hH : ∀ t : unitInterval, t ≠ 0 → p t ∈ upperHalfPlane) :
+    TendstoLocallyUniformlyOn (initialInverseChart p hi h0 hH) id (𝓝 0) upperHalfPlane := by
+  rw [tendstoLocallyUniformlyOn_iff_forall_isCompact isOpen_upperHalfPlane]
+  intro K hKH hK
+  by_cases hne : K.Nonempty
+  · obtain ⟨m,hm,hmin⟩ := compact_upperHalfPlane_min_height hK hKH hne
+    have hcap : Tendsto (initialCapacity p hi h0 hH) (𝓝 0) (𝓝 0) := by
+      simpa only [initialCapacity_zero] using (initialCapacity_continuousAt_zero p hi h0 hH).tendsto
+    have hsmall : Tendsto (fun t => initialCapacity p hi h0 hH t/m) (𝓝 0) (𝓝 0) := by
+      simpa only [zero_div] using hcap.div_const m
+    rw [Metric.tendstoUniformlyOn_iff]
+    intro ε hε
+    filter_upwards [hsmall.eventually (gt_mem_nhds hε)] with t ht
+    intro z hz
+    rw [dist_eq_norm,show id z=z from rfl,norm_sub_rev]
+    exact ((initialInverseChart_displacement p hi h0 hH t (hKH hz)).trans
+      (div_le_div_of_nonneg_left (initialCapacity_nonneg p hi h0 hH t) hm (hmin z hz))).trans_lt ht
+  · simpa only [not_nonempty_iff_eq_empty.mp hne] using
+      (tendstoUniformlyOn_empty : TendstoUniformlyOn (initialInverseChart p hi h0 hH) id (𝓝 0) ∅)
+
+end SLEExactGauge
+
+end
+
+end OAI

lean/OAI/Probability/SLE/Loewner/InitialInverseCommonDomain.lean

@@ -1,45 +1,45 @@
-import OAI.Probability.SLE.Loewner.InitialForwardRecovery
-import OAI.Probability.SLE.Loewner.InitialInverseLimit
-import OAI.Probability.SLE.Geometry.LocallyUniformEvaluation
-
-namespace OAI
-
-/-! Every inverse-chart limit covers the common final slit domain.
-No convergence of the times, nor a boundary driving value, is assumed here. -/
-noncomputable section
-open Set Filter Function Complex
-open scoped Topology
-
-namespace SLEExactGauge
-
-theorem initialInverse_limit_covers_final_domain (p : C(unitInterval,ℂ)) (hi : Injective p)
-    (h0 : p 0=0) (hH : ∀ t : unitInterval, t ≠ 0 → p t ∈ upperHalfPlane)
-    {t : ℕ → unitInterval} {F : ℂ → ℂ}
-    (hF : DifferentiableOn ℂ F upperHalfPlane)
-    (hlim : TendstoLocallyUniformlyOn (fun n => initialInverseChart p hi h0 hH (t n))
-      F atTop upperHalfPlane) :
-    ∀ z∈upperHalfPlane \ range p, ∃ w∈upperHalfPlane, F w=z := by
-  obtain ⟨φ,A,hφ,hA,hAlim⟩ := initialForwardCayley_subsequence p hi h0 hH t
-  have hFsub := locallyUniform_reindex hlim hφ.tendsto_atTop
-  intro z hz
-  have hAz := initialForwardCayley_limit_interior p hi h0 hH hA hAlim z hz
-  have hw : halfPlaneCayleyInv (A z)∈upperHalfPlane := halfPlaneCayleyInv_open hAz
-  refine ⟨halfPlaneCayleyInv (A z),hw,?_⟩
-  have hforward := initialForward_limit_tendsto p hi h0 hH hA hAlim hz
-  have heval := locallyUniform_evaluation_tendsto isOpen_upperHalfPlane
-    hF.continuousOn hFsub hw hforward
-  have hconstant : Tendsto (fun n => initialInverseChart p hi h0 hH (t (φ n))
-      (initialForwardChart p hi h0 hH (t (φ n)) z)) atTop (𝓝 z) := by
-    have he : (fun n => initialInverseChart p hi h0 hH (t (φ n))
-        (initialForwardChart p hi h0 hH (t (φ n)) z)) = (fun _ : ℕ => z) := by
-      funext n
-      exact initialInverse_forward_on_final p hi h0 hH (t (φ n)) hz
-    rw [he]
-    exact tendsto_const_nhds
-  exact tendsto_nhds_unique heval hconstant
-
-end SLEExactGauge
-
-end
-
-end OAI
+import OAI.Probability.SLE.Loewner.InitialForwardRecovery
+import OAI.Probability.SLE.Loewner.InitialInverseLimit
+import OAI.Probability.SLE.Geometry.LocallyUniformEvaluation
+
+namespace OAI
+
+/-! Every inverse-chart limit covers the common final slit domain.
+No convergence of the times, nor a boundary driving value, is assumed here. -/
+noncomputable section
+open Set Filter Function Complex
+open scoped Topology
+
+namespace SLEExactGauge
+
+theorem initialInverse_limit_covers_final_domain (p : C(unitInterval,ℂ)) (hi : Injective p)
+    (h0 : p 0=0) (hH : ∀ t : unitInterval, t ≠ 0 → p t ∈ upperHalfPlane)
+    {t : ℕ → unitInterval} {F : ℂ → ℂ}
+    (hF : DifferentiableOn ℂ F upperHalfPlane)
+    (hlim : TendstoLocallyUniformlyOn (fun n => initialInverseChart p hi h0 hH (t n))
+      F atTop upperHalfPlane) :
+    ∀ z∈upperHalfPlane \ range p, ∃ w∈upperHalfPlane, F w=z := by
+  obtain ⟨φ,A,hφ,hA,hAlim⟩ := initialForwardCayley_subsequence p hi h0 hH t
+  have hFsub := locallyUniform_reindex hlim hφ.tendsto_atTop
+  intro z hz
+  have hAz := initialForwardCayley_limit_interior p hi h0 hH hA hAlim z hz
+  have hw : halfPlaneCayleyInv (A z)∈upperHalfPlane := halfPlaneCayleyInv_open hAz
+  refine ⟨halfPlaneCayleyInv (A z),hw,?_⟩
+  have hforward := initialForward_limit_tendsto p hi h0 hH hA hAlim hz
+  have heval := locallyUniform_evaluation_tendsto isOpen_upperHalfPlane
+    hF.continuousOn hFsub hw hforward
+  have hconstant : Tendsto (fun n => initialInverseChart p hi h0 hH (t (φ n))
+      (initialForwardChart p hi h0 hH (t (φ n)) z)) atTop (𝓝 z) := by
+    have he : (fun n => initialInverseChart p hi h0 hH (t (φ n))
+        (initialForwardChart p hi h0 hH (t (φ n)) z)) = (fun _ : ℕ => z) := by
+      funext n
+      exact initialInverse_forward_on_final p hi h0 hH (t (φ n)) hz
+    rw [he]
+    exact tendsto_const_nhds
+  exact tendsto_nhds_unique heval hconstant
+
+end SLEExactGauge
+
+end
+
+end OAI

lean/OAI/Probability/SLE/Loewner/InitialInverseEnergyBound.lean

@@ -1,52 +1,52 @@
-import OAI.Probability.SLE.Loewner.SlitUniformInverseBound
-import OAI.Probability.SLE.Loewner.InverseDirichletEnergy
-
-namespace OAI
-
-/-! A common finite Dirichlet-energy bound for the whole initial inverse
-family on a fixed upper half-disk. -/
-noncomputable section
-open Set Filter Function Complex Metric MeasureTheory
-open scoped Topology ENNReal
-
-namespace SLEExactGauge
-
-theorem initialInverse_dirichlet_bound (p : C(unitInterval,ℂ)) (hi : Injective p)
-    (h0 : p 0=0) (hH : ∀ t : unitInterval, t≠0 → p t∈upperHalfPlane)
-    {R : ℝ} (hR : 0<R) (hp : ∀ t : unitInterval, ‖p t‖<R)
-    (s : unitInterval) (A : ℝ) :
-    (∫⁻ z in upperHalfPlane ∩ ball (0:ℂ) A,
-      ENNReal.ofReal (‖deriv (initialInverseChart p hi h0 hH s) z‖^2))≤
-        volume (closedBall (0:ℂ) (A+3*R)) := by
-  let F := initialInverseChart p hi h0 hH s
-  let S := upperHalfPlane ∩ ball (0:ℂ) A
-  have hS : MeasurableSet S := isOpen_upperHalfPlane.measurableSet.inter measurableSet_ball
-  have hd (z : ℂ) (hz : z∈S) : HasDerivAt F (deriv F z) z :=
-    ((initialInverseChart_differentiableOn p hi h0 hH s).differentiableAt
-      (isOpen_upperHalfPlane.mem_nhds hz.1)).hasDerivAt
-  have hinj : InjOn F S := by
-    intro z hz w hw he
-    have hz' := initialForward_inverse p hi h0 hH s hz.1
-    have hw' := initialForward_inverse p hi h0 hH s hw.1
-    change initialForwardChart p hi h0 hH s (F z)=z at hz'
-    change initialForwardChart p hi h0 hH s (F w)=w at hw'
-    rw [he,hw'] at hz'
-    exact hz'.symm
-  have he : (∫⁻ z in S, ENNReal.ofReal (‖deriv F z‖^2))=volume (F '' S) := by
-    have hh := lintegral_abs_det_fderiv_eq_addHaar_image volume hS
-      (fun z hz => ((hd z hz).hasFDerivAt.restrictScalars ℝ).hasFDerivWithinAt) hinj
-    simpa only [complex_derivative_real_det,abs_pow,abs_norm] using hh
-  change (∫⁻ z in S, ENNReal.ofReal (‖deriv F z‖^2))≤_
-  rw [he]
-  apply measure_mono
-  rintro _ ⟨z,hz,rfl⟩
-  rw [mem_closedBall_zero_iff]
-  have hb := initialInverse_uniform_bound p hi h0 hH hR hp s hz.1
-  have hzA : ‖z‖<A := mem_ball_zero_iff.mp hz.2
-  exact hb.trans (by linarith)
-
-end SLEExactGauge
-
-end
-
-end OAI
+import OAI.Probability.SLE.Loewner.SlitUniformInverseBound
+import OAI.Probability.SLE.Loewner.InverseDirichletEnergy
+
+namespace OAI
+
+/-! A common finite Dirichlet-energy bound for the whole initial inverse
+family on a fixed upper half-disk. -/
+noncomputable section
+open Set Filter Function Complex Metric MeasureTheory
+open scoped Topology ENNReal
+
+namespace SLEExactGauge
+
+theorem initialInverse_dirichlet_bound (p : C(unitInterval,ℂ)) (hi : Injective p)
+    (h0 : p 0=0) (hH : ∀ t : unitInterval, t≠0 → p t∈upperHalfPlane)
+    {R : ℝ} (hR : 0<R) (hp : ∀ t : unitInterval, ‖p t‖<R)
+    (s : unitInterval) (A : ℝ) :
+    (∫⁻ z in upperHalfPlane ∩ ball (0:ℂ) A,
+      ENNReal.ofReal (‖deriv (initialInverseChart p hi h0 hH s) z‖^2))≤
+        volume (closedBall (0:ℂ) (A+3*R)) := by
+  let F := initialInverseChart p hi h0 hH s
+  let S := upperHalfPlane ∩ ball (0:ℂ) A
+  have hS : MeasurableSet S := isOpen_upperHalfPlane.measurableSet.inter measurableSet_ball
+  have hd (z : ℂ) (hz : z∈S) : HasDerivAt F (deriv F z) z :=
+    ((initialInverseChart_differentiableOn p hi h0 hH s).differentiableAt
+      (isOpen_upperHalfPlane.mem_nhds hz.1)).hasDerivAt
+  have hinj : InjOn F S := by
+    intro z hz w hw he
+    have hz' := initialForward_inverse p hi h0 hH s hz.1
+    have hw' := initialForward_inverse p hi h0 hH s hw.1
+    change initialForwardChart p hi h0 hH s (F z)=z at hz'
+    change initialForwardChart p hi h0 hH s (F w)=w at hw'
+    rw [he,hw'] at hz'
+    exact hz'.symm
+  have he : (∫⁻ z in S, ENNReal.ofReal (‖deriv F z‖^2))=volume (F '' S) := by
+    have hh := lintegral_abs_det_fderiv_eq_addHaar_image volume hS
+      (fun z hz => ((hd z hz).hasFDerivAt.restrictScalars ℝ).hasFDerivWithinAt) hinj
+    simpa only [complex_derivative_real_det,abs_pow,abs_norm] using hh
+  change (∫⁻ z in S, ENNReal.ofReal (‖deriv F z‖^2))≤_
+  rw [he]
+  apply measure_mono
+  rintro _ ⟨z,hz,rfl⟩
+  rw [mem_closedBall_zero_iff]
+  have hb := initialInverse_uniform_bound p hi h0 hH hR hp s hz.1
+  have hzA : ‖z‖<A := mem_ball_zero_iff.mp hz.2
+  exact hb.trans (by linarith)
+
+end SLEExactGauge
+
+end
+
+end OAI

lean/OAI/Probability/SLE/Loewner/InitialInverseEnergyIntegral.lean

@@ -1,41 +1,41 @@
-import OAI.Probability.SLE.Loewner.InitialInverseEnergyBound
-
-namespace OAI
-
-/-! Real, integrable versions of the common inverse Dirichlet bound. -/
-noncomputable section
-open Set Filter Function Complex Metric MeasureTheory
-open scoped Topology ENNReal
-
-namespace SLEExactGauge
-
-lemma initialInverse_energy_integrable (p : C(unitInterval,ℂ)) (hi : Injective p)
-    (h0 : p 0=0) (hH : ∀ t : unitInterval, t≠0 → p t∈upperHalfPlane)
-    {R : ℝ} (hR : 0<R) (hp : ∀ t : unitInterval, ‖p t‖<R)
-    (s : unitInterval) (A : ℝ) :
-    IntegrableOn (fun z => ‖deriv (initialInverseChart p hi h0 hH s) z‖^2)
-      (upperHalfPlane ∩ ball (0:ℂ) A) := by
-  have hm : Measurable (fun z => ‖deriv (initialInverseChart p hi h0 hH s) z‖^2) :=
-    (measurable_deriv _).norm.pow_const 2
-  refine ⟨hm.aestronglyMeasurable,?_⟩
-  rw [hasFiniteIntegral_iff_ofReal (ae_of_all _ (fun z => sq_nonneg _))]
-  exact (initialInverse_dirichlet_bound p hi h0 hH hR hp s A).trans_lt
-    (isCompact_closedBall (0:ℂ) (A+3*R)).measure_lt_top
-
-lemma initialInverse_energy_integral_le (p : C(unitInterval,ℂ)) (hi : Injective p)
-    (h0 : p 0=0) (hH : ∀ t : unitInterval, t≠0 → p t∈upperHalfPlane)
-    {R : ℝ} (hR : 0<R) (hp : ∀ t : unitInterval, ‖p t‖<R)
-    (s : unitInterval) (A : ℝ) :
-    (∫ z in upperHalfPlane ∩ ball (0:ℂ) A,
-      ‖deriv (initialInverseChart p hi h0 hH s) z‖^2)≤
-        (volume (closedBall (0:ℂ) (A+3*R))).toReal := by
-  rw [integral_eq_lintegral_of_nonneg_ae (ae_of_all _ (fun z => sq_nonneg _))
-    ((measurable_deriv _).norm.pow_const 2).aestronglyMeasurable]
-  exact ENNReal.toReal_mono (isCompact_closedBall (0:ℂ) (A+3*R)).measure_lt_top.ne
-    (initialInverse_dirichlet_bound p hi h0 hH hR hp s A)
-
-end SLEExactGauge
-
-end
-
-end OAI
+import OAI.Probability.SLE.Loewner.InitialInverseEnergyBound
+
+namespace OAI
+
+/-! Real, integrable versions of the common inverse Dirichlet bound. -/
+noncomputable section
+open Set Filter Function Complex Metric MeasureTheory
+open scoped Topology ENNReal
+
+namespace SLEExactGauge
+
+lemma initialInverse_energy_integrable (p : C(unitInterval,ℂ)) (hi : Injective p)
+    (h0 : p 0=0) (hH : ∀ t : unitInterval, t≠0 → p t∈upperHalfPlane)
+    {R : ℝ} (hR : 0<R) (hp : ∀ t : unitInterval, ‖p t‖<R)
+    (s : unitInterval) (A : ℝ) :
+    IntegrableOn (fun z => ‖deriv (initialInverseChart p hi h0 hH s) z‖^2)
+      (upperHalfPlane ∩ ball (0:ℂ) A) := by
+  have hm : Measurable (fun z => ‖deriv (initialInverseChart p hi h0 hH s) z‖^2) :=
+    (measurable_deriv _).norm.pow_const 2
+  refine ⟨hm.aestronglyMeasurable,?_⟩
+  rw [hasFiniteIntegral_iff_ofReal (ae_of_all _ (fun z => sq_nonneg _))]
+  exact (initialInverse_dirichlet_bound p hi h0 hH hR hp s A).trans_lt
+    (isCompact_closedBall (0:ℂ) (A+3*R)).measure_lt_top
+
+lemma initialInverse_energy_integral_le (p : C(unitInterval,ℂ)) (hi : Injective p)
+    (h0 : p 0=0) (hH : ∀ t : unitInterval, t≠0 → p t∈upperHalfPlane)
+    {R : ℝ} (hR : 0<R) (hp : ∀ t : unitInterval, ‖p t‖<R)
+    (s : unitInterval) (A : ℝ) :
+    (∫ z in upperHalfPlane ∩ ball (0:ℂ) A,
+      ‖deriv (initialInverseChart p hi h0 hH s) z‖^2)≤
+        (volume (closedBall (0:ℂ) (A+3*R))).toReal := by
+  rw [integral_eq_lintegral_of_nonneg_ae (ae_of_all _ (fun z => sq_nonneg _))
+    ((measurable_deriv _).norm.pow_const 2).aestronglyMeasurable]
+  exact ENNReal.toReal_mono (isCompact_closedBall (0:ℂ) (A+3*R)).measure_lt_top.ne
+    (initialInverse_dirichlet_bound p hi h0 hH hR hp s A)
+
+end SLEExactGauge
+
+end
+
+end OAI

lean/OAI/Probability/SLE/Loewner/InitialInverseJointContinuity.lean

@@ -1,51 +1,51 @@
-import OAI.Probability.SLE.Loewner.InitialInverseLimitAt
-
-namespace OAI
-
-/-! Joint continuity of the exact inverse charts in time and an interior
-half-plane coordinate. -/
-noncomputable section
-open Set Filter Function
-open scoped Topology
-
-namespace SLEExactGauge
-
-lemma initialInverse_limit_eq (p : C(unitInterval,ℂ)) (hi : Injective p)
-    (h0 : p 0=0) (hH : ∀ t : unitInterval, t ≠ 0 → p t ∈ upperHalfPlane)
-    {t : ℕ → unitInterval} {F : ℂ → ℂ} (hF : DifferentiableOn ℂ F upperHalfPlane)
-    (hlim : TendstoLocallyUniformlyOn (fun n => initialInverseChart p hi h0 hH (t n))
-      F atTop upperHalfPlane) {s : unitInterval} (ht : Tendsto t atTop (𝓝 s)) :
-    EqOn F (initialInverseChart p hi h0 hH s) upperHalfPlane := by
-  by_cases hs : s=0
-  · subst s
-    intro z hz
-    have hzero := ((initialInverseChart_tendsto_identity p hi h0 hH).tendsto_at hz).comp ht
-    have he : F z=id z := tendsto_nhds_unique (hlim.tendsto_at hz) hzero
-    simpa only [initialInverseChart_zero] using he
-  · exact initialInverse_limit_eq_at p hi h0 hH hF hlim hs ht
-
-theorem initialInverseChart_joint_continuous (p : C(unitInterval,ℂ)) (hi : Injective p)
-    (h0 : p 0=0) (hH : ∀ t : unitInterval, t ≠ 0 → p t ∈ upperHalfPlane) :
-    Continuous (fun a : unitInterval × upperHalfPlane =>
-      initialInverseChart p hi h0 hH a.1 a.2) := by
-  rw [continuous_iff_continuousAt]
-  intro a
-  apply tendsto_of_subseq_tendsto
-  intro v hv
-  have ht : Tendsto (fun n => (v n).1) atTop (𝓝 a.1) :=
-    (continuous_fst.tendsto a).comp hv
-  have hz : Tendsto (fun n => ((v n).2:ℂ)) atTop (𝓝 (a.2:ℂ)) :=
-    ((continuous_subtype_val.comp continuous_snd).tendsto a).comp hv
-  obtain ⟨φ,F,hφ,hF,hlim⟩ := initialInverseChart_subsequence p hi h0 hH (fun n => (v n).1)
-  have he := initialInverse_limit_eq p hi h0 hH hF hlim (ht.comp hφ.tendsto_atTop)
-  have heval := locallyUniform_evaluation_tendsto isOpen_upperHalfPlane hF.continuousOn
-    hlim a.2.property (hz.comp hφ.tendsto_atTop)
-  rw [he a.2.property] at heval
-  refine ⟨φ,?_⟩
-  exact heval
-
-end SLEExactGauge
-
-end
-
-end OAI
+import OAI.Probability.SLE.Loewner.InitialInverseLimitAt
+
+namespace OAI
+
+/-! Joint continuity of the exact inverse charts in time and an interior
+half-plane coordinate. -/
+noncomputable section
+open Set Filter Function
+open scoped Topology
+
+namespace SLEExactGauge
+
+lemma initialInverse_limit_eq (p : C(unitInterval,ℂ)) (hi : Injective p)
+    (h0 : p 0=0) (hH : ∀ t : unitInterval, t ≠ 0 → p t ∈ upperHalfPlane)
+    {t : ℕ → unitInterval} {F : ℂ → ℂ} (hF : DifferentiableOn ℂ F upperHalfPlane)
+    (hlim : TendstoLocallyUniformlyOn (fun n => initialInverseChart p hi h0 hH (t n))
+      F atTop upperHalfPlane) {s : unitInterval} (ht : Tendsto t atTop (𝓝 s)) :
+    EqOn F (initialInverseChart p hi h0 hH s) upperHalfPlane := by
+  by_cases hs : s=0
+  · subst s
+    intro z hz
+    have hzero := ((initialInverseChart_tendsto_identity p hi h0 hH).tendsto_at hz).comp ht
+    have he : F z=id z := tendsto_nhds_unique (hlim.tendsto_at hz) hzero
+    simpa only [initialInverseChart_zero] using he
+  · exact initialInverse_limit_eq_at p hi h0 hH hF hlim hs ht
+
+theorem initialInverseChart_joint_continuous (p : C(unitInterval,ℂ)) (hi : Injective p)
+    (h0 : p 0=0) (hH : ∀ t : unitInterval, t ≠ 0 → p t ∈ upperHalfPlane) :
+    Continuous (fun a : unitInterval × upperHalfPlane =>
+      initialInverseChart p hi h0 hH a.1 a.2) := by
+  rw [continuous_iff_continuousAt]
+  intro a
+  apply tendsto_of_subseq_tendsto
+  intro v hv
+  have ht : Tendsto (fun n => (v n).1) atTop (𝓝 a.1) :=
+    (continuous_fst.tendsto a).comp hv
+  have hz : Tendsto (fun n => ((v n).2:ℂ)) atTop (𝓝 (a.2:ℂ)) :=
+    ((continuous_subtype_val.comp continuous_snd).tendsto a).comp hv
+  obtain ⟨φ,F,hφ,hF,hlim⟩ := initialInverseChart_subsequence p hi h0 hH (fun n => (v n).1)
+  have he := initialInverse_limit_eq p hi h0 hH hF hlim (ht.comp hφ.tendsto_atTop)
+  have heval := locallyUniform_evaluation_tendsto isOpen_upperHalfPlane hF.continuousOn
+    hlim a.2.property (hz.comp hφ.tendsto_atTop)
+  rw [he a.2.property] at heval
+  refine ⟨φ,?_⟩
+  exact heval
+
+end SLEExactGauge
+
+end
+
+end OAI