Add lean source and binary files (part 77)

lean/OAI/Geometry/SurfaceImmersion/Geometry/CompactTranslationStability.lean

@@ -0,0 +1,50 @@
+import OAI.Geometry.SurfaceImmersion.Geometry.RegularZeroStability
+
+namespace OAI
+
+/-! Small scalar-weighted translations preserve compact regular zero sets. -/
+noncomputable section
+open Set Metric
+open scoped ContDiff Topology
+namespace ClosedSurfaceR4.FiniteOrderSmoothing
+variable {E F : Type*} [NormedAddCommGroup E] [NormedSpace ℝ E]
+  [NormedAddCommGroup F] [NormedSpace ℝ F] [FiniteDimensional ℝ F]
+local instance translationScalarNormed : NormedAddCommGroup (E →L[ℝ] ℝ) := inferInstance
+local instance translationScalarSpace : NormedSpace ℝ (E →L[ℝ] ℝ) := inferInstance
+local instance translationTargetNormed : NormedAddCommGroup (E →L[ℝ] F) := inferInstance
+local instance translationTargetSpace : NormedSpace ℝ (E →L[ℝ] F) := inferInstance
+
+theorem compact_translation_stability {f : E → F} {χ : E → ℝ}
+    (hf : ContDiff ℝ ∞ f) (hχ : ContDiff ℝ ∞ χ)
+    {K : Set E} (hK : IsCompact K)
+    (hreg : ∀ x ∈ K, f x = 0 → Function.Surjective (fderiv ℝ f x)) :
+    ∃ δ > 0, ∀ a : F, ‖a‖ < δ → ∀ x ∈ K, f x+χ x • a = 0 →
+      Function.Surjective (fderiv ℝ (fun y => f y+χ y • a) x) := by
+  obtain ⟨ε,hε,hεreg⟩ := compact_regular_zero_stability hf hK hreg
+  obtain ⟨M₀,hM₀⟩ := hK.exists_bound_of_continuousOn hχ.continuous.continuousOn
+  obtain ⟨M₁,hM₁⟩ := hK.exists_bound_of_continuousOn (hχ.continuous_fderiv (by simp)).continuousOn
+  let B := max M₀ (max M₁ 0)+1
+  have hB : 0 < B := by dsimp [B]; have := le_max_right M₀ (max M₁ 0); have := le_max_right M₁ 0; linarith
+  refine ⟨ε/B,div_pos hε hB,?_⟩
+  intro a ha
+  have hab : B*‖a‖ < ε := by
+    simpa only [mul_comm] using (lt_div_iff₀ hB).mp ha
+  apply hεreg (fun y => f y+χ y • a)
+  · intro x hx
+    rw [add_sub_cancel_left,norm_smul]
+    have hχB : ‖χ x‖ ≤ B := (hM₀ x hx).trans (by dsimp [B]; linarith [le_max_left M₀ (max M₁ 0)])
+    exact (mul_le_mul_of_nonneg_right hχB (norm_nonneg a)).trans_lt hab
+  · intro x hx
+    have hd := ((hf.differentiable (by simp) x).hasFDerivAt.add
+      ((hχ.differentiable (by simp) x).hasFDerivAt.smul_const a)).fderiv
+    change ‖fderiv ℝ (f + fun y => χ y • a) x-fderiv ℝ f x‖ < ε
+    rw [hd,add_sub_cancel_left,ContinuousLinearMap.norm_smulRight_apply]
+    have hχB : ‖fderiv ℝ χ x‖ ≤ B := (hM₁ x hx).trans (by
+      dsimp [B]; linarith [le_max_right M₀ (max M₁ 0),le_max_left M₁ 0])
+    exact (mul_le_mul_of_nonneg_right hχB (norm_nonneg a)).trans_lt hab
+
+end ClosedSurfaceR4.FiniteOrderSmoothing
+
+end
+
+end OAI

lean/OAI/Geometry/SurfaceImmersion/Geometry/CompactVaryingFrameTube.lean

@@ -0,0 +1,58 @@
+import OAI.Geometry.SurfaceImmersion.Whitney.VaryingFramedCurveTube
+import Mathlib.Analysis.Calculus.InverseFunctionTheorem.ContDiff
+
+namespace OAI
+
+/-! One transverse radius works for all points of a compact regular
+ segment of the ruled target tube. -/
+noncomputable section
+open Set Filter Matrix
+open scoped ContDiff Topology
+namespace ClosedSurfaceR4.FiniteOrderSmoothing
+open JetPolynomial (Base)
+
+theorem compact_varying_frame_tube {c a : ℝ → (Fin 3 → ℝ)}
+    (hc : ContDiff ℝ ∞ c) (ha : ContDiff ℝ ∞ a) {K : Set ℝ}
+    (hK : IsCompact K) (hne : K.Nonempty)
+    (hv : ∀ t ∈ K, deriv c t ≠ 0) (htrans : ∀ t ∈ K, ∀ r : ℝ, r • deriv c t ≠ a t) :
+    ∃ (r : ℝ) (U : Set ℝ), 0 < r ∧ IsOpen U ∧ K ⊆ U ∧
+      ∀ x : Base, ‖x‖ < r → ∀ t ∈ U,
+        Function.Bijective (fderiv ℝ (varyingFramedCurveTube c a) (x,t)) := by
+  obtain ⟨t₀,ht₀⟩ := hne
+  have hR := varyingFramedCurveTube_regular_axis hc ha (hv t₀ ht₀) (htrans t₀ ht₀)
+  let R : (Base × ℝ) ≃L[ℝ] (Fin 3 → ℝ) :=
+    ContinuousLinearEquiv.ofBijective (fderiv ℝ (varyingFramedCurveTube c a) (0,t₀))
+      (LinearMap.ker_eq_bot.mpr hR.1) (LinearMap.range_eq_top.mpr hR.2)
+  let W : Set (Base × ℝ) :=
+    {z | IsUnit (R.symm.toContinuousLinearMap.comp (fderiv ℝ (varyingFramedCurveTube c a) z))}
+  have hcont : Continuous (fun z =>
+      R.symm.toContinuousLinearMap.comp (fderiv ℝ (varyingFramedCurveTube c a) z)) :=
+    continuous_const.clm_comp ((varyingFramedCurveTube_smooth hc ha).continuous_fderiv (by simp))
+  have hW : IsOpen W := Units.isOpen.preimage hcont
+  have haxis : ({0} : Set Base) ×ˢ K ⊆ W := by
+    rintro ⟨x,t⟩ ⟨hx,ht⟩
+    obtain rfl : x = 0 := hx
+    apply ContinuousLinearMap.isUnit_iff_bijective.mpr
+    exact R.symm.bijective.comp (varyingFramedCurveTube_regular_axis hc ha (hv t ht) (htrans t ht))
+  obtain ⟨V,U,hV,hU,h0V,hKU,hVU⟩ :=
+    generalized_tube_lemma isCompact_singleton hK hW haxis
+  obtain ⟨r,hr,hball⟩ := Metric.isOpen_iff.mp hV 0 (h0V (by simp))
+  refine ⟨r,U,hr,hU,hKU,?_⟩
+  intro x hx t ht
+  have hxV : x ∈ V := hball (by simpa [dist_zero_right] using hx)
+  have hunit : IsUnit (R.symm.toContinuousLinearMap.comp
+      (fderiv ℝ (varyingFramedCurveTube c a) (x,t))) := hVU ⟨hxV,ht⟩
+  have hbij := ContinuousLinearMap.isUnit_iff_bijective.mp hunit
+  have heq : (R : (Base × ℝ) → (Fin 3 → ℝ)) ∘
+      (R.symm.toContinuousLinearMap.comp (fderiv ℝ (varyingFramedCurveTube c a) (x,t))) =
+      fderiv ℝ (varyingFramedCurveTube c a) (x,t) := by
+    funext v
+    exact R.apply_symm_apply _
+  rw [← heq]
+  exact R.bijective.comp hbij
+
+end ClosedSurfaceR4.FiniteOrderSmoothing
+
+end
+
+end OAI

lean/OAI/Geometry/SurfaceImmersion/Geometry/ComplexFirstVariation.lean

@@ -0,0 +1,80 @@
+import OAI.Geometry.SurfaceImmersion.Geometry.ComplexMixedJets
+import OAI.Geometry.SurfaceImmersion.Geometry.ComplexJetDecomposition
+
+namespace OAI
+
+/-! The complex polynomial first variation is exactly the complexification
+of the actual real differential. -/
+noncomputable section
+open scoped ContDiff BigOperators
+
+namespace ClosedSurfaceR4.JetPolynomial
+open MixedExpression
+
+def complexDirectionData (G : Base → Space) (H : Base → Fin 4 → ℂ) : JetData :=
+  Fin.cases (fun w a p => (jet G w a p : ℂ))
+    (fun j w a p => if j = 0 then complexJet H w a p else 0)
+
+lemma evalComplex_sumList {ι : Type*} (l : List ι) (f : ι → MixedExpression)
+    (G : Base → Space) (J : JetData) (z : Base × ℝ) :
+    (sumList l f).evalComplex G J z = (l.map (fun i => (f i).evalComplex G J z)).sum := by
+  induction l with
+  | nil => rfl
+  | cons i l ih => simp only [sumList, evalComplex, List.map_cons, List.sum_cons, ih]
+
+lemma evalComplex_ofExpression (e : Expression) (G : Base → Space)
+    (H : Base → Fin 4 → ℂ) (z : Base × ℝ) :
+    (ofExpression e).evalComplex G (complexDirectionData G H) z = (e.eval G z : ℂ) := by
+  induction e with
+  | coeff c => rfl
+  | atom w a e ih => simp only [ofExpression, evalComplex, complexDirectionData, Fin.cases_zero,
+      ih, Expression.eval, Complex.ofReal_mul]
+  | add e f ihe ihf => simp only [ofExpression, evalComplex, ihe, ihf, Expression.eval, Complex.ofReal_add]
+
+lemma complex_coefficient_variation (c : LowJet × ℝ → ℝ) (G : Base → Space)
+    (H : Base → Fin 4 → ℂ) (z : Base × ℝ) :
+    ((coeff c).differentiate 0).evalComplex G (complexDirectionData G H) z =
+      ∑ i : Fin 7 × Fin 4, complexJet H (lowWord i.1) i.2 z.1 *
+        (coefficientDerivative c i (lowJet G z.1, z.2) : ℂ) := by
+  simp only [differentiate, evalComplex_sumList, evalComplex, complexDirectionData,
+    Fin.cases_succ, ↓reduceIte]
+  exact Finset.sum_map_toList _ _
+
+private lemma complex_sum_decompose {ι : Type*} [Fintype ι] (a b d : ι → ℝ) :
+    (∑ i, ((a i : ℂ) + Complex.I * (b i : ℂ)) * (d i : ℂ)) =
+      (∑ i, a i * d i : ℝ) + Complex.I * (∑ i, b i * d i : ℝ) := by
+  simp only [add_mul, mul_assoc, Finset.sum_add_distrib, ← Finset.mul_sum,
+    ← Complex.ofReal_mul, ← Complex.ofReal_sum]
+
+/-- This identity identifies the algebraic complex evaluation with the
+actual real differential on the real and imaginary parts separately. -/
+theorem complex_first_variation (e : Expression) (G : Base → Space)
+    {H : Base → Fin 4 → ℂ} (hH : ContDiff ℝ ∞ H) (z : Base × ℝ) :
+    ((ofExpression e).differentiate 0).evalComplex G (complexDirectionData G H) z =
+      (e.variation G (realField H) z : ℂ) +
+        Complex.I * (e.variation G (imagField H) z : ℂ) := by
+  induction e with
+  | coeff c =>
+    rw [ofExpression, complex_coefficient_variation]
+    simp_rw [complexJet_decompose hH]
+    rw [complex_sum_decompose]
+    rw [Expression.variation, Expression.variation,
+      coefficient_variation_sum, coefficient_variation_sum]
+    rfl
+  | atom w a e ih =>
+    simp only [ofExpression, differentiate, ↓reduceIte, evalComplex,
+      complexDirectionData, Fin.cases_zero, Fin.cases_succ, evalComplex_ofExpression, ih,
+      Expression.variation]
+    rw [complexJet_decompose hH]
+    push_cast
+    ring
+  | add e f ihe ihf =>
+    simp only [ofExpression, differentiate, evalComplex, ihe, ihf, Expression.variation,
+      Complex.ofReal_add]
+    ring
+
+end ClosedSurfaceR4.JetPolynomial
+
+end
+
+end OAI

lean/OAI/Geometry/SurfaceImmersion/Geometry/ComplexJetDecomposition.lean

@@ -0,0 +1,66 @@
+import OAI.Geometry.SurfaceImmersion.Geometry.JetVariations
+
+namespace OAI
+
+/-! Real and imaginary parts commute with all actual ordered jets. -/
+noncomputable section
+open scoped ContDiff
+
+namespace ClosedSurfaceR4.JetPolynomial
+open WeightedEstimates
+
+lemma directional_clm {A E F : Type*} [NormedAddCommGroup A] [NormedSpace ℝ A]
+    [NormedAddCommGroup E] [NormedSpace ℝ E] [NormedAddCommGroup F] [NormedSpace ℝ F]
+    (L : E →L[ℝ] F) {f : A → E} (hf : ContDiff ℝ ∞ f) (w : List A) :
+    iteratedDirectional w (L ∘ f) = L ∘ iteratedDirectional w f := by
+  induction w with
+  | nil => rfl
+  | cons v w ih =>
+    rw [iteratedDirectional, ih]
+    funext p
+    have hs := contDiffOn_univ.mp (contDiffOn_iteratedDirectional isOpen_univ hf.contDiffOn w)
+    exact congrArg (fun T : A →L[ℝ] F => T v)
+      ((L.hasFDerivAt.comp p (hs.differentiable (by simp) p).hasFDerivAt).fderiv)
+
+def complexJet (H : Base → Fin 4 → ℂ) (w : List (Fin 2)) (a : Fin 4) : Base → ℂ :=
+  iteratedDirectional (w.map coordinateVector) (fun p => H p a)
+
+def realField (H : Base → Fin 4 → ℂ) : Base → Space := fun p a => (H p a).re
+def imagField (H : Base → Fin 4 → ℂ) : Base → Space := fun p a => (H p a).im
+
+lemma realField_smooth {H : Base → Fin 4 → ℂ} (hH : ContDiff ℝ ∞ H) :
+    ContDiff ℝ ∞ (realField H) := by
+  apply contDiff_pi.mpr
+  intro a
+  exact Complex.reCLM.contDiff.comp (contDiff_pi.mp hH a)
+
+lemma imagField_smooth {H : Base → Fin 4 → ℂ} (hH : ContDiff ℝ ∞ H) :
+    ContDiff ℝ ∞ (imagField H) := by
+  apply contDiff_pi.mpr
+  intro a
+  exact Complex.imCLM.contDiff.comp (contDiff_pi.mp hH a)
+
+lemma complexJet_re {H : Base → Fin 4 → ℂ} (hH : ContDiff ℝ ∞ H)
+    (w : List (Fin 2)) (a : Fin 4) (p : Base) :
+    (complexJet H w a p).re = jet (realField H) w a p := by
+  exact (congrFun (directional_clm Complex.reCLM (contDiff_pi.mp hH a)
+    (w.map coordinateVector)) p).symm
+
+lemma complexJet_im {H : Base → Fin 4 → ℂ} (hH : ContDiff ℝ ∞ H)
+    (w : List (Fin 2)) (a : Fin 4) (p : Base) :
+    (complexJet H w a p).im = jet (imagField H) w a p := by
+  exact (congrFun (directional_clm Complex.imCLM (contDiff_pi.mp hH a)
+    (w.map coordinateVector)) p).symm
+
+lemma complexJet_decompose {H : Base → Fin 4 → ℂ} (hH : ContDiff ℝ ∞ H)
+    (w : List (Fin 2)) (a : Fin 4) (p : Base) :
+    complexJet H w a p = (jet (realField H) w a p : ℂ) +
+      Complex.I * (jet (imagField H) w a p : ℂ) := by
+  rw [← complexJet_re hH, ← complexJet_im hH]
+  exact Complex.ext (by simp) (by simp)
+
+end ClosedSurfaceR4.JetPolynomial
+
+end
+
+end OAI

lean/OAI/Geometry/SurfaceImmersion/Geometry/ComplexMixedJets.lean

@@ -0,0 +1,74 @@
+import OAI.Geometry.SurfaceImmersion.Correction.PolynomialVariationScaling
+
+namespace OAI
+
+/-! Complex evaluation of the real polynomial variations, keeping the base
+map fixed and complexifying the direction jets. -/
+noncomputable section
+open scoped ContDiff
+
+namespace ClosedSurfaceR4.JetPolynomial.MixedExpression
+
+abbrev JetData := Fin 4 → List (Fin 2) → Fin 4 → Base → ℂ
+
+def evalComplex : MixedExpression → (Base → Space) → JetData → Base × ℝ → ℂ
+  | .coeff c, G, _, z => (c (lowJet G z.1, z.2) : ℂ)
+  | .atom i w a e, G, J, z => J i w a z.1 * e.evalComplex G J z
+  | .add e f, G, J, z => e.evalComplex G J z + f.evalComplex G J z
+
+def scaleJetSlot (J : JetData) (j : Fin 3) (c : Base → ℂ) : JetData :=
+  fun i w a p => if i = j.succ then c p * J i w a p else J i w a p
+
+lemma DegreeIn.evalComplex_scaleSlot {j : Fin 3} {e : MixedExpression} {n : ℕ}
+    (he : DegreeIn j e n) (G : Base → Space) (J : JetData) (c : Base → ℂ) (z : Base × ℝ) :
+    e.evalComplex G (scaleJetSlot J j c) z = c z.1 ^ n * e.evalComplex G J z := by
+  induction he with
+  | coeff d => simp only [evalComplex, pow_zero, one_mul]
+  | zero n => simp only [evalComplex, Complex.ofReal_zero, mul_zero]
+  | other i w a hi h ih =>
+    simp only [evalComplex, scaleJetSlot, hi, ↓reduceIte, ih]
+    ring
+  | same w a h ih =>
+    simp only [evalComplex, scaleJetSlot, ↓reduceIte, ih, pow_succ]
+    ring
+  | add he hf ihe ihf => simp only [evalComplex, ihe, ihf, mul_add]
+
+def scaleJets (J : JetData) (c : Fin 3 → Base → ℂ) : JetData :=
+  scaleJetSlot (scaleJetSlot (scaleJetSlot J 0 (c 0)) 1 (c 1)) 2 (c 2)
+
+lemma evalComplex_scaleJets {e : MixedExpression} {n : Fin 3 → ℕ}
+    (he : ∀ j, DegreeIn j e (n j)) (G : Base → Space) (J : JetData)
+    (c : Fin 3 → Base → ℂ) (z : Base × ℝ) :
+    e.evalComplex G (scaleJets J c) z =
+      ((c 0 z.1) ^ n 0 * (c 1 z.1) ^ n 1 * (c 2 z.1) ^ n 2) * e.evalComplex G J z := by
+  simp only [scaleJets, (he 2).evalComplex_scaleSlot, (he 1).evalComplex_scaleSlot,
+    (he 0).evalComplex_scaleSlot]
+  ring
+
+lemma evalComplex_smooth {O : Set LowJet} {U : Set Base} {G : Base → Space}
+    (hG : ContDiff ℝ ∞ G) (hQ : Set.MapsTo (lowJet G) U O)
+    {J : JetData} (hJ : ∀ i w a, ContDiffOn ℝ ∞ (J i w a) U)
+    {e : MixedExpression} (he : e.SmoothCoeffs O) :
+    ContDiffOn ℝ ∞ (e.evalComplex G J) (U ×ˢ Set.univ) := by
+  induction e with
+  | coeff c =>
+    exact Complex.ofRealCLM.contDiff.comp_contDiffOn
+      (he.comp (((lowJet_smooth hG).comp contDiff_fst).prodMk contDiff_snd).contDiffOn
+        (fun z hz => ⟨hQ hz.1, hz.2⟩))
+  | atom i w a e ih =>
+    exact ((hJ i w a).comp contDiffOn_fst (fun _ hz => hz.1)).mul (ih he)
+  | add e f ihe ihf => exact (ihe he.1).add (ihf he.2)
+
+lemma evalComplex_parameter_smooth {O : Set LowJet} {U : Set Base} {G : Base → Space}
+    (hG : ContDiff ℝ ∞ G) (hQ : Set.MapsTo (lowJet G) U O)
+    {J : JetData} (hJ : ∀ i w a, ContDiffOn ℝ ∞ (J i w a) U)
+    {e : MixedExpression} (he : e.SmoothCoeffs O) (t : ℝ) :
+    ContDiffOn ℝ ∞ (fun p => e.evalComplex G J (p, t)) U :=
+  (evalComplex_smooth hG hQ hJ he).comp (contDiffOn_id.prodMk contDiffOn_const)
+    (fun _ hp => ⟨hp, Set.mem_univ t⟩)
+
+end ClosedSurfaceR4.JetPolynomial.MixedExpression
+
+end
+
+end OAI

lean/OAI/Geometry/SurfaceImmersion/Geometry/ComplexQuadraticVariation.lean

