Add lean source and binary files (part 37)

lean/OAI/Analysis/RieszRectifiability/Rigidity/ShrinkingJetSeminorms.lean

@@ -0,0 +1,97 @@
+import Mathlib
+import OAI.Analysis.RieszRectifiability.Rigidity.VanishingJetGrowth
+import OAI.Analysis.RieszRectifiability.Limits.SchwartzCutoffConvergence
+
+namespace OAI
+
+namespace RieszRectifiability
+
+noncomputable section
+
+open SchwartzMap Metric Set Filter Topology
+open scoped ContDiff
+
+def jetCutoffCoefficient (C : ℕ → ℝ) (n : ℕ) : ℝ :=
+  ∑ i ∈ Finset.range (n + 1), (n.choose i : ℝ) * C i * 2 ^ (i + 1)
+
+theorem jetCutoffCoefficient_nonneg (C : ℕ → ℝ) (hC : ∀ i, 0 ≤ C i) (n : ℕ) :
+    0 ≤ jetCutoffCoefficient C n :=
+  Finset.sum_nonneg fun i _ => mul_nonneg (mul_nonneg (by positivity) (hC i)) (by positivity)
+
+theorem inverse_scale_cancel (r : ℝ) (hr : 0 < r) (i : ℕ) :
+    (r⁻¹) ^ i * (2 * r) ^ (i + 1) = 2 ^ (i + 1) * r := by
+  rw [mul_pow, pow_succ r]
+  calc
+    _ = 2 ^ (i + 1) * ((r⁻¹) ^ i * r ^ i) * r := by ring
+    _ = _ := by rw [← mul_pow, inv_mul_cancel₀ hr.ne', one_pow, mul_one]
+
+theorem zero_jet_localized_derivative_bound {d : ℕ} {F : Type*}
+    [NormedAddCommGroup F] [NormedSpace ℝ F]
+    (g : 𝓢(Ambient d, F)) (n : ℕ)
+    (hz : ∀ i, i ≤ n → iteratedFDeriv ℝ i g 0 = 0)
+    (q : Ambient d → ℝ) (hq : ContDiff ℝ ∞ q)
+    (C : ℕ → ℝ) (hC : ∀ i, 0 ≤ C i) (r : ℝ) (hr : 0 < r)
+    (hb : ∀ i x, ‖iteratedFDeriv ℝ i q x‖ ≤ C i * (r⁻¹) ^ i)
+    (x : Ambient d) (hx : ‖x‖ ≤ 2 * r) :
+    ‖iteratedFDeriv ℝ n (fun y => q y • g y) x‖ ≤
+      SchwartzMap.seminorm ℝ 0 (n + 1) g * jetCutoffCoefficient C n * r := by
+  let M := SchwartzMap.seminorm ℝ 0 (n + 1) g
+  have hM : 0 ≤ M := apply_nonneg _ _
+  have hd := norm_iteratedFDeriv_smul_le hq (g.smooth ⊤) x (n := n) (mod_cast le_top)
+  apply hd.trans
+  calc
+    _ ≤ ∑ i ∈ Finset.range (n + 1), M * ((n.choose i : ℝ) * C i * 2 ^ (i + 1)) * r := by
+      apply Finset.sum_le_sum
+      intro i hi
+      have hin : i ≤ n := by simpa only [Finset.mem_range, Nat.lt_succ_iff] using! hi
+      have hg : ‖iteratedFDeriv ℝ (n - i) g x‖ ≤ M * (2 * r) ^ (i + 1) := by
+        have ht := schwartz_zero_jet_derivative_bound g n (n - i) (by omega) hz x
+        rw [show n + 1 - (n - i) = i + 1 by omega] at ht
+        exact ht.trans (mul_le_mul_of_nonneg_left (pow_le_pow_left₀ (norm_nonneg _) hx _) hM)
+      calc
+        _ ≤ (n.choose i : ℝ) * (C i * (r⁻¹) ^ i) * (M * (2 * r) ^ (i + 1)) := by
+          exact mul_le_mul (mul_le_mul_of_nonneg_left (hb i x) (by positivity)) hg
+            (norm_nonneg _) (mul_nonneg (by positivity) (mul_nonneg (hC i) (by positivity)))
+        _ = M * ((n.choose i : ℝ) * C i) * ((r⁻¹) ^ i * (2 * r) ^ (i + 1)) := by ring
+        _ = _ := by rw [inverse_scale_cancel r hr i]; ring
+    _ = _ := by
+      unfold jetCutoffCoefficient
+      rw [Finset.mul_sum, Finset.sum_mul]
+
+theorem zero_jet_localized_seminorm_bound {d : ℕ} {F : Type*}
+    [NormedAddCommGroup F] [NormedSpace ℝ F]
+    (g : 𝓢(Ambient d, F)) (k n : ℕ)
+    (hz : ∀ i, i ≤ n → iteratedFDeriv ℝ i g 0 = 0)
+    (q : Ambient d → ℝ) (hq : q.HasTemperateGrowth)
+    (C : ℕ → ℝ) (hC : ∀ i, 0 ≤ C i) (r : ℝ) (hr : 0 < r) (hrsmall : 2 * r ≤ 1)
+    (hb : ∀ i x, ‖iteratedFDeriv ℝ i q x‖ ≤ C i * (r⁻¹) ^ i)
+    (hs : tsupport q ⊆ closedBall (0 : Ambient d) (2 * r)) :
+    SchwartzMap.seminorm ℝ k n (smulLeftCLM F q g) ≤
+      SchwartzMap.seminorm ℝ 0 (n + 1) g * jetCutoffCoefficient C n * r := by
+  have hnonneg : 0 ≤ SchwartzMap.seminorm ℝ 0 (n + 1) g * jetCutoffCoefficient C n * r :=
+    mul_nonneg (mul_nonneg (apply_nonneg _ _) (jetCutoffCoefficient_nonneg C hC n)) hr.le
+  apply seminorm_le_bound ℝ k n _ hnonneg
+  intro x
+  rw [smulLeftCLM_apply hq]
+  by_cases hx : x ∈ closedBall (0 : Ambient d) (2 * r)
+  · have hxr : ‖x‖ ≤ 2 * r := by simpa only [mem_closedBall, dist_zero_right] using! hx
+    calc
+      _ ≤ 1 * ‖iteratedFDeriv ℝ n (fun y => q y • g y) x‖ :=
+        mul_le_mul_of_nonneg_right (pow_le_one₀ (norm_nonneg _) (hxr.trans hrsmall)) (norm_nonneg _)
+      _ ≤ _ := by
+        rw [one_mul]
+        exact zero_jet_localized_derivative_bound g n hz q hq.1 C hC r hr hb x hxr
+  · have hnot : x ∉ tsupport q := fun h => hx (hs h)
+    have heq : (fun y => q y • g y) =ᶠ[𝓝 x] (fun _ => (0 : F)) := by
+      filter_upwards [notMem_tsupport_iff_eventuallyEq.mp hnot] with y hy
+      simp only [Pi.zero_apply] at hy
+      rw [hy, zero_smul]
+    have hd := (heq.iteratedFDeriv ℝ n).eq_of_nhds
+    rw [hd]
+    simpa only [iteratedFDeriv_fun_zero, Pi.zero_apply, norm_zero, mul_zero] using! hnonneg
+
+end
+
+end RieszRectifiability
+
+end OAI

lean/OAI/Analysis/RieszRectifiability/Rigidity/SourceDensityFractionalEquation.lean

@@ -0,0 +1,51 @@
+import Mathlib
+import OAI.Analysis.RieszRectifiability.Kernel.SourceDensityRieszEquation
+import OAI.Analysis.RieszRectifiability.Foundations.DensityGradientEquation
+
+namespace OAI
+
+namespace RieszRectifiability
+
+noncomputable section
+
+open MeasureTheory SchwartzMap Metric Set Filter Topology
+open scoped NNReal ENNReal
+
+theorem source_planar_density_fractional_equation {d : ℕ} (p : ℕ) (C G : ℝ)
+    (μ : ℕ → Measure (Ambient d)) (ν : Measure (Ambient d))
+    [∀ j, IsFiniteMeasureOnCompacts (μ j)] [IsFiniteMeasureOnCompacts ν]
+    (hgrowth : ∀ j, GlobalUpperGrowth (p + 1) C (μ j))
+    (hgν : GlobalUpperGrowth (p + 1) G ν) (hweak : CompactTestConvergence μ ν)
+    (D : ℝ≥0)
+    (hB : ∀ j ε, 0 < ε → ∀ u : Ambient d → ℝ, MemLp u 2 (μ j) →
+      MemLp (truncated (p + 1) (μ j) ε u) 2 (μ j) ∧
+        eLpNorm (truncated (p + 1) (μ j) ε u) 2 (μ j) ≤ (D : ℝ≥0∞) * eLpNorm u 2 (μ j))
+    (L : Ambient (p + 1) →ₗᵢ[ℝ] Ambient d) (f : Ambient (p + 1) → ℝ)
+    (hf : Measurable f) (c : ℝ) (hc : 0 < c) (hlower : ∀ x, c ≤ f x)
+    (M : ℝ) (hupper : ∀ x, |f x| ≤ M)
+    (hdensity : ((volume : Measure (Ambient (p + 1))).withDensity
+      (fun x => ENNReal.ofReal (f x))).map L = ν)
+    (a : Ambient (p + 1)) (H R : ℝ) (hH : 0 < H) (hR : 0 < R) (hHR : 2 * H ≤ R)
+    (hboundary : ν (frontier (ball (L a) R)) = 0) (hmass : ν (ball (L a) R) ≠ 0)
+    (cMass : ℝ) (hcMass : 0 < cMass)
+    (hlowerMass : ENNReal.ofReal (cMass * (H / 4) ^ (p + 1)) ≤ ν (ball (L a) (H / 4)))
+    (hreflect : ScalarReflectionlessAt (p + 1) ν (L a))
+    (ψ : 𝓢(Ambient (p + 1), ℝ)) (hψc : HasCompactSupport ψ) (hψs : tsupport ψ ⊆ ball a H) :
+    Integrable (fun y => f y * ((-1 / 2 : ℝ) * ∫ h, fractionalSchwartzKernel (p + 1) ψ y h)) volume ∧
+      (∫ y, f y * ((-1 / 2 : ℝ) * ∫ h, fractionalSchwartzKernel (p + 1) ψ y h)) = 0 := by
+  apply density_fractional_equation_of_riesz_tests p f ψ
+  intro e
+  obtain ⟨_, _, hDs, _, hmean⟩ :=
+    compact_smooth_directional_derivative_test ψ (ψ.smooth ⊤) hψc e
+  have hsupport : ∀ x, scalarSchwartzDerivative ψ e x ≠ 0 → x ∈ ball a H := by
+    intro x hx
+    exact hψs (hDs (subset_tsupport (fun y => fderiv ℝ ψ y e) hx))
+  exact source_planar_density_riesz_test_equation p C G μ ν hgrowth hgν hweak D hB
+    L f hf c hc hlower M hupper hdensity e a H R hH hR hHR hboundary hmass cMass hcMass
+    hlowerMass hreflect (scalarSchwartzDerivative ψ e) hmean hsupport
+
+end
+
+end RieszRectifiability
+
+end OAI

lean/OAI/Analysis/RieszRectifiability/Rigidity/SupportedFractionalCutoff.lean

@@ -0,0 +1,89 @@
+import Mathlib
+import OAI.Analysis.RieszRectifiability.Nets.FinitePairingCancellation
+import OAI.Analysis.RieszRectifiability.Rigidity.FiniteFractionalHeightPairing
+import OAI.Analysis.RieszRectifiability.Kernel.SupportedKernelDecomposition
+
+namespace OAI
+
+/-!
+# Fractional cutoffs for supported tests
+
+Separation between the test support and the exterior region makes the cutoff
+inactive in cross terms. The cutoff increment is also the closed-exterior
+indicator of the full increment, giving its integrability and its equality
+with the truncated fractional Schwartz test.
+-/
+
+namespace RieszRectifiability
+
+noncomputable section
+
+open MeasureTheory Metric Set Filter SchwartzMap
+
+theorem supported_fractional_cutoff_cross {d : ℕ} (m : ℕ) (ε H R : ℝ)
+    (a x y : Ambient d) (g : Ambient d → ℂ)
+    (hnear : g x ≠ 0 → dist x a ≤ H) (hfar : y ∈ closedExterior a R)
+    (hsep : ε + H ≤ R) :
+    symmetricFractionalCutoffKernel m ε (x, y) • g x =
+      inverseDistancePow (m + 1) x y • g x := by
+  by_cases hg : g x = 0
+  · rw [hg]
+    exact (smul_zero _).trans (smul_zero _).symm
+  · have hy : R ≤ dist a y := hfar
+    have ht := dist_triangle a x y
+    rw [dist_comm a x] at ht
+    have hd : ε ≤ dist x y := by linarith [hnear hg]
+    simp only [symmetricFractionalCutoffKernel, ite_eq_left hd]
+
+theorem supported_fractional_cutoff_cross_swap {d : ℕ} (m : ℕ) (ε H R : ℝ)
+    (a x y : Ambient d) (g : Ambient d → ℂ)
+    (hnear : g x ≠ 0 → dist x a ≤ H) (hfar : y ∈ closedExterior a R)
+    (hsep : ε + H ≤ R) :
+    symmetricFractionalCutoffKernel m ε (y, x) • g x =
+      inverseDistancePow (m + 1) x y • g x := by
+  rw [show symmetricFractionalCutoffKernel m ε (y, x) =
+      symmetricFractionalCutoffKernel m ε (x, y) from
+    symmetricFractionalCutoffKernel_swap m ε (x, y)]
+  exact supported_fractional_cutoff_cross m ε H R a x y g hnear hfar hsep
+
+theorem test_zero_outside_localization {d : ℕ} (g : Ambient d → ℂ)
+    (a : Ambient d) (H R : ℝ) (hHR : H < R)
+    (hnear : ∀ x, g x ≠ 0 → dist x a ≤ H) :
+    ∀ y ∈ (ball a R)ᶜ, g y = 0 := by
+  intro y hy
+  by_contra hgy
+  have hh := hnear y hgy
+  have hf : R ≤ dist y a := by simpa only [mem_compl_iff, mem_ball, not_lt] using! hy
+  linarith
+
+theorem fractional_cutoff_increment_eq_indicator {d : ℕ} (m : ℕ) (ε : ℝ)
+    (g : Ambient d → ℂ) (x : Ambient d) :
+    (fun y => symmetricFractionalCutoffKernel m ε (x, y) • (g x - g y)) =
+      (closedExterior x ε).indicator (fun y => inverseDistancePow (m + 1) x y • (g x - g y)) := by
+  funext y
+  by_cases h : ε ≤ dist x y
+  · rw [indicator_of_mem (show y ∈ closedExterior x ε from h)]
+    simp only [symmetricFractionalCutoffKernel, ite_eq_left h]
+  · rw [indicator_of_notMem (show y ∉ closedExterior x ε from h)]
+    simp only [symmetricFractionalCutoffKernel, ite_eq_right h]
+    exact zero_smul ℝ (g x - g y)
+
+theorem fractional_cutoff_increment_integrable (p : ℕ) (ε : ℝ) (hε : 0 < ε)
+    (g : 𝓢(Ambient (p + 1), ℂ)) (x : Ambient (p + 1)) :
+    Integrable (fun y => symmetricFractionalCutoffKernel (p + 1) ε (x, y) • (g x - g y)) volume := by
+  rw [fractional_cutoff_increment_eq_indicator]
+  exact (integrable_indicator_iff (closedExterior_measurable x ε)).2
+    (fractionalSchwartz_single_increment_integrable p ε hε g x)
+
+theorem fractional_cutoff_increment_integral (p : ℕ) (ε : ℝ) (hε : 0 < ε)
+    (g : 𝓢(Ambient (p + 1), ℂ)) (x : Ambient (p + 1)) :
+    (∫ y, symmetricFractionalCutoffKernel (p + 1) ε (x, y) • (g x - g y)) =
+      fractionalSchwartzTruncatedTest p ε g x := by
+  rw [fractional_cutoff_increment_eq_indicator, integral_indicator (closedExterior_measurable x ε)]
+  exact (fractionalSchwartzTruncatedTest_eq_single_increment p ε hε g x).symm
+
+end
+
+end RieszRectifiability
+
+end OAI

lean/OAI/Analysis/RieszRectifiability/Rigidity/TemperedFiniteOrderBound.lean

@@ -0,0 +1,28 @@
+import Mathlib
+import OAI.Analysis.RieszRectifiability.Rigidity.HeightTemperedDistribution
+
+namespace OAI
+
+namespace RieszRectifiability
+
+noncomputable section
+
+open SchwartzMap MeasureTheory
+
+theorem tempered_distribution_finite_seminorm_bound {d : ℕ}
+    (T : 𝓢'(Ambient d, ℂ)) :
+    ∃ s : Finset (ℕ × ℕ), ∃ C : ℝ, 0 < C ∧
+      ∀ g : 𝓢(Ambient d, ℂ),
+        ‖T g‖ ≤ C * s.sup (schwartzSeminormFamily ℂ (Ambient d) ℂ) g := by
+  let q : Seminorm ℂ 𝓢(Ambient d, ℂ) := (normSeminorm ℂ ℂ).comp T.toLinearMap
+  have hq : Continuous q := continuous_norm.comp T.continuous
+  obtain ⟨s, C, hC, hbound⟩ := Seminorm.bound_of_continuous
+    (schwartz_withSeminorms ℂ (Ambient d) ℂ) q hq
+  refine ⟨s, C, by exact_mod_cast (pos_iff_ne_zero.mpr hC), fun g => ?_⟩
+  exact hbound g
+
+end
+
+end RieszRectifiability
+
+end OAI

lean/OAI/Analysis/RieszRectifiability/Rigidity/TemperedHeightWeights.lean

@@ -0,0 +1,81 @@
+import Mathlib
+import OAI.Analysis.RieszRectifiability.Nets.FinitePairingCancellation
+
+namespace OAI
+
+namespace RieszRectifiability
+
+noncomputable section
+
+open MeasureTheory Metric Set Function Filter Topology
+
+def polynomialDecay {d : ℕ} (q : ℕ) (x : Ambient d) : ℝ := ((1 + ‖x‖) ^ q)⁻¹
+
+theorem polynomialDecay_measurable {d : ℕ} (q : ℕ) :
+    Measurable (polynomialDecay (d := d) q) := by
+  unfold polynomialDecay
+  fun_prop
+
+theorem polynomialDecay_nonneg {d : ℕ} (q : ℕ) (x : Ambient d) : 0 ≤ polynomialDecay q x := by
+  unfold polynomialDecay
+  positivity
+
+theorem polynomialDecay_le_one {d : ℕ} (q : ℕ) (x : Ambient d) : polynomialDecay q x ≤ 1 := by
+  unfold polynomialDecay
+  apply inv_le_one_of_one_le₀
+  exact one_le_pow₀ (by linarith [norm_nonneg x] : (1 : ℝ) ≤ 1 + ‖x‖)
+
+theorem polynomialDecay_eq_rpow {d : ℕ} (q : ℕ) (x : Ambient d) :
+    polynomialDecay q x = (1 + ‖x‖) ^ (-(q : ℝ)) := by
+  rw [Real.rpow_neg (by positivity), Real.rpow_natCast]
+  rfl
+
+theorem polynomialDecay_le_far {d : ℕ} (q : ℕ) (a x : Ambient d) (hx : 0 < dist a x) :
+    polynomialDecay q x ≤ (1 + ‖a‖) ^ q * inverseDistancePow q a x := by
+  have hd : dist a x ≤ (1 + ‖a‖) * (1 + ‖x‖) := by
+    have h : dist a x ≤ ‖a‖ + ‖x‖ := by
+      rw [dist_eq_norm]
+      exact norm_sub_le a x
+    nlinarith [norm_nonneg a, norm_nonneg x, mul_nonneg (norm_nonneg a) (norm_nonneg x)]
+  have hp := pow_le_pow_left₀ (by positivity : 0 ≤ dist a x) hd q
+  rw [inverseDistancePow, ← div_eq_mul_inv]
+  apply (le_div_iff₀ (pow_pos hx q)).mpr
+  calc
+    _ ≤ polynomialDecay q x * ((1 + ‖a‖) * (1 + ‖x‖)) ^ q :=
+      mul_le_mul_of_nonneg_left hp (polynomialDecay_nonneg q x)
+    _ = _ := by
+      unfold polynomialDecay
+      rw [mul_pow]
+      field_simp
+
+theorem polynomial_weight_integrable_from_height_tail {d : ℕ} (q : ℕ)
+    (μ : Measure (Ambient d)) (f : Ambient d → ℝ) (hf : Measurable f)
+    (a : Ambient d) (R : ℝ) (hR : 0 < R)
+    (hnear : IntegrableOn f (ball a R) μ)
+    (hfar : IntegrableOn (fun x => |f x| * inverseDistancePow q a x) (closedExterior a R) μ) :
+    Integrable (fun x => |f x| * polynomialDecay q x) μ := by
+  have hm : Measurable (fun x => |f x| * polynomialDecay q x) :=
+    hf.abs.mul (polynomialDecay_measurable q)
+  have hi : IntegrableOn (fun x => |f x| * polynomialDecay q x) (ball a R) μ := by
+    apply hnear.abs.mono' hm.aestronglyMeasurable
+    apply Eventually.of_forall
+    intro x
+    rw [Real.norm_of_nonneg (mul_nonneg (abs_nonneg _) (polynomialDecay_nonneg q x))]
+    simpa only [mul_one] using! mul_le_mul_of_nonneg_left (polynomialDecay_le_one q x) (abs_nonneg _)
+  have ho : IntegrableOn (fun x => |f x| * polynomialDecay q x) (closedExterior a R) μ := by
+    apply (hfar.const_mul ((1 + ‖a‖) ^ q)).mono' hm.aestronglyMeasurable
+    filter_upwards [ae_restrict_mem (closedExterior_measurable a R)] with x hx
+    rw [Real.norm_of_nonneg (mul_nonneg (abs_nonneg _) (polynomialDecay_nonneg q x))]
+    calc
+      _ ≤ |f x| * ((1 + ‖a‖) ^ q * inverseDistancePow q a x) :=
+        mul_le_mul_of_nonneg_left (polynomialDecay_le_far q a x (hR.trans_le hx)) (abs_nonneg _)
+      _ = _ := by ring
+  have hu := hi.union ho
+  rw [closedExterior_eq_compl_ball, union_compl_self, integrableOn_univ] at hu
+  exact hu
+
+end
+
+end RieszRectifiability
+
+end OAI

lean/OAI/Analysis/RieszRectifiability/Rigidity/TemperedRealFiniteOrderBound.lean

@@ -0,0 +1,29 @@
+import Mathlib
+import OAI.Analysis.RieszRectifiability.Rigidity.TemperedFiniteOrderBound
+
+namespace OAI
+
+namespace RieszRectifiability
+
+noncomputable section
+
+open SchwartzMap
+
+theorem tempered_distribution_finite_real_seminorm_bound {d : ℕ}
+    (T : 𝓢'(Ambient d, ℂ)) :
+    ∃ s : Finset (ℕ × ℕ), ∃ C : ℝ, 0 < C ∧
+      ∀ g : 𝓢(Ambient d, ℂ),
+        ‖T g‖ ≤ C * s.sup (schwartzSeminormFamily ℝ (Ambient d) ℂ) g := by
+  obtain ⟨s, C, hC, hbound⟩ := tempered_distribution_finite_seminorm_bound T
+  refine ⟨s, C, hC, fun g => ?_⟩
+  have heq : s.sup (schwartzSeminormFamily ℂ (Ambient d) ℂ) g =
+      s.sup (schwartzSeminormFamily ℝ (Ambient d) ℂ) g := by
+    simp only [Seminorm.finset_sup_apply]
+    rfl
+  exact (hbound g).trans_eq (congrArg (fun t : ℝ => C * t) heq)
+
+end
+
+end RieszRectifiability
+
+end OAI

lean/OAI/Analysis/RieszRectifiability/Rigidity/TruncatedRenormalizedHeightIdentity.lean

@@ -0,0 +1,127 @@
+import Mathlib
+import OAI.Analysis.RieszRectifiability.Rigidity.SupportedFractionalCutoff
+import OAI.Analysis.RieszRectifiability.Kernel.ComplexExteriorIntegrability
+import OAI.Analysis.RieszRectifiability.Nets.RenormalizedCrossCancellation
+
+namespace OAI
+
+/-!
+# Truncated height pairing and its renormalized exterior term
+
+For a compactly supported mean-zero Schwartz test, the weighted truncated
+fractional pairing splits into a symmetric local pairing and a renormalized
+exterior integral. Support separation removes the cutoff in cross terms, and
+the weighted exterior hypothesis supplies the integrability needed for cancellation.
+-/
+
+namespace RieszRectifiability
+
+noncomputable section
+
+open MeasureTheory Metric Set Filter SchwartzMap
+
+theorem compact_schwartz_truncated_height_pairing (p : ℕ)
+    (a : Ambient (p + 1)) (H R : ℝ) (hH : 0 ≤ H) (hR : 0 < R) (hHR : 2 * H ≤ R)
+    (ε : ℝ) (hε : 0 < ε) (hsep : ε + H ≤ R)
+    (w : Ambient (p + 1) → ℝ) (hwm : Measurable w)
+    (hw : IntegrableOn w (ball a R) volume)
+    (g : 𝓢(Ambient (p + 1), ℂ)) (hzero : (∫ x, g x) = 0)
+    (hnear : ∀ x, g x ≠ 0 → dist x a ≤ H)
+    (B : ℝ) (hB : 0 ≤ B) (hgB : ∀ x, ‖g x‖ ≤ B)
+    (hweighted : IntegrableOn (fun y => |w y| * inverseDistancePow (p + 1 + 2) a y)
+      (closedExterior a R) volume) :
+    Integrable (fun x => w x • fractionalSchwartzTruncatedTest p ε g x) volume ∧
+      (∫ x, w x • fractionalSchwartzTruncatedTest p ε g x) =
+        (1 / 2 : ℝ) • (∫ q : Ambient (p + 1) × Ambient (p + 1),
+          (w q.1 - w q.2) • (symmetricFractionalCutoffKernel (p + 1) ε q • (g q.1 - g q.2))
+          ∂(volume.restrict (ball a R)).prod (volume.restrict (ball a R))) +
+        ∫ q, complexRenormalizedNormalIntegrand (p + 1) w g a q
+          ∂(volume.restrict (ball a R)).prod (volume.restrict (ball a R)ᶜ) := by
+  let μ : Measure (Ambient (p + 1)) := volume
+  let ν := μ.restrict (ball a R)
+  let η := μ.restrict (ball a R)ᶜ
+  let C := (volume (ball (0 : Ambient (p + 1)) 1)).toReal
+  let k := symmetricFractionalCutoffKernel (d := p + 1) (p + 1) ε
+  have hgrowth : GlobalUpperGrowth (p + 1) C μ := volume_global_upper_growth (p + 1)
+  let : IsFiniteMeasure ν := finiteMeasure_restrict_ball_of_globalGrowth (p + 1) C μ hgrowth a R hR
+  have hgs := test_zero_outside_localization g a H R (by linarith) hnear
+  have hgm : Measurable g := g.continuous.measurable
+  have hgn : Integrable (fun x => ‖g x‖) ν := g.integrable.restrict.norm
+  have hgnw : Integrable (fun x => ‖g x‖ * w x) ν :=
+    hw.bdd_mul hgm.norm.aestronglyMeasurable
+      (Eventually.of_forall fun x => by simpa only [norm_norm] using! hgB x)
+  have hzν : (∫ x, g x ∂ν) = 0 := by
+    exact (setIntegral_eq_integral_of_forall_compl_eq_zero hgs).trans hzero
+  have hD : Integrable (fun q : Ambient (p + 1) × Ambient (p + 1) =>
+      w q.1 • (inverseDistancePow (p + 1 + 1) q.1 q.2 • g q.1)) (ν.prod η) := by
+    simpa only [closedExterior_eq_compl_ball] using! direct_height_exterior_integrable
+      (p + 1) C μ ν hgrowth w g hwm hgm hgnw a H R hR hHR (Eventually.of_forall hnear)
+  have hN : Integrable (complexRenormalizedNormalIntegrand (p + 1) w g a) (ν.prod η) := by
+    simpa only [closedExterior_eq_compl_ball] using! complex_renormalized_exterior_integrable
+      (p + 1) C μ ν hgrowth w g hwm hgm hgn hgnw a H R hH hR hHR
+      (Eventually.of_forall hnear) hweighted
+  have hraw : ∀ᵐ y ∂η, Integrable (fun x => inverseDistancePow (p + 1 + 1) x y • g x) ν := by
+    filter_upwards [ae_restrict_mem (μ := μ)
+      (show MeasurableSet (ball a R)ᶜ from measurableSet_ball.compl)] with y hy
+    have hy' : R ≤ dist a y := by
+      rwa [← closedExterior_eq_compl_ball] at hy
+    exact far_kernel_test_integrable_of_support ν g hgm g.integrable.restrict
+      (p + 1) a y H R hR hHR (Eventually.of_forall hnear) hy'
+  have hcross := renormalized_complex_cross_integral_identity (p + 1) ν η w g a
+    g.integrable.restrict hzν hraw hD hN
+  have hcut (x y : Ambient (p + 1)) (hy : y ∈ (ball a R)ᶜ) :
+      k (x, y) • g x = inverseDistancePow (p + 1 + 1) x y • g x :=
+    supported_fractional_cutoff_cross (p + 1) ε H R a x y g (hnear x)
+      (by rwa [closedExterior_eq_compl_ball]) hsep
+  have hcutswap (x y : Ambient (p + 1)) (hy : y ∈ (ball a R)ᶜ) :
+      k (y, x) • g x = inverseDistancePow (p + 1 + 1) x y • g x :=
+    supported_fractional_cutoff_cross_swap (p + 1) ε H R a x y g (hnear x)
+      (by rwa [closedExterior_eq_compl_ball]) hsep
+  have hDcut : Integrable (fun q : Ambient (p + 1) × Ambient (p + 1) =>
+      w q.1 • (k q • g q.1)) (ν.prod η) := by
+    apply hD.congr
+    filter_upwards [Measure.quasiMeasurePreserving_snd.ae
+      (ae_restrict_mem (μ := μ) (show MeasurableSet (ball a R)ᶜ from measurableSet_ball.compl))] with q hq
+    exact congrArg (fun z : ℂ => w q.1 • z) (hcut q.1 q.2 hq).symm
+  have hOeq : (fun y => w y • (∫ x, k (y, x) • g x ∂ν)) =��[η]
+      fun y => w y • (∫ x, inverseDistancePow (p + 1 + 1) x y • g x ∂ν) := by
+    filter_upwards [ae_restrict_mem (μ := μ)
+      (show MeasurableSet (ball a R)ᶜ from measurableSet_ball.compl)] with y hy
+    apply congrArg (fun z : ℂ => w y • z)
+    exact integral_congr_ae (Eventually.of_forall fun x => hcutswap x y hy)
+  have hO := hcross.1.congr hOeq.symm
+  have hL := bounded_kernel_height_integrable ν w hwm hw g hgm B hB hgB k
+    (symmetricFractionalCutoffKernel_measurable (p + 1) ε) ((ε ^ (p + 1 + 1))⁻¹)
+    (symmetricFractionalCutoffKernel_bound (p + 1) ε hε)
+  have hdec := supported_height_kernel_integral_decomposition μ (ball a R) measurableSet_ball
+    w g hgs k (fractional_cutoff_increment_integrable p ε hε g) hL hDcut hO
+  have hpair := (finite_symmetric_height_kernel_pairing ν w hwm hw g hgm B hB hgB k
+    (symmetricFractionalCutoffKernel_measurable (p + 1) ε) ((ε ^ (p + 1 + 1))⁻¹)
+    (symmetricFractionalCutoffKernel_bound (p + 1) ε hε)
+    (symmetricFractionalCutoffKernel_swap (p + 1) ε)).2
+  have hDeq : (∫ x, w x • (∫ y, k (x, y) • g x ∂η) ∂ν) =
+      ∫ x, w x • (∫ y, inverseDistancePow (p + 1 + 1) x y • g x ∂η) ∂ν := by
+    apply integral_congr_ae
+    apply Eventually.of_forall
+    intro x
+    apply congrArg (fun z : ℂ => w x • z)
+    apply setIntegral_congr_fun measurableSet_ball.compl
+    intro y hy
+    exact hcut x y hy
+  have hAe : (fun x => w x • (∫ y, k (x, y) • (g x - g y) ∂μ)) =
+      fun x => w x • fractionalSchwartzTruncatedTest p ε g x := by
+    funext x
+    exact congrArg (fun z : ℂ => w x • z) (fractional_cutoff_increment_integral p ε hε g x)
+  rw [hAe] at hdec
+  refine ⟨hdec.1, ?_⟩
+  change (∫ x, w x • fractionalSchwartzTruncatedTest p ε g x ∂μ) =
+    (1 / 2 : ℝ) • (∫ q, (w q.1 - w q.2) • (k q • (g q.1 - g q.2)) ∂ν.prod ν) +
+      ∫ q, complexRenormalizedNormalIntegrand (p + 1) w g a q ∂ν.prod η
+  rw [hdec.2, ← hpair, hDeq, integral_congr_ae hOeq, hcross.2]
+  abel
+
+end
+
+end RieszRectifiability
+
+end OAI

lean/OAI/Analysis/RieszRectifiability/Rigidity/VanishingJetGrowth.lean

@@ -0,0 +1,65 @@
+import Mathlib
+import OAI.Analysis.RieszRectifiability.Kernel.SchwartzSecondDifference
+
+namespace OAI
+
+namespace RieszRectifiability
+
+noncomputable section
+
+open SchwartzMap Metric Set
+open scoped ContDiff
+
+theorem iteratedFDeriv_growth_of_zero_jets {d : ℕ} {F : Type*}
+    [NormedAddCommGroup F] [NormedSpace ℝ F]
+    (f : Ambient d → F) (hf : ContDiff ℝ ∞ f)
+    (M : ℝ) (hM : 0 ≤ M) (n k : ℕ)
+    (hz : ∀ j, n ≤ j → j < n + k → iteratedFDeriv ℝ j f 0 = 0)
+    (hb : ∀ x, ‖iteratedFDeriv ℝ (n + k) f x‖ ≤ M) (x : Ambient d) :
+    ‖iteratedFDeriv ℝ n f x‖ ≤ M * ‖x‖ ^ k := by
+  induction k generalizing n x with
+  | zero => simpa only [Nat.add_zero, pow_zero, mul_one] using! hb x
+  | succ k ih =>
+    have hn : ∀ y, ‖iteratedFDeriv ℝ (n + 1) f y‖ ≤ M * ‖y‖ ^ k := by
+      intro y
+      apply ih (n + 1)
+      · intro j hj hjk
+        exact hz j (by omega) (by omega)
+      · intro z
+        rw [show n + 1 + k = n + (k + 1) by omega]
+        exact hb z
+    have hfinite : ContDiff ℝ (n + 1 : ℕ) f := hf.of_le (by exact_mod_cast le_top)
+    have hd : Differentiable ℝ (iteratedFDeriv ℝ n f) :=
+      hfinite.differentiable_iteratedFDeriv (by exact_mod_cast Nat.lt_succ_self n)
+    have hbound : ∀ y ∈ segment ℝ (0 : Ambient d) x,
+        ‖fderiv ℝ (iteratedFDeriv ℝ n f) y‖ ≤ M * ‖x‖ ^ k := by
+      intro y hy
+      rw [norm_fderiv_iteratedFDeriv]
+      apply (hn y).trans
+      have hxy : ‖y‖ ≤ ‖x‖ := by
+        simpa only [sub_zero] using! norm_sub_le_of_mem_segment hy
+      gcongr
+    have hv := (convex_segment (0 : Ambient d) x).norm_image_sub_le_of_norm_fderiv_le
+      (fun y _ => hd y) hbound (left_mem_segment ℝ 0 x) (right_mem_segment ℝ 0 x)
+    rw [hz n le_rfl (by omega), sub_zero, sub_zero] at hv
+    simpa only [pow_succ, mul_assoc] using! hv
+
+theorem schwartz_zero_jet_derivative_bound {d : ℕ} {F : Type*}
+    [NormedAddCommGroup F] [NormedSpace ℝ F]
+    (g : 𝓢(Ambient d, F)) (N j : ℕ) (hj : j ≤ N + 1)
+    (hz : ∀ i, i ≤ N → iteratedFDeriv ℝ i g 0 = 0) (x : Ambient d) :
+    ‖iteratedFDeriv ℝ j g x‖ ≤
+      SchwartzMap.seminorm ℝ 0 (N + 1) g * ‖x‖ ^ (N + 1 - j) := by
+  apply iteratedFDeriv_growth_of_zero_jets g (g.smooth ⊤)
+    (SchwartzMap.seminorm ℝ 0 (N + 1) g) (apply_nonneg _ _) j (N + 1 - j)
+  · intro i _ hi
+    exact hz i (by omega)
+  · intro y
+    rw [show j + (N + 1 - j) = N + 1 by omega]
+    exact norm_iteratedFDeriv_le_seminorm ℝ g (N + 1) y
+
+end
+
+end RieszRectifiability
+
+end OAI

lean/OAI/Analysis/RieszRectifiability/Surfaces/ActualNativeSurfaceGeometry.lean

@@ -0,0 +1,77 @@
+import Mathlib
+import OAI.Analysis.RieszRectifiability.Surfaces.NativeSurfaceRegularity
+import OAI.Analysis.RieszRectifiability.Restart.ActiveRegionMatchedProjection
+
+namespace OAI
+
+/-!
+# Geometry of the native area measure on a limit surface
+
+Two-sided Hausdorff area bounds on a closed embedded active-region limit image
+give regularity, exact support, AD regularity, and infinite support diameter for
+its native area measure. Matched projection estimates then transfer to that
+support with the same explicit flatness and disk-coverage constants.
+-/
+
+namespace RieszRectifiability
+
+noncomputable section
+
+open MeasureTheory Metric Set Topology
+open scoped ENNReal
+
+theorem active_region_native_surface_geometry {n d : ℕ} (hn : 0 < n)
+    (μ : Measure (Ambient d)) (R : ℝ) (hR : 0 < R) (k : ℕ)
+    (z : (supportLatticeNets μ R hR k).points)
+    (Good : SupportCellDescendant μ R hR k z → Prop)
+    (S : SupportCellDescendant μ R hR k z → AffineSubspace ℝ (Ambient d))
+    (hS : ∀ i, IsAffineNPlane n (S i)) (ε : ℝ) (hε : 0 < ε)
+    (hεfine : ε ≤ 1 / 72057594037927936) (hsmall : activeProjectionError d ε ≤ 1 / 4096)
+    (hfit : ∀ i, activeRegionCell Good i →
+      bilateralPlaneError μ i.center (1024 * i.radius) (S i) < ε)
+    (f : S (supportCellRoot μ R hR k z) → Ambient d)
+    (hmodel : IsActiveRegionLimitModel μ R hR k z Good S hS ε f)
+    (hembed : IsClosedEmbedding f)
+    (c C : ℝ≥0∞) (hc : 0 < c) (hcfin : c < ⊤) (hC : C < ⊤)
+    (hlower : ∀ p ∈ Set.range f, ∀ r : ℝ, 0 < r →
+      c * (ENNReal.ofReal r) ^ n ≤
+        (μH[(n : ℝ)] : Measure (Ambient d)) (Set.range f ∩ closedBall p r))
+    (hupper : ∀ (p : Ambient d) (r : ℝ), 0 < r →
+      (μH[(n : ℝ)] : Measure (Ambient d)) (Set.range f ∩ closedBall p r) ≤
+        C * (ENNReal.ofReal r) ^ n) :
+    let ν := nativeSurfaceArea n (Set.range f)
+    ν.Regular ∧ ν.support = Set.range f ∧ ADRegular n ν ∧ ediam ν.support = ⊤ ∧
+      1 ≤ nativeSurfaceADConstant n c C ∧
+      GlobalUpperGrowth n (nativeSurfaceADConstant n c C) ν ∧
+      (∀ p ∈ ν.support, ∀ r : ℝ, 0 < r →
+        ENNReal.ofReal (r ^ n / nativeSurfaceADConstant n c C) ≤ ν (ball p r)) ∧
+      ∀ p ∈ ν.support, ∀ r : ℝ, 0 < r →
+        ∃ P : Submodule ℝ (Ambient d), Module.finrank ℝ P = n ∧
+          (∀ x ∈ ν.support ∩ closedBall p (1024 * r),
+            infDist x (AffineSubspace.mk' p P : Set (Ambient d)) ≤
+              (281474976710656 * (ε + activeProjectionError d ε)) * r) ∧
+          closedBall (P.orthogonalProjectionOnto p) (r / 32) ⊆
+            P.orthogonalProjectionOnto '' (ν.support ∩ closedBall p (r / 16)) := by
+  dsimp only
+  have hclosed := hembed.isClosed_range
+  have hs := nativeSurfaceArea_support (Set.range f) hclosed c hc hlower
+  have hne : (Set.range f).Nonempty := by
+    obtain ⟨a, ha⟩ := (hS (supportCellRoot μ R hR k z)).1
+    exact ⟨f ⟨a, ha⟩, Set.mem_range_self _⟩
+  obtain ⟨hK, hg, hl⟩ := nativeSurfaceArea_uniform_bounds (Set.range f) c C hc hcfin hC hlower hupper
+  refine ⟨nativeSurfaceArea_regular _ C hC hupper, hs,
+    nativeSurfaceArea_adRegular _ hclosed c C hc hcfin hC hlower hupper,
+    nativeSurfaceArea_support_ediam_top hn _ hclosed hne c C hc hcfin hC hlower hupper,
+    hK, hg, ?_, ?_⟩
+  · intro p hp r hr
+    exact hl p (hs ▸ hp) r hr
+  · rw [hs]
+    intro p hp r hr
+    exact exists_active_region_matched_projection_all_scales μ R hR k z Good S hS
+      ε hε hεfine hsmall hfit f hmodel p hp r hr
+
+end
+
+end RieszRectifiability
+
+end OAI

lean/OAI/Analysis/RieszRectifiability/Surfaces/BallChartPartialMap.lean

@@ -0,0 +1,52 @@
+import Mathlib
+import OAI.Analysis.RieszRectifiability.Foundations.MeasureBounds
+
+namespace OAI
+
+/-!
+# Ball charts as ambient parameter maps
+
+A chart on a parameter ball is extended by zero outside its domain. On the ball,
+this ambient map agrees with the chart and retains its Lipschitz bound.
+-/
+
+namespace RieszRectifiability
+
+noncomputable section
+
+open Metric Set
+open scoped NNReal
+
+def ballChartPartialMap {n d : ℕ} (r : ℝ)
+    (g : ball (0 : Ambient n) r → Ambient d) (u : Ambient n) : Ambient d := by
+  classical
+  exact if hu : u ∈ ball (0 : Ambient n) r then g ⟨u, hu⟩ else 0
+
+theorem ballChartPartialMap_apply {n d : ℕ} (r : ℝ)
+    (g : ball (0 : Ambient n) r → Ambient d) (u : Ambient n) (hu : u ∈ ball (0 : Ambient n) r) :
+    ballChartPartialMap r g u = g ⟨u, hu⟩ := by
+  simp only [ballChartPartialMap, dite_eq_left hu]
+
+theorem ballChartPartialMap_lipschitzOn {n d : ℕ} (r : ℝ)
+    (g : ball (0 : Ambient n) r → Ambient d) (M : ℝ≥0) (hg : LipschitzWith M g) :
+    LipschitzOnWith M (ballChartPartialMap r g) (ball (0 : Ambient n) r) := by
+  apply LipschitzOnWith.of_dist_le_mul
+  intro x hx y hy
+  rw [ballChartPartialMap_apply r g x hx, ballChartPartialMap_apply r g y hy]
+  exact hg.dist_le_mul ⟨x, hx⟩ ⟨y, hy⟩
+
+theorem ballChartPartialMap_image {n d : ℕ} (r : ℝ)
+    (g : ball (0 : Ambient n) r → Ambient d) :
+    ballChartPartialMap r g '' ball (0 : Ambient n) r = Set.range g := by
+  apply Set.Subset.antisymm
+  · rintro y ⟨u, hu, rfl⟩
+    rw [ballChartPartialMap_apply r g u hu]
+    exact Set.mem_range_self (⟨u, hu⟩ : ball (0 : Ambient n) r)
+  · rintro y ⟨u, rfl⟩
+    exact ⟨u.val, u.property, ballChartPartialMap_apply r g u.val u.property⟩
+
+end
+
+end RieszRectifiability
+
+end OAI

lean/OAI/Analysis/RieszRectifiability/Surfaces/BoundedNormalizedBallCharts.lean

@@ -0,0 +1,82 @@
+import Mathlib
+import OAI.Analysis.RieszRectifiability.Surfaces.RescaledBallCharts
+
+namespace OAI
+
+/-!
+# Bounded normalized ball charts
+
+Metric projection onto a nonempty complete convex set gives a nonexpansive retraction.
+Composing this retraction with a rescaled ball chart bounds its range by a closed ball
+while preserving every point of the original image in that ball. The normalization
+halves the domain radius and multiplies the Lipschitz bound by two.
+-/
+
+namespace RieszRectifiability
+
+noncomputable section
+
+open Metric Set
+open scoped NNReal
+
+theorem exists_nonexpansive_retraction_of_complete_convex {d : ℕ}
+    (K : Set (Ambient d)) (hne : K.Nonempty) (hcomplete : IsComplete K) (hconvex : Convex ℝ K) :
+    ∃ p : Ambient d → Ambient d, LipschitzWith 1 p ∧
+      (∀ x, p x ∈ K) ∧ ∀ x ∈ K, p x = x := by
+  classical
+  choose p hp hmin using exists_norm_eq_iInf_of_complete_convex hne hcomplete hconvex
+  have hv (x : Ambient d) : ∀ w ∈ K, inner ℝ (x - p x) (w - p x) ≤ 0 :=
+    (norm_eq_iInf_iff_real_inner_le_zero hconvex (hp x)).mp (hmin x)
+  refine ⟨p, ?_, hp, ?_⟩
+  · apply LipschitzWith.of_dist_le_mul
+    intro x y
+    have hx := hv x (p y) (hp y)
+    have hy := hv y (p x) (hp x)
+    have hid : inner ℝ (x - y) (p x - p y) = ‖p x - p y‖ ^ 2 -
+        inner ℝ (x - p x) (p y - p x) - inner ℝ (y - p y) (p x - p y) := by
+      rw [← real_inner_self_eq_norm_sq]
+      simp only [inner_sub_left, inner_sub_right]
+      ring
+    have hc := real_inner_le_norm (x - y) (p x - p y)
+    simp only [NNReal.coe_one, one_mul, dist_eq_norm]
+    nlinarith [norm_nonneg (x - y), norm_nonneg (p x - p y)]
+  · intro x hx
+    have h := hv x x hx
+    rw [real_inner_self_eq_norm_sq] at h
+    have hz : ‖x - p x‖ = 0 := by nlinarith [norm_nonneg (x - p x)]
+    exact (sub_eq_zero.mp (norm_eq_zero.mp hz)).symm
+
+theorem exists_bounded_normalized_ball_chart {n d : ℕ}
+    (r : ℝ) (c : Ambient d) (b : ℝ) (hb : 0 ≤ b)
+    (f : ball (0 : Ambient n) (2 * r) → Ambient d) (M : ℝ≥0) (hf : LipschitzWith M f) :
+    ∃ g : ball (0 : Ambient n) r → Ambient d,
+      LipschitzWith (M * 2) g ∧ Set.range g ⊆ closedBall c b ∧
+      (closedBall c b ∩ Set.range f) ⊆ Set.range g := by
+  obtain ⟨p, hp, hpRange, hpFix⟩ := exists_nonexpansive_retraction_of_complete_convex
+    (closedBall c b) ⟨c, mem_closedBall_self hb⟩ isClosed_closedBall.isComplete (convex_closedBall c b)
+  obtain ⟨h, hhLip, hhRange⟩ := exists_rescaled_ball_chart (2 * r) (0 : Ambient n)
+    2 (by norm_num) f M hf
+  have heq : (2 * r) / ((2 : ℝ≥0) : ℝ) = r := by change (2 * r) / 2 = r; ring
+  rw [heq] at hhLip hhRange
+  let h' : ball (0 : Ambient n) r → Ambient d := (ball (0 : Ambient n) r).domRestrict h
+  have hh'Lip : LipschitzWith (M * 2) h' := hhLip.to_restrict
+  have hh'Range : Set.range h' = Set.range f := by
+    apply Set.Subset.antisymm
+    · rintro y ⟨u, rfl⟩
+      exact hhRange ▸ mem_image_of_mem h u.property
+    · intro y hy
+      obtain ⟨u, hu, he⟩ := hhRange ▸ hy
+      exact ⟨⟨u, hu⟩, he⟩
+  refine ⟨p ∘ h', ?_, ?_, ?_⟩
+  · simpa only [one_mul] using! hp.comp hh'Lip
+  · rintro y ⟨u, rfl⟩
+    exact hpRange (h' u)
+  · intro y hy
+    obtain ⟨u, hu⟩ := hh'Range ▸ hy.2
+    exact ⟨u, by change p (h' u) = y; rw [hu, hpFix y hy.1]⟩
+
+end
+
+end RieszRectifiability
+
+end OAI

lean/OAI/Analysis/RieszRectifiability/Surfaces/CenteredPerturbedBallCoverage.lean

@@ -0,0 +1,113 @@
+import Mathlib
+import OAI.Analysis.RieszRectifiability.Surfaces.PerturbedBallCoverage
+
+namespace OAI
+
+/-!
+# Centered coverage for perturbed charts
+
+Lipschitz perturbations of the identity cover balls centered at any parameter
+with sufficient room in the domain. Applied to tangential projection, this gives
+a disk covered by the portion of the surface inside a controlled ambient ball.
+-/
+
+namespace RieszRectifiability
+
+noncomputable section
+
+open Metric Set
+open scoped NNReal
+
+theorem centered_ball_covered_by_lipschitz_perturbation {X : Type*}
+    [NormedAddCommGroup X] [CompleteSpace X]
+    (c : X) (R : ℝ) (f : closedBall c R → X) (K : ℝ≥0) (hK : K < 1)
+    (herr : LipschitzWith K (fun u => f u - u.val))
+    (a : closedBall c R) (r : ℝ) (hr : 0 ≤ r) (hroom : dist a.val c + r ≤ R) :
+    ∀ z ∈ closedBall (f a) ((1 - (K : ℝ)) * r),
+      ∃ u : closedBall c R, dist u a ≤ r ∧ f u = z := by
+  have hsub : closedBall a.val r ⊆ closedBall c R := by
+    intro x hx
+    have hx' : dist x a.val ≤ r := hx
+    change dist x c ≤ R
+    exact (dist_triangle x a.val c).trans (by linarith)
+  let j : closedBall a.val r → closedBall c R := fun u => ⟨u.val, hsub u.property⟩
+  let g : closedBall a.val r → X := fun u => f (j u) - f a + a.val
+  have hdisp : ∀ u, dist (g u) u.val ≤ (K : ℝ) * r := by
+    intro u
+    have hid : g u - u.val = (f (j u) - (j u).val) - (f a - a.val) := by
+      dsimp [g, j]
+      abel
+    rw [dist_eq_norm, hid]
+    have h := (herr.dist_le_mul (j u) a).trans
+      (mul_le_mul_of_nonneg_left (show dist (j u) a ≤ r from u.property) K.coe_nonneg)
+    simpa only [dist_eq_norm] using! h
+  have hLip : LipschitzWith K (fun u : closedBall a.val r => g u - u.val) := by
+    apply LipschitzWith.of_dist_le_mul
+    intro u v
+    have hid : (g u - u.val) - (g v - v.val) =
+        (f (j u) - (j u).val) - (f (j v) - (j v).val) := by
+      dsimp [g, j]
+      abel
+    rw [dist_eq_norm, hid]
+    simpa only [dist_eq_norm] using! herr.dist_le_mul (j u) (j v)
+  intro z hz
+  have hz' : z - f a + a.val ∈ closedBall a.val (r - (K : ℝ) * r) := by
+    have hd : dist (z - f a + a.val) a.val = dist z (f a) := by
+      rw [dist_eq_norm, dist_eq_norm]
+      congr 1
+      abel
+    rw [mem_closedBall, hd]
+    have hzr : dist z (f a) ≤ (1 - (K : ℝ)) * r := hz
+    nlinarith
+  obtain ⟨u, hu⟩ := closedBall_covered_by_lipschitz_perturbation a.val r ((K : ℝ) * r)
+    hr K hK g hdisp hLip hz'
+  refine ⟨j u, u.property, ?_⟩
+  change f (j u) - f a + a.val = z - f a + a.val at hu
+  exact sub_left_inj.mp (add_right_cancel hu)
+
+theorem centered_projection_disk_in_surface_ball {d : ℕ}
+    (P : Submodule ℝ (Ambient d)) (c : P) (R : ℝ)
+    (H : closedBall c R → Ambient d) (K L : ℝ≥0)
+    (hK : (K : ℝ) ≤ 1 / 2) (hL : (L : ℝ) ≤ 1 / 2)
+    (hError : LipschitzWith K (fun u => P.orthogonalProjectionOnto (H u) - u.val))
+    (hNormal : LipschitzWith L (fun u => (Pᗮ : Submodule ℝ (Ambient d)).starProjection (H u)))
+    (a : closedBall c R) (ρ : ℝ) (hρ : 0 ≤ ρ)
+    (hroom : dist a.val c + 2 * ρ ≤ R)
+    (surface : Set (Ambient d)) (hSurface : ∀ u, dist u a ≤ 2 * ρ → H u ∈ surface) :
+    closedBall (P.orthogonalProjectionOnto (H a)) ρ ⊆
+      P.orthogonalProjectionOnto '' (surface ∩ closedBall (H a) (2 * ρ)) := by
+  have hKone : K < 1 := by
+    have hreal : (K : ℝ) < 1 := by linarith
+    exact_mod_cast hreal
+  intro z hz
+  have hz' : z ∈ closedBall (P.orthogonalProjectionOnto (H a)) ((1 - (K : ℝ)) * (2 * ρ)) := by
+    have hdist : dist z (P.orthogonalProjectionOnto (H a)) ≤ ρ := hz
+    change dist z (P.orthogonalProjectionOnto (H a)) ≤ _
+    nlinarith [mul_le_mul_of_nonneg_right hK hρ]
+  obtain ⟨u, hua, hu⟩ := centered_ball_covered_by_lipschitz_perturbation c R
+    (fun v => P.orthogonalProjectionOnto (H v)) K hKone hError a (2 * ρ)
+    (by positivity) hroom z hz'
+  change P.orthogonalProjectionOnto (H u) = z at hu
+  refine ⟨H u, ⟨hSurface u hua, ?_⟩, hu⟩
+  have hp : ‖P.starProjection (H u - H a)‖ ≤ ρ := by
+    rw [map_sub]
+    change dist (P.orthogonalProjectionOnto (H u)) (P.orthogonalProjectionOnto (H a)) ≤ ρ
+    rw [hu]
+    exact hz
+  have hn := hNormal.dist_le_mul u a
+  rw [dist_eq_norm, ← map_sub] at hn
+  have ht := norm_add_le (P.starProjection (H u - H a))
+    ((Pᗮ : Submodule ℝ (Ambient d)).starProjection (H u - H a))
+  rw [P.starProjection_add_starProjection_orthogonal] at ht
+  change dist (H u) (H a) ≤ 2 * ρ
+  rw [dist_eq_norm]
+  have hnr : (L : ℝ) * dist u a ≤ ρ := by
+    have hb := mul_le_mul_of_nonneg_left hua L.coe_nonneg
+    nlinarith [mul_le_mul_of_nonneg_right hL hρ]
+  linarith
+
+end
+
+end RieszRectifiability
+
+end OAI

lean/OAI/Analysis/RieszRectifiability/Surfaces/ChartNormalCone.lean

@@ -0,0 +1,34 @@
+import Mathlib
+import OAI.Analysis.RieszRectifiability.Foundations.MeasureBounds
+
+namespace OAI
+
+namespace RieszRectifiability
+
+noncomputable section
+
+open MeasureTheory Metric Set
+open scoped NNReal
+
+theorem normal_projection_bound_on_chart_range {X : Type*} [PseudoMetricSpace X] {d : ℕ}
+    (P : Submodule ℝ (Ambient d)) (H : X → Ambient d) (K L : ℝ≥0)
+    (hNormal : LipschitzWith K (fun u => (Pᗮ : Submodule ℝ (Ambient d)).starProjection (H u)))
+    (hSep : AntilipschitzWith L H)
+    (x : Ambient d) (hx : x ∈ Set.range H) (y : Ambient d) (hy : y ∈ Set.range H) :
+    ‖(Pᗮ : Submodule ℝ (Ambient d)).starProjection (x - y)‖ ≤
+      ((K * L : ℝ≥0) : ℝ) * dist x y := by
+  obtain ⟨u, rfl⟩ := hx
+  obtain ⟨v, rfl⟩ := hy
+  have h := hNormal.dist_le_mul u v
+  rw [dist_eq_norm, ← map_sub] at h
+  calc
+    _ ≤ (K : ℝ) * dist u v := h
+    _ ≤ (K : ℝ) * ((L : ℝ) * dist (H u) (H v)) :=
+      mul_le_mul_of_nonneg_left (hSep.le_mul_dist u v) K.coe_nonneg
+    _ = _ := by rw [NNReal.coe_mul]; ring
+
+end
+
+end RieszRectifiability
+
+end OAI

lean/OAI/Analysis/RieszRectifiability/Surfaces/ChildAndPointChartGluing.lean

@@ -0,0 +1,112 @@
+import Mathlib
+import OAI.Analysis.RieszRectifiability.Surfaces.RescaledChildChartGluing
+
+namespace OAI
+
+namespace RieszRectifiability
+
+noncomputable section
+
+open Metric Set
+open scoped NNReal
+
+theorem exists_ball_lipschitz_cover_of_children_and_points {n d : ℕ} {ι κ : Type*}
+    (a : ι → Ambient n) (c : ι → Ambient d) (r : ι → ℝ)
+    (b : κ → Ambient n) (y : κ → Ambient d)
+    (f : ∀ i : ι, ball (0 : Ambient n) (r i) → Ambient d)
+    (M A L : ℝ≥0) (hA : 0 < A)
+    (hsep : ∀ i j : ι, i ≠ j → r i + r j ≤ (A : ℝ) * dist (a i) (a j))
+    (hcenters : ∀ i j : ι, dist (c i) (c j) ≤ (L : ℝ) * dist (a i) (a j))
+    (hsepPoint : ∀ i : ι, ∀ j : κ, r i ≤ (A : ℝ) * dist (a i) (b j))
+    (hcenterPoint : ∀ i : ι, ∀ j : κ, dist (c i) (y j) ≤ (L : ℝ) * dist (a i) (b j))
+    (hpointLip : ∀ i j : κ, dist (y i) (y j) ≤ (L : ℝ) * dist (b i) (b j))
+    (himage : ∀ i : ι, Set.range (f i) ⊆ closedBall (c i) (3 * r i))
+    (hLip : ∀ i : ι, LipschitzWith M (f i))
+    (ρ : ℝ) (hball : ∀ i : ι, ball (a i) (r i / (4 * (A : ℝ))) ⊆ ball (0 : Ambient n) ρ)
+    (hpointBall : ∀ j : κ, b j ∈ ball (0 : Ambient n) ρ) :
+    ∃ F : ball (0 : Ambient n) ρ → Ambient d,
+      LipschitzWith (lipschitzExtensionConstant (Ambient d) *
+        separatedPatchGluingConstant (M * (4 * A)) A L) F ∧
+      ((⋃ i : ι, Set.range (f i)) ∪ Set.range y) ⊆ Set.range F := by
+  classical
+  have hs : 0 < 4 * A := by positivity
+  have hc (i : ι) := exists_rescaled_ball_chart (r i) (a i) (4 * A) hs (f i) M (hLip i)
+  choose g hg hrange using hc
+  have hrange' (i : ι) : g i '' ball (a i) (r i / (4 * (A : ℝ))) = Set.range (f i) := by
+    simpa only [NNReal.coe_mul, NNReal.coe_ofNat] using! hrange i
+  have hg' (i : ι) : LipschitzOnWith (M * (4 * A)) (g i)
+      (ball (a i) (r i / (4 * (A : ℝ)))) := by
+    simpa only [NNReal.coe_mul, NNReal.coe_ofNat] using! hg i
+  let a' : Sum ι κ → Ambient n := Sum.elim a b
+  let c' : Sum ι κ → Ambient d := Sum.elim c y
+  let r' : Sum ι κ → ℝ := Sum.elim r (fun _ => 0)
+  let D' : Sum ι κ → Set (Ambient n) :=
+    Sum.elim (fun i => ball (a i) (r i / (4 * (A : ℝ)))) (fun j => {b j})
+  let g' : Sum ι κ → Ambient n → Ambient d := Sum.elim g (fun j _ => y j)
+  have hsep' (i j : Sum ι κ) (hij : i ≠ j) :
+      r' i + r' j ≤ (A : ℝ) * dist (a' i) (a' j) := by
+    cases i with
+    | inl i =>
+      cases j with
+      | inl j => exact hsep i j (fun heq => hij (congrArg Sum.inl heq))
+      | inr j => simpa only [r', a', Sum.elim_inl, Sum.elim_inr, add_zero] using! hsepPoint i j
+    | inr i =>
+      cases j with
+      | inl j => simpa only [r', a', Sum.elim_inl, Sum.elim_inr, zero_add, dist_comm] using! hsepPoint j i
+      | inr j =>
+        change 0 + 0 ≤ _
+        rw [zero_add]
+        exact mul_nonneg A.coe_nonneg dist_nonneg
+  have hcenters' (i j : Sum ι κ) : dist (c' i) (c' j) ≤ (L : ℝ) * dist (a' i) (a' j) := by
+    cases i with
+    | inl i =>
+      cases j with
+      | inl j => exact hcenters i j
+      | inr j => exact hcenterPoint i j
+    | inr i =>
+      cases j with
+      | inl j => simpa only [c', a', Sum.elim_inl, Sum.elim_inr, dist_comm] using! hcenterPoint j i
+      | inr j => exact hpointLip i j
+  have hparam' (i : Sum ι κ) (u : Ambient n) (hu : u ∈ D' i) :
+      dist u (a' i) ≤ r' i / (4 * (A : ℝ)) := by
+    cases i with
+    | inl i => exact le_of_lt hu
+    | inr j =>
+      have heq : u = b j := hu
+      simp only [a', r', Sum.elim_inr, heq, dist_self, zero_div, le_refl]
+  have himage' (i : Sum ι κ) (u : Ambient n) (hu : u ∈ D' i) :
+      dist (g' i u) (c' i) ≤ 3 * r' i := by
+    cases i with
+    | inl i => exact himage i (hrange' i ▸ mem_image_of_mem (g i) hu)
+    | inr j => simp only [g', c', r', Sum.elim_inr, dist_self, mul_zero, le_refl]
+  have hLip' (i : Sum ι κ) : LipschitzOnWith (M * (4 * A)) (g' i) (D' i) := by
+    cases i with
+    | inl i => exact hg' i
+    | inr j =>
+      apply LipschitzOnWith.of_dist_le_mul
+      intro u hu v hv
+      change dist (y j) (y j) ≤ _
+      rw [dist_self]
+      positivity
+  have hball' : (⋃ i : Sum ι κ, D' i) ⊆ ball (0 : Ambient n) ρ := by
+    apply iUnion_subset
+    intro i
+    cases i with
+    | inl i => exact hball i
+    | inr j => exact singleton_subset_iff.mpr (hpointBall j)
+  obtain ⟨F, hF, hcover⟩ := exists_ball_lipschitz_cover_of_separated_parameter_patches
+    a' c' r' D' g' (M * (4 * A)) A L hA hsep' hcenters' hparam' himage' hLip' ρ hball'
+  refine ⟨F, hF, ?_⟩
+  intro v hv
+  rcases hv with hchild | hpoint
+  · obtain ⟨i, hi⟩ := mem_iUnion.mp hchild
+    have hi' : v ∈ g i '' ball (a i) (r i / (4 * (A : ℝ))) := hrange' i ▸ hi
+    exact hcover (mem_iUnion.mpr ⟨Sum.inl i, hi'⟩)
+  · obtain ⟨j, rfl⟩ := hpoint
+    exact hcover (mem_iUnion.mpr ⟨Sum.inr j, b j, mem_singleton (b j), rfl⟩)
+
+end
+
+end RieszRectifiability
+
+end OAI

lean/OAI/Analysis/RieszRectifiability/Surfaces/CoherentCellCharts.lean

@@ -0,0 +1,71 @@
+import Mathlib
+import OAI.Analysis.RieszRectifiability.Nets.PointCellChains
+import OAI.Analysis.RieszRectifiability.Projections.ProjectionPieceParameterization
+
+namespace OAI
+
+/-!
+# Lipschitz charts from coherent cell fits
+
+For each pair of points, a descendant at the separation scale supplies a nearby affine
+plane with small angle to a fixed subspace. The resulting lower bound on projected
+distances gives an inverse Lipschitz estimate and a ball parameterization of the piece.
+-/
+
+namespace RieszRectifiability
+
+noncomputable section
+
+open MeasureTheory Metric Set
+open scoped NNReal ENNReal
+
+theorem projection_separates_of_coherent_cell_fits {n d : ℕ}
+    (μ : Measure (Ambient d)) (R : ℝ) (hR : 0 < R) (k : ℕ)
+    (z : (supportLatticeNets μ R hR k).points)
+    (E : Set (Ambient d)) (hE : E ⊆ cleanSupportCell μ R hR k z)
+    (P : Submodule ℝ (Ambient d))
+    (hfit : ∀ i : SupportCellDescendant μ R hR k z,
+      (E ∩ i.cell).Nonempty → ∃ S : AffineSubspace ℝ (Ambient d),
+        IsAffineNPlane n S ∧
+        (∀ w ∈ E ∩ ball i.center (1024 * i.radius), infDist w (S : Set (Ambient d)) ≤ i.radius) ∧
+        ∀ v ∈ S.direction,
+          ‖(Pᗮ : Submodule ℝ (Ambient d)).starProjection v‖ ≤ (1 / 4) * ‖v‖) :
+    ∀ x ∈ E, ∀ y ∈ E, dist x y ≤ 2 * dist (P.starProjection x) (P.starProjection y) := by
+  intro x hx y hy
+  by_cases hxy : x = y
+  · simp only [hxy, dist_self, mul_zero, le_refl]
+  obtain ⟨i, hxi, hupper, _, hxball, hyball⟩ :=
+    exists_pair_scale_support_descendant μ R hR k z x y (hE hx) (hE hy) hxy
+  obtain ⟨S, hS, hnear, hangle⟩ := hfit i ⟨x, hx, hxi⟩
+  let : Nonempty S := hS.1.to_subtype
+  have hxs : infDist x (S : Set (Ambient d)) ≤ (1 / 8) * dist x y := by
+    have h := hnear x ⟨hx, hxball⟩
+    linarith
+  have hys : infDist y (S : Set (Ambient d)) ≤ (1 / 8) * dist x y := by
+    have h := hnear y ⟨hy, hyball⟩
+    linarith
+  exact projection_separates_of_pairwise_plane P S x y (1 / 8) (1 / 4)
+    (by norm_num) (by norm_num) hxs hys hangle
+
+theorem exists_ball_lipschitz_cover_of_coherent_cell_fits {n d : ℕ}
+    (μ : Measure (Ambient d)) (R : ℝ) (hR : 0 < R) (k : ℕ)
+    (z : (supportLatticeNets μ R hR k).points)
+    (E : Set (Ambient d)) (hE : E ⊆ cleanSupportCell μ R hR k z)
+    (a : Ambient d) (r : ℝ) (hball : E ⊆ ball a r)
+    (P : Submodule ℝ (Ambient d)) (hdim : Module.finrank ℝ P = n)
+    (hfit : ∀ i : SupportCellDescendant μ R hR k z,
+      (E ∩ i.cell).Nonempty → ∃ S : AffineSubspace ℝ (Ambient d),
+        IsAffineNPlane n S ∧
+        (∀ w ∈ E ∩ ball i.center (1024 * i.radius), infDist w (S : Set (Ambient d)) ≤ i.radius) ∧
+        ∀ v ∈ S.direction,
+          ‖(Pᗮ : Submodule ℝ (Ambient d)).starProjection v‖ ≤ (1 / 4) * ‖v‖) :
+    ∃ g : (ball (0 : Ambient n) r) → Ambient d,
+      LipschitzWith (lipschitzExtensionConstant (Ambient d) * 2) g ∧ E ⊆ range g := by
+  exact exists_ball_lipschitz_cover_of_projection E a r hball P hdim 2
+    (projection_separates_of_coherent_cell_fits μ R hR k z E hE P hfit)
+
+end
+
+end RieszRectifiability
+
+end OAI

lean/OAI/Analysis/RieszRectifiability/Surfaces/ContinuousChartInnerCoverage.lean

@@ -0,0 +1,67 @@
+import Mathlib
+import OAI.Analysis.RieszRectifiability.Projections.ProjectionTubeLocation
+import OAI.Analysis.RieszRectifiability.Surfaces.ContinuousPerturbedBallCoverage
+
+namespace OAI
+
+/-!
+# Inner projection coverage of continuous charts
+
+A chart whose projected displacement is small covers an inner ball in the plane direction.
+Bounds on the chart height and the base point's distance to the plane keep the covering
+points inside the required ambient ball.
+-/
+
+namespace RieszRectifiability
+
+noncomputable section
+
+open Metric Set
+
+theorem continuous_chart_inner_projection_coverage {d : ℕ}
+    (S : AffineSubspace ℝ (Ambient d)) (hS : (S : Set (Ambient d)).Nonempty)
+    (c : S.direction) (R : ℝ) (H : closedBall c R → Ambient d)
+    (hH : Continuous H) (surface : Set (Ambient d)) (hRange : Set.range H ⊆ surface)
+    (p : Ambient d) (ρ e a b : ℝ) (hρ : 0 ≤ ρ)
+    (hroom : dist (S.direction.orthogonalProjectionOnto p) c + 2 * ρ ≤ R)
+    (hDisp : ∀ u, dist (S.direction.orthogonalProjectionOnto (H u)) u.val ≤ e)
+    (hHeight : ∀ u, infDist (H u) (S : Set (Ambient d)) ≤ a)
+    (hBase : infDist p (S : Set (Ambient d)) ≤ b)
+    (he : e ≤ ρ) (hab : a + b ≤ ρ) :
+    closedBall (S.direction.orthogonalProjectionOnto p) ρ ⊆
+      S.direction.orthogonalProjectionOnto '' (surface ∩ closedBall p (2 * ρ)) := by
+  let P := S.direction
+  have hsub : closedBall (P.orthogonalProjectionOnto p) (2 * ρ) ⊆ closedBall c R := by
+    intro u hu
+    have ht := dist_triangle u (P.orthogonalProjectionOnto p) c
+    have hud : dist u (P.orthogonalProjectionOnto p) ≤ 2 * ρ := hu
+    change dist u c ≤ R
+    linarith
+  let j : closedBall (P.orthogonalProjectionOnto p) (2 * ρ) → closedBall c R :=
+    fun u => ⟨u.val, hsub u.property⟩
+  have hj : Continuous j := continuous_subtype_val.subtype_mk _
+  have hCont : Continuous (fun u => P.orthogonalProjectionOnto (H (j u))) :=
+    P.orthogonalProjectionOnto.continuous.comp (hH.comp hj)
+  intro z hz
+  have hz' : z ∈ closedBall (P.orthogonalProjectionOnto p) (2 * ρ - e) := by
+    have hzd : dist z (P.orthogonalProjectionOnto p) ≤ ρ := hz
+    change dist z (P.orthogonalProjectionOnto p) ≤ _
+    linarith
+  obtain ⟨u, hu⟩ := closedBall_covered_by_continuous_perturbation
+    (P.orthogonalProjectionOnto p) (2 * ρ) e (by positivity)
+    (fun u => P.orthogonalProjectionOnto (H (j u))) hCont (fun u => hDisp (j u)) hz'
+  change P.orthogonalProjectionOnto (H (j u)) = z at hu
+  refine ⟨H (j u), ⟨hRange ⟨j u, rfl⟩, ?_⟩, hu⟩
+  have hprojected : dist (P.starProjection (H (j u))) (P.starProjection p) ≤ ρ := by
+    change dist (P.orthogonalProjectionOnto (H (j u))) (P.orthogonalProjectionOnto p) ≤ ρ
+    rw [hu]
+    exact hz
+  have ht := dist_le_projection_add_plane_distances S hS (H (j u)) p
+  change dist (H (j u)) p ≤ 2 * ρ
+  linarith [hHeight (j u)]
+
+end
+
+end RieszRectifiability
+
+end OAI

lean/OAI/Analysis/RieszRectifiability/Surfaces/ContinuousPerturbedBallCoverage.lean

@@ -0,0 +1,52 @@
+import Mathlib
+import OAI.Analysis.RieszRectifiability.Foundations.MeasureBounds
+import FixedPointTheorems.brouwer
+
+namespace OAI
+
+namespace RieszRectifiability
+
+noncomputable section
+
+open Metric Set
+
+theorem closedBall_covered_by_continuous_perturbation {X : Type*}
+    [NormedAddCommGroup X] [NormedSpace ℝ X] [FiniteDimensional ℝ X]
+    (a : X) (r δ : ℝ) (hr : 0 ≤ r)
+    (f : closedBall a r → X) (hf : Continuous f)
+    (hdisp : ∀ x, dist (f x) x.val ≤ δ) :
+    closedBall a (r - δ) ⊆ Set.range f := by
+  intro z hz
+  have hz' : ‖z - a‖ ≤ r - δ := by
+    simpa only [mem_closedBall, dist_eq_norm] using! hz
+  have hmaps (x : closedBall a r) : z - (f x - x.val) ∈ closedBall a r := by
+    change dist (z - (f x - x.val)) a ≤ r
+    calc
+      _ = ‖(z - a) - (f x - x.val)‖ := by
+        rw [dist_eq_norm]
+        congr 1
+        abel
+      _ ≤ ‖z - a‖ + ‖f x - x.val‖ := norm_sub_le _ _
+      _ ≤ (r - δ) + δ := add_le_add hz'
+        (by simpa only [dist_eq_norm] using! hdisp x)
+      _ = r := by ring
+  let T : C(closedBall a r, closedBall a r) :=
+    ⟨fun x => ⟨z - (f x - x.val), hmaps x⟩,
+      (continuous_const.sub (hf.sub continuous_subtype_val)).subtype_mk _⟩
+  obtain ⟨u, hu⟩ := _root_.brouwer_fixed_point (closedBall a r)
+    (convex_closedBall a r) (isCompact_closedBall a r)
+    ⟨a, mem_closedBall_self hr⟩ T
+  have heq := congrArg (fun x : closedBall a r => x.val) hu
+  change z - (f u - u.val) = u.val at heq
+  refine ⟨u, ?_⟩
+  calc
+    f u = (f u - u.val) + u.val := (sub_add_cancel _ _).symm
+    _ = (f u - u.val) + (z - (f u - u.val)) :=
+      congrArg (fun w => (f u - u.val) + w) heq.symm
+    _ = z := by abel
+
+end
+
+end RieszRectifiability
+
+end OAI

lean/OAI/Analysis/RieszRectifiability/Surfaces/ConvexChartContraction.lean

@@ -0,0 +1,65 @@
+import Mathlib
+import OAI.Analysis.RieszRectifiability.Foundations.MeasureBounds
+
+namespace OAI
+
+namespace RieszRectifiability
+
+noncomputable section
+
+open Metric Set Topology
+
+theorem exists_contraction_in_convex_chart {E V : Type*}
+    [NormedAddCommGroup E] [NormedSpace ℝ E] [MetricSpace V]
+    (C : Set E) (hC : Convex ℝ C) (H : C → V) (hH : IsEmbedding H)
+    (A : Set V) (hA : A ⊆ Set.range H) (p : V) (hp : p ∈ A) :
+    ∃ F : unitInterval × A → V, Continuous F ∧
+      (∀ x, F (0, x) = x.val) ∧ (∀ x, F (1, x) = p) ∧
+      (∀ s, F (s, ⟨p, hp⟩) = p) ∧ (∀ w, F w ∈ Set.range H) := by
+  classical
+  have hpre : ∀ x : A, ∃ u : C, H u = x.val := fun x => hA x.property
+  choose j hj using hpre
+  have hjcont : Continuous j := hH.continuous_iff.mpr (by
+    have hid : H ∘ j = (Subtype.val : A → V) := funext hj
+    rw [hid]
+    exact continuous_subtype_val)
+  let u0 : C := j ⟨p, hp⟩
+  let T : unitInterval × A → C := fun w =>
+    ⟨(1 - (w.1 : ℝ)) • (j w.2 : E) + (w.1 : ℝ) • (u0 : E),
+      hC (j w.2).property u0.property (sub_nonneg.mpr w.1.property.2)
+        w.1.property.1 (by ring)⟩
+  have hs : Continuous (fun w : unitInterval × A => (w.1 : ℝ)) :=
+    continuous_subtype_val.comp continuous_fst
+  have hjv : Continuous (fun w : unitInterval × A => (j w.2 : E)) :=
+    continuous_subtype_val.comp (hjcont.comp continuous_snd)
+  have hT : Continuous T :=
+    (((continuous_const.sub hs).smul hjv).add (hs.smul continuous_const)).subtype_mk _
+  let F := H ∘ T
+  refine ⟨F, hH.continuous.comp hT, ?_, ?_, ?_, ?_⟩
+  · intro x
+    have ht : T (0, x) = j x := by apply Subtype.ext; simp [T]
+    change H (T (0, x)) = x.val
+    rw [ht]
+    exact hj x
+  · intro x
+    have ht : T (1, x) = u0 := by apply Subtype.ext; simp [T]
+    change H (T (1, x)) = p
+    rw [ht]
+    exact hj ⟨p, hp⟩
+  · intro s
+    have ht : T (s, ⟨p, hp⟩) = u0 := by
+      apply Subtype.ext
+      change (1 - (s : ℝ)) • (u0 : E) + (s : ℝ) • (u0 : E) = (u0 : E)
+      rw [← add_smul]
+      simp
+    change H (T (s, ⟨p, hp⟩)) = p
+    rw [ht]
+    exact hj ⟨p, hp⟩
+  · intro w
+    exact ⟨T w, rfl⟩
+
+end
+
+end RieszRectifiability
+
+end OAI

lean/OAI/Analysis/RieszRectifiability/Surfaces/FiniteBallChartUnion.lean

@@ -0,0 +1,83 @@
+import Mathlib
+import OAI.Analysis.RieszRectifiability.Surfaces.RescaledChildChartGluing
+import OAI.Analysis.RieszRectifiability.Surfaces.BoundedNormalizedBallCharts
+import OAI.Analysis.RieszRectifiability.Surfaces.FiniteChartParameterPacking
+
+namespace OAI
+
+/-!
+# Finite unions of ball charts
+
+Separated parameter islands encode finitely many bounded Lipschitz charts in a single
+ball chart. The union constant combines the packing factor, the gluing estimate, and
+the ambient Lipschitz extension constant. Extension followed by a nonexpansive
+retraction also handles charts initially defined on subsets of the parameter ball.
+-/
+
+namespace RieszRectifiability
+
+noncomputable section
+
+open Metric Set
+open scoped NNReal
+
+def finiteBallChartUnionConstant (d N : ℕ) (M : ℝ≥0) : ℝ≥0 :=
+  lipschitzExtensionConstant (Ambient d) *
+    separatedPatchGluingConstant (M * (4 * finiteChartPackingFactor N)) (finiteChartPackingFactor N) 0
+
+theorem exists_ball_lipschitz_cover_of_finite_ball_charts {n d : ℕ} (hn : 0 < n)
+    (N : ℕ) (r : ℝ) (hr : 0 < r) (z : Ambient d)
+    (f : Fin N → ball (0 : Ambient n) r → Ambient d)
+    (M : ℝ≥0) (hLip : ∀ i, LipschitzWith M (f i))
+    (himage : ∀ i, Set.range (f i) ⊆ closedBall z (3 * r)) :
+    ∃ g : ball (0 : Ambient n) r → Ambient d,
+      LipschitzWith (finiteBallChartUnionConstant d N M) g ∧
+      (⋃ i : Fin N, Set.range (f i)) ⊆ Set.range g := by
+  have hdim : 0 < Module.finrank ℝ (Ambient n) := by simpa [Ambient] using! hn
+  let : Nontrivial (Ambient n) := Module.nontrivial_of_finrank_pos hdim
+  obtain ⟨e, he⟩ := exists_norm_eq (Ambient n) (show 0 ≤ (1 : ℝ) by norm_num)
+  have hA : 0 < finiteChartPackingFactor N := by unfold finiteChartPackingFactor; positivity
+  exact exists_ball_lipschitz_cover_of_rescaled_children (finiteChartParameterCenter e r N)
+    (fun _ => z) (fun _ => r) f M (finiteChartPackingFactor N) 0 hA
+    (finite_chart_parameter_centers_separated e he r hr N)
+    (fun _ _ => by simp only [dist_self, NNReal.coe_zero, zero_mul, le_refl])
+    himage hLip r (finite_chart_parameter_island_subset e he r hr N)
+
+theorem exists_ball_lipschitz_cover_of_finite_partial_charts {n d : ℕ} (hn : 0 < n)
+    (N : ℕ) (r : ℝ) (hr : 0 < r) (z : Ambient d)
+    (D : Fin N → Set (Ambient n)) (hD : ∀ i, D i ⊆ ball (0 : Ambient n) r)
+    (f : Fin N → Ambient n → Ambient d) (M : ℝ≥0)
+    (hLip : ∀ i, LipschitzOnWith M (f i) (D i))
+    (himage : ∀ i, f i '' D i ⊆ closedBall z (3 * r)) :
+    ∃ g : ball (0 : Ambient n) r → Ambient d,
+      LipschitzWith (finiteBallChartUnionConstant d N (lipschitzExtensionConstant (Ambient d) * M)) g ∧
+      (⋃ i : Fin N, f i '' D i) ⊆ Set.range g := by
+  classical
+  have hext (i : Fin N) := (hLip i).extend_finite_dimension
+  choose F hF hEq using hext
+  obtain ⟨p, hp, hpRange, hpFix⟩ := exists_nonexpansive_retraction_of_complete_convex
+    (closedBall z (3 * r)) ⟨z, mem_closedBall_self (by positivity)⟩
+    isClosed_closedBall.isComplete (convex_closedBall z (3 * r))
+  let g : Fin N → ball (0 : Ambient n) r → Ambient d :=
+    fun i => p ∘ (ball (0 : Ambient n) r).domRestrict (F i)
+  have hgLip (i : Fin N) : LipschitzWith (lipschitzExtensionConstant (Ambient d) * M) (g i) := by
+    simpa only [one_mul] using! hp.comp ((hF i).restrict (ball (0 : Ambient n) r))
+  have hgRange (i : Fin N) : Set.range (g i) ⊆ closedBall z (3 * r) := by
+    rintro y ⟨u, rfl⟩
+    exact hpRange (F i u.val)
+  obtain ⟨h, hhLip, hhCover⟩ := exists_ball_lipschitz_cover_of_finite_ball_charts hn N r hr z g
+    (lipschitzExtensionConstant (Ambient d) * M) hgLip hgRange
+  refine ⟨h, hhLip, ?_⟩
+  intro y hy
+  obtain ⟨i, u, hu, rfl⟩ := mem_iUnion.mp hy
+  apply hhCover
+  apply mem_iUnion.mpr
+  refine ⟨i, ⟨u, hD i hu⟩, ?_⟩
+  change p (F i u) = f i u
+  rw [← hEq i hu, hpFix (f i u) (himage i (mem_image_of_mem (f i) hu))]
+
+end
+
+end RieszRectifiability
+
+end OAI

lean/OAI/Analysis/RieszRectifiability/Surfaces/FiniteChartParameterPacking.lean

@@ -0,0 +1,84 @@
+import Mathlib
+import OAI.Analysis.RieszRectifiability.Foundations.MeasureBounds
+
+namespace OAI
+
+namespace RieszRectifiability
+
+noncomputable section
+
+open Metric Set
+open scoped NNReal
+
+def finiteChartPackingFactor (N : ℕ) : ℝ≥0 := 4 * ((N : ℝ≥0) + 1)
+
+def finiteChartParameterCenter {n : ℕ} (e : Ambient n) (r : ℝ) (N : ℕ) (i : Fin N) : Ambient n :=
+  (((i.val : ℝ) + 1) * (r / (2 * ((N : ℝ) + 1)))) • e
+
+theorem finite_chart_parameter_center_mem {n : ℕ}
+    (e : Ambient n) (he : ‖e‖ = 1) (r : ℝ) (hr : 0 < r) (N : ℕ) (i : Fin N) :
+    finiteChartParameterCenter e r N i ∈ closedBall (0 : Ambient n) (r / 2) := by
+  have hi : (i.val : ℝ) + 1 ≤ (N : ℝ) := by exact_mod_cast Nat.succ_le_of_lt i.isLt
+  have hN : 0 ≤ (N : ℝ) := Nat.cast_nonneg N
+  rw [mem_closedBall_zero_iff, finiteChartParameterCenter, norm_smul,
+    Real.norm_eq_abs, abs_of_nonneg (by positivity), he, mul_one]
+  have hden : 0 < 2 * ((N : ℝ) + 1) := by positivity
+  rw [← mul_div_assoc, div_le_iff₀ hden]
+  nlinarith
+
+theorem finite_chart_parameter_centers_separated {n : ℕ}
+    (e : Ambient n) (he : ‖e‖ = 1) (r : ℝ) (hr : 0 < r) (N : ℕ)
+    (i j : Fin N) (hij : i ≠ j) :
+    r + r ≤ (finiteChartPackingFactor N : ℝ) *
+      dist (finiteChartParameterCenter e r N i) (finiteChartParameterCenter e r N j) := by
+  let δ := r / (2 * ((N : ℝ) + 1))
+  have hδ : 0 < δ := by dsimp [δ]; positivity
+  have hneq : i.val ≠ j.val := fun h => hij (Fin.ext h)
+  have habs : 1 ≤ |(i.val : ℝ) - (j.val : ℝ)| := by
+    rcases lt_or_gt_of_ne hneq with hlt | hgt
+    · have h : (i.val : ℝ) + 1 ≤ (j.val : ℝ) := by exact_mod_cast Nat.succ_le_of_lt hlt
+      rw [abs_of_nonpos (by linarith)]
+      linarith
+    · have h : (j.val : ℝ) + 1 ≤ (i.val : ℝ) := by exact_mod_cast Nat.succ_le_of_lt hgt
+      rw [abs_of_nonneg (by linarith)]
+      linarith
+  have hdist : δ ≤ dist (finiteChartParameterCenter e r N i) (finiteChartParameterCenter e r N j) := by
+    rw [dist_eq_norm, finiteChartParameterCenter, finiteChartParameterCenter,
+      ← sub_smul, norm_smul, Real.norm_eq_abs, he, mul_one]
+    change δ ≤ |((i.val : ℝ) + 1) * δ - ((j.val : ℝ) + 1) * δ|
+    rw [show ((i.val : ℝ) + 1) * δ - ((j.val : ℝ) + 1) * δ =
+      ((i.val : ℝ) - (j.val : ℝ)) * δ by ring, abs_mul, abs_of_pos hδ]
+    simpa only [one_mul] using! mul_le_mul_of_nonneg_right habs hδ.le
+  have hid : (finiteChartPackingFactor N : ℝ) * δ = r + r := by
+    change (4 * ((N : ℝ) + 1)) * (r / (2 * ((N : ℝ) + 1))) = r + r
+    have hN : (N : ℝ) + 1 ≠ 0 := by positivity
+    field_simp
+    ring
+  rw [← hid]
+  exact mul_le_mul_of_nonneg_left hdist (finiteChartPackingFactor N).coe_nonneg
+
+theorem finite_chart_parameter_island_subset {n : ℕ}
+    (e : Ambient n) (he : ‖e‖ = 1) (r : ℝ) (hr : 0 < r) (N : ℕ) (i : Fin N) :
+    ball (finiteChartParameterCenter e r N i) (r / (4 * (finiteChartPackingFactor N : ℝ))) ⊆
+      ball (0 : Ambient n) r := by
+  intro u hu
+  have hc : dist (finiteChartParameterCenter e r N i) (0 : Ambient n) ≤ r / 2 :=
+    finite_chart_parameter_center_mem e he r hr N i
+  have hA : 4 ≤ (finiteChartPackingFactor N : ℝ) := by
+    change 4 ≤ 4 * ((N : ℝ) + 1)
+    have hN := Nat.cast_nonneg (α := ℝ) N
+    linarith
+  have hden : 0 < 4 * (finiteChartPackingFactor N : ℝ) := by linarith
+  have hrad : r / (4 * (finiteChartPackingFactor N : ℝ)) ≤ r / 4 :=
+    (div_le_iff₀ hden).mpr (by nlinarith)
+  have ht := dist_triangle u (finiteChartParameterCenter e r N i) (0 : Ambient n)
+  have hu' : dist u (finiteChartParameterCenter e r N i) <
+      r / (4 * (finiteChartPackingFactor N : ℝ)) := hu
+  change dist u (0 : Ambient n) < r
+  linarith
+
+end
+
+end RieszRectifiability
+
+end OAI

lean/OAI/Analysis/RieszRectifiability/Surfaces/FiniteChartUnionBounds.lean

@@ -0,0 +1,43 @@
+import Mathlib
+import OAI.Analysis.RieszRectifiability.Surfaces.FiniteBallChartUnion
+
+namespace OAI
+
+namespace RieszRectifiability
+
+noncomputable section
+
+open Metric Set
+open scoped NNReal
+
+theorem finiteBallChartUnionConstant_mono (d : ℕ) {N K : ℕ} (hNK : N ≤ K)
+    {M L : ℝ≥0} (hML : M ≤ L) :
+    finiteBallChartUnionConstant d N M ≤ finiteBallChartUnionConstant d K L := by
+  have hNK' : (N : ℝ≥0) ≤ (K : ℝ≥0) := by exact_mod_cast hNK
+  unfold finiteBallChartUnionConstant separatedPatchGluingConstant finiteChartPackingFactor
+  gcongr
+
+theorem exists_ball_lipschitz_cover_of_bounded_finite_family {n d : ℕ} (hn : 0 < n)
+    {ι : Type*} [Fintype ι] (N : ℕ) (hN : Fintype.card ι ≤ N)
+    (r : ℝ) (hr : 0 < r) (z : Ambient d)
+    (f : ι → ball (0 : Ambient n) r → Ambient d)
+    (M : ℝ≥0) (hLip : ∀ i, LipschitzWith M (f i))
+    (himage : ∀ i, Set.range (f i) ⊆ closedBall z (3 * r)) :
+    ∃ g : ball (0 : Ambient n) r → Ambient d,
+      LipschitzWith (finiteBallChartUnionConstant d N M) g ∧
+      (⋃ i : ι, Set.range (f i)) ⊆ Set.range g := by
+  let e : Fin (Fintype.card ι) ≃ ι := (Fintype.equivFin ι).symm
+  obtain ⟨g, hg, hcover⟩ := exists_ball_lipschitz_cover_of_finite_ball_charts hn
+    (Fintype.card ι) r hr z (fun j => f (e j)) M (fun j => hLip (e j)) (fun j => himage (e j))
+  refine ⟨g, hg.weaken (finiteBallChartUnionConstant_mono d hN le_rfl), ?_⟩
+  intro y hy
+  obtain ⟨i, hi⟩ := mem_iUnion.mp hy
+  apply hcover
+  apply mem_iUnion.mpr
+  exact ⟨e.symm i, by simpa only [e.apply_symm_apply] using! hi⟩
+
+end
+
+end RieszRectifiability
+
+end OAI

lean/OAI/Analysis/RieszRectifiability/Surfaces/FittingPlaneInputChart.lean

@@ -0,0 +1,51 @@
+import Mathlib
+import OAI.Analysis.RieszRectifiability.Surfaces.InitialAffineCharts
+
+namespace OAI
+
+/-!
+# Input charts on fitting planes
+
+A small bilateral plane error bounds the offset of a support center from the fitting
+plane. The located affine chart then gives the input disk, with constant normal component,
+exact projected range, and image contained in the ambient ball of radius `3 * r`.
+-/
+
+namespace RieszRectifiability
+
+noncomputable section
+
+open MeasureTheory Metric Set
+open scoped NNReal
+
+theorem exists_fitting_plane_input_chart {n d : ℕ}
+    (μ : Measure (Ambient d)) (c : Ambient d) (hc : c ∈ μ.support)
+    (r : ℝ) (hr : 0 < r) (ε : ℝ) (hεsmall : ε ≤ 1 / 2048)
+    (S : AffineSubspace ℝ (Ambient d)) (hS : IsAffineNPlane n S)
+    (hfit : bilateralPlaneError μ c (1024 * r) S < ε) :
+    ∃ g : closedBall (S.direction.orthogonalProjectionOnto c) ((5 / 2 : ℝ) * r) → Ambient d,
+      LipschitzWith 2 g ∧
+      LipschitzWith 0 (fun u => (S.directionᗮ : Submodule ℝ (Ambient d)).starProjection (g u)) ∧
+      (∀ u, g u ∈ S ∧ S.direction.orthogonalProjectionOnto (g u) = u.val ∧
+        g u ∈ closedBall c (3 * r)) ∧
+      Set.range g = (S : Set (Ambient d)) ∩ S.direction.orthogonalProjectionOnto ⁻¹'
+        closedBall (S.direction.orthogonalProjectionOnto c) ((5 / 2 : ℝ) * r) := by
+  have hcenter := (bilateralPlaneError_lt_pointwise μ ⟨c, hc⟩ c (1024 * r) ε
+    (by positivity) S hS hfit).1 c (mem_ball_self (by positivity)) hc
+  have hoffset : infDist c (S : Set (Ambient d)) ≤ r / 2 := by
+    have hm := mul_le_mul_of_nonneg_right hεsmall (show 0 ≤ 1024 * r by positivity)
+    linarith
+  obtain ⟨g, hLip, hnLip, hcoords, hrange⟩ :=
+    exists_located_affine_plane_disk_chart S hS.1 c ((5 / 2 : ℝ) * r)
+  refine ⟨g, hLip.weaken (by norm_num), hnLip, ?_, hrange⟩
+  intro u
+  refine ⟨(hcoords u).1, (hcoords u).2.1, ?_⟩
+  have hloc := (hcoords u).2.2
+  change dist (g u) c ≤ 3 * r
+  linarith
+
+end
+
+end RieszRectifiability
+
+end OAI

lean/OAI/Analysis/RieszRectifiability/Surfaces/ImmediateChildChartAssembly.lean

@@ -0,0 +1,79 @@
+import Mathlib
+import OAI.Analysis.RieszRectifiability.Surfaces.FiniteChartUnionBounds
+import OAI.Analysis.RieszRectifiability.Surfaces.ImmediateChildChartRescaling
+
+namespace OAI
+
+namespace RieszRectifiability
+
+noncomputable section
+
+open MeasureTheory Metric Set
+open scoped NNReal ENNReal
+
+def immediateChildAssemblyConstant (d : ℕ) (M : ℝ≥0) : ℝ≥0 :=
+  finiteBallChartUnionConstant d (257 ^ d) (M / 64)
+
+theorem exists_immediate_child_chart_assembly {n d : ℕ} (hn : 0 < n)
+    (μ : Measure (Ambient d)) (R : ℝ) (hR : 0 < R) (k : ℕ)
+    (z : (supportLatticeNets μ R hR k).points)
+    (f : ∀ i : supportImmediateChildren μ R hR k z, ball (0 : Ambient n) i.val.radius → Ambient d)
+    (M : ℝ≥0) (hLip : ∀ i, LipschitzWith M (f i))
+    (himage : ∀ i, Set.range (f i) ⊆ closedBall i.val.center (2 * i.val.radius)) :
+    ∃ g : ball (0 : Ambient n) (latticeRadius R k) → Ambient d,
+      LipschitzWith (immediateChildAssemblyConstant d M) g ∧
+      Set.range g ⊆ closedBall (z : Ambient d) (2 * latticeRadius R k) ∧
+      (∀ i, i.val.cell ∩ Set.range (f i) ⊆ Set.range g) ∧
+      μ (cleanSupportCell μ R hR k z \ Set.range g) ≤
+        ∑ i : supportImmediateChildren μ R hR k z, μ (i.val.cell \ Set.range (f i)) := by
+  classical
+  have hr : 0 < latticeRadius R k := latticeRadius_pos R hR k
+  obtain ⟨F, hF, hFRange⟩ := exists_immediate_child_charts_on_parent_ball μ R hR k z f M hLip
+  have hcount : Fintype.card (supportImmediateChildren μ R hR k z) ≤ 257 ^ d := by
+    simpa using! supportImmediateChildren_card_le μ R hR k z
+  have hFImage (i : supportImmediateChildren μ R hR k z) :
+      Set.range (F i) ⊆ closedBall (z : Ambient d) (3 * latticeRadius R k) := by
+    intro y hy
+    have hnear : dist y i.val.center ≤ 2 * i.val.radius := himage i (hFRange i ▸ hy)
+    have hc := i.val.center_dist_top
+    have ht := dist_triangle y i.val.center (z : Ambient d)
+    rw [supportImmediateChild_radius μ R hR k z i] at hnear
+    change dist y (z : Ambient d) ≤ 3 * latticeRadius R k
+    linarith
+  obtain ⟨g, hgLip, hgCover⟩ := exists_ball_lipschitz_cover_of_bounded_finite_family hn
+    (257 ^ d) hcount (latticeRadius R k) hr (z : Ambient d) F (M / 64) hF hFImage
+  obtain ⟨p, hpLip, hpRange, hpFix⟩ := exists_nonexpansive_retraction_of_complete_convex
+    (closedBall (z : Ambient d) (2 * latticeRadius R k))
+    ⟨(z : Ambient d), mem_closedBall_self (by positivity)⟩ isClosed_closedBall.isComplete
+    (convex_closedBall (z : Ambient d) (2 * latticeRadius R k))
+  have hcover (i : supportImmediateChildren μ R hR k z) (y : Ambient d)
+      (hy : y ∈ i.val.cell) (hyRange : y ∈ Set.range (f i)) : y ∈ Set.range (p ∘ g) := by
+    have htop := i.val.cell_subset_top hy
+    have hball : y ∈ closedBall (z : Ambient d) (2 * latticeRadius R k) :=
+      (supportLatticeCell_bounds μ R hR k z).2 htop.1
+    have hyF : y ∈ Set.range (F i) := hFRange i ▸ hyRange
+    obtain ⟨u, hu⟩ := hgCover (mem_iUnion.mpr ⟨i, hyF⟩)
+    exact ⟨u, by change p (g u) = y; rw [hu, hpFix y hball]⟩
+  have hsub : cleanSupportCell μ R hR k z \ Set.range (p ∘ g) ⊆
+      ⋃ i : supportImmediateChildren μ R hR k z, i.val.cell \ Set.range (f i) := by
+    intro y hy
+    have hpart : y ∈ ⋃ i : supportImmediateChildren μ R hR k z, i.val.cell :=
+      cleanSupportCell_eq_immediate_children μ R hR k z ▸ hy.1
+    obtain ⟨i, hi⟩ := mem_iUnion.mp hpart
+    exact mem_iUnion.mpr ⟨i, hi, fun h => hy.2 (hcover i y hi h)⟩
+  refine ⟨p ∘ g, ?_, ?_, ?_, ?_⟩
+  · simpa only [one_mul] using! hpLip.comp hgLip
+  · rintro y ⟨u, rfl⟩
+    exact hpRange (g u)
+  · intro i y hy
+    exact hcover i y hy.1 hy.2
+  · have h : μ (cleanSupportCell μ R hR k z \ Set.range (p ∘ g)) ≤
+        ∑' i : supportImmediateChildren μ R hR k z, μ (i.val.cell \ Set.range (f i)) :=
+      (measure_mono hsub).trans (measure_iUnion_le _)
+    simpa only [tsum_fintype] using! h
+
+end
+
+end RieszRectifiability
+
+end OAI

lean/OAI/Analysis/RieszRectifiability/Surfaces/ImmediateChildChartRescaling.lean

@@ -0,0 +1,57 @@
+import Mathlib
+import OAI.Analysis.RieszRectifiability.Surfaces.RescaledBallCharts
+import OAI.Analysis.RieszRectifiability.Foundations.ImmediateChildPartition
+
+namespace OAI
+
+/-!
+# Immediate-child charts on a parent ball
+
+Rescaling immediate-child charts to the parent lattice ball preserves their images and divides
+their Lipschitz bounds by the fixed radius ratio of 64. Restricting the rescaled maps to the open
+parent ball gives a common parameter domain for all children.
+-/
+
+namespace RieszRectifiability
+
+noncomputable section
+
+open MeasureTheory Metric Set
+open scoped NNReal
+
+theorem exists_immediate_child_charts_on_parent_ball {n d : ℕ}
+    (μ : Measure (Ambient d)) (R : ℝ) (hR : 0 < R) (k : ℕ)
+    (z : (supportLatticeNets μ R hR k).points)
+    (f : ∀ i : supportImmediateChildren μ R hR k z, ball (0 : Ambient n) i.val.radius → Ambient d)
+    (M : ℝ≥0) (hLip : ∀ i, LipschitzWith M (f i)) :
+    ∃ F : supportImmediateChildren μ R hR k z → ball (0 : Ambient n) (latticeRadius R k) → Ambient d,
+      (∀ i, LipschitzWith (M / 64) (F i)) ∧ ∀ i, Set.range (F i) = Set.range (f i) := by
+  classical
+  have hcharts (i : supportImmediateChildren μ R hR k z) :
+      ∃ g : Ambient n → Ambient d,
+        LipschitzOnWith (M / 64) g (ball (0 : Ambient n) (latticeRadius R k)) ∧
+        g '' ball (0 : Ambient n) (latticeRadius R k) = Set.range (f i) := by
+    have h := exists_rescaled_ball_chart i.val.radius (0 : Ambient n) (1 / 64)
+      (by norm_num) (f i) M (hLip i)
+    have hdom : i.val.radius / ((1 / 64 : ℝ≥0) : ℝ) = latticeRadius R k := by
+      change i.val.radius / (1 / 64 : ℝ) = latticeRadius R k
+      rw [supportImmediateChild_radius μ R hR k z i]
+      ring
+    rw [hdom] at h
+    simpa only [one_div, div_eq_mul_inv, one_mul] using! h
+  choose g hg hRange using hcharts
+  refine ⟨fun i => (ball (0 : Ambient n) (latticeRadius R k)).domRestrict (g i),
+    fun i => (hg i).to_restrict, ?_⟩
+  intro i
+  apply Set.Subset.antisymm
+  · rintro y ⟨u, rfl⟩
+    exact hRange i ▸ mem_image_of_mem (g i) u.property
+  · intro y hy
+    obtain ⟨u, hu, he⟩ := hRange i ▸ hy
+    exact ⟨⟨u, hu⟩, he⟩
+
+end
+
+end RieszRectifiability
+
+end OAI

lean/OAI/Analysis/RieszRectifiability/Surfaces/InitialAffineCharts.lean

@@ -0,0 +1,88 @@
+import Mathlib
+import OAI.Analysis.RieszRectifiability.Restart.ActiveProjectionDiskCoverage
+import OAI.Analysis.RieszRectifiability.Projections.CoveredProjectionCharts
+
+namespace OAI
+
+/-!
+# Initial affine-plane charts
+
+Orthogonal coordinates parametrize each affine-plane disk by a 1-Lipschitz chart with
+constant normal component and exact range. A distance estimate locates the chart near
+an ambient center, with error given by that center's distance to the plane.
+-/
+
+namespace RieszRectifiability
+
+noncomputable section
+
+open Metric Set EuclideanGeometry
+open scoped NNReal
+
+theorem exists_affine_plane_disk_chart {d : ℕ}
+    (S : AffineSubspace ℝ (Ambient d)) (hS : (S : Set (Ambient d)).Nonempty)
+    (a : S.direction) (ρ : ℝ) :
+    ∃ g : closedBall a ρ → Ambient d,
+      LipschitzWith 1 g ∧
+      LipschitzWith 0 (fun u => (S.directionᗮ : Submodule ℝ (Ambient d)).starProjection (g u)) ∧
+      (∀ u, g u ∈ S ∧ S.direction.orthogonalProjectionOnto (g u) = u.val) ∧
+      Set.range g = (S : Set (Ambient d)) ∩ S.direction.orthogonalProjectionOnto ⁻¹' closedBall a ρ := by
+  let : Nonempty S := hS.to_subtype
+  have hcover : closedBall a ρ ⊆ S.direction.orthogonalProjectionOnto '' (S : Set (Ambient d)) := by
+    intro v _
+    refine ⟨nonemptyAffineProjection S hS (v : Ambient d), ?_, ?_⟩
+    · exact orthogonalProjection_mem (v : Ambient d)
+    · rw [nonemptyAffineProjection_tangential]
+      exact S.direction.orthogonalProjectionOnto_mem_subspace_eq_self v
+  have hcone : ∀ x ∈ (S : Set (Ambient d)), ∀ y ∈ (S : Set (Ambient d)),
+      ‖(S.directionᗮ : Submodule ℝ (Ambient d)).starProjection (x - y)‖ ≤
+        ((0 : ℝ≥0) : ℝ) * dist (S.direction.starProjection x) (S.direction.starProjection y) := by
+    intro x hx y hy
+    have hv : x - y ∈ S.direction := AffineSubspace.vsub_mem_direction hx hy
+    rw [S.direction.starProjection_orthogonal_val,
+      S.direction.starProjection_eq_self_iff.mpr hv, sub_self, norm_zero, NNReal.coe_zero, zero_mul]
+  simpa only [add_zero] using!
+    exists_chart_on_covered_projection S.direction (S : Set (Ambient d)) 0 (closedBall a ρ) hcover hcone
+
+theorem affine_plane_dist_le_projection_add_offset {d : ℕ}
+    (S : AffineSubspace ℝ (Ambient d)) (hS : (S : Set (Ambient d)).Nonempty)
+    (x c : Ambient d) (hx : x ∈ S) :
+    dist x c ≤ dist (S.direction.starProjection x) (S.direction.starProjection c) +
+      infDist c (S : Set (Ambient d)) := by
+  let : Nonempty S := hS.to_subtype
+  have hn := normal_projection_bound_by_plane_distances S x c
+  rw [infDist_zero_of_mem hx, zero_add] at hn
+  have ht := norm_add_le (S.direction.starProjection (x - c))
+    ((S.directionᗮ : Submodule ℝ (Ambient d)).starProjection (x - c))
+  rw [S.direction.starProjection_add_starProjection_orthogonal] at ht
+  rw [map_sub, ← dist_eq_norm x c,
+    ← dist_eq_norm (S.direction.starProjection x) (S.direction.starProjection c)] at ht
+  exact ht.trans (add_le_add le_rfl hn)
+
+theorem exists_located_affine_plane_disk_chart {d : ℕ}
+    (S : AffineSubspace ℝ (Ambient d)) (hS : (S : Set (Ambient d)).Nonempty)
+    (c : Ambient d) (ρ : ℝ) :
+    ∃ g : closedBall (S.direction.orthogonalProjectionOnto c) ρ → Ambient d,
+      LipschitzWith 1 g ∧
+      LipschitzWith 0 (fun u => (S.directionᗮ : Submodule ℝ (Ambient d)).starProjection (g u)) ∧
+      (∀ u, g u ∈ S ∧ S.direction.orthogonalProjectionOnto (g u) = u.val ∧
+        dist (g u) c ≤ ρ + infDist c (S : Set (Ambient d))) ∧
+      Set.range g = (S : Set (Ambient d)) ∩ S.direction.orthogonalProjectionOnto ⁻¹'
+        closedBall (S.direction.orthogonalProjectionOnto c) ρ := by
+  obtain ⟨g, hLip, hnLip, hcoords, hrange⟩ :=
+    exists_affine_plane_disk_chart S hS (S.direction.orthogonalProjectionOnto c) ρ
+  refine ⟨g, hLip, hnLip, ?_, hrange⟩
+  intro u
+  refine ⟨(hcoords u).1, (hcoords u).2, ?_⟩
+  have hstar : S.direction.starProjection (g u) = (u.val : Ambient d) :=
+    congrArg (fun v : S.direction => (v : Ambient d)) (hcoords u).2
+  have h := affine_plane_dist_le_projection_add_offset S hS (g u) c (hcoords u).1
+  rw [hstar] at h
+  have hu : dist (u.val : Ambient d) (S.direction.starProjection c) ≤ ρ := u.property
+  exact h.trans (add_le_add hu le_rfl)
+
+end
+
+end RieszRectifiability
+
+end OAI

lean/OAI/Analysis/RieszRectifiability/Surfaces/LipschitzChartLift.lean

@@ -0,0 +1,37 @@
+import Mathlib
+import OAI.Analysis.RieszRectifiability.Foundations.MeasureBounds
+
+namespace OAI
+
+namespace RieszRectifiability
+
+noncomputable section
+
+open Set
+open scoped NNReal
+
+theorem exists_lipschitz_lift_of_antilipschitz {X U V : Type*}
+    [MetricSpace X] [MetricSpace U] [MetricSpace V]
+    (F : U → V) (K : ℝ≥0) (hF : AntilipschitzWith K F)
+    (g : X → V) (L : ℝ≥0) (hg : LipschitzWith L g)
+    (hinto : Set.range g ⊆ Set.range F) :
+    ∃ h : X → U, LipschitzWith (K * L) h ∧ ∀ x, F (h x) = g x := by
+  classical
+  have hpre : ∀ x : X, ∃ u : U, F u = g x := fun x => hinto ⟨x, rfl⟩
+  choose h hh using hpre
+  refine ⟨h, ?_, hh⟩
+  apply LipschitzWith.of_dist_le_mul
+  intro x y
+  have hb := hF.le_mul_dist (h x) (h y)
+  rw [hh x, hh y] at hb
+  calc
+    dist (h x) (h y) ≤ (K : ℝ) * dist (g x) (g y) := hb
+    _ ≤ (K : ℝ) * ((L : ℝ) * dist x y) :=
+      mul_le_mul_of_nonneg_left (hg.dist_le_mul x y) K.coe_nonneg
+    _ = ((K * L : ℝ≥0) : ℝ) * dist x y := by rw [NNReal.coe_mul]; ring
+
+end
+
+end RieszRectifiability
+
+end OAI

lean/OAI/Analysis/RieszRectifiability/Surfaces/MatchedSurfaceBallDepthCharts.lean

@@ -0,0 +1,79 @@
+import Mathlib
+import OAI.Analysis.RieszRectifiability.Surfaces.MatchedSurfaceDepthCharts
+import OAI.Analysis.RieszRectifiability.Surfaces.SurfaceBallChartAssembly
+
+namespace OAI
+
+/-!
+# Finite-depth charts on surface balls
+
+Finite unions of matched-surface cell charts produce maps from Euclidean balls.
+The construction retains the finite-depth mass-deficit estimate and an explicit
+Lipschitz bound determined by the cell-chart bound and the covering multiplicity.
+-/
+
+namespace RieszRectifiability
+
+noncomputable section
+
+open MeasureTheory Metric Set Filter Topology
+open scoped NNReal ENNReal
+
+variable {n d : ℕ}
+    (ν : Measure (Ambient d)) (A : Set (Ambient d)) (hν : ν = nativeSurfaceArea n A)
+    (hsupport : ν.support = A)
+    (C G : ℝ) (hC : 0 < C) (hG : 0 < G) (hg : GlobalUpperGrowth n G ν)
+    (hlower : ∀ x ∈ ν.support, ∀ r : ℝ, AdmissibleRadius ν r →
+      ENNReal.ofReal (r ^ n / C) ≤ ν (ball x r))
+    (σ κ : ℝ) (hσ : 0 < σ) (hκ : 0 < κ) (hκ1 : κ ≤ 1)
+    (hwidth : σ + κ ≤ 1) (hsmall : 2048 * σ * (κ + 1) ≤ κ)
+    (hshadow : projectionStopShadowConstant n C σ κ ≤ nativeCoreAreaFraction n G)
+    (hgeometry : ∀ p ∈ ν.support, ∀ r : ℝ, 0 < r →
+      ∃ P : Submodule ℝ (Ambient d), Module.finrank ℝ P = n ∧
+        (∀ x ∈ ν.support ∩ closedBall p (1024 * r),
+          infDist x (AffineSubspace.mk' p P : Set (Ambient d)) ≤ σ * r) ∧
+        closedBall (P.orthogonalProjectionOnto p) (r / 32) ⊆
+          P.orthogonalProjectionOnto '' (ν.support ∩ closedBall p (r / 16)))
+    (hdiam : ediam ν.support = ⊤)
+
+include hν hsupport hC hG hg hlower hσ hκ hκ1 hwidth hsmall hshadow hgeometry hdiam
+
+theorem exists_matched_surface_ball_depth_chart (hn : 0 < n) (J : ℕ)
+    (r : ℝ) (hr : 0 < r) (a : Ambient d) :
+    ∃ g : ball (0 : Ambient n) r → Ambient d,
+      LipschitzWith (finiteBallChartUnionConstant d (11 ^ d)
+        (projectionRegionDepthConstant d (Real.toNNReal (2 / κ)) J)) g ∧
+      Set.range g ⊆ closedBall a (3 * r) ∧
+      (μH[(n : ℝ)] : Measure (Ambient d)) ((A ∩ closedBall a (3 * r)) \ Set.range g) ≤
+        (ENNReal.ofReal (1 - nativeCoreAreaFraction n G)) ^ J * ENNReal.ofReal (G * (8 * r) ^ n) := by
+  apply exists_surface_ball_chart_of_cell_deficits hn ν A hν hsupport C G hC hG hg hlower
+    r hr a (projectionRegionDepthConstant d (Real.toNNReal (2 / κ)) J)
+    ((ENNReal.ofReal (1 - nativeCoreAreaFraction n G)) ^ J)
+  intro z
+  have hlocal := exists_matched_surface_depth_chart ν A hν hsupport C G hC hG hg hlower
+    σ κ hσ hκ hκ1 hwidth hsmall hshadow hgeometry hdiam J r hr 0 z.val
+  obtain ⟨g₀, hg₀, _, hdef⟩ := hlocal
+  let cast : ball (0 : Ambient n) r → ball (0 : Ambient n) (latticeRadius r 0) :=
+    fun u => ⟨u.val, by simpa only [latticeRadius_zero] using! u.property⟩
+  have hcast : Isometry cast := fun _ _ => rfl
+  have hsurj : Function.Surjective cast := by
+    intro u
+    exact ⟨⟨u.val, by simpa only [latticeRadius_zero] using! u.property⟩, Subtype.ext rfl⟩
+  let g := g₀ ∘ cast
+  have hrange : Set.range g = Set.range g₀ := by
+    apply Set.Subset.antisymm
+    · rintro y ⟨u, rfl⟩
+      exact Set.mem_range_self (cast u)
+    · rintro y ⟨u, rfl⟩
+      obtain ⟨v, hv⟩ := hsurj u
+      exact ⟨v, congrArg g₀ hv⟩
+  refine ⟨g, ?_, ?_⟩
+  · simpa only [mul_one] using! hg₀.comp hcast.lipschitzWith
+  · rw [hrange]
+    exact hdef
+
+end
+
+end RieszRectifiability
+
+end OAI

lean/OAI/Analysis/RieszRectifiability/Surfaces/MatchedSurfaceCellPlanes.lean

@@ -0,0 +1,58 @@
+import Mathlib
+import OAI.Analysis.RieszRectifiability.Projections.ProjectionConditionedRegions
+
+namespace OAI
+
+/-!
+# Matched planes for support-cell descendants
+
+Pointwise geometric fits select an affine plane through every descendant center.
+The root plane retains the projected disk coverage supplied by the same choice.
+-/
+
+namespace RieszRectifiability
+
+noncomputable section
+
+open MeasureTheory Metric Set
+
+theorem exists_matched_surface_cell_planes {n d : ℕ}
+    (ν : Measure (Ambient d)) (σ : ℝ)
+    (hgeometry : ∀ p ∈ ν.support, ∀ r : ℝ, 0 < r →
+      ∃ P : Submodule ℝ (Ambient d), Module.finrank ℝ P = n ∧
+        (∀ x ∈ ν.support ∩ closedBall p (1024 * r),
+          infDist x (AffineSubspace.mk' p P : Set (Ambient d)) ≤ σ * r) ∧
+        closedBall (P.orthogonalProjectionOnto p) (r / 32) ⊆
+          P.orthogonalProjectionOnto '' (ν.support ∩ closedBall p (r / 16)))
+    (R : ℝ) (hR : 0 < R) (k : ℕ) (z : (supportLatticeNets ν R hR k).points) :
+    ∃ S : SupportCellDescendant ν R hR k z → AffineSubspace ℝ (Ambient d),
+      (∀ i, IsAffineNPlane n (S i)) ∧ (∀ i, i.center ∈ S i) ∧
+      (∀ i, ∀ x ∈ ν.support ∩ closedBall i.center (1024 * i.radius),
+        infDist x (S i : Set (Ambient d)) ≤ σ * i.radius) ∧
+      let P := (S (supportCellRoot ν R hR k z)).direction
+      closedBall (P.orthogonalProjectionOnto z) (latticeRadius R k / 32) ⊆
+        P.orthogonalProjectionOnto '' (ν.support ∩ closedBall (z : Ambient d) (latticeRadius R k / 16)) := by
+  classical
+  have hall (i : SupportCellDescendant ν R hR k z) :=
+    hgeometry i.center i.center_mem_support i.radius i.radius_pos
+  choose Ps hdim hfit hcover using hall
+  let S (i : SupportCellDescendant ν R hR k z) := AffineSubspace.mk' i.center (Ps i)
+  have hS : ∀ i, IsAffineNPlane n (S i) := by
+    intro i
+    refine ⟨AffineSubspace.mk'_nonempty i.center (Ps i), ?_⟩
+    rw [AffineSubspace.direction_mk']
+    exact hdim i
+  refine ⟨S, hS, ?_, hfit, ?_⟩
+  · intro i
+    apply AffineSubspace.mem_mk'.mpr
+    simpa only [vsub_self] using! (Ps i).zero_mem
+  · change closedBall ((S (supportCellRoot ν R hR k z)).direction.orthogonalProjectionOnto z) _ ⊆ _
+    dsimp only [S]
+    rw [AffineSubspace.direction_mk']
+    exact hcover (supportCellRoot ν R hR k z)
+
+end
+
+end RieszRectifiability
+
+end OAI

lean/OAI/Analysis/RieszRectifiability/Surfaces/MatchedSurfaceDepthCharts.lean

@@ -0,0 +1,91 @@
+import Mathlib
+import OAI.Analysis.RieszRectifiability.Projections.ProjectionRegionDepthCharts
+import OAI.Analysis.RieszRectifiability.Projections.ContractingProjectionRegions
+
+namespace OAI
+
+/-!
+# Matched surface charts with controlled loss
+
+For surfaces of infinite support diameter, contracting projection regions provide
+finite-depth charts with geometric mass loss. Choosing the depth from a positive
+loss tolerance gives one Lipschitz bound valid at every lattice scale and cell.
+-/
+
+namespace RieszRectifiability
+
+noncomputable section
+
+open MeasureTheory Metric Set Filter Topology
+open scoped NNReal ENNReal
+
+variable {n d : ℕ}
+    (ν : Measure (Ambient d)) (A : Set (Ambient d)) (hν : ν = nativeSurfaceArea n A)
+    (hsupport : ν.support = A)
+    (C G : ℝ) (hC : 0 < C) (hG : 0 < G) (hg : GlobalUpperGrowth n G ν)
+    (hlower : ∀ x ∈ ν.support, ∀ r : ℝ, AdmissibleRadius ν r →
+      ENNReal.ofReal (r ^ n / C) ≤ ν (ball x r))
+    (σ κ : ℝ) (hσ : 0 < σ) (hκ : 0 < κ) (hκ1 : κ ≤ 1)
+    (hwidth : σ + κ ≤ 1) (hsmall : 2048 * σ * (κ + 1) ≤ κ)
+    (hshadow : projectionStopShadowConstant n C σ κ ≤ nativeCoreAreaFraction n G)
+    (hgeometry : ∀ p ∈ ν.support, ∀ r : ℝ, 0 < r →
+      ∃ P : Submodule ℝ (Ambient d), Module.finrank ℝ P = n ∧
+        (∀ x ∈ ν.support ∩ closedBall p (1024 * r),
+          infDist x (AffineSubspace.mk' p P : Set (Ambient d)) ≤ σ * r) ∧
+        closedBall (P.orthogonalProjectionOnto p) (r / 32) ⊆
+          P.orthogonalProjectionOnto '' (ν.support ∩ closedBall p (r / 16)))
+    (hdiam : ediam ν.support = ⊤)
+
+include hν hsupport hC hG hg hlower hσ hκ hκ1 hwidth hsmall hshadow hgeometry hdiam
+
+theorem exists_matched_surface_depth_chart (J : ℕ) :
+    ∀ (R : ℝ) (hR : 0 < R) (k : ℕ) (z : (supportLatticeNets ν R hR k).points),
+      ∃ g : ball (0 : Ambient n) (latticeRadius R k) → Ambient d,
+        LipschitzWith (projectionRegionDepthConstant d (Real.toNNReal (2 / κ)) J) g ∧
+        Set.range g ⊆ closedBall (z : Ambient d) (2 * latticeRadius R k) ∧
+        ν (cleanSupportCell ν R hR k z \ Set.range g) ≤
+          (ENNReal.ofReal (1 - nativeCoreAreaFraction n G)) ^ J * ν (cleanSupportCell ν R hR k z) := by
+  have hL : 1 ≤ Real.toNNReal (2 / κ) := by
+    have h : (1 : ℝ) ≤ (Real.toNNReal (2 / κ) : ℝ) := by
+      rw [Real.coe_toNNReal _ (by positivity)]
+      apply (le_div_iff₀ hκ).mpr
+      linarith
+    exact_mod_cast h
+  apply exists_projection_region_depth_chart ν (Real.toNNReal (2 / κ)) hL (nativeCoreAreaFraction n G) ?_ J
+  intro R hR k z
+  have hcore : AdmissibleRadius ν (latticeRadius R k / 8) := by
+    refine ⟨by have hr := latticeRadius_pos R hR k; positivity, ?_⟩
+    rw [hdiam]
+    exact le_top
+  obtain ⟨Good, _, P, hdim, hsep, _, hstop⟩ := exists_contracting_projection_region
+    ν A hν hsupport C G hC hG hg hlower σ κ hσ hκ hκ1 hwidth hsmall hshadow hgeometry R hR k hcore z
+  refine ⟨Good, P, hdim, ?_, hstop⟩
+  simpa only [Real.coe_toNNReal _ (by positivity : 0 ≤ 2 / κ)] using! hsep
+
+theorem exists_matched_surface_uniform_small_loss_chart (δ : ℝ) (hδ : 0 < δ) :
+    ∃ M : ℝ≥0, ∀ (R : ℝ) (hR : 0 < R) (k : ℕ) (z : (supportLatticeNets ν R hR k).points),
+      ∃ g : ball (0 : Ambient n) (latticeRadius R k) → Ambient d,
+        LipschitzWith M g ∧
+        Set.range g ⊆ closedBall (z : Ambient d) (2 * latticeRadius R k) ∧
+        ν (cleanSupportCell ν R hR k z \ Set.range g) ≤
+          ENNReal.ofReal δ * ν (cleanSupportCell ν R hR k z) := by
+  have hθ := nativeCoreAreaFraction_pos_le_half n G hG
+  have hzero : 0 ≤ 1 - nativeCoreAreaFraction n G := by linarith [hθ.2]
+  have hone : 1 - nativeCoreAreaFraction n G < 1 := by linarith [hθ.1]
+  have hlim := tendsto_pow_atTop_nhds_zero_of_lt_one hzero hone
+  have hevent : ∀ᶠ J : ℕ in atTop, (1 - nativeCoreAreaFraction n G) ^ J < δ :=
+    hlim.eventually (gt_mem_nhds hδ)
+  obtain ⟨J, hJ⟩ := hevent.exists
+  refine ⟨projectionRegionDepthConstant d (Real.toNNReal (2 / κ)) J, ?_⟩
+  intro R hR k z
+  obtain ⟨g, hg, hrange, hdeficit⟩ := exists_matched_surface_depth_chart
+    ν A hν hsupport C G hC hG hg hlower σ κ hσ hκ hκ1 hwidth hsmall hshadow hgeometry hdiam J R hR k z
+  refine ⟨g, hg, hrange, hdeficit.trans (mul_le_mul' ?_ le_rfl)⟩
+  rw [← ENNReal.ofReal_pow hzero]
+  exact ENNReal.ofReal_le_ofReal hJ.le
+
+end
+
+end RieszRectifiability
+
+end OAI

lean/OAI/Analysis/RieszRectifiability/Surfaces/MatchedSurfacePrecision.lean

@@ -0,0 +1,33 @@
+import Mathlib
+import OAI.Analysis.RieszRectifiability.Restart.ActiveRegionSurfaceModel
+
+namespace OAI
+
+namespace RieszRectifiability
+
+noncomputable section
+
+theorem exists_matched_surface_precision (d : ℕ) (δ : ℝ) (hδ : 0 < δ) :
+    ∃ ε : ℝ, 0 < ε ∧ ε ≤ 1 / 72057594037927936 ∧
+      activeProjectionError d ε ≤ 1 / 4096 ∧
+      281474976710656 * (ε + activeProjectionError d ε) ≤ δ := by
+  let C : ℝ := 2048 + 1048576 * (9 : ℝ) ^ d
+  have hC : 0 < C := by dsimp only [C]; positivity
+  let ε : ℝ := min (1 / 72057594037927936) (min (1 / (4096 * C))
+    (δ / (281474976710656 * (1 + C))))
+  have hε : 0 < ε := lt_min (by norm_num) (lt_min (by positivity) (by positivity))
+  have h₁ : ε ≤ 1 / (4096 * C) := (min_le_right _ _).trans (min_le_left _ _)
+  have h₂ : ε ≤ δ / (281474976710656 * (1 + C)) := (min_le_right _ _).trans (min_le_right _ _)
+  refine ⟨ε, hε, min_le_left _ _, ?_, ?_⟩
+  · change C * ε ≤ 1 / 4096
+    have heq : C * (1 / (4096 * C)) = 1 / 4096 := by field_simp
+    exact (mul_le_mul_of_nonneg_left h₁ hC.le).trans_eq heq
+  · change 281474976710656 * (ε + C * ε) ≤ δ
+    have h := (le_div_iff₀ (by positivity : 0 < 281474976710656 * (1 + C))).mp h₂
+    nlinarith
+
+end
+
+end RieszRectifiability
+
+end OAI

lean/OAI/Analysis/RieszRectifiability/Surfaces/NativeCoreAreaFraction.lean

@@ -0,0 +1,82 @@
+import Mathlib
+import OAI.Analysis.RieszRectifiability.Packing.LatticeMassPacking
+import OAI.Analysis.RieszRectifiability.Surfaces.PlaneDiskLowerArea
+import OAI.Analysis.RieszRectifiability.Foundations.NativeHausdorffGrowth
+
+namespace OAI
+
+/-!
+# A uniform fraction for core area
+
+The core-area fraction depends only on the dimension and upper growth
+constant. Its coefficient bound compares lattice-cell mass with the
+Hausdorff measure of a plane disk at the smaller core scale.
+-/
+
+namespace RieszRectifiability
+
+noncomputable section
+
+open MeasureTheory Metric Set
+open scoped ENNReal
+
+def nativeCoreAreaFraction (n : ℕ) (G : ℝ) : ℝ :=
+  min (1 / 2) ((planeUnitHausdorffMeasure n).toReal /
+    (2 * (G * (3 : ℝ) ^ n * (32 : ℝ) ^ n)))
+
+theorem nativeCoreAreaFraction_pos_le_half (n : ℕ) (G : ℝ) (hG : 0 < G) :
+    0 < nativeCoreAreaFraction n G ∧ nativeCoreAreaFraction n G ≤ 1 / 2 := by
+  have hu : 0 < (planeUnitHausdorffMeasure n).toReal :=
+    ENNReal.toReal_pos_iff.mpr ⟨planeUnitHausdorffMeasure_pos n, planeUnitHausdorffMeasure_lt_top n⟩
+  exact ⟨lt_min (by norm_num) (by positivity), min_le_left _ _⟩
+
+theorem nativeCoreAreaFraction_coefficient_bound (n : ℕ) (G : ℝ) (hG : 0 < G) :
+    2 * nativeCoreAreaFraction n G * (G * (3 : ℝ) ^ n) ≤
+      (planeUnitHausdorffMeasure n).toReal / (32 : ℝ) ^ n := by
+  have h := min_le_right (1 / 2 : ℝ)
+    ((planeUnitHausdorffMeasure n).toReal / (2 * (G * (3 : ℝ) ^ n * (32 : ℝ) ^ n)))
+  change nativeCoreAreaFraction n G ≤ _ at h
+  have hb := (le_div_iff₀ (by positivity : 0 < 2 * (G * (3 : ℝ) ^ n * (32 : ℝ) ^ n))).mp h
+  apply (le_div_iff₀ (by positivity : 0 < (32 : ℝ) ^ n)).mpr
+  nlinarith
+
+theorem native_core_disk_area_ge_double_fraction {n d : ℕ}
+    (ν : Measure (Ambient d)) (G : ℝ) (hG : 0 < G) (hg : GlobalUpperGrowth n G ν)
+    (R : ℝ) (hR : 0 < R) (k : ℕ) (z : (supportLatticeNets ν R hR k).points)
+    (a : Ambient n) :
+    ENNReal.ofReal (2 * nativeCoreAreaFraction n G) * ν (cleanSupportCell ν R hR k z) ≤
+      (μH[(n : ℝ)] : Measure (Ambient n)) (closedBall a (latticeRadius R k / 32)) := by
+  have hr := latticeRadius_pos R hR k
+  have hθ := (nativeCoreAreaFraction_pos_le_half n G hG).1
+  have htop : ν (cleanSupportCell ν R hR k z) ≤ ENNReal.ofReal (G * (3 * latticeRadius R k) ^ n) := by
+    have hb := (supportLatticeCell_bounds ν R hR k z).2
+    have hsub : cleanSupportCell ν R hR k z ⊆ ball (z : Ambient d) (3 * latticeRadius R k) :=
+      sdiff_subset.trans (hb.trans (closedBall_subset_ball (by have hr := latticeRadius_pos R hR k; linarith)))
+    exact (measure_mono hsub).trans (hg.2 z _ (by positivity))
+  have hcoeff := nativeCoreAreaFraction_coefficient_bound n G hG
+  have hreal : (2 * nativeCoreAreaFraction n G) * (G * (3 * latticeRadius R k) ^ n) ≤
+      (latticeRadius R k / 32) ^ n * (planeUnitHausdorffMeasure n).toReal := by
+    have h := mul_le_mul_of_nonneg_right hcoeff (pow_nonneg (latticeRadius_pos R hR k).le n)
+    calc
+      _ = (2 * nativeCoreAreaFraction n G * (G * (3 : ℝ) ^ n)) * (latticeRadius R k) ^ n := by
+        rw [mul_pow]; ring
+      _ ≤ ((planeUnitHausdorffMeasure n).toReal / (32 : ℝ) ^ n) * (latticeRadius R k) ^ n := h
+      _ = _ := by rw [div_pow]; ring
+  calc
+    _ ≤ ENNReal.ofReal (2 * nativeCoreAreaFraction n G) *
+        ENNReal.ofReal (G * (3 * latticeRadius R k) ^ n) := mul_le_mul' le_rfl htop
+    _ = ENNReal.ofReal ((2 * nativeCoreAreaFraction n G) * (G * (3 * latticeRadius R k) ^ n)) :=
+      (ENNReal.ofReal_mul (by positivity)).symm
+    _ ≤ ENNReal.ofReal ((latticeRadius R k / 32) ^ n * (planeUnitHausdorffMeasure n).toReal) :=
+      ENNReal.ofReal_le_ofReal hreal
+    _ = _ := by
+      rw [ambient_closedBall_hausdorffMeasure n a _ (by positivity),
+        ENNReal.ofReal_mul (by positivity),
+        ENNReal.ofReal_toReal (planeUnitHausdorffMeasure_lt_top n).ne,
+        ENNReal.ofReal_pow (by positivity)]
+
+end
+
+end RieszRectifiability
+
+end OAI

lean/OAI/Analysis/RieszRectifiability/Surfaces/NativeSurfaceArea.lean

@@ -0,0 +1,96 @@
+import Mathlib
+import OAI.Analysis.RieszRectifiability.Kernel.KernelBasic
+
+namespace OAI
+
+/-!
+# Intrinsic surface-area measures
+
+The native surface-area measure is Hausdorff measure restricted to the surface.
+Upper area growth gives local finiteness and regularity, while lower area bounds
+identify the support when the surface is closed.
+-/
+
+namespace RieszRectifiability
+
+noncomputable section
+
+open MeasureTheory Metric Set Topology
+open scoped ENNReal
+
+def nativeSurfaceArea {d : ℕ} (n : ℕ) (A : Set (Ambient d)) : Measure (Ambient d) :=
+  (μH[(n : ℝ)] : Measure (Ambient d)).restrict A
+
+theorem nativeSurfaceArea_apply {n d : ℕ} (A B : Set (Ambient d))
+    (hB : MeasurableSet B) :
+    nativeSurfaceArea n A B = (μH[(n : ℝ)] : Measure (Ambient d)) (A ∩ B) := by
+  rw [nativeSurfaceArea, Measure.restrict_apply hB, inter_comm]
+
+theorem nativeSurfaceArea_open_ball_lower {n d : ℕ}
+    (A : Set (Ambient d)) (c : ℝ≥0∞)
+    (hlower : ∀ p ∈ A, ∀ r : ℝ, 0 < r →
+      c * (ENNReal.ofReal r) ^ n ≤
+        (μH[(n : ℝ)] : Measure (Ambient d)) (A ∩ closedBall p r))
+    (p : Ambient d) (hp : p ∈ A) (r : ℝ) (hr : 0 < r) :
+    (c * (ENNReal.ofReal (1 / 2 : ℝ)) ^ n) * (ENNReal.ofReal r) ^ n ≤
+      nativeSurfaceArea n A (ball p r) := by
+  rw [nativeSurfaceArea_apply A _ measurableSet_ball]
+  have h := hlower p hp (r / 2) (by positivity)
+  have heq : c * (ENNReal.ofReal (r / 2)) ^ n =
+      (c * (ENNReal.ofReal (1 / 2 : ℝ)) ^ n) * (ENNReal.ofReal r) ^ n := by
+    rw [show r / 2 = (1 / 2) * r by ring,
+      ENNReal.ofReal_mul (by norm_num : (0 : ℝ) ≤ 1 / 2), mul_pow]
+    exact (mul_assoc _ _ _).symm
+  rw [heq] at h
+  exact h.trans (measure_mono (inter_subset_inter_right _
+    (closedBall_subset_ball (by linarith : r / 2 < r))))
+
+theorem nativeSurfaceArea_global_upper_growth {n d : ℕ}
+    (A : Set (Ambient d)) (C : ℝ≥0∞) (hC : C < ⊤)
+    (hupper : ∀ (p : Ambient d) (r : ℝ), 0 < r →
+      (μH[(n : ℝ)] : Measure (Ambient d)) (A ∩ closedBall p r) ≤
+        C * (ENNReal.ofReal r) ^ n) :
+    GlobalUpperGrowth n C.toReal (nativeSurfaceArea n A) := by
+  refine ⟨ENNReal.toReal_nonneg, ?_⟩
+  intro p r hr
+  rw [nativeSurfaceArea_apply A _ measurableSet_ball,
+    ENNReal.ofReal_mul ENNReal.toReal_nonneg, ENNReal.ofReal_toReal hC.ne,
+    ENNReal.ofReal_pow hr.le]
+  exact (measure_mono (inter_subset_inter_right _ ball_subset_closedBall)).trans
+    (hupper p r hr)
+
+theorem nativeSurfaceArea_regular {n d : ℕ}
+    (A : Set (Ambient d)) (C : ℝ≥0∞) (hC : C < ⊤)
+    (hupper : ∀ (p : Ambient d) (r : ℝ), 0 < r →
+      (μH[(n : ℝ)] : Measure (Ambient d)) (A ∩ closedBall p r) ≤
+        C * (ENNReal.ofReal r) ^ n) :
+    (nativeSurfaceArea n A).Regular := by
+  have hg := nativeSurfaceArea_global_upper_growth A C hC hupper
+  let : IsLocallyFiniteMeasure (nativeSurfaceArea n A) :=
+    ⟨fun x => ⟨ball x 1, ball_mem_nhds x (by norm_num),
+      (hg.2 x 1 (by norm_num)).trans_lt ENNReal.ofReal_lt_top⟩⟩
+  infer_instance
+
+theorem nativeSurfaceArea_support {n d : ℕ}
+    (A : Set (Ambient d)) (hA : IsClosed A) (c : ℝ≥0∞) (hc : 0 < c)
+    (hlower : ∀ p ∈ A, ∀ r : ℝ, 0 < r →
+      c * (ENNReal.ofReal r) ^ n ≤
+        (μH[(n : ℝ)] : Measure (Ambient d)) (A ∩ closedBall p r)) :
+    (nativeSurfaceArea n A).support = A := by
+  apply Subset.antisymm
+  · exact (nativeSurfaceArea n A).support_subset_of_isClosed hA
+      (ae_restrict_mem hA.measurableSet)
+  · intro p hp
+    apply ((nativeSurfaceArea n A).mem_support_iff_forall p).mpr
+    intro U hU
+    obtain ⟨r, hr, hsub⟩ := Metric.mem_nhds_iff.mp hU
+    have hpos : 0 < (c * (ENNReal.ofReal (1 / 2 : ℝ)) ^ n) * (ENNReal.ofReal r) ^ n := by
+      positivity
+    exact (hpos.trans_le (nativeSurfaceArea_open_ball_lower A c hlower p hp r hr)).trans_le
+      (measure_mono hsub)
+
+end
+
+end RieszRectifiability
+
+end OAI

lean/OAI/Analysis/RieszRectifiability/Surfaces/NativeSurfaceRegularity.lean

@@ -0,0 +1,115 @@
+import Mathlib
+import OAI.Analysis.RieszRectifiability.Flatness.PlaneBoxGrowth
+import OAI.Analysis.RieszRectifiability.Surfaces.NativeSurfaceArea
+import OAI.Analysis.RieszRectifiability.Foundations.GlobalLowerDiameter
+
+namespace OAI
+
+/-!
+Two-sided Hausdorff measure bounds yield a single AD constant for native surface area.
+Global positive-dimensional lower growth also forces infinite support diameter.
+-/
+
+namespace RieszRectifiability
+
+noncomputable section
+
+open MeasureTheory Metric Set Topology
+open scoped ENNReal
+
+def nativeSurfaceADConstant (n : ℕ) (c C : ℝ≥0∞) : ℝ :=
+  1 + C.toReal + (c * (ENNReal.ofReal (1 / 2 : ℝ)) ^ n).toReal⁻¹
+
+theorem nativeSurfaceArea_uniform_bounds {n d : ℕ}
+    (A : Set (Ambient d)) (c C : ℝ≥0∞) (hc : 0 < c) (hcfin : c < ⊤) (hC : C < ⊤)
+    (hlower : ∀ p ∈ A, ∀ r : ℝ, 0 < r →
+      c * (ENNReal.ofReal r) ^ n ≤
+        (μH[(n : ℝ)] : Measure (Ambient d)) (A ∩ closedBall p r))
+    (hupper : ∀ (p : Ambient d) (r : ℝ), 0 < r →
+      (μH[(n : ℝ)] : Measure (Ambient d)) (A ∩ closedBall p r) ≤
+        C * (ENNReal.ofReal r) ^ n) :
+    1 ≤ nativeSurfaceADConstant n c C ∧
+      GlobalUpperGrowth n (nativeSurfaceADConstant n c C) (nativeSurfaceArea n A) ∧
+      ∀ p ∈ A, ∀ r : ℝ, 0 < r →
+        ENNReal.ofReal (r ^ n / nativeSurfaceADConstant n c C) ≤
+          nativeSurfaceArea n A (ball p r) := by
+  let l : ℝ≥0∞ := c * (ENNReal.ofReal (1 / 2 : ℝ)) ^ n
+  have hlpos : 0 < l := by dsimp only [l]; positivity
+  have hlfin : l < ⊤ := ENNReal.mul_lt_top hcfin (ENNReal.pow_lt_top ENNReal.ofReal_lt_top)
+  have hlreal : 0 < l.toReal := ENNReal.toReal_pos_iff.mpr ⟨hlpos, hlfin⟩
+  have hCnonneg : 0 ≤ C.toReal := ENNReal.toReal_nonneg
+  have hK1 : 1 ≤ nativeSurfaceADConstant n c C := by
+    change 1 ≤ 1 + C.toReal + l.toReal⁻¹
+    have : 0 ≤ l.toReal⁻¹ := (inv_pos.mpr hlreal).le
+    linarith
+  have hKC : C.toReal ≤ nativeSurfaceADConstant n c C := by
+    change C.toReal ≤ 1 + C.toReal + l.toReal⁻¹
+    have : 0 ≤ l.toReal⁻¹ := (inv_pos.mpr hlreal).le
+    linarith
+  have hKinv : l.toReal⁻¹ ≤ nativeSurfaceADConstant n c C := by
+    change l.toReal⁻¹ ≤ 1 + C.toReal + l.toReal⁻¹
+    linarith
+  refine ⟨hK1, (nativeSurfaceArea_global_upper_growth A C hC hupper).mono_constant hKC, ?_⟩
+  intro p hp r hr
+  have hKpos : 0 < nativeSurfaceADConstant n c C := zero_lt_one.trans_le hK1
+  have hprod : 1 ≤ l.toReal * nativeSurfaceADConstant n c C := by
+    have h := mul_le_mul_of_nonneg_left hKinv hlreal.le
+    simpa only [mul_inv_cancel₀ hlreal.ne'] using! h
+  have hdiv : r ^ n / nativeSurfaceADConstant n c C ≤ l.toReal * r ^ n := by
+    apply (div_le_iff₀ hKpos).mpr
+    calc
+      r ^ n = 1 * r ^ n := (one_mul _).symm
+      _ ≤ (l.toReal * nativeSurfaceADConstant n c C) * r ^ n :=
+        mul_le_mul_of_nonneg_right hprod (pow_nonneg hr.le n)
+      _ = (l.toReal * r ^ n) * nativeSurfaceADConstant n c C := by ring
+  have h := nativeSurfaceArea_open_ball_lower A c hlower p hp r hr
+  have heq : ENNReal.ofReal (l.toReal * r ^ n) = l * (ENNReal.ofReal r) ^ n := by
+    rw [ENNReal.ofReal_mul hlreal.le, ENNReal.ofReal_toReal hlfin.ne, ENNReal.ofReal_pow hr.le]
+  exact (ENNReal.ofReal_le_ofReal hdiv).trans (heq.symm ▸ h)
+
+theorem nativeSurfaceArea_adRegular {n d : ℕ}
+    (A : Set (Ambient d)) (hA : IsClosed A)
+    (c C : ℝ≥0∞) (hc : 0 < c) (hcfin : c < ⊤) (hC : C < ⊤)
+    (hlower : ∀ p ∈ A, ∀ r : ℝ, 0 < r →
+      c * (ENNReal.ofReal r) ^ n ≤
+        (μH[(n : ℝ)] : Measure (Ambient d)) (A ∩ closedBall p r))
+    (hupper : ∀ (p : Ambient d) (r : ℝ), 0 < r →
+      (μH[(n : ℝ)] : Measure (Ambient d)) (A ∩ closedBall p r) ≤
+        C * (ENNReal.ofReal r) ^ n) :
+    ADRegular n (nativeSurfaceArea n A) := by
+  obtain ⟨hK, hg, hl⟩ := nativeSurfaceArea_uniform_bounds A c C hc hcfin hC hlower hupper
+  refine ⟨nativeSurfaceADConstant n c C, hK, ?_⟩
+  intro p hp r hr
+  rw [nativeSurfaceArea_support A hA c hc hlower] at hp
+  exact ⟨hl p hp r hr.1, hg.2 p r hr.1⟩
+
+theorem nativeSurfaceArea_support_ediam_top {n d : ℕ} (hn : 0 < n)
+    (A : Set (Ambient d)) (hA : IsClosed A) (hne : A.Nonempty)
+    (c C : ℝ≥0∞) (hc : 0 < c) (hcfin : c < ⊤) (hC : C < ⊤)
+    (hlower : ∀ p ∈ A, ∀ r : ℝ, 0 < r →
+      c * (ENNReal.ofReal r) ^ n ≤
+        (μH[(n : ℝ)] : Measure (Ambient d)) (A ∩ closedBall p r))
+    (hupper : ∀ (p : Ambient d) (r : ℝ), 0 < r →
+      (μH[(n : ℝ)] : Measure (Ambient d)) (A ∩ closedBall p r) ≤
+        C * (ENNReal.ofReal r) ^ n) :
+    ediam (nativeSurfaceArea n A).support = ⊤ := by
+  let : (nativeSurfaceArea n A).Regular := nativeSurfaceArea_regular A C hC hupper
+  have hs := nativeSurfaceArea_support A hA c hc hlower
+  obtain ⟨hK, _, hl⟩ := nativeSurfaceArea_uniform_bounds A c C hc hcfin hC hlower hupper
+  have hKpos : 0 < nativeSurfaceADConstant n c C := zero_lt_one.trans_le hK
+  have hnz : nativeSurfaceArea n A ≠ 0 := by
+    intro hz
+    obtain ⟨p, hp⟩ := hne
+    have h := hl p hp 1 (by norm_num)
+    rw [hz] at h
+    have hpos : 0 < ENNReal.ofReal ((1 : ℝ) ^ n / nativeSurfaceADConstant n c C) :=
+      ENNReal.ofReal_pos.mpr (by positivity)
+    exact (not_le_of_gt hpos) (by simpa using! h)
+  exact global_lower_growth_support_ediam_top n hn (nativeSurfaceArea n A) hnz
+    (nativeSurfaceADConstant n c C) hKpos (fun p hp r hr => hl p (hs ▸ hp) r hr)
+
+end
+
+end RieszRectifiability
+
+end OAI

lean/OAI/Analysis/RieszRectifiability/Surfaces/OriginalADMatchedSurfaceModels.lean

@@ -0,0 +1,75 @@
+import Mathlib
+import OAI.Analysis.RieszRectifiability.Surfaces.OriginalADUniformPrecisionAreaModels
+import OAI.Analysis.RieszRectifiability.Surfaces.ActualNativeSurfaceGeometry
+import OAI.Analysis.RieszRectifiability.Surfaces.MatchedSurfacePrecision
+
+namespace OAI
+
+/-!
+# Matched surface models for an AD-regular measure
+
+Uniform-precision area models combine with the native surface geometry to give
+matched projection coverage at every scale. The top-mass and AD constants are
+chosen before the precision and support cell, while the resulting surface keeps
+its exact support, infinite support diameter, and two-sided growth bounds.
+-/
+
+namespace RieszRectifiability
+
+noncomputable section
+
+open MeasureTheory Metric Set Topology
+open scoped ENNReal
+
+theorem exists_original_AD_matched_surface_models {n d : ℕ} (hn : 0 < n) (hnd : n ≤ d)
+    (μ : Measure (Ambient d)) [μ.Regular] (hAD : ADRegular n μ) :
+    ∃ Ktop : ℝ≥0∞, Ktop < ⊤ ∧ ∃ K : ℝ, 1 ≤ K ∧
+      ∀ ε : ℝ, 0 < ε → ε ≤ 1 / 72057594037927936 → activeProjectionError d ε ≤ 1 / 4096 →
+      ∀ (R : ℝ) (hR : 0 < R) (k : ℕ) (z : (supportLatticeNets μ R hR k).points),
+        AdmissibleRadius μ (latticeRadius R k / 8) →
+        let Good := fun q : SupportCellDescendant μ R hR k z =>
+          bilateralBeta n μ q.center (1024 * q.radius) < ε
+        ∃ (S : SupportCellDescendant μ R hR k z → AffineSubspace ℝ (Ambient d))
+          (hS : ∀ i, IsAffineNPlane n (S i)),
+          (∀ i, activeRegionCell Good i → bilateralPlaneError μ i.center (1024 * i.radius) (S i) < ε) ∧
+          ∃ f : S (supportCellRoot μ R hR k z) → Ambient d,
+            IsActiveRegionLimitModel μ R hR k z Good S hS ε f ∧
+            (μH[(n : ℝ)] : Measure (Ambient d))
+              (Set.range f ∩ closedBall (z : Ambient d) (2 * latticeRadius R k)) ≤
+                Ktop * μ (cleanSupportCell μ R hR k z) ∧
+            let ν := nativeSurfaceArea n (Set.range f)
+            ν.Regular ∧ ν.support = Set.range f ∧ ADRegular n ν ∧ ediam ν.support = ⊤ ∧
+              GlobalUpperGrowth n K ν ∧
+              (∀ p ∈ ν.support, ∀ r : ℝ, 0 < r →
+                ENNReal.ofReal (r ^ n / K) ≤ ν (ball p r)) ∧
+              ∀ p ∈ ν.support, ∀ r : ℝ, 0 < r →
+                ∃ P : Submodule ℝ (Ambient d), Module.finrank ℝ P = n ∧
+                  (∀ x ∈ ν.support ∩ closedBall p (1024 * r),
+                    infDist x (AffineSubspace.mk' p P : Set (Ambient d)) ≤
+                      (281474976710656 * (ε + activeProjectionError d ε)) * r) ∧
+                  closedBall (P.orthogonalProjectionOnto p) (r / 32) ⊆
+                    P.orthogonalProjectionOnto '' (ν.support ∩ closedBall p (r / 16)) := by
+  obtain ⟨Ktop, hKtop, C, hC, c, hc, hcfin, hmodels⟩ :=
+    exists_actual_AD_uniform_precision_area_models hn hnd μ hAD
+  have hK1 : 1 ≤ nativeSurfaceADConstant n c C := by
+    have hCnonneg : 0 ≤ C.toReal := ENNReal.toReal_nonneg
+    have hinv : 0 ≤ (c * (ENNReal.ofReal (1 / 2 : ℝ)) ^ n).toReal⁻¹ :=
+      inv_nonneg.mpr ENNReal.toReal_nonneg
+    dsimp only [nativeSurfaceADConstant]
+    linarith
+  refine ⟨Ktop, hKtop, nativeSurfaceADConstant n c C, hK1, ?_⟩
+  intro ε hε hεfine hsmall R hR k z hcore
+  let Good := fun q : SupportCellDescendant μ R hR k z =>
+    bilateralBeta n μ q.center (1024 * q.radius) < ε
+  obtain ⟨S, hS, hfit, f, hmodel, hembed, htop, hupper, hlower⟩ :=
+    hmodels ε hε (by linarith) (by linarith) R hR k z hcore
+  obtain ⟨hreg, hs, hADν, hdiam, _, hg, hl, hplanes⟩ :=
+    active_region_native_surface_geometry hn μ R hR k z Good S hS ε hε hεfine hsmall hfit
+      f hmodel hembed c C hc hcfin hC hlower hupper
+  exact ⟨S, hS, hfit, f, hmodel, htop, hreg, hs, hADν, hdiam, hg, hl, hplanes⟩
+
+end
+
+end RieszRectifiability
+
+end OAI

lean/OAI/Analysis/RieszRectifiability/Surfaces/OriginalADUniformPrecisionAreaModels.lean

@@ -0,0 +1,79 @@
+import Mathlib
+import OAI.Analysis.RieszRectifiability.Restart.OriginalADActiveRegionAllRadiusAreaModel
+
+namespace OAI
+
+namespace RieszRectifiability
+
+noncomputable section
+
+open MeasureTheory Metric Set Topology
+open scoped ENNReal
+
+theorem exists_actual_AD_uniform_precision_area_models {n d : ℕ} (hn : 0 < n) (hnd : n ≤ d)
+    (μ : Measure (Ambient d)) [μ.Regular] (hAD : ADRegular n μ) :
+    ∃ Ktop : ℝ≥0∞, Ktop < ⊤ ∧ ∃ Kupper : ℝ≥0∞, Kupper < ⊤ ∧
+      ∃ Klower : ℝ≥0∞, 0 < Klower ∧ Klower < ⊤ ∧
+      ∀ ε : ℝ, 0 < ε → ε ≤ 1 / 281474976710656 → activeProjectionError d ε ≤ 1 / 128 →
+      ∀ (R : ℝ) (hR : 0 < R) (k : ℕ) (z : (supportLatticeNets μ R hR k).points),
+        AdmissibleRadius μ (latticeRadius R k / 8) →
+        let Good := fun q : SupportCellDescendant μ R hR k z =>
+          bilateralBeta n μ q.center (1024 * q.radius) < ε
+        ∃ (S : SupportCellDescendant μ R hR k z → AffineSubspace ℝ (Ambient d))
+          (hS : ∀ i, IsAffineNPlane n (S i)),
+          (∀ i, activeRegionCell Good i → bilateralPlaneError μ i.center (1024 * i.radius) (S i) < ε) ∧
+          ∃ f : S (supportCellRoot μ R hR k z) → Ambient d,
+            IsActiveRegionLimitModel μ R hR k z Good S hS ε f ∧ IsClosedEmbedding f ∧
+            (μH[(n : ℝ)] : Measure (Ambient d))
+              (Set.range f ∩ closedBall (z : Ambient d) (2 * latticeRadius R k)) ≤
+                Ktop * μ (cleanSupportCell μ R hR k z) ∧
+            (∀ (p : Ambient d) (r : ℝ), 0 < r →
+              (μH[(n : ℝ)] : Measure (Ambient d)) (Set.range f ∩ closedBall p r) ≤
+                Kupper * (ENNReal.ofReal r) ^ n) ∧
+            ∀ p ∈ Set.range f, ∀ (r : ℝ), 0 < r →
+              Klower * (ENNReal.ofReal r) ^ n ≤
+                (μH[(n : ℝ)] : Measure (Ambient d)) (Set.range f ∩ closedBall p r) := by
+  by_cases hsupport : μ.support.Nontrivial
+  · obtain ⟨G, hg⟩ := globalGrowth_of_ADRegular_nontrivial n μ hAD hsupport
+    have hG : 0 < G + 1 := by linarith [hg.1]
+    have hg' : GlobalUpperGrowth n (G + 1) μ := hg.mono_constant (by linarith)
+    obtain ⟨C, hC, hballs⟩ := hAD
+    have hCpos : 0 < C := zero_lt_one.trans_le hC
+    refine ⟨activeRegionUniformAreaConstant n d C (G + 1),
+      activeRegionUniformAreaConstant_lt_top n d C (G + 1),
+      activeRegionLocalUpperAreaConstant n d C (G + 1),
+      activeRegionLocalUpperAreaConstant_lt_top n d C (G + 1),
+      activeRegionAllRadiusLowerAreaConstant n C (G + 1),
+      activeRegionAllRadiusLowerAreaConstant_pos n C (G + 1),
+      activeRegionAllRadiusLowerAreaConstant_lt_top n C (G + 1), ?_⟩
+    intro ε hε hεfine hsmall R hR k z hcore
+    let Good := fun q : SupportCellDescendant μ R hR k z =>
+      bilateralBeta n μ q.center (1024 * q.radius) < ε
+    have hεtiny : ε ≤ 1 / 268435456 := by linarith
+    obtain ⟨S, hS, hfit, _⟩ := exists_active_level_projection_maps μ R hR k z hnd ε hε
+    obtain ⟨f, hmodel⟩ := exists_active_region_limit_model μ R hR k z Good S hS ε hε hεtiny hsmall hfit
+    refine ⟨S, hS, hfit, f, hmodel,
+      active_region_limit_isClosedEmbedding μ R hR k z Good S hS ε hε hεtiny hsmall hfit f hmodel,
+      active_region_limit_area_le_original_top μ C (G + 1) hCpos hG hg'
+        (fun x hx r hr => (hballs x hx r hr).1) R hR k hcore z Good S hS ε hε hεfine hsmall hfit f hmodel,
+      ?_, ?_⟩
+    · intro p r hr
+      exact active_region_limit_local_ball_area_le μ C (G + 1) hCpos hG hg'
+        (fun x hx s hs => (hballs x hx s hs).1) R hR k hcore z Good S hS
+        ε hε hεfine hsmall hfit f hmodel p r hr
+    · intro p hp r hr
+      exact active_region_limit_all_radius_ball_area_ge hn μ C (G + 1) hCpos hG hg'
+        (fun x hx s hs => (hballs x hx s hs).1) R hR k hcore z Good S hS
+        ε hε hεfine hsmall hfit f hmodel p hp r hr
+  · refine ⟨0, by norm_num, 0, by norm_num, 1, by norm_num, by norm_num, ?_⟩
+    intro ε hε hεfine hsmall R hR k z hcore
+    have hdiam : ediam μ.support = 0 := ediam_eq_zero_iff.mpr (Set.not_nontrivial_iff.mp hsupport)
+    have hzero : ENNReal.ofReal (latticeRadius R k / 8) = 0 :=
+      le_antisymm (hdiam ▸ hcore.2) (zero_le)
+    exact ((ENNReal.ofReal_pos.mpr hcore.1).ne' hzero).elim
+
+end
+
+end RieszRectifiability
+
+end OAI

lean/OAI/Analysis/RieszRectifiability/Surfaces/OriginalADUniformSurfaceBallCharts.lean

@@ -0,0 +1,95 @@
+import Mathlib
+import OAI.Analysis.RieszRectifiability.Surfaces.OriginalADMatchedSurfaceModels
+import OAI.Analysis.RieszRectifiability.Surfaces.SurfaceBallTransferFoundations
+
+namespace OAI
+
+/-!
+# Uniform ball charts for active-region surfaces
+
+Matched surface models give a precision independent of the support cell. For
+each positive loss tolerance, a finite-depth ball chart covers the model up to
+weighted Hausdorff area bounded by that tolerance times the original cell mass.
+Its Lipschitz constant is chosen before the cell scale and center.
+-/
+
+namespace RieszRectifiability
+
+noncomputable section
+
+open MeasureTheory Metric Set
+open scoped NNReal ENNReal
+
+theorem exists_original_AD_uniform_surface_ball_charts {n d : ℕ} (hn : 0 < n) (hnd : n ≤ d)
+    (μ : Measure (Ambient d)) [μ.Regular] (hAD : ADRegular n μ)
+    (G : ℝ) (hG : 0 < G) (hg : GlobalUpperGrowth n G μ) :
+    ∃ ε : ℝ, 0 < ε ∧ ε ≤ 1 / 281474976710656 ∧ activeProjectionError d ε ≤ 1 / 128 ∧
+      ∀ δ : ℝ, 0 < δ → ∃ M : ℝ≥0,
+      ∀ (R : ℝ) (hR : 0 < R) (k : ℕ) (z : (supportLatticeNets μ R hR k).points),
+        AdmissibleRadius μ (latticeRadius R k / 8) →
+        let Good := fun q : SupportCellDescendant μ R hR k z =>
+          bilateralBeta n μ q.center (1024 * q.radius) < ε
+        ∃ (S : SupportCellDescendant μ R hR k z → AffineSubspace ℝ (Ambient d))
+          (hS : ∀ i, IsAffineNPlane n (S i)),
+          (∀ i, activeRegionCell Good i → bilateralPlaneError μ i.center (1024 * i.radius) (S i) < ε) ∧
+          ∃ f : S (supportCellRoot μ R hR k z) → Ambient d,
+            IsActiveRegionLimitModel μ R hR k z Good S hS ε f ∧
+            ∃ g : ball (0 : Ambient n) (latticeRadius R k) → Ambient d,
+              LipschitzWith M g ∧ Set.range g ⊆ closedBall (z : Ambient d) (3 * latticeRadius R k) ∧
+              (ENNReal.ofReal G + activeRegionStopMassAreaConstant n G) *
+                (μH[(n : ℝ)] : Measure (Ambient d))
+                  ((Set.range f ∩ closedBall (z : Ambient d) (3 * latticeRadius R k)) \ Set.range g) ≤
+                    ENNReal.ofReal δ * μ (cleanSupportCell μ R hR k z) := by
+  obtain ⟨Ktop, hKtop, K, hK, hmodels⟩ := exists_original_AD_matched_surface_models hn hnd μ hAD
+  have hKpos : 0 < K := zero_lt_one.trans_le hK
+  obtain ⟨κ, hκ, hκquarter, σ, hσ, hwidth, hpair, hshadow⟩ := exists_projection_region_thresholds n K K hKpos hKpos
+  obtain ⟨ε, hε, hεfine, hsmall, hprecision⟩ := exists_matched_surface_precision d σ hσ
+  refine ⟨ε, hε, by linarith, by linarith, ?_⟩
+  intro δ hδ
+  obtain ⟨C, hC, hballs⟩ := hAD
+  have hCpos : 0 < C := zero_lt_one.trans_le hC
+  let W := ENNReal.ofReal G + activeRegionStopMassAreaConstant n G
+  have hW : W < ⊤ := by
+    have hstop := activeRegionStopMassAreaConstant_lt_top n G
+    exact ENNReal.add_lt_top.mpr ⟨ENNReal.ofReal_lt_top, hstop⟩
+  have hθ := nativeCoreAreaFraction_pos_le_half n K hKpos
+  have hzero : 0 ≤ 1 - nativeCoreAreaFraction n K := by linarith [hθ.2]
+  have hone : 1 - nativeCoreAreaFraction n K < 1 := by linarith [hθ.1]
+  obtain ⟨J, hJ⟩ := exists_depth_for_weighted_geometric_loss
+    (1 - nativeCoreAreaFraction n K) hzero hone W hW (K * C * (64 : ℝ) ^ n) (by positivity) δ hδ
+  let M := finiteBallChartUnionConstant d (11 ^ d) (projectionRegionDepthConstant d (Real.toNNReal (2 / κ)) J)
+  refine ⟨M, ?_⟩
+  intro R hR k z hcore
+  let Good := fun q : SupportCellDescendant μ R hR k z =>
+    bilateralBeta n μ q.center (1024 * q.radius) < ε
+  obtain ⟨S, hS, hfit, f, hmodel, _, hreg, hs, _, hdiam, hgν, hlν, hplanes⟩ :=
+    hmodels ε hε hεfine hsmall R hR k z hcore
+  let ν := nativeSurfaceArea n (Set.range f)
+  have hgeometry : ∀ p ∈ ν.support, ∀ r : ℝ, 0 < r →
+      ∃ P : Submodule ℝ (Ambient d), Module.finrank ℝ P = n ∧
+        (∀ x ∈ ν.support ∩ closedBall p (1024 * r),
+          infDist x (AffineSubspace.mk' p P : Set (Ambient d)) ≤ σ * r) ∧
+        closedBall (P.orthogonalProjectionOnto p) (r / 32) ⊆
+          P.orthogonalProjectionOnto '' (ν.support ∩ closedBall p (r / 16)) := by
+    intro p hp r hr
+    obtain ⟨P, hP, hheight, hcover⟩ := hplanes p hp r hr
+    exact ⟨P, hP, fun x hx => (hheight x hx).trans (mul_le_mul_of_nonneg_right hprecision hr.le), hcover⟩
+  obtain ⟨g, hglip, hgrange, harea⟩ := exists_matched_surface_ball_depth_chart ν (Set.range f) rfl hs
+    K K hKpos hKpos hgν (fun p hp r hr => hlν p hp r hr.1) σ κ hσ hκ (by linarith) hwidth hpair hshadow
+    hgeometry hdiam hn J (latticeRadius R k) (latticeRadius_pos R hR k) z
+  have hmass := radius_eight_growth_le_original_cell_mass μ C G hCpos hG hg
+    (fun p hp r hr => (hballs p hp r hr).1) R hR k hcore z K hKpos.le
+  refine ⟨S, hS, hfit, f, hmodel, g, hglip, hgrange, ?_⟩
+  calc
+    _ ≤ W * ((ENNReal.ofReal (1 - nativeCoreAreaFraction n K)) ^ J *
+        (ENNReal.ofReal (K * C * (64 : ℝ) ^ n) * μ (cleanSupportCell �� R hR k z))) :=
+      mul_le_mul' le_rfl (harea.trans (mul_le_mul' le_rfl hmass))
+    _ = (W * (ENNReal.ofReal (1 - nativeCoreAreaFraction n K)) ^ J *
+        ENNReal.ofReal (K * C * (64 : ℝ) ^ n)) * μ (cleanSupportCell μ R hR k z) := by ring
+    _ ≤ _ := mul_le_mul' hJ le_rfl
+
+end
+
+end RieszRectifiability
+
+end OAI

lean/OAI/Analysis/RieszRectifiability/Surfaces/OriginalTopAreaCharges.lean

@@ -0,0 +1,65 @@
+import Mathlib
+import OAI.Analysis.RieszRectifiability.Restart.ActiveLevelOriginalMass
+import OAI.Analysis.RieszRectifiability.Nets.SupportCellRoot
+
+namespace OAI
+
+namespace RieszRectifiability
+
+noncomputable section
+
+open MeasureTheory Metric Set
+open scoped ENNReal
+
+def enlargedTopMassConstant (n : ℕ) (C G : ℝ) : ℝ≥0∞ :=
+  ENNReal.ofReal (G * 4 ^ n) * ENNReal.ofReal (C * 8 ^ n)
+
+theorem enlargedTopMassConstant_lt_top (n : ℕ) (C G : ℝ) :
+    enlargedTopMassConstant n C G < ⊤ := by
+  exact ENNReal.mul_lt_top ENNReal.ofReal_lt_top ENNReal.ofReal_lt_top
+
+theorem clean_top_radius_power_le_mass {n d : ℕ}
+    (μ : Measure (Ambient d)) (C G : ℝ) (hC : 0 < C) (hG : 0 < G)
+    (hg : GlobalUpperGrowth n G μ)
+    (hlower : ∀ x ∈ μ.support, ∀ r : ℝ, AdmissibleRadius μ r →
+      ENNReal.ofReal (r ^ n / C) ≤ μ (ball x r))
+    (R : ℝ) (hR : 0 < R) (k : ℕ) (hcore : AdmissibleRadius μ (latticeRadius R k / 8))
+    (z : (supportLatticeNets μ R hR k).points) :
+    (ENNReal.ofReal (latticeRadius R k)) ^ n ≤
+      ENNReal.ofReal (C * 8 ^ n) * μ (cleanSupportCell μ R hR k z) := by
+  simpa only [SupportCellDescendant.radius, SupportCellDescendant.cell, supportCellRoot, Nat.add_zero]
+    using! SupportCellDescendant.radius_power_le_mass μ C G hC hG hg hlower R hR k hcore z
+      (supportCellRoot μ R hR k z)
+
+theorem enlarged_top_ball_mass_le_clean_top {n d : ℕ}
+    (μ : Measure (Ambient d)) (C G : ℝ) (hC : 0 < C) (hG : 0 < G)
+    (hg : GlobalUpperGrowth n G μ)
+    (hlower : ∀ x ∈ μ.support, ∀ r : ℝ, AdmissibleRadius μ r →
+      ENNReal.ofReal (r ^ n / C) ≤ μ (ball x r))
+    (R : ℝ) (hR : 0 < R) (k : ℕ) (hcore : AdmissibleRadius μ (latticeRadius R k / 8))
+    (z : (supportLatticeNets μ R hR k).points) :
+    μ (closedBall (z : Ambient d) (3 * latticeRadius R k)) ≤
+      enlargedTopMassConstant n C G * μ (cleanSupportCell μ R hR k z) := by
+  have hr := latticeRadius_pos R hR k
+  have hupper : μ (closedBall (z : Ambient d) (3 * latticeRadius R k)) ≤
+      ENNReal.ofReal (G * 4 ^ n) * (ENNReal.ofReal (latticeRadius R k)) ^ n := by
+    calc
+      _ ≤ μ (ball (z : Ambient d) (4 * latticeRadius R k)) :=
+        measure_mono (closedBall_subset_ball (by linarith))
+      _ ≤ ENNReal.ofReal (G * (4 * latticeRadius R k) ^ n) :=
+        hg.2 (z : Ambient d) (4 * latticeRadius R k) (by positivity)
+      _ = _ := by
+        rw [mul_pow, ← mul_assoc, ENNReal.ofReal_mul (by positivity : 0 ≤ G * 4 ^ n),
+          ENNReal.ofReal_pow hr.le]
+  have hlowerTop := clean_top_radius_power_le_mass μ C G hC hG hg hlower R hR k hcore z
+  calc
+    _ ≤ ENNReal.ofReal (G * 4 ^ n) * (ENNReal.ofReal (latticeRadius R k)) ^ n := hupper
+    _ ≤ ENNReal.ofReal (G * 4 ^ n) *
+        (ENNReal.ofReal (C * 8 ^ n) * μ (cleanSupportCell μ R hR k z)) := mul_le_mul_right hlowerTop _
+    _ = _ := by unfold enlargedTopMassConstant; rw [mul_assoc]
+
+end
+
+end RieszRectifiability
+
+end OAI

lean/OAI/Analysis/RieszRectifiability/Surfaces/ParentChartPlaneHeight.lean

@@ -0,0 +1,67 @@
+import Mathlib
+import OAI.Analysis.RieszRectifiability.Projections.NeighborProjectionEstimates
+
+namespace OAI
+
+/-!
+# Transferring parent-chart height bounds
+
+For adjacent cell scales, neighboring-plane projection estimates transfer a height bound
+relative to the parent plane to a quantitative bound relative to the child plane.
+-/
+
+namespace RieszRectifiability
+
+noncomputable section
+
+open MeasureTheory Metric Set EuclideanGeometry
+
+theorem parent_chart_plane_height_transfer {n d : ℕ}
+    (μ : Measure (Ambient d)) (R : ℝ) (hR : 0 < R) (k : ℕ)
+    (z : (supportLatticeNets μ R hR k).points)
+    (i q : SupportCellDescendant μ R hR k z)
+    (hscale : q.radius = 64 * i.radius)
+    (hnear : dist i.center q.center ≤ 2 * q.radius)
+    (ε : ℝ) (hε : 0 < ε) (hεsmall : ε ≤ 1 / 1024)
+    (S W : AffineSubspace ℝ (Ambient d)) (hS : IsAffineNPlane n S) (hW : IsAffineNPlane n W)
+    (hSi : bilateralPlaneError μ i.center (1024 * i.radius) S < ε)
+    (hWq : bilateralPlaneError μ q.center (1024 * q.radius) W < ε)
+    (x : Ambient d) (hx : x ∈ closedBall q.center (3 * q.radius))
+    (hheight : infDist x (W : Set (Ambient d)) ≤ (262144 * ε) * q.radius) :
+    infDist x (S : Set (Ambient d)) ≤ (524288 * ε) * q.radius := by
+  let : Nonempty S := hS.1.to_subtype
+  let : Nonempty W := hW.1.to_subtype
+  have hri := i.radius_pos
+  have hrq := q.radius_pos
+  have hsmall : i.radius ≤ q.radius := by rw [hscale]; linarith
+  have hlarge : q.radius ≤ 64 * i.radius := hscale.le
+  have hneighbor : dist i.center q.center ≤ 128 * q.radius := by linarith
+  have hop := neighbor_cell_projection_operator_norm_le μ R hR k z i q
+    hsmall hlarge hneighbor ε hε hεsmall S W hS hW hSi hWq
+  have hScenter := (bilateralPlaneError_lt_pointwise μ ⟨i.center, i.center_mem_support⟩
+    i.center (1024 * i.radius) ε (by positivity) S hS hSi).1 i.center
+      (mem_ball_self (by positivity)) i.center_mem_support
+  have hWcenter := (bilateralPlaneError_lt_pointwise μ ⟨i.center, i.center_mem_support⟩
+    q.center (1024 * q.radius) ε (by positivity) W hW hWq).1 i.center
+      (by change dist i.center q.center < 1024 * q.radius; linarith) i.center_mem_support
+  have hdx : dist x i.center ≤ 5 * q.radius := by
+    have ht := dist_triangle x q.center i.center
+    rw [dist_comm q.center i.center] at ht
+    have hx' : dist x q.center ≤ 3 * q.radius := hx
+    linarith
+  have hpair := affine_projection_pair_dist_bound S W i.center x (2048 * ε) hop
+  have hm := mul_le_mul_of_nonneg_left hdx (show 0 ≤ 2048 * ε by positivity)
+  have ht := dist_triangle (orthogonalProjection S x : Ambient d)
+    (orthogonalProjection W x : Ambient d) x
+  rw [dist_comm (orthogonalProjection S x : Ambient d) x,
+    dist_orthogonalProjection_eq_infDist S x,
+    dist_comm (orthogonalProjection W x : Ambient d) x,
+    dist_orthogonalProjection_eq_infDist W x] at ht
+  have hscaleError := mul_le_mul_of_nonneg_left hsmall hε.le
+  nlinarith [mul_pos hε hrq]
+
+end
+
+end RieszRectifiability
+
+end OAI

lean/OAI/Analysis/RieszRectifiability/Surfaces/ParentToChildInputChart.lean

@@ -0,0 +1,152 @@
+import Mathlib
+import OAI.Analysis.RieszRectifiability.Surfaces.RecenteredDiskCharts
+import OAI.Analysis.RieszRectifiability.Projections.ProjectionTubeLocation
+import OAI.Analysis.RieszRectifiability.Surfaces.ParentChartPlaneHeight
+import OAI.Analysis.RieszRectifiability.Surfaces.PlaneChangeCharts
+
+namespace OAI
+
+/-!
+# Parent-to-child input charts
+
+A parent chart is reparametrized over the nearby child plane and restricted to the child
+disk. Projection and height estimates preserve the exact restricted range, the Lipschitz
+and normal-component bounds, and containment in the physical child ball.
+-/
+
+namespace RieszRectifiability
+
+noncomputable section
+
+open MeasureTheory Metric Set
+open scoped NNReal
+
+theorem exists_parent_to_child_input_chart {n d : ℕ}
+    (μ : Measure (Ambient d)) (R : ℝ) (hR : 0 < R) (k : ℕ)
+    (z : (supportLatticeNets μ R hR k).points)
+    (i q : SupportCellDescendant μ R hR k z)
+    (hscale : q.radius = 64 * i.radius)
+    (hnear : dist i.center q.center ≤ 2 * q.radius)
+    (ε : ℝ) (hε : 0 < ε) (hεtiny : ε ≤ 1 / 268435456)
+    (S W : AffineSubspace ℝ (Ambient d)) (hS : IsAffineNPlane n S) (hW : IsAffineNPlane n W)
+    (hSi : bilateralPlaneError μ i.center (1024 * i.radius) S < ε)
+    (hWq : bilateralPlaneError μ q.center (1024 * q.radius) W < ε)
+    (g : closedBall (W.direction.orthogonalProjectionOnto q.center) ((5 / 2 : ℝ) * q.radius) → Ambient d)
+    (L : ℝ≥0) (hsmall : (L : ℝ) + 2048 * ε ≤ 1 / 8)
+    (hcoordinates : ∀ u, W.direction.orthogonalProjectionOnto (g u) = u.val)
+    (hnormal : LipschitzWith L
+      (fun u => (W.directionᗮ : Submodule ℝ (Ambient d)).starProjection (g u)))
+    (hheight : ∀ u, infDist (g u) (W : Set (Ambient d)) ≤ (262144 * ε) * q.radius)
+    (hphysical : ∀ u, g u ∈ closedBall q.center (3 * q.radius)) :
+    ∃ h : closedBall (S.direction.orthogonalProjectionOnto i.center) ((11 / 4 : ℝ) * i.radius) → Ambient d,
+      LipschitzWith 2 h ∧
+      LipschitzWith (2 * (L + Real.toNNReal (2048 * ε)))
+        (fun u => (S.directionᗮ : Submodule ℝ (Ambient d)).starProjection (h u)) ∧
+      (∀ u, h u ∈ Set.range g ∧ S.direction.orthogonalProjectionOnto (h u) = u.val ∧
+        h u ∈ closedBall i.center (3 * i.radius)) ∧
+      Set.range h = Set.range g ∩ S.direction.orthogonalProjectionOnto ⁻¹'
+        closedBall (S.direction.orthogonalProjectionOnto i.center) ((11 / 4 : ℝ) * i.radius) := by
+  let P := W.direction
+  let Q := S.direction
+  let a := P.orthogonalProjectionOnto q.center
+  let ac := Q.orthogonalProjectionOnto i.center
+  let ρ := (5 / 2 : ℝ) * q.radius
+  have hri := i.radius_pos
+  have hrq := q.radius_pos
+  have hρ : 0 < ρ := by dsimp [ρ]; positivity
+  let u0 : closedBall a ρ := ⟨a, mem_closedBall_self hρ.le⟩
+  let b := Q.orthogonalProjectionOnto (g u0)
+  let α : ℝ≥0 := ⟨2048 * ε, by positivity⟩
+  have hα : α = Real.toNNReal (2048 * ε) := by
+    apply Subtype.ext
+    exact (Real.coe_toNNReal _ (by positivity : 0 ≤ 2048 * ε)).symm
+  have hεsmall : ε ≤ 1 / 1024 := by linarith
+  have hop := neighbor_cell_projection_operator_norm_le μ R hR k z i q
+    (by rw [hscale]; linarith) hscale.le (by linarith)
+    ε hε hεsmall S W hS hW hSi hWq
+  have hop' : ‖P.starProjection - Q.starProjection‖ ≤ (α : ℝ) := by
+    rw [norm_sub_rev]
+    exact hop
+  have hsmall' : (L : ℝ) + (α : ℝ) ≤ 1 / 4 := by
+    change (L : ℝ) + 2048 * ε ≤ 1 / 4
+    linarith
+  have hcq := (bilateralPlaneError_lt_pointwise μ ⟨q.center, q.center_mem_support⟩
+    q.center (1024 * q.radius) ε (by positivity) W hW hWq).1 q.center
+      (mem_ball_self (by positivity)) q.center_mem_support
+  have hci := (bilateralPlaneError_lt_pointwise μ ⟨i.center, i.center_mem_support⟩
+    i.center (1024 * i.radius) ε (by positivity) S hS hSi).1 i.center
+      (mem_ball_self (by positivity)) i.center_mem_support
+  have hx0 : dist (g u0) q.center ≤ (263168 * ε) * q.radius := by
+    have h := dist_le_projection_add_plane_distances W hW.1 (g u0) q.center
+    have hc : P.starProjection (g u0) = P.starProjection q.center :=
+      congrArg (fun v : P => (v : Ambient d)) (hcoordinates u0)
+    change dist (g u0) q.center ≤ dist (P.starProjection (g u0)) (P.starProjection q.center) +
+      infDist (g u0) (W : Set (Ambient d)) + infDist q.center (W : Set (Ambient d)) at h
+    rw [hc, dist_self, zero_add] at h
+    nlinarith [hheight u0]
+  have hx0small : dist (g u0) q.center ≤ q.radius / 16 := by
+    have hm := mul_le_mul_of_nonneg_right hεtiny hrq.le
+    nlinarith
+  have hb : dist ac b ≤ 2 * q.radius + q.radius / 16 := by
+    have hp := Q.norm_starProjection_apply_le (i.center - g u0)
+    rw [map_sub, ← dist_eq_norm, ← dist_eq_norm] at hp
+    have ht := dist_triangle i.center q.center (g u0)
+    rw [dist_comm q.center (g u0)] at ht
+    change dist (Q.starProjection i.center) (Q.starProjection (g u0)) ≤ _
+    linarith
+  obtain ⟨hradius, j, hjLip, hjNormal, hjCoords, hjRange⟩ :=
+    exists_chart_over_nearby_plane P Q a ρ hρ g L α hsmall' hcoordinates hnormal hop'
+  have hcontain : dist ac b + (11 / 4 : ℝ) * i.radius ≤
+      ρ - ((L : ℝ) + (α : ℝ)) * ρ := by
+    have hm := mul_le_mul_of_nonneg_right hsmall hrq.le
+    change dist ac b + (11 / 4 : ℝ) * i.radius ≤
+      (5 / 2 : ℝ) * q.radius - ((L : ℝ) + 2048 * ε) * ((5 / 2 : ℝ) * q.radius)
+    nlinarith
+  obtain ⟨h, hhLip, hhNormal, hhCoords, hhRange⟩ :=
+    exists_recentered_disk_chart Q b (ρ - ((L : ℝ) + (α : ℝ)) * ρ) j (2 * (L + α))
+      (fun u => (hjCoords u).2) hjNormal ac ((11 / 4 : ℝ) * i.radius) hcontain
+  have hL : 1 + 2 * (L + α) ≤ (2 : ℝ≥0) := by
+    have hreal : ((1 + 2 * (L + α) : ℝ≥0) : ℝ) ≤ 2 := by
+      change 1 + 2 * ((L : ℝ) + 2048 * ε) ≤ 2
+      linarith
+    exact_mod_cast hreal
+  have hrange : Set.range h = Set.range g ∩ Q.orthogonalProjectionOnto ⁻¹'
+      closedBall ac ((11 / 4 : ℝ) * i.radius) := by
+    rw [hhRange, hjRange]
+    ext y
+    constructor
+    · intro hy
+      exact ⟨hy.1.1, hy.2⟩
+    · intro hy
+      refine ⟨⟨hy.1, ?_⟩, hy.2⟩
+      have hy' : dist (Q.orthogonalProjectionOnto y) ac ≤ (11 / 4 : ℝ) * i.radius := hy.2
+      have ht := dist_triangle (Q.orthogonalProjectionOnto y) ac b
+      change dist (Q.orthogonalProjectionOnto y) b ≤ ρ - ((L : ℝ) + (α : ℝ)) * ρ
+      linarith
+  have hhg : ∀ u, h u ∈ Set.range g := by
+    intro u
+    exact (hrange ▸ (show h u ∈ Set.range h from ⟨u, rfl⟩)).1
+  have hhheight : ∀ u, infDist (h u) (S : Set (Ambient d)) ≤ (524288 * ε) * q.radius := by
+    intro u
+    obtain ⟨v, hv⟩ := hhg u
+    rw [← hv]
+    exact parent_chart_plane_height_transfer μ R hR k z i q hscale hnear ε hε hεsmall
+      S W hS hW hSi hWq (g v) (hphysical v) (hheight v)
+  have hhphysical : ∀ u, h u ∈ closedBall i.center (3 * i.radius) := by
+    intro u
+    have hloc := plane_chart_location_of_height S hS.1 i.center ((11 / 4 : ℝ) * i.radius)
+      ((524288 * ε) * q.radius) h (fun v => (hhCoords v).2) hhheight u
+    have hm := mul_le_mul_of_nonneg_right hεtiny hri.le
+    rw [hscale] at hloc
+    change dist (h u) i.center ≤ 3 * i.radius
+    nlinarith
+  refine ⟨h, hhLip.weaken hL, ?_, ?_, hrange⟩
+  · rwa [← hα]
+  · intro u
+    exact ⟨hhg u, (hhCoords u).2, hhphysical u⟩
+
+end
+
+end RieszRectifiability
+
+end OAI

lean/OAI/Analysis/RieszRectifiability/Surfaces/PerturbedBallCoverage.lean

@@ -0,0 +1,67 @@
+import Mathlib
+import OAI.Analysis.RieszRectifiability.Foundations.MeasureBounds
+
+namespace OAI
+
+/-!
+# Ball coverage by a Lipschitz perturbation
+
+A map with bounded displacement whose error from the identity is a strict
+contraction covers a smaller concentric closed ball. A fixed point of the
+associated correction map provides the preimage of each target point.
+-/
+
+namespace RieszRectifiability
+
+noncomputable section
+
+open Metric Set
+open scoped NNReal
+
+theorem closedBall_covered_by_lipschitz_perturbation {X : Type*}
+    [NormedAddCommGroup X] [CompleteSpace X]
+    (a : X) (r δ : ℝ) (hr : 0 ≤ r) (K : ℝ≥0) (hK : K < 1)
+    (f : closedBall a r → X)
+    (hdisp : ∀ x, dist (f x) x.val ≤ δ)
+    (herr : LipschitzWith K (fun x : closedBall a r => f x - x.val)) :
+    closedBall a (r - δ) ⊆ Set.range f := by
+  intro z hz
+  have hz' : ‖z - a‖ ≤ r - δ := by simpa only [mem_closedBall, dist_eq_norm] using! hz
+  have hmaps (x : closedBall a r) : z - (f x - x.val) ∈ closedBall a r := by
+    change dist (z - (f x - x.val)) a ≤ r
+    calc
+      _ = ‖(z - a) - (f x - x.val)‖ := by
+        rw [dist_eq_norm]
+        congr 1
+        abel
+      _ ≤ ‖z - a‖ + ‖f x - x.val‖ := norm_sub_le _ _
+      _ ≤ (r - δ) + δ := add_le_add hz' (by simpa only [dist_eq_norm] using! hdisp x)
+      _ = r := by ring
+  let T : closedBall a r → closedBall a r :=
+    fun x => ⟨z - (f x - x.val), hmaps x⟩
+  have hLip : LipschitzWith K T := by
+    apply LipschitzWith.of_dist_le_mul
+    intro x y
+    change dist (z - (f x - x.val)) (z - (f y - y.val)) ≤ K * dist x y
+    have heq : (z - (f x - x.val)) - (z - (f y - y.val)) =
+        -((f x - x.val) - (f y - y.val)) := by abel
+    rw [dist_eq_norm, heq, norm_neg]
+    simpa only [dist_eq_norm] using! herr.dist_le_mul x y
+  let : CompleteSpace (closedBall a r) :=
+    (show IsClosed (closedBall a r) from isClosed_closedBall).isComplete.completeSpace_coe
+  have hT : ContractingWith K T := ⟨hK, hLip⟩
+  obtain ⟨u, hu, _, _⟩ := hT.exists_fixedPoint ⟨a, mem_closedBall_self hr⟩ (edist_ne_top _ _)
+  have heq := congrArg (fun x : closedBall a r => x.val) hu
+  change z - (f u - u.val) = u.val at heq
+  refine ⟨u, ?_⟩
+  calc
+    f u = (f u - u.val) + u.val := (sub_add_cancel _ _).symm
+    _ = (f u - u.val) + (z - (f u - u.val)) :=
+      congrArg (fun w => (f u - u.val) + w) heq.symm
+    _ = z := by abel
+
+end
+
+end RieszRectifiability
+
+end OAI

lean/OAI/Analysis/RieszRectifiability/Surfaces/PlaneChangeCharts.lean

@@ -0,0 +1,83 @@
+import Mathlib
+import OAI.Analysis.RieszRectifiability.Projections.CoveredProjectionCharts
+import OAI.Analysis.RieszRectifiability.Flatness.PlaneChangeCoverage
+import OAI.Analysis.RieszRectifiability.Projections.ProjectionConeTransfer
+
+namespace OAI
+
+/-!
+# Reparameterizing a chart over a nearby plane
+
+Small normal slope and a small change of projection leave a positive disk
+covered in the new plane. The projection inverse defines a chart on this disk,
+with quantitative Lipschitz bounds for the chart and its normal component.
+-/
+
+namespace RieszRectifiability
+
+noncomputable section
+
+open Metric Set
+open scoped NNReal
+
+theorem exists_chart_over_nearby_plane {d : ℕ}
+    (P Q : Submodule ℝ (Ambient d)) (a : P) (ρ : ℝ) (hρ : 0 < ρ)
+    (g : closedBall a ρ → Ambient d) (L α : ℝ≥0)
+    (hsmall : (L : ℝ) + (α : ℝ) ≤ 1 / 4)
+    (hcoordinates : ∀ v, P.orthogonalProjectionOnto (g v) = v.val)
+    (hnormal : LipschitzWith L
+      (fun v => (Pᗮ : Submodule ℝ (Ambient d)).starProjection (g v)))
+    (hop : ‖P.starProjection - Q.starProjection‖ ≤ (α : ℝ)) :
+    let b := Q.orthogonalProjectionOnto (g ⟨a, mem_closedBall_self hρ.le⟩)
+    let r := ρ - ((L : ℝ) + (α : ℝ)) * ρ
+    let D := closedBall b r
+    0 < r ∧ ∃ h : D → Ambient d,
+      LipschitzWith 2 h ∧
+      LipschitzWith (2 * (L + α))
+        (fun u => (Qᗮ : Submodule ℝ (Ambient d)).starProjection (h u)) ∧
+      (∀ u, h u ∈ Set.range g ∧ Q.orthogonalProjectionOnto (h u) = u.val) ∧
+      Set.range h = Set.range g ∩ Q.orthogonalProjectionOnto ⁻¹' D := by
+  let b := Q.orthogonalProjectionOnto (g ⟨a, mem_closedBall_self hρ.le⟩)
+  let r := ρ - ((L : ℝ) + (α : ℝ)) * ρ
+  let D := closedBall b r
+  have hr : 0 < r := by
+    have hm := mul_le_mul_of_nonneg_right hsmall hρ.le
+    dsimp only [r]
+    linarith
+  have hcontract : L + α < 1 := by
+    have h : ((L + α : ℝ≥0) : ℝ) < 1 := by
+      rw [NNReal.coe_add]
+      linarith
+    exact_mod_cast h
+  have hcover : D ⊆ Q.orthogonalProjectionOnto '' Set.range g :=
+    graph_covers_changed_plane_disk P Q a ρ hρ.le g L α hcontract hcoordinates hnormal hop
+  have hstar (u : closedBall a ρ) : P.starProjection (g u) = (u.val : Ambient d) :=
+    congrArg (fun v : P => (v : Ambient d)) (hcoordinates u)
+  have hcone : ∀ x ∈ Set.range g, ∀ y ∈ Set.range g,
+      ‖(Pᗮ : Submodule ℝ (Ambient d)).starProjection (x - y)‖ ≤
+        (L : ℝ) * dist (P.starProjection x) (P.starProjection y) := by
+    rintro x ⟨u, rfl⟩ y ⟨v, rfl⟩
+    have h := hnormal.dist_le_mul u v
+    rw [dist_eq_norm, ← map_sub] at h
+    rw [hstar u, hstar v]
+    exact h
+  have hconeQ : ∀ x ∈ Set.range g, ∀ y ∈ Set.range g,
+      ‖(Qᗮ : Submodule ℝ (Ambient d)).starProjection (x - y)‖ ≤
+        ((2 * (L + α) : ℝ≥0) : ℝ) * dist (Q.starProjection x) (Q.starProjection y) := by
+    intro x hx y hy
+    simpa only [NNReal.coe_mul, NNReal.coe_ofNat, NNReal.coe_add] using!
+      projection_cone_transfer P Q (Set.range g) L α (hsmall.trans (by norm_num)) hop hcone x hx y hy
+  obtain ⟨h, hLip, hnLip, hcoords, hrange⟩ :=
+    exists_chart_on_covered_projection Q (Set.range g) (2 * (L + α)) D hcover hconeQ
+  have hL : 1 + 2 * (L + α) ≤ (2 : ℝ≥0) := by
+    have hh : ((1 + 2 * (L + α) : ℝ≥0) : ℝ) ≤ 2 := by
+      rw [NNReal.coe_add, NNReal.coe_one, NNReal.coe_mul, NNReal.coe_ofNat, NNReal.coe_add]
+      linarith
+    exact_mod_cast hh
+  exact ⟨hr, h, hLip.weaken hL, hnLip, hcoords, hrange⟩
+
+end
+
+end RieszRectifiability
+
+end OAI

lean/OAI/Analysis/RieszRectifiability/Surfaces/PlaneChartBallArea.lean

@@ -0,0 +1,79 @@
+import Mathlib
+import OAI.Analysis.RieszRectifiability.Flatness.PlaneDiskHausdorffMeasure
+
+namespace OAI
+
+namespace RieszRectifiability
+
+noncomputable section
+
+open MeasureTheory Metric Set
+open scoped NNReal ENNReal
+
+def planeChartBallAreaConstant (n : ℕ) (K L : ℝ≥0) : ℝ≥0∞ :=
+  ((2 : ℝ≥0∞) * (K : ℝ≥0∞) * (L : ℝ≥0∞)) ^ n * planeUnitHausdorffMeasure n
+
+theorem planeChartBallAreaConstant_lt_top (n : ℕ) (K L : ℝ≥0) :
+    planeChartBallAreaConstant n K L < ⊤ := by
+  exact ENNReal.mul_lt_top (by finiteness) (planeUnitHausdorffMeasure_lt_top n)
+
+theorem plane_chart_ball_hausdorffMeasure_le {n d e : ℕ}
+    (P : Submodule ℝ (Ambient d)) (hdim : Module.finrank ℝ P = n)
+    (C : Set P) (g : C → Ambient e) (K L : ℝ≥0) (hL : 0 < L)
+    (hg : LipschitzWith K g) (hsep : AntilipschitzWith L g)
+    (p : Ambient e) (r : ℝ) (hr : 0 < r) :
+    (μH[(n : ℝ)] : Measure (Ambient e)) (Set.range g ∩ closedBall p r) ≤
+      planeChartBallAreaConstant n K L * (ENNReal.ofReal r) ^ n := by
+  classical
+  by_cases hempty : Set.range g ∩ closedBall p r = ∅
+  · rw [hempty, measure_empty]
+    exact zero_le
+  obtain ⟨y, hy⟩ := Set.nonempty_iff_ne_empty.mpr hempty
+  obtain ⟨a, ha⟩ := hy.1
+  let T := g ⁻¹' closedBall p r
+  have hdomain : (Subtype.val : C → P) '' T ⊆ closedBall a.val (2 * (L : ℝ) * r) := by
+    rintro _ ⟨x, hx, rfl⟩
+    have hxball : dist (g x) p ≤ r := hx
+    have hyball : dist (g a) p ≤ r := by rw [ha]; exact hy.2
+    have ht := dist_triangle_right (g x) (g a) p
+    have hpair : dist (g x) (g a) ≤ 2 * r := by linarith
+    have h := (hsep.le_mul_dist x a).trans (mul_le_mul_of_nonneg_left hpair L.coe_nonneg)
+    change dist x.val a.val ≤ 2 * (L : ℝ) * r
+    change dist x.val a.val ≤ (L : ℝ) * (2 * r) at h
+    linarith
+  have hrad : 0 < 2 * (L : ℝ) * r := by
+    have hLreal : 0 < (L : ℝ) := hL
+    positivity
+  have hdom : (μH[(n : ℝ)] : Measure C) T ≤
+      (ENNReal.ofReal (2 * (L : ℝ) * r)) ^ n * planeUnitHausdorffMeasure n := by
+    have hiso := (isometry_subtype_coe (s := C)).hausdorffMeasure_image
+      (Or.inl (show 0 ≤ (n : ℝ) by positivity)) T
+    rw [← hiso]
+    exact (measure_mono hdomain).trans_eq (plane_closedBall_hausdorffMeasure P hdim a.val _ hrad)
+  have himage : g '' T = Set.range g ∩ closedBall p r := by
+    ext x
+    constructor
+    · rintro ⟨u, hu, rfl⟩
+      exact ⟨⟨u, rfl⟩, hu⟩
+    · rintro ⟨⟨u, rfl⟩, hu⟩
+      exact ⟨u, hu, rfl⟩
+  have harea := hg.hausdorffMeasure_image_le (show 0 ≤ (n : ℝ) by positivity) T
+  rw [himage, ENNReal.rpow_natCast] at harea
+  calc
+    _ ≤ (K : ℝ≥0∞) ^ n * (μH[(n : ℝ)] : Measure C) T := harea
+    _ ≤ (K : ℝ≥0∞) ^ n *
+        ((ENNReal.ofReal (2 * (L : ℝ) * r)) ^ n * planeUnitHausdorffMeasure n) :=
+      mul_le_mul_right hdom _
+    _ = planeChartBallAreaConstant n K L * (ENNReal.ofReal r) ^ n := by
+      rw [ENNReal.ofReal_mul (by positivity : 0 ≤ 2 * (L : ℝ)),
+        ENNReal.ofReal_mul (by norm_num : (0 : ℝ) ≤ 2),
+        ENNReal.ofReal_ofNat, ENNReal.ofReal_coe_nnreal]
+      unfold planeChartBallAreaConstant
+      simp only [mul_pow]
+      ring
+
+end
+
+end RieszRectifiability
+
+end OAI

lean/OAI/Analysis/RieszRectifiability/Surfaces/PlaneDiskLowerArea.lean

@@ -0,0 +1,54 @@
+import Mathlib
+import OAI.Analysis.RieszRectifiability.Flatness.PlaneDiskHausdorffMeasure
+
+namespace OAI
+
+namespace RieszRectifiability
+
+noncomputable section
+
+open MeasureTheory Metric Set
+open scoped NNReal ENNReal
+
+theorem planeUnitHausdorffMeasure_pos (n : ℕ) :
+    0 < planeUnitHausdorffMeasure n := by
+  have h := measure_closedBall_pos
+    (μH[(Module.finrank ℝ (Ambient n) : ℝ)] : Measure (Ambient n))
+    (0 : Ambient n) (by norm_num : (0 : ℝ) < 1)
+  simpa only [finrank_euclideanSpace_fin, planeUnitHausdorffMeasure] using! h
+
+def planeDiskLowerAreaConstant (n : ℕ) (L : ℝ≥0) : ℝ≥0∞ :=
+  planeUnitHausdorffMeasure n / (L : ℝ≥0∞) ^ n
+
+theorem planeDiskLowerAreaConstant_pos (n : ℕ) (L : ℝ≥0) :
+    0 < planeDiskLowerAreaConstant n L := by
+  exact ENNReal.div_pos (planeUnitHausdorffMeasure_pos n).ne' (by finiteness)
+
+theorem planeDiskLowerAreaConstant_lt_top (n : ℕ) (L : ℝ≥0) (hL : 0 < L) :
+    planeDiskLowerAreaConstant n L < ⊤ := by
+  have hL0 : (L : ℝ≥0∞) ≠ 0 := by exact_mod_cast hL.ne'
+  exact ENNReal.div_lt_top (planeUnitHausdorffMeasure_lt_top n).ne
+    (pow_ne_zero n hL0)
+
+theorem plane_disk_antilipschitz_range_hausdorffMeasure_ge {n d e : ℕ}
+    (P : Submodule ℝ (Ambient d)) (hdim : Module.finrank ℝ P = n)
+    (a : P) (r : ℝ) (hr : 0 < r) (L : ℝ≥0) (hL : 0 < L)
+    (g : closedBall a r → Ambient e) (hg : AntilipschitzWith L g) :
+    planeDiskLowerAreaConstant n L * (ENNReal.ofReal r) ^ n ≤
+      (μH[(n : ℝ)] : Measure (Ambient e)) (Set.range g) := by
+  have h := hg.le_hausdorffMeasure_image (show 0 ≤ (n : ℝ) by positivity) Set.univ
+  simp only [Set.image_univ, ENNReal.rpow_natCast,
+    plane_closedBall_subtype_hausdorffMeasure P hdim a r hr] at h
+  have hL0 : (L : ℝ≥0∞) ^ n ≠ 0 := pow_ne_zero n (by exact_mod_cast hL.ne')
+  have hLt : (L : ℝ≥0∞) ^ n ≠ ⊤ := by finiteness
+  have hdiv := (ENNReal.div_le_iff' hL0 hLt).mpr h
+  convert! hdiv using 1
+  unfold planeDiskLowerAreaConstant
+  simp only [div_eq_mul_inv]
+  ring
+
+end
+
+end RieszRectifiability
+
+end OAI

lean/OAI/Analysis/RieszRectifiability/Surfaces/QuantitativeConvexChartContraction.lean

@@ -0,0 +1,92 @@
+import Mathlib
+import OAI.Analysis.RieszRectifiability.Surfaces.ConvexChartContraction
+
+namespace OAI
+
+namespace RieszRectifiability
+
+noncomputable section
+
+open Metric Set Topology
+open scoped NNReal
+
+theorem exists_bounded_contraction_in_bilipschitz_convex_chart {E V : Type*}
+    [NormedAddCommGroup E] [NormedSpace ℝ E] [MetricSpace V]
+    (C : Set E) (hC : Convex ℝ C) (H : C → V) (K L : ℝ≥0)
+    (hLip : LipschitzWith K H) (hsep : AntilipschitzWith L H)
+    (A : Set V) (hA : A ⊆ Set.range H) (p : V) (hp : p ∈ A)
+    (r : ℝ) (hball : A ⊆ closedBall p r) :
+    ∃ F : unitInterval × A → V, Continuous F ∧
+      (∀ x, F (0, x) = x.val) ∧ (∀ x, F (1, x) = p) ∧
+      (∀ s, F (s, ⟨p, hp⟩) = p) ∧
+      (∀ w, F w ∈ Set.range H ∩ closedBall p ((K : ℝ) * (L : ℝ) * r)) := by
+  classical
+  have hH : IsEmbedding H := hsep.isEmbedding hLip.continuous
+  have hpre : ∀ x : A, ∃ u : C, H u = x.val := fun x => hA x.property
+  choose j hj using hpre
+  have hjcont : Continuous j := hH.continuous_iff.mpr (by
+    have hid : H ∘ j = (Subtype.val : A → V) := funext hj
+    rw [hid]
+    exact continuous_subtype_val)
+  let u0 : C := j ⟨p, hp⟩
+  have hH0 : H u0 = p := hj ⟨p, hp⟩
+  let T : unitInterval × A → C := fun w =>
+    ⟨(1 - (w.1 : ℝ)) • (j w.2 : E) + (w.1 : ℝ) • (u0 : E),
+      hC (j w.2).property u0.property (sub_nonneg.mpr w.1.property.2)
+        w.1.property.1 (by ring)⟩
+  have hs : Continuous (fun w : unitInterval × A => (w.1 : ℝ)) :=
+    continuous_subtype_val.comp continuous_fst
+  have hjv : Continuous (fun w : unitInterval × A => (j w.2 : E)) :=
+    continuous_subtype_val.comp (hjcont.comp continuous_snd)
+  have hT : Continuous T :=
+    (((continuous_const.sub hs).smul hjv).add (hs.smul continuous_const)).subtype_mk _
+  let F := H ∘ T
+  refine ⟨F, hLip.continuous.comp hT, ?_, ?_, ?_, ?_⟩
+  · intro x
+    have ht : T (0, x) = j x := by apply Subtype.ext; simp [T]
+    change H (T (0, x)) = x.val
+    rw [ht]
+    exact hj x
+  · intro x
+    have ht : T (1, x) = u0 := by apply Subtype.ext; simp [T]
+    change H (T (1, x)) = p
+    rw [ht]
+    exact hH0
+  · intro s
+    have ht : T (s, ⟨p, hp⟩) = u0 := by
+      apply Subtype.ext
+      change (1 - (s : ℝ)) • (u0 : E) + (s : ℝ) • (u0 : E) = (u0 : E)
+      rw [← add_smul]
+      simp
+    change H (T (s, ⟨p, hp⟩)) = p
+    rw [ht]
+    exact hH0
+  · intro w
+    refine ⟨⟨T w, rfl⟩, ?_⟩
+    have hseg : dist (T w) u0 ≤ dist (j w.2) u0 := by
+      calc
+        dist (T w) u0 = (1 - (w.1 : ℝ)) * dist (j w.2) u0 := by
+          simp only [Subtype.dist_eq, dist_eq_norm]
+          change ‖((1 - (w.1 : ℝ)) • (j w.2 : E) + (w.1 : ℝ) • (u0 : E)) - (u0 : E)‖ =
+            (1 - (w.1 : ℝ)) * ‖(j w.2 : E) - (u0 : E)‖
+          rw [show ((1 - (w.1 : ℝ)) • (j w.2 : E) + (w.1 : ℝ) • (u0 : E)) - (u0 : E) =
+            (1 - (w.1 : ℝ)) • ((j w.2 : E) - (u0 : E)) by module]
+          rw [norm_smul, Real.norm_eq_abs, abs_of_nonneg (sub_nonneg.mpr w.1.property.2)]
+        _ ≤ dist (j w.2) u0 := mul_le_of_le_one_left dist_nonneg (by linarith [w.1.property.1])
+    have hjdist : dist (j w.2) u0 ≤ (L : ℝ) * r := by
+      have h := hsep.le_mul_dist (j w.2) u0
+      rw [hj w.2, hH0] at h
+      exact h.trans (mul_le_mul_of_nonneg_left (hball w.2.property) L.coe_nonneg)
+    change dist (H (T w)) p ≤ (K : ℝ) * (L : ℝ) * r
+    rw [← hH0]
+    calc
+      dist (H (T w)) (H u0) ≤ (K : ℝ) * dist (T w) u0 := hLip.dist_le_mul _ _
+      _ ≤ (K : ℝ) * ((L : ℝ) * r) :=
+        mul_le_mul_of_nonneg_left (hseg.trans hjdist) K.coe_nonneg
+      _ = (K : ℝ) * (L : ℝ) * r := by ring
+
+end
+
+end RieszRectifiability
+
+end OAI

lean/OAI/Analysis/RieszRectifiability/Surfaces/RecenteredDiskCharts.lean

@@ -0,0 +1,58 @@
+import Mathlib
+import OAI.Analysis.RieszRectifiability.Projections.CoveredProjectionCharts
+
+namespace OAI
+
+/-!
+# Recentering disk charts
+
+A chart whose projection is the identity restricts to any closed disk contained in
+its parameter disk. The recentered chart preserves the normal Lipschitz bound and
+parametrizes exactly the part of the original range over the smaller disk.
+-/
+
+namespace RieszRectifiability
+
+noncomputable section
+
+open Metric Set
+open scoped NNReal
+
+theorem exists_recentered_disk_chart {d : ℕ}
+    (P : Submodule ℝ (Ambient d)) (a : P) (ρ : ℝ)
+    (g : closedBall a ρ → Ambient d) (L : ℝ≥0)
+    (hcoordinates : ∀ v, P.orthogonalProjectionOnto (g v) = v.val)
+    (hnormal : LipschitzWith L
+      (fun v => (Pᗮ : Submodule ℝ (Ambient d)).starProjection (g v)))
+    (b : P) (r : ℝ) (hcontain : dist b a + r ≤ ρ) :
+    ∃ h : closedBall b r → Ambient d,
+      LipschitzWith (1 + L) h ∧
+      LipschitzWith L (fun u => (Pᗮ : Submodule ℝ (Ambient d)).starProjection (h u)) ∧
+      (∀ u, h u ∈ Set.range g ∧ P.orthogonalProjectionOnto (h u) = u.val) ∧
+      Set.range h = Set.range g ∩ P.orthogonalProjectionOnto ⁻¹' closedBall b r := by
+  have hcover : closedBall b r ⊆ P.orthogonalProjectionOnto '' Set.range g := by
+    intro v hv
+    have hnear : v ∈ closedBall a ρ := by
+      have ht := dist_triangle v b a
+      have hv' : dist v b ≤ r := hv
+      change dist v a ≤ ρ
+      linarith
+    let u : closedBall a ρ := ⟨v, hnear⟩
+    exact ⟨g u, ⟨u, rfl⟩, hcoordinates u⟩
+  have hstar (u : closedBall a ρ) : P.starProjection (g u) = (u.val : Ambient d) :=
+    congrArg (fun v : P => (v : Ambient d)) (hcoordinates u)
+  have hcone : ∀ x ∈ Set.range g, ∀ y ∈ Set.range g,
+      ‖(Pᗮ : Submodule ℝ (Ambient d)).starProjection (x - y)‖ ≤
+        (L : ℝ) * dist (P.starProjection x) (P.starProjection y) := by
+    rintro x ⟨u, rfl⟩ y ⟨v, rfl⟩
+    have h := hnormal.dist_le_mul u v
+    rw [dist_eq_norm, ← map_sub] at h
+    rw [hstar u, hstar v]
+    exact h
+  exact exists_chart_on_covered_projection P (Set.range g) L (closedBall b r) hcover hcone
+
+end
+
+end RieszRectifiability
+
+end OAI

lean/OAI/Analysis/RieszRectifiability/Surfaces/RegionRepresentativeCharts.lean

@@ -0,0 +1,88 @@
+import Mathlib
+import OAI.Analysis.RieszRectifiability.Foundations.RegionRepresentativeGeometry
+
+namespace OAI
+
+/-!
+# Lipschitz charts for region representatives
+
+Good cells at the scale of each pair provide affine-plane tube and angle bounds.
+These bounds make projection onto the reference plane separate region representatives
+with inverse Lipschitz constant two. A Lipschitz extension then covers the representatives
+by the image of a ball in the Euclidean space of the plane's dimension.
+-/
+
+namespace RieszRectifiability
+
+noncomputable section
+
+open MeasureTheory Metric Set
+open scoped NNReal
+
+theorem projection_separates_region_representatives {n d : ℕ}
+    (μ : Measure (Ambient d)) (R : ℝ) (hR : 0 < R) (k : ℕ)
+    (z : (supportLatticeNets μ R hR k).points)
+    (Good : SupportCellDescendant μ R hR k z → Prop)
+    (hroot : ∀ i : SupportCellDescendant μ R hR k z, i.depth = 0 → Good i)
+    (P : Submodule ℝ (Ambient d))
+    (hfit : ∀ i : SupportCellDescendant μ R hR k z, Good i →
+      ∃ S : AffineSubspace ℝ (Ambient d), IsAffineNPlane n S ∧
+        (∀ w ∈ ball i.center (1024 * i.radius), w ∈ μ.support →
+          infDist w (S : Set (Ambient d)) ≤ i.radius / 16384) ∧
+        ∀ v ∈ S.direction,
+          ‖(Pᗮ : Submodule ℝ (Ambient d)).starProjection v‖ ≤ (1 / 4 : ℝ) * ‖v‖) :
+    ∀ x ∈ cellRegionRepresentatives μ R hR k z Good,
+    ∀ y ∈ cellRegionRepresentatives μ R hR k z Good,
+      dist x y ≤ 2 * dist (P.starProjection x) (P.starProjection y) := by
+  intro x hx y hy
+  by_cases hxy : x = y
+  · simp only [hxy, dist_self, mul_zero, le_refl]
+  obtain ⟨q, hgood, _, hupper, _, hxball, hyball⟩ :=
+    exists_good_pair_cell_for_representatives μ R hR k z Good hroot x y hx hy hxy
+  obtain ⟨S, hS, htube, hangle⟩ := hfit q hgood
+  let : Nonempty S := hS.1.to_subtype
+  have hxμ := supportLatticeCell_subset_support μ R hR k z
+    (cellRegionRepresentatives_subset_top μ R hR k z Good hx).1
+  have hyμ := supportLatticeCell_subset_support μ R hR k z
+    (cellRegionRepresentatives_subset_top μ R hR k z Good hy).1
+  have hxS : infDist x (S : Set (Ambient d)) ≤ (1 / 32 : ℝ) * dist x y := by
+    have h := htube x hxball hxμ
+    linarith
+  have hyS : infDist y (S : Set (Ambient d)) ≤ (1 / 32 : ℝ) * dist x y := by
+    have h := htube y hyball hyμ
+    linarith
+  exact projection_separates_of_pairwise_plane P S x y (1 / 32) (1 / 4)
+    (by norm_num) (by norm_num) hxS hyS hangle
+
+theorem exists_ball_lipschitz_cover_of_region_representatives {n d : ℕ}
+    (μ : Measure (Ambient d)) (R : ℝ) (hR : 0 < R) (k : ℕ)
+    (z : (supportLatticeNets μ R hR k).points)
+    (Good : SupportCellDescendant μ R hR k z → Prop)
+    (hroot : ∀ i : SupportCellDescendant μ R hR k z, i.depth = 0 → Good i)
+    (P : Submodule ℝ (Ambient d)) (hdim : Module.finrank ℝ P = n)
+    (hfit : ∀ i : SupportCellDescendant μ R hR k z, Good i →
+      ∃ S : AffineSubspace ℝ (Ambient d), IsAffineNPlane n S ∧
+        (∀ w ∈ ball i.center (1024 * i.radius), w ∈ μ.support →
+          infDist w (S : Set (Ambient d)) ≤ i.radius / 16384) ∧
+        ∀ v ∈ S.direction,
+          ‖(Pᗮ : Submodule ℝ (Ambient d)).starProjection v‖ ≤ (1 / 4 : ℝ) * ‖v‖) :
+    ∃ g : (ball (0 : Ambient n) (3 * latticeRadius R k)) → Ambient d,
+      LipschitzWith (lipschitzExtensionConstant (Ambient d) * 2) g ∧
+        cellRegionRepresentatives μ R hR k z Good ⊆ range g := by
+  have hball : cellRegionRepresentatives μ R hR k z Good ⊆
+      ball (z : Ambient d) (3 * latticeRadius R k) := by
+    intro x hx
+    have hb := (supportLatticeCell_bounds μ R hR k z).2
+      (cellRegionRepresentatives_subset_top μ R hR k z Good hx).1
+    change dist x (z : Ambient d) ≤ 2 * latticeRadius R k at hb
+    rw [mem_ball]
+    have hr := latticeRadius_pos R hR k
+    linarith
+  exact exists_ball_lipschitz_cover_of_projection _ _ _ hball P hdim 2
+    (projection_separates_region_representatives μ R hR k z Good hroot P hfit)
+
+end
+
+end RieszRectifiability
+
+end OAI

lean/OAI/Analysis/RieszRectifiability/Surfaces/RescaledBallCharts.lean

@@ -0,0 +1,81 @@
+import Mathlib
+import OAI.Analysis.RieszRectifiability.Foundations.MeasureBounds
+
+namespace OAI
+
+/-!
+A Lipschitz chart on a centered ball can be translated and rescaled without changing its image.
+Rescaling the parameter ball by the inverse factor multiplies the Lipschitz bound by that factor.
+-/
+
+namespace RieszRectifiability
+
+noncomputable section
+
+open Metric Set
+open scoped NNReal
+
+theorem exists_rescaled_ball_chart {n d : ℕ}
+    (r : ℝ) (a : Ambient n) (s : ℝ≥0) (hs : 0 < s)
+    (f : ball (0 : Ambient n) r → Ambient d) (M : ℝ≥0) (hf : LipschitzWith M f) :
+    ∃ g : Ambient n → Ambient d,
+      LipschitzOnWith (M * s) g (ball a (r / (s : ℝ))) ∧
+      g '' ball a (r / (s : ℝ)) = Set.range f := by
+  classical
+  have hsr : 0 < (s : ℝ) := hs
+  have hnorm (u : Ambient n) : ‖(s : ℝ) • (u - a)‖ = (s : ℝ) * dist u a := by
+    rw [norm_smul, Real.norm_eq_abs, abs_of_nonneg s.coe_nonneg, dist_eq_norm]
+  have hmem (u : Ambient n) (hu : u ∈ ball a (r / (s : ℝ))) :
+      (s : ℝ) • (u - a) ∈ ball (0 : Ambient n) r := by
+    rw [mem_ball_zero_iff]
+    rw [hnorm]
+    have h := (lt_div_iff₀ hsr).mp hu
+    simpa only [mul_comm] using! h
+  let T : ball a (r / (s : ℝ)) → ball (0 : Ambient n) r :=
+    fun u => ⟨(s : ℝ) • (u.val - a), hmem u.val u.property⟩
+  have hTdist (u v : ball a (r / (s : ℝ))) :
+      dist (T u) (T v) = (s : ℝ) * dist u v := by
+    change dist ((s : ℝ) • (u.val - a)) ((s : ℝ) • (v.val - a)) =
+      (s : ℝ) * dist u.val v.val
+    rw [dist_smul₀, Real.norm_eq_abs, abs_of_nonneg s.coe_nonneg]
+    congr 1
+    simp only [dist_eq_norm]
+    congr 1
+    abel
+  have hsurj : Function.Surjective T := by
+    intro v
+    let u : Ambient n := a + (s : ℝ)⁻¹ • v.val
+    have hu : u ∈ ball a (r / (s : ℝ)) := by
+      change dist (a + (s : ℝ)⁻¹ • v.val) a < r / (s : ℝ)
+      rw [dist_eq_norm, add_sub_cancel_left, norm_smul, Real.norm_eq_abs,
+        abs_of_pos (inv_pos.mpr hsr)]
+      have hv : ‖v.val‖ < r := mem_ball_zero_iff.mp v.property
+      have h := mul_lt_mul_of_pos_left hv (inv_pos.mpr hsr)
+      simpa only [div_eq_mul_inv, mul_comm] using! h
+    refine ⟨⟨u, hu⟩, ?_⟩
+    apply Subtype.ext
+    change (s : ℝ) • ((a + (s : ℝ)⁻¹ • v.val) - a) = v.val
+    rw [add_sub_cancel_left, smul_smul, mul_inv_cancel₀ hsr.ne', one_smul]
+  let g : Ambient n → Ambient d := fun u =>
+    if hu : u ∈ ball a (r / (s : ℝ)) then f (T ⟨u, hu⟩) else 0
+  have hg (u : Ambient n) (hu : u ∈ ball a (r / (s : ℝ))) : g u = f (T ⟨u, hu⟩) := by
+    simp only [g, dite_eq_left hu]
+  refine ⟨g, ?_, ?_⟩
+  · apply LipschitzOnWith.of_dist_le_mul
+    intro u hu v hv
+    rw [hg u hu, hg v hv]
+    have h := hf.dist_le_mul (T ⟨u, hu⟩) (T ⟨v, hv⟩)
+    rw [hTdist] at h
+    simpa only [NNReal.coe_mul, Subtype.dist_eq, mul_assoc] using! h
+  · apply Set.Subset.antisymm
+    · rintro y ⟨u, hu, rfl⟩
+      exact ⟨T ⟨u, hu⟩, (hg u hu).symm⟩
+    · rintro y ⟨v, rfl⟩
+      obtain ⟨u, hu⟩ := hsurj v
+      exact ⟨u.val, u.property, (hg u.val u.property).trans (congrArg f hu)⟩
+
+end
+
+end RieszRectifiability
+
+end OAI

lean/OAI/Analysis/RieszRectifiability/Surfaces/RescaledChildChartGluing.lean

@@ -0,0 +1,64 @@
+import Mathlib
+import OAI.Analysis.RieszRectifiability.Foundations.SeparatedParameterPatchGluing
+import OAI.Analysis.RieszRectifiability.Surfaces.RescaledBallCharts
+
+namespace OAI
+
+namespace RieszRectifiability
+
+noncomputable section
+
+open Metric Set
+open scoped NNReal
+
+theorem exists_ball_lipschitz_cover_of_rescaled_children {n d : ℕ} {ι : Type*}
+    (a : ι → Ambient n) (c : ι → Ambient d) (r : ι → ℝ)
+    (f : ∀ i : ι, ball (0 : Ambient n) (r i) → Ambient d)
+    (M A L : ℝ≥0) (hA : 0 < A)
+    (hsep : ∀ i j : ι, i ≠ j → r i + r j ≤ (A : ℝ) * dist (a i) (a j))
+    (hcenters : ∀ i j : ι, dist (c i) (c j) ≤ (L : ℝ) * dist (a i) (a j))
+    (himage : ∀ i : ι, Set.range (f i) ⊆ closedBall (c i) (3 * r i))
+    (hLip : ∀ i : ι, LipschitzWith M (f i))
+    (ρ : ℝ) (hball : ∀ i : ι, ball (a i) (r i / (4 * (A : ℝ))) ⊆ ball (0 : Ambient n) ρ) :
+    ∃ F : ball (0 : Ambient n) ρ → Ambient d,
+      LipschitzWith (lipschitzExtensionConstant (Ambient d) *
+        separatedPatchGluingConstant (M * (4 * A)) A L) F ∧
+      (⋃ i : ι, Set.range (f i)) ⊆ Set.range F := by
+  classical
+  have hs : 0 < 4 * A := by positivity
+  have hc (i : ι) := exists_rescaled_ball_chart (r i) (a i) (4 * A) hs (f i) M (hLip i)
+  choose g hg hrange using hc
+  have hrange' (i : ι) : g i '' ball (a i) (r i / (4 * (A : ℝ))) = Set.range (f i) := by
+    simpa only [NNReal.coe_mul, NNReal.coe_ofNat] using! hrange i
+  have hg' (i : ι) : LipschitzOnWith (M * (4 * A)) (g i)
+      (ball (a i) (r i / (4 * (A : ℝ)))) := by
+    simpa only [NNReal.coe_mul, NNReal.coe_ofNat] using! hg i
+  obtain ⟨F, hF, hcover⟩ := exists_ball_lipschitz_cover_of_separated_parameter_patches
+    a c r (fun i => ball (a i) (r i / (4 * (A : ℝ)))) g (M * (4 * A)) A L hA hsep hcenters
+    (fun _ _ hu => le_of_lt hu)
+    (fun i u hu => himage i (hrange' i ▸ mem_image_of_mem (g i) hu)) hg'
+    ρ (iUnion_subset hball)
+  refine ⟨F, hF, ?_⟩
+  intro y hy
+  obtain ⟨i, hi⟩ := mem_iUnion.mp hy
+  exact hcover (mem_iUnion.mpr ⟨i, hrange' i ▸ hi⟩)
+
+theorem small_parameter_ball_subset_double_ball {n : ℕ}
+    (a : Ambient n) (ρ r : ℝ) (hρ : 0 < ρ) (ha : a ∈ closedBall (0 : Ambient n) ρ)
+    (s : ℝ≥0) (hs : 1 ≤ s) (hr : r ≤ ρ) :
+    ball a (r / (s : ℝ)) ⊆ ball (0 : Ambient n) (2 * ρ) := by
+  intro u hu
+  have hs' : 1 ≤ (s : ℝ) := hs
+  have hsp : 0 < (s : ℝ) := lt_of_lt_of_le zero_lt_one hs'
+  have hrad : r / (s : ℝ) ≤ ρ := (div_le_iff₀ hsp).mpr (by nlinarith)
+  have hnear : dist u a < r / (s : ℝ) := hu
+  have hac : dist a (0 : Ambient n) ≤ ρ := ha
+  have ht := dist_triangle u a (0 : Ambient n)
+  change dist u (0 : Ambient n) < 2 * ρ
+  linarith
+
+end
+
+end RieszRectifiability
+
+end OAI

lean/OAI/Analysis/RieszRectifiability/Surfaces/RieszFromUniformSurfacePieces.lean

@@ -0,0 +1,60 @@
+import Mathlib
+import OAI.Analysis.RieszRectifiability.Restart.CleanCellChartTargetBridge
+
+namespace OAI
+
+/-!
+# Uniform rectifiability from restart surface pieces
+
+`HasUniformRestartSurfacePieces` uniformly bounds the number and Lipschitz
+constants of pieces covering restart models up to a prescribed weighted area
+loss. Combining this data with AD regularity and the Riesz bound gives clean-cell
+charts with half-mass deficit, and hence uniform rectifiability.
+-/
+
+namespace RieszRectifiability
+
+noncomputable section
+
+open MeasureTheory Metric Set
+open scoped NNReal ENNReal
+
+def HasUniformRestartSurfacePieces {d : ℕ} (n : ℕ)
+    (μ : Measure (Ambient d)) (G ε : ℝ) : Prop :=
+  ∀ δ : ℝ, 0 < δ → ∃ (N : ℕ) (P : ℝ≥0),
+    ∀ (R : ℝ) (hR : 0 < R) (k : ℕ) (z : (supportLatticeNets μ R hR k).points),
+      AdmissibleRadius μ (latticeRadius R k / 8) →
+      let Bad := fun i : SupportCellDescendant μ R hR k z =>
+        ε ≤ bilateralBeta n μ i.center (1024 * i.radius)
+      ∃ (E : {q : SupportCellDescendant μ R hR k z // cellRestartsAfter Bad q} → Set (Ambient d))
+        (data : ∀ q : {q : SupportCellDescendant μ R hR k z // cellRestartsAfter Bad q},
+          ¬ Bad q.val → SelectedRestartSurfaceData n Bad q.val (E q) ε N P),
+        ∀ q hq, (ENNReal.ofReal G + activeRegionStopMassAreaConstant n G) *
+          (μH[(n : ℝ)] : Measure (Ambient d))
+            ((Set.range (data q hq).model ∩ closedBall q.val.center (3 * q.val.radius)) \ E q) ≤
+              ENNReal.ofReal δ * μ q.val.cell
+
+theorem uniformlyRectifiable_of_Riesz_and_uniform_restart_surface_pieces
+    {p d : ℕ} (hnd : p + 1 ≤ d) (μ : Measure (Ambient d)) [μ.Regular]
+    (hAD : ADRegular (p + 1) μ) (hRiesz : RieszL2Bounded (p + 1) μ)
+    (G : ℝ) (hG : 0 < G) (hg : GlobalUpperGrowth (p + 1) G μ)
+    (ε : ℝ) (hε : 0 < ε) (hεfine : ε ≤ 1 / 281474976710656)
+    (hsmall : activeProjectionError d ε ≤ 1 / 128)
+    (hpieces : HasUniformRestartSurfacePieces (p + 1) μ G ε) :
+    UniformlyRectifiable (p + 1) μ := by
+  obtain ⟨δ, hδ, b, _, hcharts⟩ := original_AD_Riesz_recursive_chart_from_surface_pieces
+    hnd μ hAD hRiesz G hG hg 1024 ε (by norm_num) hε hεfine hsmall (1 / 2) (by norm_num)
+  obtain ⟨N, P, hdata⟩ := hpieces δ hδ
+  apply uniformlyRectifiable_of_uniform_clean_cell_deficits μ hAD G hG hg
+    (1 / 2) (by norm_num) (by norm_num)
+    (badBudgetChartConstant (fun M => restartChartStepConstant d N P (restartChartStepConstant d N P M)) b)
+  intro R hR k z hcore
+  obtain ⟨E, data, hloss⟩ := hdata R hR k z hcore
+  obtain ⟨g, hg, _, hdeficit⟩ := hcharts N P R hR k z hcore E data hloss
+  exact ⟨g, hg, hdeficit⟩
+
+end
+
+end RieszRectifiability
+
+end OAI

lean/OAI/Analysis/RieszRectifiability/Surfaces/SurfaceBallCellCover.lean

@@ -0,0 +1,101 @@
+import Mathlib
+import OAI.Analysis.RieszRectifiability.Restart.CleanSupportPartition
+import OAI.Analysis.RieszRectifiability.Packing.EuclideanPackingBound
+
+namespace OAI
+
+/-!
+# Finite cell centers near a surface ball
+
+Compactness makes the separated lattice centers near a ball finite. A Euclidean packing
+estimate bounds their number uniformly in the ball center and radius.
+-/
+
+namespace RieszRectifiability
+
+noncomputable section
+
+open MeasureTheory Metric Set
+
+theorem surface_ball_cell_centers_finite {d : ℕ} (ν : Measure (Ambient d))
+    (r : ℝ) (hr : 0 < r) (a : Ambient d) :
+    {z : (supportLatticeNets ν r hr 0).points | dist (z : Ambient d) a ≤ 5 * r}.Finite := by
+  have hf := separated_set_finite_inter_compact (supportLatticeNets ν r hr 0).points
+    (closedBall a (5 * r)) (latticeRadius r 0) (latticeRadius_pos r hr 0)
+    (supportLatticeNets ν r hr 0).separated (isCompact_closedBall _ _)
+  have hpre := hf.preimage (f := fun z : (supportLatticeNets ν r hr 0).points => (z : Ambient d))
+    Subtype.val_injective.injOn
+  apply hpre.subset
+  intro z hz
+  exact ⟨z.property, hz⟩
+
+def surfaceBallCellCenters {d : ℕ} (ν : Measure (Ambient d))
+    (r : ℝ) (hr : 0 < r) (a : Ambient d) : Finset (supportLatticeNets ν r hr 0).points :=
+  (surface_ball_cell_centers_finite ν r hr a).toFinset
+
+theorem mem_surfaceBallCellCenters {d : ℕ} (ν : Measure (Ambient d))
+    (r : ℝ) (hr : 0 < r) (a : Ambient d) (z : (supportLatticeNets ν r hr 0).points) :
+    z ∈ surfaceBallCellCenters ν r hr a ↔ dist (z : Ambient d) a ≤ 5 * r := by
+  simp only [surfaceBallCellCenters, Set.Finite.mem_toFinset, mem_ofPred_eq]
+
+theorem surfaceBallCellCenters_card_le {d : ℕ} (ν : Measure (Ambient d))
+    (r : ℝ) (hr : 0 < r) (a : Ambient d) :
+    (surfaceBallCellCenters ν r hr a).card ≤ 11 ^ d := by
+  classical
+  let F := surfaceBallCellCenters ν r hr a
+  let f : (supportLatticeNets ν r hr 0).points → Ambient d := fun z => z.val - a
+  have hinj : Set.InjOn f F := by
+    intro z hz w hw heq
+    apply Subtype.ext
+    have h := congrArg (fun v : Ambient d => v + a) heq
+    simpa only [f, sub_add_cancel] using! h
+  have hbound : ∀ x ∈ F.image f, ‖x‖ ≤ 5 * r := by
+    intro x hx
+    obtain ⟨z, hz, rfl⟩ := Finset.mem_image.mp hx
+    simpa only [f, ← dist_eq_norm] using! (mem_surfaceBallCellCenters ν r hr a z).mp hz
+  have hsep : ∀ x ∈ F.image f, ∀ y ∈ F.image f, x ≠ y → 2 * (r / 2) ≤ dist x y := by
+    intro x hx y hy hxy
+    obtain ⟨z, hz, rfl⟩ := Finset.mem_image.mp hx
+    obtain ⟨w, hw, rfl⟩ := Finset.mem_image.mp hy
+    have hzw : (z : Ambient d) ≠ (w : Ambient d) := fun h => hxy (congrArg (fun v => v - a) h)
+    have h := (supportLatticeNets ν r hr 0).separated z.property w.property hzw
+    simpa only [f, dist_sub_right, latticeRadius_zero,
+      mul_div_cancel₀ _ (by norm_num : (2 : ℝ) ≠ 0)] using! h
+  have hcard := euclidean_separated_card_le (F.image f) (5 * r) (r / 2)
+    (by positivity) (by positivity) hbound hsep
+  have heq : (5 * r + r / 2) / (r / 2) = 11 := by
+    apply (div_eq_iff (show r / 2 ≠ 0 by positivity)).mpr
+    ring
+  rw [Finset.card_image_iff.mpr hinj, heq] at hcard
+  exact_mod_cast hcard
+
+theorem surface_ball_covered_by_selected_cells_off_exceptional {d : ℕ}
+    (ν : Measure (Ambient d)) (r : ℝ) (hr : 0 < r) (a : Ambient d)
+    (x : Ambient d) (hx : x ∈ ν.support ∩ closedBall a (3 * r))
+    (hnot : x ∉ supportLatticeExceptional ν r hr) :
+    ∃ z ∈ surfaceBallCellCenters ν r hr a, x ∈ cleanSupportCell ν r hr 0 z := by
+  obtain ⟨z, hz⟩ := cleanSupportCell_cover ν r hr 0 x hx.1 hnot
+  refine ⟨z, (mem_surfaceBallCellCenters ν r hr a z).mpr ?_, hz⟩
+  have hnear := (supportLatticeCell_bounds ν r hr 0 z).2 hz.1
+  simp only [latticeRadius_zero] at hnear
+  have hnear' : dist (z : Ambient d) x ≤ 2 * r := by simpa only [mem_closedBall, dist_comm] using! hnear
+  have ha : dist x a ≤ 3 * r := hx.2
+  exact (dist_triangle _ x a).trans (by linarith)
+
+theorem selected_surface_ball_cell_subset_seven_ball {d : ℕ}
+    (ν : Measure (Ambient d)) (r : ℝ) (hr : 0 < r) (a : Ambient d)
+    (z : (supportLatticeNets ν r hr 0).points) (hz : z ∈ surfaceBallCellCenters ν r hr a) :
+    cleanSupportCell ν r hr 0 z ⊆ closedBall a (7 * r) := by
+  intro x hx
+  have hnear := (supportLatticeCell_bounds ν r hr 0 z).2 hx.1
+  simp only [latticeRadius_zero] at hnear
+  have hxz : dist x (z : Ambient d) ≤ 2 * r := hnear
+  have hza := (mem_surfaceBallCellCenters ν r hr a z).mp hz
+  change dist x a ≤ 7 * r
+  exact (dist_triangle x (z : Ambient d) a).trans (by linarith)
+
+end
+
+end RieszRectifiability
+
+end OAI