@@ -0,0 +1,93 @@
+import OAI.Geometry.SurfaceImmersion.Geometry.ComplexSlotAdditivity
+import OAI.Geometry.SurfaceImmersion.Geometry.ComplexFirstVariation
+
+namespace OAI
+
+/-! Actual complexified second polynomial variation, with both direction
+slots and their bilinear algebra made explicit. -/
+noncomputable section
+open scoped ContDiff
+namespace ClosedSurfaceR4.JetPolynomial
+open MixedExpression
+
+abbrev DirectionJets := List (Fin 2) → Fin 4 → Base → ℂ
+
+def pairJetData (G : Base → Space) (J K : DirectionJets) : JetData :=
+  ![fun w a p => (jet G w a p : ℂ), J, K, 0]
+
+def quadraticComplex (e : Expression) (G : Base → Space)
+    (J K : DirectionJets) (z : Base × ℝ) : ℂ :=
+  (e.variations 1).evalComplex G (pairJetData G J K) z
+
+lemma quadraticComplex_add_left (e : Expression) (G : Base → Space)
+    (J K L : DirectionJets) (z : Base × ℝ) :
+    quadraticComplex e G (J + K) L z = quadraticComplex e G J L z + quadraticComplex e G K L z := by
+  apply DegreeIn.evalComplex_add (j := 0)
+    (show DegreeIn 0 (e.variations 1) 1 by simpa using e.variations_degree 1 0)
+  · intro i hi w a
+    fin_cases i <;> simp_all [pairJetData]
+  · intro i hi w a
+    fin_cases i <;> simp_all [pairJetData]
+  · intro w a
+    rfl
+
+lemma quadraticComplex_add_right (e : Expression) (G : Base → Space)
+    (J K L : DirectionJets) (z : Base × ℝ) :
+    quadraticComplex e G J (K + L) z = quadraticComplex e G J K z + quadraticComplex e G J L z := by
+  apply DegreeIn.evalComplex_add (j := 1)
+    (show DegreeIn 1 (e.variations 1) 1 by simpa using e.variations_degree 1 1)
+  · intro i hi w a
+    fin_cases i <;> simp_all [pairJetData]
+  · intro i hi w a
+    fin_cases i <;> simp_all [pairJetData]
+  · intro w a
+    rfl
+
+lemma quadraticComplex_smul_left (e : Expression) (G : Base → Space)
+    (J K : DirectionJets) (c : ℂ) (z : Base × ℝ) :
+    quadraticComplex e G (c • J) K z = c * quadraticComplex e G J K z := by
+  have hh := (show DegreeIn 0 (e.variations 1) 1 by simpa using e.variations_degree 1 0).evalComplex_scaleSlot
+    G (pairJetData G J K) (fun _ => c) z
+  have he : scaleJetSlot (pairJetData G J K) 0 (fun _ => c) = pairJetData G (c • J) K := by
+    funext i w a p
+    fin_cases i <;> simp [scaleJetSlot, pairJetData]
+  rw [he, pow_one] at hh
+  exact hh
+
+lemma quadraticComplex_smul_right (e : Expression) (G : Base → Space)
+    (J K : DirectionJets) (c : ℂ) (z : Base × ℝ) :
+    quadraticComplex e G J (c • K) z = c * quadraticComplex e G J K z := by
+  have hh := (show DegreeIn 1 (e.variations 1) 1 by simpa using e.variations_degree 1 1).evalComplex_scaleSlot
+    G (pairJetData G J K) (fun _ => c) z
+  have he : scaleJetSlot (pairJetData G J K) 1 (fun _ => c) = pairJetData G J (c • K) := by
+    funext i w a p
+    fin_cases i <;> simp [scaleJetSlot, pairJetData]
+  rw [he, pow_one] at hh
+  exact hh
+
+def starDirectionJets (J : DirectionJets) : DirectionJets := fun w a p => star (J w a p)
+
+lemma evalComplex_star (e : MixedExpression) (G : Base → Space) (J : JetData) (z : Base × ℝ) :
+    e.evalComplex G (fun i w a p => star (J i w a p)) z = star (e.evalComplex G J z) := by
+  induction e with
+  | coeff c => simp only [evalComplex, Complex.star_def, Complex.conj_ofReal]
+  | atom i w a e ih => simp only [evalComplex, ih, star_mul']
+  | add e f ihe ihf => simp only [evalComplex, ihe, ihf, star_add]
+
+lemma quadraticComplex_star (e : Expression) (G : Base → Space)
+    (J K : DirectionJets) (z : Base × ℝ) :
+    quadraticComplex e G (starDirectionJets J) (starDirectionJets K) z =
+      star (quadraticComplex e G J K z) := by
+  have he : pairJetData G (starDirectionJets J) (starDirectionJets K) =
+      fun i w a p => star (pairJetData G J K i w a p) := by
+    funext i w a p
+    fin_cases i <;> simp [pairJetData, starDirectionJets]
+  change (e.variations 1).evalComplex G _ z = _
+  rw [he]
+  exact evalComplex_star (e.variations 1) G (pairJetData G J K) z
+
+end ClosedSurfaceR4.JetPolynomial
+
+end
+
+end OAI

lean/OAI/Geometry/SurfaceImmersion/Geometry/ComplexSlotAdditivity.lean

@@ -0,0 +1,69 @@
+import OAI.Geometry.SurfaceImmersion.Geometry.ComplexMixedJets
+
+namespace OAI
+
+/-! Additivity in each degree-one complex direction slot of the actual
+mixed polynomial variation. -/
+noncomputable section
+namespace ClosedSurfaceR4.JetPolynomial.MixedExpression
+
+private theorem degree_addition {j : Fin 3} {e : MixedExpression} {n : ℕ}
+    (he : DegreeIn j e n) (G : Base → Space) (J₁ J₂ J₃ : JetData) (z : Base × ℝ)
+    (h₂ : ∀ i, i ≠ j.succ → ∀ w a, J₂ i w a z.1 = J₁ i w a z.1)
+    (h₃ : ∀ i, i ≠ j.succ → ∀ w a, J₃ i w a z.1 = J₁ i w a z.1)
+    (hadd : ∀ w a, J₃ j.succ w a z.1 = J₁ j.succ w a z.1 + J₂ j.succ w a z.1) :
+    (n = 0 → e.evalComplex G J₁ z = e.evalComplex G J₂ z ∧
+      e.evalComplex G J₃ z = e.evalComplex G J₁ z) ∧
+    (n = 1 → e.evalComplex G J₃ z = e.evalComplex G J₁ z + e.evalComplex G J₂ z) := by
+  induction he with
+  | coeff c =>
+    constructor
+    · intro _; exact ⟨rfl, rfl⟩
+    · intro hn; omega
+  | zero k => simp [evalComplex]
+  | other i w a hi h ih =>
+    constructor
+    · intro hn
+      obtain ⟨h12, h31⟩ := ih.1 hn
+      simp only [evalComplex, h₂ i hi, h₃ i hi, h12, h31, and_self]
+    · intro hn
+      simp only [evalComplex, h₂ i hi, h₃ i hi, ih.2 hn, mul_add]
+  | @same e k w a h ih =>
+    constructor
+    · intro hn; omega
+    · intro hn
+      have hk : k = 0 := by omega
+      obtain ⟨h12, h31⟩ := ih.1 hk
+      simp only [evalComplex, hadd, h31, ← h12, add_mul]
+  | add he hf ihe ihf =>
+    constructor
+    · intro hn
+      obtain ⟨he12, he31⟩ := ihe.1 hn
+      obtain ⟨hf12, hf31⟩ := ihf.1 hn
+      simp only [evalComplex, he12, he31, hf12, hf31, and_self]
+    · intro hn
+      simp only [evalComplex, ihe.2 hn, ihf.2 hn]
+      ring
+
+theorem DegreeIn.evalComplex_add {j : Fin 3} {e : MixedExpression}
+    (he : DegreeIn j e 1) (G : Base → Space) (J₁ J₂ J₃ : JetData) (z : Base × ℝ)
+    (h₂ : ∀ i, i ≠ j.succ → ∀ w a, J₂ i w a z.1 = J₁ i w a z.1)
+    (h₃ : ∀ i, i ≠ j.succ → ∀ w a, J₃ i w a z.1 = J₁ i w a z.1)
+    (hadd : ∀ w a, J₃ j.succ w a z.1 = J₁ j.succ w a z.1 + J₂ j.succ w a z.1) :
+    e.evalComplex G J₃ z = e.evalComplex G J₁ z + e.evalComplex G J₂ z :=
+  (degree_addition he G J₁ J₂ J₃ z h₂ h₃ hadd).2 rfl
+
+theorem DegreeIn.evalComplex_independent {j : Fin 3} {e : MixedExpression}
+    (he : DegreeIn j e 0) (G : Base → Space) (J₁ J₂ : JetData) (z : Base × ℝ)
+    (h₂ : ∀ i, i ≠ j.succ → ∀ w a, J₂ i w a z.1 = J₁ i w a z.1) :
+    e.evalComplex G J₁ z = e.evalComplex G J₂ z := by
+  let J₃ : JetData := fun i w a p => if i = j.succ then J₁ i w a p + J₂ i w a p else J₁ i w a p
+  exact ((degree_addition he G J₁ J₂ J₃ z h₂
+    (fun i hi w a => by simp only [J₃, hi, ↓reduceIte])
+    (fun w a => by simp only [J₃, ↓reduceIte])).1 rfl).1
+
+end ClosedSurfaceR4.JetPolynomial.MixedExpression
+
+end
+
+end OAI

lean/OAI/Geometry/SurfaceImmersion/Geometry/ConditionalMain.lean

@@ -0,0 +1,146 @@
+import OAI.Geometry.SurfaceImmersion.Geometry.UniformCorrectedTermC1
+import OAI.Geometry.SurfaceImmersion.Geometry.ReferenceBoundaryStartingFamily
+import OAI.Geometry.SurfaceImmersion.Geometry.UniformScaledPathBounds
+import OAI.Geometry.SurfaceImmersion.Geometry.CycleCorrectedGeometry
+import OAI.Geometry.SurfaceImmersion.Primitive.IndependentCircularRealization
+import OAI.Geometry.SurfaceImmersion.Whitney.WhitneyStartingGeometry
+
+namespace OAI
+
+/-! Smooth isometric immersions constructed from spherical immersions,
+and from the compact surface case of Whitney (1944), Theorem 8, p.274. -/
+noncomputable section
+open Set Manifold
+open scoped ContDiff Topology
+namespace ClosedSurfaceR4.FiniteOrderSmoothing
+variable {M : Type*} [TopologicalSpace M] [ChartedSpace Plane M]
+  [IsManifold planeModel ∞ M] [CompactSpace M] [T2Space M] [SecondCountableTopology M]
+local instance mainFiberNormed : NormedAddCommGroup TensorFiber := inferInstance
+local instance mainFiberSpace : NormedSpace ℝ TensorFiber := inferInstance
+local instance mainDualAdd : ∀ p : M, ContinuousAdd (TangentSpace planeModel p →L[ℝ] ℝ) :=
+  fun _ => inferInstanceAs (ContinuousAdd (Plane →L[ℝ] ℝ))
+local instance mainDualSmul : ∀ p : M, ContinuousSMul ℝ (TangentSpace planeModel p →L[ℝ] ℝ) :=
+  fun _ => inferInstanceAs (ContinuousSMul ℝ (Plane →L[ℝ] ℝ))
+local instance mainSectionNormed (p : M) : NormedAddCommGroup (CovariantTwoTensor p) :=
+  inferInstanceAs (NormedAddCommGroup TensorFiber)
+local instance mainSectionSpace (p : M) : NormedSpace ℝ (CovariantTwoTensor p) :=
+  inferInstanceAs (NormedSpace ℝ TensorFiber)
+
+omit [SecondCountableTopology M] in
+/-- The construction starting from a smooth unit spherical immersion. All
+primitive amplitudes and the starting scale are chosen uniformly before
+selecting the finite crossings. -/
+theorem isometric_immersion_of_spherical_immersion (g : SmoothMetric M)
+    {I : M → Space} (hI : ContMDiff planeModel spaceModel ∞ I)
+    (hunit : ∀ p, ‖I p‖ = 1)
+    (hImm : ∀ p, Function.Injective (mfderiv planeModel spaceModel I p)) :
+    ∃ W : M → Space, IsSmoothIsometricImmersion M g W := by
+  classical
+  obtain ⟨A⟩ := exists_smoothingAtlas (M := M)
+  obtain ⟨r,D,c,hr,hr1,hD,hc,_hIb,_hIm,hIs,hstart⟩ :=
+    A.reference_circular_starting_family g hI hunit hImm zero_lt_one
+  let gref := A.shortRemainderMetric g (space_smul_contMDiff hI r) hIs
+  have href : gref.inner = g.inner-inducedTensor (r • I) := rfl
+  obtain ⟨C,hC,hpath⟩ := A.uniform_scaled_path_bound g r hD
+  obtain ⟨d⟩ := A.exists_reference_circular_atlas gref g hc (show 0 ≤ C+1 by linarith)
+  obtain ⟨pt,wt,mt,hpt,hwt,hmt,hterm⟩ := d.uniform_corrected_term_C1 hI r href hD
+  let m := Fintype.card (d.B.centers × Fin 3)
+  let e : Fin m ≃ (d.B.centers × Fin 3) := (Fintype.equivFin _).symm
+  obtain ⟨mapTol,delta,W,hmapTol,hmapLe,_hdelta,_hdeltaR,hW,hcycles⟩ :=
+    d.corrected_cycles hI r href hpt hwt hmt e
+  obtain ⟨E,hE,hterms⟩ := hterm (W 1) (hW 1)
+  obtain ⟨N,hN,hrealize⟩ := A.independent_circular_realization g c C d.B
+    d.radius d.L (fun i => ‖(d.P i).ξ‖+1) d.L_pos d.region
+    d.weight_nonneg d.weight_positive d.convex m E hE
+  obtain ⟨q,hindex,houter,_hchart,hpart,hell,hphase,hweights,hweightClose,hcorrect⟩ :=
+    hcycles N hN
+  obtain ⟨G,g₀,normal,hG,_hu,hG₀,hg₀,⟨good⟩,_hn,hnear,hGb,hlower,_hgm,hshort,hgeom⟩ :=
+    hstart (N*m) d.B q mapTol hmapTol
+  obtain ⟨f,dCirc,hamp,hphi,hcurves,_hrad,_houter',_hchart',hlinear,hconvex,hcycle,hcyclePhase,_htotal⟩ :=
+    hcorrect G hG hnear
+  have hnear' : A.WeightedBound 1 1 mt (G-I) :=
+    fun i => (hnear i).mono_const hmapLe
+  have hcopy (k : Fin N) (b : d.B.centers × Fin 3) :
+      (finProdFinEquiv (k,e.symm b)).divNat = k ∧
+        e (finProdFinEquiv (k,e.symm b)).modNat = b := by
+    have hh := Prod.mk.inj (finProdFinEquiv.symm_apply_apply (k,e.symm b))
+    exact ⟨hh.1,by rw [hh.2,e.apply_symm_apply]⟩
+  have hell' (k : Fin N) (i : d.B.centers) (j : Fin 3) :
+      ‖d.cycleLinearParts e q k i j-(d.P i).ξ j‖ < pt := by
+    have h := hphase (finProdFinEquiv (k,e.symm (i,j)))
+    simpa only [ReferenceCircularAtlas.cycleLinearParts,
+      (hcopy k (i,j)).2] using h
+  have htermBound (k : Fin N) (a : Fin m) :
+      A.TensorWeightedBound 1 1 E ((f k).term a) := by
+    let f' := (f k).reindex e.symm
+    have hp' : f'.phase = d.perturbedPhases (d.cycleLinearParts e q k) := by
+      funext b
+      exact (hphi k (e.symm b)).trans (congrArg _ (e.apply_symm_apply b))
+    have ha' : f'.amplitude = d.B.correctedPrimitiveAmplitude d.basis
+        (d.cycleWeights e q k) (d.perturbedPhases (d.cycleLinearParts e q k))
+        (g.inner-inducedTensor (r • G)) := by
+      funext b
+      exact (hamp k (e.symm b)).trans (congrArg _ (e.apply_symm_apply b))
+    have hnon (b : d.B.centers × Fin 3) :
+        ContMDiff planeModel 𝓘(ℝ) ∞ (d.cycleWeights e q k b) := by
+      let a : Fin (N*m) := finProdFinEquiv (k,e.symm b)
+      have hh : e a.modNat = b := (hcopy k b).2
+      have hrsmall : (q.radius a)^2 < (d.radius b.1)^2 := by
+        have hrpos := q.radius_pos a
+        have hro := q.radius_outer a
+        rw [houter a,hh] at hro
+        nlinarith [d.radius_pos b.1]
+      exact (shrinkingCircularWeight_smooth (b.1 : M) (d.B.weight b.1)
+        (d.B.weight_smooth b.1) (d.region b.1) hrsmall).1
+    have hsupp (b : d.B.centers × Fin 3) :
+        tsupport (d.cycleWeights e q k b) ⊆ tsupport (d.B.weight b.1) := by
+      apply closure_mono
+      intro p hp
+      change d.cycleWeights e q k b p ≠ 0 at hp
+      change d.B.weight b.1 p ≠ 0
+      intro hz
+      exact hp (by simp only [ReferenceCircularAtlas.cycleWeights,shrinkingCircularWeight,hz,zero_mul])
+    have hb := hterms (d.cycleLinearParts e q k) (d.cycleWeights e q k) (hell' k)
+      hnon hsupp (hweightClose k) (fun b => hweights k b 1) G hG hnear' hGb f' hp' ha' (e a)
+    change A.TensorWeightedBound 1 1 E ((f k).term (e.symm (e a))) at hb
+    simpa only [e.symm_apply_apply] using hb
+  have hshort' : ∀ p v, inducedForm (r • G) p v v ≤ (1/2 : ℝ)*g.inner p v v := by
+    intro p v
+    change inducedTensor (r • G) p v v ≤ _
+    rw [← hg₀]
+    exact hshort p v
+  have hpBound (k : Fin N) : A.TensorWeightedBound 1 1 C
+      (g₀.inner+((k.val : ℝ)/(N : ℝ)) • (g.inner-inducedTensor (r • G))) := by
+    rw [hg₀]
+    exact hpath G hG hGb (hG₀.mfderiv_injective) hshort' _
+      (div_nonneg (Nat.cast_nonneg _) (Nat.cast_nonneg _))
+      ((div_le_one (by exact_mod_cast hN)).mpr (by exact_mod_cast k.isLt.le))
+  have hcv (a : Fin (N*m)) : dCirc.convexPart a = d.L (dCirc.curves a).index := by
+    rw [hconvex,hpart,hcurves,hindex]
+  have hlin (a : Fin (N*m)) : ‖dCirc.linearPart a‖ ≤ ‖(d.P (dCirc.curves a).index).ξ‖+1 := by
+    rw [hlinear,hcurves,hindex]
+    exact hell a
+  have htarget : g.inner = g₀.inner+(g.inner-inducedTensor (r • G)) := by
+    rw [hg₀]
+    abel
+  have hgeom' : FiniteBoundaryGeometry dCirc.curves
+      (boundaryCrossingSet dCirc.curves univ) (r • G) normal := by
+    rw [hcurves]
+    exact hgeom
+  obtain ⟨F,hF,_hgood⟩ := hrealize g₀ hlower _ f htermBound hpBound dCirc
+    hcycle hcyclePhase hcv hlin g htarget (r • G) normal hG₀ good hgeom'
+  exact ⟨F,hF⟩
+
+/-- Main theorem of paper 094-01. The sole published hypothesis is Whitney
+(1944), Theorem 8, p.274, specialized to a closed smooth surface. -/
+theorem smooth_isometric_immersion_conditional (g : SmoothMetric M)
+    (hW : PublishedInputs.WhitneySurfaceInput M) :
+    ∃ F : M → Space, IsSmoothIsometricImmersion M g F := by
+  obtain ⟨I,hI,hunit,hImm,_⟩ := metricPhaseData_of_whitney g hW
+  exact isometric_immersion_of_spherical_immersion g hI hunit hImm
+
+end ClosedSurfaceR4.FiniteOrderSmoothing
+
+end
+
+end OAI

lean/OAI/Geometry/SurfaceImmersion/Geometry/ConjugatedMultilinearBounds.lean

@@ -0,0 +1,74 @@
+import OAI.Geometry.SurfaceImmersion.Geometry.ModulatedJetScaling
+
+namespace OAI
+
+/-! The conjugated polynomial estimates retain the product of the input
+amplitude bounds. -/
+noncomputable section
+open scoped ContDiff
+
+namespace ClosedSurfaceR4.JetPolynomial.ModulatedJets
+open WeightedEstimates MixedExpression
+
+/-- Product estimate corresponding to the fixed-power perturbation bound
+in the small-modes argument. No output-order or accuracy dependence is
+hidden in the short-scale exponent. -/
+theorem compact_conjugated_multilinear_bound {U : Set Base} {O K : Set LowJet}
+    (hU : IsOpen U) (hO : IsOpen O) (hK : IsCompact K) (hKO : K ⊆ O)
+    (e : Expression) (he : e.SmoothCoeffs O) (m : ℕ) (B P : ℝ) (hB : 1 ≤ B) (hP : 0 ≤ P) :
+    ∃ D : ℝ, 0 ≤ D ∧ ∀ (G : Base → Space) (φ : Fin 3 → Base → ℝ)
+      (H : DirectionFields) (s τ : ℝ) (C : Fin 3 → ℝ),
+      0 < τ → 0 < s → τ ≤ s → s ≤ 1 → (∀ j, 0 < C j) →
+      ContDiff ℝ ∞ G → (∀ j, ContDiff ℝ ∞ (φ j)) → (∀ j, ContDiff ℝ ∞ (H j)) →
+      Set.MapsTo (lowJet G) U K →
+      WeightedBound U s (m + e.order) B (lowJet G) →
+      (∀ j, WeightedBound U s (m + e.order) (C j) (H j)) →
+      (∀ j v, WeightedBound U s (m + e.order) P
+        (fun p => fderiv ℝ (φ j) p (coordinateVector v))) →
+      ∀ t ∈ Set.Icc (0 : ℝ) 1, ∀ i : Fin 3,
+        WeightedBound U s m
+          (D * (C 0 * (if 1 ≤ i then C 1 else 1) * (if 2 ≤ i then C 2 else 1)) /
+            τ ^ (e.loss + 6)) (fun p => conjugatedVariation e G φ H τ i (p, t)) := by
+  obtain ⟨D, hD, hb⟩ := compact_conjugated_variation_bound hU hO hK hKO e he m B P hB hP
+  refine ⟨D, hD, ?_⟩
+  intro G φ H s τ C hτ hs hτs hs1 hC hG hφ hH hGK hGb hHb hφb t ht i
+  let V := scaleDirections H (fun j => (C j)⁻¹)
+  have hV := scaleDirections_smooth hH (fun j => (C j)⁻¹)
+  have hunit : ∀ j, WeightedBound U s (m + e.order) 1 (V j) := by
+    intro j
+    have h := (hHb j).const_smul hU.uniqueDiffOn (hH j).contDiffOn (C j)⁻¹
+    change WeightedBound U s (m + e.order) 1 (fun p => (C j)⁻¹ • H j p)
+    simpa only [abs_of_pos (inv_pos.mpr (hC j)),
+      inv_mul_cancel₀ (ne_of_gt (hC j))] using h
+  have hbound := hb G φ V s τ hτ hs hτs hs1 hG hφ hV hGK hGb hunit hφb t ht i
+  let W : ℝ := C 0 * (if 1 ≤ i then C 1 else 1) * (if 2 ≤ i then C 2 else 1)
+  have hW : 0 < W := by
+    have h₀ := hC 0
+    have h₁ := hC 1
+    have h₂ := hC 2
+    dsimp only [W]
+    split_ifs <;> positivity
+  have heq : (fun p => conjugatedVariation e G φ H τ i (p, t)) =
+      (fun p => W • conjugatedVariation e G φ V τ i (p, t)) := by
+    funext p
+    have h := conjugatedVariation_scale e G hφ hV τ C i (p, t)
+    rw [scaleDirections_inverse H C (fun j => ne_of_gt (hC j))] at h
+    exact h
+  rw [heq]
+  have hsmooth : ContDiffOn ℝ ∞ (fun p => conjugatedVariation e G φ V τ i (p, t)) U := by
+    have h := evalComplex_parameter_smooth hG (fun p hp => hKO (hGK hp))
+      (fun j w a => (amplitudeData_smooth hG hφ hV τ j w a).contDiffOn)
+      (e := e.variations i) (e.variations_smoothCoeffs hO he i) t
+    convert h using 1
+    funext p
+    exact conjugatedVariation_eq e G hφ hV τ i (p, t)
+  have h := hbound.const_smul hU.uniqueDiffOn hsmooth W
+  convert h using 1
+  rw [abs_of_pos hW]
+  ring
+
+end ClosedSurfaceR4.JetPolynomial.ModulatedJets
+
+end
+
+end OAI

lean/OAI/Geometry/SurfaceImmersion/Geometry/ConjugatedOperatorBounds.lean

@@ -0,0 +1,94 @@
+import OAI.Geometry.SurfaceImmersion.Correction.ConjugatedPolynomialOperator
+
+namespace OAI
+
+/-! The fixed-loss conjugated estimate for the actual supported linear map. -/
+noncomputable section
+open TopologicalSpace
+open scoped ContDiff NNReal
+
+namespace ClosedSurfaceR4.JetPolynomial
+open WeightedEstimates MixedExpression ModulatedJets
+
+lemma supportedField_eq_zero_of_seminorm_eq_zero {F : Type*} [NormedAddCommGroup F]
+    [NormedSpace ℝ F] {K : Compacts Base} (s : ℝ≥0) (m : ℕ)
+    {f : SupportedField (F := F) K} (hf : supportedWeightedSeminorm K s m f = 0) : f = 0 := by
+  apply DFunLike.ext
+  intro p
+  have h := (weightedBound_of_supportedSeminorm s m f).norm_le (Set.mem_univ p)
+  rw [hf] at h
+  exact norm_eq_zero.mp (le_antisymm h (norm_nonneg _))
+
+namespace Expression
+
+theorem conjugatedVariationLM_bound {U : Set Base} {O Q : Set LowJet}
+    (hU : IsOpen U) (hO : IsOpen O) (hQcompact : IsCompact Q) (hQO : Q ⊆ O)
+    (e : Expression) (he : e.SmoothCoeffs O) (K : Compacts Base)
+    (hKU : (K : Set Base) ⊆ U) (m : ℕ) (B P : ℝ) (hB : 1 ≤ B) (hP : 0 ≤ P) :
+    ∃ D : ℝ, 0 ≤ D ∧ ∀ (G : Base → Space) (φ : Base → ℝ)
+      (hG : ContDiff ℝ ∞ G) (hφ : ContDiff ℝ ∞ φ)
+      (hGQ : Set.MapsTo (lowJet G) U Q) (s : ℝ≥0) (τ : ℝ),
+      0 < τ → 0 < (s : ℝ) → τ ≤ s → s ≤ 1 →
+      WeightedBound U s (m + e.order) B (lowJet G) →
+      (∀ v, WeightedBound U s (m + e.order) P
+        (fun p => fderiv ℝ φ p (coordinateVector v))) →
+      ∀ t ∈ Set.Icc (0 : ℝ) 1, ∀ H : SupportedField (F := Fin 4 → ℂ) K,
+        supportedWeightedSeminorm K s m
+          (conjugatedVariationLM hO hU he hG (fun _ hp => hQO (hGQ hp)) K hKU hφ τ t H) ≤
+        D / τ ^ (e.loss + 6) * supportedWeightedSeminorm K s (m + e.order) H := by
+  obtain ⟨D, hD, hd⟩ := compact_conjugated_multilinear_bound hU hO hQcompact hQO e he m B P hB hP
+  refine ⟨D, hD, ?_⟩
+  intro G φ hG hφ hGQ s τ hτ hs hτs hs1 hGb hφb t ht H
+  let C := supportedWeightedSeminorm K s (m + e.order) H
+  have hC : 0 ≤ C := apply_nonneg _ _
+  by_cases hC0 : C = 0
+  · have hH0 : H = 0 := supportedField_eq_zero_of_seminorm_eq_zero s (m + e.order) hC0
+    simp only [hH0, map_zero, mul_zero, le_refl]
+  · have hCpos : 0 < C := lt_of_le_of_ne hC (Ne.symm hC0)
+    have hCs : ∀ j : Fin 3, 0 < (![C, 1, 1] j) := by
+      intro j
+      fin_cases j <;> simp [hCpos]
+    have hHb : ∀ j, WeightedBound U s (m + e.order) (![C, 1, 1] j) (singleDirection H j) := by
+      intro j
+      fin_cases j
+      · exact (weightedBound_of_supportedSeminorm s (m + e.order) H).restrict_open hU
+      · exact (weightedBound_zero U s (m + e.order)).mono_const zero_le_one
+      · exact (weightedBound_zero U s (m + e.order)).mono_const zero_le_one
+    have hΦb : ∀ j v, WeightedBound U s (m + e.order) P
+        (fun p => fderiv ℝ (singlePhase φ j) p (coordinateVector v)) := by
+      intro j v
+      fin_cases j
+      · exact hφb v
+      · change WeightedBound U s (m + e.order) P
+          (fun p => fderiv ℝ (fun _ : Base => (0 : ℝ)) p (coordinateVector v))
+        simpa only [fderiv_fun_const, Pi.zero_apply, zero_apply] using
+          (weightedBound_zero U s (m + e.order) (F := ℝ)).mono_const hP
+      · change WeightedBound U s (m + e.order) P
+          (fun p => fderiv ℝ (fun _ : Base => (0 : ℝ)) p (coordinateVector v))
+        simpa only [fderiv_fun_const, Pi.zero_apply, zero_apply] using
+          (weightedBound_zero U s (m + e.order) (F := ℝ)).mono_const hP
+    have hv := hd G (singlePhase φ) (singleDirection H) s τ ![C, 1, 1]
+      hτ hs hτs hs1 hCs hG (singlePhase_smooth hφ) (singleDirection_smooth H.contDiff)
+      hGQ hGb hHb hΦb t ht 0
+    have hl : WeightedBound U s m (D * C / τ ^ (e.loss + 6))
+        (conjugatedVariationLM hO hU he hG (fun _ hp => hQO (hGQ hp)) K hKU hφ τ t H) := by
+      apply (show WeightedBound U s m (D * C / τ ^ (e.loss + 6))
+        (fun p => conjugatedVariation e G (singlePhase φ) (singleDirection H) τ 0 (p, t)) by
+          simpa using hv).congr
+      intro p _
+      exact conjugatedVariationLM_apply hO hU he hG (fun _ hp => hQO (hGQ hp)) K hKU hφ τ t H p
+    have hg := hl.extend_support hU
+      ((conjugatedVariationLM hO hU he hG (fun _ hp => hQO (hGQ hp)) K hKU hφ τ t H).tsupport_subset.trans hKU)
+      (by positivity)
+    have hn := supportedSeminorm_le_of_weightedBound hs (show 0 ≤ D * C / τ ^ (e.loss + 6) by positivity)
+      (conjugatedVariationLM hO hU he hG (fun _ hp => hQO (hGQ hp)) K hKU hφ τ t H) hg
+    convert hn using 1
+    dsimp only [C]
+    ring
+
+end Expression
+end ClosedSurfaceR4.JetPolynomial
+
+end
+
+end OAI

lean/OAI/Geometry/SurfaceImmersion/Geometry/ConjugatedVariationBounds.lean

@@ -0,0 +1,85 @@
+import OAI.Geometry.SurfaceImmersion.Geometry.ModulatedJetDataBounds
+
+namespace OAI
+
+/-! Sharp slow-scale estimates for the first three conjugated polynomial
+variations. The power E+6 is independent of correction accuracy and order. -/
+noncomputable section
+open scoped ContDiff BigOperators
+
+namespace ClosedSurfaceR4.JetPolynomial.ModulatedJets
+open WeightedEstimates MixedExpression
+
+def phaseProduct (φ : Fin 3 → Base → ℝ) (τ : ℝ) (i : Fin 3) (p : Base) : ℂ :=
+  phase τ (φ 0) p * (if 1 ≤ i then phase τ (φ 1) p else 1) *
+    (if 2 ≤ i then phase τ (φ 2) p else 1)
+
+lemma phaseProduct_ne_zero (φ : Fin 3 → Base → ℝ) (τ : ℝ) (i : Fin 3) (p : Base) :
+    phaseProduct φ τ i p ≠ 0 := by
+  have h (j : Fin 3) : phase τ (φ j) p ≠ 0 := Complex.exp_ne_zero _
+  apply mul_ne_zero
+  · exact mul_ne_zero (h 0) (by split_ifs; exact h 1; exact one_ne_zero)
+  · split_ifs
+    · exact h 2
+    · exact one_ne_zero
+
+def conjugatedVariation (e : Expression) (G : Base → Space)
+    (φ : Fin 3 → Base → ℝ) (H : DirectionFields) (τ : ℝ) (i : Fin 3) (z : Base × ℝ) : ℂ :=
+  (phaseProduct φ τ i z.1)⁻¹ * (e.variations i).evalComplex G (oscillatoryData G φ H τ) z
+
+lemma conjugatedVariation_eq (e : Expression) (G : Base → Space) {φ : Fin 3 → Base → ℝ}
+    {H : DirectionFields} (hφ : ∀ j, ContDiff ℝ ∞ (φ j))
+    (hH : ∀ j, ContDiff ℝ ∞ (H j)) (τ : ℝ) (i : Fin 3) (z : Base × ℝ) :
+    conjugatedVariation e G φ H τ i z =
+      (e.variations i).evalComplex G (amplitudeData G φ H τ) z := by
+  rw [conjugatedVariation, variation_phase_factor e G hφ hH τ z i]
+  change (phaseProduct φ τ i z.1)⁻¹ *
+    (phaseProduct φ τ i z.1 * (e.variations i).evalComplex G (amplitudeData G φ H τ) z) = _
+  rw [← mul_assoc, inv_mul_cancel₀ (phaseProduct_ne_zero φ τ i z.1), one_mul]
+
+/-- Unit amplitude bounds give the sharp exponent for every first, second,
+and third variation after removing all participating phase factors. -/
+theorem compact_conjugated_variation_bound {U : Set Base} {O K : Set LowJet}
+    (hU : IsOpen U) (hO : IsOpen O) (hK : IsCompact K) (hKO : K ⊆ O)
+    (e : Expression) (he : e.SmoothCoeffs O) (m : ℕ) (B P : ℝ) (hB : 1 ≤ B) (hP : 0 ≤ P) :
+    ∃ D : ℝ, 0 ≤ D ∧ ∀ (G : Base → Space) (φ : Fin 3 → Base → ℝ)
+      (H : DirectionFields) (s τ : ℝ),
+      0 < τ → 0 < s → τ ≤ s → s ≤ 1 →
+      ContDiff ℝ ∞ G → (∀ j, ContDiff ℝ ∞ (φ j)) → (∀ j, ContDiff ℝ ∞ (H j)) →
+      Set.MapsTo (lowJet G) U K →
+      WeightedBound U s (m + e.order) B (lowJet G) →
+      (∀ j, WeightedBound U s (m + e.order) 1 (H j)) →
+      (∀ j v, WeightedBound U s (m + e.order) P
+        (fun p => fderiv ℝ (φ j) p (coordinateVector v))) →
+      ∀ t ∈ Set.Icc (0 : ℝ) 1, ∀ i : Fin 3,
+        WeightedBound U s m (D / τ ^ (e.loss + 6))
+          (fun p => conjugatedVariation e G φ H τ i (p, t)) := by
+  classical
+  let A := amplitudeBudget e.order m B P
+  have hA : 1 ≤ A := amplitudeBudget_ge_one (zero_le_one.trans hB) hP
+  have hex := fun i : Fin 3 => compact_complex_mixed_bound hU hO hK hKO (e.variations i)
+    (e.variations_smoothCoeffs hO he i) m A hA
+  choose D hD hb using hex
+  refine ⟨∑ i, D i, Finset.sum_nonneg (fun i _ => hD i), ?_⟩
+  intro G φ H s τ hτ hs hτs hs1 hG hφ hH hGK hGb hHb hφb t ht i
+  have hdata := weighted_amplitudeData hU hG hφ hH hτ hs hτs (zero_le_one.trans hB) hP
+    m e.order hGb hHb hφb
+  have h := hb i G (amplitudeData G φ H τ) s τ hs hτ (hτs.trans hs1) hG hGK
+    ((hGb.mono_order (by omega)).mono_const (le_amplitudeBudget hP))
+    (fun j w a => (amplitudeData_smooth hG hφ hH τ j w a).contDiffOn)
+    (fun j w a hw => hdata j w a (hw.trans (e.variations_order i))) t ht
+  have hbound : D i / τ ^ (e.variations i).loss ≤ (∑ j, D j) / τ ^ (e.loss + 6) := by
+    calc
+      _ ≤ D i / τ ^ (e.loss + 6) := div_le_div_of_nonneg_left (hD i) (pow_pos hτ _)
+        (pow_le_pow_of_le_one hτ.le (hτs.trans hs1) (e.variations_loss i))
+      _ ≤ _ := div_le_div_of_nonneg_right
+        (Finset.single_le_sum (fun j _ => hD j) (Finset.mem_univ i)) (pow_nonneg hτ.le _)
+  apply (h.mono_const hbound).congr
+  intro p _
+  exact conjugatedVariation_eq e G hφ hH τ i (p, t)
+
+end ClosedSurfaceR4.JetPolynomial.ModulatedJets
+
+end
+
+end OAI

lean/OAI/Geometry/SurfaceImmersion/Geometry/ConnectedOpenPieces.lean

@@ -0,0 +1,37 @@
+import OAI.Geometry.SurfaceImmersion.Geometry.SubarcTopology
+
+namespace OAI
+
+/-! Connected open pieces with frontier in a deleted vertex set either
+coincide or are disjoint. -/
+noncomputable section
+open Set
+namespace ClosedSurfaceR4.FiniteOrderSmoothing
+variable {X : Type*} [TopologicalSpace X]
+
+theorem connected_open_pieces_equal_or_disjoint
+    {S T V : Set X} (hSo : IsOpen S) (hTo : IsOpen T)
+    (hSc : IsPreconnected S) (hTc : IsPreconnected T)
+    (hSb : closure S \ S ⊆ V) (hTb : closure T \ T ⊆ V)
+    (hSV : Disjoint S V) (hTV : Disjoint T V) : S = T ∨ Disjoint S T := by
+  by_cases hd : Disjoint S T
+  · exact Or.inr hd
+  left
+  have hi : (S ∩ T).Nonempty := not_disjoint_iff_nonempty_inter.mp hd
+  have hTS : T ⊆ S := hTc.subset_of_closure_inter_subset hSo (by simpa only [inter_comm] using hi)
+    (by
+      intro x hx
+      by_contra hn
+      exact disjoint_left.mp hTV hx.2 (hSb ⟨hx.1,hn⟩))
+  have hST : S ⊆ T := hSc.subset_of_closure_inter_subset hTo hi
+    (by
+      intro x hx
+      by_contra hn
+      exact disjoint_left.mp hSV hx.2 (hTb ⟨hx.1,hn⟩))
+  exact Subset.antisymm hST hTS
+
+end ClosedSurfaceR4.FiniteOrderSmoothing
+
+end
+
+end OAI

lean/OAI/Geometry/SurfaceImmersion/Geometry/ConstantNormBoundaryGeometry.lean

@@ -0,0 +1,88 @@
+import OAI.Geometry.SurfaceImmersion.Atlas.SphericalMetricPhaseData
+import OAI.Geometry.SurfaceImmersion.Geometry.RealMetricDerivatives
+import OAI.Geometry.SurfaceImmersion.Geometry.NormalInterpolation
+import OAI.Geometry.SurfaceImmersion.Primitive.VelocityCoordinateData
+
+namespace OAI
+
+/-! The initial inward normal has a strictly positive pairing with every
+nonzero directional second form, at every point of a constant-radius sphere. -/
+noncomputable section
+open Set Filter
+open scoped ContDiff Matrix Topology
+namespace ClosedSurfaceR4.RealModes
+open SmallModes NormalFrame VelocityFrame
+
+lemma constant_norm_radial_first {F : RField 4} {R : ℝ} {x : Base}
+    (hF : DifferentiableAt ℝ F x) (hR : ∀ y, F y ⬝ᵥ F y = R) (v : Base) :
+    F x ⬝ᵥ coordDeriv v F x = 0 := by
+  have he : (fun y => F y ⬝ᵥ F y) = fun _ => R := funext hR
+  have hd : coordDeriv v (fun y => F y ⬝ᵥ F y) x = 0 := by
+    rw [he]
+    simp [coordDeriv]
+  rw [real_partial_dot hF hF,dotProduct_comm (coordDeriv v F x) (F x)] at hd
+  linarith
+
+lemma constant_norm_radial_second {F : RField 4} {U : Set Base} {R : ℝ}
+    (hU : IsOpen U) (hF : ContDiffOn ℝ ∞ F U) (hR : ∀ y, F y ⬝ᵥ F y = R)
+    {x : Base} (hx : x ∈ U) (v w : Base) :
+    F x ⬝ᵥ coordDeriv v (coordDeriv w F) x =
+      -(coordDeriv v F x ⬝ᵥ coordDeriv w F x) := by
+  have hFx := (hF x hx).contDiffAt (hU.mem_nhds hx)
+  have he : (fun y => F y ⬝ᵥ coordDeriv w F y) =ᶠ[𝓝 x] (fun _ => (0 : ℝ)) := by
+    filter_upwards [hU.mem_nhds hx] with y hy
+    exact constant_norm_radial_first
+      (((hF y hy).contDiffAt (hU.mem_nhds hy)).differentiableAt (by simp)) hR w
+  have hd : coordDeriv v (fun y => F y ⬝ᵥ coordDeriv w F y) x = 0 := by
+    change fderiv ℝ _ x v = 0
+    rw [he.fderiv_eq]
+    simp
+  rw [real_partial_dot (hFx.differentiableAt (by simp))
+    ((contDiffAt_coordDeriv hFx w).differentiableAt (by simp))] at hd
+  linarith
+
+lemma constant_norm_secondForm_inward {F : RField 4} {U : Set Base} {R : ℝ}
+    (hU : IsOpen U) (hF : ContDiffOn ℝ ∞ F U) (hR : ∀ y, F y ⬝ᵥ F y = R)
+    {x : Base} (hx : x ∈ U) (v w : Base) :
+    realSecondForm F v w x ⬝ᵥ (-F x) = coordDeriv v F x ⬝ᵥ coordDeriv w F x := by
+  have hFx := ((hF x hx).contDiffAt (hU.mem_nhds hx)).differentiableAt (by simp)
+  have hX : coordDeriv dx F x ⬝ᵥ (-F x) = 0 := by
+    rw [dotProduct_neg,dotProduct_comm,constant_norm_radial_first hFx hR,neg_zero]
+  have hY : coordDeriv dy F x ⬝ᵥ (-F x) = 0 := by
+    rw [dotProduct_neg,dotProduct_comm,constant_norm_radial_first hFx hR,neg_zero]
+  unfold realSecondForm realNormalPart
+  simp only [sub_dotProduct,smul_dotProduct,smul_eq_mul,hX,hY,mul_zero,sub_zero]
+  rw [dotProduct_neg,dotProduct_comm,constant_norm_radial_second hU hF hR hx,neg_neg]
+
+lemma positive_pairing_excludes_antipode {X n : Vec} (hp : 0 < X ⬝ᵥ n) :
+    X ≠ 0 ∧ normalize X ≠ -n := by
+  have hn : X ≠ 0 := by
+    intro hz
+    rw [hz,zero_dotProduct] at hp
+    exact lt_irrefl _ hp
+  refine ⟨hn,?_⟩
+  intro he
+  have hs := dot_normalize_self hn
+  rw [he,dotProduct_neg] at hs
+  linarith [Real.sqrt_nonneg (X ⬝ᵥ X)]
+
+theorem constant_norm_boundary_geometry {F : RField 4} {U : Set Base} {R r : ℝ}
+    (hU : IsOpen U) (hF : ContDiffOn ℝ ∞ F U) (hR : ∀ y, F y ⬝ᵥ F y = R)
+    (hr : 0 < r) {x : Base} (hx : x ∈ U)
+    (hI : Function.Injective (fderiv ℝ F x)) {v : Base} (hv : v ≠ 0) :
+    0 < realSecondForm F v v x ⬝ᵥ (r⁻¹ • (-F x)) ∧
+    realSecondForm F v v x ≠ 0 ∧
+    normalize (realSecondForm F v v x) ≠ -(r⁻¹ • (-F x)) := by
+  have hd : coordDeriv v F x ≠ 0 := by
+    intro hz
+    exact hv (hI (by simpa only [coordDeriv,map_zero] using hz))
+  have hp : 0 < realSecondForm F v v x ⬝ᵥ (r⁻¹ • (-F x)) := by
+    rw [dotProduct_smul,constant_norm_secondForm_inward hU hF hR hx]
+    exact mul_pos (inv_pos.mpr hr) (dot_self_pos hd)
+  exact ⟨hp,positive_pairing_excludes_antipode hp⟩
+
+end ClosedSurfaceR4.RealModes
+
+end
+
+end OAI

lean/OAI/Geometry/SurfaceImmersion/Geometry/ConvexDerivativeInjectivity.lean

@@ -0,0 +1,57 @@
+import OAI.Geometry.SurfaceImmersion.Geometry.CompactTranslationImmersion
+import Mathlib.Analysis.Calculus.MeanValue
+
+namespace OAI
+
+/-! A fixed strict derivative bound excludes distinct coincidences on a
+convex coordinate neighborhood. -/
+noncomputable section
+open Set Metric
+open scoped ContDiff Topology
+namespace ClosedSurfaceR4.FiniteOrderSmoothing
+open JetPolynomial (Base)
+
+theorem convex_injective_of_derivative_close
+    {f : Base → ProjectionTarget 3} {L : Base →L[ℝ] ProjectionTarget 3}
+    {K : NNReal} (hK : 0 < K) (hL : AntilipschitzWith K L)
+    {S : Set Base} (hS : Convex ℝ S)
+    (hf : ∀ x ∈ S, DifferentiableAt ℝ f x)
+    (hclose : ∀ x ∈ S, ‖fderiv ℝ f x-L‖ ≤ 1/(2*(K:ℝ))) :
+    Set.InjOn f S := by
+  intro x hx y hy he
+  have hb := hS.norm_image_sub_le_of_norm_fderiv_le' hf hclose hx hy
+  have hl := ZeroHomClass.bound_of_antilipschitz L hL (y-x)
+  rw [he,sub_self,zero_sub,norm_neg] at hb
+  have hKr : 0 < (K:ℝ) := hK
+  have hnum : (K:ℝ)*(1/(2*(K:ℝ))) = 1/2 := by field_simp [ne_of_gt hKr]
+  have hnorm : ‖y-x‖ ≤ (1/2)*‖y-x‖ := by
+    calc
+      ‖y-x‖ ≤ (K:ℝ)*‖L (y-x)‖ := hl
+      _ ≤ (K:ℝ)*((1/(2*(K:ℝ)))*‖y-x‖) := mul_le_mul_of_nonneg_left hb hKr.le
+      _ = (1/2)*‖y-x‖ := by rw [← mul_assoc,hnum]
+  have hz : y-x = 0 := norm_eq_zero.mp (by linarith [norm_nonneg (y-x)])
+  exact (sub_eq_zero.mp hz).symm
+
+theorem exists_injective_coordinate_ball {f : Base → ProjectionTarget 3}
+    (hf : ContDiff ℝ ∞ f) {x : Base} (hi : Function.Injective (fderiv ℝ f x)) :
+    ∃ K : NNReal, 0 < K ∧ AntilipschitzWith K (fderiv ℝ f x) ∧
+      ∃ r : ℝ, 0 < r ∧ ∀ y ∈ closedBall x r,
+        ‖fderiv ℝ f y-fderiv ℝ f x‖ < 1/(4*(K:ℝ)) := by
+  obtain ⟨K,hK,hL⟩ := (fderiv ℝ f x).toLinearMap.exists_antilipschitzWith
+    (LinearMap.ker_eq_bot.mpr hi)
+  have hp : 0 < 1/(4*(K:ℝ)) := by positivity
+  have hn : ∀ᶠ y in 𝓝 x, ‖fderiv ℝ f y-fderiv ℝ f x‖ < 1/(4*(K:ℝ)) :=
+    by
+      simpa only [dist_eq_norm] using
+        (Metric.tendsto_nhds.mp (hf.continuous_fderiv (by simp)).continuousAt) _ hp
+  obtain ⟨r,hr,hrn⟩ := Metric.mem_nhds_iff.mp hn
+  refine ⟨K,hK,hL,r/2,half_pos hr,?_⟩
+  intro y hy
+  apply hrn
+  exact (closedBall_subset_ball (by linarith : r/2 < r)) hy
+
+end ClosedSurfaceR4.FiniteOrderSmoothing
+
+end
+
+end OAI

lean/OAI/Geometry/SurfaceImmersion/Geometry/ConvolutionDerivativeBounds.lean

@@ -0,0 +1,55 @@
+import OAI.Geometry.SurfaceImmersion.Correction.SmoothingDerivativeBounds
+
+namespace OAI
+
+/-! Differentiating the compact kernel gives derivative gains without using
+uncontrolled derivatives of the input. -/
+noncomputable section
+open scoped ContDiff Convolution
+
+universe u v w
+namespace ClosedSurfaceR4.FiniteOrderSmoothing
+open MeasureTheory ContinuousLinearMap
+open JetPolynomial (Base)
+
+variable {E : Type u} {F : Type v} {H : Type w} [NormedAddCommGroup E] [NormedSpace ℝ E]
+  [NormedAddCommGroup F] [NormedSpace ℝ F] [NormedAddCommGroup H] [NormedSpace ℝ H]
+
+/-- All derivatives may be placed on the compactly supported kernel. -/
+theorem convolution_iterated_norm_le (L : E →L[ℝ] F →L[ℝ] H) (n : ℕ)
+    {f : Base → E} (hf : ContDiff ℝ ∞ f) (hfc : HasCompactSupport f)
+    {g : Base → F} (hg : Continuous g) {C : ℝ} (hb : ∀ x, ‖g x‖ ≤ C) (x : Base) :
+    ‖iteratedFDeriv ℝ n (f ⋆[L, volume] g) x‖ ≤
+      ‖L‖ * (∫ y, ‖iteratedFDeriv ℝ n f y‖) * C := by
+  have hC : 0 ≤ C := (norm_nonneg (g 0)).trans (hb 0)
+  induction n generalizing E H with
+  | zero =>
+    simp only [norm_iteratedFDeriv_zero]
+    have hi := (hf.continuous.integrable_of_hasCompactSupport (μ := volume) hfc).norm
+    change ‖∫ y, L (f y) (g (x - y))‖ ≤ _
+    calc
+      _ ≤ ∫ y, ‖L‖ * ‖f y‖ * C := by
+        apply norm_integral_le_of_norm_le ((hi.const_mul ‖L‖).mul_const C)
+        exact Filter.Eventually.of_forall fun y =>
+          (L.le_opNorm₂ _ _).trans (mul_le_mul_of_nonneg_left (hb (x - y))
+            (mul_nonneg (norm_nonneg L) (norm_nonneg (f y))))
+      _ = _ := by rw [integral_mul_const, integral_const_mul]
+  | succ n ih =>
+    rw [← norm_iteratedFDeriv_fderiv]
+    have heq : fderiv ℝ (f ⋆[L, volume] g) =
+        (fderiv ℝ f ⋆[L.precompL Base, volume] g) := by
+      funext y
+      exact (hfc.hasFDerivAt_convolution_left L (hf.of_le (by simp)) hg.locallyIntegrable y).fderiv
+    rw [heq]
+    have h := ih (L.precompL Base) (hf.fderiv_right (m := ∞) (by simp))
+      (hfc.fderiv ℝ)
+    simp_rw [norm_iteratedFDeriv_fderiv] at h
+    apply h.trans
+    gcongr
+    exact L.norm_precompL_le Base
+
+end ClosedSurfaceR4.FiniteOrderSmoothing
+
+end
+
+end OAI

lean/OAI/Geometry/SurfaceImmersion/Geometry/CorrectedNormalSeed.lean

@@ -0,0 +1,75 @@
+import OAI.Geometry.SurfaceImmersion.Correction.UniformFreeModeConstants
+import OAI.Geometry.SurfaceImmersion.Geometry.NormalizedPerturbedDifference
+
+namespace OAI
+
+/-! Explicit size and difference budgets for the actual corrected normal seed. -/
+noncomputable section
+open TopologicalSpace
+open scoped ContDiff NNReal
+namespace ClosedSurfaceR4.RealModes
+open SmallModes WeightedEstimates
+open JetPolynomial (SupportedField supportedWeightedSeminorm)
+
+variable {F : RField 4} {U : Set Base}
+
+def correctedNormalSeed (δ τ : ℝ) (hF : ContDiff ℝ ∞ F) (h : RealModeDomain F U)
+    (K : Compacts Base) (hKU : (K : Set Base) ⊆ U)
+    (R : SupportedField (F := Ambient 4) K →ₗ[ℝ] SupportedField (F := Fin 3 → ℂ) K)
+    (q : ℕ) (b : SupportedField (F := ℝ) K) : SupportedField (F := Ambient 4) K :=
+  perturbedFreeLM τ (contDiff_complexify hF) (h.complexDomain hF) K hKU R q
+    (supportedFreeSeed δ τ hF h K hKU b)
+
+def correctedSeedBudget (L : ℕ) (B D : ℕ → ℝ) (q m : ℕ) (N : ℝ) : ℝ :=
+  (1 + freeModeBudget 4 L B D q m) *
+    (Real.sqrt 2 * 2 ^ (m + (q + 1) * (L + 1)) * N)
+
+lemma correctedSeedBudget_nonneg (L : ℕ) (B D : ℕ → ℝ) (hB : ∀ m, 0 ≤ B m)
+    (q m : ℕ) {N : ℝ} (hN : 0 ≤ N) : 0 ≤ correctedSeedBudget L B D q m N := by
+  have h := freeModeBudget_nonneg 4 L B D hB q m
+  dsimp only [correctedSeedBudget]
+  positivity
+
+lemma correctedNormalSeed_sub (δ τ : ℝ) (hF : ContDiff ℝ ∞ F) (h : RealModeDomain F U)
+    (K : Compacts Base) (hKU : (K : Set Base) ⊆ U)
+    (R : SupportedField (F := Ambient 4) K →ₗ[ℝ] SupportedField (F := Fin 3 → ℂ) K)
+    (q : ℕ) (b c : SupportedField (F := ℝ) K) :
+    correctedNormalSeed δ τ hF h K hKU R q (b - c) =
+      correctedNormalSeed δ τ hF h K hKU R q b - correctedNormalSeed δ τ hF h K hKU R q c := by
+  simp only [correctedNormalSeed, supportedFreeSeed_sub, map_sub]
+
+theorem correctedNormalSeed_bound (δ τ : ℝ) (hF : ContDiff ℝ ∞ F) (h : RealModeDomain F U)
+    (K : Compacts Base) (hKU : (K : Set Base) ⊆ U) {s : ℝ≥0} {ε : ℝ} {p L : ℕ}
+    (hδ : 0 ≤ δ) (hτ : 0 < τ) (hs : 0 < (s : ℝ)) (hτs : τ ≤ s) (hs1 : s ≤ 1) (hε : 0 ≤ ε)
+    (hsmall : τ / s + ε / τ ^ p ≤ 1)
+    (B D : ℕ → ℝ) (hB : ∀ m, 0 ≤ B m) (hD : ∀ m, 0 ≤ D m)
+    (hc : ∀ m, ReconstructionCoefficientBound (fun p => complexify (F p)) U s (m + 1) (B m))
+    (R : SupportedField (F := Ambient 4) K →ₗ[ℝ] SupportedField (F := Fin 3 → ℂ) K)
+    (hR : ∀ m Z, supportedWeightedSeminorm K s m (R Z) ≤
+      ε / τ ^ p * D m * supportedWeightedSeminorm K s (m + L) Z)
+    (q m : ℕ) (A N : ℝ) (hA : 0 ≤ A) (hN : 0 ≤ N)
+    (hbN : WeightedBound U s (m + (q + 1) * (L + 1)) N (freeNormal F))
+    (b : SupportedField (F := ℝ) K)
+    (hb : supportedWeightedSeminorm K s (m + (q + 1) * (L + 1)) b ≤ A) :
+    supportedWeightedSeminorm K s m (correctedNormalSeed δ τ hF h K hKU R q b) ≤
+      correctedSeedBudget L B D q m N * A * (δ * τ) := by
+  have hv := supportedFreeSeed_bound hF h K hKU b hδ hτ.le hs hA hN
+    (m + (q + 1) * (L + 1)) hb hbN
+  have ht := freeModeBudget_size (contDiff_complexify hF) (h.complexDomain hF)
+    K hKU hτ hs hτs hs1 hε hsmall B D hB hD hc R hR q m
+    (supportedFreeSeed δ τ hF h K hKU b) (supportedFreeSeed_isFree δ τ hF h K hKU b)
+  have hbudget := freeModeBudget_nonneg 4 L B D hB q m
+  calc
+    _ ≤ (1 + freeModeBudget 4 L B D q m) *
+        supportedWeightedSeminorm K s (m + (q + 1) * (L + 1))
+          (supportedFreeSeed δ τ hF h K hKU b) := ht
+    _ ≤ (1 + freeModeBudget 4 L B D q m) *
+        ((Real.sqrt 2 * 2 ^ (m + (q + 1) * (L + 1)) * A * N) * (δ * τ)) :=
+      mul_le_mul_of_nonneg_left hv (by positivity)
+    _ = _ := by dsimp only [correctedSeedBudget]; ring
+
+end ClosedSurfaceR4.RealModes
+
+end
+
+end OAI

lean/OAI/Geometry/SurfaceImmersion/Geometry/CovarianceParameter.lean

@@ -0,0 +1,229 @@
+import OAI.Geometry.SurfaceImmersion.Correction.CovarianceCorrector
+
+namespace OAI
+
+/-!
+Smooth parameter dependence of the actual finite covariance solve.  Averaging
+is a bounded linear map on continuous periodic functions; the covariance is
+a quadratic map on that Banach space.  Thus no regularity assumption on the
+inverse matrix is needed.
+-/
+
+noncomputable section
+
+open MeasureTheory
+open scoped ContDiff
+
+namespace ClosedSurfaceR4.CovarianceCorrector
+
+section PeriodicMaps
+
+variable {E F G : Type*}
+  [NormedAddCommGroup E] [NormedSpace ℝ E]
+  [NormedAddCommGroup F] [NormedSpace ℝ F]
+  [NormedAddCommGroup G] [NormedSpace ℝ G]
+
+/-- Apply a continuous bilinear map pointwise to continuous periodic maps. -/
+def periodicBilinear (B : E →L[ℝ] F →L[ℝ] G) :
+    C(Period, E) →L[ℝ] C(Period, F) →L[ℝ] C(Period, G) := by
+  let b : C(Period, E) → C(Period, F) → C(Period, G) := fun f g =>
+    ⟨fun t => B (f t) (g t), (B.continuous.comp f.continuous).clm_apply g.continuous⟩
+  let L : C(Period, E) →ₗ[ℝ] C(Period, F) →ₗ[ℝ] C(Period, G) :=
+    LinearMap.mk₂ ℝ b
+      (by intros; ext; simp [b, map_add])
+      (by intros; ext; simp [b, map_smul])
+      (by intros; ext; simp [b, map_add])
+      (by intros; ext; simp [b, map_smul])
+  exact L.mkContinuous₂ ‖B‖ (by
+    intro f g
+    apply (ContinuousMap.norm_le _ (by positivity)).mpr
+    intro t
+    exact (B.le_opNorm₂ (f t) (g t)).trans (by
+      gcongr
+      · exact f.norm_coe_le_norm t
+      · exact g.norm_coe_le_norm t))
+
+@[simp] theorem periodicBilinear_apply (B : E →L[ℝ] F →L[ℝ] G)
+    (f : C(Period, E)) (g : C(Period, F)) (t : Period) :
+    periodicBilinear B f g t = B (f t) (g t) := rfl
+
+variable [CompleteSpace E]
+
+/-- The normalized Haar average, bundled with its norm bound. -/
+def averageCLM : C(Period, E) →L[ℝ] E :=
+  ({ toFun := fun f => ∫ t, f t ∂AddCircle.haarAddCircle
+     map_add' := fun f g => integral_add
+       (integrable_of_continuous f.continuous) (integrable_of_continuous g.continuous)
+     map_smul' := fun c f => integral_smul c f } : C(Period, E) →ₗ[ℝ] E).mkContinuous
+    1 (by
+      intro f
+      have h := norm_integral_le_of_norm_le_const
+        (μ := AddCircle.haarAddCircle) (f := fun t => f t)
+        (Filter.Eventually.of_forall f.norm_coe_le_norm)
+      simpa using h)
+
+omit [CompleteSpace E] in
+@[simp] theorem averageCLM_apply (f : C(Period, E)) :
+    averageCLM f = ∫ t, f t ∂AddCircle.haarAddCircle := rfl
+
+def centeredPeriodic (V : C(Period, E)) : C(Period, E) :=
+  V - ContinuousMap.const Period (averageCLM V)
+
+omit [CompleteSpace E] in
+theorem contDiff_centeredPeriodic : ContDiff ℝ ∞ (centeredPeriodic : C(Period, E) → _) := by
+  let L : E →L[ℝ] C(Period, E) := ContinuousLinearMap.const ℝ Period
+  exact contDiff_id.sub (L.contDiff.comp (averageCLM (E := E)).contDiff)
+
+end PeriodicMaps
+
+variable {E P : Type*} [NormedAddCommGroup E] [InnerProductSpace ℝ E]
+  [CompleteSpace E] [FiniteDimensional ℝ E]
+  [NormedAddCommGroup P] [NormedSpace ℝ P]
+
+/-- The covariance as a quadratic expression in a continuous periodic map. -/
+def covarianceCLM (V : C(Period, E)) : E →L[ℝ] E :=
+  averageCLM (periodicBilinear (InnerProductSpace.rankOne ℝ)
+    (centeredPeriodic V) (centeredPeriodic V))
+
+omit [CompleteSpace E] [FiniteDimensional ℝ E] in
+theorem covarianceCLM_apply (V : C(Period, E)) (m : E) :
+    covarianceCLM V m = covariance V (average V) m := by
+  unfold covarianceCLM
+  rw [averageCLM_apply]
+  change (∫ t, periodicBilinear (InnerProductSpace.rankOne ℝ)
+    (centeredPeriodic V) (centeredPeriodic V) t ∂AddCircle.haarAddCircle) m = _
+  rw [ContinuousLinearMap.integral_apply (integrable_of_continuous
+    (periodicBilinear (InnerProductSpace.rankOne ℝ)
+      (centeredPeriodic V) (centeredPeriodic V)).continuous)]
+  rfl
+
+omit [CompleteSpace E] in
+theorem contDiff_covarianceCLM : ContDiff ℝ ∞ (covarianceCLM : C(Period, E) → _) := by
+  rw [contDiff_clm_apply_iff]
+  intro m
+  let L : C(Period, E) →L[ℝ] C(Period, ℝ) :=
+    (innerSL ℝ m).compLeftContinuous ℝ Period
+  let B : C(Period, ℝ) →L[ℝ] C(Period, E) →L[ℝ] C(Period, E) :=
+    periodicBilinear (ContinuousLinearMap.lsmul ℝ ℝ)
+  have hB := B.isBoundedBilinearMap.contDiff.comp
+    ((L.contDiff.comp contDiff_centeredPeriodic).prodMk contDiff_centeredPeriodic)
+  have hh := averageCLM.contDiff.comp hB
+  convert hh using 1
+  ext V
+  rw [covarianceCLM_apply]
+  change (∫ t, inner ℝ (V t - average V) m • (V t - average V)
+    ∂AddCircle.haarAddCircle) =
+    ∫ t, inner ℝ m (V t - average V) • (V t - average V) ∂AddCircle.haarAddCircle
+  congr 1
+  funext t
+  rw [real_inner_comm]
+
+def meanCLM (V : C(Period, E)) (q : ℝ) : E →L[ℝ] E :=
+  ContinuousLinearMap.id ℝ E - q⁻¹ • covarianceCLM V
+
+omit [CompleteSpace E] [FiniteDimensional ℝ E] in
+theorem meanCLM_apply (V : C(Period, E)) (q : ℝ) (m : E) :
+    meanCLM V q m = m - q⁻¹ ��� covariance V (average V) m := by
+  simp only [meanCLM, sub_apply, ContinuousLinearMap.id_apply,
+    smul_apply, covarianceCLM_apply]
+
+theorem meanCLM_isInvertible {V : C(Period, E)} {q : ℝ} (hq : 0 < q)
+    (hcircle : ∀ t, inner ℝ (V t) (V t) = q) : (meanCLM V q).IsInvertible := by
+  have hinj : Function.Injective (meanCLM V q) := by
+    intro m n he
+    apply sub_eq_zero.mp
+    apply meanOperator_kernel_trivial V.continuous rfl hq hcircle
+    change (m - n) - q⁻¹ • covariance V (average V) (m - n) = 0
+    rw [← meanCLM_apply, map_sub, he, sub_self]
+  have hsurj : Function.Surjective (meanCLM V q) :=
+    LinearMap.surjective_of_injective (f := (meanCLM V q).toLinearMap) hinj
+  refine ⟨(LinearEquiv.ofBijective (meanCLM V q).toLinearMap ⟨hinj, hsurj⟩).toContinuousLinearEquiv, ?_⟩
+  rfl
+
+def weightedAverage (V : C(Period, E)) (r : C(Period, ℝ)) : E :=
+  averageCLM (periodicBilinear (ContinuousLinearMap.lsmul ℝ ℝ) r V)
+
+omit [CompleteSpace E] [FiniteDimensional ℝ E] in
+@[simp] theorem weightedAverage_apply (V : C(Period, E)) (r : C(Period, ℝ)) :
+    weightedAverage V r = average (fun t => r t • V t) := rfl
+
+def covarianceSolution (V : C(Period, E)) (r : C(Period, ℝ)) (q : ℝ) : E :=
+  (meanCLM V q).inverse (weightedAverage V r)
+
+theorem covarianceSolution_equation {V : C(Period, E)} (r : C(Period, ℝ))
+    {q : ℝ} (hq : 0 < q) (hcircle : ∀ t, inner ℝ (V t) (V t) = q) :
+    covarianceSolution V r q - q⁻¹ • covariance V (average V) (covarianceSolution V r q) =
+      average (fun t => r t • V t) := by
+  rw [← meanCLM_apply]
+  exact (meanCLM_isInvertible hq hcircle).self_apply_inverse _
+
+theorem contDiff_covarianceSolution {V : P → C(Period, E)} {r : P → C(Period, ℝ)}
+    {q : P → ℝ} (hV : ContDiff ℝ ∞ V) (hr : ContDiff ℝ ∞ r)
+    (hq : ContDiff ℝ ∞ q) (hqpos : ∀ x, 0 < q x)
+    (hcircle : ∀ x t, inner ℝ (V x t) (V x t) = q x) :
+    ContDiff ℝ ∞ (fun x => covarianceSolution (V x) (r x) (q x)) := by
+  have hM : ContDiff ℝ ∞ (fun x => meanCLM (V x) (q x)) :=
+    contDiff_const.sub ((hq.inv (fun x => (hqpos x).ne')).smul
+      (contDiff_covarianceCLM.comp hV))
+  have hMinv : ContDiff ℝ ∞ (fun x => (meanCLM (V x) (q x)).inverse) := by
+    rw [contDiff_iff_contDiffAt]
+    intro x
+    exact (meanCLM_isInvertible (hqpos x) (hcircle x)).contDiffAt_map_inverse.comp x hM.contDiffAt
+  have hsource : ContDiff ℝ ∞ (fun x => weightedAverage (V x) (r x)) :=
+    by
+      let B : C(Period, ℝ) →L[ℝ] C(Period, E) →L[ℝ] C(Period, E) :=
+        periodicBilinear (ContinuousLinearMap.lsmul ℝ ℝ)
+      exact averageCLM.contDiff.comp (B.isBoundedBilinearMap.contDiff.comp (hr.prodMk hV))
+  exact hMinv.clm_apply hsource
+
+def parameterCorrector (V : P → C(Period, E)) (r : P → C(Period, ℝ))
+    (q : P → ℝ) (x : P) : Period → E :=
+  correctedVector (V x) (average (V x)) (q x) (r x)
+    (covarianceSolution (V x) (r x) (q x))
+
+omit [NormedAddCommGroup P] [NormedSpace ℝ P] in
+theorem parameterCorrector_average {V : P → C(Period, E)} {r : P → C(Period, ℝ)}
+    {q : P → ℝ} (hqpos : ∀ x, 0 < q x)
+    (hcircle : ∀ x t, inner ℝ (V x t) (V x t) = q x) (x : P) :
+    average (parameterCorrector V r q x) = 0 :=
+  average_correctedVector (V x).continuous rfl (r x).continuous (q x)
+    (covarianceSolution (V x) (r x) (q x))
+    (covarianceSolution_equation (r x) (hqpos x) (hcircle x))
+
+omit [CompleteSpace E] [FiniteDimensional ℝ E] [NormedAddCommGroup P] [NormedSpace ℝ P] in
+theorem parameterCorrector_projection {V : P → C(Period, E)} {r : P → C(Period, ℝ)}
+    {q : P → ℝ} (hr0 : ∀ x, average (r x) = 0) (hqpos : ∀ x, 0 < q x)
+    (hcircle : ∀ x t, inner ℝ (V x t) (V x t) = q x) (x : P) :
+    fluctuation (fun t => inner ℝ (V x t) (parameterCorrector V r q x t)) = r x :=
+  corrected_projection (V x) (average (V x)) (r x).continuous (hr0 x)
+    (hqpos x).ne' (hcircle x) _
+
+/-- Smoothness in both the finite-dimensional parameters and the angular
+variable. The Banach-space hypotheses ensure uniform parameter smoothness;
+the real-lift hypotheses provide angular smoothness and mixed derivatives. -/
+theorem contDiff_parameterCorrector {V : P → C(Period, E)} {r : P → C(Period, ℝ)}
+    {q : P → ℝ} (hV : ContDiff ℝ ∞ V) (hr : ContDiff ℝ ∞ r)
+    (hq : ContDiff ℝ ∞ q) (hqpos : ∀ x, 0 < q x)
+    (hcircle : ∀ x t, inner ℝ (V x t) (V x t) = q x)
+    (hVlift : ContDiff ℝ ∞ (fun p : P × ℝ => V p.1 (p.2 : Period)))
+    (hrlift : ContDiff ℝ ∞ (fun p : P × ℝ => r p.1 (p.2 : Period))) :
+    ContDiff ℝ ∞ (fun p : P × ℝ => parameterCorrector V r q p.1 (p.2 : Period)) := by
+  have hm : ContDiff ℝ ∞ (fun p : P × ℝ =>
+      covarianceSolution (V p.1) (r p.1) (q p.1)) :=
+    (contDiff_covarianceSolution hV hr hq hqpos hcircle).comp contDiff_fst
+  have hv : ContDiff ℝ ∞ (fun p : P × ℝ => average (V p.1)) :=
+    (averageCLM.contDiff.comp hV).comp contDiff_fst
+  have hi : ContDiff ℝ ∞ (fun p : P × ℝ => (q p.1)⁻¹) :=
+    (hq.comp contDiff_fst).inv (fun p => (hqpos p.1).ne')
+  have hs : ContDiff ℝ ∞ (fun p : P × ℝ =>
+      correctedScalar (V p.1) (average (V p.1)) (q p.1) (r p.1)
+        (covarianceSolution (V p.1) (r p.1) (q p.1)) (p.2 : Period)) := by
+    simpa only [correctedScalar, div_eq_mul_inv] using
+      hrlift.add (((hVlift.sub hv).inner ℝ hm).mul hi)
+  exact hi.smul ((hs.smul hVlift).sub hm)
+
+end ClosedSurfaceR4.CovarianceCorrector
+
+end
+
+end OAI

lean/OAI/Geometry/SurfaceImmersion/Geometry/CovarianceRealOperator.lean

@@ -0,0 +1,116 @@
+import OAI.Geometry.SurfaceImmersion.Geometry.LocalCovarianceParameter
+
+namespace OAI
+
+/-! The actual covariance correction acting on real-parameter forcing.
+This form exposes linearity and does not require separate periodicity proofs
+for the individual coefficients of a jet polynomial. -/
+noncomputable section
+open MeasureTheory
+open scoped ContDiff
+
+namespace ClosedSurfaceR4.CovarianceCorrector
+
+variable {E P : Type} [NormedAddCommGroup E] [InnerProductSpace ℝ E]
+  [CompleteSpace E] [FiniteDimensional ℝ E]
+  [NormedAddCommGroup P] [NormedSpace ℝ P] [FiniteDimensional ℝ P]
+
+def realMoment (V : C(Period, E)) (r : ℝ → ℝ) : E :=
+  ∫ t in 0..1, r t • V (t : Period)
+
+def realMeanSolution (V : C(Period, E)) (q : ℝ) (r : ℝ → ℝ) : E :=
+  (meanCLM V q).inverse (realMoment V r)
+
+def realCorrector (V : C(Period, E)) (q : ℝ) (r : ℝ → ℝ) (t : ℝ) : E :=
+  let m := realMeanSolution V q r
+  q⁻¹ • ((r t + inner ℝ (V (t : Period) - average V) m / q) • V (t : Period) - m)
+
+omit [CompleteSpace E] [FiniteDimensional ℝ E] in
+lemma realMeanSolution_add (V : C(Period, E)) (q : ℝ) {f g : ℝ → ℝ}
+    (hf : Continuous f) (hg : Continuous g) :
+    realMeanSolution V q (fun t => f t + g t) =
+      realMeanSolution V q f + realMeanSolution V q g := by
+  unfold realMeanSolution realMoment
+  simp only [add_smul]
+  have hfi : IntervalIntegrable (fun t : ℝ => f t • V (t : Period)) volume 0 1 :=
+    (hf.smul (V.continuous.comp (AddCircle.continuous_mk' 1))).intervalIntegrable 0 1
+  have hgi : IntervalIntegrable (fun t : ℝ => g t • V (t : Period)) volume 0 1 :=
+    (hg.smul (V.continuous.comp (AddCircle.continuous_mk' 1))).intervalIntegrable 0 1
+  rw [intervalIntegral.integral_add hfi hgi, map_add]
+
+omit [CompleteSpace E] [FiniteDimensional ℝ E] in
+lemma realMeanSolution_smul (V : C(Period, E)) (q a : ℝ) (f : ℝ → ℝ) :
+    realMeanSolution V q (fun t => a * f t) = a • realMeanSolution V q f := by
+  unfold realMeanSolution realMoment
+  simp only [mul_smul, intervalIntegral.integral_smul, map_smul]
+
+omit [CompleteSpace E] [FiniteDimensional ℝ E] in
+lemma realCorrector_add (V : C(Period, E)) (q : ℝ) {f g : ℝ → ℝ}
+    (hf : Continuous f) (hg : Continuous g) (t : ℝ) :
+    realCorrector V q (fun s => f s + g s) t = realCorrector V q f t + realCorrector V q g t := by
+  simp only [realCorrector, realMeanSolution_add V q hf hg, inner_add_right, add_div]
+  module
+
+omit [CompleteSpace E] [FiniteDimensional ℝ E] in
+lemma realCorrector_smul (V : C(Period, E)) (q a : ℝ) (f : ℝ → ℝ) (t : ℝ) :
+    realCorrector V q (fun s => a * f s) t = a • realCorrector V q f t := by
+  simp only [realCorrector, realMeanSolution_smul, inner_smul_right]
+  have ha : a * f t + a * inner ℝ (V (t : Period) - average V) (realMeanSolution V q f) / q =
+      a * (f t + inner ℝ (V (t : Period) - average V) (realMeanSolution V q f) / q) := by ring
+  rw [ha]
+  module
+
+omit [CompleteSpace E] [FiniteDimensional ℝ E] [NormedAddCommGroup P]
+  [NormedSpace ℝ P] [FiniteDimensional ℝ P] in
+/-- Agreement with the covariance correction already used in the periodic solver. -/
+lemma realCorrector_eq_parameterCorrector (V : P → C(Period, E)) (q : P → ℝ)
+    (r : P → C(Period, ℝ)) (p : P) (t : ℝ) :
+    realCorrector (V p) (q p) (fun s => r p (s : Period)) t =
+      parameterCorrector V r q p (t : Period) := by
+  have hm : realMoment (V p) (fun s => r p (s : Period)) = weightedAverage (V p) (r p) := by
+    exact PeriodicPrimitive.integral_lift_eq_haar (fun s => r p s • V p s)
+  simp only [realCorrector, realMeanSolution, hm, parameterCorrector,
+    correctedVector, correctedScalar, covarianceSolution]
+
+lemma contDiffOn_realMeanSolution {O : Set P} (hO : IsOpen O)
+    {V : P → C(Period, E)} {q : P → ℝ} {c : P × ℝ → ℝ}
+    (hV : ContDiffOn ℝ ∞ (fun z : P × ℝ => V z.1 (z.2 : Period)) (O ×ˢ Set.univ))
+    (hq : ContDiffOn ℝ ∞ q O) (hqpos : ∀ p ∈ O, 0 < q p)
+    (hcircle : ∀ p ∈ O, ∀ t, inner ℝ (V p t) (V p t) = q p)
+    (hc : ContDiffOn ℝ ∞ c (O ×ˢ Set.univ)) :
+    ContDiffOn ℝ ∞ (fun p => realMeanSolution (V p) (q p) (fun t => c (p, t))) O := by
+  have hM : ContDiffOn ℝ ∞ (fun p => meanCLM (V p) (q p)) O :=
+    contDiffOn_const.sub ((hq.inv (fun p hp => (hqpos p hp).ne')).smul
+      (contDiffOn_covarianceCLM_joint hO hV))
+  have hi : ContDiffOn ℝ ∞ (fun p => (meanCLM (V p) (q p)).inverse) O := by
+    apply hO.contDiffOn_iff.mpr
+    intro p hp
+    exact (meanCLM_isInvertible (hqpos p hp) (hcircle p hp)).contDiffAt_map_inverse.comp p
+      (hM.contDiffAt (hO.mem_nhds hp))
+  exact hi.clm_apply (SmoothParameterIntegral.contDiffOn_integral hO (hc.smul hV) 0 1)
+
+lemma contDiffOn_realCorrector {O : Set P} (hO : IsOpen O)
+    {V : P → C(Period, E)} {q : P → ℝ} {c : P × ℝ → ℝ}
+    (hV : ContDiffOn ℝ ∞ (fun z : P × ℝ => V z.1 (z.2 : Period)) (O ×ˢ Set.univ))
+    (hq : ContDiffOn ℝ ∞ q O) (hqpos : ∀ p ∈ O, 0 < q p)
+    (hcircle : ∀ p ∈ O, ∀ t, inner ℝ (V p t) (V p t) = q p)
+    (hc : ContDiffOn ℝ ∞ c (O ×ˢ Set.univ)) :
+    ContDiffOn ℝ ∞ (fun z : P × ℝ => realCorrector (V z.1) (q z.1)
+      (fun t => c (z.1, t)) z.2) (O ×ˢ Set.univ) := by
+  have hm : ContDiffOn ℝ ∞ (fun z : P × ℝ =>
+      realMeanSolution (V z.1) (q z.1) (fun t => c (z.1, t))) (O ×ˢ Set.univ) :=
+    (contDiffOn_realMeanSolution hO hV hq hqpos hcircle hc).comp
+    contDiffOn_fst (fun _ hz => hz.1)
+  have hv : ContDiffOn ℝ ∞ (fun z : P × ℝ => average (V z.1)) (O ×ˢ Set.univ) :=
+    (contDiffOn_average_joint hO hV).comp contDiffOn_fst (fun _ hz => hz.1)
+  have hq' : ContDiffOn ℝ ∞ (fun z : P × ℝ => q z.1) (O ×ˢ Set.univ) :=
+    hq.comp contDiffOn_fst (fun _ hz => hz.1)
+  have hi := hq'.inv (fun z hz => (hqpos z.1 hz.1).ne')
+  exact hi.smul (((hc.add (((hV.sub hv).inner ℝ hm).div hq'
+    (fun z hz => (hqpos z.1 hz.1).ne'))).smul hV).sub hm)
+
+end ClosedSurfaceR4.CovarianceCorrector
+
+end
+
+end OAI

lean/OAI/Geometry/SurfaceImmersion/Geometry/CovectorPullbackParameters.lean

@@ -0,0 +1,90 @@
+import OAI.Geometry.SurfaceImmersion.Atlas.IndependentPhaseProjections
+import OAI.Geometry.Immersion.ClosedSurface.AtlasPhases
+
+namespace OAI
+
+/-! Actual pullback of phase covectors by a chart derivative. Its parameter
+map is open when the chart determinant is nonzero. -/
+noncomputable section
+open Set
+namespace ClosedSurfaceR4.PhaseGeometry
+open SmallModes RealModes
+
+def pullCovectorMap (A : CurvePlane →L[ℝ] CurvePlane) : CurvePlane →L[ℝ] CurvePlane :=
+  (((A dx).1 • ContinuousLinearMap.fst ℝ ℝ ℝ) +
+    ((A dx).2 • ContinuousLinearMap.snd ℝ ℝ ℝ)).prod
+  (((A dy).1 • ContinuousLinearMap.fst ℝ ℝ ℝ) +
+    ((A dy).2 • ContinuousLinearMap.snd ℝ ℝ ℝ))
+
+lemma pullCovectorMap_apply (A : CurvePlane →L[ℝ] CurvePlane) (v : CurvePlane) :
+    pullCovectorMap A v = pullCovector A v := by
+  ext <;> simp [pullCovectorMap,pullCovector] <;> ring
+
+lemma pullCovectorMap_surjective (A : CurvePlane →L[ℝ] CurvePlane)
+    (hA : coordDet A ≠ 0) : Function.Surjective (pullCovectorMap A) := by
+  intro y
+  refine ⟨(((A dy).2*y.1-(A dx).2*y.2)/coordDet A,
+    ((A dx).1*y.2-(A dy).1*y.1)/coordDet A),?_⟩
+  rw [pullCovectorMap_apply]
+  ext <;> dsimp [pullCovector] <;> field_simp [hA] <;> dsimp [coordDet] <;> ring
+
+lemma covectorDet_pullback (A : CurvePlane →L[ℝ] CurvePlane) (v w : CurvePlane) :
+    covectorDet (pullCovector A v) (pullCovector A w) = coordDet A * covectorDet v w := by
+  dsimp [covectorDet,pullCovector,coordDet]
+  ring
+
+lemma phaseLinear_ne_zero_on_kernel {v w t : CurvePlane}
+    (hdet : covectorDet v w ≠ 0) (ht : t ≠ 0) (hv : phaseLinear v t = 0) :
+    phaseLinear w t ≠ 0 := by
+  intro hw
+  by_cases ht1 : t.1 = 0
+  · have ht2 : t.2 ≠ 0 := fun ht2 => ht (Prod.ext ht1 ht2)
+    have he : covectorDet v w * t.2 = v.1 * phaseLinear w t-w.1 * phaseLinear v t := by
+      dsimp [covectorDet,phaseLinear_apply]
+      ring
+    rw [hv,hw,mul_zero,mul_zero,sub_self] at he
+    exact hdet ((mul_eq_zero.mp he).resolve_right ht2)
+  · have he : covectorDet v w * t.1 = w.2 * phaseLinear v t-v.2 * phaseLinear w t := by
+      dsimp [covectorDet,phaseLinear_apply]
+      ring
+    rw [hv,hw,mul_zero,mul_zero,sub_self] at he
+    exact hdet ((mul_eq_zero.mp he).resolve_right ht1)
+
+variable {ι : Type*} [Fintype ι] [DecidableEq ι]
+
+lemma independent_pulled_covectors_open_dense {i j : ι} (hij : i ≠ j)
+    (A B : CurvePlane →L[ℝ] CurvePlane) (hA : coordDet A ≠ 0) (hB : coordDet B ≠ 0)
+    (a b : CurvePlane) :
+    IsOpen {ell : ι → CurvePlane |
+      covectorDet (pullCovector A (ell i+a)) (pullCovector B (ell j+b)) ≠ 0} ∧
+    Dense {ell : ι → CurvePlane |
+      covectorDet (pullCovector A (ell i+a)) (pullCovector B (ell j+b)) ≠ 0} := by
+  let T : (CurvePlane × CurvePlane) →L[ℝ] (CurvePlane × CurvePlane) :=
+    ((pullCovectorMap A).comp (ContinuousLinearMap.fst ℝ CurvePlane CurvePlane)).prod
+      ((pullCovectorMap B).comp (ContinuousLinearMap.snd ℝ CurvePlane CurvePlane))
+  have hT : Function.Surjective T := by
+    intro y
+    obtain ⟨v,hv⟩ := pullCovectorMap_surjective A hA y.1
+    obtain ⟨w,hw⟩ := pullCovectorMap_surjective B hB y.2
+    exact ⟨(v,w),Prod.ext hv hw⟩
+  let F : (ι → CurvePlane) → CurvePlane × CurvePlane :=
+    fun ell => T (phasePairProjection i j ell+(a,b))
+  have hF : Continuous F := by fun_prop
+  have hopen : IsOpenMap F := (T.isOpenMap hT).comp
+    ((isOpenMap_add_right (a,b)).comp
+      ((phasePairProjection i j).isOpenMap (phasePairProjection_surjective hij)))
+  have he : {ell : ι → CurvePlane |
+      covectorDet (pullCovector A (ell i+a)) (pullCovector B (ell j+b)) ≠ 0} =
+      F ⁻¹' {z | covectorDet z.1 z.2 ≠ 0} := by
+    ext ell
+    change covectorDet (pullCovector A (ell i+a)) (pullCovector B (ell j+b)) ≠ 0 ↔
+      covectorDet (pullCovectorMap A (ell i+a)) (pullCovectorMap B (ell j+b)) ≠ 0
+    rw [pullCovectorMap_apply,pullCovectorMap_apply]
+  rw [he]
+  exact ⟨covectorDet_open_dense.1.preimage hF,covectorDet_open_dense.2.preimage hopen⟩
+
+end ClosedSurfaceR4.PhaseGeometry
+
+end
+
+end OAI

lean/OAI/Geometry/SurfaceImmersion/Geometry/CriticalSetClosed.lean

@@ -0,0 +1,49 @@
+import OAI.Geometry.SurfaceImmersion.Geometry.SplitSardCompact
+import Mathlib.Analysis.Normed.Ring.Units
+
+namespace OAI
+
+/-! Finite-dimensional critical loci are closed. This supplies compact
+exhaustions for the fiberwise critical-value argument. -/
+noncomputable section
+open Set Filter
+open scoped ContDiff Topology
+namespace ClosedSurfaceR4.FiniteOrderSmoothing
+variable {E F : Type*} [NormedAddCommGroup E] [NormedSpace ℝ E]
+  [NormedAddCommGroup F] [NormedSpace ℝ F] [FiniteDimensional ℝ F]
+
+theorem surjective_clm_open : IsOpen {K : E →L[ℝ] F | Function.Surjective K} := by
+  rw [isOpen_iff_mem_nhds]
+  intro K hK
+  obtain ⟨R,hR⟩ := K.toLinearMap.exists_rightInverse_of_surjective (LinearMap.range_eq_top.mpr hK)
+  let R' : F →L[ℝ] E := R.toContinuousLinearMap
+  have hKR : K.comp R' = ContinuousLinearMap.id ℝ F := by
+    apply ContinuousLinearMap.ext
+    intro x
+    exact congrArg (fun L : F →ₗ[ℝ] F => L x) hR
+  have hc : Continuous (fun L : E →L[ℝ] F => L.comp R') := continuous_id.clm_comp continuous_const
+  have hn : ∀ᶠ L in 𝓝 K, IsUnit (L.comp R') := by
+    change (fun L : E →L[ℝ] F => L.comp R') ⁻¹' {A | IsUnit A} ∈ 𝓝 K
+    apply hc.continuousAt.preimage_mem_nhds
+    apply Units.isOpen.mem_nhds
+    rw [hKR]
+    exact isUnit_one
+  filter_upwards [hn] with L hL
+  obtain ⟨u,hu⟩ := hL
+  intro y
+  refine ⟨R' ((↑u⁻¹ : F →L[ℝ] F) y),?_⟩
+  have hval : L (R' ((↑u⁻¹ : F →L[ℝ] F) y)) =
+      (↑u : F →L[ℝ] F) ((↑u⁻¹ : F →L[ℝ] F) y) := by rw [hu]; rfl
+  rw [hval]
+  change ((u : F →L[ℝ] F) * (↑u⁻¹ : F →L[ℝ] F)) y = y
+  simp
+
+theorem smooth_critical_set_closed {f : E → F} (hf : ContDiff ℝ ∞ f) :
+    IsClosed {x | ¬ Function.Surjective (fderiv ℝ f x)} :=
+  (surjective_clm_open.preimage (hf.continuous_fderiv (by simp))).isClosed_compl
+
+end ClosedSurfaceR4.FiniteOrderSmoothing
+
+end
+
+end OAI

lean/OAI/Geometry/SurfaceImmersion/Geometry/CubicTaylorRemainder.lean

@@ -0,0 +1,67 @@
+import Mathlib
+
+namespace OAI
+
+/-! The third-order integral remainder needed after the finite quadratic
+mean correction. -/
+noncomputable section
+open Set MeasureTheory
+open scoped ContDiff
+
+namespace ClosedSurfaceR4
+
+variable {E : Type*} [NormedAddCommGroup E] [NormedSpace ℝ E] [CompleteSpace E]
+
+omit [CompleteSpace E] in
+lemma quadraticTaylor_value {f : ℝ → E} (hf : ContDiff ℝ ∞ f) :
+    taylorWithinEval f 2 (uIcc (0 : ℝ) 1) 0 1 =
+      f 0 + deriv f 0 + (1 / 2 : ℝ) • iteratedDeriv 2 f 0 := by
+  have hi (k : ℕ) : iteratedDerivWithin k f (uIcc (0 : ℝ) 1) 0 = iteratedDeriv k f 0 :=
+    iteratedDerivWithin_eq_iteratedDeriv (uniqueDiffOn_uIcc (by norm_num))
+      ((hf.of_le (by simp : (k : ℕ∞ω) ≤ ∞)).contDiffAt) (by simp)
+  rw [show 2 = 1 + 1 from rfl, taylorWithinEval_succ, taylorWithinEval_succ,
+    taylor_within_zero_eval, hi 1, hi 2]
+  norm_num
+
+lemma cubicTaylor_remainder {f : ℝ → E} (hf : ContDiff ℝ ∞ f) :
+    f 1 - f 0 - deriv f 0 - (1 / 2 : ℝ) • iteratedDeriv 2 f 0 =
+      ∫ t in (0 : ℝ)..1, ((1 - t) ^ 2 / 2) • iteratedDeriv 3 f t := by
+  have ht := taylor_integral_remainder (f := f) (n := 2) (x₀ := 0) (x := 1)
+    (hf.of_le (by simp : ((2 + 1 : ℕ) : ℕ∞ω) ≤ ∞)).contDiffOn
+  rw [quadraticTaylor_value hf] at ht
+  have hi : (∫ t in (0 : ℝ)..1, ((1 - t) ^ 2 / (Nat.factorial 2 : ℝ)) •
+      iteratedDerivWithin 3 f (uIcc (0 : ℝ) 1) t) =
+      ∫ t in (0 : ℝ)..1, ((1 - t) ^ 2 / 2) • iteratedDeriv 3 f t := by
+    apply intervalIntegral.integral_congr
+    intro t ht
+    dsimp only
+    rw [iteratedDerivWithin_eq_iteratedDeriv (uniqueDiffOn_uIcc (by norm_num))
+      ((hf.of_le (by simp : (3 : ℕ∞ω) ≤ ∞)).contDiffAt) ht]
+    norm_num
+  rw [hi] at ht
+  convert ht using 1
+  abel
+
+lemma cubicTaylor_bound {f : ℝ → E} (hf : ContDiff ℝ ∞ f) {M : ℝ} (hM : 0 ≤ M)
+    (hderiv : ∀ t ∈ Icc (0 : ℝ) 1, ‖iteratedDeriv 3 f t‖ ≤ M) :
+    ‖f 1 - f 0 - deriv f 0 - (1 / 2 : ℝ) • iteratedDeriv 2 f 0‖ ≤ M / 2 := by
+  rw [cubicTaylor_remainder hf]
+  have hbound : ‖∫ t in (0 : ℝ)..1, ((1 - t) ^ 2 / 2) • iteratedDeriv 3 f t‖ ≤
+      (M / 2) * |1 - 0| := by
+    apply intervalIntegral.norm_integral_le_of_norm_le_const
+    intro t ht
+    have ht' : t ∈ Icc (0 : ℝ) 1 := by
+      simpa using uIoc_subset_uIcc ht
+    have hweight : (1 - t) ^ 2 / 2 ≤ (1 / 2 : ℝ) := by nlinarith [ht'.1, ht'.2]
+    rw [norm_smul, Real.norm_eq_abs, abs_of_nonneg (by positivity : 0 ≤ (1 - t) ^ 2 / 2)]
+    calc
+      _ ≤ ((1 - t) ^ 2 / 2) * M := mul_le_mul_of_nonneg_left (hderiv t ht') (by positivity)
+      _ ≤ (1 / 2 : ℝ) * M := mul_le_mul_of_nonneg_right hweight hM
+      _ = M / 2 := by ring
+  simpa using hbound
+
+end ClosedSurfaceR4
+
+end
+
+end OAI

lean/OAI/Geometry/SurfaceImmersion/Geometry/CurveEdgeLocalization.lean

@@ -0,0 +1,60 @@
+import OAI.Geometry.SurfaceImmersion.Geometry.CurveEdgePaths
+import OAI.Geometry.SurfaceImmersion.Geometry.CurveIncidenceGraph
+
+namespace OAI
+
+/-! Localization of a full edge path at its two graph vertices and its
+single open interval edge. -/
+noncomputable section
+open Set
+namespace ClosedSurfaceR4.FiniteOrderSmoothing
+variable {X : Type*} [TopologicalSpace X] [T2Space X]
+
+theorem curve_edge_frontier_endpoints {V : Set X} {E : Set X}
+    (w : CurveEdgeWitness V E) (hdis : Disjoint E V) (a b : V) (hne : a ≠ b)
+    (ha : a.val ∈ closure E) (hb : b.val ∈ closure E) :
+    closure E \ E = {a.val,b.val} := by
+  have hne' : a.val ≠ b.val := fun h => hne (Subtype.ext h)
+  rcases (w.endpoint_iff hdis a.property).mp ha with hal | har <;>
+    rcases (w.endpoint_iff hdis b.property).mp hb with hbl | hbr
+  · exact False.elim (hne' (hal.trans hbl.symm))
+  · rw [w.frontier_eq,hal,hbr]
+  · rw [w.frontier_eq,har,hbl,pair_comm]
+  · exact False.elim (hne' (har.trans hbr.symm))
+
+theorem curve_edge_path_localization {V : Set X} {P : Finset (Set X)}
+    (hP : ∀ E ∈ P, Disjoint E V)
+    (hdis : ∀ E ∈ P, ∀ F ∈ P, E ≠ F → Disjoint E F)
+    (E : P) (w : CurveEdgeWitness V E.val) (a b : V) (hne : a ≠ b)
+    (ha : a.val ∈ closure E.val) (hb : b.val ∈ closure E.val)
+    (γ : Path a.val b.val) (hrange : range γ = closure E.val) :
+    (∀ v : V, v.val ∈ range γ → v = a ∨ v = b) ∧
+    (∀ F : P, (range γ ∩ F.val).Nonempty → F = E) := by
+  have hfront := curve_edge_frontier_endpoints w (hP E.val E.property) a b hne ha hb
+  constructor
+  · intro v hv
+    have hn : v.val ∉ E.val := fun h => disjoint_left.mp (hP E.val E.property) h v.property
+    have hv' : v.val ∈ closure E.val \ E.val := ⟨hrange ▸ hv,hn⟩
+    rw [hfront] at hv'
+    rcases hv' with he | he
+    · exact Or.inl (Subtype.ext he)
+    · exact Or.inr (Subtype.ext (mem_singleton_iff.mp he))
+  · rintro F ⟨x,hxγ,hxF⟩
+    by_contra hFE
+    have hxcl : x ∈ closure E.val := hrange ▸ hxγ
+    by_cases hxE : x ∈ E.val
+    · exact disjoint_left.mp (hdis F.val F.property E.val E.property
+        (fun h => hFE (Subtype.ext h))) hxF hxE
+    · have hxV : x ∈ V := by
+        have hx : x ∈ closure E.val \ E.val := ⟨hxcl,hxE⟩
+        rw [w.frontier_eq] at hx
+        rcases hx with he | he
+        · exact he ▸ w.left_mem
+        · exact (mem_singleton_iff.mp he) ▸ w.right_mem
+      exact disjoint_left.mp (hP F.val F.property) hxF hxV
+
+end ClosedSurfaceR4.FiniteOrderSmoothing
+
+end
+
+end OAI

lean/OAI/Geometry/SurfaceImmersion/Geometry/CurveEdgeParametrization.lean

@@ -0,0 +1,53 @@
+import OAI.Geometry.SurfaceImmersion.Geometry.CurveEdgeWitness
+import OAI.Geometry.SurfaceImmersion.Atlas.LineChartEndpointObstruction
+
+namespace OAI
+
+/-! Retained edge witnesses give actual compact interval
+parametrizations of their closures. -/
+noncomputable section
+open Set Topology
+namespace ClosedSurfaceR4.FiniteOrderSmoothing
+variable {X : Type*} [TopologicalSpace X] [T2Space X]
+
+def CurveEdgeWitness.param {V E : Set X} (w : CurveEdgeWitness V E) : Icc w.lo w.hi → X :=
+  fun t => w.arc.map ⟨t.val,w.lower.trans t.property.1,t.property.2.trans w.upper⟩
+
+lemma CurveEdgeWitness.param_closedEmbedding {V E : Set X} (w : CurveEdgeWitness V E) :
+    IsClosedEmbedding w.param := by
+  let j : Icc w.lo w.hi → Icc w.arc.left w.arc.right := fun t =>
+    ⟨t.val,w.lower.trans t.property.1,t.property.2.trans w.upper⟩
+  have hj : Continuous j := continuous_subtype_val.subtype_mk _
+  have hc : Continuous w.param := w.arc.embedding.continuous.comp hj
+  apply hc.isClosedEmbedding
+  intro s t hst
+  have he := w.arc.embedding.injective hst
+  exact Subtype.ext (congrArg (fun u : Icc w.arc.left w.arc.right => (u:ℝ)) he)
+
+omit [T2Space X] in
+lemma CurveEdgeWitness.param_range {V E : Set X} (w : CurveEdgeWitness V E) :
+    range w.param = closure E := by
+  conv_rhs => rw [w.piece_eq,w.arc.subarc_closure w.lower w.upper w.ordered]
+  apply Subset.antisymm
+  · rintro x ⟨t,rfl⟩
+    exact ⟨⟨t.val,w.lower.trans t.property.1,t.property.2.trans w.upper⟩,t.property,rfl⟩
+  · rintro x ⟨t,ht,rfl⟩
+    exact ⟨⟨t.val,ht⟩,rfl⟩
+
+lemma CurveEdgeWitness.frontier_not_interior_closure {V E : Set X} (w : CurveEdgeWitness V E)
+    (d : OpenPartialHomeomorph X ℝ) {p : X} (hp : p ∈ d.source)
+    (hb : p ∈ closure E \ E) : p ∉ interior (closure E) := by
+  have hend : p = w.param ⟨w.lo,le_rfl,w.ordered.le⟩ ∨
+      p = w.param ⟨w.hi,w.ordered.le,le_rfl⟩ := by
+    rw [w.frontier_eq] at hb
+    rcases hb with h | h
+    · exact Or.inl h
+    · exact Or.inr (mem_singleton_iff.mp h)
+  rw [← w.param_range]
+  exact compact_arc_endpoint_not_interior d w.ordered.le w.param w.param_closedEmbedding.isEmbedding hp hend
+
+end ClosedSurfaceR4.FiniteOrderSmoothing
+
+end
+
+end OAI

lean/OAI/Geometry/SurfaceImmersion/Geometry/CurveEdgePaths.lean

@@ -0,0 +1,61 @@
+import OAI.Geometry.SurfaceImmersion.Geometry.GeometricCurvePaths
+
+namespace OAI
+
+/-! Each retained compact interval edge is parametrized by an injective
+path, in either orientation. -/
+noncomputable section
+open Set Topology unitInterval
+namespace ClosedSurfaceR4.FiniteOrderSmoothing
+variable {X : Type*} [TopologicalSpace X] [T2Space X]
+
+def CurveEdgeWitness.path {V E : Set X} (w : CurveEdgeWitness V E) :
+    Path w.leftPoint w.rightPoint where
+  toFun t := w.param ((iccHomeoI w.lo w.hi w.ordered).symm t)
+  continuous_toFun := w.param_closedEmbedding.continuous.comp (iccHomeoI w.lo w.hi w.ordered).symm.continuous
+  source' := by
+    change w.param _ = w.param ⟨w.lo,le_rfl,w.ordered.le⟩
+    congr 1
+    apply Subtype.ext
+    simp
+  target' := by
+    change w.param _ = w.param ⟨w.hi,w.ordered.le,le_rfl⟩
+    congr 1
+    apply Subtype.ext
+    simp
+
+lemma CurveEdgeWitness.path_injective {V E : Set X} (w : CurveEdgeWitness V E) :
+    Function.Injective w.path :=
+  w.param_closedEmbedding.injective.comp (iccHomeoI w.lo w.hi w.ordered).symm.injective
+
+lemma CurveEdgeWitness.path_range {V E : Set X} (w : CurveEdgeWitness V E) :
+    range w.path = closure E := by
+  change range (w.param ∘ (iccHomeoI w.lo w.hi w.ordered).symm) = _
+  rw [range_comp,(iccHomeoI w.lo w.hi w.ordered).symm.surjective.range_eq,image_univ,w.param_range]
+
+lemma CurveEdgeWitness.endpoint_iff {V E : Set X} (w : CurveEdgeWitness V E)
+    (hdis : Disjoint E V) {p : X} (hp : p ∈ V) :
+    p ∈ closure E ↔ p = w.leftPoint ∨ p = w.rightPoint := by
+  have hnot : p ∉ E := fun h => disjoint_left.mp hdis h hp
+  have he : p ∈ closure E ↔ p ∈ closure E \ E := by simp only [mem_sdiff,hnot,not_false_eq_true,and_true]
+  rw [he,w.frontier_eq]
+  simp only [mem_insert_iff,mem_singleton_iff]
+
+lemma CurveEdgeWitness.oriented_path {V E : Set X} (w : CurveEdgeWitness V E)
+    (hdis : Disjoint E V) {p q : X} (hp : p ∈ V) (hq : q ∈ V) (hne : p ≠ q)
+    (hpE : p ∈ closure E) (hqE : q ∈ closure E) :
+    ∃ γ : Path p q, Function.Injective γ ∧ range γ = closure E := by
+  rcases (w.endpoint_iff hdis hp).mp hpE with hpl | hpr <;>
+    rcases (w.endpoint_iff hdis hq).mp hqE with hql | hqr
+  · exact False.elim (hne (hpl.trans hql.symm))
+  · exact ⟨w.path.cast hpl hqr,w.path_injective,w.path_range⟩
+  · refine ⟨w.path.symm.cast hpr hql,?_,?_⟩
+    · exact w.path_injective.comp unitInterval.symm_bijective.injective
+    · simpa only [Path.cast_coe,Path.symm_range] using w.path_range
+  · exact False.elim (hne (hpr.trans hqr.symm))
+
+end ClosedSurfaceR4.FiniteOrderSmoothing
+
+end
+
+end OAI

lean/OAI/Geometry/SurfaceImmersion/Geometry/CurveEdgeWitness.lean

@@ -0,0 +1,45 @@
+import OAI.Geometry.SurfaceImmersion.Geometry.SubarcClosure
+
+namespace OAI
+
+/-! Each finite curve edge retains its actual compact interval
+parametrization, two distinct endpoints, and exact frontier. -/
+noncomputable section
+open Set
+namespace ClosedSurfaceR4.FiniteOrderSmoothing
+variable {X : Type*} [TopologicalSpace X]
+
+structure CurveEdgeWitness (V E : Set X) where
+  arc : CompactCurveArc X
+  lo : ℝ
+  hi : ℝ
+  lower : arc.left ≤ lo
+  upper : hi ≤ arc.right
+  ordered : lo < hi
+  piece_eq : E = arc.openSubarc lo hi
+  left_mem : arc.map ⟨lo,lower,ordered.le.trans upper⟩ ∈ V
+  right_mem : arc.map ⟨hi,lower.trans ordered.le,upper⟩ ∈ V
+
+def CurveEdgeWitness.leftPoint {V E : Set X} (w : CurveEdgeWitness V E) : X :=
+  w.arc.map ⟨w.lo,w.lower,w.ordered.le.trans w.upper⟩
+
+def CurveEdgeWitness.rightPoint {V E : Set X} (w : CurveEdgeWitness V E) : X :=
+  w.arc.map ⟨w.hi,w.lower.trans w.ordered.le,w.upper⟩
+
+lemma CurveEdgeWitness.endpoints_ne {V E : Set X} (w : CurveEdgeWitness V E) :
+    w.leftPoint ≠ w.rightPoint := by
+  intro he
+  have ht := w.arc.embedding.injective he
+  exact w.ordered.ne (congrArg Subtype.val ht)
+
+variable [T2Space X]
+lemma CurveEdgeWitness.frontier_eq {V E : Set X} (w : CurveEdgeWitness V E) :
+    closure E \ E = {w.leftPoint,w.rightPoint} := by
+  conv_lhs => rw [w.piece_eq]
+  exact w.arc.subarc_boundary_eq w.lower w.upper w.ordered
+
+end ClosedSurfaceR4.FiniteOrderSmoothing
+
+end
+
+end OAI

lean/OAI/Geometry/SurfaceImmersion/Geometry/CurveFrameInverse.lean

@@ -0,0 +1,69 @@
+import OAI.Geometry.SurfaceImmersion.Whitney.CrosscapStripFrame
+
+namespace OAI
+
+/-! Smooth inverse frames and the exact normal-coordinate immersion criterion. -/
+noncomputable section
+open Set Filter Matrix
+open scoped ContDiff Topology
+namespace ClosedSurfaceR4.FiniteOrderSmoothing
+open JetPolynomial (Base)
+
+lemma curveNormalLinear_invertible {v a : Fin 3 → ℝ}
+    (hv : v ≠ 0) (ha : ∀ r : ℝ, r • v ≠ a) : (curveNormalLinear v a).IsInvertible := by
+  have hb := curveNormalLinear_bijective hv ha
+  exact ⟨ContinuousLinearEquiv.ofBijective (curveNormalLinear v a)
+    (LinearMap.ker_eq_bot.mpr hb.1) (LinearMap.range_eq_top.mpr hb.2),rfl⟩
+
+lemma curveNormalLinear_inverse_velocity {v a : Fin 3 → ℝ}
+    (hv : v ≠ 0) (ha : ∀ r : ℝ, r • v ≠ a) :
+    (curveNormalLinear v a).inverse v = ((0 : Base),1) := by
+  apply ((curveNormalLinear_invertible hv ha).inverse_apply_eq).mpr
+  simp [curveNormalLinear_apply]
+
+lemma curveNormalLinear_inverse_smooth {v : ℝ → Fin 3 → ℝ}
+    (hv : ContDiff ℝ ∞ v) {a : Fin 3 → ℝ} {J : Set ℝ}
+    (hn : ∀ t ∈ J, v t ≠ 0) (ha : ∀ t r : ℝ, r • v t ≠ a) :
+    ContDiffOn ℝ ∞ (fun t => (curveNormalLinear (v t) a).inverse) J := by
+  intro t ht
+  exact ((curveNormalLinear_invertible (hn t ht) (ha t)).contDiffAt_map_inverse.comp t
+    (curveNormalLinear_smooth hv a).contDiffAt).contDiffWithinAt
+
+lemma normal_coordinates_injective_iff (L : Base →L[ℝ] (Base × ℝ))
+    (hL : L (![1,0] : Base) = ((0:Base),1)) :
+    Function.Injective L ↔ (L (![0,1] : Base)).1 ≠ 0 := by
+  have hsplit : ∀ x : Base, L x = (x 0) • L (![1,0] : Base) + (x 1) • L (![0,1] : Base) := by
+    intro x
+    have hx : x = (x 0) • (![1,0] : Base) + (x 1) • (![0,1] : Base) := by
+      ext i; fin_cases i <;> simp
+    conv_lhs => rw [hx]
+    rw [map_add,map_smul,map_smul]
+  constructor
+  · intro h hz
+    have hEq : L (![0,1] : Base) = L (((L (![0,1] : Base)).2) • (![1,0] : Base)) := by
+      rw [map_smul,hL]
+      apply Prod.ext
+      · simpa using hz
+      · simp
+    have h0 := congrFun (h hEq) 1
+    norm_num at h0
+  · intro hn x y hxy
+    have hd : L (x-y) = 0 := by rw [map_sub,hxy,sub_self]
+    rw [hsplit,hL] at hd
+    have hfst := congrArg Prod.fst hd
+    have h1 : (x-y) 1 = 0 := by
+      have hm : (x-y) 1 • (L (![0,1] : Base)).1 = 0 := by simpa using hfst
+      exact (smul_eq_zero.mp hm).resolve_right hn
+    have hsnd := congrArg Prod.snd hd
+    have h0 : (x-y) 0 = 0 := by simpa [h1] using hsnd
+    apply sub_eq_zero.mp
+    ext i
+    fin_cases i
+    · exact h0
+    · exact h1
+
+end ClosedSurfaceR4.FiniteOrderSmoothing
+
+end
+
+end OAI

lean/OAI/Geometry/SurfaceImmersion/Geometry/CurveIncidenceBoundaryPair.lean

@@ -0,0 +1,79 @@
+import OAI.Geometry.SurfaceImmersion.Geometry.BoundaryDegreeOne
+import OAI.Geometry.SurfaceImmersion.Geometry.OrdinaryDegreeTwo
+import OAI.Geometry.SurfaceImmersion.Geometry.DegreeOneReachability
+
+namespace OAI
+
+/-! Every boundary point of a compact curve is connected to a different
+boundary point in its actual finite interval incidence graph. -/
+noncomputable section
+open Set Topology
+attribute [local instance] Classical.propDecidable
+namespace ClosedSurfaceR4.FiniteOrderSmoothing
+variable {X : Type*} [TopologicalSpace X] [T2Space X]
+
+theorem curve_incidence_degrees (D V : Set X) (hV : V.Finite) (P : Finset (Set X))
+    (hP : ∀ E ∈ P, IsOpen E ∧ Disjoint E V ∧ closure E \ E ⊆ V)
+    (hdis : ∀ E ∈ P, ∀ F ∈ P, E ≠ F → Disjoint E F)
+    (hcover : Vᶜ = ⋃ E ∈ P, E) (hwitness : ∀ E ∈ P, Nonempty (CurveEdgeWitness V E))
+    (hline : ∀ p ∉ D, ∃ c : OpenPartialHomeomorph X ℝ, p ∈ c.source)
+    (hhalf : ∀ p ∈ D, ∃ c : OpenPartialHomeomorph X (Ici (0:ℝ)),
+      p ∈ c.source ∧ c p = ⟨0,by simp⟩) [Fintype V] :
+    (∀ p : V, (curveIncidenceGraph V P).degree (Sum.inl p) = if p.val ∈ D then 1 else 2) ∧
+    (∀ E : P, (curveIncidenceGraph V P).degree (Sum.inr E) = 2) := by
+  constructor
+  · intro p
+    by_cases hp : p.val ∈ D
+    · simp only [hp, ↓reduceIte]
+      obtain ⟨c,hc,hc0⟩ := hhalf p.val hp
+      exact curveIncidenceGraph_degree_left_one V P p
+        (boundary_vertex_degree_one V hV P hP hdis hcover p.property c hc hc0)
+    · simp only [hp, ↓reduceIte]
+      obtain ⟨c,hc⟩ := hline p.val hp
+      exact curveIncidenceGraph_degree_left_two V P p
+        (ordinary_vertex_degree_two V hV P hP hdis hcover hwitness p.property c hc)
+  · intro E
+    exact curveIncidenceGraph_degree_right_two V P E (hP E.val E.property).2.1
+      (Classical.choice (hwitness E.val E.property))
+
+theorem curve_boundary_pair (D V : Set X) (hDV : D ⊆ V) (hV : V.Finite)
+    (P : Finset (Set X))
+    (hP : ∀ E ∈ P, IsOpen E ∧ Disjoint E V ∧ closure E \ E ⊆ V)
+    (hdis : ∀ E ∈ P, ∀ F ∈ P, E ≠ F → Disjoint E F)
+    (hcover : Vᶜ = ⋃ E ∈ P, E) (hwitness : ∀ E ∈ P, Nonempty (CurveEdgeWitness V E))
+    (hline : ∀ p ∉ D, ∃ c : OpenPartialHomeomorph X ℝ, p ∈ c.source)
+    (hhalf : ∀ p ∈ D, ∃ c : OpenPartialHomeomorph X (Ici (0:ℝ)),
+      p ∈ c.source ∧ c p = ⟨0,by simp⟩)
+    (p : D) : ∃ (q : D), q ≠ p ∧ Nonempty
+      ((curveIncidenceGraph V P).Path (Sum.inl ⟨p.val,hDV p.property⟩)
+        (Sum.inl ⟨q.val,hDV q.property⟩)) := by
+  let : Fintype V := hV.fintype
+  let G := curveIncidenceGraph V P
+  obtain ⟨hl,hr⟩ := curve_incidence_degrees D V hV P hP hdis hcover hwitness hline hhalf
+  have hdegrees : ∀ x, G.degree x = 1 ∨ G.degree x = 2 := by
+    rintro (v|E)
+    · rw [hl]
+      split_ifs <;> simp
+    · exact Or.inr (hr E)
+  have hp : G.degree (Sum.inl ⟨p.val,hDV p.property⟩) = 1 := by
+    rw [hl]
+    simp only [p.property, ↓reduceIte]
+  obtain ⟨q,hqp,hq,hpath⟩ := degree_one_reaches_degree_one G hdegrees
+    (Sum.inl ⟨p.val,hDV p.property⟩) hp
+  cases q with
+  | inr E => rw [hr] at hq; norm_num at hq
+  | inl v =>
+    have hvD : v.val ∈ D := by
+      rw [hl] at hq
+      by_contra hn
+      simp only [hn, ↓reduceIte] at hq
+      norm_num at hq
+    refine ⟨⟨v.val,hvD⟩,?_,hpath⟩
+    intro he
+    exact hqp (congrArg Sum.inl (Subtype.ext (congrArg (fun z : D => z.val) he)))
+
+end ClosedSurfaceR4.FiniteOrderSmoothing
+
+end
+
+end OAI

lean/OAI/Geometry/SurfaceImmersion/Geometry/CurveIncidenceGraph.lean

@@ -0,0 +1,102 @@
+import OAI.Geometry.SurfaceImmersion.Geometry.CurveEdgeWitness
+import Mathlib.Combinatorics.SimpleGraph.DegreeSum
+import Mathlib.Combinatorics.SimpleGraph.Connectivity.Connected
+
+namespace OAI
+
+/-! The bipartite incidence graph remembers distinct parallel interval edges. -/
+noncomputable section
+open Set
+attribute [local instance] Classical.propDecidable
+namespace ClosedSurfaceR4.FiniteOrderSmoothing
+variable {X : Type*} [TopologicalSpace X]
+
+def curveIncidenceGraph (V : Set X) (P : Finset (Set X)) : SimpleGraph (V ⊕ P) where
+  Adj a b := match a,b with
+    | Sum.inl v, Sum.inr E => v.val ∈ closure E.val
+    | Sum.inr E, Sum.inl v => v.val ∈ closure E.val
+    | _,_ => False
+  symm := ⟨by rintro (v|E) (w|F) h <;> exact h⟩
+  loopless := ⟨by rintro (v|E) h <;> exact h⟩
+
+@[simp] lemma curveIncidenceGraph_left_right (V : Set X) (P : Finset (Set X)) (v : V) (E : P) :
+    (curveIncidenceGraph V P).Adj (Sum.inl v) (Sum.inr E) ↔ v.val ∈ closure E.val := Iff.rfl
+
+lemma graph_degree_two {A : Type*} (G : SimpleGraph A) [Fintype A]
+    (p a b : A) (hne : a ≠ b) (ha : G.Adj p a) (hb : G.Adj p b)
+    (hall : ∀ z, G.Adj p z → z = a ∨ z = b) : G.degree p = 2 := by
+  classical
+  have hs : G.neighborSet p = {a,b} := by
+    ext z
+    constructor
+    · exact hall z
+    · rintro (rfl | hz)
+      · exact ha
+      · exact (mem_singleton_iff.mp hz) ▸ hb
+  rw [← G.ncard_neighborSet,hs]
+  simp [hne]
+
+lemma curveIncidenceGraph_degree_left_one (V : Set X) (P : Finset (Set X)) [Fintype V]
+    (v : V) (h : ∃ E ∈ P, v.val ∈ closure E ∧
+      ∀ F ∈ P, v.val ∈ closure F → F = E) :
+    (curveIncidenceGraph V P).degree (Sum.inl v) = 1 := by
+  apply SimpleGraph.degree_eq_one_iff_existsUnique_adj.mpr
+  obtain ⟨E,hE,hv,huniq⟩ := h
+  refine ⟨Sum.inr ⟨E,hE⟩,hv,?_⟩
+  rintro (w|F) hw
+  · exact False.elim hw
+  · exact congrArg Sum.inr (Subtype.ext (huniq F.val F.property hw))
+
+lemma curveIncidenceGraph_degree_left_two (V : Set X) (P : Finset (Set X)) [Fintype V]
+    (v : V) (h : ∃ E ∈ P, ∃ F ∈ P, E ≠ F ∧ v.val ∈ closure E ∧ v.val ∈ closure F ∧
+      ∀ G ∈ P, v.val ∈ closure G → G = E ∨ G = F) :
+    (curveIncidenceGraph V P).degree (Sum.inl v) = 2 := by
+  obtain ⟨E,hE,F,hF,hne,hvE,hvF,hall⟩ := h
+  apply graph_degree_two (curveIncidenceGraph V P) (Sum.inl v)
+    (Sum.inr ⟨E,hE⟩) (Sum.inr ⟨F,hF⟩)
+  · intro he
+    exact hne (congrArg (fun z : P => z.val) (Sum.inr.inj he))
+  · exact hvE
+  · exact hvF
+  · rintro (w|G) hg
+    · exact False.elim hg
+    · rcases hall G.val G.property hg with he | he
+      · exact Or.inl (congrArg Sum.inr (Subtype.ext he))
+      · exact Or.inr (congrArg Sum.inr (Subtype.ext he))
+
+variable [T2Space X]
+lemma curveIncidenceGraph_degree_right_two (V : Set X) (P : Finset (Set X)) [Fintype V]
+    (E : P) (hdis : Disjoint E.val V) (w : CurveEdgeWitness V E.val) :
+    (curveIncidenceGraph V P).degree (Sum.inr E) = 2 := by
+  let l : V := ⟨w.leftPoint,w.left_mem⟩
+  let r : V := ⟨w.rightPoint,w.right_mem⟩
+  have hboundary : ∀ x ∈ V, x ∈ closure E.val ↔ x = w.leftPoint ∨ x = w.rightPoint := by
+    intro x hxV
+    have hn : x ∉ E.val := fun h => disjoint_left.mp hdis h hxV
+    have h := w.frontier_eq
+    constructor
+    · intro hx
+      have hb : x ∈ closure E.val \ E.val := ⟨hx,hn⟩
+      rw [h] at hb
+      simpa only [mem_insert_iff,mem_singleton_iff] using hb
+    · intro hx
+      have hb : x ∈ closure E.val \ E.val := by
+        rw [h]
+        simpa only [mem_insert_iff,mem_singleton_iff] using hx
+      exact hb.1
+  apply graph_degree_two (curveIncidenceGraph V P) (Sum.inr E) (Sum.inl l) (Sum.inl r)
+  · intro he
+    exact w.endpoints_ne (congrArg (fun z : V => z.val) (Sum.inl.inj he))
+  · exact (hboundary _ w.left_mem).mpr (Or.inl rfl)
+  · exact (hboundary _ w.right_mem).mpr (Or.inr rfl)
+  · rintro (v|F) hv
+    · rcases (hboundary _ v.property).mp hv with he | he
+      · exact Or.inl (congrArg Sum.inl (Subtype.ext he))
+      · exact Or.inr (congrArg Sum.inl (Subtype.ext he))
+    · exact False.elim hv
+
+end ClosedSurfaceR4.FiniteOrderSmoothing
+
+end
+
+end OAI

lean/OAI/Geometry/SurfaceImmersion/Geometry/CurveNormalFrame.lean

@@ -0,0 +1,57 @@
+import OAI.Geometry.SurfaceImmersion.Geometry.CurveTransverseVector
+
+namespace OAI
+
+/-! An explicit invertible three-dimensional frame along a regular curve. -/
+noncomputable section
+open Set Matrix
+open scoped ContDiff Topology
+namespace ClosedSurfaceR4.FiniteOrderSmoothing
+open JetPolynomial (Base)
+
+def curveNormalLinear (v a : Fin 3 → ℝ) : (Base × ℝ) →L[ℝ] (Fin 3 → ℝ) :=
+  (ContinuousLinearMap.snd ℝ Base ℝ).smulRight v +
+    ((ContinuousLinearMap.proj (0 : Fin 2)).comp (ContinuousLinearMap.fst ℝ Base ℝ)).smulRight a +
+    ((ContinuousLinearMap.proj (1 : Fin 2)).comp (ContinuousLinearMap.fst ℝ Base ℝ)).smulRight (v ⨯₃ a)
+
+lemma curveNormalLinear_apply (v a : Fin 3 → ℝ) (z : Base × ℝ) :
+    curveNormalLinear v a z = z.2 • v+z.1 0 • a+z.1 1 • (v ⨯₃ a) := rfl
+
+lemma curveNormalLinear_bijective {v a : Fin 3 → ℝ}
+    (hv : v ≠ 0) (ha : ∀ r : ℝ, r • v ≠ a) :
+    Function.Bijective (curveNormalLinear v a) := by
+  have hli := curve_transverse_vector_independent hv ha
+  have hw := curve_transverse_cross_ne_zero hv ha
+  have hwv : (v ⨯₃ a) ⬝ᵥ v = 0 := by rw [dotProduct_comm]; exact dot_self_cross v a
+  have hwa : (v ⨯₃ a) ⬝ᵥ a = 0 := by rw [dotProduct_comm]; exact dot_cross_self v a
+  have hww : (v ⨯₃ a) ⬝ᵥ (v ⨯₃ a) ≠ 0 := (dotProduct_self_eq_zero).not.mpr hw
+  have hz : ∀ z : Base × ℝ, curveNormalLinear v a z = 0 → z = 0 := by
+    intro z h
+    have hd := congrArg (fun w => (v ⨯₃ a) ⬝ᵥ w) h
+    rw [curveNormalLinear_apply] at hd
+    simp only [dotProduct_add,dotProduct_smul,hwv,hwa,smul_eq_mul,mul_zero,zero_add,dotProduct_zero] at hd
+    have hz1 : z.1 1 = 0 := (mul_eq_zero.mp hd).resolve_right hww
+    have hsum : z.2 • v+z.1 0 • a = 0 := by
+      simpa only [curveNormalLinear_apply,hz1,zero_smul,add_zero] using h
+    obtain ⟨hz2,hz0⟩ := (LinearIndependent.pair_iff.mp hli) z.2 (z.1 0) hsum
+    apply Prod.ext
+    · ext i
+      fin_cases i
+      · exact hz0
+      · exact hz1
+    · exact hz2
+  have hi : Function.Injective (curveNormalLinear v a) := by
+    intro z w h
+    apply sub_eq_zero.mp
+    apply hz
+    rw [map_sub,h,sub_self]
+  refine ⟨hi,?_⟩
+  apply (LinearMap.injective_iff_surjective_of_finrank_eq_finrank
+    (f := (curveNormalLinear v a).toLinearMap) _).mp hi
+  simp [Base]
+
+end ClosedSurfaceR4.FiniteOrderSmoothing
+
+end
+
+end OAI

lean/OAI/Geometry/SurfaceImmersion/Geometry/CurveSecondFields.lean

@@ -0,0 +1,122 @@
+import OAI.Geometry.SurfaceImmersion.Atlas.PhaseMetricPositive
+import OAI.Geometry.SurfaceImmersion.Atlas.PhaseMetricRegularity
+import OAI.Geometry.SurfaceImmersion.Correction.CompactSmoothCutoffs
+import OAI.Geometry.SurfaceImmersion.Atlas.PhaseDiskNormalGluing
+
+namespace OAI
+
+/-! Smooth global representatives of second-form fields along a compact curve.
+A cutoff in its own phase chart extends the field without choosing a normal frame. -/
+noncomputable section
+open Set Filter Manifold
+open scoped ContDiff Topology
+namespace ClosedSurfaceR4.RealModes
+open SmallModes NormalFrame
+
+lemma realSecondForm_field_smoothAt {F : RField 4} {v w : Base → Base}
+    (hF : ContDiff ℝ ∞ F) (hv : ContDiff ℝ ∞ v) (hw : ContDiff ℝ ∞ w)
+    {p : Base} (hD : gramDet (coordDeriv dx F p) (coordDeriv dy F p) ≠ 0) :
+    ContDiffAt ℝ ∞ (fun q => realSecondForm F (v q) (w q) q) p := by
+  have hDF := hF.fderiv_right (m := ∞) (by simp)
+  have hDDF := hDF.fderiv_right (m := ∞) (by simp)
+  have heq : (fun q => realSecondForm F (v q) (w q) q) =
+      fun q => realNormalPart (coordDeriv dx F q) (coordDeriv dy F q)
+        (fderiv ℝ (fderiv ℝ F) q (v q) (w q)) := by
+    funext q
+    unfold realSecondForm
+    rw [real_second_coordDeriv ((hDF.differentiable (by simp)) q)]
+  rw [heq]
+  exact contDiffAt_realNormalPart (contDiff_real_coordDeriv hF dx).contDiffAt
+    (contDiff_real_coordDeriv hF dy).contDiffAt
+    ((hDDF.clm_apply hv).clm_apply hw).contDiffAt hD
+
+end ClosedSurfaceR4.RealModes
+namespace ClosedSurfaceR4.FiniteOrderSmoothing
+open RealModes SmallModes NormalFrame SurfaceJetCoordinates
+variable {M : Type*} [TopologicalSpace M] [ChartedSpace Plane M]
+  [IsManifold planeModel ∞ M] [CompactSpace M]
+namespace SmoothingAtlas
+variable (A : SmoothingAtlas M)
+
+lemma phase_gram_ne_zero (i : A.centers)
+    (e : OpenPartialHomeomorph JetPolynomial.Base JetPolynomial.Base)
+    (he : ContDiff ℝ ∞ e) (hi : ContDiff ℝ ∞ e.symm)
+    {g : SmoothMetric M} {F : M → Space} (hF : IsSmoothIsometricImmersion M g F)
+    {p : SmallModes.Base} (hp : baseEquiv.symm p ∈ e.target)
+    (ha : A.chartWeight i (e.symm (baseEquiv.symm p)) ≠ 0) :
+    gramDet (coordDeriv dx (A.phaseRealChartMap i e.symm F) p)
+      (coordDeriv dy (A.phaseRealChartMap i e.symm F) p) ≠ 0 := by
+  rw [A.phaseMetricRead_isometry_det i hi hF ha]
+  have hh := (A.phaseMetricRead_positive i g e he hi hp ha).2.ne'
+  simpa only [baseEquiv.apply_symm_apply] using hh
+
+/-- This cutoff is selected from the curve and phase chart before selecting
+any later isometric immersion. -/
+lemma phase_curve_cutoff (i : A.centers)
+    (e : OpenPartialHomeomorph JetPolynomial.Base JetPolynomial.Base)
+    (hi : ContDiff ℝ ∞ e.symm)
+    {K : Set SmallModes.Base} (hK : IsCompact K)
+    (hKt : ∀ p ∈ K, baseEquiv.symm p ∈ e.target)
+    (hKa : ∀ p ∈ K, A.chartWeight i (e.symm (baseEquiv.symm p)) ≠ 0) :
+    ∃ β : SmallModes.Base → ℝ, ContDiff ℝ ∞ β ∧ HasCompactSupport β ∧
+      (∀ p ∈ K, β p = 1) ∧ ∀ p ∈ tsupport β,
+        baseEquiv.symm p ∈ e.target ∧ A.chartWeight i (e.symm (baseEquiv.symm p)) ≠ 0 := by
+  let U : Set SmallModes.Base := baseEquiv.symm ⁻¹' e.target ∩
+    {p | A.chartWeight i (e.symm (baseEquiv.symm p)) ≠ 0}
+  have hU : IsOpen U := (e.open_target.preimage baseEquiv.symm.continuous).inter
+    (isOpen_ne.preimage ((A.chartWeight_smooth i).continuous.comp
+      (hi.continuous.comp baseEquiv.symm.continuous)))
+  obtain ⟨β,hβ,hβc,_,hβs,hβone⟩ := CollarVelocity.compact_cutoff hK hU
+    (fun p hp => ⟨hKt p hp,hKa p hp⟩)
+  exact ⟨β,hβ,hβc,hβone,fun p hp => hβs hp⟩
+
+def phaseCurveSecondField (i : A.centers)
+    (e : OpenPartialHomeomorph JetPolynomial.Base JetPolynomial.Base)
+    (β : SmallModes.Base → ℝ) (F : M → Space) (v w : SmallModes.Base → SmallModes.Base) : M → Space :=
+  restore (i : M) (A.outer i) (fun x => spaceCoordinates.symm
+    (β (baseEquiv (e x)) • realSecondForm (A.phaseRealChartMap i e.symm F)
+      (v (baseEquiv (e x))) (w (baseEquiv (e x))) (baseEquiv (e x))))
+
+lemma phaseCurveSecondField_smooth (i : A.centers)
+    (e : OpenPartialHomeomorph JetPolynomial.Base JetPolynomial.Base)
+    (he : ContDiff ℝ ∞ e) (hi : ContDiff ℝ ∞ e.symm)
+    {g : SmoothMetric M} {F : M → Space} (hF : IsSmoothIsometricImmersion M g F)
+    {β : SmallModes.Base → ℝ} (hβ : ContDiff ℝ ∞ β)
+    (hs : ∀ p ∈ tsupport β, baseEquiv.symm p ∈ e.target ∧
+      A.chartWeight i (e.symm (baseEquiv.symm p)) ≠ 0)
+    {v w : SmallModes.Base → SmallModes.Base} (hv : ContDiff ℝ ∞ v) (hw : ContDiff ℝ ∞ w) :
+    ContMDiff planeModel spaceModel ∞ (A.phaseCurveSecondField i e β F v w) := by
+  have hB : ContDiff ℝ ∞ (fun p => β p •
+      realSecondForm (A.phaseRealChartMap i e.symm F) (v p) (w p) p) := by
+    rw [contDiff_iff_contDiffAt]
+    intro p
+    by_cases hp : p ∈ tsupport β
+    · exact hβ.contDiffAt.smul (realSecondForm_field_smoothAt
+        (A.phaseRealChartMap_smooth i hi hF.1) hv hw (A.phase_gram_ne_zero i e he hi hF
+          (hs p hp).1 (hs p hp).2))
+    · apply (contDiffAt_const (c := (0 : Vec))).congr_of_eventuallyEq
+      filter_upwards [notMem_tsupport_iff_eventuallyEq.mp hp] with q hq
+      simp only [Pi.zero_apply] at hq
+      simp only [hq,zero_smul]
+  exact restore_smooth (i : M) (A.outer_smooth i) (A.outer_support i)
+    (spaceCoordinates.symm.contDiff.comp (hB.comp (baseEquiv.contDiff.comp he)))
+
+omit [CompactSpace M] in
+lemma phaseCurveSecondField_eq (i : A.centers)
+    (e : OpenPartialHomeomorph JetPolynomial.Base JetPolynomial.Base)
+    (β : SmallModes.Base → ℝ) (F : M → Space) (v w : SmallModes.Base → SmallModes.Base)
+    {p : M} (hp : p ∈ (chart (i : M)).source) (ho : A.outer i p = 1)
+    (hβ : β (baseEquiv (e (chart (i : M) p))) = 1) :
+    spaceCoordinates (A.phaseCurveSecondField i e β F v w p) =
+      realSecondForm (A.phaseRealChartMap i e.symm F)
+        (v (baseEquiv (e (chart (i : M) p)))) (w (baseEquiv (e (chart (i : M) p))))
+        (baseEquiv (e (chart (i : M) p))) := by
+  simp only [phaseCurveSecondField,restore,indicator_of_mem hp,ho,hβ,one_smul,
+    spaceCoordinates.apply_symm_apply]
+
+end SmoothingAtlas
+end ClosedSurfaceR4.FiniteOrderSmoothing
+
+end
+
+end OAI

lean/OAI/Geometry/SurfaceImmersion/Geometry/CurveSecondTransition.lean

@@ -0,0 +1,49 @@
+import OAI.Geometry.SurfaceImmersion.Atlas.PhaseTransitionVectors
+
+namespace OAI
+
+/-! A curve's global second-form representative agrees with its transported
+second form in the current primitive chart. -/
+noncomputable section
+open Set Filter Manifold
+open scoped ContDiff Topology
+namespace ClosedSurfaceR4.FiniteOrderSmoothing
+open SmallModes RealModes SurfaceJetCoordinates
+variable {M : Type*} [TopologicalSpace M] [ChartedSpace Plane M]
+  [IsManifold planeModel ∞ M] [CompactSpace M]
+namespace SmoothingAtlas
+
+lemma curveSecondField_transition (A B : SmoothingAtlas M)
+    (i : A.centers) (j : B.centers)
+    (e f : OpenPartialHomeomorph JetPolynomial.Base JetPolynomial.Base)
+    (he : ContDiff ℝ ∞ e) (hi : ContDiff ℝ ∞ e.symm)
+    (hf : ContDiff ℝ ∞ f) (hfi : ContDiff ℝ ∞ f.symm)
+    {g : SmoothMetric M} {F : M → Space} (hF : IsSmoothIsometricImmersion M g F)
+    (β : SmallModes.Base → ℝ)
+    {x : SmallModes.Base} (hx : x ∈ (surfacePhaseTransition (j : M) f (i : M) e).source)
+    (hwB : B.weight j ((surfacePhaseChart (j : M) f).symm x) ≠ 0)
+    (hwA : A.weight i ((surfacePhaseChart (j : M) f).symm x) ≠ 0)
+    (hβ : β x = 1) :
+    let T := surfacePhaseTransition (j : M) f (i : M) e
+    spaceCoordinates (B.phaseCurveSecondField j f β F (fun _ => dy) (fun _ => dy)
+      ((surfacePhaseChart (j : M) f).symm x)) =
+      realSecondForm (A.phaseRealChartMap i e.symm F)
+        (fderiv ℝ T x dy) (fderiv ℝ T x dy) (T x) := by
+  have hxj : x ∈ (surfacePhaseChart (j : M) f).target := hx.1
+  have hp := (surfacePhaseChart (j : M) f).map_target hxj
+  have hread := B.phaseCurveSecondField_eq j f β F (fun _ => dy) (fun _ => dy)
+    hp.1 (B.outer_one j _ (subset_tsupport (B.weight j) hwB)) (by
+      change β ((surfacePhaseChart (j : M) f) ((surfacePhaseChart (j : M) f).symm x)) = 1
+      rwa [(surfacePhaseChart (j : M) f).right_inv hxj])
+  have hr : baseEquiv (f (chart (j : M) ((surfacePhaseChart (j : M) f).symm x))) = x :=
+    (surfacePhaseChart (j : M) f).right_inv hxj
+  simp only [hr] at hread
+  rw [hread]
+  exact B.phase_secondForm_transition A j i f e hf hfi he hi hF hx hwB hwA dy dy
+
+end SmoothingAtlas
+end ClosedSurfaceR4.FiniteOrderSmoothing
+
+end
+
+end OAI

lean/OAI/Geometry/SurfaceImmersion/Geometry/CurveTransverseVector.lean

@@ -0,0 +1,46 @@
+import OAI.Geometry.SurfaceImmersion.Geometry.EuclideanSurfaceImageNull
+import Mathlib.LinearAlgebra.CrossProduct
+
+namespace OAI
+
+/-! A smooth curve in three-space admits one constant vector transverse
+to every nonzero velocity.  This uses the proved two-dimensional image estimate. -/
+noncomputable section
+open Set Filter MeasureTheory Matrix
+open scoped ContDiff Topology
+namespace ClosedSurfaceR4.FiniteOrderSmoothing
+open JetPolynomial (Base)
+
+theorem exists_curve_transverse_vector (v : ℝ → (Fin 3 → ℝ))
+    (hv : ContDiff ℝ ∞ v) :
+    ∃ a : Fin 3 → ℝ, ∀ t r : ℝ, r • v t ≠ a := by
+  let E := EuclideanSpace.equiv (Fin 3) ℝ
+  let f : Base → ProjectionTarget 3 := fun x => E.symm (x 0 • v (x 1))
+  have hf : ContDiff ℝ ∞ f :=
+    E.symm.contDiff.comp ((contDiff_apply ℝ ℝ 0).smul (hv.comp (contDiff_apply ℝ ℝ 1)))
+  have hn : volume (range f) = 0 := euclidean_surface_image_null f hf
+  have hae : ∀ᵐ x ∂volume, x ∉ range f := by
+    simp only [ae_iff,not_not]
+    exact hn
+  obtain ⟨a,_,ha⟩ := (Measure.dense_of_ae hae).inter_open_nonempty
+    univ isOpen_univ Set.univ_nonempty
+  refine ⟨E a,?_⟩
+  intro t r heq
+  apply ha
+  refine ⟨![r,t],?_⟩
+  change E.symm (r • v t) = a
+  rw [heq,E.symm_apply_apply]
+
+lemma curve_transverse_vector_independent {v a : Fin 3 → ℝ}
+    (hv : v ≠ 0) (ha : ∀ r : ℝ, r • v ≠ a) : LinearIndependent ℝ ![v,a] :=
+  (LinearIndependent.pair_iff' hv).mpr ha
+
+lemma curve_transverse_cross_ne_zero {v a : Fin 3 → ℝ}
+    (hv : v ≠ 0) (ha : ∀ r : ℝ, r • v ≠ a) : v ⨯₃ a ≠ 0 :=
+  crossProduct_ne_zero_iff_linearIndependent.mpr (curve_transverse_vector_independent hv ha)
+
+end ClosedSurfaceR4.FiniteOrderSmoothing
+
+end
+
+end OAI

lean/OAI/Geometry/SurfaceImmersion/Geometry/CycleCorrectedGeometry.lean

@@ -0,0 +1,341 @@
+import OAI.Geometry.SurfaceImmersion.Geometry.ReferenceCorrectedFamily
+import OAI.Geometry.SurfaceImmersion.Primitive.CircularCycleMetrics
+import OAI.Geometry.SurfaceImmersion.Geometry.IndependentRadiusBox
+import OAI.Geometry.SurfaceImmersion.Primitive.PreparedCircularFamilyGeometry
+
+namespace OAI
+
+/-! Reference charts give the generic finite geometry for any number of
+cycles without shrinking the admissible chart radii after that number is
+chosen. The actual corrected families are then attached to those circles. -/
+noncomputable section
+open Set Filter Manifold Bundle
+open scoped ContDiff Topology BigOperators
+namespace ClosedSurfaceR4.FiniteOrderSmoothing
+open SmallModes PhaseGeometry SurfaceJetCoordinates
+variable {M : Type*} [TopologicalSpace M] [ChartedSpace Plane M]
+  [IsManifold planeModel ∞ M] [CompactSpace M] [T2Space M]
+local instance cycleGeometryFiberNormed : NormedAddCommGroup TensorFiber := inferInstance
+local instance cycleGeometryFiberSpace : NormedSpace ℝ TensorFiber := inferInstance
+local instance cycleGeometryDualAdd : ∀ p : M, ContinuousAdd (TangentSpace planeModel p →L[ℝ] ℝ) := fun _ => inferInstance
+local instance cycleGeometryDualSmul : ∀ p : M, ContinuousSMul ℝ (TangentSpace planeModel p →L[ℝ] ℝ) := fun _ => inferInstance
+local instance cycleGeometrySectionNormed (p : M) : NormedAddCommGroup (CovariantTwoTensor p) :=
+  inferInstanceAs (NormedAddCommGroup TensorFiber)
+local instance cycleGeometrySectionSpace (p : M) : NormedSpace ℝ (CovariantTwoTensor p) :=
+  inferInstanceAs (NormedSpace ℝ TensorFiber)
+namespace ReferenceCircularAtlas
+variable {A : SmoothingAtlas M} {gref g : SmoothMetric M} {c C : ℝ}
+  (d : ReferenceCircularAtlas A gref g c C)
+
+/-- Use the already selected full-disk reference charts, for arbitrarily many
+copies, rather than choosing a new admissible radius after the copy count. -/
+theorem finite_copy_geometry {ι : Type*} [Fintype ι] [DecidableEq ι]
+    (index : ι → d.B.centers) (component : ι → Fin 3)
+    (lo hi : ι → ℝ) (hlo : ∀ a, 0 < lo a) (hlohi : ∀ a, lo a < hi a)
+    (hhi : ∀ a, hi a < d.radius (index a))
+    {eta : ℝ} (heta : 0 < eta) :
+    ∃ q : CircularFamilyGeometry d.B ι,
+      (∀ a, lo a < q.radius a ∧ q.radius a < hi a) ∧
+      (∀ a, (q.curves a).index = index a) ∧
+      (∀ a, q.outerRadius a = d.radius (index a)) ∧
+      (∀ a, q.chartRadius a = d.radius (index a)) ∧
+      (∀ a, q.convexPart a = d.L (index a)) ∧
+      (∀ a, ‖q.linearPart a-(d.P (index a)).ξ (component a)‖ < eta) ∧
+      ∀ a, q.linearPart a ∈ Metric.closedBall ((d.P (index a)).ξ (component a))
+        (d.epsilon (index a)) := by
+  classical
+  let eps : ι → ℝ := fun a => min eta (d.epsilon (index a))
+  let U : Set (ι → Base) := {ell | ∀ a, ‖ell a-(d.P (index a)).ξ (component a)‖ < eps a}
+  have hU : IsOpen U := by
+    simp only [U,ofPred_forall]
+    apply isOpen_iInter_of_finite
+    intro a
+    exact isOpen_lt (((continuous_apply a).sub continuous_const).norm) continuous_const
+  have hne : U.Nonempty := by
+    refine ⟨fun a => (d.P (index a)).ξ (component a),?_⟩
+    intro a
+    simpa only [sub_self,norm_zero] using lt_min heta (d.epsilon_pos (index a))
+  obtain ⟨r,ell,hell,hr,hcross,htriple,htrans,htangent,hind⟩ :=
+    d.B.finite_circular_preparation index (fun a => d.radius (index a)) lo hi
+      (fun a => d.L (index a)) hlo hlohi hhi
+      (fun a => d.weight_positive (index a)) (fun a => d.region (index a)) U hU hne
+  have hball (a : ι) : ell a ∈ Metric.closedBall ((d.P (index a)).ξ (component a))
+      (d.epsilon (index a)) := by
+    rw [Metric.mem_closedBall,dist_eq_norm]
+    exact ((hell a).trans_le (min_le_right _ _)).le
+  choose e he hei hephase hecover using fun a => d.charts (index a) (component a) (ell a) (hball a)
+  have hrpos (a : ι) : 0 < r a := (hlo a).trans (hr a).1
+  have hrr (a : ι) : r a < d.radius (index a) := (hr a).2.trans (hhi a)
+  have hrreg (a : ι) : circularCoordinateRegion (index a : M) (r a) ⊆
+      (coordinateChart (index a : M)).target := by
+    intro x hx
+    change circularRadiusSquared (coordinateChart (index a : M) (index a)) x ≤ (r a)^2 at hx
+    exact d.region (index a) (hx.trans (by nlinarith [hrpos a,hrr a]))
+  have hcover (a : ι) : ∀ x ∈ circularCoordinateRegion (index a : M) (r a),
+      baseEquiv.symm x ∈ (e a).source := by
+    intro x hx
+    apply hecover a x
+    change circularRadiusSquared (coordinateChart (index a : M) (index a)) x ≤ (r a)^2 at hx
+    change circularRadiusSquared (coordinateChart (index a : M) (index a)) x ≤ (d.radius (index a))^2
+    exact hx.trans (by nlinarith [hrpos a,hrr a])
+  let curves : ι → PhaseBoundaryCurve d.B := fun a =>
+    d.B.circularPhaseBoundaryCurve (index a) (hrpos a) (by nlinarith [hrpos a,hrr a])
+      (d.weight_positive (index a)) (hrreg a) (e a) (he a) (hei a) (hcover a)
+  have hcarrier (a : ι) : (curves a).carrier = circularBoundary (index a : M) (r a) := rfl
+  have hsub : boundaryCrossingSet curves univ ⊆ circularCrossingSet (fun a => (index a : M)) r := by
+    rintro p ⟨a,_,b,_,hab,hpa,hpb⟩
+    exact mem_iUnion.mpr ⟨⟨(a,b),hab⟩,⟨hpa,hpb⟩⟩
+  let q : CircularFamilyGeometry d.B ι := {
+    curves := curves, radius := r, outerRadius := fun a => d.radius (index a),
+    chartRadius := fun a => d.radius (index a), linearPart := ell, convexPart := fun a => d.L (index a),
+    radius_pos := hrpos, radius_outer := fun a => by nlinarith [hrpos a,hrr a],
+    radius_chart := hrr, weight_positive := fun a => d.weight_positive (index a),
+    region := hrreg, carrier := hcarrier, cover := hcover, first_coordinate := hephase,
+    pair_finite := fun a b hab => hcross.subset (fun _ hp => hsub
+      (boundaryCrossingSet_pair curves (mem_univ a) (mem_univ b) hab hp.1 hp.2)),
+    triple_empty := htriple, tangencies_finite := htangent,
+    independent := fun a b hab p hp hpa hpb => hind a b hab p (hsub hp) hpa hpb }
+  exact ⟨q,hr,(fun _ => rfl),(fun _ => rfl),(fun _ => rfl),(fun _ => rfl),
+    (fun a => (hell a).trans_le (min_le_left _ _)),hball⟩
+
+end ReferenceCircularAtlas
+
+namespace SmoothPrimitiveFamily
+variable {u : ∀ p : M, CovariantTwoTensor p} {ι κ : Type*} [Fintype ι] [Fintype κ]
+
+/-- Reindex only the genuine finite family, preserving its exact sum. -/
+def reindex (f : SmoothPrimitiveFamily ι u) (e : κ ≃ ι) : SmoothPrimitiveFamily κ u where
+  amplitude := f.amplitude ∘ e
+  phase := f.phase ∘ e
+  smoothAmplitude a := f.smoothAmplitude (e a)
+  smoothPhase a := f.smoothPhase (e a)
+  sum_eq p := by
+    simpa only [Function.comp_apply] using
+      (e.sum_comp (fun a => (f.amplitude a p)^2 •
+        SmoothingAtlas.phaseDifferentialSquare (f.phase a) p)).trans (f.sum_eq p)
+
+end SmoothPrimitiveFamily
+
+namespace CircularFamilyGeometry
+variable {B : SmoothingAtlas M} {ι : Type*} [Fintype ι]
+
+/-- The actual restored phase, allowing repeated copies of a chart. -/
+def copiedPhases (q : CircularFamilyGeometry B ι) (a : ι) : M → ℝ :=
+  B.circularPhase (q.curves a).index (q.linearPart a) (q.convexPart a)
+
+omit [CompactSpace M] [T2Space M] in
+lemma copiedPhases_germ (q : CircularFamilyGeometry B ι)
+    (houter : ∀ i p, p ∈ tsupport (B.weight i) → B.outer i =ᶠ[𝓝 p] (fun _ => 1))
+    (a : ι) {p : M}
+    (hp : p ∈ circularCoordinateDisk ((q.curves a).index : M) (q.radius a)) :
+    q.copiedPhases a =ᶠ[𝓝 p]
+      (fun x => ((q.curves a).phase (chart ((q.curves a).index : M) x)) 0) := by
+  have hw : B.weight (q.curves a).index p ≠ 0 := by
+    apply ne_of_gt ((q.weight_positive a p).mpr ?_)
+    exact ⟨hp.1,hp.2.trans (q.radius_outer a)⟩
+  let loc : B.centers → Fin 3 → Base → ℝ := fun i _ =>
+    centeredConvexPhase (q.linearPart a) (q.convexPart a) (coordinateChart (i : M) i)
+  have hg := B.curvedAtlasPhase_eventually loc ((q.curves a).index,0)
+    (houter (q.curves a).index) (subset_tsupport _ hw)
+  change q.copiedPhases a =ᶠ[𝓝 p]
+    (centeredConvexPhase (q.linearPart a) (q.convexPart a)
+      (coordinateChart ((q.curves a).index : M) (q.curves a).index) ∘
+        coordinateChart ((q.curves a).index : M)) at hg
+  apply hg.trans
+  apply Filter.Eventually.of_forall
+  intro x
+  have hh := q.first_coordinate a (chart ((q.curves a).index : M) x)
+  change ((q.curves a).phase (chart ((q.curves a).index : M) x)) 0 = _ at hh
+  exact hh.symm
+
+omit [CompactSpace M] [T2Space M] in
+/-- Attach cycle amplitudes without changing any selected generic geometry. -/
+theorem with_cycle_families {N m : ℕ} (q : CircularFamilyGeometry B (Fin (N*m)))
+    {u : ∀ p : M, CovariantTwoTensor p}
+    (f : Fin N → SmoothPrimitiveFamily (Fin m) u) (hN : 0 < N)
+    (hamp : ∀ k a p, 0 ≤ (f k).amplitude a p)
+    (hpos : ∀ a p, 0 < (f a.divNat).amplitude a.modNat p ↔
+      p ∈ circularCoordinateDisk ((q.curves a).index : M) (q.radius a))
+    (hphase : ∀ a, (f a.divNat).phase a.modNat = q.copiedPhases a)
+    (houter : ∀ i p, p ∈ tsupport (B.weight i) → B.outer i =ᶠ[𝓝 p] (fun _ => 1)) :
+    ∃ D : CircularPrimitiveFamily B (Fin (N*m)),
+      D.curves = q.curves ∧ D.radius = q.radius ∧ D.outerRadius = q.outerRadius ∧
+      D.chartRadius = q.chartRadius ∧ D.linearPart = q.linearPart ∧ D.convexPart = q.convexPart ∧
+      (∀ a p, D.amplitude a p = (f a.divNat).cycleAmplitude N a.modNat p) ∧
+      (∀ a, D.phase a = (f a.divNat).phase a.modNat) ∧ D.totalTensor = u := by
+  let amp := fun a : Fin (N*m) => (f a.divNat).cycleAmplitude N a.modNat
+  let phi := fun a : Fin (N*m) => (f a.divNat).phase a.modNat
+  have ha : ∀ a, ContMDiff planeModel 𝓘(ℝ) ∞ (amp a) :=
+    fun a => (f a.divNat).cycleAmplitude_smooth N a.modNat
+  have hp : ∀ a, ContMDiff planeModel 𝓘(ℝ) ∞ (phi a) :=
+    fun a => (f a.divNat).smoothPhase a.modNat
+  have hn : ∀ a p, 0 ≤ amp a p := fun a p =>
+    div_nonneg (hamp _ _ _) (Real.sqrt_nonneg _)
+  have hpos' : ∀ a p, 0 < amp a p ↔
+      p ∈ circularCoordinateDisk ((q.curves a).index : M) (q.radius a) := by
+    intro a p
+    exact ((f a.divNat).cycleAmplitude_pos_iff hN a.modNat p).trans (hpos a p)
+  have hg : ∀ a p, p ∈ circularCoordinateDisk ((q.curves a).index : M) (q.radius a) →
+      phi a =ᶠ[𝓝 p] (fun x => ((q.curves a).phase (chart ((q.curves a).index : M) x)) 0) := by
+    intro a p hpa
+    change (f a.divNat).phase a.modNat =ᶠ[𝓝 p] _
+    rw [hphase a]
+    exact q.copiedPhases_germ houter a hpa
+  let D := q.withAmplitudes amp phi ha hp hn hpos' hg
+  refine ⟨D,rfl,rfl,rfl,rfl,rfl,rfl,(fun _ _ => rfl),(fun _ => rfl),?_⟩
+  exact D.totalTensor_cycle f (fun _ _ => rfl) (fun _ => rfl) hN
+
+end CircularFamilyGeometry
+
+namespace ReferenceCircularAtlas
+variable {A : SmoothingAtlas M} {gref g : SmoothMetric M} {c C : ℝ}
+  (d : ReferenceCircularAtlas A gref g c C)
+
+def cycleLinearParts {N m : ℕ} (e : Fin m ≃ (d.B.centers × Fin 3))
+    (q : CircularFamilyGeometry d.B (Fin (N*m))) (k : Fin N) (i : d.B.centers) (j : Fin 3) : Base :=
+  q.linearPart (finProdFinEquiv (k,e.symm (i,j)))
+
+def cycleWeights {N m : ℕ} (e : Fin m ≃ (d.B.centers × Fin 3))
+    (q : CircularFamilyGeometry d.B (Fin (N*m))) (k : Fin N) (b : d.B.centers × Fin 3) : M → ℝ :=
+  shrinkingCircularWeight (b.1 : M) (d.B.weight b.1) (d.radius b.1)
+    (q.radius (finProdFinEquiv (k,e.symm b)))
+
+/-- One radius box and map neighborhood precede every cycle count. The
+output retains the actual amplitude formula and fixed cutoff bounds, so
+the uniform C1 estimate can be applied without choosing further constants. -/
+theorem corrected_cycles {F : M → Space}
+    (hF : ContMDiff planeModel spaceModel ∞ F) (r : ℝ)
+    (href : gref.inner = g.inner-inducedTensor (r • F))
+    {phaseBound weightBound mapBound : ℝ}
+    (hphaseBound : 0 < phaseBound) (hweightBound : 0 < weightBound)
+    (hmapBound : 0 < mapBound)
+    {m : ℕ} (e : Fin m ≃ (d.B.centers × Fin 3)) :
+    ∃ (mapTol delta : ℝ) (W : ℕ → ℝ),
+      0 < mapTol ∧ mapTol ≤ mapBound ∧ 0 < delta ∧
+      (∀ i, delta ≤ d.radius i/2) ∧ (∀ j, 0 ≤ W j) ∧
+      ∀ N : ℕ, 0 < N →
+      ∃ q : CircularFamilyGeometry d.B (Fin (N*m)),
+        (∀ a, (q.curves a).index = (e a.modNat).1) ∧
+        (∀ a, q.outerRadius a = d.radius (e a.modNat).1) ∧
+        (∀ a, q.chartRadius a = d.radius (e a.modNat).1) ∧
+        (∀ a, q.convexPart a = d.L (e a.modNat).1) ∧
+        (∀ a, ‖q.linearPart a‖ ≤ ‖(d.P (e a.modNat).1).ξ‖+1) ∧
+        (∀ a, ‖q.linearPart a-(d.P (e a.modNat).1).ξ (e a.modNat).2‖ < phaseBound) ∧
+        (∀ k b j, d.B.WeightedBound 1 j (W j) (d.cycleWeights e q k b)) ∧
+        (∀ k b p, |d.cycleWeights e q k b p-d.B.weight b.1 p| < weightBound) ∧
+        ∀ G : M → Space, ContMDiff planeModel spaceModel ∞ G →
+          A.WeightedBound 1 1 mapTol (G-F) →
+        ∃ (f : Fin N → SmoothPrimitiveFamily (Fin m) (g.inner-inducedTensor (r • G)))
+          (D : CircularPrimitiveFamily d.B (Fin (N*m))),
+          (∀ k a, (f k).amplitude a = d.B.correctedPrimitiveAmplitude d.basis
+            (d.cycleWeights e q k) (d.perturbedPhases (d.cycleLinearParts e q k))
+            (g.inner-inducedTensor (r • G)) (e a)) ∧
+          (∀ k a, (f k).phase a = d.perturbedPhases (d.cycleLinearParts e q k) (e a)) ∧
+          D.curves = q.curves ∧ D.radius = q.radius ∧ D.outerRadius = q.outerRadius ∧
+          D.chartRadius = q.chartRadius ∧ D.linearPart = q.linearPart ∧ D.convexPart = q.convexPart ∧
+          (∀ a p, D.amplitude a p = (f a.divNat).cycleAmplitude N a.modNat p) ∧
+          (∀ a, D.phase a = (f a.divNat).phase a.modNat) ∧
+          D.totalTensor = g.inner-inducedTensor (r • G) := by
+  classical
+  obtain ⟨pt,wt,mt,hpt,hwt,hmt,hcorrect⟩ := d.corrected_smooth_family hF r href
+  obtain ⟨delta,W,hdelta,hdeltaR,hW,hweights⟩ := d.B.independent_radius_box
+    (fun b : d.B.centers × Fin 3 => b.1) (fun b => d.radius b.1)
+    (fun b => d.weight_nonneg b.1) (fun b => d.radius_pos b.1) (fun b => d.region b.1)
+    (fun b => d.weight_positive b.1) (lt_min hwt hweightBound)
+  refine ⟨min mt mapBound,delta,W,lt_min hmt hmapBound,min_le_right _ _,hdelta,
+    (fun i => hdeltaR (i,0)),hW,?_⟩
+  intro N hN
+  let ind := fun a : Fin (N*m) => (e a.modNat).1
+  let cmp := fun a : Fin (N*m) => (e a.modNat).2
+  let lo := fun a : Fin (N*m) => d.radius (ind a)-delta
+  let hi := fun a : Fin (N*m) => d.radius (ind a)-delta/2
+  have hlo (a : Fin (N*m)) : 0 < lo a := by
+    have hh := hdeltaR (ind a,cmp a)
+    have hp := d.radius_pos (ind a)
+    dsimp only [lo]
+    linarith
+  have hmid (a : Fin (N*m)) : lo a < hi a := by dsimp only [lo,hi]; linarith
+  have hhi (a : Fin (N*m)) : hi a < d.radius (ind a) := by dsimp only [hi]; linarith
+  obtain ⟨q,hr,hindex,houter,hchart,hL,hell,hball⟩ :=
+    d.finite_copy_geometry ind cmp lo hi hlo hmid hhi (lt_min hpt hphaseBound)
+  let copy := fun (k : Fin N) (b : d.B.centers × Fin 3) => finProdFinEquiv (k,e.symm b)
+  have hcopy (k : Fin N) (b : d.B.centers × Fin 3) :
+      (copy k b).divNat = k ∧ e (copy k b).modNat = b := by
+    have hh := Prod.mk.inj (finProdFinEquiv.symm_apply_apply (k,e.symm b))
+    exact ⟨hh.1,by rw [hh.2,e.apply_symm_apply]⟩
+  have hcopy' (a : Fin (N*m)) : copy a.divNat (e a.modNat) = a := by
+    simp only [copy,e.symm_apply_apply]
+    exact finProdFinEquiv.apply_symm_apply a
+  let rr := fun (k : Fin N) (b : d.B.centers × Fin 3) => q.radius (copy k b)
+  let ell := d.cycleLinearParts e q
+  let psi := d.cycleWeights e q
+  have hrr (k : Fin N) (b : d.B.centers × Fin 3) :
+      d.radius b.1-delta < rr k b ∧ rr k b < d.radius b.1-delta/2 := by
+    have hh := hr (copy k b)
+    simpa only [lo,hi,ind,(hcopy k b).2,rr] using hh
+  have hpsi (k : Fin N) := hweights (rr k) (hrr k)
+  have hrsmall (k : Fin N) (b : d.B.centers × Fin 3) : (rr k b)^2 < (d.radius b.1)^2 := by
+    have hh := hrr k b
+    have hp := (hpsi k).1 b
+    have hR := d.radius_pos b.1
+    nlinarith
+  have hnorm (a : Fin (N*m)) : ‖q.linearPart a‖ ≤ ‖(d.P (ind a)).ξ‖+1 :=
+    (d.parameters (ind a) (cmp a) (q.linearPart a) (hball a)).2
+  refine ⟨q,hindex,houter,hchart,hL,hnorm,
+    (fun a => (hell a).trans_le (min_le_right _ _)),
+    (fun k => (hpsi k).2.2.2.2.2),
+    (fun k b p => ((hpsi k).2.2.2.2.1 b p).trans_le (min_le_right _ _)),?_⟩
+  intro G hG hGF
+  have hnon (k : Fin N) (b : d.B.centers × Fin 3) (p : M) : 0 ≤ psi k b p :=
+    (shrinkingCircularWeight_nonneg_le (b.1 : M) (d.B.weight b.1)
+      (d.weight_nonneg b.1) (hrsmall k b).le p).1
+  have hsupp (k : Fin N) (b : d.B.centers × Fin 3) :
+      tsupport (psi k b) ⊆ tsupport (d.B.weight b.1) := by
+    apply closure_mono
+    intro p hp
+    change psi k b p ≠ 0 at hp
+    change d.B.weight b.1 p ≠ 0
+    intro hz
+    exact hp (by simp only [psi,cycleWeights,shrinkingCircularWeight,hz,zero_mul])
+  have hell' (k : Fin N) (i : d.B.centers) (j : Fin 3) :
+      ‖ell k i j-(d.P i).ξ j‖ < pt := by
+    have hh := (hell (copy k (i,j))).trans_le (min_le_left _ _)
+    simpa only [ind,cmp,(hcopy k (i,j)).2,ell,cycleLinearParts] using hh
+  choose fc hphase hamp hnonamp hposamp hsamp using fun k : Fin N =>
+    hcorrect (ell k) (psi k) (hell' k) (hpsi k).2.1 (hnon k) (hsupp k)
+      (fun b p => ((hpsi k).2.2.2.2.1 b p).trans_le (min_le_left _ _)) G hG
+      (fun i => (hGF i).mono_const (min_le_left _ _))
+  let f := fun k => (fc k).reindex e
+  have hphase' (a : Fin (N*m)) : (f a.divNat).phase a.modNat = q.copiedPhases a := by
+    change (fc a.divNat).phase (e a.modNat) = _
+    rw [hphase a.divNat]
+    change d.B.circularPhase (e a.modNat).1
+      (ell a.divNat (e a.modNat).1 (e a.modNat).2) (d.L (e a.modNat).1) = _
+    rw [show ell a.divNat (e a.modNat).1 (e a.modNat).2 = q.linearPart a from by
+      change q.linearPart (copy a.divNat (e a.modNat)) = q.linearPart a
+      rw [hcopy' a]]
+    simp only [CircularFamilyGeometry.copiedPhases,hindex a,hL a,ind]
+  have hpositive (a : Fin (N*m)) (p : M) :
+      0 < (f a.divNat).amplitude a.modNat p ↔
+        p ∈ circularCoordinateDisk ((q.curves a).index : M) (q.radius a) := by
+    change 0 < (fc a.divNat).amplitude (e a.modNat) p ↔ _
+    rw [hposamp a.divNat (e a.modNat) p]
+    have hh := (hpsi a.divNat).2.2.1 (e a.modNat) p
+    change 0 < psi a.divNat (e a.modNat) p ↔ _ at hh
+    simpa only [rr,hcopy' a,hindex a,ind] using hh
+  obtain ⟨D,hD⟩ := q.with_cycle_families f hN
+    (fun k a p => hnonamp k (e a) p) hpositive hphase' d.outer
+  refine ⟨f,D,?_,?_,hD⟩
+  · intro k a
+    change (fc k).amplitude (e a) = _
+    exact congrFun (hamp k) (e a)
+  · intro k a
+    change (fc k).phase (e a) = _
+    exact congrFun (hphase k) (e a)
+
+end ReferenceCircularAtlas
+end ClosedSurfaceR4.FiniteOrderSmoothing
+
+end
+
+end OAI

lean/OAI/Geometry/SurfaceImmersion/Geometry/DegreeOneReachability.lean

@@ -0,0 +1,40 @@
+import OAI.Geometry.SurfaceImmersion.Geometry.CurveIncidenceGraph
+
+namespace OAI
+
+/-! A finite graph of degrees one and two joins each degree-one vertex
+to a distinct degree-one vertex by a simple path. -/
+noncomputable section
+open Set
+attribute [local instance] Classical.propDecidable
+namespace ClosedSurfaceR4.FiniteOrderSmoothing
+
+theorem degree_one_reaches_degree_one {A : Type*} [Fintype A]
+    (G : SimpleGraph A) (hdegrees : ∀ x, G.degree x = 1 ∨ G.degree x = 2)
+    (p : A) (hp : G.degree p = 1) :
+    ∃ q : A, q ≠ p ∧ G.degree q = 1 ∧ Nonempty (G.Path p q) := by
+  classical
+  let C : Set A := {x | G.Reachable p x}
+  let H := G.induce C
+  let p' : C := ⟨p,SimpleGraph.Reachable.rfl⟩
+  have hdegree (x : C) : H.degree x = G.degree x.val :=
+    G.degree_induce_of_neighborSet_subset (fun _ hy => x.property.trans hy.reachable)
+  have hodd : Odd (H.degree p') := by rw [hdegree,hp]; decide
+  obtain ⟨q,hne,hq⟩ := H.exists_ne_odd_degree_of_exists_odd_degree p' hodd
+  have hqp : q.val ≠ p := by
+    intro he
+    exact hne (Subtype.ext he)
+  have hq1 : G.degree q.val = 1 := by
+    rw [hdegree] at hq
+    rcases hdegrees q.val with h | h
+    · exact h
+    · rw [h] at hq
+      norm_num at hq
+  obtain ⟨w,hw⟩ := q.property.exists_isPath
+  exact ⟨q.val,hqp,hq1,⟨⟨w,hw⟩⟩⟩
+
+end ClosedSurfaceR4.FiniteOrderSmoothing
+
+end
+
+end OAI

lean/OAI/Geometry/SurfaceImmersion/Geometry/DensityNormalizedPath.lean

@@ -0,0 +1,47 @@
+import OAI.Geometry.SurfaceImmersion.Primitive.LoopDensityMoments
+import OAI.Geometry.SurfaceImmersion.Primitive.PositiveDensityTurns
+
+namespace OAI
+
+/-! Actual smooth unit-circle loops with the prescribed uniform mean. -/
+noncomputable section
+open Set
+open scoped ContDiff
+
+namespace ClosedSurfaceR4.LoopDensity
+
+variable {B : Type} [NormedAddCommGroup B] [NormedSpace ℝ B] [FiniteDimensional ℝ B]
+
+def normalizedPath (ρ : B × ℝ → ℝ) (p : B → ℝ → Plane) : B × ℝ → Plane :=
+  PositiveDensity.reparametrize ρ (fun z => p z.1 z.2)
+
+theorem normalizedPath_properties {ρ : B × ℝ → ℝ} {p : B → ℝ → Plane}
+    {c : B → Plane} {U : Set B} (hU : IsOpen U)
+    (hρ : ContDiffOn ℝ ∞ ρ (U ×ˢ univ))
+    (hp : ContDiffOn ℝ ∞ (fun z : B × ℝ => p z.1 z.2) (U ×ˢ univ))
+    (hpos : ∀ b ∈ U, ∀ t, 0 < ρ (b, t))
+    (hper : ∀ b ∈ U, Function.Periodic (fun t => ρ (b, t)) 1)
+    (hpper : ∀ b ∈ U, Function.Periodic (p b) 1)
+    (hmom : ∀ b ∈ U, (∫ t in 0..1, ρ (b, t) • augment (p b t)) = augment (c b))
+    (hunit : ∀ b ∈ U, ∀ t, p b t 0 ^ 2 + p b t 1 ^ 2 = 1) :
+    ContDiffOn ℝ ∞ (normalizedPath ρ p) (U ×ˢ univ) ∧
+      (∀ b ∈ U, Function.Periodic (fun t => normalizedPath ρ p (b, t)) 1) ∧
+      (∀ b ∈ U, (∫ t in 0..1, normalizedPath ρ p (b, t)) = c b) ∧
+      ∀ b ∈ U, ∀ t, normalizedPath ρ p (b, t) 0 ^ 2 + normalizedPath ρ p (b, t) 1 ^ 2 = 1 := by
+  have hmm (b : B) (hb : b ∈ U) := mass_and_mean
+    (LocalPeriodicCalculus.smooth_slice hU hρ hb).continuous
+    (LocalPeriodicCalculus.smooth_slice hU hp hb).continuous (hmom b hb)
+  have hmass : ∀ b ∈ U, (∫ t in 0..1, ρ (b, t)) = 1 := fun b hb => (hmm b hb).1
+  refine ⟨PositiveDensity.reparametrize_smoothOn hU hρ hpos hper hmass hp, ?_, ?_, ?_⟩
+  · intro b hb
+    exact PositiveDensity.reparametrize_periodic hU hρ hpos hper hmass hpper hb
+  · intro b hb
+    exact (PositiveDensity.reparametrize_mean hU hρ hpos hper hmass hp hb).trans (hmm b hb).2
+  · intro b hb t
+    exact hunit b hb (PositiveDensity.inverseClock ρ b t)
+
+end ClosedSurfaceR4.LoopDensity
+
+end
+
+end OAI

lean/OAI/Geometry/SurfaceImmersion/Geometry/DirectionalJetBounds.lean

@@ -0,0 +1,67 @@
+import OAI.Geometry.SurfaceImmersion.Correction.WeightedPolynomialBounds
+
+namespace OAI
+
+/-! Higher directional jets of a controlled second jet lose one scale per
+additional derivative. These are the factors in the finite jet polynomials. -/
+noncomputable section
+open scoped ContDiff
+
+namespace ClosedSurfaceR4.WeightedEstimates
+
+variable {A E : Type*} [NormedAddCommGroup A] [NormedSpace ℝ A]
+  [NormedAddCommGroup E] [NormedSpace ℝ E]
+
+def iteratedDirectional : List A → (A → E) → A → E
+  | [], f => f
+  | v :: vs, f => fun x => fderiv ℝ (iteratedDirectional vs f) x v
+
+lemma contDiffOn_iteratedDirectional {U : Set A} (hU : IsOpen U) {f : A → E}
+    (hf : ContDiffOn ℝ ∞ f U) (vs : List A) :
+    ContDiffOn ℝ ∞ (iteratedDirectional vs f) U := by
+  induction vs with
+  | nil => exact hf
+  | cons v vs ih =>
+    exact (ih.fderiv_of_isOpen hU (by simp)).clm_apply contDiffOn_const
+
+lemma WeightedBound.iteratedDirectional {U : Set A} (hU : IsOpen U) {f : A → E}
+    {s C : ℝ} (hs : 0 < s) (hC : 0 ≤ C) (hf : ContDiffOn ℝ ∞ f U)
+    (vs : List A) (hv : ∀ v ∈ vs, ‖v‖ ≤ 1) (m : ℕ)
+    (hb : WeightedBound U s (m + vs.length) C f) :
+    WeightedBound U s m (C / s ^ vs.length) (iteratedDirectional vs f) := by
+  induction vs generalizing m with
+  | nil => simpa [ClosedSurfaceR4.WeightedEstimates.iteratedDirectional] using hb
+  | cons v vs ih =>
+    have he : m + (v :: vs).length = (m + 1) + vs.length := by simp; omega
+    have ht := ih (fun w hw => hv w (List.mem_cons_of_mem v hw)) (m + 1) (he ▸ hb)
+    have hd := ht.directional hU hs (contDiffOn_iteratedDirectional hU hf vs) v
+    apply hd.mono_const
+    have hn : ‖v‖ ≤ 1 := hv v (List.mem_cons_self ..)
+    have hc : 0 ≤ C / s ^ vs.length / s := by positivity
+    calc
+      ‖v‖ * (C / s ^ vs.length / s) ≤ C / s ^ vs.length / s := mul_le_of_le_one_left hc hn
+      _ = C / s ^ (v :: vs).length := by simp [pow_succ, div_div]
+
+/-- Products of higher-jet factors have a loss equal to the sum of their
+additional derivative orders. The sum is independent of the output order. -/
+lemma weighted_higher_jet_monomial {ι : Type*} {U : Set A} (hU : IsOpen U)
+    {s : ℝ} (hs : 0 < s) (a : Finset ι) (C : ι → ℝ) (vs : ι → List A)
+    (f : ι → A → ℝ) (m : ℕ) (hC : ∀ i ∈ a, 0 ≤ C i)
+    (hv : ∀ i ∈ a, ∀ v ∈ vs i, ‖v‖ ≤ 1)
+    (hf : ∀ i ∈ a, ContDiffOn ℝ ∞ (f i) U)
+    (hb : ∀ i ∈ a, WeightedBound U s (m + (vs i).length) (C i) (f i)) :
+    WeightedBound U s m
+      (((2 ^ m) ^ a.card * ∏ i ∈ a, C i) / s ^ (∑ i ∈ a, (vs i).length))
+      (fun x => ∏ i ∈ a, iteratedDirectional (vs i) (f i) x) := by
+  apply WeightedBound.finset_prod_losses hU.uniqueDiffOn hs a C (fun i => (vs i).length)
+    (fun i => iteratedDirectional (vs i) (f i)) hC
+  · intro i hi
+    exact contDiffOn_iteratedDirectional hU (hf i hi) (vs i)
+  · intro i hi
+    exact (hb i hi).iteratedDirectional hU hs (hC i hi) (hf i hi) (vs i) (hv i hi) m
+
+end ClosedSurfaceR4.WeightedEstimates
+
+end
+
+end OAI

lean/OAI/Geometry/SurfaceImmersion/Geometry/DisjointJetBounds.lean

@@ -0,0 +1,55 @@
+import OAI.Geometry.SurfaceImmersion.Atlas.QuadraticCutoffBounds
+import OAI.Geometry.Immersion.ClosedSurface.WeightedBounds
+
+namespace OAI
+
+/-! Disjoint supports prevent a factor counting the prescribed points in
+the finite-point preparation estimates. -/
+noncomputable section
+open Set Filter Metric
+open scoped ContDiff Topology BigOperators
+namespace ClosedSurfaceR4.SphericalJets
+variable {E V : Type*} [NormedAddCommGroup E] [NormedSpace ℝ E]
+  [NormedAddCommGroup V] [NormedSpace ℝ V]
+
+theorem disjoint_sum_jet_bound {ι : Type*} [DecidableEq ι] (s : Finset ι)
+    (q : ι → E → V) (hq : ∀ i ∈ s, ContDiff ℝ ∞ (q i))
+    (hdisj : (↑s : Set ι).Pairwise fun i j => Disjoint (tsupport (q i)) (tsupport (q j)))
+    {C : ℝ} (hC : 0 ≤ C) (j : ℕ)
+    (hb : ∀ i ∈ s, ∀ x, ‖iteratedFDeriv ℝ j (q i) x‖ ≤ C) (x : E) :
+    ‖iteratedFDeriv ℝ j (fun x => ∑ i ∈ s, q i x) x‖ ≤ C := by
+  rw [iteratedFDeriv_fun_sum_apply (fun i hi => ((hq i hi).of_le (by simp)).contDiffAt)]
+  have hz (i : ι) (hx : x ∉ tsupport (q i)) : iteratedFDeriv ℝ j (q i) x = 0 := by
+    by_contra hn
+    exact hx (tsupport_iteratedFDeriv_subset j (subset_closure hn))
+  by_cases hex : ∃ i ∈ s, x ∈ tsupport (q i)
+  · obtain ⟨i,hi,hxi⟩ := hex
+    have hzero : ∀ k ∈ s, k ≠ i → iteratedFDeriv ℝ j (q k) x = 0 := by
+      intro k hk hki
+      apply hz k
+      exact fun hxk => Set.disjoint_left.mp (hdisj hk hi hki) hxk hxi
+    rw [Finset.sum_eq_single i hzero (by simp [hi])]
+    exact hb i hi x
+  · have hzero : ∀ i ∈ s, iteratedFDeriv ℝ j (q i) x = 0 := by
+      intro i hi
+      exact hz i (fun hxi => hex ⟨i,hi,hxi⟩)
+    rw [Finset.sum_eq_zero hzero,norm_zero]
+    exact hC
+
+theorem disjoint_sum_weighted_bound {ι : Type*} [DecidableEq ι] (s : Finset ι)
+    (q : ι → E → V) (hq : ∀ i ∈ s, ContDiff ℝ ∞ (q i))
+    (hdisj : (↑s : Set ι).Pairwise fun i j => Disjoint (tsupport (q i)) (tsupport (q j)))
+    {C : ℝ} (hC : 0 ≤ C) {m : ℕ}
+    (hb : ∀ i ∈ s, WeightedEstimates.WeightedBound univ 1 m C (q i)) :
+    WeightedEstimates.WeightedBound univ 1 m C (fun x => ∑ i ∈ s, q i x) := by
+  intro j hj x hx
+  simp only [one_pow,one_mul,iteratedFDerivWithin_univ]
+  apply disjoint_sum_jet_bound s q hq hdisj hC j
+  intro i hi y
+  simpa only [one_pow,one_mul,iteratedFDerivWithin_univ] using hb i hi j hj y (mem_univ y)
+
+end ClosedSurfaceR4.SphericalJets
+
+end
+
+end OAI

lean/OAI/Geometry/SurfaceImmersion/Geometry/DisplacementSum.lean

@@ -0,0 +1,25 @@
+import OAI.Geometry.Immersion.ClosedSurface.QuadraticMean
+
+namespace OAI
+
+/-! Exact recombination of phase targets split by a finite partition. -/
+noncomputable section
+open scoped BigOperators
+namespace ClosedSurfaceR4.QuadraticMean
+
+lemma realMode_sum {n : ℕ} {ι : Type*} [Fintype ι] (θ : ℝ) (A : ι → CVec n) :
+    realMode θ (∑ i, A i) = ∑ i, realMode θ (A i) := by
+  funext k
+  simp [realMode,realPart,Finset.mul_sum]
+
+lemma displacement_sum {n : ℕ} {ι : Type*} [Fintype ι]
+    (τ : ℝ) (φ : Base → ℝ) (A : ι → Base → CVec n) :
+    displacement τ φ (fun x => ∑ i, A i x) = fun x => ∑ i, displacement τ φ (A i) x := by
+  funext x
+  exact realMode_sum (φ x / τ) (fun i => A i x)
+
+end ClosedSurfaceR4.QuadraticMean
+
+end
+
+end OAI

lean/OAI/Geometry/SurfaceImmersion/Geometry/EmbeddedCurveGraphPath.lean

@@ -0,0 +1,106 @@
+import OAI.Geometry.SurfaceImmersion.Geometry.CurveEdgeLocalization
+import OAI.Geometry.SurfaceImmersion.Geometry.InjectivePathConcatenation
+
+namespace OAI
+
+/-! A simple path in the interval incidence graph has an actual
+embedded realization in the compact curve. -/
+noncomputable section
+open Set Topology
+namespace ClosedSurfaceR4.FiniteOrderSmoothing
+variable {X : Type*} [TopologicalSpace X] [T2Space X]
+
+structure RealizedCurveWalk {V : Set X} {P : Finset (Set X)} {a b : V}
+    (p : (curveIncidenceGraph V P).Walk (Sum.inl a) (Sum.inl b)) where
+  path : Path a.val b.val
+  injective : a ≠ b → Function.Injective path
+  vertex : ∀ v : V, v.val ∈ range path → Sum.inl v ∈ p.support
+  edge : ∀ E : P, (range path ∩ E.val).Nonempty → Sum.inr E ∈ p.support
+
+theorem realize_simple_curve_walk {V : Set X} {P : Finset (Set X)}
+    (hP : ∀ E ∈ P, Disjoint E V)
+    (hdis : ∀ E ∈ P, ∀ F ∈ P, E ≠ F → Disjoint E F)
+    (w : ∀ E : P, CurveEdgeWitness V E.val)
+    {a b : V} (p : (curveIncidenceGraph V P).Walk (Sum.inl a) (Sum.inl b))
+    (hp : p.IsPath) : Nonempty (RealizedCurveWalk p) := by
+  classical
+  suffices ∀ n (a b : V) (p : (curveIncidenceGraph V P).Walk (Sum.inl a) (Sum.inl b)),
+      p.length = n → p.IsPath → Nonempty (RealizedCurveWalk p) by
+    exact this p.length a b p rfl hp
+  intro n
+  induction n using Nat.strong_induction_on with
+  | h n ih =>
+    intro a b p hn hp
+    cases p with
+    | nil =>
+      refine ⟨⟨Path.refl a.val,?_,?_,?_⟩⟩
+      · intro h
+        exact False.elim (h rfl)
+      · rintro v ⟨t,ht⟩
+        have hv : v = a := Subtype.ext ht.symm
+        simp [hv]
+      · rintro E ⟨x,⟨t,ht⟩,hxE⟩
+        have hx : x = a.val := ht.symm
+        exact False.elim (disjoint_left.mp (hP E.val E.property) hxE (hx ▸ a.property))
+    | cons h p =>
+      rename_i c
+      cases c with
+      | inl c => exact False.elim h
+      | inr E =>
+        cases p with
+        | cons h' q =>
+          rename_i c
+          cases c with
+          | inr F => exact False.elim h'
+          | inl c =>
+            obtain ⟨hp',haNot⟩ := (SimpleGraph.Walk.cons_isPath_iff _ _).mp hp
+            obtain ⟨hq,hENot⟩ := (SimpleGraph.Walk.cons_isPath_iff _ _).mp hp'
+            have hac : a ≠ c := by
+              intro he
+              apply haNot
+              simp [he]
+            obtain ⟨σ,hσ,hσrange⟩ := (w E).oriented_path (hP E.val E.property)
+              a.property c.property (fun he => hac (Subtype.ext he)) h h'
+            obtain ⟨hσV,hσE⟩ := curve_edge_path_localization hP hdis E (w E) a c hac h h' σ hσrange
+            by_cases hcb : c = b
+            · subst b
+              refine ⟨⟨σ,fun _ => hσ,?_,?_⟩⟩
+              · intro v hv
+                rcases hσV v hv with he | he <;> simp [he]
+              · intro F hF
+                have he := hσE F hF
+                simp [he]
+            · have hqn : q.length < n := by
+                simp only [SimpleGraph.Walk.length_cons] at hn
+                omega
+              obtain ⟨r⟩ := ih q.length hqn c b q rfl hq
+              have hmeet : range σ ∩ range r.path ⊆ {c.val} := by
+                rintro x ⟨hxσ,hxr⟩
+                by_cases hxE : x ∈ E.val
+                · exact False.elim (hENot (r.edge E ⟨x,hxr,hxE⟩))
+                · have hfront : x ∈ closure E.val \ E.val := ⟨hσrange ▸ hxσ,hxE⟩
+                  rw [curve_edge_frontier_endpoints (w E) (hP E.val E.property) a c hac h h'] at hfront
+                  rcases hfront with he | he
+                  · have ha : a.val ∈ range r.path := he ▸ hxr
+                    exact False.elim (haNot (by simp [r.vertex a ha]))
+                  · exact he
+              refine ⟨⟨σ.trans r.path,fun _ => path_trans_injective_of_range σ r.path hσ
+                (r.injective hcb) hmeet,?_,?_⟩⟩
+              · intro v hv
+                rw [Path.trans_range] at hv
+                rcases hv with hv | hv
+                · rcases hσV v hv with he | he <;> simp [he]
+                · simp [r.vertex v hv]
+              · intro F hF
+                obtain ⟨x,hx,hxF⟩ := hF
+                rw [Path.trans_range] at hx
+                rcases hx with hx | hx
+                · have he := hσE F ⟨x,hx,hxF⟩
+                  simp [he]
+                · simp [r.edge F ⟨x,hx,hxF⟩]
+
+end ClosedSurfaceR4.FiniteOrderSmoothing
+
+end
+
+end OAI

lean/OAI/Geometry/SurfaceImmersion/Geometry/EmbeddedOpenSubset.lean

@@ -0,0 +1,48 @@
+import OAI.Geometry.SurfaceImmersion.Whitney.CompactCurveArc
+
+namespace OAI
+
+/-! Open subarcs remain open in the ambient curve. -/
+noncomputable section
+open Set Topology
+namespace ClosedSurfaceR4.FiniteOrderSmoothing
+variable {X Y : Type*} [TopologicalSpace X] [TopologicalSpace Y]
+
+theorem embedded_open_subset {f : X → Y} (hf : IsEmbedding f)
+    {U S : Set X} (hU : IsOpen (f '' U)) (hS : IsOpen S) (hSU : S ⊆ U) :
+    IsOpen (f '' S) := by
+  obtain ⟨V,hV,hVS⟩ := hf.isInducing.isOpen_iff.mp hS
+  have heq : f '' S = (f '' U) ∩ V := by
+    ext y
+    constructor
+    · rintro ⟨x,hx,rfl⟩
+      exact ⟨⟨x,hSU hx,rfl⟩,by rw [← hVS] at hx; exact hx⟩
+    · rintro ⟨⟨x,hx,rfl⟩,hy⟩
+      exact ⟨x,by rw [← hVS]; exact hy,rfl⟩
+  rw [heq]
+  exact hU.inter hV
+
+variable {Z : Type*} [TopologicalSpace Z]
+
+def CompactCurveArc.openSubarc (A : CompactCurveArc Z) (u v : ℝ) : Set Z :=
+  A.map '' {t | u < (t:ℝ) ∧ (t:ℝ) < v}
+
+def CompactCurveArc.closedSubarc (A : CompactCurveArc Z) (u v : ℝ) : Set Z :=
+  A.map '' {t | u ≤ (t:ℝ) ∧ (t:ℝ) ≤ v}
+
+lemma CompactCurveArc.openSubarc_open (A : CompactCurveArc Z) {u v : ℝ}
+    (hu : A.left ≤ u) (hv : v ≤ A.right) : IsOpen (A.openSubarc u v) := by
+  apply embedded_open_subset A.embedding.isEmbedding A.interior_open
+  · exact isOpen_Ioo.preimage continuous_subtype_val
+  · intro t ht
+    exact ⟨hu.trans_lt ht.1,ht.2.trans_le hv⟩
+
+lemma CompactCurveArc.closedSubarc_compact (A : CompactCurveArc Z) (u v : ℝ) :
+    IsCompact (A.closedSubarc u v) := by
+  exact (IsClosed.isCompact (isClosed_Icc.preimage continuous_subtype_val)).image A.embedding.continuous
+
+end ClosedSurfaceR4.FiniteOrderSmoothing
+
+end
+
+end OAI

lean/OAI/Geometry/SurfaceImmersion/Geometry/EuclideanImmersionLocalInjective.lean

@@ -0,0 +1,41 @@
+import OAI.Geometry.SurfaceImmersion.Atlas.SurfaceChartRepresentative
+import Mathlib.Analysis.Calculus.InverseFunctionTheorem.ContDiff
+
+namespace OAI
+
+/-! A smooth finite-dimensional immersion is locally injective, using
+an actual linear left inverse followed by the inverse function theorem. -/
+noncomputable section
+open Set Filter Topology
+open scoped ContDiff
+namespace ClosedSurfaceR4.FiniteOrderSmoothing
+open JetPolynomial (Base)
+
+theorem euclidean_immersion_locally_injective {f : Base → ProjectionTarget 3}
+    (hf : ContDiff ℝ ∞ f) (p : Base) (hp : Function.Injective (fderiv ℝ f p)) :
+    ∃ U : Set Base, IsOpen U ∧ p ∈ U ∧ U.InjOn f := by
+  let L := fderiv ℝ f p
+  obtain ⟨A,hA⟩ := L.toLinearMap.exists_leftInverse_of_injective (LinearMap.ker_eq_bot.mpr hp)
+  let P : ProjectionTarget 3 →L[ℝ] Base := A.toContinuousLinearMap
+  have hPL : P.comp L = ContinuousLinearMap.id ℝ Base := by
+    apply ContinuousLinearMap.ext
+    intro v
+    exact congrArg (fun T : Base →ₗ[ℝ] Base => T v) hA
+  let g := P ∘ f
+  have hg : ContDiff ℝ ∞ g := P.contDiff.comp hf
+  have hd : HasFDerivAt g (ContinuousLinearEquiv.refl ℝ Base).toContinuousLinearMap p := by
+    have h := P.hasFDerivAt.comp p (hf.differentiable (by simp) p).hasFDerivAt
+    change HasFDerivAt g (P.comp L) p at h
+    rw [hPL] at h
+    exact h
+  let e := hg.contDiffAt.toOpenPartialHomeomorph g hd (by simp)
+  refine ⟨e.source,e.open_source,hg.contDiffAt.mem_toOpenPartialHomeomorph_source hd (by simp),?_⟩
+  intro x hx y hy hxy
+  apply e.injOn hx hy
+  exact congrArg P hxy
+
+end ClosedSurfaceR4.FiniteOrderSmoothing
+
+end
+
+end OAI

lean/OAI/Geometry/SurfaceImmersion/Geometry/EuclideanRestoration.lean

@@ -0,0 +1,62 @@
+import OAI.Geometry.SurfaceImmersion.Correction.ManifoldSmoothing
+import OAI.Geometry.SurfaceImmersion.Atlas.FinitePointChartBalls
+
+namespace OAI
+
+/-! Restore a compactly supported Euclidean chart correction. The support
+and germ formulas are used in finite-point spherical preparation. -/
+noncomputable section
+open Set Filter Manifold
+open scoped ContDiff Topology Manifold
+namespace ClosedSurfaceR4.FiniteOrderSmoothing
+variable {M : Type*} [TopologicalSpace M] [ChartedSpace Plane M]
+
+def euclideanRestore (p : M) (χ : M → ℝ) (h : Plane → Space) : M → Space :=
+  restore p χ (h ∘ (EuclideanSpace.equiv (Fin 2) ℝ).symm)
+
+lemma euclideanRestore_eq (p : M) (χ : M → ℝ) (h : Plane → Space) :
+    euclideanRestore p χ h = (chartAt Plane p).source.indicator
+      (fun x => χ x • h (chartAt Plane p x)) := by
+  funext x
+  by_cases hx : x ∈ (chartAt Plane p).source
+  · simp [euclideanRestore,restore,chart,hx]
+  · simp [euclideanRestore,restore,chart,hx]
+
+lemma euclideanRestore_smooth [IsManifold planeModel ∞ M] (p : M) {χ : M → ℝ}
+    (hχ : ContMDiff planeModel 𝓘(ℝ) ∞ χ)
+    (hχs : tsupport χ ⊆ (chartAt Plane p).source) {h : Plane → Space}
+    (hh : ContDiff ℝ ∞ h) : ContMDiff planeModel spaceModel ∞ (euclideanRestore p χ h) := by
+  exact restore_smooth p hχ (by simpa only [chart_source] using hχs)
+    (hh.comp (EuclideanSpace.equiv (Fin 2) ℝ).symm.contDiff)
+
+lemma euclideanRestore_tsupport [T2Space M] (p : M) (χ : M → ℝ) {h : Plane → Space}
+    {K : Set Plane} (hK : IsCompact K) (hKt : K ⊆ (chartAt Plane p).target)
+    (hs : tsupport h ⊆ K) :
+    tsupport (euclideanRestore p χ h) ⊆ (chartAt Plane p).symm '' K := by
+  have hclosed : IsClosed ((chartAt Plane p).symm '' K) :=
+    (hK.image_of_continuousOn ((chartAt Plane p).continuousOn_symm.mono hKt)).isClosed
+  apply closure_minimal _ hclosed
+  intro x hx
+  by_contra hn
+  rw [euclideanRestore_eq] at hx
+  by_cases hxs : x ∈ (chartAt Plane p).source
+  · have hh : h (chartAt Plane p x) = 0 := by
+      apply image_eq_zero_of_notMem_tsupport
+      intro hmem
+      exact hn ⟨chartAt Plane p x,hs hmem,(chartAt Plane p).left_inv hxs⟩
+    exact hx (by simp [indicator_of_mem hxs,hh])
+  · exact hx (indicator_of_notMem hxs _)
+
+lemma euclideanRestore_chart_germ (p : M) (χ : M → ℝ) (h : Plane → Space)
+    {x : Plane} (hx : x ∈ (chartAt Plane p).target)
+    (hχ : (fun y => χ ((chartAt Plane p).symm y)) =ᶠ[𝓝 x] (fun _ => (1 : ℝ))) :
+    (fun y => euclideanRestore p χ h ((chartAt Plane p).symm y)) =ᶠ[𝓝 x] h := by
+  filter_upwards [(chartAt Plane p).open_target.mem_nhds hx,hχ] with y hy hχy
+  rw [euclideanRestore_eq,indicator_of_mem ((chartAt Plane p).map_target hy),
+    hχy,one_smul,(chartAt Plane p).right_inv hy]
+
+end ClosedSurfaceR4.FiniteOrderSmoothing
+
+end
+
+end OAI

lean/OAI/Geometry/SurfaceImmersion/Geometry/EuclideanSurfaceImageNull.lean

@@ -0,0 +1,51 @@
+import OAI.Geometry.SurfaceImmersion.Geometry.LowerDimensionalImage
+import OAI.Geometry.SurfaceImmersion.Geometry.LinearEquivNullImage
+import OAI.Geometry.SurfaceImmersion.Atlas.SurfaceChartRepresentative
+
+namespace OAI
+
+/-! Smooth two-dimensional images in three-space are null, in the
+actual coordinate models used by the surface perturbations. -/
+noncomputable section
+open Set MeasureTheory Manifold
+open scoped ContDiff Topology
+namespace ClosedSurfaceR4.FiniteOrderSmoothing
+open JetPolynomial (Base)
+local instance : (volume : Measure (Plane × ℝ)).IsAddHaarMeasure :=
+  Measure.prod.instIsAddHaarMeasure _ _
+
+theorem euclidean_surface_image_null (f : Base → ProjectionTarget 3) (hf : ContDiff ℝ ∞ f) :
+    volume (range f) = 0 := by
+  let L : Plane ≃L[ℝ] Base := ContinuousLinearEquiv.ofFinrankEq (by simp [Base])
+  let T : ProjectionTarget 3 ≃L[ℝ] Plane × ℝ := ContinuousLinearEquiv.ofFinrankEq (by simp)
+  have hnull := PublishedInputs.smooth_surface_image_volume_zero (T ∘ f ∘ L)
+    (T.contDiff.comp (hf.comp L.contDiff))
+  have hnull' := linear_equiv_null_image T.symm volume volume hnull
+  have he : T.symm '' range (T ∘ f ∘ L) = range f := by
+    ext y
+    constructor
+    · rintro ⟨z,⟨x,rfl⟩,rfl⟩
+      exact ⟨L x,by simp⟩
+    · rintro ⟨x,rfl⟩
+      exact ⟨T (f x),⟨L.symm x,by simp⟩,by simp⟩
+  rwa [he] at hnull'
+
+variable {M : Type*} [TopologicalSpace M] [ChartedSpace Plane M]
+  [IsManifold planeModel ∞ M] [CompactSpace M]
+theorem compact_surface_image_null (f : M → ProjectionTarget 3)
+    (hf : ContMDiff planeModel 𝓘(ℝ,ProjectionTarget 3) ∞ f) : volume (range f) = 0 := by
+  choose U F hU hp hsrc hF he using fun p => surface_chart_representative hf p
+  obtain ⟨s,hs⟩ := isCompact_univ.elim_finite_subcover U hU
+    (fun p _ => mem_iUnion.mpr ⟨p,hp p⟩)
+  have hsub : range f ⊆ ⋃ p ∈ s, range (F p) := by
+    rintro y ⟨x,rfl⟩
+    obtain ⟨p,hps,hxp⟩ := mem_iUnion₂.mp (hs (mem_univ x))
+    exact mem_iUnion₂.mpr ⟨p,hps,⟨chart p x,(he p hxp).symm⟩⟩
+  apply measure_mono_null hsub
+  exact (measure_biUnion_null_iff s.finite_toSet.countable).mpr (fun p _ => euclidean_surface_image_null (F p) (hF p))
+
+end ClosedSurfaceR4.FiniteOrderSmoothing
+
+end
+
+end OAI

lean/OAI/Geometry/SurfaceImmersion/Geometry/ExactFastFamily.lean

@@ -0,0 +1,193 @@
+import OAI.Geometry.SurfaceImmersion.Correction.AnchoredPreparedCorrection
+import OAI.Geometry.SurfaceImmersion.Geometry.RescaledReadBounds
+import OAI.Geometry.SurfaceImmersion.Correction.PolynomialPreparedInitialization
+import OAI.Geometry.SurfaceImmersion.Correction.InitialCorrectionStage
+
+namespace OAI
+
+/-! Arbitrarily accurate primitive maps give an actual smooth exact metric. -/
+noncomputable section
+open Set Manifold Bundle
+open scoped ContDiff Manifold Topology BigOperators
+namespace ClosedSurfaceR4.FiniteOrderSmoothing
+open RealModes JetPolynomial JetPolynomial.Perturbation
+local instance exactFastFiberNormed : NormedAddCommGroup TensorFiber := inferInstance
+local instance exactFastFiberSpace : NormedSpace ℝ TensorFiber := inferInstance
+variable {M : Type*} [TopologicalSpace M] [ChartedSpace Plane M]
+  [IsManifold planeModel ∞ M] [CompactSpace M]
+local instance exactFastDualAdd : ∀ p : M, ContinuousAdd (TangentSpace planeModel p →L[ℝ] ℝ) :=
+  fun _ => inferInstanceAs (ContinuousAdd (Plane →L[ℝ] ℝ))
+local instance exactFastDualSmul : ∀ p : M, ContinuousSMul ℝ (TangentSpace planeModel p →L[ℝ] ℝ) :=
+  fun _ => inferInstanceAs (ContinuousSMul ℝ (Plane →L[ℝ] ℝ))
+local instance exactFastSectionNormed (p : M) : NormedAddCommGroup (CovariantTwoTensor p) :=
+  inferInstanceAs (NormedAddCommGroup TensorFiber)
+local instance exactFastSectionSpace (p : M) : NormedSpace ℝ (CovariantTwoTensor p) :=
+  inferInstanceAs (NormedSpace ℝ TensorFiber)
+namespace SmoothingAtlas
+variable (A : SmoothingAtlas M)
+
+/-- Quantitative finite-accuracy data supplied by the actual primitive construction. -/
+def GeometricFastFamily (g : SmoothMetric M) (R c b V₀ : ℝ) : Prop :=
+  ∀ N : ℕ, ∃ η C Cv : ℝ, 0 < η ∧ 0 ≤ C ∧ 0 ≤ Cv ∧
+      ∀ z : ℝ, 0 < z → z < η → ∃ F : M → Space,
+        ContMDiff planeModel spaceModel ∞ F ∧
+        A.WeightedBound 1 0 V₀ F ∧ A.WeightedBound z 442 Cv F ∧
+        A.ShiftedBound 2 440 z (Cv/z^2) F ∧
+        A.TensorWeightedBound 1 440 (C*z^(N+1)) (inducedTensor F-g.inner) ∧
+        ∀ i x, x ∈ (modeSupport (A.chartWeightCompact i) : Set SmallModes.Base) →
+          ‖firstJetPair (spaceCoordinates ∘ A.vectorPlaneRead i F) x‖ ≤ R ∧
+          c ≤ NormalFrame.gramDet
+            (firstJetPair (spaceCoordinates ∘ A.vectorPlaneRead i F) x).1
+            (firstJetPair (spaceCoordinates ∘ A.vectorPlaneRead i F) x).2 ∧
+          b ≤ ‖realSecondTensor (spaceCoordinates ∘ A.vectorPlaneRead i F) x‖
+
+/-- Retain a proved property of the actual finite-accuracy approximant. -/
+def GeometricFastFamilyWithProperty (g : SmoothMetric M) (R c b V₀ : ℝ) (property : ℝ → (M → Space) → Prop) : Prop :=
+  ∀ N : ℕ, ∃ η C Cv : ℝ, 0 < η ∧ 0 ≤ C ∧ 0 ≤ Cv ∧
+      ∀ z : ℝ, 0 < z → z < η → ∃ F : M → Space,
+        ContMDiff planeModel spaceModel ∞ F ∧ property z F ∧
+        A.WeightedBound 1 0 V₀ F ∧ A.WeightedBound z 442 Cv F ∧
+        A.ShiftedBound 2 440 z (Cv/z^2) F ∧
+        A.TensorWeightedBound 1 440 (C*z^(N+1)) (inducedTensor F-g.inner) ∧
+        ∀ i x, x ∈ (modeSupport (A.chartWeightCompact i) : Set SmallModes.Base) →
+          ‖firstJetPair (spaceCoordinates ∘ A.vectorPlaneRead i F) x‖ ≤ R ∧
+          c ≤ NormalFrame.gramDet
+            (firstJetPair (spaceCoordinates ∘ A.vectorPlaneRead i F) x).1
+            (firstJetPair (spaceCoordinates ∘ A.vectorPlaneRead i F) x).2 ∧
+          b ≤ ‖realSecondTensor (spaceCoordinates ∘ A.vectorPlaneRead i F) x‖
+
+theorem exact_metric_with_property (g : SmoothMetric M)
+    (houter : ∀ i p, p ∈ tsupport (A.weight i) → A.outer i =ᶠ[𝓝 p] (fun _ => 1))
+    (R c b V₀ : ℝ) (hc : 0 < c) (hb : 0 < b) (hV₀ : 0 ≤ V₀)
+    (property : ℝ → (M → Space) → Prop)
+    (hfamily : A.GeometricFastFamilyWithProperty g R c b V₀ property) :
+    ∃ B : ℝ, 1 ≤ B ∧ ∀ ζ : ℝ, 0 < ζ → ∀ K : ℝ, 0 < K →
+    ∃ z : ℝ, 0 < z ∧ z < ζ ∧ z ≤ 1 ∧ ∃ F G : M → Space,
+      ContMDiff planeModel spaceModel ∞ F ∧ property z F ∧ IsSmoothIsometricImmersion M g G ∧
+      A.WeightedBound 1 2 (z^8/K) (G-F) ∧
+      (∀ i, WeightedEstimates.WeightedBound univ (z^2) 3 B
+        (spaceCoordinates ∘ A.vectorPlaneRead i F)) ∧
+      ∀ i x, x ∈ (modeSupport (A.chartWeightCompact i) : Set SmallModes.Base) →
+        ‖firstJetPair (spaceCoordinates ∘ A.vectorPlaneRead i F) x‖ ≤ R ∧
+        c ≤ NormalFrame.gramDet
+          (firstJetPair (spaceCoordinates ∘ A.vectorPlaneRead i F) x).1
+          (firstJetPair (spaceCoordinates ∘ A.vectorPlaneRead i F) x).2 ∧
+        b ≤ ‖realSecondTensor (spaceCoordinates ∘ A.vectorPlaneRead i F) x‖ := by
+  obtain ⟨B,hB,hreads⟩ := A.uniform_rescaled_read_bound V₀ hV₀
+  refine ⟨B,hB,?_⟩
+  intro ζ hζ
+  obtain ⟨z₀,a,D,hz₀,hz₀1,ha,hD,hprep⟩ :=
+    A.anchored_prepared_correction g houter R c B b hc (zero_le_one.trans hB) hb
+  let P : ℝ → ℝ := fun x => x^2
+  have hP : HasPolynomialBound P := polynomialBound_id.pow 2
+  obtain ⟨Budget,EpsInv,hBudget,hEpsInv,hdata⟩ := hprep P P hP hP
+  obtain ⟨ν,hν,N,hinit⟩ := ExactCorrection.polynomial_prepared_initialization EpsInv hEpsInv
+  obtain ⟨ηf,C,Cv,hηf,hC,hCv,hf⟩ := hfamily N
+  obtain ⟨Dg,hDg,hg⟩ := A.exists_bundle_bound A.tensorTriv A.tensorTriv_domain 440 g.contMDiff
+  let H := max C Cv
+  have hH : 0 ≤ H := hC.trans (le_max_left _ _)
+  have hCH : C ≤ H := le_max_left _ _
+  have hCvH : Cv ≤ H := le_max_right _ _
+  obtain ⟨ηr,hηr,hηr1,hr⟩ := hreads Cv hCv
+  obtain ⟨ηb,hηb,_,hbase⟩ := ExactCorrection.positive_power_threshold Cv 2 1 (by norm_num) zero_lt_one
+  intro K hK
+  obtain ⟨ηi,hηi,hηi1,hi⟩ := hinit H Dg (a/16) D K hH hDg (by positivity) hD hK
+  let η := min z₀ (min ηf (min ηr (min ηb (min ηi ζ))))
+  have hη : 0 < η := lt_min hz₀ (lt_min hηf (lt_min hηr (lt_min hηb (lt_min hηi hζ))))
+  let z := η/2
+  have hz : 0 < z := half_pos hη
+  have hzη : z < η := half_lt_self hη
+  have hzz₀ : z < z₀ := hzη.trans_le (min_le_left _ _)
+  have hzf : z < ηf := hzη.trans_le ((min_le_right _ _).trans (min_le_left _ _))
+  have hzr : z < ηr := hzη.trans_le ((min_le_right _ _).trans ((min_le_right _ _).trans (min_le_left _ _)))
+  have hzb : z < ηb := hzη.trans_le ((min_le_right _ _).trans ((min_le_right _ _).trans ((min_le_right _ _).trans (min_le_left _ _))))
+  have hziζ : z < min ηi ζ := hzη.trans_le ((min_le_right _ _).trans ((min_le_right _ _).trans ((min_le_right _ _).trans (min_le_right _ _))))
+  have hzi := hziζ.trans_le (min_le_left _ _)
+  have hzζ := hziζ.trans_le (min_le_right _ _)
+  have hz1 : z ≤ 1 := hzz₀.le.trans hz₀1
+  have hzsq : z^2 ≤ z := by simpa only [pow_one] using pow_le_pow_of_le_one hz.le hz1 (by norm_num : 1 ≤ 2)
+  obtain ⟨F,hF,hproperty,hFzero,hFwb,hFshift,herr,hgeom⟩ := hf z hz hzf
+  have hFread := hr z hz hzr F hF hFzero (fun i => (hFwb i).mono_order (by omega))
+  have hsmall : Cv*z^2 ≤ 1 := by
+    simpa only [Real.rpow_ofNat] using (hbase z hz hzb).le
+  have hFbase : A.ShiftedBound 2 0 1 (P ((z^2)⁻¹)) F := by
+    intro i j hj x
+    have hj0 : j-2 = 0 := by omega
+    have hh := hFshift i j (by omega) x
+    simp only [hj0,pow_zero,one_mul] at hh ⊢
+    apply hh.trans
+    change Cv/z^2 ≤ ((z^2)⁻¹)^2
+    apply (div_le_iff₀ (pow_pos hz 2)).mpr
+    have heq : ((z^2)⁻¹)^2*z^2 = 1/z^2 := by field_simp
+    rw [heq]
+    exact (le_div_iff₀ (pow_pos hz 2)).mpr hsmall
+  obtain ⟨p,hpa,hprho,hpbudget,hpWish,hpε⟩ := hdata (z^2) (pow_pos hz 2)
+    (hzsq.trans hzz₀.le)
+    F hF hFread hgeom hFbase
+  have hρ : p.ρ = z^8/D := by rw [hprho]; congr 1; ring
+  have hbudget : 1/z^4 ≤ p.budget := by
+    have hPval : P ((z^2)⁻¹) = 1/z^4 := by dsimp [P]; field_simp
+    rw [hPval] at hpWish
+    linarith [p.budget_pos]
+  obtain ⟨htz,ht32,htε,hMB,hHB,hnear,herror,hcontrol⟩ := hi z hz hzi
+  have ht : 0 < z^ν := Real.rpow_pos_of_pos hz _
+  have ht1 : z^ν ≤ 1 := by linarith
+  have hmap : A.ShiftedBound 2 440 z (H/z^2) F := by
+    intro i j hj x
+    exact (hFshift i j hj x).trans (div_le_div_of_nonneg_right hCvH (sq_nonneg z))
+  have hmap0 : A.ShiftedBound 2 0 1 (H/z^2) F := by
+    intro i j hj x
+    have hj0 : j-2 = 0 := by omega
+    simpa only [hj0,pow_zero,one_mul] using hmap i j (by omega) x
+  have hmetric0 : A.TensorWeightedBound 1 0 Dg g.inner := fun i => (hg i).mono_order (by omega)
+  have herror' : A.TensorWeightedBound (z^ν) 440 (((z^ν)^(10 : ℝ))^2*(a/16))
+      (inducedTensor F-g.inner) := by
+    intro i
+    apply ((herr i).shrink_scale ht.le ht1).mono_const
+    exact (mul_le_mul_of_nonneg_right hCH (pow_nonneg hz.le _)).trans herror
+  obtain ⟨seed,hseed⟩ := p.initial_stage_of_scaled_bounds hF ht ht32
+    (htε _ (p.ε_pos 0) hpε) hz htz (by positivity) (by positivity) hDg (by positivity)
+    hmap0 hmap hmetric0 hg herror' (hMB.trans hbudget) (hHB.trans hbudget)
+    (by rwa [hρ]) (by rw [hpa]; linarith)
+  obtain ⟨G,hG,hclose⟩ := p.exact_correction_initial_displacement hF ht ht32
+    (by positivity) hmap0 seed hseed
+  rw [hρ] at hclose
+  exact ⟨z,hz,hzζ,hz1,F,G,hF,hproperty,hG,(fun i => (hclose i).mono_const hcontrol),hFread,hgeom⟩
+
+/-- The original geometric conclusion, with no extra property requested. -/
+theorem exact_metric_from_fast_family (g : SmoothMetric M)
+    (houter : ∀ i p, p ∈ tsupport (A.weight i) → A.outer i =ᶠ[𝓝 p] (fun _ => 1))
+    (R c b V₀ : ℝ) (hc : 0 < c) (hb : 0 < b) (hV₀ : 0 ≤ V₀)
+    (hfamily : A.GeometricFastFamily g R c b V₀) :
+    ∃ B : ℝ, 1 ≤ B ∧ ∀ ζ : ℝ, 0 < ζ → ∀ K : ℝ, 0 < K →
+    ∃ z : ℝ, 0 < z ∧ z < ζ ∧ z ≤ 1 ∧ ∃ F G : M → Space,
+      ContMDiff planeModel spaceModel ∞ F ∧ IsSmoothIsometricImmersion M g G ∧
+      A.WeightedBound 1 2 (z^8/K) (G-F) ∧
+      (∀ i, WeightedEstimates.WeightedBound univ (z^2) 3 B
+        (spaceCoordinates ∘ A.vectorPlaneRead i F)) ∧
+      ∀ i x, x ∈ (modeSupport (A.chartWeightCompact i) : Set SmallModes.Base) →
+        ‖firstJetPair (spaceCoordinates ∘ A.vectorPlaneRead i F) x‖ ≤ R ∧
+        c ≤ NormalFrame.gramDet
+          (firstJetPair (spaceCoordinates ∘ A.vectorPlaneRead i F) x).1
+          (firstJetPair (spaceCoordinates ∘ A.vectorPlaneRead i F) x).2 ∧
+        b ≤ ‖realSecondTensor (spaceCoordinates ∘ A.vectorPlaneRead i F) x‖ := by
+  have hdecorated : A.GeometricFastFamilyWithProperty g R c b V₀ (fun _ _ => True) := by
+    intro N
+    obtain ⟨η,C,Cv,hη,hC,hCv,hf⟩ := hfamily N
+    refine ⟨η,C,Cv,hη,hC,hCv,?_⟩
+    intro z hz hzη
+    obtain ⟨F,hF,hFzero,hFwb,hFshift,herr,hgeom⟩ := hf z hz hzη
+    exact ⟨F,hF,trivial,hFzero,hFwb,hFshift,herr,hgeom⟩
+  obtain ⟨B,hB,hall⟩ := A.exact_metric_with_property g houter R c b V₀ hc hb hV₀
+    (fun _ _ => True) hdecorated
+  refine ⟨B,hB,?_⟩
+  intro ζ hζ K hK
+  obtain ⟨z,hz,hzζ,hz1,F,G,hF,_,hG,hclose,hread,hgeom⟩ := hall ζ hζ K hK
+  exact ⟨z,hz,hzζ,hz1,F,G,hF,hG,hclose,hread,hgeom⟩
+
+end SmoothingAtlas
+end ClosedSurfaceR4.FiniteOrderSmoothing
+
+end
+
+end OAI

lean/OAI/Geometry/SurfaceImmersion/Geometry/ExactGeometricFastFamily.lean

@@ -0,0 +1,102 @@
+import OAI.Geometry.SurfaceImmersion.Geometry.ExactFastFamily
+import OAI.Geometry.SurfaceImmersion.Geometry.UniformFastNormalMargin
+import OAI.Geometry.SurfaceImmersion.Atlas.AtlasImmersionGeometry
+
+namespace OAI
+
+/-! Exact limits retain the geometric hypotheses needed for the next primitive. -/
+noncomputable section
+open Set Manifold Bundle
+open scoped ContDiff Manifold Topology BigOperators
+namespace ClosedSurfaceR4.FiniteOrderSmoothing
+open RealModes JetPolynomial JetPolynomial.Perturbation
+local instance exactGeometricFastFiberNormed : NormedAddCommGroup TensorFiber := inferInstance
+local instance exactGeometricFastFiberSpace : NormedSpace ℝ TensorFiber := inferInstance
+variable {M : Type*} [TopologicalSpace M] [ChartedSpace Plane M]
+  [IsManifold planeModel ∞ M] [CompactSpace M]
+local instance exactGeometricFastDualAdd : ∀ p : M, ContinuousAdd (TangentSpace planeModel p →L[ℝ] ℝ) :=
+  fun _ => inferInstanceAs (ContinuousAdd (Plane →L[ℝ] ℝ))
+local instance exactGeometricFastDualSmul : ∀ p : M, ContinuousSMul ℝ (TangentSpace planeModel p →L[ℝ] ℝ) :=
+  fun _ => inferInstanceAs (ContinuousSMul ℝ (Plane →L[ℝ] ℝ))
+local instance exactGeometricFastSectionNormed (p : M) : NormedAddCommGroup (CovariantTwoTensor p) :=
+  inferInstanceAs (NormedAddCommGroup TensorFiber)
+local instance exactGeometricFastSectionSpace (p : M) : NormedSpace ℝ (CovariantTwoTensor p) :=
+  inferInstanceAs (NormedSpace ℝ TensorFiber)
+namespace SmoothingAtlas
+variable (A : SmoothingAtlas M)
+
+theorem exact_geometric_metric_with_property [T2Space M] (g : SmoothMetric M)
+    (houter : ∀ i p, p ∈ tsupport (A.weight i) → A.outer i =ᶠ[𝓝 p] (fun _ => 1))
+    (R c b V₀ : ℝ) (hc : 0 < c) (hb : 0 < b) (hV₀ : 0 ≤ V₀)
+    (property : ℝ → (M → Space) → Prop)
+    (hfamily : A.GeometricFastFamilyWithProperty g R c b V₀ property)
+    (ζ : ℝ) (hζ : 0 < ζ) :
+    ∃ z : ℝ, 0 < z ∧ z < ζ ∧ z ≤ 1 ∧ ∃ F G : M → Space,
+      ContMDiff planeModel spaceModel ∞ F ∧ property z F ∧
+      IsSmoothIsometricImmersion M g G ∧ Nonempty (MetricGoodPhaseData g G) ∧
+      A.WeightedBound 1 2 (z^8) (G-F) := by
+  obtain ⟨B,hB,hall⟩ := A.exact_metric_with_property g houter R c b V₀ hc hb hV₀ property hfamily
+  obtain ⟨η,hη,hη1,hnormal⟩ := uniform_fast_normal_margin R c B b hc (zero_le_one.trans hB) hb
+  obtain ⟨D,hD,hball⟩ := A.readJetBall_radius
+  obtain ⟨z,hz,hzcap,hz1,F,G,hF,hproperty,hG,hclose,hread,hgeom⟩ :=
+    hall (min η ζ) (lt_min hη hζ) D (zero_lt_one.trans_le hD)
+  have hzη := hzcap.trans_le (min_le_left _ _)
+  have hzζ := hzcap.trans_le (min_le_right _ _)
+  have hclose' : A.WeightedBound 1 2 ((z^2)^4/D) (G-F) := by
+    convert hclose using 1; ring
+  have hjet := hball (z^2) F G hF hG.1 hclose'
+  have hsη : z^2 ≤ η := (show z^2 ≤ z from by
+    simpa only [pow_one] using pow_le_pow_of_le_one hz.le hz1 (by norm_num : 1 ≤ 2)).trans hzη.le
+  have hlocal := fun i x hx => hnormal (z^2) (pow_pos hz 2) hsη
+    (spaceCoordinates ∘ A.vectorPlaneRead i F) (spaceCoordinates ∘ A.vectorPlaneRead i G)
+    (spaceCoordinates.contDiff.comp (A.vectorPlaneRead_smooth i hF)) (hread i) x
+    (hgeom i x hx).1 (hgeom i x hx).2.1 (hgeom i x hx).2.2
+    (hjet.2 i x hx).1 (hjet.2 i x hx).2
+  have hgeometry := A.geometry_of_chartwise_good hG.1 houter (by
+    intro p
+    obtain ⟨i,hi⟩ : ∃ i : A.centers, A.weight i p ≠ 0 := by
+      by_contra! hz
+      have hh := A.partition p
+      simp only [hz,zero_pow (by decide : 2 ≠ 0),Finset.sum_const_zero] at hh
+      norm_num at hh
+    have hp : p ∈ tsupport (A.weight i) := subset_tsupport _ hi
+    have hx : planeCoordinateIsometry (chart (i : M) p) ∈
+        (modeSupport (A.chartWeightCompact i) : Set SmallModes.Base) :=
+      ⟨chart (i : M) p,⟨p,hp,rfl⟩,rfl⟩
+    obtain ⟨hI,hN⟩ := hlocal i _ hx
+    have hNZ : realSecondTensor (spaceCoordinates ∘ A.vectorPlaneRead i G)
+        (planeCoordinateIsometry (chart (i : M) p)) ≠ 0 :=
+      norm_pos_iff.mp ((half_pos hb).trans_le hN)
+    obtain ⟨ξ,Q,_,_,hgood,_⟩ := PhaseGeometry.positive_good_phase_data hNZ
+      (H₀ := ![(1:ℝ),0,1]) (by simp) (by simp)
+    exact ⟨i,hp,hI,ξ 0,hgood 0⟩)
+  refine ⟨z,hz,hzζ,hz1,F,G,hF,hproperty,hG,
+    MetricGoodPhaseData.nonempty g hG.1 hgeometry.1 hgeometry.2,?_⟩
+  intro i
+  apply (hclose i).mono_const
+  apply (div_le_iff₀ (zero_lt_one.trans_le hD)).mpr
+  nlinarith [mul_le_mul_of_nonneg_left hD (pow_nonneg hz.le 8)]
+
+/-- The geometric conclusion after forgetting the approximant. -/
+theorem exact_geometric_metric_from_fast_family [T2Space M] (g : SmoothMetric M)
+    (houter : ∀ i p, p ∈ tsupport (A.weight i) → A.outer i =ᶠ[𝓝 p] (fun _ => 1))
+    (R c b V₀ : ℝ) (hc : 0 < c) (hb : 0 < b) (hV₀ : 0 ≤ V₀)
+    (hfamily : A.GeometricFastFamily g R c b V₀) :
+    ∃ G : M → Space, IsSmoothIsometricImmersion M g G ∧ Nonempty (MetricGoodPhaseData g G) := by
+  have hdecorated : A.GeometricFastFamilyWithProperty g R c b V₀ (fun _ _ => True) := by
+    intro N
+    obtain ⟨η,C,Cv,hη,hC,hCv,hf⟩ := hfamily N
+    refine ⟨η,C,Cv,hη,hC,hCv,?_⟩
+    intro z hz hzη
+    obtain ⟨F,hF,hFzero,hFwb,hFshift,herr,hgeom⟩ := hf z hz hzη
+    exact ⟨F,hF,trivial,hFzero,hFwb,hFshift,herr,hgeom⟩
+  obtain ⟨z,hz,hz1,_,F,G,hF,_,hG,hgeometry,_⟩ := A.exact_geometric_metric_with_property
+    g houter R c b V₀ hc hb hV₀ (fun _ _ => True) hdecorated 1 zero_lt_one
+  exact ⟨G,hG,hgeometry⟩
+
+end SmoothingAtlas
+end ClosedSurfaceR4.FiniteOrderSmoothing
+
+end
+
+end OAI

lean/OAI/Geometry/SurfaceImmersion/Geometry/ExactInputRecurrence.lean

@@ -0,0 +1,55 @@
+import OAI.Geometry.SurfaceImmersion.Geometry.GlobalInputRecurrence
+import OAI.Geometry.SurfaceImmersion.Geometry.ExactInputRecurrenceBound
+import OAI.Geometry.SurfaceImmersion.Geometry.ExactScaleOrdering
+
+namespace OAI
+
+/-! The actual next map and normalized defect satisfy the waiting recurrence. -/
+noncomputable section
+open Set Manifold Bundle
+open scoped ContDiff Manifold Topology
+namespace ClosedSurfaceR4.FiniteOrderSmoothing
+local instance exactInputFiberNormed : NormedAddCommGroup TensorFiber := inferInstance
+local instance exactInputFiberSpace : NormedSpace ℝ TensorFiber := inferInstance
+variable {M : Type*} [TopologicalSpace M] [ChartedSpace Plane M]
+  [IsManifold planeModel ∞ M] [CompactSpace M]
+namespace SmoothingAtlas
+variable (A : SmoothingAtlas M)
+
+theorem exact_scale_input_recurrence {g : SmoothMetric M} {G U : M → Space}
+    (hG : ContMDiff planeModel spaceModel ∞ G) (hU : ContMDiff planeModel spaceModel ∞ U)
+    {t P P₀ Pm B C L B₀ δ' : ℝ} {k m : ℕ}
+    (ht : 0 < t) (ht1 : t ≤ 1) (hk : 10 ≤ k)
+    (hP : 0 ≤ P) (hP₀ : 0 ≤ P₀) (hPm : 0 ≤ Pm)
+    (hB : 0 ≤ B) (hC : 0 ≤ C) (hL : 0 ≤ L) (hB₀ : 0 ≤ B₀)
+    (hp : A.ShiftedBound 2 0 t P G)
+    (hc : A.ShiftedBound 2 m t C G)
+    (hu : A.WeightedBound (t^(6/5 : ℝ)) (2+m) (B*(t^(k : ℝ)*t^(6/5 : ℝ))) U)
+    (ht₀ : A.TensorWeightedBound 1 0 P₀ g.inner)
+    (htm : A.TensorWeightedBound 1 m Pm g.inner)
+    (he : A.TensorWeightedBound (t^(6/5 : ℝ)) m (L*(1+B₀+C)*t^(1/5 : ℝ))
+      (normalizedTensorDefect g.inner δ' (G+U)-g.inner)) :
+    A.InputBound (t^(6/5 : ℝ)) m
+      (P+P₀+(Pm+B+L*(1+B₀)+1+L)*t^(1/5 : ℝ)*(1+C))
+      (G+U) (normalizedTensorDefect g.inner δ' (G+U)) := by
+  have hτ : 0 < t^(6/5 : ℝ) := Real.rpow_pos_of_pos ht _
+  obtain ⟨_,_,hτs,hst⟩ := ExactCorrection.exact_scale_order ht ht1 hk
+  have hτt := hτs.trans hst
+  have hh := A.next_input_bound g.contMDiff hG hU ht hτ hτt (hτt.trans ht1)
+    hP hP₀ hPm hC (mul_nonneg hB (mul_nonneg (Real.rpow_nonneg ht.le _) hτ.le))
+    (mul_nonneg (mul_nonneg hL (by linarith)) (Real.rpow_nonneg ht.le _))
+    hp hc hu ht₀ htm he
+  have hsize := ExactCorrection.exact_input_recurrence_bound ht ht1 hk hPm hB hC hL hB₀
+    (P := P) (P₀ := P₀)
+  constructor
+  · intro i j hj x
+    exact (hh.1 i j hj x).trans hsize
+  · intro i
+    exact (hh.2 i).mono_const hsize
+
+end SmoothingAtlas
+end ClosedSurfaceR4.FiniteOrderSmoothing
+
+end
+
+end OAI

lean/OAI/Geometry/SurfaceImmersion/Geometry/ExactInputRecurrenceBound.lean

@@ -0,0 +1,51 @@
+import OAI.Geometry.SurfaceImmersion.Correction.CorrectionScaleAlgebra
+
+namespace OAI
+
+/-! The two components of the actual input share a contracting affine bound. -/
+noncomputable section
+namespace ClosedSurfaceR4.ExactCorrection
+
+theorem exact_input_recurrence_bound {t P P₀ Pm B C L B₀ : ℝ} {k : ℕ}
+    (ht : 0 < t) (ht1 : t ≤ 1) (hk : 10 ≤ k)
+    (hPm : 0 ≤ Pm) (hB : 0 ≤ B) (hC : 0 ≤ C) (hL : 0 ≤ L) (hB₀ : 0 ≤ B₀) :
+    P+P₀+t^(6/5 : ℝ)*Pm+(t^(6/5 : ℝ)/t)*C+
+      (B*(t^(k : ℝ)*t^(6/5 : ℝ)))/(t^(6/5 : ℝ))^2+
+      L*(1+B₀+C)*t^(1/5 : ℝ) ≤
+    P+P₀+(Pm+B+L*(1+B₀)+1+L)*t^(1/5 : ℝ)*(1+C) := by
+  have hk' : (10 : ℝ) ≤ k := by exact_mod_cast hk
+  have hτ : t^(6/5 : ℝ) ≤ t^(1/5 : ℝ) :=
+    Real.rpow_le_rpow_of_exponent_ge ht ht1 (by norm_num)
+  have hratio : t^(6/5 : ℝ)/t = t^(1/5 : ℝ) := by
+    conv_lhs => rhs; rw [← Real.rpow_one t]
+    rw [← Real.rpow_sub ht]
+    norm_num
+  have hquotient : (t^(k : ℝ)*t^(6/5 : ℝ))/(t^(6/5 : ℝ))^2 =
+      t^((k : ℝ)-(6/5 : ℝ)) := by
+    rw [← Real.rpow_natCast,← Real.rpow_mul ht.le,scale_quotient_product ht]
+    congr 1
+    ring
+  have hquotient_le : (t^(k : ℝ)*t^(6/5 : ℝ))/(t^(6/5 : ℝ))^2 ≤ t^(1/5 : ℝ) := by
+    rw [hquotient]
+    exact Real.rpow_le_rpow_of_exponent_ge ht ht1 (by linarith)
+  have hterm : (B*(t^(k : ℝ)*t^(6/5 : ℝ)))/(t^(6/5 : ℝ))^2 ≤ B*t^(1/5 : ℝ) := by
+    rw [mul_div_assoc]
+    exact mul_le_mul_of_nonneg_left hquotient_le hB
+  calc
+    _ ≤ P+P₀+t^(1/5 : ℝ)*Pm+t^(1/5 : ℝ)*C+B*t^(1/5 : ℝ)+
+        L*(1+B₀+C)*t^(1/5 : ℝ) := by
+      rw [hratio]
+      gcongr
+    _ = P+P₀+(Pm+C+B+L*(1+B₀+C))*t^(1/5 : ℝ) := by ring
+    _ ≤ _ := by
+      apply add_le_add le_rfl
+      rw [mul_assoc _ _ (1+C),mul_comm (t^(1/5 : ℝ)) (1+C),← mul_assoc]
+      apply mul_le_mul_of_nonneg_right _ (Real.rpow_nonneg ht.le _)
+      nlinarith [mul_nonneg hPm hC,mul_nonneg hB hC,
+        mul_nonneg (mul_nonneg hL hB₀) hC]
+
+end ClosedSurfaceR4.ExactCorrection
+
+end
+
+end OAI

lean/OAI/Geometry/SurfaceImmersion/Geometry/ExactScaleOrdering.lean

@@ -0,0 +1,39 @@
+import OAI.Geometry.SurfaceImmersion.Correction.CorrectionScaleAlgebra
+
+namespace OAI
+
+/-! Positivity and ordering of the actual scales in each correction step. -/
+noncomputable section
+
+namespace ClosedSurfaceR4.ExactCorrection
+
+theorem exact_scale_positive {t : ℝ} (ht : 0 < t) (k : ℕ) :
+    0 < t^((6/5 : ℝ)*((k : ℝ)+1)) ∧ 0 < t^(k : ℝ) ∧
+      0 < t^(6/5 : ℝ) ∧ 0 < t^(11/10 : ℝ) :=
+  ⟨Real.rpow_pos_of_pos ht _,Real.rpow_pos_of_pos ht _,
+    Real.rpow_pos_of_pos ht _,Real.rpow_pos_of_pos ht _⟩
+
+theorem exact_scale_order {t : ℝ} (ht : 0 < t) (ht1 : t ≤ 1) {k : ℕ} (hk : 10 ≤ k) :
+    t^((6/5 : ℝ)*((k : ℝ)+1)) ≤ t^(k : ℝ) ∧
+      t^(k : ℝ) ≤ t^(6/5 : ℝ) ∧ t^(6/5 : ℝ) ≤ t^(11/10 : ℝ) ∧
+      t^(11/10 : ℝ) ≤ t := by
+  have hk' : (10 : ℝ) ≤ k := by exact_mod_cast hk
+  refine ⟨Real.rpow_le_rpow_of_exponent_ge ht ht1 (by linarith),
+    Real.rpow_le_rpow_of_exponent_ge ht ht1 (by linarith),
+    Real.rpow_le_rpow_of_exponent_ge ht ht1 (by norm_num),?_⟩
+  simpa only [Real.rpow_one] using
+    Real.rpow_le_rpow_of_exponent_ge ht ht1 (show (1 : ℝ) ≤ 11/10 by norm_num)
+
+theorem next_amplitude_scale {t : ℝ} (ht : 0 < t) (k : ℕ) :
+    t^((6/5 : ℝ)*((k : ℝ)+1)) = (t^(6/5 : ℝ))^(k+1) := by
+  rw [← Real.rpow_natCast,← Real.rpow_mul ht.le]
+  simp only [Nat.cast_add,Nat.cast_one]
+
+theorem amplitude_scale_nat (t : ℝ) (k : ℕ) : t^(k : ℝ) = t^k :=
+  Real.rpow_natCast t k
+
+end ClosedSurfaceR4.ExactCorrection
+
+end
+
+end OAI

lean/OAI/Geometry/SurfaceImmersion/Geometry/ExplicitFixedOrderThreshold.lean

@@ -0,0 +1,112 @@
+import OAI.Geometry.SurfaceImmersion.Correction.PolynomialPowerThreshold
+
+namespace OAI
+
+/-! The fixed-order scale conditions with one explicitly specified
+threshold. Its reciprocal is polynomial in the finite numerical budgets. -/
+noncomputable section
+open scoped BigOperators
+namespace ClosedSurfaceR4.ExactCorrection
+
+def fixedOrderNumericalBudget (k : ℕ) (D B K : ℝ) (C : ℕ → ℝ) : ℝ :=
+  2+D*B+K+∑ m ∈ Finset.range (k/2+1), |C m|
+
+def fixedOrderThreshold (k : ℕ) (ρ a η D B K : ℝ) (C : ℕ → ℝ) : ℝ :=
+  powerThreshold 10 (fixedOrderNumericalBudget k D B K C) (min η (min (ρ/4) (a/8)))
+
+theorem fixedOrderThreshold_spec (k : ℕ) (hk : 10 ≤ k)
+    (ρ a η D B K : ℝ) (hρ : 0 < ρ) (ha : 0 < a) (hη : 0 < η)
+    (hD : 0 ≤ D) (hB : 0 ≤ B) (hK : 0 ≤ K) (C : ℕ → ℝ) :
+    0 < fixedOrderThreshold k ρ a η D B K C ∧
+    fixedOrderThreshold k ρ a η D B K C ≤ 1 ∧
+    ∀ t : ℝ, 0 < t → t < fixedOrderThreshold k ρ a η D B K C →
+    ∀ j : ℕ, k ≤ j → j ≤ k+1 →
+      t^(6/5 : ℝ)/t^(11/10 : ℝ) ≤ η ∧
+      D*B*(t^(11/10 : ℝ)/t)^(40*(k+1)) ≤ min (ρ/4) (a/8) ∧
+      (t^((6/5 : ℝ)*(j : ℝ))/t^(k : ℝ))^(2 : ℕ)*K ≤ a/8 ∧
+      (∀ m ≤ k/2, C m*(t^(k : ℝ)*t^(6/5 : ℝ))/(t^(6/5 : ℝ))^m ≤ ρ*t) ∧
+      t^((6/5 : ℝ)*(j : ℝ)) ≤ t^(k : ℝ) ∧
+      t^((6/5 : ℝ)*((k : ℝ)+1)) ≤ t^((6/5 : ℝ)*(j : ℝ)) := by
+  let M := 1+∑ m ∈ Finset.range (k/2+1), |C m|
+  let S := fixedOrderNumericalBudget k D B K C
+  let b := min η (min (ρ/4) (a/8))
+  have hsum : 0 ≤ ∑ m ∈ Finset.range (k/2+1), |C m| :=
+    Finset.sum_nonneg (fun _ _ => abs_nonneg _)
+  have hDB := mul_nonneg hD hB
+  have hS : 0 ≤ S := by dsimp [S, fixedOrderNumericalBudget]; linarith
+  have hS1 : 1 ≤ S := by dsimp [S, fixedOrderNumericalBudget]; linarith
+  have hSDB : D*B ≤ S := by dsimp [S, fixedOrderNumericalBudget]; linarith
+  have hSK : K ≤ S := by dsimp [S, fixedOrderNumericalBudget]; linarith
+  have hSM : M ≤ S := by dsimp [S, fixedOrderNumericalBudget, M]; linarith
+  have hb : 0 < b := lt_min hη (lt_min (by positivity) (by positivity))
+  have hε := powerThreshold_spec (n := 10) (by decide) hS hb
+    (show ((10 : ℕ) : ℝ)⁻¹ ≤ (1/10 : ℝ) by norm_num)
+  refine ⟨hε.1,hε.2.1,?_⟩
+  intro t ht htε j hkj hjk
+  have ht1 : t ≤ 1 := htε.le.trans hε.2.1
+  have hk' : (10 : ℝ) ≤ k := by exact_mod_cast hk
+  have hkj' : (k : ℝ) ≤ j := by exact_mod_cast hkj
+  have hjk' : (j : ℝ) ≤ (k : ℝ)+1 := by exact_mod_cast hjk
+  have hbound (c p : ℝ) (hc : c ≤ S) (hp : (1/10 : ℝ) ≤ p) : c*t^p ≤ b := by
+    have hh := (powerThreshold_spec (n := 10) (by decide) hS hb
+      (show ((10 : ℕ) : ℝ)⁻¹ ≤ p by norm_num; exact hp)).2.2 t ht htε
+    exact (mul_le_mul_of_nonneg_right hc (Real.rpow_nonneg ht.le _)).trans hh.le
+  have hr : t^(6/5 : ℝ)/t^(11/10 : ℝ) = t^(1/10 : ℝ) := by
+    rw [← Real.rpow_sub ht]
+    norm_num
+  have hs : t^(11/10 : ℝ)/t = t^(1/10 : ℝ) := by
+    conv_lhs => rhs; rw [← Real.rpow_one t]
+    rw [← Real.rpow_sub ht]
+    norm_num
+  have hpow : (t^(11/10 : ℝ)/t)^(40*(k+1)) = t^(4*((k : ℝ)+1)) := by
+    rw [hs,← Real.rpow_natCast,← Real.rpow_mul ht.le]
+    congr 1
+    push_cast
+    ring
+  have hδ : (t^((6/5 : ℝ)*(j : ℝ))/t^(k : ℝ))^(2 : ℕ) =
+      t^((12/5 : ℝ)*(j : ℝ)-2*(k : ℝ)) := by
+    rw [← Real.rpow_sub ht,← Real.rpow_natCast,← Real.rpow_mul ht.le]
+    congr 1
+    ring
+  refine ⟨?_,?_,?_,?_,?_,?_⟩
+  · rw [hr]
+    have hh := hbound 1 (1/10) hS1 le_rfl
+    simpa only [one_mul] using hh.trans (min_le_left _ _)
+  · rw [hpow]
+    exact (hbound (D*B) _ hSDB (by linarith)).trans (min_le_right _ _)
+  · rw [hδ,mul_comm]
+    exact (hbound K _ hSK (by linarith)).trans
+      ((min_le_right _ _).trans (min_le_right _ _))
+  · intro m hm
+    have hCM : C m ≤ M := by
+      have hh := Finset.single_le_sum (fun j (_ : j ∈ Finset.range (k/2+1)) => abs_nonneg (C j))
+        (Finset.mem_range.mpr (by omega : m < k/2+1))
+      have hc := le_abs_self (C m)
+      dsimp [M]
+      linarith
+    let e : ℝ := (k : ℝ)+(1/5 : ℝ)-(6/5 : ℝ)*(m : ℝ)
+    have hmk : 2*m ≤ k := by omega
+    have hmk' : (2 : ℝ)*(m : ℝ) ≤ (k : ℝ) := by exact_mod_cast hmk
+    have he : (1/10 : ℝ) ≤ e := by dsimp [e]; linarith
+    have heρ : C m*t^e ≤ ρ := (hbound (C m) e (hCM.trans hSM) he).trans (by
+      have hbρ : b ≤ ρ/4 := (min_le_right _ _).trans (min_le_left _ _)
+      linarith)
+    have hratio : (t^(k : ℝ)*t^(6/5 : ℝ))/(t^(6/5 : ℝ))^m = t^e*t := by
+      rw [← Real.rpow_natCast,← Real.rpow_mul ht.le,scale_quotient_product ht]
+      conv_rhs => rhs; rw [← Real.rpow_one t]
+      rw [← Real.rpow_add ht]
+      congr 1
+      dsimp [e]
+      ring
+    calc
+      _ = C m*((t^(k : ℝ)*t^(6/5 : ℝ))/(t^(6/5 : ℝ))^m) := by ring
+      _ = (C m*t^e)*t := by rw [hratio]; ring
+      _ ≤ ρ*t := mul_le_mul_of_nonneg_right heρ ht.le
+  · exact Real.rpow_le_rpow_of_exponent_ge ht ht1 (by linarith)
+  · exact Real.rpow_le_rpow_of_exponent_ge ht ht1 (by linarith)
+
+end ClosedSurfaceR4.ExactCorrection
+
+end
+
+end OAI

lean/OAI/Geometry/SurfaceImmersion/Geometry/ExplicitPowerThreshold.lean

@@ -0,0 +1,65 @@
+import OAI.Geometry.SurfaceImmersion.Geometry.FixedOrderThreshold
+import OAI.Geometry.SurfaceImmersion.Correction.PolynomialBudgetAlgebra
+
+namespace OAI
+
+/-! Explicit integer-power thresholds for the finitely many real powers
+used by the first correction block. -/
+noncomputable section
+namespace ClosedSurfaceR4.ExactCorrection
+
+/-- The exponent of this threshold depends only on a lower bound for the
+positive exponent, not on either numerical constant. -/
+def powerThreshold (n : ℕ) (c b : ℝ) : ℝ := (min 1 (b/(c+1)))^n
+
+theorem powerThreshold_spec {n : ℕ} (hn : 0 < n) {c b p : ℝ}
+    (hc : 0 ≤ c) (hb : 0 < b) (hp : (n : ℝ)⁻¹ ≤ p) :
+    0 < powerThreshold n c b ∧ powerThreshold n c b ≤ 1 ∧
+    ∀ t : ℝ, 0 < t → t < powerThreshold n c b → c*t^p < b := by
+  let q := min 1 (b/(c+1))
+  have hq : 0 < q := lt_min zero_lt_one (div_pos hb (by linarith))
+  have hq1 : q ≤ 1 := min_le_left _ _
+  have hn' : 0 < (n : ℝ) := by exact_mod_cast hn
+  refine ⟨pow_pos hq n, pow_le_one₀ hq.le hq1,?_⟩
+  intro t ht hsmall
+  have ht1 : t ≤ 1 := hsmall.le.trans (pow_le_one₀ hq.le hq1)
+  have hroot : t^((n : ℝ)⁻¹) < q := by
+    have h := Real.rpow_lt_rpow ht.le hsmall (inv_pos.mpr hn')
+    change t^((n : ℝ)⁻¹) < (q^n)^((n : ℝ)⁻¹) at h
+    rwa [← Real.rpow_natCast, Real.rpow_rpow_inv hq.le hn'.ne'] at h
+  have htp : t^p < q :=
+    (Real.rpow_le_rpow_of_exponent_ge ht ht1 hp).trans_lt hroot
+  have hqb : (c+1)*q ≤ b := by
+    have h := (le_div_iff₀ (show 0 < c+1 by linarith)).mp
+      (show q ≤ b/(c+1) from min_le_right _ _)
+    nlinarith
+  calc
+    c*t^p ≤ (c+1)*t^p := mul_le_mul_of_nonneg_right (by linarith) (Real.rpow_nonneg ht.le _)
+    _ < (c+1)*q := mul_lt_mul_of_pos_left htp (by linarith)
+    _ ≤ b := hqb
+
+/-- An upper bound on the reciprocal threshold follows from upper bounds
+on the coefficient and reciprocal margin. -/
+lemma powerThreshold_inverse_le {n : ℕ} {c b C B : ℝ}
+    (hc : 0 ≤ c) (hb : 0 < b) (hC : c ≤ C) (hB : b⁻¹ ≤ B) :
+    (powerThreshold n c b)⁻¹ ≤ (1+(C+1)*B)^n := by
+  have hC0 : 0 ≤ C := hc.trans hC
+  have hB0 : 0 ≤ B := (inv_pos.mpr hb).le.trans hB
+  have hq : 0 < min 1 (b/(c+1)) := lt_min zero_lt_one (div_pos hb (by linarith))
+  have hi : (min 1 (b/(c+1)))⁻¹ ≤ 1+(C+1)*B := by
+    have hh : (c+1)/b ≤ (C+1)*B := by
+      rw [div_eq_mul_inv]
+      exact mul_le_mul (by linarith) hB (inv_nonneg.mpr hb.le) (by linarith)
+    by_cases hle : b/(c+1) ≤ 1
+    · rw [min_eq_right hle, inv_div]
+      linarith
+    · rw [min_eq_left (le_of_not_ge hle), inv_one]
+      nlinarith
+  rw [powerThreshold, ← inv_pow]
+  exact pow_le_pow_left₀ (inv_nonneg.mpr hq.le) hi n
+
+end ClosedSurfaceR4.ExactCorrection
+
+end
+
+end OAI